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