1 /*
2 * fs/cifs/cifsencrypt.c
3 *
4 * Encryption and hashing operations relating to NTLM, NTLMv2. See MS-NLMP
5 * for more detailed information
6 *
7 * Copyright (C) International Business Machines Corp., 2005,2013
8 * Author(s): Steve French (sfrench@us.ibm.com)
9 *
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.
14 *
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.
19 *
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
23 */
24
25 #include <linux/fs.h>
26 #include <linux/slab.h>
27 #include "cifspdu.h"
28 #include "cifsglob.h"
29 #include "cifs_debug.h"
30 #include "cifs_unicode.h"
31 #include "cifsproto.h"
32 #include "ntlmssp.h"
33 #include <linux/ctype.h>
34 #include <linux/random.h>
35 #include <linux/highmem.h>
36 #include <crypto/skcipher.h>
37 #include <crypto/aead.h>
38
__cifs_calc_signature(struct smb_rqst * rqst,struct TCP_Server_Info * server,char * signature,struct shash_desc * shash)39 int __cifs_calc_signature(struct smb_rqst *rqst,
40 struct TCP_Server_Info *server, char *signature,
41 struct shash_desc *shash)
42 {
43 int i;
44 int rc;
45 struct kvec *iov = rqst->rq_iov;
46 int n_vec = rqst->rq_nvec;
47 int is_smb2 = server->vals->header_preamble_size == 0;
48
49 /* iov[0] is actual data and not the rfc1002 length for SMB2+ */
50 if (is_smb2) {
51 if (iov[0].iov_len <= 4)
52 return -EIO;
53 i = 0;
54 } else {
55 if (n_vec < 2 || iov[0].iov_len != 4)
56 return -EIO;
57 i = 1; /* skip rfc1002 length */
58 }
59
60 for (; i < n_vec; i++) {
61 if (iov[i].iov_len == 0)
62 continue;
63 if (iov[i].iov_base == NULL) {
64 cifs_dbg(VFS, "null iovec entry\n");
65 return -EIO;
66 }
67
68 rc = crypto_shash_update(shash,
69 iov[i].iov_base, iov[i].iov_len);
70 if (rc) {
71 cifs_dbg(VFS, "%s: Could not update with payload\n",
72 __func__);
73 return rc;
74 }
75 }
76
77 /* now hash over the rq_pages array */
78 for (i = 0; i < rqst->rq_npages; i++) {
79 void *kaddr;
80 unsigned int len, offset;
81
82 rqst_page_get_length(rqst, i, &len, &offset);
83
84 kaddr = (char *) kmap(rqst->rq_pages[i]) + offset;
85
86 rc = crypto_shash_update(shash, kaddr, len);
87 if (rc) {
88 cifs_dbg(VFS, "%s: Could not update with payload\n",
89 __func__);
90 kunmap(rqst->rq_pages[i]);
91 return rc;
92 }
93
94 kunmap(rqst->rq_pages[i]);
95 }
96
97 rc = crypto_shash_final(shash, signature);
98 if (rc)
99 cifs_dbg(VFS, "%s: Could not generate hash\n", __func__);
100
101 return rc;
102 }
103
104 /*
105 * Calculate and return the CIFS signature based on the mac key and SMB PDU.
106 * The 16 byte signature must be allocated by the caller. Note we only use the
107 * 1st eight bytes and that the smb header signature field on input contains
108 * the sequence number before this function is called. Also, this function
109 * should be called with the server->srv_mutex held.
110 */
cifs_calc_signature(struct smb_rqst * rqst,struct TCP_Server_Info * server,char * signature)111 static int cifs_calc_signature(struct smb_rqst *rqst,
112 struct TCP_Server_Info *server, char *signature)
113 {
114 int rc;
115
116 if (!rqst->rq_iov || !signature || !server)
117 return -EINVAL;
118
119 rc = cifs_alloc_hash("md5", &server->secmech.md5,
120 &server->secmech.sdescmd5);
121 if (rc)
122 return -1;
123
124 rc = crypto_shash_init(&server->secmech.sdescmd5->shash);
125 if (rc) {
126 cifs_dbg(VFS, "%s: Could not init md5\n", __func__);
127 return rc;
128 }
129
130 rc = crypto_shash_update(&server->secmech.sdescmd5->shash,
131 server->session_key.response, server->session_key.len);
132 if (rc) {
133 cifs_dbg(VFS, "%s: Could not update with response\n", __func__);
134 return rc;
135 }
136
137 return __cifs_calc_signature(rqst, server, signature,
138 &server->secmech.sdescmd5->shash);
139 }
140
141 /* must be called with server->srv_mutex held */
cifs_sign_rqst(struct smb_rqst * rqst,struct TCP_Server_Info * server,__u32 * pexpected_response_sequence_number)142 int cifs_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server,
143 __u32 *pexpected_response_sequence_number)
144 {
145 int rc = 0;
146 char smb_signature[20];
147 struct smb_hdr *cifs_pdu = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
148
149 if (rqst->rq_iov[0].iov_len != 4 ||
150 rqst->rq_iov[0].iov_base + 4 != rqst->rq_iov[1].iov_base)
151 return -EIO;
152
153 if ((cifs_pdu == NULL) || (server == NULL))
154 return -EINVAL;
155
156 if (!(cifs_pdu->Flags2 & SMBFLG2_SECURITY_SIGNATURE) ||
157 server->tcpStatus == CifsNeedNegotiate)
158 return rc;
159
160 if (!server->session_estab) {
161 memcpy(cifs_pdu->Signature.SecuritySignature, "BSRSPYL", 8);
162 return rc;
163 }
164
165 cifs_pdu->Signature.Sequence.SequenceNumber =
166 cpu_to_le32(server->sequence_number);
167 cifs_pdu->Signature.Sequence.Reserved = 0;
168
169 *pexpected_response_sequence_number = ++server->sequence_number;
170 ++server->sequence_number;
171
172 rc = cifs_calc_signature(rqst, server, smb_signature);
173 if (rc)
174 memset(cifs_pdu->Signature.SecuritySignature, 0, 8);
175 else
176 memcpy(cifs_pdu->Signature.SecuritySignature, smb_signature, 8);
177
178 return rc;
179 }
180
cifs_sign_smbv(struct kvec * iov,int n_vec,struct TCP_Server_Info * server,__u32 * pexpected_response_sequence)181 int cifs_sign_smbv(struct kvec *iov, int n_vec, struct TCP_Server_Info *server,
182 __u32 *pexpected_response_sequence)
183 {
184 struct smb_rqst rqst = { .rq_iov = iov,
185 .rq_nvec = n_vec };
186
187 return cifs_sign_rqst(&rqst, server, pexpected_response_sequence);
188 }
189
190 /* must be called with server->srv_mutex held */
cifs_sign_smb(struct smb_hdr * cifs_pdu,struct TCP_Server_Info * server,__u32 * pexpected_response_sequence_number)191 int cifs_sign_smb(struct smb_hdr *cifs_pdu, struct TCP_Server_Info *server,
192 __u32 *pexpected_response_sequence_number)
193 {
194 struct kvec iov[2];
195
196 iov[0].iov_base = cifs_pdu;
197 iov[0].iov_len = 4;
198 iov[1].iov_base = (char *)cifs_pdu + 4;
199 iov[1].iov_len = be32_to_cpu(cifs_pdu->smb_buf_length);
200
201 return cifs_sign_smbv(iov, 2, server,
202 pexpected_response_sequence_number);
203 }
204
cifs_verify_signature(struct smb_rqst * rqst,struct TCP_Server_Info * server,__u32 expected_sequence_number)205 int cifs_verify_signature(struct smb_rqst *rqst,
206 struct TCP_Server_Info *server,
207 __u32 expected_sequence_number)
208 {
209 unsigned int rc;
210 char server_response_sig[8];
211 char what_we_think_sig_should_be[20];
212 struct smb_hdr *cifs_pdu = (struct smb_hdr *)rqst->rq_iov[0].iov_base;
213
214 if (rqst->rq_iov[0].iov_len != 4 ||
215 rqst->rq_iov[0].iov_base + 4 != rqst->rq_iov[1].iov_base)
216 return -EIO;
217
218 if (cifs_pdu == NULL || server == NULL)
219 return -EINVAL;
220
221 if (!server->session_estab)
222 return 0;
223
224 if (cifs_pdu->Command == SMB_COM_LOCKING_ANDX) {
225 struct smb_com_lock_req *pSMB =
226 (struct smb_com_lock_req *)cifs_pdu;
227 if (pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE)
228 return 0;
229 }
230
231 /* BB what if signatures are supposed to be on for session but
232 server does not send one? BB */
233
234 /* Do not need to verify session setups with signature "BSRSPYL " */
235 if (memcmp(cifs_pdu->Signature.SecuritySignature, "BSRSPYL ", 8) == 0)
236 cifs_dbg(FYI, "dummy signature received for smb command 0x%x\n",
237 cifs_pdu->Command);
238
239 /* save off the origiginal signature so we can modify the smb and check
240 its signature against what the server sent */
241 memcpy(server_response_sig, cifs_pdu->Signature.SecuritySignature, 8);
242
243 cifs_pdu->Signature.Sequence.SequenceNumber =
244 cpu_to_le32(expected_sequence_number);
245 cifs_pdu->Signature.Sequence.Reserved = 0;
246
247 mutex_lock(&server->srv_mutex);
248 rc = cifs_calc_signature(rqst, server, what_we_think_sig_should_be);
249 mutex_unlock(&server->srv_mutex);
250
251 if (rc)
252 return rc;
253
254 /* cifs_dump_mem("what we think it should be: ",
255 what_we_think_sig_should_be, 16); */
256
257 if (memcmp(server_response_sig, what_we_think_sig_should_be, 8))
258 return -EACCES;
259 else
260 return 0;
261
262 }
263
264 /* first calculate 24 bytes ntlm response and then 16 byte session key */
setup_ntlm_response(struct cifs_ses * ses,const struct nls_table * nls_cp)265 int setup_ntlm_response(struct cifs_ses *ses, const struct nls_table *nls_cp)
266 {
267 int rc = 0;
268 unsigned int temp_len = CIFS_SESS_KEY_SIZE + CIFS_AUTH_RESP_SIZE;
269 char temp_key[CIFS_SESS_KEY_SIZE];
270
271 if (!ses)
272 return -EINVAL;
273
274 ses->auth_key.response = kmalloc(temp_len, GFP_KERNEL);
275 if (!ses->auth_key.response)
276 return -ENOMEM;
277
278 ses->auth_key.len = temp_len;
279
280 rc = SMBNTencrypt(ses->password, ses->server->cryptkey,
281 ses->auth_key.response + CIFS_SESS_KEY_SIZE, nls_cp);
282 if (rc) {
283 cifs_dbg(FYI, "%s Can't generate NTLM response, error: %d\n",
284 __func__, rc);
285 return rc;
286 }
287
288 rc = E_md4hash(ses->password, temp_key, nls_cp);
289 if (rc) {
290 cifs_dbg(FYI, "%s Can't generate NT hash, error: %d\n",
291 __func__, rc);
292 return rc;
293 }
294
295 rc = mdfour(ses->auth_key.response, temp_key, CIFS_SESS_KEY_SIZE);
296 if (rc)
297 cifs_dbg(FYI, "%s Can't generate NTLM session key, error: %d\n",
298 __func__, rc);
299
300 return rc;
301 }
302
303 #ifdef CONFIG_CIFS_WEAK_PW_HASH
calc_lanman_hash(const char * password,const char * cryptkey,bool encrypt,char * lnm_session_key)304 int calc_lanman_hash(const char *password, const char *cryptkey, bool encrypt,
305 char *lnm_session_key)
306 {
307 int i;
308 int rc;
309 char password_with_pad[CIFS_ENCPWD_SIZE] = {0};
310
311 if (password)
312 strncpy(password_with_pad, password, CIFS_ENCPWD_SIZE);
313
314 if (!encrypt && global_secflags & CIFSSEC_MAY_PLNTXT) {
315 memcpy(lnm_session_key, password_with_pad,
316 CIFS_ENCPWD_SIZE);
317 return 0;
318 }
319
320 /* calculate old style session key */
321 /* calling toupper is less broken than repeatedly
322 calling nls_toupper would be since that will never
323 work for UTF8, but neither handles multibyte code pages
324 but the only alternative would be converting to UCS-16 (Unicode)
325 (using a routine something like UniStrupr) then
326 uppercasing and then converting back from Unicode - which
327 would only worth doing it if we knew it were utf8. Basically
328 utf8 and other multibyte codepages each need their own strupper
329 function since a byte at a time will ont work. */
330
331 for (i = 0; i < CIFS_ENCPWD_SIZE; i++)
332 password_with_pad[i] = toupper(password_with_pad[i]);
333
334 rc = SMBencrypt(password_with_pad, cryptkey, lnm_session_key);
335
336 return rc;
337 }
338 #endif /* CIFS_WEAK_PW_HASH */
339
340 /* Build a proper attribute value/target info pairs blob.
341 * Fill in netbios and dns domain name and workstation name
342 * and client time (total five av pairs and + one end of fields indicator.
343 * Allocate domain name which gets freed when session struct is deallocated.
344 */
345 static int
build_avpair_blob(struct cifs_ses * ses,const struct nls_table * nls_cp)346 build_avpair_blob(struct cifs_ses *ses, const struct nls_table *nls_cp)
347 {
348 unsigned int dlen;
349 unsigned int size = 2 * sizeof(struct ntlmssp2_name);
350 char *defdmname = "WORKGROUP";
351 unsigned char *blobptr;
352 struct ntlmssp2_name *attrptr;
353
354 if (!ses->domainName) {
355 ses->domainName = kstrdup(defdmname, GFP_KERNEL);
356 if (!ses->domainName)
357 return -ENOMEM;
358 }
359
360 dlen = strlen(ses->domainName);
361
362 /*
363 * The length of this blob is two times the size of a
364 * structure (av pair) which holds name/size
365 * ( for NTLMSSP_AV_NB_DOMAIN_NAME followed by NTLMSSP_AV_EOL ) +
366 * unicode length of a netbios domain name
367 */
368 ses->auth_key.len = size + 2 * dlen;
369 ses->auth_key.response = kzalloc(ses->auth_key.len, GFP_KERNEL);
370 if (!ses->auth_key.response) {
371 ses->auth_key.len = 0;
372 return -ENOMEM;
373 }
374
375 blobptr = ses->auth_key.response;
376 attrptr = (struct ntlmssp2_name *) blobptr;
377
378 /*
379 * As defined in MS-NTLM 3.3.2, just this av pair field
380 * is sufficient as part of the temp
381 */
382 attrptr->type = cpu_to_le16(NTLMSSP_AV_NB_DOMAIN_NAME);
383 attrptr->length = cpu_to_le16(2 * dlen);
384 blobptr = (unsigned char *)attrptr + sizeof(struct ntlmssp2_name);
385 cifs_strtoUTF16((__le16 *)blobptr, ses->domainName, dlen, nls_cp);
386
387 return 0;
388 }
389
390 /* Server has provided av pairs/target info in the type 2 challenge
391 * packet and we have plucked it and stored within smb session.
392 * We parse that blob here to find netbios domain name to be used
393 * as part of ntlmv2 authentication (in Target String), if not already
394 * specified on the command line.
395 * If this function returns without any error but without fetching
396 * domain name, authentication may fail against some server but
397 * may not fail against other (those who are not very particular
398 * about target string i.e. for some, just user name might suffice.
399 */
400 static int
find_domain_name(struct cifs_ses * ses,const struct nls_table * nls_cp)401 find_domain_name(struct cifs_ses *ses, const struct nls_table *nls_cp)
402 {
403 unsigned int attrsize;
404 unsigned int type;
405 unsigned int onesize = sizeof(struct ntlmssp2_name);
406 unsigned char *blobptr;
407 unsigned char *blobend;
408 struct ntlmssp2_name *attrptr;
409
410 if (!ses->auth_key.len || !ses->auth_key.response)
411 return 0;
412
413 blobptr = ses->auth_key.response;
414 blobend = blobptr + ses->auth_key.len;
415
416 while (blobptr + onesize < blobend) {
417 attrptr = (struct ntlmssp2_name *) blobptr;
418 type = le16_to_cpu(attrptr->type);
419 if (type == NTLMSSP_AV_EOL)
420 break;
421 blobptr += 2; /* advance attr type */
422 attrsize = le16_to_cpu(attrptr->length);
423 blobptr += 2; /* advance attr size */
424 if (blobptr + attrsize > blobend)
425 break;
426 if (type == NTLMSSP_AV_NB_DOMAIN_NAME) {
427 if (!attrsize || attrsize >= CIFS_MAX_DOMAINNAME_LEN)
428 break;
429 if (!ses->domainName) {
430 ses->domainName =
431 kmalloc(attrsize + 1, GFP_KERNEL);
432 if (!ses->domainName)
433 return -ENOMEM;
434 cifs_from_utf16(ses->domainName,
435 (__le16 *)blobptr, attrsize, attrsize,
436 nls_cp, NO_MAP_UNI_RSVD);
437 break;
438 }
439 }
440 blobptr += attrsize; /* advance attr value */
441 }
442
443 return 0;
444 }
445
446 /* Server has provided av pairs/target info in the type 2 challenge
447 * packet and we have plucked it and stored within smb session.
448 * We parse that blob here to find the server given timestamp
449 * as part of ntlmv2 authentication (or local current time as
450 * default in case of failure)
451 */
452 static __le64
find_timestamp(struct cifs_ses * ses)453 find_timestamp(struct cifs_ses *ses)
454 {
455 unsigned int attrsize;
456 unsigned int type;
457 unsigned int onesize = sizeof(struct ntlmssp2_name);
458 unsigned char *blobptr;
459 unsigned char *blobend;
460 struct ntlmssp2_name *attrptr;
461 struct timespec64 ts;
462
463 if (!ses->auth_key.len || !ses->auth_key.response)
464 return 0;
465
466 blobptr = ses->auth_key.response;
467 blobend = blobptr + ses->auth_key.len;
468
469 while (blobptr + onesize < blobend) {
470 attrptr = (struct ntlmssp2_name *) blobptr;
471 type = le16_to_cpu(attrptr->type);
472 if (type == NTLMSSP_AV_EOL)
473 break;
474 blobptr += 2; /* advance attr type */
475 attrsize = le16_to_cpu(attrptr->length);
476 blobptr += 2; /* advance attr size */
477 if (blobptr + attrsize > blobend)
478 break;
479 if (type == NTLMSSP_AV_TIMESTAMP) {
480 if (attrsize == sizeof(u64))
481 return *((__le64 *)blobptr);
482 }
483 blobptr += attrsize; /* advance attr value */
484 }
485
486 ktime_get_real_ts64(&ts);
487 return cpu_to_le64(cifs_UnixTimeToNT(ts));
488 }
489
calc_ntlmv2_hash(struct cifs_ses * ses,char * ntlmv2_hash,const struct nls_table * nls_cp)490 static int calc_ntlmv2_hash(struct cifs_ses *ses, char *ntlmv2_hash,
491 const struct nls_table *nls_cp)
492 {
493 int rc = 0;
494 int len;
495 char nt_hash[CIFS_NTHASH_SIZE];
496 __le16 *user;
497 wchar_t *domain;
498 wchar_t *server;
499
500 if (!ses->server->secmech.sdeschmacmd5) {
501 cifs_dbg(VFS, "%s: can't generate ntlmv2 hash\n", __func__);
502 return -1;
503 }
504
505 /* calculate md4 hash of password */
506 E_md4hash(ses->password, nt_hash, nls_cp);
507
508 rc = crypto_shash_setkey(ses->server->secmech.hmacmd5, nt_hash,
509 CIFS_NTHASH_SIZE);
510 if (rc) {
511 cifs_dbg(VFS, "%s: Could not set NT Hash as a key\n", __func__);
512 return rc;
513 }
514
515 rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
516 if (rc) {
517 cifs_dbg(VFS, "%s: could not init hmacmd5\n", __func__);
518 return rc;
519 }
520
521 /* convert ses->user_name to unicode */
522 len = ses->user_name ? strlen(ses->user_name) : 0;
523 user = kmalloc(2 + (len * 2), GFP_KERNEL);
524 if (user == NULL) {
525 rc = -ENOMEM;
526 return rc;
527 }
528
529 if (len) {
530 len = cifs_strtoUTF16(user, ses->user_name, len, nls_cp);
531 UniStrupr(user);
532 } else {
533 memset(user, '\0', 2);
534 }
535
536 rc = crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
537 (char *)user, 2 * len);
538 kfree(user);
539 if (rc) {
540 cifs_dbg(VFS, "%s: Could not update with user\n", __func__);
541 return rc;
542 }
543
544 /* convert ses->domainName to unicode and uppercase */
545 if (ses->domainName) {
546 len = strlen(ses->domainName);
547
548 domain = kmalloc(2 + (len * 2), GFP_KERNEL);
549 if (domain == NULL) {
550 rc = -ENOMEM;
551 return rc;
552 }
553 len = cifs_strtoUTF16((__le16 *)domain, ses->domainName, len,
554 nls_cp);
555 rc =
556 crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
557 (char *)domain, 2 * len);
558 kfree(domain);
559 if (rc) {
560 cifs_dbg(VFS, "%s: Could not update with domain\n",
561 __func__);
562 return rc;
563 }
564 } else {
565 /* We use ses->serverName if no domain name available */
566 len = strlen(ses->serverName);
567
568 server = kmalloc(2 + (len * 2), GFP_KERNEL);
569 if (server == NULL) {
570 rc = -ENOMEM;
571 return rc;
572 }
573 len = cifs_strtoUTF16((__le16 *)server, ses->serverName, len,
574 nls_cp);
575 rc =
576 crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
577 (char *)server, 2 * len);
578 kfree(server);
579 if (rc) {
580 cifs_dbg(VFS, "%s: Could not update with server\n",
581 __func__);
582 return rc;
583 }
584 }
585
586 rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
587 ntlmv2_hash);
588 if (rc)
589 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
590
591 return rc;
592 }
593
594 static int
CalcNTLMv2_response(const struct cifs_ses * ses,char * ntlmv2_hash)595 CalcNTLMv2_response(const struct cifs_ses *ses, char *ntlmv2_hash)
596 {
597 int rc;
598 struct ntlmv2_resp *ntlmv2 = (struct ntlmv2_resp *)
599 (ses->auth_key.response + CIFS_SESS_KEY_SIZE);
600 unsigned int hash_len;
601
602 /* The MD5 hash starts at challenge_key.key */
603 hash_len = ses->auth_key.len - (CIFS_SESS_KEY_SIZE +
604 offsetof(struct ntlmv2_resp, challenge.key[0]));
605
606 if (!ses->server->secmech.sdeschmacmd5) {
607 cifs_dbg(VFS, "%s: can't generate ntlmv2 hash\n", __func__);
608 return -1;
609 }
610
611 rc = crypto_shash_setkey(ses->server->secmech.hmacmd5,
612 ntlmv2_hash, CIFS_HMAC_MD5_HASH_SIZE);
613 if (rc) {
614 cifs_dbg(VFS, "%s: Could not set NTLMV2 Hash as a key\n",
615 __func__);
616 return rc;
617 }
618
619 rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
620 if (rc) {
621 cifs_dbg(VFS, "%s: could not init hmacmd5\n", __func__);
622 return rc;
623 }
624
625 if (ses->server->negflavor == CIFS_NEGFLAVOR_EXTENDED)
626 memcpy(ntlmv2->challenge.key,
627 ses->ntlmssp->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);
628 else
629 memcpy(ntlmv2->challenge.key,
630 ses->server->cryptkey, CIFS_SERVER_CHALLENGE_SIZE);
631 rc = crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
632 ntlmv2->challenge.key, hash_len);
633 if (rc) {
634 cifs_dbg(VFS, "%s: Could not update with response\n", __func__);
635 return rc;
636 }
637
638 /* Note that the MD5 digest over writes anon.challenge_key.key */
639 rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
640 ntlmv2->ntlmv2_hash);
641 if (rc)
642 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
643
644 return rc;
645 }
646
647 int
setup_ntlmv2_rsp(struct cifs_ses * ses,const struct nls_table * nls_cp)648 setup_ntlmv2_rsp(struct cifs_ses *ses, const struct nls_table *nls_cp)
649 {
650 int rc;
651 int baselen;
652 unsigned int tilen;
653 struct ntlmv2_resp *ntlmv2;
654 char ntlmv2_hash[16];
655 unsigned char *tiblob = NULL; /* target info blob */
656 __le64 rsp_timestamp;
657
658 if (ses->server->negflavor == CIFS_NEGFLAVOR_EXTENDED) {
659 if (!ses->domainName) {
660 if (ses->domainAuto) {
661 rc = find_domain_name(ses, nls_cp);
662 if (rc) {
663 cifs_dbg(VFS, "error %d finding domain name\n",
664 rc);
665 goto setup_ntlmv2_rsp_ret;
666 }
667 } else {
668 ses->domainName = kstrdup("", GFP_KERNEL);
669 }
670 }
671 } else {
672 rc = build_avpair_blob(ses, nls_cp);
673 if (rc) {
674 cifs_dbg(VFS, "error %d building av pair blob\n", rc);
675 goto setup_ntlmv2_rsp_ret;
676 }
677 }
678
679 /* Must be within 5 minutes of the server (or in range +/-2h
680 * in case of Mac OS X), so simply carry over server timestamp
681 * (as Windows 7 does)
682 */
683 rsp_timestamp = find_timestamp(ses);
684
685 baselen = CIFS_SESS_KEY_SIZE + sizeof(struct ntlmv2_resp);
686 tilen = ses->auth_key.len;
687 tiblob = ses->auth_key.response;
688
689 ses->auth_key.response = kmalloc(baselen + tilen, GFP_KERNEL);
690 if (!ses->auth_key.response) {
691 rc = -ENOMEM;
692 ses->auth_key.len = 0;
693 goto setup_ntlmv2_rsp_ret;
694 }
695 ses->auth_key.len += baselen;
696
697 ntlmv2 = (struct ntlmv2_resp *)
698 (ses->auth_key.response + CIFS_SESS_KEY_SIZE);
699 ntlmv2->blob_signature = cpu_to_le32(0x00000101);
700 ntlmv2->reserved = 0;
701 ntlmv2->time = rsp_timestamp;
702
703 get_random_bytes(&ntlmv2->client_chal, sizeof(ntlmv2->client_chal));
704 ntlmv2->reserved2 = 0;
705
706 memcpy(ses->auth_key.response + baselen, tiblob, tilen);
707
708 mutex_lock(&ses->server->srv_mutex);
709
710 rc = cifs_alloc_hash("hmac(md5)",
711 &ses->server->secmech.hmacmd5,
712 &ses->server->secmech.sdeschmacmd5);
713 if (rc) {
714 goto unlock;
715 }
716
717 /* calculate ntlmv2_hash */
718 rc = calc_ntlmv2_hash(ses, ntlmv2_hash, nls_cp);
719 if (rc) {
720 cifs_dbg(VFS, "could not get v2 hash rc %d\n", rc);
721 goto unlock;
722 }
723
724 /* calculate first part of the client response (CR1) */
725 rc = CalcNTLMv2_response(ses, ntlmv2_hash);
726 if (rc) {
727 cifs_dbg(VFS, "Could not calculate CR1 rc: %d\n", rc);
728 goto unlock;
729 }
730
731 /* now calculate the session key for NTLMv2 */
732 rc = crypto_shash_setkey(ses->server->secmech.hmacmd5,
733 ntlmv2_hash, CIFS_HMAC_MD5_HASH_SIZE);
734 if (rc) {
735 cifs_dbg(VFS, "%s: Could not set NTLMV2 Hash as a key\n",
736 __func__);
737 goto unlock;
738 }
739
740 rc = crypto_shash_init(&ses->server->secmech.sdeschmacmd5->shash);
741 if (rc) {
742 cifs_dbg(VFS, "%s: Could not init hmacmd5\n", __func__);
743 goto unlock;
744 }
745
746 rc = crypto_shash_update(&ses->server->secmech.sdeschmacmd5->shash,
747 ntlmv2->ntlmv2_hash,
748 CIFS_HMAC_MD5_HASH_SIZE);
749 if (rc) {
750 cifs_dbg(VFS, "%s: Could not update with response\n", __func__);
751 goto unlock;
752 }
753
754 rc = crypto_shash_final(&ses->server->secmech.sdeschmacmd5->shash,
755 ses->auth_key.response);
756 if (rc)
757 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
758
759 unlock:
760 mutex_unlock(&ses->server->srv_mutex);
761 setup_ntlmv2_rsp_ret:
762 kfree(tiblob);
763
764 return rc;
765 }
766
767 int
calc_seckey(struct cifs_ses * ses)768 calc_seckey(struct cifs_ses *ses)
769 {
770 int rc;
771 struct crypto_skcipher *tfm_arc4;
772 struct scatterlist sgin, sgout;
773 struct skcipher_request *req;
774 unsigned char *sec_key;
775
776 sec_key = kmalloc(CIFS_SESS_KEY_SIZE, GFP_KERNEL);
777 if (sec_key == NULL)
778 return -ENOMEM;
779
780 get_random_bytes(sec_key, CIFS_SESS_KEY_SIZE);
781
782 tfm_arc4 = crypto_alloc_skcipher("ecb(arc4)", 0, CRYPTO_ALG_ASYNC);
783 if (IS_ERR(tfm_arc4)) {
784 rc = PTR_ERR(tfm_arc4);
785 cifs_dbg(VFS, "could not allocate crypto API arc4\n");
786 goto out;
787 }
788
789 rc = crypto_skcipher_setkey(tfm_arc4, ses->auth_key.response,
790 CIFS_SESS_KEY_SIZE);
791 if (rc) {
792 cifs_dbg(VFS, "%s: Could not set response as a key\n",
793 __func__);
794 goto out_free_cipher;
795 }
796
797 req = skcipher_request_alloc(tfm_arc4, GFP_KERNEL);
798 if (!req) {
799 rc = -ENOMEM;
800 cifs_dbg(VFS, "could not allocate crypto API arc4 request\n");
801 goto out_free_cipher;
802 }
803
804 sg_init_one(&sgin, sec_key, CIFS_SESS_KEY_SIZE);
805 sg_init_one(&sgout, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);
806
807 skcipher_request_set_callback(req, 0, NULL, NULL);
808 skcipher_request_set_crypt(req, &sgin, &sgout, CIFS_CPHTXT_SIZE, NULL);
809
810 rc = crypto_skcipher_encrypt(req);
811 skcipher_request_free(req);
812 if (rc) {
813 cifs_dbg(VFS, "could not encrypt session key rc: %d\n", rc);
814 goto out_free_cipher;
815 }
816
817 /* make secondary_key/nonce as session key */
818 memcpy(ses->auth_key.response, sec_key, CIFS_SESS_KEY_SIZE);
819 /* and make len as that of session key only */
820 ses->auth_key.len = CIFS_SESS_KEY_SIZE;
821
822 out_free_cipher:
823 crypto_free_skcipher(tfm_arc4);
824 out:
825 kfree(sec_key);
826 return rc;
827 }
828
829 void
cifs_crypto_secmech_release(struct TCP_Server_Info * server)830 cifs_crypto_secmech_release(struct TCP_Server_Info *server)
831 {
832 if (server->secmech.cmacaes) {
833 crypto_free_shash(server->secmech.cmacaes);
834 server->secmech.cmacaes = NULL;
835 }
836
837 if (server->secmech.hmacsha256) {
838 crypto_free_shash(server->secmech.hmacsha256);
839 server->secmech.hmacsha256 = NULL;
840 }
841
842 if (server->secmech.md5) {
843 crypto_free_shash(server->secmech.md5);
844 server->secmech.md5 = NULL;
845 }
846
847 if (server->secmech.sha512) {
848 crypto_free_shash(server->secmech.sha512);
849 server->secmech.sha512 = NULL;
850 }
851
852 if (server->secmech.hmacmd5) {
853 crypto_free_shash(server->secmech.hmacmd5);
854 server->secmech.hmacmd5 = NULL;
855 }
856
857 if (server->secmech.ccmaesencrypt) {
858 crypto_free_aead(server->secmech.ccmaesencrypt);
859 server->secmech.ccmaesencrypt = NULL;
860 }
861
862 if (server->secmech.ccmaesdecrypt) {
863 crypto_free_aead(server->secmech.ccmaesdecrypt);
864 server->secmech.ccmaesdecrypt = NULL;
865 }
866
867 kfree(server->secmech.sdesccmacaes);
868 server->secmech.sdesccmacaes = NULL;
869 kfree(server->secmech.sdeschmacsha256);
870 server->secmech.sdeschmacsha256 = NULL;
871 kfree(server->secmech.sdeschmacmd5);
872 server->secmech.sdeschmacmd5 = NULL;
873 kfree(server->secmech.sdescmd5);
874 server->secmech.sdescmd5 = NULL;
875 kfree(server->secmech.sdescsha512);
876 server->secmech.sdescsha512 = NULL;
877 }
878