Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b4020c1b authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge git://git.kernel.org/pub/scm/linux/kernel/git/sfrench/cifs-2.6 

* git://git.kernel.org/pub/scm/linux/kernel/git/sfrench/cifs-2.6:
  cifs: Cleanup and thus reduce smb session structure and fields used during authentication
  NTLM auth and sign - Use appropriate server challenge
  cifs: add kfree() on error path
  NTLM auth and sign - minor error corrections and cleanup
  NTLM auth and sign - Use kernel crypto apis to calculate hashes and smb signatures
  NTLM auth and sign - Define crypto hash functions and create and send keys needed for key exchange
  cifs: cifs_convert_address() returns zero on error
  NTLM auth and sign - Allocate session key/client response dynamically
  cifs: update comments - [s/GlobalSMBSesLock/cifs_file_list_lock/g]
  cifs: eliminate cifsInodeInfo->write_behind_rc (try #6)
  [CIFS] Fix checkpatch warnings and bump cifs version number
  cifs: wait for writeback to complete in cifs_flush
  cifs: convert cifsFileInfo->count to non-atomic counter
parents 435f49a5 d3686d54

fs/cifs/Kconfig

+3 −0
Original line number Diff line number Diff line
@@ -2,6 +2,9 @@ config CIFS 
	tristate "CIFS support (advanced network filesystem, SMBFS successor)"

	depends on INET

	select NLS

	select CRYPTO

	select CRYPTO_MD5

	select CRYPTO_ARC4

	help

	  This is the client VFS module for the Common Internet File System

	  (CIFS) protocol which is the successor to the Server Message Block

fs/cifs/cifsencrypt.c

+320 −107
Original line number Diff line number Diff line
@@ -43,18 +43,32 @@ extern void SMBencrypt(unsigned char *passwd, const unsigned char *c8, 
		       unsigned char *p24);



static int cifs_calculate_signature(const struct smb_hdr *cifs_pdu,

				const struct session_key *key, char *signature)

				struct TCP_Server_Info *server, char *signature)

{

	struct	MD5Context context;

	int rc;



	if ((cifs_pdu == NULL) || (signature == NULL) || (key == NULL))

	if (cifs_pdu == NULL || signature == NULL || server == NULL)

		return -EINVAL;



	cifs_MD5_init(&context);

	cifs_MD5_update(&context, (char *)&key->data, key->len);

	cifs_MD5_update(&context, cifs_pdu->Protocol, cifs_pdu->smb_buf_length);

	if (!server->secmech.sdescmd5) {

		cERROR(1, "%s: Can't generate signature\n", __func__);

		return -1;

	}



	rc = crypto_shash_init(&server->secmech.sdescmd5->shash);

	if (rc) {

		cERROR(1, "%s: Oould not init md5\n", __func__);

		return rc;

	}



	crypto_shash_update(&server->secmech.sdescmd5->shash,

		server->session_key.response, server->session_key.len);



	crypto_shash_update(&server->secmech.sdescmd5->shash,

		cifs_pdu->Protocol, cifs_pdu->smb_buf_length);



	rc = crypto_shash_final(&server->secmech.sdescmd5->shash, signature);



	cifs_MD5_final(signature, &context);

	return 0;

}
@@ -79,8 +93,7 @@ int cifs_sign_smb(struct smb_hdr *cifs_pdu, struct TCP_Server_Info *server, 
	server->sequence_number++;

	spin_unlock(&GlobalMid_Lock);



	rc = cifs_calculate_signature(cifs_pdu, &server->session_key,

				      smb_signature);

	rc = cifs_calculate_signature(cifs_pdu, server, smb_signature);

	if (rc)

		memset(cifs_pdu->Signature.SecuritySignature, 0, 8);

	else
@@ -90,16 +103,28 @@ int cifs_sign_smb(struct smb_hdr *cifs_pdu, struct TCP_Server_Info *server, 
}



static int cifs_calc_signature2(const struct kvec *iov, int n_vec,

				const struct session_key *key, char *signature)

				struct TCP_Server_Info *server, char *signature)

{

	struct  MD5Context context;

	int i;

	int rc;



	if ((iov == NULL) || (signature == NULL) || (key == NULL))

	if (iov == NULL || signature == NULL || server == NULL)

		return -EINVAL;



	cifs_MD5_init(&context);

	cifs_MD5_update(&context, (char *)&key->data, key->len);

	if (!server->secmech.sdescmd5) {

		cERROR(1, "%s: Can't generate signature\n", __func__);

		return -1;

	}



	rc = crypto_shash_init(&server->secmech.sdescmd5->shash);

	if (rc) {

		cERROR(1, "%s: Oould not init md5\n", __func__);

		return rc;

	}



	crypto_shash_update(&server->secmech.sdescmd5->shash,

		server->session_key.response, server->session_key.len);



	for (i = 0; i < n_vec; i++) {

		if (iov[i].iov_len == 0)

			continue;
@@ -112,18 +137,18 @@ static int cifs_calc_signature2(const struct kvec *iov, int n_vec, 
		if (i == 0) {

			if (iov[0].iov_len <= 8) /* cmd field at offset 9 */

				break; /* nothing to sign or corrupt header */

			cifs_MD5_update(&context, iov[0].iov_base+4,

				  iov[0].iov_len-4);

			crypto_shash_update(&server->secmech.sdescmd5->shash,

				iov[i].iov_base + 4, iov[i].iov_len - 4);

		} else

			cifs_MD5_update(&context, iov[i].iov_base, iov[i].iov_len);

			crypto_shash_update(&server->secmech.sdescmd5->shash,

				iov[i].iov_base, iov[i].iov_len);

	}



	cifs_MD5_final(signature, &context);

	rc = crypto_shash_final(&server->secmech.sdescmd5->shash, signature);



	return 0;

	return rc;

}





int cifs_sign_smb2(struct kvec *iov, int n_vec, struct TCP_Server_Info *server,

		   __u32 *pexpected_response_sequence_number)

{
@@ -146,8 +171,7 @@ int cifs_sign_smb2(struct kvec *iov, int n_vec, struct TCP_Server_Info *server, 
	server->sequence_number++;

	spin_unlock(&GlobalMid_Lock);



	rc = cifs_calc_signature2(iov, n_vec, &server->session_key,

				      smb_signature);

	rc = cifs_calc_signature2(iov, n_vec, server, smb_signature);

	if (rc)

		memset(cifs_pdu->Signature.SecuritySignature, 0, 8);

	else
@@ -157,14 +181,14 @@ int cifs_sign_smb2(struct kvec *iov, int n_vec, struct TCP_Server_Info *server, 
}



int cifs_verify_signature(struct smb_hdr *cifs_pdu,

			  const struct session_key *session_key,

			  struct TCP_Server_Info *server,

			  __u32 expected_sequence_number)

{

	unsigned int rc;

	char server_response_sig[8];

	char what_we_think_sig_should_be[20];



	if (cifs_pdu == NULL || session_key == NULL)

	if (cifs_pdu == NULL || server == NULL)

		return -EINVAL;



	if (cifs_pdu->Command == SMB_COM_NEGOTIATE)
@@ -193,7 +217,7 @@ int cifs_verify_signature(struct smb_hdr *cifs_pdu, 
					cpu_to_le32(expected_sequence_number);

	cifs_pdu->Signature.Sequence.Reserved = 0;



	rc = cifs_calculate_signature(cifs_pdu, session_key,

	rc = cifs_calculate_signature(cifs_pdu, server,

		what_we_think_sig_should_be);



	if (rc)
@@ -209,18 +233,28 @@ int cifs_verify_signature(struct smb_hdr *cifs_pdu, 


}



/* We fill in key by putting in 40 byte array which was allocated by caller */

int cifs_calculate_session_key(struct session_key *key, const char *rn,

			   const char *password)

/* first calculate 24 bytes ntlm response and then 16 byte session key */

int setup_ntlm_response(struct cifsSesInfo *ses)

{

	char temp_key[16];

	if ((key == NULL) || (rn == NULL))

	unsigned int temp_len = CIFS_SESS_KEY_SIZE + CIFS_AUTH_RESP_SIZE;

	char temp_key[CIFS_SESS_KEY_SIZE];



	if (!ses)

		return -EINVAL;



	E_md4hash(password, temp_key);

	mdfour(key->data.ntlm, temp_key, 16);

	memcpy(key->data.ntlm+16, rn, CIFS_SESS_KEY_SIZE);

	key->len = 40;

	ses->auth_key.response = kmalloc(temp_len, GFP_KERNEL);

	if (!ses->auth_key.response) {

		cERROR(1, "NTLM can't allocate (%u bytes) memory", temp_len);

		return -ENOMEM;

	}

	ses->auth_key.len = temp_len;



	SMBNTencrypt(ses->password, ses->server->cryptkey,

			ses->auth_key.response + CIFS_SESS_KEY_SIZE);



	E_md4hash(ses->password, temp_key);

	mdfour(ses->auth_key.response, temp_key, CIFS_SESS_KEY_SIZE);



	return 0;

}
@@ -294,15 +328,15 @@ build_avpair_blob(struct cifsSesInfo *ses, const struct nls_table *nls_cp) 
	 * two times the unicode length of a server name +

	 * size of a timestamp (which is 8 bytes).

	 */

	ses->tilen = size + 2 * (2 * dlen) + 2 * (2 * wlen) + 8;

	ses->tiblob = kzalloc(ses->tilen, GFP_KERNEL);

	if (!ses->tiblob) {

		ses->tilen = 0;

	ses->auth_key.len = size + 2 * (2 * dlen) + 2 * (2 * wlen) + 8;

	ses->auth_key.response = kzalloc(ses->auth_key.len, GFP_KERNEL);

	if (!ses->auth_key.response) {

		ses->auth_key.len = 0;

		cERROR(1, "Challenge target info allocation failure");

		return -ENOMEM;

	}



	blobptr = ses->tiblob;

	blobptr = ses->auth_key.response;

	attrptr = (struct ntlmssp2_name *) blobptr;



	attrptr->type = cpu_to_le16(NTLMSSP_AV_NB_DOMAIN_NAME);
@@ -357,7 +391,7 @@ build_avpair_blob(struct cifsSesInfo *ses, const struct nls_table *nls_cp) 
 * about target string i.e. for some, just user name might suffice.

 */

static int

find_domain_name(struct cifsSesInfo *ses)

find_domain_name(struct cifsSesInfo *ses, const struct nls_table *nls_cp)

{

	unsigned int attrsize;

	unsigned int type;
@@ -366,11 +400,11 @@ find_domain_name(struct cifsSesInfo *ses) 
	unsigned char *blobend;

	struct ntlmssp2_name *attrptr;



	if (!ses->tilen || !ses->tiblob)

	if (!ses->auth_key.len || !ses->auth_key.response)

		return 0;



	blobptr = ses->tiblob;

	blobend = ses->tiblob + ses->tilen;

	blobptr = ses->auth_key.response;

	blobend = blobptr + ses->auth_key.len;



	while (blobptr + onesize < blobend) {

		attrptr = (struct ntlmssp2_name *) blobptr;
@@ -386,16 +420,13 @@ find_domain_name(struct cifsSesInfo *ses) 
			if (!attrsize)

				break;

			if (!ses->domainName) {

				struct nls_table *default_nls;

				ses->domainName =

					kmalloc(attrsize + 1, GFP_KERNEL);

				if (!ses->domainName)

						return -ENOMEM;

				default_nls = load_nls_default();

				cifs_from_ucs2(ses->domainName,

					(__le16 *)blobptr, attrsize, attrsize,

					default_nls, false);

				unload_nls(default_nls);

					nls_cp, false);

				break;

			}

		}
@@ -405,82 +436,136 @@ find_domain_name(struct cifsSesInfo *ses) 
	return 0;

}



static int calc_ntlmv2_hash(struct cifsSesInfo *ses,

static int calc_ntlmv2_hash(struct cifsSesInfo *ses, char *ntlmv2_hash,

			    const struct nls_table *nls_cp)

{

	int rc = 0;

	int len;

	char nt_hash[16];

	struct HMACMD5Context *pctxt;

	char nt_hash[CIFS_NTHASH_SIZE];

	wchar_t *user;

	wchar_t *domain;

	wchar_t *server;



	pctxt = kmalloc(sizeof(struct HMACMD5Context), GFP_KERNEL);



	if (pctxt == NULL)

		return -ENOMEM;

	if (!ses->server->secmech.sdeschmacmd5) {

		cERROR(1, "calc_ntlmv2_hash: can't generate ntlmv2 hash\n");

		return -1;

	}



	/* calculate md4 hash of password */

	E_md4hash(ses->password, nt_hash);



	/* convert Domainname to unicode and uppercase */

	hmac_md5_init_limK_to_64(nt_hash, 16, pctxt);

	crypto_shash_setkey(ses->server->secmech.hmacmd5, nt_hash,

				CIFS_NTHASH_SIZE);



	rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);

	if (rc) {

		cERROR(1, "calc_ntlmv2_hash: could not init hmacmd5\n");

		return rc;

	}



	/* convert ses->userName to unicode and uppercase */

	len = strlen(ses->userName);

	user = kmalloc(2 + (len * 2), GFP_KERNEL);

	if (user == NULL)

	if (user == NULL) {

		cERROR(1, "calc_ntlmv2_hash: user mem alloc failure\n");

		rc = -ENOMEM;

		goto calc_exit_2;

	}

	len = cifs_strtoUCS((__le16 *)user, ses->userName, len, nls_cp);

	UniStrupr(user);

	hmac_md5_update((char *)user, 2*len, pctxt);



	crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,

				(char *)user, 2 * len);



	/* convert ses->domainName to unicode and uppercase */

	if (ses->domainName) {

		len = strlen(ses->domainName);



		domain = kmalloc(2 + (len * 2), GFP_KERNEL);

		if (domain == NULL)

		if (domain == NULL) {

			cERROR(1, "calc_ntlmv2_hash: domain mem alloc failure");

			rc = -ENOMEM;

			goto calc_exit_1;

		}

		len = cifs_strtoUCS((__le16 *)domain, ses->domainName, len,

					nls_cp);

		/* the following line was removed since it didn't work well

		   with lower cased domain name that passed as an option.

		   Maybe converting the domain name earlier makes sense */

		/* UniStrupr(domain); */



		hmac_md5_update((char *)domain, 2*len, pctxt);



		crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,

					(char *)domain, 2 * len);

		kfree(domain);

	} else if (ses->serverName) {

		len = strlen(ses->serverName);



		server = kmalloc(2 + (len * 2), GFP_KERNEL);

		if (server == NULL) {

			cERROR(1, "calc_ntlmv2_hash: server mem alloc failure");

			rc = -ENOMEM;

			goto calc_exit_1;

		}

		len = cifs_strtoUCS((__le16 *)server, ses->serverName, len,

					nls_cp);

		crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,

					(char *)server, 2 * len);

		kfree(server);

	}



	rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,

					ntlmv2_hash);



calc_exit_1:

	kfree(user);

calc_exit_2:

	/* BB FIXME what about bytes 24 through 40 of the signing key?

	   compare with the NTLM example */

	hmac_md5_final(ses->ntlmv2_hash, pctxt);

	return rc;

}



static int

CalcNTLMv2_response(const struct cifsSesInfo *ses, char *ntlmv2_hash)

{

	int rc;

	unsigned int offset = CIFS_SESS_KEY_SIZE + 8;



	if (!ses->server->secmech.sdeschmacmd5) {

		cERROR(1, "calc_ntlmv2_hash: can't generate ntlmv2 hash\n");

		return -1;

	}



	crypto_shash_setkey(ses->server->secmech.hmacmd5,

				ntlmv2_hash, CIFS_HMAC_MD5_HASH_SIZE);



	rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);

	if (rc) {

		cERROR(1, "CalcNTLMv2_response: could not init hmacmd5");

		return rc;

	}



	if (ses->server->secType == RawNTLMSSP)

		memcpy(ses->auth_key.response + offset,

			ses->ntlmssp->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);

	else

		memcpy(ses->auth_key.response + offset,

			ses->server->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);

	crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,

		ses->auth_key.response + offset, ses->auth_key.len - offset);



	rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,

		ses->auth_key.response + CIFS_SESS_KEY_SIZE);



	kfree(pctxt);

	return rc;

}





int

setup_ntlmv2_rsp(struct cifsSesInfo *ses, char *resp_buf,

		      const struct nls_table *nls_cp)

setup_ntlmv2_rsp(struct cifsSesInfo *ses, const struct nls_table *nls_cp)

{

	int rc;

	struct ntlmv2_resp *buf = (struct ntlmv2_resp *)resp_buf;

	struct HMACMD5Context context;



	buf->blob_signature = cpu_to_le32(0x00000101);

	buf->reserved = 0;

	buf->time = cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));

	get_random_bytes(&buf->client_chal, sizeof(buf->client_chal));

	buf->reserved2 = 0;

	int baselen;

	unsigned int tilen;

	struct ntlmv2_resp *buf;

	char ntlmv2_hash[16];

	unsigned char *tiblob = NULL; /* target info blob */



	if (ses->server->secType == RawNTLMSSP) {

		if (!ses->domainName) {

			rc = find_domain_name(ses);

			rc = find_domain_name(ses, nls_cp);

			if (rc) {

				cERROR(1, "error %d finding domain name", rc);

				goto setup_ntlmv2_rsp_ret;
@@ -490,51 +575,179 @@ setup_ntlmv2_rsp(struct cifsSesInfo *ses, char *resp_buf, 
		rc = build_avpair_blob(ses, nls_cp);

		if (rc) {

			cERROR(1, "error %d building av pair blob", rc);

			return rc;

			goto setup_ntlmv2_rsp_ret;

		}

	}



	/* calculate buf->ntlmv2_hash */

	rc = calc_ntlmv2_hash(ses, nls_cp);

	baselen = CIFS_SESS_KEY_SIZE + sizeof(struct ntlmv2_resp);

	tilen = ses->auth_key.len;

	tiblob = ses->auth_key.response;



	ses->auth_key.response = kmalloc(baselen + tilen, GFP_KERNEL);

	if (!ses->auth_key.response) {

		rc = ENOMEM;

		ses->auth_key.len = 0;

		cERROR(1, "%s: Can't allocate auth blob", __func__);

		goto setup_ntlmv2_rsp_ret;

	}

	ses->auth_key.len += baselen;



	buf = (struct ntlmv2_resp *)

			(ses->auth_key.response + CIFS_SESS_KEY_SIZE);

	buf->blob_signature = cpu_to_le32(0x00000101);

	buf->reserved = 0;

	buf->time = cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));

	get_random_bytes(&buf->client_chal, sizeof(buf->client_chal));

	buf->reserved2 = 0;



	memcpy(ses->auth_key.response + baselen, tiblob, tilen);



	/* calculate ntlmv2_hash */

	rc = calc_ntlmv2_hash(ses, ntlmv2_hash, nls_cp);

	if (rc) {

		cERROR(1, "could not get v2 hash rc %d", rc);

		goto setup_ntlmv2_rsp_ret;

	}

	CalcNTLMv2_response(ses, resp_buf);



	/* calculate first part of the client response (CR1) */

	rc = CalcNTLMv2_response(ses, ntlmv2_hash);

	if (rc) {

		cERROR(1, "Could not calculate CR1  rc: %d", rc);

		goto setup_ntlmv2_rsp_ret;

	}



	/* now calculate the session key for NTLMv2 */

	hmac_md5_init_limK_to_64(ses->ntlmv2_hash, 16, &context);

	hmac_md5_update(resp_buf, 16, &context);

	hmac_md5_final(ses->auth_key.data.ntlmv2.key, &context);

	crypto_shash_setkey(ses->server->secmech.hmacmd5,

		ntlmv2_hash, CIFS_HMAC_MD5_HASH_SIZE);



	rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);

	if (rc) {

		cERROR(1, "%s: Could not init hmacmd5\n", __func__);

		goto setup_ntlmv2_rsp_ret;

	}



	memcpy(&ses->auth_key.data.ntlmv2.resp, resp_buf,

	       sizeof(struct ntlmv2_resp));

	ses->auth_key.len = 16 + sizeof(struct ntlmv2_resp);

	crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,

		ses->auth_key.response + CIFS_SESS_KEY_SIZE,

		CIFS_HMAC_MD5_HASH_SIZE);



	return 0;

	rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,

		ses->auth_key.response);



setup_ntlmv2_rsp_ret:

	kfree(ses->tiblob);

	ses->tiblob = NULL;

	ses->tilen = 0;

	kfree(tiblob);



	return rc;

}



void CalcNTLMv2_response(const struct cifsSesInfo *ses,

			 char *v2_session_response)

int

calc_seckey(struct cifsSesInfo *ses)

{

	struct HMACMD5Context context;

	/* rest of v2 struct already generated */

	memcpy(v2_session_response + 8, ses->cryptKey, 8);

	hmac_md5_init_limK_to_64(ses->ntlmv2_hash, 16, &context);

	int rc;

	struct crypto_blkcipher *tfm_arc4;

	struct scatterlist sgin, sgout;

	struct blkcipher_desc desc;

	unsigned char sec_key[CIFS_SESS_KEY_SIZE]; /* a nonce */



	get_random_bytes(sec_key, CIFS_SESS_KEY_SIZE);



	tfm_arc4 = crypto_alloc_blkcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);

	if (!tfm_arc4 || IS_ERR(tfm_arc4)) {

		cERROR(1, "could not allocate crypto API arc4\n");

		return PTR_ERR(tfm_arc4);

	}



	desc.tfm = tfm_arc4;



	hmac_md5_update(v2_session_response+8,

			sizeof(struct ntlmv2_resp) - 8, &context);

	crypto_blkcipher_setkey(tfm_arc4, ses->auth_key.response,

					CIFS_SESS_KEY_SIZE);



	if (ses->tilen)

		hmac_md5_update(ses->tiblob, ses->tilen, &context);

	sg_init_one(&sgin, sec_key, CIFS_SESS_KEY_SIZE);

	sg_init_one(&sgout, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);



	hmac_md5_final(v2_session_response, &context);

/*	cifs_dump_mem("v2_sess_rsp: ", v2_session_response, 32); */

	rc = crypto_blkcipher_encrypt(&desc, &sgout, &sgin, CIFS_CPHTXT_SIZE);

	if (rc) {

		cERROR(1, "could not encrypt session key rc: %d\n", rc);

		crypto_free_blkcipher(tfm_arc4);

		return rc;

	}



	/* make secondary_key/nonce as session key */

	memcpy(ses->auth_key.response, sec_key, CIFS_SESS_KEY_SIZE);

	/* and make len as that of session key only */

	ses->auth_key.len = CIFS_SESS_KEY_SIZE;



	crypto_free_blkcipher(tfm_arc4);



	return 0;

}



void

cifs_crypto_shash_release(struct TCP_Server_Info *server)

{

	if (server->secmech.md5)

		crypto_free_shash(server->secmech.md5);



	if (server->secmech.hmacmd5)

		crypto_free_shash(server->secmech.hmacmd5);



	kfree(server->secmech.sdeschmacmd5);



	kfree(server->secmech.sdescmd5);

}



int

cifs_crypto_shash_allocate(struct TCP_Server_Info *server)

{

	int rc;

	unsigned int size;



	server->secmech.hmacmd5 = crypto_alloc_shash("hmac(md5)", 0, 0);

	if (!server->secmech.hmacmd5 ||

			IS_ERR(server->secmech.hmacmd5)) {

		cERROR(1, "could not allocate crypto hmacmd5\n");

		return PTR_ERR(server->secmech.hmacmd5);

	}



	server->secmech.md5 = crypto_alloc_shash("md5", 0, 0);

	if (!server->secmech.md5 || IS_ERR(server->secmech.md5)) {

		cERROR(1, "could not allocate crypto md5\n");

		rc = PTR_ERR(server->secmech.md5);

		goto crypto_allocate_md5_fail;

	}



	size = sizeof(struct shash_desc) +

			crypto_shash_descsize(server->secmech.hmacmd5);

	server->secmech.sdeschmacmd5 = kmalloc(size, GFP_KERNEL);

	if (!server->secmech.sdeschmacmd5) {

		cERROR(1, "cifs_crypto_shash_allocate: can't alloc hmacmd5\n");

		rc = -ENOMEM;

		goto crypto_allocate_hmacmd5_sdesc_fail;

	}

	server->secmech.sdeschmacmd5->shash.tfm = server->secmech.hmacmd5;

	server->secmech.sdeschmacmd5->shash.flags = 0x0;





	size = sizeof(struct shash_desc) +

			crypto_shash_descsize(server->secmech.md5);

	server->secmech.sdescmd5 = kmalloc(size, GFP_KERNEL);

	if (!server->secmech.sdescmd5) {

		cERROR(1, "cifs_crypto_shash_allocate: can't alloc md5\n");

		rc = -ENOMEM;

		goto crypto_allocate_md5_sdesc_fail;

	}

	server->secmech.sdescmd5->shash.tfm = server->secmech.md5;

	server->secmech.sdescmd5->shash.flags = 0x0;



	return 0;



crypto_allocate_md5_sdesc_fail:

	kfree(server->secmech.sdeschmacmd5);



crypto_allocate_hmacmd5_sdesc_fail:

	crypto_free_shash(server->secmech.md5);



crypto_allocate_md5_fail:

	crypto_free_shash(server->secmech.hmacmd5);



	return rc;

}

fs/cifs/cifsfs.c

+0 −1
Original line number Diff line number Diff line
@@ -318,7 +318,6 @@ cifs_alloc_inode(struct super_block *sb) 
		return NULL;

	cifs_inode->cifsAttrs = 0x20;	/* default */

	cifs_inode->time = 0;

	cifs_inode->write_behind_rc = 0;

	/* Until the file is open and we have gotten oplock

	info back from the server, can not assume caching of

	file data or metadata */

fs/cifs/cifsfs.h

+1 −1
Original line number Diff line number Diff line
@@ -112,5 +112,5 @@ extern long cifs_ioctl(struct file *filep, unsigned int cmd, unsigned long arg); 
extern const struct export_operations cifs_export_ops;

#endif /* EXPERIMENTAL */



#define CIFS_VERSION   "1.67"

#define CIFS_VERSION   "1.68"

#endif				/* _CIFSFS_H */

fs/cifs/cifsglob.h

+37 −18
Original line number Diff line number Diff line
@@ -25,6 +25,9 @@ 
#include <linux/workqueue.h>

#include "cifs_fs_sb.h"

#include "cifsacl.h"

#include <crypto/internal/hash.h>

#include <linux/scatterlist.h>



/*

 * The sizes of various internal tables and strings

 */
@@ -99,14 +102,29 @@ enum protocolEnum { 


struct session_key {

	unsigned int len;

	union {

		char ntlm[CIFS_SESS_KEY_SIZE + 16];

		char krb5[CIFS_SESS_KEY_SIZE + 16]; /* BB: length correct? */

		struct {

			char key[16];

			struct ntlmv2_resp resp;

		} ntlmv2;

	} data;

	char *response;

};



/* crypto security descriptor definition */

struct sdesc {

	struct shash_desc shash;

	char ctx[];

};



/* crypto hashing related structure/fields, not specific to a sec mech */

struct cifs_secmech {

	struct crypto_shash *hmacmd5; /* hmac-md5 hash function */

	struct crypto_shash *md5; /* md5 hash function */

	struct sdesc *sdeschmacmd5;  /* ctxt to generate ntlmv2 hash, CR1 */

	struct sdesc *sdescmd5; /* ctxt to generate cifs/smb signature */

};



/* per smb session structure/fields */

struct ntlmssp_auth {

	__u32 client_flags; /* sent by client in type 1 ntlmsssp exchange */

	__u32 server_flags; /* sent by server in type 2 ntlmssp exchange */

	unsigned char ciphertext[CIFS_CPHTXT_SIZE]; /* sent to server */

	char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlmssp */

};



struct cifs_cred {
@@ -179,12 +197,14 @@ struct TCP_Server_Info { 
	int capabilities; /* allow selective disabling of caps by smb sess */

	int timeAdj;  /* Adjust for difference in server time zone in sec */

	__u16 CurrentMid;         /* multiplex id - rotating counter */

	char cryptkey[CIFS_CRYPTO_KEY_SIZE]; /* used by ntlm, ntlmv2 etc */

	/* 16th byte of RFC1001 workstation name is always null */

	char workstation_RFC1001_name[RFC1001_NAME_LEN_WITH_NULL];

	__u32 sequence_number; /* needed for CIFS PDU signature */

	struct session_key session_key;

	unsigned long lstrp; /* when we got last response from this server */

	u16 dialect; /* dialect index that server chose */

	struct cifs_secmech secmech; /* crypto sec mech functs, descriptors */

	/* extended security flavors that server supports */

	bool	sec_kerberos;		/* supports plain Kerberos */

	bool	sec_mskerberos;		/* supports legacy MS Kerberos */
@@ -222,11 +242,8 @@ struct cifsSesInfo { 
	char userName[MAX_USERNAME_SIZE + 1];

	char *domainName;

	char *password;

	char cryptKey[CIFS_CRYPTO_KEY_SIZE];

	struct session_key auth_key;

	char ntlmv2_hash[16];

	unsigned int tilen; /* length of the target info blob */

	unsigned char *tiblob; /* target info blob in challenge response */

	struct ntlmssp_auth *ntlmssp; /* ciphertext, flags, server challenge */

	bool need_reconnect:1; /* connection reset, uid now invalid */

};

/* no more than one of the following three session flags may be set */
@@ -395,16 +412,19 @@ struct cifsFileInfo { 
	struct list_head llist; /* list of byte range locks we have. */

	bool invalidHandle:1;	/* file closed via session abend */

	bool oplock_break_cancelled:1;

	atomic_t count;		/* reference count */

	int count;		/* refcount protected by cifs_file_list_lock */

	struct mutex fh_mutex; /* prevents reopen race after dead ses*/

	struct cifs_search_info srch_inf;

	struct work_struct oplock_break; /* work for oplock breaks */

};



/* Take a reference on the file private data */

/*

 * Take a reference on the file private data. Must be called with

 * cifs_file_list_lock held.

 */

static inline void cifsFileInfo_get(struct cifsFileInfo *cifs_file)

{

	atomic_inc(&cifs_file->count);

	++cifs_file->count;

}



void cifsFileInfo_put(struct cifsFileInfo *cifs_file);
@@ -417,7 +437,6 @@ struct cifsInodeInfo { 
	struct list_head lockList;

	/* BB add in lists for dirty pages i.e. write caching info for oplock */

	struct list_head openFileList;

	int write_behind_rc;

	__u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */

	unsigned long time;	/* jiffies of last update/check of inode */

	bool clientCanCacheRead:1;	/* read oplock */
@@ -668,7 +687,7 @@ require use of the stronger protocol */ 
 *  GlobalMid_Lock protects:

 *	list operations on pending_mid_q and oplockQ

 *      updates to XID counters, multiplex id  and SMB sequence numbers

 *  GlobalSMBSesLock protects:

 *  cifs_file_list_lock protects:

 *	list operations on tcp and SMB session lists and tCon lists

 *  f_owner.lock protects certain per file struct operations

 *  mapping->page_lock protects certain per page operations