source3/smbd/negprot.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    negprot reply code
   5    Copyright (C) Andrew Tridgell 1992-1998
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern int Protocol;
  25 extern int max_recv;
  26 extern fstring global_myworkgroup;
  27 extern fstring remote_machine;
  28 BOOL global_encrypted_passwords_negotiated = False;
  29 BOOL global_spnego_negotiated = False;
  30 struct auth_context *negprot_global_auth_context = NULL;
  31
  32 static void get_challange(char buff[8])
  33 {
  34         NTSTATUS nt_status;
  35         const uint8 *cryptkey;
  36
  37         /* We might be called more than once, muliple negprots are premitted */
  38         if (negprot_global_auth_context) {
  39                 DEBUG(3, ("get challange: is this a secondary negprot?  negprot_global_auth_context is non-NULL!\n"));
  40                 negprot_global_auth_context->free(&negprot_global_auth_context);
  41         }
  42
  43         DEBUG(10, ("get challange: creating negprot_global_auth_context\n"));
  44         if (!NT_STATUS_IS_OK(nt_status = make_auth_context_subsystem(&negprot_global_auth_context))) {
  45                 DEBUG(0, ("make_auth_context_subsystem returned %s", get_nt_error_msg(nt_status)));
  46                 smb_panic("cannot make_negprot_global_auth_context!\n");
  47         }
  48         DEBUG(10, ("get challange: getting challange\n"));
  49         cryptkey = negprot_global_auth_context->get_ntlm_challenge(negprot_global_auth_context);
  50         memcpy(buff, cryptkey, 8);
  51 }
  52
  53 /****************************************************************************
  54 reply for the core protocol
  55 ****************************************************************************/
  56 static int reply_corep(char *inbuf, char *outbuf)
  57 {
  58         int outsize = set_message(outbuf,1,0,True);
  59
  60         Protocol = PROTOCOL_CORE;
  61
  62         return outsize;
  63 }
  64
  65
  66 /****************************************************************************
  67 reply for the coreplus protocol
  68 ****************************************************************************/
  69 static int reply_coreplus(char *inbuf, char *outbuf)
  70 {
  71   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
  72   int outsize = set_message(outbuf,13,0,True);
  73   SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
  74                                  readbraw and writebraw (possibly) */
  75   /* Reply, SMBlockread, SMBwritelock supported. */
  76   SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
  77   SSVAL(outbuf,smb_vwv1,0x1); /* user level security, don't encrypt */
  78
  79   Protocol = PROTOCOL_COREPLUS;
  80
  81   return outsize;
  82 }
  83
  84
  85 /****************************************************************************
  86 reply for the lanman 1.0 protocol
  87 ****************************************************************************/
  88 static int reply_lanman1(char *inbuf, char *outbuf)
  89 {
  90   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
  91   int secword=0;
  92   time_t t = time(NULL);
  93
  94   global_encrypted_passwords_negotiated = lp_encrypted_passwords();
  95
  96   if (lp_security()>=SEC_USER) secword |= 1;
  97   if (global_encrypted_passwords_negotiated) secword |= 2;
  98
  99   set_message(outbuf,13,global_encrypted_passwords_negotiated?8:0,True);
 100   SSVAL(outbuf,smb_vwv1,secword);
 101   /* Create a token value and add it to the outgoing packet. */
 102   if (global_encrypted_passwords_negotiated) {
 103           get_challange(smb_buf(outbuf));
 104   }
 105
 106   Protocol = PROTOCOL_LANMAN1;
 107
 108   /* Reply, SMBlockread, SMBwritelock supported. */
 109   SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
 110   SSVAL(outbuf,smb_vwv2,max_recv);
 111   SSVAL(outbuf,smb_vwv3,lp_maxmux()); /* maxmux */
 112   SSVAL(outbuf,smb_vwv4,1);
 113   SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
 114                                  readbraw writebraw (possibly) */
 115   SIVAL(outbuf,smb_vwv6,sys_getpid());
 116   SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
 117
 118   put_dos_date(outbuf,smb_vwv8,t);
 119
 120   return (smb_len(outbuf)+4);
 121 }
 122
 123
 124 /****************************************************************************
 125 reply for the lanman 2.0 protocol
 126 ****************************************************************************/
 127 static int reply_lanman2(char *inbuf, char *outbuf)
 128 {
 129   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
 130   int secword=0;
 131   time_t t = time(NULL);
 132
 133   global_encrypted_passwords_negotiated = lp_encrypted_passwords();
 134
 135   if (lp_security()>=SEC_USER) secword |= 1;
 136   if (global_encrypted_passwords_negotiated) secword |= 2;
 137
 138   set_message(outbuf,13,global_encrypted_passwords_negotiated?8:0,True);
 139   SSVAL(outbuf,smb_vwv1,secword);
 140   SIVAL(outbuf,smb_vwv6,sys_getpid());
 141
 142   /* Create a token value and add it to the outgoing packet. */
 143   if (global_encrypted_passwords_negotiated) {
 144           get_challange(smb_buf(outbuf));
 145   }
 146
 147   Protocol = PROTOCOL_LANMAN2;
 148
 149   /* Reply, SMBlockread, SMBwritelock supported. */
 150   SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
 151   SSVAL(outbuf,smb_vwv2,max_recv);
 152   SSVAL(outbuf,smb_vwv3,lp_maxmux());
 153   SSVAL(outbuf,smb_vwv4,1);
 154   SSVAL(outbuf,smb_vwv5,raw); /* readbraw and/or writebraw */
 155   SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
 156   put_dos_date(outbuf,smb_vwv8,t);
 157
 158   return (smb_len(outbuf)+4);
 159 }
 160
 161
 162
 163 /*
 164    generate the spnego negprot reply blob. Return the number of bytes used
 165 */
 166 static int negprot_spnego(char *p)
 167 {
 168         DATA_BLOB blob;
 169         extern pstring global_myname;
 170         uint8 guid[16];
 171         const char *OIDs_krb5[] = {OID_NTLMSSP,
 172                                    OID_KERBEROS5,
 173                                    OID_KERBEROS5_OLD,
 174                                    NULL};
 175         const char *OIDs_plain[] = {OID_NTLMSSP, NULL};
 176         char *principal;
 177         int len;
 178
 179         global_spnego_negotiated = True;
 180
 181         memset(guid, 0, 16);
 182         safe_strcpy((char *)guid, global_myname, 16);
 183         strlower((char *)guid);
 184
 185 #if 0
 186         /* strangely enough, NT does not sent the single OID NTLMSSP when
 187            not a ADS member, it sends no OIDs at all
 188
 189            we can't do this until we teach our sesssion setup parser to know
 190            about raw NTLMSSP (clients send no ASN.1 wrapping if we do this)
 191         */
 192         if (lp_security() != SEC_ADS) {
 193                 memcpy(p, guid, 16);
 194                 return 16;
 195         }
 196 #endif
 197         {
 198                 ADS_STRUCT *ads;
 199                 ads = ads_init(NULL, NULL, NULL, NULL);
 200
 201                 /* win2000 uses host$@REALM, which we will probably use eventually,
 202                    but for now this works */
 203                 asprintf(&principal, "HOST/%s@%s", guid, ads->realm);
 204                 blob = spnego_gen_negTokenInit(guid,
 205                                                lp_security()==SEC_ADS ? OIDs_krb5 : OIDs_plain,
 206                                                principal);
 207                 free(principal);
 208                 ads_destroy(&ads);
 209         }
 210         memcpy(p, blob.data, blob.length);
 211         len = blob.length;
 212         data_blob_free(&blob);
 213         return len;
 214 }
 215
 216
 217
 218 /****************************************************************************
 219 reply for the nt protocol
 220 ****************************************************************************/
 221 static int reply_nt1(char *inbuf, char *outbuf)
 222 {
 223         /* dual names + lock_and_read + nt SMBs + remote API calls */
 224         int capabilities = CAP_NT_FIND|CAP_LOCK_AND_READ|
 225                 CAP_LEVEL_II_OPLOCKS|CAP_STATUS32;
 226
 227         int secword=0;
 228         time_t t = time(NULL);
 229         char *p, *q;
 230         BOOL negotiate_spnego = False;
 231
 232         global_encrypted_passwords_negotiated = lp_encrypted_passwords();
 233
 234         /* do spnego in user level security if the client
 235            supports it and we can do encrypted passwords */
 236
 237         if (global_encrypted_passwords_negotiated &&
 238             (lp_security() != SEC_SHARE) &&
 239             lp_use_spnego() &&
 240             (SVAL(inbuf, smb_flg2) & FLAGS2_EXTENDED_SECURITY)) {
 241                 negotiate_spnego = True;
 242                 capabilities |= CAP_EXTENDED_SECURITY;
 243         }
 244
 245         capabilities |= CAP_NT_SMBS|CAP_RPC_REMOTE_APIS;
 246
 247         if (lp_large_readwrite() && (SMB_OFF_T_BITS == 64)) {
 248                 capabilities |= CAP_LARGE_READX|CAP_LARGE_WRITEX|CAP_W2K_SMBS;
 249         }
 250
 251         if (SMB_OFF_T_BITS == 64) {
 252                 capabilities |= CAP_LARGE_FILES;
 253         }
 254
 255         if (lp_readraw() && lp_writeraw()) {
 256                 capabilities |= CAP_RAW_MODE;
 257         }
 258
 259         /* allow for disabling unicode */
 260         if (lp_unicode()) {
 261                 capabilities |= CAP_UNICODE;
 262         }
 263
 264         if (lp_host_msdfs())
 265                 capabilities |= CAP_DFS;
 266
 267         if (lp_security() >= SEC_USER) secword |= 1;
 268         if (global_encrypted_passwords_negotiated) secword |= 2;
 269
 270         set_message(outbuf,17,0,True);
 271
 272         CVAL(outbuf,smb_vwv1) = secword;
 273
 274         Protocol = PROTOCOL_NT1;
 275
 276         SSVAL(outbuf,smb_vwv1+1,lp_maxmux()); /* maxmpx */
 277         SSVAL(outbuf,smb_vwv2+1,1); /* num vcs */
 278         SIVAL(outbuf,smb_vwv3+1,0xffff); /* max buffer. LOTS! */
 279         SIVAL(outbuf,smb_vwv5+1,0x10000); /* raw size. full 64k */
 280         SIVAL(outbuf,smb_vwv7+1,sys_getpid()); /* session key */
 281         SIVAL(outbuf,smb_vwv9+1,capabilities); /* capabilities */
 282         put_long_date(outbuf+smb_vwv11+1,t);
 283         SSVALS(outbuf,smb_vwv15+1,TimeDiff(t)/60);
 284
 285         p = q = smb_buf(outbuf);
 286         if (!negotiate_spnego) {
 287                 /* Create a token value and add it to the outgoing packet. */
 288                 if (global_encrypted_passwords_negotiated) {
 289                         get_challange(p);
 290                 }
 291                 SSVALS(outbuf,smb_vwv16+1,8);
 292                 p += 8;
 293                 p += srvstr_push(outbuf, p, global_myworkgroup, -1,
 294                                  STR_UNICODE|STR_TERMINATE|STR_NOALIGN);
 295                 DEBUG(3,("not using SPNEGO\n"));
 296         } else {
 297                 int len = negprot_spnego(p);
 298
 299                 SSVALS(outbuf,smb_vwv16+1,len);
 300                 p += len;
 301                 DEBUG(3,("using SPNEGO\n"));
 302         }
 303
 304         SSVAL(outbuf,smb_vwv17, p - q); /* length of challenge+domain strings */
 305         set_message_end(outbuf, p);
 306
 307         return (smb_len(outbuf)+4);
 308 }
 309
 310 /* these are the protocol lists used for auto architecture detection:
 311
 312 WinNT 3.51:
 313 protocol [PC NETWORK PROGRAM 1.0]
 314 protocol [XENIX CORE]
 315 protocol [MICROSOFT NETWORKS 1.03]
 316 protocol [LANMAN1.0]
 317 protocol [Windows for Workgroups 3.1a]
 318 protocol [LM1.2X002]
 319 protocol [LANMAN2.1]
 320 protocol [NT LM 0.12]
 321
 322 Win95:
 323 protocol [PC NETWORK PROGRAM 1.0]
 324 protocol [XENIX CORE]
 325 protocol [MICROSOFT NETWORKS 1.03]
 326 protocol [LANMAN1.0]
 327 protocol [Windows for Workgroups 3.1a]
 328 protocol [LM1.2X002]
 329 protocol [LANMAN2.1]
 330 protocol [NT LM 0.12]
 331
 332 Win2K:
 333 protocol [PC NETWORK PROGRAM 1.0]
 334 protocol [LANMAN1.0]
 335 protocol [Windows for Workgroups 3.1a]
 336 protocol [LM1.2X002]
 337 protocol [LANMAN2.1]
 338 protocol [NT LM 0.12]
 339
 340 OS/2:
 341 protocol [PC NETWORK PROGRAM 1.0]
 342 protocol [XENIX CORE]
 343 protocol [LANMAN1.0]
 344 protocol [LM1.2X002]
 345 protocol [LANMAN2.1]
 346 */
 347
 348 /*
 349   * Modified to recognize the architecture of the remote machine better.
 350   *
 351   * This appears to be the matrix of which protocol is used by which
 352   * MS product.
 353        Protocol                       WfWg    Win95   WinNT  Win2K  OS/2
 354        PC NETWORK PROGRAM 1.0          1       1       1      1      1
 355        XENIX CORE                                      2             2
 356        MICROSOFT NETWORKS 3.0          2       2
 357        DOS LM1.2X002                   3       3
 358        MICROSOFT NETWORKS 1.03                         3
 359        DOS LANMAN2.1                   4       4
 360        LANMAN1.0                                       4      2      3
 361        Windows for Workgroups 3.1a     5       5       5      3
 362        LM1.2X002                                       6      4      4
 363        LANMAN2.1                                       7      5      5
 364        NT LM 0.12                              6       8      6
 365   *
 366   *  tim@fsg.com 09/29/95
 367   *  Win2K added by matty 17/7/99
 368   */
 369
 370 #define ARCH_WFWG     0x3      /* This is a fudge because WfWg is like Win95 */
 371 #define ARCH_WIN95    0x2
 372 #define ARCH_WINNT    0x4
 373 #define ARCH_WIN2K    0xC      /* Win2K is like NT */
 374 #define ARCH_OS2      0x14     /* Again OS/2 is like NT */
 375 #define ARCH_SAMBA    0x20
 376
 377 #define ARCH_ALL      0x3F
 378
 379 /* List of supported protocols, most desired first */
 380 static struct {
 381   char *proto_name;
 382   char *short_name;
 383   int (*proto_reply_fn)(char *, char *);
 384   int protocol_level;
 385 } supported_protocols[] = {
 386   {"NT LANMAN 1.0",           "NT1",      reply_nt1,      PROTOCOL_NT1},
 387   {"NT LM 0.12",              "NT1",      reply_nt1,      PROTOCOL_NT1},
 388   {"LM1.2X002",               "LANMAN2",  reply_lanman2,  PROTOCOL_LANMAN2},
 389   {"Samba",                   "LANMAN2",  reply_lanman2,  PROTOCOL_LANMAN2},
 390   {"DOS LM1.2X002",           "LANMAN2",  reply_lanman2,  PROTOCOL_LANMAN2},
 391   {"LANMAN1.0",               "LANMAN1",  reply_lanman1,  PROTOCOL_LANMAN1},
 392   {"MICROSOFT NETWORKS 3.0",  "LANMAN1",  reply_lanman1,  PROTOCOL_LANMAN1},
 393   {"MICROSOFT NETWORKS 1.03", "COREPLUS", reply_coreplus, PROTOCOL_COREPLUS},
 394   {"PC NETWORK PROGRAM 1.0",  "CORE",     reply_corep,    PROTOCOL_CORE},
 395   {NULL,NULL,NULL,0},
 396 };
 397
 398
 399 /****************************************************************************
 400   reply to a negprot
 401 ****************************************************************************/
 402 int reply_negprot(connection_struct *conn,
 403                   char *inbuf,char *outbuf, int dum_size,
 404                   int dum_buffsize)
 405 {
 406   int outsize = set_message(outbuf,1,0,True);
 407   int Index=0;
 408   int choice= -1;
 409   int protocol;
 410   char *p;
 411   int bcc = SVAL(smb_buf(inbuf),-2);
 412   int arch = ARCH_ALL;
 413   START_PROFILE(SMBnegprot);
 414
 415   p = smb_buf(inbuf)+1;
 416   while (p < (smb_buf(inbuf) + bcc))
 417     {
 418       Index++;
 419       DEBUG(3,("Requested protocol [%s]\n",p));
 420       if (strcsequal(p,"Windows for Workgroups 3.1a"))
 421         arch &= ( ARCH_WFWG | ARCH_WIN95 | ARCH_WINNT | ARCH_WIN2K );
 422       else if (strcsequal(p,"DOS LM1.2X002"))
 423         arch &= ( ARCH_WFWG | ARCH_WIN95 );
 424       else if (strcsequal(p,"DOS LANMAN2.1"))
 425         arch &= ( ARCH_WFWG | ARCH_WIN95 );
 426       else if (strcsequal(p,"NT LM 0.12"))
 427         arch &= ( ARCH_WIN95 | ARCH_WINNT | ARCH_WIN2K );
 428       else if (strcsequal(p,"LANMAN2.1"))
 429         arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
 430       else if (strcsequal(p,"LM1.2X002"))
 431         arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
 432       else if (strcsequal(p,"MICROSOFT NETWORKS 1.03"))
 433         arch &= ARCH_WINNT;
 434       else if (strcsequal(p,"XENIX CORE"))
 435         arch &= ( ARCH_WINNT | ARCH_OS2 );
 436       else if (strcsequal(p,"Samba")) {
 437         arch = ARCH_SAMBA;
 438         break;
 439       }
 440
 441       p += strlen(p) + 2;
 442     }
 443
 444   switch ( arch ) {
 445   case ARCH_SAMBA:
 446     set_remote_arch(RA_SAMBA);
 447     break;
 448   case ARCH_WFWG:
 449     set_remote_arch(RA_WFWG);
 450     break;
 451   case ARCH_WIN95:
 452     set_remote_arch(RA_WIN95);
 453     break;
 454   case ARCH_WINNT:
 455    if(SVAL(inbuf,smb_flg2)==FLAGS2_WIN2K_SIGNATURE)
 456      set_remote_arch(RA_WIN2K);
 457    else
 458      set_remote_arch(RA_WINNT);
 459     break;
 460   case ARCH_WIN2K:
 461     set_remote_arch(RA_WIN2K);
 462     break;
 463   case ARCH_OS2:
 464     set_remote_arch(RA_OS2);
 465     break;
 466   default:
 467     set_remote_arch(RA_UNKNOWN);
 468     break;
 469   }
 470
 471   /* possibly reload - change of architecture */
 472   reload_services(True);
 473
 474   /* Check for protocols, most desirable first */
 475   for (protocol = 0; supported_protocols[protocol].proto_name; protocol++)
 476     {
 477       p = smb_buf(inbuf)+1;
 478       Index = 0;
 479       if ((supported_protocols[protocol].protocol_level <= lp_maxprotocol()) &&
 480           (supported_protocols[protocol].protocol_level >= lp_minprotocol()))
 481         while (p < (smb_buf(inbuf) + bcc))
 482           {
 483             if (strequal(p,supported_protocols[protocol].proto_name))
 484               choice = Index;
 485             Index++;
 486             p += strlen(p) + 2;
 487           }
 488       if(choice != -1)
 489         break;
 490     }
 491
 492   SSVAL(outbuf,smb_vwv0,choice);
 493   if(choice != -1) {
 494     extern fstring remote_proto;
 495     fstrcpy(remote_proto,supported_protocols[protocol].short_name);
 496     reload_services(True);
 497     outsize = supported_protocols[protocol].proto_reply_fn(inbuf, outbuf);
 498     DEBUG(3,("Selected protocol %s\n",supported_protocols[protocol].proto_name));
 499   }
 500   else {
 501     DEBUG(0,("No protocol supported !\n"));
 502   }
 503   SSVAL(outbuf,smb_vwv0,choice);
 504
 505   DEBUG( 5, ( "negprot index=%d\n", choice ) );
 506
 507   END_PROFILE(SMBnegprot);
 508   return(outsize);
 509 }
 510