fs/cifs/smb2transport.c

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