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

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

2020-05-22 : Avec seulement 6 commandes shell , vous pouvez accomplir cela.

Veuillez ne pas modifier les paramètres de sécurité de votre navigateur.

Avec le code suivant, vous pouvez (1) devenir votre propre autorité de certification, (2) puis signer votre certificat SSL en tant qu'autorité de certification. (3) Importez ensuite le certificat CA (pas le certificat SSL, qui va sur votre serveur) dans Chrome / Chromium. (Oui, cela fonctionne même sous Linux.)

######################
# Become a Certificate Authority
######################

# Generate private key
openssl genrsa -des3 -out myCA.key 2048
# Generate root certificate
openssl req -x509 -new -nodes -key myCA.key -sha256 -days 825 -out myCA.pem

######################
# Create CA-signed certs
######################

NAME=mydomain.com # Use your own domain name
# Generate a private key
openssl genrsa -out $NAME.key 2048
# Create a certificate-signing request
openssl req -new -key $NAME.key -out $NAME.csr
# Create a config file for the extensions
>$NAME.ext cat <<-EOF
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
subjectAltName = @alt_names
[alt_names]
DNS.1 = $NAME # Be sure to include the domain name here because Common Name is not so commonly honoured by itself
DNS.2 = bar.$NAME # Optionally, add additional domains (I've added a subdomain here)
IP.1 = 192.168.0.13 # Optionally, add an IP address (if the connection which you have planned requires it)
EOF
# Create the signed certificate
openssl x509 -req -in $NAME.csr -CA myCA.pem -CAkey myCA.key -CAcreateserial \
-out $NAME.crt -days 825 -sha256 -extfile $NAME.ext

Récapituler:

1. Devenez CA
2. Signez votre certificat à l'aide de votre clé CA
3. Importer myCA.pemen tant qu'autorité dans vos paramètres Chrome (Paramètres> Gérer les certificats> Autorités> Importer)
4. Utilisez le .crtfichier sur votre serveur

Étapes supplémentaires (pour Mac, au moins):

1. Importez le certificat CA dans "Fichier> Importer un fichier", puis trouvez-le également dans la liste, faites un clic droit dessus, développez "> Confiance" et sélectionnez "Toujours".
2. Ajoutez extendedKeyUsage=serverAuth,clientAuthci basicConstraints=CA:FALSE- dessous et assurez-vous de définir le "CommonName" sur le même que $NAMElors de la demande de configuration

Vous pouvez vérifier votre travail

openssl verify -CAfile myCA.pem -verify_hostname bar.mydomain.com mydomain.com.crt

Pour localhostseulement:

Collez-le simplement dans votre chrome:

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

Vous devriez voir le texte en surbrillance dire: Autoriser les certificats non valides pour les ressources chargées à partir de l'hôte local

Cliquez Enable.

Cela a fonctionné pour moi:

1. À l'aide de Chrome, accédez à une page de votre serveur via HTTPS et continuez après la page d'avertissement rouge (en supposant que vous ne l'ayez pas déjà fait).
2. Ouvrez Chrome Settings > Show advanced settings > HTTPS/SSL > Manage Certificates.
3. Cliquez sur l' Authoritiesonglet 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 maintenant avoir le joli cadenas vert sur vos pages.

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

1. Sur la page contenant le certificat non approuvé ( https://barré en rouge), cliquez sur le verrou> Informations sur le certificat. REMARQUE: sur les versions plus récentes de Chrome, vous devez ouvrir Developer Tools > Securityet sélectionner View certificate.
2. Cliquez sur Details tab > Export. Choisissez PKCS #7, single certificatecomme format de fichier.
3. Suivez ensuite mes instructions d'origine pour accéder à la page Gérer les certificats. Cliquez sur Authorities tab > Importet choisissez le fichier dans lequel vous avez exporté le certificat, et assurez-vous de choisir PKCS #7, single certificate comme type de fichier .
4. Si un magasin de certification vous y invite, choisissez Autorités de certification racines de confiance
5. Cochez toutes les cases et cliquez sur OK. Redémarrez Chrome.

MISE À JOUR POUR CHROME 58+ (SORTIE 2017-04-19)

Depuis Chrome 58, la possibilité d'identifier l'hôte en utilisant uniquement a commonName été supprimée . Les certificats doivent désormais être utilisés subjectAltNamepour identifier leurs hôtes. Voir plus de discussion ici et tracker de bogues ici . Auparavant, subjectAltNameétait utilisé uniquement pour les certificats multi-hôtes, de sorte que certains outils CA internes ne les incluent pas.

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

Donc, quelle que soit la méthode que vous utilisez pour générer votre certificat auto-signé (ou certificat signé par une autorité de certification auto-signée), assurez-vous que le certificat du serveur contient un subjectAltNameavec la bonne DNSet / ou IPentrée / entrées, même si c'est juste pour un seul hôte .

Pour openssl, cela signifie que votre configuration OpenSSL ( /etc/ssl/openssl.cnfsur Ubuntu) devrait avoir quelque chose de similaire à ce qui suit pour un seul hôte:

[v3_ca]   # and/or [v3_req], if you are generating a CSR
subjectAltName = DNS:example.com

ou pour plusieurs hôtes:

[v3_ca]   # and/or [v3_req], if you are generating a CSR
subjectAltName = DNS:example.com, DNS:host1.example.com, DNS:*.host2.example.com, IP:10.1.2.3

Dans la visionneuse de cert de Chrome (qui a déplacé à l' onglet « Sécurité » sous F12) vous devriez le voir répertorié sous Extensionscomme Certificate Subject Alternative Name:

Sur le Mac, vous pouvez utiliser l'utilitaire d'accès au trousseau pour ajouter le certificat auto-signé au trousseau système, et Chrome l'acceptera ensuite. J'ai trouvé les instructions étape par étape ici:

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

Fondamentalement:

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

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

" thisisunsafe" est un BYPASS_SEQUENCE pour Chrome version 65

" badidea" Chrome version 62 - 64.

" danger" fonctionnait dans les versions antérieures de Chrome

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

Je l'ai essayé sur Mac High Sierra.

Pour vérifier s'ils l'ont changé à nouveau, accédez au dernier code source de chrome

Pour rechercher BYPASS_SEQUENCE, pour le moment cela ressemble à ça:

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

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

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

Linux

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

• Configuration des certificats SSL sur Linux.
• Base de données partagée NSS et LINUX
• Guide de base de données partagée NSS

Fondamentalement:

• cliquez sur l'icône du cadenas avec un X,
• choisissez les informations du certificat
• aller à l'onglet Détails
• Cliquez sur Exporter ... (enregistrer en tant que fichier)

Maintenant, la commande suivante va ajouter le certificat (où VOTRE_FICHIER 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 pouvez être affecté par ce bogue: Problème 55050: Erreur SSL Ubuntu 8179

PS Veuillez également vous assurer que vous avez libnss3-tools, avant de pouvoir utiliser les commandes ci-dessus.

Si vous n'en avez pas, veuillez l'installer en:

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-authparamètre

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

Sur le Mac, vous pouvez créer un certificat entièrement 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.extpour éviter les erreurs manquantes du nom alternatif du sujet

Si vous souhaitez créer un nouveau certificat auto-signé entièrement fiable à l'aide de votre propre autorité racine, vous pouvez le faire à l'aide de 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=825
    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 permettre aux certificats auto-signés d'être 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 mitmproxy :

Vous pouvez le faire de deux manières, en ligne de commande, en utilisant cette commande qui vous demandera votre mot de passe:

$ sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain rootCA.pem

ou en utilisant l' Keychain Accessapplication:

1. Accès au trousseau ouvert
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. Naviguez jusqu'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éveloppez l'option "Trust"
9. Remplacez «Lors de l'utilisation de ce certificat» par «Toujours faire confiance»
10. Fermez la boîte de dialogue et vous serez invité à entrer votre mot de passe.
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 de clients java pour faire confiance aux certificats, vous pouvez le faire en important vos certificats dans le magasin de clés java. Notez que cela supprimera le certificat du magasin 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 s'applique qu'aux 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

MISE À JOUR 11/2017: Cette réponse ne fonctionnera probablement pas pour la plupart des versions plus récentes de Chrome.

MISE À JOUR 02/2016: De meilleures instructions pour les utilisateurs de 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:

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

   3. Cliquez sur le Détails onglet, le cliquez sur le bouton Copier dans un fichier ... . Cela ouvrira l'Assistant Exportation de certificat, cliquez sur Suivant pour accéder à l' écran Exporter le format de fichier .

   4. Choisissez le binaire codé DER X.509 (.CER) , cliquez sur Suivant

   5. Cliquez sur Parcourir ... et enregistrez le fichier sur votre ordinateur. Nommez-le quelque chose de descriptif. Cliquez sur Suivant , puis sur Terminer .

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

   7. Sous HTTPS / SSL , cliquez sur Gérer les certificats ...

   8. Cliquez sur la racine de confiance Autorités de certification onglet, puis cliquez sur l' importation ... bouton. Cela ouvre l'Assistant Importation de certificat. Cliquez sur Suivant pour accéder à l' écran Fichier à importer .

   9. Cliquez sur Parcourir ... et sélectionnez le fichier de certificat que vous avez enregistré précédemment, puis cliquez sur Suivant .

   10. Sélectionnez Placer tous les certificats dans le magasin suivant . Le magasin sélectionné doit être des autorités de certification racines de confiance . Si ce n'est pas le cas, cliquez sur Parcourir ... et sélectionnez-le. Cliquez sur Suivant et Terminer

   11. Cliquez sur Oui dans l'avertissement de sécurité.

   12. Redémarrez Chrome.

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

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

3. Cliquez sur "Informations sur le certificat"

   Vous devriez maintenant voir ceci:

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 l'accès au trousseau à 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, changez l'option "Lors de l'utilisation de ce certificat" en "Toujours faire confiance"

Rechargez maintenant la page en question et le problème 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 ( source ):

1. Enregistrez le script suivant sous 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. Rendez le script exécutable (à partir du shell):

   chmod +x whitelist_ssl_certificate.ssh

3. Exécutez le script pour le domaine que vous souhaitez (copiez / collez simplement les URL complètes):

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

MISE À JOUR 23 avril 2020

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 super facile

Il existe une phrase de contournement secrète qui peut être tapée dans la page d'erreur pour que Chrome continue malgré l'erreur de sécurité: thisisunsafe (dans les versions antérieures de Chrome, tapez badidea , et même plus tôt, danger ). N'UTILISEZ PAS CELA À MOINS QUE VOUS COMPRENIEZ EXACTEMENT POURQUOI VOUS EN AVEZ BESOIN!

La source:

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

(REMARQUE qui window.atob('dGhpc2lzdW5zYWZl')résoutthisisunsafe )

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 la window.atobfonction peut être exécutée dans une console JS.

Pour savoir pourquoi 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 (Solution # 1)

Pour des one-offs rapides si l'option "Continue Anyway" n'est pas disponible, ou si la phrase de contournement fonctionne, ce hack fonctionne bien:

1. Autoriser les erreurs de certificat localhosten activant cet indicateur (notez que Chrome a besoin d'un redémarrage après avoir modifié la valeur de l'indicateur):

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

   (et réponse au 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 sur le port 8090 et connectez-vous broken-remote-site.comsur le port 443, assurez-vous d'avoir socatinstallé et exécuté quelque chose comme ceci dans une fenêtre de terminal:

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

3. Accédez à https: // localhost: 8090 dans votre navigateur.

Si tout le reste échoue (Solution # 2)

Similaire à "Si tout le reste échoue (Solution # 1)", nous configurons ici un proxy pour notre service local en utilisant ngrok . Étant donné que vous pouvez accéder aux tunnels http ngrok via TLS (auquel cas il est terminé par ngrok avec un certificat valide) ou via un point de terminaison non TLS, le navigateur ne se plaindra pas des certificats non valides.

Téléchargez et installez ngrok, puis exposez-le via ngrok.io:

ngrok http https://localhost

ngrok démarrera et vous fournira un nom d'hôte auquel vous pourrez vous connecter, et toutes les demandes seront retransmises en tunnel vers votre machine locale.

Pour un environnement de test

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

Cela lui fera 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 relancer la ligne de commande ou cela ouvrira une nouvelle fenêtre mais ignorera les paramètres.

Je configure Intellij pour lancer 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.

Comme quelqu'un l'a remarqué, vous devez redémarrer TOUS Chrome, pas seulement les fenêtres du navigateur. Le moyen le plus rapide de le faire est d'ouvrir un onglet pour ...

chrome://restart

WINDOWS JUN / 2017 Windows Server 2012

J'ai suivi la réponse de @Brad Parks. Sous Windows, vous devez importer rootCA.pem dans le magasin Trusted Root Certificates Authorities.

J'ai fait les étapes suivantes:

openssl genrsa -out rootCA.key 4096
openssl req -x509 -new -nodes -key rootCA.key -newkey rsa:4096 -sha256 -days 1024 -out rootCA.pem
openssl req -new -newkey rsa:4096 -sha256 -nodes -keyout device.key -out device.csr
openssl x509 -req -in device.csr -CA rootCA.pem -CAkey rootCA.key -CAcreateserial -out device.crt -days 2000 -sha256 -extfile v3.ext

Où v3.ext est:

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

[alt_names]
DNS.1 = localhost
IP.1 = 192.168.0.2
IP.2 = 127.0.0.1

Ensuite, dans mon cas, j'ai une application web auto-hébergée, j'ai donc besoin de lier le certificat avec l'adresse IP et le port, le certificat doit être sur MON magasin avec des informations de clé privée, j'ai donc exporté au format pfx.

openssl pkcs12 -export -out device.pfx -inkey device.key -in device.crt

Avec la console mmc (Fichier / Ajouter ou supprimer des composants logiciels enfichables / Certificats / Ajouter / Compte d'ordinateur / Ordinateur local / OK), j'ai importé un fichier pfx dans le magasin personnel.

Plus tard, j'ai utilisé cette commande pour lier le certificat (vous pouvez également utiliser l'outil HttpConfig):

netsh http add sslcert ipport=0.0.0.0:12345 certhash=b02de34cfe609bf14efd5c2b9be72a6cb6d6fe54 appid={BAD76723-BF4D-497F-A8FE-F0E28D3052F4}

certhash = certificat Thumprint

appid = GUID (votre choix)

J'ai d'abord essayé d'importer le certificat "device.crt" sur les autorités de certification racines de confiance de différentes manières, mais j'obtiens toujours la même erreur:

Mais j'ai réalisé que je devais importer un certificat d'autorité racine et non un certificat pour le domaine. J'ai donc utilisé la console mmc (Fichier / Ajouter ou supprimer des composants logiciels enfichables / Certificats / Ajouter / Compte d'ordinateur / LocalComputer / OK) J'ai importé rootCA.pem dans le magasin Trusted Root Certificates Authorities.

Redémarrez Chrome et voilà, cela fonctionne.

Avec localhost:

Ou avec adresse IP:

La seule chose que je n'ai pas pu réaliser, c'est qu'il a un chiffrement obsolète (carré rouge sur la photo). Une aide est appréciée sur ce point.

Avec makecert, il n'est pas possible d'ajouter des informations SAN. Avec New-SelfSignedCertificate (Powershell), vous pouvez ajouter des informations SAN, cela fonctionne également.

1. Ajoutez le certificat de l'autorité de certification dans le magasin racine racine approuvé.

2. Allez dans Chrome et activez ce drapeau!

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

Enfin, utilisez simplement le domaine * .me ou tout domaine valide comme * .com et * .net et conservez-les dans le fichier hôte. Pour mes développeurs locaux, j'utilise * .me ou * .com avec un fichier hôte maintenu comme suit:

3. Ajouter à l'hôte. C: / windows / system32 / drivers / etc / hosts

   127.0.0.1 nextwebapp.me

Remarque: Si le navigateur est déjà ouvert lors de cette opération, l'erreur continuera de s'afficher. Veuillez donc fermer le navigateur et recommencer. Mieux encore, passez incognito ou démarrez une nouvelle session pour un effet immédiat.

Êtes-vous sûr que l'adresse sur laquelle le site est servi est la même que le certificat? J'ai eu les mêmes problèmes avec Chrome et un certificat auto-signé, mais à la fin j'ai trouvé que c'était juste incroyablement pointilleux sur la validation du nom de domaine sur le certificat (comme il se doit).

Chrome n'a pas son propre magasin de certificats et utilise celui de Windows. Cependant, Chrome ne fournit aucun moyen d'importer des certificats dans la boutique, vous devez donc les ajouter via IE à la place.

Installation de certificats dans Google Chrome

Installation de certificats dans Internet Explorer

Jetez également un œil à ceci pour quelques approches différentes pour créer des certificats auto-signés (je suppose que vous utilisez IIS comme vous ne l'avez pas mentionné).

Comment créer un certificat auto-signé dans IIS 7

J'ai suivi le processus d'utilisation de ce que bjnord a suggéré, à savoir: Google Chrome, Mac OS X et les certificats SSL auto-signés

Ce qui est montré dans le blog n'a pas fonctionné.

Cependant, l'un des commentaires du blog était d'or:

sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain site.crt

Vous devrez suivre le blog sur la façon d'obtenir le fichier cert, après quoi vous pouvez utiliser la commande ci-dessus et devrait être bon pour aller.

L'interface graphique de gestion des certificats SSL sur Chromium sous Linux ne fonctionnait PAS correctement pour moi. Cependant, leurs documents ont donné la bonne réponse. L'astuce consistait à exécuter la commande ci-dessous qui importe le certificat SSL auto-signé. Mettez simplement à jour le nom du <certificate-nickname>et certificate-filename.cer, puis redémarrez chrome / chrome.

Depuis les documents:

Sous Linux, Chromium utilise la base de données partagée NSS. Si le gestionnaire intégré ne fonctionne pas pour vous, vous pouvez configurer des certificats avec les outils de ligne de commande NSS.

Obtenez les outils

• Debian / Ubuntu: sudo apt-get install libnss3-tools

• Feutre: su -c "yum install nss-tools"

• Gentoo: su -c "echo 'dev-libs/nss utils' >> /etc/portage/package.use && emerge dev-libs/nss"(Vous devez lancer toutes les commandes ci-dessous avec le nsspréfixe, par exemple nsscertutil.) Opensuse:sudo zypper install mozilla-nss-tools

Pour faire confiance à un certificat de serveur auto-signé, nous devons utiliser

certutil -d sql:$HOME/.pki/nssdb -A -t "P,," -n <certificate-nickname> -i certificate-filename.cer

Lister tous les certificats

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

Les TRUSTARGS sont trois chaînes de zéro ou plusieurs caractères alphabétiques, séparées par des virgules. Ils définissent la manière dont le certificat doit être approuvé pour SSL, la messagerie électronique et la signature d'objet, et sont expliqués dans les documents certutil ou le blog de Meena sur les indicateurs de confiance.

Ajouter un certificat personnel et une clé privée pour l'authentification client SSL Utilisez la commande:

pk12util -d sql:$HOME/.pki/nssdb -i PKCS12_file.p12

pour importer un certificat personnel et une clé privée stockés dans un fichier PKCS # 12. Les TRUSTARGS du certificat personnel seront définis sur «u, u, u».

Supprimer un certificat certutil -d sql:$HOME/.pki/nssdb -D -n <certificate nickname>

Extrait de: https://chromium.googlesource.com/chromium/src/+/HEAD/docs/linux_cert_management.md

Filippo Valsorda a écrit un outil multiplateforme mkcert, pour le faire par lots magasins de confiance. Je suppose qu'il l'a écrit pour la même raison qu'il y a tant de réponses à cette question: c'est une peine de faire la "bonne" chose pour les certificats SubjectAltName signés par une autorité de certification racine de confiance.

mkcert est inclus dans les principaux systèmes de gestion de packages pour Windows, macOS et plusieurs versions de Linux.

mkcert

mkcertest un outil simple pour créer des certificats de développement approuvés localement. Il ne nécessite aucune configuration.

$ mkcert -install
Created a new local CA at "/Users/filippo/Library/Application Support/mkcert" 💥
The local CA is now installed in the system trust store! ⚡️
The local CA is now installed in the Firefox trust store (requires browser restart)! 🦊

$ mkcert example.com "*.example.com" example.test localhost 127.0.0.1 ::1
Using the local CA at "/Users/filippo/Library/Application Support/mkcert" ✨

Created a new certificate valid for the following names 📜
 - "example.com"
 - "*.example.com"
 - "example.test"
 - "localhost"
 - "127.0.0.1"
 - "::1"

The certificate is at "./example.com+5.pem" and the key at "./example.com+5-key.pem" ✅

Lorsque vous cliquez sur la petite icône de verrouillage barrée à côté de l'URL, vous obtenez une boîte ressemblant à ceci:

Après avoir cliqué sur le lien Informations sur le certificat , vous verrez la boîte de dialogue suivante:

Il vous indique quel magasin de certificats est le bon, ce sont les autorités de certification racines de confiance magasin des .

Vous pouvez utiliser l'une des méthodes décrites dans les autres réponses pour ajouter le certificat à ce magasin ou utiliser:

certutil -addstore -user "ROOT" cert.pem

• ROOT est le nom interne du magasin de certificats mentionné précédemment.
• cert.pem est le nom de votre certificat auto-signé.

Cela a fonctionné pour moi. Voir: http://www.robpeck.com/2010/10/google-chrome-mac-os-x-and-self-signed-ssl-certificates/#.Vcy8_ZNVhBc

Dans la barre d'adresse, cliquez sur le petit cadenas avec le X. Cela fera apparaître un petit écran d'informations. Cliquez sur le bouton qui dit "Informations sur le certificat".

Cliquez et faites glisser l'image sur votre bureau. Cela ressemble à un petit certificat.

Double-cliquez dessus. Cela fera apparaître l'utilitaire d'accès au trousseau. Entrez votre mot de passe pour le déverrouiller.

Assurez-vous d'ajouter le certificat au trousseau système, pas au trousseau de connexion. Cliquez sur "Toujours faire confiance", même si cela ne semble rien faire.

Une fois qu'il a été ajouté, double-cliquez dessus. Vous devrez peut-être vous authentifier à nouveau.

Développez la section "Trust".

"Lors de l'utilisation de ce certificat", défini sur "Toujours faire confiance"

J'ai tout essayé et ce qui l'a fait fonctionner: lors de l'importation, sélectionnez la bonne catégorie, à savoir les autorités de certification racine de confiance :

(désolé c'est l'allemand, mais suivez simplement l'image)

mkdir CA
openssl genrsa -aes256 -out CA/rootCA.key 4096
openssl req -x509 -new -nodes -key CA/rootCA.key -sha256 -days 1024 -out CA/rootCA.crt

openssl req -new -nodes -keyout example.com.key -out domain.csr -days 3650 -subj "/C=US/L=Some/O=Acme, Inc./CN=example.com"
openssl x509 -req -days 3650 -sha256 -in domain.csr -CA CA/rootCA.crt -CAkey CA/rootCA.key -CAcreateserial -out example.com.crt -extensions v3_ca -extfile <(
cat <<-EOF
[ v3_ca ]
subjectAltName = DNS:example.com
EOF
)

Ce message est déjà inondé de réponses, mais j'ai créé un script bash basé sur certaines des autres réponses pour faciliter la génération d'un certificat TLS auto-signé valide dans Chrome (testé dans Chrome 65.x). J'espère que c'est utile aux autres.

script bash auto-signé-tls

Après avoir installé ( et approuvé ) le certificat, n'oubliez pas de redémarrer Chrome ( chrome://restart)

Un autre outil à découvrir est la cfsslboîte à outils de CloudFlare :

cfssl

Pour créer un certificat auto-signé dans Windows auquel Chrome v58 et versions ultérieures feront confiance, lancez Powershell avec des privilèges élevés et tapez:

New-SelfSignedCertificate -CertStoreLocation Cert:\LocalMachine\My -Subject "fruity.local" -DnsName "fruity.local", "*.fruity.local" -FriendlyName "FruityCert" -NotAfter (Get-Date).AddYears(10)
#notes: 
#    -subject "*.fruity.local" = Sets the string subject name to the wildcard *.fruity.local
#    -DnsName "fruity.local", "*.fruity.local"
#         ^ Sets the subject alternative name to fruity.local, *.fruity.local. (Required by Chrome v58 and later)
#    -NotAfter (Get-Date).AddYears(10) = make the certificate last 10 years. Note: only works from Windows Server 2016 / Windows 10 onwards!!

Une fois que vous faites cela, le certificat sera enregistré dans les certificats de l'ordinateur local sous Personal \ Certificates magasin .

Vous souhaitez copier ce certificat dans les autorités de certification racines de confiance \ Certificats magasin .

Une façon de procéder: cliquez sur le bouton Démarrer de Windows et tapez certlm.msc. Ensuite, faites glisser et déposez le certificat nouvellement créé vers le magasin Autorités de certification racine de confiance \ Certificats selon la capture d'écran ci-dessous.

Correction de l'hôte local SSL / HTTPS sur le mac / osx:

1. Cliquez sur le cadenas rouge avec la croix dans votre barre d'adresse lorsque vous essayez d'ouvrir votre environnement https localhost. Une fenêtre s'ouvre avec des informations sur le certificat.

2. Cliquez sur la fenêtre d'information "Détails"

3. Les outils de développement Chrome s'ouvrent sur l'onglet «Sécurité». Cliquez sur Afficher le certificat . L'image du certificat

4. Ajoutez-le à votre trousseau «Système» (pas votre trousseau «connexion» qui est sélectionné par défaut).

5. Ouvrez (à nouveau) votre trousseau et trouvez le certificat. Cliquez dessus et assurez-vous que vous "faites confiance" à tous.

6. Redémarrez Chrome et cela devrait fonctionner.

Je rencontrais le même problème: j'avais installé le certificat dans le magasin des autorités racines de confiance de Windows et Chrome refusait toujours le certificat, avec l'erreur ERR_CERT_COMMON_NAME_INVALID. Notez que lorsque le certificat n'est pas correctement installé dans le magasin, l'erreur est ERR_CERT_AUTHORITY_INVALID.

Comme l'indique le nom de l'erreur, ce commentaire et cette question , le problème résidait dans le nom de domaine déclaré dans le certificat. Lorsqu'on m'a demandé le "Nom commun" lors de la génération du certificat, j'ai dû saisir le nom de domaine que j'utilisais pour accéder au site ( localhostdans mon cas). J'ai redémarré Chrome à l'aide chrome://restartet il était enfin satisfait de ce nouveau certificat.

Depuis Chrome 58+, j'ai commencé à obtenir une erreur de certificat sur macOS en raison d'un SAN manquant. Voici comment récupérer le verrou vert sur la barre d'adresse.

1. Générez un nouveau certificat avec la commande suivante:

   openssl req \
     -newkey rsa:2048 \
     -x509 \
     -nodes \
     -keyout server.key \
     -new \
     -out server.crt \
     -subj /CN=*.domain.dev \
     -reqexts SAN \
     -extensions SAN \
     -config <(cat /System/Library/OpenSSL/openssl.cnf \
         <(printf '[SAN]\nsubjectAltName=DNS:*.domain.dev')) \
     -sha256 \
     -days 720

2. Importez le server.crtdans votre KeyChain, puis double-cliquez dans le certificat, développez le Trust et sélectionnez Always Trust

Actualisez la page https://domain.dev dans Google Chrome, afin que le verrou vert soit de retour.

Pour Chrome sur MacOS, si vous avez préparé un certificat:

• Quittez Chrome ( cmd+ Q).
• Démarrez l'application Keychain Access et ouvrez la catégorie "Certificats".
• Faites glisser votre fichier de certificat sur la fenêtre d'accès au trousseau et saisissez le mot de passe du fichier de certificat.
• Double-cliquez sur votre certificat et dépliez la liste "Trust".
  • Dans la ligne "Lors de l'utilisation de ce certificat", choisissez "Toujours faire confiance".
  • Fermez ce truc et tapez votre mot de passe.
• Démarrez Chrome et supprimez tous les caches.
• Vérifiez que tout va bien.

Permettre à localhost non sécurisé de fonctionner correctement via cette méthode chrome: // flags / # allow-insecure-localhost

Juste que vous devez créer votre nom d'hôte de développement sur xxx.localhost.