fs/cifs/cifsencrypt.c

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