¿Cómo editar conocido_hosts cuando varios hosts comparten el mismo nombre de IP y DNS?

Regularmente ssh en una computadora que es una computadora OS X / Linux de arranque dual. Las dos instancias del sistema operativo no comparten la misma clave de host, por lo que pueden verse como dos hosts que comparten la misma IP y DNS. Digamos que la IP es 192.168.0.9, y los nombres son hostnameyhostname.domainname

Según tengo entendido, la solución para poder conectarse a los dos hosts es agregarlos al ~/.ssh/know_hostsarchivo. Sin embargo, es más fácil decirlo que hacerlo, ya que el archivo es ordenado, y tiene probablemente varias entradas por host ( 192.168.0.9, hostname, hostname.domainname). Como consecuencia, tengo la siguiente advertencia

Warning: the ECDSA host key for 'hostname' differs from the key for the IP address '192.168.0.9'

¿Hay una manera fácil de editar el known_hostsarchivo, manteniendo los hash? Por ejemplo, ¿cómo puedo encontrar las líneas correspondientes a un hostame dado? ¿Cómo puedo generar los hashes para algunos hosts conocidos?

La solución ideal me permitiría conectarme sin problemas a esta computadora con ssh, sin importar si lo llamo o no 192.168.0.9, hostnameo hostname.domainnamesi usa su clave de host Linux o su clave de host OSX. Sin embargo, todavía quiero recibir una advertencia si hay un verdadero ataque de hombre en el medio, es decir , si se usa una clave diferente a estas dos.

La solución más sencilla aquí es usar las mismas claves de host para Linux y OS X. Es decir, elegir un conjunto de /etc/ssh/ssh_host_*_key*archivos y copiarlos al otro sistema operativo. Luego, la misma clave de host se presentará a un cliente SSH independientemente del sistema operativo en el que haya arrancado, y el cliente SSH no será más sabio.

Como @Izzy sugirió en un comentario anterior, ssh te dice la línea ofensiva, y al eliminar esa línea, (guardarla en otro lugar), aceptar la nueva clave y luego copiar la línea eliminada, terminas con dos claves para la misma host, y ssh aceptará cualquiera de los dos.

(También puede usar ssh-keygen -H -F <hostname>para buscar líneas en su archivo conocido_hosts que coincidan con ese nombre de host. Ejecutar esto después de copiar la línea eliminada de nuevo debería enumerar dos entradas).

Si alguien sabe cómo hacer que PuTTY haga lo mismo, me interesaría saberlo.

Encontré esto que puede ayudarte con lo que quieres lograr.

Fuente: /programming/733753/how-to-handle-ssh-host-key-verification-with-2-different-hosts-on-the-same-but

Cree un archivo de configuración en su directorio .ssh de la siguiente manera:

Host server1
  Hostname x1.example.com
  HostKeyAlias server1
  CheckHostIP no
  Port 22001
  User karl

Host server2
  Hostname x2.example.com
  HostKeyAlias server2
  CheckHostIP no
  Port 22002
  User karl

Explicación a continuación (de man ssh_config)

CheckHostIP

Si este indicador se establece en "yes", ssh (1) verificará adicionalmente la dirección IP del host en el archivo known_hosts. Esto permite que ssh detecte si una clave de host cambió debido a la falsificación de DNS. Si la opción se establece en "no", la verificación no se ejecutará. El valor predeterminado es "sí".

HostKeyAlias

Especifica un alias que debe usarse en lugar del nombre de host real al buscar o guardar la clave de host en los archivos de la base de datos de claves de host. Esta opción es útil para tunelizar conexiones SSH o para múltiples servidores que se ejecutan en un solo host.

La línea de nombre de usuario y puerto evita que tenga que dar esas opciones en la línea de comando, por lo que puede usar:

% ssh server1
% ssh server2

La forma más fácil de resolver su problema es dar a cada host una dirección IP propia / distinta. Con 253 direcciones disponibles en su red (privada) e IPv4, eso no debería ser gran cosa. Déles direcciones IP fijas (ya que un servidor DHCP identificaría la máquina en función de la dirección MAC de las tarjetas de red, y ambas obtendrían la misma dirección). No veo ninguna otra solución si desea mantener las medidas de seguridad (que tampoco descartaría por esa pequeña "comodidad").

No me encuentro con ese problema cuando me conecto a varias cajas VPS que comparten la misma IP porque cada una tiene un puerto SSH diferente (20022,30022, etc.) por lo que están registradas como hosts conocidos con diferentes claves.

¿Podría ser una solución para usted?

Otro artículo , que describe varias formas de manejar su problema:

El segundo método usa dos parámetros openSSH: StrictHostKeyCheckiny UserKnownHostsFile. Este método engaña a SSH configurándolo para usar un archivo empty_hosts vacío y NO para pedirle que confirme la clave de identidad del host remoto.

Como desea mantener la estricta comprobación de la clave del host, quisiera que usaran diferentes known_hostsarchivos. Para hacer esto, configure su ~/.ssh/configarchivo (o el /etc/ssh/ssh_configarchivo si necesita que funcione en múltiples cuentas de usuarios locales) de esta manera:

Host myserver.osx
  UserKnownHostsFile ~/.ssh/known_hosts.dual.osx
  # default is ~/.ssh/known_hosts
  Hostname $REALHOSTNAME

Host myserver.linux
  UserKnownHostsFile ~/.ssh/known_hosts.dual.linux
  Hostname $REALHOSTNAME

, reemplazando $REALHOSTNAMEcon el nombre de host real o la dirección IP, por supuesto. (No importa cuál elija, siempre y cuando elija algo después del "Nombre de host" que resolvería en la dirección IP, pero usaría el nombre de host en lugar de una dirección IP, solo por principios generales).

Entonces, ssh myserver.linuxy por ssh myserver.osxlo tanto, puede tener diferentes claves de host, pero aún así obtiene la comprobación. Si Linux está activo y escribe OS X (o viceversa), recibirá la advertencia (que creo que es el efecto deseado).

Si tuviera este problema, me aseguraría de que hubiera algo completamente incorrecto en el known_hostsarchivo principal que no coincida con ninguno de los dos, de modo que si escribe en $REALHOSTNAMElugar de myserver.osxrecibir la advertencia. :-) Lo haría poniendo algo como

<ip-address-of-github.com> $REALHOSTNAME

en mi /etc/hosts, luego haciendo una ssh $REALHOSTNAMEy aceptando la nueva clave, luego sacando esa entrada.