2 * Modified from NFSv4 project for Lustre
4 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
6 * Copyright (c) 2012, 2016, Intel Corporation.
8 * Author: Eric Mei <ericm@clusterfs.com>
11 #ifndef __PTLRPC_GSS_GSS_INTERNAL_H_
12 #define __PTLRPC_GSS_GSS_INTERNAL_H_
14 #include <crypto/hash.h>
15 #include <libcfs/libcfs_crypto.h>
16 #include <lustre_sec.h>
21 typedef struct netobj_s {
26 #define NETOBJ_EMPTY ((netobj_t) { 0 })
28 typedef struct rawobj_s {
33 #define RAWOBJ_EMPTY ((rawobj_t) { 0, NULL })
35 typedef struct rawobj_buf_s {
42 int rawobj_empty(rawobj_t *obj);
43 int rawobj_alloc(rawobj_t *obj, char *buf, int len);
44 void rawobj_free(rawobj_t *obj);
45 int rawobj_equal(rawobj_t *a, rawobj_t *b);
46 int rawobj_dup(rawobj_t *dest, rawobj_t *src);
47 int rawobj_serialize(rawobj_t *obj, __u32 **buf, __u32 *buflen);
48 int rawobj_extract(rawobj_t *obj, __u32 **buf, __u32 *buflen);
49 int rawobj_extract_alloc(rawobj_t *obj, __u32 **buf, __u32 *buflen);
50 int rawobj_extract_local(rawobj_t *obj, __u32 **buf, __u32 *buflen);
51 int rawobj_extract_local_alloc(rawobj_t *obj, __u32 **buf, __u32 *buflen);
52 int rawobj_from_netobj(rawobj_t *rawobj, netobj_t *netobj);
53 int rawobj_from_netobj_alloc(rawobj_t *obj, netobj_t *netobj);
55 int buffer_extract_bytes(const void **buf, __u32 *buflen,
56 void *res, __u32 reslen);
59 * several timeout values. client refresh upcall timeout we using
60 * default in pipefs implemnetation.
62 #define __TIMEOUT_DELTA (10)
64 #define GSS_SECINIT_RPC_TIMEOUT \
65 (obd_timeout < __TIMEOUT_DELTA ? \
66 __TIMEOUT_DELTA : obd_timeout - __TIMEOUT_DELTA)
68 #define GSS_SECFINI_RPC_TIMEOUT (__TIMEOUT_DELTA)
69 #define GSS_SECSVC_UPCALL_TIMEOUT (GSS_SECINIT_RPC_TIMEOUT)
74 #define GSS_GC_INTERVAL (60 * 60) /* 60 minutes */
76 static inline time64_t gss_round_ctx_expiry(time64_t expiry,
77 unsigned long sec_flags)
79 if (sec_flags & PTLRPC_SEC_FL_REVERSE)
82 if (ktime_get_real_seconds() + __TIMEOUT_DELTA <= expiry)
83 return expiry - __TIMEOUT_DELTA;
89 * Max encryption element in block cipher algorithms.
91 #define GSS_MAX_CIPHER_BLOCK (16)
94 * XXX make it visible of kernel and lgssd/lsvcgssd
97 GSSD_INTERFACE_VERSION_V1 = 1,
98 GSSD_INTERFACE_VERSION_V2 = 2,
99 GSSD_INTERFACE_VERSION = GSSD_INTERFACE_VERSION_V2,
102 #define PTLRPC_GSS_VERSION (1)
105 enum ptlrpc_gss_proc {
106 PTLRPC_GSS_PROC_DATA = 0,
107 PTLRPC_GSS_PROC_INIT = 1,
108 PTLRPC_GSS_PROC_CONTINUE_INIT = 2,
109 PTLRPC_GSS_PROC_DESTROY = 3,
110 PTLRPC_GSS_PROC_ERR = 4,
113 enum ptlrpc_gss_tgt {
114 LUSTRE_GSS_TGT_MGS = 0,
115 LUSTRE_GSS_TGT_MDS = 1,
116 LUSTRE_GSS_TGT_OSS = 2,
119 enum ptlrpc_gss_header_flags {
120 LUSTRE_GSS_PACK_BULK = 1,
121 LUSTRE_GSS_PACK_USER = 2,
125 __u32 import_to_gss_svc(struct obd_import *imp)
127 int cl_sp_to = LUSTRE_SP_ANY;
130 cl_sp_to = imp->imp_obd->u.cli.cl_sp_to;
134 return LUSTRE_GSS_TGT_MDS;
136 return LUSTRE_GSS_TGT_OSS;
139 return LUSTRE_GSS_TGT_MGS;
148 * following 3 header must have the same size and offset
151 __u8 gh_version; /* gss version */
152 __u8 gh_sp; /* sec part */
154 __u32 gh_flags; /* wrap flags */
155 __u32 gh_proc; /* proc */
156 __u32 gh_seq; /* sequence */
157 __u32 gh_svc; /* service */
161 netobj_t gh_handle; /* context handle */
164 struct gss_rep_header {
178 struct gss_err_header {
193 * part of wire context information send from client which be saved and
194 * used later by server.
196 struct gss_wire_ctx {
204 #define PTLRPC_GSS_MAX_HANDLE_SIZE (8)
205 #define PTLRPC_GSS_HEADER_SIZE (sizeof(struct gss_header) + \
206 PTLRPC_GSS_MAX_HANDLE_SIZE)
209 static inline __u64 gss_handle_to_u64(rawobj_t *handle)
211 if (handle->len != PTLRPC_GSS_MAX_HANDLE_SIZE)
213 return *((__u64 *) handle->data);
216 #define GSS_SEQ_WIN (2048)
217 #define GSS_SEQ_WIN_MAIN GSS_SEQ_WIN
218 #define GSS_SEQ_WIN_BACK (128)
219 #define GSS_SEQ_REPACK_THRESHOLD (GSS_SEQ_WIN_MAIN / 2 + \
220 GSS_SEQ_WIN_MAIN / 4)
222 struct gss_svc_seq_data {
225 * highest sequence number seen so far, for main and back window
230 * main and back window
231 * for i such that ssd_max - GSS_SEQ_WIN < i <= ssd_max, the i-th bit
232 * of ssd_win is nonzero iff sequence number i has been seen already.
234 unsigned long ssd_win_main[GSS_SEQ_WIN_MAIN/BITS_PER_LONG];
235 unsigned long ssd_win_back[GSS_SEQ_WIN_BACK/BITS_PER_LONG];
239 struct gss_ctx *gsc_mechctx;
240 struct gss_svc_seq_data gsc_seqdata;
241 rawobj_t gsc_rvs_hdl;
245 uid_t gsc_mapped_uid;
246 unsigned int gsc_usr_root:1,
253 struct gss_svc_reqctx {
254 struct ptlrpc_svc_ctx src_base;
258 struct gss_wire_ctx src_wirectx;
259 struct gss_svc_ctx *src_ctx;
261 * record place of bulk_sec_desc in request/reply buffer
263 struct ptlrpc_bulk_sec_desc *src_reqbsd;
265 struct ptlrpc_bulk_sec_desc *src_repbsd;
270 unsigned int src_init:1,
277 struct ptlrpc_cli_ctx gc_base;
283 struct gss_ctx *gc_mechctx;
284 /* handle for the buddy svc ctx */
285 rawobj_t gc_svc_handle;
288 struct gss_cli_ctx_keyring {
289 struct gss_cli_ctx gck_base;
291 struct timer_list *gck_timer;
295 struct ptlrpc_sec gs_base;
296 struct gss_api_mech *gs_mech;
301 struct gss_sec_pipefs {
302 struct gss_sec gsp_base;
303 int gsp_chash_size; /* must be 2^n */
304 struct hlist_head gsp_chash[0];
308 * FIXME cleanup the keyring upcall mutexes
310 #define HAVE_KEYRING_UPCALL_SERIALIZED 1
312 struct gss_sec_keyring {
313 struct gss_sec gsk_base;
315 * all contexts listed here. access is protected by sec spinlock.
317 struct hlist_head gsk_clist;
319 * specially point to root ctx (only one at a time). access is
320 * protected by sec spinlock.
322 struct ptlrpc_cli_ctx *gsk_root_ctx;
324 * specially serialize upcalls for root context.
326 struct mutex gsk_root_uc_lock;
328 #ifdef HAVE_KEYRING_UPCALL_SERIALIZED
329 struct mutex gsk_uc_lock; /* serialize upcalls */
333 static inline struct gss_cli_ctx *ctx2gctx(struct ptlrpc_cli_ctx *ctx)
335 return container_of(ctx, struct gss_cli_ctx, gc_base);
339 struct gss_cli_ctx_keyring *ctx2gctx_keyring(struct ptlrpc_cli_ctx *ctx)
341 return container_of(ctx2gctx(ctx),
342 struct gss_cli_ctx_keyring, gck_base);
345 static inline struct gss_sec *sec2gsec(struct ptlrpc_sec *sec)
347 return container_of(sec, struct gss_sec, gs_base);
350 static inline struct gss_sec_pipefs *sec2gsec_pipefs(struct ptlrpc_sec *sec)
352 return container_of(sec2gsec(sec), struct gss_sec_pipefs, gsp_base);
355 static inline struct gss_sec_keyring *sec2gsec_keyring(struct ptlrpc_sec *sec)
357 return container_of(sec2gsec(sec), struct gss_sec_keyring, gsk_base);
361 #define GSS_CTX_INIT_MAX_LEN (1024)
364 * This only guaranteed be enough for current krb5 des-cbc-crc . We might
365 * adjust this when new enc type or mech added in.
367 #define GSS_PRIVBUF_PREFIX_LEN (32)
368 #define GSS_PRIVBUF_SUFFIX_LEN (32)
371 struct gss_svc_reqctx *gss_svc_ctx2reqctx(struct ptlrpc_svc_ctx *ctx)
374 return container_of(ctx, struct gss_svc_reqctx, src_base);
378 struct gss_svc_ctx *gss_svc_ctx2gssctx(struct ptlrpc_svc_ctx *ctx)
381 return gss_svc_ctx2reqctx(ctx)->src_ctx;
385 int gss_cli_ctx_match(struct ptlrpc_cli_ctx *ctx, struct vfs_cred *vcred);
386 int gss_cli_ctx_display(struct ptlrpc_cli_ctx *ctx, char *buf, int bufsize);
387 int gss_cli_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
388 int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
389 int gss_cli_ctx_seal(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
390 int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
392 int gss_sec_install_rctx(struct obd_import *imp, struct ptlrpc_sec *sec,
393 struct ptlrpc_cli_ctx *ctx);
394 int gss_alloc_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req,
396 void gss_free_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req);
397 int gss_alloc_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req,
399 void gss_free_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req);
400 int gss_enlarge_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req,
401 int segment, int newsize);
403 int gss_svc_accept(struct ptlrpc_sec_policy *policy,
404 struct ptlrpc_request *req);
405 void gss_svc_invalidate_ctx(struct ptlrpc_svc_ctx *svc_ctx);
406 int gss_svc_alloc_rs(struct ptlrpc_request *req, int msglen);
407 int gss_svc_authorize(struct ptlrpc_request *req);
408 void gss_svc_free_rs(struct ptlrpc_reply_state *rs);
409 void gss_svc_free_ctx(struct ptlrpc_svc_ctx *ctx);
411 int cli_ctx_expire(struct ptlrpc_cli_ctx *ctx);
412 int cli_ctx_check_death(struct ptlrpc_cli_ctx *ctx);
414 int gss_copy_rvc_cli_ctx(struct ptlrpc_cli_ctx *cli_ctx,
415 struct ptlrpc_svc_ctx *svc_ctx);
417 struct gss_header *gss_swab_header(struct lustre_msg *msg, int segment,
419 netobj_t *gss_swab_netobj(struct lustre_msg *msg, int segment);
421 void gss_cli_ctx_uptodate(struct gss_cli_ctx *gctx);
422 int gss_pack_err_notify(struct ptlrpc_request *req, __u32 major, __u32 minor);
423 int gss_check_seq_num(struct gss_svc_seq_data *sd, __u32 seq_num, int set);
425 int gss_sec_create_common(struct gss_sec *gsec,
426 struct ptlrpc_sec_policy *policy,
427 struct obd_import *imp,
428 struct ptlrpc_svc_ctx *ctx,
429 struct sptlrpc_flavor *sf);
430 void gss_sec_destroy_common(struct gss_sec *gsec);
431 void gss_sec_kill(struct ptlrpc_sec *sec);
433 int gss_cli_ctx_init_common(struct ptlrpc_sec *sec,
434 struct ptlrpc_cli_ctx *ctx,
435 struct ptlrpc_ctx_ops *ctxops,
436 struct vfs_cred *vcred);
437 int gss_cli_ctx_fini_common(struct ptlrpc_sec *sec,
438 struct ptlrpc_cli_ctx *ctx);
440 void gss_cli_ctx_flags2str(unsigned long flags, char *buf, int bufsize);
443 #ifndef HAVE_GSS_KEYRING
444 static inline int __init gss_init_keyring(void) { return 0; }
445 static inline void __exit gss_exit_keyring(void) { return; }
447 int __init gss_init_keyring(void);
448 void __exit gss_exit_keyring(void);
452 #ifndef HAVE_GSS_PIPEFS
453 static inline int __init gss_init_pipefs(void) { return 0; }
454 static inline void __exit gss_exit_pipefs(void) { return; }
456 int __init gss_init_pipefs(void);
457 void __exit gss_exit_pipefs(void);
461 int gss_cli_prep_bulk(struct ptlrpc_request *req,
462 struct ptlrpc_bulk_desc *desc);
463 int gss_cli_ctx_wrap_bulk(struct ptlrpc_cli_ctx *ctx,
464 struct ptlrpc_request *req,
465 struct ptlrpc_bulk_desc *desc);
466 int gss_cli_ctx_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
467 struct ptlrpc_request *req,
468 struct ptlrpc_bulk_desc *desc);
469 int gss_svc_prep_bulk(struct ptlrpc_request *req,
470 struct ptlrpc_bulk_desc *desc);
471 int gss_svc_unwrap_bulk(struct ptlrpc_request *req,
472 struct ptlrpc_bulk_desc *desc);
473 int gss_svc_wrap_bulk(struct ptlrpc_request *req,
474 struct ptlrpc_bulk_desc *desc);
476 /* gss_generic_token.c */
477 int g_token_size(rawobj_t *mech, unsigned int body_size);
478 void g_make_token_header(rawobj_t *mech, int body_size, unsigned char **buf);
479 __u32 g_verify_token_header(rawobj_t *mech, int *body_size,
480 unsigned char **buf_in, int toksize);
483 /* gss_cli_upcall.c */
484 int gss_do_ctx_init_rpc(char __user *buffer, unsigned long count);
485 int gss_do_ctx_fini_rpc(struct gss_cli_ctx *gctx);
487 int __init gss_init_cli_upcall(void);
488 void gss_exit_cli_upcall(void);
490 /* gss_svc_upcall.c */
491 __u64 gss_get_next_ctx_index(void);
492 int gss_svc_upcall_install_rvs_ctx(struct obd_import *imp,
493 struct gss_sec *gsec,
494 struct gss_cli_ctx *gctx);
495 int gss_svc_upcall_expire_rvs_ctx(rawobj_t *handle);
496 int gss_svc_upcall_dup_handle(rawobj_t *handle, struct gss_svc_ctx *ctx);
497 int gss_svc_upcall_update_sequence(rawobj_t *handle, __u32 seq);
498 int gss_svc_upcall_handle_init(struct ptlrpc_request *req,
499 struct gss_svc_reqctx *grctx,
500 struct gss_wire_ctx *gw,
501 struct obd_device *target,
505 struct gss_svc_ctx *gss_svc_upcall_get_ctx(struct ptlrpc_request *req,
506 struct gss_wire_ctx *gw);
507 void gss_svc_upcall_put_ctx(struct gss_svc_ctx *ctx);
508 void gss_svc_upcall_destroy_ctx(struct gss_svc_ctx *ctx);
510 int __init gss_init_svc_upcall(void);
511 void gss_exit_svc_upcall(void);
514 void gss_stat_oos_record_cli(int behind);
515 void gss_stat_oos_record_svc(int phase, int replay);
517 int __init gss_init_lproc(void);
518 void gss_exit_lproc(void);
520 /* gss_null_mech.c */
521 int __init init_null_module(void);
522 void cleanup_null_module(void);
524 /* gss_krb5_mech.c */
525 int __init init_kerberos_module(void);
526 void cleanup_kerberos_module(void);
529 #ifdef HAVE_OPENSSL_SSK
530 int __init init_sk_module(void);
531 void cleanup_sk_module(void);
533 static inline int init_sk_module(void) { return 0; }
534 static inline void cleanup_sk_module(void) { return; }
535 #endif /* HAVE_OPENSSL_SSK */
539 void __dbg_memdump(char *name, void *ptr, int size)
541 char *buf, *p = (char *) ptr;
542 int bufsize = size * 2 + 1, i;
544 OBD_ALLOC(buf, bufsize);
546 CDEBUG(D_ERROR, "DUMP ERROR: can't alloc %d bytes\n", bufsize);
550 for (i = 0; i < size; i++)
551 sprintf(&buf[i+i], "%02x", (__u8) p[i]);
552 buf[size + size] = '\0';
553 LCONSOLE_INFO("DUMP %s@%p(%d): %s\n", name, ptr, size, buf);
554 OBD_FREE(buf, bufsize);
557 static inline unsigned int ll_read_key_usage(struct key *key)
559 #ifdef HAVE_KEY_USAGE_REFCOUNT
560 return refcount_read(&key->usage);
562 return atomic_read(&key->usage);
566 #endif /* __PTLRPC_GSS_GSS_INTERNAL_H_ */