Question Comment dire à git quelle clé privée utiliser?


ssh a la -i option pour indiquer quel fichier de clé privée utiliser lors de l'authentification:

-i fichier d'identité

    Sélectionne un fichier à partir duquel   l'identité (clé privée) pour l'authentification RSA ou DSA est lue.   La valeur par défaut est ~/.ssh/identity pour le protocole version 1,   et ~/.ssh/id_rsa et ~/.ssh/id_dsa pour le protocole version 2.   Les fichiers d'identité peuvent également être spécifiés par hôte   dans le fichier de configuration. Il est possible d'avoir plusieurs -i options    (et plusieurs identités spécifiées dans les fichiers de configuration).

Y a-t-il une façon similaire de dire git quel fichier de clé privée utiliser sur un système avec plusieurs clés privées dans le ~/.ssh annuaire?


463
2018-01-12 18:20


origine


Voir cette question dans StackOverflow ainsi que. - Flimm
Aussi lié serverfault.com/questions/194567/... - Machavity


Réponses:


Dans ~/.ssh/config, ajouter:

host github.com
 HostName github.com
 IdentityFile ~/.ssh/id_rsa_github
 User git

Maintenant tu peux faire git clone git@github.com:username/repo.git.

REMARQUE: Vérifiez que les autorisations sur IdentityFile sont 400.SSH rejettera, de manière non explicite, les clés SSH trop lisibles. Cela ressemblera simplement à un rejet d'informations d'identification. La solution, dans ce cas, est la suivante:

chmod 400 ~/.ssh/id_rsa_github

513
2018-01-12 19:36



Que faire si vous devez vous connecter au même hôte avec des clés différentes? - Valentin Klinghammer
@Quelltextfabrik - vous pouvez ajouter une autre section avec un hôte différent: nerderati.com/2011/03/... - Ben Challenor
@Cliff Nop, dans ma page de manuel: "HostName: Spécifie le nom d'hôte réel auquel se connecter. Cela peut être utilisé pour spécifier des pseudonymes ou des abréviations pour les hôtes. "Ma version ssh est openssh-6.7p1. - Grissiom
@Grissiom C'est exactement ce que ça dit. Mais vous semblez comprendre la signification à l'envers. Host (ou Match) est requis. Pour créer un pseudonyme d'hôte, placez le pseudonyme dans la ligne Hôte et le nom d'hôte réel dans la ligne HostName. Exemples: saltycrane.com/blog/2008/11/... - Cliff
Si le fichier de configuration est nouveau, n'oubliez pas de le faire chmod 600 ~/.ssh/config - elysch


Variable d'environnement GIT_SSH_COMMAND:

A partir de la version 2.3.0 de Git, vous pouvez utiliser la variable d'environnement GIT_SSH_COMMAND comme ça:

GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa_example" git clone example

Notez que -i peut parfois être remplacé par votre fichier de configuration, auquel cas, vous devriez donner à SSH un fichier de configuration vide, comme ceci:

GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa_example -F /dev/null" git clone example

Configuration core.sshCommand:

A partir de la version 2.10.0 de Git, vous pouvez configurer ceci par référentiel ou globalement, vous n'avez donc plus besoin de définir la variable d'environnement!

git config core.sshCommand "ssh -i ~/.ssh/id_rsa_example -F /dev/null"
git pull
git push

215
2018-05-08 09:43



Je devais exporter le coquille variable à une variable d'environnement pour faire ce travail, c'est à dire export GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa_example", puis git clone example - Abdull
@Abdull Dans Bash, effectuez l'affectation sur la même ligne que la commande et exportez la variable d'environnement pour cette seule commande. Essayez-le: example=hello /usr/bin/env | grep example. - Flimm
les choses sont devenues encore meilleures: à partir de Git 2.10, vous pouvez stocker la commande dans votre configuration Git: stackoverflow.com/a/38474220/520162 - eckes
@Noitidart /dev/null est uniquement un nom de fichier valide dans les systèmes d'exploitation de type UNIX, il ne fonctionne pas sous Windows. - Flimm
Si vous avez besoin de plusieurs clés, le paramètre -i peut être répété et ssh essaiera chaque clé à son tour. git config core.sshcommand "ssh -i /path/to/keyA -i /path/to/keyB". Cela permet à git d'utiliser différentes clés avec différents hôtes distants. - Mark


Il y a non direct façon dire git quelle clé privée utiliser, car elle repose sur ssh pour l'authentification du référentiel. Cependant, il y a encore quelques manières d'atteindre votre objectif:

Option 1: ssh-agent

Vous pouvez utiliser ssh-agent pour autoriser temporairement votre clé privée.

Par exemple:

$ ssh-agent sh -c 'ssh-add ~/.ssh/id_rsa; git fetch user@host'

Option 2: GIT_SSH_COMMAND

Passez les arguments ssh en utilisant le GIT_SSH_COMMAND variable d'environnement (Git 2.3.0+).

Par exemple:

$ GIT_SSH_COMMAND='ssh -i ~/.ssh/id_rsa -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no' \
  git clone user@host

Vous pouvez taper tout cela sur une seule ligne - ignorer $ et laisser de côté \.

Option 3: GIT_SSH

Passez les arguments ssh en utilisant le GIT_SSH variable d'environnement pour spécifier alternatif ssh binaire.

Par exemple:

$ echo 'ssh -i ~/.ssh/id_rsa -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no $*' > ssh
$ chmod +x ssh
$ GIT_TRACE=1 GIT_SSH='./ssh' git clone user@host

Note: Les lignes ci-dessus sont des lignes de commande shell (terminal) que vous devez coller dans votre terminal. Ils vont créer un fichier nommé ssh, rendez-le exécutable et (indirectement) exécutez-le.

Remarque: GIT_SSH est disponible depuis la v0.99.4 (2005).

Option 4: ~/.ssh/config

Utilisez le ~/.ssh/config fichier comme suggéré dans d'autres réponses afin de spécifier l'emplacement de votre clé privée, par exemple

Host github.com
  User git
  Hostname github.com
  IdentityFile ~/.ssh/id_rsa

62
2018-01-23 22:08



//, Et si votre identité dans ssh-agent est transmise, comme dans cette question? superuser.com/questions/971732/... - Nathan Basanese
Je me suis permis de reformater ce post: IMO c'est de loin la réponse la plus complète. Dans sa conception originale, une analyse rapide suggérait le post décrivant une seule solution compliquée au problème, donc cela me manquait. - Alberto
$ ssh-agent sh -c 'ssh-add ~/.ssh/id_rsa; git fetch user@host' travaillé pour moi quand rien d'autre ne le ferait. Gloire. - Daniel Dewhurst
Je devais utiliser ~/.ssh/config méthode, env vars n'a pas fonctionné pour moi ... - Greg Dubicki
GIT_SSH est disponible depuis v0.99.4 (août 2005), donc fondamentalement depuis que Git existe (avril 2005). - Dominik


Ecrire un script qui appelle ssh avec les arguments que vous voulez, et mettez le nom de fichier du script dans $GIT_SSH. Ou mettez simplement votre configuration dans ~/.ssh/config.


32
2018-01-12 18:25



Une autre explication de comment faire cela. - Sithsu
~/.ssh/config Est la marche à suivre. - hek2mgl
Je travaille sur une machine (A) à partir de laquelle je pousse un serveur (B) qui accepte uniquement l'authentification par clé ssh. Alors que ma configuration ~ / .ssh / config sur (A) fonctionne parfaitement lorsque je travaille directement sur cette machine, ce n'est pas le cas lorsque je me connecte depuis un autre endroit (C). En utilisant $GIT_SSH et un script a résolu ce problème. Merci! - bsumirak


Si vous ne voulez pas spécifier de variables d'environnement à chaque fois que vous exécutez git, ne voulez pas un autre script d'encapsulation, ne pouvez pas / ne pouvez pas exécuter ssh-agent (1), ni télécharger un autre package uniquement pour cela, utilisez git -remote-ext (1) transport externe:

$ git clone 'ext::ssh -i $HOME/.ssh/alternate_id git.example.com %S /path/to/repository.git'
Cloning into 'repository'
(...)
$ cd repository
$ git remote -v
origin  ext::ssh -i $HOME/.ssh/alternate_id git.example.com %S /path/to/repository.git (fetch)
origin  ext::ssh -i $HOME/.ssh/alternate_id git.example.com %S /path/to/repository.git (push)

Je considère cette solution supérieure parce que:

  • Il est spécifique au dépôt / à distance
  • Éviter le ballonnement du script wrapper
  • Vous n'avez pas besoin de l'agent SSH - utile si vous voulez des clones / push / pulls sans surveillance (par exemple, dans cron)
  • Certainement, aucun outil externe nécessaire

14
2017-07-21 19:44



//, excellente solution. Je me demande cependant si cela permettrait de spécifier une identité transmise via le transfert d’agent. La plupart de mes clés ne sont pas locales sur les serveurs sur lesquels je les utilise. J'ai demandé à ce sujet ici: superuser.com/questions/971732/... - Nathan Basanese
La réponse ne traite que d'un moyen de spécifier des lignes de commande arbitraires à utiliser comme référentiels git. À mon humble avis, vous devriez essayer de régler votre problème en utilisant ssh tout d'abord (par exemple, "ssh hôte"devrait se connecter en utilisant la bonne clé. Je vais essayer de fournir plus d'informations sur votre autre question, cependant. - flaviovs
Cette réponse était exactement ce dont j'avais besoin pour forcer les chefs git ressource pour utiliser des clés de déploiement spécifiques au référentiel pour cloner / récupérer des référentiels Github privés. L'avantage supplémentaire de cette méthode par rapport aux environnements / scripts est que, puisque le chemin de la clé est codé dans la configuration de working-repo, il utilisera la même clé à la fois sur le clone initial et les extractions / poussées ultérieures. - Adam Franco
HOU LA LA! C'est juste génial, je ne savais pas à ce sujet. Merci pour la réponse, très utile aussi dans les environnements de marionnettes, pour éviter les tracas supplémentaires à gérer .ssh/config etc. +1! - gf_
Si vous rencontrez l'erreur suivante fatal: transport 'ext' not allowed, vous devez mettre en liste blanche le protocole ext via le export GIT_ALLOW_PROTOCOL=ext. Fondamentalement, l'aide à distance git-remote-ext (qui prend en charge les URL "ext :: ssh exemple.com% S foo / repo") permet l'exécution de commandes arbitraires. Cela ne pose généralement pas de problème car l'utilisateur voit et approuve toujours l'URL transmise à git. Cependant, les sous-modules git, via le fichier .gitmodules, permettent à un attaquant de demander au client de récupérer des URL git arbitraires. hackerone.com/reports/104465 - Gomino


Après ma lutte avec $GIT_SSH Je voudrais partager ce qui a fonctionné pour moi.

À travers mes exemples, je suppose que votre clé privée est située à/home/user/.ssh/jenkins

Erreur à éviter: la valeur GIT_SSH inclut des options

$ export GIT_SSH="ssh -i /home/user/.ssh/jenkins"

ou quelle que soit la volonté similaire échoue, comme git va essayer d'exécuter la valeur sous forme de fichier. Pour cette raison, vous devez créer un script.

Exemple de travail du script $ GIT_SSH /home/user/gssh.sh

Le script sera appelé comme suit:

$ $GIT_SSH [username@]host [-p <port>] <command>

Un exemple de script fonctionnant pourrait ressembler à ceci:

#!/bin/sh
ssh -i /home/user/.ssh/jenkins $*

Noter la $* à la fin, c'est une partie importante de cela.

Une alternative encore plus sûre, qui empêcherait tout conflit possible avec quoi que ce soit dans votre fichier de configuration par défaut (plus explicitement en mentionnant le port à utiliser) serait:

#!/bin/sh
ssh -i /home/user/.ssh/jenkins -F /dev/null -p 22 $*

En supposant que le script est en /home/user/gssh.shvous devrez alors:

$ export GIT_SSH=/home/user/gssh.sh

et tout travaillera.


13
2018-05-28 17:09



Merci. Remarque: utilisez "$ @" au lieu de $ * pour les arguments de pass-thru, car le premier se comporte correctement lorsque les arguments contiennent des espaces. - Piotr Findeisen
@PiotrFindeisen Merci pour votre note. Cependant, je ne le comprends pas complètement - en zsh, cela m'aide à garder des chaînes avec un espace en un seul morceau, mais pas en bash. Pouvez-vous m'en dire plus ou indiquer des explications? Je ne veux pas ajouter des modifications à l'aveuglette. - Jan Vlcinsky
Vous devez supprimer la première moitié de votre réponse. Personne ne s'intéresse à une solution qui ne fonctionne pas, et c'est une lecture inutile qui masque la bonne réponse en bas, ce qui fonctionne à merveille. - Cerin
@Cerin Si vous voulez dire "Erreur à éviter", je vais le conserver. Il partage un écueil commun à éviter et il est très court. Je suis sûr que quelqu'un essaiera d'optimiser la solution en fournissant toutes les choses dans la variable (cela m'est arrivé), alors j'ai essayé de raccourcir le chemin de la réussite. - Jan Vlcinsky


Utiliser la configuration d'hôte personnalisée dans ~/.ssh/config, comme ça:

Host gitlab-as-thuc  
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_rsa.thuc
    IdentitiesOnly yes

puis utilisez votre nom d'hôte personnalisé comme ceci:

git remote add thuc git@gitlab-as-thuc:your-repo.git  

6
2018-05-17 15:03



C'est la réponse que je cherchais, car j'ai des comptes GitHub distincts pour la maison et le travail. Je devais juste mettre Host work.github.com  HostName github.com  IdentityFile ~/.ssh/work, puis remplacez "github.com" par "work.github.com" chaque fois que je clone un référentiel de travail. Il se connecte toujours à "github.com", mais en utilisant une paire de clés autre que celle par défaut. - Mikkel
L'URL pour plus de détails ("itblog.study.land / ... ") ne fonctionne plus :( - Carl Smotricz


Vous pouvez simplement utiliser ssh-ident au lieu de créer votre propre wrapper.

Vous pouvez lire plus à:    https://github.com/ccontavalli/ssh-ident

Il charge les clés ssh à la demande lorsque cela est nécessaire pour la première fois, une fois, même avec plusieurs sessions de connexion, des foyers partagés xterms ou NFS.

Avec un minuscule fichier de configuration, il peut automatiquement charger différentes clés et les séparer dans différents agents (pour le transfert d’agent) en fonction de ce que vous devez faire.


5
2018-03-23 01:35





J'avais un client qui avait besoin d'un compte github distinct. Je devais donc utiliser une clé séparée uniquement pour ce projet.

Ma solution a été d'ajouter ceci à mon fichier .zshrc / .bashrc:

alias infogit="GIT_SSH_COMMAND=\"ssh -i ~/.ssh/id_specialkey\" git $@"

Quand je veux utiliser git pour ce projet, je remplace "infogit" par git:

infogit commit -am "Some message" && infogit push

Pour moi, c'est plus facile à retenir.


3
2018-03-26 19:26





Ma solution était la suivante:

créer un script:

#!/bin/bash
KEY=dafault_key_to_be_used
PORT=10022 #default port...
for i in $@;do
   case $i in
    --port=*)
        PORT="${i:7}";;
    --key=*)KEY="${i:6}";;
   esac
done
export GIT_SSH_COMMAND="ssh -i $HOME/.ssh/${KEY} -p ${PORT}"
echo Command: $GIT_SSH_COMMAND

alors quand vous devez changer le var:

. ./thescript.sh [--port=] [--key=]

N'oubliez pas le point supplémentaire !! Cela rend le script défini les environnements vars !! --key et --port sont facultatifs.


2
2017-12-05 12:22





Généralement, vous voulez utiliser ~/.ssh/config pour ça. Il suffit de jumeler les adresses de serveur avec les clés que vous voulez utiliser comme suit:

Host github.com
  IdentityFile ~/.ssh/id_rsa.github
Host heroku.com
  IdentityFile ~/.ssh/id_rsa.heroku
Host *
  IdentityFile ~/.ssh/id_rsa

Host * dénote n'importe quel serveur, donc je l'utilise pour définir ~/.ssh/id_rsa comme clé par défaut à utiliser.


1
2018-02-11 22:44