source/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
  29 /****************************************************************************
  30 reply for the core protocol
  31 ****************************************************************************/
  32 static int reply_corep(char *outbuf)
  33 {
  34         int outsize = set_message(outbuf,1,0,True);
  35
  36         Protocol = PROTOCOL_CORE;
  37
  38         return outsize;
  39 }
  40
  41
  42 /****************************************************************************
  43 reply for the coreplus protocol
  44 ****************************************************************************/
  45 static int reply_coreplus(char *outbuf)
  46 {
  47   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
  48   int outsize = set_message(outbuf,13,0,True);
  49   SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
  50                                  readbraw and writebraw (possibly) */
  51   /* Reply, SMBlockread, SMBwritelock supported. */
  52   SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
  53   SSVAL(outbuf,smb_vwv1,0x1); /* user level security, don't encrypt */
  54
  55   Protocol = PROTOCOL_COREPLUS;
  56
  57   return outsize;
  58 }
  59
  60
  61 /****************************************************************************
  62 reply for the lanman 1.0 protocol
  63 ****************************************************************************/
  64 static int reply_lanman1(char *outbuf)
  65 {
  66   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
  67   int secword=0;
  68   BOOL doencrypt = SMBENCRYPT();
  69   time_t t = time(NULL);
  70
  71   if (lp_security()>=SEC_USER) secword |= 1;
  72   if (doencrypt) secword |= 2;
  73
  74   set_message(outbuf,13,doencrypt?8:0,True);
  75   SSVAL(outbuf,smb_vwv1,secword);
  76   /* Create a token value and add it to the outgoing packet. */
  77   if (doencrypt)
  78     generate_next_challenge(smb_buf(outbuf));
  79
  80   Protocol = PROTOCOL_LANMAN1;
  81
  82   /* Reply, SMBlockread, SMBwritelock supported. */
  83   SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
  84   SSVAL(outbuf,smb_vwv2,max_recv);
  85   SSVAL(outbuf,smb_vwv3,lp_maxmux()); /* maxmux */
  86   SSVAL(outbuf,smb_vwv4,1);
  87   SSVAL(outbuf,smb_vwv5,raw); /* tell redirector we support
  88                                  readbraw writebraw (possibly) */
  89   SIVAL(outbuf,smb_vwv6,sys_getpid());
  90   SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
  91
  92   put_dos_date(outbuf,smb_vwv8,t);
  93
  94   return (smb_len(outbuf)+4);
  95 }
  96
  97
  98 /****************************************************************************
  99 reply for the lanman 2.0 protocol
 100 ****************************************************************************/
 101 static int reply_lanman2(char *outbuf)
 102 {
 103   int raw = (lp_readraw()?1:0) | (lp_writeraw()?2:0);
 104   int secword=0;
 105   BOOL doencrypt = SMBENCRYPT();
 106   time_t t = time(NULL);
 107   struct cli_state *cli = NULL;
 108   char cryptkey[8];
 109   char crypt_len = 0;
 110
 111   if (lp_security() == SEC_SERVER) {
 112           cli = server_cryptkey();
 113   }
 114
 115   if (cli) {
 116           DEBUG(3,("using password server validation\n"));
 117           doencrypt = ((cli->sec_mode & 2) != 0);
 118   }
 119
 120   if (lp_security()>=SEC_USER) secword |= 1;
 121   if (doencrypt) secword |= 2;
 122
 123   if (doencrypt) {
 124           crypt_len = 8;
 125           if (!cli) {
 126                   generate_next_challenge(cryptkey);
 127           } else {
 128                   memcpy(cryptkey, cli->cryptkey, 8);
 129                   set_challenge(cli->cryptkey);
 130           }
 131   }
 132
 133   set_message(outbuf,13,crypt_len,True);
 134   SSVAL(outbuf,smb_vwv1,secword);
 135   SIVAL(outbuf,smb_vwv6,sys_getpid());
 136   if (doencrypt)
 137           memcpy(smb_buf(outbuf), cryptkey, 8);
 138
 139   Protocol = PROTOCOL_LANMAN2;
 140
 141   /* Reply, SMBlockread, SMBwritelock supported. */
 142   SCVAL(outbuf,smb_flg,FLAG_REPLY|FLAG_SUPPORT_LOCKREAD);
 143   SSVAL(outbuf,smb_vwv2,max_recv);
 144   SSVAL(outbuf,smb_vwv3,lp_maxmux());
 145   SSVAL(outbuf,smb_vwv4,1);
 146   SSVAL(outbuf,smb_vwv5,raw); /* readbraw and/or writebraw */
 147   SSVAL(outbuf,smb_vwv10, TimeDiff(t)/60);
 148   put_dos_date(outbuf,smb_vwv8,t);
 149
 150   return (smb_len(outbuf)+4);
 151 }
 152
 153
 154 /****************************************************************************
 155 reply for the nt protocol
 156 ****************************************************************************/
 157 static int reply_nt1(char *outbuf)
 158 {
 159   /* dual names + lock_and_read + nt SMBs + remote API calls */
 160   int capabilities = CAP_NT_FIND|CAP_LOCK_AND_READ|CAP_LEVEL_II_OPLOCKS|
 161                         (lp_nt_status_support() ? CAP_STATUS32 : 0)|
 162                         (lp_unix_extensions() ? CAP_UNIX : 0) |
 163                         (lp_nt_smb_support() ? CAP_NT_SMBS | CAP_RPC_REMOTE_APIS : 0) |
 164                         ((lp_large_readwrite() && (SMB_OFF_T_BITS == 64)) ?  CAP_LARGE_READX | CAP_LARGE_WRITEX | CAP_W2K_SMBS : 0) |
 165                         (SMB_OFF_T_BITS == 64 ? CAP_LARGE_FILES : 0);
 166   int secword=0;
 167   BOOL doencrypt = SMBENCRYPT();
 168   time_t t = time(NULL);
 169   int data_len;
 170   struct cli_state *cli = NULL;
 171   char cryptkey[8];
 172   char crypt_len = 0;
 173
 174   if (lp_security() == SEC_SERVER) {
 175           cli = server_cryptkey();
 176   }
 177
 178   if (cli) {
 179           DEBUG(3,("using password server validation\n"));
 180           doencrypt = ((cli->sec_mode & 2) != 0);
 181   }
 182
 183   if (doencrypt) {
 184           crypt_len = 8;
 185           if (!cli) {
 186                   generate_next_challenge(cryptkey);
 187           } else {
 188                   memcpy(cryptkey, cli->cryptkey, 8);
 189                   set_challenge(cli->cryptkey);
 190           }
 191   }
 192
 193   if (lp_readraw() && lp_writeraw()) {
 194           capabilities |= CAP_RAW_MODE;
 195   }
 196
 197 #ifdef WITH_MSDFS
 198   if(lp_host_msdfs())
 199         capabilities |= CAP_DFS;
 200 #endif
 201
 202   if (lp_security() >= SEC_USER) secword |= 1;
 203   if (doencrypt) secword |= 2;
 204
 205   /* decide where (if) to put the encryption challenge, and
 206      follow it with the OEM'd domain name
 207    */
 208   data_len = crypt_len + strlen(global_myworkgroup) + 1;
 209
 210   set_message(outbuf,17,data_len,True);
 211   pstrcpy(smb_buf(outbuf)+crypt_len, global_myworkgroup);
 212
 213   SCVAL(outbuf,smb_vwv1,secword);
 214   SSVALS(outbuf,smb_vwv16+1,crypt_len);
 215   if (doencrypt)
 216           memcpy(smb_buf(outbuf), cryptkey, 8);
 217
 218   Protocol = PROTOCOL_NT1;
 219
 220   SSVAL(outbuf,smb_vwv1+1,lp_maxmux()); /* maxmpx */
 221   SSVAL(outbuf,smb_vwv2+1,1); /* num vcs */
 222   SIVAL(outbuf,smb_vwv3+1,max_recv); /* max buffer. LOTS! */
 223   SIVAL(outbuf,smb_vwv5+1,0x10000); /* raw size. full 64k */
 224   SIVAL(outbuf,smb_vwv7+1,sys_getpid()); /* session key */
 225   SIVAL(outbuf,smb_vwv9+1,capabilities); /* capabilities */
 226   put_long_date(outbuf+smb_vwv11+1,t);
 227   SSVALS(outbuf,smb_vwv15+1,TimeDiff(t)/60);
 228   SSVAL(outbuf,smb_vwv17,data_len); /* length of challenge+domain strings */
 229
 230   return (smb_len(outbuf)+4);
 231 }
 232
 233 /* these are the protocol lists used for auto architecture detection:
 234
 235 WinNT 3.51:
 236 protocol [PC NETWORK PROGRAM 1.0]
 237 protocol [XENIX CORE]
 238 protocol [MICROSOFT NETWORKS 1.03]
 239 protocol [LANMAN1.0]
 240 protocol [Windows for Workgroups 3.1a]
 241 protocol [LM1.2X002]
 242 protocol [LANMAN2.1]
 243 protocol [NT LM 0.12]
 244
 245 Win95:
 246 protocol [PC NETWORK PROGRAM 1.0]
 247 protocol [XENIX CORE]
 248 protocol [MICROSOFT NETWORKS 1.03]
 249 protocol [LANMAN1.0]
 250 protocol [Windows for Workgroups 3.1a]
 251 protocol [LM1.2X002]
 252 protocol [LANMAN2.1]
 253 protocol [NT LM 0.12]
 254
 255 Win2K:
 256 protocol [PC NETWORK PROGRAM 1.0]
 257 protocol [LANMAN1.0]
 258 protocol [Windows for Workgroups 3.1a]
 259 protocol [LM1.2X002]
 260 protocol [LANMAN2.1]
 261 protocol [NT LM 0.12]
 262
 263 OS/2:
 264 protocol [PC NETWORK PROGRAM 1.0]
 265 protocol [XENIX CORE]
 266 protocol [LANMAN1.0]
 267 protocol [LM1.2X002]
 268 protocol [LANMAN2.1]
 269 */
 270
 271 /*
 272   * Modified to recognize the architecture of the remote machine better.
 273   *
 274   * This appears to be the matrix of which protocol is used by which
 275   * MS product.
 276        Protocol                       WfWg    Win95   WinNT  Win2K  OS/2
 277        PC NETWORK PROGRAM 1.0          1       1       1      1      1
 278        XENIX CORE                                      2             2
 279        MICROSOFT NETWORKS 3.0          2       2
 280        DOS LM1.2X002                   3       3
 281        MICROSOFT NETWORKS 1.03                         3
 282        DOS LANMAN2.1                   4       4
 283        LANMAN1.0                                       4      2      3
 284        Windows for Workgroups 3.1a     5       5       5      3
 285        LM1.2X002                                       6      4      4
 286        LANMAN2.1                                       7      5      5
 287        NT LM 0.12                              6       8      6
 288   *
 289   *  tim@fsg.com 09/29/95
 290   *  Win2K added by matty 17/7/99
 291   */
 292
 293 #define ARCH_WFWG     0x3      /* This is a fudge because WfWg is like Win95 */
 294 #define ARCH_WIN95    0x2
 295 #define ARCH_WINNT    0x4
 296 #define ARCH_WIN2K    0xC      /* Win2K is like NT */
 297 #define ARCH_OS2      0x14     /* Again OS/2 is like NT */
 298 #define ARCH_SAMBA    0x20
 299
 300 #define ARCH_ALL      0x3F
 301
 302 /* List of supported protocols, most desired first */
 303 static struct {
 304   char *proto_name;
 305   char *short_name;
 306   int (*proto_reply_fn)(char *);
 307   int protocol_level;
 308 } supported_protocols[] = {
 309   {"NT LANMAN 1.0",           "NT1",      reply_nt1,      PROTOCOL_NT1},
 310   {"NT LM 0.12",              "NT1",      reply_nt1,      PROTOCOL_NT1},
 311   {"LM1.2X002",               "LANMAN2",  reply_lanman2,  PROTOCOL_LANMAN2},
 312   {"Samba",                   "LANMAN2",  reply_lanman2,  PROTOCOL_LANMAN2},
 313   {"DOS LM1.2X002",           "LANMAN2",  reply_lanman2,  PROTOCOL_LANMAN2},
 314   {"LANMAN1.0",               "LANMAN1",  reply_lanman1,  PROTOCOL_LANMAN1},
 315   {"MICROSOFT NETWORKS 3.0",  "LANMAN1",  reply_lanman1,  PROTOCOL_LANMAN1},
 316   {"MICROSOFT NETWORKS 1.03", "COREPLUS", reply_coreplus, PROTOCOL_COREPLUS},
 317   {"PC NETWORK PROGRAM 1.0",  "CORE",     reply_corep,    PROTOCOL_CORE},
 318   {NULL,NULL,NULL,0},
 319 };
 320
 321
 322 /****************************************************************************
 323   reply to a negprot
 324 ****************************************************************************/
 325 int reply_negprot(connection_struct *conn,
 326                   char *inbuf,char *outbuf, int dum_size,
 327                   int dum_buffsize)
 328 {
 329   int outsize = set_message(outbuf,1,0,True);
 330   int Index=0;
 331   int choice= -1;
 332   int protocol;
 333   char *p;
 334   int bcc = SVAL(smb_buf(inbuf),-2);
 335   int arch = ARCH_ALL;
 336   START_PROFILE(SMBnegprot);
 337
 338   p = smb_buf(inbuf)+1;
 339   while (p < (smb_buf(inbuf) + bcc))
 340     {
 341       Index++;
 342       DEBUG(3,("Requested protocol [%s]\n",p));
 343       if (strcsequal(p,"Windows for Workgroups 3.1a"))
 344         arch &= ( ARCH_WFWG | ARCH_WIN95 | ARCH_WINNT | ARCH_WIN2K );
 345       else if (strcsequal(p,"DOS LM1.2X002"))
 346         arch &= ( ARCH_WFWG | ARCH_WIN95 );
 347       else if (strcsequal(p,"DOS LANMAN2.1"))
 348         arch &= ( ARCH_WFWG | ARCH_WIN95 );
 349       else if (strcsequal(p,"NT LM 0.12"))
 350         arch &= ( ARCH_WIN95 | ARCH_WINNT | ARCH_WIN2K );
 351       else if (strcsequal(p,"LANMAN2.1"))
 352         arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
 353       else if (strcsequal(p,"LM1.2X002"))
 354         arch &= ( ARCH_WINNT | ARCH_WIN2K | ARCH_OS2 );
 355       else if (strcsequal(p,"MICROSOFT NETWORKS 1.03"))
 356         arch &= ARCH_WINNT;
 357       else if (strcsequal(p,"XENIX CORE"))
 358         arch &= ( ARCH_WINNT | ARCH_OS2 );
 359       else if (strcsequal(p,"Samba")) {
 360         arch = ARCH_SAMBA;
 361         break;
 362       }
 363
 364       p += strlen(p) + 2;
 365     }
 366
 367   switch ( arch ) {
 368   case ARCH_SAMBA:
 369     set_remote_arch(RA_SAMBA);
 370     break;
 371   case ARCH_WFWG:
 372     set_remote_arch(RA_WFWG);
 373     break;
 374   case ARCH_WIN95:
 375     set_remote_arch(RA_WIN95);
 376     break;
 377   case ARCH_WINNT:
 378    if(SVAL(inbuf,smb_flg2)==FLAGS2_WIN2K_SIGNATURE)
 379      set_remote_arch(RA_WIN2K);
 380    else
 381      set_remote_arch(RA_WINNT);
 382     break;
 383   case ARCH_WIN2K:
 384     set_remote_arch(RA_WIN2K);
 385     break;
 386   case ARCH_OS2:
 387     set_remote_arch(RA_OS2);
 388     break;
 389   default:
 390     set_remote_arch(RA_UNKNOWN);
 391     break;
 392   }
 393
 394   /* possibly reload - change of architecture */
 395   reload_services(True);
 396
 397   /* a special case to stop password server loops */
 398   if (Index == 1 && strequal(remote_machine,myhostname()) &&
 399       (lp_security()==SEC_SERVER || lp_security()==SEC_DOMAIN))
 400     exit_server("Password server loop!");
 401
 402   /* Check for protocols, most desirable first */
 403   for (protocol = 0; supported_protocols[protocol].proto_name; protocol++)
 404     {
 405       p = smb_buf(inbuf)+1;
 406       Index = 0;
 407       if ((supported_protocols[protocol].protocol_level <= lp_maxprotocol()) &&
 408           (supported_protocols[protocol].protocol_level >= lp_minprotocol()))
 409         while (p < (smb_buf(inbuf) + bcc))
 410           {
 411             if (strequal(p,supported_protocols[protocol].proto_name))
 412               choice = Index;
 413             Index++;
 414             p += strlen(p) + 2;
 415           }
 416       if(choice != -1)
 417         break;
 418     }
 419
 420   SSVAL(outbuf,smb_vwv0,choice);
 421   if(choice != -1) {
 422     extern fstring remote_proto;
 423     fstrcpy(remote_proto,supported_protocols[protocol].short_name);
 424     reload_services(True);
 425     outsize = supported_protocols[protocol].proto_reply_fn(outbuf);
 426     DEBUG(3,("Selected protocol %s\n",supported_protocols[protocol].proto_name));
 427   }
 428   else {
 429     DEBUG(0,("No protocol supported !\n"));
 430   }
 431   SSVAL(outbuf,smb_vwv0,choice);
 432
 433   DEBUG( 5, ( "negprot index=%d\n", choice ) );
 434
 435   END_PROFILE(SMBnegprot);
 436   return(outsize);
 437 }