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