Usando o Git, existe uma maneira de dizer para aceitar um certificado autoassinado?

Estou usando um servidor https para hospedar um servidor git, mas por enquanto o certificado é autoassinado.

Quando tento criar o repositório pela primeira vez:

git push origin master -f

Eu recebo o erro:

error: Cannot access URL     
https://the server/git.aspx/PocketReferences/, return code 22

fatal: git-http-push failed

Para aceitar permanentemente um certificado específico

Tente http.sslCAPathou http.sslCAInfo. A resposta de Adam Spiers dá alguns ótimos exemplos. Esta é a solução mais segura para a pergunta.

Para desativar a verificação TLS / SSL para um único comando git

tente passar -cpara gitcom a variável de configuração adequada, ou usar a resposta de fluxo :

git -c http.sslVerify=false clone https://example.com/path/to/git

Para desativar a verificação SSL para um repositório específico

Se o repositório estiver completamente sob seu controle, você pode tentar:

git config --global http.sslVerify false

Existem várias opções de configuração SSL no git. Na página do manual de git config:

http.sslVerify
    Whether to verify the SSL certificate when fetching or pushing over HTTPS.
    Can be overridden by the GIT_SSL_NO_VERIFY environment variable.

http.sslCAInfo
    File containing the certificates to verify the peer with when fetching or pushing
    over HTTPS. Can be overridden by the GIT_SSL_CAINFO environment variable.

http.sslCAPath
    Path containing files with the CA certificates to verify the peer with when
    fetching or pushing over HTTPS.
    Can be overridden by the GIT_SSL_CAPATH environment variable.

Algumas outras opções úteis de configuração SSL:

http.sslCert
    File containing the SSL certificate when fetching or pushing over HTTPS.
    Can be overridden by the GIT_SSL_CERT environment variable.

http.sslKey
    File containing the SSL private key when fetching or pushing over HTTPS.
    Can be overridden by the GIT_SSL_KEY environment variable.

http.sslCertPasswordProtected
    Enable git's password prompt for the SSL certificate. Otherwise OpenSSL will
    prompt the user, possibly many times, if the certificate or private key is encrypted.
    Can be overridden by the GIT_SSL_CERT_PASSWORD_PROTECTED environment variable.

Você pode definir GIT_SSL_NO_VERIFYpara true:

GIT_SSL_NO_VERIFY=true git clone https://example.com/path/to/git

ou configure o Git para não verificar a conexão na linha de comando:

git -c http.sslVerify=false clone https://example.com/path/to/git

Observe que, se você não verificar os certificados SSL / TLS, estará suscetível a ataques do MitM .

Não sou muito fã das respostas [EDIT: versões originais das] existentes, porque desabilitar as verificações de segurança deve ser o último recurso, não a primeira solução oferecida. Mesmo que você não possa confiar em certificados autoassinados no primeiro recebimento sem algum método adicional de verificação, o uso do certificado para gitoperações subseqüentes dificulta muito a vida de ataques que só ocorrem após o download do certificado. Em outras palavras, se o certificado baixado for genuíno, você será bom a partir desse ponto em diante. Por outro lado, se você simplesmente desabilitar a verificação, estará aberto a qualquer tipo de ataque man-in-the-middle a qualquer momento .

Para dar um exemplo específico: o famoso repo.or.czrepositório fornece um certificado autoassinado . Eu posso baixar esse arquivo, colocá-lo em algum lugar como /etc/ssl/certse, em seguida, fazer:

# Initial clone
GIT_SSL_CAINFO=/etc/ssl/certs/rorcz_root_cert.pem \
    git clone https://repo.or.cz/org-mode.git

# Ensure all future interactions with origin remote also work
cd org-mode
git config http.sslCAInfo /etc/ssl/certs/rorcz_root_cert.pem

Observe que usar local git configaqui (ou seja, sem --global) significa que esse certificado autoassinado é confiável apenas para este repositório específico, o que é bom. Também é melhor do que usar, GIT_SSL_CAPATHpois elimina o risco de gitfazer a verificação por meio de uma Autoridade de Certificação diferente, que pode ser comprometida.

Configuração de certificado autoassinado Git

tl; dr

NUNCA desative toda a verificação SSL!

Isso cria uma cultura de segurança ruim. Não seja essa pessoa.

As chaves de configuração que você procura são:

• http.sslverify- Sempre verdade. Veja a nota acima.

Estes são para configurar certificados de host nos quais você confia

• http.sslCAPath
• http.sslCAInfo

Estes são para configurar o seu certificado para responder aos desafios do SSL.

• http.sslCert
• http.sslCertPasswordProtected

Aplique seletivamente as configurações acima a hosts específicos.

• http.<url>.*

Global .gitconfigpara autoridades de certificação autoassinadas

Para meu bem e dos meus colegas, aqui é como conseguimos que os certificados autoassinados funcionem sem desativar sslVerify. Edite seu arquivo.gitconfig para git config --global -eadicionar estes:

# Specify the scheme and host as a 'context' that only these settings apply
# Must use Git v1.8.5+ for these contexts to work
[credential "https://your.domain.com"]
  username = user.name

  # Uncomment the credential helper that applies to your platform
  # Windows
  # helper = manager

  # OSX
  # helper = osxkeychain

  # Linux (in-memory credential helper)
  # helper = cache

  # Linux (permanent storage credential helper)
  # https://askubuntu.com/a/776335/491772

# Specify the scheme and host as a 'context' that only these settings apply 
# Must use Git v1.8.5+ for these contexts to work
[http "https://your.domain.com"]
  ##################################
  # Self Signed Server Certificate #
  ##################################

  # MUST be PEM format
  # Some situations require both the CAPath AND CAInfo 
  sslCAInfo = /path/to/selfCA/self-signed-certificate.crt
  sslCAPath = /path/to/selfCA/
  sslVerify = true

  ###########################################
  # Private Key and Certificate information #
  ###########################################

  # Must be PEM format and include BEGIN CERTIFICATE / END CERTIFICATE, 
  # not just the BEGIN PRIVATE KEY / END PRIVATE KEY for Git to recognise it.
  sslCert = /path/to/privatekey/myprivatecert.pem

  # Even if your PEM file is password protected, set this to false.
  # Setting this to true always asks for a password even if you don't have one.
  # When you do have a password, even with this set to false it will prompt anyhow. 
  sslCertPasswordProtected = 0

Referências:

• Credenciais Git
• Armazenamento de credenciais Git
• Usando o Gnome Keyring como armazenamento de credenciais
• Git Config http. <url>. * Compatível com Git v1.8.5

Especifique a configuração ao git clone-ing

Se você precisar aplicá-lo por repo, a documentação solicitará que você execute git config --local no diretório repo. Bem, isso não é útil quando você não tem o repositório clonado localmente, mas agora é?

Você pode fazer o global -> local hokey-pokey definindo sua configuração global como acima e, em seguida, copiá-las para sua configuração de repositório local, uma vez que clona ...

OU o que você pode fazer é especificar comandos de configuraçãogit clone que serão aplicados ao repositório de destino depois que ele for clonado.

# Declare variables to make clone command less verbose     
OUR_CA_PATH=/path/to/selfCA/
OUR_CA_FILE=$OUR_CA_PATH/self-signed-certificate.crt
MY_PEM_FILE=/path/to/privatekey/myprivatecert.pem
SELF_SIGN_CONFIG="-c http.sslCAPath=$OUR_CA_PATH -c http.sslCAInfo=$OUR_CA_FILE -c http.sslVerify=1 -c http.sslCert=$MY_PEM_FILE -c http.sslCertPasswordProtected=0"

# With this environment variable defined it makes subsequent clones easier if you need to pull down multiple repos.
git clone $SELF_SIGN_CONFIG https://mygit.server.com/projects/myproject.git myproject/

One Liner

EDIT: Veja a resposta do VonC que aponta uma ressalva sobre caminhos absolutos e relativos para versões específicas do git de 2.14.x / 2.15 para este liner

git clone -c http.sslCAPath="/path/to/selfCA" -c http.sslCAInfo="/path/to/selfCA/self-signed-certificate.crt" -c http.sslVerify=1 -c http.sslCert="/path/to/privatekey/myprivatecert.pem" -c http.sslCertPasswordProtected=0 https://mygit.server.com/projects/myproject.git myproject/

CentOS unable to load client key

Se você está tentando fazer isso no CentOS e seu .pemarquivo está fornecendo

unable to load client key: "-8178 (SEC_ERROR_BAD_KEY)"

Então você vai querer esta resposta StackOverflow sobre comocurl usa o NSS em vez do Open SSL.

E você deseja reconstruir a curlpartir da fonte :

git clone http://github.com/curl/curl.git curl/
cd curl/
# Need these for ./buildconf
yum install autoconf automake libtool m4 nroff perl -y
#Need these for ./configure
yum install openssl-devel openldap-devel libssh2-devel -y

./buildconf
su # Switch to super user to install into /usr/bin/curl
./configure --with-openssl --with-ldap --with-libssh2 --prefix=/usr/
make
make install

reinicie o computador, pois a libcurl ainda está na memória como uma biblioteca compartilhada

Python, pip e conda

Relacionado : Como adicionar um certificado raiz da CA personalizado ao CA Store usado pelo pip no Windows?

Eu continuo encontrando esse problema, então escrevi um script para baixar o certificado autoassinado do servidor e instalá-lo em ~ / .gitcerts, e atualize o git-config para apontar para esses certificados. Ele é armazenado na configuração global, portanto, você só precisa executá-lo uma vez por controle remoto.

https://github.com/iwonbigbro/tools/blob/master/bin/git-remote-install-cert.sh

Esta resposta foi extraída deste artigo de autoria de Michael Kauffman.

Use o Git for Windows com um certificado SSL corporativo

Edição :

Se você possui um certificado SSL corporativo e deseja clonar seu repositório no console ou no VSCode, obtém o seguinte erro:

fatal: não é possível acessar ' https: // myserver / tfs / DefaultCollection / _git / Proj / ': problema com o certificado SSL: não é possível obter o certificado do emissor local

Solução :

1. Exporte o certificado autoassinado raiz para um arquivo. Você pode fazer isso de dentro do seu navegador.

2. Localize o arquivo “ca-bundle.crt” na sua pasta git (versão atual C: \ Arquivos de Programas \ Git \ usr \ ssl \ certs, mas foi alterado no passado). Copie o arquivo para o seu perfil de usuário. Abra-o com um editor de texto como o VSCode e adicione o conteúdo do seu certificado exportado ao final do arquivo.

Agora temos que configurar o git para usar o novo arquivo:

git config --global http.sslCAInfo C:/Users/<yourname>/ca-bundle.crt

Isso adicionará a seguinte entrada ao seu arquivo .gitconfig na raiz do seu perfil de usuário.

[http] sslCAInfo = C:/Users/<yourname>/ca-bundle.crt

Para desativar a verificação SSL para um repositório específico Se o repositório estiver completamente sob seu controle, você pode tentar:

 git config --global http.sslVerify false

Tenha cuidado quando você estiver usando um forro usando SslKey ou sslcert, como em Josh Peak 's resposta :

git clone -c http.sslCAPath="/path/to/selfCA" \
  -c http.sslCAInfo="/path/to/selfCA/self-signed-certificate.crt" \
  -c http.sslVerify=1 \
  -c http.sslCert="/path/to/privatekey/myprivatecert.pem" \
  -c http.sslCertPasswordProtected=0 \
https://mygit.server.com/projects/myproject.git myproject

Somente o Git 2.14.x / 2.15 (terceiro trimestre de 2015) seria capaz de interpretar um caminho como ~username/mykeycorretamente (embora ainda possa interpretar um caminho absoluto como/path/to/privatekey ).

Veja commit 8d15496 (20 de julho de 2017) por Junio ​​C Hamano ( gitster) .
Ajudado por: Charles Bailey ( hashpling) .
^{(Mesclado por Junio ​​C Hamano - gitster- na confirmação 17b1e1d , 11 de agosto de 2017)}

http.c: http.sslcertehttp.sslkey são os dois nomes de caminho

Voltar quando o caminho de código http_options () moderno foi criado para analisar várias opções http. * Em 29508e1 ("Isolar funcionalidade de solicitação HTTP compartilhada", 18/11/2005, Git 0.99.9k) e depois foi corrigido para a interação entre os vários arquivos de configuração no 7059cd9 (" http_init(): Corrigir análise do arquivo de configuração", 09/03/2009, Git 1.6.3-rc0), analisamos variáveis ​​de configuração como http.sslkey, http.sslcertcomo strings simples, porque git_config_pathname()esse " ~[username]/" prefixo não existe.

Mais tarde, convertemos alguns deles (a saber, http.sslCAPathe http.sslCAInfo) para usar a função e adicionamos variáveis ​​como http.cookeyFile http.pinnedpubkeyusar a função desde o início. Por isso, todas essas variáveis ​​" ~[username]/" entendem o prefixo.

Torne as duas variáveis ​​restantes http.sslcerte http.sslkeytambém saiba da convenção, pois ambas são nomes de caminho claramente para arquivos.

Usando a versão de 64 bits do Git no Windows, basta adicionar o certificado CA autoassinado nesses arquivos:

• C: \ Arquivos de programas \ Git \ mingw64 \ ssl \ certs \ ca-bundle.crt
• C: \ Arquivos de programas \ Git \ mingw64 \ ssl \ certs \ ca-bundle.trust.crt

Se for apenas um certificado autoassinado do servidor, adicione-o

• C: \ Arquivos de programas \ Git \ mingw64 \ ssl \ cert.pem

Verifique suas configurações de antivírus e firewall.

De um dia para o outro, o git não funcionava mais. Com o que foi descrito acima, descobri que a Kaspersky coloca no meio um certificado raiz pessoal do Anti-virus autoassinado. Não consegui deixar o Git aceitar esse certificado seguindo as instruções acima. Eu desisti disso. O que funciona para mim é desativar o recurso de Verificar conexões criptografadas.

1. Abra o Kaspersky
2. Configurações> Adicional> Rede> Não verificar conexões criptografadas

Depois disso, o git funciona novamente com o sslVerify ativado.

Nota. Isso ainda não é satisfatório para mim, porque eu gostaria de ter esse recurso do meu antivírus ativo. Nas configurações avançadas, o Kaspersky mostra uma lista de sites que não funcionarão com esse recurso. O Github não está listado como um deles. Vou verificá-lo no fórum da Kaspersky. Parece haver alguns tópicos, por exemplo, https://forum.kaspersky.com/index.php?/topic/395220-kis-interfering-with-git/&tab=comments#comment-2801211

No arquivo .gitconfig, você pode adicionar o valor abaixo indicado para tornar aceitável o certificado autoassinado

sslCAInfo = /home/XXXX/abc.crt

Eu faço assim:

git init
git config --global http.sslVerify false
git clone https://myurl/myrepo.git

No Windows, isso funcionou para mim:

Adicione o conteúdo do seu certificado autoassinado ao final do arquivo ca-bundle . Incluindo o ----- COMEÇAR CERTIFICADO ----- e ----- TERMINAR CERTIFICADO ----- linhas

A localização do arquivo ca-bundle geralmente é C: \ Arquivos de Programas \ Git \ mingw64 \ ssl \ certs

Depois, adicione o caminho do pacote CA arquivo à configuração global do git. O seguinte comando faz o truque:git config --global http.sslCAInfo "C:/Program Files/Git/mingw64/ssl/certs/ca-bundle.crt"

Observação: o caminho depende do caminho local do arquivo ca-bundle!

Eu uso uma máquina Windows e este artigo me ajudou. Basicamente, abri o ca-bundle.crt no bloco de notas e adicionei certificados de cadeia (todos eles). Esse problema geralmente ocorre em redes de empresas onde temos intermediários sentados entre o sistema e o repositório git. Precisamos exportar todos os certificados na cadeia de certificados, exceto o certificado de folhas no formato base 64 e adicioná-los ao ca-bundle.crt e, em seguida, configurar o git para esse arquivo crt modificado.

Não é uma boa prática definir http.sslVerify false. Em vez disso, podemos usar o certificado SSL.

Portanto, o agente de construção usará https com certificado SSL e PAT para autenticação.

Copie o conteúdo do arquivo cer, incluindo –begin — e –end--.

git bash no agente de construção => git config –global http.sslcainfo “C: / Arquivos de Programas / Git / mingw64 / ssl / certs / ca-bundle.crt” Vá para este arquivo e anexe o conteúdo .cer.

Assim, o agente de construção pode acessar o certificado SSL

Minha resposta pode estar atrasada, mas funcionou para mim. Pode ajudar alguém.

Tentei as etapas acima mencionadas e isso não resolveu o problema.

tente issogit config --global http.sslVerify false