Een Certificate Authority (CA) aanmaken en beheren met Bash

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.

Deze handleiding laat zien hoe je met **Bash en OpenSSL een eenvoudige interne CA op Linux** aanmaakt en beheert.

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:

DirectoryDoel
certsUitgegeven certificaten
crlCertificaatintrekkingslijsten
newcertsDoor OpenSSL gearchiveerde certificaten
privatePrivate keys
csrCertificate 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:

Was dit nuttig?