¿Cómo configuro SSH para no tener que escribir mi contraseña?

Generar una clave SSH (si no tienes una)

Si usas GNOME, la aplicación seahorse (“Passwords and Encryption Keys”) puede hacerlo por ti: File -> New -> Secure Shell Key.

Si prefiere el terminal, ejecute ssh-keygen -t <type> para generar un par de claves. Los tipos de pares de claves válidos son:

• rsa: el predeterminado
• dsa: más o menos equivalente, excepto que está restringido a claves de 1024 bits
• ecdsa: la misma seguridad con claves más pequeñas, pero relativamente nuevo y algo raro en el software SSH.
• ed25519: Alta seguridad (más resistente a los ataques de canal lateral y generadores de números aleatorios débiles). Generación de firma muy rápida. Muy nuevo. Sólo disponible en OpenSSH >= 6.5 .

El programa le pedirá una passphrase y una ubicación donde guardar la nueva clave. Se recomienda utilizar la ruta por defecto sugerida porque todas las demás herramientas la buscarán allí.

Cargar la clave pública en el servidor remoto

De nuevo, seahorse puede hacerlo por usted - en Mis claves personales, haga clic con el botón derecho del ratón en su clave SSH y elija Configurar clave para shell seguro.

O, ssh-copy-id -i ~/.ssh/id_rsa.pub remote-user@remote-host en la terminal.

O bien, de forma completamente manual paso a paso:

1. Crear un directorio (si no existe ya) llamado .ssh en el directorio principal del usuario remoto en el host remoto.
2. En ese directorio, cree un archivo llamado authorized_keys (si no existe ya).
3. En caso de que su umask remoto sea más liberal de lo habitual, haga que el archivo no sea escribible por el grupo: chmod go-w ~/.ssh ~/.ssh/authorized_keys.
4. Por último, copie de alguna manera (añada) el contenido de su clave pública local (~/.ssh/id_rsa.pub) en el archivo ~/.ssh/authorized_keys remoto.

Cargar la clave en el agente ssh

Si cargas tu clave privada en un agente ssh, éste mantendrá la clave descifrada en memoria. Queremos esto para evitar reintroducir la clave cada vez que nos conectamos a un servidor.

Primero, el agente debe ser iniciado o la ruta de un socket de comunicación lanzado debe ser cargado en una variable. Ejecutar ssh-agent en un terminal generará comandos para asignar y establecer las variables del agente. Estos comandos pueden guardarse en un archivo para utilizarlos en otro terminal. Alternativamente, uno podría ejecutar estos comandos y olvidarse de reutilizar el mismo agente en otra terminal. por ejemplo: eval $(ssh-agent).

Cargar la clave es una simple cuestión de ejecutar ssh-add y darle la frase de paso.

Si está usando GNOME, gnome-keyring-daemon normalmente proporciona la misma funcionalidad de agente SSH que ssh-agent, así que no debería necesitar iniciar nada. GNOME también cargará y desbloqueará automáticamente la clave al iniciar la sesión.

Acceder al servidor remoto sin contraseña

Si todo se ha hecho correctamente, usando ssh user@server no le pedirá una contraseña. Si algo está mal con el agente y no con la clave, se le pedirá que escriba la frase de paso para la clave, y no la contraseña para la cuenta de usuario.

Cualquier cosa que utilice ssh para comunicarse funcionará sin necesidad de introducir la contraseña de la cuenta de usuario cuando la clave correcta esté cargada en el agente. Programas como scp , sftp y rsync hacen uso de esto.

• *

Notas:

• Sólo necesitas una clave SSHv2, ya que SSHv1 es muy insegura y ahora no se utiliza.
• También sólo necesitas un tipo de clave - ya sea RSA o DSA es suficiente. (ed25519 y ECDSA son ambos recientes y, por tanto, no están soportados en todas partes).
• Todos estos pasos son los mismos para las claves RSA y DSA. Si utiliza DSA, utilice id_dsa en lugar de id_rsa, y ECDSA tendrá id_ecdsa.
  
• Los servidores OpenSSH anteriores a la versión 3.0 utilizaban authorized_keys2 - pero es realmente improbable que encuentres algo anterior a la versión 5.0 en uso.

• Estas instrucciones sólo se aplican a la versión 3.0 de OpenSSH y posteriores. lsh, ssh.com, y otros servidores SSH (Unix y no) no están incluidos en este tutorial.

Ejemplos:

• Copiar la clave pública a un host remoto:

• Guardar las variables del agente para reutilizarlas (ejemplo elaborado) ssh-agent \> ~/.ssh/cross-terminal-agent . ~/.ssh/cross-terminal-agent

No has especificado en qué Unix estás, a qué Unix te estás conectando, qué shell estás usando, qué variante de SSH estás usando, etc. Así que algo de esto podría necesitar ser ajustado ligeramente; esto está basado en versiones razonablemente recientes de OpenSSH, que se usa en muchas variantes de Unix.

Todo esto es de su sistema de escritorio local.

ssh-keygen

Asegúrese de usar el valor por defecto para el nombre clave. Le sugiero que haga una frase de paso en esa clave, de lo contrario es un problema de seguridad. “-t rsa” no sería una mala idea, pero probablemente no sea necesario.

ssh-copy-id username@server

Eso le pedirá la contraseña que usaría para entrar, y configura las claves autorizadas por usted. (no es necesario hacerlo a mano)

Luego, esto:

`ssh-agent`

o quizás esto:

exec ssh-agent sh

o:

exec ssh-agent bash

Eso iniciará un agente SSH que puede contener su clave. En muchas variantes modernas de Unix, si estás conectado gráficamente, esto ya habrá tenido lugar. La primera variante (con los palillos) pone un agente ssh en segundo plano y configura las variables de entorno para hablar con él. Las dos segundas hacen que el agente ejecute un shell por ti, de modo que cuando sales del shell, el agente sale.

Muchas variantes modernas de Unix ya tendrán un agente ejecutándose por ti, especialmente si te has conectado gráficamente. Puedes probar con “ps aux | grep ssh-agent” o “ps -ef | grep ssh-agent”; si ya hay algo ejecutándose, úsalo.

Luego, finalmente:

ssh-add

Le pedirá una frase de paso; déle la que le dio a ssh-keygen. También hay formas de hacer que pregunte gráficamente. Y puedes poner las cosas de ssh-agent y ssh-add en tus scripts de inicio de sesión (la configuración es diferente dependiendo del shell que utilices) para automatizar esto, pero algunas variantes de Unix (el actual Ubuntu Linux, por ejemplo) hacen la mayor parte de eso automáticamente, de modo que todo lo que realmente necesitas hacer es crear una clave y utilizar ssh-copy-id para configurarla en el host remoto.

Ahora, “ssh username@server” debería funcionar sin pedir ninguna autenticación. Detrás de las escenas, está usando una clave que el agente ssh tiene, y pidiendo al agente que haga los trucos mágicos de firma por él.

Es posible hacer esto en PuTTY en Windows también.

Una vez que tengas el par de claves públicas/privadas configurado (como muestran otras respuestas aquí) ejecuta PuttyGen. Allí, carga la clave privada existente que ya has configurado, y luego guárdala como una clave privada PuTTY (ppk).

Luego, en PuTTY, simplemente haga clic en la sesión guardada en la que desea iniciar sesión automáticamente y haga clic en Cargar. A partir de aquí, vaya a Connection -> Data en el panel izquierdo, y en “Auto-login username” escriba el nombre de usuario para ese servidor remoto:

Después vaya a Connection -> SSH -> Auth, y busque el ppk que hizo en PuttyGen:

Luego vuelva a la página de la sesión y guarde la sesión que cargó antes.

A partir de una pregunta muy similar en ServerFault , yo recomendaría usar ssh-copy-id , que hace todos los pasos relacionados con la configuración de las claves de autenticación por ti:

ssh-copy-id es un script que utiliza ssh para iniciar sesión en una máquina remota (presumiblemente utilizando una contraseña de acceso, por lo que la autenticación por contraseña debe estar habilitada, a menos que haya hecho un uso inteligente de múltiples identidades)

También cambia los permisos del home del usuario remoto, ~/. ssh, y ~/.ssh/authorized_keys para eliminar la posibilidad de escribir en el grupo (que de otra manera le impediría iniciar sesión, si el sshd remoto tiene StrictModes establecido en su configuración).

Si se da la opción -i entonces se utiliza el archivo de identidad (por defecto ~/.ssh/identity.pub), independientemente de si hay alguna clave en su ssh-agent.

Todo lo que necesita hacer es simplemente esto:

ssh-copy-id user@host

Escriba su contraseña una vez, ¡y ya está!

Aparte de todo lo que ya se ha dicho sobre cómo configurar las claves ssh, recomiendo Keychain como frontend de la consola ssh-agent que permite manejar una sola por proceso del sistema en vez de por login.

Sé que ya hay herramientas de GNOME y KDE que hacen lo mismo pero si eres del tipo consola junkie esto es genial (y se puede usar en la mayoría de los sistemas Unix).

Para usarlo, simplemente añada lo siguiente a su ~/.bashrc (similar para otros shells):

if type keychain >/dev/null 2>/dev/null; then
  keychain --nogui -q <all your SSH/PGP keys>
  [-f ~/.keychain/${HOSTNAME}-sh] && . ~/.keychain/${HOSTNAME}-sh
  [-f ~/.keychain/${HOSTNAME}-sh-gpg] && . ~/.keychain/${HOSTNAME}-sh-gpg
fi

Escribí este tutorial muy muy corto después de conseguir REALMENTE frustrado con tutoriales REALMENTE largos porque realmente es tan simple :)

test -f ~/.ssh/id_rsa.pub || ssh-keygen -t rsa #press enter twice if given prompts, then "ssh-add"

scp ~/.ssh/id_rsa.pub destID@destMachine:/tmp/ #type password

ssh destID@destMachine #type password

cat /tmp/id_rsa.pub >> ~/.ssh/authorized_keys

rm /tmp/id_rsa.pub

http://linuxproblem.org/art_9.html

Su objetivo

Quiere utilizar Linux y OpenSSH para automatizar sus tareas. Por lo tanto, necesitas un inicio de sesión automático desde el host A / usuario a al host B / usuario b. No quieres introducir ninguna contraseña, porque quieres llamar a ssh desde un dentro de un script de shell.

Putty tiene una opción -pw que te permite crear un acceso directo en el escritorio como este:

"C:\Program Files\PuTTY\putty.exe" -ssh user@192.168.2.2 -pw your_password

1. En el host de conexión, ejecute ssh-keygen. (Si te dice que tienes que especificar un tipo, haz ssh-keygen -t rsa.) Cuando te pida una ubicación de archivo, toma la predeterminada. Cuando te pida una frase de acceso, pulsa enter para no tener una frase de acceso.
2. cat ~/.ssh/id_rsa.pub (o lo que sea la ubicación de archivo por defecto en ssh-keygen, aunque tendrías que tener una instalación realmente antigua de ssh para que sea diferente); copia el resultado en tu portapapeles.
3. Inicie sesión normalmente en el host de destino como la cuenta a la que desea conectarse. 4. Edita el archivo ~/.ssh/authorized_keys (si ~/.ssh no existe, slogin a algún sitio; esta es la forma sencilla y fácil de conseguir que se cree con los permisos adecuados). Pega tu portapapeles (que contiene el id_rsa.pub del otro host) en este archivo.

Si quieres hacerlo todo en la terminal en Linux:

En el host

cd ~/.ssh/

ssh-keygen -t {rsa|dsa} -b {1024|2048|4096} -C “algún texto de comentario si quieres” -f id_ArbitraryName

_Los elementos en {} son opciones, usa rsa o dsa y elige el tamaño de bits (más grande). -C “algún texto de comentario si quieres” -f id_ArbitraryName

Los elementos en el {} son opciones, usa rsa o dsa y elige el tamaño de los bits (más grande es más seguro)

Luego necesitas añadir los permisos a los archivos authorized_keys y authorized_keys2.

cat id_ArbitraryName.pub |>> authorized_keys

cat id_AribtraryName.pub |>> authorized_keys2

Luego descargue el archivo id_AribtraryName a la caja desde la que quiere hacer ssh. Si la caja que se conecta está basada en unix, puede ser necesario un archivo de configuración (en putty, alguien más arriba lo cubrió).

En la caja de conexión

En su archivo de configuración - vim ~/.ssh/config

Host example.host.com # o el nombre de su computadora

Nombre de usuario

IdentityFile ~/.ssh/id_ArbitraryName

El archivo de configuración necesita permisos de 600. La carpeta SSh necesita 700.

Espero que esto ayude si te encuentras con el problema de la configuración que se omite mucho.