fs/smb/client/cifsencrypt.c

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