Comment ajouter automatiquement un compte d'utilisateur et un mot de passe avec un script Bash?

, Vous pouvez également utiliser chpasswd:

echo username:new_password | chpasswd

Donc, vous changez le mot de passe de l'utilisateur username en new_password.

Je me demandais la même chose, et je ne voulais pas compter sur un script Python. C'est la ligne pour ajouter un utilisateur avec un mot de passe défini dans l'une bash:

/usr/sbin/useradd -p \`openssl passwd -1 $PASS\` $USER

Le code ci-dessous a fonctionné dans Ubuntu 14.04. Essayez avant de l'utiliser dans d'autres versions/variantes 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

J'ai aimé l'approche de Tralemonkey de echo thePassword | passwd theUsername --stdin bien que cela ne fonctionne pas tout à fait pour moi comme écrit. Toutefois, cela a fonctionné pour moi.

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

-e est de reconnaître \n comme nouvelle ligne.

sudo est l'accès root Pour Ubuntu.

Les guillemets doubles doivent reconnaître $ et développer les variables.

La commande ci-dessus passe le mot de passe et une nouvelle ligne, deux fois, à passwd, ce qui est ce que passwd exige.

Si vous n'utilisez pas de variables, je pense que cela est probablement travail.

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

Les guillemets simples devraient suffire ici.

Ce qui suit fonctionne pour moi et testé sur Ubuntu 14.04. C'est un one liner qui ne nécessite aucune entrée de l'utilisateur.

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

Extrait de @Tralemonkey

Vous pouvez utiliser l'option-P.

useradd -p encrypted_password newuser

Malheureusement, cela vous oblige à hacher le mot de passe vous-même (où passwd le fait pour vous). Malheureusement, il ne semble pas y avoir d'utilitaire standard pour hacher certaines données, vous devrez donc l'écrire vous-même.

Voici un petit script Python que j'ai fouetté pour faire le cryptage pour vous. En supposant que vous l'appeliez pcrypt, vous écririez alors votre ligne de commande ci-dessus dans:

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

Quelques avertissements pour être au courant de.

1. pendant que pcrypt est en cours d'exécution, le texte en clair sera visible par tout utilisateur via la commande ps.
2. pcrypt utilise la fonction crypt de style ancien-si vous utilisez quelque chose de plus moderne comme un hachage MD5, vous devrez changer pcrypt.

Et voici 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),))

--stdin ne fonctionne pas sur Debian. Il dit:

`passwd: unrecognized option '--stdin'`

Cela a fonctionné pour moi:

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

Ici, nous pouvons trouver d'autres bons moyens:

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

Vous pouvez utiliser expect dans votre script bash.

À Partir de 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"

Je sais que je viens à cette année plus tard, mais je ne peux pas croire que personne n'a suggéré usermod.

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

Enfer, juste au cas où quelqu'un veut faire cela sur un HPUX plus ancien, vous pouvez utiliser usermod.sam.

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

Le-F n'est nécessaire que si la personne exécutant le script est l'utilisateur actuel. Bien sûr, vous n'avez pas besoin D'utiliser Perl pour créer le hachage. Vous pouvez utiliser openssl ou de nombreuses autres commandes à sa place.

Single liner pour créer un utilisateur sudo avec le répertoire personnel et le mot de passe.

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

Voici un script qui le fera pour vous .....

Vous pouvez ajouter une liste d'utilisateurs (ou juste un utilisateur) si vous le souhaitez, le tout dans un aller et un mot de passe différent. En prime, vous êtes présenté à la fin du script avec une liste de chaque mot de passe des utilisateurs. .... Si vous le souhaitez, vous pouvez ajouter des options de maintenance utilisateur

Comme:

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

Au script qui définira l'âge du mot de passe et ainsi de suite.

=======

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

===========

J'espère que ça aider.

Santé, Carel

J'ai testé dans mon propre script shell.

• $new_username signifie utilisateur nouvellement créé
• $new_password signifie nouveau mot de passe

Pour CentOS

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

Pour Debian / Ubuntu

echo "$new_username:$new_password" | chpasswd

Pour OpenSUSE

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

La solution qui fonctionne à la fois sur Debian et Red Hat. Dépend de perl, utilise des hachages 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

Utilisation:

userpassadd jim jimslongpassword

Il peut effectivement être utilisé comme un one-liner, mais vous devrez spécifier le mot de passe, le sel et le nom d'utilisateur aux bons endroits:

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

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

Créer un fichier texte, disons texte.txt et le remplir avec user: password paires comme suit:

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

Enregistrez le texte.fichier txt, et exécutez

cat text.txt | chpassword

C'est ça. La solution est (a) évolutive et (b) n'implique pas l'impression de mots de passe sur la ligne de commande.

La solution de Tralemonkey a presque fonctionné pour moi aussi ... mais pas tout à fait. J'ai fini par le faire de cette façon:

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

2 détails clés que sa solution n'incluait pas, le -n empêche echo d'ajouter un \n au mot de passe qui est chiffré, et les guillemets simples protègent le contenu de l'interprétation par le shell (bash) dans mon cas.

BTW j'ai exécuté cette commande en tant que root sur un système CentOS 5.6 au cas où quelqu'un se poserait la question.

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

Pour RedHat / CentOS voici le code qui crée un utilisateur, ajoute les mots de passe et fait de l'utilisateur 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

Utilisation: ./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;