GNU Linux-libre 6.1.86-gnu
[releases.git] / fs / smb / server / 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 "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 }