En utilisant Git, existe-t-il un moyen de lui dire d'accepter un certificat auto-signé?

J'utilise un serveur https pour héberger un serveur git mais pour l'instant le certificat est auto-signé.

Lorsque j'essaie de créer le référentiel là-bas pour la première fois:

git push origin master -f

Je reçois l'erreur:

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

fatal: git-http-push failed

Pour accepter définitivement un certificat spécifique

Essayez http.sslCAPathou http.sslCAInfo. La réponse d'Adam Spiers donne de bons exemples. Il s'agit de la solution la plus sûre à la question.

Pour désactiver la vérification TLS / SSL pour une seule commande git

essayez de passer -cà gitavec la variable de configuration appropriée, ou utilisez la réponse de Flow :

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

Pour désactiver la vérification SSL pour un référentiel spécifique

Si le référentiel est entièrement sous votre contrôle, vous pouvez essayer:

git config --global http.sslVerify false

Il y a pas mal d'options de configuration SSL dans git. Depuis la page de manuel 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.

Quelques autres options de configuration SSL utiles:

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.

Vous pouvez définir GIT_SSL_NO_VERIFYà true:

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

ou bien configurez Git pour ne pas vérifier la connexion sur la ligne de commande:

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

Notez que si vous ne vérifiez pas les certificats SSL / TLS, vous êtes vulnérable aux attaques MitM .

Je ne suis pas un grand fan des [EDIT: versions originales des] réponses existantes, car la désactivation des contrôles de sécurité devrait être un dernier recours, pas la première solution proposée. Même si vous ne pouvez pas faire confiance aux certificats auto-signés à la première réception sans une méthode de vérification supplémentaire, l'utilisation du certificat pour les gitopérations suivantes rend au moins la vie beaucoup plus difficile pour les attaques qui ne surviennent qu'après avoir téléchargé le certificat. En d'autres termes, si le certificat que vous avez téléchargé est authentique, vous êtes bon à partir de ce moment. En revanche, si vous simplement désactiver la vérification , alors vous êtes ouverts à tout type d'attaque man-in-the-middle à tout moment .

Pour donner un exemple précis: le fameux repo.or.czréférentiel fournit un certificat auto-signé . Je peux télécharger ce fichier, le placer quelque part comme /etc/ssl/certs, puis faire:

# 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

Notez que l'utilisation locale git configici (c'est-à-dire sans --global) signifie que ce certificat auto-signé n'est approuvé que pour ce référentiel particulier, ce qui est bien. C'est aussi plus agréable que d'utiliser GIT_SSL_CAPATHcar il élimine le risque de gitfaire la vérification via une autre autorité de certification qui pourrait potentiellement être compromise.

Configuration de certificat auto-signé Git

tl; dr

Ne désactivez JAMAIS toutes les vérifications SSL!

Cela crée une mauvaise culture de sécurité. Ne soyez pas cette personne.

Les clés de configuration que vous recherchez sont les suivantes:

• http.sslverify- Toujours vrai. Voir la note ci-dessus.

Ce sont pour la configuration des certificats hôtes auxquels vous faites confiance

• http.sslCAPath
• http.sslCAInfo

Ce sont pour configurer VOTRE certificat pour répondre aux défis SSL.

• http.sslCert
• http.sslCertPasswordProtected

Appliquez sélectivement les paramètres ci-dessus à des hôtes spécifiques.

• http.<url>.*

Global .gitconfigpour les autorités de certification auto-signées

Pour moi et mes collègues, voici comment nous avons réussi à faire fonctionner les certificats auto-signés sans les désactiver sslVerify. Modifiez votre.gitconfig à l'aide de git config --global -eces ajouter:

# 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

Références:

• Identifiants Git
• Git Credential Store
• Utilisation de Gnome Keyring comme magasin d'informations d'identification
• Git Config http. <url>. * Pris en charge par Git v1.8.5

Spécifiez la configuration lorsque git clone-ing

Si vous devez l'appliquer sur une base par dépôt, la documentation vous indique de simplement exécuter git config --localdans votre répertoire de dépôt. Eh bien, ce n'est pas utile lorsque vous n'avez pas cloné le référentiel localement, n'est-ce pas?

Vous pouvez faire le global -> localhokey-pokey en définissant votre configuration globale comme ci-dessus, puis copiez ces paramètres dans votre configuration de dépôt locale une fois qu'elle est clonée ...

OU ce que vous pouvez faire est de spécifier des commandes de configuration àgit clone appliquer au référentiel cible une fois qu'il est cloné.

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

Bon mot

EDIT: Voir la réponse de VonC qui souligne une mise en garde sur les chemins absolus et relatifs pour les versions spécifiques de git de 2.14.x / 2.15 à cette ligne

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

Si vous essayez ceci sur CentOS et que votre .pemfichier vous donne

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

Ensuite, vous voudrez cette réponse StackOverflow sur la façon dont curlNSS au lieu d'Open SSL.

Et vous aimerez vouloir reconstruire à curlpartir de la source :

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

redémarrer l'ordinateur car libcurl est toujours en mémoire en tant que bibliothèque partagée

Python, pip et conda

Connexe : Comment ajouter un certificat racine CA personnalisé au CA Store utilisé par pip dans Windows?

Je continue de rencontrer ce problème, j'ai donc écrit un script pour télécharger le certificat auto-signé depuis le serveur et l'installer dans ~ / .gitcerts, puis mettre à jour git-config pour pointer vers ces certificats. Il est stocké dans la configuration globale, vous n'avez donc besoin de l'exécuter qu'une seule fois par télécommande.

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

Cette réponse est extraite de cet article rédigé par Michael Kauffman.

Utiliser Git pour Windows avec un certificat SSL d'entreprise

Problème :

Si vous avez un certificat SSL d'entreprise et que vous souhaitez cloner votre référentiel à partir de la console ou du VSCode, vous obtenez l'erreur suivante:

fatal: impossible d'accéder à ' https: // myserver / tfs / DefaultCollection / _git / Proj / ': problème de certificat SSL: impossible d'obtenir le certificat d'émetteur local

Solution :

1. Exportez le certificat auto-signé racine dans un fichier. Vous pouvez le faire depuis votre navigateur.

2. Localisez le fichier «ca-bundle.crt» dans votre dossier git (version actuelle C: \ Program Files \ Git \ usr \ ssl \ certs mais elle a changé dans le passé). Copiez le fichier dans votre profil utilisateur. Ouvrez-le avec un éditeur de texte comme VSCode et ajoutez le contenu de votre certificat exporté à la fin du fichier.

Maintenant, nous devons configurer git pour utiliser le nouveau fichier:

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

Cela ajoutera l'entrée suivante à votre fichier .gitconfig à la racine de votre profil utilisateur.

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

Pour désactiver la vérification SSL pour un référentiel spécifique Si le référentiel est entièrement sous votre contrôle, vous pouvez essayer:

 git config --global http.sslVerify false

Soyez prudent lorsque vous utilisez une doublure à l'aide de sslKey ou sslCert, comme dans la réponse de Josh Peak :

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

Seul Git 2.14.x / 2.15 (Q3 2015) serait capable d'interpréter un chemin comme ~username/mykeycorrectement (alors qu'il peut toujours interpréter un chemin absolu comme /path/to/privatekey).

Voir commit 8d15496 (20 juil.2017 ) de Junio ​​C Hamano ( gitster) .
Aidé par: Charles Bailey ( hashpling) .
^{(Fusionné par Junio ​​C Hamano - gitster- en commit 17b1e1d , 11 août 2017)}

http.c: http.sslcertet http.sslkeysont les deux chemins

À l'époque où le chemin de code moderne http_options () a été créé pour analyser diverses options http. * À 29508e1 ("Isoler la fonctionnalité de demande HTTP partagée", 2005-11-18, Git 0.99.9k), puis a été corrigé plus tard pour l'interaction entre les multiples fichiers de configuration dans 7059cd9 (" http_init(): Correction de l'analyse des fichiers de configuration", 2009-03-09, Git 1.6.3-rc0), nous avons analysé les variables de configuration comme http.sslkey, http.sslcertcomme des chaînes vanille simples, car git_config_pathname()cela comprend " ~[username]/" le préfixe n'existait pas.

Plus tard, nous avons converti certains d'entre eux (à savoir, http.sslCAPathet http.sslCAInfo) pour utiliser la fonction, et ajouté des variables comme http.cookeyFile http.pinnedpubkeypour utiliser la fonction depuis le début. Pour cette raison, ces variables comprennent toutes le " ~[username]/" préfixe.

Faites les deux variables restantes http.sslcertet http.sslkey, également conscient de la convention, car elles sont toutes les deux clairement des chemins d'accès aux fichiers.

En utilisant la version 64 bits de Git sur Windows, ajoutez simplement le certificat CA auto-signé dans ces fichiers:

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

S'il s'agit simplement d'un certificat auto-signé du serveur, ajoutez-le à

• C: \ Program Files \ Git \ mingw64 \ ssl \ cert.pem

Vérifiez vos paramètres antivirus et pare-feu.

Du jour au lendemain, git ne fonctionnait plus. Avec ce qui est décrit ci-dessus, j'ai trouvé que Kaspersky place un certificat racine personnel antivirus auto-signé au milieu. Je n'ai pas réussi à laisser Git accepter ce certificat en suivant les instructions ci-dessus. J'ai abandonné ça. Ce qui fonctionne pour moi, c'est de désactiver la fonction pour analyser les connexions cryptées.

1. Ouvrez Kaspersky
2. Paramètres> Supplémentaire> Réseau> Ne pas analyser les connexions cryptées

Après cela, git fonctionne à nouveau avec sslVerify activé.

Remarque. Ce n'est toujours pas satisfaisant pour moi, car j'aimerais que cette fonctionnalité de mon antivirus soit active. Dans les paramètres avancés, Kaspersky affiche une liste de sites Web qui ne fonctionneront pas avec cette fonctionnalité. Github n'est pas répertorié comme l'un d'eux. Je vais le vérifier sur le forum Kaspersky. Il semble y avoir certains sujets, par exemple https://forum.kaspersky.com/index.php?/topic/395220-kis-interfering-with-git/&tab=comments#comment-2801211

Dans le .gitconfig fichier , vous pouvez ajouter la valeur indiquée ci-dessous pour rendre le certificat auto-signé acceptable

sslCAInfo = /home/XXXX/abc.crt

Je le fais comme ça:

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

Sous Windows, cela a fonctionné pour moi:

Ajoutez le contenu de votre certificat auto-signé à la fin du fichier ca-bundle . Y compris le ----- BEGIN CERTIFICATE ----- et ----- END CERTIFICATE ----- lignes

L'emplacement du fichier ca-bundle est généralement C: \ Program Files \ Git \ mingw64 \ ssl \ certs

Ensuite, ajoutez le chemin du ca-bundle fichier à la configuration globale de git. La commande suivante fait l'affaire:git config --global http.sslCAInfo "C:/Program Files/Git/mingw64/ssl/certs/ca-bundle.crt"

Remarque: le chemin dépend de votre chemin local du fichier ca-bundle!

J'utilise une machine Windows et cet article m'a aidé. Fondamentalement, j'ai ouvert ca-bundle.crt dans le bloc-notes et y ai ajouté des certificats de chaîne (tous). Ce problème se produit généralement pour les réseaux d'entreprise où nous avons des intermédiaires assis entre le système et le dépôt git. Nous devons exporter tous les certificats dans la chaîne cert, sauf le certificat leaf au format base 64, les ajouter tous à ca-bundle.crt, puis configurer git pour ce fichier crt modifié.

Ce n'est pas une bonne pratique de définir http.sslVerify false. Au lieu de cela, nous pouvons utiliser un certificat SSL.

Ainsi, l'agent de build utilisera https avec le certificat SSL et PAT pour l'authentification.

Copiez le contenu du fichier cer, y compris –begin — et –end--.

git bash sur l'agent de build => git config –global http.sslcainfo «C: / Program Files / Git / mingw64 / ssl / certs / ca-bundle.crt» Accédez à ce fichier et ajoutez le contenu .cer.

Ainsi, l'agent de build peut accéder au certificat SSL

Ma réponse est peut-être en retard, mais cela a fonctionné pour moi. Cela peut aider quelqu'un.

J'ai essayé les étapes mentionnées ci-dessus et cela n'a pas résolu le problème.

essaye çagit config --global http.sslVerify false