~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/cifs/cifsencrypt.c

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 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  */
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 */
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 
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 */
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 
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 */
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
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
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
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
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 
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
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
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
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
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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp