fs/cifs/sess.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  *
   4  *   SMB/CIFS session setup handling routines
   5  *
   6  *   Copyright (c) International Business Machines  Corp., 2006, 2009
   7  *   Author(s): Steve French ([email protected])
   8  *
   9  */
  10
  11 #include "cifspdu.h"
  12 #include "cifsglob.h"
  13 #include "cifsproto.h"
  14 #include "cifs_unicode.h"
  15 #include "cifs_debug.h"
  16 #include "ntlmssp.h"
  17 #include "nterr.h"
  18 #include <linux/utsname.h>
  19 #include <linux/slab.h>
  20 #include "cifs_spnego.h"
  21 #include "smb2proto.h"
  22 #include "fs_context.h"
  23
  24 static int
  25 cifs_ses_add_channel(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
  26                      struct cifs_server_iface *iface);
  27
  28 bool
  29 is_server_using_iface(struct TCP_Server_Info *server,
  30                       struct cifs_server_iface *iface)
  31 {
  32         struct sockaddr_in *i4 = (struct sockaddr_in *)&iface->sockaddr;
  33         struct sockaddr_in6 *i6 = (struct sockaddr_in6 *)&iface->sockaddr;
  34         struct sockaddr_in *s4 = (struct sockaddr_in *)&server->dstaddr;
  35         struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)&server->dstaddr;
  36
  37         if (server->dstaddr.ss_family != iface->sockaddr.ss_family)
  38                 return false;
  39         if (server->dstaddr.ss_family == AF_INET) {
  40                 if (s4->sin_addr.s_addr != i4->sin_addr.s_addr)
  41                         return false;
  42         } else if (server->dstaddr.ss_family == AF_INET6) {
  43                 if (memcmp(&s6->sin6_addr, &i6->sin6_addr,
  44                            sizeof(i6->sin6_addr)) != 0)
  45                         return false;
  46         } else {
  47                 /* unknown family.. */
  48                 return false;
  49         }
  50         return true;
  51 }
  52
  53 bool is_ses_using_iface(struct cifs_ses *ses, struct cifs_server_iface *iface)
  54 {
  55         int i;
  56
  57         spin_lock(&ses->chan_lock);
  58         for (i = 0; i < ses->chan_count; i++) {
  59                 if (is_server_using_iface(ses->chans[i].server, iface)) {
  60                         spin_unlock(&ses->chan_lock);
  61                         return true;
  62                 }
  63         }
  64         spin_unlock(&ses->chan_lock);
  65         return false;
  66 }
  67
  68 /* returns number of channels added */
  69 int cifs_try_adding_channels(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses)
  70 {
  71         int old_chan_count, new_chan_count;
  72         int left;
  73         int i = 0;
  74         int rc = 0;
  75         int tries = 0;
  76         struct cifs_server_iface *ifaces = NULL;
  77         size_t iface_count;
  78
  79         if (ses->server->dialect < SMB30_PROT_ID) {
  80                 cifs_dbg(VFS, "multichannel is not supported on this protocol version, use 3.0 or above\n");
  81                 return 0;
  82         }
  83
  84         spin_lock(&ses->chan_lock);
  85
  86         new_chan_count = old_chan_count = ses->chan_count;
  87         left = ses->chan_max - ses->chan_count;
  88
  89         if (left <= 0) {
  90                 cifs_dbg(FYI,
  91                          "ses already at max_channels (%zu), nothing to open\n",
  92                          ses->chan_max);
  93                 spin_unlock(&ses->chan_lock);
  94                 return 0;
  95         }
  96
  97         if (!(ses->server->capabilities & SMB2_GLOBAL_CAP_MULTI_CHANNEL)) {
  98                 ses->chan_max = 1;
  99                 spin_unlock(&ses->chan_lock);
 100                 cifs_dbg(VFS, "server %s does not support multichannel\n", ses->server->hostname);
 101                 return 0;
 102         }
 103         spin_unlock(&ses->chan_lock);
 104
 105         /*
 106          * Make a copy of the iface list at the time and use that
 107          * instead so as to not hold the iface spinlock for opening
 108          * channels
 109          */
 110         spin_lock(&ses->iface_lock);
 111         iface_count = ses->iface_count;
 112         if (iface_count <= 0) {
 113                 spin_unlock(&ses->iface_lock);
 114                 cifs_dbg(VFS, "no iface list available to open channels\n");
 115                 return 0;
 116         }
 117         ifaces = kmemdup(ses->iface_list, iface_count*sizeof(*ifaces),
 118                          GFP_ATOMIC);
 119         if (!ifaces) {
 120                 spin_unlock(&ses->iface_lock);
 121                 return 0;
 122         }
 123         spin_unlock(&ses->iface_lock);
 124
 125         /*
 126          * Keep connecting to same, fastest, iface for all channels as
 127          * long as its RSS. Try next fastest one if not RSS or channel
 128          * creation fails.
 129          */
 130         while (left > 0) {
 131                 struct cifs_server_iface *iface;
 132
 133                 tries++;
 134                 if (tries > 3*ses->chan_max) {
 135                         cifs_dbg(FYI, "too many channel open attempts (%d channels left to open)\n",
 136                                  left);
 137                         break;
 138                 }
 139
 140                 iface = &ifaces[i];
 141                 if (is_ses_using_iface(ses, iface) && !iface->rss_capable) {
 142                         i = (i+1) % iface_count;
 143                         continue;
 144                 }
 145
 146                 rc = cifs_ses_add_channel(cifs_sb, ses, iface);
 147                 if (rc) {
 148                         cifs_dbg(FYI, "failed to open extra channel on iface#%d rc=%d\n",
 149                                  i, rc);
 150                         i = (i+1) % iface_count;
 151                         continue;
 152                 }
 153
 154                 cifs_dbg(FYI, "successfully opened new channel on iface#%d\n",
 155                          i);
 156                 left--;
 157                 new_chan_count++;
 158         }
 159
 160         kfree(ifaces);
 161         return new_chan_count - old_chan_count;
 162 }
 163
 164 /*
 165  * If server is a channel of ses, return the corresponding enclosing
 166  * cifs_chan otherwise return NULL.
 167  */
 168 struct cifs_chan *
 169 cifs_ses_find_chan(struct cifs_ses *ses, struct TCP_Server_Info *server)
 170 {
 171         int i;
 172
 173         spin_lock(&ses->chan_lock);
 174         for (i = 0; i < ses->chan_count; i++) {
 175                 if (ses->chans[i].server == server) {
 176                         spin_unlock(&ses->chan_lock);
 177                         return &ses->chans[i];
 178                 }
 179         }
 180         spin_unlock(&ses->chan_lock);
 181         return NULL;
 182 }
 183
 184 static int
 185 cifs_ses_add_channel(struct cifs_sb_info *cifs_sb, struct cifs_ses *ses,
 186                      struct cifs_server_iface *iface)
 187 {
 188         struct TCP_Server_Info *chan_server;
 189         struct cifs_chan *chan;
 190         struct smb3_fs_context ctx = {NULL};
 191         static const char unc_fmt[] = "\\%s\\foo";
 192         char unc[sizeof(unc_fmt)+SERVER_NAME_LEN_WITH_NULL] = {0};
 193         struct sockaddr_in *ipv4 = (struct sockaddr_in *)&iface->sockaddr;
 194         struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)&iface->sockaddr;
 195         int rc;
 196         unsigned int xid = get_xid();
 197
 198         if (iface->sockaddr.ss_family == AF_INET)
 199                 cifs_dbg(FYI, "adding channel to ses %p (speed:%zu bps rdma:%s ip:%pI4)\n",
 200                          ses, iface->speed, iface->rdma_capable ? "yes" : "no",
 201                          &ipv4->sin_addr);
 202         else
 203                 cifs_dbg(FYI, "adding channel to ses %p (speed:%zu bps rdma:%s ip:%pI6)\n",
 204                          ses, iface->speed, iface->rdma_capable ? "yes" : "no",
 205                          &ipv6->sin6_addr);
 206
 207         /*
 208          * Setup a ctx with mostly the same info as the existing
 209          * session and overwrite it with the requested iface data.
 210          *
 211          * We need to setup at least the fields used for negprot and
 212          * sesssetup.
 213          *
 214          * We only need the ctx here, so we can reuse memory from
 215          * the session and server without caring about memory
 216          * management.
 217          */
 218
 219         /* Always make new connection for now (TODO?) */
 220         ctx.nosharesock = true;
 221
 222         /* Auth */
 223         ctx.domainauto = ses->domainAuto;
 224         ctx.domainname = ses->domainName;
 225         ctx.server_hostname = ses->server->hostname;
 226         ctx.username = ses->user_name;
 227         ctx.password = ses->password;
 228         ctx.sectype = ses->sectype;
 229         ctx.sign = ses->sign;
 230
 231         /* UNC and paths */
 232         /* XXX: Use ses->server->hostname? */
 233         sprintf(unc, unc_fmt, ses->ip_addr);
 234         ctx.UNC = unc;
 235         ctx.prepath = "";
 236
 237         /* Reuse same version as master connection */
 238         ctx.vals = ses->server->vals;
 239         ctx.ops = ses->server->ops;
 240
 241         ctx.noblocksnd = ses->server->noblocksnd;
 242         ctx.noautotune = ses->server->noautotune;
 243         ctx.sockopt_tcp_nodelay = ses->server->tcp_nodelay;
 244         ctx.echo_interval = ses->server->echo_interval / HZ;
 245         ctx.max_credits = ses->server->max_credits;
 246
 247         /*
 248          * This will be used for encoding/decoding user/domain/pw
 249          * during sess setup auth.
 250          */
 251         ctx.local_nls = cifs_sb->local_nls;
 252
 253         /* Use RDMA if possible */
 254         ctx.rdma = iface->rdma_capable;
 255         memcpy(&ctx.dstaddr, &iface->sockaddr, sizeof(struct sockaddr_storage));
 256
 257         /* reuse master con client guid */
 258         memcpy(&ctx.client_guid, ses->server->client_guid,
 259                SMB2_CLIENT_GUID_SIZE);
 260         ctx.use_client_guid = true;
 261
 262         chan_server = cifs_get_tcp_session(&ctx, ses->server);
 263
 264         mutex_lock(&ses->session_mutex);
 265         spin_lock(&ses->chan_lock);
 266         chan = ses->binding_chan = &ses->chans[ses->chan_count];
 267         chan->server = chan_server;
 268         if (IS_ERR(chan->server)) {
 269                 rc = PTR_ERR(chan->server);
 270                 chan->server = NULL;
 271                 spin_unlock(&ses->chan_lock);
 272                 goto out;
 273         }
 274         spin_unlock(&ses->chan_lock);
 275
 276         /*
 277          * We need to allocate the server crypto now as we will need
 278          * to sign packets before we generate the channel signing key
 279          * (we sign with the session key)
 280          */
 281         rc = smb311_crypto_shash_allocate(chan->server);
 282         if (rc) {
 283                 cifs_dbg(VFS, "%s: crypto alloc failed\n", __func__);
 284                 goto out;
 285         }
 286
 287         ses->binding = true;
 288         rc = cifs_negotiate_protocol(xid, ses);
 289         if (rc)
 290                 goto out;
 291
 292         rc = cifs_setup_session(xid, ses, cifs_sb->local_nls);
 293         if (rc)
 294                 goto out;
 295
 296         /* success, put it on the list
 297          * XXX: sharing ses between 2 tcp servers is not possible, the
 298          * way "internal" linked lists works in linux makes element
 299          * only able to belong to one list
 300          *
 301          * the binding session is already established so the rest of
 302          * the code should be able to look it up, no need to add the
 303          * ses to the new server.
 304          */
 305
 306         spin_lock(&ses->chan_lock);
 307         ses->chan_count++;
 308         atomic_set(&ses->chan_seq, 0);
 309         spin_unlock(&ses->chan_lock);
 310
 311 out:
 312         ses->binding = false;
 313         ses->binding_chan = NULL;
 314         mutex_unlock(&ses->session_mutex);
 315
 316         if (rc && chan->server)
 317                 cifs_put_tcp_session(chan->server, 0);
 318
 319         return rc;
 320 }
 321
 322 /* Mark all session channels for reconnect */
 323 void cifs_ses_mark_for_reconnect(struct cifs_ses *ses)
 324 {
 325         int i;
 326
 327         for (i = 0; i < ses->chan_count; i++) {
 328                 spin_lock(&GlobalMid_Lock);
 329                 if (ses->chans[i].server->tcpStatus != CifsExiting)
 330                         ses->chans[i].server->tcpStatus = CifsNeedReconnect;
 331                 spin_unlock(&GlobalMid_Lock);
 332         }
 333 }
 334
 335 static __u32 cifs_ssetup_hdr(struct cifs_ses *ses, SESSION_SETUP_ANDX *pSMB)
 336 {
 337         __u32 capabilities = 0;
 338
 339         /* init fields common to all four types of SessSetup */
 340         /* Note that offsets for first seven fields in req struct are same  */
 341         /*      in CIFS Specs so does not matter which of 3 forms of struct */
 342         /*      that we use in next few lines                               */
 343         /* Note that header is initialized to zero in header_assemble */
 344         pSMB->req.AndXCommand = 0xFF;
 345         pSMB->req.MaxBufferSize = cpu_to_le16(min_t(u32,
 346                                         CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4,
 347                                         USHRT_MAX));
 348         pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
 349         pSMB->req.VcNumber = cpu_to_le16(1);
 350
 351         /* Now no need to set SMBFLG_CASELESS or obsolete CANONICAL PATH */
 352
 353         /* BB verify whether signing required on neg or just on auth frame
 354            (and NTLM case) */
 355
 356         capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
 357                         CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
 358
 359         if (ses->server->sign)
 360                 pSMB->req.hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 361
 362         if (ses->capabilities & CAP_UNICODE) {
 363                 pSMB->req.hdr.Flags2 |= SMBFLG2_UNICODE;
 364                 capabilities |= CAP_UNICODE;
 365         }
 366         if (ses->capabilities & CAP_STATUS32) {
 367                 pSMB->req.hdr.Flags2 |= SMBFLG2_ERR_STATUS;
 368                 capabilities |= CAP_STATUS32;
 369         }
 370         if (ses->capabilities & CAP_DFS) {
 371                 pSMB->req.hdr.Flags2 |= SMBFLG2_DFS;
 372                 capabilities |= CAP_DFS;
 373         }
 374         if (ses->capabilities & CAP_UNIX)
 375                 capabilities |= CAP_UNIX;
 376
 377         return capabilities;
 378 }
 379
 380 static void
 381 unicode_oslm_strings(char **pbcc_area, const struct nls_table *nls_cp)
 382 {
 383         char *bcc_ptr = *pbcc_area;
 384         int bytes_ret = 0;
 385
 386         /* Copy OS version */
 387         bytes_ret = cifs_strtoUTF16((__le16 *)bcc_ptr, "Linux version ", 32,
 388                                     nls_cp);
 389         bcc_ptr += 2 * bytes_ret;
 390         bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, init_utsname()->release,
 391                                     32, nls_cp);
 392         bcc_ptr += 2 * bytes_ret;
 393         bcc_ptr += 2; /* trailing null */
 394
 395         bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
 396                                     32, nls_cp);
 397         bcc_ptr += 2 * bytes_ret;
 398         bcc_ptr += 2; /* trailing null */
 399
 400         *pbcc_area = bcc_ptr;
 401 }
 402
 403 static void unicode_domain_string(char **pbcc_area, struct cifs_ses *ses,
 404                                    const struct nls_table *nls_cp)
 405 {
 406         char *bcc_ptr = *pbcc_area;
 407         int bytes_ret = 0;
 408
 409         /* copy domain */
 410         if (ses->domainName == NULL) {
 411                 /* Sending null domain better than using a bogus domain name (as
 412                 we did briefly in 2.6.18) since server will use its default */
 413                 *bcc_ptr = 0;
 414                 *(bcc_ptr+1) = 0;
 415                 bytes_ret = 0;
 416         } else
 417                 bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->domainName,
 418                                             CIFS_MAX_DOMAINNAME_LEN, nls_cp);
 419         bcc_ptr += 2 * bytes_ret;
 420         bcc_ptr += 2;  /* account for null terminator */
 421
 422         *pbcc_area = bcc_ptr;
 423 }
 424
 425
 426 static void unicode_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
 427                                    const struct nls_table *nls_cp)
 428 {
 429         char *bcc_ptr = *pbcc_area;
 430         int bytes_ret = 0;
 431
 432         /* BB FIXME add check that strings total less
 433         than 335 or will need to send them as arrays */
 434
 435         /* unicode strings, must be word aligned before the call */
 436 /*      if ((long) bcc_ptr % 2) {
 437                 *bcc_ptr = 0;
 438                 bcc_ptr++;
 439         } */
 440         /* copy user */
 441         if (ses->user_name == NULL) {
 442                 /* null user mount */
 443                 *bcc_ptr = 0;
 444                 *(bcc_ptr+1) = 0;
 445         } else {
 446                 bytes_ret = cifs_strtoUTF16((__le16 *) bcc_ptr, ses->user_name,
 447                                             CIFS_MAX_USERNAME_LEN, nls_cp);
 448         }
 449         bcc_ptr += 2 * bytes_ret;
 450         bcc_ptr += 2; /* account for null termination */
 451
 452         unicode_domain_string(&bcc_ptr, ses, nls_cp);
 453         unicode_oslm_strings(&bcc_ptr, nls_cp);
 454
 455         *pbcc_area = bcc_ptr;
 456 }
 457
 458 static void ascii_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
 459                                  const struct nls_table *nls_cp)
 460 {
 461         char *bcc_ptr = *pbcc_area;
 462         int len;
 463
 464         /* copy user */
 465         /* BB what about null user mounts - check that we do this BB */
 466         /* copy user */
 467         if (ses->user_name != NULL) {
 468                 len = strscpy(bcc_ptr, ses->user_name, CIFS_MAX_USERNAME_LEN);
 469                 if (WARN_ON_ONCE(len < 0))
 470                         len = CIFS_MAX_USERNAME_LEN - 1;
 471                 bcc_ptr += len;
 472         }
 473         /* else null user mount */
 474         *bcc_ptr = 0;
 475         bcc_ptr++; /* account for null termination */
 476
 477         /* copy domain */
 478         if (ses->domainName != NULL) {
 479                 len = strscpy(bcc_ptr, ses->domainName, CIFS_MAX_DOMAINNAME_LEN);
 480                 if (WARN_ON_ONCE(len < 0))
 481                         len = CIFS_MAX_DOMAINNAME_LEN - 1;
 482                 bcc_ptr += len;
 483         } /* else we will send a null domain name
 484              so the server will default to its own domain */
 485         *bcc_ptr = 0;
 486         bcc_ptr++;
 487
 488         /* BB check for overflow here */
 489
 490         strcpy(bcc_ptr, "Linux version ");
 491         bcc_ptr += strlen("Linux version ");
 492         strcpy(bcc_ptr, init_utsname()->release);
 493         bcc_ptr += strlen(init_utsname()->release) + 1;
 494
 495         strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
 496         bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
 497
 498         *pbcc_area = bcc_ptr;
 499 }
 500
 501 static void
 502 decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
 503                       const struct nls_table *nls_cp)
 504 {
 505         int len;
 506         char *data = *pbcc_area;
 507
 508         cifs_dbg(FYI, "bleft %d\n", bleft);
 509
 510         kfree(ses->serverOS);
 511         ses->serverOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
 512         cifs_dbg(FYI, "serverOS=%s\n", ses->serverOS);
 513         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
 514         data += len;
 515         bleft -= len;
 516         if (bleft <= 0)
 517                 return;
 518
 519         kfree(ses->serverNOS);
 520         ses->serverNOS = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
 521         cifs_dbg(FYI, "serverNOS=%s\n", ses->serverNOS);
 522         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
 523         data += len;
 524         bleft -= len;
 525         if (bleft <= 0)
 526                 return;
 527
 528         kfree(ses->serverDomain);
 529         ses->serverDomain = cifs_strndup_from_utf16(data, bleft, true, nls_cp);
 530         cifs_dbg(FYI, "serverDomain=%s\n", ses->serverDomain);
 531
 532         return;
 533 }
 534
 535 static void decode_ascii_ssetup(char **pbcc_area, __u16 bleft,
 536                                 struct cifs_ses *ses,
 537                                 const struct nls_table *nls_cp)
 538 {
 539         int len;
 540         char *bcc_ptr = *pbcc_area;
 541
 542         cifs_dbg(FYI, "decode sessetup ascii. bleft %d\n", bleft);
 543
 544         len = strnlen(bcc_ptr, bleft);
 545         if (len >= bleft)
 546                 return;
 547
 548         kfree(ses->serverOS);
 549
 550         ses->serverOS = kmalloc(len + 1, GFP_KERNEL);
 551         if (ses->serverOS) {
 552                 memcpy(ses->serverOS, bcc_ptr, len);
 553                 ses->serverOS[len] = 0;
 554                 if (strncmp(ses->serverOS, "OS/2", 4) == 0)
 555                         cifs_dbg(FYI, "OS/2 server\n");
 556         }
 557
 558         bcc_ptr += len + 1;
 559         bleft -= len + 1;
 560
 561         len = strnlen(bcc_ptr, bleft);
 562         if (len >= bleft)
 563                 return;
 564
 565         kfree(ses->serverNOS);
 566
 567         ses->serverNOS = kmalloc(len + 1, GFP_KERNEL);
 568         if (ses->serverNOS) {
 569                 memcpy(ses->serverNOS, bcc_ptr, len);
 570                 ses->serverNOS[len] = 0;
 571         }
 572
 573         bcc_ptr += len + 1;
 574         bleft -= len + 1;
 575
 576         len = strnlen(bcc_ptr, bleft);
 577         if (len > bleft)
 578                 return;
 579
 580         /* No domain field in LANMAN case. Domain is
 581            returned by old servers in the SMB negprot response */
 582         /* BB For newer servers which do not support Unicode,
 583            but thus do return domain here we could add parsing
 584            for it later, but it is not very important */
 585         cifs_dbg(FYI, "ascii: bytes left %d\n", bleft);
 586 }
 587
 588 int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
 589                                     struct cifs_ses *ses)
 590 {
 591         unsigned int tioffset; /* challenge message target info area */
 592         unsigned int tilen; /* challenge message target info area length  */
 593
 594         CHALLENGE_MESSAGE *pblob = (CHALLENGE_MESSAGE *)bcc_ptr;
 595
 596         if (blob_len < sizeof(CHALLENGE_MESSAGE)) {
 597                 cifs_dbg(VFS, "challenge blob len %d too small\n", blob_len);
 598                 return -EINVAL;
 599         }
 600
 601         if (memcmp(pblob->Signature, "NTLMSSP", 8)) {
 602                 cifs_dbg(VFS, "blob signature incorrect %s\n",
 603                          pblob->Signature);
 604                 return -EINVAL;
 605         }
 606         if (pblob->MessageType != NtLmChallenge) {
 607                 cifs_dbg(VFS, "Incorrect message type %d\n",
 608                          pblob->MessageType);
 609                 return -EINVAL;
 610         }
 611
 612         memcpy(ses->ntlmssp->cryptkey, pblob->Challenge, CIFS_CRYPTO_KEY_SIZE);
 613         /* BB we could decode pblob->NegotiateFlags; some may be useful */
 614         /* In particular we can examine sign flags */
 615         /* BB spec says that if AvId field of MsvAvTimestamp is populated then
 616                 we must set the MIC field of the AUTHENTICATE_MESSAGE */
 617         ses->ntlmssp->server_flags = le32_to_cpu(pblob->NegotiateFlags);
 618         tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);
 619         tilen = le16_to_cpu(pblob->TargetInfoArray.Length);
 620         if (tioffset > blob_len || tioffset + tilen > blob_len) {
 621                 cifs_dbg(VFS, "tioffset + tilen too high %u + %u\n",
 622                          tioffset, tilen);
 623                 return -EINVAL;
 624         }
 625         if (tilen) {
 626                 ses->auth_key.response = kmemdup(bcc_ptr + tioffset, tilen,
 627                                                  GFP_KERNEL);
 628                 if (!ses->auth_key.response) {
 629                         cifs_dbg(VFS, "Challenge target info alloc failure\n");
 630                         return -ENOMEM;
 631                 }
 632                 ses->auth_key.len = tilen;
 633         }
 634
 635         return 0;
 636 }
 637
 638 static int size_of_ntlmssp_blob(struct cifs_ses *ses, int base_size)
 639 {
 640         int sz = base_size + ses->auth_key.len
 641                 - CIFS_SESS_KEY_SIZE + CIFS_CPHTXT_SIZE + 2;
 642
 643         if (ses->domainName)
 644                 sz += sizeof(__le16) * strnlen(ses->domainName, CIFS_MAX_DOMAINNAME_LEN);
 645         else
 646                 sz += sizeof(__le16);
 647
 648         if (ses->user_name)
 649                 sz += sizeof(__le16) * strnlen(ses->user_name, CIFS_MAX_USERNAME_LEN);
 650         else
 651                 sz += sizeof(__le16);
 652
 653         sz += sizeof(__le16) * strnlen(ses->workstation_name, CIFS_MAX_WORKSTATION_LEN);
 654
 655         return sz;
 656 }
 657
 658 static inline void cifs_security_buffer_from_str(SECURITY_BUFFER *pbuf,
 659                                                  char *str_value,
 660                                                  int str_length,
 661                                                  unsigned char *pstart,
 662                                                  unsigned char **pcur,
 663                                                  const struct nls_table *nls_cp)
 664 {
 665         unsigned char *tmp = pstart;
 666         int len;
 667
 668         if (!pbuf)
 669                 return;
 670
 671         if (!pcur)
 672                 pcur = &tmp;
 673
 674         if (!str_value) {
 675                 pbuf->BufferOffset = cpu_to_le32(*pcur - pstart);
 676                 pbuf->Length = 0;
 677                 pbuf->MaximumLength = 0;
 678                 *pcur += sizeof(__le16);
 679         } else {
 680                 len = cifs_strtoUTF16((__le16 *)*pcur,
 681                                       str_value,
 682                                       str_length,
 683                                       nls_cp);
 684                 len *= sizeof(__le16);
 685                 pbuf->BufferOffset = cpu_to_le32(*pcur - pstart);
 686                 pbuf->Length = cpu_to_le16(len);
 687                 pbuf->MaximumLength = cpu_to_le16(len);
 688                 *pcur += len;
 689         }
 690 }
 691
 692 /* BB Move to ntlmssp.c eventually */
 693
 694 int build_ntlmssp_negotiate_blob(unsigned char **pbuffer,
 695                                  u16 *buflen,
 696                                  struct cifs_ses *ses,
 697                                  const struct nls_table *nls_cp)
 698 {
 699         int rc = 0;
 700         struct TCP_Server_Info *server = cifs_ses_server(ses);
 701         NEGOTIATE_MESSAGE *sec_blob;
 702         __u32 flags;
 703         unsigned char *tmp;
 704         int len;
 705
 706         len = size_of_ntlmssp_blob(ses, sizeof(NEGOTIATE_MESSAGE));
 707         *pbuffer = kmalloc(len, GFP_KERNEL);
 708         if (!*pbuffer) {
 709                 rc = -ENOMEM;
 710                 cifs_dbg(VFS, "Error %d during NTLMSSP allocation\n", rc);
 711                 *buflen = 0;
 712                 goto setup_ntlm_neg_ret;
 713         }
 714         sec_blob = (NEGOTIATE_MESSAGE *)*pbuffer;
 715
 716         memset(*pbuffer, 0, sizeof(NEGOTIATE_MESSAGE));
 717         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
 718         sec_blob->MessageType = NtLmNegotiate;
 719
 720         /* BB is NTLMV2 session security format easier to use here? */
 721         flags = NTLMSSP_NEGOTIATE_56 |  NTLMSSP_REQUEST_TARGET |
 722                 NTLMSSP_NEGOTIATE_128 | NTLMSSP_NEGOTIATE_UNICODE |
 723                 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_EXTENDED_SEC |
 724                 NTLMSSP_NEGOTIATE_SEAL;
 725         if (server->sign)
 726                 flags |= NTLMSSP_NEGOTIATE_SIGN;
 727         if (!server->session_estab || ses->ntlmssp->sesskey_per_smbsess)
 728                 flags |= NTLMSSP_NEGOTIATE_KEY_XCH;
 729
 730         tmp = *pbuffer + sizeof(NEGOTIATE_MESSAGE);
 731         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 732
 733         /* these fields should be null in negotiate phase MS-NLMP 3.1.5.1.1 */
 734         cifs_security_buffer_from_str(&sec_blob->DomainName,
 735                                       NULL,
 736                                       CIFS_MAX_DOMAINNAME_LEN,
 737                                       *pbuffer, &tmp,
 738                                       nls_cp);
 739
 740         cifs_security_buffer_from_str(&sec_blob->WorkstationName,
 741                                       NULL,
 742                                       CIFS_MAX_WORKSTATION_LEN,
 743                                       *pbuffer, &tmp,
 744                                       nls_cp);
 745
 746         *buflen = tmp - *pbuffer;
 747 setup_ntlm_neg_ret:
 748         return rc;
 749 }
 750
 751 int build_ntlmssp_auth_blob(unsigned char **pbuffer,
 752                                         u16 *buflen,
 753                                    struct cifs_ses *ses,
 754                                    const struct nls_table *nls_cp)
 755 {
 756         int rc;
 757         AUTHENTICATE_MESSAGE *sec_blob;
 758         __u32 flags;
 759         unsigned char *tmp;
 760         int len;
 761
 762         rc = setup_ntlmv2_rsp(ses, nls_cp);
 763         if (rc) {
 764                 cifs_dbg(VFS, "Error %d during NTLMSSP authentication\n", rc);
 765                 *buflen = 0;
 766                 goto setup_ntlmv2_ret;
 767         }
 768
 769         len = size_of_ntlmssp_blob(ses, sizeof(AUTHENTICATE_MESSAGE));
 770         *pbuffer = kmalloc(len, GFP_KERNEL);
 771         if (!*pbuffer) {
 772                 rc = -ENOMEM;
 773                 cifs_dbg(VFS, "Error %d during NTLMSSP allocation\n", rc);
 774                 *buflen = 0;
 775                 goto setup_ntlmv2_ret;
 776         }
 777         sec_blob = (AUTHENTICATE_MESSAGE *)*pbuffer;
 778
 779         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
 780         sec_blob->MessageType = NtLmAuthenticate;
 781
 782         flags = NTLMSSP_NEGOTIATE_56 |
 783                 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_TARGET_INFO |
 784                 NTLMSSP_NEGOTIATE_128 | NTLMSSP_NEGOTIATE_UNICODE |
 785                 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_EXTENDED_SEC |
 786                 NTLMSSP_NEGOTIATE_SEAL | NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED;
 787         if (ses->server->sign)
 788                 flags |= NTLMSSP_NEGOTIATE_SIGN;
 789         if (!ses->server->session_estab || ses->ntlmssp->sesskey_per_smbsess)
 790                 flags |= NTLMSSP_NEGOTIATE_KEY_XCH;
 791
 792         tmp = *pbuffer + sizeof(AUTHENTICATE_MESSAGE);
 793         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 794
 795         sec_blob->LmChallengeResponse.BufferOffset =
 796                                 cpu_to_le32(sizeof(AUTHENTICATE_MESSAGE));
 797         sec_blob->LmChallengeResponse.Length = 0;
 798         sec_blob->LmChallengeResponse.MaximumLength = 0;
 799
 800         sec_blob->NtChallengeResponse.BufferOffset =
 801                                 cpu_to_le32(tmp - *pbuffer);
 802         if (ses->user_name != NULL) {
 803                 memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 804                                 ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 805                 tmp += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
 806
 807                 sec_blob->NtChallengeResponse.Length =
 808                                 cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 809                 sec_blob->NtChallengeResponse.MaximumLength =
 810                                 cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 811         } else {
 812                 /*
 813                  * don't send an NT Response for anonymous access
 814                  */
 815                 sec_blob->NtChallengeResponse.Length = 0;
 816                 sec_blob->NtChallengeResponse.MaximumLength = 0;
 817         }
 818
 819         cifs_security_buffer_from_str(&sec_blob->DomainName,
 820                                       ses->domainName,
 821                                       CIFS_MAX_DOMAINNAME_LEN,
 822                                       *pbuffer, &tmp,
 823                                       nls_cp);
 824
 825         cifs_security_buffer_from_str(&sec_blob->UserName,
 826                                       ses->user_name,
 827                                       CIFS_MAX_USERNAME_LEN,
 828                                       *pbuffer, &tmp,
 829                                       nls_cp);
 830
 831         cifs_security_buffer_from_str(&sec_blob->WorkstationName,
 832                                       ses->workstation_name,
 833                                       CIFS_MAX_WORKSTATION_LEN,
 834                                       *pbuffer, &tmp,
 835                                       nls_cp);
 836
 837         if (((ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_KEY_XCH) ||
 838                 (ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))
 839                         && !calc_seckey(ses)) {
 840                 memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);
 841                 sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);
 842                 sec_blob->SessionKey.Length = cpu_to_le16(CIFS_CPHTXT_SIZE);
 843                 sec_blob->SessionKey.MaximumLength =
 844                                 cpu_to_le16(CIFS_CPHTXT_SIZE);
 845                 tmp += CIFS_CPHTXT_SIZE;
 846         } else {
 847                 sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);
 848                 sec_blob->SessionKey.Length = 0;
 849                 sec_blob->SessionKey.MaximumLength = 0;
 850         }
 851
 852         *buflen = tmp - *pbuffer;
 853 setup_ntlmv2_ret:
 854         return rc;
 855 }
 856
 857 enum securityEnum
 858 cifs_select_sectype(struct TCP_Server_Info *server, enum securityEnum requested)
 859 {
 860         switch (server->negflavor) {
 861         case CIFS_NEGFLAVOR_EXTENDED:
 862                 switch (requested) {
 863                 case Kerberos:
 864                 case RawNTLMSSP:
 865                         return requested;
 866                 case Unspecified:
 867                         if (server->sec_ntlmssp &&
 868                             (global_secflags & CIFSSEC_MAY_NTLMSSP))
 869                                 return RawNTLMSSP;
 870                         if ((server->sec_kerberos || server->sec_mskerberos) &&
 871                             (global_secflags & CIFSSEC_MAY_KRB5))
 872                                 return Kerberos;
 873                         fallthrough;
 874                 default:
 875                         return Unspecified;
 876                 }
 877         case CIFS_NEGFLAVOR_UNENCAP:
 878                 switch (requested) {
 879                 case NTLMv2:
 880                         return requested;
 881                 case Unspecified:
 882                         if (global_secflags & CIFSSEC_MAY_NTLMV2)
 883                                 return NTLMv2;
 884                         break;
 885                 default:
 886                         break;
 887                 }
 888                 fallthrough;
 889         default:
 890                 return Unspecified;
 891         }
 892 }
 893
 894 struct sess_data {
 895         unsigned int xid;
 896         struct cifs_ses *ses;
 897         struct nls_table *nls_cp;
 898         void (*func)(struct sess_data *);
 899         int result;
 900
 901         /* we will send the SMB in three pieces:
 902          * a fixed length beginning part, an optional
 903          * SPNEGO blob (which can be zero length), and a
 904          * last part which will include the strings
 905          * and rest of bcc area. This allows us to avoid
 906          * a large buffer 17K allocation
 907          */
 908         int buf0_type;
 909         struct kvec iov[3];
 910 };
 911
 912 static int
 913 sess_alloc_buffer(struct sess_data *sess_data, int wct)
 914 {
 915         int rc;
 916         struct cifs_ses *ses = sess_data->ses;
 917         struct smb_hdr *smb_buf;
 918
 919         rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
 920                                   (void **)&smb_buf);
 921
 922         if (rc)
 923                 return rc;
 924
 925         sess_data->iov[0].iov_base = (char *)smb_buf;
 926         sess_data->iov[0].iov_len = be32_to_cpu(smb_buf->smb_buf_length) + 4;
 927         /*
 928          * This variable will be used to clear the buffer
 929          * allocated above in case of any error in the calling function.
 930          */
 931         sess_data->buf0_type = CIFS_SMALL_BUFFER;
 932
 933         /* 2000 big enough to fit max user, domain, NOS name etc. */
 934         sess_data->iov[2].iov_base = kmalloc(2000, GFP_KERNEL);
 935         if (!sess_data->iov[2].iov_base) {
 936                 rc = -ENOMEM;
 937                 goto out_free_smb_buf;
 938         }
 939
 940         return 0;
 941
 942 out_free_smb_buf:
 943         cifs_small_buf_release(smb_buf);
 944         sess_data->iov[0].iov_base = NULL;
 945         sess_data->iov[0].iov_len = 0;
 946         sess_data->buf0_type = CIFS_NO_BUFFER;
 947         return rc;
 948 }
 949
 950 static void
 951 sess_free_buffer(struct sess_data *sess_data)
 952 {
 953
 954         free_rsp_buf(sess_data->buf0_type, sess_data->iov[0].iov_base);
 955         sess_data->buf0_type = CIFS_NO_BUFFER;
 956         kfree(sess_data->iov[2].iov_base);
 957 }
 958
 959 static int
 960 sess_establish_session(struct sess_data *sess_data)
 961 {
 962         struct cifs_ses *ses = sess_data->ses;
 963
 964         mutex_lock(&ses->server->srv_mutex);
 965         if (!ses->server->session_estab) {
 966                 if (ses->server->sign) {
 967                         ses->server->session_key.response =
 968                                 kmemdup(ses->auth_key.response,
 969                                 ses->auth_key.len, GFP_KERNEL);
 970                         if (!ses->server->session_key.response) {
 971                                 mutex_unlock(&ses->server->srv_mutex);
 972                                 return -ENOMEM;
 973                         }
 974                         ses->server->session_key.len =
 975                                                 ses->auth_key.len;
 976                 }
 977                 ses->server->sequence_number = 0x2;
 978                 ses->server->session_estab = true;
 979         }
 980         mutex_unlock(&ses->server->srv_mutex);
 981
 982         cifs_dbg(FYI, "CIFS session established successfully\n");
 983         spin_lock(&GlobalMid_Lock);
 984         ses->status = CifsGood;
 985         ses->need_reconnect = false;
 986         spin_unlock(&GlobalMid_Lock);
 987
 988         return 0;
 989 }
 990
 991 static int
 992 sess_sendreceive(struct sess_data *sess_data)
 993 {
 994         int rc;
 995         struct smb_hdr *smb_buf = (struct smb_hdr *) sess_data->iov[0].iov_base;
 996         __u16 count;
 997         struct kvec rsp_iov = { NULL, 0 };
 998
 999         count = sess_data->iov[1].iov_len + sess_data->iov[2].iov_len;
1000         be32_add_cpu(&smb_buf->smb_buf_length, count);
1001         put_bcc(count, smb_buf);
1002
1003         rc = SendReceive2(sess_data->xid, sess_data->ses,
1004                           sess_data->iov, 3 /* num_iovecs */,
1005                           &sess_data->buf0_type,
1006                           CIFS_LOG_ERROR, &rsp_iov);
1007         cifs_small_buf_release(sess_data->iov[0].iov_base);
1008         memcpy(&sess_data->iov[0], &rsp_iov, sizeof(struct kvec));
1009
1010         return rc;
1011 }
1012
1013 static void
1014 sess_auth_ntlmv2(struct sess_data *sess_data)
1015 {
1016         int rc = 0;
1017         struct smb_hdr *smb_buf;
1018         SESSION_SETUP_ANDX *pSMB;
1019         char *bcc_ptr;
1020         struct cifs_ses *ses = sess_data->ses;
1021         __u32 capabilities;
1022         __u16 bytes_remaining;
1023
1024         /* old style NTLM sessionsetup */
1025         /* wct = 13 */
1026         rc = sess_alloc_buffer(sess_data, 13);
1027         if (rc)
1028                 goto out;
1029
1030         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1031         bcc_ptr = sess_data->iov[2].iov_base;
1032         capabilities = cifs_ssetup_hdr(ses, pSMB);
1033
1034         pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
1035
1036         /* LM2 password would be here if we supported it */
1037         pSMB->req_no_secext.CaseInsensitivePasswordLength = 0;
1038
1039         if (ses->user_name != NULL) {
1040                 /* calculate nlmv2 response and session key */
1041                 rc = setup_ntlmv2_rsp(ses, sess_data->nls_cp);
1042                 if (rc) {
1043                         cifs_dbg(VFS, "Error %d during NTLMv2 authentication\n", rc);
1044                         goto out;
1045                 }
1046
1047                 memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
1048                                 ses->auth_key.len - CIFS_SESS_KEY_SIZE);
1049                 bcc_ptr += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
1050
1051                 /* set case sensitive password length after tilen may get
1052                  * assigned, tilen is 0 otherwise.
1053                  */
1054                 pSMB->req_no_secext.CaseSensitivePasswordLength =
1055                         cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
1056         } else {
1057                 pSMB->req_no_secext.CaseSensitivePasswordLength = 0;
1058         }
1059
1060         if (ses->capabilities & CAP_UNICODE) {
1061                 if (sess_data->iov[0].iov_len % 2) {
1062                         *bcc_ptr = 0;
1063                         bcc_ptr++;
1064                 }
1065                 unicode_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
1066         } else {
1067                 ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
1068         }
1069
1070
1071         sess_data->iov[2].iov_len = (long) bcc_ptr -
1072                         (long) sess_data->iov[2].iov_base;
1073
1074         rc = sess_sendreceive(sess_data);
1075         if (rc)
1076                 goto out;
1077
1078         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1079         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
1080
1081         if (smb_buf->WordCount != 3) {
1082                 rc = -EIO;
1083                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
1084                 goto out;
1085         }
1086
1087         if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
1088                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
1089
1090         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
1091         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
1092
1093         bytes_remaining = get_bcc(smb_buf);
1094         bcc_ptr = pByteArea(smb_buf);
1095
1096         /* BB check if Unicode and decode strings */
1097         if (bytes_remaining == 0) {
1098                 /* no string area to decode, do nothing */
1099         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
1100                 /* unicode string area must be word-aligned */
1101                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
1102                         ++bcc_ptr;
1103                         --bytes_remaining;
1104                 }
1105                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
1106                                       sess_data->nls_cp);
1107         } else {
1108                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
1109                                     sess_data->nls_cp);
1110         }
1111
1112         rc = sess_establish_session(sess_data);
1113 out:
1114         sess_data->result = rc;
1115         sess_data->func = NULL;
1116         sess_free_buffer(sess_data);
1117         kfree(ses->auth_key.response);
1118         ses->auth_key.response = NULL;
1119 }
1120
1121 #ifdef CONFIG_CIFS_UPCALL
1122 static void
1123 sess_auth_kerberos(struct sess_data *sess_data)
1124 {
1125         int rc = 0;
1126         struct smb_hdr *smb_buf;
1127         SESSION_SETUP_ANDX *pSMB;
1128         char *bcc_ptr;
1129         struct cifs_ses *ses = sess_data->ses;
1130         __u32 capabilities;
1131         __u16 bytes_remaining;
1132         struct key *spnego_key = NULL;
1133         struct cifs_spnego_msg *msg;
1134         u16 blob_len;
1135
1136         /* extended security */
1137         /* wct = 12 */
1138         rc = sess_alloc_buffer(sess_data, 12);
1139         if (rc)
1140                 goto out;
1141
1142         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1143         bcc_ptr = sess_data->iov[2].iov_base;
1144         capabilities = cifs_ssetup_hdr(ses, pSMB);
1145
1146         spnego_key = cifs_get_spnego_key(ses);
1147         if (IS_ERR(spnego_key)) {
1148                 rc = PTR_ERR(spnego_key);
1149                 spnego_key = NULL;
1150                 goto out;
1151         }
1152
1153         msg = spnego_key->payload.data[0];
1154         /*
1155          * check version field to make sure that cifs.upcall is
1156          * sending us a response in an expected form
1157          */
1158         if (msg->version != CIFS_SPNEGO_UPCALL_VERSION) {
1159                 cifs_dbg(VFS, "incorrect version of cifs.upcall (expected %d but got %d)\n",
1160                          CIFS_SPNEGO_UPCALL_VERSION, msg->version);
1161                 rc = -EKEYREJECTED;
1162                 goto out_put_spnego_key;
1163         }
1164
1165         ses->auth_key.response = kmemdup(msg->data, msg->sesskey_len,
1166                                          GFP_KERNEL);
1167         if (!ses->auth_key.response) {
1168                 cifs_dbg(VFS, "Kerberos can't allocate (%u bytes) memory\n",
1169                          msg->sesskey_len);
1170                 rc = -ENOMEM;
1171                 goto out_put_spnego_key;
1172         }
1173         ses->auth_key.len = msg->sesskey_len;
1174
1175         pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
1176         capabilities |= CAP_EXTENDED_SECURITY;
1177         pSMB->req.Capabilities = cpu_to_le32(capabilities);
1178         sess_data->iov[1].iov_base = msg->data + msg->sesskey_len;
1179         sess_data->iov[1].iov_len = msg->secblob_len;
1180         pSMB->req.SecurityBlobLength = cpu_to_le16(sess_data->iov[1].iov_len);
1181
1182         if (ses->capabilities & CAP_UNICODE) {
1183                 /* unicode strings must be word aligned */
1184                 if ((sess_data->iov[0].iov_len
1185                         + sess_data->iov[1].iov_len) % 2) {
1186                         *bcc_ptr = 0;
1187                         bcc_ptr++;
1188                 }
1189                 unicode_oslm_strings(&bcc_ptr, sess_data->nls_cp);
1190                 unicode_domain_string(&bcc_ptr, ses, sess_data->nls_cp);
1191         } else {
1192                 /* BB: is this right? */
1193                 ascii_ssetup_strings(&bcc_ptr, ses, sess_data->nls_cp);
1194         }
1195
1196         sess_data->iov[2].iov_len = (long) bcc_ptr -
1197                         (long) sess_data->iov[2].iov_base;
1198
1199         rc = sess_sendreceive(sess_data);
1200         if (rc)
1201                 goto out_put_spnego_key;
1202
1203         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1204         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
1205
1206         if (smb_buf->WordCount != 4) {
1207                 rc = -EIO;
1208                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
1209                 goto out_put_spnego_key;
1210         }
1211
1212         if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
1213                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
1214
1215         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
1216         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
1217
1218         bytes_remaining = get_bcc(smb_buf);
1219         bcc_ptr = pByteArea(smb_buf);
1220
1221         blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
1222         if (blob_len > bytes_remaining) {
1223                 cifs_dbg(VFS, "bad security blob length %d\n",
1224                                 blob_len);
1225                 rc = -EINVAL;
1226                 goto out_put_spnego_key;
1227         }
1228         bcc_ptr += blob_len;
1229         bytes_remaining -= blob_len;
1230
1231         /* BB check if Unicode and decode strings */
1232         if (bytes_remaining == 0) {
1233                 /* no string area to decode, do nothing */
1234         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
1235                 /* unicode string area must be word-aligned */
1236                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
1237                         ++bcc_ptr;
1238                         --bytes_remaining;
1239                 }
1240                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
1241                                       sess_data->nls_cp);
1242         } else {
1243                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
1244                                     sess_data->nls_cp);
1245         }
1246
1247         rc = sess_establish_session(sess_data);
1248 out_put_spnego_key:
1249         key_invalidate(spnego_key);
1250         key_put(spnego_key);
1251 out:
1252         sess_data->result = rc;
1253         sess_data->func = NULL;
1254         sess_free_buffer(sess_data);
1255         kfree(ses->auth_key.response);
1256         ses->auth_key.response = NULL;
1257 }
1258
1259 #endif /* ! CONFIG_CIFS_UPCALL */
1260
1261 /*
1262  * The required kvec buffers have to be allocated before calling this
1263  * function.
1264  */
1265 static int
1266 _sess_auth_rawntlmssp_assemble_req(struct sess_data *sess_data)
1267 {
1268         SESSION_SETUP_ANDX *pSMB;
1269         struct cifs_ses *ses = sess_data->ses;
1270         __u32 capabilities;
1271         char *bcc_ptr;
1272
1273         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1274
1275         capabilities = cifs_ssetup_hdr(ses, pSMB);
1276         if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
1277                 cifs_dbg(VFS, "NTLMSSP requires Unicode support\n");
1278                 return -ENOSYS;
1279         }
1280
1281         pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
1282         capabilities |= CAP_EXTENDED_SECURITY;
1283         pSMB->req.Capabilities |= cpu_to_le32(capabilities);
1284
1285         bcc_ptr = sess_data->iov[2].iov_base;
1286         /* unicode strings must be word aligned */
1287         if ((sess_data->iov[0].iov_len + sess_data->iov[1].iov_len) % 2) {
1288                 *bcc_ptr = 0;
1289                 bcc_ptr++;
1290         }
1291         unicode_oslm_strings(&bcc_ptr, sess_data->nls_cp);
1292
1293         sess_data->iov[2].iov_len = (long) bcc_ptr -
1294                                         (long) sess_data->iov[2].iov_base;
1295
1296         return 0;
1297 }
1298
1299 static void
1300 sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data);
1301
1302 static void
1303 sess_auth_rawntlmssp_negotiate(struct sess_data *sess_data)
1304 {
1305         int rc;
1306         struct smb_hdr *smb_buf;
1307         SESSION_SETUP_ANDX *pSMB;
1308         struct cifs_ses *ses = sess_data->ses;
1309         __u16 bytes_remaining;
1310         char *bcc_ptr;
1311         unsigned char *ntlmsspblob = NULL;
1312         u16 blob_len;
1313
1314         cifs_dbg(FYI, "rawntlmssp session setup negotiate phase\n");
1315
1316         /*
1317          * if memory allocation is successful, caller of this function
1318          * frees it.
1319          */
1320         ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL);
1321         if (!ses->ntlmssp) {
1322                 rc = -ENOMEM;
1323                 goto out;
1324         }
1325         ses->ntlmssp->sesskey_per_smbsess = false;
1326
1327         /* wct = 12 */
1328         rc = sess_alloc_buffer(sess_data, 12);
1329         if (rc)
1330                 goto out;
1331
1332         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1333
1334         /* Build security blob before we assemble the request */
1335         rc = build_ntlmssp_negotiate_blob(&ntlmsspblob,
1336                                      &blob_len, ses,
1337                                      sess_data->nls_cp);
1338         if (rc)
1339                 goto out;
1340
1341         sess_data->iov[1].iov_len = blob_len;
1342         sess_data->iov[1].iov_base = ntlmsspblob;
1343         pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
1344
1345         rc = _sess_auth_rawntlmssp_assemble_req(sess_data);
1346         if (rc)
1347                 goto out;
1348
1349         rc = sess_sendreceive(sess_data);
1350
1351         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1352         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
1353
1354         /* If true, rc here is expected and not an error */
1355         if (sess_data->buf0_type != CIFS_NO_BUFFER &&
1356             smb_buf->Status.CifsError ==
1357                         cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))
1358                 rc = 0;
1359
1360         if (rc)
1361                 goto out;
1362
1363         cifs_dbg(FYI, "rawntlmssp session setup challenge phase\n");
1364
1365         if (smb_buf->WordCount != 4) {
1366                 rc = -EIO;
1367                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
1368                 goto out;
1369         }
1370
1371         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
1372         cifs_dbg(FYI, "UID = %llu\n", ses->Suid);
1373
1374         bytes_remaining = get_bcc(smb_buf);
1375         bcc_ptr = pByteArea(smb_buf);
1376
1377         blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
1378         if (blob_len > bytes_remaining) {
1379                 cifs_dbg(VFS, "bad security blob length %d\n",
1380                                 blob_len);
1381                 rc = -EINVAL;
1382                 goto out;
1383         }
1384
1385         rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
1386 out:
1387         sess_free_buffer(sess_data);
1388
1389         if (!rc) {
1390                 sess_data->func = sess_auth_rawntlmssp_authenticate;
1391                 return;
1392         }
1393
1394         /* Else error. Cleanup */
1395         kfree(ses->auth_key.response);
1396         ses->auth_key.response = NULL;
1397         kfree(ses->ntlmssp);
1398         ses->ntlmssp = NULL;
1399
1400         sess_data->func = NULL;
1401         sess_data->result = rc;
1402 }
1403
1404 static void
1405 sess_auth_rawntlmssp_authenticate(struct sess_data *sess_data)
1406 {
1407         int rc;
1408         struct smb_hdr *smb_buf;
1409         SESSION_SETUP_ANDX *pSMB;
1410         struct cifs_ses *ses = sess_data->ses;
1411         __u16 bytes_remaining;
1412         char *bcc_ptr;
1413         unsigned char *ntlmsspblob = NULL;
1414         u16 blob_len;
1415
1416         cifs_dbg(FYI, "rawntlmssp session setup authenticate phase\n");
1417
1418         /* wct = 12 */
1419         rc = sess_alloc_buffer(sess_data, 12);
1420         if (rc)
1421                 goto out;
1422
1423         /* Build security blob before we assemble the request */
1424         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1425         smb_buf = (struct smb_hdr *)pSMB;
1426         rc = build_ntlmssp_auth_blob(&ntlmsspblob,
1427                                         &blob_len, ses, sess_data->nls_cp);
1428         if (rc)
1429                 goto out_free_ntlmsspblob;
1430         sess_data->iov[1].iov_len = blob_len;
1431         sess_data->iov[1].iov_base = ntlmsspblob;
1432         pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
1433         /*
1434          * Make sure that we tell the server that we are using
1435          * the uid that it just gave us back on the response
1436          * (challenge)
1437          */
1438         smb_buf->Uid = ses->Suid;
1439
1440         rc = _sess_auth_rawntlmssp_assemble_req(sess_data);
1441         if (rc)
1442                 goto out_free_ntlmsspblob;
1443
1444         rc = sess_sendreceive(sess_data);
1445         if (rc)
1446                 goto out_free_ntlmsspblob;
1447
1448         pSMB = (SESSION_SETUP_ANDX *)sess_data->iov[0].iov_base;
1449         smb_buf = (struct smb_hdr *)sess_data->iov[0].iov_base;
1450         if (smb_buf->WordCount != 4) {
1451                 rc = -EIO;
1452                 cifs_dbg(VFS, "bad word count %d\n", smb_buf->WordCount);
1453                 goto out_free_ntlmsspblob;
1454         }
1455
1456         if (le16_to_cpu(pSMB->resp.Action) & GUEST_LOGIN)
1457                 cifs_dbg(FYI, "Guest login\n"); /* BB mark SesInfo struct? */
1458
1459         if (ses->Suid != smb_buf->Uid) {
1460                 ses->Suid = smb_buf->Uid;
1461                 cifs_dbg(FYI, "UID changed! new UID = %llu\n", ses->Suid);
1462         }
1463
1464         bytes_remaining = get_bcc(smb_buf);
1465         bcc_ptr = pByteArea(smb_buf);
1466         blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
1467         if (blob_len > bytes_remaining) {
1468                 cifs_dbg(VFS, "bad security blob length %d\n",
1469                                 blob_len);
1470                 rc = -EINVAL;
1471                 goto out_free_ntlmsspblob;
1472         }
1473         bcc_ptr += blob_len;
1474         bytes_remaining -= blob_len;
1475
1476
1477         /* BB check if Unicode and decode strings */
1478         if (bytes_remaining == 0) {
1479                 /* no string area to decode, do nothing */
1480         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
1481                 /* unicode string area must be word-aligned */
1482                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
1483                         ++bcc_ptr;
1484                         --bytes_remaining;
1485                 }
1486                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses,
1487                                       sess_data->nls_cp);
1488         } else {
1489                 decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,
1490                                     sess_data->nls_cp);
1491         }
1492
1493 out_free_ntlmsspblob:
1494         kfree(ntlmsspblob);
1495 out:
1496         sess_free_buffer(sess_data);
1497
1498          if (!rc)
1499                 rc = sess_establish_session(sess_data);
1500
1501         /* Cleanup */
1502         kfree(ses->auth_key.response);
1503         ses->auth_key.response = NULL;
1504         kfree(ses->ntlmssp);
1505         ses->ntlmssp = NULL;
1506
1507         sess_data->func = NULL;
1508         sess_data->result = rc;
1509 }
1510
1511 static int select_sec(struct cifs_ses *ses, struct sess_data *sess_data)
1512 {
1513         int type;
1514
1515         type = cifs_select_sectype(ses->server, ses->sectype);
1516         cifs_dbg(FYI, "sess setup type %d\n", type);
1517         if (type == Unspecified) {
1518                 cifs_dbg(VFS, "Unable to select appropriate authentication method!\n");
1519                 return -EINVAL;
1520         }
1521
1522         switch (type) {
1523         case NTLMv2:
1524                 sess_data->func = sess_auth_ntlmv2;
1525                 break;
1526         case Kerberos:
1527 #ifdef CONFIG_CIFS_UPCALL
1528                 sess_data->func = sess_auth_kerberos;
1529                 break;
1530 #else
1531                 cifs_dbg(VFS, "Kerberos negotiated but upcall support disabled!\n");
1532                 return -ENOSYS;
1533 #endif /* CONFIG_CIFS_UPCALL */
1534         case RawNTLMSSP:
1535                 sess_data->func = sess_auth_rawntlmssp_negotiate;
1536                 break;
1537         default:
1538                 cifs_dbg(VFS, "secType %d not supported!\n", type);
1539                 return -ENOSYS;
1540         }
1541
1542         return 0;
1543 }
1544
1545 int CIFS_SessSetup(const unsigned int xid, struct cifs_ses *ses,
1546                     const struct nls_table *nls_cp)
1547 {
1548         int rc = 0;
1549         struct sess_data *sess_data;
1550
1551         if (ses == NULL) {
1552                 WARN(1, "%s: ses == NULL!", __func__);
1553                 return -EINVAL;
1554         }
1555
1556         sess_data = kzalloc(sizeof(struct sess_data), GFP_KERNEL);
1557         if (!sess_data)
1558                 return -ENOMEM;
1559
1560         rc = select_sec(ses, sess_data);
1561         if (rc)
1562                 goto out;
1563
1564         sess_data->xid = xid;
1565         sess_data->ses = ses;
1566         sess_data->buf0_type = CIFS_NO_BUFFER;
1567         sess_data->nls_cp = (struct nls_table *) nls_cp;
1568
1569         while (sess_data->func)
1570                 sess_data->func(sess_data);
1571
1572         /* Store result before we free sess_data */
1573         rc = sess_data->result;
1574
1575 out:
1576         kfree(sess_data);
1577         return rc;
1578 }