Como especificar a chave SSH privada a ser usada ao executar o comando shell no Git?

Uma situação bastante incomum, talvez, mas quero especificar uma chave SSH privada para usar ao executar um comando shell (git) no computador local.

Basicamente assim:

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

Ou ainda melhor (em Ruby):

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

Eu já vi exemplos de conexão com um servidor remoto com o Net :: SSH que usa uma chave privada especificada, mas este é um comando local. É possível?

Algo assim deve funcionar (sugerido pelo orip):

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

se você preferir sub-conchas, tente o seguinte (embora seja mais frágil):

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

O Git invocará o SSH, que encontrará seu agente pela variável de ambiente; por sua vez, a chave será carregada.

Como alternativa, a configuração HOMEtambém pode funcionar, desde que você esteja disposto a configurar um diretório que contenha apenas um .sshdiretório como HOME; isso pode conter um identity.pub ou uma configuração de arquivo de configuração IdentityFile.

Nenhuma dessas soluções funcionou para mim.

Em vez disso, elaborei a menção de @Martin v. Löwis em definir um configarquivo para SSH.

O SSH procurará o ~/.ssh/configarquivo do usuário . Eu tenho a minha configuração como:

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

E eu adiciono um repositório remoto do git:

git remote add origin git@gitserv:myrepo.git

E então os comandos git funcionam normalmente para mim.

git push -v origin master

NOTAS

• O IdentitiesOnly yesé necessário para evitar o comportamento padrão SSH de enviar o arquivo de identidade combinando o nome de arquivo padrão para cada protocolo. Se você tiver um arquivo nomeado ~/.ssh/id_rsaque será tentado ANTES de você ~/.ssh/id_rsa.githubsem essa opção.

Referências

• Melhor maneira de usar várias chaves privadas SSH em um cliente
• Como eu poderia parar de ssh oferecer uma chave errada

A partir do Git 2.3.0, também temos o comando simples (nenhum arquivo de configuração é necessário):

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

As sugestões de outras pessoas ~/.ssh/configsão extremamente complicadas. Pode ser tão simples quanto:

Host github.com
  IdentityFile ~/.ssh/github_rsa

Conteúdo de my_git_ssh_wrapper:

#!/bin/bash

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

Então você pode usar a chave fazendo:

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

Com git 2.10+ (Q3 2016: lançado setembro 2d, 2016), você tem a possibilidade de definir uma configuração para GIT_SSH_COMMAND(e não apenas uma variável de ambiente como descrito na Rober Jack Will 's resposta )

Ver commit 3c8ede3 (26 de junho de 2016) por Nguyễn Thái Ngọc Duy ( pclouds) .
^{(Mesclado por Junio ​​C Hamano - gitster- na confirmação dc21164 , 19 de julho de 2016)}

Uma nova variável de configuração core.sshCommandfoi adicionada para especificar qual valor GIT_SSH_COMMANDusar por repositório.

core.sshCommand:

Se essa variável estiver configurada git fetche git pushusar o comando especificado em vez de sshquando eles precisarem se conectar a um sistema remoto.
O comando está na mesma forma que a GIT_SSH_COMMANDvariável de ambiente e é substituído quando a variável de ambiente é configurada.

Isso significa que git clonepode ser:

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

Você pode configurá-lo para apenas um comando:

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

Isso é mais fácil do que definir uma GIT_SSH_COMMANDvariável de ambiente que, no Windows, conforme observado por Mátyás Kuti-Kreszács , seria

set "GIT_SSH_COMMAND=ssh -i private_key_file"

Para resumir respostas e comentários , a melhor maneira de configurar o git para usar arquivos-chave diferentes e depois esquecê-lo, que também suporta usuários diferentes para o mesmo host (por exemplo, uma conta pessoal do GitHub e outra funcional), que funciona no Windows também é editar ~/.ssh/config(ou c:\Users\<your user>\.ssh\config) e especificar várias identidades:

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

Em seguida, para clonar um projeto como seu usuário pessoal, basta executar o git clonecomando regular .

Para clonar o repositório como o workuser, execute git clone git@github-work:company/project.git.

Como indicado aqui: https://superuser.com/a/912281/607049

Você pode configurá-lo por repo:

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

O problema é quando você tem repositórios remotos diferentes no mesmo host (por exemplo, github.com) e deseja interagir com eles usando diferentes chaves ssh (por exemplo, contas diferentes do GitHub).

A fim de fazer isso:

1. Primeiro você deve declarar suas diferentes chaves no ~/.ssh/configarquivo.

   # 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

   Ao fazer isso, você associa a segunda chave a um novo nome amigável "XXX" para o github.com.

2. Então você deve alterar a origem remota do seu repositório específico, para que ele use o nome amigável que você acabou de definir.

   Vá para a pasta do repositório local em um prompt de comando e exiba a origem remota atual:

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

   Altere a origem com:

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

   Agora você pode pressionar, buscar ... com a tecla certa automaticamente.

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

ou

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

Muito melhor ideia de adicionar esse host ou ip ao .ssh/configarquivo da seguinte maneira:

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)

Eu fui com a variável de ambiente GIT_SSH. Aqui está meu invólucro, semelhante ao de Joe Block acima, mas lida com qualquer quantidade de argumentos.

Arquivo ~ / gitwrap.sh

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

Em seguida, no meu .bashrc, adicione o seguinte:

export GIT_SSH=~/gitwrap.sh

Se nenhuma das outras soluções aqui funcionar para você e você criou várias chaves ssh, mas ainda não pode fazer coisas simples, como

git pull

supondo que você tenha dois arquivos de chave ssh como

id_rsa
id_rsa_other_key

depois, dentro do repositório git, tente:

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

e também verifique se o nome de usuário e o ID do usuário padrão do github estão corretos:

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

Consulte https://gist.github.com/jexchan/2351996 para obter mais informações.

Quando você precisa se conectar a github com um pedido normal ( git pull origin master), dando o anfitrião como *no ~/.ssh/configfuncionou para mim, qualquer outro anfitrião (digamos, "github" ou "gb") não estava funcionando.

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

Muitas dessas soluções pareciam atraentes. No entanto, achei a abordagem genérica do git-wrapping-script no seguinte link a mais útil:

Como especificar um arquivo de chave ssh com o gitcomando

O ponto é que não há gitcomando como o seguinte:

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

A solução da Alvin é usar um script bem definido de wrapper que preencha esta lacuna:

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

Onde git.shfica:

#!/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 verificar se isso resolveu um problema que eu estava tendo com o usuário reconhecimento / chave para um repo bitbucket remoto com git remote update, git pulle git clone; agora tudo funciona bem em um cronscript de trabalho que estava tendo problemas para navegar no shell limitado. Também pude chamar esse script no R e ainda resolver exatamente o mesmo cronproblema de execução (por exemplo,system("bash git.sh -i ~/.ssh/thatuserkey.pem pull") ).

Não que R seja o mesmo que Ruby, mas se R puder fazê-lo ... O :-)

se você tiver um diretório no caminho em que deseja assinar com um determinado arquivo de identificação, poderá especificar o uso de um arquivo de identificação específico por meio do arquivo .ssh / config, definindo o ControlPathexemplo:

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

Em seguida ssh, usará o arquivo de identidade especificado ao executar comandos git no caminho de trabalho especificado.

Você precisa criar um ~ / .ssh / config como abaixo

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

permissão como abaixo

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

Adicione sua chave pública ao seu git (cat ~ / .ssh / id_rsa_pub [ou nome similar])

e depois git clone como abaixo

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

Muitas respostas boas, mas algumas delas assumem conhecimento prévio em administração.

Eu acho que é importante enfatizar explicitamente que, se você iniciou o projeto clonando a URL da Web - https://github.com/<user-name>/<project-name>.git
precisará garantir que o url valor abaixo [remote "origin"]do .git/config foi alterado para a URL SSH (consulte o bloco de código abaixo).

Além disso, certifique-se de adicionar o sshCommmandmencionado abaixo:

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

Leia mais sobre isso aqui .

No Windows com Git Bash, você pode usar o seguinte para adicionar um repositório, ssh-agent bash -c 'ssh-add "key-address"; git remote add origin "rep-address"' por exemplo: ssh-agent bash -c 'ssh-add /d/test/PrivateKey.ppk; git remote add origin git@git.test.com:test/test.git'Qual chave privada está na unidade D, teste de pasta do computador. Além disso, se você deseja clonar um repositório, pode alterar git remote add origincom git clone.

Depois de inserir isso no Git Bash, ele solicitará uma senha.

Esteja ciente de que a chave privada openssh e a putty private key são diferentes.

Se você criou suas chaves com puttygen, deve converter sua chave privada em openssh!

Você pode usar a variável de ambiente GIT_SSH. Mas você precisará agrupar ssh e opções em um script de shell.

Veja o manual do git: man gitno seu shell de comando.

Eu uso zshe chaves diferentes são carregadas no meu shell zsh ssh-agentautomaticamente para outros fins (ou seja, acesso a servidores remotos) no meu laptop. Modifiquei a resposta de @ Nick e a uso em um dos meus repositórios que precisam ser atualizados com frequência. (Nesse caso, é meu dotfilesque eu quero a mesma e a versão mais recente em todas as minhas máquinas, onde quer que esteja trabalhando.)

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

• Cria um agente ssh
• Adicionar chave somente leitura ao agente
• Alterar diretório para meu repositório git
• Se o cdrepo dir tiver êxito, puxe do repo remoto
• Mate o agente ssh gerado. (Eu não gostaria que muitos agentes permanecessem por aqui.)

para o gitlab RSAAuthentication yes

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

doc está aqui

Para que a variável de ambiente GIT_SSH_COMMAND funcione no Windows, em vez de:

set GIT_SSH_COMMAND="ssh -i private_key_file"

Usar:

set "GIT_SSH_COMMAND=ssh -i private_key_file"

A citação deve ser como

set "variable=value" 

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

Se o número da porta SSH não é 22 (padrão), adicione Port xxem~/.ssh/config

No meu caso (sinologia),

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

Em seguida, clone usando o título Host na configuração. ("my_synology". para evitar @chopstik 's "*")

git clone my_synology:path/to/repo.git

Se você é como eu, pode:

• Mantenha suas chaves ssh organizadas

• Mantenha seus comandos git clone simples

• Manipule qualquer número de chaves para qualquer número de repositórios.

• Reduza sua manutenção de chave ssh.

Eu mantenho minhas chaves na minha ~/.ssh/keys diretório.

Eu prefiro convenção do que configuração.

Eu acho que código é lei; quanto mais simples, melhor.

PASSO 1 - Criar alias

Adicione este alias ao seu shell: alias git-clone='GIT_SSH=ssh_wrapper git clone'

PASSO 2 - Criar Script

Adicione este script ssh_wrapper ao seu PATH:

#!/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}" "$@"

EXEMPLOS

Use a chave github.com/l3x:

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

O exemplo a seguir também usa a chave github.com/l3x (por padrão):

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

Use a chave bitbucket.org/lsheehan:

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

NOTAS

Altere o SSH_KEY padrão no script ssh_wrapper para o que você usa na maioria das vezes. Dessa forma, você não precisa usar a variável KEY na maioria das vezes.

Você pode pensar: "Ei! Isso está acontecendo muito com um apelido, um script e um diretório de chaves", mas para mim é uma convenção. Quase todas as minhas estações de trabalho (e servidores) estão configuradas da mesma forma.

Meu objetivo aqui é simplificar os comandos que executo regularmente.

Minhas convenções, por exemplo, scripts Bash, aliases etc., criam um ambiente consistente e me ajudam a manter as coisas simples.

BEIJO e nomes importam.

Para obter mais dicas de design, consulte o Capítulo 4 do SOLID Design no Go do meu livro: https://www.amazon.com/Learning-Functional-Programming-Lex-Sheehan-ebook/dp/B0725B8MYW

Espero que ajude. - Lex

Você pode tentar o pacote sshmulti npm para manter várias chaves ssh.

O problema com esse método é que, pelo menos ao executar o bash.exe no Windows, ele cria um novo processo sempre que permanecer inativo.

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

Se você quiser usá-lo para sincronizar o repositório na programação, precisará adicionar "&& ssh-agent -k" no final.

Algo como:

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

O ssh-agent -k matará o processo quando terminar.

Eu só precisava adicionar a chave e executar o clone git novamente.

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

Aqui está o hack da chave ssh que encontrei ao encontrar a solução para esse problema:

Por exemplo, você tem 2 conjuntos diferentes de chaves:

key1, key1.pub, key2, key2.pub

Mantenha essas chaves em seu .sshdiretório

Agora no seu arquivo .bashrcou .bash_profilealias, adicione estes comandos

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'

Voila! Você tem um atalho para alternar as teclas quando quiser!

Espero que funcione para voce.