Corriger l’erreur « $ is not recognized » dans Windows CMD : GPG, PowerShell, WSL, Git Bash

Vous copiez une commande depuis une documentation et Windows affiche : “$ is not recognized as an internal or external command”. Voici la cause exacte, la solution immédiate et des procédures détaillées pour CMD, PowerShell, WSL, Git Bash et Cygwin, avec tous les pièges à éviter.

Sommaire

Erreur « `$` is not recognized as an internal or external command » : comprendre le symptôme

Dans de nombreuses documentations orientées Unix, chaque ligne de commande est précédée d’un symbole de prompt : $ pour un utilisateur non‑root et # pour root. Exemple :

$ gpg --import ./mykey.gpg

Si vous collez cette ligne telle quelle dans l’Invite de commandes Windows (CMD) ou dans PowerShell, Windows tente d’exécuter un programme nommé $. Comme il n’existe pas, le système répond :

'$' is not recognized as an internal or external command,
operable program or batch file.

Autrement dit, le $ n’est pas un interprète de commandes sous Windows ; c’est un simple symbole de prompt issu des shells Unix (bash, zsh…). Il ne fait pas partie de la commande.

Solution express

Supprimez le caractère $ au début de la ligne : exécutez gpg --import ./mykey.gpg dans CMD.
Choisissez le shell adapté : si la documentation est pensée pour Unix, utilisez WSL, Git Bash ou Cygwin plutôt que CMD.
Vérifiez GPG : assurez‑vous que gpg.exe est installé et présent dans PATH (test : gpg --version).
Validez l’import : exécutez gpg --list-keys pour confirmer la présence de la clé dans le trousseau.

Procédure détaillée sous CMD

CMD accepte les commandes sans le symbole $. Si votre fichier se trouve dans le dossier courant :

gpg --import .\mykey.gpg
gpg --list-keys

À noter : .\ est la notation PowerShell ; CMD accepte généralement .\ mais préfère les chemins au format Windows :

gpg --import mykey.gpg
gpg --import C:\Users\<Vous>\Downloads\mykey.gpg

Les chemins Windows utilisent \ comme séparateur.
Entourez de guillemets doubles un chemin contenant des espaces : "C:\Mon Dossier\mykey.gpg".

Procédure détaillée sous PowerShell

PowerShell exécute les mêmes commandes GPG, mais la convention pour les chemins relatifs est .\ (point + antislash) :

gpg --import .\mykey.gpg
gpg --list-keys

Différences utiles par rapport à CMD :

Variables d’environnement : $env:Path au lieu de %PATH%.
Interpolation : les guillemets doubles "…" interprètent les variables, les simples '…' non.
Continuation de ligne : utilisez l’accent grave (`), pas la barre oblique inverse.

Utiliser un shell compatible Unix (WSL, Git Bash, Cygwin)

Si la documentation fournit des commandes explicitement prévues pour bash/zsh (avec pipes, substitutions $(…), redirections avancées…), exécutez‑les dans un environnement Unix pour Windows :

WSL (Windows Subsystem for Linux) : Ubuntu/Debian/Fedora disponibles directement dans Windows ; le prompt $ y est normal.
Git Bash : livré avec Git pour Windows, pratique pour les scripts légers.
Cygwin : offre une couche de compatibilité POSIX riche en utilitaires.

Dans ces environnements, vous pouvez coller la commande telle quelle :

$ gpg --import ./mykey.gpg
$ gpg --list-keys

Le $ affiché est seulement le prompt d’affichage ; ne le copiez pas si vous transférez ensuite la commande vers CMD/PowerShell.

Tableau de correspondance des syntaxes entre shells

Concept	CMD	PowerShell	Bash (WSL/Git Bash/Cygwin)
Symbole de prompt	`>` (par défaut)	`>` (par défaut)	`$` (utilisateur), `#` (root)
Chemin relatif au dossier courant	`.` ou direct (`fichier.ext`)	`.\fichier.ext`	`./fichier.ext`
Séparateur de chemin	`\`	`\`	`/`
Variable d’environnement PATH	`%PATH%`	`$env:Path`	`$PATH`
Guillemets pour chemins avec espaces	`"…"`	`"…"` (interp.) ou `'…'` (litt.)	`'…'` (litt.) ou `"…"` (interp.)
Continuation de ligne	`^` à la fin	` à la fin	`\` à la fin
Redirection de sortie	`>`, `>>`	`>`, `>>`	`>`, `>>`
Exécuter un programme du dossier courant	`program.exe` (ou `.\program.exe`)	`.\program.exe`	`./program`

Vérifier l’installation et le chemin de `gpg.exe`

Si vous rencontrez plutôt “gpg is not recognized as an internal or external command”, GPG n’est pas installé ou son binaire n’est pas dans le PATH.

Étapes de contrôle

Tester la présence : gpg --version. Si la commande répond avec une version, GPG est installé et accessible.
Localiser GPG : vérifiez les dossiers habituels, par exemple :
- C:\Program Files\GnuPG\bin\gpg.exe
- C:\Program Files (x86)\GnuPG\bin\gpg.exe
Ajouter au PATH :
1. Ouvrez Paramètres système avancés → Variables d’environnement….
2. Éditez la variable Path de votre compte (ou du système) et ajoutez le dossier contenant gpg.exe.
3. Fermez/rouvrez le terminal puis retestez gpg --version.

PowerShell permet d’inspecter rapidement le chemin effectif :

$env:Path -split ';' | Where-Object { $_ -match 'GnuPG' }

Importer et authentifier une clé : exemples concrets

Imports typiques

CMD :

gpg --import "C:\Users\<Vous>\Downloads\mykey.gpg"
gpg --list-keys

PowerShell :

gpg --import .\mykey.gpg
gpg --list-keys

WSL / Git Bash / Cygwin :

gpg --import ./mykey.gpg
gpg --list-keys

Interpréter les messages GPG

“gpg: key <ID>: public key imported” : la clé publique est bien importée.
“gpg: Total number processed: 1 / imported: 1” : succès.
“gpg: key <ID>: already in secret keyring” : vous aviez déjà la clé.
“gpg: no valid OpenPGP data found” : le fichier ne contient pas de données GPG valides (mauvais fichier ou corruption).
“gpg: can’t open ‘…’ : No such file or directory” : chemin incorrect ou guillemets manquants.

Authentifier la clé (marquer la confiance)

Selon le contexte (signature logicielle, dépôt package, etc.), vous pouvez définir un niveau de confiance :

gpg --edit-key <ID_OU_EMAIL>
gpg> trust
gpg> 5  (ultimately)
gpg> quit

Adaptez la valeur de confiance aux politiques de votre organisation.

Traduire correctement une documentation Unix vers Windows

En plus du $, plusieurs détails de syntaxe exigent une adaptation. Voici une aide‑mémoire.

Exemple dans la doc	Signification	Équivalent CMD	Équivalent PowerShell
`$ gpg --import ./mykey.gpg`	Commande bash (prompt + exécution)	`gpg --import mykey.gpg`	`gpg --import .\mykey.gpg`
`echo $PATH`	Afficher `PATH`	`echo %PATH%`	`$env:Path`
`./program`	Exécuter binaire du dossier courant	`program.exe` ou `.\program.exe`	`.\program.exe`
`VAR=value command`	Variable d’env. temporaire	`set VAR=value & command`	`$env:VAR='value'; command`
`cmd1 \` `\| cmd2`	Continuation + pipe	`cmd1 ^` `\| cmd2`	cmd1 ` `\| cmd2`

Pièges fréquents et correctifs

Copier le prompt : supprimez systématiquement $ ou # quand vous collez dans Windows.
Chemins avec espaces : entourez de guillemets : "C:\Mes Clés\my key.gpg".
Fin de ligne : une commande Unix sur plusieurs lignes with \ doit être réassemblée pour CMD/PowerShell ou réécrite avec leurs opérateurs de continuation (^ / `).
Extensions masquées : vérifiez que le fichier est bien .gpg (Windows peut masquer les extensions).
Permissions : l’import de clé ne requiert pas forcément un terminal Administrateur. Essayez d’abord sans élévation.
Encodage : évitez d’ouvrir/éditer la clé dans un éditeur qui pourrait altérer le fichier (sauts de ligne, BOM, etc.).
Variables d’environnement non prises en compte : après modification de PATH, rouvrez la fenêtre CMD/PowerShell pour recharger l’environnement.

Checklist de dépannage rapide

La commande commence‑t‑elle par $ ? Retirez‑le.
Dans quel shell suis‑je ? CMD, PowerShell ou un shell Unix (WSL/Git Bash/Cygwin) ?
GPG est‑il accessible ? gpg --version doit afficher une version.
Le chemin du fichier est‑il correct et entre guillemets si nécessaire ?
La commande d’import réussit‑elle ? Vérifiez avec gpg --list-keys.
Besoin d’une approche Unix ? Basculer sur WSL, Git Bash ou Cygwin et exécuter la commande telle que documentée.

Cas d’usage : procédures de signature logicielle

Pour npm, apt, ou la vérification d’artefacts signés, l’import et la gestion des clés sont essentiels. Recommandations concrètes :

Séparez clés publiques et privées dans des dossiers explicites (PublicKeys, PrivateKeys), hors répertoires synchronisés si la confidentialité est critique.
Hachez vos clés/artefacts pour les comparer : CertUtil -hashfile .\mykey.gpg SHA256 (CMD/PowerShell).
Documentez la provenance (source, date, fingerprint) dans un fichier texte stocké avec la clé.
Vérifiez régulièrement les empreintes (gpg --fingerprint <ID>) et révoquez si nécessaire (gpg --delete-key / --delete-secret-keys).

Exemples prêts à copier (sans le `$`)

CMD

gpg --version
gpg --import "C:\Users\<Vous>\Downloads\mykey.gpg"
gpg --list-keys

PowerShell

gpg --version
gpg --import .\mykey.gpg
gpg --list-keys

WSL / Git Bash / Cygwin

gpg --version
gpg --import ./mykey.gpg
gpg --list-keys

Questions fréquentes

Pourquoi certaines docs ajoutent‑elles un $ au début ?
Pour indiquer visuellement le prompt d’un shell Unix. C’est un marqueur d’interface, pas une partie de la commande.

Je vois parfois # au lieu de $ ; quelle différence ?
# indique généralement un prompt exécuté en tant que root. Sur Windows, cela n’a pas de sens direct ; ignorez le symbole.

Je dois exécuter des pipelines complexes avec |, xargs, substitutions $(…)…
Utilisez WSL, Git Bash ou Cygwin ; la réécriture pour CMD/PowerShell peut devenir lourde.

gpg --import renvoie “No such file or directory”
Revérifiez le chemin, les guillemets, les antislashs vs slashs et le dossier courant (cd).

Faut‑il exécuter CMD “en tant qu’administrateur” ?
Non, pas nécessaire pour un import de clé standard. Élevez uniquement si votre politique de sécurité ou un chemin protégé l’exige.

Bonnes pratiques pour éviter l’erreur à l’avenir

Ne copiez jamais le prompt ($ / # / >) lorsque vous copiez une commande.
Préférez un shell cohérent avec la documentation : WSL/Git Bash/Cygwin si la doc parle d’Unix ; CMD ou PowerShell si elle cible Windows.
Créez un “bloc note” d’adaptation avec vos conversions types (chemins, variables, continuations de ligne).
Vérifiez le binaire (gpg --version) avant les opérations sensibles.
Documentez les empreintes des clés importées (gpg --fingerprint), surtout en contexte de CI/CD.

Résumé opérationnel

Le message “$ is not recognized as an internal or external command” provient du fait que Windows tente d’exécuter le caractère $ comme s’il s’agissait d’un programme. Retirez ce symbole, adaptez les chemins et, si la commande dépend de fonctionnalités Unix, utilisez un shell approprié (WSL, Git Bash, Cygwin). Vérifiez que gpg.exe est accessible dans PATH, puis confirmez l’import via gpg --list-keys. En suivant ces étapes, vous éliminerez l’erreur et sécuriserez votre flux de travail de signature et de vérification.

Référence rapide : commandes clés

gpg --version — vérifier l’installation.
gpg --import <chemin> — importer une clé.
gpg --list-keys — lister les clés publiques.
gpg --list-secret-keys — lister les clés privées.
gpg --fingerprint <ID> — afficher l’empreinte d’une clé.

Conclusion

L’erreur liée au symbole $ n’est pas un bug de Windows ni un problème de GPG : c’est simplement un artefact de documentation hérité d’Unix. La correction est immédiate (supprimer $) et la réussite dépend surtout de l’adaptation de la syntaxe au shell choisi. Munis des équivalences ci‑dessus, vous pouvez passer sans friction de la doc Unix à un environnement Windows moderne (CMD/PowerShell) ou, à l’inverse, choisir un shell Unix natif (WSL/Git Bash/Cygwin) lorsque c’est plus adapté.