Wie fügt man automatisch Benutzerkonto UND Passwort mit einem Bash-Skript hinzu?

Muss ich die Fähigkeit haben, erstellen Sie Benutzerkonten auf meinem Linux (Fedora 10) und automatisch ein Passwort vergeben über ein bash-Skript(oder sonst, wenn es sein muss).

Es ist einfach zu erstellen, die den Benutzer über die Bash z.B.:

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

Ist es möglich, ein Kennwort zu vergeben in Bash, etwas mit ähnlicher Funktion wie dieses, aber automatisch:

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

InformationsquelleAutor der Frage ModernCarpentry | 2010-01-27

91

Führen Sie den Befehl passwd aus und senden Sie es geleitet Eingang. So etwas wie:
```
echo thePassword | passwd theUsername --stdin
```
InformationsquelleAutor der Antwort Tralemonkey
162

Könnten Sie auch chpasswd:
```
echo username:new_password | chpasswd
```
so ändern Sie das Kennwort für den Benutzer username zu new_password.

InformationsquelleAutor der Antwort SilverDaemon
57

Frage ich mich die gleiche Sache, und wollte nicht zu verlassen Sie sich auf ein Python-Skript.
Dies ist die Zeile, um einen Benutzer hinzuzufügen, der mit einer definierten Passwort in einer bash-Zeile:
```
/usr/sbin/useradd -p \`openssl passwd -1 $PASS\` $USER
```
InformationsquelleAutor der Antwort Damien

Den code unten arbeitete in Ubuntu 14.04. Versuchen Sie es, bevor Sie es in anderen Versionen/linux-Varianten.

# 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

InformationsquelleAutor der Antwort Ying

29

Ich mochte Tralemonkey Ansatz von echo thePassword | passwd theUsername --stdin obwohl es nicht ganz der Arbeit für mich als geschrieben. Dies ist jedoch für mich gearbeitet.
```
echo -e "$password\n$password\n" | sudo passwd $user
```
-e ist zu erkennen \n als neue Zeile.

sudo ist root-Zugang für Ubuntu.

Den Anführungszeichen zu erkennen $ und erweitern Sie die Variablen.

Den oben genannten Befehl übergibt das Passwort und eine neue Zeile ein, zwei mal, auf passwdwas passwd erfordert.

Wenn nicht mit Hilfe von Variablen, ich denke, das funktioniert wohl.
```
echo -e 'password\npassword\n' | sudo passwd username
```
Einzelne Zitate sollen hier genügen.

InformationsquelleAutor der Antwort Paul S
20

Folgende funktioniert bei mir und getestet auf Ubuntu 14.04. Es ist ein Einzeiler, die nicht erfordert keine Benutzereingaben.
```
sudo useradd -p $(openssl passwd -1 $PASS) $USERNAME
```
Genommen von @Tralemonkey

InformationsquelleAutor der Antwort cevaris
11

Können Sie mit der option-p.
```
useradd -p encrypted_password newuser
```
Leider, dies bedeutet, müssen Sie das Kennwort gehasht sich selbst (wo passwd tut das für Sie). Leider, es scheint nicht zu einem standard-Werkzeug für die hash-einige Daten, so müssen Sie schreiben, dass sich.

Hier ein kleines Python-script, das ich ausgepeitscht, bis die Verschlüsselung für Sie. Vorausgesetzt, Sie nannte es pcrypt, Sie würden dann schreiben Sie Ihre obigen Befehlszeile:
```
useradd -p $(pcrypt ${passwd}) newuser
```
Ein paar Warnungen bewusst zu sein.
1. Während pcrypt ausgeführt wird, der nur-Text werden die für jeden Benutzer sichtbar, die über den ps-Befehl.
2. pcrypt benutzt den alten Stil crypt-Funktion - wenn Sie mit etwas mehr moderne, wie ein MD5-hash, müssen Sie ändern pcrypt.
und hier ist 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),))
```
InformationsquelleAutor der Antwort R Samuel Klatchko
7

--stdin funktioniert nicht auf Debian. Es sagt:
```
`passwd: unrecognized option '--stdin'`
```
Dieser arbeitete für mich:
```
#useradd $USER
#echo "$USER:$SENHA" | chpasswd
```
Hier finden wir einige andere gute Möglichkeiten:
- http://www.debian-administration.org/articles/668
InformationsquelleAutor der Antwort Roger

Können Sie erwarten, in dein bash-script.

Vom 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"

InformationsquelleAutor der Antwort Carlos Tasada

4

Ich weiß, ich komme in diesem Jahre später, aber ich kann nicht glauben, dass noch niemand vorgeschlagen, usermod.
```
usermod --password `perl -e "print crypt('password','sa');"` root
```
Hölle, nur für den Fall jemand will, um dies zu tun auf einem älteren HPUX können Sie usermod.sam.
```
/usr/sam/lbin/usermod.sam -F -p `perl -e "print crypt('password','sa');"` username
```
- F ist nur erforderlich, wenn die person, die die Ausführung des Skripts ist der aktuelle Benutzer. Natürlich Sie nicht brauchen, um verwenden Perl, um den hash. Sie könnte verwenden openssl oder viele andere Befehle an seine Stelle.

InformationsquelleAutor der Antwort Jeight
4

Single-liner erstellen Sie einen sudo-Benutzer mit home-Verzeichnis und das Kennwort.
```
useradd -m -p $(openssl passwd -1 ${PASSWORD}) -s /bin/bash -G sudo ${USERNAME}
```
InformationsquelleAutor der Antwort Sandeep

Hier ist ein Skript, das dies für Sie tun wird .....

Können Sie eine Liste der Benutzer (oder Benutzer) wenn Sie wollen, alle auf einmal und jede hat ein anderes Passwort. Als bonus erhalten Sie am Ende des Skripts mit einer Liste der einzelnen Benutzer-Passwort. .... Wenn Sie möchten, können Sie fügen Sie einige Benutzer-Wartung-Optionen

wie:

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

dem Skript das Passwort, Alter und so weiter.

=======

#!/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

===========

Hoffe, das hilft.

Cheers,
Carel

InformationsquelleAutor der Antwort Carel Lubbe

2

Getestet hab ich in meiner eigenen shell-Skript.
- $new_username bedeutet, dass neu erstellte Benutzer
- $new_password bedeutet neu Passwort
Für CentOS
```
echo "$new_password" | passwd --stdin "$new_username"
```
Für Debian/Ubuntu
```
echo "$new_username:$new_password" | chpasswd
```
Für OpenSUSE
```
echo -e "$new_password\n$new_password" | passwd "$new_username"
```
InformationsquelleAutor der Antwort Gorgon
1

Die Lösung, die funktioniert auf beiden Debian und Red Hat. Hängt davon ab, perl, verwendet sha-512-hashes:
```
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
```
Verwendung:
```
userpassadd jim jimslongpassword
```
Es kann effektiv verwendet werden, als ein one-liner, aber Sie müssen, um das Kennwort anzugeben, Salz und Benutzername an den richtigen stellen selbst:
```
useradd -p $(perl -e "print crypt('pass', '\$6\$salt\$')") username
```
InformationsquelleAutor der Antwort golem
1

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

Erstellen Sie eine Textdatei, sagen text.txt und füllen Sie es mit user:password-Paare wie folgt:
```
user1:password1
user2:password2
...
usern:passwordn
```
Speichern text.txt Datei, und führen Sie
```
cat text.txt | chpassword
```
Das ist es. Die richtige Lösung ist skalierbar und (b) nicht mit Druck Passwörter auf der Kommandozeile.

InformationsquelleAutor der Antwort Vietnhi Phuvan
0

Tralemonkey die Lösung fast arbeitete für mich als auch ... aber nicht ganz. Ich landete, es zu tun auf diese Weise:
```
echo -n '$#@password@#$' | passwd myusername --stdin
```
2 wichtige details seiner Lösung nicht enthalten, die -n hält, echo hinzufügen, eine \n um das Kennwort wird immer verschlüsselt, und die einfachen Anführungszeichen schützen den Inhalt interpretiert wird von der shell (bash) in meinem Fall.

BTW ich lief diesen Befehl als root auf einem CentOS 5.6-system, falls sich jemand wundert.

InformationsquelleAutor der Antwort slm

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

InformationsquelleAutor der Antwort edacval

Für RedHat /CentOS hier ist der code, der erstellt einen Benutzer, fügt die Passwörter und lässt den Benutzer ein 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

InformationsquelleAutor der Antwort Lefty G Balogh

Verwendung: ./my_add_user.sh USER PASSWD

code:

#!/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;

InformationsquelleAutor der Antwort hustljian

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Für CentOS

Für Debian/Ubuntu

Für OpenSUSE