Files

447 lines
22 KiB
Python
Executable File

#!/usr/bin/env python3
"""Offline root custody, OpenBao intermediate issuance and atomic leaf rotation."""
from __future__ import annotations
import json
import os
from pathlib import Path
import re
import secrets
import ssl
import time
from lab7_environment import BaoClient, Environment, OperationError, ROLES, atomic_write
class PKI:
def __init__(self, environment: Environment) -> None:
self.env = environment
self.state_path = environment.state / 'pki-state.json'
self.state = environment.read_json(self.state_path, {
'active_root': 1, 'trust_roots': [1], 'issuers': {},
})
def save(self) -> None:
self.env.private_json(self.state_path, self.state)
def root_dir(self, generation: int | str) -> Path:
return self.env.state / ('root-' + str(generation))
def create_root(self, generation: int | str) -> bool:
directory = self.root_dir(generation)
directory.mkdir(parents=True, exist_ok=True, mode=0o700)
if not (directory / 'ca.key').exists():
self.env.run(['openssl', 'genpkey', '-algorithm', 'EC', '-pkeyopt',
'ec_paramgen_curve:P-256', '-out', str(directory / 'ca.key')])
os.chmod(directory / 'ca.key', 0o600)
self.env.run(['openssl', 'req', '-new', '-x509', '-days', '3650',
'-key', str(directory / 'ca.key'), '-out', str(directory / 'ca.crt'),
'-subj', '/CN=MTUSI-Lab7-Root-' + str(generation),
'-addext', 'basicConstraints=critical,CA:TRUE,pathlen:1',
'-addext', 'keyUsage=critical,keyCertSign,cRLSign',
'-addext', 'subjectKeyIdentifier=hash'])
for name, initial in (('index.txt', ''), ('serial', secrets.token_hex(16) + '\n'),
('crlnumber', secrets.token_hex(8) + '\n')):
if not (directory / name).exists():
atomic_write(directory / name, initial)
(directory / 'newcerts').mkdir(exist_ok=True, mode=0o700)
config = f'''[ca]
default_ca = issuer
[issuer]
dir = {directory}
database = $dir/index.txt
new_certs_dir = $dir/newcerts
certificate = $dir/ca.crt
private_key = $dir/ca.key
serial = $dir/serial
crlnumber = $dir/crlnumber
default_md = sha256
default_days = 1
default_crl_days = 3
policy = names
unique_subject = no
copy_extensions = none
[names]
commonName = supplied
'''
atomic_write(directory / 'openssl.cnf', config)
crl = directory / 'ca.crl'
refresh = not crl.exists()
if not refresh:
result = self.env.run(['openssl', 'crl', '-in', str(crl), '-noout', '-nextupdate'])
expires = ssl.cert_time_to_seconds(result.stdout.strip().split('=', 1)[1])
refresh = expires <= time.time() + 86400
if refresh:
result = self.env.run(['openssl', 'ca', '-gencrl', '-config', str(directory / 'openssl.cnf')])
atomic_write(crl, result.stdout)
return refresh
def root_bundle(self) -> str:
return ''.join((self.root_dir(generation) / 'ca.crt').read_text()
for generation in self.state['trust_roots'])
def bundle(self) -> str:
result = self.root_bundle()
for generation in self.state['trust_roots']:
path = self.root_dir(generation) / 'intermediate.crt'
if path.exists():
result += path.read_text()
return result
def root_crls(self) -> str:
return ''.join((self.root_dir(generation) / 'ca.crl').read_text()
for generation in self.state['trust_roots'])
def cached_crls(self) -> str:
result = self.root_crls()
for generation in self.state['trust_roots']:
path = self.root_dir(generation) / 'intermediate.crl'
if path.exists():
result += path.read_text()
return result
def offline_leaf(self, role: str, generation: int | str, *,
common_name: str | None = None, uri_role: str | None = None) -> tuple[str, str]:
directory = self.env.state / 'offline-leaves' / role
directory.mkdir(parents=True, exist_ok=True, mode=0o700)
key = directory / 'tls.key'
csr = directory / 'leaf.csr'
certificate = directory / 'tls.crt'
self.env.run(['openssl', 'genpkey', '-algorithm', 'EC', '-pkeyopt',
'ec_paramgen_curve:P-256', '-out', str(key)])
os.chmod(key, 0o600)
cn = common_name or role
self.env.run(['openssl', 'req', '-new', '-key', str(key), '-out', str(csr),
'-subj', '/CN=' + cn])
dns = ROLES.get(role, [cn])
san = ','.join(['DNS:' + value for value in dns] + ['URI:spiffe://mtusi/' + (uri_role or role)])
extensions = f'''[leaf]
basicConstraints=critical,CA:FALSE
keyUsage=critical,digitalSignature,keyEncipherment
extendedKeyUsage=serverAuth,clientAuth
subjectKeyIdentifier=hash
authorityKeyIdentifier=keyid,issuer
subjectAltName={san}
'''
atomic_write(directory / 'extensions.cnf', extensions)
self.env.run(['openssl', 'ca', '-batch', '-notext', '-days', '1',
'-config', str(self.root_dir(generation) / 'openssl.cnf'),
'-extfile', str(directory / 'extensions.cnf'), '-extensions', 'leaf',
'-in', str(csr), '-out', str(certificate)])
return certificate.read_text(), key.read_text()
def prepare(self) -> None:
refreshed = False
for generation in self.state['trust_roots']:
refreshed = self.create_root(generation) or refreshed
for role in ROLES:
if not self.env.identity(role).exists():
certificate, key = self.offline_leaf(role, self.state['active_root'])
self.env.publish(role, certificate, key, self.bundle(), self.cached_crls())
elif refreshed or not (self.env.secrets / 'pki' / role / 'current-version').exists():
snapshot = self.env.snapshot(role)
self.env.publish(role, snapshot['tls.crt'], snapshot['tls.key'],
self.bundle(), self.cached_crls())
# Controlled wrong identity and wrong CA fixtures contain no root key.
if not self.env.identity('wrong-identity').exists():
certificate, key = self.offline_leaf('wrong-identity', self.state['active_root'],
common_name='lb', uri_role='rogue')
self.env.publish('wrong-identity', certificate, key, self.bundle(), self.cached_crls())
if not self.env.identity('untrusted').exists():
self.create_root('foreign')
certificate, key = self.offline_leaf('untrusted', 'foreign', common_name='lb', uri_role='lb')
self.env.publish('untrusted', certificate, key, self.bundle(), self.cached_crls())
self.save()
def recover_transport(self) -> bool:
restarted_listener = False
for role in ('operator', 'openbao'):
certificate = self.env.identity(role) / 'tls.crt'
valid = self.env.run(['openssl', 'x509', '-checkend', '300', '-noout',
'-in', str(certificate)], check=False).returncode == 0
if valid:
continue
issued, key = self.offline_leaf(role, self.state['active_root'])
self.env.publish(role, issued, key, self.bundle(), self.cached_crls())
restarted_listener = restarted_listener or role == 'openbao'
return restarted_listener
def create_intermediate(self, client: BaoClient, token: str, generation: int) -> str:
known = self.state['issuers'].get(str(generation))
if known:
client.request('GET', 'pki/issuer/' + known, token=token)
return known
before = client.request('LIST', 'pki/issuers', token=token, allowed=(200, 404))
previous = set(before.get('data', {}).get('keys', []))
response = client.request('POST', 'pki/intermediate/generate/internal', {
'common_name': 'MTUSI-Lab7-Intermediate-' + str(generation),
'key_type': 'ec', 'key_bits': 256,
}, token)
csr = response.get('data', {}).get('csr')
if not csr:
raise OperationError('OpenBao did not return an intermediate CSR')
directory = self.root_dir(generation)
atomic_write(directory / 'intermediate.csr', csr)
atomic_write(directory / 'intermediate.cnf', '''[intermediate]
basicConstraints=critical,CA:TRUE,pathlen:0
keyUsage=critical,keyCertSign,cRLSign
subjectKeyIdentifier=hash
authorityKeyIdentifier=keyid,issuer
''')
self.env.run(['openssl', 'ca', '-batch', '-notext', '-days', '365',
'-config', str(directory / 'openssl.cnf'),
'-extfile', str(directory / 'intermediate.cnf'), '-extensions', 'intermediate',
'-in', str(directory / 'intermediate.csr'), '-out', str(directory / 'intermediate.crt')])
imported = client.request('POST', 'pki/intermediate/set-signed', {
'certificate': (directory / 'intermediate.crt').read_text() + (directory / 'ca.crt').read_text(),
}, token)
issuers = imported.get('data', {}).get('imported_issuers', [])
if not issuers:
after = client.request('LIST', 'pki/issuers', token=token)
issuers = list(set(after['data']['keys']) - previous)
expected = (directory / 'intermediate.crt').read_text().strip()
matching = []
for candidate in issuers:
record = client.request('GET', 'pki/issuer/' + candidate, token=token)
if record.get('data', {}).get('certificate', '').strip() == expected:
matching.append(candidate)
if len(matching) != 1:
raise OperationError('cannot identify imported intermediate issuer')
self.state['issuers'][str(generation)] = matching[0]
self.save()
return matching[0]
def provision(self, client: BaoClient, token: str) -> None:
mounts = client.request('GET', 'sys/mounts', token=token)
mounts = mounts.get('data', mounts)
if 'pki/' not in mounts:
client.request('POST', 'sys/mounts/pki', {
'type': 'pki', 'config': {'max_lease_ttl': '8760h'},
}, token)
issuer = self.create_intermediate(client, token, self.state['active_root'])
client.request('POST', 'pki/config/issuers', {'default': issuer}, token)
client.request('POST', 'pki/config/urls', {
'issuing_certificates': ['https://openbao:8200/v1/pki/ca'],
'crl_distribution_points': ['https://openbao:8200/v1/pki/crl'],
}, token)
client.request('POST', 'pki/config/crl', {
'expiry': '72h', 'auto_rebuild': True, 'auto_rebuild_grace_period': '24h',
}, token, allowed=(200, 204, 404))
for role, domains in ROLES.items():
client.request('POST', 'pki/roles/' + role, {
'allowed_domains': domains, 'allow_bare_domains': True,
'allow_subdomains': False, 'allow_glob_domains': False,
'allow_wildcard_certificates': False,
'allow_localhost': 'localhost' in domains,
'allow_ip_sans': False,
'allowed_uri_sans': ['spiffe://mtusi/' + role],
'key_type': 'ec', 'key_bits': 256, 'ttl': '1h', 'max_ttl': '1h',
'server_flag': True, 'client_flag': True, 'issuer_ref': 'default',
}, token)
def crl_remaining(self, crl: str) -> float:
result = self.env.run(['openssl', 'crl', '-noout', '-nextupdate'], data=crl, check=False)
if result.returncode:
return -1
try:
stamp = result.stdout.strip().split('=', 1)[1]
return ssl.cert_time_to_seconds(stamp) - time.time()
except (IndexError, ValueError):
return -1
def sync_crls(self, client: BaoClient, token: str) -> int:
for generation in self.state['trust_roots']:
self.create_root(generation)
issuer = self.state['issuers'].get(str(generation))
if issuer:
crl = client.request('GET', 'pki/issuer/' + issuer + '/crl/pem',
token=token, raw=True)
if self.crl_remaining(crl) < 86400:
client.request('POST', 'pki/issuer/' + issuer + '/crl/rotate', {},
token=token, allowed=(200, 204, 403, 404, 405))
crl = client.request('GET', 'pki/issuer/' + issuer + '/crl/pem',
token=token, raw=True)
if self.crl_remaining(crl) < 86400:
raise OperationError('intermediate CRL remains inside its 24h margin')
atomic_write(self.root_dir(generation) / 'intermediate.crl', crl)
client.request('POST', 'auth/cert/crls/intermediate-' + str(generation),
{'crl': crl}, token)
root_crl = (self.root_dir(generation) / 'ca.crl').read_text()
client.request('POST', 'auth/cert/crls/root-' + str(generation), {'crl': root_crl}, token)
republished = 0
for role in list(ROLES) + ['wrong-identity', 'untrusted', 'next-lb']:
if self.env.identity(role).exists():
snapshot = self.env.snapshot(role)
self.env.publish(role, snapshot['tls.crt'], snapshot['tls.key'],
self.bundle(), self.cached_crls())
republished += 1
return republished
def issue(self, role: str, ttl: str = '1h', *, service_auth: bool = False,
issuer: str | None = None) -> dict:
if role not in ROLES:
raise OperationError('unknown PKI role')
client = BaoClient(self.env, role if service_auth else 'operator')
token = client.login()
path = 'pki/issue/' + role
if issuer:
if service_auth:
raise OperationError('service cannot override its allowed issuer path')
path = 'pki/issuer/' + issuer + '/issue/' + role
response = client.request('POST', path, {
'common_name': role, 'alt_names': ','.join(ROLES[role][1:]),
'uri_sans': 'spiffe://mtusi/' + role, 'ttl': ttl,
}, token)
data = response.get('data', {})
certificate = data.get('certificate', '')
private_key = data.get('private_key', '')
if not certificate or not private_key:
raise OperationError('OpenBao did not issue a complete leaf identity')
chain = '\n'.join(part.strip() for part in [certificate, *data.get('ca_chain', [])]) + '\n'
description = self.env.publish(role, chain, private_key,
self.bundle(), self.cached_crls())
archive = self.env.state / 'issued'
archive.mkdir(exist_ok=True, mode=0o700)
atomic_write(archive / (description['serial_number'] + '.crt'), certificate)
return description
def renew_watch(self, role: str, ttl: str, interval: float, on_issued=None) -> None:
if not 0 < interval <= 1:
raise OperationError('leaf watchdog interval must be in (0, 1] seconds')
result = self.issue(role, ttl, service_auth=True)
if on_issued is not None:
on_issued(role)
print(json.dumps(result), flush=True)
expiry = ssl.cert_time_to_seconds(result['not_after'])
next_renewal = time.time() + max(1, (expiry - time.time()) / 2)
while True:
now = time.time()
if now >= expiry - 1:
raise OperationError('leaf renewal did not complete before certificate deadline')
if now >= next_renewal:
try:
result = self.issue(role, ttl, service_auth=True)
if on_issued is not None:
on_issued(role)
except OperationError as error:
print(json.dumps({'role': role, 'renewal_error': str(error)}), flush=True)
time.sleep(interval)
continue
print(json.dumps(result), flush=True)
expiry = ssl.cert_time_to_seconds(result['not_after'])
next_renewal = time.time() + max(1, (expiry - time.time()) / 2)
time.sleep(interval)
def crl_contains_serial(self, bundle: str, normalized: str) -> bool:
wanted = normalized.lstrip('0').lower()
for block in re.findall(r'-----BEGIN X509 CRL-----.*?-----END X509 CRL-----', bundle, re.S):
output = self.env.run(['openssl', 'crl', '-noout', '-text'], data=block,
check=False).stdout
for line in output.splitlines():
if 'Serial Number:' not in line:
continue
value = line.split(':', 1)[1].strip().replace(':', '').lower().lstrip('0')
if value == wanted:
return True
return False
def revoke(self, role: str, serial: str) -> dict:
normalized = serial.replace(':', '').replace('-', '').lower()
if not normalized or any(ch not in '0123456789abcdef' for ch in normalized):
raise OperationError('invalid public certificate serial')
client = BaoClient(self.env)
token = client.login()
formatted = ':'.join(normalized[index:index + 2] for index in range(0, len(normalized), 2))
client.request('POST', 'pki/revoke', {'serial_number': formatted}, token)
# auto_rebuild only refreshes an expired CRL; a fresh revocation must
# be published now, before the old identity can be retried. OpenBao
# exposes rotation as GET /pki/crl/rotate (POST is 405 here).
client.request('GET', 'pki/crl/rotate', token=token)
self.sync_crls(client, token)
if not self.crl_contains_serial(self.cached_crls(), normalized):
raise OperationError('published CRL does not contain the revoked serial')
return {'role': role, 'revoked_serial': normalized, 'crls_updated': True,
'crl_rotated': True, 'crl_contains_serial': True}
def prepare_rollover(self) -> dict:
if self.state.get('next_root'):
return {'phase': 'prepare', 'next_root': self.state['next_root']}
generation = self.state['active_root'] + 1
self.create_root(generation)
client = BaoClient(self.env)
token = client.login()
self.create_intermediate(client, token, generation)
self.state['next_root'] = generation
self.state['trust_roots'].append(generation)
self.save()
# sync_crls publishes the overlap bundle to every role before issue:
# clients and native services trust the next root before new leaves.
republished = self.sync_crls(client, token)
certificate, key = self.offline_leaf('next-lb', generation, common_name='lb', uri_role='lb')
self.env.publish('next-lb', certificate, key, self.bundle(), self.cached_crls())
return {'phase': 'prepare', 'next_root': generation, 'identities_republished': republished}
def switch_issuer(self) -> dict:
generation = self.state.get('next_root')
if not generation:
raise OperationError('prepare CA overlap before switching issuance')
client = BaoClient(self.env)
token = client.login()
client.request('POST', 'pki/config/issuers', {
'default': self.state['issuers'][str(generation)],
}, token)
self.state['previous_root'] = self.state['active_root']
self.state['active_root'] = generation
self.save()
leaves = [self.issue(role) for role in ROLES]
# Keep the same-CA rogue identity fixture meaningful after the switch:
# otherwise it would be rejected as unknown CA instead of bad identity.
if self.env.identity('wrong-identity').exists():
certificate, key = self.offline_leaf('wrong-identity', generation,
common_name='lb', uri_role='rogue')
self.env.publish('wrong-identity', certificate, key, self.bundle(), self.cached_crls())
return {'phase': 'issue', 'active_root': generation, 'leaves': leaves}
def certificate_name(self, path: Path, field: str) -> str:
output = self.env.run(['openssl', 'x509', '-in', str(path), '-noout',
'-' + field, '-nameopt', 'RFC2253']).stdout.strip()
return output.split('=', 1)[1] if '=' in output else output
def retire_issuer(self) -> dict:
previous = self.state.get('previous_root')
if not previous:
raise OperationError('switch issuance before retiring old CA')
root_dir = self.root_dir(self.state['active_root'])
active_issuers = {
self.certificate_name(root_dir / 'intermediate.crt', 'subject'),
self.certificate_name(root_dir / 'ca.crt', 'subject'),
}
for role in list(ROLES) + ['wrong-identity']:
current = self.env.identity(role)
if not current.exists():
continue
if self.certificate_name(current / 'tls.crt', 'issuer') not in active_issuers:
raise OperationError('retire blocked: leaf is not from the active issuer: ' + role)
verified = self.env.run(['openssl', 'verify',
'-CAfile', str(root_dir / 'ca.crt'),
'-untrusted', str(root_dir / 'intermediate.crt'),
str(current / 'tls.crt')], check=False)
if verified.returncode:
raise OperationError('retire blocked: leaf chain does not verify: ' + role)
client = BaoClient(self.env)
token = client.login()
self.state['trust_roots'] = [self.state['active_root']]
self.state.pop('next_root', None)
self.save()
# sync_crls re-publishes every identity with the retired trust set:
# the leaf stays, but the old root and its CRL disappear from mounts.
republished = self.sync_crls(client, token)
# Old auth CRLs are removed to avoid stale/cross-issuer serial constraints.
for name in ('root-' + str(previous), 'intermediate-' + str(previous)):
client.request('DELETE', 'auth/cert/crls/' + name, token=token)
old_issuer = self.state['issuers'].get(str(previous))
if old_issuer:
client.request('DELETE', 'pki/issuer/' + old_issuer, token=token)
return {'phase': 'retire', 'retired_root': previous, 'active_root': self.state['active_root'],
'identities_republished': republished}