Come specificare la chiave SSH privata da usare quando si esegue il comando shell su Git?

Forse una situazione piuttosto insolita, ma voglio specificare una chiave SSH privata da usare quando si esegue un comando shell (git) dal computer locale.

Fondamentalmente in questo modo:

git clone git@github.com:TheUser/TheProject.git -key "/home/christoffer/ssh_keys/theuser"

O ancora meglio (in Ruby):

with_key("/home/christoffer/ssh_keys/theuser") do
  sh("git clone git@github.com:TheUser/TheProject.git")
end

Ho visto esempi di connessione a un server remoto con Net :: SSH che utilizza una chiave privata specificata, ma questo è un comando locale. È possibile?

Qualcosa del genere dovrebbe funzionare (suggerito da orip):

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git'

se preferisci i subshells, puoi provare quanto segue (sebbene sia più fragile):

ssh-agent $(ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git)

Git invocherà SSH che troverà il suo agente in base alla variabile d'ambiente; questo, a sua volta, avrà la chiave caricata.

In alternativa, l'impostazione HOMEpuò anche fare il trucco, a condizione che tu sia disposto a configurare una directory che contenga solo una .sshdirectory come HOME; questo può contenere un file identity.pub o un'impostazione del file di configurazione IdentityFile.

Nessuna di queste soluzioni ha funzionato per me.

Invece, elaboro la menzione di @Martin v. Löwis sull'impostazione di un configfile per SSH.

SSH cercherà il ~/.ssh/configfile dell'utente . Ho il mio setup come:

Host gitserv
    Hostname remote.server.com
    IdentityFile ~/.ssh/id_rsa.github
    IdentitiesOnly yes # see NOTES below

E aggiungo un repository git remoto:

git remote add origin git@gitserv:myrepo.git

E poi i comandi git funzionano normalmente per me.

git push -v origin master

APPUNTI

• Il IdentitiesOnly yesè necessario per evitare che il comportamento di default SSH di inviare il file di identità che corrisponde al nome del file di default per ciascun protocollo. Se hai un file chiamato ~/.ssh/id_rsache verrà provato PRIMA del tuo ~/.ssh/id_rsa.githubsenza questa opzione.

Riferimenti

• Il modo migliore per utilizzare più chiavi private SSH su un client
• Come potrei impedire a ssh di offrire una chiave sbagliata

A partire da Git 2.3.0 abbiamo anche il comando semplice (non è necessario alcun file di configurazione):

GIT_SSH_COMMAND='ssh -i private_key_file' git clone user@host:repo.git

I suggerimenti di altre persone ~/.ssh/configsono molto complicati. Può essere semplice come:

Host github.com
  IdentityFile ~/.ssh/github_rsa

Contenuti di my_git_ssh_wrapper:

#!/bin/bash

ssh -i /path/to/ssh/secret/key $1 $2

Quindi puoi usare il tasto facendo:

GIT_SSH=my_git_ssh_wrapper git clone git@github.com:TheUser/TheProject.git

Con git 2.10+ (Q3 2016: rilasciato settembre 2d, 2016), si ha la possibilità di impostare una configurazione per la GIT_SSH_COMMAND(e non solo una variabile di ambiente, come descritto nella Rober Jack di Will 's risposta )

Vedi commit 3c8ede3 (26 giu 2016) di Nguyễn Thái Ngọc Duy ( pclouds) .
^{(Unita da Junio ​​C Hamano - gitster- in commit dc21164 , 19 lug 2016)}

È core.sshCommandstata aggiunta una nuova variabile di configurazione per specificare quale valore GIT_SSH_COMMANDutilizzare per repository.

core.sshCommand:

Se questa variabile è impostata git fetche git pushutilizzerà il comando specificato anziché sshquando è necessario connettersi a un sistema remoto.
Il comando ha la stessa forma della GIT_SSH_COMMANDvariabile d'ambiente e viene sovrascritto quando viene impostata la variabile d'ambiente.

Significa che git clonepuò essere:

cd /path/to/my/repo
git config core.sshCommand 'ssh -i private_key_file' 
# later on
git clone host:repo.git

Puoi persino impostarlo per un solo comando:

git -c core.sshCommand="ssh -i private_key_file" clone host:repo.git

Questo è più facile che impostare una GIT_SSH_COMMANDvariabile d'ambiente che, su Windows, come notato da Mátyás Kuti-Kreszács , sarebbe

set "GIT_SSH_COMMAND=ssh -i private_key_file"

Per riassumere risposte e commenti , il modo migliore per impostare git in modo da utilizzare file chiave diversi e poi dimenticarsene, che supporta anche utenti diversi per lo stesso host (ad esempio un account GitHub personale e uno di lavoro), che funziona su Windows inoltre, è di modificare ~/.ssh/config(o c:\Users\<your user>\.ssh\config) e specificare più identità:

Host github.com
HostName github.com
IdentityFile /path/to/your/personal/github/private/key
User dandv

Host github-work
HostName github.com
IdentityFile /path/to/your/work/github/private/key
User workuser

Quindi, per clonare un progetto come utente personale, basta eseguire il git clonecomando normale .

Per clonare il repository come workuser, eseguire git clone git@github-work:company/project.git.

Come indicato qui: https://superuser.com/a/912281/607049

Puoi configurarlo per repository:

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

Il problema è quando si hanno repository remoti diversi sullo stesso host (ad esempio github.com) e si desidera interagire con essi utilizzando chiavi ssh diverse (ovvero account GitHub diversi).

Per fare ciò:

1. Per prima cosa dovresti dichiarare le tue diverse chiavi nel ~/.ssh/configfile.

   # Key for usual repositories on github.com
   Host github.com
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_rsa
   
   # Key for a particular repository on github.com
   Host XXX
   HostName github.com
   User git
   IdentityFile ~/.ssh/id_other_rsa

   In questo modo associ la seconda chiave a un nuovo nome descrittivo "XXX" per github.com.

2. Quindi è necessario modificare l'origine remota del proprio repository in modo che utilizzi il nome descrittivo appena definito.

   Passare alla cartella del repository locale all'interno di un prompt dei comandi e visualizzare l'origine remota corrente:

   >git remote -v
   origin  git@github.com:myuser/myrepo.git (fetch)
   origin  git@github.com:myuser/myrepo.git (push)

   Quindi cambia origine con:

   >git remote set-url origin git@XXX:myuser/myrepo.git
   >git remote -v
   origin  git@XXX:myuser/myrepo.git (fetch)
   origin  git@XXX:myuser/myrepo.git (push)

   Ora puoi premere, recuperare ... con il tasto destro automaticamente.

GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key" git clone $git_repo

o

export GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key"
git clone REPO
git push

Un'idea migliore per aggiungere quell'host o IP al .ssh/configfile in questo modo:

Host (a space separated list of made up aliases you want to use for the host)
    User git
    Hostname (ip or hostname of git server)
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_(the key you want for this repo)

Sono andato con la variabile d'ambiente GIT_SSH. Ecco il mio wrapper, simile a quello di Joe Block dall'alto, ma gestisce qualsiasi quantità di argomenti.

File ~ / gitwrap.sh

#!/bin/bash
ssh -i ~/.ssh/gitkey_rsa "$@"

Quindi, nel mio .bashrc, aggiungi quanto segue:

export GIT_SSH=~/gitwrap.sh

Se nessuna delle altre soluzioni qui funziona per te e hai creato più ssh-key, ma non riesci ancora a fare cose semplici come

git pull

supponendo quindi di avere due file di chiavi ssh come

id_rsa
id_rsa_other_key

quindi all'interno del repository git, prova:

# Run these commands INSIDE your git directory
eval `ssh-agent -s`
ssh-add ~/.ssh/id_rsa
ssh-add ~/.ssh/id_rsa_other_key

e assicurati anche che il nome utente e l'id utente predefiniti di github siano corretti:

# Run these commands INSIDE your git directory
git config user.name "Mona Lisa"
git config user.email "mona.lisa@email.com"

Vedi https://gist.github.com/jexchan/2351996 per ulteriori informazioni.

Quando avete bisogno di connettersi a GitHub con una richiesta normale ( git pull origin master), impostando l'host come *in ~/.ssh/configlavorato per me, qualsiasi altro host (ad esempio, "GitHub" o "GB") non funzionava.

Host *
    User git
    Hostname github.com
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_xxx

Molte di queste soluzioni sembravano allettanti. Tuttavia, ho trovato l'approccio generico git-wrapping-script al seguente link per essere il più utile:

Come specificare un file chiave ssh con il gitcomando

Il punto è che non esiste un gitcomando come il seguente:

git -i ~/.ssh/thatuserkey.pem clone thatuser@myserver.com:/git/repo.git

La soluzione di Alvin è quella di utilizzare uno script bash-wrapper ben definito che colma questa lacuna:

git.sh -i ~/.ssh/thatuserkey.pem clone thatuser@myserver.com:/git/repo.git

Dove git.shè:

#!/bin/bash

# The MIT License (MIT)
# Copyright (c) 2013 Alvin Abad
# https://alvinabad.wordpress.com/2013/03/23/how-to-specify-an-ssh-key-file-with-the-git-command

if [ $# -eq 0 ]; then
    echo "Git wrapper script that can specify an ssh-key file
Usage:
    git.sh -i ssh-key-file git-command
    "
    exit 1
fi

# remove temporary file on exit
trap 'rm -f /tmp/.git_ssh.$$' 0

if [ "$1" = "-i" ]; then
    SSH_KEY=$2; shift; shift
    echo "ssh -i $SSH_KEY \$@" > /tmp/.git_ssh.$$
    chmod +x /tmp/.git_ssh.$$
    export GIT_SSH=/tmp/.git_ssh.$$
fi

# in case the git command is repeated
[ "$1" = "git" ] && shift

# Run the git command
git "$@"

Posso verificare che questo risolto un problema ho avuto con l'utente / riconoscimento della chiave di repo bitbucket remoto con git remote update, git pulle git clone; tutto ciò ora funziona bene in uno cronscript di lavoro che altrimenti avrebbe avuto problemi a navigare nella shell limitata. Sono stato anche in grado di chiamare questo script dall'interno di R e risolvere comunque lo stesso identico cronproblema di esecuzione (ad es system("bash git.sh -i ~/.ssh/thatuserkey.pem pull").).

Non che R sia uguale a Ruby, ma se R può farlo ... O :-)

se hai una directory sul tuo percorso in cui vuoi firmare con un dato file di identificazione puoi specificare di usare un file di identificazione specifico tramite il file .ssh / config impostando ControlPathad esempio:

host github.com
  ControlPath ~/Projects/work/**
  HostName github.com
  IdentityFile ~/.ssh/id_work
  User git

Quindi sshutilizzerà il file di identità specificato durante l'esecuzione dei comandi git nel percorso di lavoro indicato.

Devi creare un ~ / .ssh / config come di seguito

Host <Your bitbucket server>
User <userid>
Hostname <Your bitbucket server as above>
IdentitiesOnly yes
IdentityFile ~/.ssh/id_rsa<file> This is your private key file

permesso come di seguito

-rw------- $HOME/.ssh/config

Aggiungi la tua chiave pubblica in git (cat ~ / .ssh / id_rsa_pub [o nome simillar])

e poi git clone come di seguito

git clone ssh://blahblah@blah.com/userid/test.git

Molte buone risposte, ma alcune di esse presuppongono conoscenze amministrative precedenti.

Penso che sia importante sottolineare esplicitamente che se hai avviato il tuo progetto clonando l'URL web , https://github.com/<user-name>/<project-name>.git
allora devi assicurarti che il url valore sotto [remote "origin"]in sia .git/config stato cambiato nell'URL SSH (vedi blocco di codice sotto).

Oltre a ciò assicurati di aggiungere sshCommmandquanto indicato di seguito:

user@workstation:~/workspace/project-name/.git$ cat config
[core]
    repositoryformatversion = 0
    filemode = true
    bare = false
    logallrefupdates = true
    sshCommand = ssh -i ~/location-of/.ssh/private_key -F /dev/null <--Check that this command exist
[remote "origin"]
    url = git@github.com:<user-name>/<project-name>.git  <-- Make sure its the SSH URL and not the WEB URL
    fetch = +refs/heads/*:refs/remotes/origin/*
[branch "master"]
    remote = origin
    merge = refs/heads/master

Leggi di più qui .

In Windows con Git Bash è possibile utilizzare, ssh-agent bash -c 'ssh-add "key-address"; git remote add origin "rep-address"' ad esempio, per aggiungere un repository : ssh-agent bash -c 'ssh-add /d/test/PrivateKey.ppk; git remote add origin git@git.test.com:test/test.git'Quale chiave privata si trova nell'unità D, test della cartella del computer. Inoltre, se si desidera clonare un repository, è possibile cambiare git remote add origincon git clone.

Dopo aver inserito questo in Git Bash, ti chiederà la passphrase!

Attenzione che la chiave privata openssh e la chiave privata putty sono diverse!

Se hai creato le tue chiavi con puttygen, devi convertire la tua chiave privata in openssh!

È possibile utilizzare la variabile di ambiente GIT_SSH. Ma dovrai avvolgere ssh e options in uno script di shell.

Vedi il manuale di git: man gitnella tua shell dei comandi.

Uso zshe chiavi diverse vengono caricate automaticamente sulla mia shell zsh ssh-agentper altri scopi (ad es. Accesso a server remoti) sul mio laptop. Ho modificato la risposta di @ Nick e la sto usando per uno dei miei repository che deve essere aggiornato spesso. (In questo caso è il mio dotfilesche voglio la stessa e ultima versione su tutte le mie macchine, ovunque io stia lavorando.)

bash -c 'eval `ssh-agent`; ssh-add /home/myname/.dotfiles/gitread; ssh-add -L; cd /home/myname/.dotfiles && git pull; kill $SSH_AGENT_PID'

• Genera un agente ssh
• Aggiungi chiave di sola lettura all'agente
• Cambia directory nel mio repository git
• Se la cdrepository dir ha esito positivo, estrarre dal repository remoto
• Uccidi generato ssh-agent. (Non vorrei che molti agenti indugiassero.)

per il gitlab RSAAuthentication yes

Host gitlab.com
  RSAAuthentication yes
  IdentityFile ~/.ssh/your_private_key_name
  IdentitiesOnly yes

doc è qui

Affinché la variabile di ambiente GIT_SSH_COMMAND funzioni in Windows anziché:

set GIT_SSH_COMMAND="ssh -i private_key_file"

Uso:

set "GIT_SSH_COMMAND=ssh -i private_key_file"

La citazione deve essere come

set "variable=value" 

Alcuni backgorund: https://stackoverflow.com/a/34402887/10671021

Se il numero di porta SSH non è 22 (default), aggiungere Port xxin~/.ssh/config

Nel mio caso (sinologia),

Host my_synology
    Hostname xxxx.synology.me
    IdentityFile ~/.ssh/id_rsa_xxxx
    User myname
    Port xx

Quindi clonare usando il titolo Host in config. ("my_synology". per evitare "*" di @chopstik)

git clone my_synology:path/to/repo.git

Se sei come me, puoi:

• Mantieni organizzate le tue chiavi ssh

• Mantieni semplici i comandi del tuo clone git

• Gestisci un numero qualsiasi di chiavi per qualsiasi numero di repository.

• Riduci la manutenzione dei tasti ssh.

Conservo le mie chiavi nella mia ~/.ssh/keysdirectory.

Preferisco la convenzione rispetto alla configurazione.

Penso che il codice sia legge; più è semplice, meglio è.

PASSAGGIO 1: creare un alias

Aggiungi questo alias alla tua shell: alias git-clone='GIT_SSH=ssh_wrapper git clone'

PASSAGGIO 2 - Crea script

Aggiungi questo script ssh_wrapper al tuo PERCORSO:

#!/bin/bash
# Filename: ssh_wrapper

if [ -z ${SSH_KEY} ]; then
    SSH_KEY='github.com/l3x'  # <= Default key
fi
SSH_KEY="~/.ssh/keys/${SSH_KEY}/id_rsa"
ssh -i "${SSH_KEY}" "$@"

ESEMPI

Utilizzare la chiave github.com/l3x:

KEY=github.com/l3x git-clone https://github.com/l3x/learn-fp-go

L'esempio seguente utilizza anche la chiave github.com/l3x (per impostazione predefinita):

git-clone https://github.com/l3x/learn-fp-go

Usa la chiave bitbucket.org/lsheehan:

KEY=bitbucket.org/lsheehan git-clone git@bitbucket.org:dave_andersen/exchange.git

APPUNTI

Cambia SSH_KEY predefinito nello script ssh_wrapper con quello che usi più spesso. In questo modo, non è necessario utilizzare la variabile KEY per la maggior parte del tempo.

Potresti pensare: "Ehi! Succede molto con un alias, uno script e una directory di chiavi", ma per me è una convenzione. Quasi tutte le mie stazioni di lavoro (e server per quella materia) sono configurate in modo simile.

Il mio obiettivo qui è semplificare i comandi che eseguo regolarmente.

Le mie convenzioni, ad esempio script di Bash, alias, ecc., Creano un ambiente coerente e mi aiutano a mantenere le cose semplici.

BACIO e nomi contano.

Per ulteriori suggerimenti di progettazione, consulta il capitolo 4 SOLID Design in Go dal mio libro: https://www.amazon.com/Learning-Functional-Programming-Lex-Sheehan-ebook/dp/B0725B8MYW

Spero che aiuti. - Lex

Puoi provare il pacchetto sshmulti npm per mantenere più chiavi ssh.

Il problema con questo metodo è, almeno quando eseguito da bash.exe su Windows, che creerà un nuovo processo ogni volta che rimarrà inattivo.

ssh-agent bash -c 'ssh-add /somewhere/yourkey; git clone git@github.com:user/project.git'

Se si desidera utilizzarlo per la sincronizzazione dei repository nei tempi previsti, è necessario aggiungere "&& ssh-agent -k" alla fine.

Qualcosa di simile a:

ssh-agent bash -c 'ssh-add C:/Users/user/.ssh/your_key; git -C "C:\Path\to\your\repo" pull && ssh-agent -k' 

ssh-agent -k interromperà il processo al termine.

Ho solo bisogno di aggiungere la chiave, quindi eseguire nuovamente il clone git.

ssh-add ~/.ssh/id_rsa_mynewkey
git clone git@bitbucket.org:mycompany/myrepo.git

Ecco l'hack chiave ssh che ho trovato durante la ricerca di soluzione a questo problema:

Ad esempio hai 2 diversi set di chiavi:

key1, key1.pub, key2, key2.pub

Conserva queste chiavi nella tua .sshdirectory

Ora nel tuo file .bashrco .bash_profilealias, aggiungi questi comandi

alias key1='cp ~/.ssh/key1 id_rsa && cp ~/.ssh/key1.pub id_rsa.pub'

alias key2='cp ~/.ssh/key2 id_rsa && cp ~/.ssh/key2.pub id_rsa.pub'

Ecco! Hai una scorciatoia per cambiare i tasti quando vuoi!

Spero che questo funzioni per te.