ssh-keygen: creare chiavi SSH, registrare la chiave pubblica e usare ssh-copy-id

Ambiente di testFamiglia RHELAlmaLinux 9.8account rootVerificato il 2026-11-05

Comandi di retessh-keygenssh-copy-idPosizione/usr/bin/ssh-keygen

ssh-keygen è il comando di OpenSSH che crea la coppia di chiave privata e chiave pubblica usata per le connessioni SSH e che si occupa anche di controllare le impronte, cambiare la passphrase e ripulire known_hosts. Ho creato chiavi ed25519 e rsa su un server AlmaLinux 9, ho controllato le impronte, cambiato passphrase e commento e poi provato ssh-copy-id in dry-run: l'unica cosa che passa al server è la riga della chiave pubblica nel file .pub.

I nomi degli account e i percorsi dei file di chiave nell'output qui sotto sono valori di esempio, mentre impronte, chiavi pubbliche e randomart vengono da chiavi create per questo articolo e poi cancellate. Il comando che registra davvero una chiave pubblica su un server è riportato, ma non è stato eseguito.

Indice

9mn read

1️⃣ Creare una chiave con ssh-keygen: -t ed25519 e il commento -C

Le chiavi si creano nella forma ssh-keygen -t tipo -C commento. -t è il tipo di chiave e -C è un commento aggiunto alla fine della chiave pubblica, dove si scrive un indirizzo email o lo scopo della chiave. Qui sotto c'è l'output completo con il file indicato da -f e Invio premuto alle due domande sulla passphrase.

ssh-keygen -t ed25519 -C "user@example.com" -f ~/.ssh/id_ed25519

Generating public/private ed25519 key pair.
Enter passphrase for "/home/user/.ssh/id_ed25519" (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_ed25519
Your public key has been saved in /home/user/.ssh/id_ed25519.pub
The key fingerprint is:
SHA256:c73KJh85pPijvy43kS1uaQo77fSsGlE4Wz+aMF+sTy8 user@example.com
The key's randomart image is:
+--[ED25519 256]--+
|                 |
|     .           |
|    o o          |
|     = o   .     |
|    =   Soo .    |
|     = *+*.. .   |
|    o.B.o++ .    |
|    .=o*Eo.+     |
|    o+=@OO=      |
+----[SHA256]-----+

Se premi solo Invio alla domanda sulla passphrase, la chiave resta senza passphrase. Se ometti -f, prima di quella domanda compare una riga che chiede dove salvare il file. Tra parentesi c'è il percorso predefinito, .ssh/id_ed25519 nella tua cartella home, e anche qui premendo solo Invio la chiave viene salvata lì.

Il randomart alla fine dell'output è l'impronta trasformata in disegno. Lo stesso disegno è comparso alla creazione della chiave e al nuovo controllo con -lv.

ls -l ~/.ssh/id_ed25519 ~/.ssh/id_ed25519.pub

-rw------- 1 user user 411 Oct 29 08:22 /home/user/.ssh/id_ed25519
-rw-r--r-- 1 user user  98 Oct 29 08:22 /home/user/.ssh/id_ed25519.pub

La chiave privata è stata creata con permessi 600 e quella pubblica con 644. Tieni la chiave privata solo sul tuo computer e non mandarla da nessuna parte.

cat ~/.ssh/id_ed25519.pub

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVLiw04ugfXq15n2m8ZDW0OywkRoug8beXw/9VnVY/L user@example.com

La chiave pubblica è una sola riga composta da tipo di chiave, valore della chiave e commento separati da spazi. È questa riga che finisce in authorized_keys sul server a cui ti colleghi. Il ruolo di ogni file della cartella è riassunto in un albero.

~/.sshCartella che raccoglie chiavi e dati di connessione · permessi 700

id_ed25519Chiave privata · file che resta solo sul tuo computer · permessi 600

id_ed25519.pubUna riga di chiave pubblica · va in authorized_keys del server di destinazione · permessi 644

authorized_keysElenco delle chiavi pubbliche autorizzate ad accedere a questo server (si trova sul server che le riceve)

known_hostsChiavi host dei server a cui ti sei collegato · ssh-keygen -R le elimina riga per riga

configAlias, porta e file di chiave per server (ssh_config)

2️⃣ Opzioni di ssh-keygen: -f, -N, -b, -q

Rispondere alle domande è comodo quando scrivi a mano, ma in uno script le domande devono sparire del tutto. Se fissi il file con -f e la passphrase con -N, la chiave viene creata subito senza domande.

ssh-keygen -t ed25519 -f ~/.ssh/deploy_key -N "" -C "deploy@example.com"

Generating public/private ed25519 key pair.
Your identification has been saved in /home/user/.ssh/deploy_key
Your public key has been saved in /home/user/.ssh/deploy_key.pub
The key fingerprint is:
SHA256:Rhk2/tgn59K8jtvDWJTOLiYnToM8t4gkdaMfu6TJ0oM deploy@example.com
The key's randomart image is:
+--[ED25519 256]--+
|        +        |
|       o +       |
|        +    .   |
|       . +  o    |
|    . o S ++o    |
|   . + +   B+    |
|  .oo * + .=+    |
|  E+o* Boo=++.   |
|   .=.=oo=o++.   |
+----[SHA256]-----+

Con virgolette vuote dopo -N la chiave resta senza passphrase, e posizione di salvataggio e impronta sono comparse in un colpo solo, senza alcuna domanda.

ssh-keygen -t ed25519 -f ~/.ssh/deploy_key -N ""

Generating public/private ed25519 key pair.
/home/user/.ssh/deploy_key already exists.
Overwrite (y/n)?

Rieseguendo con lo stesso nome, dopo already exists chiede se sovrascrivere. Premendo n non è cambiato nulla e il comando è terminato con codice di uscita 1. Per non sovrascrivere per errore una chiave in uso, crea le nuove chiavi con un altro nome.

ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N "" -C "user@example.com"

Generating public/private rsa key pair.
Your identification has been saved in /home/user/.ssh/id_rsa
Your public key has been saved in /home/user/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:f+uwCSQjMka1BEHzXADwIWbrlbVRiP6Z4tjnwNwPVAA user@example.com
The key's randomart image is:
+---[RSA 4096]----+
|o=BE*=+.         |
|oo.Oo++          |
| .+o+. .         |
|....  .          |
| .+ o.= S        |
| .o+o= + .       |
|  ++.o  . o .    |
| . o..o  . = .   |
|    o. .  o.o    |
+----[SHA256]-----+

Per rsa, -b fissa la lunghezza. Secondo il manuale il valore predefinito è 3072 bit; sopra la chiave è stata creata a 4096 bit e nell'intestazione del randomart è comparso RSA 4096. Il manuale indica che ed25519 ha una lunghezza fissa, quindi -b viene ignorato.

ssh-keygen -f ~/.ssh/default_key -N "" -C "user@example.com"

Generating public/private ed25519 key pair.
Your identification has been saved in /home/user/.ssh/default_key
Your public key has been saved in /home/user/.ssh/default_key.pub
The key fingerprint is:
SHA256:mwy02fpKxjxEVvLC2EUJeaMIiNFOVS0GwWVjN9v0j4c user@example.com
The key's randomart image is:
+--[ED25519 256]--+
|o+ o+=O=*..      |
|o + .*+B== .     |
| o ..oB+o.. .    |
|  . .+.=     +   |
|      = S   E o  |
|     + + o   .   |
|      B +        |
|     o o         |
|      ...        |
+----[SHA256]-----+

Omettendo -t è stata creata una chiave ed25519.

ssh-keygen -q -t ed25519 -f ~/.ssh/backup_key -N "" -C "backup@example.com"; echo rc=$?

rc=0

Con -q tutto viene nascosto, anche impronta e randomart, e resta solo il codice di uscita. Si usa quando uno script crea chiavi per più server.

📌 Opzioni principali: risultati di questo articolo

Opzione	Compito	Risultato in questo articolo
-t tipo	Tipo di chiave da creare	La prima riga dell'output mostra il tipo, come ed25519 o rsa; se omesso, ed25519
-C commento	Commento aggiunto alla fine della chiave pubblica	user@example.com alla fine della chiave pubblica vista con cat
-f file	Percorso del file di chiave	Una riga che dice che è stato salvato in /home/user/.ssh/deploy_key; rieseguendo con lo stesso nome, already exists e Overwrite (y/n)?
-N passphrase	Nuova passphrase; virgolette vuote significano nessuna passphrase	Posizione di salvataggio e impronta in un colpo solo, senza domanda sulla passphrase
-b bit	Lunghezza della chiave	Con 4096 per rsa, RSA 4096 nell'intestazione del randomart
-q	Nasconde tutto l'output	Resta solo la riga rc=0 stampata con echo
-l	Stampa l'impronta di un file di chiave	La stessa impronta SHA256 da chiave pubblica e privata; per authorized_keys, una riga per chiave
-E hash	Imposta il tipo di hash dell'impronta	Con -E md5, un'impronta che inizia con MD5:00:7b:02:5e
-v	Insieme a -l stampa anche il randomart	Lo stesso randomart della creazione della chiave
-y	Estrae e stampa la chiave pubblica dalla chiave privata	Una riga di chiave pubblica identica, carattere per carattere, al file .pub
-p	Cambia la passphrase della chiave privata	Compare una riga che dice che è stata salvata con la nuova passphrase, e la chiave privata passa da 411 a 464 byte
-P passphrase	Vecchia passphrase (quella impostata ora)	Con la passphrase giusta la chiave pubblica, con una sbagliata incorrect passphrase supplied to decrypt private key
-c	Cambia il commento; il nuovo si dà con -C	Old comment: user@example.com e Comment 'user@laptop' applied
-F host	Cerca la riga di quell'host in known_hosts	# Host 192.0.2.10 found: line 1 e la riga stessa
-R host	Elimina la riga di quell'host da known_hosts	known_hosts updated e il file originale known_hosts.old; un host assente dà not found
-H	Applica l'hash ai nomi host e agli indirizzi di known_hosts	Righe che iniziano con \|1\|, più un WARNING che avvisa che il file .old conserva le righe senza hash

📎 Altre opzioni: secondo il manuale ufficiale

Opzione	Compito
-a cicli	Cicli KDF (bcrypt_pbkdf) al salvataggio della chiave privata; più sono, più lento il controllo della passphrase e più difficile la forza bruta; predefinito 16
-A	Crea le chiavi host mancanti per ogni tipo predefinito (rsa, ecdsa, ed25519) nei percorsi predefiniti
-B	Stampa il digest bubblebabble di un file di chiave
-e	Converte una chiave OpenSSH nel formato -m (predefinito RFC4716) e la stampa, per altri programmi SSH
-i	Converte una chiave senza passphrase in formato -m (predefinito RFC4716) nel formato OpenSSH e la stampa
-m formato	Imposta il formato della chiave (RFC4716, PKCS8, PEM); con -p converte le chiavi private tra i formati OpenSSH e PEM
-r host	Stampa dalla chiave pubblica il record DNS SSHFP per quel nome host
-s chiave_CA	Firma una chiave pubblica con una chiave CA per creare un certificato
-L	Stampa il contenuto di un certificato
-K	Scarica nella cartella corrente le chiavi resident salvate su un autenticatore FIDO
-Y sign	Firma un file con una chiave SSH; la firma viene salvata aggiungendo .sig al nome del file, e lo spazio dei nomi si dà con -n

3️⃣ ssh-keygen -l per l'impronta e -y per estrarre la chiave pubblica

Con più file di chiave, dal solo nome è difficile capire quale chiave pubblica fa coppia con quale chiave privata. Poiché l'impronta è la stessa per chiave privata e pubblica, confrontando con -l le impronte dei due file confermi la coppia.

ssh-keygen -l -f ~/.ssh/id_ed25519.pub

256 SHA256:c73KJh85pPijvy43kS1uaQo77fSsGlE4Wz+aMF+sTy8 user@example.com (ED25519)

ssh-keygen -l -f ~/.ssh/id_ed25519

256 SHA256:c73KJh85pPijvy43kS1uaQo77fSsGlE4Wz+aMF+sTy8 user@example.com (ED25519)

Il file della chiave pubblica e quello della chiave privata hanno dato la stessa impronta SHA256. Il 256 iniziale è la lunghezza della chiave e la parentesi finale indica il tipo di chiave.

ssh-keygen -l -E md5 -f ~/.ssh/id_ed25519.pub

256 MD5:00:7b:02:5e:b8:ba:85:0c:32:d7:15:7e:72:45:f7:bc user@example.com (ED25519)

Con -E md5 si passa al vecchio formato di impronta MD5. Serve per il confronto quando un vecchio server o un pannello di gestione mostra impronte MD5.

ssh-keygen -lv -f ~/.ssh/id_ed25519.pub

256 SHA256:c73KJh85pPijvy43kS1uaQo77fSsGlE4Wz+aMF+sTy8 user@example.com (ED25519)
+--[ED25519 256]--+
|                 |
|     .           |
|    o o          |
|     = o   .     |
|    =   Soo .    |
|     = *+*.. .   |
|    o.B.o++ .    |
|    .=o*Eo.+     |
|    o+=@OO=      |
+----[SHA256]-----+

Aggiungendo -v il randomart ricompare. Era lo stesso disegno stampato alla creazione della chiave.

ssh-keygen -l -f ~/.ssh/authorized_keys

256 SHA256:Rhk2/tgn59K8jtvDWJTOLiYnToM8t4gkdaMfu6TJ0oM deploy@example.com (ED25519)

Se dai un file con più righe di chiavi pubbliche, come authorized_keys, ottieni una riga di impronta per ogni chiave. In questo modo controlli quali chiavi sono registrate su un server.

ssh-keygen -y -f ~/.ssh/id_ed25519

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVLiw04ugfXq15n2m8ZDW0OywkRoug8beXw/9VnVY/L user@example.com

-y estrae di nuovo la chiave pubblica dalla chiave privata. Se hai cancellato il file .pub o hai spostato solo la chiave privata su un altro computer, basta salvare questo output in un file. L'output era identico, carattere per carattere, al file .pub originale.

4️⃣ ssh-keygen -p per cambiare la passphrase e -c per cambiare il commento

Con una passphrase sulla chiave privata, il file non si può usare senza di essa anche se viene diffuso. In cambio devi digitarla a ogni connessione, quindi è adatta alle chiavi usate a mano dalle persone, non a quelle degli script che girano da soli, come i job di cron.

ssh-keygen -p -f ~/.ssh/id_ed25519 -P "" -N "example-pass"

Key has comment 'user@example.com'
Your identification has been saved with the new passphrase.

-P è la vecchia passphrase e -N la nuova. La chiave non aveva passphrase, quindi -P ha ricevuto virgolette vuote, e sono comparse due righe che dicono che è stata salvata di nuovo con la nuova passphrase. Secondo il manuale, -p da solo senza opzioni chiede in sequenza la vecchia e la nuova passphrase.

ls -l ~/.ssh/id_ed25519

-rw------- 1 user user 464 Oct 29 08:22 /home/user/.ssh/id_ed25519

Dopo aver impostato la passphrase, il file della chiave privata è cresciuto da 411 a 464 byte.

ssh-keygen -y -f ~/.ssh/id_ed25519 -P "example-pass"

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVLiw04ugfXq15n2m8ZDW0OywkRoug8beXw/9VnVY/L user@example.com

ssh-keygen -y -f ~/.ssh/id_ed25519 -P "wrongpass"

Load key "/home/user/.ssh/id_ed25519": incorrect passphrase supplied to decrypt private key

Con una chiave protetta da passphrase, anche -y ha bisogno della passphrase passata con -P. Con quella giusta è uscita la stessa chiave pubblica di prima, con una sbagliata il comando è terminato con l'errore incorrect passphrase. Il manuale chiarisce che una passphrase persa non si può recuperare: se la dimentichi, crea una nuova chiave e registra di nuovo la chiave pubblica.

ssh-keygen -c -C "user@laptop" -f ~/.ssh/id_ed25519 -P "example-pass"

Old comment: user@example.com
Comment 'user@laptop' applied

cat ~/.ssh/id_ed25519.pub

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVLiw04ugfXq15n2m8ZDW0OywkRoug8beXw/9VnVY/L user@laptop

-c cambia il commento. Il vecchio e il nuovo commento compaiono su una riga ciascuno, e anche il commento alla fine del file della chiave pubblica è diventato user@laptop. Il commento è solo un'etichetta per distinguere le chiavi, quindi il valore della chiave non è cambiato.

ssh-keygen -p -f ~/.ssh/id_ed25519 -P "example-pass" -N ""

Key has comment 'user@laptop'
Your identification has been saved with the new passphrase.

Per togliere la passphrase passa virgolette vuote a -N. Compaiono le stesse due righe e da lì in poi -y ha funzionato di nuovo senza -P.

5️⃣ ssh-keygen -R per eliminare le chiavi host da known_hosts

In known_hosts si accumulano, una per riga, le chiavi host dei server a cui ti sei collegato. Se un server viene reinstallato e la sua chiave host cambia, ssh rifiuta la connessione perché la chiave non corrisponde a quella salvata, e l'opzione che elimina la vecchia riga è -R. Il known_hosts qui sotto è un file di tre righe con indirizzi di esempio, indicato con -f.

cat ~/.ssh/known_hosts

192.0.2.10 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKKphFOc7oiKNpIHFTzK/ippCS5U5D+lF3xmXM6dmYjk
server2.example.com,192.0.2.20 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR
[192.0.2.30]:2222 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIC0WmcBD2HIsiSn+tERrbeFIyExAodSEUhE9j5WMpkRW

Ogni riga contiene nome host o indirizzo, tipo di chiave e valore della chiave, in quest'ordine. La seconda riga, unita da una virgola, riporta nome e indirizzo dello stesso server, e le parentesi quadre con i due punti nella terza riga indicano una porta diversa dalla 22.

ssh-keygen -F 192.0.2.10 -f ~/.ssh/known_hosts

# Host 192.0.2.10 found: line 1
192.0.2.10 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKKphFOc7oiKNpIHFTzK/ippCS5U5D+lF3xmXM6dmYjk

-F stampa la riga di quell'host insieme al suo numero di riga. Per un host assente non ha stampato nulla ed è terminato con codice di uscita 1.

ssh-keygen -R 192.0.2.10 -f ~/.ssh/known_hosts

# Host 192.0.2.10 found: line 1
/home/user/.ssh/known_hosts updated.
Original contents retained as /home/user/.ssh/known_hosts.old

cat ~/.ssh/known_hosts

server2.example.com,192.0.2.20 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR
[192.0.2.30]:2222 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIC0WmcBD2HIsiSn+tERrbeFIyExAodSEUhE9j5WMpkRW

-R elimina la riga di quell'host e conserva il file originale come known_hosts.old. Dopo l'eliminazione sono rimaste solo due righe.

ssh-keygen -R 192.0.2.99 -f ~/.ssh/known_hosts

Host 192.0.2.99 not found in /home/user/.ssh/known_hosts

ssh-keygen -R "[192.0.2.30]:2222" -f ~/.ssh/known_hosts

# Host [192.0.2.30]:2222 found: line 2
/home/user/.ssh/known_hosts updated.
Original contents retained as /home/user/.ssh/known_hosts.old

Indicando un host assente è comparsa solo una riga not found. Per un server su una porta diversa bisogna inserire parentesi quadre e porta esattamente come compaiono in known_hosts.

ssh-keygen -H -f ~/.ssh/known_hosts

WARNING: /home/user/.ssh/known_hosts.old contains unhashed entries
Delete this file to ensure privacy of hostnames
/home/user/.ssh/known_hosts updated.
Original contents retained as /home/user/.ssh/known_hosts.old

cat ~/.ssh/known_hosts

|1|JL/knNlx/BnCoOWp5rNeRo3r1rE=|OCPyeFd1rgG8P2QGzrju/V2Y8c4= ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR
|1|AG9QJQvGaQmVsEusSdND1lM9cKI=|Ue0a9suJIzN0yxoJgV7ClLBgSYw= ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR

-H applica l'hash a nomi host e indirizzi. È l'opzione che impedisce a un file diffuso di rivelare a quali server ti sei collegato; nome e indirizzo uniti da una virgola sono stati separati in due righe con hash. È comparso anche un avviso che il file .old conserva ancora il contenuto senza hash.

ssh-keygen -F server2.example.com -f ~/.ssh/known_hosts

# Host server2.example.com found: line 1
|1|JL/knNlx/BnCoOWp5rNeRo3r1rE=|OCPyeFd1rgG8P2QGzrju/V2Y8c4= ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAID3s6oYeTCz7KeYs0f/60/Ix0DhmK4hf1uHCC10TrXyR

Anche nel file con hash, -F ha trovato la riga tramite il nome.

6️⃣ ssh-copy-id per registrare la chiave pubblica e authorized_keys

Creare la chiave non basta: finché il server non conosce la chiave pubblica, l'accesso avviene ancora con la password. Il posto in cui il server viene a conoscere la chiave pubblica è ~/.ssh/authorized_keys dell'account a cui ti colleghi, e ssh-copy-id è il comando che inserisce la riga del .pub in quel file. La chiave privata resta sul tuo computer e passa solo la riga della chiave pubblica. Premi i pulsanti dei passaggi nel diagramma qui sotto per vedere dove finiscono i due file.

🔐 Come la coppia di chiavi di ssh-keygen viene usata per l'accesso

Diagramma esplicativo

🔍 Passaggi

$ ssh-keygen -t ed25519 -C user@example.comssh-copy-id -i ~/.ssh/id_ed25519.pub user@192.0.2.10ssh -i ~/.ssh/id_ed25519 user@192.0.2.10

💻 Il mio computer ~/.ssh

🔒id_ed25519Chiave privata · non esce mai

🔑id_ed25519.pubUna riga di chiave pubblica · copiata sul server

➜Non ancora sul serverUna riga di chiave pubblica copiataIl server verifica con la chiave pubblica

🖥️ Server ~/.ssh/authorized_keys

📄VuotoAccesso solo con password

🔑ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIJVLiw04ugfXq15n2m8ZDW0OywkRoug8beXw/9VnVY/L user@example.comChiave pubblica registrata · passa solo la chiave privata che fa coppia con questa riga

ssh-keygen crea la chiave privata e quella pubblica come coppia. La chiave privata resta solo in ~/.ssh sul tuo computer, e quella pubblica è la riga del file .pub. In questo passaggio sul server non c'è ancora nulla, quindi accedi solo con la password.

ssh-copy-id aggiunge la riga della chiave pubblica alla fine di ~/.ssh/authorized_keys sul server. La chiave privata non viene copiata. La chiave pubblica non deve restare segreta, quindi puoi inserire la stessa riga su più server.

Alla connessione, il server usa la chiave pubblica in authorized_keys per verificare la firma della tua chiave privata. Se la coppia corrisponde accedi senza password; su un computer senza il file della chiave privata, la password viene chiesta anche per lo stesso account.

ssh-copy-id -n -i ~/.ssh/deploy_key.pub -o ConnectTimeout=3 user@192.0.2.10

/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/user/.ssh/deploy_key.pub"
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed

/usr/bin/ssh-copy-id: ERROR: ssh: connect to host 192.0.2.10 port 22: Connection timed out

-n è un dry-run, quindi sul server non viene scritto nulla. Ciononostante ssh-copy-id prova prima ad accedere con quella chiave per scartare quelle già registrate, e siccome 192.0.2.10 è un indirizzo riservato alla documentazione, la connessione non è riuscita ed è terminato con timed out. Le opzioni dopo -o passano così come sono a ssh.

ssh-copy-id -n -f -i ~/.ssh/deploy_key.pub -o ConnectTimeout=3 user@192.0.2.10

/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/user/.ssh/deploy_key.pub"
=-=-=-=-=-=-=-=
Would have added the following key(s):

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKKphFOc7oiKNpIHFTzK/ippCS5U5D+lF3xmXM6dmYjk deploy@example.com
=-=-=-=-=-=-=-=

-f è la modalità forzata che salta questo controllo. Insieme a -n, la riga di chiave pubblica che andrebbe sul server è comparsa sotto Would have added. È la stessa riga del contenuto del file .pub.

ssh-copy-id -i ~/.ssh/id_ed25519.pub user@192.0.2.10

La registrazione vera si fa con questo comando senza -n. Secondo lo script di ssh-copy-id e il manuale, chiede una volta la password dell'account, aggiunge la chiave pubblica alla fine di ~/.ssh/authorized_keys sul server e poi stampa Number of key(s) added: 1. Se file e cartella mancano li crea, e se la stessa chiave c'è già la salta.

ssh-copy-id -i ~/.ssh/id_ed25519.pub -p 2222 user@192.0.2.10

Se la porta non è la 22, passala con -p.

Dove manca ssh-copy-id, aggiungi tu la riga della chiave pubblica in authorized_keys sul server. Accedi al server con la password e segui l'ordine qui sotto. L'output è stato verificato aggiungendo il file .pub sullo stesso server; su un server diverso copia la riga del file .pub e aggiungila con echo.

mkdir -p ~/.ssh

chmod 700 ~/.ssh

Se la cartella .ssh non esiste, creala e imposta i permessi a 700.

cat ~/.ssh/deploy_key.pub >> ~/.ssh/authorized_keys

chmod 600 ~/.ssh/authorized_keys

cat ~/.ssh/authorized_keys

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKKphFOc7oiKNpIHFTzK/ippCS5U5D+lF3xmXM6dmYjk deploy@example.com

ls -l ~/.ssh/authorized_keys

-rw------- 1 user user 100 Oct 29 08:22 /home/user/.ssh/authorized_keys

La riga della chiave pubblica è entrata in authorized_keys con permessi 600. La voce StrictModes del manuale di sshd_config indica che con le impostazioni predefinite sshd controlla prima i permessi dei file dell'utente e rifiuta l'accesso se chiunque può scriverci.

ssh -i ~/.ssh/id_ed25519 user@192.0.2.10

Finita la registrazione, collegati con la chiave privata. Se la chiave ha un nome predefinito come id_ed25519, ssh la trova da solo; se ha un altro nome come deploy_key, indica il file con l'opzione ssh -i.

🔲 Simulatore del comando ssh-keygen

Nel simulatore qui sotto puoi digitare tu stesso ssh-keygen per creare chiavi, controllare le impronte, cambiare la passphrase, ripulire known_hosts e provare ssh-copy-id. Impronte e chiavi pubbliche sono gli stessi valori di esempio dell'articolo, e ssh-copy-id si limita a simulare la registrazione su un server virtuale.

Simulatore del comando ssh-keygenOpenSSH 9.9p1 · user

[root@server work]#

Con i tasti ↑↓ richiami i comandi digitati prima.

🔢 FAQ & contenuti consigliati

Il valore predefinito di ssh-keygen è ed25519, e la chiave è corta: la riga della chiave pubblica era di 98 byte. La chiave pubblica rsa a 4096 bit era di 742 byte; rsa si usa per collegarsi a server o dispositivi vecchi che non accettano ed25519.

Sì. Secondo il manuale di ssh, ssh cerca da solo solo i nomi predefiniti come ~/.ssh/id_ed25519 e ~/.ssh/id_rsa; per un altro nome indicalo con -i quando ti colleghi oppure scrivilo in IdentityFile di ~/.ssh/config.

Secondo il manuale di sshd_config, imposta PasswordAuthentication su no e fai rileggere la configurazione a sshd. Disattivalo solo dopo aver verificato in un altro terminale che l'accesso con chiave funziona. Se lo disattivi prima di verificare, puoi restare chiuso fuori dal server senza poter entrare né con la password né con la chiave.

🔝 Comandi Linux

🔗 Contenuti consigliati

Passo successivo Come accedere a Cloudways in SFTP & SSH: impostazioni di FileZilla e registrazione delle chiavi SSH Ho riprodotto in simulatori l'SFTP con FileZilla e l'accesso dal terminale SSH web e da PowerShell, e verificato su un server di test la registrazione delle chiavi SSH e la whitelist IP. Leggi l'articolo →

Schermata del simulatore FileZilla per la connessione SFTP a Cloudways

Procedura guidata di Xshell per generare chiavi utente - impostazione dei parametri di generazione

Windows · Chiave pubblica Come generare una chiave pubblica in Xshell Passaggi per creare una chiave pubblica con la procedura guidata del client SSH per Windows Xshell e registrarla su un server.

SSH · Impostazioni del server Configurazione SSH: funzioni e impostazioni del file sshd_config Articolo su come impostare, nel sshd_config del server che riceve la connessione, voci come la porta, l'accesso root e l'autenticazione con chiave pubblica.

Linux · Concetti SSH su Linux: definizione e impostazioni di base Che cos'è SSH, in cosa differisce da Telnet e come avviare sshd su un server e controllarne le impostazioni di base.

🪐RiferimentiFonti ufficiali 2

📡ssh-keygen(1) — OpenBSD manual pages 📡ssh-copy-id(1) — Linux manual page

ℹ️ Informativa sull'affiliazione
I contenuti di questo sito includono link di affiliazione. Se un visitatore acquista un prodotto o un servizio tramite uno di questi link, il sito riceve una commissione dal venditore. In questo processo l'importo pagato dall'acquirente^{(durante le promozioni l'importo scende↓)} non aumenta. Prezzi, sconti e disponibilità indicati si riferiscono al momento della stesura e possono differire da quelli reali: prima di acquistare verifica sempre presso il venditore. I prodotti vengono scelti e valutati secondo criteri propri, e le commissioni non influiscono sull'ordine di presentazione né sul contenuto delle valutazioni.