[linux.git] / fs / cifs / asn1.c

/* 
 * The ASB.1/BER parsing code is derived from ip_nat_snmp_basic.c which was in
 * turn derived from the gxsnmp package by Gregory McLean & Jochen Friedrich
 *      
 * Copyright (c) 2000 RP Internet (www.rpi.net.au).
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/config.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include "cifspdu.h"
#include "cifsglob.h"
#include "cifs_debug.h"
#include "cifsproto.h"

/*****************************************************************************
 *
 * Basic ASN.1 decoding routines (gxsnmp author Dirk Wisse)
 *
 *****************************************************************************/

/* Class */
#define ASN1_UNI	0	/* Universal */
#define ASN1_APL	1	/* Application */
#define ASN1_CTX	2	/* Context */
#define ASN1_PRV	3	/* Private */

/* Tag */
#define ASN1_EOC	0	/* End Of Contents or N/A */
#define ASN1_BOL	1	/* Boolean */
#define ASN1_INT	2	/* Integer */
#define ASN1_BTS	3	/* Bit String */
#define ASN1_OTS	4	/* Octet String */
#define ASN1_NUL	5	/* Null */
#define ASN1_OJI	6	/* Object Identifier  */
#define ASN1_OJD	7	/* Object Description */
#define ASN1_EXT	8	/* External */
#define ASN1_SEQ	16	/* Sequence */
#define ASN1_SET	17	/* Set */
#define ASN1_NUMSTR	18	/* Numerical String */
#define ASN1_PRNSTR	19	/* Printable String */
#define ASN1_TEXSTR	20	/* Teletext String */
#define ASN1_VIDSTR	21	/* Video String */
#define ASN1_IA5STR	22	/* IA5 String */
#define ASN1_UNITIM	23	/* Universal Time */
#define ASN1_GENTIM	24	/* General Time */
#define ASN1_GRASTR	25	/* Graphical String */
#define ASN1_VISSTR	26	/* Visible String */
#define ASN1_GENSTR	27	/* General String */

/* Primitive / Constructed methods*/
#define ASN1_PRI	0	/* Primitive */
#define ASN1_CON	1	/* Constructed */

/*
 * Error codes.
 */
#define ASN1_ERR_NOERROR		0
#define ASN1_ERR_DEC_EMPTY		2
#define ASN1_ERR_DEC_EOC_MISMATCH	3
#define ASN1_ERR_DEC_LENGTH_MISMATCH	4
#define ASN1_ERR_DEC_BADVALUE		5

#define SPNEGO_OID_LEN 7
#define NTLMSSP_OID_LEN  10
static unsigned long SPNEGO_OID[7] = { 1, 3, 6, 1, 5, 5, 2 };
static unsigned long NTLMSSP_OID[10] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10 };

/* 
 * ASN.1 context.
 */
struct asn1_ctx {
	int error;		/* Error condition */
	unsigned char *pointer;	/* Octet just to be decoded */
	unsigned char *begin;	/* First octet */
	unsigned char *end;	/* Octet after last octet */
};

/*
 * Octet string (not null terminated)
 */
struct asn1_octstr {
	unsigned char *data;
	unsigned int len;
};

static void
asn1_open(struct asn1_ctx *ctx, unsigned char *buf, unsigned int len)
{
	ctx->begin = buf;
	ctx->end = buf + len;
	ctx->pointer = buf;
	ctx->error = ASN1_ERR_NOERROR;
}

static unsigned char
asn1_octet_decode(struct asn1_ctx *ctx, unsigned char *ch)
{
	if (ctx->pointer >= ctx->end) {
		ctx->error = ASN1_ERR_DEC_EMPTY;
		return 0;
	}
	*ch = *(ctx->pointer)++;
	return 1;
}

static unsigned char
asn1_tag_decode(struct asn1_ctx *ctx, unsigned int *tag)
{
	unsigned char ch;

	*tag = 0;

	do {
		if (!asn1_octet_decode(ctx, &ch))
			return 0;
		*tag <<= 7;
		*tag |= ch & 0x7F;
	} while ((ch & 0x80) == 0x80);
	return 1;
}

static unsigned char
asn1_id_decode(struct asn1_ctx *ctx,
	       unsigned int *cls, unsigned int *con, unsigned int *tag)
{
	unsigned char ch;

	if (!asn1_octet_decode(ctx, &ch))
		return 0;

	*cls = (ch & 0xC0) >> 6;
	*con = (ch & 0x20) >> 5;
	*tag = (ch & 0x1F);

	if (*tag == 0x1F) {
		if (!asn1_tag_decode(ctx, tag))
			return 0;
	}
	return 1;
}

static unsigned char
asn1_length_decode(struct asn1_ctx *ctx, unsigned int *def, unsigned int *len)
{
	unsigned char ch, cnt;

	if (!asn1_octet_decode(ctx, &ch))
		return 0;

	if (ch == 0x80)
		*def = 0;
	else {
		*def = 1;

		if (ch < 0x80)
			*len = ch;
		else {
			cnt = (unsigned char) (ch & 0x7F);
			*len = 0;

			while (cnt > 0) {
				if (!asn1_octet_decode(ctx, &ch))
					return 0;
				*len <<= 8;
				*len |= ch;
				cnt--;
			}
		}
	}
	return 1;
}

static unsigned char
asn1_header_decode(struct asn1_ctx *ctx,
		   unsigned char **eoc,
		   unsigned int *cls, unsigned int *con, unsigned int *tag)
{
	unsigned int def = 0; 
	unsigned int len = 0;

	if (!asn1_id_decode(ctx, cls, con, tag))
		return 0;

	if (!asn1_length_decode(ctx, &def, &len))
		return 0;

	if (def)
		*eoc = ctx->pointer + len;
	else
		*eoc = NULL;
	return 1;
}

static unsigned char
asn1_eoc_decode(struct asn1_ctx *ctx, unsigned char *eoc)
{
	unsigned char ch;

	if (eoc == NULL) {
		if (!asn1_octet_decode(ctx, &ch))
			return 0;

		if (ch != 0x00) {
			ctx->error = ASN1_ERR_DEC_EOC_MISMATCH;
			return 0;
		}

		if (!asn1_octet_decode(ctx, &ch))
			return 0;

		if (ch != 0x00) {
			ctx->error = ASN1_ERR_DEC_EOC_MISMATCH;
			return 0;
		}
		return 1;
	} else {
		if (ctx->pointer != eoc) {
			ctx->error = ASN1_ERR_DEC_LENGTH_MISMATCH;
			return 0;
		}
		return 1;
	}
}

/* static unsigned char asn1_null_decode(struct asn1_ctx *ctx,
				      unsigned char *eoc)
{
	ctx->pointer = eoc;
	return 1;
}

static unsigned char asn1_long_decode(struct asn1_ctx *ctx,
				      unsigned char *eoc, long *integer)
{
	unsigned char ch;
	unsigned int len;

	if (!asn1_octet_decode(ctx, &ch))
		return 0;

	*integer = (signed char) ch;
	len = 1;

	while (ctx->pointer < eoc) {
		if (++len > sizeof(long)) {
			ctx->error = ASN1_ERR_DEC_BADVALUE;
			return 0;
		}

		if (!asn1_octet_decode(ctx, &ch))
			return 0;

		*integer <<= 8;
		*integer |= ch;
	}
	return 1;
}

static unsigned char asn1_uint_decode(struct asn1_ctx *ctx,
				      unsigned char *eoc,
				      unsigned int *integer)
{
	unsigned char ch;
	unsigned int len;

	if (!asn1_octet_decode(ctx, &ch))
		return 0;

	*integer = ch;
	if (ch == 0)
		len = 0;
	else
		len = 1;

	while (ctx->pointer < eoc) {
		if (++len > sizeof(unsigned int)) {
			ctx->error = ASN1_ERR_DEC_BADVALUE;
			return 0;
		}

		if (!asn1_octet_decode(ctx, &ch))
			return 0;

		*integer <<= 8;
		*integer |= ch;
	}
	return 1;
}

static unsigned char asn1_ulong_decode(struct asn1_ctx *ctx,
				       unsigned char *eoc,
				       unsigned long *integer)
{
	unsigned char ch;
	unsigned int len;

	if (!asn1_octet_decode(ctx, &ch))
		return 0;

	*integer = ch;
	if (ch == 0)
		len = 0;
	else
		len = 1;

	while (ctx->pointer < eoc) {
		if (++len > sizeof(unsigned long)) {
			ctx->error = ASN1_ERR_DEC_BADVALUE;
			return 0;
		}

		if (!asn1_octet_decode(ctx, &ch))
			return 0;

		*integer <<= 8;
		*integer |= ch;
	}
	return 1;
} 

static unsigned char
asn1_octets_decode(struct asn1_ctx *ctx,
		   unsigned char *eoc,
		   unsigned char **octets, unsigned int *len)
{
	unsigned char *ptr;

	*len = 0;

	*octets = kmalloc(eoc - ctx->pointer, GFP_ATOMIC);
	if (*octets == NULL) {
		return 0;
	}

	ptr = *octets;
	while (ctx->pointer < eoc) {
		if (!asn1_octet_decode(ctx, (unsigned char *) ptr++)) {
			kfree(*octets);
			*octets = NULL;
			return 0;
		}
		(*len)++;
	}
	return 1;
} */

static unsigned char
asn1_subid_decode(struct asn1_ctx *ctx, unsigned long *subid)
{
	unsigned char ch;

	*subid = 0;

	do {
		if (!asn1_octet_decode(ctx, &ch))
			return 0;

		*subid <<= 7;
		*subid |= ch & 0x7F;
	} while ((ch & 0x80) == 0x80);
	return 1;
}

static int 
asn1_oid_decode(struct asn1_ctx *ctx,
		unsigned char *eoc, unsigned long **oid, unsigned int *len)
{
	unsigned long subid;
	unsigned int size;
	unsigned long *optr;

	size = eoc - ctx->pointer + 1;
	*oid = kmalloc(size * sizeof (unsigned long), GFP_ATOMIC);
	if (*oid == NULL) {
		return 0;
	}

	optr = *oid;

	if (!asn1_subid_decode(ctx, &subid)) {
		kfree(*oid);
		*oid = NULL;
		return 0;
	}

	if (subid < 40) {
		optr[0] = 0;
		optr[1] = subid;
	} else if (subid < 80) {
		optr[0] = 1;
		optr[1] = subid - 40;
	} else {
		optr[0] = 2;
		optr[1] = subid - 80;
	}

	*len = 2;
	optr += 2;

	while (ctx->pointer < eoc) {
		if (++(*len) > size) {
			ctx->error = ASN1_ERR_DEC_BADVALUE;
			kfree(*oid);
			*oid = NULL;
			return 0;
		}

		if (!asn1_subid_decode(ctx, optr++)) {
			kfree(*oid);
			*oid = NULL;
			return 0;
		}
	}
	return 1;
}

static int
compare_oid(unsigned long *oid1, unsigned int oid1len,
	    unsigned long *oid2, unsigned int oid2len)
{
	unsigned int i;

	if (oid1len != oid2len)
		return 0;
	else {
		for (i = 0; i < oid1len; i++) {
			if (oid1[i] != oid2[i])
				return 0;
		}
		return 1;
	}
}

	/* BB check for endian conversion issues here */

int
decode_negTokenInit(unsigned char *security_blob, int length,
		    enum securityEnum *secType)
{
	struct asn1_ctx ctx;
	unsigned char *end;
	unsigned char *sequence_end;
	unsigned long *oid = NULL;
	unsigned int cls, con, tag, oidlen, rc;
	int use_ntlmssp = FALSE;

	*secType = NTLM; /* BB eventually make Kerberos or NLTMSSP the default */

	/* cifs_dump_mem(" Received SecBlob ", security_blob, length); */

	asn1_open(&ctx, security_blob, length);

	if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
		cFYI(1, ("Error decoding negTokenInit header "));
		return 0;
	} else if ((cls != ASN1_APL) || (con != ASN1_CON)
		   || (tag != ASN1_EOC)) {
		cFYI(1, ("cls = %d con = %d tag = %d", cls, con, tag));
		return 0;
	} else {
		/*      remember to free obj->oid */
		rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag);
		if (rc) {
			if ((tag == ASN1_OJI) && (cls == ASN1_PRI)) {
				rc = asn1_oid_decode(&ctx, end, &oid, &oidlen);
				if (rc) {
					rc = compare_oid(oid, oidlen,
							 SPNEGO_OID,
							 SPNEGO_OID_LEN);
					kfree(oid);
				}
			} else
				rc = 0;
		}

		if (!rc) {
			cFYI(1, ("Error decoding negTokenInit header"));
			return 0;
		}

		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
			cFYI(1, ("Error decoding negTokenInit "));
			return 0;
		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)
			   || (tag != ASN1_EOC)) {
			cFYI(1,("cls = %d con = %d tag = %d end = %p (%d) exit 0",
			      cls, con, tag, end, *end));
			return 0;
		}

		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
			cFYI(1, ("Error decoding negTokenInit "));
			return 0;
		} else if ((cls != ASN1_UNI) || (con != ASN1_CON)
			   || (tag != ASN1_SEQ)) {
			cFYI(1,("cls = %d con = %d tag = %d end = %p (%d) exit 1",
			      cls, con, tag, end, *end));
			return 0;
		}

		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
			cFYI(1, ("Error decoding 2nd part of negTokenInit "));
			return 0;
		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)
			   || (tag != ASN1_EOC)) {
			cFYI(1,
			     ("cls = %d con = %d tag = %d end = %p (%d) exit 0",
			      cls, con, tag, end, *end));
			return 0;
		}

		if (asn1_header_decode
		    (&ctx, &sequence_end, &cls, &con, &tag) == 0) {
			cFYI(1, ("Error decoding 2nd part of negTokenInit "));
			return 0;
		} else if ((cls != ASN1_UNI) || (con != ASN1_CON)
			   || (tag != ASN1_SEQ)) {
			cFYI(1,
			     ("cls = %d con = %d tag = %d end = %p (%d) exit 1",
			      cls, con, tag, end, *end));
			return 0;
		}

		while (!asn1_eoc_decode(&ctx, sequence_end)) {
			rc = asn1_header_decode(&ctx, &end, &cls, &con, &tag);
			if (!rc) {
				cFYI(1,
				     ("Error 1 decoding negTokenInit header exit 2"));
				return 0;
			}
			if ((tag == ASN1_OJI) && (con == ASN1_PRI)) {
				rc = asn1_oid_decode(&ctx, end, &oid, &oidlen);
				if(rc) {		
					cFYI(1,
					  ("OID len = %d oid = 0x%lx 0x%lx 0x%lx 0x%lx",
					   oidlen, *oid, *(oid + 1), *(oid + 2),
					   *(oid + 3)));
					rc = compare_oid(oid, oidlen, NTLMSSP_OID,
						 NTLMSSP_OID_LEN);
					kfree(oid);
					if (rc)
						use_ntlmssp = TRUE;
				}
			} else {
				cFYI(1,("This should be an oid what is going on? "));
			}
		}

		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
			cFYI(1,
			     ("Error decoding last part of negTokenInit exit 3"));
			return 0;
		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)) {	/* tag = 3 indicating mechListMIC */
			cFYI(1,
			     ("Exit 4 cls = %d con = %d tag = %d end = %p (%d)",
			      cls, con, tag, end, *end));
			return 0;
		}
		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
			cFYI(1,
			     ("Error decoding last part of negTokenInit exit 5"));
			return 0;
		} else if ((cls != ASN1_UNI) || (con != ASN1_CON)
			   || (tag != ASN1_SEQ)) {
			cFYI(1,
			     ("Exit 6 cls = %d con = %d tag = %d end = %p (%d)",
			      cls, con, tag, end, *end));
		}

		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
			cFYI(1,
			     ("Error decoding last part of negTokenInit exit 7"));
			return 0;
		} else if ((cls != ASN1_CTX) || (con != ASN1_CON)) {
			cFYI(1,
			     ("Exit 8 cls = %d con = %d tag = %d end = %p (%d)",
			      cls, con, tag, end, *end));
			return 0;
		}
		if (asn1_header_decode(&ctx, &end, &cls, &con, &tag) == 0) {
			cFYI(1,
			     ("Error decoding last part of negTokenInit exit 9"));
			return 0;
		} else if ((cls != ASN1_UNI) || (con != ASN1_PRI)
			   || (tag != ASN1_GENSTR)) {
			cFYI(1,
			     ("Exit 10 cls = %d con = %d tag = %d end = %p (%d)",
			      cls, con, tag, end, *end));
			return 0;
		}
		cFYI(1, ("Need to call asn1_octets_decode() function for this %s", ctx.pointer));	/* is this UTF-8 or ASCII? */
	}

	/* if (use_kerberos) 
	   *secType = Kerberos 
	   else */
	if (use_ntlmssp) {
		*secType = NTLMSSP;
	}

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