O push do Git requer nome de usuário e senha

Clonei um repositório Git da minha conta GitHub para o meu PC.

Quero trabalhar com meu PC e laptop, mas com uma conta GitHub.

Quando tento acessar ou extrair do GitHub usando meu PC, ele exige um nome de usuário e uma senha, mas não quando estou usando o laptop!

Não quero digitar meu nome de usuário e senha sempre que interagir  origin. O que estou perdendo aqui?

Uma causa comum é a clonagem usando o padrão (HTTPS) em vez do SSH. Você pode corrigir isso indo ao seu repositório, clicando em "Clonar ou fazer download" e, em seguida, clique no botão "Usar SSH" acima do campo URL e atualizando o URL do seu controle remoto de origem da seguinte maneira:

git remote set-url origin git@github.com:username/repo.git

Isso está documentado no GitHub: Alternando URLs remotas de HTTPS para SSH .

Autenticando permanentemente com repositórios Git

Execute o seguinte comando para ativar o cache de credenciais :

$ git config credential.helper store
$ git push https://github.com/owner/repo.git

Username for 'https://github.com': <USERNAME>
Password for 'https://USERNAME@github.com': <PASSWORD>

Você também deve especificar vencimento do cache ,

git config --global credential.helper 'cache --timeout 7200'

Depois de ativar o cache de credenciais, ele será armazenado em cache por 7200 segundos (2 horas) .

Acabei de encontrar o mesmo problema, e a solução mais simples que encontrei foi usar o URL SSH em vez do HTTPS:

ssh://git@github.com/username/repo.git

E não é isso:

https://github.com/username/repo.git

Agora você pode validar apenas com a chave SSH em vez de usernamee password.

Além de mudar para SSH, você também pode continuar usando HTTPS, se não quiser colocar sua senha em texto não criptografado. Coloque isso no seu ~/.netrce ele não solicitará seu nome de usuário / senha (pelo menos no Linux e Mac):

machine github.com
       login <user>
       password <password>

Adição (veja o segundo comentário de VonC): no Windows, o nome do arquivo é%HOME%\_netrc .

Leia também o primeiro comentário do VonC, caso você queira criptografar.

Outra adição (consulte o comentário de user137717) que você pode usar se tiver o Git 1.7.10 ou mais recente .

Coloque em cache sua senha do GitHub no Git usando um auxiliar de credencial :

Se você estiver clonando repositórios do GitHub usando HTTPS, poderá usar um auxiliar de credencial para dizer ao Git para lembrar seu nome de usuário e senha do GitHub toda vez que conversar com o GitHub.

Isso também funciona no Linux, Mac e Windows.

Para os não iniciados que estão confusos com as respostas anteriores, você pode:

git remote -v

O que responderá com algo como

origin    https://yourname@github.com/yourname/yourrepo.git (fetch)
origin    https://yourname@github.com/yourname/yourrepo.git (push)

Em seguida, você pode executar o comando que muitos outros sugeriram, mas agora você conhece seu nome e seu repositório de cima, para poder recortar e colar yourname/yourrepo.gitdo acima em:

git remote set-url origin git@github.com:yourname/yourrepo.git

Se você estiver usando SSH e sua chave privada estiver criptografada com uma senha, você ainda será solicitado a digitar a senha / senha da chave privada ao realizar operações de rede com o Gitpush , como pull, e fetch.

Use ssh-agent para salvar as credenciais de senha / senha da chave privada

Se você quiser evitar ter que digitar sua senha sempre, use ssh-agentas suas credenciais de senha de chave privada uma vez por sessão do terminal, como explico em minha resposta para Não foi possível abrir uma conexão com o seu agente de autenticação :

$ eval `ssh-agent -s`
$ ssh-add

Em um msysgit Bash do Windows, você precisa avaliar a saída de ssh-agent, mas não tenho certeza se você precisa fazer o mesmo em outros ambientes de desenvolvimento e sistemas operacionais.

ssh-addprocura uma chave privada na sua .sshpasta pessoal chamadaid_rsa , que é o nome padrão, mas você pode passar um caminho de arquivo para uma chave com um nome diferente.

Matando o agente

Quando você terminar sua sessão de terminal, poderá encerrar ssh-agentcom a bandeira de interrupção -k:

$ ssh-agent -k

Conforme explicado no ssh-agentmanual :

-k

Mate o agente atual (fornecido pela variável de ambiente SSH_AGENT_PID).

Tempo limite opcional

Além disso, pode levar um parâmetro de tempo limite opcional, da seguinte maneira:

$ ssh-add -t <timeout>

onde <timeout>está no formato <n>hpor <n>horas, <n>mpor<n> minutos, e assim por diante.

De acordo com o ssh-agentmanual :

-t life

Defina um valor padrão para a vida útil máxima de identidades adicionadas ao agente. A vida útil pode ser especificada em segundos ou em um formato de hora especificado em sshd_config (5) . Uma vida útil especificada para uma identidade com ssh-add (1) substitui esse valor. Sem essa opção, a vida útil máxima padrão é para sempre.

Veja esta página para mais formatos de hora .

Aviso de segurança para usuários do Cygwin

Os usuários do Cygwin devem estar cientes de um risco potencial à segurança ao usar o ssh-agent no Cygwin :

as pessoas devem estar cientes dos perigos potenciais do ssh-agent no Cygwin 1 , embora sob um netstat local e portscan remoto, não parece que a porta especificada em / tmp / ssh-foo esteja acessível a qualquer pessoa ...?

[1]: http://www.cygwin.com/ml/cygwin/2001-01/msg00063.html

E no link citado :

no entanto, observe que os soquetes de domínio Unix da Cygwin são FUNDAMENTALMENTE INSEGUROS e, portanto, DESCOUÇO fortemente o uso do ssh-agent no Cygwin.

quando você executa o ssh-agent no Cygwin, ele cria o soquete AF_UNIX no /tmp/ssh-$USERNAME/diretório No Cygwin, os soquetes AF_UNIX são emulados pelos soquetes AF_INET. Você pode ver facilmente isso se procurar no /tmp/ssh-$USERNAME/agent-socket-*arquivo via Bloco de Notas. Você verá algo como

!<socket >2080

então corra netstat -ae surpreenda! Você tem algum programa ouvindo a porta 2080. É ssh-agent. Quando o ssh recebe um desafio de RSA do servidor, ele se refere à correspondência /tmp/ssh-$USERNAME/agent-socket-*(no Cygwin, no nosso caso, isso significa que ele abrirá a conexão comlocalhost:2080 ) e solicita ao ssh-agent que processe o desafio de RSA com a chave privada que possui e, em seguida, simplesmente passa a resposta recebida do agente ssh para o servidor.

No Unix, esse cenário funciona sem problemas, porque o kernel do Unix verifica as permissões quando o programa tenta acessar um soquete AF_UNIX. Para soquetes AF_INET, no entanto, as conexões são anônimas (leia-se "inseguro"). Imagine que você tem o agente ssh Cygwin em execução. Um hacker mal-intencionado pode portar a sua caixa, localizar a porta aberta usada pelo ssh-agent, abrir uma conexão com o servidor SSH, receber o desafio RSA dele, enviá-lo ao seu ssh-agent por uma porta aberta que ele encontrou, receber o Resposta RSA, envie-a para o servidor SSH e pronto, ele / ela logou com sucesso no seu servidor como você.

Fonte: Configurar o Git

O comando a seguir salvará sua senha na memória por algum tempo (para Git 1.7.10 ou posterior).

$ git config --global credential.helper cache
# Set git to use the credential memory cache

$ git config --global credential.helper 'cache --timeout=3600'
# Set the cache to timeout after one hour (setting is in seconds)

Quando você usa https para pull & push do Git, basta configurar remote.origin.urlpara o seu projeto, para evitar a entrada de nome de usuário (ou senha) sempre que for pressionado.

Como configurar remote.origin.url:

Formato de URL:
    https: // {nome de usuário: senha @} github.com/ {owner} / {repo}

Parâmetros no URL:

* nome de usuário 

    Opcional, o nome de usuário a ser usado quando necessário.
autenticação,
    se especificado, não é necessário inserir o nome de usuário novamente quando precisar de autenticação.
    Não use email; use seu nome de usuário que não tenha "@"; caso contrário, o URL não poderá ser analisado corretamente,
* senha
    opcional, a senha a ser usada quando precisar de autenticação.
    Se especificado, não há necessidade de digitar a senha novamente quando precisar de autenticação.
    Gorjeta:
        esse valor é armazenado como texto sem formatação. Portanto, por questões de segurança, não especifique esse parâmetro,
*

por exemplo
    git config remote.origin.url https: //eric@github.com/eric/myproject

@Update - usando ssh

Eu acho que usar sshprotocolo é uma solução melhor do que https, embora a etapa de instalação seja um pouco mais complexa.

Etapas difíceis:

• Crie chaves ssh usando o comando, por exemplo, ssh-keygenno Linux, no Windows msysgitforneça comandos semelhantes.
• Mantenha a chave privada na máquina local em um local adequado, por exemplo ~/.ssh,. E adicione-o ao agente ssh através do ssh-addcomando
• Carregue a chave pública no servidor Git.
• Mudança remote.origin.urldo repositório Git para o sshestilo, por exemplo,git@gitlab.com:myaccount/myrepo.git
• Então, quando puxa ou empurra, não há necessidade de inserir o nome de usuário ou a senha.

Dicas:

• Se a sua chave ssh tiver uma senha, será necessário inseri-la no primeiro uso da chave após cada reinicialização da máquina, por padrão.

@Update - Alterna entre httpse sshprotocolo.

Simplesmente mudar remote.origin.urlserá suficiente, ou você pode editar repo_home/.git/configdiretamente para alterar o valor (por exemplo, usando vino Linux).

Normalmente, adiciono uma linha para cada protocolo e comento um deles usando #.

Por exemplo

[origem remota]
        url = git@gitlab.com: myaccount / myrepo.git
        # url = https: //myaccount@gitlab.com/myaccount/myrepo.git
        busca = + refs / heads / *: refs / remotes / origin / *

Você pode armazenar em cache sua senha do GitHub no Git:

Basta seguir as instruções da documentação oficial do GitHub .

Após seguir as instruções do link acima, você poderá pressionar / puxar para / do seu repositório sem digitar seu nome de usuário / senha todas as vezes.

Aqui está outra opção:

Em vez de escrever

git push origin HEAD

Você pode escrever:

git push https://user:pass@yourrepo.com/path HEAD

Obviamente, com a maioria dos shells, isso resultará na cache da senha no histórico, portanto, lembre-se disso.

O que funcionou para mim foi editar .git/confige usar

[remote "origin"]
        url = https://<login>:<password>@gitlab.com(...).git

Escusado será dizer que esta é uma maneira insegura de armazenar sua senha, mas existem ambientes / casos em que isso pode não ser um problema.

Se a chave ou o .netrcarquivo SSH não funcionou para você, outra solução simples, mas menos segura, que poderia funcionar para você é o git-credential-store - Helper para armazenar credenciais no disco:

git config --global credential.helper store

Por padrão, as credenciais serão salvas no arquivo ~/.git-credentials. Será criado e gravado para.

Observe que o uso desse ajudante armazenará suas senhas não criptografadas no disco, protegidas apenas pelas permissões do sistema de arquivos. Se isso não for uma troca aceitável de segurança.

Eu tive o mesmo problema.

Então mudei o .git/configarquivo do meu projeto,

url = https://github.com/<your-user-here>/<your-repo-here>

para

url = git@github.com:<your-user-here>/<your-repo-here>

e adicionou a chave pública SSH ao perfil Git, que está na configuração.

Para a chave pública SSH:

cat ~/.ssh/id_rsa.pub

Atualização para HTTPS:

O GitHub lançou um novo programa para Windows que armazena suas credenciais quando você está usando HTTPS:

Usar:

• Faça o download do programa aqui

• Depois de executar o programa, ele editará seu .gitconfigarquivo. Verifique novamente se ele editou o correto .gitconfig, caso você tenha vários deles. Se não editou o correto, adicione o seguinte ao seu.gitconfig

  [credential]
      helper = !'C:\\Path\\To\\Your\\Downloaded\\File\\git-credential-winstore.exe'
  

  NOTA a quebra de linha depois [credential]. É necessário.

• Abra seu cliente de linha de comando e tente git push origin masteruma vez. Se ele solicitar uma senha, insira-a e pronto. Senha salva!

Para usuários do Windows Git, após a execução git config --global credential.helper store, se ainda solicitar uma senha, é melhor verificar para onde o arquivo de configuração está gravado, usando este comando

git config --list --show-origin

No meu caso, depois de editar manualmente o arquivo de configuração 'C: \ Arquivos de Programas \ Git \ mingw64 \ etc \ gitconfig' e adicionar o texto a seguir, funcionou.

[credential]
    helper = store

Você basicamente tem duas opções.

Se você usar o mesmo usuário em ambas as máquinas, precisará copiar a chave .pub no seu PC, para que o GitHub saiba que você é o mesmo usuário.

Se você criou um novo arquivo .pub para o seu PC e deseja tratar as máquinas como usuários diferentes, é necessário registrar o novo arquivo .pub no site do GitHub.

Se isso ainda não funcionar, pode ser porque o ssh não está configurado corretamente e esse ssh falha ao encontrar o local das suas chaves. Tentar

ssh -vv username@github.com

Para obter mais informações sobre por que o SSH falha.

Atualizando seu arquivo de configuração do Git diretamente ( se você não deseja memorizar comandos sofisticados ):

Abra seu .git/configarquivo no seu editor de texto favorito. Ele estará na pasta em que você clonou ou no repositório em que você executou git init. Entre nesse repositório. .gité uma pasta oculta e pressionar Ctrl+ Hdeve mostrar a pasta oculta ( ls -ano terminal).

Abaixo está uma amostra do .git/configarquivo. Copie e cole essas linhas e atualize essas linhas com suas informações do Git.

[user]
        name = Tux
        email = tux@gmail.com
        username = happy_feet

[remote "origin"]
        url = https://github.com/happy_feet/my_code.git
        fetch = +refs/heads/*:refs/remotes/origin/*

Altere a parte da URL com o seguinte formato para SSH:

url = git@github.com:happy_feet/my_code.git

( Os formatos acima não mudam com vários servidores remotos do Git, como o GitHub ou o Bitbucket. É o mesmo se você estiver usando o Git para controle de versão ):

Nota: A maneira SSH de se conectar a um repositório Git remoto exigirá que você adicione sua chave SSH pública ao servidor remoto Git ( como GitHub ou Bitbucket. Pesquise na página de configurações por chaves SSH ).

Para saber como gerar suas chaves SSH, consulte: Criando chaves SSH

Isto é o que funcionou para mim:

git remote set-url origin https://username@github.com/username/reponame.git

Exemplo:

git remote set-url origin https://jsmith@github.com/jsmith/master.git

Você precisa executar duas etapas -

1. git remote remove origin
2. git remote add origin git@github.com:NuggetAI/nugget.git

Observe que o URL do Git é um URL SSH e não um URL HTTPS ... Que você pode selecionar aqui:

Se você clonou o HTTPS em vez do SSH e enfrentou um problema com o prompt de nome de usuário e senha ao puxar, pressione e busque. Você pode resolver este problema simplesmente para UBUNTU

Etapa 1: mover para o diretório raiz

cd ~/

crie um arquivo .git-credentials

Adicione esse conteúdo a esse arquivo com você usename passwordegithosting URL

https://user:pass@example.com

Em seguida, execute o comando

git config --global credential.helper store

Agora você poderá pressionar e buscar todos os detalhes do seu repositório sem qualquer aborrecimento.

Se você estiver usando o Git (por exemplo, Git Bash) no Windows (e se não quiser mudar de HTTPS para SSH), também poderá usar o Git Credential Manager para Windows

Esta aplicação irá manter o nome de usuário e senha para você ...

Como muitos usuários disseram, basta alterar o URL do repositório Git de HTTPS para SSH.

Se você não gerou uma chave SSH em sua máquina, precisará fazê-lo.

Apenas como informação adicional, depois de fazer essa alteração, ainda estava recebendo o mesmo erro:

Permissão negada.

No meu caso, o problema era que eu estava usando o Shell do Windows para executar o comando ngh; como esse comando deve abrir um prompt para solicitar a frase SSH e o Windows Shell não abrir esse tipo de prompt, a autenticação falhou.

Então, eu apenas tive que abrir o shell do Git e executar o comando ngh lá, colocar a frase SSH no prompt toda vez que ele pedisse e "voilà" ... Funcionou bem!

    # create the company identity file
    ssh-keygen -t rsa -b 4096 -C "first.last@corp.com"
    # save private key to ~/.ssh/id_rsa.corp, 
    cat ~/.ssh/id_rsa.corp.pub # copy paste this string into your corp web ui security ssh keys

    # create your private identify file
    ssh-keygen -t rsa -b 4096 -C "me@gmail.com"
    # save private key to ~/.ssh/id_rsa.me, note the public key ~/.ssh/id_rsa.me.pub
    cat ~/.ssh/id_rsa.me.pub # copy paste this one into your githubs, private keys

    # clone company internal repo as follows
    GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.corp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" \
    git clone git@git.in.corp.com:corp/project.git

    export git_msg="my commit msg with my corporate identity"
    git add --all ; git commit -m "$git_msg" --author "MeFirst MeLast <first.last@corp.com>"
    GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.corp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" \
    git push 

    # clone public repo as follows
    GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.corp -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" \
    git clone git@github.com:acoolprojectowner/coolproject.git

    export git_msg="my commit msg with my personal identity"
    git add --all ; git commit -m "$git_msg" --author "MeFirst MeLast <first.last@gmail.com>"
    GIT_SSH_COMMAND="ssh -i ~/.ssh/id_rsa.me -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no" \
    git push 

    # stop :: how-to use different ssh identity files