2 * fs/cifs/smb2transport.c
4 * Copyright (C) International Business Machines Corp., 2002, 2011
6 * Author(s): Steve French (sfrench@us.ibm.com)
7 * Jeremy Allison (jra@samba.org) 2006
8 * Pavel Shilovsky (pshilovsky@samba.org) 2012
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/list.h>
27 #include <linux/wait.h>
28 #include <linux/net.h>
29 #include <linux/delay.h>
30 #include <linux/uaccess.h>
31 #include <asm/processor.h>
32 #include <linux/mempool.h>
33 #include <linux/highmem.h>
34 #include <crypto/aead.h>
37 #include "cifsproto.h"
38 #include "smb2proto.h"
39 #include "cifs_debug.h"
40 #include "smb2status.h"
44 smb2_crypto_shash_allocate(struct TCP_Server_Info
*server
)
49 if (server
->secmech
.sdeschmacsha256
!= NULL
)
50 return 0; /* already allocated */
52 server
->secmech
.hmacsha256
= crypto_alloc_shash("hmac(sha256)", 0, 0);
53 if (IS_ERR(server
->secmech
.hmacsha256
)) {
54 cifs_dbg(VFS
, "could not allocate crypto hmacsha256\n");
55 rc
= PTR_ERR(server
->secmech
.hmacsha256
);
56 server
->secmech
.hmacsha256
= NULL
;
60 size
= sizeof(struct shash_desc
) +
61 crypto_shash_descsize(server
->secmech
.hmacsha256
);
62 server
->secmech
.sdeschmacsha256
= kmalloc(size
, GFP_KERNEL
);
63 if (!server
->secmech
.sdeschmacsha256
) {
64 crypto_free_shash(server
->secmech
.hmacsha256
);
65 server
->secmech
.hmacsha256
= NULL
;
68 server
->secmech
.sdeschmacsha256
->shash
.tfm
= server
->secmech
.hmacsha256
;
69 server
->secmech
.sdeschmacsha256
->shash
.flags
= 0x0;
75 smb3_crypto_shash_allocate(struct TCP_Server_Info
*server
)
80 if (server
->secmech
.sdesccmacaes
!= NULL
)
81 return 0; /* already allocated */
83 rc
= smb2_crypto_shash_allocate(server
);
87 server
->secmech
.cmacaes
= crypto_alloc_shash("cmac(aes)", 0, 0);
88 if (IS_ERR(server
->secmech
.cmacaes
)) {
89 cifs_dbg(VFS
, "could not allocate crypto cmac-aes");
90 kfree(server
->secmech
.sdeschmacsha256
);
91 server
->secmech
.sdeschmacsha256
= NULL
;
92 crypto_free_shash(server
->secmech
.hmacsha256
);
93 server
->secmech
.hmacsha256
= NULL
;
94 rc
= PTR_ERR(server
->secmech
.cmacaes
);
95 server
->secmech
.cmacaes
= NULL
;
99 size
= sizeof(struct shash_desc
) +
100 crypto_shash_descsize(server
->secmech
.cmacaes
);
101 server
->secmech
.sdesccmacaes
= kmalloc(size
, GFP_KERNEL
);
102 if (!server
->secmech
.sdesccmacaes
) {
103 cifs_dbg(VFS
, "%s: Can't alloc cmacaes\n", __func__
);
104 kfree(server
->secmech
.sdeschmacsha256
);
105 server
->secmech
.sdeschmacsha256
= NULL
;
106 crypto_free_shash(server
->secmech
.hmacsha256
);
107 crypto_free_shash(server
->secmech
.cmacaes
);
108 server
->secmech
.hmacsha256
= NULL
;
109 server
->secmech
.cmacaes
= NULL
;
112 server
->secmech
.sdesccmacaes
->shash
.tfm
= server
->secmech
.cmacaes
;
113 server
->secmech
.sdesccmacaes
->shash
.flags
= 0x0;
119 smb2_find_smb_ses(struct TCP_Server_Info
*server
, __u64 ses_id
)
121 struct cifs_ses
*ses
;
123 spin_lock(&cifs_tcp_ses_lock
);
124 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
125 if (ses
->Suid
!= ses_id
)
127 spin_unlock(&cifs_tcp_ses_lock
);
130 spin_unlock(&cifs_tcp_ses_lock
);
136 smb2_calc_signature(struct smb_rqst
*rqst
, struct TCP_Server_Info
*server
)
139 unsigned char smb2_signature
[SMB2_HMACSHA256_SIZE
];
140 unsigned char *sigptr
= smb2_signature
;
141 struct kvec
*iov
= rqst
->rq_iov
;
142 struct smb2_sync_hdr
*shdr
= (struct smb2_sync_hdr
*)iov
[1].iov_base
;
143 struct cifs_ses
*ses
;
145 ses
= smb2_find_smb_ses(server
, shdr
->SessionId
);
147 cifs_dbg(VFS
, "%s: Could not find session\n", __func__
);
151 memset(smb2_signature
, 0x0, SMB2_HMACSHA256_SIZE
);
152 memset(shdr
->Signature
, 0x0, SMB2_SIGNATURE_SIZE
);
154 rc
= smb2_crypto_shash_allocate(server
);
156 cifs_dbg(VFS
, "%s: shah256 alloc failed\n", __func__
);
160 rc
= crypto_shash_setkey(server
->secmech
.hmacsha256
,
161 ses
->auth_key
.response
, SMB2_NTLMV2_SESSKEY_SIZE
);
163 cifs_dbg(VFS
, "%s: Could not update with response\n", __func__
);
167 rc
= crypto_shash_init(&server
->secmech
.sdeschmacsha256
->shash
);
169 cifs_dbg(VFS
, "%s: Could not init sha256", __func__
);
173 rc
= __cifs_calc_signature(rqst
, server
, sigptr
,
174 &server
->secmech
.sdeschmacsha256
->shash
);
177 memcpy(shdr
->Signature
, sigptr
, SMB2_SIGNATURE_SIZE
);
182 static int generate_key(struct cifs_ses
*ses
, struct kvec label
,
183 struct kvec context
, __u8
*key
, unsigned int key_size
)
185 unsigned char zero
= 0x0;
186 __u8 i
[4] = {0, 0, 0, 1};
187 __u8 L
[4] = {0, 0, 0, 128};
189 unsigned char prfhash
[SMB2_HMACSHA256_SIZE
];
190 unsigned char *hashptr
= prfhash
;
192 memset(prfhash
, 0x0, SMB2_HMACSHA256_SIZE
);
193 memset(key
, 0x0, key_size
);
195 rc
= smb3_crypto_shash_allocate(ses
->server
);
197 cifs_dbg(VFS
, "%s: crypto alloc failed\n", __func__
);
198 goto smb3signkey_ret
;
201 rc
= crypto_shash_setkey(ses
->server
->secmech
.hmacsha256
,
202 ses
->auth_key
.response
, SMB2_NTLMV2_SESSKEY_SIZE
);
204 cifs_dbg(VFS
, "%s: Could not set with session key\n", __func__
);
205 goto smb3signkey_ret
;
208 rc
= crypto_shash_init(&ses
->server
->secmech
.sdeschmacsha256
->shash
);
210 cifs_dbg(VFS
, "%s: Could not init sign hmac\n", __func__
);
211 goto smb3signkey_ret
;
214 rc
= crypto_shash_update(&ses
->server
->secmech
.sdeschmacsha256
->shash
,
217 cifs_dbg(VFS
, "%s: Could not update with n\n", __func__
);
218 goto smb3signkey_ret
;
221 rc
= crypto_shash_update(&ses
->server
->secmech
.sdeschmacsha256
->shash
,
222 label
.iov_base
, label
.iov_len
);
224 cifs_dbg(VFS
, "%s: Could not update with label\n", __func__
);
225 goto smb3signkey_ret
;
228 rc
= crypto_shash_update(&ses
->server
->secmech
.sdeschmacsha256
->shash
,
231 cifs_dbg(VFS
, "%s: Could not update with zero\n", __func__
);
232 goto smb3signkey_ret
;
235 rc
= crypto_shash_update(&ses
->server
->secmech
.sdeschmacsha256
->shash
,
236 context
.iov_base
, context
.iov_len
);
238 cifs_dbg(VFS
, "%s: Could not update with context\n", __func__
);
239 goto smb3signkey_ret
;
242 rc
= crypto_shash_update(&ses
->server
->secmech
.sdeschmacsha256
->shash
,
245 cifs_dbg(VFS
, "%s: Could not update with L\n", __func__
);
246 goto smb3signkey_ret
;
249 rc
= crypto_shash_final(&ses
->server
->secmech
.sdeschmacsha256
->shash
,
252 cifs_dbg(VFS
, "%s: Could not generate sha256 hash\n", __func__
);
253 goto smb3signkey_ret
;
256 memcpy(key
, hashptr
, key_size
);
267 struct derivation_triplet
{
268 struct derivation signing
;
269 struct derivation encryption
;
270 struct derivation decryption
;
274 generate_smb3signingkey(struct cifs_ses
*ses
,
275 const struct derivation_triplet
*ptriplet
)
279 rc
= generate_key(ses
, ptriplet
->signing
.label
,
280 ptriplet
->signing
.context
, ses
->smb3signingkey
,
285 rc
= generate_key(ses
, ptriplet
->encryption
.label
,
286 ptriplet
->encryption
.context
, ses
->smb3encryptionkey
,
291 return generate_key(ses
, ptriplet
->decryption
.label
,
292 ptriplet
->decryption
.context
,
293 ses
->smb3decryptionkey
, SMB3_SIGN_KEY_SIZE
);
297 generate_smb30signingkey(struct cifs_ses
*ses
)
300 struct derivation_triplet triplet
;
301 struct derivation
*d
;
303 d
= &triplet
.signing
;
304 d
->label
.iov_base
= "SMB2AESCMAC";
305 d
->label
.iov_len
= 12;
306 d
->context
.iov_base
= "SmbSign";
307 d
->context
.iov_len
= 8;
309 d
= &triplet
.encryption
;
310 d
->label
.iov_base
= "SMB2AESCCM";
311 d
->label
.iov_len
= 11;
312 d
->context
.iov_base
= "ServerIn ";
313 d
->context
.iov_len
= 10;
315 d
= &triplet
.decryption
;
316 d
->label
.iov_base
= "SMB2AESCCM";
317 d
->label
.iov_len
= 11;
318 d
->context
.iov_base
= "ServerOut";
319 d
->context
.iov_len
= 10;
321 return generate_smb3signingkey(ses
, &triplet
);
325 generate_smb311signingkey(struct cifs_ses
*ses
)
328 struct derivation_triplet triplet
;
329 struct derivation
*d
;
331 d
= &triplet
.signing
;
332 d
->label
.iov_base
= "SMB2AESCMAC";
333 d
->label
.iov_len
= 12;
334 d
->context
.iov_base
= "SmbSign";
335 d
->context
.iov_len
= 8;
337 d
= &triplet
.encryption
;
338 d
->label
.iov_base
= "SMB2AESCCM";
339 d
->label
.iov_len
= 11;
340 d
->context
.iov_base
= "ServerIn ";
341 d
->context
.iov_len
= 10;
343 d
= &triplet
.decryption
;
344 d
->label
.iov_base
= "SMB2AESCCM";
345 d
->label
.iov_len
= 11;
346 d
->context
.iov_base
= "ServerOut";
347 d
->context
.iov_len
= 10;
349 return generate_smb3signingkey(ses
, &triplet
);
353 smb3_calc_signature(struct smb_rqst
*rqst
, struct TCP_Server_Info
*server
)
356 unsigned char smb3_signature
[SMB2_CMACAES_SIZE
];
357 unsigned char *sigptr
= smb3_signature
;
358 struct kvec
*iov
= rqst
->rq_iov
;
359 struct smb2_sync_hdr
*shdr
= (struct smb2_sync_hdr
*)iov
[1].iov_base
;
360 struct cifs_ses
*ses
;
362 ses
= smb2_find_smb_ses(server
, shdr
->SessionId
);
364 cifs_dbg(VFS
, "%s: Could not find session\n", __func__
);
368 memset(smb3_signature
, 0x0, SMB2_CMACAES_SIZE
);
369 memset(shdr
->Signature
, 0x0, SMB2_SIGNATURE_SIZE
);
371 rc
= crypto_shash_setkey(server
->secmech
.cmacaes
,
372 ses
->smb3signingkey
, SMB2_CMACAES_SIZE
);
375 cifs_dbg(VFS
, "%s: Could not set key for cmac aes\n", __func__
);
380 * we already allocate sdesccmacaes when we init smb3 signing key,
381 * so unlike smb2 case we do not have to check here if secmech are
384 rc
= crypto_shash_init(&server
->secmech
.sdesccmacaes
->shash
);
386 cifs_dbg(VFS
, "%s: Could not init cmac aes\n", __func__
);
390 rc
= __cifs_calc_signature(rqst
, server
, sigptr
,
391 &server
->secmech
.sdesccmacaes
->shash
);
394 memcpy(shdr
->Signature
, sigptr
, SMB2_SIGNATURE_SIZE
);
399 /* must be called with server->srv_mutex held */
401 smb2_sign_rqst(struct smb_rqst
*rqst
, struct TCP_Server_Info
*server
)
404 struct smb2_sync_hdr
*shdr
=
405 (struct smb2_sync_hdr
*)rqst
->rq_iov
[1].iov_base
;
407 if (!(shdr
->Flags
& SMB2_FLAGS_SIGNED
) ||
408 server
->tcpStatus
== CifsNeedNegotiate
)
411 if (!server
->session_estab
) {
412 strncpy(shdr
->Signature
, "BSRSPYL", 8);
416 rc
= server
->ops
->calc_signature(rqst
, server
);
422 smb2_verify_signature(struct smb_rqst
*rqst
, struct TCP_Server_Info
*server
)
425 char server_response_sig
[16];
426 struct smb2_sync_hdr
*shdr
=
427 (struct smb2_sync_hdr
*)rqst
->rq_iov
[1].iov_base
;
429 if ((shdr
->Command
== SMB2_NEGOTIATE
) ||
430 (shdr
->Command
== SMB2_SESSION_SETUP
) ||
431 (shdr
->Command
== SMB2_OPLOCK_BREAK
) ||
432 (!server
->session_estab
))
436 * BB what if signatures are supposed to be on for session but
437 * server does not send one? BB
440 /* Do not need to verify session setups with signature "BSRSPYL " */
441 if (memcmp(shdr
->Signature
, "BSRSPYL ", 8) == 0)
442 cifs_dbg(FYI
, "dummy signature received for smb command 0x%x\n",
446 * Save off the origiginal signature so we can modify the smb and check
447 * our calculated signature against what the server sent.
449 memcpy(server_response_sig
, shdr
->Signature
, SMB2_SIGNATURE_SIZE
);
451 memset(shdr
->Signature
, 0, SMB2_SIGNATURE_SIZE
);
453 mutex_lock(&server
->srv_mutex
);
454 rc
= server
->ops
->calc_signature(rqst
, server
);
455 mutex_unlock(&server
->srv_mutex
);
460 if (memcmp(server_response_sig
, shdr
->Signature
, SMB2_SIGNATURE_SIZE
))
467 * Set message id for the request. Should be called after wait_for_free_request
468 * and when srv_mutex is held.
471 smb2_seq_num_into_buf(struct TCP_Server_Info
*server
,
472 struct smb2_sync_hdr
*shdr
)
474 unsigned int i
, num
= le16_to_cpu(shdr
->CreditCharge
);
476 shdr
->MessageId
= get_next_mid64(server
);
477 /* skip message numbers according to CreditCharge field */
478 for (i
= 1; i
< num
; i
++)
479 get_next_mid(server
);
482 static struct mid_q_entry
*
483 smb2_mid_entry_alloc(const struct smb2_sync_hdr
*shdr
,
484 struct TCP_Server_Info
*server
)
486 struct mid_q_entry
*temp
;
488 if (server
== NULL
) {
489 cifs_dbg(VFS
, "Null TCP session in smb2_mid_entry_alloc\n");
493 temp
= mempool_alloc(cifs_mid_poolp
, GFP_NOFS
);
497 memset(temp
, 0, sizeof(struct mid_q_entry
));
498 temp
->mid
= le64_to_cpu(shdr
->MessageId
);
499 temp
->pid
= current
->pid
;
500 temp
->command
= shdr
->Command
; /* Always LE */
501 temp
->when_alloc
= jiffies
;
502 temp
->server
= server
;
505 * The default is for the mid to be synchronous, so the
506 * default callback just wakes up the current task.
508 temp
->callback
= cifs_wake_up_task
;
509 temp
->callback_data
= current
;
512 atomic_inc(&midCount
);
513 temp
->mid_state
= MID_REQUEST_ALLOCATED
;
518 smb2_get_mid_entry(struct cifs_ses
*ses
, struct smb2_sync_hdr
*shdr
,
519 struct mid_q_entry
**mid
)
521 if (ses
->server
->tcpStatus
== CifsExiting
)
524 if (ses
->server
->tcpStatus
== CifsNeedReconnect
) {
525 cifs_dbg(FYI
, "tcp session dead - return to caller to retry\n");
529 if (ses
->status
== CifsNew
) {
530 if ((shdr
->Command
!= SMB2_SESSION_SETUP
) &&
531 (shdr
->Command
!= SMB2_NEGOTIATE
))
533 /* else ok - we are setting up session */
536 if (ses
->status
== CifsExiting
) {
537 if (shdr
->Command
!= SMB2_LOGOFF
)
539 /* else ok - we are shutting down the session */
542 *mid
= smb2_mid_entry_alloc(shdr
, ses
->server
);
545 spin_lock(&GlobalMid_Lock
);
546 list_add_tail(&(*mid
)->qhead
, &ses
->server
->pending_mid_q
);
547 spin_unlock(&GlobalMid_Lock
);
552 smb2_check_receive(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
555 unsigned int len
= get_rfc1002_length(mid
->resp_buf
);
557 struct smb_rqst rqst
= { .rq_iov
= iov
,
560 iov
[0].iov_base
= (char *)mid
->resp_buf
;
562 iov
[1].iov_base
= (char *)mid
->resp_buf
+ 4;
563 iov
[1].iov_len
= len
;
565 dump_smb(mid
->resp_buf
, min_t(u32
, 80, len
));
566 /* convert the length into a more usable form */
567 if (len
> 24 && server
->sign
&& !mid
->decrypted
) {
570 rc
= smb2_verify_signature(&rqst
, server
);
572 cifs_dbg(VFS
, "SMB signature verification returned error = %d\n",
576 return map_smb2_to_linux_error(mid
->resp_buf
, log_error
);
580 smb2_setup_request(struct cifs_ses
*ses
, struct smb_rqst
*rqst
)
583 struct smb2_sync_hdr
*shdr
=
584 (struct smb2_sync_hdr
*)rqst
->rq_iov
[1].iov_base
;
585 struct mid_q_entry
*mid
;
587 smb2_seq_num_into_buf(ses
->server
, shdr
);
589 rc
= smb2_get_mid_entry(ses
, shdr
, &mid
);
592 rc
= smb2_sign_rqst(rqst
, ses
->server
);
594 cifs_delete_mid(mid
);
601 smb2_setup_async_request(struct TCP_Server_Info
*server
, struct smb_rqst
*rqst
)
604 struct smb2_sync_hdr
*shdr
=
605 (struct smb2_sync_hdr
*)rqst
->rq_iov
[1].iov_base
;
606 struct mid_q_entry
*mid
;
608 smb2_seq_num_into_buf(server
, shdr
);
610 mid
= smb2_mid_entry_alloc(shdr
, server
);
612 return ERR_PTR(-ENOMEM
);
614 rc
= smb2_sign_rqst(rqst
, server
);
616 DeleteMidQEntry(mid
);
624 smb3_crypto_aead_allocate(struct TCP_Server_Info
*server
)
626 struct crypto_aead
*tfm
;
628 if (!server
->secmech
.ccmaesencrypt
) {
629 tfm
= crypto_alloc_aead("ccm(aes)", 0, 0);
631 cifs_dbg(VFS
, "%s: Failed to alloc encrypt aead\n",
635 server
->secmech
.ccmaesencrypt
= tfm
;
638 if (!server
->secmech
.ccmaesdecrypt
) {
639 tfm
= crypto_alloc_aead("ccm(aes)", 0, 0);
641 crypto_free_aead(server
->secmech
.ccmaesencrypt
);
642 server
->secmech
.ccmaesencrypt
= NULL
;
643 cifs_dbg(VFS
, "%s: Failed to alloc decrypt aead\n",
647 server
->secmech
.ccmaesdecrypt
= tfm
;