linux password Como adicionar automaticamente a conta de usuário e senha com um script Bash?



root change other user password (16)

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

Eu preciso ter a capacidade de criar contas de usuário no meu Linux (Fedora 10) e automaticamente atribuir uma senha através de um script bash (ou de outra forma, se necessário).

É fácil criar o usuário via Bash, por exemplo:

[[email protected] ]#  /usr/sbin/useradd newuser

É possível atribuir uma senha no Bash, algo funcionalmente semelhante a isso, mas automaticamente:

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

Answer #1

O seguinte funciona para mim e testado no Ubuntu 14.04. É um forro que não requer nenhuma entrada do usuário.

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

Retirado de @Tralemonkey


Answer #2

Você também pode usar o chpasswd :

echo username:new_password | chpasswd

Assim, você altera a senha do username de username para new_password .


Answer #3

Você pode executar o comando passwd e enviar a entrada canalizada. Então, faça algo como:

echo thePassword | passwd theUsername --stdin

Answer #4

Você pode usar a opção -p.

useradd -p encrypted_password newuser

Infelizmente, isso exige que você use hash a senha (onde o passwd faz isso para você). Infelizmente, parece não haver um utilitário padrão para manipular alguns dados, então você mesmo terá que escrever isso.

Aqui está um pequeno script Python que eu preparei para fazer a criptografia para você. Supondo que você o chamou de pcrypt, você escreveria sua linha de comando acima para:

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

Um par de avisos para estar ciente.

  1. Enquanto o pcrypt está sendo executado, o texto simples será visível para qualquer usuário através do comando ps.
  2. O pcrypt usa a função crypt do estilo antigo - se você estiver usando algo mais moderno como um hash MD5, você precisará alterar o pcrypt.

e aqui está o 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 #5

Single liner para criar um usuário sudo com diretório pessoal e senha.

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

Answer #6

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

Para RedHat / CentOS, aqui está o código que cria um usuário, adiciona as senhas e faz do usuário um 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 #8

Aqui está um script que vai fazer isso por você .....

Você pode adicionar uma lista de usuários (ou apenas um usuário), se você quiser, tudo de uma vez e cada um terá uma senha diferente. Como bônus, você é apresentado no final do script com uma lista de cada senha de usuário. .... Se você quiser, pode adicionar algumas opções de manutenção do usuário

gostar:

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

para o script que irá definir a idade da senha e assim por diante.

=======

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

Felicidades, Carel


Answer #9

A solução que funciona tanto no Debian quanto no Red Hat. Depende do perl, usa 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

Uso:

userpassadd jim jimslongpassword

Ele pode efetivamente ser usado como um one-liner, mas você terá que especificar a senha, o salt e o nome de usuário nos lugares certos:

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

Answer #10

Eu testei no meu próprio script de shell.

  • $new_username significa usuário recém-criado
  • $new_password significa nova senha

Para o CentOS

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

Para o Debian / Ubuntu

echo "$new_username:$new_password" | chpasswd

Para o OpenSUSE

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

Answer #11

Eu estava me perguntando a mesma coisa e não queria confiar em um script Python.

Esta é a linha para adicionar um usuário com uma senha definida em uma linha bash:

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

Answer #12

O código abaixo funcionou no Ubuntu 14.04. Experimente antes de usá-lo em outras versões / variantes do 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 #13

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

Crie um arquivo de texto, diga text.txt e preencha-o com os pares user: password da seguinte forma:

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

Salve o arquivo text.txt e execute

cat text.txt | chpassword

É isso aí. A solução é (a) escalável e (b) não envolve a impressão de senhas na linha de comando.


Answer #14

Você pode usar esperar no seu 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 #15

Eu gostei da abordagem de echo thePassword | passwd theUsername --stdin de echo thePassword | passwd theUsername --stdin echo thePassword | passwd theUsername --stdin embora não funcionou bem para mim como está escrito. Isso, no entanto, funcionou para mim.

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

-e é reconhecer \n como nova linha.

sudo é o acesso root para o Ubuntu.

As aspas duplas são para reconhecer $ e expandir as variáveis.

O comando acima passa a senha e uma nova linha, duas vezes, para passwd , que é o que o passwd requer.

Se não estiver usando variáveis, acho que isso provavelmente funciona.

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

Aspas simples devem ser suficientes aqui.





passwd