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

Ich muss in der Lage sein, Benutzerkonten unter meinem Linux (Fedora 10) zu erstellen und automatisch ein Kennwort über ein Bash-Skript zuzuweisen (oder bei Bedarf auf andere Weise).

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

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

Ist es möglich, in Bash ein Passwort zuzuweisen, das funktionell ähnlich ist, 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 ]#

Sie können den Befehl passwd ausführen und eine Pipeline-Eingabe senden. Also mach so etwas wie:

echo thePassword | passwd theUsername --stdin

Sie können auch chpasswd verwenden :

echo username:new_password | chpasswd

Sie ändern also das Passwort für den Benutzer usernamein new_password.

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

Dies ist die Zeile zum Hinzufügen eines Benutzers mit einem definierten Kennwort in einer Bash-Zeile:

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

Der folgende Code funktionierte in Ubuntu 14.04. Versuchen Sie es, 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, echo thePassword | passwd theUsername --stdinobwohl er für mich nicht ganz so funktioniert hat, wie er geschrieben wurde. Dies funktionierte jedoch für mich.

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

-eist \nals neue Zeile zu erkennen .

sudo ist Root-Zugriff für Ubuntu.

Die doppelten Anführungszeichen dienen zum Erkennen $und Erweitern der Variablen.

Der obige Befehl übergibt das Passwort und eine neue Zeile zweimal an passwd, was passwderforderlich ist.

Wenn keine Variablen verwendet werden, funktioniert dies wahrscheinlich.

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

Einfache Anführungszeichen sollten hier ausreichen.

Das Folgende funktioniert für mich und wurde unter Ubuntu 14.04 getestet. Es ist ein Einzeiler, für den keine Benutzereingaben erforderlich sind.

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

Entnommen aus @Tralemonkey

Sie können die Option -p verwenden.

useradd -p encrypted_password newuser

Leider müssen Sie das Passwort selbst hashen (wo passwd das für Sie erledigt). Leider scheint es kein Standarddienstprogramm zum Hashing einiger Daten zu geben, sodass Sie diese selbst schreiben müssen.

Hier ist ein kleines Python-Skript, das ich erstellt habe, um die Verschlüsselung für Sie durchzuführen. Angenommen, Sie haben es pcrypt genannt, dann schreiben Sie Ihre obige Befehlszeile an:

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

Ein paar Warnungen zu beachten.

1. Während pcrypt ausgeführt wird, ist der Klartext für jeden Benutzer über den Befehl ps sichtbar.
2. pcrypt verwendet die alte Kryptofunktion. 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 __name__ == "__main__":
    random.seed()
    for arg in sys.argv[1:]:
        sys.stdout.write("%s\n" % (hash(arg),))

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}

--stdinfunktioniert nicht unter Debian. Es sagt:

`passwd: unrecognized option '--stdin'`

Das hat bei mir funktioniert:

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

Hier finden wir einige andere gute Möglichkeiten:

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

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ß, dass ich dieses Jahr später komme, aber ich kann nicht glauben, dass niemand Usermod vorgeschlagen hat.

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

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

/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önnen stattdessen openssl oder viele andere Befehle verwenden.

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

Sie können eine Liste von Benutzern (oder nur einen Benutzer) hinzufügen, wenn Sie möchten, alles auf einmal und jeder hat ein anderes Passwort. Als Bonus erhalten Sie am Ende des Skripts eine Liste der Kennwörter der einzelnen Benutzer. .... Wenn Sie möchten, können Sie einige Benutzerwartungsoptionen hinzufügen

mögen:

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

zu dem Skript, das das Passwortalter festlegt 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.

Prost, Carel

Ich habe in meinem eigenen Shell-Skript getestet.

• $new_username bedeutet neu erstellter 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"

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

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

2 wichtige Details, die seine Lösung nicht enthielt, das -nEcho verhindert, \ndass dem zu verschlüsselnden Passwort ein hinzugefügt wird, und die einfachen Anführungszeichen schützen den Inhalt in meinem Fall davor, von der Shell (Bash) interpretiert zu werden.

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

Die Lösung, die sowohl auf Debian als auch auf 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

Verwendung:

userpassadd jim jimslongpassword

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

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

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

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

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.

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

Für RedHat / CentOS ist hier der Code, der einen Benutzer erstellt, die Passwö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;