CTC++ Coverage Report - Execution Profile    #854/1532

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last

File: fs/cifs/cifsencrypt.c
Instrumentation mode: function-decision-multicondition
TER: 0 % ( 0/133)

Start/	End/
True	False	-	Line	Source
			1	/*
			2	*   fs/cifs/cifsencrypt.c
			3	*
			4	*   Copyright (C) International Business Machines  Corp., 2005
			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
0	0	-	39	static int cifs_calculate_signature(const struct smb_hdr * cifs_pdu, const char * key, char * signature)
			40	{
			41	struct   MD5Context context;
			42
0	0	-	43	if((cifs_pdu == NULL) || (signature == NULL))
0		-	43	(T) || (_)
0		-	43	(F) || (T)
	0	-	43	(F) || (F)
0		-	44	return -EINVAL;
			45
			46	MD5Init(&context);
			47	MD5Update(&context,key,CIFS_SESSION_KEY_SIZE+16);
			48	MD5Update(&context,cifs_pdu->Protocol,cifs_pdu->smb_buf_length);
			49	MD5Final(signature,&context);
0		-	50	return 0;
			51	}
			52
0	0	-	53	int cifs_sign_smb(struct smb_hdr * cifs_pdu, struct TCP_Server_Info * server,
			54	__u32 * pexpected_response_sequence_number)
			55	{
			56	int rc = 0;
			57	char smb_signature[20];
			58
0	0	-	59	if((cifs_pdu == NULL) || (server == NULL))
0		-	59	(T) || (_)
0		-	59	(F) || (T)
	0	-	59	(F) || (F)
0		-	60	return -EINVAL;
			61
0	0	-	62	if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0)
0		-	63	return rc;
			64
			65	spin_lock(&GlobalMid_Lock);
			65	do
0	0	-	65	do-while (0)
0	0	-	65	do-while (0)
			66	cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(server->sequence_number);
			67	cifs_pdu->Signature.Sequence.Reserved = 0;
			68
			69	*pexpected_response_sequence_number = server->sequence_number++;
			70	server->sequence_number++;
			71	spin_unlock(&GlobalMid_Lock);
			71	do
0	0	-	71	do-while (0)
0	0	-	71	do-while (0)
			72
			73	rc = cifs_calculate_signature(cifs_pdu, server->mac_signing_key,smb_signature);
0	0	-	74	if(rc)
			75	memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
			76	else
			77	memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
			78
0		-	79	return rc;
			80	}
			81
0	0	-	82	static int cifs_calc_signature2(const struct kvec * iov, int n_vec,
			83	const char * key, char * signature)
			84	{
			85	struct  MD5Context context;
			86	int i;
			87
0	0	-	88	if((iov == NULL) || (signature == NULL))
0		-	88	(T) || (_)
0		-	88	(F) || (T)
	0	-	88	(F) || (F)
0		-	89	return -EINVAL;
			90
			91	MD5Init(&context);
			92	MD5Update(&context,key,CIFS_SESSION_KEY_SIZE+16);
0	0	-	93	for(i=0;i<n_vec;i++) {
0	0	-	94	if(iov[i].iov_base == NULL) {
0	0	-	95	cERROR(1,("null iovec entry"));
0	0	-	95	if (cifsERROR)
0		-	96	return -EIO;
0	0	-	97	} else if(iov[i].iov_len == 0)
0		-	98	break; /* bail out if we are sent nothing to sign */
			99	/* The first entry includes a length field (which does not get
			100	signed that occupies the first 4 bytes before the header */
0	0	-	101	if(i==0) {
0	0	-	102	if (iov[0].iov_len <= 8 ) /* cmd field at offset 9 */
0		-	103	break; /* nothing to sign or corrupt header */
			104	MD5Update(&context,iov[0].iov_base+4, iov[0].iov_len-4);
			105	} else
			106	MD5Update(&context,iov[i].iov_base, iov[i].iov_len);
			107	}
			108
			109	MD5Final(signature,&context);
			110
0		-	111	return 0;
			112	}
			113
			114
0	0	-	115	int cifs_sign_smb2(struct kvec * iov, int n_vec, struct TCP_Server_Info *server,
			116	__u32 * pexpected_response_sequence_number)
			117	{
			118	int rc = 0;
			119	char smb_signature[20];
			120	struct smb_hdr * cifs_pdu = iov[0].iov_base;
			121
0	0	-	122	if((cifs_pdu == NULL) || (server == NULL))
0		-	122	(T) || (_)
0		-	122	(F) || (T)
	0	-	122	(F) || (F)
0		-	123	return -EINVAL;
			124
0	0	-	125	if((cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) == 0)
0		-	126	return rc;
			127
			128	spin_lock(&GlobalMid_Lock);
			128	do
0	0	-	128	do-while (0)
0	0	-	128	do-while (0)
			129	cifs_pdu->Signature.Sequence.SequenceNumber =
			130	cpu_to_le32(server->sequence_number);
			131	cifs_pdu->Signature.Sequence.Reserved = 0;
			132
			133	*pexpected_response_sequence_number = server->sequence_number++;
			134	server->sequence_number++;
			135	spin_unlock(&GlobalMid_Lock);
			135	do
0	0	-	135	do-while (0)
0	0	-	135	do-while (0)
			136
			137	rc = cifs_calc_signature2(iov, n_vec, server->mac_signing_key,
			138	smb_signature);
0	0	-	139	if(rc)
			140	memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
			141	else
			142	memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
			143
0		-	144	return rc;
			145
			146	}
			147
0	0	-	148	int cifs_verify_signature(struct smb_hdr * cifs_pdu, const char * mac_key,
			149	__u32 expected_sequence_number)
			150	{
			151	unsigned int rc;
			152	char server_response_sig[8];
			153	char what_we_think_sig_should_be[20];
			154
0	0	-	155	if((cifs_pdu == NULL) || (mac_key == NULL))
0		-	155	(T) || (_)
0		-	155	(F) || (T)
	0	-	155	(F) || (F)
0		-	156	return -EINVAL;
			157
0	0	-	158	if (cifs_pdu->Command == SMB_COM_NEGOTIATE)
0		-	159	return 0;
			160
0	0	-	161	if (cifs_pdu->Command == SMB_COM_LOCKING_ANDX) {
			162	struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)cifs_pdu;
0	0	-	163	if(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE)
0		-	164	return 0;
			165	}
			166
			167	/* BB what if signatures are supposed to be on for session but server does not
			168	send one? BB */
			169
			170	/* Do not need to verify session setups with signature "BSRSPYL "  */
0	0	-	171	if(memcmp(cifs_pdu->Signature.SecuritySignature,"BSRSPYL ",8)==0)
0	0	-	172	cFYI(1,("dummy signature received for smb command 0x%x",cifs_pdu->Command));
0	0	-	172	if (cifsFYI & 0x01)
			173
			174	/* save off the origiginal signature so we can modify the smb and check
			175	its signature against what the server sent */
			176	memcpy(server_response_sig,cifs_pdu->Signature.SecuritySignature,8);
			177
			178	cifs_pdu->Signature.Sequence.SequenceNumber = cpu_to_le32(expected_sequence_number);
			179	cifs_pdu->Signature.Sequence.Reserved = 0;
			180
			181	rc = cifs_calculate_signature(cifs_pdu, mac_key,
			182	what_we_think_sig_should_be);
			183
0	0	-	184	if(rc)
0		-	185	return rc;
			186
			187
			188	/*   cifs_dump_mem("what we think it should be: ",what_we_think_sig_should_be,16); */
			189
0	0	-	190	if(memcmp(server_response_sig, what_we_think_sig_should_be, 8))
0		-	191	return -EACCES;
			192	else
0		-	193	return 0;
			194
			195	}
			196
			197	/* We fill in key by putting in 40 byte array which was allocated by caller */
0	0	-	198	int cifs_calculate_mac_key(char * key, const char * rn, const char * password)
			199	{
			200	char temp_key[16];
0	0	-	201	if ((key == NULL) || (rn == NULL))
0		-	201	(T) || (_)
0		-	201	(F) || (T)
	0	-	201	(F) || (F)
0		-	202	return -EINVAL;
			203
			204	E_md4hash(password, temp_key);
			205	mdfour(key,temp_key,16);
			206	memcpy(key+16,rn, CIFS_SESSION_KEY_SIZE);
0		-	207	return 0;
			208	}
			209
0	0	-	210	int CalcNTLMv2_partial_mac_key(struct cifsSesInfo * ses, struct nls_table * nls_info)
			211	{
			212	char temp_hash[16];
			213	struct HMACMD5Context ctx;
			214	char * ucase_buf;
			215	__le16 * unicode_buf;
			216	unsigned int i,user_name_len,dom_name_len;
			217
0	0	-	218	if(ses == NULL)
0		-	219	return -EINVAL;
			220
			221	E_md4hash(ses->password, temp_hash);
			222
			223	hmac_md5_init_limK_to_64(temp_hash, 16, &ctx);
			224	user_name_len = strlen(ses->userName);
0	0	-	225	if(user_name_len > MAX_USERNAME_SIZE)
0		-	226	return -EINVAL;
			227	dom_name_len = strlen(ses->domainName);
0	0	-	228	if(dom_name_len > MAX_USERNAME_SIZE)
0		-	229	return -EINVAL;
			230
			231	ucase_buf = kmalloc((MAX_USERNAME_SIZE+1), GFP_KERNEL);
0	0	-	232	if(ucase_buf == NULL)
0		-	233	return -ENOMEM;
			234	unicode_buf = kmalloc((MAX_USERNAME_SIZE+1)*4, GFP_KERNEL);
0	0	-	235	if(unicode_buf == NULL) {
			236	kfree(ucase_buf);
0		-	237	return -ENOMEM;
			238	}
			239
0	0	-	240	for(i=0;i<user_name_len;i++)
			241	ucase_buf[i] = nls_info->charset2upper[(int)ses->userName[i]];
			242	ucase_buf[i] = 0;
			243	user_name_len = cifs_strtoUCS(unicode_buf, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);
			244	unicode_buf[user_name_len] = 0;
			245	user_name_len++;
			246
0	0	-	247	for(i=0;i<dom_name_len;i++)
			248	ucase_buf[i] = nls_info->charset2upper[(int)ses->domainName[i]];
			249	ucase_buf[i] = 0;
			250	dom_name_len = cifs_strtoUCS(unicode_buf+user_name_len, ucase_buf, MAX_USERNAME_SIZE*2, nls_info);
			251
			252	unicode_buf[user_name_len + dom_name_len] = 0;
			253	hmac_md5_update((const unsigned char *) unicode_buf,
			254	(user_name_len+dom_name_len)*2,&ctx);
			255
			256	hmac_md5_final(ses->server->mac_signing_key,&ctx);
			257	kfree(ucase_buf);
			258	kfree(unicode_buf);
0		-	259	return 0;
			260	}
0	0	-	261	void CalcNTLMv2_response(const struct cifsSesInfo * ses,char * v2_session_response)
			262	{
			263	struct HMACMD5Context context;
			264	memcpy(v2_session_response + 8, ses->server->cryptKey,8);
			265	/* gen_blob(v2_session_response + 16); */
			266	hmac_md5_init_limK_to_64(ses->server->mac_signing_key, 16, &context);
			267
			268	hmac_md5_update(ses->server->cryptKey,8,&context);
			269	/*   hmac_md5_update(v2_session_response+16)client thing,8,&context); */ /* BB fix */
			270
			271	hmac_md5_final(v2_session_response,&context);
			272	}
***TER 0% (0/133) of SOURCE FILE cifsencrypt.c

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last | Top