Client authenticatie via SSH

SSH maakt gebruik van asymmetrische cryptografie om de verbinding tussen de server en de client te beveiligen. De SSH client maakt een keypair aan. Wanneer de client voor het eerst verbindt met de server, wordt de public key van de client's keypair op de server opgeslagen (doorgaans in ~/.ssh/known_hosts ).  Deze key wordt daarna gebruikt om beveiligd te communiceren. De public key is dan ook terug te zien in het known_hosts bestand op de server:

[xolphin@server xolphin]# cd .ssh
[xolphin@server .ssh]# cat known_hosts
10.50.99.100 ssh-rsa AAAAB0IEV4dGVybmFsIFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBF
eHRlcm5hbCBDQSBSb290MB4XDTA1MDYwNzA4MDkxMFoXDTIwMDUzMDEwNDgzOFow
gZcxCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJVVDEXMBUGA1UEBxMOU2FsdCBMYWtl
aHR0cDovL3d3dy51c2VydHJ1c3QuY29tMR8wHQYDVQQDExZVVE4tVVNFUkZpcnN0=
[xolphin@server .ssh]#

Client authenticatie met een keypair

Het is ook mogelijk om de noodzaak van een wachtwoord helemaal weg te halen door de public key te kopiëren naar de ssh server en op te slaan in het bestand ~/.ssh/authorized_keys (of in sommige versies: ~/.ssh/authorized_keys2 ):

Eerst wordt eerst een keypair aangemaakt op de client.
NB: het is meestal handig om geen wachtwoord op te geven voor de beveiliging van de private key, aangezien men dan het wachtwoord elke keer zou moeten invoeren wanneer de private key wordt gebruikt (hetgeen een beetje het doel voorbijschiet). Om dit risico op te vangen wordt de map waarin de private key zich bevindt beveiligd.

[user@client .ssh]# ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (~/.ssh/id_rsa): my.key
Enter passphrase (empty for no passphrase): {Enter}
Enter same passphrase again: {Enter}
Your identification has been saved in my.key.
Your public key has been saved in my.key.pub.
The key fingerprint is:
xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx user@client.local
The key's randomart image is:
<ASCII image>
[user@client .ssh]#

Beveilig nu de key en de map:

[user@client .ssh]# chmod 600 *.key
[user@client .ssh]# chmod 700 ~/.ssh/

Vervolgens kan de net aangemaakte public key als volgt worden overgezet naar de ssh server (in dit voorbeeld 10.50.99.10 ), en worden toegevoegd aan het bestand ~/.ssh/authorized_keys:

[user@client .ssh]# ssh-copy-id -i my.key.pub xolphin@10.50.99.10
Password:
Now try logging into the machine, with "ssh 'xolphin@10.50.99.10'", and check in:
 .ssh/authorized_keys
to make sure we haven't added extra keys that you weren't expecting.
[user@client .ssh]#

Wanneer men vervolgens een ssh-verbinding legt met de server wordt er niet meer gevraagd om een wachtwoord omdat de authenticatie plaatsvindt door de aanwezigheid van de public key op de server in authorized_keys:

[user@desktop .ssh]# ssh xolphin@10.50.99.10
[xolphin@server ~]#

In het bestand authorized_keys staat nu de public key toegevoegd, samen met de gebruikersnaam en de servernaam:

[xolphin@server ~]# cd .ssh
[xolphin@server .ssh]# cat authorized_keys
ssh-rsa AAAABvD6sYb0KiA7I3z3ufARMnQpea5HW7sftKI2rTYeJc9BupNAeFosU4XZEA39jrOTN
SZzFkvSrMqFIWwIDAQABo4HhMIHeMB8GA1UdIwQYMBaAFK29mHo0tCb3+sQmVO8D
veAky1QaMB0GA1UdDgQWBBShcl8mGyiYQ5VdBzfVhZadS9LDRTAOBgNVHQ8BAf8E
BAMCAQYwDwYDVR0TAQH/BAUwAwEB== xolphin@server
[xolphin@server .ssh]#

Vervolgens kan account xolphin worden ingesteld om geen authenticatie met wachtwoorden meer toe te staan:

[xolphin@server .ssh]# su -
[xolphin@server .ssh]# password -l xolphin
Password changed.

Vanaf nu is het mogelijk om altijd beveiligd te verbinden met de server vanaf de client, zonder dat hier verder een wachtwoord hoeft te worden ingevoerd. De enige vereiste is dat de public key op de server staat opgeslagen in authorized_keys, en dat de private key aanwezig is in de map ~/.ssh/ .

Het is sterk aan te raden om van keypairs altijd een (beveiligde) backup te maken. In de praktijk is het vaak ook handig om de keys op een host te bewaren en vandaaruit weer te verbinden met andere servers; op die manier is het mogelijk om vanaf een willekeurige machine te verbinden met de "ssh host" en vandaaruit weer te verbinden met andere machines waarmee regelmatig wordt gecommuniceerd.