source3/utils/smbpasswd.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * Copyright (C) Jeremy Allison 1995-1998
   4  * Copyright (C) Tim Potter     2001
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2 of the License, or (at your
   9  * option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program; if not, write to the Free Software Foundation, Inc., 675
  18  * Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "includes.h"
  21
  22 extern BOOL AllowDebugChange;
  23
  24 /*
  25  * Next two lines needed for SunOS and don't
  26  * hurt anything else...
  27  */
  28 extern char *optarg;
  29 extern int optind;
  30
  31 /* forced running in root-mode */
  32 static BOOL got_pass = False, got_username = False;
  33 static BOOL stdin_passwd_get = False;
  34 static fstring user_name, user_password;
  35 static char *new_passwd = NULL;
  36 static const char *remote_machine = NULL;
  37
  38 static fstring ldap_secret;
  39
  40 /* FUNCTION DECLARATIONS */
  41
  42  BOOL remote_password_change(const char *rmachine, const char *username,
  43                             const char *old_pw, const char *new_pw,
  44                             char *err_str, size_t err_str_len);
  45
  46
  47 /*********************************************************
  48  Print command usage on stderr and die.
  49 **********************************************************/
  50 static void usage(void)
  51 {
  52         printf("When run by root:\n");
  53         printf("    smbpasswd [options] [username] [password]\n");
  54         printf("otherwise:\n");
  55         printf("    smbpasswd [options] [password]\n\n");
  56
  57         printf("options:\n");
  58         printf("  -L                   local mode (must be first option)\n");
  59         printf("  -h                   print this usage message\n");
  60         printf("  -s                   use stdin for password prompt\n");
  61         printf("  -c smb.conf file     Use the given path to the smb.conf file\n");
  62         printf("  -D LEVEL             debug level\n");
  63         printf("  -r MACHINE           remote machine\n");
  64         printf("  -U USER              remote username\n");
  65
  66         printf("extra options when run by root or in local mode:\n");
  67         printf("  -a                   add user\n");
  68         printf("  -d                   disable user\n");
  69         printf("  -e                   enable user\n");
  70         printf("  -i                   interdomain trust account\n");
  71         printf("  -m                   machine trust account\n");
  72         printf("  -n                   set no password\n");
  73         printf("  -w PASSWORD          ldap admin password\n");
  74         printf("  -x                   delete user\n");
  75         printf("  -R ORDER             name resolve order\n");
  76
  77         exit(1);
  78 }
  79
  80 static void set_line_buffering(FILE *f)
  81 {
  82         setvbuf(f, NULL, _IOLBF, 0);
  83 }
  84
  85 /*******************************************************************
  86  Process command line options
  87  ******************************************************************/
  88 static int process_options(int argc, char **argv, int local_flags)
  89 {
  90         int ch;
  91         pstring configfile;
  92         pstrcpy(configfile, dyn_CONFIGFILE);
  93
  94         local_flags |= LOCAL_SET_PASSWORD;
  95
  96         ZERO_STRUCT(user_name);
  97         ZERO_STRUCT(user_password);
  98
  99         user_name[0] = '\0';
 100
 101         while ((ch = getopt(argc, argv, "c:axdehminjr:sw:R:D:U:L")) != EOF) {
 102                 switch(ch) {
 103                 case 'L':
 104                         local_flags |= LOCAL_AM_ROOT;
 105                         break;
 106                 case 'c':
 107                         pstrcpy(configfile,optarg);
 108                         break;
 109                 case 'a':
 110                         local_flags |= LOCAL_ADD_USER;
 111                         break;
 112                 case 'x':
 113                         local_flags |= LOCAL_DELETE_USER;
 114                         local_flags &= ~LOCAL_SET_PASSWORD;
 115                         break;
 116                 case 'd':
 117                         local_flags |= LOCAL_DISABLE_USER;
 118                         local_flags &= ~LOCAL_SET_PASSWORD;
 119                         break;
 120                 case 'e':
 121                         local_flags |= LOCAL_ENABLE_USER;
 122                         local_flags &= ~LOCAL_SET_PASSWORD;
 123                         break;
 124                 case 'm':
 125                         local_flags |= LOCAL_TRUST_ACCOUNT;
 126                         break;
 127                 case 'i':
 128                         local_flags |= LOCAL_INTERDOM_ACCOUNT;
 129                         break;
 130                 case 'j':
 131                         d_printf("See 'net join' for this functionality\n");
 132                         exit(1);
 133                         break;
 134                 case 'n':
 135                         local_flags |= LOCAL_SET_NO_PASSWORD;
 136                         local_flags &= ~LOCAL_SET_PASSWORD;
 137                         new_passwd = smb_xstrdup("NO PASSWORD");
 138                         break;
 139                 case 'r':
 140                         remote_machine = optarg;
 141                         break;
 142                 case 's':
 143                         set_line_buffering(stdin);
 144                         set_line_buffering(stdout);
 145                         set_line_buffering(stderr);
 146                         stdin_passwd_get = True;
 147                         break;
 148                 case 'w':
 149                         local_flags |= LOCAL_SET_LDAP_ADMIN_PW;
 150                         fstrcpy(ldap_secret, optarg);
 151                         break;
 152                 case 'R':
 153                         lp_set_name_resolve_order(optarg);
 154                         break;
 155                 case 'D':
 156                         DEBUGLEVEL = atoi(optarg);
 157                         break;
 158                 case 'U': {
 159                         char *lp;
 160
 161                         got_username = True;
 162                         fstrcpy(user_name, optarg);
 163
 164                         if ((lp = strchr(user_name, '%'))) {
 165                                 *lp = 0;
 166                                 fstrcpy(user_password, lp + 1);
 167                                 got_pass = True;
 168                                 memset(strchr_m(optarg, '%') + 1, 'X',
 169                                        strlen(user_password));
 170                         }
 171
 172                         break;
 173                 }
 174                 case 'h':
 175                 default:
 176                         usage();
 177                 }
 178         }
 179
 180         argc -= optind;
 181         argv += optind;
 182
 183         switch(argc) {
 184         case 0:
 185                 if (!got_username)
 186                         fstrcpy(user_name, "");
 187                 break;
 188         case 1:
 189                 if (!(local_flags & LOCAL_AM_ROOT)) {
 190                         new_passwd = argv[0];
 191                 } else {
 192                         if (got_username) {
 193                                 usage();
 194                         } else {
 195                                 fstrcpy(user_name, argv[0]);
 196                         }
 197                 }
 198                 break;
 199         case 2:
 200                 if (!(local_flags & LOCAL_AM_ROOT) || got_username || got_pass) {
 201                         usage();
 202                 }
 203
 204                 fstrcpy(user_name, argv[0]);
 205                 new_passwd = smb_xstrdup(argv[1]);
 206                 break;
 207         default:
 208                 usage();
 209         }
 210
 211         if (!lp_load(configfile,True,False,False)) {
 212                 fprintf(stderr, "Can't load %s - run testparm to debug it\n",
 213                         dyn_CONFIGFILE);
 214                 exit(1);
 215         }
 216
 217         return local_flags;
 218 }
 219
 220 /*************************************************************
 221  Utility function to prompt for passwords from stdin. Each
 222  password entered must end with a newline.
 223 *************************************************************/
 224 static char *stdin_new_passwd(void)
 225 {
 226         static fstring new_pw;
 227         size_t len;
 228
 229         ZERO_ARRAY(new_pw);
 230
 231         /*
 232          * if no error is reported from fgets() and string at least contains
 233          * the newline that ends the password, then replace the newline with
 234          * a null terminator.
 235          */
 236         if ( fgets(new_pw, sizeof(new_pw), stdin) != NULL) {
 237                 if ((len = strlen(new_pw)) > 0) {
 238                         if(new_pw[len-1] == '\n')
 239                                 new_pw[len - 1] = 0;
 240                 }
 241         }
 242         return(new_pw);
 243 }
 244
 245
 246 /*************************************************************
 247  Utility function to get passwords via tty or stdin
 248  Used if the '-s' option is set to silently get passwords
 249  to enable scripting.
 250 *************************************************************/
 251 static char *get_pass( const char *prompt, BOOL stdin_get)
 252 {
 253         char *p;
 254         if (stdin_get) {
 255                 p = stdin_new_passwd();
 256         } else {
 257                 p = getpass(prompt);
 258         }
 259         return smb_xstrdup(p);
 260 }
 261
 262 /*************************************************************
 263  Utility function to prompt for new password.
 264 *************************************************************/
 265 static char *prompt_for_new_password(BOOL stdin_get)
 266 {
 267         char *p;
 268         fstring new_pw;
 269
 270         ZERO_ARRAY(new_pw);
 271
 272         p = get_pass("New SMB password:", stdin_get);
 273
 274         fstrcpy(new_pw, p);
 275         SAFE_FREE(p);
 276
 277         p = get_pass("Retype new SMB password:", stdin_get);
 278
 279         if (strcmp(p, new_pw)) {
 280                 fprintf(stderr, "Mismatch - password unchanged.\n");
 281                 ZERO_ARRAY(new_pw);
 282                 SAFE_FREE(p);
 283                 return NULL;
 284         }
 285
 286         return p;
 287 }
 288
 289
 290 /*************************************************************
 291  Change a password either locally or remotely.
 292 *************************************************************/
 293
 294 static BOOL password_change(const char *remote_mach, char *username,
 295                             char *old_passwd, char *new_pw, int local_flags)
 296 {
 297         BOOL ret;
 298         pstring err_str;
 299         pstring msg_str;
 300
 301         if (remote_mach != NULL) {
 302                 if (local_flags & (LOCAL_ADD_USER|LOCAL_DELETE_USER|LOCAL_DISABLE_USER|LOCAL_ENABLE_USER|
 303                                                         LOCAL_TRUST_ACCOUNT|LOCAL_SET_NO_PASSWORD)) {
 304                         /* these things can't be done remotely yet */
 305                         return False;
 306                 }
 307                 ret = remote_password_change(remote_mach, username,
 308                                              old_passwd, new_pw, err_str, sizeof(err_str));
 309                 if(*err_str)
 310                         fprintf(stderr, err_str);
 311                 return ret;
 312         }
 313
 314         ret = local_password_change(username, local_flags, new_pw,
 315                                      err_str, sizeof(err_str), msg_str, sizeof(msg_str));
 316
 317         if(*msg_str)
 318                 printf(msg_str);
 319         if(*err_str)
 320                 fprintf(stderr, err_str);
 321
 322         return ret;
 323 }
 324
 325 /*******************************************************************
 326  Store the LDAP admin password in secrets.tdb
 327  ******************************************************************/
 328 static BOOL store_ldap_admin_pw (char* pw)
 329 {
 330         if (!pw)
 331                 return False;
 332
 333         if (!secrets_init())
 334                 return False;
 335
 336         return secrets_store_ldap_pw(lp_ldap_admin_dn(), pw);
 337 }
 338
 339
 340 /*************************************************************
 341  Handle password changing for root.
 342 *************************************************************/
 343
 344 static int process_root(int local_flags)
 345 {
 346         struct passwd  *pwd;
 347         int result = 0;
 348         char *old_passwd = NULL;
 349
 350         if (local_flags & LOCAL_SET_LDAP_ADMIN_PW)
 351         {
 352                 printf("Setting stored password for \"%s\" in secrets.tdb\n",
 353                         lp_ldap_admin_dn());
 354                 if (!store_ldap_admin_pw(ldap_secret))
 355                         DEBUG(0,("ERROR: Failed to store the ldap admin password!\n"));
 356                 goto done;
 357         }
 358
 359         /*
 360          * Ensure both add/delete user are not set
 361          * Ensure add/delete user and either remote machine or join domain are
 362          * not both set.
 363          */
 364         if(((local_flags & (LOCAL_ADD_USER|LOCAL_DELETE_USER)) == (LOCAL_ADD_USER|LOCAL_DELETE_USER)) ||
 365            ((local_flags & (LOCAL_ADD_USER|LOCAL_DELETE_USER)) &&
 366                 (remote_machine != NULL))) {
 367                 usage();
 368         }
 369
 370         /* Only load interfaces if we are doing network operations. */
 371
 372         if (remote_machine) {
 373                 load_interfaces();
 374         }
 375
 376         if (!user_name[0] && (pwd = getpwuid_alloc(geteuid()))) {
 377                 fstrcpy(user_name, pwd->pw_name);
 378                 passwd_free(&pwd);
 379         }
 380
 381         if (!user_name[0]) {
 382                 fprintf(stderr,"You must specify a username\n");
 383                 exit(1);
 384         }
 385
 386         if (local_flags & LOCAL_TRUST_ACCOUNT) {
 387                 /* add the $ automatically */
 388                 static fstring buf;
 389
 390                 /*
 391                  * Remove any trailing '$' before we
 392                  * generate the initial machine password.
 393                  */
 394
 395                 if (user_name[strlen(user_name)-1] == '$') {
 396                         user_name[strlen(user_name)-1] = 0;
 397                 }
 398
 399                 if (local_flags & LOCAL_ADD_USER) {
 400                         SAFE_FREE(new_passwd);
 401                         new_passwd = smb_xstrdup(user_name);
 402                         strlower_m(new_passwd);
 403                 }
 404
 405                 /*
 406                  * Now ensure the username ends in '$' for
 407                  * the machine add.
 408                  */
 409
 410                 slprintf(buf, sizeof(buf)-1, "%s$", user_name);
 411                 fstrcpy(user_name, buf);
 412         } else if (local_flags & LOCAL_INTERDOM_ACCOUNT) {
 413                 static fstring buf;
 414
 415                 if ((local_flags & LOCAL_ADD_USER) && (new_passwd == NULL)) {
 416                         /*
 417                          * Prompt for trusting domain's account password
 418                          */
 419                         new_passwd = prompt_for_new_password(stdin_passwd_get);
 420                         if(!new_passwd) {
 421                                 fprintf(stderr, "Unable to get newpassword.\n");
 422                                 exit(1);
 423                         }
 424                 }
 425
 426                 /* prepare uppercased and '$' terminated username */
 427                 slprintf(buf, sizeof(buf) - 1, "%s$", user_name);
 428                 fstrcpy(user_name, buf);
 429
 430         } else {
 431
 432                 if (remote_machine != NULL) {
 433                         old_passwd = get_pass("Old SMB password:",stdin_passwd_get);
 434                 }
 435
 436                 if (!(local_flags & LOCAL_SET_PASSWORD)) {
 437
 438                         /*
 439                          * If we are trying to enable a user, first we need to find out
 440                          * if they are using a modern version of the smbpasswd file that
 441                          * disables a user by just writing a flag into the file. If so
 442                          * then we can re-enable a user without prompting for a new
 443                          * password. If not (ie. they have a no stored password in the
 444                          * smbpasswd file) then we need to prompt for a new password.
 445                          */
 446
 447                         if(local_flags & LOCAL_ENABLE_USER) {
 448                                 SAM_ACCOUNT *sampass = NULL;
 449                                 BOOL ret;
 450
 451                                 pdb_init_sam(&sampass);
 452                                 ret = pdb_getsampwnam(sampass, user_name);
 453                                 if((sampass != False) && (pdb_get_lanman_passwd(sampass) == NULL)) {
 454                                         local_flags |= LOCAL_SET_PASSWORD;
 455                                 }
 456                                 pdb_free_sam(&sampass);
 457                         }
 458                 }
 459
 460                 if((local_flags & LOCAL_SET_PASSWORD) && (new_passwd == NULL)) {
 461                         new_passwd = prompt_for_new_password(stdin_passwd_get);
 462
 463                         if(!new_passwd) {
 464                                 fprintf(stderr, "Unable to get new password.\n");
 465                                 exit(1);
 466                         }
 467                 }
 468         }
 469
 470         if (!password_change(remote_machine, user_name, old_passwd, new_passwd, local_flags)) {
 471                 fprintf(stderr,"Failed to modify password entry for user %s\n", user_name);
 472                 result = 1;
 473                 goto done;
 474         }
 475
 476         if(remote_machine) {
 477                 printf("Password changed for user %s on %s.\n", user_name, remote_machine );
 478         } else if(!(local_flags & (LOCAL_ADD_USER|LOCAL_DISABLE_USER|LOCAL_ENABLE_USER|LOCAL_DELETE_USER|LOCAL_SET_NO_PASSWORD|LOCAL_SET_PASSWORD))) {
 479                 SAM_ACCOUNT *sampass = NULL;
 480                 BOOL ret;
 481
 482                 pdb_init_sam(&sampass);
 483                 ret = pdb_getsampwnam(sampass, user_name);
 484
 485                 printf("Password changed for user %s.", user_name );
 486                 if( (ret != False) && (pdb_get_acct_ctrl(sampass)&ACB_DISABLED) )
 487                         printf(" User has disabled flag set.");
 488                 if((ret != False) && (pdb_get_acct_ctrl(sampass) & ACB_PWNOTREQ) )
 489                         printf(" User has no password flag set.");
 490                 printf("\n");
 491                 pdb_free_sam(&sampass);
 492         }
 493
 494  done:
 495         SAFE_FREE(new_passwd);
 496         return result;
 497 }
 498
 499
 500 /*************************************************************
 501  Handle password changing for non-root.
 502 *************************************************************/
 503
 504 static int process_nonroot(int local_flags)
 505 {
 506         struct passwd  *pwd = NULL;
 507         int result = 0;
 508         char *old_pw = NULL;
 509         char *new_pw = NULL;
 510
 511         if (local_flags & ~(LOCAL_AM_ROOT | LOCAL_SET_PASSWORD)) {
 512                 /* Extra flags that we can't honor non-root */
 513                 usage();
 514         }
 515
 516         if (!user_name[0]) {
 517                 pwd = getpwuid_alloc(getuid());
 518                 if (pwd) {
 519                         fstrcpy(user_name,pwd->pw_name);
 520                         passwd_free(&pwd);
 521                 } else {
 522                         fprintf(stderr, "smbpasswd: you don't exist - go away\n");
 523                         exit(1);
 524                 }
 525         }
 526
 527         /*
 528          * A non-root user is always setting a password
 529          * via a remote machine (even if that machine is
 530          * localhost).
 531          */
 532
 533         load_interfaces(); /* Delayed from main() */
 534
 535         if (remote_machine == NULL) {
 536                 remote_machine = "127.0.0.1";
 537         }
 538
 539         if (remote_machine != NULL) {
 540                 old_pw = get_pass("Old SMB password:",stdin_passwd_get);
 541         }
 542
 543         if (!new_passwd) {
 544                 new_pw = prompt_for_new_password(stdin_passwd_get);
 545         }
 546         else
 547                 new_pw = smb_xstrdup(new_passwd);
 548
 549         if (!new_pw) {
 550                 fprintf(stderr, "Unable to get new password.\n");
 551                 exit(1);
 552         }
 553
 554         if (!password_change(remote_machine, user_name, old_pw, new_pw, 0)) {
 555                 fprintf(stderr,"Failed to change password for %s\n", user_name);
 556                 result = 1;
 557                 goto done;
 558         }
 559
 560         printf("Password changed for user %s\n", user_name);
 561
 562  done:
 563         SAFE_FREE(old_pw);
 564         SAFE_FREE(new_pw);
 565
 566         return result;
 567 }
 568
 569
 570
 571 /*********************************************************
 572  Start here.
 573 **********************************************************/
 574 int main(int argc, char **argv)
 575 {
 576         int local_flags = 0;
 577
 578         AllowDebugChange = False;
 579
 580 #if defined(HAVE_SET_AUTH_PARAMETERS)
 581         set_auth_parameters(argc, argv);
 582 #endif /* HAVE_SET_AUTH_PARAMETERS */
 583
 584         if (getuid() == 0) {
 585                 local_flags = LOCAL_AM_ROOT;
 586         }
 587
 588         local_flags = process_options(argc, argv, local_flags);
 589
 590         setup_logging("smbpasswd", True);
 591
 592         /*
 593          * Set the machine NETBIOS name if not already
 594          * set from the config file.
 595          */
 596
 597         if (!init_names())
 598                 return 1;
 599
 600         /* Check the effective uid - make sure we are not setuid */
 601         if (is_setuid_root()) {
 602                 fprintf(stderr, "smbpasswd must *NOT* be setuid root.\n");
 603                 exit(1);
 604         }
 605
 606         if (local_flags & LOCAL_AM_ROOT) {
 607                 secrets_init();
 608                 return process_root(local_flags);
 609         }
 610
 611         return process_nonroot(local_flags);
 612 }