forked from mtusi2026/mtusi2026lab7
447 lines
22 KiB
Python
Executable File
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}
|