/* * Unix SMB/Netbios implementation. Version 1.9. smbpasswd module. Copyright * (C) Jeremy Allison 1995-1998 * * This program is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., 675 * Mass Ave, Cambridge, MA 02139, USA. */ #include "includes.h" extern pstring scope; extern pstring myhostname; extern pstring global_myname; extern fstring global_myworkgroup; extern int DEBUGLEVEL; /********************************************************* a strdup with exit **********************************************************/ static char *xstrdup(char *s) { s = strdup(s); if (!s) { fprintf(stderr,"out of memory\n"); exit(1); } return s; } /********************************************************* Print command usage on stderr and die. **********************************************************/ static void usage(void) { if (getuid() == 0) { printf("smbpasswd [options] [username] [password]\n"); } else { printf("smbpasswd [options] [password]\n"); } printf("options:\n"); printf(" -s use stdin for password prompt\n"); printf(" -D LEVEL debug level\n"); printf(" -U USER remote username\n"); printf(" -r MACHINE remote machine\n"); if (getuid() == 0) { printf(" -R ORDER name resolve order\n"); printf(" -j DOMAIN join domain name\n"); printf(" -a add user\n"); printf(" -d delete user\n"); printf(" -e enable user\n"); printf(" -n set no password\n"); printf(" -m machine trust account\n"); } exit(1); } /********************************************************* Join a domain. **********************************************************/ static int join_domain(char *domain, char *remote) { pstring remote_machine; fstring trust_passwd; unsigned char orig_trust_passwd_hash[16]; BOOL ret; pstrcpy(remote_machine, remote ? remote : ""); fstrcpy(trust_passwd, global_myname); strlower(trust_passwd); E_md4hash( (uchar *)trust_passwd, orig_trust_passwd_hash); /* Ensure that we are not trying to join a domain if we are locally set up as a domain controller. */ if(strequal(remote, global_myname)) { 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); return 1; } /* * Create the machine account password file. */ if(!trust_password_lock( domain, global_myname, True)) { fprintf(stderr, "unable to open the machine account password file for \ machine %s in domain %s.\n", global_myname, domain); return 1; } /* * Write the old machine account password. */ if(!set_trust_account_password( orig_trust_passwd_hash)) { fprintf(stderr, "unable to write the machine account password for \ machine %s in domain %s.\n", global_myname, domain); trust_password_unlock(); return 1; } /* * If we are given a remote machine assume this is the PDC. */ if(remote == NULL) { pstrcpy(remote_machine, lp_passwordserver()); } if(!*remote_machine) { fprintf(stderr, "No password server list given in smb.conf - \ unable to join domain.\n"); trust_password_unlock(); return 1; } ret = change_trust_account_password( domain, remote_machine); trust_password_unlock(); if(!ret) { trust_password_delete( domain, global_myname); fprintf(stderr,"Unable to join domain %s.\n",domain); } else { printf("Joined domain %s.\n",domain); } return (int)ret; } static void set_line_buffering(FILE *f) { setvbuf(f, NULL, _IOLBF, 0); } /************************************************************* Utility function to prompt for passwords from stdin. Each password entered must end with a newline. *************************************************************/ static char *stdin_new_passwd(void) { static fstring new_passwd; size_t len; ZERO_STRUCT(new_passwd); /* * if no error is reported from fgets() and string at least contains * the newline that ends the password, then replace the newline with * a null terminator. */ if ( fgets(new_passwd, sizeof(new_passwd), stdin) != NULL) { if ((len = strlen(new_passwd)) > 0) { if(new_passwd[len-1] == '\n') new_passwd[len - 1] = 0; } } return(new_passwd); } /************************************************************* Utility function to get passwords via tty or stdin Used if the '-s' option is set to silently get passwords to enable scripting. *************************************************************/ static char *get_pass( char *prompt, BOOL stdin_get) { char *p; if (stdin_get) { p = stdin_new_passwd(); } else { p = getpass(prompt); } return xstrdup(p); } /************************************************************* Utility function to prompt for new password. *************************************************************/ static char *prompt_for_new_password(BOOL stdin_get) { char *p; fstring new_passwd; ZERO_STRUCT(new_passwd); p = get_pass("New SMB password:", stdin_get); fstrcpy(new_passwd, p); p = get_pass("Retype new SMB password:", stdin_get); if (strcmp(p, new_passwd)) { fprintf(stderr, "Mismatch - password unchanged.\n"); return NULL; } return xstrdup(p); } /************************************************************* change a password on a remote machine using IPC calls *************************************************************/ static BOOL remote_password_change(const char *remote_machine, const char *user_name, const char *old_passwd, const char *new_passwd) { struct nmb_name calling, called; struct cli_state cli; struct in_addr ip; if(!resolve_name( remote_machine, &ip, 0x20)) { fprintf(stderr, "unable to find an IP address for machine %s.\n", remote_machine ); return False; } ZERO_STRUCT(cli); if (!cli_initialise(&cli) || !cli_connect(&cli, remote_machine, &ip)) { fprintf(stderr, "unable to connect to SMB server on machine %s. Error was : %s.\n", remote_machine, cli_errstr(&cli) ); return False; } make_nmb_name(&calling, global_myname , 0x0 , scope); make_nmb_name(&called , remote_machine, 0x20, scope); if (!cli_session_request(&cli, &calling, &called)) { fprintf(stderr, "machine %s rejected the session setup. Error was : %s.\n", remote_machine, cli_errstr(&cli) ); cli_shutdown(&cli); return False; } cli.protocol = PROTOCOL_NT1; if (!cli_negprot(&cli)) { fprintf(stderr, "machine %s rejected the negotiate protocol. Error was : %s.\n", remote_machine, cli_errstr(&cli) ); cli_shutdown(&cli); return False; } /* * We should connect as the anonymous user here, in case * the server has "must change password" checked... * Thanks to for this fix. */ if (!cli_session_setup(&cli, "", "", 0, "", 0, "")) { fprintf(stderr, "machine %s rejected the session setup. Error was : %s.\n", remote_machine, cli_errstr(&cli) ); cli_shutdown(&cli); return False; } if (!cli_send_tconX(&cli, "IPC$", "IPC", "", 1)) { fprintf(stderr, "machine %s rejected the tconX on the IPC$ share. Error was : %s.\n", remote_machine, cli_errstr(&cli) ); cli_shutdown(&cli); return False; } if(!cli_oem_change_password(&cli, user_name, new_passwd, old_passwd)) { fprintf(stderr, "machine %s rejected the password change: Error was : %s.\n", remote_machine, cli_errstr(&cli) ); cli_shutdown(&cli); return False; } cli_shutdown(&cli); return True; } /************************************************************* add a new user to the local smbpasswd file *************************************************************/ static BOOL add_new_user(char *user_name, uid_t uid, BOOL trust_account, BOOL disable_user, BOOL set_no_password, uchar *new_p16, uchar *new_nt_p16) { struct smb_passwd new_smb_pwent; /* Create a new smb passwd entry and set it to the given password. */ new_smb_pwent.smb_userid = uid; new_smb_pwent.smb_name = user_name; new_smb_pwent.smb_passwd = NULL; new_smb_pwent.smb_nt_passwd = NULL; new_smb_pwent.acct_ctrl = (trust_account ? ACB_WSTRUST : ACB_NORMAL); if(disable_user) { new_smb_pwent.acct_ctrl |= ACB_DISABLED; } else if (set_no_password) { new_smb_pwent.acct_ctrl |= ACB_PWNOTREQ; } else { new_smb_pwent.smb_passwd = new_p16; new_smb_pwent.smb_nt_passwd = new_nt_p16; } return add_smbpwd_entry(&new_smb_pwent); } /************************************************************* change a password entry in the local smbpasswd file *************************************************************/ static BOOL local_password_change(char *user_name, BOOL trust_account, BOOL add_user, BOOL enable_user, BOOL disable_user, BOOL set_no_password, char *new_passwd) { struct passwd *pwd; void *vp; struct smb_passwd *smb_pwent; uchar new_p16[16]; uchar new_nt_p16[16]; pwd = getpwnam(user_name); /* * Check for a machine account. */ if(trust_account && !pwd) { fprintf(stderr, "User %s does not exist in system password file (usually /etc/passwd). Cannot add machine account without a valid system user.\n", user_name); return False; } /* Calculate the MD4 hash (NT compatible) of the new password. */ nt_lm_owf_gen(new_passwd, new_nt_p16, new_p16); /* * Open the smbpaswd file. */ vp = startsmbpwent(True); if (!vp && errno == ENOENT) { FILE *fp; fprintf(stderr,"smbpasswd file did not exist - attempting to create it.\n"); fp = fopen(lp_smb_passwd_file(), "w"); if (fp) { fprintf(fp, "# Samba SMB password file\n"); fclose(fp); vp = startsmbpwent(True); } } if (!vp) { perror(lp_smb_passwd_file()); return False; } /* Get the smb passwd entry for this user */ smb_pwent = getsmbpwnam(user_name); if (smb_pwent == NULL) { if(add_user == False) { fprintf(stderr, "Failed to find entry for user %s.\n", pwd->pw_name); endsmbpwent(vp); return False; } if (add_new_user(user_name, pwd->pw_uid, trust_account, disable_user, set_no_password, new_p16, new_nt_p16)) { printf("Added user %s.\n", user_name); endsmbpwent(vp); return True; } else { fprintf(stderr, "Failed to add entry for user %s.\n", user_name); endsmbpwent(vp); return False; } } else { /* the entry already existed */ add_user = False; } /* * We are root - just write the new password * and the valid last change time. */ if(disable_user) { smb_pwent->acct_ctrl |= ACB_DISABLED; } else if (enable_user) { if(smb_pwent->smb_passwd == NULL) { smb_pwent->smb_passwd = new_p16; smb_pwent->smb_nt_passwd = new_nt_p16; } smb_pwent->acct_ctrl &= ~ACB_DISABLED; } else if (set_no_password) { smb_pwent->acct_ctrl |= ACB_PWNOTREQ; /* This is needed to preserve ACB_PWNOTREQ in mod_smbfilepwd_entry */ smb_pwent->smb_passwd = NULL; smb_pwent->smb_nt_passwd = NULL; } else { smb_pwent->acct_ctrl &= ~ACB_PWNOTREQ; smb_pwent->smb_passwd = new_p16; smb_pwent->smb_nt_passwd = new_nt_p16; } if(mod_smbpwd_entry(smb_pwent,True) == False) { fprintf(stderr, "Failed to modify entry for user %s.\n", pwd->pw_name); endsmbpwent(vp); return False; } endsmbpwent(vp); return True; } /************************************************************* change a password either locally or remotely *************************************************************/ static BOOL password_change(const char *remote_machine, char *user_name, char *old_passwd, char *new_passwd, BOOL add_user, BOOL enable_user, BOOL disable_user, BOOL set_no_password, BOOL trust_account) { if (remote_machine != NULL) { if (add_user || enable_user || disable_user || set_no_password || trust_account) { /* these things can't be done remotely yet */ return False; } return remote_password_change(remote_machine, user_name, old_passwd, new_passwd); } return local_password_change(user_name, trust_account, add_user, enable_user, disable_user, set_no_password, new_passwd); } /************************************************************* handle password changing for root *************************************************************/ static int process_root(int argc, char *argv[]) { struct passwd *pwd; int ch; BOOL joining_domain = False; BOOL trust_account = False; BOOL add_user = False; BOOL disable_user = False; BOOL enable_user = False; BOOL set_no_password = False; BOOL stdin_passwd_get = False; char *user_name = NULL; char *new_domain = NULL; char *new_passwd = NULL; char *old_passwd = NULL; char *remote_machine = NULL; while ((ch = getopt(argc, argv, "adehmnj:r:sR:D:U:")) != EOF) { switch(ch) { case 'a': add_user = True; break; case 'd': disable_user = True; new_passwd = "XXXXXX"; break; case 'e': enable_user = True; break; case 'D': DEBUGLEVEL = atoi(optarg); break; case 'n': set_no_password = True; new_passwd = "NO PASSWORD"; case 'r': remote_machine = optarg; break; case 's': set_line_buffering(stdin); set_line_buffering(stdout); set_line_buffering(stderr); stdin_passwd_get = True; break; case 'R': lp_set_name_resolve_order(optarg); break; case 'm': trust_account = True; break; case 'j': new_domain = optarg; strupper(new_domain); joining_domain = True; break; case 'U': user_name = optarg; break; default: usage(); } } argc -= optind; argv += optind; /* * Ensure add_user and either remote machine or join domain are * not both set. */ if(add_user && ((remote_machine != NULL) || joining_domain)) { usage(); } if(joining_domain) { if (argc != 0) usage(); return join_domain(new_domain, remote_machine); } /* * Deal with root - can add a user, but only locally. */ switch(argc) { case 0: break; case 1: user_name = argv[0]; break; case 2: user_name = argv[0]; new_passwd = argv[1]; break; default: usage(); } if (!user_name && (pwd = getpwuid(0))) { user_name = xstrdup(pwd->pw_name); } if (!user_name) { fprintf(stderr,"You must specify a username\n"); exit(1); } if (!remote_machine && !Get_Pwnam(user_name, True)) { fprintf(stderr, "User \"%s\" was not found in system password file.\n", user_name); exit(1); } if (user_name[strlen(user_name)-1] == '$') { user_name[strlen(user_name)-1] = 0; } if (trust_account) { /* add the $ automatically */ static fstring buf; if (add_user) { new_passwd = xstrdup(user_name); strlower(new_passwd); } slprintf(buf, sizeof(buf)-1, "%s$", user_name); user_name = buf; } if (remote_machine != NULL) { old_passwd = get_pass("Old SMB password:",stdin_passwd_get); } if (!new_passwd) { new_passwd = prompt_for_new_password(stdin_passwd_get); } if (!password_change(remote_machine, user_name, old_passwd, new_passwd, add_user, enable_user, disable_user, set_no_password, trust_account)) { fprintf(stderr,"Failed to change password entry for %s\n", user_name); return 1; } if(disable_user) { printf("User %s disabled.\n", user_name); } else if(enable_user) { printf("User %s enabled.\n", user_name); } else if (set_no_password) { printf("User %s - set to no password.\n", user_name); } else { printf("Password changed for user %s\n", user_name); } return 0; } /************************************************************* handle password changing for non-root *************************************************************/ static int process_nonroot(int argc, char *argv[]) { struct passwd *pwd = NULL; int ch; BOOL stdin_passwd_get = False; char *old_passwd = NULL; char *remote_machine = NULL; char *user_name = NULL; char *new_passwd = NULL; while ((ch = getopt(argc, argv, "hD:r:sU:")) != EOF) { switch(ch) { case 'D': DEBUGLEVEL = atoi(optarg); break; case 'r': remote_machine = optarg; break; case 's': set_line_buffering(stdin); set_line_buffering(stdout); set_line_buffering(stderr); stdin_passwd_get = True; break; case 'U': user_name = optarg; break; default: usage(); } } argc -= optind; argv += optind; if(argc > 1) { usage(); } if (argc == 1) { new_passwd = argv[0]; } if (!user_name) { pwd = getpwuid(getuid()); if (pwd) { user_name = xstrdup(pwd->pw_name); } else { fprintf(stderr,"you don't exist - go away\n"); exit(1); } } /* * A non-root user is always setting a password * via a remote machine (even if that machine is * localhost). */ if (remote_machine == NULL) { remote_machine = "127.0.0.1"; } if (remote_machine != NULL) { old_passwd = get_pass("Old SMB password:",stdin_passwd_get); } if (!new_passwd) { new_passwd = prompt_for_new_password(stdin_passwd_get); } if (!new_passwd) { printf("unable to get new password\n"); exit(0); } if (!password_change(remote_machine, user_name, old_passwd, new_passwd, False, False, False, False, False)) { fprintf(stderr,"Failed to change password for %s\n", user_name); return 1; } printf("Password changed for user %s\n", user_name); return 0; } /********************************************************* Start here. **********************************************************/ int main(int argc, char **argv) { static pstring servicesf = CONFIGFILE; TimeInit(); setup_logging("smbpasswd", True); charset_initialise(); if(!initialize_password_db()) { fprintf(stderr, "Can't setup password database vectors.\n"); exit(1); } if (!lp_load(servicesf,True,False,False)) { fprintf(stderr, "Can't load %s - run testparm to debug it\n", servicesf); exit(1); } if(!get_myname(myhostname,NULL)) { fprintf(stderr, "unable to get my hostname.\n"); exit(1); } /* * Set the machine NETBIOS name if not already * set from the config file. */ if (!*global_myname) { char *p; fstrcpy(global_myname, myhostname); p = strchr(global_myname, '.' ); if (p) *p = 0; } strupper(global_myname); codepage_initialise(lp_client_code_page()); /* Check the effective uid - make sure we are not setuid */ if ((geteuid() == (uid_t)0) && (getuid() != (uid_t)0)) { fprintf(stderr, "smbpasswd must *NOT* be setuid root.\n"); exit(1); } if (getuid() == 0) { return process_root(argc, argv); } return process_nonroot(argc, argv); }