lustre/ptlrpc/gss/gss_sk_mech.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (C) 2013, Trustees of Indiana University
  24  * Author: Andrew Korty <ajk@iu.edu>
  25  */
  26
  27 #define DEBUG_SUBSYSTEM S_SEC
  28 #include <linux/init.h>
  29 #include <linux/module.h>
  30 #include <linux/slab.h>
  31 #include <linux/crypto.h>
  32 #include <linux/mutex.h>
  33
  34 #include <obd.h>
  35 #include <obd_class.h>
  36 #include <obd_support.h>
  37
  38 #include "gss_err.h"
  39 #include "gss_internal.h"
  40 #include "gss_api.h"
  41 #include "gss_asn1.h"
  42
  43 struct sk_ctx {
  44 };
  45
  46 static
  47 __u32 gss_import_sec_context_sk(rawobj_t *inbuf, struct gss_ctx *gss_context)
  48 {
  49         struct sk_ctx *sk_context;
  50
  51         if (inbuf == NULL || inbuf->data == NULL)
  52                 return GSS_S_FAILURE;
  53
  54         OBD_ALLOC_PTR(sk_context);
  55         if (sk_context == NULL)
  56                 return GSS_S_FAILURE;
  57
  58         gss_context->internal_ctx_id = sk_context;
  59         CDEBUG(D_SEC, "succesfully imported sk context\n");
  60
  61         return GSS_S_COMPLETE;
  62 }
  63
  64 static
  65 __u32 gss_copy_reverse_context_sk(struct gss_ctx *gss_context_old,
  66                                     struct gss_ctx *gss_context_new)
  67 {
  68         struct sk_ctx *sk_context_old;
  69         struct sk_ctx *sk_context_new;
  70
  71         OBD_ALLOC_PTR(sk_context_new);
  72         if (sk_context_new == NULL)
  73                 return GSS_S_FAILURE;
  74
  75         sk_context_old = gss_context_old->internal_ctx_id;
  76         memcpy(sk_context_new, sk_context_old, sizeof(*sk_context_new));
  77         gss_context_new->internal_ctx_id = sk_context_new;
  78         CDEBUG(D_SEC, "succesfully copied reverse sk context\n");
  79
  80         return GSS_S_COMPLETE;
  81 }
  82
  83 static
  84 __u32 gss_inquire_context_sk(struct gss_ctx *gss_context,
  85                                unsigned long *endtime)
  86 {
  87         *endtime = 0;
  88         return GSS_S_COMPLETE;
  89 }
  90
  91 static
  92 __u32 gss_get_mic_sk(struct gss_ctx *gss_context,
  93                      int message_count,
  94                      rawobj_t *messages,
  95                      int iov_count,
  96                      lnet_kiov_t *iovs,
  97                      rawobj_t *token)
  98 {
  99         token->data = NULL;
 100         token->len = 0;
 101
 102         return GSS_S_COMPLETE;
 103 }
 104
 105 static
 106 __u32 gss_verify_mic_sk(struct gss_ctx *gss_context,
 107                         int message_count,
 108                         rawobj_t *messages,
 109                         int iov_count,
 110                         lnet_kiov_t *iovs,
 111                         rawobj_t *token)
 112 {
 113         return GSS_S_COMPLETE;
 114 }
 115
 116 static
 117 __u32 gss_wrap_sk(struct gss_ctx *gss_context, rawobj_t *gss_header,
 118                     rawobj_t *message, int message_buffer_length,
 119                     rawobj_t *token)
 120 {
 121         return GSS_S_COMPLETE;
 122 }
 123
 124 static
 125 __u32 gss_unwrap_sk(struct gss_ctx *gss_context, rawobj_t *gss_header,
 126                       rawobj_t *token, rawobj_t *message)
 127 {
 128         return GSS_S_COMPLETE;
 129 }
 130
 131 static
 132 __u32 gss_prep_bulk_sk(struct gss_ctx *gss_context,
 133                          struct ptlrpc_bulk_desc *desc)
 134 {
 135         return GSS_S_COMPLETE;
 136 }
 137
 138 static
 139 __u32 gss_wrap_bulk_sk(struct gss_ctx *gss_context,
 140                          struct ptlrpc_bulk_desc *desc, rawobj_t *token,
 141                          int adj_nob)
 142 {
 143         return GSS_S_COMPLETE;
 144 }
 145
 146 static
 147 __u32 gss_unwrap_bulk_sk(struct gss_ctx *gss_context,
 148                            struct ptlrpc_bulk_desc *desc,
 149                            rawobj_t *token, int adj_nob)
 150 {
 151         return GSS_S_COMPLETE;
 152 }
 153
 154 static
 155 void gss_delete_sec_context_sk(void *internal_context)
 156 {
 157         struct sk_ctx *sk_context = internal_context;
 158
 159         OBD_FREE_PTR(sk_context);
 160 }
 161
 162 int gss_display_sk(struct gss_ctx *gss_context, char *buf, int bufsize)
 163 {
 164         return snprintf(buf, bufsize, "sk");
 165 }
 166
 167 static struct gss_api_ops gss_sk_ops = {
 168         .gss_import_sec_context     = gss_import_sec_context_sk,
 169         .gss_copy_reverse_context   = gss_copy_reverse_context_sk,
 170         .gss_inquire_context        = gss_inquire_context_sk,
 171         .gss_get_mic                = gss_get_mic_sk,
 172         .gss_verify_mic             = gss_verify_mic_sk,
 173         .gss_wrap                   = gss_wrap_sk,
 174         .gss_unwrap                 = gss_unwrap_sk,
 175         .gss_prep_bulk              = gss_prep_bulk_sk,
 176         .gss_wrap_bulk              = gss_wrap_bulk_sk,
 177         .gss_unwrap_bulk            = gss_unwrap_bulk_sk,
 178         .gss_delete_sec_context     = gss_delete_sec_context_sk,
 179         .gss_display                = gss_display_sk,
 180 };
 181
 182 static struct subflavor_desc gss_sk_sfs[] = {
 183         {
 184                 .sf_subflavor   = SPTLRPC_SUBFLVR_SKI,
 185                 .sf_qop         = 0,
 186                 .sf_service     = SPTLRPC_SVC_INTG,
 187                 .sf_name        = "ski"
 188         },
 189         {
 190                 .sf_subflavor   = SPTLRPC_SUBFLVR_SKPI,
 191                 .sf_qop         = 0,
 192                 .sf_service     = SPTLRPC_SVC_PRIV,
 193                 .sf_name        = "skpi"
 194         },
 195 };
 196
 197 /*
 198  * currently we leave module owner NULL
 199  */
 200 static struct gss_api_mech gss_sk_mech = {
 201         .gm_owner       = NULL, /*THIS_MODULE, */
 202         .gm_name        = "sk",
 203         .gm_oid         = (rawobj_t) {
 204                 12,
 205                 "\053\006\001\004\001\311\146\215\126\001\000\001",
 206         },
 207         .gm_ops         = &gss_sk_ops,
 208         .gm_sf_num      = 2,
 209         .gm_sfs         = gss_sk_sfs,
 210 };
 211
 212 int __init init_sk_module(void)
 213 {
 214         int status;
 215
 216         status = lgss_mech_register(&gss_sk_mech);
 217         if (status)
 218                 CERROR("Failed to register sk gss mechanism!\n");
 219
 220         return status;
 221 }
 222
 223 void cleanup_sk_module(void)
 224 {
 225         lgss_mech_unregister(&gss_sk_mech);
 226 }