fs/smb/client/smb2transport.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002, 2011
   5  *                 Etersoft, 2012
   6  *   Author(s): Steve French (sfrench@us.ibm.com)
   7  *              Jeremy Allison (jra@samba.org) 2006
   8  *              Pavel Shilovsky (pshilovsky@samba.org) 2012
   9  *
  10  */
  11
  12 #include <linux/fs.h>
  13 #include <linux/list.h>
  14 #include <linux/wait.h>
  15 #include <linux/net.h>
  16 #include <linux/delay.h>
  17 #include <linux/uaccess.h>
  18 #include <asm/processor.h>
  19 #include <linux/mempool.h>
  20 #include <linux/highmem.h>
  21 #include <crypto/aead.h>
  22 #include "cifsglob.h"
  23 #include "cifsproto.h"
  24 #include "smb2proto.h"
  25 #include "cifs_debug.h"
  26 #include "smb2status.h"
  27 #include "smb2glob.h"
  28
  29 static int
  30 smb3_crypto_shash_allocate(struct TCP_Server_Info *server)
  31 {
  32         struct cifs_secmech *p = &server->secmech;
  33         int rc;
  34
  35         rc = cifs_alloc_hash("hmac(sha256)", &p->hmacsha256);
  36         if (rc)
  37                 goto err;
  38
  39         rc = cifs_alloc_hash("cmac(aes)", &p->aes_cmac);
  40         if (rc)
  41                 goto err;
  42
  43         return 0;
  44 err:
  45         cifs_free_hash(&p->hmacsha256);
  46         return rc;
  47 }
  48
  49 int
  50 smb311_crypto_shash_allocate(struct TCP_Server_Info *server)
  51 {
  52         struct cifs_secmech *p = &server->secmech;
  53         int rc = 0;
  54
  55         rc = cifs_alloc_hash("hmac(sha256)", &p->hmacsha256);
  56         if (rc)
  57                 return rc;
  58
  59         rc = cifs_alloc_hash("cmac(aes)", &p->aes_cmac);
  60         if (rc)
  61                 goto err;
  62
  63         rc = cifs_alloc_hash("sha512", &p->sha512);
  64         if (rc)
  65                 goto err;
  66
  67         return 0;
  68
  69 err:
  70         cifs_free_hash(&p->aes_cmac);
  71         cifs_free_hash(&p->hmacsha256);
  72         return rc;
  73 }
  74
  75
  76 static
  77 int smb2_get_sign_key(__u64 ses_id, struct TCP_Server_Info *server, u8 *key)
  78 {
  79         struct cifs_chan *chan;
  80         struct TCP_Server_Info *pserver;
  81         struct cifs_ses *ses = NULL;
  82         int i;
  83         int rc = 0;
  84         bool is_binding = false;
  85
  86         spin_lock(&cifs_tcp_ses_lock);
  87
  88         /* If server is a channel, select the primary channel */
  89         pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
  90
  91         list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) {
  92                 if (ses->Suid == ses_id)
  93                         goto found;
  94         }
  95         trace_smb3_ses_not_found(ses_id);
  96         cifs_server_dbg(FYI, "%s: Could not find session 0x%llx\n",
  97                         __func__, ses_id);
  98         rc = -ENOENT;
  99         goto out;
 100
 101 found:
 102         spin_lock(&ses->ses_lock);
 103         spin_lock(&ses->chan_lock);
 104
 105         is_binding = (cifs_chan_needs_reconnect(ses, server) &&
 106                       ses->ses_status == SES_GOOD);
 107         if (is_binding) {
 108                 /*
 109                  * If we are in the process of binding a new channel
 110                  * to an existing session, use the master connection
 111                  * session key
 112                  */
 113                 memcpy(key, ses->smb3signingkey, SMB3_SIGN_KEY_SIZE);
 114                 spin_unlock(&ses->chan_lock);
 115                 spin_unlock(&ses->ses_lock);
 116                 goto out;
 117         }
 118
 119         /*
 120          * Otherwise, use the channel key.
 121          */
 122
 123         for (i = 0; i < ses->chan_count; i++) {
 124                 chan = ses->chans + i;
 125                 if (chan->server == server) {
 126                         memcpy(key, chan->signkey, SMB3_SIGN_KEY_SIZE);
 127                         spin_unlock(&ses->chan_lock);
 128                         spin_unlock(&ses->ses_lock);
 129                         goto out;
 130                 }
 131         }
 132         spin_unlock(&ses->chan_lock);
 133         spin_unlock(&ses->ses_lock);
 134
 135         cifs_dbg(VFS,
 136                  "%s: Could not find channel signing key for session 0x%llx\n",
 137                  __func__, ses_id);
 138         rc = -ENOENT;
 139
 140 out:
 141         spin_unlock(&cifs_tcp_ses_lock);
 142         return rc;
 143 }
 144
 145 static struct cifs_ses *
 146 smb2_find_smb_ses_unlocked(struct TCP_Server_Info *server, __u64 ses_id)
 147 {
 148         struct TCP_Server_Info *pserver;
 149         struct cifs_ses *ses;
 150
 151         /* If server is a channel, select the primary channel */
 152         pserver = SERVER_IS_CHAN(server) ? server->primary_server : server;
 153
 154         list_for_each_entry(ses, &pserver->smb_ses_list, smb_ses_list) {
 155                 if (ses->Suid != ses_id)
 156                         continue;
 157
 158                 spin_lock(&ses->ses_lock);
 159                 if (ses->ses_status == SES_EXITING) {
 160                         spin_unlock(&ses->ses_lock);
 161                         continue;
 162                 }
 163                 cifs_smb_ses_inc_refcount(ses);
 164                 spin_unlock(&ses->ses_lock);
 165                 return ses;
 166         }
 167
 168         return NULL;
 169 }
 170
 171 struct cifs_ses *
 172 smb2_find_smb_ses(struct TCP_Server_Info *server, __u64 ses_id)
 173 {
 174         struct cifs_ses *ses;
 175
 176         spin_lock(&cifs_tcp_ses_lock);
 177         ses = smb2_find_smb_ses_unlocked(server, ses_id);
 178         spin_unlock(&cifs_tcp_ses_lock);
 179
 180         return ses;
 181 }
 182
 183 static struct cifs_tcon *
 184 smb2_find_smb_sess_tcon_unlocked(struct cifs_ses *ses, __u32  tid)
 185 {
 186         struct cifs_tcon *tcon;
 187
 188         list_for_each_entry(tcon, &ses->tcon_list, tcon_list) {
 189                 if (tcon->tid != tid)
 190                         continue;
 191                 ++tcon->tc_count;
 192                 return tcon;
 193         }
 194
 195         return NULL;
 196 }
 197
 198 /*
 199  * Obtain tcon corresponding to the tid in the given
 200  * cifs_ses
 201  */
 202
 203 struct cifs_tcon *
 204 smb2_find_smb_tcon(struct TCP_Server_Info *server, __u64 ses_id, __u32  tid)
 205 {
 206         struct cifs_ses *ses;
 207         struct cifs_tcon *tcon;
 208
 209         spin_lock(&cifs_tcp_ses_lock);
 210         ses = smb2_find_smb_ses_unlocked(server, ses_id);
 211         if (!ses) {
 212                 spin_unlock(&cifs_tcp_ses_lock);
 213                 return NULL;
 214         }
 215         tcon = smb2_find_smb_sess_tcon_unlocked(ses, tid);
 216         if (!tcon) {
 217                 cifs_put_smb_ses(ses);
 218                 spin_unlock(&cifs_tcp_ses_lock);
 219                 return NULL;
 220         }
 221         spin_unlock(&cifs_tcp_ses_lock);
 222         /* tcon already has a ref to ses, so we don't need ses anymore */
 223         cifs_put_smb_ses(ses);
 224
 225         return tcon;
 226 }
 227
 228 int
 229 smb2_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,
 230                         bool allocate_crypto)
 231 {
 232         int rc;
 233         unsigned char smb2_signature[SMB2_HMACSHA256_SIZE];
 234         unsigned char *sigptr = smb2_signature;
 235         struct kvec *iov = rqst->rq_iov;
 236         struct smb2_hdr *shdr = (struct smb2_hdr *)iov[0].iov_base;
 237         struct cifs_ses *ses;
 238         struct shash_desc *shash = NULL;
 239         struct smb_rqst drqst;
 240
 241         ses = smb2_find_smb_ses(server, le64_to_cpu(shdr->SessionId));
 242         if (unlikely(!ses)) {
 243                 cifs_server_dbg(VFS, "%s: Could not find session\n", __func__);
 244                 return -ENOENT;
 245         }
 246
 247         memset(smb2_signature, 0x0, SMB2_HMACSHA256_SIZE);
 248         memset(shdr->Signature, 0x0, SMB2_SIGNATURE_SIZE);
 249
 250         if (allocate_crypto) {
 251                 rc = cifs_alloc_hash("hmac(sha256)", &shash);
 252                 if (rc) {
 253                         cifs_server_dbg(VFS,
 254                                         "%s: sha256 alloc failed\n", __func__);
 255                         goto out;
 256                 }
 257         } else {
 258                 shash = server->secmech.hmacsha256;
 259         }
 260
 261         rc = crypto_shash_setkey(shash->tfm, ses->auth_key.response,
 262                         SMB2_NTLMV2_SESSKEY_SIZE);
 263         if (rc) {
 264                 cifs_server_dbg(VFS,
 265                                 "%s: Could not update with response\n",
 266                                 __func__);
 267                 goto out;
 268         }
 269
 270         rc = crypto_shash_init(shash);
 271         if (rc) {
 272                 cifs_server_dbg(VFS, "%s: Could not init sha256", __func__);
 273                 goto out;
 274         }
 275
 276         /*
 277          * For SMB2+, __cifs_calc_signature() expects to sign only the actual
 278          * data, that is, iov[0] should not contain a rfc1002 length.
 279          *
 280          * Sign the rfc1002 length prior to passing the data (iov[1-N]) down to
 281          * __cifs_calc_signature().
 282          */
 283         drqst = *rqst;
 284         if (drqst.rq_nvec >= 2 && iov[0].iov_len == 4) {
 285                 rc = crypto_shash_update(shash, iov[0].iov_base,
 286                                          iov[0].iov_len);
 287                 if (rc) {
 288                         cifs_server_dbg(VFS,
 289                                         "%s: Could not update with payload\n",
 290                                         __func__);
 291                         goto out;
 292                 }
 293                 drqst.rq_iov++;
 294                 drqst.rq_nvec--;
 295         }
 296
 297         rc = __cifs_calc_signature(&drqst, server, sigptr, shash);
 298         if (!rc)
 299                 memcpy(shdr->Signature, sigptr, SMB2_SIGNATURE_SIZE);
 300
 301 out:
 302         if (allocate_crypto)
 303                 cifs_free_hash(&shash);
 304         if (ses)
 305                 cifs_put_smb_ses(ses);
 306         return rc;
 307 }
 308
 309 static int generate_key(struct cifs_ses *ses, struct kvec label,
 310                         struct kvec context, __u8 *key, unsigned int key_size)
 311 {
 312         unsigned char zero = 0x0;
 313         __u8 i[4] = {0, 0, 0, 1};
 314         __u8 L128[4] = {0, 0, 0, 128};
 315         __u8 L256[4] = {0, 0, 1, 0};
 316         int rc = 0;
 317         unsigned char prfhash[SMB2_HMACSHA256_SIZE];
 318         unsigned char *hashptr = prfhash;
 319         struct TCP_Server_Info *server = ses->server;
 320
 321         memset(prfhash, 0x0, SMB2_HMACSHA256_SIZE);
 322         memset(key, 0x0, key_size);
 323
 324         rc = smb3_crypto_shash_allocate(server);
 325         if (rc) {
 326                 cifs_server_dbg(VFS, "%s: crypto alloc failed\n", __func__);
 327                 goto smb3signkey_ret;
 328         }
 329
 330         rc = crypto_shash_setkey(server->secmech.hmacsha256->tfm,
 331                 ses->auth_key.response, SMB2_NTLMV2_SESSKEY_SIZE);
 332         if (rc) {
 333                 cifs_server_dbg(VFS, "%s: Could not set with session key\n", __func__);
 334                 goto smb3signkey_ret;
 335         }
 336
 337         rc = crypto_shash_init(server->secmech.hmacsha256);
 338         if (rc) {
 339                 cifs_server_dbg(VFS, "%s: Could not init sign hmac\n", __func__);
 340                 goto smb3signkey_ret;
 341         }
 342
 343         rc = crypto_shash_update(server->secmech.hmacsha256, i, 4);
 344         if (rc) {
 345                 cifs_server_dbg(VFS, "%s: Could not update with n\n", __func__);
 346                 goto smb3signkey_ret;
 347         }
 348
 349         rc = crypto_shash_update(server->secmech.hmacsha256, label.iov_base, label.iov_len);
 350         if (rc) {
 351                 cifs_server_dbg(VFS, "%s: Could not update with label\n", __func__);
 352                 goto smb3signkey_ret;
 353         }
 354
 355         rc = crypto_shash_update(server->secmech.hmacsha256, &zero, 1);
 356         if (rc) {
 357                 cifs_server_dbg(VFS, "%s: Could not update with zero\n", __func__);
 358                 goto smb3signkey_ret;
 359         }
 360
 361         rc = crypto_shash_update(server->secmech.hmacsha256, context.iov_base, context.iov_len);
 362         if (rc) {
 363                 cifs_server_dbg(VFS, "%s: Could not update with context\n", __func__);
 364                 goto smb3signkey_ret;
 365         }
 366
 367         if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
 368                 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)) {
 369                 rc = crypto_shash_update(server->secmech.hmacsha256, L256, 4);
 370         } else {
 371                 rc = crypto_shash_update(server->secmech.hmacsha256, L128, 4);
 372         }
 373         if (rc) {
 374                 cifs_server_dbg(VFS, "%s: Could not update with L\n", __func__);
 375                 goto smb3signkey_ret;
 376         }
 377
 378         rc = crypto_shash_final(server->secmech.hmacsha256, hashptr);
 379         if (rc) {
 380                 cifs_server_dbg(VFS, "%s: Could not generate sha256 hash\n", __func__);
 381                 goto smb3signkey_ret;
 382         }
 383
 384         memcpy(key, hashptr, key_size);
 385
 386 smb3signkey_ret:
 387         return rc;
 388 }
 389
 390 struct derivation {
 391         struct kvec label;
 392         struct kvec context;
 393 };
 394
 395 struct derivation_triplet {
 396         struct derivation signing;
 397         struct derivation encryption;
 398         struct derivation decryption;
 399 };
 400
 401 static int
 402 generate_smb3signingkey(struct cifs_ses *ses,
 403                         struct TCP_Server_Info *server,
 404                         const struct derivation_triplet *ptriplet)
 405 {
 406         int rc;
 407         bool is_binding = false;
 408         int chan_index = 0;
 409
 410         spin_lock(&ses->ses_lock);
 411         spin_lock(&ses->chan_lock);
 412         is_binding = (cifs_chan_needs_reconnect(ses, server) &&
 413                       ses->ses_status == SES_GOOD);
 414
 415         chan_index = cifs_ses_get_chan_index(ses, server);
 416         if (chan_index == CIFS_INVAL_CHAN_INDEX) {
 417                 spin_unlock(&ses->chan_lock);
 418                 spin_unlock(&ses->ses_lock);
 419
 420                 return -EINVAL;
 421         }
 422
 423         spin_unlock(&ses->chan_lock);
 424         spin_unlock(&ses->ses_lock);
 425
 426         /*
 427          * All channels use the same encryption/decryption keys but
 428          * they have their own signing key.
 429          *
 430          * When we generate the keys, check if it is for a new channel
 431          * (binding) in which case we only need to generate a signing
 432          * key and store it in the channel as to not overwrite the
 433          * master connection signing key stored in the session
 434          */
 435
 436         if (is_binding) {
 437                 rc = generate_key(ses, ptriplet->signing.label,
 438                                   ptriplet->signing.context,
 439                                   ses->chans[chan_index].signkey,
 440                                   SMB3_SIGN_KEY_SIZE);
 441                 if (rc)
 442                         return rc;
 443         } else {
 444                 rc = generate_key(ses, ptriplet->signing.label,
 445                                   ptriplet->signing.context,
 446                                   ses->smb3signingkey,
 447                                   SMB3_SIGN_KEY_SIZE);
 448                 if (rc)
 449                         return rc;
 450
 451                 /* safe to access primary channel, since it will never go away */
 452                 spin_lock(&ses->chan_lock);
 453                 memcpy(ses->chans[chan_index].signkey, ses->smb3signingkey,
 454                        SMB3_SIGN_KEY_SIZE);
 455                 spin_unlock(&ses->chan_lock);
 456
 457                 rc = generate_key(ses, ptriplet->encryption.label,
 458                                   ptriplet->encryption.context,
 459                                   ses->smb3encryptionkey,
 460                                   SMB3_ENC_DEC_KEY_SIZE);
 461                 rc = generate_key(ses, ptriplet->decryption.label,
 462                                   ptriplet->decryption.context,
 463                                   ses->smb3decryptionkey,
 464                                   SMB3_ENC_DEC_KEY_SIZE);
 465                 if (rc)
 466                         return rc;
 467         }
 468
 469         if (rc)
 470                 return rc;
 471
 472 #ifdef CONFIG_CIFS_DEBUG_DUMP_KEYS
 473         cifs_dbg(VFS, "%s: dumping generated AES session keys\n", __func__);
 474         /*
 475          * The session id is opaque in terms of endianness, so we can't
 476          * print it as a long long. we dump it as we got it on the wire
 477          */
 478         cifs_dbg(VFS, "Session Id    %*ph\n", (int)sizeof(ses->Suid),
 479                         &ses->Suid);
 480         cifs_dbg(VFS, "Cipher type   %d\n", server->cipher_type);
 481         cifs_dbg(VFS, "Session Key   %*ph\n",
 482                  SMB2_NTLMV2_SESSKEY_SIZE, ses->auth_key.response);
 483         cifs_dbg(VFS, "Signing Key   %*ph\n",
 484                  SMB3_SIGN_KEY_SIZE, ses->smb3signingkey);
 485         if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
 486                 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)) {
 487                 cifs_dbg(VFS, "ServerIn Key  %*ph\n",
 488                                 SMB3_GCM256_CRYPTKEY_SIZE, ses->smb3encryptionkey);
 489                 cifs_dbg(VFS, "ServerOut Key %*ph\n",
 490                                 SMB3_GCM256_CRYPTKEY_SIZE, ses->smb3decryptionkey);
 491         } else {
 492                 cifs_dbg(VFS, "ServerIn Key  %*ph\n",
 493                                 SMB3_GCM128_CRYPTKEY_SIZE, ses->smb3encryptionkey);
 494                 cifs_dbg(VFS, "ServerOut Key %*ph\n",
 495                                 SMB3_GCM128_CRYPTKEY_SIZE, ses->smb3decryptionkey);
 496         }
 497 #endif
 498         return rc;
 499 }
 500
 501 int
 502 generate_smb30signingkey(struct cifs_ses *ses,
 503                          struct TCP_Server_Info *server)
 504
 505 {
 506         struct derivation_triplet triplet;
 507         struct derivation *d;
 508
 509         d = &triplet.signing;
 510         d->label.iov_base = "SMB2AESCMAC";
 511         d->label.iov_len = 12;
 512         d->context.iov_base = "SmbSign";
 513         d->context.iov_len = 8;
 514
 515         d = &triplet.encryption;
 516         d->label.iov_base = "SMB2AESCCM";
 517         d->label.iov_len = 11;
 518         d->context.iov_base = "ServerIn ";
 519         d->context.iov_len = 10;
 520
 521         d = &triplet.decryption;
 522         d->label.iov_base = "SMB2AESCCM";
 523         d->label.iov_len = 11;
 524         d->context.iov_base = "ServerOut";
 525         d->context.iov_len = 10;
 526
 527         return generate_smb3signingkey(ses, server, &triplet);
 528 }
 529
 530 int
 531 generate_smb311signingkey(struct cifs_ses *ses,
 532                           struct TCP_Server_Info *server)
 533
 534 {
 535         struct derivation_triplet triplet;
 536         struct derivation *d;
 537
 538         d = &triplet.signing;
 539         d->label.iov_base = "SMBSigningKey";
 540         d->label.iov_len = 14;
 541         d->context.iov_base = ses->preauth_sha_hash;
 542         d->context.iov_len = 64;
 543
 544         d = &triplet.encryption;
 545         d->label.iov_base = "SMBC2SCipherKey";
 546         d->label.iov_len = 16;
 547         d->context.iov_base = ses->preauth_sha_hash;
 548         d->context.iov_len = 64;
 549
 550         d = &triplet.decryption;
 551         d->label.iov_base = "SMBS2CCipherKey";
 552         d->label.iov_len = 16;
 553         d->context.iov_base = ses->preauth_sha_hash;
 554         d->context.iov_len = 64;
 555
 556         return generate_smb3signingkey(ses, server, &triplet);
 557 }
 558
 559 int
 560 smb3_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,
 561                         bool allocate_crypto)
 562 {
 563         int rc;
 564         unsigned char smb3_signature[SMB2_CMACAES_SIZE];
 565         unsigned char *sigptr = smb3_signature;
 566         struct kvec *iov = rqst->rq_iov;
 567         struct smb2_hdr *shdr = (struct smb2_hdr *)iov[0].iov_base;
 568         struct shash_desc *shash = NULL;
 569         struct smb_rqst drqst;
 570         u8 key[SMB3_SIGN_KEY_SIZE];
 571
 572         rc = smb2_get_sign_key(le64_to_cpu(shdr->SessionId), server, key);
 573         if (unlikely(rc)) {
 574                 cifs_server_dbg(FYI, "%s: Could not get signing key\n", __func__);
 575                 return rc;
 576         }
 577
 578         if (allocate_crypto) {
 579                 rc = cifs_alloc_hash("cmac(aes)", &shash);
 580                 if (rc)
 581                         return rc;
 582         } else {
 583                 shash = server->secmech.aes_cmac;
 584         }
 585
 586         memset(smb3_signature, 0x0, SMB2_CMACAES_SIZE);
 587         memset(shdr->Signature, 0x0, SMB2_SIGNATURE_SIZE);
 588
 589         rc = crypto_shash_setkey(shash->tfm, key, SMB2_CMACAES_SIZE);
 590         if (rc) {
 591                 cifs_server_dbg(VFS, "%s: Could not set key for cmac aes\n", __func__);
 592                 goto out;
 593         }
 594
 595         /*
 596          * we already allocate aes_cmac when we init smb3 signing key,
 597          * so unlike smb2 case we do not have to check here if secmech are
 598          * initialized
 599          */
 600         rc = crypto_shash_init(shash);
 601         if (rc) {
 602                 cifs_server_dbg(VFS, "%s: Could not init cmac aes\n", __func__);
 603                 goto out;
 604         }
 605
 606         /*
 607          * For SMB2+, __cifs_calc_signature() expects to sign only the actual
 608          * data, that is, iov[0] should not contain a rfc1002 length.
 609          *
 610          * Sign the rfc1002 length prior to passing the data (iov[1-N]) down to
 611          * __cifs_calc_signature().
 612          */
 613         drqst = *rqst;
 614         if (drqst.rq_nvec >= 2 && iov[0].iov_len == 4) {
 615                 rc = crypto_shash_update(shash, iov[0].iov_base,
 616                                          iov[0].iov_len);
 617                 if (rc) {
 618                         cifs_server_dbg(VFS, "%s: Could not update with payload\n",
 619                                  __func__);
 620                         goto out;
 621                 }
 622                 drqst.rq_iov++;
 623                 drqst.rq_nvec--;
 624         }
 625
 626         rc = __cifs_calc_signature(&drqst, server, sigptr, shash);
 627         if (!rc)
 628                 memcpy(shdr->Signature, sigptr, SMB2_SIGNATURE_SIZE);
 629
 630 out:
 631         if (allocate_crypto)
 632                 cifs_free_hash(&shash);
 633         return rc;
 634 }
 635
 636 /* must be called with server->srv_mutex held */
 637 static int
 638 smb2_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server)
 639 {
 640         int rc = 0;
 641         struct smb2_hdr *shdr;
 642         struct smb2_sess_setup_req *ssr;
 643         bool is_binding;
 644         bool is_signed;
 645
 646         shdr = (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
 647         ssr = (struct smb2_sess_setup_req *)shdr;
 648
 649         is_binding = shdr->Command == SMB2_SESSION_SETUP &&
 650                 (ssr->Flags & SMB2_SESSION_REQ_FLAG_BINDING);
 651         is_signed = shdr->Flags & SMB2_FLAGS_SIGNED;
 652
 653         if (!is_signed)
 654                 return 0;
 655         spin_lock(&server->srv_lock);
 656         if (server->ops->need_neg &&
 657             server->ops->need_neg(server)) {
 658                 spin_unlock(&server->srv_lock);
 659                 return 0;
 660         }
 661         spin_unlock(&server->srv_lock);
 662         if (!is_binding && !server->session_estab) {
 663                 strncpy(shdr->Signature, "BSRSPYL", 8);
 664                 return 0;
 665         }
 666
 667         rc = server->ops->calc_signature(rqst, server, false);
 668
 669         return rc;
 670 }
 671
 672 int
 673 smb2_verify_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server)
 674 {
 675         unsigned int rc;
 676         char server_response_sig[SMB2_SIGNATURE_SIZE];
 677         struct smb2_hdr *shdr =
 678                         (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
 679
 680         if ((shdr->Command == SMB2_NEGOTIATE) ||
 681             (shdr->Command == SMB2_SESSION_SETUP) ||
 682             (shdr->Command == SMB2_OPLOCK_BREAK) ||
 683             server->ignore_signature ||
 684             (!server->session_estab))
 685                 return 0;
 686
 687         /*
 688          * BB what if signatures are supposed to be on for session but
 689          * server does not send one? BB
 690          */
 691
 692         /* Do not need to verify session setups with signature "BSRSPYL " */
 693         if (memcmp(shdr->Signature, "BSRSPYL ", 8) == 0)
 694                 cifs_dbg(FYI, "dummy signature received for smb command 0x%x\n",
 695                          shdr->Command);
 696
 697         /*
 698          * Save off the origiginal signature so we can modify the smb and check
 699          * our calculated signature against what the server sent.
 700          */
 701         memcpy(server_response_sig, shdr->Signature, SMB2_SIGNATURE_SIZE);
 702
 703         memset(shdr->Signature, 0, SMB2_SIGNATURE_SIZE);
 704
 705         rc = server->ops->calc_signature(rqst, server, true);
 706
 707         if (rc)
 708                 return rc;
 709
 710         if (memcmp(server_response_sig, shdr->Signature, SMB2_SIGNATURE_SIZE)) {
 711                 cifs_dbg(VFS, "sign fail cmd 0x%x message id 0x%llx\n",
 712                         shdr->Command, shdr->MessageId);
 713                 return -EACCES;
 714         } else
 715                 return 0;
 716 }
 717
 718 /*
 719  * Set message id for the request. Should be called after wait_for_free_request
 720  * and when srv_mutex is held.
 721  */
 722 static inline void
 723 smb2_seq_num_into_buf(struct TCP_Server_Info *server,
 724                       struct smb2_hdr *shdr)
 725 {
 726         unsigned int i, num = le16_to_cpu(shdr->CreditCharge);
 727
 728         shdr->MessageId = get_next_mid64(server);
 729         /* skip message numbers according to CreditCharge field */
 730         for (i = 1; i < num; i++)
 731                 get_next_mid(server);
 732 }
 733
 734 static struct mid_q_entry *
 735 smb2_mid_entry_alloc(const struct smb2_hdr *shdr,
 736                      struct TCP_Server_Info *server)
 737 {
 738         struct mid_q_entry *temp;
 739         unsigned int credits = le16_to_cpu(shdr->CreditCharge);
 740
 741         if (server == NULL) {
 742                 cifs_dbg(VFS, "Null TCP session in smb2_mid_entry_alloc\n");
 743                 return NULL;
 744         }
 745
 746         temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
 747         memset(temp, 0, sizeof(struct mid_q_entry));
 748         kref_init(&temp->refcount);
 749         temp->mid = le64_to_cpu(shdr->MessageId);
 750         temp->credits = credits > 0 ? credits : 1;
 751         temp->pid = current->pid;
 752         temp->command = shdr->Command; /* Always LE */
 753         temp->when_alloc = jiffies;
 754         temp->server = server;
 755
 756         /*
 757          * The default is for the mid to be synchronous, so the
 758          * default callback just wakes up the current task.
 759          */
 760         get_task_struct(current);
 761         temp->creator = current;
 762         temp->callback = cifs_wake_up_task;
 763         temp->callback_data = current;
 764
 765         atomic_inc(&mid_count);
 766         temp->mid_state = MID_REQUEST_ALLOCATED;
 767         trace_smb3_cmd_enter(le32_to_cpu(shdr->Id.SyncId.TreeId),
 768                              le64_to_cpu(shdr->SessionId),
 769                              le16_to_cpu(shdr->Command), temp->mid);
 770         return temp;
 771 }
 772
 773 static int
 774 smb2_get_mid_entry(struct cifs_ses *ses, struct TCP_Server_Info *server,
 775                    struct smb2_hdr *shdr, struct mid_q_entry **mid)
 776 {
 777         spin_lock(&server->srv_lock);
 778         if (server->tcpStatus == CifsExiting) {
 779                 spin_unlock(&server->srv_lock);
 780                 return -ENOENT;
 781         }
 782
 783         if (server->tcpStatus == CifsNeedReconnect) {
 784                 spin_unlock(&server->srv_lock);
 785                 cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
 786                 return -EAGAIN;
 787         }
 788
 789         if (server->tcpStatus == CifsNeedNegotiate &&
 790            shdr->Command != SMB2_NEGOTIATE) {
 791                 spin_unlock(&server->srv_lock);
 792                 return -EAGAIN;
 793         }
 794         spin_unlock(&server->srv_lock);
 795
 796         spin_lock(&ses->ses_lock);
 797         if (ses->ses_status == SES_NEW) {
 798                 if ((shdr->Command != SMB2_SESSION_SETUP) &&
 799                     (shdr->Command != SMB2_NEGOTIATE)) {
 800                         spin_unlock(&ses->ses_lock);
 801                         return -EAGAIN;
 802                 }
 803                 /* else ok - we are setting up session */
 804         }
 805
 806         if (ses->ses_status == SES_EXITING) {
 807                 if (shdr->Command != SMB2_LOGOFF) {
 808                         spin_unlock(&ses->ses_lock);
 809                         return -EAGAIN;
 810                 }
 811                 /* else ok - we are shutting down the session */
 812         }
 813         spin_unlock(&ses->ses_lock);
 814
 815         *mid = smb2_mid_entry_alloc(shdr, server);
 816         if (*mid == NULL)
 817                 return -ENOMEM;
 818         spin_lock(&server->mid_lock);
 819         list_add_tail(&(*mid)->qhead, &server->pending_mid_q);
 820         spin_unlock(&server->mid_lock);
 821
 822         return 0;
 823 }
 824
 825 int
 826 smb2_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 827                    bool log_error)
 828 {
 829         unsigned int len = mid->resp_buf_size;
 830         struct kvec iov[1];
 831         struct smb_rqst rqst = { .rq_iov = iov,
 832                                  .rq_nvec = 1 };
 833
 834         iov[0].iov_base = (char *)mid->resp_buf;
 835         iov[0].iov_len = len;
 836
 837         dump_smb(mid->resp_buf, min_t(u32, 80, len));
 838         /* convert the length into a more usable form */
 839         if (len > 24 && server->sign && !mid->decrypted) {
 840                 int rc;
 841
 842                 rc = smb2_verify_signature(&rqst, server);
 843                 if (rc)
 844                         cifs_server_dbg(VFS, "SMB signature verification returned error = %d\n",
 845                                  rc);
 846         }
 847
 848         return map_smb2_to_linux_error(mid->resp_buf, log_error);
 849 }
 850
 851 struct mid_q_entry *
 852 smb2_setup_request(struct cifs_ses *ses, struct TCP_Server_Info *server,
 853                    struct smb_rqst *rqst)
 854 {
 855         int rc;
 856         struct smb2_hdr *shdr =
 857                         (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
 858         struct mid_q_entry *mid;
 859
 860         smb2_seq_num_into_buf(server, shdr);
 861
 862         rc = smb2_get_mid_entry(ses, server, shdr, &mid);
 863         if (rc) {
 864                 revert_current_mid_from_hdr(server, shdr);
 865                 return ERR_PTR(rc);
 866         }
 867
 868         rc = smb2_sign_rqst(rqst, server);
 869         if (rc) {
 870                 revert_current_mid_from_hdr(server, shdr);
 871                 delete_mid(mid);
 872                 return ERR_PTR(rc);
 873         }
 874
 875         return mid;
 876 }
 877
 878 struct mid_q_entry *
 879 smb2_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
 880 {
 881         int rc;
 882         struct smb2_hdr *shdr =
 883                         (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
 884         struct mid_q_entry *mid;
 885
 886         spin_lock(&server->srv_lock);
 887         if (server->tcpStatus == CifsNeedNegotiate &&
 888            shdr->Command != SMB2_NEGOTIATE) {
 889                 spin_unlock(&server->srv_lock);
 890                 return ERR_PTR(-EAGAIN);
 891         }
 892         spin_unlock(&server->srv_lock);
 893
 894         smb2_seq_num_into_buf(server, shdr);
 895
 896         mid = smb2_mid_entry_alloc(shdr, server);
 897         if (mid == NULL) {
 898                 revert_current_mid_from_hdr(server, shdr);
 899                 return ERR_PTR(-ENOMEM);
 900         }
 901
 902         rc = smb2_sign_rqst(rqst, server);
 903         if (rc) {
 904                 revert_current_mid_from_hdr(server, shdr);
 905                 release_mid(mid);
 906                 return ERR_PTR(rc);
 907         }
 908
 909         return mid;
 910 }
 911
 912 int
 913 smb3_crypto_aead_allocate(struct TCP_Server_Info *server)
 914 {
 915         struct crypto_aead *tfm;
 916
 917         if (!server->secmech.enc) {
 918                 if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
 919                     (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
 920                         tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
 921                 else
 922                         tfm = crypto_alloc_aead("ccm(aes)", 0, 0);
 923                 if (IS_ERR(tfm)) {
 924                         cifs_server_dbg(VFS, "%s: Failed alloc encrypt aead\n",
 925                                  __func__);
 926                         return PTR_ERR(tfm);
 927                 }
 928                 server->secmech.enc = tfm;
 929         }
 930
 931         if (!server->secmech.dec) {
 932                 if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
 933                     (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
 934                         tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
 935                 else
 936                         tfm = crypto_alloc_aead("ccm(aes)", 0, 0);
 937                 if (IS_ERR(tfm)) {
 938                         crypto_free_aead(server->secmech.enc);
 939                         server->secmech.enc = NULL;
 940                         cifs_server_dbg(VFS, "%s: Failed to alloc decrypt aead\n",
 941                                  __func__);
 942                         return PTR_ERR(tfm);
 943                 }
 944                 server->secmech.dec = tfm;
 945         }
 946
 947         return 0;
 948 }