Como dizer ao git qual chave privada usar?

Question

ssh tem a opção -i para informar qual arquivo de chave privada deve ser usado na autenticação:

-i identity_file

Selects a file from which the identity (private key) for RSA or DSA authentication is read.  The default is ~/.ssh/identity for protocol version 1, and ~/.ssh/id_rsa and ~/.ssh/id_dsa for protocol version 2.  Identity files may also be specified on a per-host basis in the configuration file.  It is possible to have multiple -i options (and multiple identities specified in configuration files).

Existe uma maneira semelhante de dizer ao git qual arquivo de chave privada usar em um sistema com várias chaves privadas no diretório ~/.ssh ?

    

Answer 1

Em ~/.ssh/config , adicione:

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

Agora você pode fazer git clone [email protected]:username/repo.git .

NOTA: Verifique se as permissões no IdentityFile são 400.SSH rejeitará, de uma maneira não claramente explícita, as chaves SSH que são legíveis demais. Ele apenas parecerá uma rejeição de credencial. A solução, neste caso, é:

chmod 400 ~/.ssh/id_rsa_github

    

Answer 2

Variável de ambiente GIT_SSH_COMMAND :

Do Git versão 2.3.0, você pode usar a variável de ambiente GIT_SSH_COMMAND da seguinte forma:

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

Note que -i às vezes pode ser substituído pelo seu arquivo de configuração, neste caso, você deve dar ao SSH um arquivo de configuração vazio, como este:

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

Configuração core.sshCommand :

A partir da versão 2.10.0 do Git, você pode configurá-lo por repo ou globalmente, assim você não precisa mais configurar a variável de ambiente!

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

    

Answer 3

Não há nenhuma direção direta para informar a git qual chave privada usar, porque ela depende de ssh para autenticação do repositório. No entanto, ainda existem algumas maneiras de atingir seu objetivo:

Opção 1: ssh-agent

Você pode usar ssh-agent para autorizar temporariamente sua chave privada.

Por exemplo:

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

Opção 2: GIT_SSH_COMMAND

Transmita os argumentos ssh usando a variável de ambiente GIT_SSH_COMMAND (Git 2.3.0 +).

Por exemplo:

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

_{Você pode digitar tudo isso em uma linha - ignorar $ e deixar de fora o \ .}

Opção 3: GIT_SSH

Passe os argumentos ssh usando a variável de ambiente GIT_SSH para especificar% binária ssh alternativa.

Por exemplo:

$ 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

_{Nota: As linhas acima são linhas de comando shell (terminal) que você deve colar no seu terminal. Eles vão criar um arquivo chamado ssh , torná-lo executável e (indiretamente) executá-lo.}

^{Nota: GIT_SSH está disponível desde a v0.99.4 (2005).}

Opção 4: ~/.ssh/config

Use o arquivo ~/.ssh/config , conforme sugerido em outras respostas, para especificar o local da sua chave privada, por exemplo,

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

    

Answer 4

Escreva um script que chame ssh com os argumentos desejados e coloque o nome do arquivo do script em $GIT_SSH . Ou apenas coloque sua configuração em ~/.ssh/config .

    

Answer 5

Se você não quer ter que especificar variáveis de ambiente toda vez que você executa git, não quer outro script wrapper, não / não pode rodar ssh-agent (1), nem deseja baixar outro pacote apenas para isso, use o transporte externo git-remote-ext (1):

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

Eu considero essa solução superior porque:

• É repositório / específico remoto
• Evite inchar o script do wrapper
• Não precisa do agente SSH - útil se você quiser clones / push / pull não assistidos (por exemplo, no cron)
• Definitivamente, nenhuma ferramenta externa necessária

Answer 6

Depois da minha luta com $GIT_SSH , gostaria de compartilhar o que funcionou para mim.

Através dos meus exemplos, assumirei que você tem sua chave privada localizada em /home/user/.ssh/jenkins

Erro a evitar: o valor GIT_SSH inclui opções

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

ou qualquer coisa parecida falhará, pois o git tentará executar o valor como um arquivo . Por esse motivo, você precisa criar um script.

Exemplo de trabalho do script $ GIT_SSH /home/user/gssh.sh

O script será chamado da seguinte forma:

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

O script de exemplo funcionando pode ser semelhante:

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

Observe o $* no final, é parte importante dele.

Uma alternativa ainda mais segura, que evitaria qualquer conflito possível com qualquer coisa em seu arquivo de configuração padrão (além de mencionar explicitamente a porta a ser usada), seria:

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

Supondo que o script esteja em /home/user/gssh.sh , você deverá:

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

e todos devem funcionar.

    

Answer 7

Use uma configuração de host personalizada em ~/.ssh/config , assim:

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

use seu nome de host personalizado assim:

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

    

Answer 8

Você pode usar o ssh-ident em vez de criar seu próprio wrapper.

Você pode ler mais em:    link

Carrega chaves ssh sob demanda quando necessário, uma vez, mesmo com várias sessões de login, xterms ou residências compartilhadas NFS.

Com um pequeno arquivo de configuração, ele pode carregar automaticamente diferentes chaves e mantê-las separadas em agentes diferentes (para o encaminhamento de agentes), dependendo do que você precisa fazer.

    

Answer 9

Eu tinha um cliente que precisava de uma conta separada do github. Então, eu precisava usar uma chave separada apenas para este projeto.

Minha solução foi adicionar isso ao meu .zshrc / .bashrc:

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

Sempre que eu quiser usar o git para esse projeto, eu substituo "infogit" pelo git:

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

Para mim, é mais fácil lembrar.

    

Answer 10

Minha solução foi esta:

crie um 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

quando você precisa alterar a execução de var:

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

Não esqueça o ponto extra !! isso faz com que o script defina os ambientes vars !! --key e --port são opcionais.

    

Answer 11

Geralmente, você deseja usar ~/.ssh/config para isso. Basta emparelhar os endereços do servidor com as chaves que você deseja usar para eles da seguinte forma:

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

Host * denota qualquer servidor, então eu o uso para definir ~/.ssh/id_rsa como a chave padrão a ser usada.

    

Answer 12

Eu construo em @shellholic e este segmento SO com alguns teaks. Eu uso o GitHub como exemplo e suponho que você tenha uma chave privada em ~/.ssh/github (caso contrário, veja este encadeamento SO ) e que você adicionou a chave pública ao seu perfil do GitHub (caso contrário, veja ajuda do GitHub ).

Se necessário, crie um novo arquivo de configuração SSH em ~/.ssh/config e altere as permissões para 400

touch ~/.ssh/config
chmod 600 ~/.ssh/config

Adicione isso ao arquivo ~/.ssh/config :

Host github.com
    IdentityFile ~/.ssh/github
    IdentitiesOnly yes

Se você já tem um controle remoto, você pode querer excluí-lo, caso contrário, você ainda pode ser solicitado para o nome de usuário e senha:

git remote rm origin

Em seguida, adicione um controle remoto ao repositório git e observe os dois pontos antes do nome do usuário:

git remote add origin [email protected]:user_name/repo_name.git

E os comandos do git funcionam normalmente, por exemplo:

git push origin master
git pull origin 

@HeyWatchThis em este segmento SO sugeriu adicionar IdentitiesOnly yes para evitar o comportamento padrão do SSH de enviar o arquivo de identidade correspondente ao nome de arquivo padrão para cada protocolo. Veja este tópico para mais informações e referências.

    

Answer 13

Estou usando o git versão 2.16 e não preciso de uma única parte do script nem mesmo de um comando config ou modificado.

• Apenas copiei minha chave privada para .ssh / id_rsa
• definir permissões para 600

E o git lê a tecla automaticamente. Eu não peço nada e isso não gera um erro. Apenas funciona bem.

    

Answer 14

Use apenas os comandos ssh-agent e ssh-add .

# create a agent
ssh-agent

# add your default key
ssh-add ~/.ssh/id_rsa

# add your second key
ssh-add ~/.ssh/<your key name>

Depois de executar os comandos acima, você pode usar a chave como o mesmo tempo. Apenas digite

git clone [email protected]:<yourname>/<your-repo>.git

para conectar seu repositório.

Você precisa executar o comando acima depois de reiniciar sua máquina.

Inglês não é minha língua nativa; por favor, desculpe erros de digitação.