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