ssh-keygen : créer des clés SSH, enregistrer la clé publique et utiliser ssh-copy-id

ssh-keygen est la commande OpenSSH qui crée la paire de clé privée et clé publique utilisée pour les connexions SSH, et qui sert aussi à vérifier les empreintes, changer la phrase secrète et nettoyer known_hosts. J'ai créé des clés ed25519 et rsa sur un serveur AlmaLinux 9, vérifié leurs empreintes, changé la phrase secrète et le commentaire, puis testé ssh-copy-id en dry-run : la seule chose qui part vers le serveur est la ligne de clé publique du fichier .pub.

Les noms de compte et les chemins des fichiers de clé dans la sortie ci-dessous sont des valeurs d'exemple, et les empreintes, les clés publiques et le randomart proviennent de clés créées pour cet article puis supprimées. La commande qui enregistre réellement une clé publique sur un serveur est indiquée, mais elle n'a pas été exécutée.

1️⃣ Créer une clé avec ssh-keygen : -t ed25519 et le commentaire -C

Une clé se crée sous la forme ssh-keygen -t type -C commentaire. -t est le type de clé et -C un commentaire ajouté à la fin de la clé publique, où l'on écrit une adresse e-mail ou l'usage de la clé. Voici la sortie complète avec le fichier indiqué par -f et Entrée pressée aux deux questions de phrase secrète.

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]-----+

Si vous appuyez seulement sur Entrée à la question de phrase secrète, la clé n'a pas de phrase secrète. Sans -f, une ligne demandant où enregistrer le fichier apparaît avant cette question. Le chemin par défaut, .ssh/id_ed25519 dans votre dossier personnel, est indiqué entre parenthèses, et un simple Entrée enregistre la clé à cet endroit.

Le randomart à la fin de la sortie est l'empreinte transformée en dessin. Le même dessin est apparu à la création de la clé et lors d'une nouvelle vérification avec -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 clé privée a été créée avec les droits 600 et la clé publique avec 644. Gardez la clé privée uniquement sur votre ordinateur et ne l'envoyez nulle part.

cat ~/.ssh/id_ed25519.pub

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

La clé publique est une seule ligne composée du type de clé, de la valeur de la clé et du commentaire, séparés par des espaces. C'est cette ligne qui va dans le fichier authorized_keys du serveur auquel vous vous connectez. Le rôle de chaque fichier du dossier est regroupé dans une arborescence.

2️⃣ Options de ssh-keygen : -f, -N, -b, -q

Répondre aux questions est pratique quand on tape à la main, mais dans un script il faut supprimer les questions. En fixant le fichier avec -f et la phrase secrète avec -N, la clé est créée tout de suite, sans question.

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]-----+

Avec des guillemets vides après -N, la clé n'a pas de phrase secrète, et l'emplacement et l'empreinte sont apparus d'un coup, sans aucune question.

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)?

Relancée avec le même nom, la commande demande après already exists s'il faut écraser le fichier. Avec n, rien n'a changé et elle s'est terminée avec le code de sortie 1. Pour ne pas écraser par erreur une clé en service, créez les nouvelles clés sous un autre nom.

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]-----+

Pour rsa, -b fixe la longueur. D'après le manuel, la valeur par défaut est 3072 bits ; ci-dessus, la clé a été créée en 4096 bits et RSA 4096 est apparu en tête du randomart. Le manuel précise que ed25519 a une longueur fixe et que -b est alors ignoré.

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]-----+

Sans -t, une clé ed25519 a été créée.

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

rc=0

Avec -q, tout est masqué, y compris l'empreinte et le randomart, et il ne reste que le code de sortie. Utile quand un script crée des clés pour plusieurs serveurs.

📌 Options principales : résultats de cet article

📎 Autres options : selon le manuel officiel

3️⃣ ssh-keygen -l pour l'empreinte et -y pour extraire la clé publique

Avec plusieurs fichiers de clé, il est difficile de savoir d'après le seul nom quelle clé publique va avec quelle clé privée. Comme l'empreinte est identique pour la clé privée et la clé publique, comparer avec -l les empreintes des deux fichiers confirme la paire.

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)

Le fichier de clé publique et le fichier de clé privée ont donné la même empreinte SHA256. Le 256 au début est la longueur de la clé, et la parenthèse à la fin le type de clé.

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)

Avec -E md5, l'affichage passe à l'ancien format d'empreinte MD5. Cela sert à comparer quand un vieux serveur ou une interface d'administration affiche des empreintes 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]-----+

En ajoutant -v, le randomart réapparaît. C'était le même dessin que celui affiché à la création de la clé.

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

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

Si vous donnez un fichier contenant plusieurs lignes de clé publique, comme authorized_keys, vous obtenez une ligne d'empreinte par clé. C'est ainsi que l'on vérifie quelles clés sont enregistrées sur un serveur.

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

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

-y extrait de nouveau la clé publique à partir de la clé privée. Si vous avez supprimé le fichier .pub ou déplacé seulement la clé privée vers un autre ordinateur, il suffit d'enregistrer cette sortie dans un fichier. La sortie était identique au caractère près au fichier .pub d'origine.

4️⃣ ssh-keygen -p pour changer la phrase secrète et -c pour changer le commentaire

Avec une phrase secrète sur la clé privée, le fichier est inutilisable sans elle, même s'il fuite. En contrepartie, il faut la saisir à chaque connexion : elle convient aux clés utilisées à la main, pas aux clés de scripts qui tournent seuls, comme les tâches 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 est l'ancienne phrase secrète et -N la nouvelle. La clé n'en avait pas, donc -P a reçu des guillemets vides, et deux lignes ont indiqué un nouvel enregistrement avec la nouvelle phrase secrète. D'après le manuel, -p seul, sans options, demande tour à tour l'ancienne et la nouvelle phrase secrète.

ls -l ~/.ssh/id_ed25519

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

Après l'ajout de la phrase secrète, le fichier de clé privée est passé de 411 à 464 octets.

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

Pour une clé protégée par une phrase secrète, -y a lui aussi besoin de la phrase passée avec -P. Avec la bonne phrase, la même clé publique qu'avant est apparue, et avec une mauvaise, la commande s'est terminée sur l'erreur incorrect passphrase. Le manuel précise qu'une phrase secrète perdue ne peut pas être récupérée : si vous l'oubliez, créez une nouvelle clé et enregistrez de nouveau la clé publique.

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 change le commentaire. L'ancien et le nouveau commentaire s'affichent chacun sur une ligne, et le commentaire à la fin du fichier de clé publique est aussi devenu user@laptop. Le commentaire n'est qu'une étiquette pour distinguer les clés : la valeur de la clé n'a pas changé.

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.

Pour retirer la phrase secrète, passez des guillemets vides à -N. Les deux mêmes lignes apparaissent, et ensuite -y a de nouveau fonctionné sans -P.

5️⃣ ssh-keygen -R pour supprimer une clé d'hôte de known_hosts

known_hosts accumule, une ligne par serveur, les clés d'hôte des serveurs auxquels vous vous êtes connecté. Si un serveur est réinstallé et que sa clé d'hôte change, ssh refuse la connexion parce que la clé diffère de celle enregistrée, et l'option qui supprime l'ancienne ligne est -R. Le known_hosts ci-dessous est un fichier de trois lignes avec des adresses d'exemple, indiqué avec -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

Chaque ligne contient le nom d'hôte ou l'adresse, le type de clé et la valeur de la clé, dans cet ordre. La deuxième ligne, avec une virgule, donne le nom et l'adresse du même serveur, et les crochets avec deux-points de la troisième ligne indiquent un port autre que 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 affiche la ligne de cet hôte avec son numéro de ligne. Pour un hôte absent, rien ne s'est affiché et la commande s'est terminée avec le code de sortie 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 supprime la ligne de cet hôte et garde le fichier d'origine sous le nom known_hosts.old. Après la suppression, il ne restait que deux lignes.

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

Avec un hôte absent, seule une ligne not found est apparue. Pour un serveur sur un autre port, il faut indiquer les crochets et le port tels qu'ils figurent dans 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 hache les noms d'hôte et les adresses. Cette option évite qu'un fichier qui fuite révèle à quels serveurs vous vous êtes connecté ; le nom et l'adresse qui étaient joints par une virgule ont été séparés en deux lignes hachées. Un avertissement indiquant que le fichier .old contient encore le contenu non haché est aussi apparu.

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

Même dans le fichier haché, -F a retrouvé la ligne par le nom.

6️⃣ ssh-copy-id pour enregistrer la clé publique et authorized_keys

Créer une clé ne suffit pas : tant que le serveur ne connaît pas la clé publique, la connexion se fait toujours par mot de passe. L'endroit où le serveur apprend la clé publique est ~/.ssh/authorized_keys du compte auquel vous vous connectez, et ssh-copy-id est la commande qui ajoute la ligne du .pub dans ce fichier. La clé privée reste sur votre ordinateur et seule la ligne de clé publique est transmise. Cliquez sur les boutons d'étape du schéma ci-dessous pour voir où se trouvent les deux fichiers.

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 est un dry-run : rien n'est écrit sur le serveur. Malgré tout, ssh-copy-id essaie d'abord de se connecter avec cette clé pour écarter les clés déjà enregistrées, et comme 192.0.2.10 est une adresse réservée à la documentation, la connexion n'a pas abouti et la commande s'est terminée sur timed out. Les options après -o sont transmises telles quelles à 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 est le mode forcé qui saute cette vérification. Avec -n, la ligne de clé publique qui irait sur le serveur est apparue sous Would have added. C'est la même ligne que le contenu du fichier .pub.

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

L'enregistrement réel se fait avec cette commande sans -n. D'après le script ssh-copy-id et son manuel, elle demande une fois le mot de passe du compte, ajoute la clé publique à la fin de ~/.ssh/authorized_keys sur le serveur, puis affiche Number of key(s) added: 1. Elle crée le fichier et le dossier s'ils n'existent pas et ignore la clé si elle est déjà présente.

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

Si le port n'est pas 22, indiquez-le avec -p.

Là où ssh-copy-id n'existe pas, ajoutez vous-même la ligne de clé publique au fichier authorized_keys du serveur. Connectez-vous au serveur avec votre mot de passe et suivez les étapes ci-dessous. La sortie a été vérifiée en ajoutant le fichier .pub sur le même serveur ; sur un autre serveur, copiez la ligne du fichier .pub et ajoutez-la avec echo.

mkdir -p ~/.ssh

chmod 700 ~/.ssh

Si le dossier .ssh n'existe pas, créez-le et réglez ses droits sur 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 ligne de clé publique est entrée dans authorized_keys, avec les droits 600. L'entrée StrictModes du manuel de sshd_config indique qu'avec les réglages par défaut, sshd vérifie d'abord les droits des fichiers de l'utilisateur et refuse la connexion s'ils sont modifiables par tout le monde.

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

Une fois l'enregistrement terminé, connectez-vous avec la clé privée. Si la clé a un nom par défaut comme id_ed25519, ssh la trouve tout seul ; si elle a un autre nom comme deploy_key, indiquez le fichier avec l'option ssh -i.

🔲 Simulateur de la commande ssh-keygen

Dans le simulateur ci-dessous, vous pouvez taper vous-même ssh-keygen pour créer des clés, vérifier les empreintes, changer la phrase secrète, nettoyer known_hosts et essayer ssh-copy-id. Les empreintes et les clés publiques sont les mêmes valeurs d'exemple que dans l'article, et ssh-copy-id ne fait que simuler l'enregistrement sur un serveur virtuel.

🔢 FAQ & contenus recommandés

🔗 Articles recommandés

Étape suivante Se connecter à Cloudways en SFTP & SSH : configurer FileZilla, ajouter une clé SSH Les connexions SFTP avec FileZilla, par terminal SSH web et par PowerShell reproduites en simulateur, avec l'ajout d'une clé SSH et la liste blanche d'IP vérifiés sur un serveur de test. Lire l'article →

Windows · Clé publique Générer une clé publique avec Xshell Étapes pour créer une clé publique avec l'assistant de génération de clés du client SSH Windows Xshell et l'enregistrer sur un serveur. SSH · Réglages du serveur Configuration SSH : fonctions et réglages du fichier sshd_config Article sur le réglage, dans le sshd_config du serveur qui reçoit la connexion, d'éléments comme le port, la connexion root et l'authentification par clé publique. Linux · Notions SSH sous Linux : définition et configuration de base Ce qu'est SSH et en quoi il diffère de Telnet, puis comment démarrer sshd sur un serveur et vérifier sa configuration de base.

ℹ️ Mention d'affiliation
Le contenu de ce site contient des liens d'affiliation. Lorsqu'un visiteur achète un produit ou un service via l'un de ces liens, le site perçoit une commission du vendeur. Le montant payé par l'acheteur^{(il baisse lors des promotions ↓)}, lui, n'augmente pas. Les prix, remises et stocks indiqués correspondent à la date de rédaction et peuvent différer ; vérifiez-les donc auprès du vendeur avant d'acheter. Les produits sont choisis et évalués selon nos propres critères, et les commissions n'influencent ni l'ordre de présentation ni le contenu des évaluations.