¿La mejor manera de cambiar una contraseña de root en más de 3000 servidores Solaris, AIX y Linux?

Larga historia corta: gran corporación antigua, muchos servidores UNIX / Linux.

Heredé la responsabilidad de un montón de guiones que dejaron hace unos años. Uno de ellos era un script que se ejecutaría cada $ X durante meses para actualizar globalmente la contraseña de root en todos nuestros servidores.

El script es un desastre de Shell Script and Expect, y funciona en la confianza SSH que se configura entre todos nuestros servidores y un servidor central de comando y control.

El problema es que el guión es un desastre gigante. Los comandos de Expect están tratando de dar cuenta de todas las versiones posibles de "passwd" que existen en cualquier cuadro de UNIX / Linux, y varían bastante.

A medida que estamos ampliando y actualizando gran parte de nuestra infraestructura, el script se está volviendo realmente inmanejable.

Mi pregunta es: ¿hay una mejor manera de hacer esto? Suponiendo que haya una confianza SSH ya establecida, ¿cuál es la mejor manera de cambiar la contraseña de root en más de 3000 servidores al mismo tiempo?

Utiliza la marioneta .

Puppet es muy flexible, fácil de mantener y utiliza SSL. Puede sonar un poco exagerado y tendrás que hacer un esfuerzo extra para construir el sistema Puppet.

Pero. Probablemente esta no sea la última actualización masiva que harás en estas máquinas. Puppet te ahorrará mucho tiempo cuando comience cualquier procedimiento de actualización masiva y los scripts sean muy legibles / reutilizables.

Al menos esto funcionó para mí hace unos años y todavía puedo reutilizar algunas de esas recetas de Puppet (también conocidos como scripts). También lo he usado en entornos un poco más pequeños, solo asegúrate de que cada máquina tenga un estado conocido .

He demostrado muchas veces (en muchas empresas) que todos los scripts de implementación personalizados se vuelven dolorosos después de un tiempo o cuando interviene el siguiente tipo. Y siempre que lleve un teléfono celular, los scripts antiguos lo perseguirán y lo harán.

Si crees que esto realmente suena bien, aquí hay un gran tutorial de Puppet con entorno virtual incluido para que comiences.

He usado el módulo Perl Authen :: PAM en Solaris con gran éxito. Aquí hay un script de muestra:

#!/usr/bin/perl

use Authen::PAM;

my $username = 'root';
my $password = '1234567';

die qq{Error: Unknown user\n} unless getpwnam($username);

die qq{Error: You must run this as root.\n} unless ($> == 0);

my $pamh;

sub my_conv_func
{
    my @res;
    while ( @_ )
    {
        my $code = shift;
        my $msg = shift;
        my $ans = "";

        if ($code == PAM_PROMPT_ECHO_OFF() )
        {
            if (($msg =~ /^New Password:/i) or ($msg =~ /^Re-enter new Password:/i))
            {
                $ans = $password;
            }
            else
            {
                die qq{Unknown message: $msg\n};
            }
        }
        else
        {
            print qq{$msg\n};
        }

        push @res, (PAM_SUCCESS(), $ans);
    }
    push @res, PAM_SUCCESS();

    return @res;
}

ref($pamh = new Authen::PAM("passwd", $username, \&my_conv_func)) || die "Error code $pamh during PAM init!";

my $res = $pamh->pam_chauthtok;

print $pamh->pam_strerror($res),"\n" unless $res == PAM_SUCCESS();

exit 0;

Si puede escribir Perl, el módulo Net :: OpenSSH :: Parallel permite escribir scripts que realizan acciones en paralelo en hosts remotos a través de SSH con bastante facilidad.

Contiene una secuencia de comandos de muestra para cambiar las contraseñas que puede usar como base. Como parece que tiene un entorno heterogéneo, le gustaría agrupar los hosts por tipo y usar un sub diálogo de manejo de diálogo diferente para cada uno.

No sé sobre "mejor", y si es posible para todas las máquinas nix * que no son Linux en su mezcla, pero ¿ha mirado títeres o cfengine para este tipo de actividad?

También hay herramientas comerciales (muy caras) para la gestión de identidad, dos que he visto / usado en el pasado son Oracle Identity Manager y el equivalente de Novela.

Después de continuar investigando esto, aprendí algunas cosas ...

En primer lugar, esta es una tarea realmente molesta para automatizar, especialmente en muchos entornos diferentes. La respuesta más correcta a esta pregunta es probablemente @ tomi's: use Puppet.

Eventualmente, espero que Puppet administre la infraestructura, pero la implementación en los servidores UNIX de toda la empresa para un cambio de contraseña de root en este momento no es una opción tan factible.

Después de leer muchas páginas de manual y un montón de Google-fu, logré crear un script que recorre una lista de servidores de destino, abre una conexión SSH y ejecuta uno de los siguientes:

# Solaris
# Generate new pass via crypt(newpass,salt) and insert it into /etc/shadow

# AIX
$ echo "root:newpass" | chpasswd -f NOCHECK

# Linux
$ echo "newpass" | passwd root --stdin

# IBM VIO (Virtual I/O)
$ echo "echo \"padmin:newpass\" | chpasswd -f NOCHECK" | oem_setup_env

# IBM HMCs (Hardware Management Consoles)
$ chhmcusr -u hscroot -t passwd -v "newpass"

Hace bastante más que ejecutar solo esos comandos, pero los anteriores son los que funcionan la magia.

No pude encontrar ninguna manera simple de cambiar la contraseña de forma no iterativa en Solaris, por lo que recurrimos a la modificación /etc/shadowsobre la marcha.

Recientemente he hecho esto usando Bash Script ...

#!/usr/bin/env bash

# Change Password of Remote Server Using SSH

#--------------------------------------------
# Define User which you want to
# Change Password in remote server
#--------------------------------------------
Uname="root"
# Create Password in Encrpyted Form Using below command,
# and store in this script
# perl -e'print crypt("YourPassword", "salt")' ; echo -e
# then copy and past in following varible,
# password should be single qouted*

Password='safv8d8ESMmWk'

Update_Pass() {
  ssh $ruser@$Server_ip  -p $port "echo ${Uname}:${Password} | chpasswd -e"
}

Show_Help(){
cat <<_EOF
Usage $0        [OPTION]..
Mandatory arguments to long options are mandatory for short options too.
  -i, --ip     <IP_ADDR_OF_SREVER> IP Address Of Remote Server
  -u, --user   <Username>          Username Of Remote Server    <Default User is root>
  -p, --port   <port>              Port Of Remote Server        <Default is 22>

Note:- For Security Reason Do Not Provide Password to the script, because
       it will get save in history, so do not provide it,
       script will prompt for password

Report $0 bugs to [email protected]
_EOF
}



Main() {

        case $1 in
           -i|--ip) Server_ip=$2;
                    ruser="$4"; [[ -z $ruser ]] && ruser=root
                    port="$6";  [[ -z $port  ]]  && port=22
                    Update_Pass ;;
                *)  Show_Help ;;
        esac
}

Main $*

Esta es mi solución hasta ahora. todavía necesito ver si funciona en múltiples sistemas

#!/usr/bin/env bash

ChangePassword()
{
    echo "changing password for server $ServerIp"
    ssh root@$ServerIp "echo root:${NewPassword} | chpasswd" < /dev/null
}

CreatePassword()
{
    while true;
    do
        echo "Please enter the new password :"
        read -s NewPassword <&0
        echo "Confirm the password :"
        read -s ConfirmPassword <&0 
        # /proc/${PPID}/fd/0

        if [ "$NewPassword" == "$ConfirmPassword" ]
        then
            break
        else
            echo "Passwords do not match"
            echo "Try again..."
        fi
    done
    ChangePassword
    echo "end of createpassword"
}

SetUpPasswordlessSSH()
{   
    echo "enter the old password from server $ServerIp when asked"
    ssh root@$ServerIp mkdir -p .ssh
    cat .ssh/id_rsa.pub | ssh root@$ServerIp 'cat >> .ssh/authorized_keys'

    echo "Passwordless SSH is now available"
    echo "Now you can change the password"
    CreatePassword
}

NoSSH()
{
    echo "Passwordless SSH for this server with ip $ServerIp is not yet set up."
    read -p "Do you want to set it up now? " -n 1 -r <&0
    echo "" 
    if [[ ! $REPLY =~ ^[Yy]$ ]]
    then
        break
    else
        SetUpPasswordlessSSH
    fi
}

AcceptHostKey()
{
    read -p "Do you trust the server? " -n 1 -r <&1 
    echo ""
    if [[ ! $REPLY =~ ^[Yy]$ ]]
    then
        break
    else
        SetUpPasswordlessSSH
    fi
}

Main()
{
    while read -r ServerIp <&9
    do
        echo  "Server $ServerIp ..."
        status=$(ssh -o BatchMode=yes -o ConnectTimeout=5 $ServerIp echo ok 2>&1)
        if [[ $status == ok ]]
        then
            echo "creating password"
            CreatePassword
            echo "password changed"
        elif [[ $status == "Permission denied"* ]]
        then
            NoSSH
        elif [[ $status == "Host key verification failed"* ]]
        then
            echo "Error: $status"
            AcceptHostKey
        else
            echo "ERROR OCCURED FOR SERVER WITH IP: $ServerIp"
            echo "Error: $status"
        fi
    done 9< servers.txt
    history -cw
    clear
}

Main $*

Puede usar pdsh para ejecutar su comando en varios hosts al mismo tiempo.

Además del títere: SaltStack Otro enfoque: automatice la ejecución usando las bibliotecas SSH de forma secuencial o en paralelo usando Fabric http://docs.fabfile.org/en/1.6/ , Capistrano o similar que no requieren mucho tiempo / esfuerzo para desplegarse.

Dos opciones:

Usar marioneta

Utilice la plataforma de ejecución. Run deck es un servidor que le permite ejecutar comandos en cientos de máquinas simultáneamente. Puede agrupar máquinas en grupos, para ejecutar comandos en solo un subconjunto de máquinas.

http://rundeck.org

Creo que el formato del /etc/shadowarchivo es bastante estándar en las distribuciones de Linux. ¿Puedes escribir un script awk simple para actualizar la contraseña?

cat /etc/shadow| awk -v pass='NEWPASSHASH' -v now=`date '+%s'` 'BEGIN{ OFS=FS=":"} /^root/ {$2=pass; $3=now} {print}' > /tmp/shadow && mv /tmp/shadow /etc/shadow

Me aseguraría de probarlo para que no te bloquees;)