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

J'ai besoin d'avoir la possibilité de créer des comptes d'utilisateurs sur mon 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 fonctionnellement similaire à cela, 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 ]#

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

echo thePassword | passwd theUsername --stdin

Vous pouvez également utiliser chpasswd :

echo username:new_password | chpasswd

ainsi, vous changez le mot de passe de l'utilisateur usernameen 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 une ligne bash:

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, echo thePassword | passwd theUsername --stdinmême si cela ne fonctionnait pas tout à fait pour moi tel qu'il était écrit. Cela a cependant 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 transmet le mot de passe et une nouvelle ligne, deux fois, à passwd, ce qui estpasswd requis.

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

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

Des guillemets simples devraient suffire ici.

Ce qui suit fonctionne pour moi et testé sur Ubuntu 14.04. Il s'agit d'une doublure qui ne nécessite aucune intervention 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 préparé pour faire le chiffrement 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 à connaître.

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 l'ancienne fonction de cryptage - 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),))

Doublure unique 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}

--stdinne 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 bons moyens:

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

Vous pouvez utiliser expect dans votre script bash.

Depuis 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 j'arrive à ces années plus tard, mais je ne peux pas croire que personne n'ait suggéré de mode d'utilisation.

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

Enfer, juste au cas où quelqu'un voudrait le faire sur un ancien HPUX que 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.

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

Vous pouvez ajouter une liste d'utilisateurs (ou un seul utilisateur) si vous le souhaitez, tous en une seule fois et chacun aura un mot de passe différent. En bonus, vous êtes présenté à la fin du script avec une liste de chaque mot de passe 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 définira l'âge du mot de passe, etc.

=======

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

À la vôtre, Carel

J'ai testé dans mon propre script shell.

• $new_username signifie un 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 de Tralemonkey a presque aussi fonctionné pour moi ... 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, l' -nécho de l'ajout d'un\n au mot de passe qui est crypté, et les guillemets simples protègent 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 demanderait.

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

Usage:

userpassadd jim jimslongpassword

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

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

Depuis 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 user: password 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.

{ 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

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