2010-02-02 17:25:35 -07:00
|
|
|
|
2010-04-06 16:14:15 -06:00
|
|
|
#include <linux/ceph/ceph_debug.h>
|
2010-02-02 17:25:35 -07:00
|
|
|
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/random.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2010-02-02 17:25:35 -07:00
|
|
|
|
2010-04-06 16:14:15 -06:00
|
|
|
#include <linux/ceph/decode.h>
|
|
|
|
#include <linux/ceph/auth.h>
|
|
|
|
|
|
|
|
#include "crypto.h"
|
2010-02-02 17:25:35 -07:00
|
|
|
#include "auth_x.h"
|
|
|
|
#include "auth_x_protocol.h"
|
|
|
|
|
|
|
|
#define TEMP_TICKET_BUF_LEN 256
|
|
|
|
|
|
|
|
static void ceph_x_validate_tickets(struct ceph_auth_client *ac, int *pneed);
|
|
|
|
|
|
|
|
static int ceph_x_is_authenticated(struct ceph_auth_client *ac)
|
|
|
|
{
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
int need;
|
|
|
|
|
|
|
|
ceph_x_validate_tickets(ac, &need);
|
|
|
|
dout("ceph_x_is_authenticated want=%d need=%d have=%d\n",
|
|
|
|
ac->want_keys, need, xi->have_keys);
|
|
|
|
return (ac->want_keys & xi->have_keys) == ac->want_keys;
|
|
|
|
}
|
|
|
|
|
2010-05-25 16:39:06 -06:00
|
|
|
static int ceph_x_should_authenticate(struct ceph_auth_client *ac)
|
|
|
|
{
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
int need;
|
|
|
|
|
|
|
|
ceph_x_validate_tickets(ac, &need);
|
|
|
|
dout("ceph_x_should_authenticate want=%d need=%d have=%d\n",
|
|
|
|
ac->want_keys, need, xi->have_keys);
|
|
|
|
return need != 0;
|
|
|
|
}
|
|
|
|
|
2010-03-15 16:52:17 -06:00
|
|
|
static int ceph_x_encrypt_buflen(int ilen)
|
|
|
|
{
|
|
|
|
return sizeof(struct ceph_x_encrypt_header) + ilen + 16 +
|
|
|
|
sizeof(u32);
|
|
|
|
}
|
|
|
|
|
2010-02-02 17:25:35 -07:00
|
|
|
static int ceph_x_encrypt(struct ceph_crypto_key *secret,
|
|
|
|
void *ibuf, int ilen, void *obuf, size_t olen)
|
|
|
|
{
|
|
|
|
struct ceph_x_encrypt_header head = {
|
|
|
|
.struct_v = 1,
|
|
|
|
.magic = cpu_to_le64(CEPHX_ENC_MAGIC)
|
|
|
|
};
|
|
|
|
size_t len = olen - sizeof(u32);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = ceph_encrypt2(secret, obuf + sizeof(u32), &len,
|
|
|
|
&head, sizeof(head), ibuf, ilen);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
ceph_encode_32(&obuf, len);
|
|
|
|
return len + sizeof(u32);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ceph_x_decrypt(struct ceph_crypto_key *secret,
|
|
|
|
void **p, void *end, void *obuf, size_t olen)
|
|
|
|
{
|
|
|
|
struct ceph_x_encrypt_header head;
|
|
|
|
size_t head_len = sizeof(head);
|
|
|
|
int len, ret;
|
|
|
|
|
|
|
|
len = ceph_decode_32(p);
|
|
|
|
if (*p + len > end)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
dout("ceph_x_decrypt len %d\n", len);
|
|
|
|
ret = ceph_decrypt2(secret, &head, &head_len, obuf, &olen,
|
|
|
|
*p, len);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (head.struct_v != 1 || le64_to_cpu(head.magic) != CEPHX_ENC_MAGIC)
|
|
|
|
return -EPERM;
|
|
|
|
*p += len;
|
|
|
|
return olen;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get existing (or insert new) ticket handler
|
|
|
|
*/
|
2010-06-11 17:58:48 -06:00
|
|
|
static struct ceph_x_ticket_handler *
|
|
|
|
get_ticket_handler(struct ceph_auth_client *ac, int service)
|
2010-02-02 17:25:35 -07:00
|
|
|
{
|
|
|
|
struct ceph_x_ticket_handler *th;
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
struct rb_node *parent = NULL, **p = &xi->ticket_handlers.rb_node;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
parent = *p;
|
|
|
|
th = rb_entry(parent, struct ceph_x_ticket_handler, node);
|
|
|
|
if (service < th->service)
|
|
|
|
p = &(*p)->rb_left;
|
|
|
|
else if (service > th->service)
|
|
|
|
p = &(*p)->rb_right;
|
|
|
|
else
|
|
|
|
return th;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* add it */
|
|
|
|
th = kzalloc(sizeof(*th), GFP_NOFS);
|
|
|
|
if (!th)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
th->service = service;
|
|
|
|
rb_link_node(&th->node, parent, p);
|
|
|
|
rb_insert_color(&th->node, &xi->ticket_handlers);
|
|
|
|
return th;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void remove_ticket_handler(struct ceph_auth_client *ac,
|
|
|
|
struct ceph_x_ticket_handler *th)
|
|
|
|
{
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
|
|
|
|
dout("remove_ticket_handler %p %d\n", th, th->service);
|
|
|
|
rb_erase(&th->node, &xi->ticket_handlers);
|
|
|
|
ceph_crypto_key_destroy(&th->session_key);
|
|
|
|
if (th->ticket_blob)
|
|
|
|
ceph_buffer_put(th->ticket_blob);
|
|
|
|
kfree(th);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ceph_x_proc_ticket_reply(struct ceph_auth_client *ac,
|
|
|
|
struct ceph_crypto_key *secret,
|
|
|
|
void *buf, void *end)
|
|
|
|
{
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
int num;
|
|
|
|
void *p = buf;
|
|
|
|
int ret;
|
|
|
|
char *dbuf;
|
|
|
|
char *ticket_buf;
|
2010-04-30 13:45:02 -06:00
|
|
|
u8 reply_struct_v;
|
2010-02-02 17:25:35 -07:00
|
|
|
|
2010-04-29 14:26:53 -06:00
|
|
|
dbuf = kmalloc(TEMP_TICKET_BUF_LEN, GFP_NOFS);
|
2010-02-02 17:25:35 -07:00
|
|
|
if (!dbuf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = -ENOMEM;
|
2010-04-29 14:26:53 -06:00
|
|
|
ticket_buf = kmalloc(TEMP_TICKET_BUF_LEN, GFP_NOFS);
|
2010-02-02 17:25:35 -07:00
|
|
|
if (!ticket_buf)
|
|
|
|
goto out_dbuf;
|
|
|
|
|
|
|
|
ceph_decode_need(&p, end, 1 + sizeof(u32), bad);
|
2010-04-30 13:45:02 -06:00
|
|
|
reply_struct_v = ceph_decode_8(&p);
|
|
|
|
if (reply_struct_v != 1)
|
2010-02-02 17:25:35 -07:00
|
|
|
goto bad;
|
|
|
|
num = ceph_decode_32(&p);
|
|
|
|
dout("%d tickets\n", num);
|
|
|
|
while (num--) {
|
|
|
|
int type;
|
2010-04-30 13:45:02 -06:00
|
|
|
u8 tkt_struct_v, blob_struct_v;
|
2010-02-02 17:25:35 -07:00
|
|
|
struct ceph_x_ticket_handler *th;
|
|
|
|
void *dp, *dend;
|
|
|
|
int dlen;
|
|
|
|
char is_enc;
|
|
|
|
struct timespec validity;
|
|
|
|
struct ceph_crypto_key old_key;
|
|
|
|
void *tp, *tpend;
|
2010-03-15 17:12:25 -06:00
|
|
|
struct ceph_timespec new_validity;
|
|
|
|
struct ceph_crypto_key new_session_key;
|
2010-03-15 16:57:04 -06:00
|
|
|
struct ceph_buffer *new_ticket_blob;
|
2010-03-15 17:12:25 -06:00
|
|
|
unsigned long new_expires, new_renew_after;
|
|
|
|
u64 new_secret_id;
|
2010-02-02 17:25:35 -07:00
|
|
|
|
|
|
|
ceph_decode_need(&p, end, sizeof(u32) + 1, bad);
|
|
|
|
|
|
|
|
type = ceph_decode_32(&p);
|
|
|
|
dout(" ticket type %d %s\n", type, ceph_entity_type_name(type));
|
|
|
|
|
2010-04-30 13:45:02 -06:00
|
|
|
tkt_struct_v = ceph_decode_8(&p);
|
|
|
|
if (tkt_struct_v != 1)
|
2010-02-02 17:25:35 -07:00
|
|
|
goto bad;
|
|
|
|
|
|
|
|
th = get_ticket_handler(ac, type);
|
|
|
|
if (IS_ERR(th)) {
|
|
|
|
ret = PTR_ERR(th);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* blob for me */
|
|
|
|
dlen = ceph_x_decrypt(secret, &p, end, dbuf,
|
|
|
|
TEMP_TICKET_BUF_LEN);
|
|
|
|
if (dlen <= 0) {
|
|
|
|
ret = dlen;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
dout(" decrypted %d bytes\n", dlen);
|
|
|
|
dend = dbuf + dlen;
|
|
|
|
dp = dbuf;
|
|
|
|
|
2010-04-30 13:45:02 -06:00
|
|
|
tkt_struct_v = ceph_decode_8(&dp);
|
|
|
|
if (tkt_struct_v != 1)
|
2010-02-02 17:25:35 -07:00
|
|
|
goto bad;
|
|
|
|
|
|
|
|
memcpy(&old_key, &th->session_key, sizeof(old_key));
|
2010-03-15 17:12:25 -06:00
|
|
|
ret = ceph_crypto_key_decode(&new_session_key, &dp, dend);
|
2010-02-02 17:25:35 -07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2010-03-15 17:12:25 -06:00
|
|
|
ceph_decode_copy(&dp, &new_validity, sizeof(new_validity));
|
|
|
|
ceph_decode_timespec(&validity, &new_validity);
|
|
|
|
new_expires = get_seconds() + validity.tv_sec;
|
|
|
|
new_renew_after = new_expires - (validity.tv_sec / 4);
|
|
|
|
dout(" expires=%lu renew_after=%lu\n", new_expires,
|
|
|
|
new_renew_after);
|
2010-02-02 17:25:35 -07:00
|
|
|
|
|
|
|
/* ticket blob for service */
|
|
|
|
ceph_decode_8_safe(&p, end, is_enc, bad);
|
|
|
|
tp = ticket_buf;
|
|
|
|
if (is_enc) {
|
|
|
|
/* encrypted */
|
|
|
|
dout(" encrypted ticket\n");
|
|
|
|
dlen = ceph_x_decrypt(&old_key, &p, end, ticket_buf,
|
|
|
|
TEMP_TICKET_BUF_LEN);
|
|
|
|
if (dlen < 0) {
|
|
|
|
ret = dlen;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
dlen = ceph_decode_32(&tp);
|
|
|
|
} else {
|
|
|
|
/* unencrypted */
|
|
|
|
ceph_decode_32_safe(&p, end, dlen, bad);
|
|
|
|
ceph_decode_need(&p, end, dlen, bad);
|
|
|
|
ceph_decode_copy(&p, ticket_buf, dlen);
|
|
|
|
}
|
|
|
|
tpend = tp + dlen;
|
|
|
|
dout(" ticket blob is %d bytes\n", dlen);
|
|
|
|
ceph_decode_need(&tp, tpend, 1 + sizeof(u64), bad);
|
2010-04-30 13:45:02 -06:00
|
|
|
blob_struct_v = ceph_decode_8(&tp);
|
2010-03-15 17:12:25 -06:00
|
|
|
new_secret_id = ceph_decode_64(&tp);
|
2010-03-15 16:57:04 -06:00
|
|
|
ret = ceph_decode_buffer(&new_ticket_blob, &tp, tpend);
|
2010-02-02 17:25:35 -07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2010-03-15 17:12:25 -06:00
|
|
|
|
|
|
|
/* all is well, update our ticket */
|
|
|
|
ceph_crypto_key_destroy(&th->session_key);
|
2010-03-15 16:57:04 -06:00
|
|
|
if (th->ticket_blob)
|
|
|
|
ceph_buffer_put(th->ticket_blob);
|
2010-03-15 17:12:25 -06:00
|
|
|
th->session_key = new_session_key;
|
2010-03-15 16:57:04 -06:00
|
|
|
th->ticket_blob = new_ticket_blob;
|
2010-03-15 17:12:25 -06:00
|
|
|
th->validity = new_validity;
|
|
|
|
th->secret_id = new_secret_id;
|
|
|
|
th->expires = new_expires;
|
|
|
|
th->renew_after = new_renew_after;
|
2010-02-02 17:25:35 -07:00
|
|
|
dout(" got ticket service %d (%s) secret_id %lld len %d\n",
|
|
|
|
type, ceph_entity_type_name(type), th->secret_id,
|
|
|
|
(int)th->ticket_blob->vec.iov_len);
|
|
|
|
xi->have_keys |= th->service;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
out:
|
2010-04-29 14:26:53 -06:00
|
|
|
kfree(ticket_buf);
|
2010-02-02 17:25:35 -07:00
|
|
|
out_dbuf:
|
2010-04-29 14:26:53 -06:00
|
|
|
kfree(dbuf);
|
2010-02-02 17:25:35 -07:00
|
|
|
return ret;
|
|
|
|
|
|
|
|
bad:
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ceph_x_build_authorizer(struct ceph_auth_client *ac,
|
|
|
|
struct ceph_x_ticket_handler *th,
|
|
|
|
struct ceph_x_authorizer *au)
|
|
|
|
{
|
2010-03-15 16:52:17 -06:00
|
|
|
int maxlen;
|
2010-02-02 17:25:35 -07:00
|
|
|
struct ceph_x_authorize_a *msg_a;
|
|
|
|
struct ceph_x_authorize_b msg_b;
|
|
|
|
void *p, *end;
|
|
|
|
int ret;
|
|
|
|
int ticket_blob_len =
|
|
|
|
(th->ticket_blob ? th->ticket_blob->vec.iov_len : 0);
|
|
|
|
|
|
|
|
dout("build_authorizer for %s %p\n",
|
|
|
|
ceph_entity_type_name(th->service), au);
|
|
|
|
|
2010-03-15 16:52:17 -06:00
|
|
|
maxlen = sizeof(*msg_a) + sizeof(msg_b) +
|
|
|
|
ceph_x_encrypt_buflen(ticket_blob_len);
|
|
|
|
dout(" need len %d\n", maxlen);
|
|
|
|
if (au->buf && au->buf->alloc_len < maxlen) {
|
2010-02-02 17:25:35 -07:00
|
|
|
ceph_buffer_put(au->buf);
|
|
|
|
au->buf = NULL;
|
|
|
|
}
|
|
|
|
if (!au->buf) {
|
2010-03-15 16:52:17 -06:00
|
|
|
au->buf = ceph_buffer_new(maxlen, GFP_NOFS);
|
2010-02-02 17:25:35 -07:00
|
|
|
if (!au->buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
au->service = th->service;
|
2013-03-25 11:26:01 -06:00
|
|
|
au->secret_id = th->secret_id;
|
2010-02-02 17:25:35 -07:00
|
|
|
|
|
|
|
msg_a = au->buf->vec.iov_base;
|
|
|
|
msg_a->struct_v = 1;
|
|
|
|
msg_a->global_id = cpu_to_le64(ac->global_id);
|
|
|
|
msg_a->service_id = cpu_to_le32(th->service);
|
|
|
|
msg_a->ticket_blob.struct_v = 1;
|
|
|
|
msg_a->ticket_blob.secret_id = cpu_to_le64(th->secret_id);
|
|
|
|
msg_a->ticket_blob.blob_len = cpu_to_le32(ticket_blob_len);
|
|
|
|
if (ticket_blob_len) {
|
|
|
|
memcpy(msg_a->ticket_blob.blob, th->ticket_blob->vec.iov_base,
|
|
|
|
th->ticket_blob->vec.iov_len);
|
|
|
|
}
|
|
|
|
dout(" th %p secret_id %lld %lld\n", th, th->secret_id,
|
|
|
|
le64_to_cpu(msg_a->ticket_blob.secret_id));
|
|
|
|
|
|
|
|
p = msg_a + 1;
|
|
|
|
p += ticket_blob_len;
|
|
|
|
end = au->buf->vec.iov_base + au->buf->vec.iov_len;
|
|
|
|
|
|
|
|
get_random_bytes(&au->nonce, sizeof(au->nonce));
|
|
|
|
msg_b.struct_v = 1;
|
|
|
|
msg_b.nonce = cpu_to_le64(au->nonce);
|
|
|
|
ret = ceph_x_encrypt(&th->session_key, &msg_b, sizeof(msg_b),
|
|
|
|
p, end - p);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out_buf;
|
|
|
|
p += ret;
|
|
|
|
au->buf->vec.iov_len = p - au->buf->vec.iov_base;
|
|
|
|
dout(" built authorizer nonce %llx len %d\n", au->nonce,
|
|
|
|
(int)au->buf->vec.iov_len);
|
2010-03-15 16:52:17 -06:00
|
|
|
BUG_ON(au->buf->vec.iov_len > maxlen);
|
2010-02-02 17:25:35 -07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_buf:
|
|
|
|
ceph_buffer_put(au->buf);
|
|
|
|
au->buf = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ceph_x_encode_ticket(struct ceph_x_ticket_handler *th,
|
|
|
|
void **p, void *end)
|
|
|
|
{
|
|
|
|
ceph_decode_need(p, end, 1 + sizeof(u64), bad);
|
|
|
|
ceph_encode_8(p, 1);
|
|
|
|
ceph_encode_64(p, th->secret_id);
|
|
|
|
if (th->ticket_blob) {
|
|
|
|
const char *buf = th->ticket_blob->vec.iov_base;
|
|
|
|
u32 len = th->ticket_blob->vec.iov_len;
|
|
|
|
|
|
|
|
ceph_encode_32_safe(p, end, len, bad);
|
|
|
|
ceph_encode_copy_safe(p, end, buf, len, bad);
|
|
|
|
} else {
|
|
|
|
ceph_encode_32_safe(p, end, 0, bad);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
bad:
|
|
|
|
return -ERANGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ceph_x_validate_tickets(struct ceph_auth_client *ac, int *pneed)
|
|
|
|
{
|
|
|
|
int want = ac->want_keys;
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
int service;
|
|
|
|
|
|
|
|
*pneed = ac->want_keys & ~(xi->have_keys);
|
|
|
|
|
|
|
|
for (service = 1; service <= want; service <<= 1) {
|
|
|
|
struct ceph_x_ticket_handler *th;
|
|
|
|
|
|
|
|
if (!(ac->want_keys & service))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (*pneed & service)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
th = get_ticket_handler(ac, service);
|
|
|
|
|
2010-08-26 03:12:38 -06:00
|
|
|
if (IS_ERR(th)) {
|
2010-02-02 17:25:35 -07:00
|
|
|
*pneed |= service;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (get_seconds() >= th->renew_after)
|
|
|
|
*pneed |= service;
|
|
|
|
if (get_seconds() >= th->expires)
|
|
|
|
xi->have_keys &= ~service;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int ceph_x_build_request(struct ceph_auth_client *ac,
|
|
|
|
void *buf, void *end)
|
|
|
|
{
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
int need;
|
|
|
|
struct ceph_x_request_header *head = buf;
|
|
|
|
int ret;
|
|
|
|
struct ceph_x_ticket_handler *th =
|
|
|
|
get_ticket_handler(ac, CEPH_ENTITY_TYPE_AUTH);
|
|
|
|
|
2010-08-26 03:12:38 -06:00
|
|
|
if (IS_ERR(th))
|
|
|
|
return PTR_ERR(th);
|
|
|
|
|
2010-02-02 17:25:35 -07:00
|
|
|
ceph_x_validate_tickets(ac, &need);
|
|
|
|
|
|
|
|
dout("build_request want %x have %x need %x\n",
|
|
|
|
ac->want_keys, xi->have_keys, need);
|
|
|
|
|
|
|
|
if (need & CEPH_ENTITY_TYPE_AUTH) {
|
|
|
|
struct ceph_x_authenticate *auth = (void *)(head + 1);
|
|
|
|
void *p = auth + 1;
|
|
|
|
struct ceph_x_challenge_blob tmp;
|
|
|
|
char tmp_enc[40];
|
|
|
|
u64 *u;
|
|
|
|
|
|
|
|
if (p > end)
|
|
|
|
return -ERANGE;
|
|
|
|
|
|
|
|
dout(" get_auth_session_key\n");
|
|
|
|
head->op = cpu_to_le16(CEPHX_GET_AUTH_SESSION_KEY);
|
|
|
|
|
|
|
|
/* encrypt and hash */
|
|
|
|
get_random_bytes(&auth->client_challenge, sizeof(u64));
|
|
|
|
tmp.client_challenge = auth->client_challenge;
|
|
|
|
tmp.server_challenge = cpu_to_le64(xi->server_challenge);
|
|
|
|
ret = ceph_x_encrypt(&xi->secret, &tmp, sizeof(tmp),
|
|
|
|
tmp_enc, sizeof(tmp_enc));
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
auth->struct_v = 1;
|
|
|
|
auth->key = 0;
|
|
|
|
for (u = (u64 *)tmp_enc; u + 1 <= (u64 *)(tmp_enc + ret); u++)
|
2010-06-11 17:58:48 -06:00
|
|
|
auth->key ^= *(__le64 *)u;
|
2010-02-02 17:25:35 -07:00
|
|
|
dout(" server_challenge %llx client_challenge %llx key %llx\n",
|
|
|
|
xi->server_challenge, le64_to_cpu(auth->client_challenge),
|
|
|
|
le64_to_cpu(auth->key));
|
|
|
|
|
|
|
|
/* now encode the old ticket if exists */
|
|
|
|
ret = ceph_x_encode_ticket(th, &p, end);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return p - buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (need) {
|
|
|
|
void *p = head + 1;
|
|
|
|
struct ceph_x_service_ticket_request *req;
|
|
|
|
|
|
|
|
if (p > end)
|
|
|
|
return -ERANGE;
|
|
|
|
head->op = cpu_to_le16(CEPHX_GET_PRINCIPAL_SESSION_KEY);
|
|
|
|
|
|
|
|
ret = ceph_x_build_authorizer(ac, th, &xi->auth_authorizer);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
ceph_encode_copy(&p, xi->auth_authorizer.buf->vec.iov_base,
|
|
|
|
xi->auth_authorizer.buf->vec.iov_len);
|
|
|
|
|
|
|
|
req = p;
|
|
|
|
req->keys = cpu_to_le32(need);
|
|
|
|
p += sizeof(*req);
|
|
|
|
return p - buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ceph_x_handle_reply(struct ceph_auth_client *ac, int result,
|
|
|
|
void *buf, void *end)
|
|
|
|
{
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
struct ceph_x_reply_header *head = buf;
|
|
|
|
struct ceph_x_ticket_handler *th;
|
|
|
|
int len = end - buf;
|
|
|
|
int op;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (result)
|
|
|
|
return result; /* XXX hmm? */
|
|
|
|
|
|
|
|
if (xi->starting) {
|
|
|
|
/* it's a hello */
|
|
|
|
struct ceph_x_server_challenge *sc = buf;
|
|
|
|
|
|
|
|
if (len != sizeof(*sc))
|
|
|
|
return -EINVAL;
|
|
|
|
xi->server_challenge = le64_to_cpu(sc->server_challenge);
|
|
|
|
dout("handle_reply got server challenge %llx\n",
|
|
|
|
xi->server_challenge);
|
|
|
|
xi->starting = false;
|
|
|
|
xi->have_keys &= ~CEPH_ENTITY_TYPE_AUTH;
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2010-06-11 16:57:06 -06:00
|
|
|
op = le16_to_cpu(head->op);
|
2010-02-02 17:25:35 -07:00
|
|
|
result = le32_to_cpu(head->result);
|
|
|
|
dout("handle_reply op %d result %d\n", op, result);
|
|
|
|
switch (op) {
|
|
|
|
case CEPHX_GET_AUTH_SESSION_KEY:
|
|
|
|
/* verify auth key */
|
|
|
|
ret = ceph_x_proc_ticket_reply(ac, &xi->secret,
|
|
|
|
buf + sizeof(*head), end);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CEPHX_GET_PRINCIPAL_SESSION_KEY:
|
|
|
|
th = get_ticket_handler(ac, CEPH_ENTITY_TYPE_AUTH);
|
2010-08-26 03:12:38 -06:00
|
|
|
if (IS_ERR(th))
|
|
|
|
return PTR_ERR(th);
|
2010-02-02 17:25:35 -07:00
|
|
|
ret = ceph_x_proc_ticket_reply(ac, &th->session_key,
|
|
|
|
buf + sizeof(*head), end);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (ac->want_keys == xi->have_keys)
|
|
|
|
return 0;
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ceph_x_create_authorizer(
|
|
|
|
struct ceph_auth_client *ac, int peer_type,
|
2012-05-16 14:16:39 -06:00
|
|
|
struct ceph_auth_handshake *auth)
|
2010-02-02 17:25:35 -07:00
|
|
|
{
|
|
|
|
struct ceph_x_authorizer *au;
|
|
|
|
struct ceph_x_ticket_handler *th;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
th = get_ticket_handler(ac, peer_type);
|
|
|
|
if (IS_ERR(th))
|
|
|
|
return PTR_ERR(th);
|
|
|
|
|
|
|
|
au = kzalloc(sizeof(*au), GFP_NOFS);
|
|
|
|
if (!au)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = ceph_x_build_authorizer(ac, th, au);
|
|
|
|
if (ret) {
|
|
|
|
kfree(au);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-16 14:16:39 -06:00
|
|
|
auth->authorizer = (struct ceph_authorizer *) au;
|
|
|
|
auth->authorizer_buf = au->buf->vec.iov_base;
|
|
|
|
auth->authorizer_buf_len = au->buf->vec.iov_len;
|
|
|
|
auth->authorizer_reply_buf = au->reply_buf;
|
|
|
|
auth->authorizer_reply_buf_len = sizeof (au->reply_buf);
|
|
|
|
|
2010-02-02 17:25:35 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-03-25 11:26:01 -06:00
|
|
|
static int ceph_x_update_authorizer(
|
|
|
|
struct ceph_auth_client *ac, int peer_type,
|
|
|
|
struct ceph_auth_handshake *auth)
|
|
|
|
{
|
|
|
|
struct ceph_x_authorizer *au;
|
|
|
|
struct ceph_x_ticket_handler *th;
|
|
|
|
|
|
|
|
th = get_ticket_handler(ac, peer_type);
|
|
|
|
if (IS_ERR(th))
|
|
|
|
return PTR_ERR(th);
|
|
|
|
|
|
|
|
au = (struct ceph_x_authorizer *)auth->authorizer;
|
|
|
|
if (au->secret_id < th->secret_id) {
|
|
|
|
dout("ceph_x_update_authorizer service %u secret %llu < %llu\n",
|
|
|
|
au->service, au->secret_id, th->secret_id);
|
|
|
|
return ceph_x_build_authorizer(ac, th, au);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-02 17:25:35 -07:00
|
|
|
static int ceph_x_verify_authorizer_reply(struct ceph_auth_client *ac,
|
|
|
|
struct ceph_authorizer *a, size_t len)
|
|
|
|
{
|
|
|
|
struct ceph_x_authorizer *au = (void *)a;
|
|
|
|
struct ceph_x_ticket_handler *th;
|
|
|
|
int ret = 0;
|
|
|
|
struct ceph_x_authorize_reply reply;
|
|
|
|
void *p = au->reply_buf;
|
|
|
|
void *end = p + sizeof(au->reply_buf);
|
|
|
|
|
|
|
|
th = get_ticket_handler(ac, au->service);
|
2010-08-26 03:12:38 -06:00
|
|
|
if (IS_ERR(th))
|
|
|
|
return PTR_ERR(th);
|
2010-02-02 17:25:35 -07:00
|
|
|
ret = ceph_x_decrypt(&th->session_key, &p, end, &reply, sizeof(reply));
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
if (ret != sizeof(reply))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
if (au->nonce + 1 != le64_to_cpu(reply.nonce_plus_one))
|
|
|
|
ret = -EPERM;
|
|
|
|
else
|
|
|
|
ret = 0;
|
|
|
|
dout("verify_authorizer_reply nonce %llx got %llx ret %d\n",
|
|
|
|
au->nonce, le64_to_cpu(reply.nonce_plus_one), ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ceph_x_destroy_authorizer(struct ceph_auth_client *ac,
|
|
|
|
struct ceph_authorizer *a)
|
|
|
|
{
|
|
|
|
struct ceph_x_authorizer *au = (void *)a;
|
|
|
|
|
|
|
|
ceph_buffer_put(au->buf);
|
|
|
|
kfree(au);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void ceph_x_reset(struct ceph_auth_client *ac)
|
|
|
|
{
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
|
|
|
|
dout("reset\n");
|
|
|
|
xi->starting = true;
|
|
|
|
xi->server_challenge = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ceph_x_destroy(struct ceph_auth_client *ac)
|
|
|
|
{
|
|
|
|
struct ceph_x_info *xi = ac->private;
|
|
|
|
struct rb_node *p;
|
|
|
|
|
|
|
|
dout("ceph_x_destroy %p\n", ac);
|
|
|
|
ceph_crypto_key_destroy(&xi->secret);
|
|
|
|
|
|
|
|
while ((p = rb_first(&xi->ticket_handlers)) != NULL) {
|
|
|
|
struct ceph_x_ticket_handler *th =
|
|
|
|
rb_entry(p, struct ceph_x_ticket_handler, node);
|
|
|
|
remove_ticket_handler(ac, th);
|
|
|
|
}
|
|
|
|
|
2010-07-05 16:36:49 -06:00
|
|
|
if (xi->auth_authorizer.buf)
|
|
|
|
ceph_buffer_put(xi->auth_authorizer.buf);
|
|
|
|
|
2010-02-02 17:25:35 -07:00
|
|
|
kfree(ac->private);
|
|
|
|
ac->private = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ceph_x_invalidate_authorizer(struct ceph_auth_client *ac,
|
|
|
|
int peer_type)
|
|
|
|
{
|
|
|
|
struct ceph_x_ticket_handler *th;
|
|
|
|
|
|
|
|
th = get_ticket_handler(ac, peer_type);
|
2010-08-26 03:12:38 -06:00
|
|
|
if (!IS_ERR(th))
|
2013-03-25 11:25:49 -06:00
|
|
|
memset(&th->validity, 0, sizeof(th->validity));
|
2010-02-02 17:25:35 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static const struct ceph_auth_client_ops ceph_x_ops = {
|
2010-05-14 10:55:18 -06:00
|
|
|
.name = "x",
|
2010-02-02 17:25:35 -07:00
|
|
|
.is_authenticated = ceph_x_is_authenticated,
|
2010-05-25 16:39:06 -06:00
|
|
|
.should_authenticate = ceph_x_should_authenticate,
|
2010-02-02 17:25:35 -07:00
|
|
|
.build_request = ceph_x_build_request,
|
|
|
|
.handle_reply = ceph_x_handle_reply,
|
|
|
|
.create_authorizer = ceph_x_create_authorizer,
|
2013-03-25 11:26:01 -06:00
|
|
|
.update_authorizer = ceph_x_update_authorizer,
|
2010-02-02 17:25:35 -07:00
|
|
|
.verify_authorizer_reply = ceph_x_verify_authorizer_reply,
|
|
|
|
.destroy_authorizer = ceph_x_destroy_authorizer,
|
|
|
|
.invalidate_authorizer = ceph_x_invalidate_authorizer,
|
|
|
|
.reset = ceph_x_reset,
|
|
|
|
.destroy = ceph_x_destroy,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
int ceph_x_init(struct ceph_auth_client *ac)
|
|
|
|
{
|
|
|
|
struct ceph_x_info *xi;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dout("ceph_x_init %p\n", ac);
|
2010-04-29 14:26:53 -06:00
|
|
|
ret = -ENOMEM;
|
2010-02-02 17:25:35 -07:00
|
|
|
xi = kzalloc(sizeof(*xi), GFP_NOFS);
|
|
|
|
if (!xi)
|
2010-04-29 14:26:53 -06:00
|
|
|
goto out;
|
2010-02-02 17:25:35 -07:00
|
|
|
|
|
|
|
ret = -EINVAL;
|
2011-03-25 17:32:57 -06:00
|
|
|
if (!ac->key) {
|
2010-02-02 17:25:35 -07:00
|
|
|
pr_err("no secret set (for auth_x protocol)\n");
|
2010-04-29 14:26:53 -06:00
|
|
|
goto out_nomem;
|
2010-02-02 17:25:35 -07:00
|
|
|
}
|
|
|
|
|
2011-03-25 17:32:57 -06:00
|
|
|
ret = ceph_crypto_key_clone(&xi->secret, ac->key);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_err("cannot clone key: %d\n", ret);
|
2010-04-29 14:26:53 -06:00
|
|
|
goto out_nomem;
|
2011-03-25 17:32:57 -06:00
|
|
|
}
|
2010-02-02 17:25:35 -07:00
|
|
|
|
|
|
|
xi->starting = true;
|
|
|
|
xi->ticket_handlers = RB_ROOT;
|
|
|
|
|
|
|
|
ac->protocol = CEPH_AUTH_CEPHX;
|
|
|
|
ac->private = xi;
|
|
|
|
ac->ops = &ceph_x_ops;
|
|
|
|
return 0;
|
|
|
|
|
2010-04-29 14:26:53 -06:00
|
|
|
out_nomem:
|
2010-02-02 17:25:35 -07:00
|
|
|
kfree(xi);
|
2010-04-29 14:26:53 -06:00
|
|
|
out:
|
2010-02-02 17:25:35 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|