[deliverable/linux.git] / fs / cifs / smbencrypt.c

/*
   Unix SMB/Netbios implementation.
   Version 1.9.
   SMB parameters and setup
   Copyright (C) Andrew Tridgell 1992-2000
   Copyright (C) Luke Kenneth Casson Leighton 1996-2000
   Modified by Jeremy Allison 1995.
   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2002-2003
   Modified by Steve French (sfrench@us.ibm.com) 2002-2003

   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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/random.h>
#include "cifs_unicode.h"
#include "cifspdu.h"
#include "cifsglob.h"
#include "md5.h"
#include "cifs_debug.h"
#include "cifsencrypt.h"

#ifndef false
#define false 0
#endif
#ifndef true
#define true 1
#endif

/* following came from the other byteorder.h to avoid include conflicts */
#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
#define SSVALX(buf,pos,val) (CVAL(buf,pos)=(val)&0xFF,CVAL(buf,pos+1)=(val)>>8)
#define SSVAL(buf,pos,val) SSVALX((buf),(pos),((__u16)(val)))

/*The following definitions come from  libsmb/smbencrypt.c  */

void SMBencrypt(unsigned char *passwd, const unsigned char *c8,
		unsigned char *p24);
void E_md4hash(const unsigned char *passwd, unsigned char *p16);
static void SMBOWFencrypt(unsigned char passwd[16], const unsigned char *c8,
		   unsigned char p24[24]);
void SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24);

/*
   This implements the X/Open SMB password encryption
   It takes a password, a 8 byte "crypt key" and puts 24 bytes of
   encrypted password into p24 */
/* Note that password must be uppercased and null terminated */
void
SMBencrypt(unsigned char *passwd, const unsigned char *c8, unsigned char *p24)
{
	unsigned char p14[15], p21[21];

	memset(p21, '\0', 21);
	memset(p14, '\0', 14);
	strncpy((char *) p14, (char *) passwd, 14);

/*	strupper((char *)p14); *//* BB at least uppercase the easy range */
	E_P16(p14, p21);

	SMBOWFencrypt(p21, c8, p24);

	memset(p14, 0, 15);
	memset(p21, 0, 21);
}

/* Routines for Windows NT MD4 Hash functions. */
static int
_my_wcslen(__u16 *str)
{
	int len = 0;
	while (*str++ != 0)
		len++;
	return len;
}

/*
 * Convert a string into an NT UNICODE string.
 * Note that regardless of processor type
 * this must be in intel (little-endian)
 * format.
 */

static int
_my_mbstowcs(__u16 *dst, const unsigned char *src, int len)
{	/* BB not a very good conversion routine - change/fix */
	int i;
	__u16 val;

	for (i = 0; i < len; i++) {
		val = *src;
		SSVAL(dst, 0, val);
		dst++;
		src++;
		if (val == 0)
			break;
	}
	return i;
}

/*
 * Creates the MD4 Hash of the users password in NT UNICODE.
 */

void
E_md4hash(const unsigned char *passwd, unsigned char *p16)
{
	int len;
	__u16 wpwd[129];

	/* Password cannot be longer than 128 characters */
	if (passwd) {
		len = strlen((char *) passwd);
		if (len > 128)
			len = 128;

		/* Password must be converted to NT unicode */
		_my_mbstowcs(wpwd, passwd, len);
	} else
		len = 0;

	wpwd[len] = 0;	/* Ensure string is null terminated */
	/* Calculate length in bytes */
	len = _my_wcslen(wpwd) * sizeof(__u16);

	mdfour(p16, (unsigned char *) wpwd, len);
	memset(wpwd, 0, 129 * 2);
}

#if 0 /* currently unused */
/* Does both the NT and LM owfs of a user's password */
static void
nt_lm_owf_gen(char *pwd, unsigned char nt_p16[16], unsigned char p16[16])
{
	char passwd[514];

	memset(passwd, '\0', 514);
	if (strlen(pwd) < 513)
		strcpy(passwd, pwd);
	else
		memcpy(passwd, pwd, 512);
	/* Calculate the MD4 hash (NT compatible) of the password */
	memset(nt_p16, '\0', 16);
	E_md4hash(passwd, nt_p16);

	/* Mangle the passwords into Lanman format */
	passwd[14] = '\0';
/*	strupper(passwd); */

	/* Calculate the SMB (lanman) hash functions of the password */

	memset(p16, '\0', 16);
	E_P16((unsigned char *) passwd, (unsigned char *) p16);

	/* clear out local copy of user's password (just being paranoid). */
	memset(passwd, '\0', sizeof(passwd));
}
#endif

/* Does the NTLMv2 owfs of a user's password */
#if 0  /* function not needed yet - but will be soon */
static void
ntv2_owf_gen(const unsigned char owf[16], const char *user_n,
		const char *domain_n, unsigned char kr_buf[16],
		const struct nls_table *nls_codepage)
{
	wchar_t *user_u;
	wchar_t *dom_u;
	int user_l, domain_l;
	struct HMACMD5Context ctx;

	/* might as well do one alloc to hold both (user_u and dom_u) */
	user_u = kmalloc(2048 * sizeof(wchar_t), GFP_KERNEL);
	if (user_u == NULL)
		return;
	dom_u = user_u + 1024;

	/* push_ucs2(NULL, user_u, user_n, (user_l+1)*2,
			STR_UNICODE|STR_NOALIGN|STR_TERMINATE|STR_UPPER);
	   push_ucs2(NULL, dom_u, domain_n, (domain_l+1)*2,
			STR_UNICODE|STR_NOALIGN|STR_TERMINATE|STR_UPPER); */

	/* BB user and domain may need to be uppercased */
	user_l = cifs_strtoUCS(user_u, user_n, 511, nls_codepage);
	domain_l = cifs_strtoUCS(dom_u, domain_n, 511, nls_codepage);

	user_l++;		/* trailing null */
	domain_l++;

	hmac_md5_init_limK_to_64(owf, 16, &ctx);
	hmac_md5_update((const unsigned char *) user_u, user_l * 2, &ctx);
	hmac_md5_update((const unsigned char *) dom_u, domain_l * 2, &ctx);
	hmac_md5_final(kr_buf, &ctx);

	kfree(user_u);
}
#endif

/* Does the des encryption from the NT or LM MD4 hash. */
static void
SMBOWFencrypt(unsigned char passwd[16], const unsigned char *c8,
	      unsigned char p24[24])
{
	unsigned char p21[21];

	memset(p21, '\0', 21);

	memcpy(p21, passwd, 16);
	E_P24(p21, c8, p24);
}

/* Does the des encryption from the FIRST 8 BYTES of the NT or LM MD4 hash. */
#if 0 /* currently unused */
static void
NTLMSSPOWFencrypt(unsigned char passwd[8],
		  unsigned char *ntlmchalresp, unsigned char p24[24])
{
	unsigned char p21[21];

	memset(p21, '\0', 21);
	memcpy(p21, passwd, 8);
	memset(p21 + 8, 0xbd, 8);

	E_P24(p21, ntlmchalresp, p24);
}
#endif

/* Does the NT MD4 hash then des encryption. */

void
SMBNTencrypt(unsigned char *passwd, unsigned char *c8, unsigned char *p24)
{
	unsigned char p21[21];

	memset(p21, '\0', 21);

	E_md4hash(passwd, p21);
	SMBOWFencrypt(p21, c8, p24);
}


/* Does the md5 encryption from the NT hash for NTLMv2. */
/* These routines will be needed later */
#if 0
static void
SMBOWFencrypt_ntv2(const unsigned char kr[16],
		   const struct data_blob *srv_chal,
		   const struct data_blob *cli_chal, unsigned char resp_buf[16])
{
	struct HMACMD5Context ctx;

	hmac_md5_init_limK_to_64(kr, 16, &ctx);
	hmac_md5_update(srv_chal->data, srv_chal->length, &ctx);
	hmac_md5_update(cli_chal->data, cli_chal->length, &ctx);
	hmac_md5_final(resp_buf, &ctx);
}

static void
SMBsesskeygen_ntv2(const unsigned char kr[16],
		   const unsigned char *nt_resp, __u8 sess_key[16])
{
	struct HMACMD5Context ctx;

	hmac_md5_init_limK_to_64(kr, 16, &ctx);
	hmac_md5_update(nt_resp, 16, &ctx);
	hmac_md5_final((unsigned char *) sess_key, &ctx);
}

static void
SMBsesskeygen_ntv1(const unsigned char kr[16],
		   const unsigned char *nt_resp, __u8 sess_key[16])
{
	mdfour((unsigned char *) sess_key, (unsigned char *) kr, 16);
}
#endif
Commit	Line	Data
790fe579	1	/*
1da177e4 LT	2	Unix SMB/Netbios implementation.
	3	Version 1.9.
	4	SMB parameters and setup
	5	Copyright (C) Andrew Tridgell 1992-2000
	6	Copyright (C) Luke Kenneth Casson Leighton 1996-2000
	7	Modified by Jeremy Allison 1995.
	8	Copyright (C) Andrew Bartlett <abartlet@samba.org> 2002-2003
	9	Modified by Steve French (sfrench@us.ibm.com) 2002-2003
50c2f753	10
1da177e4 LT	11	This program is free software; you can redistribute it and/or modify
	12	it under the terms of the GNU General Public License as published by
	13	the Free Software Foundation; either version 2 of the License, or
	14	(at your option) any later version.
50c2f753	15
1da177e4 LT	16	This program is distributed in the hope that it will be useful,
	17	but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	GNU General Public License for more details.
50c2f753	20
1da177e4 LT	21	You should have received a copy of the GNU General Public License
	22	along with this program; if not, write to the Free Software
	23	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	24	*/
	25
	26	#include <linux/module.h>
	27	#include <linux/fs.h>
	28	#include <linux/string.h>
	29	#include <linux/kernel.h>
	30	#include <linux/random.h>
	31	#include "cifs_unicode.h"
	32	#include "cifspdu.h"
3979877e	33	#include "cifsglob.h"
1da177e4 LT	34	#include "md5.h"
	35	#include "cifs_debug.h"
	36	#include "cifsencrypt.h"
	37
4b18f2a9 SF	38	#ifndef false
4b18f2a9 SF	39	#define false 0
1da177e4	40	#endif
4b18f2a9 SF	41	#ifndef true
4b18f2a9 SF	42	#define true 1
1da177e4 LT	43	#endif
	44
	45	/* following came from the other byteorder.h to avoid include conflicts */
	46	#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
	47	#define SSVALX(buf,pos,val) (CVAL(buf,pos)=(val)&0xFF,CVAL(buf,pos+1)=(val)>>8)
	48	#define SSVAL(buf,pos,val) SSVALX((buf),(pos),((__u16)(val)))
	49
	50	/The following definitions come from libsmb/smbencrypt.c /
	51
4e53a3fb JL	52	void SMBencrypt(unsigned char passwd, const unsigned char c8,
4e53a3fb JL	53	unsigned char *p24);
1da177e4	54	void E_md4hash(const unsigned char passwd, unsigned char p16);
4e53a3fb	55	static void SMBOWFencrypt(unsigned char passwd[16], const unsigned char *c8,
1da177e4	56	unsigned char p24[24]);
1da177e4 LT	57	void SMBNTencrypt(unsigned char passwd, unsigned char c8, unsigned char *p24);
	58
	59	/*
	60	This implements the X/Open SMB password encryption
790fe579	61	It takes a password, a 8 byte "crypt key" and puts 24 bytes of
1da177e4 LT	62	encrypted password into p24 */
	63	/* Note that password must be uppercased and null terminated */
	64	void
4e53a3fb	65	SMBencrypt(unsigned char passwd, const unsigned char c8, unsigned char *p24)
1da177e4 LT	66	{
	67	unsigned char p14[15], p21[21];
	68
	69	memset(p21, '\0', 21);
	70	memset(p14, '\0', 14);
	71	strncpy((char ) p14, (char ) passwd, 14);
	72
	73	/* strupper((char )p14); //* BB at least uppercase the easy range */
	74	E_P16(p14, p21);
	75
	76	SMBOWFencrypt(p21, c8, p24);
50c2f753	77
790fe579 SF	78	memset(p14, 0, 15);
790fe579 SF	79	memset(p21, 0, 21);
1da177e4 LT	80	}
	81
	82	/* Routines for Windows NT MD4 Hash functions. */
	83	static int
63d2583f	84	_my_wcslen(__u16 *str)
1da177e4 LT	85	{
	86	int len = 0;
	87	while (*str++ != 0)
	88	len++;
	89	return len;
	90	}
	91
	92	/*
	93	* Convert a string into an NT UNICODE string.
790fe579	94	* Note that regardless of processor type
1da177e4 LT	95	* this must be in intel (little-endian)
	96	* format.
	97	*/
	98
	99	static int
63d2583f	100	_my_mbstowcs(__u16 dst, const unsigned char src, int len)
790fe579	101	{ /* BB not a very good conversion routine - change/fix */
1da177e4 LT	102	int i;
	103	__u16 val;
	104
	105	for (i = 0; i < len; i++) {
	106	val = *src;
	107	SSVAL(dst, 0, val);
	108	dst++;
	109	src++;
	110	if (val == 0)
	111	break;
	112	}
	113	return i;
	114	}
	115
790fe579	116	/*
1da177e4 LT	117	* Creates the MD4 Hash of the users password in NT UNICODE.
	118	*/
	119
	120	void
	121	E_md4hash(const unsigned char passwd, unsigned char p16)
	122	{
	123	int len;
	124	__u16 wpwd[129];
	125
	126	/* Password cannot be longer than 128 characters */
790fe579	127	if (passwd) {
1da177e4	128	len = strlen((char *) passwd);
63d2583f	129	if (len > 128)
1da177e4	130	len = 128;
63d2583f	131
1da177e4 LT	132	/* Password must be converted to NT unicode */
	133	_my_mbstowcs(wpwd, passwd, len);
	134	} else
	135	len = 0;
	136
	137	wpwd[len] = 0; /* Ensure string is null terminated */
	138	/* Calculate length in bytes */
630f3f0c	139	len = _my_wcslen(wpwd) * sizeof(__u16);
1da177e4 LT	140
1da177e4 LT	141	mdfour(p16, (unsigned char *) wpwd, len);
790fe579	142	memset(wpwd, 0, 129 * 2);
1da177e4 LT	143	}
1da177e4 LT	144
e10847ed	145	#if 0 /* currently unused */
1da177e4	146	/* Does both the NT and LM owfs of a user's password */
2cd646a2	147	static void
1da177e4 LT	148	nt_lm_owf_gen(char *pwd, unsigned char nt_p16[16], unsigned char p16[16])
	149	{
	150	char passwd[514];
	151
	152	memset(passwd, '\0', 514);
	153	if (strlen(pwd) < 513)
	154	strcpy(passwd, pwd);
	155	else
	156	memcpy(passwd, pwd, 512);
	157	/* Calculate the MD4 hash (NT compatible) of the password */
	158	memset(nt_p16, '\0', 16);
	159	E_md4hash(passwd, nt_p16);
	160
	161	/* Mangle the passwords into Lanman format */
	162	passwd[14] = '\0';
	163	/* strupper(passwd); */
	164
	165	/* Calculate the SMB (lanman) hash functions of the password */
	166
	167	memset(p16, '\0', 16);
	168	E_P16((unsigned char ) passwd, (unsigned char ) p16);
	169
	170	/* clear out local copy of user's password (just being paranoid). */
630f3f0c	171	memset(passwd, '\0', sizeof(passwd));
1da177e4	172	}
e10847ed	173	#endif
1da177e4 LT	174
	175	/* Does the NTLMv2 owfs of a user's password */
	176	#if 0 /* function not needed yet - but will be soon */
	177	static void
	178	ntv2_owf_gen(const unsigned char owf[16], const char *user_n,
	179	const char *domain_n, unsigned char kr_buf[16],
	180	const struct nls_table *nls_codepage)
	181	{
50c2f753 SF	182	wchar_t *user_u;
50c2f753 SF	183	wchar_t *dom_u;
1da177e4 LT	184	int user_l, domain_l;
	185	struct HMACMD5Context ctx;
	186
	187	/* might as well do one alloc to hold both (user_u and dom_u) */
790fe579 SF	188	user_u = kmalloc(2048 * sizeof(wchar_t), GFP_KERNEL);
790fe579 SF	189	if (user_u == NULL)
1da177e4 LT	190	return;
1da177e4 LT	191	dom_u = user_u + 1024;
50c2f753	192
63d2583f SF	193	/* push_ucs2(NULL, user_u, user_n, (user_l+1)*2,
	194	STR_UNICODE\|STR_NOALIGN\|STR_TERMINATE\|STR_UPPER);
	195	push_ucs2(NULL, dom_u, domain_n, (domain_l+1)*2,
	196	STR_UNICODE\|STR_NOALIGN\|STR_TERMINATE\|STR_UPPER); */
1da177e4 LT	197
	198	/* BB user and domain may need to be uppercased */
	199	user_l = cifs_strtoUCS(user_u, user_n, 511, nls_codepage);
	200	domain_l = cifs_strtoUCS(dom_u, domain_n, 511, nls_codepage);
	201
	202	user_l++; /* trailing null */
	203	domain_l++;
	204
	205	hmac_md5_init_limK_to_64(owf, 16, &ctx);
	206	hmac_md5_update((const unsigned char ) user_u, user_l 2, &ctx);
	207	hmac_md5_update((const unsigned char ) dom_u, domain_l 2, &ctx);
	208	hmac_md5_final(kr_buf, &ctx);
	209
	210	kfree(user_u);
	211	}
790fe579	212	#endif
1da177e4 LT	213
	214	/* Does the des encryption from the NT or LM MD4 hash. */
	215	static void
4e53a3fb	216	SMBOWFencrypt(unsigned char passwd[16], const unsigned char *c8,
1da177e4 LT	217	unsigned char p24[24])
	218	{
	219	unsigned char p21[21];
	220
	221	memset(p21, '\0', 21);
	222
	223	memcpy(p21, passwd, 16);
	224	E_P24(p21, c8, p24);
	225	}
	226
	227	/* Does the des encryption from the FIRST 8 BYTES of the NT or LM MD4 hash. */
e10847ed	228	#if 0 /* currently unused */
2cd646a2	229	static void
1da177e4 LT	230	NTLMSSPOWFencrypt(unsigned char passwd[8],
	231	unsigned char *ntlmchalresp, unsigned char p24[24])
	232	{
	233	unsigned char p21[21];
	234
	235	memset(p21, '\0', 21);
	236	memcpy(p21, passwd, 8);
	237	memset(p21 + 8, 0xbd, 8);
	238
	239	E_P24(p21, ntlmchalresp, p24);
	240	}
e10847ed	241	#endif
1da177e4 LT	242
	243	/* Does the NT MD4 hash then des encryption. */
	244
	245	void
	246	SMBNTencrypt(unsigned char passwd, unsigned char c8, unsigned char *p24)
	247	{
	248	unsigned char p21[21];
	249
	250	memset(p21, '\0', 21);
	251
	252	E_md4hash(passwd, p21);
	253	SMBOWFencrypt(p21, c8, p24);
	254	}
	255
	256
	257	/* Does the md5 encryption from the NT hash for NTLMv2. */
	258	/* These routines will be needed later */
	259	#if 0
	260	static void
	261	SMBOWFencrypt_ntv2(const unsigned char kr[16],
790fe579 SF	262	const struct data_blob *srv_chal,
790fe579 SF	263	const struct data_blob *cli_chal, unsigned char resp_buf[16])
1da177e4	264	{
790fe579	265	struct HMACMD5Context ctx;
1da177e4	266
790fe579 SF	267	hmac_md5_init_limK_to_64(kr, 16, &ctx);
	268	hmac_md5_update(srv_chal->data, srv_chal->length, &ctx);
	269	hmac_md5_update(cli_chal->data, cli_chal->length, &ctx);
	270	hmac_md5_final(resp_buf, &ctx);
1da177e4 LT	271	}
	272
	273	static void
	274	SMBsesskeygen_ntv2(const unsigned char kr[16],
	275	const unsigned char *nt_resp, __u8 sess_key[16])
	276	{
	277	struct HMACMD5Context ctx;
	278
	279	hmac_md5_init_limK_to_64(kr, 16, &ctx);
	280	hmac_md5_update(nt_resp, 16, &ctx);
	281	hmac_md5_final((unsigned char *) sess_key, &ctx);
	282	}
	283
	284	static void
	285	SMBsesskeygen_ntv1(const unsigned char kr[16],
	286	const unsigned char *nt_resp, __u8 sess_key[16])
	287	{
	288	mdfour((unsigned char ) sess_key, (unsigned char ) kr, 16);
	289	}
	290	#endif