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