source3/utils/smbpasswd.c

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