Se puede generar una clave usando RSA o DSA

DSA es más rápido, pero en generarl RSA es más seguro. Se suele decir que  DSA es más rápido "firmando", pero más lento "verificando".

En cualquier caso una llave  de RSA 2048 bit  será suficiente o mejor incluso una llave  de RSA 4096 bit

$ ssh-keygen -b 4096 -t rsa

La passphrase si se rellena tiene un comportamiento similar a la contraseña, será solicitada al utilizar esta clave. Deberá ser una frase, en la que se pueden incluir espacios en blanco y signos de puntuación.
En nuestro caso hemos decidido dejarla vacía para así poder utilizar este método de autenticación en procesos no interactivos. Puedes utilizar una frase de paso si no confías en la seguridad de tu máquina.      

Usando el comando para  copiar nuestra llave pública al servidor remoto.

ssh-copy-id remote_ip

ssh-copy-id -i ~/.ssh/id_rsa.pub user@server 

O copiando la llave pública vía scp  

scp ~/.ssh/id_rsa.pub username@remote_ip:

en el directorio:

~/.ssh/authorized_keys

 Crear el directorio, añadir la llave pública rsa a la lista de autorizadas, eliminar  la llave pública y asignar permisos correctos:

$ mkdir ~/.ssh
$ cat ~/id_rsa.pub >> ~/.ssh/authorized_keys
$ rm ~/id_rsa.pub
$ chmod 600 ~/.ssh/authorized_keys

Recordar proteger el directorio con permisos sólo para el creador:

chmod 400 ~/.ssh/authorized_keys

Y/o aplicar el "immutable"

chattr +i ~/.ssh/authorized_keys

Revisar que la configuración del servidor SSH  /etc/ssh/sshd_config  acepta llaves SSH

PubkeyAuthentication yes
RSAAuthentication yes

También podemos deshabilitar la autenticación con contraseña añadiendo:

ChallengeResponseAuthentication no
# Disable password authentication forcing use of keys
PasswordAuthentication no
UsePAM no

Si hemos puesto una (passphrase) al generar la llave pública la próxima vez que nos conectemos al servidor remoto. en lugar de pedirnos la contraseña del usuario, nos pedirá la frase clave con la que la ciframos nuestra llave privada.

[el-brujo@ns2] $ ssh ip_remota
Enter passphrase for key '/home/el-brujo/.ssh/id_rsa':

Se puede especificar con la opción -i en el comando ssh y en el comando scp la llave privada que queremos usar para conectaros remotamente y también cambiar el puerto por defecto (22) con -p en ssh y -P (mayúsculas en scp)

          -i identity_file

            Selects the file from which the identity (private key) for RSA
            authentication is read.  This option is directly passed to ssh.

      -P port
            Specifies the port to connect to on the remote host.  Note that
            this option is written with a capital P, because -p is already
            reserved for preserving the times and modes of the file in rcp.

Ejemplo conectarse a ns2.elhacker.net con el usuario backup por el puerto 22 (ssh) usando la llave de el-brujo

ssh -i /home/el-brujo/.ssh/id_rsa -p 22 backup@ns2.elhacker.net 

Copiar remotamente el local fichero.bz2  al directorio /home/backup de la máquina remota ns2.elhacker.net usando la llave del usuario backup:

scp -P 22 -i /home/backup/.ssh/id_rsa /home/backup/fichero.bz2 backup@ns2.elhacker.net:/home/backup/

 En el log de syslog:

Accepted publickey for el-brujo from ns.elhacker.net port 46592 ssh2

Para la gestión de llaves podemos usar ssh-agent, ssh-add o key-chain


Aunque scp puede copiar directorios, no es necesariamente el mejor método. Si su directorio contiene enlaces duros o blandos, no van a ser duplicadas. Los enlaces se copiarán los archivos sin formato (los destinos de vínculos), y peor aún, directorio de enlaces circulares causan scp1 al bucle indefinidamente. (scp2 detecta los enlaces y las copias de sus objetivos simbólicos en su lugar.) Otros tipos de archivos especiales, tales como canalizaciones con nombre, también no se copian correctamente. Una mejor solución es utilizar el alquitrán, que maneja archivos especiales correctamente, y enviarlo a la máquina remota para ser desempaquetado, a través de SSH:

tar cf - /usr/local/bin | ssh ns.elhacker.net tar xf -

Tar + ssh (Tar sobre ssh)

Crear un comprimido .tar.gz de todo el directorio /home y subdirectorios en el servidor remoto ns.elhacker.net en la raíz / con el nombre home.tar.gz

tar cvzf - /home | ssh el-brujo@ns.elhacker.net "cat > /home/el-brujo/home.tar.gz"

Otro ejemplo:

tar cvzf - dir/ | ssh user@host "dd of=/backup/dir.tar.gz"

 También puedes restaurar el comprimido remotamente:

ssh el-brujo@ns.elhacker.net "cat /backup/home.tar.gz" | tar zxvf - 

En próximas entradas veremos el funcionamiento de rsync, sftp, winscp, Tartarus.

rsync -e ssh -avpz directorio_local el-brujo@ns2.elhacker.net:directorio_destino

Listado comandos para GNU/Linux

 

•  Herramientas que todo SysAdmin debería conocer

 

Comandos para comprimir y descomprimir ficheros en Linux

Archivos tar

• Empaquetar: tar -cvf archivo.tar /dir/a/comprimir/
• Desempaquetar: tar -xvf archivo.tar
• Ver contenido tar -tf archivo.tar

Archivos gz

• Comprimir: gzip -9 fichero
• Descomprimir: gzip -d fichero.gz

Archivos bz2

• Comprimir: bzip fichero
• Descomprimir: bzip2 -d fichero.bz2

Archivos zip

• Comprimir: zip archivo.zip ficheros
• Descomprimir: unzip archivo.zip
• Ver contenido: unzip -v archivo.zip

Archivos lha

• Comprimir: lha -a archivo.lha ficheros
• Descomprimir: lha -x archivo.lha
• Ver contenido: lha -v archivo.lha
• Ver contenido: lha -l archivo.lha

Archivos arj

• Comprimir: arj a archivo.arj ficheros
• Descomprimir: unarj archivo.arj
• Descomprimir: arj -x archivo.arj
• Ver contenido: arj -v archivo.arj
• Ver contenido: arj -l archivo.arj

Archivos zoo

• Comprimir: zoo a archivo.zoo ficheros
• Descomprimir: zoo -x archivo.zoo
• Ver contenido: zoo -L archivo.zoo
• Ver contenido: zoo -v archivo.zoo

Archivos rar

• Comprimir: rar -a archivo.rar ficheros
• Descomprimir: rar -x archivo.rar
• Ver contenido: rar -l archivo.rar
• Ver contenido: rar -v archivo.rar

También podemos crear una entrada en el fichero .bashrc para descomprimir automáticamente:

# .bashrc
# User specific aliases and functions

extract () {
   if [ -f $1 ] ; then
       case $1 in
    *.tar.bz2)    tar xvjf $1 && cd $(basename "$1" .tar.bz2) ;;
    *.tar.gz)    tar xvzf $1 && cd $(basename "$1" .tar.gz) ;;
    *.tar.xz)    tar Jxvf $1 && cd $(basename "$1" .tar.xz) ;;
    *.bz2)        bunzip2 $1 && cd $(basename "$1" /bz2) ;;
    *.rar)        unrar x $1 && cd $(basename "$1" .rar) ;;
    *.gz)        gunzip $1 && cd $(basename "$1" .gz) ;;
    *.tar)        tar xvf $1 && cd $(basename "$1" .tar) ;;
    *.tbz2)        tar xvjf $1 && cd $(basename "$1" .tbz2) ;;
    *.tgz)        tar xvzf $1 && cd $(basename "$1" .tgz) ;;
    *.zip)        unzip $1 && cd $(basename "$1" .zip) ;;
    *.Z)        uncompress $1 && cd $(basename "$1" .Z) ;;
    *.7z)        7z x $1 && cd $(basename "$1" .7z) ;;
    *)        echo "don't know how to extract '$1'..." ;;
       esac
   else
       echo "'$1' is not a valid file!"
   fi
 }

Ahora sólo tendremos que escribir:

 extract fichero_comprimido.extension

Y automáticamente descomprimirará el fichero sea el formato que sea.