Chrome wird aufgefordert, selbstsigniertes localhost-Zertifikat zu akzeptieren

Nur für localhost:

Fügen Sie dies einfach in Ihr Chrome ein:

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

Der hervorgehobene Text sollte lauten: Ungültige Zertifikate für von localhost geladene Ressourcen zulassen

Klicken Sie auf Enable.

Das hat bei mir funktioniert:

1. Schlagen Sie mit Chrome über HTTPS eine Seite auf Ihrem Server an und fahren Sie über die rote Warnseite hinaus fort (vorausgesetzt, Sie haben dies noch nicht getan).
2. Öffne Chrome Settings > Show advanced settings > HTTPS/SSL > Manage Certificates.
3. Klicken Sie auf die Registerkarte Authorities und scrollen Sie nach unten, um Ihr Zertifikat unter dem Organisationsnamen zu finden, den Sie dem Zertifikat gegeben haben.
4. Wählen Sie es aus, klicken Sie auf "Bearbeiten" (NOTE: In neueren Chrome-Versionen ist die Schaltfläche jetzt "Erweitert" anstelle von "Bearbeiten". Aktivieren Sie alle Kontrollkästchen und klicken Sie auf "OK". Möglicherweise müssen Sie Chrome neu starten.

Sie sollten jetzt das schöne grüne Schloss auf Ihren Seiten haben.

EDIT: Ich habe es auf einem neuen Computer erneut versucht und das Zertifikat wurde nicht im Fenster Zertifikate verwalten angezeigt, nur indem ich von der roten Seite für nicht vertrauenswürdige Zertifikate aus fortfuhr. Ich musste Folgendes tun:

1. Klicken Sie auf der Seite mit dem nicht vertrauenswürdigen Zertifikat (https:// ist rot durchgestrichen) auf das Schloss> Zertifikatinformationen. HINWEIS: Bei neueren Chrome-Versionen müssen Sie Developer Tools > Security öffnen und View certificate auswählen.
2. Klicken Sie auf den Details tab > Export. Wählen Sie PKCS #7, single certificate als Dateiformat.
3. Folgen Sie dann meinen ursprünglichen Anweisungen, um zur Seite "Zertifikate verwalten" zu gelangen. Klicken Sie auf Authorities tab > Import und wählen Sie die Datei aus, in die Sie das Zertifikat exportiert haben. Stellen Sie sicher, dass Sie PKCS #7, single certificate als Dateityp .
4. Wenn Sie zum Speichern der Zertifizierung aufgefordert werden, wählen Sie Vertrauenswürdige Stammzertifizierungsstellen .
5. Aktivieren Sie alle Kontrollkästchen und klicken Sie auf OK. Starten Sie Chrome neu.

UPDATE FÜR CHROME 58+ (RELEASED 2017-04-19)

Ab Chrome 58, Identifizierung des Hosts nur mit commonNamewird entfernt . Siehe weiter Diskussion hier und Bug-Tracker hier . In der Vergangenheit wurde subjectAltName nur für Multi-Host-Zertifikate verwendet, sodass einige interne CA-Tools diese möglicherweise nicht enthalten.

Wenn Ihre selbstsignierten Zertifikate in der Vergangenheit gut funktioniert haben , aber plötzlich Fehler in Chrome 58 generiert haben, ist dies der Grund.

Unabhängig von der Methode, mit der Sie Ihr selbstsigniertes Zertifikat (oder ein von einer selbstsignierten Zertifizierungsstelle signiertes Zertifikat) erstellen, müssen Sie sicherstellen, dass das Zertifikat des Servers ein subjectAltName mit dem richtigen DNS und/oder IP entry/entries, auch wenn es sich nur um einen einzelnen Host handelt .

Für openssl bedeutet dies, dass Ihre OpenSSL-Konfiguration (/etc/ssl/openssl.cnf unter Ubuntu) für einen einzelnen Host ungefähr Folgendes haben sollte:

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

oder für mehrere Hosts:

[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

In Chrome Cert Viewer (der unter F12 auf den Tab "Sicherheit" verschoben wurde) sollte er unter Extensions als Certificate Subject Alternative Name aufgeführt sein:

Auf dem Mac können Sie das selbstsignierte Zertifikat mit dem Dienstprogramm für den Schlüsselbundzugriff zum Systemschlüsselbund hinzufügen, und Chrome akzeptiert es dann. Die Schritt-für-Schritt-Anleitung habe ich hier gefunden:

Google Chrome, Mac OS X und selbstsignierte SSL-Zertifikate

Grundsätzlich gilt:

1. doppelklicken Sie auf das Schlosssymbol mit einem X und ziehen Sie das Zertifikatssymbol auf den Desktop.
2. öffnen Sie diese Datei (mit der Endung .cer). Dadurch wird die Schlüsselbundanwendung geöffnet, mit der Sie das Zertifikat genehmigen können.

Klicken Sie auf eine beliebige Stelle auf der Seite und geben Sie BYPASS_SEQUENCE ein

"thisisunsafe" ist eine BYPASS_SEQUENCE für Chrome Version 65

"badidea" Chrome Version 62 - 64.

"danger" wurde in früheren Chrome-Versionen verwendet

Sie müssen nicht nach einem Eingabefeld suchen, sondern müssen es nur eingeben. Es fühlt sich seltsam an, aber es funktioniert.

Ich habe es auf dem Mac High Sierra ausprobiert.

Um zu überprüfen, ob sie es erneut geändert haben, gehen Sie zu Neueste Chrom Quellcode

Um nach BYPASS_SEQUENCE zu suchen, sieht es im Moment so aus:

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

Jetzt haben sie es getarnt, aber um die echte BYPASS_SEQUENCE zu sehen, können Sie folgende Zeile in einer Browser-Konsole ausführen.

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

UPDATE 11/2017: Diese Antwort funktioniert wahrscheinlich nicht für die meisten neueren Versionen von Chrome.

UPDATE 02/2016: Bessere Anweisungen für Mac-Benutzer finden Sie hier .

1. Klicken Sie auf der Site, die Sie hinzufügen möchten, mit der rechten Maustaste auf das rote Schlosssymbol in der Adressleiste:

   2. Klicken Sie auf die Registerkarte Verbindung und dann auf Zertifikatinformationen .

   3. Klicken Sie auf die Registerkarte Details und dann auf die Schaltfläche In Datei kopieren ... . Der Zertifikatsexport-Assistent wird geöffnet. Klicken Sie auf Weiter , um zum Bildschirm Export File Format zu gelangen.

   4. Wählen Sie DER-codierte binäre X.509 (.CER) , klicken Sie auf Weiter

   5. Klicken Sie auf Durchsuchen ... und speichern Sie die Datei auf Ihrem Computer. Nennen Sie es etwas Beschreibendes. Klicken Sie auf Weiter und dann auf Fertig stellen .

   6. Öffnen Sie Chrome Einstellungen, scrollen Sie nach unten und klicken Sie auf Erweiterte Einstellungen anzeigen ...

   7. Klicken Sie unter HTTPS/SSL auf Zertifikate verwalten ...

   8. Klicken Sie auf die Registerkarte Vertrauenswürdige Stammzertifizierungsstellen und dann auf die Schaltfläche Importieren ... . Dies öffnet den Zertifikatimport-Assistenten. Klicken Sie auf Weiter , um zum Bildschirm Zu importierende Datei zu gelangen.

   9. Klicken Sie auf Durchsuchen ... und wählen Sie die zuvor gespeicherte Zertifikatdatei aus. Klicken Sie dann auf Weiter .

   10. Wählen Sie Alle Zertifikate in folgendem Speicher ablegen . Der ausgewählte Speicher sollte vertrauenswürdige Stammzertifizierungsstellen sein. Wenn nicht, klicken Sie auf Durchsuchen ... und wählen Sie es aus. Klicken Sie auf Weiter und Fertig stellen

   11. Klicken Sie in der Sicherheitswarnung auf Ja .

   12. Starten Sie Chrome neu.

Linux

Wenn Sie Linux verwenden, können Sie auch diesen offiziellen Wiki-Seiten folgen:

• SSL-Zertifikate unter Linux konfigurieren.
• NSS Shared DB und LINUX
• NSS Shared DB Howto

Grundsätzlich gilt:

• klicken Sie auf das Schlosssymbol mit einem X,
• wählen Sie Zertifikatsinformationen
• gehen Sie zur Registerkarte Details
• Klicken Sie auf Exportieren ... (als Datei speichern)

Mit dem folgenden Befehl wird nun das Zertifikat hinzugefügt (wobei YOUR_FILE Ihre exportierte Datei ist):

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

Führen Sie den folgenden Befehl aus, um alle Ihre Zertifikate aufzulisten:

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

Wenn es immer noch nicht funktioniert, könnten Sie von diesem Fehler betroffen sein: Problem 55050: Ubuntu SSL-Fehler 8179

P.S. Bitte stellen Sie auch sicher, dass Sie libnss3-tools haben, bevor Sie die obigen Befehle verwenden können.

Wenn Sie nicht haben, installieren Sie es bitte durch:

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

Als Bonus können Sie die folgenden praktischen Skripte verwenden:

$ 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'

Verwendungszweck:

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

Fehlerbehebung

• Führen Sie Chrome mit dem Parameter --auto-ssl-client-auth aus

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

Auf dem Mac können Sie ein Zertifikat erstellen, dem Chrome und Safari auf Systemebene uneingeschränkt vertrauen, indem Sie folgende Schritte ausführen:

# 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

Das Obige verwendet die folgenden Skripte und eine unterstützende Datei v3.ext, um Fehler aufgrund fehlender alternativer Namen zu vermeiden

Wenn Sie ein neues selbstsigniertes Zertifikat erstellen möchten, das mit Ihrer eigenen Root-Berechtigung voll vertrauenswürdig ist, können Sie dies mit diesen Skripten tun.

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%%

Noch ein Schritt - Wie Sie die selbstsignierten Zertifikate in Chrome/Safari als vertrauenswürdig einstufen

Damit die selbstsignierten Zertifikate in Chrome und Safari VOLLSTÄNDIG als vertrauenswürdig eingestuft werden, müssen Sie eine neue Zertifizierungsstelle in Ihren Mac importieren. Befolgen Sie dazu diese Anweisungen oder die detaillierteren Anweisungen zu diesem allgemeinen Vorgang auf der mitmproxy-Website :

Sie können dies auf zwei Arten in der Befehlszeile tun, indem Sie diesen Befehl verwenden, der Sie zur Eingabe Ihres Passworts auffordert:

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

oder mit der Keychain Access App:

1. Öffnen Sie den Schlüsselbund
2. Wählen Sie "System" in der Liste "Schlüsselanhänger"
3. Wählen Sie "Zertifikate" in der Liste "Kategorie"
4. Wählen Sie "Datei | Objekte importieren ..."
5. Navigieren Sie zu der oben erstellten Datei "rootCA.pem", wählen Sie sie aus und klicken Sie auf "Öffnen".
6. Wählen Sie Ihr neu importiertes Zertifikat in der Liste "Zertifikate" aus.
7. Klicken Sie auf die Schaltfläche "i" oder klicken Sie mit der rechten Maustaste auf Ihr Zertifikat und wählen Sie "Get Info".
8. Erweitern Sie die Option "Trust"
9. Ändern Sie "Bei Verwendung dieses Zertifikats" in "Immer vertrauen".
10. Schließen Sie das Dialogfeld, und Sie werden aufgefordert, Ihr Kennwort einzugeben.
11. Schließen Sie alle Registerkarten, die Ihre Zieldomäne verwenden, und öffnen Sie sie erneut. Sie werden dann sicher geladen!

und als Bonus können Sie, wenn Sie Java Clients benötigen, um den Zertifikaten zu vertrauen, Ihre Zertifikate in den Java Keystore importieren. Beachten Sie, dass das Zertifikat aus dem Keystore entfernt wird, wenn es bereits vorhanden ist, da es aktualisiert werden muss, falls sich etwas ändert. Dies gilt natürlich nur für die importierten Zertifikate.

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

Wenn Sie auf einem Mac sind und die Registerkarte "Export" nicht sehen oder wissen, wie Sie das Zertifikat erhalten, hat dies für mich funktioniert:

1. Klicken Sie auf das Schloss vor dem https: //
2. Gehen Sie zur Registerkarte "Verbindung"

3. Klicken Sie auf "Zertifikatsinformationen".

   Jetzt solltest du folgendes sehen: 

4. Ziehen Sie das kleine Zertifikatssymbol auf Ihren Desktop (oder irgendwo).

5. Doppelklicken Sie auf die heruntergeladene CER-Datei. Dadurch sollte sie in Ihren Schlüsselbund importiert und der Schlüsselbund-Zugriff auf Ihre Zertifikatsliste geöffnet werden.

   In einigen Fällen reicht dies aus und Sie können die Seite jetzt aktualisieren.

   Andernfalls:

6. Doppelklicken Sie auf das neu hinzugefügte Zertifikat.
7. Ändern Sie in der Dropdown-Liste "Vertrauen" die Option "Bei Verwendung dieses Zertifikats" in "Immer vertrauen".

Laden Sie nun die betreffende Seite neu und es sollte das Problem behoben sein! Hoffe das hilft.

Bearbeiten von Wolph

Um dies ein wenig zu vereinfachen, können Sie das folgende Skript verwenden ( source ):

1. Speichern Sie das folgende Skript als 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. Machen Sie das Skript ausführbar (aus der Shell):

   chmod +x whitelist_ssl_certificate.ssh
   

3. Führen Sie das Skript für die gewünschte Domain aus (Kopieren/Einfügen der vollständigen URL funktioniert):

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

AKTUALISIERT Apr 3/2018

Empfohlen vom Chromium Team

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

Schnelle Super-Easy-Lösung

Es gibt eine geheime Umgehungsphrase, die in die Fehlerseite eingegeben werden kann, damit Chrome trotz des Sicherheitsfehlers fortgesetzt wird: thisisunsafe (in frühere Chrome-Versionen geben badidea und noch früher danger ein . DO NOT BENUTZEN SIE DIES, AUSSER SIE VERSTEHEN GENAU, WARUM SIE ES BENÖTIGEN!

Quelle:

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

(HINWEIS, dass window.atob('dGhpc2lzdW5zYWZl') in thisisunsafe aufgelöst wird.)

Die neueste Version der Quelle ist @ https://chromium.googlesource.com/chromium/src/+/refs/heads/master/components/security_interstitials/core/browser/resources/interstitial_large.js und die Funktion window.atob kann in einer JS-Konsole ausgeführt werden.

Hintergrundinformationen dazu, warum das Chrome Team die Umgehungsphrase (zum ersten Mal) geändert hat:

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

Wenn alle Stricke reißen

Für schnelle einmalige Aktionen, wenn die Option "Trotzdem fortfahren" nicht verfügbar ist oder die Umgehungsphrase nicht funktioniert, funktioniert dieser Hack gut:

1. Zulassen von Zertifikatfehlern von localhost durch Aktivieren dieses Flags (Hinweis Chrome muss nach dem Ändern des Flag-Werts neu gestartet werden):

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

   (und Abstimmungsantwort https://stackoverflow.com/a/31900210/430128 von @Chris)

2. Wenn die Site, zu der Sie eine Verbindung herstellen möchten, localhost ist, sind Sie fertig. Andernfalls richten Sie einen TCP Tunnel ein, um Port 8090 lokal abzuhören, und stellen Sie über Port 443 eine Verbindung zu broken-remote-site.com her. Stellen Sie sicher, dass socat installiert ist, und führen Sie in einem Terminalfenster Folgendes aus:

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

3. Wechseln Sie in Ihrem Browser zu https: // localhost: 809 .

Für eine Testumgebung

Sie können --ignore-certificate-errors als Befehlszeilenparameter verwenden, wenn Sie chrome starten (Arbeiten mit Version 28.0.1500.52 unter Ubuntu).

Dadurch werden die Fehler ignoriert und die Verbindung wird ohne Warnung hergestellt. Wenn bereits eine Version von chrome ausgeführt wird, müssen Sie diese schließen, bevor Sie sie über die Befehlszeile neu starten. Andernfalls wird ein neues Fenster geöffnet, die Parameter werden jedoch ignoriert.

Ich konfiguriere Intellij so, dass chrome beim Debuggen auf diese Weise gestartet wird, da die Testserver niemals gültige Zertifikate haben.

Normales Browsen wie dieses würde ich allerdings nicht empfehlen, da Zertifikatsüberprüfungen ein wichtiges Sicherheitsmerkmal sind, dies kann jedoch für einige hilfreich sein.

Wie jemand bemerkt hat, müssen Sie ALLES von Chrome neu starten, nicht nur die Browserfenster. Der schnellste Weg, dies zu tun, besteht darin, einen Tab zu öffnen, um ...

chrome://restart

WINDOWS JUN/2017 Windows Server 2012

Ich folgte @ Brad Parks Antwort. Unter Windows sollten Sie rootCA.pem in den Speicher für vertrauenswürdige Stammzertifizierungsstellen importieren.

Ich habe die folgenden Schritte ausgeführt:

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

Wobei v3.ext ist:

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

In meinem Fall habe ich dann eine selbst gehostete Web-App, daher muss ich das Zertifikat mit der IP-Adresse und dem Port binden. Das Zertifikat sollte sich in MEINEM Geschäft mit Informationen zu privaten Schlüsseln befinden, also habe ich es in das PFX-Format exportiert.

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

Mit der MMC-Konsole (Datei/Snap-Ins hinzufügen oder entfernen/Zertifikate/Konto hinzufügen/Computert/LocalComputer/OK) habe ich eine PFX-Datei in den persönlichen Speicher importiert.

Später habe ich diesen Befehl verwendet, um das Zertifikat zu binden (Sie können auch das Tool HttpConfig verwenden):

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

certhash = Zertifikat Thumprint

appid = GUID (Ihre Wahl)

Zuerst habe ich versucht, das Zertifikat "device.crt" auf verschiedene Arten in vertrauenswürdige Stammzertifizierungsstellen zu importieren, aber es wird immer noch derselbe Fehler angezeigt:

Aber ich erkannte, dass ich das Zertifikat der Root-Autorität importieren sollte, nicht das Zertifikat für die Domain. Also habe ich die mmc-Konsole verwendet (Datei/Snap-Ins hinzufügen oder entfernen/Zertifikate/Konto hinzufügen/Computert/Lokaler Computer/OK). Ich habe rootCA.pem in den Speicher für vertrauenswürdige Stammzertifizierungsstellen importiert.

Starten Sie Chrome neu und es funktioniert.

Mit localhost:

Oder mit IP-Adresse:

Das einzige, was ich nicht erreichen konnte, ist, dass es veraltete Chiffre hat (rotes Quadrat auf dem Bild). Hilfe wird in diesem Punkt geschätzt.

Mit makecert ist es nicht möglich, SAN Informationen hinzuzufügen. Mit New-SelfSignedCertificate (Powershell) können Sie SAN Informationen hinzufügen, es funktioniert auch.

Sind Sie sicher, dass die Adresse, an die die Site geliefert wird, mit der des Zertifikats übereinstimmt? Ich hatte die gleichen Probleme mit Chrome und einem selbstsignierten Zertifikat, aber am Ende stellte ich fest, dass die Validierung des Domainnamens auf dem Zertifikat (wie es sein sollte) unglaublich pingelig war.

Chrome hat keinen eigenen Zertifizierungsspeicher und verwendet den von Windows. Allerdings bietet Chrome keine Möglichkeit, Zertifikate in den Store zu importieren. Fügen Sie sie stattdessen über IE hinzu.

Installieren von Zertifikaten in Google Chrome

Installieren von Zertifikaten in Internet Explorer

Sehen Sie sich dies auch an, um einige verschiedene Ansätze zum Erstellen von selbstsignierten Zertifikaten zu finden (ich gehe davon aus, dass Sie IIS verwenden, wie Sie es noch nicht erwähnt haben).

So erstellen Sie ein selbstsigniertes Zertifikat in IIS 7

Wenn Sie auf das kleine durchgestrichene Schlosssymbol neben der URL klicken, wird ein Feld angezeigt, das wie folgt aussieht:

Nachdem Sie auf den Link Certificate information geklickt haben, wird das folgende Dialogfeld angezeigt:

Hier erfahren Sie, welcher Zertifikatspeicher der richtige ist. Es handelt sich um den Speicher Trusted Root Certification Authorities.

Sie können entweder eine der in den anderen Antworten beschriebenen Methoden verwenden, um das Zertifikat zu diesem Speicher hinzuzufügen, oder Folgendes verwenden:

certutil -addstore -user "ROOT" cert.pem

• ROOT ist der interne Name des zuvor erwähnten Zertifikatspeichers.
• cert.pem ist der Name Ihres selbstsignierten Zertifikats.

Ich habe die folgenden Vorschläge von bjnord verwendet: Google Chrome, Mac OS X und selbstsignierte SSL-Zertifikate

Was im Blog gezeigt wird, hat nicht funktioniert.

Einer der Kommentare im Blog war jedoch Gold:

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

Sie müssen dem Blog folgen, um die Zertifikatsdatei zu erhalten. Danach können Sie den obigen Befehl verwenden und sollten einsatzbereit sein.

Dieser Beitrag ist bereits mit Antworten überflutet, aber ich habe ein Bash-Skript erstellt, das auf einigen der anderen Antworten basiert, um das Ermöglichen von Erstellen Sie ein selbstsigniertes TLS-Zertifikat , das in Chrome gültig ist (getestet in Chrome 65.x). Hoffe, es ist nützlich für andere.

selbstsigniertes Bash-Skript

Vergessen Sie nach der Installation ( und Vertrauenswürdigkeit nicht, Chrome (chrome://restart)

Ein weiteres Tool, das es wert ist, überprüft zu werden, ist das cfssl Toolkit von CloudFlare:

cfssl

Ab Chrome 58+ erhalte ich auf macOS einen Zertifikatfehler, da ein SAN fehlt. Hier erfahren Sie, wie Sie die grüne Adressleiste wieder sperren können.

1. Generieren Sie ein neues Zertifikat mit dem folgenden Befehl:

   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. Importieren Sie den server.crt in Ihren Schlüsselbund, doppelklicken Sie dann auf das Zertifikat, erweitern Sie die Vertrauensstellung und wählen Sie Immer Vertrauen

Aktualisieren Sie die Seite https://domain.dev in Google Chrome, damit die grüne Sperre wieder angezeigt wird.

Ich habe alles versucht und was hat es funktioniert: Wählen Sie beim Importieren die richtige Kategorie aus, nämlich Vertrauenswürdige Stammzertifizierungsstellen :

(sorry es ist deutsch, aber folge einfach dem Bild)

Die GUI zum Verwalten von SSL-Zertifikaten auf Chromium unter Linux funktionierte bei mir NICHT ordnungsgemäß. Ihre Dokumente gaben jedoch die richtige Antwort. Der Trick bestand darin, den folgenden Befehl auszuführen, mit dem das selbstsignierte SSL-Zertifikat importiert wird. Aktualisieren Sie einfach den Namen von <certificate-nickname> und certificate-filename.cer und starten Sie dann chrom/chrome neu.

Aus den Dokumenten:

Unter Linux verwendet Chromium die NSS Shared DB. Wenn der integrierte Manager für Sie nicht funktioniert, können Sie Zertifikate mit den NSS-Befehlszeilentools konfigurieren.

Holen Sie sich die Werkzeuge

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

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

• Gentoo: su -c "echo 'dev-libs/nss utils' >> /etc/portage/package.use && emerge dev-libs/nss" (Sie müssen alle folgenden Befehle mit dem Präfix nss starten, z. B. nsscertutil.) Opensuse: Sudo zypper install mozilla-nss-tools

Um einem selbstsignierten Serverzertifikat zu vertrauen, sollten wir verwenden.

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

Alle Zertifikate auflisten

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

Die TRUSTARGS sind drei durch Kommas getrennte Zeichenfolgen mit null oder mehr Buchstaben. Sie definieren, wie dem Zertifikat für SSL, E-Mail und Objektsignierung vertraut werden soll, und werden in den certutil-Dokumenten oder in Meenas Blogbeitrag zu Vertrauensmarkierungen erläutert.

Fügen Sie ein persönliches Zertifikat und einen privaten Schlüssel für die SSL-Clientauthentifizierung hinzu. Verwenden Sie den folgenden Befehl:

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

um ein persönliches Zertifikat und einen privaten Schlüssel zu importieren, die in einer PKCS # 12-Datei gespeichert sind. Die TRUSTARGS des persönlichen Zertifikats werden auf "u, u, u" gesetzt.

Zertifikat löschen certutil -d sql:$HOME/.pki/nssdb -D -n <certificate nickname>

Auszug aus: https://chromium.googlesource.com/chromium/src/+/HEAD/docs/linux_cert_management.md =

Wenn unter Fedora und Ubuntu die Fehlermeldung example.com Not a Certification authority angezeigt wird, wenn Sie das Zertifikat mithilfe der GUI zum Hinzufügen einer neuen Stammzertifizierungsstelle hinzufügen.

Versuchen Sie Folgendes mit einem aus Chrom exportierten Zertifikat, jedes Format funktioniert (base64 chain/singe, pkcs 7, der binary, etc). Dies hat bei mir funktioniert, als ALLE GUI-Methoden kläglich versagten.

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

Starten Sie Chrome neu, um die Änderungen anzuzeigen, und beenden Sie es gegebenenfalls im Hintergrund. Firefox wird sich immer noch beschweren.

Um es später zu löschen, gehen Sie zu Chrome -> Einstellungen -> Erweitert -> Zertifikate verwalten -> Server. Es wird schließlich dort angezeigt, wo es gelöscht werden kann.

Quelle, Warnung, sehr, sehr fleckig und teilweise veraltet: https://chromium.googlesource.com/chromium/src/+/HEAD/docs/linux_cert_management.md

Das Zulassen von unsicherem localhost funktioniert mit der folgenden Methode: chrome: // flags/# allow-insecure-localhost

Sie müssen lediglich Ihren Entwicklungshostnamen für xxx.localhost erstellen.

2017-06-27 neueste Methode:

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

fügen Sie anschließend yoursite.crt und yoursite.key zu Ihrer Nginx-Konfiguration hinzu.

von: https://github.com/webpack/webpack-dev-server/issues/854

Es hat bei mir nicht funktioniert, als ich versuchte, das Zertifikat in den Browser zu importieren ... Öffnen Sie in chrome Developer Tools> Security und wählen Sie Zertifikat anzeigen. Klicken Sie auf die Registerkarte Details und exportieren Sie sie.

// LINUX

Sudo apt-get install libnss3-tools 

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

Führen Sie diesen Befehl aus und wenn Sie die Datei sehen, die Sie gerade importiert haben, können Sie loslegen!

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

// Windows

Start => run => certmgr.msc

Wählen Sie auf der linken Seite Vertrauenswürdige Stammzertifizierungsstellen => Persönlich aus. Klicken Sie auf die Registerkarte "Aktionen" => "Alle Aktionen/Importieren" und wählen Sie die zuvor exportierte Datei aus dem Browser aus

Vergiss nicht, Chrome neu zu starten !!!

VIEL GLÜCK! ;)

Ich habe dieses Problem für mich behoben, ohne die Einstellungen in Browsern mit korrekten SSL-Zertifizierungen zu ändern. Ich benutze einen Mac, daher ist ein Schlüsselbund-Update für meine SSL-Zertifizierungen erforderlich. Ich musste der SSL-Zertifizierung Betreff-ALT-Namen hinzufügen, damit chrome sie akzeptierte. Ab heute gilt dies für die Chrome -Versionsnummer: 62.0.3202.94

Mein Beispiel sind einfach zu verwendende Befehle und Konfigurationsdateien:

fügen Sie diese Dateien hinzu, und dieses Beispiel befindet sich in einem Stammverzeichnis

ssl.conf

[ req ]
default_bits       = 4096
distinguished_name = req_distinguished_name
req_extensions     = req_ext

[ req_distinguished_name ]
countryName                 = Country Name (2 letter code)
stateOrProvinceName         = State or Province Name (full name)
localityName                = Locality Name (eg, city)
organizationName            = Organization Name (eg, company)
commonName                  = Common Name (e.g. server FQDN or YOUR name)
commonName_max              = 64

[ req_ext ]
subjectAltName = @alt_names

[alt_names]
DNS.1   = localhost

Führen Sie den Befehl aus, um eine Zertifizierung zu erstellen:

openssl req -newkey rsa:4096 -nodes -keyout key.pem -x509 -days 3650 -out certificate.pem -extensions req_ext -config ssl.conf -subj '/CN=localhost/O=Stackflow/C=US/L=Los Angeles/OU=StackflowTech'

Nur für Macs zum Hinzufügen einer vertrauenswürdigen Zertifizierung (erforderlich):

Sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain ./certificate.pem

Für Windows müssen Sie herausfinden, wie Sie unsere SSL-Zertifikate lokal unabhängig überprüfen können. Ich benutze kein Windows. Sorry Windows Jungs und Mädels.

Ich verwende einen node.js-Server mit express.js, für den nur mein Schlüssel und die Zertifizierung erforderlich sind.

app.js

const https = require('https');
const Express = require('express');
const fs = require('fs');
const app = new Express();
const server = https.createServer({
    key: fs.readFileSync('./key.pem'),
    cert: fs.readFileSync('./certificate.pem'),
}, app);
server.listen(3000);

Möglicherweise mache ich dies in Zukunft für andere Backend-Frames, sodass ich dieses Beispiel in Zukunft für andere aktualisieren kann. Aber das war mein Fix in Node.js für dieses Problem. Löschen Sie den Browser-Cache und führen Sie Ihre App unter https: // aus.

Hier ist ein Beispiel für die Ausführung von https: // localhost auf einem Node.js-Server für Mac-Benutzer:

https://github.com/laynefaler/Stack-Overflow-running-HTTPS-localhost

Viel Spaß beim Codieren!

Für Chrome unter MacOS, wenn Sie ein Zertifikat vorbereitet haben:

• Beenden Sie Chrome (cmd+Q).
• Starten Sie die Keychain Access App und öffnen Sie die Kategorie "Zertifikate".
• Ziehen Sie Ihre Zertifikatdatei in das Fenster Schlüsselbund und geben Sie das Kennwort für die Zertifikatdatei ein.
• Doppelklicken Sie auf Ihr Zertifikat und klappen Sie die "Trust" -Liste auf.
  • Wählen Sie in der Zeile "Wenn Sie dieses Zertifikat verwenden" die Option "Immer vertrauen".
  • Schließen Sie dieses Zeug und geben Sie Ihr Passwort ein.
• Starten Sie Chrome und löschen Sie alle Caches.
• Überprüfen Sie, ob alles in Ordnung ist.

Ich musste den Launcher Chrome unter MacOSX optimieren und das folgende Skript hinzufügen. Gespeichert wie unten;

/ Programme/Google\Chrome.app/Contents/MacOS/Chrome.command

#!/bin/sh
RealBin="Google Chrome"
AppDir="$(dirname "$0")"
exec "$AppDir/$RealBin" --ignore-certificate-errors "[email protected]"

Wenn ich Chrome mit diesem Skript starte, funktionieren selbstsignierte Zertifikate problemlos. Aber durchsuchen Sie das Internet nicht mit dem Browser, der mit diesem Skript gestartet wurde Sie werden nicht vor ungültigen Zertifikaten gewarnt!

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
)

Das hat bei mir funktioniert. Siehe: http://www.robpeck.com/2010/10/google-chrome-mac-os-x-and-self-signed-ssl-certificates/#.Vcy8_ZNVhBc

Klicken Sie in der Adressleiste auf das kleine Schloss mit dem X. Daraufhin wird ein kleiner Informationsbildschirm angezeigt. Klicken Sie auf die Schaltfläche "Zertifikatinformationen".

Klicken Sie auf das Bild und ziehen Sie es auf Ihren Desktop. Es sieht aus wie ein kleines Zertifikat.

Doppelklicken Sie darauf. Dadurch wird das Dienstprogramm für den Schlüsselbundzugriff aufgerufen. Geben Sie Ihr Passwort ein, um es zu entsperren.

Stellen Sie sicher, dass Sie das Zertifikat zum Systemschlüsselbund und nicht zum Anmeldeschlüsselbund hinzufügen. Klicken Sie auf "Immer vertrauen", obwohl dies nichts zu bewirken scheint.

Nachdem es hinzugefügt wurde, doppelklicken Sie darauf. Möglicherweise müssen Sie sich erneut authentifizieren.

Erweitern Sie den Abschnitt "Trust".

"Bei Verwendung dieses Zertifikats" auf "Immer vertrauen" setzen

Dies ist etwas, das immer wieder auftaucht - insbesondere für Google Chrome unter Mac OS X Yosemite!

Zum Glück hat mir heute einer unserer Entwickler diesen Link gesendet, und die Methode funktioniert zuverlässig, während Sie weiterhin steuern können, für welche Sites Sie Zertifikate akzeptieren.

https://www.reddit.com/r/sysadmin/comments/3ercx4/chrome_shortcut_past_the_your_connection_is_not/cthporl

jersully Beiträge:

Wenn Sie sich nicht um interne Zertifikate kümmern möchten ...

1. Geben Sie chrome://flags/ in die Adressleiste ein.
2. Scrollen Sie zu "Entscheidungen speichern" oder suchen Sie nach "Entscheidungen speichern", um SSL-Fehler für eine bestimmte Zeitspanne durchzuarbeiten.
3. Wählen Sie Remember für drei Monate.

Um in Windows ein selbstsigniertes Zertifikat zu erstellen, dem Chrome v58 und höher vertraut, starten Sie Powershell mit erhöhten Berechtigungen und geben Sie Folgendes ein:

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!!

Sobald Sie dies tun, wird das Zertifikat in den Zertifikaten des lokalen Computers unter Personal\Certificates gespeichert.

Sie möchten dieses Zertifikat in den Speicher Vertrauenswürdige Stammzertifizierungsstellen\Zertifikate kopieren.

Eine Möglichkeit, dies zu tun: Klicken Sie auf die Windows-Startschaltfläche und geben Sie certlm.msc ein. Ziehen Sie das neu erstellte Zertifikat per Drag & Drop in den Speicher Vertrauenswürdige Stammzertifizierungsstellen\Zertifikate (siehe Abbildung unten).

Was soll ich tun, damit Chrome das Zertifikat akzeptiert und sich nicht mehr darüber beschwert?

Sie sollten eine PKI mit erstellen;

1) Selbstsignierte Stammzertifizierungsstelle.
2) Unter-/Zwischenzertifikat [unterzeichnet von der Stammzertifizierungsstelle].
3) normales Zertifikat/Endentitätszertifikat [entweder von der Stammzertifizierungsstelle oder der Unterzertifizierungsstelle signiert] (commonName oder subjectAltName (SAN) als localhost) (einschließlich https: // localhost / als URI in SAN).
4) Importieren/Installieren Sie diese Stammzertifizierungsstelle in Ihrem Windows-Betriebssystem (weil Sie den IE erwähnt haben. Google Chrome verwendet die gleichen Ressourcen, während Sie nach Zertifikatsketten suchen - https: // www.chromium.org/Home/chromium-security/root-ca-policy ) als vertrauenswürdige Stammzertifizierungsstellen.
5) Installieren Sie dieses Endentitätszertifikat als Webserverzertifikat, und diese Fehlermeldung wird nicht mehr angezeigt.

Hoffe das hilft.

Ich hatte Erfolg nach der Antwort von kellen mit dem Vital pdate von Toby J , musste aber diese Überarbeitung vornehmen:

Beim Erstellen des selbstsignierten Zertifikats musste das neue Feld subjectAltName unter den Erweiterungen v3_ca anstelle von v3_req platziert werden. Ich habe /etc/ssl/openssl.conf in eine temporäre Datei kopiert und dann unter subjectAltName = DNS:*.example.com eine Zeile [ v3_ca ] eingefügt. Übergeben Sie diese Datei dann an den Befehl cert creation

  openssl req -x509 -nodes -newkey rsa:2048 \
          -config /tmp/openssl-revised.cfg \
          -keyout example.com.key -out example.com.crt

und folgte kellen's aktualisierten Schritten.

Fix für Chrome unter Windows.

Zunächst müssen Sie das Zertifikat exportieren.

• Suchen Sie die URL im Browser. Das "https" -Segment der URL wird mit der roten Linie durchgestrichen und links befindet sich ein Schlosssymbol.
• Klicken Sie mit der rechten Maustaste auf das durchgestrichene "https" -Segment.
• Sie sehen ein Informationsfenster mit verschiedenen Informationen
• Klicken Sie auf "Details".
• Exportieren Sie das Zertifikat und befolgen Sie die Anweisungen, um die Standardeinstellungen zu akzeptieren.

Importieren

• Wechseln Sie zu Chrome Einstellungen
• Klicken Sie auf "Erweiterte Einstellungen"
• Klicken Sie unter HTTPS/SSL auf "Zertifikate verwalten".
• Gehen Sie zu "Vertrauenswürdige Stammzertifizierungsstellen".
• Klicken Sie auf "Importieren"
• Es wird ein Popup-Fenster angezeigt, in dem Sie gefragt werden, ob Sie dieses Zertifikat installieren möchten. Klicken Sie auf "Ja".

Für Entwicklungszwecke unter Windows können Sie
zu Chrome Shortcut-Flag --ignore-certificate-errors hinzufügen

Es wird erwartet, dass Zertifikatfehler ignoriert werden und Sie auf ungültige Zertifikatwebsites zugreifen können.
Bessere detaillierte Anweisungen in https://support.opendns.com/entries/66657664 .

Es trat das gleiche Problem auf: Ich hatte das Zertifikat im Speicher für vertrauenswürdige Stammzertifizierungsstellen von Windows installiert und Chrome lehnte das Zertifikat weiterhin mit dem Fehler ERR_CERT_COMMON_NAME_INVALID ab. Beachten Sie, dass der Fehler ERR_CERT_AUTHORITY_INVALID lautet, wenn das Zertifikat nicht ordnungsgemäß im Speicher installiert ist.

Wie der Name des Fehlers, dieser Kommentar und diese Frage andeutet, lag das Problem im deklarierten Domänennamen im Zertifikat. Als ich beim Generieren des Zertifikats zur Eingabe des "Common Name" aufgefordert wurde, musste ich den Domain-Namen eingeben , mit dem ich auf die Site zugegriffen habe (localhost in meinem Fall). Ich habe Chrome mit chrome://restart neu gestartet und war schließlich mit diesem neuen Zertifikat zufrieden.

SSL/HTTPS localhost fix auf dem Mac/osx:

1. Klicken Sie auf das rote Schloss mit dem Kreuz in Ihrer Adressleiste, wenn Sie versuchen, Ihre https localhost-Umgebung zu öffnen. Es öffnet sich ein Fenster mit Informationen zum Zertifikat.

2. Klicken Sie auf "Details" Informationsfenster

3. Das Entwicklertool chrome wird auf der Registerkarte 'Sicherheit' geöffnet. Klicken Sie auf Zertifikat anzeigen . Das Zertifikatbild

4. Fügen Sie es Ihrem "System" -Schlüsselbund hinzu (nicht Ihrem "Login" -Schlüsselbund, der standardmäßig ausgewählt ist).

5. Öffnen Sie Ihren Schlüsselbund (erneut) und suchen Sie das Zertifikat. Klicken Sie darauf und stellen Sie sicher, dass Sie allen vertrauen.

6. Starten Sie chrome neu und es sollte funktionieren.

Filippo Valsorda hat das plattformübergreifende Tool mkcert für lots von Trust Stores geschrieben. Ich nehme an, er hat es aus demselben Grund geschrieben, weil es so viele Antworten auf diese Frage gibt: Es ist mühsam, das "Richtige" für SubjectAltName-Zertifikate zu tun, die von einer vertrauenswürdigen Stammzertifizierungsstelle signiert wurden.

mkcert ist in den wichtigsten Paketverwaltungssystemen für Windows, macOS und verschiedene Linux-Versionen enthalten.

mkcert

mkcert ist ein einfaches Tool zum Erstellen von lokal vertrauenswürdigen Entwicklungszertifikaten. Es ist keine Konfiguration erforderlich.

$ 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" ✅

Meine Lösung und Erklärung:

Ich hatte ein selbstsigniertes Zertifikat, das mit dem Resource Kit-Tool IIS erstellt wurde SelfSSL.exe . In den Zertifikatslisten auf meinem lokalen Computer habe ich festgestellt, dass dieses selbstsignierte Zertifikat nur einen Zweck hat : Serverauthentifizierung . Daher habe ich für beide Zwecke ein neues selbstsigniertes Zertifikat erstellt: Serverauthentifizierung und Clientauthentifizierung . Und jetzt beschwert sich Chrome nicht mehr.

Dieser Artikel zeigt viele Möglichkeiten, um selbstsignierte Zertifikate zu generieren. Beachten Sie, dass Sie nicht bei allen Optionen den Zweck des Zertifikats angeben können. Ich habe die PowerShell-Methode verwendet:

$cert = New-SelfSignedCertificate -certstorelocation cert:\localmachine\my -dnsname company.co.nz

Hinweis: Wie in diesem Antwort von kellen Chrome angegeben, können Sie die Verwendungszwecke für Zertifikate festlegen. Allerdings kann IMO keinen neuen Verwendungszweck für ein Zertifikat hinzufügen, wenn das letzte Zertifikat nicht mit einem solchen erstellt wurde im Kopf.

Keine der obigen Antworten hat mir unter Windows 10 beim Testen vor Ort geholfen

https://localhost:<port>.

Allerdings habe ich diese Seite gefunden, auf der eine andere Flagge angezeigt wird:

https://www.chromium.org/blink/serviceworker/service-worker-faq

Wenn Sie mit einem selbstsignierten Zertifikat auf https: // localhost testen möchten, gehen Sie wie folgt vor:

$ ./chrome --allow-insecure-localhost https: // localhost

Damit wurde die rote Warnung nicht beseitigt, aber ich konnte nur https-fähige Funktionen wie Servicemitarbeiter und Web-Push-Benachrichtigungen verwenden.

Hier ist eine Lösung, die nur Java 8 keytool.exe anstelle von openssl verwendet:

@echo off
set PWD=changeit
set DNSNAME=%COMPUTERNAME%

echo create ca key
keytool -genkeypair -alias ca -keystore test.jks -keyalg RSA -validity 3650 -ext bc:critical=ca:true -dname "CN=CA" -storepass:env PWD -keypass:env PWD
echo generate cert request for ca signing
keytool -certreq -keystore test.jks -storepass:env PWD -alias ca -file ca.csr -ext bc:critical=ca:true
echo generate signed cert
keytool -gencert -keystore test.jks -storepass:env PWD -alias ca -infile ca.csr -outfile ca.cer -validity 3650 -ext bc:critical=ca:true
echo CA created. Import ca.cer in windows and firefox' certificate store as "Trusted CA".
pause

echo create server cert key for %DNSNAME%
keytool -genkeypair -alias leaf -keystore test.jks -keyalg RSA -validity 3650 -ext bc=ca:false -ext san=dns:%DNSNAME%,dns:localhost,ip:127.0.0.1 -dname "CN=Leaf" -storepass:env PWD -keypass:env PWD
echo generate cert request
keytool -certreq -keystore test.jks -storepass:env PWD -alias leaf -file leaf.csr -ext bc=ca:false -ext san=dns:%DNSNAME%,dns:localhost,ip:127.0.0.1
echo generate signed cert
keytool -gencert -keystore test.jks -storepass:env PWD -alias ca -infile leaf.csr -outfile leaf.cer -validity 3650 -ext bc=ca:false -ext san=dns:%DNSNAME%,dns:localhost,ip:127.0.0.1

rem see content
rem keytool -printcert -file leaf.cer -storepass:env PWD 

echo install in orig keystore
keytool -importcert -keystore test.jks -storepass:env PWD -file leaf.cer -alias leaf

echo content of test.jks:
keytool -list -v -storepass:env PWD -keystore test.jks
pause

Sie können auch Pipes anstelle von Dateien verwenden, aber mit den Dateien können Sie die Zwischenergebnisse überprüfen, wenn etwas schief geht. SSL getestet mit IE11, Edge, FF54, Chrome60 unter Windows und Chrome60 unter Android.

Bitte ändern Sie das Standardkennwort, bevor Sie das Skript verwenden.