usuario - script para cambiar password linux

¿Cómo agregar automáticamente la cuenta de usuario Y la contraseña con un script Bash?

Question

Necesito tener la capacidad de crear cuentas de usuario en mi Linux (Fedora 10) y asignar automáticamente una contraseña a través de un script bash (o de lo contrario, si es necesario).

Es fácil crear el usuario a través de Bash, por ejemplo:

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

¿Es posible asignar una contraseña en Bash, algo funcionalmente similar a esto, pero de forma automática:

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

Answer 1

Aquí hay un script que lo hará por ti .....

Puede agregar una lista de usuarios (o solo un usuario) si lo desea, todo de una vez y cada uno tendrá una contraseña diferente. Como bonificación, se le presenta al final de la secuencia de comandos con una lista de las contraseñas de cada usuario. .... Si lo desea, puede agregar algunas opciones de mantenimiento del usuario

me gusta:

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

a la secuencia de comandos que establecerá la edad de la contraseña y así sucesivamente.

=======

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

===========

Espero que esto ayude.

Saludos, Carel

Answer 2

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

Cree un archivo de texto, digamos text.txt y rellene con user: password pairs de la siguiente manera:

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

Guarde el archivo text.txt y ejecútelo

cat text.txt | chpassword

Eso es. La solución es (a) escalable y (b) no implica la impresión de contraseñas en la línea de comando.

Answer 3

El siguiente código funcionó en Ubuntu 14.04. Pruebe antes de usarlo en otras versiones / 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

Answer 4

He probado en mi propio script de shell.

• $new_username significa usuario recién creado
• $new_password significa nueva contraseña

Para CentOS

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

Para Debian / Ubuntu

echo "$new_username:$new_password" | chpasswd

Para OpenSUSE

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

Answer 5

La solución de Tralemonkey casi funcionó para mí también ... pero no del todo. Terminé haciéndolo de esta manera:

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

2 detalles clave que su solución no incluía, el -n evita que echo agregue /n a la contraseña que se está encriptando, y las comillas simples protegen los contenidos para que no sean interpretados por el shell (bash) en mi caso.

Por cierto, ejecuté este comando como root en un sistema CentOS 5.6 en caso de que alguien se esté preguntando.

Answer 6

La solución que funciona tanto en Debian como en Red Hat. Depende de perl, usa hash 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

Uso:

userpassadd jim jimslongpassword

Se puede usar de manera efectiva como un trazador de líneas, pero deberá especificar la contraseña, el nombre de usuario y el nombre de usuario en los lugares correctos usted mismo:

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

Answer 7

Lo siguiente funciona para mí y probado en Ubuntu 14.04. Es un trazador de líneas que no requiere ninguna entrada del usuario.

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

Tomado de @Tralemonkey

Answer 8

Me estaba preguntando lo mismo y no quería confiar en un script de Python. Esta es la línea para agregar un usuario con una contraseña definida en una línea de bash:

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

Answer 9

Me gustó el enfoque de echo thePassword | passwd theUsername --stdin de echo thePassword | passwd theUsername --stdin echo thePassword | passwd theUsername --stdin aunque no funcionó para mí como está escrito. Sin embargo, esto funcionó para mí.

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

-e es reconocer /n como nueva línea.

sudo es el acceso raíz para Ubuntu.

Las comillas dobles son para reconocer $ y expandir las variables.

El comando anterior pasa la contraseña y una nueva línea, dos veces, para passwd , que es lo que requiere passwd .

Si no se usan variables, creo que esto probablemente funcione.

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

Las comillas simples deberían ser suficientes aquí.

Answer 10

Para RedHat / CentOS, aquí está el código que crea un usuario, agrega las contraseñas y convierte al usuario en 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

Answer 11

Puede ejecutar el comando passwd y enviarlo por canal de entrada. Entonces, haz algo como:

echo thePassword | passwd theUsername --stdin

Answer 12

Puedes usar expect en tu 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"

Answer 13

Puedes usar la opción -p.

useradd -p encrypted_password newuser

Desafortunadamente, esto requiere que hagas la contraseña tú mismo (donde passwd hace eso por ti). Lamentablemente, no parece haber una utilidad estándar para almacenar algunos datos, por lo que tendrá que escribirlos usted mismo.

Aquí hay un pequeño script de Python que preparé para hacer el cifrado por usted. Asumiendo que lo llamó pcrypt, entonces escribiría su línea de comando anterior a:

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

Un par de advertencias para tener en cuenta.

1. Mientras pcrypt se está ejecutando, el texto en claro será visible para cualquier usuario a través del comando ps.
2. pcrypt usa la función crypt de estilo antiguo; si estás utilizando algo más moderno como un hash MD5, deberás cambiar pcrypt.

y aquí está 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),))

Answer 14

Sé que llegaré años después, pero no puedo creer que nadie sugiriera usermod.

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

Demonios, solo en caso de que alguien quiera hacer esto en un HPUX antiguo, puede usar usermod.sam .

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

El -F solo es necesario si la persona que ejecuta el script es el usuario actual. Por supuesto, no es necesario usar Perl para crear el hash. Puede usar openssl u otros muchos comandos en su lugar.

Answer 15

Solo trazador de líneas para crear un usuario de sudo con el directorio de inicio y la contraseña.

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

Answer 16

También chpasswd usar chpasswd :

echo username:new_password | chpasswd

entonces, cambia la contraseña para el username de username a new_password .

Answer 17

uso: ./my_add_user.sh USER PASSWD

código:

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

Answer 18

--stdin no funciona en Debian. Dice:

`passwd: unrecognized option ''--stdin''`

Esto funcionó para mí:

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

Aquí podemos encontrar algunas otras buenas maneras:

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

Answer 19

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