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