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 "ksmbd_spnego_negtokeninit.asn1.h" 22 #include "ksmbd_spnego_negtokentarg.asn1.h" 23 24 #define NTLMSSP_OID_LEN 10 25 26 static char NTLMSSP_OID_STR[NTLMSSP_OID_LEN] = { 0x2b, 0x06, 0x01, 0x04, 0x01, 27 0x82, 0x37, 0x02, 0x02, 0x0a }; 28 29 int 30 ksmbd_decode_negTokenInit(unsigned char *security_blob, int length, 31 struct ksmbd_conn *conn) 32 { 33 return asn1_ber_decoder(&ksmbd_spnego_negtokeninit_decoder, conn, 34 security_blob, length); 35 } 36 37 int 38 ksmbd_decode_negTokenTarg(unsigned char *security_blob, int length, 39 struct ksmbd_conn *conn) 40 { 41 return asn1_ber_decoder(&ksmbd_spnego_negtokentarg_decoder, conn, 42 security_blob, length); 43 } 44 45 static int compute_asn_hdr_len_bytes(int len) 46 { 47 if (len > 0xFFFFFF) 48 return 4; 49 else if (len > 0xFFFF) 50 return 3; 51 else if (len > 0xFF) 52 return 2; 53 else if (len > 0x7F) 54 return 1; 55 else 56 return 0; 57 } 58 59 static void encode_asn_tag(char *buf, unsigned int *ofs, char tag, char seq, 60 int length) 61 { 62 int i; 63 int index = *ofs; 64 char hdr_len = compute_asn_hdr_len_bytes(length); 65 int len = length + 2 + hdr_len; 66 67 /* insert tag */ 68 buf[index++] = tag; 69 70 if (!hdr_len) { 71 buf[index++] = len; 72 } else { 73 buf[index++] = 0x80 | hdr_len; 74 for (i = hdr_len - 1; i >= 0; i--) 75 buf[index++] = (len >> (i * 8)) & 0xFF; 76 } 77 78 /* insert seq */ 79 len = len - (index - *ofs); 80 buf[index++] = seq; 81 82 if (!hdr_len) { 83 buf[index++] = len; 84 } else { 85 buf[index++] = 0x80 | hdr_len; 86 for (i = hdr_len - 1; i >= 0; i--) 87 buf[index++] = (len >> (i * 8)) & 0xFF; 88 } 89 90 *ofs += (index - *ofs); 91 } 92 93 int build_spnego_ntlmssp_neg_blob(unsigned char **pbuffer, u16 *buflen, 94 char *ntlm_blob, int ntlm_blob_len) 95 { 96 char *buf; 97 unsigned int ofs = 0; 98 int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1; 99 int oid_len = 4 + compute_asn_hdr_len_bytes(NTLMSSP_OID_LEN) * 2 + 100 NTLMSSP_OID_LEN; 101 int ntlmssp_len = 4 + compute_asn_hdr_len_bytes(ntlm_blob_len) * 2 + 102 ntlm_blob_len; 103 int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len + 104 oid_len + ntlmssp_len) * 2 + 105 neg_result_len + oid_len + ntlmssp_len; 106 107 buf = kmalloc(total_len, GFP_KERNEL); 108 if (!buf) 109 return -ENOMEM; 110 111 /* insert main gss header */ 112 encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len + oid_len + 113 ntlmssp_len); 114 115 /* insert neg result */ 116 encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1); 117 buf[ofs++] = 1; 118 119 /* insert oid */ 120 encode_asn_tag(buf, &ofs, 0xa1, 0x06, NTLMSSP_OID_LEN); 121 memcpy(buf + ofs, NTLMSSP_OID_STR, NTLMSSP_OID_LEN); 122 ofs += NTLMSSP_OID_LEN; 123 124 /* insert response token - ntlmssp blob */ 125 encode_asn_tag(buf, &ofs, 0xa2, 0x04, ntlm_blob_len); 126 memcpy(buf + ofs, ntlm_blob, ntlm_blob_len); 127 ofs += ntlm_blob_len; 128 129 *pbuffer = buf; 130 *buflen = total_len; 131 return 0; 132 } 133 134 int build_spnego_ntlmssp_auth_blob(unsigned char **pbuffer, u16 *buflen, 135 int neg_result) 136 { 137 char *buf; 138 unsigned int ofs = 0; 139 int neg_result_len = 4 + compute_asn_hdr_len_bytes(1) * 2 + 1; 140 int total_len = 4 + compute_asn_hdr_len_bytes(neg_result_len) * 2 + 141 neg_result_len; 142 143 buf = kmalloc(total_len, GFP_KERNEL); 144 if (!buf) 145 return -ENOMEM; 146 147 /* insert main gss header */ 148 encode_asn_tag(buf, &ofs, 0xa1, 0x30, neg_result_len); 149 150 /* insert neg result */ 151 encode_asn_tag(buf, &ofs, 0xa0, 0x0a, 1); 152 if (neg_result) 153 buf[ofs++] = 2; 154 else 155 buf[ofs++] = 0; 156 157 *pbuffer = buf; 158 *buflen = total_len; 159 return 0; 160 } 161 162 int ksmbd_gssapi_this_mech(void *context, size_t hdrlen, unsigned char tag, 163 const void *value, size_t vlen) 164 { 165 enum OID oid; 166 167 oid = look_up_OID(value, vlen); 168 if (oid != OID_spnego) { 169 char buf[50]; 170 171 sprint_oid(value, vlen, buf, sizeof(buf)); 172 ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf); 173 return -EBADMSG; 174 } 175 176 return 0; 177 } 178 179 int ksmbd_neg_token_init_mech_type(void *context, size_t hdrlen, 180 unsigned char tag, const void *value, 181 size_t vlen) 182 { 183 struct ksmbd_conn *conn = context; 184 enum OID oid; 185 int mech_type; 186 187 oid = look_up_OID(value, vlen); 188 if (oid == OID_ntlmssp) { 189 mech_type = KSMBD_AUTH_NTLMSSP; 190 } else if (oid == OID_mskrb5) { 191 mech_type = KSMBD_AUTH_MSKRB5; 192 } else if (oid == OID_krb5) { 193 mech_type = KSMBD_AUTH_KRB5; 194 } else if (oid == OID_krb5u2u) { 195 mech_type = KSMBD_AUTH_KRB5U2U; 196 } else { 197 char buf[50]; 198 199 sprint_oid(value, vlen, buf, sizeof(buf)); 200 ksmbd_debug(AUTH, "Unexpected OID: %s\n", buf); 201 return -EBADMSG; 202 } 203 204 conn->auth_mechs |= mech_type; 205 if (conn->preferred_auth_mech == 0) 206 conn->preferred_auth_mech = mech_type; 207 208 return 0; 209 } 210 211 static int ksmbd_neg_token_alloc(void *context, size_t hdrlen, 212 unsigned char tag, const void *value, 213 size_t vlen) 214 { 215 struct ksmbd_conn *conn = context; 216 217 if (!vlen) 218 return -EINVAL; 219 220 conn->mechToken = kmemdup_nul(value, vlen, GFP_KERNEL); 221 if (!conn->mechToken) 222 return -ENOMEM; 223 224 conn->mechTokenLen = (unsigned int)vlen; 225 226 return 0; 227 } 228 229 int ksmbd_neg_token_init_mech_token(void *context, size_t hdrlen, 230 unsigned char tag, const void *value, 231 size_t vlen) 232 { 233 return ksmbd_neg_token_alloc(context, hdrlen, tag, value, vlen); 234 } 235 236 int ksmbd_neg_token_targ_resp_token(void *context, size_t hdrlen, 237 unsigned char tag, const void *value, 238 size_t vlen) 239 { 240 return ksmbd_neg_token_alloc(context, hdrlen, tag, value, vlen); 241 } 242