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_MGS              = 0,
 110         LUSTRE_GSS_TGT_MDS              = 1,
 111         LUSTRE_GSS_TGT_OSS              = 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_MGC_NAME))
 125                 return LUSTRE_GSS_TGT_MGS;
 126         if (!strcmp(name, LUSTRE_MDC_NAME))
 127                 return LUSTRE_GSS_TGT_MDS;
 128         if (!strcmp(name, LUSTRE_OSC_NAME))
 129                 return LUSTRE_GSS_TGT_OSS;
 130         LBUG();
 131         return 0;
 132 }
 133
 134 /*
 135  * following 3 header must have the same size and offset
 136  */
 137 struct gss_header {
 138         __u8                    gh_version;     /* gss version */
 139         __u8                    gh_sp;          /* sec part */
 140         __u16                   gh_pad0;
 141         __u32                   gh_flags;       /* wrap flags */
 142         __u32                   gh_proc;        /* proc */
 143         __u32                   gh_seq;         /* sequence */
 144         __u32                   gh_svc;         /* service */
 145         __u32                   gh_pad1;
 146         __u32                   gh_pad2;
 147         __u32                   gh_pad3;
 148         netobj_t                gh_handle;      /* context handle */
 149 };
 150
 151 struct gss_rep_header {
 152         __u8                    gh_version;
 153         __u8                    gh_sp;
 154         __u16                   gh_pad0;
 155         __u32                   gh_flags;
 156         __u32                   gh_proc;
 157         __u32                   gh_major;
 158         __u32                   gh_minor;
 159         __u32                   gh_seqwin;
 160         __u32                   gh_pad2;
 161         __u32                   gh_pad3;
 162         netobj_t                gh_handle;
 163 };
 164
 165 struct gss_err_header {
 166         __u8                    gh_version;
 167         __u8                    gh_sp;
 168         __u16                   gh_pad0;
 169         __u32                   gh_flags;
 170         __u32                   gh_proc;
 171         __u32                   gh_major;
 172         __u32                   gh_minor;
 173         __u32                   gh_pad1;
 174         __u32                   gh_pad2;
 175         __u32                   gh_pad3;
 176         netobj_t                gh_handle;
 177 };
 178
 179 /*
 180  * part of wire context information send from client which be saved and
 181  * used later by server.
 182  */
 183 struct gss_wire_ctx {
 184         __u32                   gw_flags;
 185         __u32                   gw_proc;
 186         __u32                   gw_seq;
 187         __u32                   gw_svc;
 188         rawobj_t                gw_handle;
 189 };
 190
 191 #define PTLRPC_GSS_MAX_HANDLE_SIZE      (8)
 192 #define PTLRPC_GSS_HEADER_SIZE          (sizeof(struct gss_header) + \
 193                                          PTLRPC_GSS_MAX_HANDLE_SIZE)
 194
 195
 196 static inline __u64 gss_handle_to_u64(rawobj_t *handle)
 197 {
 198         if (handle->len != PTLRPC_GSS_MAX_HANDLE_SIZE)
 199                 return -1;
 200         return *((__u64 *) handle->data);
 201 }
 202
 203 #define GSS_SEQ_WIN                     (2048)
 204 #define GSS_SEQ_WIN_MAIN                GSS_SEQ_WIN
 205 #define GSS_SEQ_WIN_BACK                (128)
 206 #define GSS_SEQ_REPACK_THRESHOLD        (GSS_SEQ_WIN_MAIN / 2 + \
 207                                          GSS_SEQ_WIN_MAIN / 4)
 208
 209 struct gss_svc_seq_data {
 210         cfs_spinlock_t          ssd_lock;
 211         /*
 212          * highest sequence number seen so far, for main and back window
 213          */
 214         __u32                   ssd_max_main;
 215         __u32                   ssd_max_back;
 216         /*
 217          * main and back window
 218          * for i such that ssd_max - GSS_SEQ_WIN < i <= ssd_max, the i-th bit
 219          * of ssd_win is nonzero iff sequence number i has been seen already.
 220          */
 221         unsigned long           ssd_win_main[GSS_SEQ_WIN_MAIN/BITS_PER_LONG];
 222         unsigned long           ssd_win_back[GSS_SEQ_WIN_BACK/BITS_PER_LONG];
 223 };
 224
 225 struct gss_svc_ctx {
 226         struct gss_ctx         *gsc_mechctx;
 227         struct gss_svc_seq_data gsc_seqdata;
 228         rawobj_t                gsc_rvs_hdl;
 229         __u32                   gsc_rvs_seq;
 230         uid_t                   gsc_uid;
 231         gid_t                   gsc_gid;
 232         uid_t                   gsc_mapped_uid;
 233         unsigned int            gsc_usr_root:1,
 234                                 gsc_usr_mds:1,
 235                                 gsc_remote:1,
 236                                 gsc_reverse:1;
 237 };
 238
 239 struct gss_svc_reqctx {
 240         struct ptlrpc_svc_ctx           src_base;
 241         /*
 242          * context
 243          */
 244         struct gss_wire_ctx             src_wirectx;
 245         struct gss_svc_ctx             *src_ctx;
 246         /*
 247          * record place of bulk_sec_desc in request/reply buffer
 248          */
 249         struct ptlrpc_bulk_sec_desc    *src_reqbsd;
 250         int                             src_reqbsd_size;
 251         struct ptlrpc_bulk_sec_desc    *src_repbsd;
 252         int                             src_repbsd_size;
 253         /*
 254          * flags
 255          */
 256         unsigned int                    src_init:1,
 257                                         src_init_continue:1,
 258                                         src_err_notify:1;
 259         int                             src_reserve_len;
 260 };
 261
 262 struct gss_cli_ctx {
 263         struct ptlrpc_cli_ctx   gc_base;
 264         __u32                   gc_flavor;
 265         __u32                   gc_proc;
 266         __u32                   gc_win;
 267         cfs_atomic_t            gc_seq;
 268         rawobj_t                gc_handle;
 269         struct gss_ctx         *gc_mechctx;
 270         /* handle for the buddy svc ctx */
 271         rawobj_t                gc_svc_handle;
 272 };
 273
 274 struct gss_cli_ctx_keyring {
 275         struct gss_cli_ctx      gck_base;
 276         struct key             *gck_key;
 277         struct timer_list      *gck_timer;
 278 };
 279
 280 struct gss_sec {
 281         struct ptlrpc_sec       gs_base;
 282         struct gss_api_mech    *gs_mech;
 283         cfs_spinlock_t          gs_lock;
 284         __u64                   gs_rvs_hdl;
 285 };
 286
 287 struct gss_sec_pipefs {
 288         struct gss_sec          gsp_base;
 289         int                     gsp_chash_size;  /* must be 2^n */
 290         cfs_hlist_head_t        gsp_chash[0];
 291 };
 292
 293 /*
 294  * FIXME cleanup the keyring upcall mutexes
 295  */
 296 #define HAVE_KEYRING_UPCALL_SERIALIZED  1
 297
 298 struct gss_sec_keyring {
 299         struct gss_sec          gsk_base;
 300         /*
 301          * all contexts listed here. access is protected by sec spinlock.
 302          */
 303         cfs_hlist_head_t        gsk_clist;
 304         /*
 305          * specially point to root ctx (only one at a time). access is
 306          * protected by sec spinlock.
 307          */
 308         struct ptlrpc_cli_ctx  *gsk_root_ctx;
 309         /*
 310          * specially serialize upcalls for root context.
 311          */
 312         cfs_mutex_t             gsk_root_uc_lock;
 313
 314 #ifdef HAVE_KEYRING_UPCALL_SERIALIZED
 315         cfs_mutex_t             gsk_uc_lock;        /* serialize upcalls */
 316 #endif
 317 };
 318
 319 static inline struct gss_cli_ctx *ctx2gctx(struct ptlrpc_cli_ctx *ctx)
 320 {
 321         return container_of(ctx, struct gss_cli_ctx, gc_base);
 322 }
 323
 324 static inline
 325 struct gss_cli_ctx_keyring *ctx2gctx_keyring(struct ptlrpc_cli_ctx *ctx)
 326 {
 327         return container_of(ctx2gctx(ctx),
 328                             struct gss_cli_ctx_keyring, gck_base);
 329 }
 330
 331 static inline struct gss_sec *sec2gsec(struct ptlrpc_sec *sec)
 332 {
 333         return container_of(sec, struct gss_sec, gs_base);
 334 }
 335
 336 static inline struct gss_sec_pipefs *sec2gsec_pipefs(struct ptlrpc_sec *sec)
 337 {
 338         return container_of(sec2gsec(sec), struct gss_sec_pipefs, gsp_base);
 339 }
 340
 341 static inline struct gss_sec_keyring *sec2gsec_keyring(struct ptlrpc_sec *sec)
 342 {
 343         return container_of(sec2gsec(sec), struct gss_sec_keyring, gsk_base);
 344 }
 345
 346
 347 #define GSS_CTX_INIT_MAX_LEN            (1024)
 348
 349 /*
 350  * This only guaranteed be enough for current krb5 des-cbc-crc . We might
 351  * adjust this when new enc type or mech added in.
 352  */
 353 #define GSS_PRIVBUF_PREFIX_LEN         (32)
 354 #define GSS_PRIVBUF_SUFFIX_LEN         (32)
 355
 356 static inline
 357 struct gss_svc_reqctx *gss_svc_ctx2reqctx(struct ptlrpc_svc_ctx *ctx)
 358 {
 359         LASSERT(ctx);
 360         return container_of(ctx, struct gss_svc_reqctx, src_base);
 361 }
 362
 363 static inline
 364 struct gss_svc_ctx *gss_svc_ctx2gssctx(struct ptlrpc_svc_ctx *ctx)
 365 {
 366         LASSERT(ctx);
 367         return gss_svc_ctx2reqctx(ctx)->src_ctx;
 368 }
 369
 370 /* sec_gss.c */
 371 int gss_cli_ctx_match(struct ptlrpc_cli_ctx *ctx, struct vfs_cred *vcred);
 372 int gss_cli_ctx_display(struct ptlrpc_cli_ctx *ctx, char *buf, int bufsize);
 373 int gss_cli_ctx_sign(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
 374 int gss_cli_ctx_verify(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
 375 int gss_cli_ctx_seal(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
 376 int gss_cli_ctx_unseal(struct ptlrpc_cli_ctx *ctx, struct ptlrpc_request *req);
 377
 378 int  gss_sec_install_rctx(struct obd_import *imp, struct ptlrpc_sec *sec,
 379                           struct ptlrpc_cli_ctx *ctx);
 380 int  gss_alloc_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req,
 381                       int msgsize);
 382 void gss_free_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req);
 383 int  gss_alloc_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req,
 384                       int msgsize);
 385 void gss_free_repbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req);
 386 int  gss_enlarge_reqbuf(struct ptlrpc_sec *sec, struct ptlrpc_request *req,
 387                         int segment, int newsize);
 388
 389 int  gss_svc_accept(struct ptlrpc_sec_policy *policy,
 390                     struct ptlrpc_request *req);
 391 void gss_svc_invalidate_ctx(struct ptlrpc_svc_ctx *svc_ctx);
 392 int  gss_svc_alloc_rs(struct ptlrpc_request *req, int msglen);
 393 int  gss_svc_authorize(struct ptlrpc_request *req);
 394 void gss_svc_free_rs(struct ptlrpc_reply_state *rs);
 395 void gss_svc_free_ctx(struct ptlrpc_svc_ctx *ctx);
 396
 397 int cli_ctx_expire(struct ptlrpc_cli_ctx *ctx);
 398 int cli_ctx_check_death(struct ptlrpc_cli_ctx *ctx);
 399
 400 int gss_copy_rvc_cli_ctx(struct ptlrpc_cli_ctx *cli_ctx,
 401                          struct ptlrpc_svc_ctx *svc_ctx);
 402
 403 struct gss_header *gss_swab_header(struct lustre_msg *msg, int segment,
 404                                    int swabbed);
 405 netobj_t *gss_swab_netobj(struct lustre_msg *msg, int segment);
 406
 407 void gss_cli_ctx_uptodate(struct gss_cli_ctx *gctx);
 408 int gss_pack_err_notify(struct ptlrpc_request *req, __u32 major, __u32 minor);
 409 int gss_check_seq_num(struct gss_svc_seq_data *sd, __u32 seq_num, int set);
 410
 411 int gss_sec_create_common(struct gss_sec *gsec,
 412                           struct ptlrpc_sec_policy *policy,
 413                           struct obd_import *imp,
 414                           struct ptlrpc_svc_ctx *ctx,
 415                           struct sptlrpc_flavor *sf);
 416 void gss_sec_destroy_common(struct gss_sec *gsec);
 417 void gss_sec_kill(struct ptlrpc_sec *sec);
 418
 419 int gss_cli_ctx_init_common(struct ptlrpc_sec *sec,
 420                             struct ptlrpc_cli_ctx *ctx,
 421                             struct ptlrpc_ctx_ops *ctxops,
 422                             struct vfs_cred *vcred);
 423 int gss_cli_ctx_fini_common(struct ptlrpc_sec *sec,
 424                             struct ptlrpc_cli_ctx *ctx);
 425
 426 void gss_cli_ctx_flags2str(unsigned long flags, char *buf, int bufsize);
 427
 428 /* gss_keyring.c */
 429 int  __init gss_init_keyring(void);
 430 void __exit gss_exit_keyring(void);
 431
 432 /* gss_pipefs.c */
 433 int  __init gss_init_pipefs(void);
 434 void __exit gss_exit_pipefs(void);
 435
 436 /* gss_bulk.c */
 437 int gss_cli_prep_bulk(struct ptlrpc_request *req,
 438                       struct ptlrpc_bulk_desc *desc);
 439 int gss_cli_ctx_wrap_bulk(struct ptlrpc_cli_ctx *ctx,
 440                           struct ptlrpc_request *req,
 441                           struct ptlrpc_bulk_desc *desc);
 442 int gss_cli_ctx_unwrap_bulk(struct ptlrpc_cli_ctx *ctx,
 443                             struct ptlrpc_request *req,
 444                             struct ptlrpc_bulk_desc *desc);
 445 int gss_svc_prep_bulk(struct ptlrpc_request *req,
 446                       struct ptlrpc_bulk_desc *desc);
 447 int gss_svc_unwrap_bulk(struct ptlrpc_request *req,
 448                         struct ptlrpc_bulk_desc *desc);
 449 int gss_svc_wrap_bulk(struct ptlrpc_request *req,
 450                       struct ptlrpc_bulk_desc *desc);
 451
 452 /* gss_mech_switch.c */
 453 int init_kerberos_module(void);
 454 void cleanup_kerberos_module(void);
 455
 456 /* gss_generic_token.c */
 457 int g_token_size(rawobj_t *mech, unsigned int body_size);
 458 void g_make_token_header(rawobj_t *mech, int body_size, unsigned char **buf);
 459 __u32 g_verify_token_header(rawobj_t *mech, int *body_size,
 460                             unsigned char **buf_in, int toksize);
 461
 462
 463 /* gss_cli_upcall.c */
 464 int gss_do_ctx_init_rpc(char *buffer, unsigned long count);
 465 int gss_do_ctx_fini_rpc(struct gss_cli_ctx *gctx);
 466
 467 int  __init gss_init_cli_upcall(void);
 468 void __exit gss_exit_cli_upcall(void);
 469
 470 /* gss_svc_upcall.c */
 471 __u64 gss_get_next_ctx_index(void);
 472 int gss_svc_upcall_install_rvs_ctx(struct obd_import *imp,
 473                                    struct gss_sec *gsec,
 474                                    struct gss_cli_ctx *gctx);
 475 int gss_svc_upcall_expire_rvs_ctx(rawobj_t *handle);
 476 int gss_svc_upcall_dup_handle(rawobj_t *handle, struct gss_svc_ctx *ctx);
 477 int gss_svc_upcall_update_sequence(rawobj_t *handle, __u32 seq);
 478 int gss_svc_upcall_handle_init(struct ptlrpc_request *req,
 479                                struct gss_svc_reqctx *grctx,
 480                                struct gss_wire_ctx *gw,
 481                                struct obd_device *target,
 482                                __u32 lustre_svc,
 483                                rawobj_t *rvs_hdl,
 484                                rawobj_t *in_token);
 485 struct gss_svc_ctx *gss_svc_upcall_get_ctx(struct ptlrpc_request *req,
 486                                            struct gss_wire_ctx *gw);
 487 void gss_svc_upcall_put_ctx(struct gss_svc_ctx *ctx);
 488 void gss_svc_upcall_destroy_ctx(struct gss_svc_ctx *ctx);
 489
 490 int  __init gss_init_svc_upcall(void);
 491 void __exit gss_exit_svc_upcall(void);
 492
 493 /* lproc_gss.c */
 494 void gss_stat_oos_record_cli(int behind);
 495 void gss_stat_oos_record_svc(int phase, int replay);
 496
 497 int  __init gss_init_lproc(void);
 498 void __exit gss_exit_lproc(void);
 499
 500 /* gss_krb5_mech.c */
 501 int __init init_kerberos_module(void);
 502 void __exit cleanup_kerberos_module(void);
 503
 504
 505 /* debug */
 506 static inline
 507 void __dbg_memdump(char *name, void *ptr, int size)
 508 {
 509         char *buf, *p = (char *) ptr;
 510         int bufsize = size * 2 + 1, i;
 511
 512         OBD_ALLOC(buf, bufsize);
 513         if (!buf) {
 514                 CDEBUG(D_ERROR, "DUMP ERROR: can't alloc %d bytes\n", bufsize);
 515                 return;
 516         }
 517
 518         for (i = 0; i < size; i++)
 519                 sprintf(&buf[i+i], "%02x", (__u8) p[i]);
 520         buf[size + size] = '\0';
 521         LCONSOLE_INFO("DUMP %s@%p(%d): %s\n", name, ptr, size, buf);
 522         OBD_FREE(buf, bufsize);
 523 }
 524
 525 #endif /* __PTLRPC_GSS_GSS_INTERNAL_H_ */