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

Je veux pouvoir me connecter à une télécommande via ssh sans avoir à entrer le mot de passe tout le temps.

• Comment puis-je le configurer?
• Une commande différente est-elle requise pour exécuter une session sans mot de passe?

Répondre

Exécutez cette commande:

ssh-keygen

Ensuite, vous devrez copier la nouvelle clé sur votre serveur :

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

Une fois la clé copiée, ssh dans la machine normalement:

ssh user@host

Vous pouvez maintenant vous connecter sans saisir de mot de passe de la machine sur laquelle vous avez exécuté les commandes.

Exemple

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.

Explication

Cela suppose que vous puissiez déjà vous connecter à votre serveur via SSH.

Vous devrez générer une paire de clés SSH qui vous permettra de vous identifier sans utiliser de mot de passe. Vous pouvez choisir de protéger les clés avec un mot de passe si vous le souhaitez, mais vous pouvez laisser ce champ vide pour permettre un accès SSH sans mot de passe.

1. Tout d' abord créer votre clés SSH en exécutant ssh-keygencela va créer un id_rsaet id_rsa.pubfichier. Le pubfichier est ce qui se passe sur les serveurs, la clé privée ( id_rsa) est ce qui vous reste et est la façon dont vous vous identifiez.
2. Copiez ensuite la clé publique sur votre serveur en ssh-copy-id user@serverremplaçant l'utilisateur par votre utilisateur distant et par le serveur par le nom DNS ou l'adresse IP de la machine. Il vous demandera votre mot de passe SSH, entrez-le et si tout est terminé, vous pourrez accéder à la machine ssh user@serversans avoir besoin d'un mot de passe.

Références

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

Tapez les commandes suivantes:

1. ssh-keygen

   Appuyez sur la Entertouche jusqu'à ce que vous obteniez l'invite

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

   (Il vous sera demandé une fois le mot de passe du système hôte)

3. ssh root@ip_address

Vous devriez maintenant pouvoir vous connecter sans mot de passe.

La façon dont je le fais habituellement est la suivante:

ssh-keygen -t rsa

(Lorsque vous êtes invité à entrer un mot de passe, laissez-le vide)

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

(Cela nécessite que le dossier .ssh soit dans le répertoire de base du nom d’hôte ciblé, avec le fichier authorised_keys)

Bien sûr, remplacez le nom d'utilisateur par le nom d'utilisateur souhaité, et le nom d'hôte par le nom d'hôte ou l'adresse IP souhaité.

Après cela, lancez simplement SSH dans cette boîte, comme vous en avez l'habitude.

Je l'utilise normalement sshpasspour ça, l'installer avec sudo apt-get install sshpasset l'utiliser comme ça

sshpass -p 'password' ssh your_username@your_server

Désactiver l'authentification par mot de passe

Comme beaucoup de personnes utilisant des serveurs SSH utilisent des mots de passe faibles, de nombreux attaquants en ligne vont rechercher un serveur SSH, puis commencent à deviner les mots de passe de manière aléatoire. Un attaquant peut essayer des milliers de mots de passe en une heure et deviner même le mot de passe le plus puissant donné. La solution recommandée consiste à utiliser des clés SSH au lieu de mots de passe. Pour être aussi difficile à deviner qu'une clé SSH normale, un mot de passe devrait contenir 634 lettres et chiffres aléatoires. Si vous pouvez toujours vous connecter à votre ordinateur avec une clé SSH, vous devez désactiver complètement l'authentification par mot de passe.

Si vous désactivez l'authentification par mot de passe, il ne sera possible de vous connecter qu'à partir d'ordinateurs spécifiquement approuvés. Cela améliore considérablement votre sécurité, mais vous empêche de vous connecter à votre propre ordinateur à partir du PC d'un ami sans préapprouver le PC, ou à partir de votre propre ordinateur portable lorsque vous supprimez accidentellement votre clé.

Il est recommandé de désactiver l'authentification par mot de passe sauf si vous avez une raison spécifique de ne pas le faire.

Pour désactiver l'authentification par mot de passe, recherchez la ligne suivante dans votre fichier sshd_config:

#PasswordAuthentication yes

remplacez-le par une ligne qui ressemble à ceci:

PasswordAuthentication no

Une fois que vous avez enregistré le fichier et redémarré votre serveur SSH, vous ne devriez même pas vous demander un mot de passe lorsque vous vous connectez.

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

Cette solution est spécialement pour les utilisateurs à l' aide de Windows pour ssh dans leurs machines distantes , y compris des images de nuages sur nuage AWS et GCE Nuage

Avertissement

Récemment utilisé cette solution pour la connexion à distance de nouvelles images VM déployées sur GCE.

Les outils utilisés:

1. puttygen puttygen télécharger
2. winscp winscp télécharger

Étapes à suivre:

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

Comment faire:

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

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

Ouvrez puttygen, appuyez sur le bouton Charger et sélectionnez votre *.pemfichier de clé privée ( ).

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

• Ouvert puttygen,
• Sélectionnez le type de clé SSH2 DSA souhaité (vous pouvez utiliser RSA ou DSA) dans la section Paramètres . Il est important de laisser le champ de phrase secrète vide.
• Appuyez sur generateet suivez les instructions pour générer une paire de clés (publique / privée).

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

2. Créez un nouveau fichier 'allowed_keys' (avec notepad)

Copiez vos données de clé publique à partir de la section "Clé publique pour le collage dans le fichier OpenSSH allowed_keys" du générateur de clé PuTTY, puis collez les données de clé dans le authorized_keysfichier.

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

3. Télécharger 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 de répertoires de base sur votre ordinateur distant.

Téléchargez le fichier allowed_keys dans le répertoire de base de la machine distante.

4. Définir les autorisations appropriées

Make .sshdirectory (si non existant)

Copier le authorized_keysfichier dans le .sshrépertoire.
(cela remplacera tout authorized_keysfichier existant , prenez-en note).

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

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

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

Vous pourrez maintenant entrer sshdans une machine distante sans entrer les informations d'identification à chaque fois.

Lectures complémentaires:

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

• Authentification par certificats de clés OpsenSSH 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'avez pas besoin de saisir 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 secrète.

Voici un des nombreux guides pratiques pour vous. Pour la sécurité de cette méthode, il est d’une importance cruciale que la clé privée générée reste privée! Vous ne devriez jamais le partager avec qui que ce soit ni en permettre l'accès de quelque manière que ce soit.

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

ssh-keygen -b 4096

Dans ~/.ssh/vous trouverez votre clé publique comme id_rsa.pub. Son contenu doit être ajouté au authorized_keysfichier de votre serveur en le transportant via un support transportable (clé USB) ou en activant brièvement l’authentification du mot de passe sur le serveur, puis en l’utilisant ssh-copy-id ~/.ssh/id_rsa.pub username@serverpuis en le désactivant à nouveau.

Si vous avez choisi de sécuriser votre clé avec une phrase secrète (dans la première étape), vous pouvez utiliser ssh-agentle trousseau de clés Ubuntu pour sécuriser ce processus localement afin de ne pas avoir à le taper tout le temps.

Pour faire quelques ajouts:

• Mac par défaut 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
  

trouvez plus ici: https://github.com/beautifulcode/ssh-copy-id-for-OSX

• si vous avez effectué un transfert de port, la commande devrait être comme ceci:

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

notez que les guillemets sont nécessaires.

Connexion / copie à distance sans mot de passe

Les applications sshet scppour la connexion à distance et la copie à distance, respectivement, vous permettent de communiquer avec un hôte distant sans donner de mot de passe. Cela nécessite que vous suiviez une procédure d'authentification similaire à celle décrite ci-dessous. Par client, nous voulons dire la machine sur laquelle vous êtes assis et par serveur, nous voulons dire la machine à 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 des clés privées et publiques, à moins que cela ne soit déjà fait sur votre machine. Ceux-ci sont stockés dans des fichiers au format $HOME/.ssh.
2. Ajoutez le contenu du fichier de clé publique au fichier $HOME/.ssh/authorized_keysou $HOME/.ssh/authorized_keys2au serveur.

Il existe trois types différents de protocoles d'authentification. Vous spécifiez le type lors de l'exécution de ssh-keygen:

1. Protocole SSH version 1, RSA1: il s’agit du choix par défaut. Il en résulte une identité de fichier (clé privée chmod 0700à prendre pour que ce fichier ne soit pas lisible par d’autres) et identity.pub (clé publique).
2. Protocole SSH version 1, RSA : ceci est obtenu en exécutant ssh-keygen -t rsaet aboutit à des fichiers id_rsa(clé privée) et id_rsa.pub(clé publique)
3. Protocole SSH version 1, DSA : ceci est obtenu en cours d'exécution ssh-keygen -t dsaet aboutit à des fichiers 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 fournissez pas de phrase secrète). Cela simplifie l’ensemble de la configuration, mais est également source d’insécurité.

Vous pouvez spécifier le type de clés à utiliser par une option de ssh ; ssh -1les forces de l' utilisation RSA1 clés (version 1 du protocole), alors que les ssh -2forces ssh à essayer en RSA ou DSA clés uniquement (version 2 du protocole). Dans les exemples ci-dessous, nous générons et installons des clés RSA1 et DSA sur l'hôte distant de manière à vous offrir davantage de flexibilité. Vous pouvez créer un fichier de configuration dans votre .sshrépertoire avec la ligne

Protocol 1,2

Cela oblige ssh à essayer une connexion RSA1 (version 1 du protocole) avant RSA / DSA (version 2 du protocole).

Utiliser les 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 de 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 secrète 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 (vous devrez peut-être utiliser -1ou utiliser -2les options de ssh ). Bien entendu, la procédure peut être répétée pour tout ordinateur auquel vous souhaitez vous connecter.

Si vous avez utilisé une phrase secrète, vous devez exécuter le programme ssh-agentpour démarrer un shell spécial, puis ssh-addenregistrer la combinaison clé / phrase secrète avec sshd. Voir 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é de: http://folk.uio.no/hpl/scripting/doc/ssh-no-password.html}

J'aimerais ajouter une réponse pour ceux qui pourraient trouver qu'ils devraient entrer le mot de passe même s'ils ont lu toutes les réponses ici parce que vous avez défini IdentitiesOnly sur yes. Et la réponse ici peut vous faire économiser beaucoup de temps pour gérer plusieurs clés, clés pour git ou serveur.

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

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

J'ai trouvé que ça n'a pas marché.

Puis je suis allé vérifier le ~/.ssh/configdossier du client, j'ai vu ceci en bas:

Host *
IdentitiesOnly yes

Puis j'ajoute ceci ci-dessus:

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

Je peux juste me connecter en entrant ssh somename.

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

Host est le nom que vous souhaitez entrer lorsque vous connectez le serveur ultérieurement. le nom d'hôte est l'adresse IP du serveur; Utilisateur est le nom d'utilisateur que vous connectez au serveur. et le fichier d'identité est le fichier dans lequel vous stockez la clé que vous avez générée.