Bash betiği ile otomatik olarak kullanıcı hesabı VE parolası nasıl eklenir?

Benim Linux (Fedora 10) kullanıcı hesapları oluşturma ve otomatik olarak bir bash komut dosyası (veya gerekirse başka bir şekilde) bir parola atama yeteneğine sahip olması gerekir.

Bash ile kullanıcı oluşturmak kolaydır, örneğin:

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

Bash'e işlevsel olarak buna benzer, ancak otomatik olarak bir şifre atamak mümkün mü:

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

Passwd komutunu çalıştırabilir ve borulu girişi gönderebilirsiniz. Yani, şöyle bir şey yapın:

echo thePassword | passwd theUsername --stdin

Ayrıca chpasswd kullanabilirsiniz :

echo username:new_password | chpasswd

öyleyse, kullanıcının parolasını değiştirmek usernameiçin new_password.

Kendime de aynı şeyi soruyordum ve bir Python betiğine güvenmek istemiyordum.

Bu, bir bash satırında tanımlı bir parolaya sahip bir kullanıcı eklemek için kullanılan satırdır:

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

Aşağıdaki kod Ubuntu 14.04'te çalıştı. Diğer sürümlerde / linux varyantlarında kullanmadan önce deneyin.

# 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

Tralemonkey'in echo thePassword | passwd theUsername --stdinbenim için yazdığı gibi pek işe yaramadığı yaklaşımını beğendim . Ancak bu benim için çalıştı.

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

-e\nyeni hat olarak tanımaktır .

sudo Ubuntu için root erişimidir.

Çift tırnaklar $değişkenleri tanımak ve genişletmektir.

Yukarıdaki komut, şifreyi ve yeni bir satırı iki kez geçirir passwd, bu da passwdgereklidir.

Değişkenler kullanılmıyorsa, bunun muhtemelen işe yaradığını düşünüyorum.

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

Burada tek tırnak işaretleri yeterlidir.

Aşağıdakiler benim için çalışıyor ve Ubuntu 14.04'te test edildi. Herhangi bir kullanıcı girişi gerektirmeyen tek bir astardır.

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

@Tralemonkey üzerinden alındı

-P seçeneğini kullanabilirsiniz.

useradd -p encrypted_password newuser

Ne yazık ki, bu parola kendiniz hash gerektirir (passwd sizin için bunu yapar). Ne yazık ki, bazı verileri özetlemek için standart bir yardımcı program yok gibi görünüyor, bu yüzden bunu kendiniz yazmak zorunda kalacaksınız.

İşte size şifrelemeyi yapmak için çırptığım küçük bir Python betiği. Buna pcrypt adını verdiğinizi varsayarsak, yukarıdaki komut satırınızı şöyle yazabilirsiniz:

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

Dikkat edilmesi gereken birkaç uyarı.

1. Pcrypt çalışırken, düz metin ps komutu aracılığıyla herhangi bir kullanıcı tarafından görülebilir.
2. pcrypt eski stil crypt işlevini kullanır - MD5 karma gibi daha moderns kullanıyorsanız, pcrypt'i değiştirmeniz gerekir.

ve işte 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),))

Giriş dizini ve parola ile sudo kullanıcısı oluşturmak için tek astar.

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

--stdinDebian üzerinde çalışmaz. Diyor ki:

`passwd: unrecognized option '--stdin'`

Bu benim için çalıştı:

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

Burada başka iyi yollar bulabiliriz:

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

Bash komut dosyasında beklemeyi kullanabilirsiniz.

Gönderen 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"

Bu yıllar sonra geleceğimi biliyorum, ama kimsenin usermod önermediğine inanamıyorum.

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

Cehennem, birisinin bunu daha eski bir HPUX'de yapmak istemesi durumunda kullanabilirsiniz usermod.sam.

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

-F yalnızca komut dosyasını yürüten kişi geçerli kullanıcıysa gereklidir. Tabii ki karma oluşturmak için Perl kullanmanıza gerek yok. Onun yerine openssl veya diğer birçok komutu kullanabilirsiniz.

İşte sizin için yapacak bir komut dosyası .....

İsterseniz kullanıcıların bir listesini (veya yalnızca bir kullanıcıyı) ekleyebilirsiniz, hepsi bir arada ve her birinin farklı bir şifresi olacaktır. Bonus olarak, komut dosyasının sonunda her kullanıcı şifresinin bir listesi sunulur. .... İsterseniz bazı kullanıcı bakım seçenekleri ekleyebilirsiniz

sevmek:

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

parola yaşını ayarlayacak betiğe vb.

=======

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

===========

Bu yardımcı olur umarım.

Şerefe, Carel

Kendi kabuk senaryomda test ettim.

• $new_username yeni oluşturulan kullanıcı anlamına gelir
• $new_password yeni şifre anlamına gelir

CentOS için

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

Debian / Ubuntu için

echo "$new_username:$new_password" | chpasswd

OpenSUSE için

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

Tralemonkey'in çözümü neredeyse benim için de işe yaradı ... ama pek de değil. Bu şekilde yaptım:

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

Çözümünün içermediği 2 önemli ayrıntı , echo'un şifrelenen şifreye -nbir eklemesini engelliyor \nve tek tırnaklar, içeriği benim durumumda kabuk (bash) tarafından yorumlanmaya karşı koruyor.

BTW Bu komutu herkesin merak etmesi durumunda CentOS 5.6 sisteminde root olarak çalıştırdım.

Hem Debian hem de Red Hat üzerinde çalışan çözüm. Perl'e bağlıdır, sha-512 karmalarını kullanır:

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

Kullanımı:

userpassadd jim jimslongpassword

Tek astar olarak etkili bir şekilde kullanılabilir, ancak şifreyi, tuzu ve kullanıcı adını doğru yerlerde kendiniz belirtmeniz gerekir:

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

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

Bir metin dosyası oluşturun, text.txt deyin ve kullanıcı: şifre çiftleriyle şu şekilde doldurun:

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

Text.txt dosyasını kaydedin ve çalıştırın

cat text.txt | chpassword

Bu kadar. Çözüm, (a) ölçeklendirilebilir ve (b) komut satırında parolaların yazdırılmasını içermez.

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

RedHat / CentOS için kullanıcı yaratan, şifreleri ekleyen ve kullanıcıyı sudoer yapan kod:

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

kullanımı: ./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;