Jak automatycznie dodać konto użytkownika ORAZ hasło za pomocą skryptu Bash?

Muszę mieć możliwość tworzenia kont użytkowników w moim systemie Linux (Fedora 10) i automatycznego przypisywania hasła za pomocą skryptu bash (lub w razie potrzeby w inny sposób).

Łatwo jest utworzyć użytkownika za pomocą Bash, np .:

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

Czy można przypisać hasło w Bash, coś funkcjonalnie podobnego do tego, ale automatycznie:

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

Możesz uruchomić polecenie passwd i wysłać dane wejściowe w potoku. Więc zrób coś takiego:

echo thePassword | passwd theUsername --stdin

Możesz także użyć chpasswd :

echo username:new_password | chpasswd

więc zmieniasz hasło użytkownika usernamena new_password.

Zadawałem sobie to samo i nie chciałem polegać na skrypcie Python.

Oto linia, w której użytkownik ma zdefiniowane hasło w jednym wierszu bash:

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

Poniższy kod działał w Ubuntu 14.04. Wypróbuj, zanim użyjesz go w innych wersjach / wariantach systemu 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

Podobało mi się podejście Tralemonkey, echo thePassword | passwd theUsername --stdinchoć nie napisało się dla mnie. To jednak działało dla mnie.

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

-erozpoznaje \njako nową linię.

sudo jest dostępem root do Ubuntu.

Podwójne cudzysłowy mają na celu rozpoznanie $i rozwinięcie zmiennych.

Powyższe polecenie przekazuje hasło i nowy wiersz dwa razy do passwd, co jest passwdwymagane.

Jeśli nie używam zmiennych, myślę, że to prawdopodobnie działa.

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

Pojedyncze cytaty powinny tu wystarczyć.

Poniższe działa dla mnie i przetestowane na Ubuntu 14.04. Jest to jeden liniowiec, który nie wymaga wkładu użytkownika.

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

Zaczerpnięte z @Tralemonkey

Możesz użyć opcji -p.

useradd -p encrypted_password newuser

Niestety wymaga to samodzielnego zaszyfrowania hasła (w przypadku, gdy robi to passwd). Niestety, wydaje się, że nie ma standardowego narzędzia do mieszania niektórych danych, więc musisz to napisać sam.

Oto mały skrypt w języku Python, który przygotowałem, aby wykonać dla Ciebie szyfrowanie. Zakładając, że nazwałeś to pcrypt, napiszesz powyższą linię poleceń do:

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

Kilka ostrzeżeń, o których należy pamiętać.

1. Podczas działania programu pcrypt tekst jawny będzie widoczny dla każdego użytkownika za pomocą polecenia ps.
2. pcrypt korzysta ze starej funkcji szyfrowania - jeśli używasz czegoś bardziej nowoczesnego, takiego jak skrót MD5, musisz zmienić pcrypt.

a oto 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),))

Pojedyncza linijka do stworzenia użytkownika sudo z katalogiem domowym i hasłem.

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

--stdinnie działa na Debianie. To mówi:

`passwd: unrecognized option '--stdin'`

To działało dla mnie:

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

Tutaj możemy znaleźć inne dobre sposoby:

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

Możesz użyć expect w skrypcie bash.

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

Wiem, że przyjdę o te lata później, ale nie mogę uwierzyć, że nikt nie sugerował trybu użytkownika.

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

Do diabła, na wypadek, gdyby ktoś chciał to zrobić na starszym HPUX, którego możesz użyć usermod.sam.

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

Opcja -F jest potrzebna tylko wtedy, gdy osoba wykonująca skrypt jest bieżącym użytkownikiem. Oczywiście nie musisz używać Perla do tworzenia skrótu. Zamiast tego możesz użyć openssl lub wielu innych poleceń.

Oto skrypt, który zrobi to za Ciebie .....

Możesz dodać listę użytkowników (lub tylko jednego użytkownika), jeśli chcesz, wszyscy za jednym razem i każdy będzie miał inne hasło. Jako bonus otrzymasz na końcu skryptu listę wszystkich haseł użytkowników. .... Jeśli chcesz, możesz dodać opcje konserwacji użytkownika

lubić:

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

do skryptu, który ustawi wiek hasła i tak dalej.

=======

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

===========

Mam nadzieję że to pomoże.

Pozdrawiam, Carel

Testowałem we własnym skrypcie powłoki.

• $new_username oznacza nowo utworzonego użytkownika
• $new_password oznacza nowe hasło

Dla CentOS

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

Dla Debiana / Ubuntu

echo "$new_username:$new_password" | chpasswd

Dla OpenSUSE

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

Rozwiązanie Tralemonkey również prawie dla mnie zadziałało ... ale nie całkiem. Skończyło się to tak:

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

2 kluczowe szczegóły, których jego rozwiązanie nie zawierało, -nutrzymuje echo przed dodaniem \ndo szyfrowanego hasła, a pojedyncze cudzysłowy chronią zawartość przed interpretacją przez powłokę (bash) w moim przypadku.

BTW Uruchomiłem to polecenie jako root w systemie CentOS 5.6 na wypadek, gdyby ktoś się zastanawiał.

Rozwiązanie, które działa zarówno na Debianie, jak i na Red Hat. Zależy od perla, używa skrótów 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

Stosowanie:

userpassadd jim jimslongpassword

Można go skutecznie wykorzystać jako jedno-liniowy, ale musisz samodzielnie podać hasło, sól i nazwę użytkownika:

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

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

Utwórz plik tekstowy, powiedz text.txt i wypełnij go użytkownikiem: hasło paruje w następujący sposób:

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

Zapisz plik text.txt i uruchom

cat text.txt | chpassword

Otóż ​​to. Rozwiązanie jest (a) skalowalne i (b) nie wymaga drukowania haseł w wierszu poleceń.

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

Dla RedHat / CentOS oto kod, który tworzy użytkownika, dodaje hasła i czyni go 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

stosowanie: ./my_add_user.sh USER PASSWD

kod:

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