fs/cifs/sess.c

   1 /*
   2  *   fs/cifs/sess.c
   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  *   This library is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU Lesser General Public License as published
  11  *   by the Free Software Foundation; either version 2.1 of the License, or
  12  *   (at your option) any later version.
  13  *
  14  *   This library is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  17  *   the GNU Lesser General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU Lesser General Public License
  20  *   along with this library; if not, write to the Free Software
  21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  22  */
  23
  24 #include "cifspdu.h"
  25 #include "cifsglob.h"
  26 #include "cifsproto.h"
  27 #include "cifs_unicode.h"
  28 #include "cifs_debug.h"
  29 #include "ntlmssp.h"
  30 #include "nterr.h"
  31 #include <linux/utsname.h>
  32 #include <linux/slab.h>
  33 #include "cifs_spnego.h"
  34
  35 /*
  36  * Checks if this is the first smb session to be reconnected after
  37  * the socket has been reestablished (so we know whether to use vc 0).
  38  * Called while holding the cifs_tcp_ses_lock, so do not block
  39  */
  40 static bool is_first_ses_reconnect(struct cifs_ses *ses)
  41 {
  42         struct list_head *tmp;
  43         struct cifs_ses *tmp_ses;
  44
  45         list_for_each(tmp, &ses->server->smb_ses_list) {
  46                 tmp_ses = list_entry(tmp, struct cifs_ses,
  47                                      smb_ses_list);
  48                 if (tmp_ses->need_reconnect == false)
  49                         return false;
  50         }
  51         /* could not find a session that was already connected,
  52            this must be the first one we are reconnecting */
  53         return true;
  54 }
  55
  56 /*
  57  *      vc number 0 is treated specially by some servers, and should be the
  58  *      first one we request.  After that we can use vcnumbers up to maxvcs,
  59  *      one for each smb session (some Windows versions set maxvcs incorrectly
  60  *      so maxvc=1 can be ignored).  If we have too many vcs, we can reuse
  61  *      any vc but zero (some servers reset the connection on vcnum zero)
  62  *
  63  */
  64 static __le16 get_next_vcnum(struct cifs_ses *ses)
  65 {
  66         __u16 vcnum = 0;
  67         struct list_head *tmp;
  68         struct cifs_ses *tmp_ses;
  69         __u16 max_vcs = ses->server->max_vcs;
  70         __u16 i;
  71         int free_vc_found = 0;
  72
  73         /* Quoting the MS-SMB specification: "Windows-based SMB servers set this
  74         field to one but do not enforce this limit, which allows an SMB client
  75         to establish more virtual circuits than allowed by this value ... but
  76         other server implementations can enforce this limit." */
  77         if (max_vcs < 2)
  78                 max_vcs = 0xFFFF;
  79
  80         spin_lock(&cifs_tcp_ses_lock);
  81         if ((ses->need_reconnect) && is_first_ses_reconnect(ses))
  82                         goto get_vc_num_exit;  /* vcnum will be zero */
  83         for (i = ses->server->srv_count - 1; i < max_vcs; i++) {
  84                 if (i == 0) /* this is the only connection, use vc 0 */
  85                         break;
  86
  87                 free_vc_found = 1;
  88
  89                 list_for_each(tmp, &ses->server->smb_ses_list) {
  90                         tmp_ses = list_entry(tmp, struct cifs_ses,
  91                                              smb_ses_list);
  92                         if (tmp_ses->vcnum == i) {
  93                                 free_vc_found = 0;
  94                                 break; /* found duplicate, try next vcnum */
  95                         }
  96                 }
  97                 if (free_vc_found)
  98                         break; /* we found a vcnumber that will work - use it */
  99         }
 100
 101         if (i == 0)
 102                 vcnum = 0; /* for most common case, ie if one smb session, use
 103                               vc zero.  Also for case when no free vcnum, zero
 104                               is safest to send (some clients only send zero) */
 105         else if (free_vc_found == 0)
 106                 vcnum = 1;  /* we can not reuse vc=0 safely, since some servers
 107                                 reset all uids on that, but 1 is ok. */
 108         else
 109                 vcnum = i;
 110         ses->vcnum = vcnum;
 111 get_vc_num_exit:
 112         spin_unlock(&cifs_tcp_ses_lock);
 113
 114         return cpu_to_le16(vcnum);
 115 }
 116
 117 static __u32 cifs_ssetup_hdr(struct cifs_ses *ses, SESSION_SETUP_ANDX *pSMB)
 118 {
 119         __u32 capabilities = 0;
 120
 121         /* init fields common to all four types of SessSetup */
 122         /* Note that offsets for first seven fields in req struct are same  */
 123         /*      in CIFS Specs so does not matter which of 3 forms of struct */
 124         /*      that we use in next few lines                               */
 125         /* Note that header is initialized to zero in header_assemble */
 126         pSMB->req.AndXCommand = 0xFF;
 127         pSMB->req.MaxBufferSize = cpu_to_le16(min_t(u32, CIFSMaxBufSize - 4,
 128                                                 USHRT_MAX));
 129         pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
 130         pSMB->req.VcNumber = get_next_vcnum(ses);
 131
 132         /* Now no need to set SMBFLG_CASELESS or obsolete CANONICAL PATH */
 133
 134         /* BB verify whether signing required on neg or just on auth frame
 135            (and NTLM case) */
 136
 137         capabilities = CAP_LARGE_FILES | CAP_NT_SMBS | CAP_LEVEL_II_OPLOCKS |
 138                         CAP_LARGE_WRITE_X | CAP_LARGE_READ_X;
 139
 140         if (ses->server->sec_mode &
 141             (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
 142                 pSMB->req.hdr.Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
 143
 144         if (ses->capabilities & CAP_UNICODE) {
 145                 pSMB->req.hdr.Flags2 |= SMBFLG2_UNICODE;
 146                 capabilities |= CAP_UNICODE;
 147         }
 148         if (ses->capabilities & CAP_STATUS32) {
 149                 pSMB->req.hdr.Flags2 |= SMBFLG2_ERR_STATUS;
 150                 capabilities |= CAP_STATUS32;
 151         }
 152         if (ses->capabilities & CAP_DFS) {
 153                 pSMB->req.hdr.Flags2 |= SMBFLG2_DFS;
 154                 capabilities |= CAP_DFS;
 155         }
 156         if (ses->capabilities & CAP_UNIX)
 157                 capabilities |= CAP_UNIX;
 158
 159         return capabilities;
 160 }
 161
 162 static void
 163 unicode_oslm_strings(char **pbcc_area, const struct nls_table *nls_cp)
 164 {
 165         char *bcc_ptr = *pbcc_area;
 166         int bytes_ret = 0;
 167
 168         /* Copy OS version */
 169         bytes_ret = cifs_strtoUCS((__le16 *)bcc_ptr, "Linux version ", 32,
 170                                   nls_cp);
 171         bcc_ptr += 2 * bytes_ret;
 172         bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, init_utsname()->release,
 173                                   32, nls_cp);
 174         bcc_ptr += 2 * bytes_ret;
 175         bcc_ptr += 2; /* trailing null */
 176
 177         bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
 178                                   32, nls_cp);
 179         bcc_ptr += 2 * bytes_ret;
 180         bcc_ptr += 2; /* trailing null */
 181
 182         *pbcc_area = bcc_ptr;
 183 }
 184
 185 static void unicode_domain_string(char **pbcc_area, struct cifs_ses *ses,
 186                                    const struct nls_table *nls_cp)
 187 {
 188         char *bcc_ptr = *pbcc_area;
 189         int bytes_ret = 0;
 190
 191         /* copy domain */
 192         if (ses->domainName == NULL) {
 193                 /* Sending null domain better than using a bogus domain name (as
 194                 we did briefly in 2.6.18) since server will use its default */
 195                 *bcc_ptr = 0;
 196                 *(bcc_ptr+1) = 0;
 197                 bytes_ret = 0;
 198         } else
 199                 bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->domainName,
 200                                           256, nls_cp);
 201         bcc_ptr += 2 * bytes_ret;
 202         bcc_ptr += 2;  /* account for null terminator */
 203
 204         *pbcc_area = bcc_ptr;
 205 }
 206
 207
 208 static void unicode_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
 209                                    const struct nls_table *nls_cp)
 210 {
 211         char *bcc_ptr = *pbcc_area;
 212         int bytes_ret = 0;
 213
 214         /* BB FIXME add check that strings total less
 215         than 335 or will need to send them as arrays */
 216
 217         /* unicode strings, must be word aligned before the call */
 218 /*      if ((long) bcc_ptr % 2) {
 219                 *bcc_ptr = 0;
 220                 bcc_ptr++;
 221         } */
 222         /* copy user */
 223         if (ses->user_name == NULL) {
 224                 /* null user mount */
 225                 *bcc_ptr = 0;
 226                 *(bcc_ptr+1) = 0;
 227         } else {
 228                 bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->user_name,
 229                                           MAX_USERNAME_SIZE, nls_cp);
 230         }
 231         bcc_ptr += 2 * bytes_ret;
 232         bcc_ptr += 2; /* account for null termination */
 233
 234         unicode_domain_string(&bcc_ptr, ses, nls_cp);
 235         unicode_oslm_strings(&bcc_ptr, nls_cp);
 236
 237         *pbcc_area = bcc_ptr;
 238 }
 239
 240 static void ascii_ssetup_strings(char **pbcc_area, struct cifs_ses *ses,
 241                                  const struct nls_table *nls_cp)
 242 {
 243         char *bcc_ptr = *pbcc_area;
 244
 245         /* copy user */
 246         /* BB what about null user mounts - check that we do this BB */
 247         /* copy user */
 248         if (ses->user_name != NULL)
 249                 strncpy(bcc_ptr, ses->user_name, MAX_USERNAME_SIZE);
 250         /* else null user mount */
 251
 252         bcc_ptr += strnlen(ses->user_name, MAX_USERNAME_SIZE);
 253         *bcc_ptr = 0;
 254         bcc_ptr++; /* account for null termination */
 255
 256         /* copy domain */
 257
 258         if (ses->domainName != NULL) {
 259                 strncpy(bcc_ptr, ses->domainName, 256);
 260                 bcc_ptr += strnlen(ses->domainName, 256);
 261         } /* else we will send a null domain name
 262              so the server will default to its own domain */
 263         *bcc_ptr = 0;
 264         bcc_ptr++;
 265
 266         /* BB check for overflow here */
 267
 268         strcpy(bcc_ptr, "Linux version ");
 269         bcc_ptr += strlen("Linux version ");
 270         strcpy(bcc_ptr, init_utsname()->release);
 271         bcc_ptr += strlen(init_utsname()->release) + 1;
 272
 273         strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
 274         bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
 275
 276         *pbcc_area = bcc_ptr;
 277 }
 278
 279 static void
 280 decode_unicode_ssetup(char **pbcc_area, int bleft, struct cifs_ses *ses,
 281                       const struct nls_table *nls_cp)
 282 {
 283         int len;
 284         char *data = *pbcc_area;
 285
 286         cFYI(1, "bleft %d", bleft);
 287
 288         kfree(ses->serverOS);
 289         ses->serverOS = cifs_strndup_from_ucs(data, bleft, true, nls_cp);
 290         cFYI(1, "serverOS=%s", ses->serverOS);
 291         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
 292         data += len;
 293         bleft -= len;
 294         if (bleft <= 0)
 295                 return;
 296
 297         kfree(ses->serverNOS);
 298         ses->serverNOS = cifs_strndup_from_ucs(data, bleft, true, nls_cp);
 299         cFYI(1, "serverNOS=%s", ses->serverNOS);
 300         len = (UniStrnlen((wchar_t *) data, bleft / 2) * 2) + 2;
 301         data += len;
 302         bleft -= len;
 303         if (bleft <= 0)
 304                 return;
 305
 306         kfree(ses->serverDomain);
 307         ses->serverDomain = cifs_strndup_from_ucs(data, bleft, true, nls_cp);
 308         cFYI(1, "serverDomain=%s", ses->serverDomain);
 309
 310         return;
 311 }
 312
 313 static int decode_ascii_ssetup(char **pbcc_area, __u16 bleft,
 314                                struct cifs_ses *ses,
 315                                const struct nls_table *nls_cp)
 316 {
 317         int rc = 0;
 318         int len;
 319         char *bcc_ptr = *pbcc_area;
 320
 321         cFYI(1, "decode sessetup ascii. bleft %d", bleft);
 322
 323         len = strnlen(bcc_ptr, bleft);
 324         if (len >= bleft)
 325                 return rc;
 326
 327         kfree(ses->serverOS);
 328
 329         ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
 330         if (ses->serverOS)
 331                 strncpy(ses->serverOS, bcc_ptr, len);
 332         if (strncmp(ses->serverOS, "OS/2", 4) == 0) {
 333                         cFYI(1, "OS/2 server");
 334                         ses->flags |= CIFS_SES_OS2;
 335         }
 336
 337         bcc_ptr += len + 1;
 338         bleft -= len + 1;
 339
 340         len = strnlen(bcc_ptr, bleft);
 341         if (len >= bleft)
 342                 return rc;
 343
 344         kfree(ses->serverNOS);
 345
 346         ses->serverNOS = kzalloc(len + 1, GFP_KERNEL);
 347         if (ses->serverNOS)
 348                 strncpy(ses->serverNOS, bcc_ptr, len);
 349
 350         bcc_ptr += len + 1;
 351         bleft -= len + 1;
 352
 353         len = strnlen(bcc_ptr, bleft);
 354         if (len > bleft)
 355                 return rc;
 356
 357         /* No domain field in LANMAN case. Domain is
 358            returned by old servers in the SMB negprot response */
 359         /* BB For newer servers which do not support Unicode,
 360            but thus do return domain here we could add parsing
 361            for it later, but it is not very important */
 362         cFYI(1, "ascii: bytes left %d", bleft);
 363
 364         return rc;
 365 }
 366
 367 static int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len,
 368                                     struct cifs_ses *ses)
 369 {
 370         unsigned int tioffset; /* challenge message target info area */
 371         unsigned int tilen; /* challenge message target info area length  */
 372
 373         CHALLENGE_MESSAGE *pblob = (CHALLENGE_MESSAGE *)bcc_ptr;
 374
 375         if (blob_len < sizeof(CHALLENGE_MESSAGE)) {
 376                 cERROR(1, "challenge blob len %d too small", blob_len);
 377                 return -EINVAL;
 378         }
 379
 380         if (memcmp(pblob->Signature, "NTLMSSP", 8)) {
 381                 cERROR(1, "blob signature incorrect %s", pblob->Signature);
 382                 return -EINVAL;
 383         }
 384         if (pblob->MessageType != NtLmChallenge) {
 385                 cERROR(1, "Incorrect message type %d", pblob->MessageType);
 386                 return -EINVAL;
 387         }
 388
 389         memcpy(ses->ntlmssp->cryptkey, pblob->Challenge, CIFS_CRYPTO_KEY_SIZE);
 390         /* BB we could decode pblob->NegotiateFlags; some may be useful */
 391         /* In particular we can examine sign flags */
 392         /* BB spec says that if AvId field of MsvAvTimestamp is populated then
 393                 we must set the MIC field of the AUTHENTICATE_MESSAGE */
 394         ses->ntlmssp->server_flags = le32_to_cpu(pblob->NegotiateFlags);
 395         tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);
 396         tilen = le16_to_cpu(pblob->TargetInfoArray.Length);
 397         if (tilen) {
 398                 ses->auth_key.response = kmalloc(tilen, GFP_KERNEL);
 399                 if (!ses->auth_key.response) {
 400                         cERROR(1, "Challenge target info allocation failure");
 401                         return -ENOMEM;
 402                 }
 403                 memcpy(ses->auth_key.response, bcc_ptr + tioffset, tilen);
 404                 ses->auth_key.len = tilen;
 405         }
 406
 407         return 0;
 408 }
 409
 410 /* BB Move to ntlmssp.c eventually */
 411
 412 /* We do not malloc the blob, it is passed in pbuffer, because
 413    it is fixed size, and small, making this approach cleaner */
 414 static void build_ntlmssp_negotiate_blob(unsigned char *pbuffer,
 415                                          struct cifs_ses *ses)
 416 {
 417         NEGOTIATE_MESSAGE *sec_blob = (NEGOTIATE_MESSAGE *)pbuffer;
 418         __u32 flags;
 419
 420         memset(pbuffer, 0, sizeof(NEGOTIATE_MESSAGE));
 421         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
 422         sec_blob->MessageType = NtLmNegotiate;
 423
 424         /* BB is NTLMV2 session security format easier to use here? */
 425         flags = NTLMSSP_NEGOTIATE_56 |  NTLMSSP_REQUEST_TARGET |
 426                 NTLMSSP_NEGOTIATE_128 | NTLMSSP_NEGOTIATE_UNICODE |
 427                 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_EXTENDED_SEC;
 428         if (ses->server->sec_mode &
 429                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
 430                 flags |= NTLMSSP_NEGOTIATE_SIGN;
 431                 if (!ses->server->session_estab)
 432                         flags |= NTLMSSP_NEGOTIATE_KEY_XCH;
 433         }
 434
 435         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 436
 437         sec_blob->WorkstationName.BufferOffset = 0;
 438         sec_blob->WorkstationName.Length = 0;
 439         sec_blob->WorkstationName.MaximumLength = 0;
 440
 441         /* Domain name is sent on the Challenge not Negotiate NTLMSSP request */
 442         sec_blob->DomainName.BufferOffset = 0;
 443         sec_blob->DomainName.Length = 0;
 444         sec_blob->DomainName.MaximumLength = 0;
 445 }
 446
 447 /* We do not malloc the blob, it is passed in pbuffer, because its
 448    maximum possible size is fixed and small, making this approach cleaner.
 449    This function returns the length of the data in the blob */
 450 static int build_ntlmssp_auth_blob(unsigned char *pbuffer,
 451                                         u16 *buflen,
 452                                    struct cifs_ses *ses,
 453                                    const struct nls_table *nls_cp)
 454 {
 455         int rc;
 456         AUTHENTICATE_MESSAGE *sec_blob = (AUTHENTICATE_MESSAGE *)pbuffer;
 457         __u32 flags;
 458         unsigned char *tmp;
 459
 460         memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
 461         sec_blob->MessageType = NtLmAuthenticate;
 462
 463         flags = NTLMSSP_NEGOTIATE_56 |
 464                 NTLMSSP_REQUEST_TARGET | NTLMSSP_NEGOTIATE_TARGET_INFO |
 465                 NTLMSSP_NEGOTIATE_128 | NTLMSSP_NEGOTIATE_UNICODE |
 466                 NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_EXTENDED_SEC;
 467         if (ses->server->sec_mode &
 468            (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
 469                 flags |= NTLMSSP_NEGOTIATE_SIGN;
 470                 if (!ses->server->session_estab)
 471                         flags |= NTLMSSP_NEGOTIATE_KEY_XCH;
 472         }
 473
 474         tmp = pbuffer + sizeof(AUTHENTICATE_MESSAGE);
 475         sec_blob->NegotiateFlags = cpu_to_le32(flags);
 476
 477         sec_blob->LmChallengeResponse.BufferOffset =
 478                                 cpu_to_le32(sizeof(AUTHENTICATE_MESSAGE));
 479         sec_blob->LmChallengeResponse.Length = 0;
 480         sec_blob->LmChallengeResponse.MaximumLength = 0;
 481
 482         sec_blob->NtChallengeResponse.BufferOffset = cpu_to_le32(tmp - pbuffer);
 483         rc = setup_ntlmv2_rsp(ses, nls_cp);
 484         if (rc) {
 485                 cERROR(1, "Error %d during NTLMSSP authentication", rc);
 486                 goto setup_ntlmv2_ret;
 487         }
 488         memcpy(tmp, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 489                         ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 490         tmp += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
 491
 492         sec_blob->NtChallengeResponse.Length =
 493                         cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 494         sec_blob->NtChallengeResponse.MaximumLength =
 495                         cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 496
 497         if (ses->domainName == NULL) {
 498                 sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 499                 sec_blob->DomainName.Length = 0;
 500                 sec_blob->DomainName.MaximumLength = 0;
 501                 tmp += 2;
 502         } else {
 503                 int len;
 504                 len = cifs_strtoUCS((__le16 *)tmp, ses->domainName,
 505                                     MAX_USERNAME_SIZE, nls_cp);
 506                 len *= 2; /* unicode is 2 bytes each */
 507                 sec_blob->DomainName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 508                 sec_blob->DomainName.Length = cpu_to_le16(len);
 509                 sec_blob->DomainName.MaximumLength = cpu_to_le16(len);
 510                 tmp += len;
 511         }
 512
 513         if (ses->user_name == NULL) {
 514                 sec_blob->UserName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 515                 sec_blob->UserName.Length = 0;
 516                 sec_blob->UserName.MaximumLength = 0;
 517                 tmp += 2;
 518         } else {
 519                 int len;
 520                 len = cifs_strtoUCS((__le16 *)tmp, ses->user_name,
 521                                     MAX_USERNAME_SIZE, nls_cp);
 522                 len *= 2; /* unicode is 2 bytes each */
 523                 sec_blob->UserName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 524                 sec_blob->UserName.Length = cpu_to_le16(len);
 525                 sec_blob->UserName.MaximumLength = cpu_to_le16(len);
 526                 tmp += len;
 527         }
 528
 529         sec_blob->WorkstationName.BufferOffset = cpu_to_le32(tmp - pbuffer);
 530         sec_blob->WorkstationName.Length = 0;
 531         sec_blob->WorkstationName.MaximumLength = 0;
 532         tmp += 2;
 533
 534         if (((ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_KEY_XCH) ||
 535                 (ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))
 536                         && !calc_seckey(ses)) {
 537                 memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);
 538                 sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - pbuffer);
 539                 sec_blob->SessionKey.Length = cpu_to_le16(CIFS_CPHTXT_SIZE);
 540                 sec_blob->SessionKey.MaximumLength =
 541                                 cpu_to_le16(CIFS_CPHTXT_SIZE);
 542                 tmp += CIFS_CPHTXT_SIZE;
 543         } else {
 544                 sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - pbuffer);
 545                 sec_blob->SessionKey.Length = 0;
 546                 sec_blob->SessionKey.MaximumLength = 0;
 547         }
 548
 549 setup_ntlmv2_ret:
 550         *buflen = tmp - pbuffer;
 551         return rc;
 552 }
 553
 554 int
 555 CIFS_SessSetup(unsigned int xid, struct cifs_ses *ses,
 556                const struct nls_table *nls_cp)
 557 {
 558         int rc = 0;
 559         int wct;
 560         struct smb_hdr *smb_buf;
 561         char *bcc_ptr;
 562         char *str_area;
 563         SESSION_SETUP_ANDX *pSMB;
 564         __u32 capabilities;
 565         __u16 count;
 566         int resp_buf_type;
 567         struct kvec iov[3];
 568         enum securityEnum type;
 569         __u16 action, bytes_remaining;
 570         struct key *spnego_key = NULL;
 571         __le32 phase = NtLmNegotiate; /* NTLMSSP, if needed, is multistage */
 572         u16 blob_len;
 573         char *ntlmsspblob = NULL;
 574
 575         if (ses == NULL)
 576                 return -EINVAL;
 577
 578         type = ses->server->secType;
 579         cFYI(1, "sess setup type %d", type);
 580         if (type == RawNTLMSSP) {
 581                 /* if memory allocation is successful, caller of this function
 582                  * frees it.
 583                  */
 584                 ses->ntlmssp = kmalloc(sizeof(struct ntlmssp_auth), GFP_KERNEL);
 585                 if (!ses->ntlmssp)
 586                         return -ENOMEM;
 587         }
 588
 589 ssetup_ntlmssp_authenticate:
 590         if (phase == NtLmChallenge)
 591                 phase = NtLmAuthenticate; /* if ntlmssp, now final phase */
 592
 593         if (type == LANMAN) {
 594 #ifndef CONFIG_CIFS_WEAK_PW_HASH
 595                 /* LANMAN and plaintext are less secure and off by default.
 596                 So we make this explicitly be turned on in kconfig (in the
 597                 build) and turned on at runtime (changed from the default)
 598                 in proc/fs/cifs or via mount parm.  Unfortunately this is
 599                 needed for old Win (e.g. Win95), some obscure NAS and OS/2 */
 600                 return -EOPNOTSUPP;
 601 #endif
 602                 wct = 10; /* lanman 2 style sessionsetup */
 603         } else if ((type == NTLM) || (type == NTLMv2)) {
 604                 /* For NTLMv2 failures eventually may need to retry NTLM */
 605                 wct = 13; /* old style NTLM sessionsetup */
 606         } else /* same size: negotiate or auth, NTLMSSP or extended security */
 607                 wct = 12;
 608
 609         rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
 610                             (void **)&smb_buf);
 611         if (rc)
 612                 return rc;
 613
 614         pSMB = (SESSION_SETUP_ANDX *)smb_buf;
 615
 616         capabilities = cifs_ssetup_hdr(ses, pSMB);
 617
 618         /* we will send the SMB in three pieces:
 619         a fixed length beginning part, an optional
 620         SPNEGO blob (which can be zero length), and a
 621         last part which will include the strings
 622         and rest of bcc area. This allows us to avoid
 623         a large buffer 17K allocation */
 624         iov[0].iov_base = (char *)pSMB;
 625         iov[0].iov_len = be32_to_cpu(smb_buf->smb_buf_length) + 4;
 626
 627         /* setting this here allows the code at the end of the function
 628            to free the request buffer if there's an error */
 629         resp_buf_type = CIFS_SMALL_BUFFER;
 630
 631         /* 2000 big enough to fit max user, domain, NOS name etc. */
 632         str_area = kmalloc(2000, GFP_KERNEL);
 633         if (str_area == NULL) {
 634                 rc = -ENOMEM;
 635                 goto ssetup_exit;
 636         }
 637         bcc_ptr = str_area;
 638
 639         ses->flags &= ~CIFS_SES_LANMAN;
 640
 641         iov[1].iov_base = NULL;
 642         iov[1].iov_len = 0;
 643
 644         if (type == LANMAN) {
 645 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 646                 char lnm_session_key[CIFS_AUTH_RESP_SIZE];
 647
 648                 pSMB->req.hdr.Flags2 &= ~SMBFLG2_UNICODE;
 649
 650                 /* no capabilities flags in old lanman negotiation */
 651
 652                 pSMB->old_req.PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
 653
 654                 /* Calculate hash with password and copy into bcc_ptr.
 655                  * Encryption Key (stored as in cryptkey) gets used if the
 656                  * security mode bit in Negottiate Protocol response states
 657                  * to use challenge/response method (i.e. Password bit is 1).
 658                  */
 659
 660                 rc = calc_lanman_hash(ses->password, ses->server->cryptkey,
 661                                  ses->server->sec_mode & SECMODE_PW_ENCRYPT ?
 662                                         true : false, lnm_session_key);
 663
 664                 ses->flags |= CIFS_SES_LANMAN;
 665                 memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_AUTH_RESP_SIZE);
 666                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
 667
 668                 /* can not sign if LANMAN negotiated so no need
 669                 to calculate signing key? but what if server
 670                 changed to do higher than lanman dialect and
 671                 we reconnected would we ever calc signing_key? */
 672
 673                 cFYI(1, "Negotiating LANMAN setting up strings");
 674                 /* Unicode not allowed for LANMAN dialects */
 675                 ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 676 #endif
 677         } else if (type == NTLM) {
 678                 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
 679                 pSMB->req_no_secext.CaseInsensitivePasswordLength =
 680                         cpu_to_le16(CIFS_AUTH_RESP_SIZE);
 681                 pSMB->req_no_secext.CaseSensitivePasswordLength =
 682                         cpu_to_le16(CIFS_AUTH_RESP_SIZE);
 683
 684                 /* calculate ntlm response and session key */
 685                 rc = setup_ntlm_response(ses);
 686                 if (rc) {
 687                         cERROR(1, "Error %d during NTLM authentication", rc);
 688                         goto ssetup_exit;
 689                 }
 690
 691                 /* copy ntlm response */
 692                 memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 693                                 CIFS_AUTH_RESP_SIZE);
 694                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
 695                 memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 696                                 CIFS_AUTH_RESP_SIZE);
 697                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
 698
 699                 if (ses->capabilities & CAP_UNICODE) {
 700                         /* unicode strings must be word aligned */
 701                         if (iov[0].iov_len % 2) {
 702                                 *bcc_ptr = 0;
 703                                 bcc_ptr++;
 704                         }
 705                         unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
 706                 } else
 707                         ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 708         } else if (type == NTLMv2) {
 709                 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
 710
 711                 /* LM2 password would be here if we supported it */
 712                 pSMB->req_no_secext.CaseInsensitivePasswordLength = 0;
 713
 714                 /* calculate nlmv2 response and session key */
 715                 rc = setup_ntlmv2_rsp(ses, nls_cp);
 716                 if (rc) {
 717                         cERROR(1, "Error %d during NTLMv2 authentication", rc);
 718                         goto ssetup_exit;
 719                 }
 720                 memcpy(bcc_ptr, ses->auth_key.response + CIFS_SESS_KEY_SIZE,
 721                                 ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 722                 bcc_ptr += ses->auth_key.len - CIFS_SESS_KEY_SIZE;
 723
 724                 /* set case sensitive password length after tilen may get
 725                  * assigned, tilen is 0 otherwise.
 726                  */
 727                 pSMB->req_no_secext.CaseSensitivePasswordLength =
 728                         cpu_to_le16(ses->auth_key.len - CIFS_SESS_KEY_SIZE);
 729
 730                 if (ses->capabilities & CAP_UNICODE) {
 731                         if (iov[0].iov_len % 2) {
 732                                 *bcc_ptr = 0;
 733                                 bcc_ptr++;
 734                         }
 735                         unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
 736                 } else
 737                         ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 738         } else if (type == Kerberos) {
 739 #ifdef CONFIG_CIFS_UPCALL
 740                 struct cifs_spnego_msg *msg;
 741
 742                 spnego_key = cifs_get_spnego_key(ses);
 743                 if (IS_ERR(spnego_key)) {
 744                         rc = PTR_ERR(spnego_key);
 745                         spnego_key = NULL;
 746                         goto ssetup_exit;
 747                 }
 748
 749                 msg = spnego_key->payload.data;
 750                 /* check version field to make sure that cifs.upcall is
 751                    sending us a response in an expected form */
 752                 if (msg->version != CIFS_SPNEGO_UPCALL_VERSION) {
 753                         cERROR(1, "incorrect version of cifs.upcall (expected"
 754                                    " %d but got %d)",
 755                                    CIFS_SPNEGO_UPCALL_VERSION, msg->version);
 756                         rc = -EKEYREJECTED;
 757                         goto ssetup_exit;
 758                 }
 759
 760                 ses->auth_key.response = kmalloc(msg->sesskey_len, GFP_KERNEL);
 761                 if (!ses->auth_key.response) {
 762                         cERROR(1, "Kerberos can't allocate (%u bytes) memory",
 763                                         msg->sesskey_len);
 764                         rc = -ENOMEM;
 765                         goto ssetup_exit;
 766                 }
 767                 memcpy(ses->auth_key.response, msg->data, msg->sesskey_len);
 768                 ses->auth_key.len = msg->sesskey_len;
 769
 770                 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
 771                 capabilities |= CAP_EXTENDED_SECURITY;
 772                 pSMB->req.Capabilities = cpu_to_le32(capabilities);
 773                 iov[1].iov_base = msg->data + msg->sesskey_len;
 774                 iov[1].iov_len = msg->secblob_len;
 775                 pSMB->req.SecurityBlobLength = cpu_to_le16(iov[1].iov_len);
 776
 777                 if (ses->capabilities & CAP_UNICODE) {
 778                         /* unicode strings must be word aligned */
 779                         if ((iov[0].iov_len + iov[1].iov_len) % 2) {
 780                                 *bcc_ptr = 0;
 781                                 bcc_ptr++;
 782                         }
 783                         unicode_oslm_strings(&bcc_ptr, nls_cp);
 784                         unicode_domain_string(&bcc_ptr, ses, nls_cp);
 785                 } else
 786                 /* BB: is this right? */
 787                         ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 788 #else /* ! CONFIG_CIFS_UPCALL */
 789                 cERROR(1, "Kerberos negotiated but upcall support disabled!");
 790                 rc = -ENOSYS;
 791                 goto ssetup_exit;
 792 #endif /* CONFIG_CIFS_UPCALL */
 793         } else if (type == RawNTLMSSP) {
 794                 if ((pSMB->req.hdr.Flags2 & SMBFLG2_UNICODE) == 0) {
 795                         cERROR(1, "NTLMSSP requires Unicode support");
 796                         rc = -ENOSYS;
 797                         goto ssetup_exit;
 798                 }
 799
 800                 cFYI(1, "ntlmssp session setup phase %d", phase);
 801                 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
 802                 capabilities |= CAP_EXTENDED_SECURITY;
 803                 pSMB->req.Capabilities |= cpu_to_le32(capabilities);
 804                 switch(phase) {
 805                 case NtLmNegotiate:
 806                         build_ntlmssp_negotiate_blob(
 807                                 pSMB->req.SecurityBlob, ses);
 808                         iov[1].iov_len = sizeof(NEGOTIATE_MESSAGE);
 809                         iov[1].iov_base = pSMB->req.SecurityBlob;
 810                         pSMB->req.SecurityBlobLength =
 811                                 cpu_to_le16(sizeof(NEGOTIATE_MESSAGE));
 812                         break;
 813                 case NtLmAuthenticate:
 814                         /*
 815                          * 5 is an empirical value, large enough to hold
 816                          * authenticate message plus max 10 of av paris,
 817                          * domain, user, workstation names, flags, etc.
 818                          */
 819                         ntlmsspblob = kzalloc(
 820                                 5*sizeof(struct _AUTHENTICATE_MESSAGE),
 821                                 GFP_KERNEL);
 822                         if (!ntlmsspblob) {
 823                                 cERROR(1, "Can't allocate NTLMSSP blob");
 824                                 rc = -ENOMEM;
 825                                 goto ssetup_exit;
 826                         }
 827
 828                         rc = build_ntlmssp_auth_blob(ntlmsspblob,
 829                                                 &blob_len, ses, nls_cp);
 830                         if (rc)
 831                                 goto ssetup_exit;
 832                         iov[1].iov_len = blob_len;
 833                         iov[1].iov_base = ntlmsspblob;
 834                         pSMB->req.SecurityBlobLength = cpu_to_le16(blob_len);
 835                         /*
 836                          * Make sure that we tell the server that we are using
 837                          * the uid that it just gave us back on the response
 838                          * (challenge)
 839                          */
 840                         smb_buf->Uid = ses->Suid;
 841                         break;
 842                 default:
 843                         cERROR(1, "invalid phase %d", phase);
 844                         rc = -ENOSYS;
 845                         goto ssetup_exit;
 846                 }
 847                 /* unicode strings must be word aligned */
 848                 if ((iov[0].iov_len + iov[1].iov_len) % 2) {
 849                         *bcc_ptr = 0;
 850                         bcc_ptr++;
 851                 }
 852                 unicode_oslm_strings(&bcc_ptr, nls_cp);
 853         } else {
 854                 cERROR(1, "secType %d not supported!", type);
 855                 rc = -ENOSYS;
 856                 goto ssetup_exit;
 857         }
 858
 859         iov[2].iov_base = str_area;
 860         iov[2].iov_len = (long) bcc_ptr - (long) str_area;
 861
 862         count = iov[1].iov_len + iov[2].iov_len;
 863         smb_buf->smb_buf_length =
 864                 cpu_to_be32(be32_to_cpu(smb_buf->smb_buf_length) + count);
 865
 866         put_bcc(count, smb_buf);
 867
 868         rc = SendReceive2(xid, ses, iov, 3 /* num_iovecs */, &resp_buf_type,
 869                           CIFS_LOG_ERROR);
 870         /* SMB request buf freed in SendReceive2 */
 871
 872         pSMB = (SESSION_SETUP_ANDX *)iov[0].iov_base;
 873         smb_buf = (struct smb_hdr *)iov[0].iov_base;
 874
 875         if ((type == RawNTLMSSP) && (smb_buf->Status.CifsError ==
 876                         cpu_to_le32(NT_STATUS_MORE_PROCESSING_REQUIRED))) {
 877                 if (phase != NtLmNegotiate) {
 878                         cERROR(1, "Unexpected more processing error");
 879                         goto ssetup_exit;
 880                 }
 881                 /* NTLMSSP Negotiate sent now processing challenge (response) */
 882                 phase = NtLmChallenge; /* process ntlmssp challenge */
 883                 rc = 0; /* MORE_PROC rc is not an error here, but expected */
 884         }
 885         if (rc)
 886                 goto ssetup_exit;
 887
 888         if ((smb_buf->WordCount != 3) && (smb_buf->WordCount != 4)) {
 889                 rc = -EIO;
 890                 cERROR(1, "bad word count %d", smb_buf->WordCount);
 891                 goto ssetup_exit;
 892         }
 893         action = le16_to_cpu(pSMB->resp.Action);
 894         if (action & GUEST_LOGIN)
 895                 cFYI(1, "Guest login"); /* BB mark SesInfo struct? */
 896         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
 897         cFYI(1, "UID = %d ", ses->Suid);
 898         /* response can have either 3 or 4 word count - Samba sends 3 */
 899         /* and lanman response is 3 */
 900         bytes_remaining = get_bcc(smb_buf);
 901         bcc_ptr = pByteArea(smb_buf);
 902
 903         if (smb_buf->WordCount == 4) {
 904                 blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
 905                 if (blob_len > bytes_remaining) {
 906                         cERROR(1, "bad security blob length %d", blob_len);
 907                         rc = -EINVAL;
 908                         goto ssetup_exit;
 909                 }
 910                 if (phase == NtLmChallenge) {
 911                         rc = decode_ntlmssp_challenge(bcc_ptr, blob_len, ses);
 912                         /* now goto beginning for ntlmssp authenticate phase */
 913                         if (rc)
 914                                 goto ssetup_exit;
 915                 }
 916                 bcc_ptr += blob_len;
 917                 bytes_remaining -= blob_len;
 918         }
 919
 920         /* BB check if Unicode and decode strings */
 921         if (bytes_remaining == 0) {
 922                 /* no string area to decode, do nothing */
 923         } else if (smb_buf->Flags2 & SMBFLG2_UNICODE) {
 924                 /* unicode string area must be word-aligned */
 925                 if (((unsigned long) bcc_ptr - (unsigned long) smb_buf) % 2) {
 926                         ++bcc_ptr;
 927                         --bytes_remaining;
 928                 }
 929                 decode_unicode_ssetup(&bcc_ptr, bytes_remaining, ses, nls_cp);
 930         } else {
 931                 rc = decode_ascii_ssetup(&bcc_ptr, bytes_remaining,
 932                                          ses, nls_cp);
 933         }
 934
 935 ssetup_exit:
 936         if (spnego_key) {
 937                 key_revoke(spnego_key);
 938                 key_put(spnego_key);
 939         }
 940         kfree(str_area);
 941         kfree(ntlmsspblob);
 942         ntlmsspblob = NULL;
 943         if (resp_buf_type == CIFS_SMALL_BUFFER) {
 944                 cFYI(1, "ssetup freeing small buf %p", iov[0].iov_base);
 945                 cifs_small_buf_release(iov[0].iov_base);
 946         } else if (resp_buf_type == CIFS_LARGE_BUFFER)
 947                 cifs_buf_release(iov[0].iov_base);
 948
 949         /* if ntlmssp, and negotiate succeeded, proceed to authenticate phase */
 950         if ((phase == NtLmChallenge) && (rc == 0))
 951                 goto ssetup_ntlmssp_authenticate;
 952
 953         return rc;
 954 }