web-dev-qa-db-fra.com

Comment ajouter automatiquement un compte utilisateur ET un mot de passe avec un script Bash?

Je dois avoir la possibilité de créer des comptes utilisateur sous Linux (Fedora 10) et d’attribuer automatiquement un mot de passe via un script bash (ou autrement, si nécessaire).

Il est facile de créer l’utilisateur via Bash, par exemple:

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

Est-il possible d'attribuer un mot de passe dans Bash, quelque chose de similaire sur le plan fonctionnel, mais automatiquement:

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

Vous pouvez exécuter la commande passwd et lui envoyer une entrée canalisée. Alors, faites quelque chose comme:

echo thePassword | passwd theUsername --stdin
104
Tralemonkey

Vous pouvez aussi utiliser chpasswd :

echo username:new_password | chpasswd

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

175
SilverDaemon

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 une ligne bash:

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

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

J'ai bien aimé l'approche de echo thePassword | passwd theUsername --stdin par Tralemonkey, même si cela n'a pas fonctionné pour moi tel qu'il est écrit. Cela a cependant fonctionné pour moi.

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

-e doit reconnaître \n comme nouvelle ligne.

Sudo est un accès root pour Ubuntu.

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

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

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

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

Les guillemets simples devraient suffire ici.

29
Paul S

Ce qui suit fonctionne pour moi et a été testé sur Ubuntu 14.04. C'est une ligne qui ne nécessite aucune intervention de l'utilisateur. 

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

Tiré de @Tralemonkey

22
cevaris

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 exister d'utilitaire standard pour hacher des données, vous devrez donc l'écrire vous-même.

Voici un petit script Python que j'ai concocté pour effectuer le chiffrement à votre place. En supposant que vous l'appeliez pcrypt, vous écririez votre ligne de commande ci-dessus dans:

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

Quelques avertissements à prendre en compte.

  1. Pendant l'exécution de pcrypt, 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 de 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 __== "__main__":
    random.seed()
    for arg in sys.argv[1:]:
        sys.stdout.write("%s\n" % (hash(arg),))
11
R Samuel Klatchko

--stdin ne fonctionne pas sur Debian. Ça dit:

`passwd: unrecognized option '--stdin'`

Cela a fonctionné pour moi:

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

Ici nous pouvons trouver d'autres bonnes manières:

7
Roger

Single Liner pour créer un utilisateur Sudo avec répertoire personnel et mot de passe.

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

Vous pouvez utiliser expect dans votre script bash.

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"
5
Carlos Tasada

Je sais que j'arrive quelques années plus tard, mais je ne peux pas croire que personne ne nous ait suggéré d'utiliser le mod 

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

Bon sang, juste au cas où quelqu'un voudrait 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

L'option -F n'est nécessaire que si la personne qui exécute 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 à la place.

4
Jeight

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

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

comme:

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

au script qui va définir 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 cela t'aides.

Cordialement, Carel

3
Carel Lubbe

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

Créez un fichier texte, dites text.txt et remplissez-le avec les paires utilisateur: mot de passe comme suit:

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

Enregistrez le fichier text.txt et exécutez

cat text.txt | chpassword

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

2
Vietnhi Phuvan

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"
2
user7040344

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

Deux détails clés que sa solution n’incluait pas, le -n empêche l’écho d’ajouter un \n au mot de passe crypté et les guillemets simples empêchent le contenu d’être interprété 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 le demanderait.

1
slm

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

Usage:

userpassadd jim jimslongpassword

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

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

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
0
Lefty G Balogh

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;
0
hustljian
{ echo $password; echo $password; } | passwd $username
0
edacval