]>
Commit | Line | Data |
---|---|---|
50c2f753 | 1 | /* |
1da177e4 LT |
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 | |
50c2f753 | 4 | * |
1da177e4 LT |
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 | ||
1da177e4 LT |
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_SEQ 16 /* Sequence */ | |
53 | #define ASN1_SET 17 /* Set */ | |
54 | #define ASN1_NUMSTR 18 /* Numerical String */ | |
55 | #define ASN1_PRNSTR 19 /* Printable String */ | |
56 | #define ASN1_TEXSTR 20 /* Teletext String */ | |
57 | #define ASN1_VIDSTR 21 /* Video String */ | |
58 | #define ASN1_IA5STR 22 /* IA5 String */ | |
59 | #define ASN1_UNITIM 23 /* Universal Time */ | |
60 | #define ASN1_GENTIM 24 /* General Time */ | |
61 | #define ASN1_GRASTR 25 /* Graphical String */ | |
62 | #define ASN1_VISSTR 26 /* Visible String */ | |
63 | #define ASN1_GENSTR 27 /* General String */ | |
64 | ||
65 | /* Primitive / Constructed methods*/ | |
66 | #define ASN1_PRI 0 /* Primitive */ | |
67 | #define ASN1_CON 1 /* Constructed */ | |
68 | ||
69 | /* | |
70 | * Error codes. | |
71 | */ | |
72 | #define ASN1_ERR_NOERROR 0 | |
73 | #define ASN1_ERR_DEC_EMPTY 2 | |
74 | #define ASN1_ERR_DEC_EOC_MISMATCH 3 | |
75 | #define ASN1_ERR_DEC_LENGTH_MISMATCH 4 | |
76 | #define ASN1_ERR_DEC_BADVALUE 5 | |
77 | ||
78 | #define SPNEGO_OID_LEN 7 | |
79 | #define NTLMSSP_OID_LEN 10 | |
e545937a JL |
80 | #define KRB5_OID_LEN 7 |
81 | #define MSKRB5_OID_LEN 7 | |
1da177e4 LT |
82 | static unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 }; |
83 | static unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 }; | |
e545937a JL |
84 | static unsigned long KRB5_OID[7] = { 1, 2, 840, 113554, 1, 2, 2 }; |
85 | static unsigned long MSKRB5_OID[7] = { 1, 2, 840, 48018, 1, 2, 2 }; | |
1da177e4 | 86 | |
50c2f753 | 87 | /* |
1da177e4 LT |
88 | * ASN.1 context. |
89 | */ | |
90 | struct asn1_ctx { | |
91 | int error; /* Error condition */ | |
92 | unsigned char *pointer; /* Octet just to be decoded */ | |
93 | unsigned char *begin; /* First octet */ | |
94 | unsigned char *end; /* Octet after last octet */ | |
95 | }; | |
96 | ||
97 | /* | |
98 | * Octet string (not null terminated) | |
99 | */ | |
100 | struct asn1_octstr { | |
101 | unsigned char *data; | |
102 | unsigned int len; | |
103 | }; | |
104 | ||
105 | static void | |
106 | asn1_open(struct asn1_ctx *ctx, unsigned char *buf, unsigned int len) | |
107 | { | |
108 | ctx->begin = buf; | |
109 | ctx->end = buf + len; | |
110 | ctx->pointer = buf; | |
111 | ctx->error = ASN1_ERR_NOERROR; | |
112 | } | |
113 | ||
114 | static unsigned char | |
115 | asn1_octet_decode(struct asn1_ctx *ctx, unsigned char *ch) | |
116 | { | |
117 | if (ctx->pointer >= ctx->end) { | |
118 | ctx->error = ASN1_ERR_DEC_EMPTY; | |
119 | return 0; | |
120 | } | |
121 | *ch = *(ctx->pointer)++; | |
122 | return 1; | |
123 | } | |
124 | ||
125 | static unsigned char | |
126 | asn1_tag_decode(struct asn1_ctx *ctx, unsigned int *tag) | |
127 | { | |
128 | unsigned char ch; | |
129 | ||
130 | *tag = 0; | |
131 | ||
132 | do { | |
133 | if (!asn1_octet_decode(ctx, &ch)) | |
134 | return 0; | |
135 | *tag <<= 7; | |
136 | *tag |= ch & 0x7F; | |
137 | } while ((ch & 0x80) == 0x80); | |
138 | return 1; | |
139 | } | |
140 | ||
141 | static unsigned char | |
142 | asn1_id_decode(struct asn1_ctx *ctx, | |
143 | unsigned int *cls, unsigned int *con, unsigned int *tag) | |
144 | { | |
145 | unsigned char ch; | |
146 | ||
147 | if (!asn1_octet_decode(ctx, &ch)) | |
148 | return 0; | |
149 | ||
150 | *cls = (ch & 0xC0) >> 6; | |
151 | *con = (ch & 0x20) >> 5; | |
152 | *tag = (ch & 0x1F); | |
153 | ||
154 | if (*tag == 0x1F) { | |
155 | if (!asn1_tag_decode(ctx, tag)) | |
156 | return 0; | |
157 | } | |
158 | return 1; | |
159 | } | |
160 | ||
161 | static unsigned char | |
162 | asn1_length_decode(struct asn1_ctx *ctx, unsigned int *def, unsigned int *len) | |
163 | { | |
164 | unsigned char ch, cnt; | |
165 | ||
166 | if (!asn1_octet_decode(ctx, &ch)) | |
167 | return 0; | |
168 | ||
169 | if (ch == 0x80) | |
170 | *def = 0; | |
171 | else { | |
172 | *def = 1; | |
173 | ||
174 | if (ch < 0x80) | |
175 | *len = ch; | |
176 | else { | |
177 | cnt = (unsigned char) (ch & 0x7F); | |
178 | *len = 0; | |
179 | ||
180 | while (cnt > 0) { | |
181 | if (!asn1_octet_decode(ctx, &ch)) | |
182 | return 0; | |
183 | *len <<= 8; | |
184 | *len |= ch; | |
185 | cnt--; | |
186 | } | |
187 | } | |
188 | } | |
189 | return 1; | |
190 | } | |
191 | ||
192 | static unsigned char | |
193 | asn1_header_decode(struct asn1_ctx *ctx, | |
194 | unsigned char **eoc, | |
195 | unsigned int *cls, unsigned int *con, unsigned int *tag) | |
196 | { | |
50c2f753 | 197 | unsigned int def = 0; |
ab2f218f | 198 | unsigned int len = 0; |
1da177e4 LT |
199 | |
200 | if (!asn1_id_decode(ctx, cls, con, tag)) | |
201 | return 0; | |
202 | ||
203 | if (!asn1_length_decode(ctx, &def, &len)) | |
204 | return 0; | |
205 | ||
206 | if (def) | |
207 | *eoc = ctx->pointer + len; | |
208 | else | |
209 | *eoc = NULL; | |
210 | return 1; | |
211 | } | |
212 | ||
213 | static unsigned char | |
214 | asn1_eoc_decode(struct asn1_ctx *ctx, unsigned char *eoc) | |
215 | { | |
216 | unsigned char ch; | |
217 | ||
218 | if (eoc == NULL) { | |
219 | if (!asn1_octet_decode(ctx, &ch)) | |
220 | return 0; | |
221 | ||
222 | if (ch != 0x00) { | |
223 | ctx->error = ASN1_ERR_DEC_EOC_MISMATCH; | |
224 | return 0; | |
225 | } | |
226 | ||
227 | if (!asn1_octet_decode(ctx, &ch)) | |
228 | return 0; | |
229 | ||
230 | if (ch != 0x00) { | |
231 | ctx->error = ASN1_ERR_DEC_EOC_MISMATCH; | |
232 | return 0; | |
233 | } | |
234 | return 1; | |
235 | } else { | |
236 | if (ctx->pointer != eoc) { | |
237 | ctx->error = ASN1_ERR_DEC_LENGTH_MISMATCH; | |
238 | return 0; | |
239 | } | |
240 | return 1; | |
241 | } | |
242 | } | |
243 | ||
244 | /* static unsigned char asn1_null_decode(struct asn1_ctx *ctx, | |
245 | unsigned char *eoc) | |
246 | { | |
247 | ctx->pointer = eoc; | |
248 | return 1; | |
249 | } | |
250 | ||
251 | static unsigned char asn1_long_decode(struct asn1_ctx *ctx, | |
252 | unsigned char *eoc, long *integer) | |
253 | { | |
254 | unsigned char ch; | |
255 | unsigned int len; | |
256 | ||
257 | if (!asn1_octet_decode(ctx, &ch)) | |
258 | return 0; | |
259 | ||
260 | *integer = (signed char) ch; | |
261 | len = 1; | |
262 | ||
263 | while (ctx->pointer < eoc) { | |
264 | if (++len > sizeof(long)) { | |
265 | ctx->error = ASN1_ERR_DEC_BADVALUE; | |
266 | return 0; | |
267 | } | |
268 | ||
269 | if (!asn1_octet_decode(ctx, &ch)) | |
270 | return 0; | |
271 | ||
272 | *integer <<= 8; | |
273 | *integer |= ch; | |
274 | } | |
275 | return 1; | |
276 | } | |
277 | ||
278 | static unsigned char asn1_uint_decode(struct asn1_ctx *ctx, | |
279 | unsigned char *eoc, | |
280 | unsigned int *integer) | |
281 | { | |
282 | unsigned char ch; | |
283 | unsigned int len; | |
284 | ||
285 | if (!asn1_octet_decode(ctx, &ch)) | |
286 | return 0; | |
287 | ||
288 | *integer = ch; | |
289 | if (ch == 0) | |
290 | len = 0; | |
291 | else | |
292 | len = 1; | |
293 | ||
294 | while (ctx->pointer < eoc) { | |
295 | if (++len > sizeof(unsigned int)) { | |
296 | ctx->error = ASN1_ERR_DEC_BADVALUE; | |
297 | return 0; | |
298 | } | |
299 | ||
300 | if (!asn1_octet_decode(ctx, &ch)) | |
301 | return 0; | |
302 | ||
303 | *integer <<= 8; | |
304 | *integer |= ch; | |
305 | } | |
306 | return 1; | |
307 | } | |
308 | ||
309 | static unsigned char asn1_ulong_decode(struct asn1_ctx *ctx, | |
310 | unsigned char *eoc, | |
311 | unsigned long *integer) | |
312 | { | |
313 | unsigned char ch; | |
314 | unsigned int len; | |
315 | ||
316 | if (!asn1_octet_decode(ctx, &ch)) | |
317 | return 0; | |
318 | ||
319 | *integer = ch; | |
320 | if (ch == 0) | |
321 | len = 0; | |
322 | else | |
323 | len = 1; | |
324 | ||
325 | while (ctx->pointer < eoc) { | |
326 | if (++len > sizeof(unsigned long)) { | |
327 | ctx->error = ASN1_ERR_DEC_BADVALUE; | |
328 | return 0; | |
329 | } | |
330 | ||
331 | if (!asn1_octet_decode(ctx, &ch)) | |
332 | return 0; | |
333 | ||
334 | *integer <<= 8; | |
335 | *integer |= ch; | |
336 | } | |
337 | return 1; | |
50c2f753 | 338 | } |
1da177e4 LT |
339 | |
340 | static unsigned char | |
341 | asn1_octets_decode(struct asn1_ctx *ctx, | |
342 | unsigned char *eoc, | |
343 | unsigned char **octets, unsigned int *len) | |
344 | { | |
345 | unsigned char *ptr; | |
346 | ||
347 | *len = 0; | |
348 | ||
349 | *octets = kmalloc(eoc - ctx->pointer, GFP_ATOMIC); | |
350 | if (*octets == NULL) { | |
351 | return 0; | |
352 | } | |
353 | ||
354 | ptr = *octets; | |
355 | while (ctx->pointer < eoc) { | |
356 | if (!asn1_octet_decode(ctx, (unsigned char *) ptr++)) { | |
357 | kfree(*octets); | |
358 | *octets = NULL; | |
359 | return 0; | |
360 | } | |
361 | (*len)++; | |
362 | } | |
363 | return 1; | |
364 | } */ | |
365 | ||
366 | static unsigned char | |
367 | asn1_subid_decode(struct asn1_ctx *ctx, unsigned long *subid) | |
368 | { | |
369 | unsigned char ch; | |
370 | ||
371 | *subid = 0; | |
372 | ||
373 | do { | |
374 | if (!asn1_octet_decode(ctx, &ch)) | |
375 | return 0; | |
376 | ||
377 | *subid <<= 7; | |
378 | *subid |= ch & 0x7F; | |
379 | } while ((ch & 0x80) == 0x80); | |
380 | return 1; | |
381 | } | |
382 | ||
50c2f753 | 383 | static int |
1da177e4 LT |
384 | asn1_oid_decode(struct asn1_ctx *ctx, |
385 | unsigned char *eoc, unsigned long **oid, unsigned int *len) | |
386 | { | |
387 | unsigned long subid; | |
388 | unsigned int size; | |
389 | unsigned long *optr; | |
390 | ||
391 | size = eoc - ctx->pointer + 1; | |
26f57364 SF |
392 | *oid = kmalloc(size * sizeof(unsigned long), GFP_ATOMIC); |
393 | if (*oid == NULL) | |
1da177e4 | 394 | return 0; |
1da177e4 LT |
395 | |
396 | optr = *oid; | |
397 | ||
398 | if (!asn1_subid_decode(ctx, &subid)) { | |
399 | kfree(*oid); | |
400 | *oid = NULL; | |
401 | return 0; | |
402 | } | |
403 | ||
404 | if (subid < 40) { | |
405 | optr[0] = 0; | |
406 | optr[1] = subid; | |
407 | } else if (subid < 80) { | |
408 | optr[0] = 1; | |
409 | optr[1] = subid - 40; | |
410 | } else { | |
411 | optr[0] = 2; | |
412 | optr[1] = subid - 80; | |
413 | } | |
414 | ||
415 | *len = 2; | |
416 | optr += 2; | |
417 | ||
418 | while (ctx->pointer < eoc) { | |
419 | if (++(*len) > size) { | |
420 | ctx->error = ASN1_ERR_DEC_BADVALUE; | |
421 | kfree(*oid); | |
422 | *oid = NULL; | |
423 | return 0; | |
424 | } | |
425 | ||
426 | if (!asn1_subid_decode(ctx, optr++)) { | |
427 | kfree(*oid); | |
428 | *oid = NULL; | |
429 | return 0; | |
430 | } | |
431 | } | |
432 | return 1; | |
433 | } | |
434 | ||
435 | static int | |
436 | compare_oid(unsigned long *oid1, unsigned int oid1len, | |
437 | unsigned long *oid2, unsigned int oid2len) | |
438 | { | |
439 | unsigned int i; | |
440 | ||
441 | if (oid1len != oid2len) | |
442 | return 0; | |
443 | else { | |
444 | for (i = 0; i < oid1len; i++) { | |
445 | if (oid1[i] != oid2[i]) | |
446 | return 0; | |
447 | } | |
448 | return 1; | |
449 | } | |
450 | } | |
451 | ||
452 | /* BB check for endian conversion issues here */ | |
453 | ||
454 | int | |
455 | decode_negTokenInit(unsigned char *security_blob, int length, | |
456 | enum securityEnum *secType) | |
457 | { | |
458 | struct asn1_ctx ctx; | |
459 | unsigned char *end; | |
460 | unsigned char *sequence_end; | |
461 | unsigned long *oid = NULL; | |
462 | unsigned int cls, con, tag, oidlen, rc; | |
463 | int use_ntlmssp = FALSE; | |
e545937a | 464 | int use_kerberos = FALSE; |
1da177e4 | 465 | |
50c2f753 | 466 | *secType = NTLM; /* BB eventually make Kerberos or NLTMSSP the default*/ |
1da177e4 LT |
467 | |
468 | /* cifs_dump_mem(" Received SecBlob ", security_blob, length); */ | |
469 | ||
470 | asn1_open(&ctx, security_blob, length); | |
471 | ||
472 | if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) { | |
26a21b98 | 473 | cFYI(1, ("Error decoding negTokenInit header")); |
1da177e4 LT |
474 | return 0; |
475 | } else if ((cls != ASN1_APL) || (con != ASN1_CON) | |
476 | || (tag != ASN1_EOC)) { | |
477 | cFYI(1, ("cls = %d con = %d tag = %d", cls, con, tag)); | |
478 | return 0; | |
479 | } else { | |
480 | /* remember to free obj->oid */ | |
481 | rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag); | |
482 | if (rc) { | |
483 | if ((tag == ASN1_OJI) && (cls == ASN1_PRI)) { | |
484 | rc = asn1_oid_decode(&ctx, end, &oid, &oidlen); | |
485 | if (rc) { | |
486 | rc = compare_oid(oid, oidlen, | |
487 | SPNEGO_OID, | |
488 | SPNEGO_OID_LEN); | |
489 | kfree(oid); | |
490 | } | |
491 | } else | |
492 | rc = 0; | |
493 | } | |
494 | ||
495 | if (!rc) { | |
496 | cFYI(1, ("Error decoding negTokenInit header")); | |
497 | return 0; | |
498 | } | |
499 | ||
500 | if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) { | |
26a21b98 | 501 | cFYI(1, ("Error decoding negTokenInit")); |
1da177e4 LT |
502 | return 0; |
503 | } else if ((cls != ASN1_CTX) || (con != ASN1_CON) | |
504 | || (tag != ASN1_EOC)) { | |
50c2f753 SF |
505 | cFYI(1, |
506 | ("cls = %d con = %d tag = %d end = %p (%d) exit 0", | |
1da177e4 LT |
507 | cls, con, tag, end, *end)); |
508 | return 0; | |
509 | } | |
510 | ||
511 | if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) { | |
26a21b98 | 512 | cFYI(1, ("Error decoding negTokenInit")); |
1da177e4 LT |
513 | return 0; |
514 | } else if ((cls != ASN1_UNI) || (con != ASN1_CON) | |
515 | || (tag != ASN1_SEQ)) { | |
50c2f753 SF |
516 | cFYI(1, |
517 | ("cls = %d con = %d tag = %d end = %p (%d) exit 1", | |
1da177e4 LT |
518 | cls, con, tag, end, *end)); |
519 | return 0; | |
520 | } | |
521 | ||
522 | if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) { | |
26a21b98 | 523 | cFYI(1, ("Error decoding 2nd part of negTokenInit")); |
1da177e4 LT |
524 | return 0; |
525 | } else if ((cls != ASN1_CTX) || (con != ASN1_CON) | |
526 | || (tag != ASN1_EOC)) { | |
527 | cFYI(1, | |
528 | ("cls = %d con = %d tag = %d end = %p (%d) exit 0", | |
529 | cls, con, tag, end, *end)); | |
530 | return 0; | |
531 | } | |
532 | ||
533 | if (asn1_header_decode | |
534 | (&ctx, &sequence_end, &cls, &con, &tag) == 0) { | |
26a21b98 | 535 | cFYI(1, ("Error decoding 2nd part of negTokenInit")); |
1da177e4 LT |
536 | return 0; |
537 | } else if ((cls != ASN1_UNI) || (con != ASN1_CON) | |
538 | || (tag != ASN1_SEQ)) { | |
539 | cFYI(1, | |
540 | ("cls = %d con = %d tag = %d end = %p (%d) exit 1", | |
541 | cls, con, tag, end, *end)); | |
542 | return 0; | |
543 | } | |
544 | ||
545 | while (!asn1_eoc_decode(&ctx, sequence_end)) { | |
546 | rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag); | |
547 | if (!rc) { | |
548 | cFYI(1, | |
50c2f753 | 549 | ("Error decoding negTokenInit hdr exit2")); |
1da177e4 LT |
550 | return 0; |
551 | } | |
552 | if ((tag == ASN1_OJI) && (con == ASN1_PRI)) { | |
e545937a JL |
553 | if (asn1_oid_decode(&ctx, end, &oid, &oidlen)) { |
554 | ||
1da177e4 | 555 | cFYI(1, |
50c2f753 SF |
556 | ("OID len = %d oid = 0x%lx 0x%lx " |
557 | "0x%lx 0x%lx", | |
558 | oidlen, *oid, *(oid + 1), | |
559 | *(oid + 2), *(oid + 3))); | |
e545937a JL |
560 | |
561 | if (compare_oid(oid, oidlen, | |
562 | MSKRB5_OID, | |
563 | MSKRB5_OID_LEN)) | |
564 | use_kerberos = TRUE; | |
565 | else if (compare_oid(oid, oidlen, | |
566 | KRB5_OID, | |
567 | KRB5_OID_LEN)) | |
568 | use_kerberos = TRUE; | |
569 | else if (compare_oid(oid, oidlen, | |
570 | NTLMSSP_OID, | |
571 | NTLMSSP_OID_LEN)) | |
1da177e4 | 572 | use_ntlmssp = TRUE; |
e545937a JL |
573 | |
574 | kfree(oid); | |
1da177e4 LT |
575 | } |
576 | } else { | |
50c2f753 | 577 | cFYI(1, ("Should be an oid what is going on?")); |
1da177e4 LT |
578 | } |
579 | } | |
580 | ||
581 | if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) { | |
582 | cFYI(1, | |
50c2f753 | 583 | ("Error decoding last part negTokenInit exit3")); |
1da177e4 | 584 | return 0; |
50c2f753 SF |
585 | } else if ((cls != ASN1_CTX) || (con != ASN1_CON)) { |
586 | /* tag = 3 indicating mechListMIC */ | |
1da177e4 LT |
587 | cFYI(1, |
588 | ("Exit 4 cls = %d con = %d tag = %d end = %p (%d)", | |
589 | cls, con, tag, end, *end)); | |
590 | return 0; | |
591 | } | |
592 | if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) { | |
593 | cFYI(1, | |
50c2f753 | 594 | ("Error decoding last part negTokenInit exit5")); |
1da177e4 LT |
595 | return 0; |
596 | } else if ((cls != ASN1_UNI) || (con != ASN1_CON) | |
597 | || (tag != ASN1_SEQ)) { | |
26f57364 SF |
598 | cFYI(1, ("cls = %d con = %d tag = %d end = %p (%d)", |
599 | cls, con, tag, end, *end)); | |
1da177e4 LT |
600 | } |
601 | ||
602 | if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) { | |
603 | cFYI(1, | |
50c2f753 | 604 | ("Error decoding last part negTokenInit exit 7")); |
1da177e4 LT |
605 | return 0; |
606 | } else if ((cls != ASN1_CTX) || (con != ASN1_CON)) { | |
607 | cFYI(1, | |
608 | ("Exit 8 cls = %d con = %d tag = %d end = %p (%d)", | |
609 | cls, con, tag, end, *end)); | |
610 | return 0; | |
611 | } | |
612 | if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) { | |
613 | cFYI(1, | |
50c2f753 | 614 | ("Error decoding last part negTokenInit exit9")); |
1da177e4 LT |
615 | return 0; |
616 | } else if ((cls != ASN1_UNI) || (con != ASN1_PRI) | |
617 | || (tag != ASN1_GENSTR)) { | |
618 | cFYI(1, | |
50c2f753 | 619 | ("Exit10 cls = %d con = %d tag = %d end = %p (%d)", |
1da177e4 LT |
620 | cls, con, tag, end, *end)); |
621 | return 0; | |
622 | } | |
50c2f753 SF |
623 | cFYI(1, ("Need to call asn1_octets_decode() function for %s", |
624 | ctx.pointer)); /* is this UTF-8 or ASCII? */ | |
1da177e4 LT |
625 | } |
626 | ||
e545937a JL |
627 | if (use_kerberos) |
628 | *secType = Kerberos; | |
629 | else if (use_ntlmssp) | |
1da177e4 | 630 | *secType = NTLMSSP; |
1da177e4 LT |
631 | |
632 | return 1; | |
633 | } |