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                 if (rc)
 462                         return rc;
 463                 rc = generate_key(ses, ptriplet->decryption.label,
 464                                   ptriplet->decryption.context,
 465                                   ses->smb3decryptionkey,
 466                                   SMB3_ENC_DEC_KEY_SIZE);
 467                 if (rc)
 468                         return rc;
 469         }
 470
 471 #ifdef CONFIG_CIFS_DEBUG_DUMP_KEYS
 472         cifs_dbg(VFS, "%s: dumping generated AES session keys\n", __func__);
 473         /*
 474          * The session id is opaque in terms of endianness, so we can't
 475          * print it as a long long. we dump it as we got it on the wire
 476          */
 477         cifs_dbg(VFS, "Session Id    %*ph\n", (int)sizeof(ses->Suid),
 478                         &ses->Suid);
 479         cifs_dbg(VFS, "Cipher type   %d\n", server->cipher_type);
 480         cifs_dbg(VFS, "Session Key   %*ph\n",
 481                  SMB2_NTLMV2_SESSKEY_SIZE, ses->auth_key.response);
 482         cifs_dbg(VFS, "Signing Key   %*ph\n",
 483                  SMB3_SIGN_KEY_SIZE, ses->smb3signingkey);
 484         if ((server->cipher_type == SMB2_ENCRYPTION_AES256_CCM) ||
 485                 (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM)) {
 486                 cifs_dbg(VFS, "ServerIn Key  %*ph\n",
 487                                 SMB3_GCM256_CRYPTKEY_SIZE, ses->smb3encryptionkey);
 488                 cifs_dbg(VFS, "ServerOut Key %*ph\n",
 489                                 SMB3_GCM256_CRYPTKEY_SIZE, ses->smb3decryptionkey);
 490         } else {
 491                 cifs_dbg(VFS, "ServerIn Key  %*ph\n",
 492                                 SMB3_GCM128_CRYPTKEY_SIZE, ses->smb3encryptionkey);
 493                 cifs_dbg(VFS, "ServerOut Key %*ph\n",
 494                                 SMB3_GCM128_CRYPTKEY_SIZE, ses->smb3decryptionkey);
 495         }
 496 #endif
 497         return rc;
 498 }
 499
 500 int
 501 generate_smb30signingkey(struct cifs_ses *ses,
 502                          struct TCP_Server_Info *server)
 503
 504 {
 505         struct derivation_triplet triplet;
 506         struct derivation *d;
 507
 508         d = &triplet.signing;
 509         d->label.iov_base = "SMB2AESCMAC";
 510         d->label.iov_len = 12;
 511         d->context.iov_base = "SmbSign";
 512         d->context.iov_len = 8;
 513
 514         d = &triplet.encryption;
 515         d->label.iov_base = "SMB2AESCCM";
 516         d->label.iov_len = 11;
 517         d->context.iov_base = "ServerIn ";
 518         d->context.iov_len = 10;
 519
 520         d = &triplet.decryption;
 521         d->label.iov_base = "SMB2AESCCM";
 522         d->label.iov_len = 11;
 523         d->context.iov_base = "ServerOut";
 524         d->context.iov_len = 10;
 525
 526         return generate_smb3signingkey(ses, server, &triplet);
 527 }
 528
 529 int
 530 generate_smb311signingkey(struct cifs_ses *ses,
 531                           struct TCP_Server_Info *server)
 532
 533 {
 534         struct derivation_triplet triplet;
 535         struct derivation *d;
 536
 537         d = &triplet.signing;
 538         d->label.iov_base = "SMBSigningKey";
 539         d->label.iov_len = 14;
 540         d->context.iov_base = ses->preauth_sha_hash;
 541         d->context.iov_len = 64;
 542
 543         d = &triplet.encryption;
 544         d->label.iov_base = "SMBC2SCipherKey";
 545         d->label.iov_len = 16;
 546         d->context.iov_base = ses->preauth_sha_hash;
 547         d->context.iov_len = 64;
 548
 549         d = &triplet.decryption;
 550         d->label.iov_base = "SMBS2CCipherKey";
 551         d->label.iov_len = 16;
 552         d->context.iov_base = ses->preauth_sha_hash;
 553         d->context.iov_len = 64;
 554
 555         return generate_smb3signingkey(ses, server, &triplet);
 556 }
 557
 558 int
 559 smb3_calc_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server,
 560                         bool allocate_crypto)
 561 {
 562         int rc;
 563         unsigned char smb3_signature[SMB2_CMACAES_SIZE];
 564         unsigned char *sigptr = smb3_signature;
 565         struct kvec *iov = rqst->rq_iov;
 566         struct smb2_hdr *shdr = (struct smb2_hdr *)iov[0].iov_base;
 567         struct shash_desc *shash = NULL;
 568         struct smb_rqst drqst;
 569         u8 key[SMB3_SIGN_KEY_SIZE];
 570
 571         rc = smb2_get_sign_key(le64_to_cpu(shdr->SessionId), server, key);
 572         if (unlikely(rc)) {
 573                 cifs_server_dbg(FYI, "%s: Could not get signing key\n", __func__);
 574                 return rc;
 575         }
 576
 577         if (allocate_crypto) {
 578                 rc = cifs_alloc_hash("cmac(aes)", &shash);
 579                 if (rc)
 580                         return rc;
 581         } else {
 582                 shash = server->secmech.aes_cmac;
 583         }
 584
 585         memset(smb3_signature, 0x0, SMB2_CMACAES_SIZE);
 586         memset(shdr->Signature, 0x0, SMB2_SIGNATURE_SIZE);
 587
 588         rc = crypto_shash_setkey(shash->tfm, key, SMB2_CMACAES_SIZE);
 589         if (rc) {
 590                 cifs_server_dbg(VFS, "%s: Could not set key for cmac aes\n", __func__);
 591                 goto out;
 592         }
 593
 594         /*
 595          * we already allocate aes_cmac when we init smb3 signing key,
 596          * so unlike smb2 case we do not have to check here if secmech are
 597          * initialized
 598          */
 599         rc = crypto_shash_init(shash);
 600         if (rc) {
 601                 cifs_server_dbg(VFS, "%s: Could not init cmac aes\n", __func__);
 602                 goto out;
 603         }
 604
 605         /*
 606          * For SMB2+, __cifs_calc_signature() expects to sign only the actual
 607          * data, that is, iov[0] should not contain a rfc1002 length.
 608          *
 609          * Sign the rfc1002 length prior to passing the data (iov[1-N]) down to
 610          * __cifs_calc_signature().
 611          */
 612         drqst = *rqst;
 613         if (drqst.rq_nvec >= 2 && iov[0].iov_len == 4) {
 614                 rc = crypto_shash_update(shash, iov[0].iov_base,
 615                                          iov[0].iov_len);
 616                 if (rc) {
 617                         cifs_server_dbg(VFS, "%s: Could not update with payload\n",
 618                                  __func__);
 619                         goto out;
 620                 }
 621                 drqst.rq_iov++;
 622                 drqst.rq_nvec--;
 623         }
 624
 625         rc = __cifs_calc_signature(&drqst, server, sigptr, shash);
 626         if (!rc)
 627                 memcpy(shdr->Signature, sigptr, SMB2_SIGNATURE_SIZE);
 628
 629 out:
 630         if (allocate_crypto)
 631                 cifs_free_hash(&shash);
 632         return rc;
 633 }
 634
 635 /* must be called with server->srv_mutex held */
 636 static int
 637 smb2_sign_rqst(struct smb_rqst *rqst, struct TCP_Server_Info *server)
 638 {
 639         int rc = 0;
 640         struct smb2_hdr *shdr;
 641         struct smb2_sess_setup_req *ssr;
 642         bool is_binding;
 643         bool is_signed;
 644
 645         shdr = (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
 646         ssr = (struct smb2_sess_setup_req *)shdr;
 647
 648         is_binding = shdr->Command == SMB2_SESSION_SETUP &&
 649                 (ssr->Flags & SMB2_SESSION_REQ_FLAG_BINDING);
 650         is_signed = shdr->Flags & SMB2_FLAGS_SIGNED;
 651
 652         if (!is_signed)
 653                 return 0;
 654         spin_lock(&server->srv_lock);
 655         if (server->ops->need_neg &&
 656             server->ops->need_neg(server)) {
 657                 spin_unlock(&server->srv_lock);
 658                 return 0;
 659         }
 660         spin_unlock(&server->srv_lock);
 661         if (!is_binding && !server->session_estab) {
 662                 strncpy(shdr->Signature, "BSRSPYL", 8);
 663                 return 0;
 664         }
 665
 666         rc = server->ops->calc_signature(rqst, server, false);
 667
 668         return rc;
 669 }
 670
 671 int
 672 smb2_verify_signature(struct smb_rqst *rqst, struct TCP_Server_Info *server)
 673 {
 674         unsigned int rc;
 675         char server_response_sig[SMB2_SIGNATURE_SIZE];
 676         struct smb2_hdr *shdr =
 677                         (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
 678
 679         if ((shdr->Command == SMB2_NEGOTIATE) ||
 680             (shdr->Command == SMB2_SESSION_SETUP) ||
 681             (shdr->Command == SMB2_OPLOCK_BREAK) ||
 682             server->ignore_signature ||
 683             (!server->session_estab))
 684                 return 0;
 685
 686         /*
 687          * BB what if signatures are supposed to be on for session but
 688          * server does not send one? BB
 689          */
 690
 691         /* Do not need to verify session setups with signature "BSRSPYL " */
 692         if (memcmp(shdr->Signature, "BSRSPYL ", 8) == 0)
 693                 cifs_dbg(FYI, "dummy signature received for smb command 0x%x\n",
 694                          shdr->Command);
 695
 696         /*
 697          * Save off the origiginal signature so we can modify the smb and check
 698          * our calculated signature against what the server sent.
 699          */
 700         memcpy(server_response_sig, shdr->Signature, SMB2_SIGNATURE_SIZE);
 701
 702         memset(shdr->Signature, 0, SMB2_SIGNATURE_SIZE);
 703
 704         rc = server->ops->calc_signature(rqst, server, true);
 705
 706         if (rc)
 707                 return rc;
 708
 709         if (memcmp(server_response_sig, shdr->Signature, SMB2_SIGNATURE_SIZE)) {
 710                 cifs_dbg(VFS, "sign fail cmd 0x%x message id 0x%llx\n",
 711                         shdr->Command, shdr->MessageId);
 712                 return -EACCES;
 713         } else
 714                 return 0;
 715 }
 716
 717 /*
 718  * Set message id for the request. Should be called after wait_for_free_request
 719  * and when srv_mutex is held.
 720  */
 721 static inline void
 722 smb2_seq_num_into_buf(struct TCP_Server_Info *server,
 723                       struct smb2_hdr *shdr)
 724 {
 725         unsigned int i, num = le16_to_cpu(shdr->CreditCharge);
 726
 727         shdr->MessageId = get_next_mid64(server);
 728         /* skip message numbers according to CreditCharge field */
 729         for (i = 1; i < num; i++)
 730                 get_next_mid(server);
 731 }
 732
 733 static struct mid_q_entry *
 734 smb2_mid_entry_alloc(const struct smb2_hdr *shdr,
 735                      struct TCP_Server_Info *server)
 736 {
 737         struct mid_q_entry *temp;
 738         unsigned int credits = le16_to_cpu(shdr->CreditCharge);
 739
 740         if (server == NULL) {
 741                 cifs_dbg(VFS, "Null TCP session in smb2_mid_entry_alloc\n");
 742                 return NULL;
 743         }
 744
 745         temp = mempool_alloc(cifs_mid_poolp, GFP_NOFS);
 746         memset(temp, 0, sizeof(struct mid_q_entry));
 747         kref_init(&temp->refcount);
 748         temp->mid = le64_to_cpu(shdr->MessageId);
 749         temp->credits = credits > 0 ? credits : 1;
 750         temp->pid = current->pid;
 751         temp->command = shdr->Command; /* Always LE */
 752         temp->when_alloc = jiffies;
 753         temp->server = server;
 754
 755         /*
 756          * The default is for the mid to be synchronous, so the
 757          * default callback just wakes up the current task.
 758          */
 759         get_task_struct(current);
 760         temp->creator = current;
 761         temp->callback = cifs_wake_up_task;
 762         temp->callback_data = current;
 763
 764         atomic_inc(&mid_count);
 765         temp->mid_state = MID_REQUEST_ALLOCATED;
 766         trace_smb3_cmd_enter(le32_to_cpu(shdr->Id.SyncId.TreeId),
 767                              le64_to_cpu(shdr->SessionId),
 768                              le16_to_cpu(shdr->Command), temp->mid);
 769         return temp;
 770 }
 771
 772 static int
 773 smb2_get_mid_entry(struct cifs_ses *ses, struct TCP_Server_Info *server,
 774                    struct smb2_hdr *shdr, struct mid_q_entry **mid)
 775 {
 776         spin_lock(&server->srv_lock);
 777         if (server->tcpStatus == CifsExiting) {
 778                 spin_unlock(&server->srv_lock);
 779                 return -ENOENT;
 780         }
 781
 782         if (server->tcpStatus == CifsNeedReconnect) {
 783                 spin_unlock(&server->srv_lock);
 784                 cifs_dbg(FYI, "tcp session dead - return to caller to retry\n");
 785                 return -EAGAIN;
 786         }
 787
 788         if (server->tcpStatus == CifsNeedNegotiate &&
 789            shdr->Command != SMB2_NEGOTIATE) {
 790                 spin_unlock(&server->srv_lock);
 791                 return -EAGAIN;
 792         }
 793         spin_unlock(&server->srv_lock);
 794
 795         spin_lock(&ses->ses_lock);
 796         if (ses->ses_status == SES_NEW) {
 797                 if ((shdr->Command != SMB2_SESSION_SETUP) &&
 798                     (shdr->Command != SMB2_NEGOTIATE)) {
 799                         spin_unlock(&ses->ses_lock);
 800                         return -EAGAIN;
 801                 }
 802                 /* else ok - we are setting up session */
 803         }
 804
 805         if (ses->ses_status == SES_EXITING) {
 806                 if (shdr->Command != SMB2_LOGOFF) {
 807                         spin_unlock(&ses->ses_lock);
 808                         return -EAGAIN;
 809                 }
 810                 /* else ok - we are shutting down the session */
 811         }
 812         spin_unlock(&ses->ses_lock);
 813
 814         *mid = smb2_mid_entry_alloc(shdr, server);
 815         if (*mid == NULL)
 816                 return -ENOMEM;
 817         spin_lock(&server->mid_lock);
 818         list_add_tail(&(*mid)->qhead, &server->pending_mid_q);
 819         spin_unlock(&server->mid_lock);
 820
 821         return 0;
 822 }
 823
 824 int
 825 smb2_check_receive(struct mid_q_entry *mid, struct TCP_Server_Info *server,
 826                    bool log_error)
 827 {
 828         unsigned int len = mid->resp_buf_size;
 829         struct kvec iov[1];
 830         struct smb_rqst rqst = { .rq_iov = iov,
 831                                  .rq_nvec = 1 };
 832
 833         iov[0].iov_base = (char *)mid->resp_buf;
 834         iov[0].iov_len = len;
 835
 836         dump_smb(mid->resp_buf, min_t(u32, 80, len));
 837         /* convert the length into a more usable form */
 838         if (len > 24 && server->sign && !mid->decrypted) {
 839                 int rc;
 840
 841                 rc = smb2_verify_signature(&rqst, server);
 842                 if (rc)
 843                         cifs_server_dbg(VFS, "SMB signature verification returned error = %d\n",
 844                                  rc);
 845         }
 846
 847         return map_smb2_to_linux_error(mid->resp_buf, log_error);
 848 }
 849
 850 struct mid_q_entry *
 851 smb2_setup_request(struct cifs_ses *ses, struct TCP_Server_Info *server,
 852                    struct smb_rqst *rqst)
 853 {
 854         int rc;
 855         struct smb2_hdr *shdr =
 856                         (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
 857         struct mid_q_entry *mid;
 858
 859         smb2_seq_num_into_buf(server, shdr);
 860
 861         rc = smb2_get_mid_entry(ses, server, shdr, &mid);
 862         if (rc) {
 863                 revert_current_mid_from_hdr(server, shdr);
 864                 return ERR_PTR(rc);
 865         }
 866
 867         rc = smb2_sign_rqst(rqst, server);
 868         if (rc) {
 869                 revert_current_mid_from_hdr(server, shdr);
 870                 delete_mid(mid);
 871                 return ERR_PTR(rc);
 872         }
 873
 874         return mid;
 875 }
 876
 877 struct mid_q_entry *
 878 smb2_setup_async_request(struct TCP_Server_Info *server, struct smb_rqst *rqst)
 879 {
 880         int rc;
 881         struct smb2_hdr *shdr =
 882                         (struct smb2_hdr *)rqst->rq_iov[0].iov_base;
 883         struct mid_q_entry *mid;
 884
 885         spin_lock(&server->srv_lock);
 886         if (server->tcpStatus == CifsNeedNegotiate &&
 887            shdr->Command != SMB2_NEGOTIATE) {
 888                 spin_unlock(&server->srv_lock);
 889                 return ERR_PTR(-EAGAIN);
 890         }
 891         spin_unlock(&server->srv_lock);
 892
 893         smb2_seq_num_into_buf(server, shdr);
 894
 895         mid = smb2_mid_entry_alloc(shdr, server);
 896         if (mid == NULL) {
 897                 revert_current_mid_from_hdr(server, shdr);
 898                 return ERR_PTR(-ENOMEM);
 899         }
 900
 901         rc = smb2_sign_rqst(rqst, server);
 902         if (rc) {
 903                 revert_current_mid_from_hdr(server, shdr);
 904                 release_mid(mid);
 905                 return ERR_PTR(rc);
 906         }
 907
 908         return mid;
 909 }
 910
 911 int
 912 smb3_crypto_aead_allocate(struct TCP_Server_Info *server)
 913 {
 914         struct crypto_aead *tfm;
 915
 916         if (!server->secmech.enc) {
 917                 if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
 918                     (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
 919                         tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
 920                 else
 921                         tfm = crypto_alloc_aead("ccm(aes)", 0, 0);
 922                 if (IS_ERR(tfm)) {
 923                         cifs_server_dbg(VFS, "%s: Failed alloc encrypt aead\n",
 924                                  __func__);
 925                         return PTR_ERR(tfm);
 926                 }
 927                 server->secmech.enc = tfm;
 928         }
 929
 930         if (!server->secmech.dec) {
 931                 if ((server->cipher_type == SMB2_ENCRYPTION_AES128_GCM) ||
 932                     (server->cipher_type == SMB2_ENCRYPTION_AES256_GCM))
 933                         tfm = crypto_alloc_aead("gcm(aes)", 0, 0);
 934                 else
 935                         tfm = crypto_alloc_aead("ccm(aes)", 0, 0);
 936                 if (IS_ERR(tfm)) {
 937                         crypto_free_aead(server->secmech.enc);
 938                         server->secmech.enc = NULL;
 939                         cifs_server_dbg(VFS, "%s: Failed to alloc decrypt aead\n",
 940                                  __func__);
 941                         return PTR_ERR(tfm);
 942                 }
 943                 server->secmech.dec = tfm;
 944         }
 945
 946         return 0;
 947 }