xref: /openbmc/linux/fs/smb/client/smb2transport.c (revision 7f7bed74)
1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3  *
4  *   Copyright (C) International Business Machines  Corp., 2002, 2011
5  *                 Etersoft, 2012
6  *   Author(s): Steve French (sfrench@us.ibm.com)
7  *              Jeremy Allison (jra@samba.org) 2006
8  *              Pavel Shilovsky (pshilovsky@samba.org) 2012
9  *
10  */
11 
12 #include <linux/fs.h>
13 #include <linux/list.h>
14 #include <linux/wait.h>
15 #include <linux/net.h>
16 #include <linux/delay.h>
17 #include <linux/uaccess.h>
18 #include <asm/processor.h>
19 #include <linux/mempool.h>
20 #include <linux/highmem.h>
21 #include <crypto/aead.h>
22 #include "cifsglob.h"
23 #include "cifsproto.h"
24 #include "smb2proto.h"
25 #include "cifs_debug.h"
26 #include "smb2status.h"
27 #include "smb2glob.h"
28 
29 static int
30 smb3_crypto_shash_allocate(struct TCP_Server_Info *server)
31 {
32 	struct cifs_secmech *p = &server->secmech;
33 	int rc;
34 
35 	rc = cifs_alloc_hash("hmac(sha256)", &p->hmacsha256);
36 	if (rc)
37 		goto err;
38 
39 	rc = cifs_alloc_hash("cmac(aes)", &p->aes_cmac);
40 	if (rc)
41 		goto err;
42 
43 	return 0;
44 err:
45 	cifs_free_hash(&p->hmacsha256);
46 	return rc;
47 }
48 
49 int
50 smb311_crypto_shash_allocate(struct TCP_Server_Info *server)
51 {
52 	struct cifs_secmech *p = &server->secmech;
53 	int rc = 0;
54 
55 	rc = cifs_alloc_hash("hmac(sha256)", &p->hmacsha256);
56 	if (rc)
57 		return rc;
58 
59 	rc = cifs_alloc_hash("cmac(aes)", &p->aes_cmac);
60 	if (rc)
61 		goto err;
62 
63 	rc = cifs_alloc_hash("sha512", &p->sha512);
64 	if (rc)
65 		goto err;
66 
67 	return 0;
68 
69 err:
70 	cifs_free_hash(&p->aes_cmac);
71 	cifs_free_hash(&p->hmacsha256);
72 	return rc;
73 }
74 
75 
76 static
77 int smb2_get_sign_key(__u64 ses_id, struct TCP_Server_Info *server, u8 *key)
78 {
79 	struct cifs_chan *chan;
80 	struct TCP_Server_Info *pserver;
81 	struct cifs_ses *ses = NULL;
82 	int i;
83 	int rc = 0;
84 	bool is_binding = false;
85 
86 	spin_lock(&cifs_tcp_ses_lock);
87 
88 	/* If server is a channel, select the primary channel */
89 	pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
90 
91 	list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) {
92 		if (ses->Suid == ses_id)
93 			goto found;
94 	}
95 	trace_smb3_ses_not_found(ses_id);
96 	cifs_server_dbg(FYI, "%s: Could not find session 0x%llx\n",
97 			__func__, ses_id);
98 	rc = -ENOENT;
99 	goto out;
100 
101 found:
102 	spin_lock(&ses->ses_lock);
103 	spin_lock(&ses->chan_lock);
104 
105 	is_binding = (cifs_chan_needs_reconnect(ses, server) &&
106 		      ses->ses_status == SES_GOOD);
107 	if (is_binding) {
108 		/*
109 		 * If we are in the process of binding a new channel
110 		 * to an existing session, use the master connection
111 		 * session key
112 		 */
113 		memcpy(key, ses->smb3signingkey, SMB3_SIGN_KEY_SIZE);
114 		spin_unlock(&ses->chan_lock);
115 		spin_unlock(&ses->ses_lock);
116 		goto out;
117 	}
118 
119 	/*
120 	 * Otherwise, use the channel key.
121 	 */
122 
123 	for (i = 0; i < ses->chan_count; i++) {
124 		chan = ses->chans + i;
125 		if (chan->server == server) {
126 			memcpy(key, chan->signkey, SMB3_SIGN_KEY_SIZE);
127 			spin_unlock(&ses->chan_lock);
128 			spin_unlock(&ses->ses_lock);
129 			goto out;
130 		}
131 	}
132 	spin_unlock(&ses->chan_lock);
133 	spin_unlock(&ses->ses_lock);
134 
135 	cifs_dbg(VFS,
136 		 "%s: Could not find channel signing key for session 0x%llx\n",
137 		 __func__, ses_id);
138 	rc = -ENOENT;
139 
140 out:
141 	spin_unlock(&cifs_tcp_ses_lock);
142 	return rc;
143 }
144 
145 static struct cifs_ses *
146 smb2_find_smb_ses_unlocked(struct TCP_Server_Info *server, __u64 ses_id)
147 {
148 	struct TCP_Server_Info *pserver;
149 	struct cifs_ses *ses;
150 
151 	/* If server is a channel, select the primary channel */
152 	pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
153 
154 	list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) {
155 		if (ses->Suid != ses_id)
156 			continue;
157 
158 		spin_lock(&ses->ses_lock);
159 		if (ses->ses_status == SES_EXITING) {
160 			spin_unlock(&ses->ses_lock);
161 			continue;
162 		}
163 		cifs_smb_ses_inc_refcount(ses);
164 		spin_unlock(&ses->ses_lock);
165 		return ses;
166 	}
167 
168 	return NULL;
169 }
170 
171 struct cifs_ses *
172 smb2_find_smb_ses(struct TCP_Server_Info *server, __u64 ses_id)
173 {
174 	struct cifs_ses *ses;
175 
176 	spin_lock(&cifs_tcp_ses_lock);
177 	ses = smb2_find_smb_ses_unlocked(server, ses_id);
178 	spin_unlock(&cifs_tcp_ses_lock);
179 
180 	return ses;
181 }
182 
183 static struct cifs_tcon *
184 smb2_find_smb_sess_tcon_unlocked(struct cifs_ses *ses, __u32  tid)
185 {
186 	struct cifs_tcon *tcon;
187 
188 	list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
189 		if (tcon->tid != tid)
190 			continue;
191 		++tcon->tc_count;
192 		return tcon;
193 	}
194 
195 	return NULL;
196 }
197 
198 /*
199  * Obtain tcon corresponding to the tid in the given
200  * cifs_ses
201  */
202 
203 struct cifs_tcon *
204 smb2_find_smb_tcon(struct TCP_Server_Info *server, __u64 ses_id, __u32  tid)
205 {
206 	struct cifs_ses *ses;
207 	struct cifs_tcon *tcon;
208 
209 	spin_lock(&cifs_tcp_ses_lock);
210 	ses = smb2_find_smb_ses_unlocked(server, ses_id);
211 	if (!ses) {
212 		spin_unlock(&cifs_tcp_ses_lock);
213 		return NULL;
214 	}
215 	tcon = smb2_find_smb_sess_tcon_unlocked(ses, tid);
216 	if (!tcon) {
217 		cifs_put_smb_ses(ses);
218 		spin_unlock(&cifs_tcp_ses_lock);
219 		return NULL;
220 	}
221 	spin_unlock(&cifs_tcp_ses_lock);
222 	/* tcon already has a ref to ses, so we don't need ses anymore */
223 	cifs_put_smb_ses(ses);
224 
225 	return tcon;
226 }
227 
228 int
229 smb2_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,
230 			bool allocate_crypto)
231 {
232 	int rc;
233 	unsigned char smb2_signature[SMB2_HMACSHA256_SIZE];
234 	unsigned char *sigptr = smb2_signature;
235 	struct kvec *iov = rqst->rq_iov;
236 	struct smb2_hdr *shdr = (struct smb2_hdr *)iov[0].iov_base;
237 	struct cifs_ses *ses;
238 	struct shash_desc *shash = NULL;
239 	struct smb_rqst drqst;
240 
241 	ses = smb2_find_smb_ses(server, le64_to_cpu(shdr->SessionId));
242 	if (unlikely(!ses)) {
243 		cifs_server_dbg(VFS, "%s: Could not find session\n", __func__);
244 		return -ENOENT;
245 	}
246 
247 	memset(smb2_signature, 0x0, SMB2_HMACSHA256_SIZE);
248 	memset(shdr->Signature, 0x0, SMB2_SIGNATURE_SIZE);
249 
250 	if (allocate_crypto) {
251 		rc = cifs_alloc_hash("hmac(sha256)", &shash);
252 		if (rc) {
253 			cifs_server_dbg(VFS,
254 					"%s: sha256 alloc failed\n", __func__);
255 			goto out;
256 		}
257 	} else {
258 		shash = server->secmech.hmacsha256;
259 	}
260 
261 	rc = crypto_shash_setkey(shash->tfm, ses->auth_key.response,
262 			SMB2_NTLMV2_SESSKEY_SIZE);
263 	if (rc) {
264 		cifs_server_dbg(VFS,
265 				"%s: Could not update with response\n",
266 				__func__);
267 		goto out;
268 	}
269 
270 	rc = crypto_shash_init(shash);
271 	if (rc) {
272 		cifs_server_dbg(VFS, "%s: Could not init sha256", __func__);
273 		goto out;
274 	}
275 
276 	/*
277 	 * For SMB2+, __cifs_calc_signature() expects to sign only the actual
278 	 * data, that is, iov[0] should not contain a rfc1002 length.
279 	 *
280 	 * Sign the rfc1002 length prior to passing the data (iov[1-N]) down to
281 	 * __cifs_calc_signature().
282 	 */
283 	drqst = *rqst;
284 	if (drqst.rq_nvec >= 2 && iov[0].iov_len == 4) {
285 		rc = crypto_shash_update(shash, iov[0].iov_base,
286 					 iov[0].iov_len);
287 		if (rc) {
288 			cifs_server_dbg(VFS,
289 					"%s: Could not update with payload\n",
290 					__func__);
291 			goto out;
292 		}
293 		drqst.rq_iov++;
294 		drqst.rq_nvec--;
295 	}
296 
297 	rc = __cifs_calc_signature(&drqst, server, sigptr, shash);
298 	if (!rc)
299 		memcpy(shdr->Signature, sigptr, SMB2_SIGNATURE_SIZE);
300 
301 out:
302 	if (allocate_crypto)
303 		cifs_free_hash(&shash);
304 	if (ses)
305 		cifs_put_smb_ses(ses);
306 	return rc;
307 }
308 
309 static int generate_key(struct cifs_ses *ses, struct kvec label,
310 			struct kvec context, __u8 *key, unsigned int key_size)
311 {
312 	unsigned char zero = 0x0;
313 	__u8 i[4] = {0, 0, 0, 1};
314 	__u8 L128[4] = {0, 0, 0, 128};
315 	__u8 L256[4] = {0, 0, 1, 0};
316 	int rc = 0;
317 	unsigned char prfhash[SMB2_HMACSHA256_SIZE];
318 	unsigned char *hashptr = prfhash;
319 	struct TCP_Server_Info *server = ses->server;
320 
321 	memset(prfhash, 0x0, SMB2_HMACSHA256_SIZE);
322 	memset(key, 0x0, key_size);
323 
324 	rc = smb3_crypto_shash_allocate(server);
325 	if (rc) {
326 		cifs_server_dbg(VFS, "%s: crypto alloc failed\n", __func__);
327 		goto smb3signkey_ret;
328 	}
329 
330 	rc = crypto_shash_setkey(server->secmech.hmacsha256->tfm,
331 		ses->auth_key.response, SMB2_NTLMV2_SESSKEY_SIZE);
332 	if (rc) {
333 		cifs_server_dbg(VFS, "%s: Could not set with session key\n", __func__);
334 		goto smb3signkey_ret;
335 	}
336 
337 	rc = crypto_shash_init(server->secmech.hmacsha256);
338 	if (rc) {
339 		cifs_server_dbg(VFS, "%s: Could not init sign hmac\n", __func__);
340 		goto smb3signkey_ret;
341 	}
342 
343 	rc = crypto_shash_update(server->secmech.hmacsha256, i, 4);
344 	if (rc) {
345 		cifs_server_dbg(VFS, "%s: Could not update with n\n", __func__);
346 		goto smb3signkey_ret;
347 	}
348 
349 	rc = crypto_shash_update(server->secmech.hmacsha256, label.iov_base, label.iov_len);
350 	if (rc) {
351 		cifs_server_dbg(VFS, "%s: Could not update with label\n", __func__);
352 		goto smb3signkey_ret;
353 	}
354 
355 	rc = crypto_shash_update(server->secmech.hmacsha256, &zero, 1);
356 	if (rc) {
357 		cifs_server_dbg(VFS, "%s: Could not update with zero\n", __func__);
358 		goto smb3signkey_ret;
359 	}
360 
361 	rc = crypto_shash_update(server->secmech.hmacsha256, context.iov_base, context.iov_len);
362 	if (rc) {
363 		cifs_server_dbg(VFS, "%s: Could not update with context\n", __func__);
364 		goto smb3signkey_ret;
365 	}
366 
367 	if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
368 		(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)) {
369 		rc = crypto_shash_update(server->secmech.hmacsha256, L256, 4);
370 	} else {
371 		rc = crypto_shash_update(server->secmech.hmacsha256, L128, 4);
372 	}
373 	if (rc) {
374 		cifs_server_dbg(VFS, "%s: Could not update with L\n", __func__);
375 		goto smb3signkey_ret;
376 	}
377 
378 	rc = crypto_shash_final(server->secmech.hmacsha256, hashptr);
379 	if (rc) {
380 		cifs_server_dbg(VFS, "%s: Could not generate sha256 hash\n", __func__);
381 		goto smb3signkey_ret;
382 	}
383 
384 	memcpy(key, hashptr, key_size);
385 
386 smb3signkey_ret:
387 	return rc;
388 }
389 
390 struct derivation {
391 	struct kvec label;
392 	struct kvec context;
393 };
394 
395 struct derivation_triplet {
396 	struct derivation signing;
397 	struct derivation encryption;
398 	struct derivation decryption;
399 };
400 
401 static int
402 generate_smb3signingkey(struct cifs_ses *ses,
403 			struct TCP_Server_Info *server,
404 			const struct derivation_triplet *ptriplet)
405 {
406 	int rc;
407 	bool is_binding = false;
408 	int chan_index = 0;
409 
410 	spin_lock(&ses->ses_lock);
411 	spin_lock(&ses->chan_lock);
412 	is_binding = (cifs_chan_needs_reconnect(ses, server) &&
413 		      ses->ses_status == SES_GOOD);
414 
415 	chan_index = cifs_ses_get_chan_index(ses, server);
416 	/* TODO: introduce ref counting for channels when the can be freed */
417 	spin_unlock(&ses->chan_lock);
418 	spin_unlock(&ses->ses_lock);
419 
420 	/*
421 	 * All channels use the same encryption/decryption keys but
422 	 * they have their own signing key.
423 	 *
424 	 * When we generate the keys, check if it is for a new channel
425 	 * (binding) in which case we only need to generate a signing
426 	 * key and store it in the channel as to not overwrite the
427 	 * master connection signing key stored in the session
428 	 */
429 
430 	if (is_binding) {
431 		rc = generate_key(ses, ptriplet->signing.label,
432 				  ptriplet->signing.context,
433 				  ses->chans[chan_index].signkey,
434 				  SMB3_SIGN_KEY_SIZE);
435 		if (rc)
436 			return rc;
437 	} else {
438 		rc = generate_key(ses, ptriplet->signing.label,
439 				  ptriplet->signing.context,
440 				  ses->smb3signingkey,
441 				  SMB3_SIGN_KEY_SIZE);
442 		if (rc)
443 			return rc;
444 
445 		/* safe to access primary channel, since it will never go away */
446 		spin_lock(&ses->chan_lock);
447 		memcpy(ses->chans[chan_index].signkey, ses->smb3signingkey,
448 		       SMB3_SIGN_KEY_SIZE);
449 		spin_unlock(&ses->chan_lock);
450 
451 		rc = generate_key(ses, ptriplet->encryption.label,
452 				  ptriplet->encryption.context,
453 				  ses->smb3encryptionkey,
454 				  SMB3_ENC_DEC_KEY_SIZE);
455 		if (rc)
456 			return rc;
457 		rc = generate_key(ses, ptriplet->decryption.label,
458 				  ptriplet->decryption.context,
459 				  ses->smb3decryptionkey,
460 				  SMB3_ENC_DEC_KEY_SIZE);
461 		if (rc)
462 			return rc;
463 	}
464 
465 #ifdef CONFIG_CIFS_DEBUG_DUMP_KEYS
466 	cifs_dbg(VFS, "%s: dumping generated AES session keys\n", __func__);
467 	/*
468 	 * The session id is opaque in terms of endianness, so we can't
469 	 * print it as a long long. we dump it as we got it on the wire
470 	 */
471 	cifs_dbg(VFS, "Session Id    %*ph\n", (int)sizeof(ses->Suid),
472 			&ses->Suid);
473 	cifs_dbg(VFS, "Cipher type   %d\n", server->cipher_type);
474 	cifs_dbg(VFS, "Session Key   %*ph\n",
475 		 SMB2_NTLMV2_SESSKEY_SIZE, ses->auth_key.response);
476 	cifs_dbg(VFS, "Signing Key   %*ph\n",
477 		 SMB3_SIGN_KEY_SIZE, ses->smb3signingkey);
478 	if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
479 		(server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)) {
480 		cifs_dbg(VFS, "ServerIn Key  %*ph\n",
481 				SMB3_GCM256_CRYPTKEY_SIZE, ses->smb3encryptionkey);
482 		cifs_dbg(VFS, "ServerOut Key %*ph\n",
483 				SMB3_GCM256_CRYPTKEY_SIZE, ses->smb3decryptionkey);
484 	} else {
485 		cifs_dbg(VFS, "ServerIn Key  %*ph\n",
486 				SMB3_GCM128_CRYPTKEY_SIZE, ses->smb3encryptionkey);
487 		cifs_dbg(VFS, "ServerOut Key %*ph\n",
488 				SMB3_GCM128_CRYPTKEY_SIZE, ses->smb3decryptionkey);
489 	}
490 #endif
491 	return rc;
492 }
493 
494 int
495 generate_smb30signingkey(struct cifs_ses *ses,
496 			 struct TCP_Server_Info *server)
497 
498 {
499 	struct derivation_triplet triplet;
500 	struct derivation *d;
501 
502 	d = &triplet.signing;
503 	d->label.iov_base = "SMB2AESCMAC";
504 	d->label.iov_len = 12;
505 	d->context.iov_base = "SmbSign";
506 	d->context.iov_len = 8;
507 
508 	d = &triplet.encryption;
509 	d->label.iov_base = "SMB2AESCCM";
510 	d->label.iov_len = 11;
511 	d->context.iov_base = "ServerIn ";
512 	d->context.iov_len = 10;
513 
514 	d = &triplet.decryption;
515 	d->label.iov_base = "SMB2AESCCM";
516 	d->label.iov_len = 11;
517 	d->context.iov_base = "ServerOut";
518 	d->context.iov_len = 10;
519 
520 	return generate_smb3signingkey(ses, server, &triplet);
521 }
522 
523 int
524 generate_smb311signingkey(struct cifs_ses *ses,
525 			  struct TCP_Server_Info *server)
526 
527 {
528 	struct derivation_triplet triplet;
529 	struct derivation *d;
530 
531 	d = &triplet.signing;
532 	d->label.iov_base = "SMBSigningKey";
533 	d->label.iov_len = 14;
534 	d->context.iov_base = ses->preauth_sha_hash;
535 	d->context.iov_len = 64;
536 
537 	d = &triplet.encryption;
538 	d->label.iov_base = "SMBC2SCipherKey";
539 	d->label.iov_len = 16;
540 	d->context.iov_base = ses->preauth_sha_hash;
541 	d->context.iov_len = 64;
542 
543 	d = &triplet.decryption;
544 	d->label.iov_base = "SMBS2CCipherKey";
545 	d->label.iov_len = 16;
546 	d->context.iov_base = ses->preauth_sha_hash;
547 	d->context.iov_len = 64;
548 
549 	return generate_smb3signingkey(ses, server, &triplet);
550 }
551 
552 int
553 smb3_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,
554 			bool allocate_crypto)
555 {
556 	int rc;
557 	unsigned char smb3_signature[SMB2_CMACAES_SIZE];
558 	unsigned char *sigptr = smb3_signature;
559 	struct kvec *iov = rqst->rq_iov;
560 	struct smb2_hdr *shdr = (struct smb2_hdr *)iov[0].iov_base;
561 	struct shash_desc *shash = NULL;
562 	struct smb_rqst drqst;
563 	u8 key[SMB3_SIGN_KEY_SIZE];
564 
565 	rc = smb2_get_sign_key(le64_to_cpu(shdr->SessionId), server, key);
566 	if (unlikely(rc)) {
567 		cifs_server_dbg(FYI, "%s: Could not get signing key\n", __func__);
568 		return rc;
569 	}
570 
571 	if (allocate_crypto) {
572 		rc = cifs_alloc_hash("cmac(aes)", &shash);
573 		if (rc)
574 			return rc;
575 	} else {
576 		shash = server->secmech.aes_cmac;
577 	}
578 
579 	memset(smb3_signature, 0x0, SMB2_CMACAES_SIZE);
580 	memset(shdr->Signature, 0x0, SMB2_SIGNATURE_SIZE);
581 
582 	rc = crypto_shash_setkey(shash->tfm, key, SMB2_CMACAES_SIZE);
583 	if (rc) {
584 		cifs_server_dbg(VFS, "%s: Could not set key for cmac aes\n", __func__);
585 		goto out;
586 	}
587 
588 	/*
589 	 * we already allocate aes_cmac when we init smb3 signing key,
590 	 * so unlike smb2 case we do not have to check here if secmech are
591 	 * initialized
592 	 */
593 	rc = crypto_shash_init(shash);
594 	if (rc) {
595 		cifs_server_dbg(VFS, "%s: Could not init cmac aes\n", __func__);
596 		goto out;
597 	}
598 
599 	/*
600 	 * For SMB2+, __cifs_calc_signature() expects to sign only the actual
601 	 * data, that is, iov[0] should not contain a rfc1002 length.
602 	 *
603 	 * Sign the rfc1002 length prior to passing the data (iov[1-N]) down to
604 	 * __cifs_calc_signature().
605 	 */
606 	drqst = *rqst;
607 	if (drqst.rq_nvec >= 2 && iov[0].iov_len == 4) {
608 		rc = crypto_shash_update(shash, iov[0].iov_base,
609 					 iov[0].iov_len);
610 		if (rc) {
611 			cifs_server_dbg(VFS, "%s: Could not update with payload\n",
612 				 __func__);
613 			goto out;
614 		}
615 		drqst.rq_iov++;
616 		drqst.rq_nvec--;
617 	}
618 
619 	rc = __cifs_calc_signature(&drqst, server, sigptr, shash);
620 	if (!rc)
621 		memcpy(shdr->Signature, sigptr, SMB2_SIGNATURE_SIZE);
622 
623 out:
624 	if (allocate_crypto)
625 		cifs_free_hash(&shash);
626 	return rc;
627 }
628 
629 /* must be called with server->srv_mutex held */
630 static int
631 smb2_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server)
632 {
633 	int rc = 0;
634 	struct smb2_hdr *shdr;
635 	struct smb2_sess_setup_req *ssr;
636 	bool is_binding;
637 	bool is_signed;
638 
639 	shdr = (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
640 	ssr = (struct smb2_sess_setup_req *)shdr;
641 
642 	is_binding = shdr->Command == SMB2_SESSION_SETUP &&
643 		(ssr->Flags & SMB2_SESSION_REQ_FLAG_BINDING);
644 	is_signed = shdr->Flags & SMB2_FLAGS_SIGNED;
645 
646 	if (!is_signed)
647 		return 0;
648 	spin_lock(&server->srv_lock);
649 	if (server->ops->need_neg &&
650 	    server->ops->need_neg(server)) {
651 		spin_unlock(&server->srv_lock);
652 		return 0;
653 	}
654 	spin_unlock(&server->srv_lock);
655 	if (!is_binding && !server->session_estab) {
656 		strncpy(shdr->Signature, "BSRSPYL", 8);
657 		return 0;
658 	}
659 
660 	rc = server->ops->calc_signature(rqst, server, false);
661 
662 	return rc;
663 }
664 
665 int
666 smb2_verify_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server)
667 {
668 	unsigned int rc;
669 	char server_response_sig[SMB2_SIGNATURE_SIZE];
670 	struct smb2_hdr *shdr =
671 			(struct smb2_hdr *)rqst->rq_iov[0].iov_base;
672 
673 	if ((shdr->Command == SMB2_NEGOTIATE) ||
674 	    (shdr->Command == SMB2_SESSION_SETUP) ||
675 	    (shdr->Command == SMB2_OPLOCK_BREAK) ||
676 	    server->ignore_signature ||
677 	    (!server->session_estab))
678 		return 0;
679 
680 	/*
681 	 * BB what if signatures are supposed to be on for session but
682 	 * server does not send one? BB
683 	 */
684 
685 	/* Do not need to verify session setups with signature "BSRSPYL " */
686 	if (memcmp(shdr->Signature, "BSRSPYL ", 8) == 0)
687 		cifs_dbg(FYI, "dummy signature received for smb command 0x%x\n",
688 			 shdr->Command);
689 
690 	/*
691 	 * Save off the origiginal signature so we can modify the smb and check
692 	 * our calculated signature against what the server sent.
693 	 */
694 	memcpy(server_response_sig, shdr->Signature, SMB2_SIGNATURE_SIZE);
695 
696 	memset(shdr->Signature, 0, SMB2_SIGNATURE_SIZE);
697 
698 	rc = server->ops->calc_signature(rqst, server, true);
699 
700 	if (rc)
701 		return rc;
702 
703 	if (memcmp(server_response_sig, shdr->Signature, SMB2_SIGNATURE_SIZE)) {
704 		cifs_dbg(VFS, "sign fail cmd 0x%x message id 0x%llx\n",
705 			shdr->Command, shdr->MessageId);
706 		return -EACCES;
707 	} else
708 		return 0;
709 }
710 
711 /*
712  * Set message id for the request. Should be called after wait_for_free_request
713  * and when srv_mutex is held.
714  */
715 static inline void
716 smb2_seq_num_into_buf(struct TCP_Server_Info *server,
717 		      struct smb2_hdr *shdr)
718 {
719 	unsigned int i, num = le16_to_cpu(shdr->CreditCharge);
720 
721 	shdr->MessageId = get_next_mid64(server);
722 	/* skip message numbers according to CreditCharge field */
723 	for (i = 1; i < num; i++)
724 		get_next_mid(server);
725 }
726 
727 static struct mid_q_entry *
728 smb2_mid_entry_alloc(const struct smb2_hdr *shdr,
729 		     struct TCP_Server_Info *server)
730 {
731 	struct mid_q_entry *temp;
732 	unsigned int credits = le16_to_cpu(shdr->CreditCharge);
733 
734 	if (server == NULL) {
735 		cifs_dbg(VFS, "Null TCP session in smb2_mid_entry_alloc\n");
736 		return NULL;
737 	}
738 
739 	temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
740 	memset(temp, 0, sizeof(struct mid_q_entry));
741 	kref_init(&temp->refcount);
742 	temp->mid = le64_to_cpu(shdr->MessageId);
743 	temp->credits = credits > 0 ? credits : 1;
744 	temp->pid = current->pid;
745 	temp->command = shdr->Command; /* Always LE */
746 	temp->when_alloc = jiffies;
747 	temp->server = server;
748 
749 	/*
750 	 * The default is for the mid to be synchronous, so the
751 	 * default callback just wakes up the current task.
752 	 */
753 	get_task_struct(current);
754 	temp->creator = current;
755 	temp->callback = cifs_wake_up_task;
756 	temp->callback_data = current;
757 
758 	atomic_inc(&mid_count);
759 	temp->mid_state = MID_REQUEST_ALLOCATED;
760 	trace_smb3_cmd_enter(le32_to_cpu(shdr->Id.SyncId.TreeId),
761 			     le64_to_cpu(shdr->SessionId),
762 			     le16_to_cpu(shdr->Command), temp->mid);
763 	return temp;
764 }
765 
766 static int
767 smb2_get_mid_entry(struct cifs_ses *ses, struct TCP_Server_Info *server,
768 		   struct smb2_hdr *shdr, struct mid_q_entry **mid)
769 {
770 	spin_lock(&server->srv_lock);
771 	if (server->tcpStatus == CifsExiting) {
772 		spin_unlock(&server->srv_lock);
773 		return -ENOENT;
774 	}
775 
776 	if (server->tcpStatus == CifsNeedReconnect) {
777 		spin_unlock(&server->srv_lock);
778 		cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
779 		return -EAGAIN;
780 	}
781 
782 	if (server->tcpStatus == CifsNeedNegotiate &&
783 	   shdr->Command != SMB2_NEGOTIATE) {
784 		spin_unlock(&server->srv_lock);
785 		return -EAGAIN;
786 	}
787 	spin_unlock(&server->srv_lock);
788 
789 	spin_lock(&ses->ses_lock);
790 	if (ses->ses_status == SES_NEW) {
791 		if ((shdr->Command != SMB2_SESSION_SETUP) &&
792 		    (shdr->Command != SMB2_NEGOTIATE)) {
793 			spin_unlock(&ses->ses_lock);
794 			return -EAGAIN;
795 		}
796 		/* else ok - we are setting up session */
797 	}
798 
799 	if (ses->ses_status == SES_EXITING) {
800 		if (shdr->Command != SMB2_LOGOFF) {
801 			spin_unlock(&ses->ses_lock);
802 			return -EAGAIN;
803 		}
804 		/* else ok - we are shutting down the session */
805 	}
806 	spin_unlock(&ses->ses_lock);
807 
808 	*mid = smb2_mid_entry_alloc(shdr, server);
809 	if (*mid == NULL)
810 		return -ENOMEM;
811 	spin_lock(&server->mid_lock);
812 	list_add_tail(&(*mid)->qhead, &server->pending_mid_q);
813 	spin_unlock(&server->mid_lock);
814 
815 	return 0;
816 }
817 
818 int
819 smb2_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
820 		   bool log_error)
821 {
822 	unsigned int len = mid->resp_buf_size;
823 	struct kvec iov[1];
824 	struct smb_rqst rqst = { .rq_iov = iov,
825 				 .rq_nvec = 1 };
826 
827 	iov[0].iov_base = (char *)mid->resp_buf;
828 	iov[0].iov_len = len;
829 
830 	dump_smb(mid->resp_buf, min_t(u32, 80, len));
831 	/* convert the length into a more usable form */
832 	if (len > 24 && server->sign && !mid->decrypted) {
833 		int rc;
834 
835 		rc = smb2_verify_signature(&rqst, server);
836 		if (rc)
837 			cifs_server_dbg(VFS, "SMB signature verification returned error = %d\n",
838 				 rc);
839 	}
840 
841 	return map_smb2_to_linux_error(mid->resp_buf, log_error);
842 }
843 
844 struct mid_q_entry *
845 smb2_setup_request(struct cifs_ses *ses, struct TCP_Server_Info *server,
846 		   struct smb_rqst *rqst)
847 {
848 	int rc;
849 	struct smb2_hdr *shdr =
850 			(struct smb2_hdr *)rqst->rq_iov[0].iov_base;
851 	struct mid_q_entry *mid;
852 
853 	smb2_seq_num_into_buf(server, shdr);
854 
855 	rc = smb2_get_mid_entry(ses, server, shdr, &mid);
856 	if (rc) {
857 		revert_current_mid_from_hdr(server, shdr);
858 		return ERR_PTR(rc);
859 	}
860 
861 	rc = smb2_sign_rqst(rqst, server);
862 	if (rc) {
863 		revert_current_mid_from_hdr(server, shdr);
864 		delete_mid(mid);
865 		return ERR_PTR(rc);
866 	}
867 
868 	return mid;
869 }
870 
871 struct mid_q_entry *
872 smb2_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
873 {
874 	int rc;
875 	struct smb2_hdr *shdr =
876 			(struct smb2_hdr *)rqst->rq_iov[0].iov_base;
877 	struct mid_q_entry *mid;
878 
879 	spin_lock(&server->srv_lock);
880 	if (server->tcpStatus == CifsNeedNegotiate &&
881 	   shdr->Command != SMB2_NEGOTIATE) {
882 		spin_unlock(&server->srv_lock);
883 		return ERR_PTR(-EAGAIN);
884 	}
885 	spin_unlock(&server->srv_lock);
886 
887 	smb2_seq_num_into_buf(server, shdr);
888 
889 	mid = smb2_mid_entry_alloc(shdr, server);
890 	if (mid == NULL) {
891 		revert_current_mid_from_hdr(server, shdr);
892 		return ERR_PTR(-ENOMEM);
893 	}
894 
895 	rc = smb2_sign_rqst(rqst, server);
896 	if (rc) {
897 		revert_current_mid_from_hdr(server, shdr);
898 		release_mid(mid);
899 		return ERR_PTR(rc);
900 	}
901 
902 	return mid;
903 }
904 
905 int
906 smb3_crypto_aead_allocate(struct TCP_Server_Info *server)
907 {
908 	struct crypto_aead *tfm;
909 
910 	if (!server->secmech.enc) {
911 		if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
912 		    (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
913 			tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
914 		else
915 			tfm = crypto_alloc_aead("ccm(aes)", 0, 0);
916 		if (IS_ERR(tfm)) {
917 			cifs_server_dbg(VFS, "%s: Failed alloc encrypt aead\n",
918 				 __func__);
919 			return PTR_ERR(tfm);
920 		}
921 		server->secmech.enc = tfm;
922 	}
923 
924 	if (!server->secmech.dec) {
925 		if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
926 		    (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
927 			tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
928 		else
929 			tfm = crypto_alloc_aead("ccm(aes)", 0, 0);
930 		if (IS_ERR(tfm)) {
931 			crypto_free_aead(server->secmech.enc);
932 			server->secmech.enc = NULL;
933 			cifs_server_dbg(VFS, "%s: Failed to alloc decrypt aead\n",
934 				 __func__);
935 			return PTR_ERR(tfm);
936 		}
937 		server->secmech.dec = tfm;
938 	}
939 
940 	return 0;
941 }
942