Een Certificate Authority (CA) aanmaken en beheren met Bash
Inleiding
Het beheren van een eigen interne Certificate Authority (CA) is een veelvoorkomende behoefte bij DevOps-teams, platform engineers, gemeenten en IT-afdelingen. Met een interne CA kunnen organisaties certificaten uitgeven en beheren voor interne diensten, Kubernetes-clusters, VPN’s, netwerkapparatuur en ontwikkelomgevingen, zonder afhankelijk te zijn van een publieke CA.
We behandelen:
- Een Root CA aanmaken
- Private keys genereren
- Servercertificaten uitgeven
- Certificate Signing Requests (CSR’s) ondertekenen
- Certificaten intrekken
- Certificate Revocation Lists (CRL’s) genereren
- Taken automatiseren met Bash
Doelgroep: DevOps engineers, reliability engineers, infrastructuurteams en IT-beveiligingsbeheerders.
Het probleem
Organisaties hebben vaak certificaten nodig voor interne webapplicaties, API-gateways, Kubernetes-ingress, VPN-servers, monitoringsystemen en apparaatauthenticatie.
Publieke Certificate Authorities zijn niet altijd geschikt voor deze toepassingen. Ze kunnen kosten met zich meebrengen, ondersteunen geen uitsluitend interne DNS-namen en zijn soms lastig te integreren in interne automatiseringsprocessen.
Zonder centraal CA-beheer ontstaan vaak losse zelfondertekende certificaten, verlopen certificaten, ontbrekende intrekkingsprocedures en onvoldoende inzicht in de levenscyclus van certificaten.
De oplossing
We bouwen een eenvoudige Certificate Authority op basis van OpenSSL en Bash. Deze bestaat uit een Root CA, een certificaatdatabase, scripts voor certificaatuitgifte en mogelijkheden voor intrekking en automatisering.
Let op: deze opzet is bedoeld als leer- en testomgeving. Voor productie is een offline Root CA met een afzonderlijke Intermediate CA, strenger sleutelbeheer en gecontroleerde uitgifteprocessen aan te raden.
Stap 1 — De mappenstructuur voor de CA aanmaken
Maak een afgeschermde directorystructuur voor de CA.
mkdir -p ~/myCA/{certs,crl,newcerts,private,csr}
chmod 700 ~/myCA/private
touch ~/myCA/index.txt
echo 1000 > ~/myCA/serial
echo 1000 > ~/myCA/crlnumber
Overzicht van de directories:
| Directory | Doel |
|---|---|
certs | Uitgegeven certificaten |
crl | Certificaatintrekkingslijsten |
newcerts | Door OpenSSL gearchiveerde certificaten |
private | Private keys |
csr | Certificate Signing Requests |
Stap 2 — De OpenSSL-configuratie aanmaken
Maak het configuratiebestand openssl.cnf aan.
nano ~/myCA/openssl.cnf
Voorbeeldconfiguratie (vervang /home/user/myCA door het werkelijke absolute pad):
[ ca ]
default_ca = CA_default
[ CA_default ]
dir = /home/user/myCA
certs = $dir/certs
crl_dir = $dir/crl
new_certs_dir = $dir/newcerts
database = $dir/index.txt
serial = $dir/serial
RANDFILE = $dir/private/.rand
private_key = $dir/private/ca.key.pem
certificate = $dir/certs/ca.cert.pem
crlnumber = $dir/crlnumber
crl = $dir/crl/ca.crl.pem
default_md = sha256
name_opt = ca_default
cert_opt = ca_default
default_days = 825
default_crl_days = 30
preserve = no
policy = policy_strict
copy_extensions = none
[ policy_strict ]
countryName = optional
stateOrProvinceName = optional
organizationName = optional
organizationalUnitName = optional
commonName = supplied
emailAddress = optional
[ req ]
default_bits = 4096
distinguished_name = req_distinguished_name
string_mask = utf8only
default_md = sha256
[ req_distinguished_name ]
commonName = Common Name
commonName_max = 64
[ v3_ca ]
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always,issuer
basicConstraints = critical, CA:true
keyUsage = critical, digitalSignature, cRLSign, keyCertSign
[ server_cert ]
basicConstraints = critical, CA:false
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid,issuer
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
De secties v3_ca en server_cert bepalen respectievelijk de eigenschappen van het Root CA-certificaat en de uitgegeven servercertificaten. Voor servercertificaten voegen we later expliciet SAN-extensies toe.
Stap 3 — De private key van de Root CA genereren
Genereer een met een wachtwoord beveiligde private key.
openssl genrsa -aes256 \
-out ~/myCA/private/ca.key.pem 4096
Beperk de bestandsrechten:
chmod 400 ~/myCA/private/ca.key.pem
Voorbeeld van uitvoer bij oudere OpenSSL-versies:
Generating RSA private key, 4096 bit long modulus
........................................++++
................................++++
e is 65537 (0x10001)
Bij recente OpenSSL-versies kan de uitvoer anders zijn.
Stap 4 — Het Root CA-certificaat aanmaken
Genereer het zelfondertekende Root CA-certificaat.
openssl req -config ~/myCA/openssl.cnf \
-key ~/myCA/private/ca.key.pem \
-new -x509 -days 3650 -sha256 \
-extensions v3_ca \
-out ~/myCA/certs/ca.cert.pem
Controleer het certificaat:
openssl x509 -noout -text \
-in ~/myCA/certs/ca.cert.pem
Screenshot-placeholder: terminalvenster met de eigenschappen van het Root CA-certificaat, inclusief CA:TRUE, geldigheidsduur en uitgever.
Stap 5 — Een servercertificaat voorbereiden
Genereer een private key voor de server.
openssl genrsa \
-out server.example.local.key.pem 2048
Maak vervolgens een CSR aan.
openssl req -new -sha256 \
-key server.example.local.key.pem \
-out ~/myCA/csr/server.example.local.csr.pem
Belangrijk: moderne TLS-clients controleren de hostnaam via Subject Alternative Names (SAN). De Common Name alleen is niet voldoende. Daarom voegen we bij het ondertekenen de SAN-extensie toe.
Stap 6 — Het certificaat ondertekenen
Maak eerst een bestand met de SAN-extensies voor dit certificaat.
cat > ~/myCA/csr/server.example.local.ext <<'EOF_EXT'
[ server_cert ]
basicConstraints = critical, CA:false
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid,issuer
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = DNS:server.example.local
EOF_EXT
Onderteken de CSR met de CA:
openssl ca -config ~/myCA/openssl.cnf \
-extfile ~/myCA/csr/server.example.local.ext \
-extensions server_cert \
-days 825 \
-notext \
-md sha256 \
-in ~/myCA/csr/server.example.local.csr.pem \
-out ~/myCA/certs/server.example.local.cert.pem
Controleer de certificaatketen en de servernaam:
openssl verify \
-CAfile ~/myCA/certs/ca.cert.pem \
-verify_hostname server.example.local \
~/myCA/certs/server.example.local.cert.pem
Verwachte uitvoer (het pad kan verschillen):
/home/user/myCA/certs/server.example.local.cert.pem: OK
Stap 7 — Een certificaat intrekken
Wanneer een certificaat is gecompromitteerd of niet meer nodig is, kun je het intrekken.
openssl ca -config ~/myCA/openssl.cnf \
-revoke ~/myCA/certs/server.example.local.cert.pem
Voorbeelduitvoer:
Revoking Certificate 1000.
Database updated
Een intrekking wordt in de CA-database geregistreerd. Clients weten pas dat het certificaat is ingetrokken wanneer zij actuele intrekkingsinformatie kunnen raadplegen en daadwerkelijk controleren.
Stap 8 — Een Certificate Revocation List (CRL) genereren
Genereer een CRL.
openssl ca -config ~/myCA/openssl.cnf \
-gencrl \
-out ~/myCA/crl/ca.crl.pem
Bekijk de inhoud:
openssl crl -in ~/myCA/crl/ca.crl.pem \
-noout -text
Let op: het genereren van een CRL is niet voldoende. De CRL moet bereikbaar zijn voor clients die intrekkingen controleren. Richt daarvoor een publicatieproces in en configureer waar nodig een CRL Distribution Point in uitgegeven certificaten.
Stap 9 — Certificaatuitgifte automatiseren met Bash
Met een eenvoudig Bash-script kun je herhaalbare certificaataanvragen uitvoeren. Het volgende voorbeeld gebruikt één DNS-naam als SAN.
Voorbeeldscript: issue-cert.sh
#!/bin/bash
set -euo pipefail
DOMAIN=${1:-}
CA_DIR="$HOME/myCA"
if [ -z "$DOMAIN" ]; then
echo "Usage: $0 domain"
exit 1
fi
if [[ ! "$DOMAIN" =~ ^[A-Za-z0-9.-]+$ ]]; then
echo "Invalid domain name"
exit 1
fi
umask 077
openssl genrsa \
-out "${DOMAIN}.key.pem" 2048
openssl req -new \
-key "${DOMAIN}.key.pem" \
-out "${CA_DIR}/csr/${DOMAIN}.csr.pem" \
-subj "/CN=${DOMAIN}"
cat > "${CA_DIR}/csr/${DOMAIN}.ext" <<EOF_EXT
[ server_cert ]
basicConstraints = critical, CA:false
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid,issuer
keyUsage = critical, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = DNS:${DOMAIN}
EOF_EXT
openssl ca -batch \
-config "${CA_DIR}/openssl.cnf" \
-extfile "${CA_DIR}/csr/${DOMAIN}.ext" \
-extensions server_cert \
-in "${CA_DIR}/csr/${DOMAIN}.csr.pem" \
-out "${CA_DIR}/certs/${DOMAIN}.cert.pem"
echo "Certificate issued:"
echo "Key: ${DOMAIN}.key.pem"
echo "Certificate: ${CA_DIR}/certs/${DOMAIN}.cert.pem"
Maak het script uitvoerbaar:
chmod +x issue-cert.sh
Gebruik:
./issue-cert.sh api.internal.local
Screenshot-placeholder: terminalvenster waarin issue-cert.sh wordt uitgevoerd en de gegenereerde certificaatbestanden worden getoond.
Dit voorbeeld is bedoeld voor een gecontroleerde testomgeving. In productie zijn aanvullende controles nodig op aanvragers, domeineigendom, autorisaties, sleutelopslag en auditing. Voer de CA-private key bij voorkeur niet op dezelfde server uit als de reguliere applicatieworkloads.
Stap 10 — Best practices
Bescherm de Root CA
Bewaar de private key van de Root CA zo veilig mogelijk:
- Houd de Root CA bij voorkeur offline.
- Gebruik versleutelde back-ups.
- Beperk de toegangsrechten.
- Gebruik waar mogelijk een Hardware Security Module (HSM).
Gebruik een Intermediate CA
Voor productieomgevingen is het verstandig om de Root CA offline te houden en een Intermediate CA voor dagelijkse certificaatuitgifte te gebruiken. Hiermee beperk je de blootstelling van de Root CA en kun je verantwoordelijkheden scheiden.
Bewaak vervaldata
Controleer de vervaldatum van een certificaat:
openssl x509 -enddate -noout \
-in certificate.pem
Voorbeelduitvoer:
notAfter=Aug 20 12:00:00 2028 GMT
Automatiseer deze controle en zorg dat beheerders tijdig meldingen ontvangen.
Gebruik SAN-certificaten
Moderne TLS-clients gebruiken Subject Alternative Names (SAN) voor hostnaamcontrole.
Voorbeeld van een extensie:
subjectAltName = DNS:api.internal.local,DNS:api
Zorg dat de SAN-extensie daadwerkelijk in het uitgegeven certificaat staat, niet uitsluitend in de CSR.
Richt CRL of OCSP in
Voor grotere omgevingen:
- Publiceer CRL’s centraal en werk ze tijdig bij.
- Overweeg OCSP waar dat past bij de PKI-architectuur.
- Controleer of applicaties certificaatintrekkingen daadwerkelijk verifiëren.
Veelvoorkomende problemen oplossen
”TXT_DB error number 2”
Deze fout kan optreden bij conflicterende records in de OpenSSL CA-database, bijvoorbeeld wanneer dezelfde subjectnaam opnieuw wordt gebruikt.
Een mogelijke configuratieaanpassing is:
unique_subject = no
Plaats deze instelling in de sectie [ CA_default ] wanneer meerdere geldige certificaten met dezelfde subjectnaam zijn toegestaan. Controleer ook de bestaande database en serienummers; de instelling lost niet ieder databaseconflict op.
”unable to load config info”
Controleer de standaardlocatie van de OpenSSL-configuratie:
openssl version -d
Gebruik het juiste configuratiepad:
-config ~/myCA/openssl.cnf
Controleer daarnaast of het configuratiebestand bestaat en leesbaar is.
Certificaatverificatie mislukt
Controleer bij een mislukte verificatie:
- Of de juiste CA-keten is geïnstalleerd.
- Of de SAN-extensie de gevraagde hostnaam bevat.
- Of het certificaat nog geldig is.
- Of de Root CA in de trust store van de client staat.
- Of de certificaatintrekking correct wordt gecontroleerd.
Conclusie
Met Bash en OpenSSL kun je een eenvoudige interne Certificate Authority opzetten en de levenscyclus van certificaten beheren. Dit biedt controle over interne certificaatuitgifte, mogelijkheden voor automatisering, minder afhankelijkheid van publieke CA’s en beter inzicht in certificaatbeheer.
Deze aanpak is vooral geschikt voor laboratoriumomgevingen, interne infrastructuur, Kubernetes-clusters, VPN-implementaties en ontwikkelomgevingen. Voor grotere of bedrijfskritische omgevingen is een robuuster PKI-platform meestal verstandiger.
Mogelijke oplossingen zijn: