Whamcloud - gitweb
b=15266
[fs/lustre-release.git] / lustre / ptlrpc / gss / gss_internal.h
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * Modified from NFSv4 project for Lustre
5  *
6  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
7  *
8  * Author: Eric Mei <ericm@clusterfs.com>
9  */
10
11 #ifndef __PTLRPC_GSS_GSS_INTERNAL_H_
12 #define __PTLRPC_GSS_GSS_INTERNAL_H_
13
14 #include <lustre_sec.h>
15
16 /*
17  * rawobj stuff
18  */
19 typedef struct netobj_s {
20         __u32           len;
21         __u8            data[0];
22 } netobj_t;
23
24 #define NETOBJ_EMPTY    ((netobj_t) { 0 })
25
26 typedef struct rawobj_s {
27         __u32           len;
28         __u8           *data;
29 } rawobj_t;
30
31 #define RAWOBJ_EMPTY    ((rawobj_t) { 0, NULL })
32
33 typedef struct rawobj_buf_s {
34         __u32           dataoff;
35         __u32           datalen;
36         __u32           buflen;
37         __u8           *buf;
38 } rawobj_buf_t;
39
40 int rawobj_empty(rawobj_t *obj);
41 int rawobj_alloc(rawobj_t *obj, char *buf, int len);
42 void rawobj_free(rawobj_t *obj);
43 int rawobj_equal(rawobj_t *a, rawobj_t *b);
44 int rawobj_dup(rawobj_t *dest, rawobj_t *src);
45 int rawobj_serialize(rawobj_t *obj, __u32 **buf, __u32 *buflen);
46 int rawobj_extract(rawobj_t *obj, __u32 **buf, __u32 *buflen);
47 int rawobj_extract_alloc(rawobj_t *obj, __u32 **buf, __u32 *buflen);
48 int rawobj_extract_local(rawobj_t *obj, __u32 **buf, __u32 *buflen);
49 int rawobj_extract_local_alloc(rawobj_t *obj, __u32 **buf, __u32 *buflen);
50 int rawobj_from_netobj(rawobj_t *rawobj, netobj_t *netobj);
51 int rawobj_from_netobj_alloc(rawobj_t *obj, netobj_t *netobj);
52
53 int buffer_extract_bytes(const void **buf, __u32 *buflen,
54                          void *res, __u32 reslen);
55
56 /*
57  * several timeout values. client refresh upcall timeout we using
58  * default in pipefs implemnetation.
59  */
60 #define __TIMEOUT_DELTA                 (10)
61
62 #define GSS_SECINIT_RPC_TIMEOUT                                         \
63         (obd_timeout < __TIMEOUT_DELTA ?                                \
64          __TIMEOUT_DELTA : obd_timeout - __TIMEOUT_DELTA)
65
66 #define GSS_SECFINI_RPC_TIMEOUT         (__TIMEOUT_DELTA)
67 #define GSS_SECSVC_UPCALL_TIMEOUT       (GSS_SECINIT_RPC_TIMEOUT)
68
69 /*
70  * default gc interval
71  */
72 #define GSS_GC_INTERVAL                 (60 * 60) /* 60 minutes */
73
74 static inline
75 unsigned long gss_round_ctx_expiry(unsigned long expiry,
76                                    unsigned long sec_flags)
77 {
78         if (sec_flags & PTLRPC_SEC_FL_REVERSE)
79                 return expiry;
80
81         if (get_seconds() + __TIMEOUT_DELTA <= expiry)
82                 return expiry - __TIMEOUT_DELTA;
83
84         return expiry;
85 }
86
87 /*
88  * Max encryption element in block cipher algorithms.
89  */
90 #define GSS_MAX_CIPHER_BLOCK               (16)
91
92 /*
93  * XXX make it visible of kernel and lgssd/lsvcgssd
94  */
95 #define GSSD_INTERFACE_VERSION          (1)
96
97 #define PTLRPC_GSS_VERSION              (1)
98
99
100 enum ptlrpc_gss_proc {
101         PTLRPC_GSS_PROC_DATA            = 0,
102         PTLRPC_GSS_PROC_INIT            = 1,
103         PTLRPC_GSS_PROC_CONTINUE_INIT   = 2,
104         PTLRPC_GSS_PROC_DESTROY         = 3,
105         PTLRPC_GSS_PROC_ERR             = 4,
106 };
107
108 enum ptlrpc_gss_tgt {
109         LUSTRE_GSS_TGT_MDS              = 0,
110         LUSTRE_GSS_TGT_OSS              = 1,
111         LUSTRE_GSS_TGT_MGS              = 2,
112 };
113
114 enum ptlrpc_gss_header_flags {
115         LUSTRE_GSS_PACK_BULK            = 1,
116         LUSTRE_GSS_PACK_USER            = 2,
117 };
118
119 static inline
120 __u32 import_to_gss_svc(struct obd_import *imp)
121 {
122         const char *name = imp->imp_obd->obd_type->typ_name;
123
124         if (!strcmp(name, LUSTRE_MDC_NAME))
125                 return LUSTRE_GSS_TGT_MDS;
126         if (!strcmp(name, LUSTRE_OSC_NAME))
127                 return LUSTRE_GSS_TGT_OSS;
128         LBUG();
129         return 0;
130 }
131
132 /*
133  * following 3 header must have the same size and offset
134  */
135 struct gss_header {
136         __u8                    gh_version;     /* gss version */
137         __u8                    gh_sp;          /* sec part */
138         __u16                   gh_pad0;
139         __u32                   gh_flags;       /* wrap flags */
140         __u32                   gh_proc;        /* proc */
141         __u32                   gh_seq;         /* sequence */
142         __u32                   gh_svc;         /* service */
143         __u32                   gh_pad1;
144         __u32                   gh_pad2;
145         __u32                   gh_pad3;
146         netobj_t                gh_handle;      /* context handle */
147 };
148
149 struct gss_rep_header {
150         __u8                    gh_version;
151         __u8                    gh_sp;
152         __u16                   gh_pad0;
153         __u32                   gh_flags;
154         __u32                   gh_proc;
155         __u32                   gh_major;
156         __u32                   gh_minor;
157         __u32                   gh_seqwin;
158         __u32                   gh_pad2;
159         __u32                   gh_pad3;
160         netobj_t                gh_handle;
161 };
162
163 struct gss_err_header {
164         __u8                    gh_version;
165         __u8                    gh_sp;
166         __u16                   gh_pad0;
167         __u32                   gh_flags;
168         __u32                   gh_proc;
169         __u32                   gh_major;
170         __u32                   gh_minor;
171         __u32                   gh_pad1;
172         __u32                   gh_pad2;
173         __u32                   gh_pad3;
174         netobj_t                gh_handle;
175 };
176
177 /*
178  * part of wire context information send from client which be saved and
179  * used later by server.
180  */
181 struct gss_wire_ctx {
182         __u32                   gw_flags;
183         __u32                   gw_proc;
184         __u32                   gw_seq;
185         __u32                   gw_svc;
186         rawobj_t                gw_handle;
187 };
188
189 #define PTLRPC_GSS_MAX_HANDLE_SIZE      (8)
190 #define PTLRPC_GSS_HEADER_SIZE          (sizeof(struct gss_header) + \
191                                          PTLRPC_GSS_MAX_HANDLE_SIZE)
192
193
194 static inline __u64 gss_handle_to_u64(rawobj_t *handle)
195 {
196         if (handle->len != PTLRPC_GSS_MAX_HANDLE_SIZE)
197                 return -1;
198         return *((__u64 *) handle->data);
199 }
200
201 #define GSS_SEQ_WIN                     (2048)
202 #define GSS_SEQ_WIN_MAIN                GSS_SEQ_WIN
203 #define GSS_SEQ_WIN_BACK                (128)
204 #define GSS_SEQ_REPACK_THRESHOLD        (GSS_SEQ_WIN_MAIN / 2 + \
205                                          GSS_SEQ_WIN_MAIN / 4)
206
207 struct gss_svc_seq_data {
208         spinlock_t              ssd_lock;
209         /*
210          * highest sequence number seen so far, for main and back window
211          */
212         __u32                   ssd_max_main;
213         __u32                   ssd_max_back;
214         /*
215          * main and back window
216          * for i such that ssd_max - GSS_SEQ_WIN < i <= ssd_max, the i-th bit
217          * of ssd_win is nonzero iff sequence number i has been seen already.
218          */
219         unsigned long           ssd_win_main[GSS_SEQ_WIN_MAIN/BITS_PER_LONG];
220         unsigned long           ssd_win_back[GSS_SEQ_WIN_BACK/BITS_PER_LONG];
221 };
222
223 struct gss_svc_ctx {
224         struct gss_ctx         *gsc_mechctx;
225         struct gss_svc_seq_data gsc_seqdata;
226         rawobj_t                gsc_rvs_hdl;
227         __u32                   gsc_rvs_seq;
228         uid_t                   gsc_uid;
229         gid_t                   gsc_gid;
230         uid_t                   gsc_mapped_uid;
231         unsigned int            gsc_usr_root:1,
232                                 gsc_usr_mds:1,
233                                 gsc_remote:1,
234                                 gsc_reverse:1;
235 };
236
237 struct gss_svc_reqctx {
238         struct ptlrpc_svc_ctx           src_base;
239         /*
240          * context
241          */
242         struct gss_wire_ctx             src_wirectx;
243         struct gss_svc_ctx             *src_ctx;
244         /*
245          * record place of bulk_sec_desc in request/reply buffer
246          */
247         struct ptlrpc_bulk_sec_desc    *src_reqbsd;
248         int                             src_reqbsd_size;
249         struct ptlrpc_bulk_sec_desc    *src_repbsd;
250         int                             src_repbsd_size;
251         /*
252          * flags
253          */
254         unsigned int                    src_init:1,
255                                         src_init_continue:1,
256                                         src_err_notify:1;
257         int                             src_reserve_len;
258 };
259
260 struct gss_cli_ctx {
261         struct ptlrpc_cli_ctx   gc_base;
262         __u32                   gc_flavor;
263         __u32                   gc_proc;
264         __u32                   gc_win;
265         atomic_t                gc_seq;
266         rawobj_t                gc_handle;
267         struct gss_ctx         *gc_mechctx;
268         /* handle for the buddy svc ctx */
269         rawobj_t                gc_svc_handle;
270 };
271
272 struct gss_cli_ctx_keyring {
273         struct gss_cli_ctx      gck_base;
274         struct key             *gck_key;
275         struct timer_list      *gck_timer;
276 };
277
278 struct gss_sec {
279         struct ptlrpc_sec       gs_base;
280         struct gss_api_mech    *gs_mech;
281         spinlock_t              gs_lock;
282         __u64                   gs_rvs_hdl;
283 };
284
285 struct gss_sec_pipefs {
286         struct gss_sec          gsp_base;
287         int                     gsp_chash_size;  /* must be 2^n */
288         struct hlist_head       gsp_chash[0];
289 };
290
291 /*
292  * FIXME cleanup the keyring upcall mutexes
293  */
294 #define HAVE_KEYRING_UPCALL_SERIALIZED  1
295
296 struct gss_sec_keyring {
297         struct gss_sec          gsk_base;
298         /*
299          * all contexts listed here. access is protected by sec spinlock.
300          */
301         struct hlist_head       gsk_clist;
302         /*
303          * specially point to root ctx (only one at a time). access is
304          * protected by sec spinlock.
305          */
306         struct ptlrpc_cli_ctx  *gsk_root_ctx;
307         /*
308          * specially serialize upcalls for root context.
309          */
310         struct mutex            gsk_root_uc_lock;
311
312 #ifdef HAVE_KEYRING_UPCALL_SERIALIZED
313         struct mutex            gsk_uc_lock;        /* serialize upcalls */
314 #endif
315 };
316
317 static inline struct gss_cli_ctx *ctx2gctx(struct ptlrpc_cli_ctx *ctx)
318 {
319         return container_of(ctx, struct gss_cli_ctx, gc_base);
320 }
321
322 static inline
323 struct gss_cli_ctx_keyring *ctx2gctx_keyring(struct ptlrpc_cli_ctx *ctx)
324 {
325         return container_of(ctx2gctx(ctx),
326                             struct gss_cli_ctx_keyring, gck_base);
327 }
328
329 static inline struct gss_sec *sec2gsec(struct ptlrpc_sec *sec)
330 {
331         return container_of(sec, struct gss_sec, gs_base);
332 }
333
334 static inline struct gss_sec_pipefs *sec2gsec_pipefs(struct ptlrpc_sec *sec)
335 {
336         return container_of(sec2gsec(sec), struct gss_sec_pipefs, gsp_base);
337 }
338
339 static inline struct gss_sec_keyring *sec2gsec_keyring(struct ptlrpc_sec *sec)
340 {
341         return container_of(sec2gsec(sec), struct gss_sec_keyring, gsk_base);
342 }
343
344
345 #define GSS_CTX_INIT_MAX_LEN            (1024)
346
347 /*
348  * This only guaranteed be enough for current krb5 des-cbc-crc . We might
349  * adjust this when new enc type or mech added in.
350  */
351 #define GSS_PRIVBUF_PREFIX_LEN         (32)
352 #define GSS_PRIVBUF_SUFFIX_LEN         (32)
353
354 static inline
355 struct gss_svc_reqctx *gss_svc_ctx2reqctx(struct ptlrpc_svc_ctx *ctx)
356 {
357         LASSERT(ctx);
358         return container_of(ctx, struct gss_svc_reqctx, src_base);
359 }
360
361 static inline
362 struct gss_svc_ctx *gss_svc_ctx2gssctx(struct ptlrpc_svc_ctx *ctx)
363 {
364         LASSERT(ctx);
365         return gss_svc_ctx2reqctx(ctx)->src_ctx;
366 }
367
368 /* sec_gss.c */
369 int gss_cli_ctx_match(struct ptlrpc_cli_ctx *ctx, struct vfs_cred *vcred);
370 int gss_cli_ctx_display(struct ptlrpc_cli_ctx *ctx, char *buf, int bufsize);
371 int gss_cli_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
372 int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
373 int gss_cli_ctx_seal(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
374 int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
375
376 int  gss_sec_install_rctx(struct obd_import *imp, struct ptlrpc_sec *sec,
377                           struct ptlrpc_cli_ctx *ctx);
378 int  gss_alloc_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req,
379                       int msgsize);
380 void gss_free_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req);
381 int  gss_alloc_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req,
382                       int msgsize);
383 void gss_free_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req);
384 int  gss_enlarge_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req,
385                         int segment, int newsize);
386
387 int  gss_svc_accept(struct ptlrpc_sec_policy *policy,
388                     struct ptlrpc_request *req);
389 void gss_svc_invalidate_ctx(struct ptlrpc_svc_ctx *svc_ctx);
390 int  gss_svc_alloc_rs(struct ptlrpc_request *req, int msglen);
391 int  gss_svc_authorize(struct ptlrpc_request *req);
392 void gss_svc_free_rs(struct ptlrpc_reply_state *rs);
393 void gss_svc_free_ctx(struct ptlrpc_svc_ctx *ctx);
394
395 int cli_ctx_expire(struct ptlrpc_cli_ctx *ctx);
396 int cli_ctx_check_death(struct ptlrpc_cli_ctx *ctx);
397
398 int gss_copy_rvc_cli_ctx(struct ptlrpc_cli_ctx *cli_ctx,
399                          struct ptlrpc_svc_ctx *svc_ctx);
400
401 struct gss_header *gss_swab_header(struct lustre_msg *msg, int segment);
402 netobj_t *gss_swab_netobj(struct lustre_msg *msg, int segment);
403
404 void gss_cli_ctx_uptodate(struct gss_cli_ctx *gctx);
405 int gss_pack_err_notify(struct ptlrpc_request *req, __u32 major, __u32 minor);
406 int gss_check_seq_num(struct gss_svc_seq_data *sd, __u32 seq_num, int set);
407
408 int gss_sec_create_common(struct gss_sec *gsec,
409                           struct ptlrpc_sec_policy *policy,
410                           struct obd_import *imp,
411                           struct ptlrpc_svc_ctx *ctx,
412                           struct sptlrpc_flavor *sf);
413 void gss_sec_destroy_common(struct gss_sec *gsec);
414 void gss_sec_kill(struct ptlrpc_sec *sec);
415
416 int gss_cli_ctx_init_common(struct ptlrpc_sec *sec,
417                             struct ptlrpc_cli_ctx *ctx,
418                             struct ptlrpc_ctx_ops *ctxops,
419                             struct vfs_cred *vcred);
420 int gss_cli_ctx_fini_common(struct ptlrpc_sec *sec,
421                             struct ptlrpc_cli_ctx *ctx);
422
423 void gss_cli_ctx_flags2str(unsigned long flags, char *buf, int bufsize);
424
425 /* gss_keyring.c */
426 int  __init gss_init_keyring(void);
427 void __exit gss_exit_keyring(void);
428
429 /* gss_pipefs.c */
430 int  __init gss_init_pipefs(void);
431 void __exit gss_exit_pipefs(void);
432
433 /* gss_bulk.c */
434 int gss_cli_ctx_wrap_bulk(struct ptlrpc_cli_ctx *ctx,
435                           struct ptlrpc_request *req,
436                           struct ptlrpc_bulk_desc *desc);
437 int gss_cli_ctx_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
438                             struct ptlrpc_request *req,
439                             struct ptlrpc_bulk_desc *desc);
440 int gss_svc_unwrap_bulk(struct ptlrpc_request *req,
441                         struct ptlrpc_bulk_desc *desc);
442 int gss_svc_wrap_bulk(struct ptlrpc_request *req,
443                       struct ptlrpc_bulk_desc *desc);
444
445 /* gss_mech_switch.c */
446 int init_kerberos_module(void);
447 void cleanup_kerberos_module(void);
448
449 /* gss_generic_token.c */
450 int g_token_size(rawobj_t *mech, unsigned int body_size);
451 void g_make_token_header(rawobj_t *mech, int body_size, unsigned char **buf);
452 __u32 g_verify_token_header(rawobj_t *mech, int *body_size,
453                             unsigned char **buf_in, int toksize);
454
455
456 /* gss_cli_upcall.c */
457 int gss_do_ctx_init_rpc(char *buffer, unsigned long count);
458 int gss_do_ctx_fini_rpc(struct gss_cli_ctx *gctx);
459
460 int  __init gss_init_cli_upcall(void);
461 void __exit gss_exit_cli_upcall(void);
462
463 /* gss_svc_upcall.c */
464 __u64 gss_get_next_ctx_index(void);
465 int gss_svc_upcall_install_rvs_ctx(struct obd_import *imp,
466                                    struct gss_sec *gsec,
467                                    struct gss_cli_ctx *gctx);
468 int gss_svc_upcall_expire_rvs_ctx(rawobj_t *handle);
469 int gss_svc_upcall_dup_handle(rawobj_t *handle, struct gss_svc_ctx *ctx);
470 int gss_svc_upcall_update_sequence(rawobj_t *handle, __u32 seq);
471 int gss_svc_upcall_handle_init(struct ptlrpc_request *req,
472                                struct gss_svc_reqctx *grctx,
473                                struct gss_wire_ctx *gw,
474                                struct obd_device *target,
475                                __u32 lustre_svc,
476                                rawobj_t *rvs_hdl,
477                                rawobj_t *in_token);
478 struct gss_svc_ctx *gss_svc_upcall_get_ctx(struct ptlrpc_request *req,
479                                            struct gss_wire_ctx *gw);
480 void gss_svc_upcall_put_ctx(struct gss_svc_ctx *ctx);
481 void gss_svc_upcall_destroy_ctx(struct gss_svc_ctx *ctx);
482
483 int  __init gss_init_svc_upcall(void);
484 void __exit gss_exit_svc_upcall(void);
485
486 /* lproc_gss.c */
487 void gss_stat_oos_record_cli(int behind);
488 void gss_stat_oos_record_svc(int phase, int replay);
489
490 int  __init gss_init_lproc(void);
491 void __exit gss_exit_lproc(void);
492
493 /* gss_krb5_mech.c */
494 int __init init_kerberos_module(void);
495 void __exit cleanup_kerberos_module(void);
496
497
498 /* debug */
499 static inline
500 void __dbg_memdump(char *name, void *ptr, int size)
501 {
502         char *buf, *p = (char *) ptr;
503         int bufsize = size * 2 + 1, i;
504
505         OBD_ALLOC(buf, bufsize);
506         if (!buf) {
507                 CDEBUG(D_ERROR, "DUMP ERROR: can't alloc %d bytes\n", bufsize);
508                 return;
509         }
510
511         for (i = 0; i < size; i++)
512                 sprintf(&buf[i+i], "%02x", (__u8) p[i]);
513         buf[size + size] = '\0';
514         LCONSOLE_INFO("DUMP %s@%p(%d): %s\n", name, ptr, size, buf);
515         OBD_FREE(buf, bufsize);
516 }
517
518 #endif /* __PTLRPC_GSS_GSS_INTERNAL_H_ */