lustre/sec/gss/gss_generic_token.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * Modifications for Lustre
   5  * Copyright 2004, Cluster File Systems, Inc.
   6  * All rights reserved
   7  * Author: Eric Mei <ericm@clusterfs.com>
   8  */
   9
  10 /*
  11  *  linux/net/sunrpc/gss_generic_token.c
  12  *
  13  *  Adapted from MIT Kerberos 5-1.2.1 lib/gssapi/generic/util_token.c
  14  *
  15  *  Copyright (c) 2000 The Regents of the University of Michigan.
  16  *  All rights reserved.
  17  *
  18  *  Andy Adamson   <andros@umich.edu>
  19  */
  20
  21 /*
  22  * Copyright 1993 by OpenVision Technologies, Inc.
  23  *
  24  * Permission to use, copy, modify, distribute, and sell this software
  25  * and its documentation for any purpose is hereby granted without fee,
  26  * provided that the above copyright notice appears in all copies and
  27  * that both that copyright notice and this permission notice appear in
  28  * supporting documentation, and that the name of OpenVision not be used
  29  * in advertising or publicity pertaining to distribution of the software
  30  * without specific, written prior permission. OpenVision makes no
  31  * representations about the suitability of this software for any
  32  * purpose.  It is provided "as is" without express or implied warranty.
  33  *
  34  * OPENVISION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  35  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  36  * EVENT SHALL OPENVISION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  37  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
  38  * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  39  * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  40  * PERFORMANCE OF THIS SOFTWARE.
  41  */
  42
  43 #ifndef EXPORT_SYMTAB
  44 # define EXPORT_SYMTAB
  45 #endif
  46 #define DEBUG_SUBSYSTEM S_SEC
  47 #ifdef __KERNEL__
  48 #include <linux/init.h>
  49 #include <linux/module.h>
  50 #include <linux/slab.h>
  51 #else
  52 #include <liblustre.h>
  53 #endif
  54
  55 #include <libcfs/kp30.h>
  56 #include <linux/obd.h>
  57 #include <linux/obd_class.h>
  58 #include <linux/obd_support.h>
  59 #include <linux/lustre_idl.h>
  60 #include <linux/lustre_net.h>
  61 #include <linux/lustre_import.h>
  62 #include <linux/lustre_sec.h>
  63
  64 #include "gss_err.h"
  65 #include "gss_internal.h"
  66 #include "gss_api.h"
  67 #include "gss_krb5.h"
  68 #include "gss_asn1.h"
  69
  70
  71 /* TWRITE_STR from gssapiP_generic.h */
  72 #define TWRITE_STR(ptr, str, len) \
  73         memcpy((ptr), (char *) (str), (len)); \
  74         (ptr) += (len);
  75
  76 /* XXXX this code currently makes the assumption that a mech oid will
  77    never be longer than 127 bytes.  This assumption is not inherent in
  78    the interfaces, so the code can be fixed if the OSI namespace
  79    balloons unexpectedly. */
  80
  81 /* Each token looks like this:
  82
  83 0x60                                tag for APPLICATION 0, SEQUENCE
  84                                         (constructed, definite-length)
  85         <length>                possible multiple bytes, need to parse/generate
  86         0x06                        tag for OBJECT IDENTIFIER
  87                 <moid_length>        compile-time constant string (assume 1 byte)
  88                 <moid_bytes>        compile-time constant string
  89         <inner_bytes>                the ANY containing the application token
  90                                         bytes 0,1 are the token type
  91                                         bytes 2,n are the token data
  92
  93 For the purposes of this abstraction, the token "header" consists of
  94 the sequence tag and length octets, the mech OID DER encoding, and the
  95 first two inner bytes, which indicate the token type.  The token
  96 "body" consists of everything else.
  97
  98 */
  99
 100 static int
 101 der_length_size( int length)
 102 {
 103         if (length < (1<<7))
 104                 return(1);
 105         else if (length < (1<<8))
 106                 return(2);
 107 #if (SIZEOF_INT == 2)
 108         else
 109                 return(3);
 110 #else
 111         else if (length < (1<<16))
 112                 return(3);
 113         else if (length < (1<<24))
 114                 return(4);
 115         else
 116                 return(5);
 117 #endif
 118 }
 119
 120 static void
 121 der_write_length(unsigned char **buf, int length)
 122 {
 123         if (length < (1<<7)) {
 124                 *(*buf)++ = (unsigned char) length;
 125         } else {
 126                 *(*buf)++ = (unsigned char) (der_length_size(length)+127);
 127 #if (SIZEOF_INT > 2)
 128                 if (length >= (1<<24))
 129                         *(*buf)++ = (unsigned char) (length>>24);
 130                 if (length >= (1<<16))
 131                         *(*buf)++ = (unsigned char) ((length>>16)&0xff);
 132 #endif
 133                 if (length >= (1<<8))
 134                         *(*buf)++ = (unsigned char) ((length>>8)&0xff);
 135                 *(*buf)++ = (unsigned char) (length&0xff);
 136         }
 137 }
 138
 139 /* returns decoded length, or < 0 on failure.  Advances buf and
 140    decrements bufsize */
 141
 142 static int
 143 der_read_length(unsigned char **buf, int *bufsize)
 144 {
 145         unsigned char sf;
 146         int ret;
 147
 148         if (*bufsize < 1)
 149                 return(-1);
 150         sf = *(*buf)++;
 151         (*bufsize)--;
 152         if (sf & 0x80) {
 153                 if ((sf &= 0x7f) > ((*bufsize)-1))
 154                         return(-1);
 155                 if (sf > SIZEOF_INT)
 156                         return (-1);
 157                 ret = 0;
 158                 for (; sf; sf--) {
 159                         ret = (ret<<8) + (*(*buf)++);
 160                         (*bufsize)--;
 161                 }
 162         } else {
 163                 ret = sf;
 164         }
 165
 166         return(ret);
 167 }
 168
 169 /* returns the length of a token, given the mech oid and the body size */
 170
 171 int
 172 g_token_size(rawobj_t *mech, unsigned int body_size)
 173 {
 174         /* set body_size to sequence contents size */
 175         body_size += 4 + (int) mech->len;         /* NEED overflow check */
 176         return(1 + der_length_size(body_size) + body_size);
 177 }
 178
 179 //EXPORT_SYMBOL(g_token_size);
 180
 181 /* fills in a buffer with the token header.  The buffer is assumed to
 182    be the right size.  buf is advanced past the token header */
 183
 184 void
 185 g_make_token_header(rawobj_t *mech, int body_size, unsigned char **buf)
 186 {
 187         *(*buf)++ = 0x60;
 188         der_write_length(buf, 4 + mech->len + body_size);
 189         *(*buf)++ = 0x06;
 190         *(*buf)++ = (unsigned char) mech->len;
 191         TWRITE_STR(*buf, mech->data, ((int) mech->len));
 192 }
 193
 194 //EXPORT_SYMBOL(g_make_token_header);
 195
 196 /*
 197  * Given a buffer containing a token, reads and verifies the token,
 198  * leaving buf advanced past the token header, and setting body_size
 199  * to the number of remaining bytes.  Returns 0 on success,
 200  * G_BAD_TOK_HEADER for a variety of errors, and G_WRONG_MECH if the
 201  * mechanism in the token does not match the mech argument.  buf and
 202  * *body_size are left unmodified on error.
 203  */
 204 __u32
 205 g_verify_token_header(rawobj_t *mech, int *body_size,
 206                       unsigned char **buf_in, int toksize)
 207 {
 208         unsigned char *buf = *buf_in;
 209         int seqsize;
 210         rawobj_t toid;
 211         int ret = 0;
 212
 213         if ((toksize-=1) < 0)
 214                 return(G_BAD_TOK_HEADER);
 215         if (*buf++ != 0x60)
 216                 return(G_BAD_TOK_HEADER);
 217
 218         if ((seqsize = der_read_length(&buf, &toksize)) < 0)
 219                 return(G_BAD_TOK_HEADER);
 220
 221         if (seqsize != toksize)
 222                 return(G_BAD_TOK_HEADER);
 223
 224         if ((toksize-=1) < 0)
 225                 return(G_BAD_TOK_HEADER);
 226         if (*buf++ != 0x06)
 227                 return(G_BAD_TOK_HEADER);
 228
 229         if ((toksize-=1) < 0)
 230                 return(G_BAD_TOK_HEADER);
 231         toid.len = *buf++;
 232
 233         if ((toksize-=toid.len) < 0)
 234                 return(G_BAD_TOK_HEADER);
 235         toid.data = buf;
 236         buf+=toid.len;
 237
 238         if (! g_OID_equal(&toid, mech))
 239                 ret = G_WRONG_MECH;
 240
 241    /* G_WRONG_MECH is not returned immediately because it's more important
 242       to return G_BAD_TOK_HEADER if the token header is in fact bad */
 243
 244         if ((toksize-=2) < 0)
 245                 return(G_BAD_TOK_HEADER);
 246
 247         if (ret)
 248                 return(ret);
 249
 250         if (!ret) {
 251                 *buf_in = buf;
 252                 *body_size = toksize;
 253         }
 254
 255         return(ret);
 256 }
 257
 258 //EXPORT_SYMBOL(g_verify_token_header);
 259
 260 /* Given a buffer containing a token, returns a copy of the mech oid in
 261  * the parameter mech. */
 262 __u32
 263 g_get_mech_oid(rawobj_t *mech, rawobj_t * in_buf)
 264 {
 265         unsigned char *buf = in_buf->data;
 266         int len = in_buf->len;
 267         int ret=0;
 268         int seqsize;
 269
 270         if ((len-=1) < 0)
 271                 return(G_BAD_TOK_HEADER);
 272         if (*buf++ != 0x60)
 273                 return(G_BAD_TOK_HEADER);
 274
 275         if ((seqsize = der_read_length(&buf, &len)) < 0)
 276                 return(G_BAD_TOK_HEADER);
 277
 278         if ((len-=1) < 0)
 279                 return(G_BAD_TOK_HEADER);
 280         if (*buf++ != 0x06)
 281                 return(G_BAD_TOK_HEADER);
 282
 283         if ((len-=1) < 0)
 284                 return(G_BAD_TOK_HEADER);
 285         mech->len = *buf++;
 286
 287         if ((len-=mech->len) < 0)
 288                 return(G_BAD_TOK_HEADER);
 289         OBD_ALLOC(mech->data, mech->len);
 290         if (!mech->data)
 291                 return(G_BUFFER_ALLOC);
 292         memcpy(mech->data, buf, mech->len);
 293
 294         return ret;
 295 }