Come aggiungere automaticamente account utente e password con uno script Bash?

Devo avere la possibilità di creare account utente sul mio Linux (Fedora 10) e assegnare automaticamente una password tramite uno script bash (o altrimenti, se necessario).

È facile creare l'utente tramite Bash, ad esempio:

[whoever@server ]#  /usr/sbin/useradd newuser

È possibile assegnare una password in Bash, qualcosa di funzionalmente simile a questo, ma automaticamente:

[whoever@server ]# passwd newuser
Changing password for user testpass.
New UNIX password:
Retype new UNIX password: 
passwd: all authentication tokens updated successfully.
[whoever@server ]#

È possibile eseguire il comando passwd e inviarlo input convogliato. Quindi, fai qualcosa del tipo:

echo thePassword | passwd theUsername --stdin

Puoi anche usare chpasswd :

echo username:new_password | chpasswd

così, si cambia la password per l'utente usernamea new_password.

Mi stavo chiedendo la stessa cosa e non volevo fare affidamento su uno script Python.

Questa è la riga per aggiungere un utente con una password definita in una riga bash:

useradd -p $(openssl passwd -1 $PASS) $USER

Il codice seguente ha funzionato in Ubuntu 14.04. Prova prima di usarlo in altre versioni / varianti di Linux.

# quietly add a user without password
adduser --quiet --disabled-password --shell /bin/bash --home /home/newuser --gecos "User" newuser

# set password
echo "newuser:newpassword" | chpasswd

Mi è piaciuto l'approccio di Tralemonkey echo thePassword | passwd theUsername --stdinanche se non ha funzionato abbastanza per me come scritto. Questo comunque ha funzionato per me.

echo -e "$password\n$password\n" | sudo passwd $user

-eè riconoscere \ncome nuova linea.

sudo è l'accesso root per Ubuntu.

Le doppie virgolette devono riconoscere $ed espandere le variabili.

Il comando sopra passa la password e una nuova riga, due volte, a passwd, che è ciò che passwdrichiede.

Se non si usano le variabili, penso che questo probabilmente funzioni.

echo -e 'password\npassword\n' | sudo passwd username

Le virgolette singole dovrebbero essere sufficienti qui.

Quanto segue funziona per me e testato su Ubuntu 14.04. È un liner che non richiede alcun input da parte dell'utente.

sudo useradd -p $(openssl passwd -1 $PASS) $USERNAME

Tratto da @Tralemonkey

Puoi usare l'opzione -p.

useradd -p encrypted_password newuser

Sfortunatamente, questo richiede che tu abbia l'hash della password (dove passwd lo fa per te). Sfortunatamente, non sembra esserci un'utilità standard per eseguire l'hashing di alcuni dati, quindi dovrai scriverli tu stesso.

Ecco un piccolo script Python che ho preparato per eseguire la crittografia per te. Supponendo che tu l'abbia chiamato pcrypt, dovresti scrivere la tua riga di comando sopra per:

useradd -p $(pcrypt ${passwd}) newuser

Un paio di avvertenze da tenere presente.

1. Mentre pcrypt è in esecuzione, il testo in chiaro sarà visibile a qualsiasi utente tramite il comando ps.
2. pcrypt usa la funzione crypt vecchio stile - se stai usando qualcosa di più moderno come un hash MD5, dovrai cambiare pcrypt.

ed ecco pcrypt:

#!/usr/bin/env python

import crypt
import sys
import random

saltchars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

def salt():
    return random.choice(saltchars) + random.choice(saltchars)

def hash(plain):
    return crypt.crypt(arg, salt())

if __name__ == "__main__":
    random.seed()
    for arg in sys.argv[1:]:
        sys.stdout.write("%s\n" % (hash(arg),))

Liner singolo per creare un utente sudo con home directory e password.

useradd -m -p $(openssl passwd -1 ${PASSWORD}) -s /bin/bash -G sudo ${USERNAME}

--stdinnon funziona su Debian. Dice:

`passwd: unrecognized option '--stdin'`

Questo ha funzionato per me:

#useradd $USER
#echo "$USER:$SENHA" | chpasswd

Qui possiamo trovare altri buoni modi:

• http://www.debian-administration.org/articles/668

Puoi usare aspettarti nel tuo script bash.

Da http://www.seanodonnell.com/code/?id=21

#!/usr/bin/expect 
######################################### 
#$ file: htpasswd.sh 
#$ desc: Automated htpasswd shell script 
######################################### 
#$ 
#$ usage example: 
#$ 
#$ ./htpasswd.sh passwdpath username userpass 
#$ 
###################################### 

set htpasswdpath [lindex $argv 0] 
set username [lindex $argv 1] 
set userpass [lindex $argv 2] 

# spawn the htpasswd command process 
spawn htpasswd $htpasswdpath $username 

# Automate the 'New password' Procedure 
expect "New password:" 
send "$userpass\r" 

expect "Re-type new password:" 
send "$userpass\r"

So che arriverò a questi anni dopo, ma non posso credere che nessuno abbia suggerito usermod.

usermod --password `perl -e "print crypt('password','sa');"` root

Al diavolo, nel caso qualcuno volesse farlo su un vecchio HPUX che puoi usare usermod.sam.

/usr/sam/lbin/usermod.sam -F -p `perl -e "print crypt('password','sa');"` username

-F è necessario solo se la persona che esegue lo script è l'utente corrente. Ovviamente non è necessario utilizzare Perl per creare l'hash. È possibile utilizzare openssl o molti altri comandi al suo posto.

Ecco uno script che lo farà per te .....

Puoi aggiungere un elenco di utenti (o solo un utente) se vuoi, tutto in una volta e ognuno avrà una password diversa. Come bonus ti viene presentato alla fine dello script con un elenco di ogni password utente. .... Se vuoi puoi aggiungere alcune opzioni di manutenzione dell'utente

piace:

chage -m 18 $user
chage -M 28 $user

allo script che imposterà la durata della password e così via.

=======

#!/bin/bash

# Checks if you have the right privileges
if [ "$USER" = "root" ]
then

# CHANGE THIS PARAMETERS FOR A PARTICULAR USE
PERS_HOME="/home/"
PERS_SH="/bin/bash"

   # Checks if there is an argument
   [ $# -eq 0 ] && { echo >&2 ERROR: You may enter as an argument a text file containing users, one per line. ; exit 1; }
   # checks if there a regular file
   [ -f "$1" ] || { echo >&2 ERROR: The input file does not exists. ; exit 1; }
   TMPIN=$(mktemp)
   # Remove blank lines and delete duplicates 
   sed '/^$/d' "$1"| sort -g | uniq > "$TMPIN"

   NOW=$(date +"%Y-%m-%d-%X")
   LOGFILE="AMU-log-$NOW.log"

   for user in $(more "$TMPIN"); do
      # Checks if the user already exists.
      cut -d: -f1 /etc/passwd | grep "$user" > /dev/null
      OUT=$?
      if [ $OUT -eq 0 ];then
         echo >&2 "ERROR: User account: \"$user\" already exists."
         echo >&2 "ERROR: User account: \"$user\" already exists." >> "$LOGFILE"
      else
         # Create a new user
         /usr/sbin/useradd -d "$PERS_HOME""$user" -s "$PERS_SH" -m "$user"
         # passwdgen must be installed
         pass=$(passwdgen -paq --length 8)
         echo $pass | passwd --stdin $user
         # save user and password in a file
         echo -e $user"\t"$pass >> "$LOGFILE"
         echo "The user \"$user\" has been created and has the password: $pass"
      fi
   done
   rm -f "$TMPIN"
   exit 0
else
   echo >&2 "ERROR: You must be a root user to execute this script."
   exit 1
fi

===========

Spero che questo ti aiuti.

Saluti, Carel

Ho testato nel mio script di shell.

• $new_username significa utente appena creato
• $new_password significa nuova password

Per CentOS

echo "$new_password" | passwd --stdin "$new_username"

Per Debian / Ubuntu

echo "$new_username:$new_password" | chpasswd

Per OpenSUSE

echo -e "$new_password\n$new_password" | passwd "$new_username"

La soluzione di Tralemonkey ha funzionato quasi anche per me ... ma non del tutto. Ho finito per farlo in questo modo:

echo -n '$#@password@#$' | passwd myusername --stdin

2 dettagli chiave che la sua soluzione non includeva, -nmantiene l'eco dall'aggiunta di a\n password che viene crittografata e le virgolette singole proteggono il contenuto dall'interpretazione della shell (bash) nel mio caso.

A proposito, ho eseguito questo comando come root su un sistema CentOS 5.6 nel caso qualcuno si stia chiedendo.

La soluzione che funziona su Debian e Red Hat. Dipende da perl, usa hash sha-512:

cat userpassadd
    #!/usr/bin/env bash

    salt=$(cat /dev/urandom | tr -dc A-Za-z0-9/_- | head -c16)
    useradd -p $(perl -e "print crypt('$2', '\$6\$' . '$salt' . '\$')") $1

Uso:

userpassadd jim jimslongpassword

Può essere effettivamente utilizzato come one-liner, ma dovrai specificare tu stesso password, salt e username nei posti giusti:

useradd -p $(perl -e "print crypt('pass', '\$6\$salt\$')") username

Da IBM ( https://www.ibm.com/support/knowledgecenter/ssw_aix_61/com.ibm.aix.cmds1/chpasswd.htm ):

Creare un file di testo, dire text.txt e popolarlo con l'utente: coppie di password come segue:

user1:password1
user2:password2
...
usern:passwordn

Salvare il file text.txt ed eseguirlo

cat text.txt | chpassword

Questo è tutto. La soluzione è (a) scalabile e (b) non comporta la stampa di password sulla riga di comando.

{ echo $password; echo $password; } | passwd $username 

Per RedHat / CentOS ecco il codice che crea un utente, aggiunge le password e rende l'utente un sudoer:

#!/bin/sh
echo -n "Enter username: "
read uname

echo -n "Enter password: "
read -s passwd

adduser "$uname"
echo $uname:$passwd | sudo chpasswd

gpasswd wheel -a $uname

utilizzo: ./my_add_user.sh USER PASSWD

codice:

#!/bin/bash
# my_add_user.sh

if [ "$#" -lt 2 ] 
 then
       echo "$0 username passwd"
       exit
fi

user=$1
passwd=$2

useradd $user -d /data/home/$user  -m  ;
echo $passwd | passwd $user --stdin;