SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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
   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/ctype.h>
  32
  33 extern void SMBencrypt(unsigned char *passwd, unsigned char *c8,
  34                        unsigned char *p24);
  35
  36 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
  37                          unsigned char *p24);
  38
  39 #ifdef CONFIG_CIFS_EXPERIMENTAL
  40
  41 static __u32 cifs_ssetup_hdr(struct cifsSesInfo *ses, SESSION_SETUP_ANDX *pSMB)
  42 {
  43         __u32 capabilities = 0;
  44
  45         /* init fields common to all four types of SessSetup */
  46         /* note that header is initialized to zero in header_assemble */
  47         pSMB->req.AndXCommand = 0xFF;
  48         pSMB->req.MaxBufferSize = cpu_to_le16(ses->server->maxBuf);
  49         pSMB->req.MaxMpxCount = cpu_to_le16(ses->server->maxReq);
  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->secMode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
  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
  78         /* BB check whether to init vcnum BB */
  79         return capabilities;
  80 }
  81
  82 void unicode_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
  83                             const struct nls_table * nls_cp)
  84 {
  85         char * bcc_ptr = *pbcc_area;
  86         int bytes_ret = 0;
  87
  88         /* BB FIXME add check that strings total less
  89         than 335 or will need to send them as arrays */
  90
  91         /* align unicode strings, must be word aligned */
  92         if ((long) bcc_ptr % 2) {
  93                 *bcc_ptr = 0;
  94                 bcc_ptr++;
  95         }
  96         /* copy user */
  97         if(ses->userName == NULL) {
  98                 /* BB what about null user mounts - check that we do this BB */
  99         } else { /* 300 should be long enough for any conceivable user name */
 100                 bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->userName,
 101                                           300, nls_cp);
 102         }
 103         bcc_ptr += 2 * bytes_ret;
 104         bcc_ptr += 2; /* account for null termination */
 105         /* copy domain */
 106         if(ses->domainName == NULL)
 107                 bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr,
 108                                           "CIFS_LINUX_DOM", 32, nls_cp);
 109         else
 110                 bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, ses->domainName,
 111                                           256, nls_cp);
 112         bcc_ptr += 2 * bytes_ret;
 113         bcc_ptr += 2;  /* account for null terminator */
 114
 115         /* Copy OS version */
 116         bytes_ret = cifs_strtoUCS((__le16 *)bcc_ptr, "Linux version ", 32,
 117                                   nls_cp);
 118         bcc_ptr += 2 * bytes_ret;
 119         bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, system_utsname.release,
 120                                   32, nls_cp);
 121         bcc_ptr += 2 * bytes_ret;
 122         bcc_ptr += 2; /* trailing null */
 123
 124         bytes_ret = cifs_strtoUCS((__le16 *) bcc_ptr, CIFS_NETWORK_OPSYS,
 125                                   32, nls_cp);
 126         bcc_ptr += 2 * bytes_ret;
 127         bcc_ptr += 2; /* trailing null */
 128
 129         *pbcc_area = bcc_ptr;
 130 }
 131
 132 void ascii_ssetup_strings(char ** pbcc_area, struct cifsSesInfo *ses,
 133                           const struct nls_table * nls_cp)
 134 {
 135         char * bcc_ptr = *pbcc_area;
 136
 137         /* copy user */
 138         /* BB what about null user mounts - check that we do this BB */
 139         /* copy user */
 140         if(ses->userName == NULL) {
 141                 /* BB what about null user mounts - check that we do this BB */
 142         } else { /* 300 should be long enough for any conceivable user name */
 143                 strncpy(bcc_ptr, ses->userName, 300);
 144         }
 145         /* BB improve check for overflow */
 146         bcc_ptr += strnlen(ses->userName, 200);
 147         *bcc_ptr = 0;
 148         bcc_ptr++; /* account for null termination */
 149
 150         /* copy domain */
 151
 152         if(ses->domainName == NULL) {
 153                 strcpy(bcc_ptr, "CIFS_LINUX_DOM");
 154                 bcc_ptr += 14;  /* strlen(CIFS_LINUX_DOM) */
 155         } else {
 156                 strncpy(bcc_ptr, ses->domainName, 256);
 157                 bcc_ptr += strnlen(ses->domainName, 256);
 158         }
 159         *bcc_ptr = 0;
 160         bcc_ptr++;
 161
 162         /* BB check for overflow here */
 163
 164         strcpy(bcc_ptr, "Linux version ");
 165         bcc_ptr += strlen("Linux version ");
 166         strcpy(bcc_ptr, system_utsname.release);
 167         bcc_ptr += strlen(system_utsname.release) + 1;
 168
 169         strcpy(bcc_ptr, CIFS_NETWORK_OPSYS);
 170         bcc_ptr += strlen(CIFS_NETWORK_OPSYS) + 1;
 171
 172         *pbcc_area = bcc_ptr;
 173 }
 174
 175 int decode_unicode_ssetup(char ** pbcc_area, int bleft, struct cifsSesInfo *ses,
 176                             const struct nls_table * nls_cp)
 177 {
 178         int rc = 0;
 179         int words_left, len;
 180         char * data = *pbcc_area;
 181
 182
 183
 184         cFYI(1,("bleft %d",bleft));
 185
 186
 187         /* word align, if bytes remaining is not even */
 188         if(bleft % 2) {
 189                 bleft--;
 190                 data++;
 191         }
 192         words_left = bleft / 2;
 193
 194         /* save off server operating system */
 195         len = UniStrnlen((wchar_t *) data, words_left);
 196
 197 /* We look for obvious messed up bcc or strings in response so we do not go off
 198    the end since (at least) WIN2K and Windows XP have a major bug in not null
 199    terminating last Unicode string in response  */
 200         if(len >= words_left)
 201                 return rc;
 202
 203         if(ses->serverOS)
 204                 kfree(ses->serverOS);
 205         /* UTF-8 string will not grow more than four times as big as UCS-16 */
 206         ses->serverOS = kzalloc(4 * len, GFP_KERNEL);
 207         if(ses->serverOS != NULL) {
 208                 cifs_strfromUCS_le(ses->serverOS, (__le16 *)data, len,
 209                                    nls_cp);
 210         }
 211         data += 2 * (len + 1);
 212         words_left -= len + 1;
 213
 214         /* save off server network operating system */
 215         len = UniStrnlen((wchar_t *) data, words_left);
 216
 217         if(len >= words_left)
 218                 return rc;
 219
 220         if(ses->serverNOS)
 221                 kfree(ses->serverNOS);
 222         ses->serverNOS = kzalloc(4 * len, GFP_KERNEL); /* BB this is wrong length FIXME BB */
 223         if(ses->serverNOS != NULL) {
 224                 cifs_strfromUCS_le(ses->serverNOS, (__le16 *)data, len,
 225                                    nls_cp);
 226                 if(strncmp(ses->serverNOS, "NT LAN Manager 4",16) == 0) {
 227                         cFYI(1,("NT4 server"));
 228                         ses->flags |= CIFS_SES_NT4;
 229                 }
 230         }
 231         data += 2 * (len + 1);
 232         words_left -= len + 1;
 233
 234         /* save off server domain */
 235         len = UniStrnlen((wchar_t *) data, words_left);
 236
 237         if(len > words_left)
 238                 return rc;
 239
 240         if(ses->serverDomain)
 241                 kfree(ses->serverDomain);
 242         ses->serverDomain = kzalloc(2 * (len + 1), GFP_KERNEL); /* BB FIXME wrong length */
 243         if(ses->serverDomain != NULL) {
 244                 cifs_strfromUCS_le(ses->serverDomain, (__le16 *)data, len,
 245                                    nls_cp);
 246                 ses->serverDomain[2*len] = 0;
 247                 ses->serverDomain[(2*len) + 1] = 0;
 248         }
 249         data += 2 * (len + 1);
 250         words_left -= len + 1;
 251
 252         cFYI(1,("words left: %d",words_left));
 253
 254         return rc;
 255 }
 256
 257 int decode_ascii_ssetup(char ** pbcc_area, int bleft, struct cifsSesInfo *ses,
 258                             const struct nls_table * nls_cp)
 259 {
 260         int rc = 0;
 261         int len;
 262         char * bcc_ptr = *pbcc_area;
 263
 264         cFYI(1,("decode sessetup ascii. bleft %d", bleft));
 265
 266         len = strnlen(bcc_ptr, bleft);
 267         if(len >= bleft)
 268                 return rc;
 269
 270         if(ses->serverOS)
 271                 kfree(ses->serverOS);
 272
 273         ses->serverOS = kzalloc(len + 1, GFP_KERNEL);
 274         if(ses->serverOS)
 275                 strncpy(ses->serverOS, bcc_ptr, len);
 276
 277         bcc_ptr += len + 1;
 278         bleft -= len + 1;
 279
 280         len = strnlen(bcc_ptr, bleft);
 281         if(len >= bleft)
 282                 return rc;
 283
 284         if(ses->serverNOS)
 285                 kfree(ses->serverNOS);
 286
 287         ses->serverNOS = kzalloc(len + 1, GFP_KERNEL);
 288         if(ses->serverNOS)
 289                 strncpy(ses->serverNOS, bcc_ptr, len);
 290
 291         bcc_ptr += len + 1;
 292         bleft -= len + 1;
 293
 294         len = strnlen(bcc_ptr, bleft);
 295         if(len > bleft)
 296                 return rc;
 297
 298         if(ses->serverDomain)
 299                 kfree(ses->serverDomain);
 300
 301         ses->serverDomain = kzalloc(len + 1, GFP_KERNEL);
 302         if(ses->serverOS)
 303                 strncpy(ses->serverOS, bcc_ptr, len);
 304
 305         bcc_ptr += len + 1;
 306         bleft -= len + 1;
 307
 308         cFYI(1,("ascii: bytes left %d",bleft));
 309
 310         return rc;
 311 }
 312
 313 int
 314 CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
 315                 const struct nls_table *nls_cp)
 316 {
 317         int rc = 0;
 318         int wct;
 319         int i;
 320         struct smb_hdr *smb_buf;
 321         char *bcc_ptr;
 322         SESSION_SETUP_ANDX *pSMB;
 323         __u32 capabilities;
 324         int count;
 325         int resp_buf_type = 0;
 326         struct kvec iov[1];
 327         enum securityEnum type;
 328         __u16 action;
 329         int bytes_remaining;
 330
 331         if(ses == NULL)
 332                 return -EINVAL;
 333
 334         type = ses->server->secType;
 335         if(type == LANMAN) {
 336 #ifndef CONFIG_CIFS_WEAK_PW_HASH
 337                 /* LANMAN and plaintext are less secure and off by default.
 338                 So we make this explicitly be turned on in kconfig (in the
 339                 build) and turned on at runtime (changed from the default)
 340                 in proc/fs/cifs or via mount parm.  Unfortunately this is
 341                 needed for old Win (e.g. Win95), some obscure NAS and OS/2 */
 342                 return -EOPNOTSUPP;
 343 #endif
 344                 wct = 10; /* lanman 2 style sessionsetup */
 345         } else if(type == NTLM) /* NTLMv2 may retry NTLM */
 346                 wct = 13; /* old style NTLM sessionsetup */
 347         else /* same size for negotiate or auth, NTLMSSP or extended security */
 348                 wct = 12;
 349
 350         rc = small_smb_init_no_tc(SMB_COM_SESSION_SETUP_ANDX, wct, ses,
 351                             (void **)&smb_buf);
 352         if(rc)
 353                 return rc;
 354
 355         pSMB = (SESSION_SETUP_ANDX *)smb_buf;
 356
 357         capabilities = cifs_ssetup_hdr(ses, pSMB);
 358         bcc_ptr = pByteArea(smb_buf);
 359
 360         if(type == LANMAN) {
 361 #ifdef CONFIG_CIFS_WEAK_PW_HASH
 362                 char lnm_session_key[CIFS_SESSION_KEY_SIZE];
 363                 char password_with_pad[CIFS_ENCPWD_SIZE];
 364
 365                 /* no capabilities flags in old lanman negotiation */
 366
 367                 pSMB->old_req.PasswordLength = CIFS_SESSION_KEY_SIZE;
 368                 /* BB calculate hash with password */
 369                 /* and copy into bcc */
 370
 371                 memset(password_with_pad, 0, CIFS_ENCPWD_SIZE);
 372                 strncpy(password_with_pad, ses->password, CIFS_ENCPWD_SIZE);
 373
 374                 /* calculate old style session key */
 375                 /* toupper may be less broken then repeatedly calling
 376                 nls_toupper would be, but neither handles multibyte code pages
 377                 but the only alternative would be converting to UCS-16 (Unicode)
 378                 uppercasing and converting back which is only worth doing if
 379                 we knew it were utf8. utf8 code page needs its own
 380                 toupper and tolower and strnicmp functions */
 381
 382                 for(i = 0; i< CIFS_ENCPWD_SIZE; i++) {
 383                         password_with_pad[i] = toupper(password_with_pad[i]);
 384                 }
 385
 386                 SMBencrypt(password_with_pad, ses->server->cryptKey,
 387                            lnm_session_key);
 388
 389 #ifdef CONFIG_CIFS_DEBUG2
 390                 cifs_dump_mem("cryptkey: ",ses->server->cryptKey,
 391                         CIFS_SESSION_KEY_SIZE);
 392 #endif
 393                 /* clear password before we return/free memory */
 394                 memset(password_with_pad, 0, CIFS_ENCPWD_SIZE);
 395                 memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_SESSION_KEY_SIZE);
 396                 bcc_ptr += CIFS_SESSION_KEY_SIZE;
 397
 398                 /* can not sign if LANMAN negotiated so no need
 399                 to calculate signing key? but what if server
 400                 changed to do higher than lanman dialect and
 401                 we reconnected would we ever calc signing_key? */
 402
 403                 cERROR(1,("Negotiating LANMAN setting up strings"));
 404                 /* Unicode not allowed for LANMAN dialects */
 405                 ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 406 #endif
 407         } else if (type == NTLM) {
 408                 char ntlm_session_key[CIFS_SESSION_KEY_SIZE];
 409
 410                 pSMB->req_no_secext.Capabilities = cpu_to_le32(capabilities);
 411                 pSMB->req_no_secext.CaseInsensitivePasswordLength =
 412                         cpu_to_le16(CIFS_SESSION_KEY_SIZE);
 413                 pSMB->req_no_secext.CaseSensitivePasswordLength =
 414                         cpu_to_le16(CIFS_SESSION_KEY_SIZE);
 415
 416                 /* calculate session key */
 417                 SMBNTencrypt(ses->password, ses->server->cryptKey,
 418                              ntlm_session_key);
 419
 420                 if(first_time) /* should this be moved into common code
 421                                   with similar ntlmv2 path? */
 422                         cifs_calculate_mac_key(
 423                                 ses->server->mac_signing_key,
 424                                 ntlm_session_key, ses->password);
 425                 /* copy session key */
 426
 427                 memcpy(bcc_ptr, (char *)ntlm_session_key,CIFS_SESSION_KEY_SIZE);
 428                 bcc_ptr += CIFS_SESSION_KEY_SIZE;
 429                 memcpy(bcc_ptr, (char *)ntlm_session_key,CIFS_SESSION_KEY_SIZE);
 430                 bcc_ptr += CIFS_SESSION_KEY_SIZE;
 431                 if(ses->capabilities & CAP_UNICODE)
 432                         unicode_ssetup_strings(&bcc_ptr, ses, nls_cp);
 433                 else
 434                         ascii_ssetup_strings(&bcc_ptr, ses, nls_cp);
 435         } else /* NTLMSSP or SPNEGO */ {
 436                 pSMB->req.hdr.Flags2 |= SMBFLG2_EXT_SEC;
 437                 capabilities |= CAP_EXTENDED_SECURITY;
 438                 pSMB->req.Capabilities = cpu_to_le32(capabilities);
 439                 /* BB set password lengths */
 440         }
 441
 442         count = (long) bcc_ptr - (long) pByteArea(smb_buf);
 443         smb_buf->smb_buf_length += count;
 444
 445         /* if we switch to small buffers, count will need to be fewer
 446            than 383 (strings less than 335 bytes) */
 447
 448         BCC_LE(smb_buf) = cpu_to_le16(count);
 449
 450
 451         /* BB FIXME check for other non ntlm code paths */
 452
 453         /* BB check is this too big for a small smb? */
 454
 455         iov[0].iov_base = (char *)pSMB;
 456         iov[0].iov_len = smb_buf->smb_buf_length + 4;
 457
 458         rc = SendReceive2(xid, ses, iov, 1 /* num_iovecs */, &resp_buf_type, 0);
 459         /* SMB request buf freed in SendReceive2 */
 460
 461         cFYI(1,("ssetup rc from sendrecv2 is %d",rc));
 462         if(rc)
 463                 goto ssetup_exit;
 464
 465         pSMB = (SESSION_SETUP_ANDX *)iov[0].iov_base;
 466         smb_buf = (struct smb_hdr *)iov[0].iov_base;
 467
 468         if((smb_buf->WordCount != 3) && (smb_buf->WordCount != 4)) {
 469                 rc = -EIO;
 470                 cERROR(1,("bad word count %d", smb_buf->WordCount));
 471                 goto ssetup_exit;
 472         }
 473         action = le16_to_cpu(pSMB->resp.Action);
 474         if (action & GUEST_LOGIN)
 475                 cFYI(1, (" Guest login")); /* BB mark SesInfo struct? */
 476         ses->Suid = smb_buf->Uid;   /* UID left in wire format (le) */
 477         cFYI(1, ("UID = %d ", ses->Suid));
 478         /* response can have either 3 or 4 word count - Samba sends 3 */
 479         /* and lanman response is 3 */
 480         bytes_remaining = BCC(smb_buf);
 481         bcc_ptr = pByteArea(smb_buf);
 482
 483         if(smb_buf->WordCount == 4) {
 484                 __u16 blob_len;
 485                 blob_len = le16_to_cpu(pSMB->resp.SecurityBlobLength);
 486                 bcc_ptr += blob_len;
 487                 if(blob_len > bytes_remaining) {
 488                         cERROR(1,("bad security blob length %d", blob_len));
 489                         rc = -EINVAL;
 490                         goto ssetup_exit;
 491                 }
 492                 bytes_remaining -= blob_len;
 493         }
 494
 495         /* BB check if Unicode and decode strings */
 496         if(smb_buf->Flags2 & SMBFLG2_UNICODE)
 497                 rc = decode_unicode_ssetup(&bcc_ptr, bytes_remaining,
 498                                                    ses, nls_cp);
 499         else
 500                 rc = decode_ascii_ssetup(&bcc_ptr, bytes_remaining, ses,nls_cp);
 501
 502 ssetup_exit:
 503         if(resp_buf_type == CIFS_SMALL_BUFFER) {
 504                 cFYI(1,("ssetup freeing small buf %p", iov[0].iov_base));
 505                 cifs_small_buf_release(iov[0].iov_base);
 506         } else if(resp_buf_type == CIFS_LARGE_BUFFER)
 507                 cifs_buf_release(iov[0].iov_base);
 508
 509         return rc;
 510 }
 511 #endif /* CONFIG_CIFS_EXPERIMENTAL */