Usando Git, c'è un modo per dirgli di accettare un certificato autofirmato?

Sto usando un server HTTPS per ospitare un server Git ma per ora il certificato è autofirmato.

Quando provo a creare il repository lì per la prima volta:

git push origin master -f

Ottengo l'errore:

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

fatal: git-http-push failed

Per accettare in modo permanente un certificato specifico

Prova http.sslCAPatho http.sslCAInfo. La risposta di Adam Spires fornisce alcuni ottimi esempi. Questa è la soluzione più sicura alla domanda.

Per disabilitare la verifica TLS / SSL per un singolo comando git

Prova a passare -ca gitcon la variabile di configurazione corretta, o utilizzare la risposta di flusso :

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

Per disabilitare la verifica SSL per un repository specifico

Se il repository è completamente sotto il tuo controllo, puoi provare:

git config --global http.sslVerify false

Ci sono alcune opzioni di configurazione SSL in git. Dalla pagina man di 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.

Alcune altre utili opzioni di configurazione 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.

È possibile impostare GIT_SSL_NO_VERIFYsu true:

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

o in alternativa configurare Git per non verificare la connessione dalla riga di comando:

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

Nota che se non verifichi i certificati SSL / TLS, sei suscettibile agli attacchi MitM .

Non sono un grande fan di [EDIT: versioni originali delle] risposte esistenti, perché disabilitare i controlli di sicurezza dovrebbe essere l'ultima risorsa, non la prima soluzione offerta. Anche se non puoi fidarti dei certificati autofirmati alla prima ricevuta senza qualche metodo di verifica aggiuntivo, l'uso del certificato per le gitoperazioni successive rende la vita molto più difficile per gli attacchi che si verificano solo dopo aver scaricato il certificato. In altre parole, se il certificato scaricato è autentico, allora sei bravo da quel momento in poi. Al contrario, se disabiliti semplicemente la verifica, sei aperto a qualsiasi tipo di attacco man-in-the-middle in qualsiasi momento .

Per fare un esempio specifico: il famoso repo.or.czrepository fornisce un certificato autofirmato . Posso scaricare quel file, posizionarlo da qualche parte come /etc/ssl/certs, quindi fare:

# 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

Si noti che l'utilizzo di local git configqui (ovvero senza --global) significa che questo certificato autofirmato è attendibile solo per questo particolare repository, il che è utile. È anche più bello dell'uso GIT_SSL_CAPATHpoiché elimina il rischio di giteseguire la verifica tramite un'autorità di certificazione diversa che potrebbe essere potenzialmente compromessa.

Configurazione del certificato autofirmato Git

tl; dr

Non disabilitare MAI tutta la verifica SSL!

Questo crea una cattiva cultura della sicurezza. Non essere quella persona.

Le chiavi di configurazione che stai cercando sono:

• http.sslverify- Sempre vero. Vedi la nota sopra.

Questi sono per la configurazione dei certificati host di cui ti fidi

• http.sslCAPath
• http.sslCAInfo

Questi sono per la configurazione del TUO certificato per rispondere alle sfide SSL.

• http.sslCert
• http.sslCertPasswordProtected

Applicare selettivamente le impostazioni sopra indicate a host specifici.

• http.<url>.*

Globale .gitconfigper le autorità di certificazione autofirmate

Per il bene mio e dei miei colleghi, ecco come siamo riusciti a far funzionare i certificati autofirmati senza disabilitarli sslVerify. Modifica il tuo.gitconfig usando git config --global -eaggiungi questi:

# 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

Riferimenti:

• Credenziali Git
• Git Credential Store
• Utilizzo di Gnome Keyring come archivio di credenziali
• Git Config http. <url>. * Supportato da Git v1.8.5

Specifica la configurazione quando git clone-ing

Se è necessario applicarlo in base al repository, la documentazione indica di eseguire semplicemente git config --localnella directory del repository. Beh, non è utile quando non hai clonato il repository a livello locale, ma adesso lo è?

È possibile eseguire il global -> localcomando hokey-pokey impostando la configurazione globale come sopra e quindi copiare tali impostazioni nella configurazione del repository locale una volta clonate ...

O quello che puoi fare è specificare i comandi di configurazionegit clone che verranno applicati al repository di destinazione una volta clonato.

# 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/

Una fodera

EDIT: vedi la risposta di VonC che indica un avvertimento sui percorsi assoluti e relativi per specifiche versioni git da 2.14.x / 2.15 a questa riga

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 lo stai provando su CentOS e il tuo .pemfile ti sta dando

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

Quindi vorrai questa risposta StackOverflow su come curlutilizza NSS anziché Open SSL.

E ti piacerebbe ricostruire curldalla 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

riavvia il computer poiché libcurl è ancora in memoria come libreria condivisa

Python, pip e conda

Correlati : Come aggiungere un certificato radice CA personalizzato all'archivio CA utilizzato dal pip in Windows?

Continuo a riscontrare questo problema, quindi ho scritto uno script per scaricare il certificato autofirmato dal server e installarlo su ~ / .gitcerts, quindi aggiornare git-config per puntare a questi certificati. È memorizzato nella configurazione globale, quindi è necessario eseguirlo solo una volta per telecomando.

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

Questa risposta è tratta da questo articolo scritto da Michael Kauffman.

Usa Git per Windows con un certificato SSL aziendale

Problema :

Se si dispone di un certificato SSL aziendale e si desidera clonare il repository dalla console o dal VSCode, viene visualizzato il seguente errore:

fatale: impossibile accedere a " https: // myserver / tfs / DefaultCollection / _git / Proj / ": problema certificato SSL: impossibile ottenere il certificato emittente locale

Soluzione :

1. Esporta il certificato autofirmato di root in un file. Puoi farlo dal tuo browser.

2. Individua il file "ca-bundle.crt" nella cartella git (versione corrente C: \ Programmi \ Git \ usr \ ssl \ certs ma è cambiata in passato). Copia il file nel tuo profilo utente. Aprilo con un editor di testo come VSCode e aggiungi il contenuto del certificato esportato alla fine del file.

Ora dobbiamo configurare git per usare il nuovo file:

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

Ciò aggiungerà la seguente voce al tuo file .gitconfig nella radice del tuo profilo utente.

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

Per disabilitare la verifica SSL per un repository specifico Se il repository è completamente sotto il tuo controllo, puoi provare:

 git config --global http.sslVerify false

Fare attenzione quando si utilizza uno di linea utilizzando sslKey o sslcert, come in Josh Peak 's risposta :

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

Solo Git 2.14.x / 2.15 (3 ° trimestre 2015) sarebbe in grado di interpretare un percorso come ~username/mykeycorrettamente (mentre può ancora interpretare un percorso assoluto come /path/to/privatekey).

Vedi commit 8d15496 (20 lug 2017) di Junio ​​C Hamano ( gitster) .
Assistito da: Charles Bailey ( hashpling) .
^{(Unito da Junio ​​C Hamano - gitster- in commit 17b1e1d , 11 ago 2017)}

http.c: http.sslcerte http.sslkeysono entrambi nomi di percorsi

All'epoca in cui il moderno codepath http_options () veniva creato per analizzare varie opzioni http. * A 29508e1 ("Isola funzionalità di richiesta HTTP condivisa", 18-11-2005, Git 0.99.9k), e in seguito è stato corretto per l'interazione tra i multipli file di configurazione in 7059cd9 (" http_init(): Fix parig file parsing", 2009-03-09, Git 1.6.3-rc0), abbiamo analizzato variabili di configurazione come http.sslkey, http.sslcertcome semplici stringhe di vaniglia, perché git_config_pathname()capisce che il ~[username]/prefisso " " non esisteva.

In seguito, ne abbiamo convertiti alcuni (ovvero, http.sslCAPathe http.sslCAInfo) per usare la funzione e abbiamo aggiunto variabili come http.cookeyFile http.pinnedpubkeyusare la funzione dall'inizio. Per questo motivo, tutte queste variabili comprendono " ~[username]/" il prefisso.

Rendere le restanti due variabili http.sslcerte http.sslkey, anche consapevoli della convenzione, in quanto entrambi sono chiaramente percorsi per i file.

Utilizzando la versione a 64 bit di Git su Windows, è sufficiente aggiungere il certificato CA autofirmato in questi file:

• C: \ Programmi \ Git \ mingw64 \ ssl \ certs \ ca-bundle.crt
• C: \ Programmi \ Git \ mingw64 \ ssl \ certs \ ca-bundle.trust.crt

Se è solo un certificato autofirmato del server, aggiungilo a

• C: \ Programmi \ Git \ mingw64 \ ssl \ cert.pem

Controlla le impostazioni di antivirus e firewall.

Da un giorno all'altro, Git non funzionava più. Con quanto descritto sopra, ho scoperto che Kaspersky mette nel mezzo un certificato radice personale Anti-virus autofirmato. Non sono riuscito a lasciare che Git accettasse quel certificato seguendo le istruzioni sopra. Ci ho rinunciato. Quello che funziona per me è disabilitare la funzione Scansione connessioni crittografate.

1. Apri Kaspersky
2. Impostazioni> Ulteriori> Rete> Non scansionare le connessioni crittografate

Dopodiché, git funziona di nuovo con sslVerify abilitato.

Nota. Questo non è ancora soddisfacente per me, perché vorrei avere quella funzionalità del mio antivirus attiva. Nelle impostazioni avanzate, Kaspersky mostra un elenco di siti Web che non funzioneranno con quella funzione. Github non è elencato come uno di loro. Lo controllerò sul forum di Kaspersky. Sembra che ci siano alcuni argomenti, ad esempio https://forum.kaspersky.com/index.php?/topic/395220-kis-interfering-with-git/&tab=comments#comment-2801211

Nel file .gitconfig è possibile aggiungere il valore indicato di seguito per rendere accettabile il certificato autofirmato

sslCAInfo = /home/XXXX/abc.crt

Lo faccio così:

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

Su Windows ha funzionato per me:

Aggiungi il contenuto del tuo certificato autofirmato alla fine del file ca-bundle . Compreso il ----- INIZIO CERTIFICATO ----- e ----- FINE CERTIFICATO ----- righe

Il percorso del file ca-bundle è in genere C: \ Programmi \ Git \ mingw64 \ ssl \ certs

Successivamente, aggiungi il percorso del file ca-bundle alla configurazione globale di git. Il seguente comando fa il trucco:git config --global http.sslCAInfo "C:/Program Files/Git/mingw64/ssl/certs/ca-bundle.crt"

Nota: il percorso dipende dal percorso locale del file ca-bundle!

Uso un computer Windows e questo articolo mi ha aiutato. Fondamentalmente ho aperto ca-bundle.crt nel blocco note e ho aggiunto certificati a catena (tutti). Questo problema si verifica in genere per le reti aziendali in cui ci sono uomini di mezzo seduti tra il sistema e il repository git. Dobbiamo esportare tutte le certs nella catena di certificati eccetto leaf cert nel formato base 64 e aggiungerle tutte a ca-bundle.crt e quindi configurare git per questo file crt modificato.

Non è una buona pratica impostare http.sslVerify false. Invece possiamo usare il certificato SSL.

Quindi, l'agente di compilazione utilizzerà https con certificato SSL e PAT per l'autenticazione.

Copia il contenuto del file cer incluso –begin — e –end--.

git bash su build agent => git config –global http.sslcainfo “C: / Programmi / Git / mingw64 / ssl / certs / ca-bundle.crt” Vai a questo file e aggiungi il contenuto .cer.

Pertanto, l'agente di costruzione può accedere al certificato SSL

La mia risposta potrebbe essere in ritardo ma ha funzionato per me. Potrebbe aiutare qualcuno.

Ho provato i passaggi sopra menzionati e questo non ha risolto il problema.

prova questogit config --global http.sslVerify false