[[ssl-schluessel_generieren]]
 
Zuletzt angesehen:»start
Inhaltsverzeichnis

SSL-Schlüssel generieren

Beschreibung (PEM)

privater Schlüssel

*.key 

-----BEGIN RSA PRIVATE KEY-----
...
-----END RSA PRIVATE KEY-----

Zertifikat (öffentlicher Schlüssel)

*.crt 

-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----

Anfrage zur Zertifikatssignierung (enthält das Zertifikat)

*.csr 

-----BEGIN CERTIFICATE REQUEST-----
...
-----END CERTIFICATE REQUEST-----

Zugehörigkeiten verifizieren

Will man wissen, ob z.B. ein Zertifikat zu einem Schlüssel gehört, dann kann man das so überprüfen: 

# openssl rsa -noout -modulus -in domain.de.key | openssl md5
0d35e7c7e4db8c07fff78dd4c3de17f1
# openssl req -noout -modulus -in domain.de.csr | openssl md5
0d35e7c7e4db8c07fff78dd4c3de17f1
# openssl x509 -noout -modulus -in domain.de.crt | openssl md5
0d35e7c7e4db8c07fff78dd4c3de17f1

Wenn alle Checksummen identisch sind, dann gehören alle Dateien zusammen.

Einzelschritte von Hand

Wenn Schlüssellänge egal ist und der Schlüssel keinen Passwortschutz benötigt, dann braucht man keinen Schlüssel separat erzeugen weil beim erzeugen eines Zertifikates automatisch ein Schlüssel generiert wird, wenn keiner vorhanden ist.

Alle gewünschten Parameter (z.B. Schlüssellänge) müssen in der /etc/ssl/openssl.cnf gesetzt werden.

einen SSL-Schlüssel generieren

ohne Passphrase

Wenn man einen Schlüssel mit einer bestimmten Länge möchte: 

# openssl genrsa -out server.key 4096

mit Passphrase

Wenn man einen mit Passwort geschützten Schlüssel möchte: 

# openssl genrsa -des3 -out server.key 4096

Passphrase entfernen

# openssl rsa < server.pem > private_key_ohne_passphrase.key

ein Zertifikat generieren

Schlüssel und Zertifikat erzeugen: 

# openssl req -new -x509 -nodes -keyout server.key -out server.crt -days 7000

damit nicht jeder ran kann: 

# chmod 0600 server.*

Fingerabdruck anzeigen: 

# openssl x509 -noout -fingerprint -in server.crt

Zertifikats-Ersteller -Signierer und Gültigkeitszeitraum: 

# openssl x509 -noout -subject -issuer -dates -in server.crt

SSL-Schlüssellänge ausgeben: 

# openssl x509 -noout -text -in server.crt | fgrep ' bit)'

per Script

Um ein Zertifikat von einer offiziellen CA signieren lassen zu können, brauchen wir eine *.csr-Datei.

Die *.csr-Datei wird dann zur Zertifizierungsstelle geschickt, die dann das signierte Zertifikat in einer *.crt-Datei zurück schicken.

*.key (privater Schlüssel) und *.csr (Anfrage zum signieren des Zertifikates mit Zertifikat) erstellen: 

# bin/make_cert.sh -d '*.firma.de' -l Hessen -c Frankfurt -o Firma -a Abteilung

nur *.csr (Anfrage zum signieren des Zertifikates mit Zertifikat) erstellen: 

# bin/make_cert.sh -d www.firma.de -l Hessen -c Frankfurt -o Firma -a Abteilung -k www.firma.de.key

*.key (privater Schlüssel) und *.crt (unsigniertes Zertifikat → öffentlicher Schlüssel) erstellen: 

# bin/make_cert.sh -d '*.firma.de' -l Hessen -c Frankfurt -o Firma -a Abteilung -u

nur *.crt (unsigniertes Zertifikat → öffentlicher Schlüssel) erstellen: 

# bin/make_cert.sh -d www.firma.de -l Hessen -c Frankfurt -o Firma -a Abteilung -u -k www.firma.de.key

bin/make_cert.sh

#!/bin/bash
# Voreinstellungen
STAAT="DE"                                      # Staat
EMAIL="default@domain.de"                       # eMail
ZEITRAUM="731"                                  # Gültigkeitszeitraum in Tagen
BITLANG="4096"                                  # Schlüssellänge in Bit
if [ -z "${1}" ] ; then
        echo "${0} -h"
        exit 1
fi
while [ "${#}" -ne "0" ]; do
        case "${1}" in
                -d)
                        DOMAIN=${2}             # neuen oder vorhandenen Schlüssel verwenden
                        shift
                        ;;
                -k)
                        KEY=${2}                # neuen oder vorhandenen Schlüssel verwenden
                        shift
                        ;;
                -u)
                        UNSIGNIERT=JA           # Schlüssel mit unsigniertem Zertifikat erstellen
                        shift
                        ;;
                -s)
                        STAAT=${2}              # z.B.: DE
                        shift
                        ;;
                -l)
                        LAND=${2}               # z.B.: Hessen
                        shift
                        ;;
                -c)
                        STADT=${2}              # z.B.: Frankfurt
                        shift
                        ;;
                -o)
                        ORGANISATION=${2}       # Organisation
                        shift
                        ;;
                -a)
                        ABTEILUNG=${2}          # Abteilung
                        shift
                        ;;
                -m)
                        EMAIL=${2}              # z.B.: default@domain.de
                        shift
                        ;;
                -z)
                        ZEITRAUM=${2}           # Gültigkeitszeitraum: 730
                        shift
                        ;;
                -b)
                        BITLANG=${2}            # Schlüssellänge: 4096
                        shift
                        ;;
                -h)
                        echo "
                        zwingend erforderliche Parameter:
                                -d Domain/FQDN
                                -l Land
                                -c City/Stadt
                                -o Organisation/Mandant
                                -a Abteilung/Marke
                        optionale Parameter:
                                -k Key-Datei der schon existiert
                                -s Staat
                                -m Mail
                                -z Zeitraum der Gültigkeit
                                -b Bit-Länge des Schlüssels
                        Beispiele
                            wild-card-Zertifikat mit neuem Schlüssel:
                                # ${0} -d '*.firma.de' -l Hessen -c Frankfurt -o Firma -a Abteilung
                            unsigniertes Standard-Zertifikat mit vorhandenem Schlüssel:
                                # ${0} -d www.firma.de -l Hessen -c Frankfurt -o Firma -a Abteilung -k www.firma.de.key -u
                        "
                        exit 0
                        ;;
                *)
                        if [ "$(echo "${1}"|egrep '^-')" ] ; then
                                echo "Der Parameter '${1}' wird nicht unterstützt!"
                                exit 1
                        fi
                        shift
                        ;;
        esac
done
ZNAME="$(echo "${DOMAIN}" | tr -s '[*]' 'w')"
if [ -z "${DOMAIN}" -o -z "${LAND}" -o -z "${STADT}" -o -z "${ORGANISATION}" -o -z "${ABTEILUNG}" ] ; then
        echo "
        Es werden mind. die Parameter -d, -l, -c, -o, und -a benötigt!
        => ${0} -h
        "
        exit 1
fi
if [ "${UNSIGNIERT}" == "JA" ] ; then
    if [ -z "${KEY}" ] ; then
        # neuer Schlüssel
        KEY="${ZNAME}.key"
        echo "openssl req -x509 -rand /dev/urandom -sha1 -newkey rsa:${BITLANG} -nodes -keyout ${KEY} -keyform PEM -out ${ZNAME}.crt -outform PEM -subj \"/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${DOMAIN}\" -days ${ZEITRAUM}"
        openssl req -x509 -rand /dev/urandom -sha1 -newkey rsa:${BITLANG} -nodes -keyout ${KEY} -keyform PEM -out ${ZNAME}.crt -outform PEM -subj "/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${DOMAIN}" -days ${ZEITRAUM}
    else
        echo "openssl req -x509 -new -key ${KEY} -out ${ZNAME}.crt -outform PEM -subj "/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${DOMAIN}" -days ${ZEITRAUM}"
        openssl req -x509 -new -key ${KEY} -out ${ZNAME}.crt -outform PEM -subj "/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${DOMAIN}" -days ${ZEITRAUM}
    fi
else
    if [ -z "${KEY}" ] ; then
        # neuer Schlüssel
        KEY="${ZNAME}.key"
        echo "openssl req -rand /dev/urandom -sha1 -newkey rsa:${BITLANG} -nodes -keyout ${KEY} -keyform PEM -out ${ZNAME}.csr -outform PEM -subj \"/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${DOMAIN}\" -days ${ZEITRAUM}"
        openssl req -rand /dev/urandom -sha1 -newkey rsa:${BITLANG} -nodes -keyout ${KEY} -keyform PEM -out ${ZNAME}.csr -outform PEM -subj "/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${DOMAIN}" -days ${ZEITRAUM}
else
        if [ -r "${KEY}" ] ; then
                # vorhandener Schlüssel
                echo "openssl req -new -key ${KEY} -keyform PEM -out ${ZNAME}.csr -outform PEM -subj \"/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${DOMAIN}\" -days ${ZEITRAUM}"
                openssl req -new -key ${KEY} -keyform PEM -out ${ZNAME}.csr -outform PEM -subj "/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${DOMAIN}" -days ${ZEITRAUM}
        else
                echo "die Datei ${KEY} ist nicht lesbar..."
                exit 1
        fi
    fi
fi
if [ -r "${ZNAME}.csr" ] ; then
        echo "${ZNAME}.csr $(openssl req -text -verify -in ${ZNAME}.csr)"
fi
if [ -r "${KEY}" ] ; then
        echo "${KEY} $(openssl rsa -noout -modulus -in ${KEY} | openssl md5)"
fi
if [ -r "${ZNAME}.csr" ] ; then
        echo "${ZNAME}.csr $(openssl req -noout -modulus -in ${ZNAME}.csr | openssl md5)"
fi
if [ -r "${ZNAME}.crt" ] ; then
        echo "${ZNAME}.crt $(openssl x509 -noout -modulus -in ${ZNAME}.crt | openssl md5)"
fi

Zertifikat mit der eigenen CA signieren

bin/ca_initialisieren.sh

Dieses Script erstellt eine eigene CA. 

#!/bin/bash
#
# Schlüssel mit Zertifikat
# für eine CA-Signatur erzeugen
#
if [ -z "${1}" ] ; then
        echo "${0} [CA-Name]"
        exit 1
else
        ### initialisieren
        . $(dirname ${0})/cert.cfg
        rm -fr CA
        mkdir -p ~/CA/private ~/CA/newcerts && echo '01' > ~/CA/serial && touch ~/CA/index.txt
        openssl req -x509 -rand /dev/urandom -sha1 -newkey rsa:${BITLANG} -keyout ~/CA/private/ca.key -keyform PEM -out ~/CA/ca.crt -outform PEM -subj "/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${1}" -days ${ZEITRAUM}
        echo -e "[ca]\ndefault_ca=CA_default\n[CA_default]\npolicy=policy_match\nserial=CA/serial\ndatabase=CA/index.txt\n[policy_match]\ncommonName=supplied" > ~/CA/openssl.cnf
fi

Für eine Testumgebung kann man die Passphrase auch entfernen: 

# openssl rsa < ~/CA/private/ca.key > ca.key
# mv ca.key ~/CA/private/ca.key

bin/ca_cert_neu.sh

Dieses Script generiert einen privaten Schlüssel, ein Zertifikat (öffentlicher Schlüssel) und signiert das Zertifikat mit der eigenen CA. 

#!/bin/bash
#
# Schlüssel mit signiertem Zertifikat erzeugen
#
if [ -z "${1}" ] ; then
        echo "${0} [FQDN des Zielhost]"
        echo "${0} www.domain.org"
        echo "${0} '*.domain.org'"
        exit 1
else
        ### generieren
        ZNAME="$(echo "${1}" | tr -s '[*]' 'i')"
        . $(dirname ${0})/cert.cfg
        openssl req -x509 -rand /dev/urandom -sha1 -newkey rsa:${BITLANG} -nodes -keyout ${ZNAME}.key -keyform PEM -out ${ZNAME}.crt -outform PEM -subj "/emailAddress=${EMAIL}/C=${STAAT}/ST=${LAND}/L=${STADT}/O=${ORGANISATION}/OU=${ABTEILUNG}/CN=${1}" -days ${ZEITRAUM}
        ### signieren
        openssl ca -config ~/CA/openssl.cnf -batch -md sha1 -selfsign -ss_cert ${ZNAME}.crt -keyfile ~/CA/private/ca.key -cert ~/CA/ca.crt -outdir ~/CA/newcerts/ -days ${ZEITRAUM}
        echo
        cp ~/CA/newcerts/$(tail -n1 ~/CA/index.txt | awk '{gsub("="," ");print $3".pem"}') ${ZNAME}.pem
        rm -f $(tail -n1 ~/CA/index.txt | awk '{gsub("="," ");print $NF".crt"}')
        openssl x509 -noout -subject -issuer -dates -in ${ZNAME}.pem
        ls -1 ${ZNAME}.*
fi

bin/ssl_check.sh

#!/bin/bash
if [ -z "${1}" ] ; then
      echo "${0} *.domain.de.*"
      exit 1
fi
echo
for i in ${@}
do
      ENDUNG="$(echo "${i}" | rev | awk -F'.' '{print $1}' | rev)"
      if [ "${ENDUNG}" == "key" ] ; then
              MD5PRUEFSUMME="$(openssl rsa -noout -modulus -in ${i} | openssl md5)"
              echo "${MD5PRUEFSUMME} - ${i}"
      elif [ "${ENDUNG}" == "csr" ] ; then
              MD5PRUEFSUMME="$(openssl req -noout -modulus -in ${i} | openssl md5)"
              echo "${MD5PRUEFSUMME} - ${i}"
      elif [ "${ENDUNG}" == "crt" ] ; then
              MD5PRUEFSUMME="$(openssl x509 -noout -modulus -in ${i} | openssl md5)"
              echo "${MD5PRUEFSUMME} - ${i}"
#     else
#             echo "${i} ..."
      fi
done | sort -n
echo

Zusammengehörigkeit von Schlüssel und Zertifikatsanfrage überprüfen: 

# /root/bin/ssl_check.sh *.domain.de.*
0d345e7c7e4db8c05fff48d4c3de17e1 - www.domain.de.crt
0d345e7c7e4db8c05fff48d4c3de17e1 - www.domain.de.csr
0d345e7c7e4db8c05fff48d4c3de17e1 - www.domain.de.key

im Apache HTTPS aktivieren

Ubuntu

nachlesen wie es geht: 

# zless /usr/share/doc/apache2.2-common/README.Debian.gz

Schlüssel und signiertes Zertifikat an die richtige Stelle legen: 

# cp www.test.net.pem /etc/ssl/certs/
# cp www.test.net.key /etc/ssl/private/

den gewünschten Schlüssel mit Zertifikat eintragen: 

# vi /etc/apache2/sites-available/default-ssl
...
        SSLCertificateFile    /etc/ssl/certs/www.test.net.pem
        SSLCertificateKeyFile /etc/ssl/private/www.test.net.key
...

SSL aktivieren: 

# a2ensite default-ssl
# a2enmod ssl
# /etc/init.d/apache2 restart

openssl -> pkcs12

# openssl pkcs12 -export -out zertifikat.p12 -inkey privater.key -in zertifikat.crt -certfile ca.crt
 
Falls nicht anders bezeichnet, ist der Inhalt dieses Wikis unter der folgenden Lizenz veröffentlicht:GNU Free Documentation License 1.2
Recent changes RSS feed Donate Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki