Wie füge ich ein Benutzerkonto UND ein Passwort automatisch mit einem Bash-Skript hinzu?

Sie können auch chpasswd verwenden:

echo username:new_password | chpasswd

sie ändern also das Kennwort für den Benutzer username in new_password.

Ich habe mich das selbe gefragt und wollte mich nicht auf ein Python-Skript verlassen.

Dies ist die Zeile, um einen Benutzer mit einem definierten Passwort in einer Bash-Zeile hinzuzufügen:

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

Der folgende Code funktioniert in Ubuntu 14.04. Probieren Sie es aus, bevor Sie es in anderen Versionen/Linux-Varianten verwenden.

# 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

Ich mochte Tralemonkeys Ansatz von echo thePassword | passwd theUsername --stdin, obwohl es für mich nicht so gut funktionierte wie geschrieben. Das hat aber für mich funktioniert.

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

-e soll \n als neue Zeile erkennen.

Sudo ist root-Zugriff für Ubuntu.

Die doppelten Anführungszeichen sollen $ erkennen und die Variablen erweitern.

Der obige Befehl übergibt das Kennwort und eine neue Zeile zweimal an passwd, was passwd erfordert.

Wenn keine Variablen verwendet werden, denke ich, dass dies wahrscheinlich funktioniert.

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

Einfache Anführungszeichen sollten hier ausreichen.

Folgendes funktioniert für mich und wurde auf Ubuntu 14.04 getestet. Es ist ein Einzeiler, der keine Benutzereingaben erfordert. 

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

Genommen von @Tralemonkey

Sie können die Option -p verwenden.

useradd -p encrypted_password newuser

Unglücklicherweise müssen Sie das Kennwort jedoch selbst anwählen (wo dies passwd für Sie tut). Leider scheint es kein Standard-Dienstprogramm zu geben, mit dem einige Daten gehasht werden können, so dass Sie diese selbst schreiben müssen.

Hier ist ein kleines Python-Skript, mit dem ich die Verschlüsselung für Sie erledigen konnte. Angenommen, Sie haben es pcrypt genannt, dann schreiben Sie Ihre obige Befehlszeile an:

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

Ein paar Warnungen, die Sie beachten sollten.

1. Während pcrypt ausgeführt wird, ist der Klartext für jeden Benutzer über den Befehl ps sichtbar.
2. pcrypt verwendet die alte Crypt-Funktion. Wenn Sie etwas moderneres wie einen MD5-Hash verwenden, müssen Sie pcrypt ändern.

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 __== "__main__":
    random.seed()
    for arg in sys.argv[1:]:
        sys.stdout.write("%s\n" % (hash(arg),))

--stdin funktioniert nicht unter Debian. Es sagt:

`passwd: unrecognized option '--stdin'`

Das hat für mich funktioniert:

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

Hier können wir andere gute Wege finden:

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

Single Liner zum Erstellen eines Sudo-Benutzers mit Home-Verzeichnis und Passwort.

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

Sie können Expect in Ihrem Bash-Skript verwenden.

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

Ich weiß, ich komme später nach, aber ich kann nicht glauben, dass niemand Usermod vorgeschlagen hat. 

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

Nur für den Fall, dass jemand dies auf einem älteren HPUX tun möchte, können Sie usermod.sam verwenden.

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

Das -F wird nur benötigt, wenn die Person, die das Skript ausführt, der aktuelle Benutzer ist. Natürlich müssen Sie Perl nicht verwenden, um den Hash zu erstellen. Sie könnten an seiner Stelle openssl oder viele andere Befehle verwenden.

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

Sie können eine Liste von Benutzern (oder nur einen Benutzer) hinzufügen, wenn Sie möchten, alle auf einmal und jeder hat ein anderes Passwort. Als Bonus werden Sie am Ende des Skripts mit einer Liste aller Benutzerpasswörter angezeigt. .... Wenn Sie möchten, können Sie einige Optionen für die Benutzerwartung hinzufügen

mögen:

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

auf das Skript, das das Kennwortalter festlegt, usw.

=======

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

Prost, .__ Carel

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

Erstellen Sie eine Textdatei, beispielsweise text.txt, und füllen Sie sie wie folgt mit Benutzer-Passwort-Paaren auf:

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

Speichern Sie die Datei text.txt und führen Sie sie aus

cat text.txt | chpassword

Das ist es. Die Lösung ist (a) skalierbar und (b) beinhaltet nicht das Drucken von Passwörtern in der Befehlszeile.

Ich habe in meinem eigenen Shell-Skript getestet.

• $new_username steht für neu erstellten Benutzer
• $new_password steht für ein neues 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"

Die Lösung von Tralemonkey hat fast auch für mich funktioniert ... aber nicht ganz. Am Ende habe ich es so gemacht:

echo -n '$#@[email protected]#$' | passwd myusername --stdin

2 Schlüsseldetails enthielt seine Lösung nicht, der -n verhindert, dass dem verschlüsselten Passwort ein \n hinzugefügt wird, und die einfachen Anführungszeichen schützen den Inhalt in meinem Fall vor der Interpretation durch die Shell (bash).

Übrigens habe ich diesen Befehl als root auf einem CentOS 5.6-System ausgeführt, falls sich jemand wundert.

Die Lösung, die sowohl für Debian als auch für Red Hat funktioniert. Abhängig von 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

Verwendungszweck:

userpassadd jim jimslongpassword

Es kann effektiv als Einzeiler verwendet werden, aber Sie müssen das Passwort, den Salt und den Benutzernamen selbst an den richtigen Stellen angeben:

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

Für RedHat/CentOS ist hier der Code, der einen Benutzer erstellt, die Kennwörter hinzufügt und den Benutzer zu einem Sudoer macht:

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

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;

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