Question Obtention de Chrome pour accepter le certificat localhost auto-signé


J'ai créé un certificat SSL auto-signé pour le CN localhost. Firefox accepte ce certificat après s'être initialement plaint à ce sujet, comme prévu. Toutefois, Chrome et IE refusent de l'accepter, même après avoir ajouté le certificat au magasin de certificats système sous Racines approuvées. Même si le certificat est répertorié comme correctement installé lorsque je clique sur "Afficher les informations de certificat" dans la fenêtre contextuelle HTTPS de Chrome, le certificat ne peut toujours pas être approuvé.

Que dois-je faire pour que Chrome accepte le certificat et arrête de se plaindre?


795
2017-09-28 08:41


origine


Réponses:


Cela a fonctionné pour moi:

  1. En utilisant Chrome, cliquez sur une page de votre serveur via HTTPS et passez la page d'avertissement rouge (en supposant que vous ne l'ayez pas déjà fait).
  2. S'ouvrir Chrome Settings > Show advanced settings > HTTPS/SSL > Manage Certificates.
  3. Clique le Authorities onglet et faites défiler vers le bas pour trouver votre certificat sous le nom de l'organisation que vous avez donné au certificat.
  4. Sélectionnez-le, cliquez sur Modifier (REMARQUE: dans les versions récentes de Chrome, le bouton est désormais "Avancé" au lieu de "Modifier"), cochez toutes les cases et cliquez sur OK. Vous devrez peut-être redémarrer Chrome.

Vous devriez obtenir le joli verrou vert sur vos pages maintenant.

MODIFIER: Je l'ai essayé à nouveau sur une nouvelle machine et le certificat n'apparaissait pas dans la fenêtre Gérer les certificats en continuant à partir de la page de certificat rouge non approuvée. Je devais faire ce qui suit:

  1. Sur la page avec le certificat non approuvé (https:// est barré en rouge), cliquez sur la serrure> Informations sur le certificat. REMARQUE: sur les nouvelles versions de chrome, vous devez ouvrir Developer Tools > Securityet sélectionnez View certificate.
  2. Clique le Details tab > Export. Choisir PKCS #7, single certificate comme le format de fichier.
  3. Suivez ensuite mes instructions d'origine pour accéder à la page Gérer les certificats. Clique le Authorities tab > Import et choisissez le fichier dans lequel vous avez exporté le certificat, et assurez-vous de choisir  PKCS #7, single certificate  comme le type de fichier.
  4. Si vous êtes invité magasin de certification, choisissez Autorités de certification racine de confiance
  5. Cochez toutes les cases et cliquez sur OK. Redémarrez Chrome.

414
2018-02-25 21:14



PAS POUR PROD

Collez simplement ceci dans votre chrome:

chrome://flags/#allow-insecure-localhost

Vous devriez voir le texte en surbrillance disant: Autoriser les certificats non valides pour les ressources chargées depuis localhost

Cliquez sur Enable.


393
2017-08-09 01:52



Sur le Mac, vous pouvez utiliser l'utilitaire Keychain Access pour ajouter le certificat auto-signé au trousseau System, et Chrome l'acceptera. J'ai trouvé les instructions étape par étape ici:

Google Chrome, Mac OS X et les certificats SSL auto-signés

Fondamentalement:

  1. double-cliquez sur l'icône de verrouillage avec un X et faites glisser l'icône du certificat sur le bureau,
  2. ouvrir ce fichier (se terminant par une extension .cer); cela ouvre l'application de trousseau qui vous permet d'approuver le certificat.

119
2017-10-31 15:56



MISE À JOUR POUR CHROME 58+ (LIBÉRÉ le 2017-04-19)

À partir de Chrome 58, identification de l'hôte en utilisant uniquement commonName  est en train d'être retiré. Voir plus loin discussion ici et bug tracker ici. Autrefois, subjectAltName a été utilisé uniquement pour les certificats multi-hôtes, de sorte que certains outils CA internes ne peuvent pas les inclure.

Si vos certificats auto-signés ont bien fonctionné dans le passé mais a soudainement commencé à générer des erreurs dans Chrome 58, c'est pourquoi.

Quelle que soit la méthode que vous utilisez pour générer votre certificat auto-signé (ou un certificat signé par une autorité de certification auto-signée), assurez-vous que le certificat du serveur contient un subjectAltName avec le bon DNS et / ou IP entrée / entrées, même si c'est pour un seul hôte.

Pour openssl, cela signifie que votre config aura quelque chose de similaire à ce qui suit pour un seul hôte:

[v3_req]
subjectAltName = DNS:example.com

ou pour plusieurs hôtes:

[v3_req]
subjectAltName = DNS:example.com, DNS:host1.example.com, DNS:*.host2.example.com, IP:10.1.2.3

Dans le visualiseur de cert de Chrome (qui a été déplacé vers l'onglet "Sécurité" sous F12), vous devriez le voir sous Extensions comme Certificate Subject Alternative Name:

Chrome cert viewer


CONTOURNEMENT TEMPORAIRE

Il est possible de revenir à l'ancien commonName comportement jusqu'à Chrome 65, en utilisant le paramètre suivant: EnableCommonNameFallbackForLocalAnchors

Sur Windows, ceci peut être réglé sur un seul PC en utilisant la commande de registre suivante (merci @Meengla):

reg add HKLM\Software\Policies\Google\Chrome /v EnableCommonNameFallbackForLocalAnchors /t REG_DWORD /d 1

Sur Mac, la commande suivante peut être utilisée (merci @BugsBunny):

defaults write com.google.Chrome EnableCommonNameFallbackForLocalAnchors -bool true

Sur Linux, créez un fichier de stratégie tel que /etc/opt/chrome/policies/managed/EnableCommonNameFallbackFor‌​LocalAnchors.json avec le contenu: { "EnableCommonNameFallbackForLocalAnchors": true } (merci @seanf)

Plus de détails sur la définition de ces stratégies pour différentes plates-formes, y compris la définition via Windows GPO, peuvent être trouvés en haut de la page liée ainsi que le guide de modèle de politique Chromium et le Guide des administrateurs.


Encore une fois, ces solutions de contournement sont temporaire jusqu'à la version 65!


98
2018-03-21 02:12



UPDATE 11/2017: Cette réponse ne fonctionnera probablement pas pour la plupart des nouvelles versions de Chrome.

MISE À JOUR 02/2016: De meilleures instructions pour les utilisateurs Mac peuvent être trouvées Ici.

  1. Sur le site que vous souhaitez ajouter, cliquez avec le bouton droit sur l'icône de verrouillage rouge dans la barre d'adresse:enter image description here

    1. Cliquez sur l'onglet intitulé Connexion, puis clique Informations sur le certificat

    2. Clique le Détails onglet, le clic sur le bouton Copier dans un fichier .... Cela ouvrira l'Assistant Exportation de certificat, cliquez sur Prochain Pour arriver au Format de fichier d'exportation écran.

    3. Choisir Binaire codé DER X.509 (.CER), Cliquez sur Prochain

    4. Cliquez sur Feuilleter... et enregistrez le fichier sur votre ordinateur. Nommez-le quelque chose de descriptif. Cliquez sur Prochain, puis clique terminer.

    5. Ouvrez les paramètres de Chrome, faites défiler vers le bas et cliquez sur Afficher les paramètres avancés...

    6. En dessous de HTTPS / SSL, Cliquez sur Gérer les certificats ...

    7. Clique le Autorités de certification racine de confiance onglet, puis cliquez sur le Importer... bouton. Cela ouvre l'Assistant Importation de certificat. Cliquez sur Prochain Pour arriver au Fichier à importer écran.

    8. Cliquez sur Feuilleter... et sélectionnez le fichier de certificat que vous avez enregistré précédemment, puis cliquez sur Prochain.

    9. Sélectionner Placez tous les certificats dans le magasin suivant. Le magasin sélectionné doit être Autorités de certification racine de confiance. Si ce n'est pas le cas, cliquez Feuilleter...et sélectionnez-le. Cliquez sur Prochain et terminer

    10. Cliquez sur Oui sur l'avertissement de sécurité.

    11. Redémarrez Chrome.


86
2017-09-03 22:56



Linux

Si vous utilisez Linux, vous pouvez également suivre les pages wiki officielles:

Fondamentalement:

  • cliquez sur l'icône de verrouillage avec un X,
  • choisissez l'information de certificat
  • aller à l'onglet Détails
  • Cliquez sur Export ... (enregistrer sous forme de fichier)

Maintenant, la commande suivante ajoutera le certificat (où YOUR_FILE est votre fichier exporté):

certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n YOUR_FILE -i YOUR_FILE

Pour répertorier tous vos certificats, exécutez la commande suivante:

certutil -d sql:$HOME/.pki/nssdb -L

Si cela ne fonctionne toujours pas, vous pourriez être affecté par ce bogue: Problème 55050: erreur Ubuntu SSL 8179

P.S. S'il vous plaît assurez-vous également que vous avez libnss3-tools, avant de pouvoir utiliser les commandes ci-dessus.

Si vous ne l'avez pas, installez le par:

sudo apt-get install libnss3-tools # on Ubuntu
sudo yum install nss-tools # on Fedora, Red Hat, etc.

En prime, vous pouvez utiliser les scripts pratiques suivants:

$ cat add_cert.sh
certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n $1 -i $1
$ cat list_cert.sh
certutil -d sql:$HOME/.pki/nssdb -L # add '-h all' to see all built-in certs
$ cat download_cert.sh
echo QUIT | openssl s_client -connect $1:443 | sed -ne '/BEGIN CERT/,/END CERT/p'

Usage:

add_cert.sh [FILE]
list_cert.sh
download_cert.sh [DOMAIN]

Dépannage

  • Exécuter Chrome avec --auto-ssl-client-auth paramètre

    google-chrome --auto-ssl-client-auth


82
2017-09-18 14:11



Cliquez n'importe où sur la page et tapez une BYPASS_SEQUENCE

"thisisunsafe"est une BYPASS_SEQUENCE pour la version Chrome 65

"badidea"Version Chrome 62 - 64.

"danger"utilisé pour travailler dans les versions antérieures de Chrome

Vous n'avez pas besoin de chercher un champ de saisie, il suffit de le taper. C'est étrange mais ça marche.

Je l'ai essayé sur Mac High Sierra.

Pour vérifier si elles l'ont encore changé, allez à Dernier chrome Code source 

Pour rechercher BYPASS_SEQUENCE, il ressemble à cela pour le moment:

var BYPASS_SEQUENCE = window.atob('dGhpc2lzdW5zYWZl');

Maintenant, ils l'ont camouflé, mais pour voir le BYPASS_SEQUENCE réel, vous pouvez exécuter la ligne suivante dans une console du navigateur.

console.log(window.atob('dGhpc2lzdW5zYWZl'));

65
2017-12-05 05:08



Si vous êtes sur un mac et ne pas voir l'onglet d'exportation ou comment obtenir le certificat cela a fonctionné pour moi:

  1. Cliquez sur le verrou avant le https: //
  2. Allez dans l'onglet "Connexion"
  3. Cliquez sur "Informations sur le certificat"

    Maintenant, vous devriez voir ceci: Different information of course and yours should be marked as trusted yet (otherwise      you probably wouldn't be here)

  4. Faites glisser cette petite icône de certificat sur votre bureau (ou n'importe où).

  5. Double-cliquez sur le fichier .cer qui a été téléchargé, cela devrait l'importer dans votre trousseau et ouvrir Keychain Access à votre liste de certificats.

    Dans certains cas, cela suffit et vous pouvez maintenant actualiser la page.

    Autrement:

  6. Double-cliquez sur le certificat nouvellement ajouté.
  7. Sous la liste déroulante de confiance, modifiez l'option "Lors de l'utilisation de ce certificat" pour "Toujours faire confiance".

Maintenant, rechargez la page en question et il devrait être résolu! J'espère que cela t'aides.


Modifier à partir de Wolph

Pour rendre cela un peu plus facile, vous pouvez utiliser le script suivant (la source):

  1. Enregistrer les éléments suivants scénario comme whitelist_ssl_certificate.ssh:

    #!/usr/bin/env bash -e
    
    SERVERNAME=$(echo "$1" | sed -E -e 's/https?:\/\///' -e 's/\/.*//')
    echo "$SERVERNAME"
    
    if [[ "$SERVERNAME" =~ .*\..* ]]; then
        echo "Adding certificate for $SERVERNAME"
        echo -n | openssl s_client -connect $SERVERNAME:443 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' | tee /tmp/$SERVERNAME.cert
        sudo security add-trusted-cert -d -r trustRoot -k "/Library/Keychains/System.keychain" /tmp/$SERVERNAME.cert
    else
        echo "Usage: $0 www.site.name"
        echo "http:// and such will be stripped automatically"
    fi
    
  2. Rendre le script exécutable (depuis le shell):

    chmod +x whitelist_ssl_certificate.ssh
    
  3. Exécutez le script pour le domaine que vous voulez (il suffit de copier / coller l'url complète):

    ./whitelist_ssl_certificate.ssh https://your_website/whatever
    

55
2018-01-14 04:53



Sur Mac, vous pouvez créer un certificat approuvé par Chrome et Safari au niveau du système en procédant comme suit:

# create a root authority cert
./create_root_cert_and_key.sh

# create a wildcard cert for mysite.com
./create_certificate_for_domain.sh mysite.com

# or create a cert for www.mysite.com, no wildcards
./create_certificate_for_domain.sh www.mysite.com www.mysite.com

Ce qui précède utilise les scripts suivants et un fichier de support v3.ext, à évitez le sujet autre nom manquant des erreurs

Si vous voulez créer un nouveau CERT auto-signé qui est entièrement approuvé en utilisant votre propre autorité racine, vous pouvez le faire en utilisant ces scripts.

create_root_cert_and_key.sh

#!/usr/bin/env bash
openssl genrsa -out rootCA.key 2048
openssl req -x509 -new -nodes -key rootCA.key -sha256 -days 1024 -out rootCA.pem

create_certificate_for_domain.sh

#!/usr/bin/env bash

if [ -z "$1" ]
then
  echo "Please supply a subdomain to create a certificate for";
  echo "e.g. www.mysite.com"
  exit;
fi

if [ ! -f rootCA.pem ]; then
  echo 'Please run "create_root_cert_and_key.sh" first, and try again!'
  exit;
fi
if [ ! -f v3.ext ]; then
  echo 'Please download the "v3.ext" file and try again!'
  exit;
fi

# Create a new private key if one doesnt exist, or use the xeisting one if it does
if [ -f device.key ]; then
  KEY_OPT="-key"
else
  KEY_OPT="-keyout"
fi

DOMAIN=$1
COMMON_NAME=${2:-*.$1}
SUBJECT="/C=CA/ST=None/L=NB/O=None/CN=$COMMON_NAME"
NUM_OF_DAYS=999
openssl req -new -newkey rsa:2048 -sha256 -nodes $KEY_OPT device.key -subj "$SUBJECT" -out device.csr
cat v3.ext | sed s/%%DOMAIN%%/"$COMMON_NAME"/g > /tmp/__v3.ext
openssl x509 -req -in device.csr -CA rootCA.pem -CAkey rootCA.key -CAcreateserial -out device.crt -days $NUM_OF_DAYS -sha256 -extfile /tmp/__v3.ext 

# move output files to final filenames
mv device.csr "$DOMAIN.csr"
cp device.crt "$DOMAIN.crt"

# remove temp file
rm -f device.crt;

echo 
echo "###########################################################################"
echo Done! 
echo "###########################################################################"
echo "To use these files on your server, simply copy both $DOMAIN.csr and"
echo "device.key to your webserver, and use like so (if Apache, for example)"
echo 
echo "    SSLCertificateFile    /path_to_your_files/$DOMAIN.crt"
echo "    SSLCertificateKeyFile /path_to_your_files/device.key"

v3.ext

authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names

[alt_names]
DNS.1 = %%DOMAIN%%

Une étape de plus - Comment rendre les certificats auto-signés entièrement fiables dans Chrome / Safari

Pour que les certificats autosignés soient entièrement approuvés dans Chrome et Safari, vous devez importer une nouvelle autorité de certification dans votre Mac. Pour ce faire, suivez ces instructions, ou les instructions plus détaillées sur ce processus général sur le site web de mitmproxy:

  1. Ouvrir l'accès au trousseau
  2. Choisissez "Système" dans la liste "Porte-clés"
  3. Choisissez "Certificats" dans la liste "Catégorie"
  4. Choisissez "Fichier | Importer des éléments ..."
  5. Accédez au fichier créé ci-dessus, "rootCA.pem", sélectionnez-le et cliquez sur "Ouvrir"
  6. Sélectionnez votre certificat nouvellement importé dans la liste "Certificats".
  7. Cliquez sur le bouton "i" ou faites un clic droit sur votre certificat et choisissez "Obtenir des informations"
  8. Développer l'option "Trust"
  9. Remplacez "Lors de l'utilisation de ce certificat" par "Toujours faire confiance"
  10. Fermez la boîte de dialogue et votre mot de passe vous sera demandé.
  11. Fermez et rouvrez tous les onglets qui utilisent votre domaine cible, et il sera chargé en toute sécurité!

et en prime, si vous avez besoin que les clients java fassent confiance aux certificats, vous pouvez le faire en important vos certificats dans le keystore java. Notez que cela supprimera le cert du fichier de clés s'il existe déjà, car il doit le mettre à jour au cas où les choses changeraient. Bien sûr, cela ne concerne que les certificats importés.

import_certs_in_current_folder_into_java_keystore.sh

KEYSTORE="$(/usr/libexec/java_home)/jre/lib/security/cacerts";

function running_as_root()
{
  if [ "$EUID" -ne 0 ]
    then echo "NO"
    exit
  fi

  echo "YES"
}

function import_certs_to_java_keystore
{
  for crt in *.crt; do 
    echo prepping $crt 
    keytool -delete -storepass changeit -alias alias__${crt} -keystore $KEYSTORE;
    keytool -import -file $crt -storepass changeit -noprompt --alias alias__${crt} -keystore $KEYSTORE
    echo 
  done
}

if [ "$(running_as_root)" == "YES" ]
then
  import_certs_to_java_keystore
else
  echo "This script needs to be run as root!"
fi

52
2018-04-27 19:20



ACTUALISÉ 3 avril 1818

Recommandé par l'équipe Chromium

https://www.chromium.org/Home/chromium-security/deprecating-powerful-features-on-insecure-origins#TOC-Testing-Powerful-Features

Solution rapide et facile

Il existe une phrase de contournement secrète qui peut être tapée dans la page d'erreur pour que Chrome procède malgré l'erreur de sécurité: thisisunsafe (dans les versions antérieures de Chrome, tapez mauvaise idéeet même plus tôt, danger). FAIRE NE PAS UTILISEZ CECI SAUF SI VOUS COMPRENEZ EXACTEMENT POURQUOI VOUS EN AVEZ BESOIN!

La source:

https://chromium.googlesource.com/chromium/src/+/d8fc089b62cd4f8d907acff6fb3f5ff58f168697%5E%21/

(Notez que window.atob('dGhpc2lzdW5zYWZl') décide de thisisunsafe)

La dernière version de la source est @ https://chromium.googlesource.com/chromium/src/+/refs/heads/master/components/security_interstitials/core/browser/resources/interstitial_large.js et le window.atob La fonction peut être exécutée dans une console JS.

Pour plus d'informations sur les raisons pour lesquelles l'équipe Chrome a modifié la phrase de contournement (la première fois):

https://bugs.chromium.org/p/chromium/issues/detail?id=581189

Si tout le reste échoue

Pour les one-off rapides si l'option "Proceed Anyway" n'est pas disponible, ni la phrase de contournement ne fonctionne, ce hack fonctionne bien:

  1. Autoriser les erreurs de certificat de localhost en activant ce drapeau (notez que Chrome doit être redémarré après avoir changé la valeur de l'indicateur):

    chrome://flags/#allow-insecure-localhost

    (et réponse de vote https://stackoverflow.com/a/31900210/430128 par @Chris)

  2. Si le site auquel vous souhaitez vous connecter est localhost, vous avez terminé. Sinon, configurez un tunnel TCP pour écouter localement le port 8090 et connectez-vous à broken-remote-site.com sur le port 443, assurez-vous d'avoir socat installé et exécuter quelque chose comme ça dans une fenêtre de terminal:

    socat tcp-listen:8090,reuseaddr,fork tcp:broken-remote-site.com:443

  3. Aller à https: // localhost: 8090 dans votre navigateur


34
2017-08-12 20:38



Pour un environnement de test

Vous pouvez utiliser --ignore-certificate-errors comme paramètre de ligne de commande lors du lancement de chrome (Travailler sur la version 28.0.1500.52 sur Ubuntu).

Cela l'amènera à ignorer les erreurs et à se connecter sans avertissement. Si vous avez déjà une version de chrome en cours d'exécution, vous devrez la fermer avant de la relancer depuis la ligne de commande, sinon elle ouvrira une nouvelle fenêtre mais ignorera les paramètres.

Je configure Intellij pour lancer le chrome de cette façon lors du débogage, car les serveurs de test n'ont jamais de certificats valides.

Je ne recommanderais pas une navigation normale comme celle-ci, car les vérifications de certificats sont une fonctionnalité de sécurité importante, mais cela peut être utile pour certains.


30
2018-06-26 13:13