¿Cómo puedo configurar el inicio de sesión SSH sin contraseña?

Quiero poder iniciar sesión en un control remoto a través de ssh sin tener que ingresar la contraseña todo el tiempo.

• ¿Cómo lo configuro?
• ¿Se requiere un comando diferente para ejecutar una sesión sin contraseña?

Responder

Ejecute estos comandos:

ssh-keygen

Luego deberá copiar la nueva clave a su servidor :

ssh-copy-id user@host
## or if your server uses custom port no:
ssh-copy-id "user@host -p 1234"

Después de copiar la clave, ssh en la máquina como de costumbre:

ssh user@host

Ahora puede iniciar sesión sin ingresar una contraseña de la máquina en particular en la que ejecutó los comandos.

Ejemplo

not-marco@rinzwind-desktop:~$ ssh-keygen 
Generating public/private rsa key pair.
Enter file in which to save the key (/home/not-marco/.ssh/id_rsa): 
Created directory '/home/not-marco/.ssh'.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/not-marco/.ssh/id_rsa.
Your public key has been saved in /home/not-marco/.ssh/id_rsa.pub.
The key fingerprint is:
b1:25:04:21:1a:38:73:38:3c:e9:e4:5b:81:e9:ac:0f not-marco@rinzwind-desktop
The key's randomart image is:
+--[ RSA 2048]----+
|.o= . oo.        |
|*B.+ . .         |
|*=o .   o .      |
| = .     =       |
|. o     S        |
|E.               |
| o               |
|  .              |
|                 |
+-----------------+

not-marco@rinzwind-desktop:~$ ssh-copy-id not-marco@server
not-marco@server's password: 
Now try logging into the machine, with "ssh 'not-marco@server'", and check in:

  ~/.ssh/authorized_keys

to make sure we haven't added extra keys that you weren't expecting.

Explicación

Esto supone que ya puede conectarse con éxito a su servidor a través de SSH.

Deberá generar un par de claves SSH que le permitirá identificarse como usted mismo sin usar una contraseña. Puede optar por proteger las claves con un código de acceso si lo desea, pero esto puede dejarse en blanco para permitir un acceso SSH totalmente sin contraseña.

1. En primer lugar crear el par de claves SSH mediante la ejecución de ssh-keygeneste creará una id_rsay id_rsa.pubarchivo. El pubarchivo es lo que va en los servidores, la clave privada ( id_rsa) es lo que permanece con usted y es cómo se identifica.
2. Luego copie la clave pública en su servidor ssh-copy-id user@serverreemplazando el usuario con su usuario remoto y el servidor con el nombre DNS o la dirección IP de la máquina. Le pedirá su contraseña SSH, ingrésela y, si todo se completa con éxito, podrá acceder a la máquina ssh user@serversin necesidad de una contraseña.

Referencias

• https://help.ubuntu.com/community/SSH/OpenSSH/Keys

Escriba los siguientes comandos:

1. ssh-keygen

   Presione la Entertecla hasta que aparezca el mensaje

2. ssh-copy-id -i root@ip_address

   (Una vez pedirá la contraseña del sistema host)

3. ssh root@ip_address

Ahora debería poder iniciar sesión sin ninguna contraseña.

La forma en que suelo hacer esto es la siguiente:

ssh-keygen -t rsa

(Cuando se le solicite una contraseña, déjela en blanco)

Entonces: cat ~/.ssh/id_rsa.pub | ssh username@hostname 'cat >> .ssh/authorized_keys'

(Esto requiere que la carpeta .ssh esté en el directorio de inicio en el nombre de host de destino, con el archivo autorizado_claves)

Por supuesto, reemplace el nombre de usuario con el nombre de usuario deseado y el nombre de host con el nombre de host o la dirección IP deseados

Después de eso, solo SSH a esa caja como estás acostumbrado.

Normalmente lo uso sshpasspara eso, lo instalo sudo apt-get install sshpassy lo uso así

sshpass -p 'password' ssh your_username@your_server

Deshabilitar autenticación de contraseña

Debido a que muchas personas con servidores SSH usan contraseñas débiles, muchos atacantes en línea buscarán un servidor SSH y luego comenzarán a adivinar las contraseñas al azar. Un atacante puede probar miles de contraseñas en una hora y adivinar incluso la contraseña más segura con suficiente tiempo. La solución recomendada es usar claves SSH en lugar de contraseñas. Para ser tan difícil de adivinar como una clave SSH normal, una contraseña debería contener 634 letras y números aleatorios. Si siempre podrá iniciar sesión en su computadora con una clave SSH, debe desactivar la autenticación de contraseña por completo.

Si deshabilita la autenticación con contraseña, solo será posible conectarse desde computadoras que haya aprobado específicamente. Esto mejora enormemente su seguridad, pero hace que sea imposible que se conecte a su propia computadora desde la PC de un amigo sin la aprobación previa de la PC, o desde su propia computadora portátil cuando borra accidentalmente su clave.

Se recomienda deshabilitar la autenticación de contraseña a menos que tenga una razón específica para no hacerlo.

Para deshabilitar la autenticación de contraseña, busque la siguiente línea en su archivo sshd_config:

#PasswordAuthentication yes

reemplácelo con una línea que se vea así:

PasswordAuthentication no

Una vez que haya guardado el archivo y reiniciado su servidor SSH, ni siquiera se le pedirá una contraseña cuando inicie sesión.

https://help.ubuntu.com/community/SSH/OpenSSH/Configuring#disable-password-authentication

Esta solución es específicamente para los usuarios que utilizan de Windows a ssh en sus máquinas remotas, incluyendo imágenes de la nube en nube de AWS y la nube CME

Descargo de responsabilidad

Recientemente usé esta solución para el inicio de sesión remoto de nuevas imágenes vm implementadas en GCE.

Herramientas utilizadas:

1. puttygen descarga de puttygen
2. winscp descarga de winscp

Pasos a realizar:

1. Genere pares de claves públicas / privadas usando puttygen.
2. Suba la clave pública a su servidor en la nube o en una ubicación remota.

Cómo hacerlo:

1. Genere una clave / par o use la clave privada existente

Si posee una clave privada:

Abra puttygen, presione el botón de carga y seleccione su *.pemarchivo de clave privada ( ).

Si no posee una clave privada:

• Abierto puttygen,
• Seleccione el tipo de clave deseado SSH2 DSA (puede usar RSA o DSA) dentro de la sección Parámetros . Es importante que deje el campo de frase de contraseña en blanco.
• Presione generatey siga las instrucciones para generar un par de claves (públicas / privadas).

(de la fuente 1, enlace a continuación)

2. Cree un nuevo archivo 'autorizado_keys' (con notepad)

Copie sus datos de clave pública de la sección "Clave pública para pegar en el archivo OpenSSH Authorized Keys" del generador de claves PuTTY y pegue los datos clave en el authorized_keysarchivo.

Asegúrese de que solo haya una línea de texto en este archivo.

3. Subir clave al servidor Linux

• Abra WinSCP
• Seleccione el protocolo de archivo SFTP e inicie sesión con sus credenciales ssh.
• Si tiene éxito, verá la estructura del directorio de inicio en su máquina remota.

Cargue el archivo authorised_keys al directorio de inicio en la máquina remota.

4. Establecer permisos adecuados

Crear .sshdirectorio (si no existe)

Copiar authorized_keysarchivo al .sshdirectorio.
(esto reemplazará cualquier authorized_keysarchivo existente , tome nota de esto).

Si el archivo existiera, simplemente agregue el contenido de este archivo al archivo existente.

Ejecute comandos para establecer permisos:

sudo chmod 700 .ssh && chmod 600 .ssh/authorized_keys

Ahora podrá sshingresar a la máquina remota sin ingresar credenciales cada vez.

Otras lecturas:

• Generando y cargando claves SSH en Windows

• OpsenSSH claves certificados autenticación PEM PUB CRT

Si crea un par de claves público / privado e inicia sesión con nuestra clave pública recién creada, no necesitará escribir su contraseña. Dependiendo de la configuración de su llavero y / o agente ssh, es posible que necesite proteger su clave con una frase de contraseña.

Aquí hay uno de los muchos pasos cortos para usted. ¡Es de crucial importancia para la seguridad de este método, que la clave privada generada siga siendo privada! Nunca debe compartirlo con nadie ni permitir el acceso a él de ninguna manera.

Este comando genera una clave razonablemente fuerte en ~/.ssh/:

ssh-keygen -b 4096

En ~/.ssh/encontrará su clave pública como id_rsa.pub. Su contenido debe agregarse al authorized_keysarchivo de su servidor transportándolo a través de un medio transportable (pen drive) o habilitando brevemente la autenticación de contraseña en el servidor, luego usándolo ssh-copy-id ~/.ssh/id_rsa.pub username@servery luego deshabilitándolo nuevamente.

Si elige proteger su clave con una frase de contraseña (en el primer paso), puede usar ssh-agento el llavero de Ubuntu para proteger ese farase localmente para que no tenga que escribirlo todo el tiempo.

Para hacer algunas adiciones:

• Mac por defecto no tiene ssh-copy-id, tendrás que instalarlo tú mismo:

  curl https://raw.github.com/beautifulcode/ssh-copy-id-for-OSX/master/ssh-copy-id.sh -o /usr/local/bin/ssh-copy-id
  chmod +x /usr/local/bin/ssh-copy-id
  

encuentre más aquí: https://github.com/beautifulcode/ssh-copy-id-for-OSX

• Si ha realizado un reenvío de puertos, el comando debería ser así:

  ssh-copy-id "[email protected] -p 2222"
  

Tenga en cuenta que las citas son necesarias.

Inicio de sesión remoto / copia sin dar una contraseña

Las aplicaciones sshy scppara el inicio de sesión remoto y la copia remota, respectivamente, le permiten comunicarse con un host remoto sin dar una contraseña. Esto requiere que siga un procedimiento de autenticación como el que se describe a continuación. Por cliente nos referimos a la máquina en la que está sentado y por servidor nos referimos a la máquina en la que desea iniciar sesión sin proporcionar una contraseña. Los pasos del procedimiento de autenticación son:

1. Ejecute ssh-keygen para generar claves privadas y públicas, a menos que esto ya se haya hecho en su máquina. Estos se almacenan en archivos en $HOME/.ssh.
2. Agregue el contenido del archivo de clave pública al archivo $HOME/.ssh/authorized_keyso $HOME/.ssh/authorized_keys2en el servidor.

Hay tres tipos diferentes de protocolos de autenticación. Usted especifica el tipo cuando ejecuta ssh-keygen:

1. Protocolo SSH versión 1, RSA1: esta es la opción predeterminada y da como resultado la identidad de los archivos (clave privada, debe chmod 0700asegurarse de que este archivo no sea legible para otros) e identity.pub (clave pública).
2. Protocolo SSH versión 1, RSA : esto se obtiene ejecutando ssh-keygen -t rsay da como resultado archivos id_rsa(clave privada) y id_rsa.pub(clave pública)
3. Protocolo SSH versión 1, DSA : esto se obtiene ejecutando ssh-keygen -t dsay da como resultado archivos id_dsa(clave privada) y id_dsa.pub(clave pública)

Al ejecutar ssh-keygen puede confiar en las respuestas predeterminadas (lo que implica que no da una frase de contraseña). Esto hace que toda la configuración sea simple, pero también insegura.

Puede especificar el tipo de claves que utilizará una opción para ssh ; ssh -1fuerza el uso de claves RSA1 (versión 1 del protocolo), mientras que ssh -2obliga a ssh a probar solo claves RSA o DSA (versión 2 del protocolo). En los ejemplos a continuación, generamos e instalamos claves RSA1 y DSA en el host remoto para que tenga más flexibilidad. Puede hacer un archivo de configuración en su .sshdirectorio con la línea

Protocol 1,2

Esto hace que ssh intente una conexión RSA1 (protocolo versión 1) antes de RSA / DSA (protocolo versión 2).

Usando claves RSA1

remote=user@remotehost   # fill in correct user and remotehost names
cd $HOME/.ssh
# create .ssh on remote host if it is non-existing:
ssh $remote 'if [ ! -d .ssh ]; then mkdir .ssh; fi' 
# copy RSA1 key: 
scp identity.pub ${remote}:.ssh
ssh $remote "cd .ssh; cat identity.pub >> authorized_keys"

Usar claves DSA

remote=user@remotehost   # fill in correct user and remotehost names
cd $HOME/.ssh
# create .ssh on remote host if it is non-existing:
ssh $remote 'if [ ! -d .ssh ]; then mkdir .ssh; fi' 
# copy DSA key: 
scp id_dsa.pub ${remote}:.ssh
ssh $remote "cd .ssh; cat id_dsa.pub >> authorized_keys2"

Esto es todo lo que tiene que hacer si no utilizó una frase de contraseña al generar las claves. Puede probar la conexión ejecutando ssh $ remote y ver si puede iniciar sesión sin dar una contraseña (es posible que necesite usar -1o -2como opciones para ssh ). El procedimiento puede, por supuesto, repetirse para cualquier máquina en la que desee iniciar sesión.

Si utilizó una frase de contraseña, deberá ejecutar el programa ssh-agentpara iniciar un shell especial, seguido de ssh-addpara registrar su combinación de clave / frase de contraseñasshd . Consulte las páginas de manual de estos programas para obtener más información.

Un script para automatizar conexiones sin contraseña: ssh-no-password.sh

#!/bin/sh

# create ssh connections without giving a password

if [ $# -lt 1 ]; then
  echo Usage: $0 username@remotehost
  exit
fi
remote="$1"  # 1st command-line argument is the user@remotehost address
this=$HOST   # name of client host

# first check if we need to run ssh-keygen for generating
# $HOME/.ssh with public and private keys:
if [ ! -d $HOME/.ssh ]; then
  echo "just type RETURN for each question:" # no passphrase - unsecure!!
  # generate RSA1, RSA and DSA keys:
  echo; echo; echo
  ssh-keygen
  echo; echo; echo
  ssh-keygen -t rsa
  echo; echo; echo
  ssh-keygen -t dsa
else
  # we have $HOME/.ssh, but check that we have all types of
  # keys (RSA1, RSA, DSA):
  if [ ! -f $HOME/.ssh/identity ]; then
     # generate RSA1 keys:
     echo "just type RETURN for each question:" # no passphrase - unsecure!!
     ssh-keygen
  fi
  if [ ! -f $HOME/.ssh/id_rsa ]; then
     # generate RSA keys:
     echo "just type RETURN for each question:" # no passphrase - unsecure!!
     ssh-keygen -t rsa
  fi
  if [ ! -f $HOME/.ssh/id_rsa ]; then
     # generate DSA keys:
     echo "just type RETURN for each question:" # no passphrase - unsecure!!
     ssh-keygen -t dsa
  fi
fi


cd $HOME/.ssh

if [ ! -f config ]; then
  # make ssh try ssh -1 (RSA1 keys) first and then ssh -2 (DSA keys)
  echo "Protocol 1,2" > config
fi

# copy public keys (all three types) to the destination host:

echo; echo; echo
# create .ssh on remote host if it's not there:
ssh $remote 'if [ ! -d .ssh ]; then mkdir .ssh; fi' 
# copy RSA1 key: 
scp identity.pub ${remote}:.ssh/${this}_rsa1.pub
# copy RSA key:
#scp id_rsa.pub ${remote}:.ssh/${this}_rsa.pub
# copy DSA key:
scp id_dsa.pub ${remote}:.ssh/${this}_dsa.pub
# make authorized_keys(2) files on remote host:

echo; echo; echo
# this one copies all three keys:
#ssh $remote "cd .ssh; touch authorized_keys authorized_keys2; cat ${this}_rsa1.pub >> authorized_keys; cat ${this}_rsa.pub >> authorized_keys2; cat ${this}_dsa.pub >> authorized_keys2;"
# this one copies RSA1 and DSA keys:
ssh $remote "cd .ssh; touch authorized_keys authorized_keys2; cat ${this}_rsa1.pub >> authorized_keys; cat ${this}_dsa.pub >> authorized_keys2;"

echo; echo; echo
echo "try an ssh $remote"

_{copiado de: http://folk.uio.no/hpl/scripting/doc/ssh-no-password.html}

Me gustaría agregar una respuesta para aquellos que puedan encontrar que deben ingresar la contraseña, incluso si han leído todas las respuestas aquí porque ha establecido IdentitiesOnly como sí. Y la respuesta aquí puede ahorrarle mucho tiempo para administrar múltiples claves, siendo claves para git o servidor.

Después de haber generado la clave y copiarla en el servidor:

ssh-keygen  # change the file to /home/yourname/.ssh/something
ssh-copy-id -i ~/.ssh/something.pub [email protected]

Descubrí que no funcionaba.

Luego fui a revisar el ~/.ssh/configarchivo en el cliente, vi esto en la parte inferior:

Host *
IdentitiesOnly yes

Luego agrego esto arriba:

Host somename
HostName 192.168.20.160
User lerner
IdentityFile ~/.ssh/something

Solo puedo iniciar sesión ingresando ssh somename.

Luego puede agregar múltiples claves ssh usando sus nombres favoritos, y solo necesita agregar la configuración como las cuatro líneas anteriores al archivo de configuración.

Host es el nombre que le gustaría ingresar cuando conecte el servidor más tarde; HostName es la ip del servidor; Usuario es el nombre de usuario que inicia sesión en el servidor; y el archivo de identidad es el archivo donde almacena la clave que ha generado.