Ich füge einem eingebetteten Linux-Gerät HTTPS-Unterstützung hinzu. Ich habe versucht, mit diesen Schritten ein selbstsigniertes Zertifikat zu erstellen:

openssl req -new > cert.csr
openssl rsa -in privkey.pem -out key.pem
openssl x509 -in cert.csr -out cert.pem -req -signkey key.pem -days 1001
cat key.pem>>cert.pem

Dies funktioniert, aber ich erhalte einige Fehler, beispielsweise bei Google Chrome:

Dies ist wahrscheinlich nicht die Seite, die Sie suchen!
Die Sicherheitszertifikat der Website ist nicht vertrauenswürdig!

Vermisse ich etwas Ist dies der richtige Weg, um ein selbstsigniertes Zertifikat zu erstellen?

Sie können dies mit einem Befehl tun:

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365

Sie können auch hinzufügen -nodes(kurz für no DES), wenn Sie Ihren privaten Schlüssel nicht mit einer Passphrase schützen möchten. Andernfalls werden Sie aufgefordert, ein Passwort mit mindestens 4 Zeichen einzugeben.

Der daysParameter (365) kann durch eine beliebige Zahl ersetzt werden, um das Ablaufdatum zu beeinflussen. Sie werden dann aufgefordert, Dinge wie "Ländername" einzugeben, aber Sie können einfach Enterdie Standardeinstellungen drücken und akzeptieren.

Hinzufügen -subj '/CN=localhost', um Fragen zum Inhalt des Zertifikats zu unterdrücken (durch localhostdie gewünschte Domain ersetzen ).

Selbstsignierte Zertifikate werden nicht von Dritten validiert, es sei denn, Sie importieren sie zuvor in die Browser. Wenn Sie mehr Sicherheit benötigen, sollten Sie ein von einer Zertifizierungsstelle (CA) signiertes Zertifikat verwenden .

Vermisse ich etwas Ist dies der richtige Weg, um ein selbstsigniertes Zertifikat zu erstellen?

Es ist einfach, ein selbstsigniertes Zertifikat zu erstellen. Sie verwenden nur dieopenssl req Befehl. Es kann schwierig sein, einen zu erstellen, der von der größten Auswahl an Clients wie Browsern und Befehlszeilentools verwendet werden kann.

Dies ist schwierig, da die Browser ihre eigenen Anforderungen haben und restriktiver sind als die IETF . Die von Browsern verwendeten Anforderungen sind in den CA / Browser-Foren dokumentiert (siehe Referenzen unten). Die Einschränkungen treten in zwei Schlüsselbereichen auf: (1) Vertrauensanker und (2) DNS-Namen.

Moderne Browser (wie die Warez, die wir 2014/2015 verwenden) möchten ein Zertifikat, das mit einem Vertrauensanker verknüpft ist, und sie möchten, dass DNS-Namen im Zertifikat auf bestimmte Weise dargestellt werden. Und Browser bewegen sich aktiv gegen selbstsignierte Serverzertifikate.

Einige Browser machen es nicht gerade einfach, ein selbstsigniertes Serverzertifikat zu importieren. In der Tat können Sie nicht mit einigen Browsern, wie Android Browser. Die vollständige Lösung besteht also darin, Ihre eigene Autorität zu werden.

Wenn Sie nicht zu Ihrer eigenen Autorität werden, müssen Sie die richtigen DNS-Namen eingeben, um dem Zertifikat die größten Erfolgschancen zu geben. Aber ich würde Sie ermutigen, Ihre eigene Autorität zu werden. Es ist einfach, Ihre eigene Autorität zu werden, und es wird alle Vertrauensprobleme umgehen (wem kann man besser vertrauen als Ihnen selbst?).

Dies ist wahrscheinlich nicht die Seite, die Sie suchen!
Die Sicherheitszertifikat der Website ist nicht vertrauenswürdig!

Dies liegt daran, dass Browser eine vordefinierte Liste von Vertrauensankern verwenden, um Serverzertifikate zu validieren. Ein selbstsigniertes Zertifikat ist nicht an einen vertrauenswürdigen Anker gebunden.

Der beste Weg, dies zu vermeiden, ist:

1. Erstellen Sie Ihre eigene Autorität (dh werden Sie eine Zertifizierungsstelle )
2. Erstellen Sie eine Zertifikatsignierungsanforderung (Certificate Signing Request, CSR) für den Server
3. Signieren Sie die CSR des Servers mit Ihrem CA-Schlüssel
4. Installieren Sie das Serverzertifikat auf dem Server
5. Installieren Sie das CA-Zertifikat auf dem Client

Schritt 1 - Erstellen Sie Ihre eigene Berechtigung. Sie müssen lediglich ein selbstsigniertes Zertifikat mit CA: trueordnungsgemäßer Schlüsselverwendung erstellen . Dies bedeutet, dass der Betreff und der Aussteller dieselbe Entität sind, die Zertifizierungsstelle in den grundlegenden Einschränkungen auf "true" gesetzt ist (sie sollte auch als kritisch markiert werden), die Schlüsselverwendung lautet keyCertSignund crlSign(wenn Sie CRLs verwenden) und die Betreffschlüsselkennung (SKI) das gleiche wie die Authority Key Identifier (AKI).

Informationen zum Werden Ihrer eigenen Zertifizierungsstelle finden Sie unter * Wie unterschreiben Sie eine Zertifikatsignierungsanforderung bei Ihrer Zertifizierungsstelle? bei Stapelüberlauf. Importieren Sie anschließend Ihre Zertifizierungsstelle in den vom Browser verwendeten Trust Store.

Die Schritte 2 bis 4 sind ungefähr das, was Sie jetzt für einen öffentlich zugänglichen Server tun, wenn Sie die Dienste einer Zertifizierungsstelle wie Startcom oder CAcert in Anspruch nehmen . In den Schritten 1 und 5 können Sie die Autorität Dritter umgehen und als Ihre eigene Autorität fungieren (wem können Sie besser vertrauen als Ihnen selbst?).

Der nächstbeste Weg, um die Browserwarnung zu vermeiden, besteht darin, dem Zertifikat des Servers zu vertrauen. Einige Browser, wie der Standardbrowser von Android, lassen dies jedoch nicht zu. Es wird also niemals auf der Plattform funktionieren.

Das Problem, dass Browser (und andere ähnliche Benutzeragenten) selbstsignierten Zertifikaten nicht vertrauen, wird im Internet der Dinge (Internet of Things, IoT) ein großes Problem darstellen. Was passiert zum Beispiel, wenn Sie eine Verbindung zu Ihrem Thermostat oder Kühlschrank herstellen, um ihn zu programmieren? Die Antwort lautet: Nichts Gutes für die Benutzererfahrung.

Die WebAppSec-Arbeitsgruppe des W3C beginnt sich mit dem Problem zu befassen. Siehe zum Beispiel Vorschlag: HTTP als nicht sicher markieren .

So erstellen Sie ein selbstsigniertes Zertifikat mit OpenSSL

Die folgenden Befehle und die Konfigurationsdatei erstellen ein selbstsigniertes Zertifikat (es zeigt Ihnen auch, wie Sie eine Signaturanforderung erstellen). Sie unterscheiden sich in einer Hinsicht von anderen Antworten: Die für das selbstsignierte Zertifikat verwendeten DNS-Namen befinden sich im SAN (Subject Alternate Name) und nicht im Common Name (CN) .

Die DNS-Namen werden im SAN über die Konfigurationsdatei mit der Zeile abgelegt subjectAltName = @alternate_names(es gibt keine Möglichkeit, dies über die Befehlszeile zu tun). Dann gibt es einen alternate_namesAbschnitt in der Konfigurationsdatei (Sie sollten diesen nach Ihrem Geschmack einstellen):

[ alternate_names ]

DNS.1       = example.com
DNS.2       = www.example.com
DNS.3       = mail.example.com
DNS.4       = ftp.example.com

# Add these if you need them. But usually you don't want them or
#   need them in production. You may need them for development.
# DNS.5       = localhost
# DNS.6       = localhost.localdomain
# IP.1        = 127.0.0.1
# IP.2        = ::1

Es ist wichtig, den DNS-Namen in das SAN und nicht in den CN einzufügen, da sowohl die IETF- als auch die CA / Browser-Foren die Vorgehensweise festlegen. Sie geben auch an, dass DNS-Namen im CN veraltet (aber nicht verboten) sind. Wenn Sie einen DNS-Namen in den CN eingeben, muss dieser unter den CA / B-Richtlinien im SAN enthalten sein. Sie können es also nicht vermeiden, den alternativen Betreffnamen zu verwenden.

Wenn Sie keine DNS-Namen in das SAN einfügen, kann das Zertifikat unter einem Browser und anderen Benutzeragenten, die den Richtlinien des CA / Browser-Forums entsprechen, nicht überprüft werden.

Verwandte Themen: Browser befolgen die Richtlinien des CA / Browser-Forums. und nicht die IETF-Richtlinien. Dies ist einer der Gründe, warum ein mit OpenSSL erstelltes Zertifikat (das im Allgemeinen der IETF folgt) manchmal nicht unter einem Browser validiert wird (Browser folgen der CA / B). Sie sind unterschiedliche Standards, haben unterschiedliche Ausstellungsrichtlinien und unterschiedliche Validierungsanforderungen.

Erstellen Sie ein selbstsigniertes Zertifikat (beachten Sie die Hinzufügung der -x509Option):

openssl req -config example-com.conf -new -x509 -sha256 -newkey rsa:2048 -nodes \
    -keyout example-com.key.pem -days 365 -out example-com.cert.pem

Erstellen Sie eine Signaturanforderung (beachten Sie das Fehlen einer -x509Option):

openssl req -config example-com.conf -new -sha256 -newkey rsa:2048 -nodes \
    -keyout example-com.key.pem -days 365 -out example-com.req.pem

Drucken Sie ein selbstsigniertes Zertifikat aus :

openssl x509 -in example-com.cert.pem -text -noout

Eine Signaturanfrage drucken :

openssl req -in example-com.req.pem -text -noout

Konfigurationsdatei (über -configOption übergeben)

[ req ]
default_bits        = 2048
default_keyfile     = server-key.pem
distinguished_name  = subject
req_extensions      = req_ext
x509_extensions     = x509_ext
string_mask         = utf8only

# The Subject DN can be formed using X501 or RFC 4514 (see RFC 4519 for a description).
#   Its sort of a mashup. For example, RFC 4514 does not provide emailAddress.
[ subject ]
countryName         = Country Name (2 letter code)
countryName_default     = US

stateOrProvinceName     = State or Province Name (full name)
stateOrProvinceName_default = NY

localityName            = Locality Name (eg, city)
localityName_default        = New York

organizationName         = Organization Name (eg, company)
organizationName_default    = Example, LLC

# Use a friendly name here because it's presented to the user. The server's DNS
#   names are placed in Subject Alternate Names. Plus, DNS names here is deprecated
#   by both IETF and CA/Browser Forums. If you place a DNS name here, then you
#   must include the DNS name in the SAN too (otherwise, Chrome and others that
#   strictly follow the CA/Browser Baseline Requirements will fail).
commonName          = Common Name (e.g. server FQDN or YOUR name)
commonName_default      = Example Company

emailAddress            = Email Address
emailAddress_default        = [email protected]

# Section x509_ext is used when generating a self-signed certificate. I.e., openssl req -x509 ...
[ x509_ext ]

subjectKeyIdentifier        = hash
authorityKeyIdentifier    = keyid,issuer

# You only need digitalSignature below. *If* you don't allow
#   RSA Key transport (i.e., you use ephemeral cipher suites), then
#   omit keyEncipherment because that's key transport.
basicConstraints        = CA:FALSE
keyUsage            = digitalSignature, keyEncipherment
subjectAltName          = @alternate_names
nsComment           = "OpenSSL Generated Certificate"

# RFC 5280, Section 4.2.1.12 makes EKU optional
#   CA/Browser Baseline Requirements, Appendix (B)(3)(G) makes me confused
#   In either case, you probably only need serverAuth.
# extendedKeyUsage    = serverAuth, clientAuth

# Section req_ext is used when generating a certificate signing request. I.e., openssl req ...
[ req_ext ]

subjectKeyIdentifier        = hash

basicConstraints        = CA:FALSE
keyUsage            = digitalSignature, keyEncipherment
subjectAltName          = @alternate_names
nsComment           = "OpenSSL Generated Certificate"

# RFC 5280, Section 4.2.1.12 makes EKU optional
#   CA/Browser Baseline Requirements, Appendix (B)(3)(G) makes me confused
#   In either case, you probably only need serverAuth.
# extendedKeyUsage    = serverAuth, clientAuth

[ alternate_names ]

DNS.1       = example.com
DNS.2       = www.example.com
DNS.3       = mail.example.com
DNS.4       = ftp.example.com

# Add these if you need them. But usually you don't want them or
#   need them in production. You may need them for development.
# DNS.5       = localhost
# DNS.6       = localhost.localdomain
# DNS.7       = 127.0.0.1

# IPv6 localhost
# DNS.8     = ::1

Möglicherweise müssen Sie für Chrome Folgendes tun. Andernfalls kann sich Chrome beschweren, dass ein allgemeiner Name ungültig ist ( ERR_CERT_COMMON_NAME_INVALID) . Ich bin mir nicht sicher, wie die Beziehung zwischen einer IP-Adresse im SAN und einem CN in diesem Fall ist.

# IPv4 localhost
# IP.1       = 127.0.0.1

# IPv6 localhost
# IP.2     = ::1

Es gibt andere Regeln für den Umgang mit DNS-Namen in X.509 / PKIX-Zertifikaten. In diesen Dokumenten finden Sie die Regeln:

• RFC 5280, Internet X.509 Public Key-Infrastrukturzertifikat und CRL-Profil (Certificate Revocation List)
• RFC 6125, Darstellung und Überprüfung der domänenbasierten Anwendungsdienstidentität in der Internet-Public-Key-Infrastruktur unter Verwendung von X.509 (PKIX) -Zertifikaten im Kontext der Transport Layer Security (TLS)
• RFC 6797, Anhang A, HTTP Strict Transport Security (HSTS)
• RFC 7469, Public Key Pinning Extension für HTTP
• Grundlegende Anforderungen für das CA / Browser-Forum
• Erweiterte Validierungsrichtlinien für CA / Browser Forum

RFC 6797 und RFC 7469 werden aufgelistet, da sie restriktiver sind als die anderen RFCs und CA / B-Dokumente. Die RFCs 6797 und 7469 erlauben ebenfalls keine IP-Adresse.

Hier sind die Optionen, die in der Antwort von @ diegows beschrieben sind, die in der Dokumentation ausführlicher beschrieben wird :

openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days XXX

req

PKCS # 10-Zertifikatanforderung und Dienstprogramm zum Generieren von Zertifikaten.

-x509

Diese Option gibt ein selbstsigniertes Zertifikat anstelle einer Zertifikatanforderung aus. Dies wird normalerweise verwendet, um ein Testzertifikat oder eine selbstsignierte Stammzertifizierungsstelle zu generieren.

-newkey arg

Diese Option erstellt eine neue Zertifikatanforderung und einen neuen privaten Schlüssel. Das Argument hat eine von mehreren Formen. rsa: nbits , wobei nbits die Anzahl der Bits ist, generiert einen RSA-Schlüssel mit einer Größe von nbits .

-keyout filename

Dies gibt den Dateinamen an, in den der neu erstellte private Schlüssel geschrieben werden soll.

-out filename

Dies gibt den Ausgabedateinamen an, in den standardmäßig geschrieben werden soll, oder die Standardausgabe.

-days n

Wenn die Option -x509 verwendet wird, gibt dies die Anzahl der Tage an, für die das Zertifikat zertifiziert werden soll. Der Standardwert beträgt 30 Tage.

-nodes

Wenn diese Option angegeben ist, wird ein privater Schlüssel, der erstellt wird, nicht verschlüsselt.

Die Dokumentation ist tatsächlich detaillierter als die oben genannten; Ich habe es hier nur zusammengefasst.

Ab 2020 erfüllt der folgende Befehl alle Ihre Anforderungen, einschließlich SAN:

openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes \
  -keyout example.key -out example.crt -extensions san -config \
  <(echo "[req]"; 
    echo distinguished_name=req; 
    echo "[san]"; 
    echo subjectAltName=DNS:example.com,DNS:example.net,IP:10.0.0.1
    ) \
  -subj "/CN=example.com"

In OpenSSL ≥ 1.1.1 kann dies verkürzt werden auf:

openssl req -x509 -newkey rsa:4096 -sha256 -days 3650 -nodes \
  -keyout example.key -out example.crt -subj "/CN=example.com" \
  -addext "subjectAltName=DNS:example.com,DNS:example.net,IP:10.0.0.1"

Es wird ein Zertifikat erstellt

• gültig für die Domains example.comund example.net(SAN),
• gilt auch für die IP-Adresse 10.0.0.1(SAN),
• relativ stark (ab 2020) und
• gültig für 3650Tage (~ 10 Jahre).

Es werden folgende Dateien erstellt:

• Privat Schlüssel: example.key
• Zertifikat: example.crt

Alle Informationen werden in der Befehlszeile bereitgestellt. Es gibt keine interaktive Eingabe , die Sie nervt. Es gibt keine Konfigurationsdateien, mit denen Sie herumspielen müssen. Alle erforderlichen Schritte werden durch einen einzigen OpenSSL-Aufruf ausgeführt : von der Generierung des privaten Schlüssels bis zum selbstsignierten Zertifikat.

Bemerkung Nr. 1: Kryptoparameter

Da das Zertifikat selbstsigniert ist und von Benutzern manuell akzeptiert werden muss, ist es nicht sinnvoll, einen kurzen Ablauf oder eine schwache Kryptografie zu verwenden.

In Zukunft möchten Sie möglicherweise mehr als 4096Bits für den RSA-Schlüssel und einen Hash-Algorithmus verwenden, der stärker ist als sha256, aber ab 2020 sind dies vernünftige Werte. Sie sind ausreichend stark und werden von allen modernen Browsern unterstützt.

Bemerkung Nr. 2: Parameter " -nodes"

Theoretisch könnten Sie den -nodesParameter weglassen (was "keine DES-Verschlüsselung" bedeutet). In diesem Fall example.keywürde er mit einem Passwort verschlüsselt. Dies ist jedoch für eine Serverinstallation fast nie nützlich, da Sie entweder das Kennwort auch auf dem Server speichern müssten oder es bei jedem Neustart manuell eingeben müssten.

Bemerkung Nr. 3: Siehe auch

• Geben Sie subjectAltName direkt in der Befehlszeile für openssl ein
• Wie füge ich einem SSL-Zertifikat über die Befehlszeile mehrere E-Mail-Adressen hinzu?
• Weitere Informationen zu MSYS_NO_PATHCONV

Ich kann nicht kommentieren, daher werde ich dies als separate Antwort setzen. Ich habe einige Probleme mit der akzeptierten Einzeiler-Antwort gefunden:

• Der Einzeiler enthält eine Passphrase im Schlüssel.
• Der Einzeiler verwendet SHA-1, das in vielen Browsern Warnungen in der Konsole ausgibt.

Hier ist eine vereinfachte Version, die die Passphrase entfernt, die Sicherheit erhöht, um Warnungen zu unterdrücken, und in Kommentaren einen Vorschlag enthält, -subj zu übergeben, um die vollständige Fragenliste zu entfernen:

openssl genrsa -out server.key 2048
openssl rsa -in server.key -out server.key
openssl req -sha256 -new -key server.key -out server.csr -subj '/CN=localhost'
openssl x509 -req -sha256 -days 365 -in server.csr -signkey server.key -out server.crt

Ersetzen Sie 'localhost' durch eine beliebige Domain. Sie müssen die ersten beiden Befehle einzeln ausführen, da OpenSSL zur Eingabe einer Passphrase auffordert.

So kombinieren Sie die beiden zu einer PEM-Datei:

cat server.crt server.key > cert.pem

Moderne Browser werfen jetzt einen Sicherheitsfehler für ansonsten wohlgeformte selbstsignierte Zertifikate aus, wenn ihnen ein SAN (Subject Alternate Name) fehlt. OpenSSL bietet keine Befehlszeilenmethode, um dies anzugeben. Daher sind die Tutorials und Lesezeichen vieler Entwickler plötzlich veraltet.

Der schnellste Weg, um wieder zum Laufen zu kommen, ist eine kurze, eigenständige Conf-Datei:

1. Erstellen Sie eine OpenSSL - Konfigurationsdatei (Beispiel: req.cnf)

   [req]
   distinguished_name = req_distinguished_name
   x509_extensions = v3_req
   prompt = no
   [req_distinguished_name]
   C = US
   ST = VA
   L = SomeCity
   O = MyCompany
   OU = MyDivision
   CN = www.company.com
   [v3_req]
   keyUsage = critical, digitalSignature, keyAgreement
   extendedKeyUsage = serverAuth
   subjectAltName = @alt_names
   [alt_names]
   DNS.1 = www.company.com
   DNS.2 = company.com
   DNS.3 = company.net
   

2. Erstellen Sie das Zertifikat, das auf diese Konfigurationsdatei verweist

   openssl req -x509 -nodes -days 730 -newkey rsa:2048 \
    -keyout cert.key -out cert.pem -config req.cnf -sha256
   

Beispielkonfiguration von https://support.citrix.com/article/CTX135602

Ich würde empfehlen, das -sha256 hinzuzufügen Parameter , um den SHA-2-Hash-Algorithmus zu verwenden, da große Browser erwägen, "SHA-1-Zertifikate" als nicht sicher .

Dieselbe Befehlszeile aus der akzeptierten Antwort - @diegows mit hinzugefügtem -sha256

openssl req -x509 -sha256 -newkey rsa: 2048 -keyout key.pem -out cert.pem -days XXX

Weitere Informationen im Google Security-Blog .

Update Mai 2018. Wie viele in den Kommentaren festgestellt haben, fügt die Verwendung von SHA-2 einem selbstsignierten Zertifikat keine Sicherheit hinzu. Ich empfehle jedoch weiterhin, es als Gewohnheit zu verwenden, keine veralteten / unsicheren kryptografischen Hash-Funktionen zu verwenden. Eine vollständige Erklärung finden Sie unter Warum ist es in Ordnung, wenn Zertifikate über dem End-Entity-Zertifikat auf SHA-1 basieren? .

Dies ist das Skript, das ich für lokale Boxen verwende, um das SAN (subjectAltName) in selbstsignierten Zertifikaten festzulegen.

Dieses Skript verwendet den Domänennamen (example.com) und generiert das SAN für * .example.com und example.com im selben Zertifikat. Die folgenden Abschnitte sind kommentiert. Nennen Sie das Skript (zgenerate-ssl.sh ) und erteilen Sie ihm ausführbare Berechtigungen. Die Dateien werden in dasselbe Verzeichnis wie das Skript geschrieben.

Ab Chrome 58 muss SAN in selbstsignierten Zertifikaten festgelegt sein.

#!/usr/bin/env bash

# Set the TLD domain we want to use
BASE_DOMAIN="example.com"

# Days for the cert to live
DAYS=1095

# A blank passphrase
PASSPHRASE=""

# Generated configuration file
CONFIG_FILE="config.txt"

cat > $CONFIG_FILE <<-EOF
[req]
default_bits = 2048
prompt = no
default_md = sha256
x509_extensions = v3_req
distinguished_name = dn

[dn]
C = CA
ST = BC
L = Vancouver
O = Example Corp
OU = Testing Domain
emailAddress = webmaster@$BASE_DOMAIN
CN = $BASE_DOMAIN

[v3_req]
subjectAltName = @alt_names

[alt_names]
DNS.1 = *.$BASE_DOMAIN
DNS.2 = $BASE_DOMAIN
EOF

# The file name can be anything
FILE_NAME="$BASE_DOMAIN"

# Remove previous keys
echo "Removing existing certs like $FILE_NAME.*"
chmod 770 $FILE_NAME.*
rm $FILE_NAME.*

echo "Generating certs for $BASE_DOMAIN"

# Generate our Private Key, CSR and Certificate
# Use SHA-2 as SHA-1 is unsupported from Jan 1, 2017

openssl req -new -x509 -newkey rsa:2048 -sha256 -nodes -keyout "$FILE_NAME.key" -days $DAYS -out "$FILE_NAME.crt" -passin pass:$PASSPHRASE -config "$CONFIG_FILE"

# OPTIONAL - write an info to see the details of the generated crt
openssl x509 -noout -fingerprint -text < "$FILE_NAME.crt" > "$FILE_NAME.info"

# Protect the key
chmod 400 "$FILE_NAME.key"

Dieses Skript schreibt auch eine Informationsdatei, sodass Sie das neue Zertifikat überprüfen und überprüfen können, ob das SAN richtig eingestellt ist.

                ...
                28:dd:b8:1e:34:b5:b1:44:1a:60:6d:e3:3c:5a:c4:
                da:3d
            Exponent: 65537 (0x10001)
    X509v3 extensions:
        X509v3 Subject Alternative Name: 
            DNS:*.example.com, DNS:example.com
Signature Algorithm: sha256WithRSAEncryption
     3b:35:5a:d6:9e:92:4f:fc:f4:f4:87:78:cd:c7:8d:cd:8c:cc:
     ...

Wenn Sie Apache verwenden, können Sie auf das obige Zertifikat in Ihrer Konfigurationsdatei wie folgt verweisen:

<VirtualHost _default_:443>
    ServerName example.com
    ServerAlias www.example.com
    DocumentRoot /var/www/htdocs

    SSLEngine on
    SSLCertificateFile path/to/your/example.com.crt
    SSLCertificateKeyFile path/to/your/example.com.key
</VirtualHost>

Denken Sie daran, Ihren Apache- (oder Nginx- oder IIS-) Server neu zu starten, damit das neue Zertifikat wirksam wird.

2017 Einzeiler:

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

Dies funktioniert auch in Chrome 57, da das SAN bereitgestellt wird, ohne dass eine andere Konfigurationsdatei vorhanden ist. Es wurde einer Antwort hier entnommen .

Dadurch wird eine einzelne PEM-Datei erstellt, die sowohl den privaten Schlüssel als auch das Zertifikat enthält. Sie können sie bei Bedarf in separate PEM-Dateien verschieben.

Ich kann keinen Kommentar abgeben, daher füge ich eine separate Antwort hinzu. Ich habe versucht, ein selbstsigniertes Zertifikat für NGINX zu erstellen, und es war einfach, aber als ich es zur weißen Liste von Chrome hinzufügen wollte, hatte ich ein Problem. Meine Lösung bestand darin, ein Stammzertifikat zu erstellen und ein untergeordnetes Zertifikat zu signieren.

Also Schritt für Schritt. Datei erstellen config_ssl_ca.cnf Beachten Sie, dass die Konfigurationsdatei eine Option basicConstraints = CA: true hat, was bedeutet, dass dieses Zertifikat root sein soll.

Dies ist eine gute Vorgehensweise, da Sie sie einmal erstellen und wiederverwenden können.

[ req ]
default_bits = 2048

prompt = no
distinguished_name=req_distinguished_name
req_extensions = v3_req

[ req_distinguished_name ]
countryName=UA
stateOrProvinceName=root region
localityName=root city
organizationName=root organisation
organizationalUnitName=roote department
commonName=root
[email protected]

[ alternate_names ]
DNS.1        = market.localhost
DNS.2        = www.market.localhost
DNS.3        = mail.market.localhost
DNS.4        = ftp.market.localhost

[ v3_req ]
keyUsage=digitalSignature
basicConstraints=CA:true
subjectKeyIdentifier = hash
subjectAltName = @alternate_names

Nächste Konfigurationsdatei für Ihr untergeordnetes Zertifikat.

[ req ]
default_bits = 2048

prompt = no
distinguished_name=req_distinguished_name
req_extensions = v3_req

[ req_distinguished_name ]
countryName=UA
stateOrProvinceName=Kyiv region
localityName=Kyiv
organizationName=market place
organizationalUnitName=market place department
commonName=FirstName LastName
[email protected]

[ alternate_names ]
DNS.1        = market.localhost
DNS.2        = www.market.localhost
DNS.3        = mail.market.localhost
DNS.4        = ftp.market.localhost

[ v3_req ]
keyUsage=digitalSignature
basicConstraints=CA:false
subjectAltName = @alternate_names
subjectKeyIdentifier = hash

Der erste Schritt - Erstellen Sie den Stammschlüssel und das Zertifikat

openssl genrsa -out ca.key 2048
openssl req -new -x509 -key ca.key -out ca.crt -days 365 -config config_ssl_ca.cnf

Im zweiten Schritt werden der untergeordnete Schlüssel und die Datei CSR - Certificate Signing Request erstellt. Denn die Idee ist, das untergeordnete Zertifikat von root zu signieren und ein korrektes Zertifikat zu erhalten

openssl genrsa -out market.key 2048
openssl req -new -sha256 -key market.key -config config_ssl.cnf -out market.csr

Öffnen Sie das Linux-Terminal und führen Sie diesen Befehl echo 0 aus

echo 1 > ca.srl
touch index.txt

Die ca.srl- Textdatei mit der nächsten Seriennummer, die in hexadezimaler Form verwendet werden soll. Verpflichtend. Diese Datei muss vorhanden sein und eine gültige Seriennummer enthalten.

Im letzten Schritt erstellen Sie eine weitere Konfigurationsdatei und nennen sie config_ca.cnf

# we use 'ca' as the default section because we're usign the ca command
[ ca ]
default_ca = my_ca

[ my_ca ]
#  a text file containing the next serial number to use in hex. Mandatory.
#  This file must be present and contain a valid serial number.
serial = ./ca.srl

# the text database file to use. Mandatory. This file must be present though
# initially it will be empty.
database = ./index.txt

# specifies the directory where new certificates will be placed. Mandatory.
new_certs_dir = ./

# the file containing the CA certificate. Mandatory
certificate = ./ca.crt

# the file contaning the CA private key. Mandatory
private_key = ./ca.key

# the message digest algorithm. Remember to not use MD5
default_md = sha256

# for how many days will the signed certificate be valid
default_days = 365

# a section with a set of variables corresponding to DN fields
policy = my_policy

# MOST IMPORTANT PART OF THIS CONFIG
copy_extensions = copy

[ my_policy ]
# if the value is "match" then the field value must match the same field in the
# CA certificate. If the value is "supplied" then it must be present.
# Optional means it may be present. Any fields not mentioned are silently
# deleted.
countryName = match
stateOrProvinceName = supplied
organizationName = supplied
commonName = supplied
organizationalUnitName = optional
commonName = supplied

Sie fragen sich vielleicht, warum so schwierig, warum wir eine weitere Konfiguration erstellen müssen, um das untergeordnete Zertifikat von root zu signieren. Die Antwort ist einfach, da das untergeordnete Zertifikat einen SAN-Block haben muss - Subject Alternative Names. Wenn wir das untergeordnete Zertifikat mit den Dienstprogrammen "openssl x509" signieren, löscht das Stammzertifikat das SAN-Feld im untergeordneten Zertifikat. Daher verwenden wir "openssl ca" anstelle von "openssl x509", um das Löschen des SAN-Felds zu vermeiden. Wir erstellen eine neue Konfigurationsdatei und weisen sie an, alle erweiterten Felder zu kopieren . Copy_extensions = copy .

openssl ca -config config_ca.cnf -out market.crt -in market.csr

Das Programm stellt Ihnen 2 Fragen: 1. Unterschreiben Sie das Zertifikat? Sagen Sie "Y" 2. 1 von 1 zertifizierten Zertifikatanforderungen, festschreiben? Sagen Sie "Y"

Im Terminal sehen Sie einen Satz mit dem Wort "Datenbank". Dies bedeutet die Datei index.txt, die Sie mit dem Befehl "touch" erstellen. Es enthält alle Informationen aller Zertifikate, die Sie mit "openssl ca" util erstellen. So überprüfen Sie die Gültigkeit des Zertifikats:

openssl rsa -in market.key -check

Wenn Sie sehen möchten, was in CRT enthalten ist:

openssl x509 -in market.crt -text -noout

Wenn Sie sehen möchten, was in CSR enthalten ist:

openssl req -in market.csr -noout -text 

Sie haben das allgemeine Verfahren korrekt. Die Syntax für den Befehl ist unten.

openssl req -new -key {private key file} -out {output file}

Die Warnungen werden jedoch angezeigt, da der Browser die Identifizierung nicht überprüfen konnte, indem er das Zertifikat bei einer bekannten Zertifizierungsstelle (CA) validierte.

Da es sich um ein selbstsigniertes Zertifikat handelt, gibt es keine Zertifizierungsstelle, und Sie können die Warnung ignorieren und fortfahren. Wenn Sie ein echtes Zertifikat erhalten möchten, das von jedem im öffentlichen Internet erkannt werden kann, gehen Sie wie folgt vor.

1. Generieren Sie einen privaten Schlüssel
2. Verwenden Sie diesen privaten Schlüssel, um eine CSR-Datei zu erstellen
3. CSR an CA senden (Verisign oder andere usw.)
4. Installieren Sie das von der Zertifizierungsstelle empfangene Zertifikat auf dem Webserver
5. Fügen Sie der Authentifizierungskette je nach Typzertifikat weitere Zertifikate hinzu

Weitere Informationen hierzu finden Sie in einem Beitrag unter Sichern der Verbindung: Erstellen eines Sicherheitszertifikats mit OpenSSL

Einzeiler FTW. Ich halte es gerne einfach. Warum nicht einen Befehl verwenden, der ALLE benötigten Argumente enthält? So gefällt es mir - dadurch werden ein x509-Zertifikat und sein PEM-Schlüssel erstellt:

openssl req -x509 \
 -nodes -days 365 -newkey rsa:4096 \
 -keyout self.key.pem \
 -out self-x509.crt \
 -subj "/C=US/ST=WA/L=Seattle/CN=example.com/[email protected]"

Dieser einzelne Befehl enthält alle Antworten, die Sie normalerweise für die Zertifikatdetails geben würden. Auf diese Weise können Sie die Parameter einstellen und den Befehl ausführen, Ihre Ausgabe abrufen und dann Kaffee trinken gehen.

>> Mehr hier <<

Einzeiler Version 2017:

CentOS:

openssl req -x509 -nodes -sha256 -newkey rsa:2048 \
-keyout localhost.key -out localhost.crt \
-days 3650 \
-subj "CN=localhost" \
-reqexts SAN -extensions SAN \
-config <(cat /etc/pki/tls/openssl.cnf <(printf "\n[SAN]\nsubjectAltName=IP:127.0.0.1,DNS:localhost"))

Ubuntu:

openssl req -x509 -nodes -sha256 -newkey rsa:2048 \
-keyout localhost.key -out localhost.crt \
-days 3650 \
-subj "/CN=localhost" \
-reqexts SAN -extensions SAN \
-config <(cat /etc/ssl/openssl.cnf <(printf "\n[SAN]\nsubjectAltName=IP:127.0.0.1,DNS:localhost"))

Bearbeiten: Vorangestellter Schrägstrich zur Option 'subj' für Ubuntu hinzugefügt.

Schlüssel generieren

Ich verwende /etc/mysqlfür die Speicherung von Zertifikaten, weil /etc/apparmor.d/usr.sbin.mysqldenthält /etc/mysql/*.pem r.

sudo su -
cd /etc/mysql
openssl genrsa -out ca-key.pem 2048;
openssl req -new -x509 -nodes -days 1000 -key ca-key.pem -out ca-cert.pem;
openssl req -newkey rsa:2048 -days 1000 -nodes -keyout server-key.pem -out server-req.pem;
openssl x509 -req -in server-req.pem -days 1000 -CA ca-cert.pem -CAkey ca-key.pem -set_serial 01 -out server-cert.pem;
openssl req -newkey rsa:2048 -days 1000 -nodes -keyout client-key.pem -out client-req.pem;
openssl x509 -req -in client-req.pem -days 1000 -CA ca-cert.pem -CAkey ca-key.pem -set_serial 01 -out client-cert.pem;

Konfiguration hinzufügen

/etc/mysql/my.cnf

[client]
ssl-ca=/etc/mysql/ca-cert.pem
ssl-cert=/etc/mysql/client-cert.pem
ssl-key=/etc/mysql/client-key.pem

[mysqld]
ssl-ca=/etc/mysql/ca-cert.pem
ssl-cert=/etc/mysql/server-cert.pem
ssl-key=/etc/mysql/server-key.pem

In meinem Setup hat sich der Ubuntu-Server angemeldet bei: /var/log/mysql/error.log

Follow-up-Notizen:

• SSL error: Unable to get certificate from '...'

  MySQL wird möglicherweise der Lesezugriff auf Ihre Zertifikatdatei verweigert, wenn es sich nicht in der Apparmors-Konfiguration befindet . Speichern Sie, wie in den vorherigen Schritten ^ erwähnt, alle unsere Zertifikate als .pemDateien in dem /etc/mysql/Verzeichnis, das standardmäßig von Apparmor genehmigt wurde (oder ändern Sie Apparmor / SELinux, um den Zugriff auf alle Speicherorte zu ermöglichen).

• SSL error: Unable to get private key

  Ihre MySQL-Serverversion unterstützt möglicherweise nicht die Standardeinstellung rsa:2048 Format

  Konvertieren generiert rsa:2048in Ebene rsamit:

  openssl rsa -in server-key.pem -out server-key.pem
  openssl rsa -in client-key.pem -out client-key.pem
  

• Überprüfen Sie, ob der lokale Server SSL unterstützt :

  mysql -u root -p
  mysql> show variables like "%ssl%";
  +---------------+----------------------------+
  | Variable_name | Value                      |
  +---------------+----------------------------+
  | have_openssl  | YES                        |
  | have_ssl      | YES                        |
  | ssl_ca        | /etc/mysql/ca-cert.pem     |
  | ssl_capath    |                            |
  | ssl_cert      | /etc/mysql/server-cert.pem |
  | ssl_cipher    |                            |
  | ssl_key       | /etc/mysql/server-key.pem  |
  +---------------+----------------------------+
  

• Überprüfen, ob eine Verbindung zur Datenbank SSL-verschlüsselt ist :

  Verbindung überprüfen

  Wenn Sie bei der MySQL-Instanz angemeldet sind, können Sie folgende Abfrage ausführen:

  show status like 'Ssl_cipher';
  

  Wenn Ihre Verbindung nicht verschlüsselt ist, ist das Ergebnis leer:

  mysql> show status like 'Ssl_cipher';
  +---------------+-------+
  | Variable_name | Value |
  +---------------+-------+
  | Ssl_cipher    |       |
  +---------------+-------+
  1 row in set (0.00 sec)
  

  Andernfalls wird eine Zeichenfolge ungleich Null für den verwendeten Chiffrier angezeigt:

  mysql> show status like 'Ssl_cipher';
  +---------------+--------------------+
  | Variable_name | Value              |
  +---------------+--------------------+
  | Ssl_cipher    | DHE-RSA-AES256-SHA |
  +---------------+--------------------+
  1 row in set (0.00 sec)
  

• SSL für die Verbindung eines bestimmten Benutzers erforderlich ('SSL erforderlich'):

  • SSL

  Weist den Server an, nur SSL-verschlüsselte Verbindungen für das Konto zuzulassen.

  GRANT ALL PRIVILEGES ON test.* TO 'root'@'localhost'
    REQUIRE SSL;
  

  Um eine Verbindung herzustellen, muss der Client die Option --ssl-ca angeben, um das Serverzertifikat zu authentifizieren, und kann zusätzlich die Optionen --ssl-key und --ssl-cert angeben. Wenn weder die Option --ssl-ca noch die Option --ssl-capath angegeben ist, authentifiziert der Client das Serverzertifikat nicht.

Alternativer Link: Langes Tutorial in Sichere PHP-Verbindungen zu MySQL mit SSL .

Wie bereits ausführlich erläutert, sind selbstsignierte Zertifikate für das Internet nicht vertrauenswürdig . Sie können Ihr selbstsigniertes Zertifikat vielen, aber nicht allen Browsern hinzufügen . Alternativ können Sie Ihre eigene Zertifizierungsstelle werden .

Der Hauptgrund, warum man kein signiertes Zertifikat von einer Zertifizierungsstelle erhalten möchte, sind die Kosten - Symantec berechnet zwischen 995 und 1.999 US-Dollar pro Jahr für Zertifikate - nur für ein Zertifikat, das für das interne Netzwerk bestimmt ist, berechnet Symantec 399 US-Dollar pro Jahr . Diese Kosten sind leicht zu rechtfertigen, wenn Sie Kreditkartenzahlungen verarbeiten oder für das Profit Center eines hochprofitablen Unternehmens arbeiten. Es ist mehr, als sich viele leisten können für ein persönliches Projekt, das man im Internet erstellt, oder für eine gemeinnützige Organisation, die mit einem minimalen Budget arbeitet, oder wenn man auf einer Kostenstelle einer Organisation arbeitet - Kostenstellen versuchen immer, mehr zu tun mit weniger.

Eine Alternative ist die Verwendung von certbot (siehe über certbot ). Certbot ist ein benutzerfreundlicher automatischer Client, der SSL / TLS-Zertifikate für Ihren Webserver abruft und bereitstellt.

Wenn Sie certbot einrichten, können Sie es aktivieren, um ein Zertifikat für Sie zu erstellen und zu verwalten, das von der Zertifizierungsstelle Let's Encrypt ausgestellt wurde .

Ich habe das über das Wochenende für meine Organisation gemacht. Ich habe die erforderlichen Pakete für certbot auf meinem Server installiert (Ubuntu 16.04) und dann den Befehl ausgeführt, der zum Einrichten und Aktivieren von certbot erforderlich ist. Man muss wahrscheinlich ein DNS - Plugin für certbot - wir verwenden derzeit DigitalOcean obwohl bald an einen anderen Dienst migrieren können.

Beachten Sie, dass einige der Anweisungen nicht ganz richtig waren und Google ein wenig Zeit und Mühe gekostet hat, um dies herauszufinden. Das hat beim ersten Mal ziemlich viel Zeit in Anspruch genommen, aber jetzt denke ich, ich könnte es in wenigen Minuten schaffen.

Bei DigitalOcean hatte ich Probleme, als ich aufgefordert wurde, den Pfad zu Ihrer INI-Datei mit DigitalOcean-Anmeldeinformationen einzugeben. Das Skript bezieht sich auf die Seite " Anwendungen und API " und die Registerkarte "Token / Schlüssel" auf dieser Seite. Sie müssen ein persönliches Zugriffstoken (Lesen und Schreiben) für die DigitalOcean-API haben oder generieren - dies ist eine hexadezimale Zeichenfolge mit 65 Zeichen. Diese Zeichenfolge muss dann in eine Datei auf dem Webserver eingefügt werden, auf dem Sie certbot ausführen. Diese Datei kann einen Kommentar als erste Zeile haben (Kommentare beginnen mit #). Die zweite Zeile lautet:

dns_digitalocean_token = 0000111122223333444455556666777788889999aaaabbbbccccddddeeeeffff

Nachdem ich herausgefunden hatte, wie ein Lese- und Schreibtoken für die DigitalOcean-API eingerichtet werden kann, war es ziemlich einfach, mit certbot ein Platzhalterzertifikat einzurichten . Beachten Sie, dass Sie kein Platzhalterzertifikat einrichten müssen. Stattdessen können Sie jede Domäne und Unterdomäne angeben, auf die das Zertifikat angewendet werden soll. Es war das Platzhalterzertifikat, für das die INI-Datei mit den Anmeldeinformationen erforderlich war, die das persönliche Zugriffstoken von DigitalOcean enthielt.

Beachten Sie, dass Public-Key-Zertifikate (auch als Identitätszertifikate oder SSL-Zertifikate bezeichnet) ablaufen und erneuert werden müssen. Daher müssen Sie Ihr Zertifikat regelmäßig (wiederkehrend) erneuern. Die Certbot-Dokumentation enthält Informationen zum Erneuern von Zertifikaten .

Mein Plan ist es, ein Skript zu schreiben, das den Befehl openssl verwendet, um das Ablaufdatum meines Zertifikats abzurufen und eine Verlängerung auszulösen, wenn es 30 Tage oder weniger dauert, bis es abläuft. Ich werde dieses Skript dann zu cron hinzufügen und es einmal pro Tag ausführen.

Hier ist der Befehl zum Lesen des Ablaufdatums Ihres Zertifikats:

root@prod-host:~# /usr/bin/openssl x509 -enddate -noout -in path-to-certificate-pem-file
notAfter=May 25 19:24:12 2019 GMT