# Se connecter au NAS en ssh et sans mot de passe



**Pré requis:**

Le serveur doit accepter la connexion par clé: la ligne `PubKeyAuthentication yes` doit être présente dans le fichier de configuration du serveur, généralement /etc/ssh/sshd_config.

Sur Mac, installer ssh-copy-id:

```bash
$ brew install ssh-copy-id
```



### Générer sur la machine locale (Mac) 

Le jeu de clé/certficat (la clé est créée dans `~/.ssh/`):

```bash
$ ssh-keygen -t rsa -b 4096 -C "Commentaire: ma clé sur le macbook"
Generating public/private rsa key pair.
Enter file in which to save the key (/Users/bruno/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /Users/bruno/.ssh/id_rsa.
Your public key has been saved in /Users/bruno/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:WFJNXaCoraMCYSiP0xqlOvdOsh74W86rC5OgHJppvuw Commentaire: ma clé sur le macbook
The key's randomart image is:
+---[RSA 4096]----+
|        .o...o.  |
|       . ....    |
|.     . o .      |
|+..    *         |
|+O    o S        |
|@=+    .         |
|@Bo o o          |
|B+oO . .         |
|.EOBB.           |
+----[SHA256]-----+
```

Plusieurs types de clé possibles (rsa, ecdsa, ed25519):

```bash
$ ssh-keygen -t rsa -b 4096 -C "USEFUL-COMMENT"
$ ssh-keygen -t ecdsa -b 521
$ ssh-keygen -t ed25519
```

Sur ovh.com -> **rsa**

Sur vps 1and1 -> **ed25519**

Les clés DSA sont dépréciées dans OpenSSH 7.0

Autres options:

-o	crée un clé privée au nouveau format OpenSSH (au lieu du format PEM plus compatible). Le nouveau format est plus résistant au brut-force mais n'est pas compatible avec OpenSSH pré 6.5. Les clés ed25519 sont toujours au nouveau format.



### Copier la clé publique sur le serveur:

Copiez la clé publique *(id_rsa.pub*) sur le serveur NAS dans le fichier “*authorized_keys*” dans le répertoire `$HOME/.ssh` de l'utilisateur.

```bash
$ cat ~/.ssh/id_rsa.pub | ssh admin@192.168.0.8 'cat>> ~/.ssh/authorized_keys'
# si ssh n'est pas sur le port 22
$ cat ~/.ssh/id_rsa.pub | ssh -p35148 admin@192.168.0.8 'cat>> ~/.ssh/authorized_keys'
```

ou

```bash
$ ssh-copy-id -i ~/.ssh/id_rsa.pub admin@192.168.0.8
# si ssh n'est pas sur le port 22
$ ssh-copy-id -i ~/.ssh/id_rsa.pub admin@192.168.0.8 -p35148
```

Pour les oneliners...

```bash
ssh matthieu@monserveur.local 'mkdir -p ~/.ssh; chmod 0700 ~/.ssh; echo ' $(< ~/.ssh/ma_cle_perso.pub) ' >> ~/.ssh/authorized_keys ; chmod 0600 ~/.ssh/authorized_keys'
```

Sur le serveur, vérifier les autorisations:

```bash
[server]$ chmod 700 ~/.ssh
[server]$ chmod 600 ~/.ssh/*
```



### Ajouter la passphrase à SSH-agent.

Démarrer ssh-agent en arrière-plan:

```bash
$ eval "$(ssh-agent -s)"
Agent pid 2876
```

Ajouter la clé à ssh-agent:

```bash
$ ssh-add -K ~/.ssh/id_rsa
Enter passphrase for /Users/bruno/.ssh/id_rsa:
Identity added: /Users/bruno/.ssh/id_rsa (/Users/bruno/.ssh/id_rsa)
```

Si on utilise une passphrase avec OSX 10.12.2+, il faut ajouter à `~/.ssh/config`

```bash
Host *
 # la passphrase de la clé privée est stockée dans la keychain de macOS
 AddKeysToAgent yes
 # ssh-agent décrypte la clé privée en mémoire
 UseKeychain yes
 IdentityFile ~/.ssh/id_rsa
```

La passphrase est stockée durablement dans la keychain, on n’a plus besoin de la rentrer à chaque session.



### SSH Config

Le fichier *config* se trouve dans `~/.ssh/`

Il permet de configurer et de faciliter les connections ssh pour chaque serveur.

```bash
Host *
	AddKeysToAgent yes
	UseKeychain yes

#SCE_ICON:linux
Host dsm414
	User bruno
	HostName 192.168.1.8
	Port 42666
	IdentityFile ~/.ssh/id_ed25519
```

On se connecte directement au serveur avec:

```bash
$ ssh dsm414
```



### Se connecter à la machine distante sans mot-de-passe:

```bash
$ ssh bruno@xxx.synology.me -p12345
bruno@DS916:~ $
```

Finalement, sur le serveur, on peut éditer le fichier `/etc/ssh/sshd_config` pour supprimer l'authentification par mot de passe (`PasswordAuthentication no`). A ne faire que si l'on a un accès physique au serveur.



### Plus:

#### En cas de compromission de la clé privée, que faut-il faire ?

- Regénérer une nouvelle paires de clés ;
- Redéployer la nouvelle clé publique sur tous les serveurs ;
- Révoquer la clé publique sur tous les serveurs où elle est présente, c’est-à-dire supprimer la ligne correspondant à votre clé publique dans le fichier ~/.ssh/authorized_keys et en même temps vérifier que d’autres clés publiques non légitimes n’ont pas été ajoutées ;
- Si la clé publique était présente sur un compte root, il va falloir faire un audit complet du serveur car il peut potentiellement avoir été compromis, bonne chance.



#### Info sur une clé:

```bash
$ ssh-keygen -l -f ~/.ssh/id_rsa.pub
2048 SHA256:a++yRIZiaqAx7hJkYdmgYBVeGJtbiFdNrFNrsr0Qi7k bruno@HackiMac.local (RSA)
```



#### Changer la passphrase:

```bash
$ ssh-keygen -f id_rsa -p
Enter new passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved with the new passphrase.
```

Cela modifie la clé privée, la clé publique ne change pas.



#### Changer le format de clé:

##### Convertir au nouveau format OpenSSH:

```bash
$ ssh-keygen -f ~/.ssh/id_dsa -o -c -C "dsa@HackiMac.local"
Key now has no comment
The comment in your key file has been changed.
```

- -o: convertit la clé privée de PEM au nouveau format format OpenSSH.
- -c: changer  le commentaire dans les clés privée et publique. 
- -C: commentaire 

##### Convertir une clé publique au format PEM:

```bash
$ ssh-keygen -f server.pub -e -m pem
```

#### Vérifier si ssh-agent est lancé (macOS):

```bash
$ launchctl list | grep ssh-agent
2251	0	com.openssh.ssh-agent
```

#### Pour retrouver la passphrase:

Trousseau d’accès -> Présentation -> Afficher les éléments invisibles - > Chercher *id_rsa* ou *ssh*

Clic droit et copier le mot de passe dans le presse-papier (le mot de passe de session est demandé)

#### Supprimer une entrée SSH du fichier known_hosts:

En vous connectant en SSH à une machine que vous venez de réinstaller, vous risquez d’avoir le message suivant sur le poste client :

```bash
$ ssh-keygen -R NomDuServeur

$ ssh-keygen -f "/home/<USERNAME>/.ssh/known_hosts" -R <NOM_DU_DOMAINE_OU_ADRESSE_MACHINE>
```

#### Regénérer les clés:

Si on veut, pour une raison ou un autre, changer cette pair de clés, il faut : 

1. **Côté serveur** : éditer le fichier `/etc/ssh/sshd_config` pour vérifier ou remettre l'authentification par mot de passe est à yes : `PasswordAuthentication yes` 
2. recharger ssh : `service ssh start` 
3. supprimer le fichier `~/.ssh/authorized_keys`
  
4. **Côté client** : supprimer les fichier `~/.ssh/id_rsa` et `~/.ssh/id_rsa.pub` puisqu'on va les régénérer en se créant une nouvelle paire de clés.

#### Les clés d'hôtes:

elles sont dans `/etc/sshd/ssh_host*`

#### Copier sa clé publique dans le presse-papier:

- ```bash
  - Mac OS: pbcopy < ~/.ssh/id_rsa.pub
  - Windows: clip < ~/.ssh/id_rsa.pub
  - Linux: xclip -sel clip < ~/.ssh/id_rsa.pub
  ```



[:fa-link: How to Set Up a Password-less SSH Login](http://osxdaily.com/2012/05/25/how-to-set-up-a-password-less-ssh-login/)

[:fa-link: ssh-copy-id](http://www.qth.fr/tag/ssh-copy-id)



[https://www.ssh.com/ssh/keygen/](https://www.ssh.com/ssh/keygen/)

[https://apple.stackexchange.com/questions/48502/how-can-i-permanently-add-my-ssh-private-key-to-keychain-so-it-is-automatically](https://apple.stackexchange.com/questions/48502/how-can-i-permanently-add-my-ssh-private-key-to-keychain-so-it-is-automatically)

[http://happygitwithr.com/ssh-keys.html](http://happygitwithr.com/ssh-keys.html)

[https://help.github.com/articles/connecting-to-github-with-ssh/](https://help.github.com/articles/connecting-to-github-with-ssh/)