Como adicionar automaticamente uma conta de usuário E senha com um script Bash?

Eu preciso ter a capacidade de criar contas de usuário no meu Linux (Fedora 10) e atribuir automaticamente uma senha por meio de um script bash (ou caso contrário, se necessário).

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

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

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

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

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

echo thePassword | passwd theUsername --stdin

Você também pode usar chpasswd :

echo username:new_password | chpasswd

assim, você alterar a senha de usuário usernamepara new_password.

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 do bash:

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

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

Gostei da abordagem de Tralemonkey, echo thePassword | passwd theUsername --stdinembora não tenha funcionado para mim como está escrito. No entanto, isso funcionou para mim.

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

-eé reconhecer \ncomo 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 passwdrequer.

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

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

Aspas simples devem bastar aqui.

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

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

Retirado de @Tralemonkey

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

useradd -p encrypted_password newuser

Infelizmente, isso exige que você faça o hash da senha (onde passwd faz isso por você). Infelizmente, não parece haver um utilitário padrão para o hash de alguns dados; portanto, você precisará escrever isso sozinho.

Aqui está um pequeno script Python que 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

Alguns avisos para estar ciente.

1. Enquanto o pcrypt estiver em execução, o texto sem formatação ficará visível para qualquer usuário através do comando ps.
2. O pcrypt usa a função de criptografia do estilo antigo - se você estiver usando algo mais moderno, como um hash MD5, 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),))

Forro único para criar um usuário sudo com diretório inicial e senha.

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

--stdinnão funciona no Debian. Diz:

`passwd: unrecognized option '--stdin'`

Isso funcionou para mim:

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

Aqui podemos encontrar outras boas maneiras:

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

Você pode usar o expect no seu script bash.

Em 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"

Sei que vou chegar anos depois, mas não acredito que ninguém sugeriu o usermod.

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

Inferno, no caso de alguém querer fazer isso em um HPUX mais antigo, você pode usar usermod.sam.

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

O -F será necessário apenas se a pessoa que estiver executando o script for o usuário atual. Claro que você não precisa usar o Perl para criar o hash. Você pode usar o openssl ou muitos outros comandos em seu lugar.

Aqui está um script que fará isso por você ...

Você pode adicionar uma lista de usuários (ou apenas um usuário), se desejar, de uma só vez e cada um terá uma senha diferente. Como bônus, você é apresentado no final do script com uma lista da senha de cada 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 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.

Saúde, Carel

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 Debian / Ubuntu

echo "$new_username:$new_password" | chpasswd

Para OpenSUSE

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

A solução da Tralemonkey quase funcionou para mim também ... mas não completamente. Acabei fazendo assim:

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

2 detalhes importantes que sua solução não incluiu, -nimpede que o eco adicione uma \nsenha que está sendo criptografada e as aspas simples protegem o conteúdo de ser interpretado pelo shell (bash) no meu caso.

BTW Eu executei este comando como root em um sistema CentOS 5.6 no caso de alguém estar se perguntando.

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

Ele pode ser usado efetivamente como uma linha, mas você precisará especificar a senha, o salt e o nome de usuário nos locais certos:

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

Na 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 pares user: password da seguinte maneira:

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.

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

Para RedHat / CentOS, eis o código que cria um usuário, adiciona as senhas e torna o 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

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;