[mirror_ubuntu-bionic-kernel.git] / fs / cifs / cifsencrypt.c

/*
 *   fs/cifs/cifsencrypt.c
 *
 *   Copyright (C) International Business Machines  Corp., 2005,2006
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as published
 *   by the Free Software Foundation; either version 2.1 of the License, or
 *   (at your option) any later version.
 *
 *   This library 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 Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with this library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <linux/fs.h>
#include "cifspdu.h"
#include "cifsglob.h" 
#include "cifs_debug.h"
#include "md5.h"
#include "cifs_unicode.h"
#include "cifsproto.h"

/* Calculate and return the CIFS signature based on the mac key and the smb pdu */
/* the 16 byte signature must be allocated by the caller  */
/* Note we only use the 1st eight bytes */
/* Note that the smb header signature field on input contains the  
	sequence number before this function is called */

extern void mdfour(unsigned char *out, unsigned char *in, int n);
extern void E_md4hash(const unsigned char *passwd, unsigned char *p16);
	
static int cifs_calculate_signature(const struct smb_hdr * cifs_pdu, 
				    const char * key, char * signature)
{
	struct	MD5Context context;

	if((cifs_pdu == NULL) || (signature == NULL))
		return -EINVAL;

	MD5Init(&context);
	MD5Update(&context,key,CIFS_SESSION_KEY_SIZE+16);
	MD5Update(&context,cifs_pdu->Protocol,cifs_pdu->smb_buf_length);
	MD5Final(signature,&context);
	return 0;
}

int cifs_sign_smb(struct smb_hdr * cifs_pdu, struct TCP_Server_Info * server,
	__u32 * pexpected_response_sequence_number)
{
	int rc = 0;
	char smb_signature[20];

	if((cifs_pdu == NULL) || (server == NULL))
		return -EINVAL;

	if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0) 
		return rc;

	spin_lock(&GlobalMid_Lock);
	cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(server->sequence_number);
	cifs_pdu->Signature.Sequence.Reserved = 0;
	
	*pexpected_response_sequence_number = server->sequence_number++;
	server->sequence_number++;
	spin_unlock(&GlobalMid_Lock);

	rc = cifs_calculate_signature(cifs_pdu, server->mac_signing_key,smb_signature);
	if(rc)
		memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
	else
		memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);

	return rc;
}

static int cifs_calc_signature2(const struct kvec * iov, int n_vec,
				const char * key, char * signature)
{
	struct  MD5Context context;
	int i;

	if((iov == NULL) || (signature == NULL))
		return -EINVAL;

	MD5Init(&context);
	MD5Update(&context,key,CIFS_SESSION_KEY_SIZE+16);
	for(i=0;i<n_vec;i++) {
		if(iov[i].iov_base == NULL) {
			cERROR(1,("null iovec entry"));
			return -EIO;
		} else if(iov[i].iov_len == 0)
			break; /* bail out if we are sent nothing to sign */
		/* The first entry includes a length field (which does not get 
		   signed that occupies the first 4 bytes before the header */
		if(i==0) {
			if (iov[0].iov_len <= 8 ) /* cmd field at offset 9 */
				break; /* nothing to sign or corrupt header */
			MD5Update(&context,iov[0].iov_base+4, iov[0].iov_len-4);
		} else
			MD5Update(&context,iov[i].iov_base, iov[i].iov_len);
	}

	MD5Final(signature,&context);

	return 0;
}


int cifs_sign_smb2(struct kvec * iov, int n_vec, struct TCP_Server_Info *server,
		   __u32 * pexpected_response_sequence_number)
{
	int rc = 0;
	char smb_signature[20];
	struct smb_hdr * cifs_pdu = iov[0].iov_base;

	if((cifs_pdu == NULL) || (server == NULL))
		return -EINVAL;

	if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0)
		return rc;

        spin_lock(&GlobalMid_Lock);
        cifs_pdu->Signature.Sequence.SequenceNumber = 
				cpu_to_le32(server->sequence_number);
        cifs_pdu->Signature.Sequence.Reserved = 0;

        *pexpected_response_sequence_number = server->sequence_number++;
        server->sequence_number++;
        spin_unlock(&GlobalMid_Lock);

        rc = cifs_calc_signature2(iov, n_vec, server->mac_signing_key,
				      smb_signature);
        if(rc)
                memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
        else
                memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);

        return rc;

}

int cifs_verify_signature(struct smb_hdr * cifs_pdu, const char * mac_key,
	__u32 expected_sequence_number)
{
	unsigned int rc;
	char server_response_sig[8];
	char what_we_think_sig_should_be[20];

	if((cifs_pdu == NULL) || (mac_key == NULL))
		return -EINVAL;

	if (cifs_pdu->Command == SMB_COM_NEGOTIATE)
		return 0;

	if (cifs_pdu->Command == SMB_COM_LOCKING_ANDX) {
		struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)cifs_pdu;
	    if(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE)
			return 0;
	}

	/* BB what if signatures are supposed to be on for session but server does not
		send one? BB */
	
	/* Do not need to verify session setups with signature "BSRSPYL "  */
	if(memcmp(cifs_pdu->Signature.SecuritySignature,"BSRSPYL ",8)==0)
		cFYI(1,("dummy signature received for smb command 0x%x",cifs_pdu->Command));

	/* save off the origiginal signature so we can modify the smb and check
		its signature against what the server sent */
	memcpy(server_response_sig,cifs_pdu->Signature.SecuritySignature,8);

	cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(expected_sequence_number);
	cifs_pdu->Signature.Sequence.Reserved = 0;

	rc = cifs_calculate_signature(cifs_pdu, mac_key,
		what_we_think_sig_should_be);

	if(rc)
		return rc;

	
/*	cifs_dump_mem("what we think it should be: ",what_we_think_sig_should_be,16); */

	if(memcmp(server_response_sig, what_we_think_sig_should_be, 8))
		return -EACCES;
	else
		return 0;

}

/* We fill in key by putting in 40 byte array which was allocated by caller */
int cifs_calculate_mac_key(char * key, const char * rn, const char * password)
{
	char temp_key[16];
	if ((key == NULL) || (rn == NULL))
		return -EINVAL;

	E_md4hash(password, temp_key);
	mdfour(key,temp_key,16);
	memcpy(key+16,rn, CIFS_SESSION_KEY_SIZE);
	return 0;
}

int CalcNTLMv2_partial_mac_key(struct cifsSesInfo * ses, struct nls_table * nls_info)
{
	char temp_hash[16];
	struct HMACMD5Context ctx;
	char * ucase_buf;
	__le16 * unicode_buf;
	unsigned int i,user_name_len,dom_name_len;

	if(ses == NULL)
		return -EINVAL;

	E_md4hash(ses->password, temp_hash);

	hmac_md5_init_limK_to_64(temp_hash, 16, &ctx);
	user_name_len = strlen(ses->userName);
	if(user_name_len > MAX_USERNAME_SIZE)
		return -EINVAL;
	if(ses->domainName == NULL)
		return -EINVAL; /* BB should we use CIFS_LINUX_DOM */
	dom_name_len = strlen(ses->domainName);
	if(dom_name_len > MAX_USERNAME_SIZE)
		return -EINVAL;
  
	ucase_buf = kmalloc((MAX_USERNAME_SIZE+1), GFP_KERNEL);
	if(ucase_buf == NULL)
		return -ENOMEM;
	unicode_buf = kmalloc((MAX_USERNAME_SIZE+1)*4, GFP_KERNEL);
	if(unicode_buf == NULL) {
		kfree(ucase_buf);
		return -ENOMEM;
	}
   
	for(i=0;i<user_name_len;i++)
		ucase_buf[i] = nls_info->charset2upper[(int)ses->userName[i]];
	ucase_buf[i] = 0;
	user_name_len = cifs_strtoUCS(unicode_buf, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);
	unicode_buf[user_name_len] = 0;
	user_name_len++;

	for(i=0;i<dom_name_len;i++)
		ucase_buf[i] = nls_info->charset2upper[(int)ses->domainName[i]];
	ucase_buf[i] = 0;
	dom_name_len = cifs_strtoUCS(unicode_buf+user_name_len, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);

	unicode_buf[user_name_len + dom_name_len] = 0;
	hmac_md5_update((const unsigned char *) unicode_buf,
		(user_name_len+dom_name_len)*2,&ctx);

	hmac_md5_final(ses->server->mac_signing_key,&ctx);
	kfree(ucase_buf);
	kfree(unicode_buf);
	return 0;
}
void CalcNTLMv2_response(const struct cifsSesInfo * ses,char * v2_session_response)
{
	struct HMACMD5Context context;
	memcpy(v2_session_response + 8, ses->server->cryptKey,8);
	/* gen_blob(v2_session_response + 16); */
	hmac_md5_init_limK_to_64(ses->server->mac_signing_key, 16, &context);

	hmac_md5_update(ses->server->cryptKey,8,&context);
/*	hmac_md5_update(v2_session_response+16)client thing,8,&context); */ /* BB fix */

	hmac_md5_final(v2_session_response,&context);
	cifs_dump_mem("v2_sess_rsp: ", v2_session_response, 32); /* BB removeme BB */
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* fs/cifs/cifsencrypt.c
	3	*
12b3b8ff	4	* Copyright (C) International Business Machines Corp., 2005,2006
1da177e4 LT	5	* Author(s): Steve French (sfrench@us.ibm.com)
	6	*
	7	* This library is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU Lesser General Public License as published
	9	* by the Free Software Foundation; either version 2.1 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	15	* the GNU Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public License
	18	* along with this library; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*/
	21
	22	#include <linux/fs.h>
	23	#include "cifspdu.h"
	24	#include "cifsglob.h"
	25	#include "cifs_debug.h"
	26	#include "md5.h"
	27	#include "cifs_unicode.h"
	28	#include "cifsproto.h"
	29
	30	/* Calculate and return the CIFS signature based on the mac key and the smb pdu */
	31	/* the 16 byte signature must be allocated by the caller */
	32	/* Note we only use the 1st eight bytes */
	33	/* Note that the smb header signature field on input contains the
	34	sequence number before this function is called */
	35
	36	extern void mdfour(unsigned char out, unsigned char in, int n);
	37	extern void E_md4hash(const unsigned char passwd, unsigned char p16);
	38
12b3b8ff SF	39	static int cifs_calculate_signature(const struct smb_hdr * cifs_pdu,
12b3b8ff SF	40	const char * key, char * signature)
1da177e4 LT	41	{
	42	struct MD5Context context;
	43
	44	if((cifs_pdu == NULL) \|\| (signature == NULL))
	45	return -EINVAL;
	46
	47	MD5Init(&context);
	48	MD5Update(&context,key,CIFS_SESSION_KEY_SIZE+16);
	49	MD5Update(&context,cifs_pdu->Protocol,cifs_pdu->smb_buf_length);
	50	MD5Final(signature,&context);
	51	return 0;
	52	}
	53
ad009ac9	54	int cifs_sign_smb(struct smb_hdr * cifs_pdu, struct TCP_Server_Info * server,
1da177e4 LT	55	__u32 * pexpected_response_sequence_number)
	56	{
	57	int rc = 0;
	58	char smb_signature[20];
	59
ad009ac9	60	if((cifs_pdu == NULL) \|\| (server == NULL))
1da177e4 LT	61	return -EINVAL;
	62
	63	if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0)
	64	return rc;
	65
	66	spin_lock(&GlobalMid_Lock);
ad009ac9	67	cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(server->sequence_number);
1da177e4 LT	68	cifs_pdu->Signature.Sequence.Reserved = 0;
1da177e4 LT	69
ad009ac9 SF	70	*pexpected_response_sequence_number = server->sequence_number++;
ad009ac9 SF	71	server->sequence_number++;
1da177e4 LT	72	spin_unlock(&GlobalMid_Lock);
1da177e4 LT	73
ad009ac9	74	rc = cifs_calculate_signature(cifs_pdu, server->mac_signing_key,smb_signature);
1da177e4 LT	75	if(rc)
	76	memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
	77	else
	78	memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
	79
	80	return rc;
	81	}
	82
84afc29b SF	83	static int cifs_calc_signature2(const struct kvec * iov, int n_vec,
	84	const char * key, char * signature)
	85	{
e9917a00 SF	86	struct MD5Context context;
e9917a00 SF	87	int i;
84afc29b	88
e9917a00 SF	89	if((iov == NULL) \|\| (signature == NULL))
e9917a00 SF	90	return -EINVAL;
84afc29b	91
e9917a00 SF	92	MD5Init(&context);
	93	MD5Update(&context,key,CIFS_SESSION_KEY_SIZE+16);
	94	for(i=0;i<n_vec;i++) {
	95	if(iov[i].iov_base == NULL) {
	96	cERROR(1,("null iovec entry"));
	97	return -EIO;
	98	} else if(iov[i].iov_len == 0)
	99	break; /* bail out if we are sent nothing to sign */
	100	/* The first entry includes a length field (which does not get
	101	signed that occupies the first 4 bytes before the header */
	102	if(i==0) {
	103	if (iov[0].iov_len <= 8 ) /* cmd field at offset 9 */
	104	break; /* nothing to sign or corrupt header */
	105	MD5Update(&context,iov[0].iov_base+4, iov[0].iov_len-4);
	106	} else
	107	MD5Update(&context,iov[i].iov_base, iov[i].iov_len);
	108	}
84afc29b	109
e9917a00	110	MD5Final(signature,&context);
84afc29b	111
e9917a00	112	return 0;
84afc29b SF	113	}
	114
	115
	116	int cifs_sign_smb2(struct kvec * iov, int n_vec, struct TCP_Server_Info *server,
	117	__u32 * pexpected_response_sequence_number)
	118	{
	119	int rc = 0;
	120	char smb_signature[20];
	121	struct smb_hdr * cifs_pdu = iov[0].iov_base;
	122
	123	if((cifs_pdu == NULL) \|\| (server == NULL))
	124	return -EINVAL;
	125
	126	if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0)
	127	return rc;
	128
	129	spin_lock(&GlobalMid_Lock);
	130	cifs_pdu->Signature.Sequence.SequenceNumber =
	131	cpu_to_le32(server->sequence_number);
	132	cifs_pdu->Signature.Sequence.Reserved = 0;
	133
	134	*pexpected_response_sequence_number = server->sequence_number++;
	135	server->sequence_number++;
	136	spin_unlock(&GlobalMid_Lock);
	137
	138	rc = cifs_calc_signature2(iov, n_vec, server->mac_signing_key,
	139	smb_signature);
	140	if(rc)
	141	memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
	142	else
	143	memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
	144
	145	return rc;
	146
	147	}
	148
1da177e4 LT	149	int cifs_verify_signature(struct smb_hdr * cifs_pdu, const char * mac_key,
	150	__u32 expected_sequence_number)
	151	{
	152	unsigned int rc;
	153	char server_response_sig[8];
	154	char what_we_think_sig_should_be[20];
	155
	156	if((cifs_pdu == NULL) \|\| (mac_key == NULL))
	157	return -EINVAL;
	158
	159	if (cifs_pdu->Command == SMB_COM_NEGOTIATE)
	160	return 0;
	161
	162	if (cifs_pdu->Command == SMB_COM_LOCKING_ANDX) {
	163	struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)cifs_pdu;
	164	if(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE)
	165	return 0;
	166	}
	167
	168	/* BB what if signatures are supposed to be on for session but server does not
	169	send one? BB */
	170
	171	/* Do not need to verify session setups with signature "BSRSPYL " */
	172	if(memcmp(cifs_pdu->Signature.SecuritySignature,"BSRSPYL ",8)==0)
	173	cFYI(1,("dummy signature received for smb command 0x%x",cifs_pdu->Command));
	174
	175	/* save off the origiginal signature so we can modify the smb and check
	176	its signature against what the server sent */
	177	memcpy(server_response_sig,cifs_pdu->Signature.SecuritySignature,8);
	178
	179	cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(expected_sequence_number);
	180	cifs_pdu->Signature.Sequence.Reserved = 0;
	181
	182	rc = cifs_calculate_signature(cifs_pdu, mac_key,
	183	what_we_think_sig_should_be);
	184
	185	if(rc)
	186	return rc;
	187
	188
	189	/* cifs_dump_mem("what we think it should be: ",what_we_think_sig_should_be,16); */
	190
	191	if(memcmp(server_response_sig, what_we_think_sig_should_be, 8))
	192	return -EACCES;
	193	else
	194	return 0;
	195
	196	}
	197
	198	/* We fill in key by putting in 40 byte array which was allocated by caller */
	199	int cifs_calculate_mac_key(char * key, const char * rn, const char * password)
	200	{
	201	char temp_key[16];
	202	if ((key == NULL) \|\| (rn == NULL))
	203	return -EINVAL;
	204
	205	E_md4hash(password, temp_key);
	206	mdfour(key,temp_key,16);
	207	memcpy(key+16,rn, CIFS_SESSION_KEY_SIZE);
	208	return 0;
	209	}
	210
	211	int CalcNTLMv2_partial_mac_key(struct cifsSesInfo * ses, struct nls_table * nls_info)
	212	{
213	char temp_hash[16];
214	struct HMACMD5Context ctx;
215	char * ucase_buf;
e89dc920	216	__le16 * unicode_buf;
1da177e4 LT	217	unsigned int i,user_name_len,dom_name_len;
	218
	219	if(ses == NULL)
	220	return -EINVAL;
	221
	222	E_md4hash(ses->password, temp_hash);
	223
	224	hmac_md5_init_limK_to_64(temp_hash, 16, &ctx);
	225	user_name_len = strlen(ses->userName);
	226	if(user_name_len > MAX_USERNAME_SIZE)
	227	return -EINVAL;
3979877e SF	228	if(ses->domainName == NULL)
3979877e SF	229	return -EINVAL; /* BB should we use CIFS_LINUX_DOM */
1da177e4 LT	230	dom_name_len = strlen(ses->domainName);
	231	if(dom_name_len > MAX_USERNAME_SIZE)
	232	return -EINVAL;
	233
	234	ucase_buf = kmalloc((MAX_USERNAME_SIZE+1), GFP_KERNEL);
	235	if(ucase_buf == NULL)
	236	return -ENOMEM;
	237	unicode_buf = kmalloc((MAX_USERNAME_SIZE+1)*4, GFP_KERNEL);
	238	if(unicode_buf == NULL) {
	239	kfree(ucase_buf);
	240	return -ENOMEM;
	241	}
	242
	243	for(i=0;i<user_name_len;i++)
	244	ucase_buf[i] = nls_info->charset2upper[(int)ses->userName[i]];
	245	ucase_buf[i] = 0;
	246	user_name_len = cifs_strtoUCS(unicode_buf, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);
	247	unicode_buf[user_name_len] = 0;
	248	user_name_len++;
	249
	250	for(i=0;i<dom_name_len;i++)
	251	ucase_buf[i] = nls_info->charset2upper[(int)ses->domainName[i]];
	252	ucase_buf[i] = 0;
	253	dom_name_len = cifs_strtoUCS(unicode_buf+user_name_len, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);
	254
	255	unicode_buf[user_name_len + dom_name_len] = 0;
	256	hmac_md5_update((const unsigned char *) unicode_buf,
	257	(user_name_len+dom_name_len)*2,&ctx);
	258
ad009ac9	259	hmac_md5_final(ses->server->mac_signing_key,&ctx);
1da177e4 LT	260	kfree(ucase_buf);
	261	kfree(unicode_buf);
	262	return 0;
	263	}
	264	void CalcNTLMv2_response(const struct cifsSesInfo * ses,char * v2_session_response)
	265	{
	266	struct HMACMD5Context context;
	267	memcpy(v2_session_response + 8, ses->server->cryptKey,8);
	268	/* gen_blob(v2_session_response + 16); */
ad009ac9	269	hmac_md5_init_limK_to_64(ses->server->mac_signing_key, 16, &context);
1da177e4 LT	270
	271	hmac_md5_update(ses->server->cryptKey,8,&context);
	272	/* hmac_md5_update(v2_session_response+16)client thing,8,&context); / / BB fix */
	273
	274	hmac_md5_final(v2_session_response,&context);
5815449d	275	cifs_dump_mem("v2_sess_rsp: ", v2_session_response, 32); /* BB removeme BB */
1da177e4	276	}