fs/cifsd/asn1.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in
   4  * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich
   5  *
   6  * Copyright (c) 2000 RP Internet (www.rpi.net.au).
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/types.h>
  11 #include <linux/kernel.h>
  12 #include <linux/mm.h>
  13 #include <linux/slab.h>
  14 #include <linux/oid_registry.h>
  15
  16 #include "glob.h"
  17
  18 #include "asn1.h"
  19 #include "connection.h"
  20 #include "auth.h"
  21 #include "spnego_negtokeninit.asn1.h"
  22 #include "spnego_negtokentarg.asn1.h"
  23
  24 #define SPNEGO_OID_LEN 7
  25 #define NTLMSSP_OID_LEN  10
  26 #define KRB5_OID_LEN  7
  27 #define KRB5U2U_OID_LEN  8
  28 #define MSKRB5_OID_LEN  7
  29 static unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 };
  30 static unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 };
  31 static unsigned long KRB5_OID[7] = { 1, 2, 840, 113554, 1, 2, 2 };
  32 static unsigned long KRB5U2U_OID[8] = { 1, 2, 840, 113554, 1, 2, 2, 3 };
  33 static unsigned long MSKRB5_OID[7] = { 1, 2, 840, 48018, 1, 2, 2 };
  34
  35 static char NTLMSSP_OID_STR[NTLMSSP_OID_LEN] = { 0x2b, 0x06, 0x01, 0x04, 0x01,
  36         0x82, 0x37, 0x02, 0x02, 0x0a };
  37
  38 static bool
  39 asn1_subid_decode(const unsigned char **begin, const unsigned char *end,
  40                 unsigned long *subid)
  41 {
  42         const unsigned char *ptr = *begin;
  43         unsigned char ch;
  44
  45         *subid = 0;
  46
  47         do {
  48                 if (ptr >= end)
  49                         return false;
  50
  51                 ch = *ptr++;
  52                 *subid <<= 7;
  53                 *subid |= ch & 0x7F;
  54         } while ((ch & 0x80) == 0x80);
  55
  56         *begin = ptr;
  57         return true;
  58 }
  59
  60 static bool asn1_oid_decode(const unsigned char *value, size_t vlen,
  61                 unsigned long **oid, size_t *oidlen)
  62 {
  63         const unsigned char *iptr = value, *end = value + vlen;
  64         unsigned long *optr;
  65         unsigned long subid;
  66
  67         vlen += 1;
  68         if (vlen < 2 || vlen > UINT_MAX/sizeof(unsigned long))
  69                 return false;
  70
  71         *oid = kmalloc(vlen * sizeof(unsigned long), GFP_KERNEL);
  72         if (!*oid)
  73                 return false;
  74
  75         optr = *oid;
  76
  77         if (!asn1_subid_decode(&iptr, end, &subid))
  78                 goto fail;
  79
  80         if (subid < 40) {
  81                 optr[0] = 0;
  82                 optr[1] = subid;
  83         } else if (subid < 80) {
  84                 optr[0] = 1;
  85                 optr[1] = subid - 40;
  86         } else {
  87                 optr[0] = 2;
  88                 optr[1] = subid - 80;
  89         }
  90
  91         *oidlen = 2;
  92         optr += 2;
  93
  94         while (iptr < end) {
  95                 if (++(*oidlen) > vlen)
  96                         goto fail;
  97
  98                 if (!asn1_subid_decode(&iptr, end, optr++))
  99                         goto fail;
 100         }
 101         return true;
 102
 103 fail:
 104         kfree(*oid);
 105         *oid = NULL;
 106         return false;
 107 }
 108
 109 static bool
 110 oid_eq(unsigned long *oid1, unsigned int oid1len,
 111                 unsigned long *oid2, unsigned int oid2len)
 112 {
 113         if (oid1len != oid2len)
 114                 return false;
 115
 116         return memcmp(oid1, oid2, oid1len) == 0;
 117 }
 118
 119 int
 120 ksmbd_decode_negTokenInit(unsigned char *security_blob, int length,
 121                 struct ksmbd_conn *conn)
 122 {
 123         return asn1_ber_decoder(&spnego_negtokeninit_decoder, conn,
 124                                 security_blob, length);
 125 }
 126
 127 int
 128 ksmbd_decode_negTokenTarg(unsigned char *security_blob, int length,
 129                 struct ksmbd_conn *conn)
 130 {
 131         return asn1_ber_decoder(&spnego_negtokentarg_decoder, conn,
 132                                 security_blob, length);
 133 }
 134
 135 static int compute_asn_hdr_len_bytes(int len)
 136 {
 137         if (len > 0xFFFFFF)
 138                 return 4;
 139         else if (len > 0xFFFF)
 140                 return 3;
 141         else if (len > 0xFF)
 142                 return 2;
 143         else if (len > 0x7F)
 144                 return 1;
 145         else
 146                 return 0;
 147 }
 148
 149 static void encode_asn_tag(char *buf,
 150                            unsigned int *ofs,
 151                            char tag,
 152                            char seq,
 153                            int length)
 154 {
 155         int i;
 156         int index = *ofs;
 157         char hdr_len = compute_asn_hdr_len_bytes(length);
 158         int len = length + 2 + hdr_len;
 159
 160         /* insert tag */
 161         buf[index++] = tag;
 162
 163         if (!hdr_len) {
 164                 buf[index++] = len;
 165         } else {
 166                 buf[index++] = 0x80 | hdr_len;
 167                 for (i = hdr_len - 1; i >= 0; i--)
 168                         buf[index++] = (len >> (i * 8)) & 0xFF;
 169         }
 170
 171         /* insert seq */
 172         len = len - (index - *ofs);
 173         buf[index++] = seq;
 174
 175         if (!hdr_len) {
 176                 buf[index++] = len;
 177         } else {
 178                 buf[index++] = 0x80 | hdr_len;
 179                 for (i = hdr_len - 1; i >= 0; i--)
 180                         buf[index++] = (len >> (i * 8)) & 0xFF;
 181         }
 182
 183         *ofs += (index - *ofs);
 184 }
 185
 186 int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer, u16 *buflen,
 187                 char *ntlm_blob, int ntlm_blob_len)
 188 {
 189         char *buf;
 190         unsigned int ofs = 0;
 191         int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1;
 192         int oid_len = 4 + compute_asn_hdr_len_bytes(NTLMSSP_OID_LEN) * 2 +
 193                 NTLMSSP_OID_LEN;
 194         int ntlmssp_len = 4 + compute_asn_hdr_len_bytes(ntlm_blob_len) * 2 +
 195                 ntlm_blob_len;
 196         int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len +
 197                         oid_len + ntlmssp_len) * 2 +
 198                         neg_result_len + oid_len + ntlmssp_len;
 199
 200         buf = kmalloc(total_len, GFP_KERNEL);
 201         if (!buf)
 202                 return -ENOMEM;
 203
 204         /* insert main gss header */
 205         encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len + oid_len +
 206                         ntlmssp_len);
 207
 208         /* insert neg result */
 209         encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1);
 210         buf[ofs++] = 1;
 211
 212         /* insert oid */
 213         encode_asn_tag(buf, &ofs, 0xa1, 0x06, NTLMSSP_OID_LEN);
 214         memcpy(buf + ofs, NTLMSSP_OID_STR, NTLMSSP_OID_LEN);
 215         ofs += NTLMSSP_OID_LEN;
 216
 217         /* insert response token - ntlmssp blob */
 218         encode_asn_tag(buf, &ofs, 0xa2, 0x04, ntlm_blob_len);
 219         memcpy(buf + ofs, ntlm_blob, ntlm_blob_len);
 220         ofs += ntlm_blob_len;
 221
 222         *pbuffer = buf;
 223         *buflen = total_len;
 224         return 0;
 225 }
 226
 227 int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, u16 *buflen,
 228                 int neg_result)
 229 {
 230         char *buf;
 231         unsigned int ofs = 0;
 232         int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1;
 233         int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len) * 2 +
 234                 neg_result_len;
 235
 236         buf = kmalloc(total_len, GFP_KERNEL);
 237         if (!buf)
 238                 return -ENOMEM;
 239
 240         /* insert main gss header */
 241         encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len);
 242
 243         /* insert neg result */
 244         encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1);
 245         if (neg_result)
 246                 buf[ofs++] = 2;
 247         else
 248                 buf[ofs++] = 0;
 249
 250         *pbuffer = buf;
 251         *buflen = total_len;
 252         return 0;
 253 }
 254
 255 int gssapi_this_mech(void *context, size_t hdrlen,
 256                 unsigned char tag, const void *value, size_t vlen)
 257 {
 258         unsigned long *oid;
 259         size_t oidlen;
 260         int err = 0;
 261
 262         if (!asn1_oid_decode(value, vlen, &oid, &oidlen)) {
 263                 err = -EBADMSG;
 264                 goto out;
 265         }
 266
 267         if (!oid_eq(oid, oidlen, SPNEGO_OID, SPNEGO_OID_LEN))
 268                 err = -EBADMSG;
 269         kfree(oid);
 270 out:
 271         if (err) {
 272                 char buf[50];
 273
 274                 sprint_oid(value, vlen, buf, sizeof(buf));
 275                 ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf);
 276         }
 277         return err;
 278 }
 279
 280 int neg_token_init_mech_type(void *context, size_t hdrlen,
 281                 unsigned char tag, const void *value, size_t vlen)
 282 {
 283         struct ksmbd_conn *conn = context;
 284         unsigned long *oid;
 285         size_t oidlen;
 286         int mech_type;
 287         char buf[50];
 288
 289         if (!asn1_oid_decode(value, vlen, &oid, &oidlen))
 290                 goto fail;
 291
 292         if (oid_eq(oid, oidlen, NTLMSSP_OID, NTLMSSP_OID_LEN))
 293                 mech_type = KSMBD_AUTH_NTLMSSP;
 294         else if (oid_eq(oid, oidlen, MSKRB5_OID, MSKRB5_OID_LEN))
 295                 mech_type = KSMBD_AUTH_MSKRB5;
 296         else if (oid_eq(oid, oidlen, KRB5_OID, KRB5_OID_LEN))
 297                 mech_type = KSMBD_AUTH_KRB5;
 298         else if (oid_eq(oid, oidlen, KRB5U2U_OID, KRB5U2U_OID_LEN))
 299                 mech_type = KSMBD_AUTH_KRB5U2U;
 300         else
 301                 goto fail;
 302
 303         conn->auth_mechs |= mech_type;
 304         if (conn->preferred_auth_mech == 0)
 305                 conn->preferred_auth_mech = mech_type;
 306
 307         kfree(oid);
 308         return 0;
 309
 310 fail:
 311         kfree(oid);
 312         sprint_oid(value, vlen, buf, sizeof(buf));
 313         ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf);
 314         return -EBADMSG;
 315 }
 316
 317 int neg_token_init_mech_token(void *context, size_t hdrlen,
 318                 unsigned char tag, const void *value, size_t vlen)
 319 {
 320         struct ksmbd_conn *conn = context;
 321
 322         conn->mechToken = kmalloc(vlen + 1, GFP_KERNEL);
 323         if (!conn->mechToken)
 324                 return -ENOMEM;
 325
 326         memcpy(conn->mechToken, value, vlen);
 327         conn->mechToken[vlen] = '\0';
 328         return 0;
 329 }
 330
 331 int neg_token_targ_resp_token(void *context, size_t hdrlen,
 332                 unsigned char tag, const void *value, size_t vlen)
 333 {
 334         struct ksmbd_conn *conn = context;
 335
 336         conn->mechToken = kmalloc(vlen + 1, GFP_KERNEL);
 337         if (!conn->mechToken)
 338                 return -ENOMEM;
 339
 340         memcpy(conn->mechToken, value, vlen);
 341         conn->mechToken[vlen] = '\0';
 342         return 0;
 343 }