SSH de A à C en passant par B, en utilisant la clé privée de B

Vérifiez si le suivi fonctionne.

ssh -t B ssh C

Utilisez la commande suivante si vous voulez utiliser la clé stockée sur B.

ssh -t B ssh -i /path/to/identity_on_B C

Ici, nous spécifions la commande, c'est-à-dire ssh -i /path/to/identity_on_B C à exécuter sur B au lieu d'un Shell de connexion.

J'ai résolu le problème maintenant. Voici la solution, qui est assez simple. J'aurais dû la voir plus tôt :

~/.ssh/config :

Host B
  HostName 1.2.3.4
  User myuser
  IdentityFile ~/.ssh/rsa_key
  ControlMaster auto
  ControlPath ~/.ssh/socket/master-%l-%r@%h:%p

Host C.*
  User customer_username
  Port customer_port
  IdentityFile remote/path/to/ssh/key
  ForwardAgent yes
  ProxyCommand ssh accessable.server nc %h %p

Host C.server-1
  HostName 2.3.4.5

B' est le serveur Proxy par lequel vous passez. Il doit être configuré comme vous le feriez normalement pour l'accès à un serveur.

'C' est l'hôte de destination. Il doit être configuré pour utiliser 'B' dans le processus de connexion. Le fichier d'identité dans 'C' est le chemin vers la clé ssh sur 'B'. La ProxyCommand utilise Netcat pour ouvrir la connexion à 'C' depuis 'B'. Netcat, ou nc, devra être installé sur 'B'.

NOTE1 : Pour que cela fonctionne, vous devez copier le fichier d'identité de B (habituellement ~/.ssh/rd_isa) vers A. Je change habituellement son nom en rd_isa_B.

NOTE2 : Cette solution fonctionne également pour scp.

J'espère que cela aidera d'autres personnes.

La réponse de Snowball a beaucoup aidé. Cependant, j'ai apporté quelques modifications à la commande et je voulais expliquer comment elle fonctionne. Étant donné cette situation :

    ssh        ssh
A -------> B -------> C
     ^          ^
  using A's  using B's
  ssh key    ssh key

Modifiez votre ~/.ssh/config et ajoutez l'hôte B à travers lequel vous voulez sauter, tout comme vous configureriez normalement un hôte :

Host B
 User myusername
 HostName b.mycompany.com

Ensuite, vous ajoutez l'hôte C sur lequel vous voulez vous retrouver :

Host C
 User myusername
 HostName c.intranet.mycompany.com
 ProxyCommand ssh -T -q -o 'ForwardAgent yes' B 'ssh-add -t 1 && nc %h %p'

Notez le ProxyCommand où :

• ssh -T -q indique qu'il ne doit pas allouer un pseudo-TTY ( -T ) et se taire ( -q ) ;
• une fois sur l'hôte de saut B nous ajoutons la clé aux clés SSH de A par le biais de ssh-add ;
• ce qui ne fonctionne que parce que nous avons fait suivre l'agent SSH en utilisant -o 'ForwardAgent yes' .
• ssh-add -t 1 indique que je veux que la clé ne soit ajoutée que pendant la 1 seconde nécessaire à l'authentification auprès de l'hôte final C ;
• et enfin, nc %h %p initie un netcat connexion à l'hôte final %h au port %p (ces deux champs seront remplis par SSH sur la base des informations contenues dans le formulaire ~/.ssh/config ).

Si vous devez spécifier une clé personnalisée sur B à utiliser, vous pouvez le faire en modifiant l'option ssh-add partie :

Host C
 User myusername
 HostName c.intranet.mycompany.com
 ProxyCommand ssh -T -q -o 'ForwardAgent yes' B 'ssh-add -t 1 ~/.ssh/mykey && nc %h %p'

J'ai écrit un simple script pour essentiellement répertorier mes clés ssh sur l'instance distante, puis ajouter celle que j'ai sélectionnée à mon agent ssh local. Ce n'est pas très propre, mais cela me permet de conserver toutes les clés sur un emplacement distant plutôt que localement.

Voici le script si quelqu'un est intéressé :

#!/usr/bin/ruby

require "rubygems"
require "fileutils"

# Get key list
key_list = (`ssh jumpbox "cd ~/.ssh/ ; ls id_rsa*" | sed 's/id_rsa_/  /g' | sed     's/id_rsa//g'`)
puts ' '
puts 'Available customer keys:'
puts key_list

# Get customer name input
puts ' '
puts 'Enter customer name: '
customer_name = gets.chomp

# Add key to ssh-agent
key_name = "~/.ssh/id_rsa_#{customer_name}"
puts ' '
puts "Adding #{key_name} to local ssh-agent"
`ssh jumpbox "ssh-add ~/.ssh/id_rsa_#{customer_name}"`
exit 0