Revert "ext4: use old interface for ext4_readdir()"
[linux-3.10.git] / fs / cifs / asn1.c
1 /*
2  * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in
3  * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich
4  *
5  * Copyright (c) 2000 RP Internet (www.rpi.net.au).
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
18  */
19
20 #include <linux/module.h>
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23 #include <linux/mm.h>
24 #include <linux/slab.h>
25 #include "cifspdu.h"
26 #include "cifsglob.h"
27 #include "cifs_debug.h"
28 #include "cifsproto.h"
29
30 /*****************************************************************************
31  *
32  * Basic ASN.1 decoding routines (gxsnmp author Dirk Wisse)
33  *
34  *****************************************************************************/
35
36 /* Class */
37 #define ASN1_UNI        0       /* Universal */
38 #define ASN1_APL        1       /* Application */
39 #define ASN1_CTX        2       /* Context */
40 #define ASN1_PRV        3       /* Private */
41
42 /* Tag */
43 #define ASN1_EOC        0       /* End Of Contents or N/A */
44 #define ASN1_BOL        1       /* Boolean */
45 #define ASN1_INT        2       /* Integer */
46 #define ASN1_BTS        3       /* Bit String */
47 #define ASN1_OTS        4       /* Octet String */
48 #define ASN1_NUL        5       /* Null */
49 #define ASN1_OJI        6       /* Object Identifier  */
50 #define ASN1_OJD        7       /* Object Description */
51 #define ASN1_EXT        8       /* External */
52 #define ASN1_ENUM       10      /* Enumerated */
53 #define ASN1_SEQ        16      /* Sequence */
54 #define ASN1_SET        17      /* Set */
55 #define ASN1_NUMSTR     18      /* Numerical String */
56 #define ASN1_PRNSTR     19      /* Printable String */
57 #define ASN1_TEXSTR     20      /* Teletext String */
58 #define ASN1_VIDSTR     21      /* Video String */
59 #define ASN1_IA5STR     22      /* IA5 String */
60 #define ASN1_UNITIM     23      /* Universal Time */
61 #define ASN1_GENTIM     24      /* General Time */
62 #define ASN1_GRASTR     25      /* Graphical String */
63 #define ASN1_VISSTR     26      /* Visible String */
64 #define ASN1_GENSTR     27      /* General String */
65
66 /* Primitive / Constructed methods*/
67 #define ASN1_PRI        0       /* Primitive */
68 #define ASN1_CON        1       /* Constructed */
69
70 /*
71  * Error codes.
72  */
73 #define ASN1_ERR_NOERROR                0
74 #define ASN1_ERR_DEC_EMPTY              2
75 #define ASN1_ERR_DEC_EOC_MISMATCH       3
76 #define ASN1_ERR_DEC_LENGTH_MISMATCH    4
77 #define ASN1_ERR_DEC_BADVALUE           5
78
79 #define SPNEGO_OID_LEN 7
80 #define NTLMSSP_OID_LEN  10
81 #define KRB5_OID_LEN  7
82 #define KRB5U2U_OID_LEN  8
83 #define MSKRB5_OID_LEN  7
84 static unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 };
85 static unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 };
86 static unsigned long KRB5_OID[7] = { 1, 2, 840, 113554, 1, 2, 2 };
87 static unsigned long KRB5U2U_OID[8] = { 1, 2, 840, 113554, 1, 2, 2, 3 };
88 static unsigned long MSKRB5_OID[7] = { 1, 2, 840, 48018, 1, 2, 2 };
89
90 /*
91  * ASN.1 context.
92  */
93 struct asn1_ctx {
94         int error;              /* Error condition */
95         unsigned char *pointer; /* Octet just to be decoded */
96         unsigned char *begin;   /* First octet */
97         unsigned char *end;     /* Octet after last octet */
98 };
99
100 /*
101  * Octet string (not null terminated)
102  */
103 struct asn1_octstr {
104         unsigned char *data;
105         unsigned int len;
106 };
107
108 static void
109 asn1_open(struct asn1_ctx *ctx, unsigned char *buf, unsigned int len)
110 {
111         ctx->begin = buf;
112         ctx->end = buf + len;
113         ctx->pointer = buf;
114         ctx->error = ASN1_ERR_NOERROR;
115 }
116
117 static unsigned char
118 asn1_octet_decode(struct asn1_ctx *ctx, unsigned char *ch)
119 {
120         if (ctx->pointer >= ctx->end) {
121                 ctx->error = ASN1_ERR_DEC_EMPTY;
122                 return 0;
123         }
124         *ch = *(ctx->pointer)++;
125         return 1;
126 }
127
128 #if 0 /* will be needed later by spnego decoding/encoding of ntlmssp */
129 static unsigned char
130 asn1_enum_decode(struct asn1_ctx *ctx, __le32 *val)
131 {
132         unsigned char ch;
133
134         if (ctx->pointer >= ctx->end) {
135                 ctx->error = ASN1_ERR_DEC_EMPTY;
136                 return 0;
137         }
138
139         ch = *(ctx->pointer)++; /* ch has 0xa, ptr points to length octet */
140         if ((ch) == ASN1_ENUM)  /* if ch value is ENUM, 0xa */
141                 *val = *(++(ctx->pointer)); /* value has enum value */
142         else
143                 return 0;
144
145         ctx->pointer++;
146         return 1;
147 }
148 #endif
149
150 static unsigned char
151 asn1_tag_decode(struct asn1_ctx *ctx, unsigned int *tag)
152 {
153         unsigned char ch;
154
155         *tag = 0;
156
157         do {
158                 if (!asn1_octet_decode(ctx, &ch))
159                         return 0;
160                 *tag <<= 7;
161                 *tag |= ch & 0x7F;
162         } while ((ch & 0x80) == 0x80);
163         return 1;
164 }
165
166 static unsigned char
167 asn1_id_decode(struct asn1_ctx *ctx,
168                unsigned int *cls, unsigned int *con, unsigned int *tag)
169 {
170         unsigned char ch;
171
172         if (!asn1_octet_decode(ctx, &ch))
173                 return 0;
174
175         *cls = (ch & 0xC0) >> 6;
176         *con = (ch & 0x20) >> 5;
177         *tag = (ch & 0x1F);
178
179         if (*tag == 0x1F) {
180                 if (!asn1_tag_decode(ctx, tag))
181                         return 0;
182         }
183         return 1;
184 }
185
186 static unsigned char
187 asn1_length_decode(struct asn1_ctx *ctx, unsigned int *def, unsigned int *len)
188 {
189         unsigned char ch, cnt;
190
191         if (!asn1_octet_decode(ctx, &ch))
192                 return 0;
193
194         if (ch == 0x80)
195                 *def = 0;
196         else {
197                 *def = 1;
198
199                 if (ch < 0x80)
200                         *len = ch;
201                 else {
202                         cnt = (unsigned char) (ch & 0x7F);
203                         *len = 0;
204
205                         while (cnt > 0) {
206                                 if (!asn1_octet_decode(ctx, &ch))
207                                         return 0;
208                                 *len <<= 8;
209                                 *len |= ch;
210                                 cnt--;
211                         }
212                 }
213         }
214
215         /* don't trust len bigger than ctx buffer */
216         if (*len > ctx->end - ctx->pointer)
217                 return 0;
218
219         return 1;
220 }
221
222 static unsigned char
223 asn1_header_decode(struct asn1_ctx *ctx,
224                    unsigned char **eoc,
225                    unsigned int *cls, unsigned int *con, unsigned int *tag)
226 {
227         unsigned int def = 0;
228         unsigned int len = 0;
229
230         if (!asn1_id_decode(ctx, cls, con, tag))
231                 return 0;
232
233         if (!asn1_length_decode(ctx, &def, &len))
234                 return 0;
235
236         /* primitive shall be definite, indefinite shall be constructed */
237         if (*con == ASN1_PRI && !def)
238                 return 0;
239
240         if (def)
241                 *eoc = ctx->pointer + len;
242         else
243                 *eoc = NULL;
244         return 1;
245 }
246
247 static unsigned char
248 asn1_eoc_decode(struct asn1_ctx *ctx, unsigned char *eoc)
249 {
250         unsigned char ch;
251
252         if (eoc == NULL) {
253                 if (!asn1_octet_decode(ctx, &ch))
254                         return 0;
255
256                 if (ch != 0x00) {
257                         ctx->error = ASN1_ERR_DEC_EOC_MISMATCH;
258                         return 0;
259                 }
260
261                 if (!asn1_octet_decode(ctx, &ch))
262                         return 0;
263
264                 if (ch != 0x00) {
265                         ctx->error = ASN1_ERR_DEC_EOC_MISMATCH;
266                         return 0;
267                 }
268                 return 1;
269         } else {
270                 if (ctx->pointer != eoc) {
271                         ctx->error = ASN1_ERR_DEC_LENGTH_MISMATCH;
272                         return 0;
273                 }
274                 return 1;
275         }
276 }
277
278 /* static unsigned char asn1_null_decode(struct asn1_ctx *ctx,
279                                       unsigned char *eoc)
280 {
281         ctx->pointer = eoc;
282         return 1;
283 }
284
285 static unsigned char asn1_long_decode(struct asn1_ctx *ctx,
286                                       unsigned char *eoc, long *integer)
287 {
288         unsigned char ch;
289         unsigned int len;
290
291         if (!asn1_octet_decode(ctx, &ch))
292                 return 0;
293
294         *integer = (signed char) ch;
295         len = 1;
296
297         while (ctx->pointer < eoc) {
298                 if (++len > sizeof(long)) {
299                         ctx->error = ASN1_ERR_DEC_BADVALUE;
300                         return 0;
301                 }
302
303                 if (!asn1_octet_decode(ctx, &ch))
304                         return 0;
305
306                 *integer <<= 8;
307                 *integer |= ch;
308         }
309         return 1;
310 }
311
312 static unsigned char asn1_uint_decode(struct asn1_ctx *ctx,
313                                       unsigned char *eoc,
314                                       unsigned int *integer)
315 {
316         unsigned char ch;
317         unsigned int len;
318
319         if (!asn1_octet_decode(ctx, &ch))
320                 return 0;
321
322         *integer = ch;
323         if (ch == 0)
324                 len = 0;
325         else
326                 len = 1;
327
328         while (ctx->pointer < eoc) {
329                 if (++len > sizeof(unsigned int)) {
330                         ctx->error = ASN1_ERR_DEC_BADVALUE;
331                         return 0;
332                 }
333
334                 if (!asn1_octet_decode(ctx, &ch))
335                         return 0;
336
337                 *integer <<= 8;
338                 *integer |= ch;
339         }
340         return 1;
341 }
342
343 static unsigned char asn1_ulong_decode(struct asn1_ctx *ctx,
344                                        unsigned char *eoc,
345                                        unsigned long *integer)
346 {
347         unsigned char ch;
348         unsigned int len;
349
350         if (!asn1_octet_decode(ctx, &ch))
351                 return 0;
352
353         *integer = ch;
354         if (ch == 0)
355                 len = 0;
356         else
357                 len = 1;
358
359         while (ctx->pointer < eoc) {
360                 if (++len > sizeof(unsigned long)) {
361                         ctx->error = ASN1_ERR_DEC_BADVALUE;
362                         return 0;
363                 }
364
365                 if (!asn1_octet_decode(ctx, &ch))
366                         return 0;
367
368                 *integer <<= 8;
369                 *integer |= ch;
370         }
371         return 1;
372 }
373
374 static unsigned char
375 asn1_octets_decode(struct asn1_ctx *ctx,
376                    unsigned char *eoc,
377                    unsigned char **octets, unsigned int *len)
378 {
379         unsigned char *ptr;
380
381         *len = 0;
382
383         *octets = kmalloc(eoc - ctx->pointer, GFP_ATOMIC);
384         if (*octets == NULL) {
385                 return 0;
386         }
387
388         ptr = *octets;
389         while (ctx->pointer < eoc) {
390                 if (!asn1_octet_decode(ctx, (unsigned char *) ptr++)) {
391                         kfree(*octets);
392                         *octets = NULL;
393                         return 0;
394                 }
395                 (*len)++;
396         }
397         return 1;
398 } */
399
400 static unsigned char
401 asn1_subid_decode(struct asn1_ctx *ctx, unsigned long *subid)
402 {
403         unsigned char ch;
404
405         *subid = 0;
406
407         do {
408                 if (!asn1_octet_decode(ctx, &ch))
409                         return 0;
410
411                 *subid <<= 7;
412                 *subid |= ch & 0x7F;
413         } while ((ch & 0x80) == 0x80);
414         return 1;
415 }
416
417 static int
418 asn1_oid_decode(struct asn1_ctx *ctx,
419                 unsigned char *eoc, unsigned long **oid, unsigned int *len)
420 {
421         unsigned long subid;
422         unsigned int size;
423         unsigned long *optr;
424
425         size = eoc - ctx->pointer + 1;
426
427         /* first subid actually encodes first two subids */
428         if (size < 2 || size > UINT_MAX/sizeof(unsigned long))
429                 return 0;
430
431         *oid = kmalloc(size * sizeof(unsigned long), GFP_ATOMIC);
432         if (*oid == NULL)
433                 return 0;
434
435         optr = *oid;
436
437         if (!asn1_subid_decode(ctx, &subid)) {
438                 kfree(*oid);
439                 *oid = NULL;
440                 return 0;
441         }
442
443         if (subid < 40) {
444                 optr[0] = 0;
445                 optr[1] = subid;
446         } else if (subid < 80) {
447                 optr[0] = 1;
448                 optr[1] = subid - 40;
449         } else {
450                 optr[0] = 2;
451                 optr[1] = subid - 80;
452         }
453
454         *len = 2;
455         optr += 2;
456
457         while (ctx->pointer < eoc) {
458                 if (++(*len) > size) {
459                         ctx->error = ASN1_ERR_DEC_BADVALUE;
460                         kfree(*oid);
461                         *oid = NULL;
462                         return 0;
463                 }
464
465                 if (!asn1_subid_decode(ctx, optr++)) {
466                         kfree(*oid);
467                         *oid = NULL;
468                         return 0;
469                 }
470         }
471         return 1;
472 }
473
474 static int
475 compare_oid(unsigned long *oid1, unsigned int oid1len,
476             unsigned long *oid2, unsigned int oid2len)
477 {
478         unsigned int i;
479
480         if (oid1len != oid2len)
481                 return 0;
482         else {
483                 for (i = 0; i < oid1len; i++) {
484                         if (oid1[i] != oid2[i])
485                                 return 0;
486                 }
487                 return 1;
488         }
489 }
490
491         /* BB check for endian conversion issues here */
492
493 int
494 decode_negTokenInit(unsigned char *security_blob, int length,
495                     struct TCP_Server_Info *server)
496 {
497         struct asn1_ctx ctx;
498         unsigned char *end;
499         unsigned char *sequence_end;
500         unsigned long *oid = NULL;
501         unsigned int cls, con, tag, oidlen, rc;
502
503         /* cifs_dump_mem(" Received SecBlob ", security_blob, length); */
504
505         asn1_open(&ctx, security_blob, length);
506
507         /* GSSAPI header */
508         if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
509                 cifs_dbg(FYI, "Error decoding negTokenInit header\n");
510                 return 0;
511         } else if ((cls != ASN1_APL) || (con != ASN1_CON)
512                    || (tag != ASN1_EOC)) {
513                 cifs_dbg(FYI, "cls = %d con = %d tag = %d\n", cls, con, tag);
514                 return 0;
515         }
516
517         /* Check for SPNEGO OID -- remember to free obj->oid */
518         rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag);
519         if (rc) {
520                 if ((tag == ASN1_OJI) && (con == ASN1_PRI) &&
521                     (cls == ASN1_UNI)) {
522                         rc = asn1_oid_decode(&ctx, end, &oid, &oidlen);
523                         if (rc) {
524                                 rc = compare_oid(oid, oidlen, SPNEGO_OID,
525                                                  SPNEGO_OID_LEN);
526                                 kfree(oid);
527                         }
528                 } else
529                         rc = 0;
530         }
531
532         /* SPNEGO OID not present or garbled -- bail out */
533         if (!rc) {
534                 cifs_dbg(FYI, "Error decoding negTokenInit header\n");
535                 return 0;
536         }
537
538         /* SPNEGO */
539         if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
540                 cifs_dbg(FYI, "Error decoding negTokenInit\n");
541                 return 0;
542         } else if ((cls != ASN1_CTX) || (con != ASN1_CON)
543                    || (tag != ASN1_EOC)) {
544                 cifs_dbg(FYI, "cls = %d con = %d tag = %d end = %p (%d) exit 0\n",
545                          cls, con, tag, end, *end);
546                 return 0;
547         }
548
549         /* negTokenInit */
550         if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
551                 cifs_dbg(FYI, "Error decoding negTokenInit\n");
552                 return 0;
553         } else if ((cls != ASN1_UNI) || (con != ASN1_CON)
554                    || (tag != ASN1_SEQ)) {
555                 cifs_dbg(FYI, "cls = %d con = %d tag = %d end = %p (%d) exit 1\n",
556                          cls, con, tag, end, *end);
557                 return 0;
558         }
559
560         /* sequence */
561         if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
562                 cifs_dbg(FYI, "Error decoding 2nd part of negTokenInit\n");
563                 return 0;
564         } else if ((cls != ASN1_CTX) || (con != ASN1_CON)
565                    || (tag != ASN1_EOC)) {
566                 cifs_dbg(FYI, "cls = %d con = %d tag = %d end = %p (%d) exit 0\n",
567                          cls, con, tag, end, *end);
568                 return 0;
569         }
570
571         /* sequence of */
572         if (asn1_header_decode
573             (&ctx, &sequence_end, &cls, &con, &tag) == 0) {
574                 cifs_dbg(FYI, "Error decoding 2nd part of negTokenInit\n");
575                 return 0;
576         } else if ((cls != ASN1_UNI) || (con != ASN1_CON)
577                    || (tag != ASN1_SEQ)) {
578                 cifs_dbg(FYI, "cls = %d con = %d tag = %d end = %p (%d) exit 1\n",
579                          cls, con, tag, end, *end);
580                 return 0;
581         }
582
583         /* list of security mechanisms */
584         while (!asn1_eoc_decode(&ctx, sequence_end)) {
585                 rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag);
586                 if (!rc) {
587                         cifs_dbg(FYI, "Error decoding negTokenInit hdr exit2\n");
588                         return 0;
589                 }
590                 if ((tag == ASN1_OJI) && (con == ASN1_PRI)) {
591                         if (asn1_oid_decode(&ctx, end, &oid, &oidlen)) {
592
593                                 cifs_dbg(FYI, "OID len = %d oid = 0x%lx 0x%lx 0x%lx 0x%lx\n",
594                                          oidlen, *oid, *(oid + 1), *(oid + 2),
595                                          *(oid + 3));
596
597                                 if (compare_oid(oid, oidlen, MSKRB5_OID,
598                                                 MSKRB5_OID_LEN))
599                                         server->sec_mskerberos = true;
600                                 else if (compare_oid(oid, oidlen, KRB5U2U_OID,
601                                                      KRB5U2U_OID_LEN))
602                                         server->sec_kerberosu2u = true;
603                                 else if (compare_oid(oid, oidlen, KRB5_OID,
604                                                      KRB5_OID_LEN))
605                                         server->sec_kerberos = true;
606                                 else if (compare_oid(oid, oidlen, NTLMSSP_OID,
607                                                      NTLMSSP_OID_LEN))
608                                         server->sec_ntlmssp = true;
609
610                                 kfree(oid);
611                         }
612                 } else {
613                         cifs_dbg(FYI, "Should be an oid what is going on?\n");
614                 }
615         }
616
617         /*
618          * We currently ignore anything at the end of the SPNEGO blob after
619          * the mechTypes have been parsed, since none of that info is
620          * used at the moment.
621          */
622         return 1;
623 }