source3/smbd/password.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Password and authentication handling
   5    Copyright (C) Andrew Tridgell 1992-1995
   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 #include "loadparm.h"
  24
  25 extern int DEBUGLEVEL;
  26 extern int Protocol;
  27
  28 /* users from session setup */
  29 static pstring session_users="";
  30
  31 /* these are kept here to keep the string_combinations function simple */
  32 static char this_user[100]="";
  33 static char this_salt[100]="";
  34 static char this_crypted[100]="";
  35
  36 #ifdef SMB_PASSWD
  37 /* Data to do lanman1/2 password challenge. */
  38 static unsigned char saved_challenge[8];
  39 static BOOL challenge_sent=False;
  40
  41 /*******************************************************************
  42 Get the next challenge value - no repeats.
  43 ********************************************************************/
  44 void generate_next_challenge(char *challenge)
  45 {
  46   extern void E1(char *,char *,char *);
  47   static int counter = 0;
  48   struct timeval tval;
  49   int v1,v2;
  50   GetTimeOfDay(&tval);
  51   v1 = (counter++) + getpid() + tval.tv_sec;
  52   v2 = (counter++) * getpid() + tval.tv_usec;
  53   SIVAL(challenge,0,v1);
  54   SIVAL(challenge,4,v2);
  55   E1(challenge,"SAMBA",saved_challenge);
  56   memcpy(challenge,saved_challenge,8);
  57   challenge_sent = True;
  58 }
  59
  60 /*******************************************************************
  61 set the last challenge sent, usually from a password server
  62 ********************************************************************/
  63 BOOL set_challenge(char *challenge)
  64 {
  65   memcpy(saved_challenge,challenge,8);
  66   challenge_sent = True;
  67   return(True);
  68 }
  69
  70 /*******************************************************************
  71 get the last challenge sent
  72 ********************************************************************/
  73 BOOL last_challenge(char *challenge)
  74 {
  75   if (!challenge_sent) return(False);
  76   memcpy(challenge,saved_challenge,8);
  77   return(True);
  78 }
  79 #endif
  80
  81 /* this holds info on user ids that are already validated for this VC */
  82 static user_struct *validated_users = NULL;
  83 static int num_validated_users = 0;
  84
  85 /****************************************************************************
  86 check if a uid has been validated, and return an index if it has. -1 if not
  87 ****************************************************************************/
  88 int valid_uid(int uid)
  89 {
  90   int i;
  91   if (uid == -1) return(-1);
  92
  93   for (i=0;i<num_validated_users;i++)
  94     if (validated_users[i].uid == uid)
  95       {
  96         DEBUG(3,("valid uid %d mapped to vuid %d (user=%s)\n",
  97                  uid,i,validated_users[i].name));
  98         return(i);
  99       }
 100   return(-1);
 101 }
 102
 103 /****************************************************************************
 104 check if a uid has been validated, and return an pointer to the user_struct
 105 if it has. NULL if not
 106 ****************************************************************************/
 107 user_struct *get_valid_user_struct(int uid)
 108 {
 109   int vuid = valid_uid(uid);
 110   if(vuid == -1 || validated_users[vuid].guest)
 111     return NULL;
 112   return &validated_users[vuid];
 113 }
 114
 115 /****************************************************************************
 116 invalidate a uid
 117 ****************************************************************************/
 118 void invalidate_uid(int uid)
 119 {
 120   int i;
 121   for (i=0;i<num_validated_users;i++)
 122     if (validated_users[i].uid == uid)
 123       {
 124         user_struct *vuser = &validated_users[i];
 125         vuser->uid = -1;
 126         vuser->gid = -1;
 127         vuser->user_ngroups = 0;
 128         if(vuser->user_groups &&
 129            (vuser->user_groups != (gid_t *)vuser->user_igroups))
 130           free(vuser->user_groups);
 131         vuser->user_groups = NULL;
 132         if(vuser->user_igroups)
 133           free(vuser->user_igroups);
 134         vuser->user_igroups = NULL;
 135       }
 136 }
 137
 138
 139 /****************************************************************************
 140 return a validated username
 141 ****************************************************************************/
 142 char *validated_username(int vuid)
 143 {
 144   return(validated_users[vuid].name);
 145 }
 146
 147 /****************************************************************************
 148 register a uid/name pair as being valid and that a valid password
 149 has been given.
 150 ****************************************************************************/
 151 void register_uid(int uid,int gid, char *name,BOOL guest)
 152 {
 153   user_struct *vuser;
 154
 155   if (valid_uid(uid) >= 0)
 156     return;
 157   validated_users = (user_struct *)Realloc(validated_users,
 158                                            sizeof(user_struct)*
 159                                            (num_validated_users+1));
 160
 161   if (!validated_users)
 162     {
 163       DEBUG(0,("Failed to realloc users struct!\n"));
 164       return;
 165     }
 166
 167   vuser = &validated_users[num_validated_users];
 168   vuser->uid = uid;
 169   vuser->gid = gid;
 170   vuser->guest = guest;
 171   strcpy(vuser->name,name);
 172
 173   vuser->user_ngroups = 0;
 174   vuser->user_groups = NULL;
 175   vuser->user_igroups = NULL;
 176
 177   /* Find all the groups this uid is in and store them.
 178      Used by become_user() */
 179   setup_groups(name,uid,gid,
 180                &vuser->user_ngroups,
 181                &vuser->user_igroups,
 182                &vuser->user_groups);
 183
 184   DEBUG(3,("uid %d registered to name %s\n",uid,name));
 185
 186   num_validated_users++;
 187 }
 188
 189
 190 /****************************************************************************
 191 add a name to the session users list
 192 ****************************************************************************/
 193 void add_session_user(char *user)
 194 {
 195   fstring suser;
 196   StrnCpy(suser,user,sizeof(suser)-1);
 197
 198   if (!Get_Pwnam(suser,True)) return;
 199
 200   if (suser && *suser && !in_list(suser,session_users,False))
 201     {
 202       if (strlen(suser) + strlen(session_users) + 2 >= sizeof(pstring))
 203         DEBUG(1,("Too many session users??\n"));
 204       else
 205         {
 206           strcat(session_users," ");
 207           strcat(session_users,suser);
 208         }
 209     }
 210 }
 211
 212
 213 #ifdef NO_GETSPNAM
 214 /* a fake shadow password routine which just fills a fake spwd struct
 215  * with the sp_pwdp field. (sreiz@aie.nl)
 216  */
 217 static struct spwd *getspnam(char *username) /* fake shadow password routine */
 218 {
 219        FILE *f;
 220        char line[1024];
 221        static char pw[20];
 222        static struct spwd static_spwd;
 223
 224        static_spwd.sp_pwdp=0;
 225        if (!(f=fopen("/etc/master.passwd", "r")))
 226                return 0;
 227        while (fgets(line, 1024, f)) {
 228                if (!strncmp(line, username, strlen(username)) &&
 229                 line[strlen(username)]==':') { /* found entry */
 230                        char *p, *q;
 231
 232                        p=line+strlen(username)+1;
 233                        if ((q=strchr(p, ':'))) {
 234                                *q=0;
 235                                if (q-p+1>20)
 236                                        break;
 237                                strcpy(pw, p);
 238                                static_spwd.sp_pwdp=pw;
 239                        }
 240                        break;
 241                }
 242        }
 243        fclose(f);
 244        if (static_spwd.sp_pwdp)
 245                return &static_spwd;
 246        return 0;
 247 }
 248 #endif
 249
 250
 251 #ifdef OSF1_ENH_SEC
 252 /****************************************************************************
 253 an enhanced crypt for OSF1
 254 ****************************************************************************/
 255 static char *osf1_bigcrypt(char *password,char *salt1)
 256 {
 257   static char result[AUTH_MAX_PASSWD_LENGTH] = "";
 258   char *p1;
 259   char *p2=password;
 260   char salt[3];
 261   int i;
 262   int parts = strlen(password) / AUTH_CLEARTEXT_SEG_CHARS;
 263   if (strlen(password)%AUTH_CLEARTEXT_SEG_CHARS)
 264     parts++;
 265
 266   StrnCpy(salt,salt1,2);
 267   StrnCpy(result,salt1,2);
 268
 269   for (i=0; i<parts;i++)
 270     {
 271       p1 = crypt(p2,salt);
 272       strcat(result,p1+2);
 273       StrnCpy(salt,&result[2+i*AUTH_CIPHERTEXT_SEG_CHARS],2);
 274       p2 += AUTH_CLEARTEXT_SEG_CHARS;
 275     }
 276
 277   return(result);
 278 }
 279 #endif
 280
 281
 282 /****************************************************************************
 283 update the enhanced security database. Only relevant for OSF1 at the moment.
 284 ****************************************************************************/
 285 static void update_protected_database( char *user, BOOL result)
 286 {
 287 #ifdef OSF1_ENH_SEC
 288   struct pr_passwd *mypasswd;
 289   time_t starttime;
 290   long tz;
 291
 292   mypasswd = getprpwnam (user);
 293   starttime = time (NULL);
 294   tz = mktime ( localtime ( &starttime ) );
 295
 296   if (result)
 297     {
 298       mypasswd->ufld.fd_slogin = tz;
 299       mypasswd->ufld.fd_nlogins = 0;
 300
 301       putprpwnam(user,mypasswd);
 302
 303       DEBUG(3,("Update protected database for Account %s after succesful connection\n",user));
 304     }
 305   else
 306     {
 307       mypasswd->ufld.fd_ulogin = tz;
 308       mypasswd->ufld.fd_nlogins = mypasswd->ufld.fd_nlogins + 1;
 309       if ( mypasswd->ufld.fd_max_tries != 0 && mypasswd->ufld.fd_nlogins > mypasswd->ufld.fd_max_tries )
 310         {
 311           mypasswd->uflg.fg_lock = 0;
 312           DEBUG(3,("Account is disabled -- see Account Administrator.\n"));
 313         }
 314       putprpwnam ( user , mypasswd );
 315       DEBUG(3,("Update protected database for Account %s after refusing connection\n",user));
 316     }
 317 #else
 318   DEBUG(6,("Updated database with %s %s\n",user,BOOLSTR(result)));
 319 #endif
 320 }
 321
 322
 323 #ifdef AFS_AUTH
 324 /*******************************************************************
 325 check on AFS authentication
 326 ********************************************************************/
 327 static BOOL afs_auth(char *this_user,char *password)
 328 {
 329   long password_expires = 0;
 330   char *reason;
 331
 332   /* For versions of AFS prior to 3.3, this routine has few arguments, */
 333   /* but since I can't find the old documentation... :-)               */
 334   setpag();
 335   if (ka_UserAuthenticateGeneral(KA_USERAUTH_VERSION+KA_USERAUTH_DOSETPAG,
 336                                  this_user,
 337                                  (char *) 0, /* instance */
 338                                  (char *) 0, /* cell */
 339                                  password,
 340                                  0,          /* lifetime, default */
 341                                  &password_expires, /*days 'til it expires */
 342                                  0,          /* spare 2 */
 343                                  &reason) == 0)
 344     return(True);
 345   return(False);
 346 }
 347 #endif
 348
 349
 350 #ifdef DFS_AUTH
 351
 352 sec_login_handle_t my_dce_sec_context;
 353 int dcelogin_atmost_once = 0;
 354
 355 /*******************************************************************
 356 check on a DCE/DFS authentication
 357 ********************************************************************/
 358 static BOOL dfs_auth(char *this_user,char *password)
 359 {
 360   error_status_t err;
 361   int err2;
 362   int prterr;
 363   boolean32 password_reset;
 364   sec_passwd_rec_t my_dce_password;
 365   sec_login_auth_src_t auth_src = sec_login_auth_src_network;
 366   unsigned char dce_errstr[dce_c_error_string_len];
 367
 368   /*
 369    * We only go for a DCE login context if the given password
 370    * matches that stored in the local password file..
 371    * Assumes local passwd file is kept in sync w/ DCE RGY!
 372    */
 373
 374   if (!strcmp((char *)crypt(password,this_salt),this_crypted) ||
 375       dcelogin_atmost_once)
 376     return(False);
 377
 378   if (sec_login_setup_identity(
 379                                (unsigned char *)this_user,
 380                                sec_login_no_flags,
 381                                &my_dce_sec_context,
 382                                &err) == 0)
 383     {
 384       dce_error_inq_text(err, dce_errstr, &err2);
 385       DEBUG(0,("DCE Setup Identity for %s failed: %s\n",
 386                this_user,dce_errstr));
 387       return(False);
 388     }
 389
 390   my_dce_password.version_number = sec_passwd_c_version_none;
 391   my_dce_password.pepper = NULL;
 392   my_dce_password.key.key_type = sec_passwd_plain;
 393   my_dce_password.key.tagged_union.plain  = (idl_char *)password;
 394
 395   if (sec_login_valid_and_cert_ident(my_dce_sec_context,
 396                                      &my_dce_password,
 397                                      &password_reset,
 398                                      &auth_src,
 399                                      &err) == 0 )
 400     {
 401       dce_error_inq_text(err, dce_errstr, &err2);
 402       DEBUG(0,("DCE Identity Validation failed for principal %s: %s\n",
 403                this_user,dce_errstr));
 404
 405       return(False);
 406     }
 407
 408   sec_login_set_context(my_dce_sec_context, &err);
 409   if (err != error_status_ok )
 410     {
 411       dce_error_inq_text(err, dce_errstr, &err2);
 412       DEBUG(0,("DCE login failed for principal %s, cant set context: %s\n",
 413                this_user,dce_errstr));
 414       sec_login_purge_context(my_dce_sec_context, &err);
 415       return(False);
 416     }
 417   else
 418     {
 419       DEBUG(0,("DCE login succeeded for principal %s on pid %d\n",
 420                this_user, getpid()));
 421     }
 422
 423   dcelogin_atmost_once = 1;
 424   return (True);
 425 }
 426
 427 void dfs_unlogin(void)
 428 {
 429   error_status_t err;
 430   int err2;
 431   unsigned char dce_errstr[dce_c_error_string_len];
 432
 433   sec_login_purge_context(my_dce_sec_context, &err);
 434   if (err != error_status_ok )
 435     {
 436       dce_error_inq_text(err, dce_errstr, &err2);
 437       DEBUG(0,("DCE purge login context failed for server instance %d: %s\n",
 438                getpid(), dce_errstr));
 439     }
 440 }
 441
 442 #endif
 443
 444
 445 #ifdef LINUX_BIGCRYPT
 446 /****************************************************************************
 447 an enhanced crypt for Linux to handle password longer than 8 characters
 448 ****************************************************************************/
 449 static int linux_bigcrypt(char *password,char *salt1, char *crypted)
 450 {
 451 #define LINUX_PASSWORD_SEG_CHARS 8
 452   char salt[3];
 453   int i;
 454
 455   StrnCpy(salt,salt1,2);
 456   crypted +=2;
 457
 458   for ( i=strlen(password); i > 0; i -= LINUX_PASSWORD_SEG_CHARS) {
 459     char * p = crypt(password,salt) + 2;
 460     if(strncmp(p, crypted, LINUX_PASSWORD_SEG_CHARS) != 0)
 461       return(0);
 462     password += LINUX_PASSWORD_SEG_CHARS;
 463     crypted  += strlen(p);
 464   }
 465
 466   return(1);
 467 }
 468 #endif
 469
 470
 471 /****************************************************************************
 472 apply a function to upper/lower case combinations
 473 of a string and return true if one of them returns true.
 474 try all combinations with N uppercase letters.
 475 offset is the first char to try and change (start with 0)
 476 it assumes the string starts lowercased
 477 ****************************************************************************/
 478 static BOOL string_combinations2(char *s,int offset,BOOL (*fn)(),int N)
 479 {
 480   int len = strlen(s);
 481   int i;
 482
 483 #ifdef PASSWORD_LENGTH
 484   len = MIN(len,PASSWORD_LENGTH);
 485 #endif
 486
 487   if (N <= 0 || offset >= len)
 488     return(fn(s));
 489
 490   for (i=offset;i<(len-(N-1));i++)
 491     {
 492       char c = s[i];
 493       if (!islower(c)) continue;
 494       s[i] = toupper(c);
 495       if (string_combinations2(s,i+1,fn,N-1))
 496         return(True);
 497       s[i] = c;
 498     }
 499   return(False);
 500 }
 501
 502 /****************************************************************************
 503 apply a function to upper/lower case combinations
 504 of a string and return true if one of them returns true.
 505 try all combinations with up to N uppercase letters.
 506 offset is the first char to try and change (start with 0)
 507 it assumes the string starts lowercased
 508 ****************************************************************************/
 509 static BOOL string_combinations(char *s,BOOL (*fn)(),int N)
 510 {
 511   int n;
 512   for (n=1;n<=N;n++)
 513     if (string_combinations2(s,0,fn,n)) return(True);
 514   return(False);
 515 }
 516
 517
 518
 519 /****************************************************************************
 520 core of password checking routine
 521 ****************************************************************************/
 522 BOOL password_check(char *password)
 523 {
 524 #ifdef AFS_AUTH
 525   if (afs_auth(this_user,password)) return(True);
 526 #endif
 527
 528 #ifdef DFS_AUTH
 529   if (dfs_auth(this_user,password)) return(True);
 530 #endif
 531
 532 #ifdef PWDAUTH
 533   if (pwdauth(this_user,password) == 0)
 534     return(True);
 535 #endif
 536
 537 #ifdef OSF1_ENH_SEC
 538   return(strcmp(osf1_bigcrypt(password,this_salt),this_crypted) == 0);
 539 #endif
 540
 541 #ifdef ULTRIX_AUTH
 542   return (strcmp((char *)crypt16(password, this_salt ),this_crypted) == 0);
 543 #endif
 544
 545 #ifdef LINUX_BIGCRYPT
 546   return(linux_bigcrypt(password,this_salt,this_crypted));
 547 #endif
 548
 549 #ifdef NO_CRYPT
 550   DEBUG(1,("Warning - no crypt available\n"));
 551   return(False);
 552 #else
 553   return(strcmp((char *)crypt(password,this_salt),this_crypted) == 0);
 554 #endif
 555 }
 556
 557 #ifdef SMB_PASSWD
 558 /****************************************************************************
 559 core of smb password checking routine.
 560 ****************************************************************************/
 561 BOOL smb_password_check(char *password, unsigned char *part_passwd, unsigned char *c8)
 562 {
 563   /* Finish the encryption of part_passwd. */
 564   unsigned char p21[21];
 565   unsigned char p24[24];
 566
 567   if(part_passwd == NULL)
 568     DEBUG(10,("No password set - allowing access\n"));
 569   /* No password set - always true ! */
 570   if(part_passwd == NULL)
 571     return 1;
 572
 573   memset(p21,'\0',21);
 574   memcpy(p21,part_passwd,16);
 575   E_P24(p21, c8, p24);
 576 #if DEBUG_PASSWORD
 577   {
 578     int i;
 579     DEBUG(100,("Part password (P16) was |"));
 580     for(i = 0; i < 16; i++)
 581       DEBUG(100,("%X ", (unsigned char)part_passwd[i]));
 582     DEBUG(100,("|\n"));
 583     DEBUG(100,("Password from client was |"));
 584     for(i = 0; i < 24; i++)
 585       DEBUG(100,("%X ", (unsigned char)password[i]));
 586     DEBUG(100,("|\n"));
 587     DEBUG(100,("Given challenge was |"));
 588     for(i = 0; i < 8; i++)
 589       DEBUG(100,("%X ", (unsigned char)c8[i]));
 590     DEBUG(100,("|\n"));
 591     DEBUG(100,("Value from encryption was |"));
 592     for(i = 0; i < 24; i++)
 593       DEBUG(100,("%X ", (unsigned char)p24[i]));
 594     DEBUG(100,("|\n"));
 595   }
 596 #endif
 597   return (memcmp(p24, password, 24) == 0);
 598 }
 599 #endif
 600
 601 /****************************************************************************
 602 check if a username/password is OK
 603 ****************************************************************************/
 604 BOOL password_ok(char *user,char *password, int pwlen, struct passwd *pwd, BOOL is_nt_password)
 605 {
 606   pstring pass2;
 607   int level = lp_passwordlevel();
 608   struct passwd *pass;
 609 #ifdef SMB_PASSWD
 610   char challenge[8];
 611   struct smb_passwd *smb_pass;
 612   BOOL challenge_done = False;
 613 #endif
 614
 615   if (password) password[pwlen] = 0;
 616
 617 #ifdef SMB_PASSWD
 618   if (pwlen == 24)
 619     challenge_done = last_challenge(challenge);
 620 #endif
 621
 622 #if DEBUG_PASSWORD
 623 #ifdef SMB_PASSWD
 624   if (challenge_done)
 625     {
 626       int i;
 627       DEBUG(100,("checking user=[%s] pass=[",user));
 628       for( i = 0; i < 24; i++)
 629         DEBUG(100,("%0x ", (unsigned char)password[i]));
 630       DEBUG(100,("]\n"));
 631     }
 632   else
 633 #endif
 634     DEBUG(100,("checking user=[%s] pass=[%s]\n",user,password));
 635 #endif
 636
 637   if (!password)
 638     return(False);
 639
 640   if (((!*password) || (!pwlen)) && !lp_null_passwords())
 641     return(False);
 642
 643   if (pwd && !user)
 644     {
 645       pass = (struct passwd *) pwd;
 646       user = pass->pw_name;
 647     }
 648   else
 649     pass = Get_Pwnam(user,True);
 650
 651 #ifdef SMB_PASSWD
 652
 653   DEBUG(4,("SMB Password - pwlen = %d, challenge_done = %d\n", pwlen, challenge_done));
 654
 655   if((pwlen == 24) && challenge_done)
 656     {
 657       DEBUG(4,("Checking SMB password for user %s (l=24)\n",user));
 658
 659       if (!pass)
 660         {
 661           DEBUG(3,("Couldn't find user %s\n",user));
 662           return(False);
 663         }
 664
 665       smb_pass = get_smbpwnam(user);
 666       if(!smb_pass)
 667         {
 668           DEBUG(3,("Couldn't find user %s in smb_passwd file.\n", user));
 669           return(False);
 670         }
 671
 672       /* Ensure the uid's match */
 673       if(smb_pass->smb_userid != pass->pw_uid)
 674         {
 675           DEBUG(3,("Error : UNIX and SMB uids in password files do not match !\n"));
 676           return(False);
 677         }
 678
 679         if(Protocol >= PROTOCOL_NT1 && is_nt_password)
 680         {
 681                 /* We have the NT MD4 hash challenge available - see if we can
 682                    use it (ie. does it exist in the smbpasswd file).
 683                 */
 684                 if(smb_pass->smb_nt_passwd != NULL)
 685                 {
 686                   DEBUG(4,("Checking NT MD4 password\n"));
 687               if(smb_password_check(password, smb_pass->smb_nt_passwd, challenge))
 688                   {
 689                 update_protected_database(user,True);
 690                 return(True);
 691           }
 692                   DEBUG(4,("NT MD4 password check failed\n"));
 693                   return (False);
 694                 }
 695         }
 696
 697         /* Try against the lanman password */
 698
 699       if(smb_password_check(password, smb_pass->smb_passwd, challenge))
 700         {
 701           update_protected_database(user,True);
 702           return(True);
 703         }
 704
 705         DEBUG(3,("Error smb_password_check failed\n"));
 706     }
 707 #endif
 708
 709   DEBUG(4,("Checking password for user %s (l=%d)\n",user,pwlen));
 710
 711   if (!pass)
 712     {
 713       DEBUG(3,("Couldn't find user %s\n",user));
 714       return(False);
 715     }
 716
 717 #ifdef SHADOW_PWD
 718   {
 719     struct spwd *spass;
 720
 721     /* many shadow systems require you to be root to get the password,
 722        in most cases this should already be the case when this
 723        function is called, except perhaps for IPC password changing
 724        requests */
 725
 726     spass = getspnam(pass->pw_name);
 727     if (spass && spass->sp_pwdp)
 728       pass->pw_passwd = spass->sp_pwdp;
 729   }
 730 #endif
 731
 732 #ifdef SecureWare
 733   {
 734     struct pr_passwd *pr_pw = getprpwnam(pass->pw_name);
 735     if (pr_pw && pr_pw->ufld.fd_encrypt)
 736       pass->pw_passwd = pr_pw->ufld.fd_encrypt;
 737   }
 738 #endif
 739
 740 #ifdef HPUX_10_TRUSTED
 741   {
 742     struct pr_passwd *pr_pw = getprpwnam(pass->pw_name);
 743     if (pr_pw && pr_pw->ufld.fd_encrypt)
 744       pass->pw_passwd = pr_pw->ufld.fd_encrypt;
 745   }
 746 #endif
 747
 748 #ifdef OSF1_ENH_SEC
 749   {
 750     struct pr_passwd *mypasswd;
 751     DEBUG(5,("Checking password for user %s in OSF1_ENH_SEC\n",user));
 752     mypasswd = getprpwnam (user);
 753     if ( mypasswd )
 754       {
 755         strcpy(pass->pw_name,mypasswd->ufld.fd_name);
 756         strcpy(pass->pw_passwd,mypasswd->ufld.fd_encrypt);
 757       }
 758     else
 759       {
 760         DEBUG(5,("No entry for user %s in protected database !\n",user));
 761         return(False);
 762       }
 763   }
 764 #endif
 765
 766 #ifdef ULTRIX_AUTH
 767   {
 768     AUTHORIZATION *ap = getauthuid( pass->pw_uid );
 769     if (ap)
 770       {
 771         strcpy( pass->pw_passwd, ap->a_password );
 772         endauthent();
 773       }
 774   }
 775 #endif
 776
 777   /* extract relevant info */
 778   strcpy(this_user,pass->pw_name);
 779   strcpy(this_salt,pass->pw_passwd);
 780   strcpy(this_crypted,pass->pw_passwd);
 781
 782   if (!*this_crypted) {
 783     if (!lp_null_passwords()) {
 784       DEBUG(2,("Disallowing access to %s due to null password\n",this_user));
 785       return(False);
 786     }
 787 #ifndef PWDAUTH
 788     if (!*password) {
 789       DEBUG(3,("Allowing access to %s with null password\n",this_user));
 790       return(True);
 791     }
 792 #endif
 793   }
 794
 795   /* try it as it came to us */
 796   if (password_check(password))
 797     {
 798       update_protected_database(user,True);
 799       return(True);
 800     }
 801
 802   /* if the password was given to us with mixed case then we don't
 803      need to proceed as we know it hasn't been case modified by the
 804      client */
 805   if (strhasupper(password) && strhaslower(password))
 806     return(False);
 807
 808   /* make a copy of it */
 809   StrnCpy(pass2,password,sizeof(pstring)-1);
 810
 811   /* try all lowercase */
 812   strlower(password);
 813   if (password_check(password))
 814     {
 815       update_protected_database(user,True);
 816       return(True);
 817     }
 818
 819   /* give up? */
 820   if(level < 1)
 821     {
 822       update_protected_database(user,False);
 823
 824       /* restore it */
 825       strcpy(password,pass2);
 826
 827       return(False);
 828     }
 829
 830   /* last chance - all combinations of up to level chars upper! */
 831   strlower(password);
 832
 833   if (string_combinations(password,password_check,level))
 834     {
 835       update_protected_database(user,True);
 836       return(True);
 837     }
 838
 839   update_protected_database(user,False);
 840
 841   /* restore it */
 842   strcpy(password,pass2);
 843
 844   return(False);
 845 }
 846
 847
 848
 849 /****************************************************************************
 850 check if a username is valid
 851 ****************************************************************************/
 852 BOOL user_ok(char *user,int snum)
 853 {
 854   pstring valid, invalid;
 855   BOOL ret;
 856
 857   StrnCpy(valid, lp_valid_users(snum), sizeof(pstring));
 858   StrnCpy(invalid, lp_invalid_users(snum), sizeof(pstring));
 859
 860   string_sub(valid,"%S",lp_servicename(snum));
 861   string_sub(invalid,"%S",lp_servicename(snum));
 862
 863   ret = !user_in_list(user,invalid);
 864
 865   if (ret && valid && *valid)
 866     ret = user_in_list(user,valid);
 867
 868   if (ret && lp_onlyuser(snum)) {
 869     char *user_list = lp_username(snum);
 870     string_sub(user_list,"%S",lp_servicename(snum));
 871     ret = user_in_list(user,user_list);
 872   }
 873
 874   return(ret);
 875 }
 876
 877
 878
 879
 880 /****************************************************************************
 881 validate a group username entry. Return the username or NULL
 882 ****************************************************************************/
 883 static char *validate_group(char *group,char *password,int pwlen,int snum)
 884 {
 885 #ifdef NETGROUP
 886   {
 887     char *host, *user, *domain;
 888     setnetgrent(group);
 889     while (getnetgrent(&host, &user, &domain)) {
 890       if (user) {
 891         if (user_ok(user, snum) &&
 892             password_ok(user,password,pwlen,NULL,False)) {
 893           endnetgrent();
 894           return(user);
 895         }
 896       }
 897     }
 898     endnetgrent();
 899   }
 900 #endif
 901
 902 #if HAVE_GETGRNAM
 903   {
 904     struct group *gptr = (struct group *)getgrnam(group);
 905     char **member;
 906     if (gptr)
 907       {
 908         member = gptr->gr_mem;
 909         while (member && *member)
 910           {
 911             static fstring name;
 912             strcpy(name,*member);
 913             if (user_ok(name,snum) &&
 914                 password_ok(name,password,pwlen,NULL,False))
 915               return(&name[0]);
 916             member++;
 917           }
 918 #ifdef GROUP_CHECK_PWENT
 919         {
 920           struct passwd *pwd;
 921           static fstring tm;
 922
 923           setpwent ();
 924           while (pwd = getpwent ()) {
 925             if (*(pwd->pw_passwd) && pwd->pw_gid == gptr->gr_gid) {
 926               /* This Entry have PASSWORD and same GID then check pwd */
 927               if (password_ok(NULL, password, pwlen, pwd,False)) {
 928                 strcpy(tm, pwd->pw_name);
 929                 endpwent ();
 930                 return tm;
 931               }
 932             }
 933           }
 934           endpwent ();
 935         }
 936 #endif /* GROUP_CHECK_PWENT */
 937       }
 938   }
 939 #endif
 940   return(NULL);
 941 }
 942
 943
 944
 945 /****************************************************************************
 946 check for authority to login to a service with a given username/password
 947 ****************************************************************************/
 948 BOOL authorise_login(int snum,char *user,char *password, int pwlen,
 949                      BOOL *guest,BOOL *force,int vuid)
 950 {
 951   BOOL ok = False;
 952
 953   *guest = False;
 954
 955 #if DEBUG_PASSWORD
 956   DEBUG(100,("checking authorisation on user=%s pass=%s\n",user,password));
 957 #endif
 958
 959   /* there are several possabilities:
 960      1) login as the given user with given password
 961      2) login as a previously registered username with the given password
 962      3) login as a session list username with the given password
 963      4) login as a previously validated user/password pair
 964      5) login as the "user =" user with given password
 965      6) login as the "user =" user with no password (guest connection)
 966      7) login as guest user with no password
 967
 968      if the service is guest_only then steps 1 to 5 are skipped
 969   */
 970
 971   if (GUEST_ONLY(snum)) *force = True;
 972
 973   if (!(GUEST_ONLY(snum) && GUEST_OK(snum)))
 974     {
 975
 976       /* check the given username and password */
 977       if (!ok && (*user) && user_ok(user,snum)) {
 978         ok = password_ok(user,password, pwlen, NULL, False);
 979         if (ok) DEBUG(3,("ACCEPTED: given username password ok\n"));
 980       }
 981
 982       /* check for a previously registered guest username */
 983       if (!ok && (vuid >= 0) && validated_users[vuid].guest) {
 984         if (user_ok(validated_users[vuid].name,snum) &&
 985             password_ok(validated_users[vuid].name, password, pwlen, NULL, False)) {
 986           strcpy(user, validated_users[vuid].name);
 987           validated_users[vuid].guest = False;
 988           DEBUG(3,("ACCEPTED: given password with registered user %s\n", user));
 989           ok = True;
 990         }
 991       }
 992
 993
 994       /* now check the list of session users */
 995       if (!ok)
 996         {
 997           char *auser;
 998           char *user_list = strdup(session_users);
 999           if (!user_list) return(False);
1000
1001           for (auser=strtok(user_list,LIST_SEP);
1002                !ok && auser;
1003                auser = strtok(NULL,LIST_SEP))
1004             {
1005               fstring user2;
1006               strcpy(user2,auser);
1007               if (!user_ok(user2,snum)) continue;
1008
1009               if (password_ok(user2,password, pwlen, NULL, False)) {
1010                 ok = True;
1011                 strcpy(user,user2);
1012                 DEBUG(3,("ACCEPTED: session list username and given password ok\n"));
1013               }
1014             }
1015           free(user_list);
1016         }
1017
1018       /* check for a previously validated username/password pair */
1019       if (!ok && !lp_revalidate(snum) &&
1020           (vuid >= 0) && !validated_users[vuid].guest &&
1021           user_ok(validated_users[vuid].name,snum)) {
1022         strcpy(user,validated_users[vuid].name);
1023         *guest = False;
1024         DEBUG(3,("ACCEPTED: validated uid ok as non-guest\n"));
1025         ok = True;
1026       }
1027
1028       /* check for a rhosts entry */
1029       if (!ok && user_ok(user,snum) && check_hosts_equiv(user)) {
1030         ok = True;
1031         DEBUG(3,("ACCEPTED: hosts equiv or rhosts entry\n"));
1032       }
1033
1034       /* check the user= fields and the given password */
1035       if (!ok && lp_username(snum)) {
1036         char *auser;
1037         pstring user_list;
1038         StrnCpy(user_list,lp_username(snum),sizeof(pstring));
1039
1040         string_sub(user_list,"%S",lp_servicename(snum));
1041
1042         for (auser=strtok(user_list,LIST_SEP);
1043              auser && !ok;
1044              auser = strtok(NULL,LIST_SEP))
1045           {
1046             if (*auser == '@')
1047               {
1048                 auser = validate_group(auser+1,password,pwlen,snum);
1049                 if (auser)
1050                   {
1051                     ok = True;
1052                     strcpy(user,auser);
1053                     DEBUG(3,("ACCEPTED: group username and given password ok\n"));
1054                   }
1055               }
1056             else
1057               {
1058                 fstring user2;
1059                 strcpy(user2,auser);
1060                 if (user_ok(user2,snum) &&
1061                     password_ok(user2,password,pwlen,NULL, False))
1062                   {
1063                     ok = True;
1064                     strcpy(user,user2);
1065                     DEBUG(3,("ACCEPTED: user list username and given password ok\n"));
1066                   }
1067               }
1068           }
1069       }
1070     } /* not guest only */
1071
1072   /* check for a normal guest connection */
1073   if (!ok && GUEST_OK(snum))
1074     {
1075       fstring guestname;
1076       StrnCpy(guestname,lp_guestaccount(snum),sizeof(guestname)-1);
1077       if (Get_Pwnam(guestname,True))
1078         {
1079           strcpy(user,guestname);
1080           ok = True;
1081           DEBUG(3,("ACCEPTED: guest account and guest ok\n"));
1082         }
1083       else
1084         DEBUG(0,("Invalid guest account %s??\n",guestname));
1085       *guest = True;
1086       *force = True;
1087     }
1088
1089   if (ok && !user_ok(user,snum))
1090     {
1091       DEBUG(0,("rejected invalid user %s\n",user));
1092       ok = False;
1093     }
1094
1095   return(ok);
1096 }
1097
1098
1099 /****************************************************************************
1100 read the a hosts.equiv or .rhosts file and check if it
1101 allows this user from this machine
1102 ****************************************************************************/
1103 static BOOL check_user_equiv(char *user, char *remote, char *equiv_file)
1104 {
1105   pstring buf;
1106   int plus_allowed = 1;
1107   char *file_host;
1108   char *file_user;
1109   FILE *fp = fopen(equiv_file, "r");
1110   DEBUG(5, ("check_user_equiv %s %s %s\n", user, remote, equiv_file));
1111   if (! fp) return False;
1112   while(fgets(buf, sizeof(buf), fp))
1113   {
1114     trim_string(buf," "," ");
1115
1116     if (buf[0] != '#' && buf[0] != '\n')
1117     {
1118       BOOL is_group = False;
1119       int plus = 1;
1120       char *bp = buf;
1121       if (strcmp(buf, "NO_PLUS\n") == 0)
1122       {
1123         DEBUG(6, ("check_user_equiv NO_PLUS\n"));
1124         plus_allowed = 0;
1125       }
1126       else {
1127         if (buf[0] == '+')
1128         {
1129           bp++;
1130           if (*bp == '\n' && plus_allowed)
1131           {
1132             /* a bare plus means everbody allowed */
1133             DEBUG(6, ("check_user_equiv everybody allowed\n"));
1134             fclose(fp);
1135             return True;
1136           }
1137         }
1138         else if (buf[0] == '-')
1139         {
1140           bp++;
1141           plus = 0;
1142         }
1143         if (*bp == '@')
1144         {
1145           is_group = True;
1146           bp++;
1147         }
1148         file_host = strtok(bp, " \t\n");
1149         file_user = strtok(NULL, " \t\n");
1150         DEBUG(7, ("check_user_equiv %s %s\n", file_host, file_user));
1151         if (file_host && *file_host)
1152         {
1153           BOOL host_ok = False;
1154
1155 #ifdef NETGROUP
1156           if (is_group)
1157             {
1158               static char *mydomain = NULL;
1159               if (!mydomain)
1160                 yp_get_default_domain(&mydomain);
1161               if (mydomain && innetgr(file_host,remote,user,mydomain))
1162                 host_ok = True;
1163             }
1164 #else
1165           if (is_group)
1166             {
1167               DEBUG(1,("Netgroups not configured - add -DNETGROUP and recompile\n"));
1168               continue;
1169             }
1170 #endif
1171
1172           /* is it this host */
1173           /* the fact that remote has come from a call of gethostbyaddr
1174            * means that it may have the fully qualified domain name
1175            * so we could look up the file version to get it into
1176            * a canonical form, but I would rather just type it
1177            * in full in the equiv file
1178            */
1179           if (!host_ok && !is_group && strequal(remote, file_host))
1180             host_ok = True;
1181
1182           if (!host_ok)
1183             continue;
1184
1185           /* is it this user */
1186           if (file_user == 0 || strequal(user, file_user))
1187             {
1188               fclose(fp);
1189               DEBUG(5, ("check_user_equiv matched %s%s %s\n",
1190                         (plus ? "+" : "-"), file_host,
1191                         (file_user ? file_user : "")));
1192               return (plus ? True : False);
1193             }
1194         }
1195       }
1196     }
1197   }
1198   fclose(fp);
1199   return False;
1200 }
1201
1202
1203 /****************************************************************************
1204 check for a possible hosts equiv or rhosts entry for the user
1205 ****************************************************************************/
1206 BOOL check_hosts_equiv(char *user)
1207 {
1208   char *fname = NULL;
1209   pstring rhostsfile;
1210   struct passwd *pass = Get_Pwnam(user,True);
1211
1212   extern struct from_host Client_info;
1213   extern int Client;
1214
1215   if (!pass)
1216     return(False);
1217
1218   fromhost(Client,&Client_info);
1219
1220   fname = lp_hosts_equiv();
1221
1222   /* note: don't allow hosts.equiv on root */
1223   if (fname && *fname && (pass->pw_uid != 0))
1224     {
1225       if (check_user_equiv(user,Client_info.name,fname))
1226         return(True);
1227     }
1228
1229   if (lp_use_rhosts())
1230     {
1231       char *home = get_home_dir(user);
1232       if (home)
1233         {
1234           sprintf(rhostsfile, "%s/.rhosts", home);
1235           if (check_user_equiv(user,Client_info.name,rhostsfile))
1236             return(True);
1237         }
1238     }
1239
1240   return(False);
1241 }
1242
1243
1244 static int password_client = -1;
1245 static fstring pserver;
1246
1247 /****************************************************************************
1248 attempted support for server level security
1249 ****************************************************************************/
1250 BOOL server_cryptkey(char *buf)
1251 {
1252   pstring inbuf,outbuf;
1253   fstring pass_protocol;
1254   extern fstring remote_machine;
1255   char *p;
1256   int len;
1257   fstring desthost;
1258   struct in_addr dest_ip;
1259   extern struct in_addr myip;
1260   int port = 139;
1261   BOOL ret;
1262
1263   if (password_client >= 0)
1264     close(password_client);
1265   password_client = -1;
1266
1267   if (Protocol < PROTOCOL_NT1) {
1268     strcpy(pass_protocol,"LM1.2X002");
1269   } else {
1270     strcpy(pass_protocol,"NT LM 0.12");
1271   }
1272
1273   bzero(inbuf,sizeof(inbuf));
1274   bzero(outbuf,sizeof(outbuf));
1275
1276   for (p=strtok(lp_passwordserver(),LIST_SEP); p ; p = strtok(NULL,LIST_SEP)) {
1277     strcpy(desthost,p);
1278     standard_sub_basic(desthost);
1279     strupper(desthost);
1280
1281     dest_ip = *interpret_addr2(desthost);
1282     if (zero_ip(dest_ip)) {
1283       DEBUG(1,("Can't resolve address for %s\n",p));
1284       continue;
1285     }
1286
1287     if (memcmp(&dest_ip,&myip,sizeof(dest_ip)) == 0) {
1288       DEBUG(1,("Password server loop - disabling password server %s\n",p));
1289       continue;
1290     }
1291
1292     password_client = open_socket_out(SOCK_STREAM, &dest_ip, port);
1293     if (password_client >= 0) {
1294       DEBUG(3,("connected to password server %s\n",p));
1295       StrnCpy(pserver,p,sizeof(pserver)-1);
1296       break;
1297     }
1298   }
1299
1300   if (password_client < 0) {
1301     DEBUG(1,("password server not available\n"));
1302     return(False);
1303   }
1304
1305
1306   /* send a session request (RFC 8002) */
1307
1308   /* put in the destination name */
1309   len = 4;
1310   p = outbuf+len;
1311   name_mangle(desthost,p,' ');
1312   len += name_len(p);
1313
1314   /* and my name */
1315   p = outbuf+len;
1316   name_mangle(remote_machine,p,' ');
1317   len += name_len(p);
1318
1319   _smb_setlen(outbuf,len);
1320   CVAL(outbuf,0) = 0x81;
1321
1322   send_smb(password_client,outbuf);
1323   receive_smb(password_client,inbuf,5000);
1324
1325   if (CVAL(inbuf,0) != 0x82) {
1326     DEBUG(1,("%s rejected the session\n",pserver));
1327     close(password_client); password_client = -1;
1328     return(False);
1329   }
1330
1331   DEBUG(3,("got session\n"));
1332
1333   bzero(outbuf,smb_size);
1334
1335   /* setup the protocol string */
1336   set_message(outbuf,0,strlen(pass_protocol)+2,True);
1337   p = smb_buf(outbuf);
1338   *p++ = 2;
1339   strcpy(p,pass_protocol);
1340
1341   CVAL(outbuf,smb_com) = SMBnegprot;
1342   CVAL(outbuf,smb_flg) = 0x8;
1343   SSVAL(outbuf,smb_flg2,0x1);
1344
1345   send_smb(password_client,outbuf);
1346   ret = receive_smb(password_client,inbuf,5000);
1347
1348   if (!ret || CVAL(inbuf,smb_rcls) || SVAL(inbuf,smb_vwv0)) {
1349     DEBUG(1,("%s rejected the protocol\n",pserver));
1350     close(password_client); password_client= -1;
1351     return(False);
1352   }
1353
1354   if (!(CVAL(inbuf,smb_vwv1) & 1)) {
1355     DEBUG(1,("%s isn't in user level security mode\n",pserver));
1356     close(password_client); password_client= -1;
1357     return(False);
1358   }
1359
1360   memcpy(buf,inbuf,smb_len(inbuf)+4);
1361
1362   DEBUG(3,("password server OK\n"));
1363
1364   return(True);
1365 }
1366
1367 /****************************************************************************
1368 attempted support for server level security
1369 ****************************************************************************/
1370 BOOL server_validate(char *buf)
1371 {
1372   pstring inbuf,outbuf;
1373   BOOL ret;
1374
1375   if (password_client < 0) {
1376     DEBUG(1,("%s not connected\n",pserver));
1377     return(False);
1378   }
1379
1380   bzero(inbuf,sizeof(inbuf));
1381   memcpy(outbuf,buf,sizeof(outbuf));
1382
1383   /* send a session setup command */
1384   CVAL(outbuf,smb_flg) = 0x8;
1385   SSVAL(outbuf,smb_flg2,0x1);
1386   CVAL(outbuf,smb_vwv0) = 0xFF;
1387
1388   set_message(outbuf,smb_numwords(outbuf),smb_buflen(outbuf),False);
1389
1390   SCVAL(inbuf,smb_rcls,1);
1391
1392   send_smb(password_client,outbuf);
1393   ret = receive_smb(password_client,inbuf,5000);
1394
1395   if (!ret || CVAL(inbuf,smb_rcls) != 0) {
1396     DEBUG(1,("password server %s rejected the password\n",pserver));
1397     return(False);
1398   }
1399
1400   /* if logged in as guest then reject */
1401   if ((SVAL(inbuf,smb_vwv2) & 1) != 0) {
1402     DEBUG(1,("password server %s gave us guest only\n",pserver));
1403     return(False);
1404   }
1405
1406   DEBUG(3,("password server %s accepted the password\n",pserver));
1407
1408 #ifndef KEEP_PASSWORD_SERVER_OPEN
1409   close(password_client); password_client= -1;
1410 #endif
1411
1412   return(True);
1413 }
1414
1415