PKI — Infrastructure à Clés Publiques

Une PKI (Public Key Infrastructure) est l’ensemble des composants techniques et organisationnels qui permettent d’émettre, gérer et révoquer des certificats numériques de manière fiable.

Le problème que la PKI résout

Sans PKI :
  Alice veut vérifier que la clé publique appartient bien à Bob.
  Mais n'importe qui peut publier une clé publique en prétendant être Bob.
  → Problème de "binding" clé publique ↔ identité

Avec PKI :
  Une CA (autorité de confiance) signe le certificat de Bob :
  { clé publique de Bob + identité de Bob + signature de la CA }
  Alice vérifie la signature de la CA → si la CA est de confiance, Bob est authentifié.

Hiérarchie des CA

La confiance est organisée en arbre. Une CA racine (Root CA) signe des CA intermédiaires, qui signent les certificats finaux (end-entity).

Root CA (CA Racine)
  ├── Intermédiaire CA 1
  │     ├── Certificat serveur : monentreprise.fr
  │     ├── Certificat serveur : api.exemple.com
  │     └── Certificat client  : service-A
  │
  └── Intermédiaire CA 2
        ├── Certificat serveur : autre-site.com
        └── Certificat S/MIME  : user@exemple.com

Pourquoi des CA intermédiaires ?

CA Racine (Root CA) :
  - Clé privée extrêmement précieuse → stockée hors ligne (HSM air-gappé)
  - Si compromise → TOUTE la chaîne de confiance est cassée
  - Signe rarement (quelques CA intermédiaires)

CA Intermédiaire :
  - Clé privée en ligne (HSM connecté)
  - Si compromise → on révoque uniquement cette CA intermédiaire
  - Signe les certificats finaux quotidiennement

→ Isolation du risque : la Root CA ne touche jamais à Internet

Trust Store — le magasin de confiance

Le trust store est la liste des CA racines implicitement connues et approuvées par un système.

Système	Trust Store	Mise à jour
Windows	Magasin de certificats Windows (MMC)	Windows Update
macOS / iOS	Keychain	Mise à jour système
Firefox	NSS (Mozilla Root Program)	Mise à jour Firefox
Chrome / Edge	Trust store de l’OS	Mise à jour OS
Linux	`/etc/ssl/certs/` ou `/etc/ca-certificates/`	`update-ca-certificates`
Java	`$JAVA_HOME/lib/security/cacerts`	`keytool`
Kubernetes	`/etc/ssl/certs/` + secrets	`cert-manager`
curl / wget	`ca-bundle.crt` (OpenSSL)	Mise à jour OS

# Ajouter une CA privée au trust store Linux
cp ma-ca-racine.crt /usr/local/share/ca-certificates/
update-ca-certificates
 
# Vérifier les CA dans le store Linux
ls /etc/ssl/certs/ | head -20
 
# Lister les CA dans le trust store Java
keytool -list -keystore $JAVA_HOME/lib/security/cacerts -storepass changeit

PKI publique vs PKI privée

	PKI publique	PKI privée
Exemples	Let’s Encrypt, DigiCert, Sectigo	HashiCorp Vault PKI, CFSSL, Kubernetes CA
Trust	Navigateurs / OS font confiance nativement	À ajouter manuellement dans le trust store
Coût	Gratuit (Let’s Encrypt) ou payant	Infrastructure à maintenir
Validation	Domaine / organisation vérifiés	Aucune contrainte (CA auto)
Idéal pour	Sites web publics, APIs publiques	Microservices internes, mTLS, Kubernetes
Révocation	CRL + OCSP publics	CRL + OCSP internes (ou pas de révocation)

Créer sa propre CA privée

Utile pour une PKI interne (microservices, tests, Kubernetes).

# 1. Générer la clé privée de la CA racine
openssl genrsa -aes256 -out ca-root.key 4096
# -aes256 : chiffrer la clé avec un mot de passe (recommandé)
 
# 2. Créer le certificat auto-signé de la CA racine (10 ans)
openssl req -new -x509 -days 3650 -key ca-root.key \
  -out ca-root.crt \
  -subj "/CN=Ma CA Racine/O=Mon Entreprise/C=FR"
 
# 3. Générer la clé de la CA intermédiaire
openssl genrsa -out ca-inter.key 4096
 
# 4. Créer le CSR de la CA intermédiaire
openssl req -new -key ca-inter.key \
  -out ca-inter.csr \
  -subj "/CN=Ma CA Intermediaire/O=Mon Entreprise/C=FR"
 
# 5. La CA racine signe la CA intermédiaire (avec basicConstraints CA:TRUE)
cat > ca-inter.ext << EOF
basicConstraints = critical, CA:TRUE, pathlen:0
keyUsage = critical, keyCertSign, cRLSign
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always
EOF
 
openssl x509 -req -days 1825 -in ca-inter.csr \
  -CA ca-root.crt -CAkey ca-root.key -CAcreateserial \
  -extfile ca-inter.ext -out ca-inter.crt
 
# 6. Signer un certificat serveur final avec la CA intermédiaire
openssl genrsa -out serveur.key 2048
openssl req -new -key serveur.key -out serveur.csr \
  -subj "/CN=api.monentreprise.fr/O=Mon Entreprise/C=FR"
 
cat > serveur.ext << EOF
subjectAltName = DNS:api.monentreprise.fr, DNS:monentreprise.fr
keyUsage = critical, digitalSignature
extendedKeyUsage = serverAuth
basicConstraints = CA:FALSE
EOF
 
openssl x509 -req -days 365 -in serveur.csr \
  -CA ca-inter.crt -CAkey ca-inter.key -CAcreateserial \
  -extfile serveur.ext -out serveur.crt
 
# 7. Construire la chaîne complète
cat serveur.crt ca-inter.crt > chain.pem
# → Présenter chain.pem + serveur.key au serveur TLS

PKI dans Kubernetes

Kubernetes embarque sa propre PKI interne pour sécuriser les communications du control plane.

/etc/kubernetes/pki/
├── ca.crt / ca.key                        ← CA racine Kubernetes
├── apiserver.crt / apiserver.key          ← cert du kube-apiserver
├── apiserver-kubelet-client.crt/.key      ← cert pour apiserver → kubelet
├── apiserver-etcd-client.crt/.key         ← cert pour apiserver → etcd
├── etcd/
│   ├── ca.crt / ca.key                    ← CA spécifique à etcd
│   ├── server.crt / server.key            ← cert du serveur etcd
│   └── peer.crt / peer.key                ← cert pour etcd peer-to-peer
├── front-proxy-ca.crt / front-proxy-ca.key
└── sa.key / sa.pub                        ← clés pour les ServiceAccount tokens

# Inspecter les certificats Kubernetes
kubeadm certs check-expiration
 
# Renouveler tous les certificats (avant expiration)
kubeadm certs renew all
 
# Voir l'expiration d'un certificat spécifique
openssl x509 -in /etc/kubernetes/pki/apiserver.crt -noout -dates

PKI avec HashiCorp Vault

Vault peut jouer le rôle de CA intermédiaire et émettre des certificats à la demande.

# Activer le secrets engine PKI
vault secrets enable -path=pki pki
vault secrets tune -max-lease-ttl=87600h pki
 
# Générer la CA intermédiaire
vault write -format=json pki/intermediate/generate/internal \
  common_name="Vault CA Intermediaire" | jq -r '.data.csr' > vault-ca.csr
 
# Après signature par la CA racine, importer le cert signé
vault write pki/intermediate/set-signed certificate=@vault-ca.crt
 
# Créer un rôle pour émettre des certificats
vault write pki/roles/mon-service \
  allowed_domains="monentreprise.fr" \
  allow_subdomains=true \
  max_ttl=720h
 
# Émettre un certificat
vault write pki/issue/mon-service \
  common_name="api.monentreprise.fr" ttl=24h

En relation avec

Certificats — Vue d’ensemble — types et usages des certificats
X.509 — Format des certificats — structure et champs des certificats
Cycle de vie et révocation — CRL, OCSP, renouvellement
Let’s Encrypt et ACME — PKI publique automatisée
TLS et SSL — utilisation de la PKI dans TLS
cert-manager — automatisation PKI dans Kubernetes

abla.adem

Recent Notes

Agents — Vue d'ensemble

Agents autonomes

Prompt Engineering — Vue d'ensemble

CARE

Explorer