Comment puis-je configurer une connexion SSH sans mot de passe ?

Cette solution s'adresse spécifiquement aux utilisateurs qui utilisent Windows a ssh dans leurs machines distantes, y compris les images en nuage sur AWS Cloud y GCE Cloud

Avis de non-responsabilité

J'ai récemment utilisé cette solution pour accéder à distance à de nouvelles images vm déployées sur GCE.

Outils utilisés :

1. puttygen téléchargement de puttygen
2. winscp téléchargement de winscp

Étapes à réaliser :

1. Générer une paire de clés publiques/privées en utilisant puttygen.
2. Téléchargez la clé publique sur votre serveur dans le nuage ou à distance.

Comment le faire :

1. Générer une clé/paire ou utiliser une clé privée existante

Si vous possédez une clé privée :

Ouvrir puttygen appuyez sur le bouton de chargement et sélectionnez votre clé privée ( *.pem ).

Si vous ne possédez pas de clé privée :

• Ouvrir puttygen ,
• Sélectionnez le type de clé souhaité SSH2 DSA (vous pouvez utiliser RSA ou DSA) dans le champ Paramètres section. Il est important que vous laissiez le champ de la phrase de passe vide.
• Pulse generate et suivez les instructions pour générer une paire de clés (publique/privée).

(de la source 1, lien donné ci-dessous)

2. Créez un nouveau fichier 'authorized_keys' (avec l'extension notepad )

Copiez les données de votre clé publique depuis la section "Clé publique à coller dans le fichier authorized_keys d'OpenSSH" du générateur de clé PuTTY, et collez les données de la clé dans le fichier authorized_keys fichier.

Assurez-vous qu'il n'y a qu'une seule ligne de texte dans ce fichier.

3. Téléchargez la clé sur le serveur Linux

• Ouvrez WinSCP,
• Sélectionnez le protocole de fichier SFTP et connectez-vous avec vos informations d'identification ssh.
• En cas de succès, vous voyez la structure du répertoire personnel de votre machine distante.

Télécharger le fichier authorized_keys dans le répertoire personnel de la machine distante.

4. Définir les autorisations appropriées

Faire .ssh répertoire (s'il n'existe pas)

Copie authorized_keys pour .ssh répertoire.
(cela remplacera toute authorized_keys prenez note de ceci).

Si le fichier existe, ajoutez simplement le contenu de ce fichier au fichier existant.

Exécutez des commandes pour définir les autorisations :

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

Maintenant, vous serez en mesure de ssh à la machine distante sans avoir à saisir les informations d'identification à chaque fois.

Pour en savoir plus :

• Génération et téléchargement de clés SSH sous Windows

• Clés OpsenSSH certificats d'authentification PEM PUB CRT

Si vous créez une paire de clés publique/principale et que vous vous connectez à l'aide de notre clé publique nouvellement créée, vous n'aurez pas besoin de taper votre mot de passe. Selon la configuration de votre porte-clés et/ou de votre agent ssh, vous devrez peut-être protéger votre clé avec une phrase de passe.

Voici un exemple parmi tant d'autres Petit guide pratique pour vous. Il est d'une importance cruciale pour la sécurité de cette méthode que la clé privée générée reste privée ! Vous ne devez jamais la partager avec qui que ce soit ou en autoriser l'accès à quelque titre que ce soit.

Cette commande génère une clé raisonnablement forte dans ~/.ssh/ :

ssh-keygen -b 4096

Sur ~/.ssh/ vous trouverez votre clé publique comme id_rsa.pub . Son contenu doit être ajouté à vos serveurs authorized_keys en transportant le fichier par l'intermédiaire d'un support transportable (clé USB) ou en activant brièvement l'authentification par mot de passe sur le serveur, puis en utilisant la fonction ssh-copy-id ~/.ssh/id_rsa.pub username@server puis le désactiver à nouveau.

Si vous avez choisi de sécuriser votre clé avec une phrase de passe (dans la première étape), vous pouvez utiliser ssh-agent ou le trousseau Ubuntu pour sécuriser ce pharse localement afin que vous n'ayez pas à le taper tout le temps.

Pour faire quelques ajouts :

• Par défaut, le Mac n'a pas ssh-copy-id vous devrez l'installer vous-même :

  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

Pour en savoir plus, cliquez ici : https://github.com/beautifulcode/ssh-copy-id-for-OSX

• si vous avez fait une redirection de port, la commande devrait être comme ceci :

  ssh-copy-id "not-marco@127.0.0.1 -p 2222"

Notez que les guillemets sont nécessaires.

Connexion/copie à distance sans donner de mot de passe

Les applications ssh y scp pour la connexion à distance et la copie à distance, respectivement, vous permettent de communiquer avec un hôte distant sans donner de mot de passe. Pour cela, vous devez suivre une procédure d'authentification comme celle décrite ci-dessous. Par client, nous entendons la machine sur laquelle vous êtes assis et par serveur, nous entendons la machine sur laquelle vous voulez vous connecter sans donner de mot de passe. Les étapes de la procédure d'authentification sont les suivantes :

1. Exécutez ssh-keygen pour générer les clés privées et publiques, à moins que cela ne soit déjà fait sur votre machine. Celles-ci sont stockées dans des fichiers dans $HOME/.ssh .
2. Ajoute le contenu du fichier de la clé publique au fichier $HOME/.ssh/authorized_keys ou $HOME/.ssh/authorized_keys2 sur le serveur.

Il existe trois types différents de protocoles d'authentification. Vous spécifiez le type lorsque vous exécutez ssh-keygen :

1. SSH protocole version 1, RSA1 : Il s'agit du choix par défaut et il en résulte des fichiers d'identité (clé privée, devrait prendre chmod 0700 pour s'assurer que ce fichier n'est pas lisible par d'autres) et identité.pub (clé publique).
2. SSH protocole version 1, RSA : on l'obtient en exécutant ssh-keygen -t rsa et donne lieu à des dossiers id_rsa (clé privée) et id_rsa.pub (clé publique)
3. SSH protocole version 1, ASD : on l'obtient en exécutant ssh-keygen -t dsa et donne lieu à des dossiers id_dsa (clé privée) et id_dsa.pub (clé publique)

Lorsque vous exécutez ssh-keygen, vous pouvez vous fier aux réponses par défaut (ce qui implique que vous ne donnez pas de phrase de passe). Cela rend l'ensemble de la configuration simple, mais aussi peu sûre.

Vous pouvez spécifier le type de clés à utiliser par une option à ssh ; ssh -1 force l'utilisation de RSA1 (protocole version 1), alors que ssh -2 forces ssh pour essayer RSA ou ASD uniquement (protocole version 2). Dans les exemples ci-dessous, nous générons et installons RSA1 y ASD sur l'hôte distant afin de disposer d'une plus grande flexibilité. Vous pouvez créer un fichier de configuration dans votre .ssh avec la ligne

Protocol 1,2

Cela rend ssh essayer un RSA1 (protocole version 1) avant la connexion RSA/DSA (protocole version 2).

Utilisation de clés 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"

Utilisation des clés 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"

C'est tout ce que vous avez à faire si vous n'avez pas utilisé de phrase de passe lors de la génération des clés. Vous pouvez tester la connexion en exécutant ssh $remote et voir si vous pouvez vous connecter sans donner de mot de passe (il se peut que vous deviez utiliser -1 ou -2 comme options pour ssh ). La procédure peut, bien entendu, être répétée pour chaque machine à laquelle vous souhaitez vous connecter.

Si vous avez utilisé une phrase de passe, vous devrez exécuter le programme ssh-agent pour lancer un Shell spécial, suivi de ssh-add pour enregistrer votre clé/passphrase combinaison avec sshd . Consultez les pages de manuel de ces programmes pour plus d'informations.

Un script pour automatiser les connexions sans mot de passe : 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"

_{copié à partir de : <a href="http://folk.uio.no/hpl/scripting/doc/ssh-no-password.html" rel="nofollow">http://folk.uio.no/hpl/scripting/doc/ssh-no-password.html</a>}

J'aimerais ajouter une réponse pour ceux qui constatent qu'ils doivent entrer le mot de passe même s'ils ont lu toutes les réponses ici parce que vous avez mis IdentitiesOnly sur oui. Et cette réponse peut vous faire gagner beaucoup de temps dans la gestion de plusieurs clés, qu'il s'agisse de clés pour git ou pour le serveur.

Après avoir généré la clé et l'avoir copiée sur le serveur :

ssh-keygen  # change the file to /home/yourname/.ssh/something
ssh-copy-id -i ~/.ssh/something.pub lerner@192.168.20.160

J'ai trouvé que ça ne marchait pas.

Puis je suis allé vérifier le ~/.ssh/config sur le client, j'ai vu ça en bas :

Host *
IdentitiesOnly yes

Puis j'ajoute ceci au-dessus :

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

Je peux simplement me connecter en entrant ssh somename .

Vous pouvez alors ajouter plusieurs clés ssh en utilisant vos noms préférés, et il vous suffit d'ajouter les paramètres comme les quatre lignes ci-dessus au fichier de configuration.

Host est le nom que vous souhaitez saisir lorsque vous vous connecterez au serveur ultérieurement ; HostName est l'adresse IP du serveur ; User est le nom de l'utilisateur qui se connecte au serveur ; et identityfile est le fichier dans lequel vous stockez la clé que vous avez générée.