Files
mtusi2026lab7/scripts/pki.py
T
2026-11-08 00:33:25 +03:00

285 lines
13 KiB
Python

"""Local PKI of the lab7 stand: one CA, one leaf certificate per service identity, CRL.
Operator tool. Runs in the "pki" container (docker compose --profile tools run --rm pki ...),
writes ONLY into ./secrets (in .gitignore), never prints private keys.
Layout:
secrets/ca/ca.key CA private key: only this tool reads it (never mounted into services)
secrets/ca/state.json issued serials and revoked serials (no secrets inside)
secrets/tls/ca/ca.crt CA certificate: public, mounted into every service as /run/ca/ca.crt
secrets/tls/ca/crl.pem CRL signed by the CA: revoked leaf serials (API checks it for LB identity)
secrets/tls/<id>/tls.crt leaf certificate of identity <id> (CN = SAN DNS = <id>)
secrets/tls/<id>/tls.key its private key (mounted only into the container of that service)
secrets/tls/<id>/tls.pem cert + key in one file (HAProxy format)
secrets/tls-test/... certificates for NEGATIVE tests only: intruder (same CA, unknown identity),
rogue-lb (identity "lb" from a foreign CA), lb-expired (expired "lb")
Commands:
init create CA if missing, issue missing/expiring leaves, test certs, CRL (idempotent)
issue <id> [--days N] re-issue one leaf IN PLACE (rotation; files are overwritten, not replaced,
so bind mounts see the new content). Prints old and new serial.
revoke <id> --serial S add serial S of <id> to the CRL (S from "show" or from "issue" output)
revoke-previous <id> revoke the certificate that "issue" replaced (rotation: issue -> reload -> revoke)
crl re-sign the CRL (it is valid CRL_DAYS days; run before it expires)
show identities, serials, expiry dates
Plain ASCII on purpose (scripts/check_contract.py reads scripts/*.py with the default encoding).
"""
import argparse
import datetime as dt
import ipaddress
import json
import os
import sys
from pathlib import Path
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID
ROOT = Path(os.environ.get("PKI_ROOT", Path(__file__).resolve().parents[1] / "secrets"))
CA_DIR, PUB_DIR, TLS_DIR, TEST_DIR = ROOT / "ca", ROOT / "tls" / "ca", ROOT / "tls", ROOT / "tls-test"
CA_DAYS, LEAF_DAYS, CRL_DAYS, RENEW_BEFORE_DAYS = 365, 30, 30, 7
LOCAL = ["localhost", "127.0.0.1"]
# identity -> extra SAN names. CN = first SAN = identity. All leaves: serverAuth + clientAuth.
IDENTITIES = {
"lb": LOCAL, # external TLS ingress (8443) and mTLS CLIENT of every API replica
"api": [], # mTLS server for LB; client of postgres/s3/valkey/broker/collector/openbao
"worker": [], # client of postgres/s3/broker/collector/openbao
"postgres": LOCAL,
"valkey": LOCAL,
"s3": LOCAL,
"broker": LOCAL,
"otel-collector": LOCAL, # OTLP gateway server; client of prometheus/loki/tempo
"prometheus": LOCAL,
"loki": LOCAL,
"tempo": LOCAL,
"grafana": LOCAL, # HTTPS for the operator; client of prometheus/loki/tempo
"openbao": LOCAL,
}
def now():
return dt.datetime.now(dt.timezone.utc)
def write(path: Path, data: bytes, mode: int = 0o644):
"""Overwrite in place (same inode): containers that bind-mount the directory see the change."""
path.parent.mkdir(parents=True, exist_ok=True)
with open(path, "r+b" if path.exists() else "wb") as fh:
fh.seek(0)
fh.write(data)
fh.truncate()
os.chmod(path, mode)
def pem_key(key) -> bytes:
return key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
serialization.NoEncryption())
def pem_cert(cert) -> bytes:
return cert.public_bytes(serialization.Encoding.PEM)
def load_state() -> dict:
path = CA_DIR / "state.json"
return json.loads(path.read_text()) if path.exists() else {"issued": {}, "revoked": []}
def save_state(state: dict):
write(CA_DIR / "state.json", json.dumps(state, indent=2, sort_keys=True).encode(), 0o600)
def new_ca(common_name: str):
key = ec.generate_private_key(ec.SECP256R1())
name = x509.Name([x509.NameAttribute(NameOID.ORGANIZATION_NAME, "MTUSI lab7"),
x509.NameAttribute(NameOID.COMMON_NAME, common_name)])
cert = (x509.CertificateBuilder().subject_name(name).issuer_name(name).public_key(key.public_key())
.serial_number(x509.random_serial_number())
.not_valid_before(now() - dt.timedelta(minutes=5)).not_valid_after(now() + dt.timedelta(days=CA_DAYS))
.add_extension(x509.BasicConstraints(ca=True, path_length=0), critical=True)
.add_extension(x509.KeyUsage(digital_signature=False, content_commitment=False, key_encipherment=False,
data_encipherment=False, key_agreement=False, key_cert_sign=True,
crl_sign=True, encipher_only=False, decipher_only=False), critical=True)
.add_extension(x509.SubjectKeyIdentifier.from_public_key(key.public_key()), critical=False)
.sign(key, hashes.SHA256()))
return key, cert
def load_ca():
key = serialization.load_pem_private_key((CA_DIR / "ca.key").read_bytes(), None)
cert = x509.load_pem_x509_certificate((PUB_DIR / "ca.crt").read_bytes())
return key, cert
def leaf(ca_key, ca_cert, identity: str, extra: list, not_before=None, not_after=None):
key = ec.generate_private_key(ec.SECP256R1())
names = []
for value in [identity] + list(extra):
try:
names.append(x509.IPAddress(ipaddress.ip_address(value)))
except ValueError:
names.append(x509.DNSName(value))
not_before = not_before or now() - dt.timedelta(minutes=5)
not_after = not_after or now() + dt.timedelta(days=LEAF_DAYS)
cert = (x509.CertificateBuilder()
.subject_name(x509.Name([x509.NameAttribute(NameOID.ORGANIZATION_NAME, "MTUSI lab7"),
x509.NameAttribute(NameOID.COMMON_NAME, identity)]))
.issuer_name(ca_cert.subject).public_key(key.public_key())
.serial_number(x509.random_serial_number())
.not_valid_before(not_before).not_valid_after(not_after)
.add_extension(x509.BasicConstraints(ca=False, path_length=None), critical=True)
.add_extension(x509.KeyUsage(digital_signature=True, content_commitment=False, key_encipherment=False,
data_encipherment=False, key_agreement=True, key_cert_sign=False,
crl_sign=False, encipher_only=False, decipher_only=False), critical=True)
.add_extension(x509.ExtendedKeyUsage([ExtendedKeyUsageOID.SERVER_AUTH,
ExtendedKeyUsageOID.CLIENT_AUTH]), critical=False)
.add_extension(x509.SubjectAlternativeName(names), critical=False)
.add_extension(x509.AuthorityKeyIdentifier.from_issuer_public_key(ca_key.public_key()), critical=False)
.sign(ca_key, hashes.SHA256()))
return key, cert
def store_leaf(directory: Path, key, cert):
write(directory / "tls.key", pem_key(key))
write(directory / "tls.crt", pem_cert(cert))
write(directory / "tls.pem", pem_cert(cert) + pem_key(key))
def serial_hex(cert) -> str:
return format(cert.serial_number, "X")
def write_crl(ca_key, ca_cert, state):
builder = (x509.CertificateRevocationListBuilder().issuer_name(ca_cert.subject)
.last_update(now() - dt.timedelta(minutes=5)).next_update(now() + dt.timedelta(days=CRL_DAYS)))
for item in state["revoked"]:
builder = builder.add_revoked_certificate(
x509.RevokedCertificateBuilder().serial_number(int(item["serial"], 16))
.revocation_date(dt.datetime.fromisoformat(item["at"])).build())
crl = builder.sign(ca_key, hashes.SHA256())
write(PUB_DIR / "crl.pem", crl.public_bytes(serialization.Encoding.PEM))
return len(state["revoked"])
def issue(identity: str, days: int | None, state: dict, quiet=False) -> str:
ca_key, ca_cert = load_ca()
old = state["issued"].get(identity, {}).get("serial")
not_after = now() + dt.timedelta(days=days) if days else None
key, cert = leaf(ca_key, ca_cert, identity, IDENTITIES[identity], not_after=not_after)
store_leaf(TLS_DIR / identity, key, cert)
state["issued"][identity] = {"serial": serial_hex(cert), "not_after": cert.not_valid_after_utc.isoformat(),
"previous": old}
if not quiet:
print(f"{identity}: issued serial {serial_hex(cert)} (valid until {cert.not_valid_after_utc:%Y-%m-%d %H:%M} UTC)"
+ (f", previous serial {old}" if old else ""))
return serial_hex(cert)
def cmd_init(_args):
os.umask(0o022)
CA_DIR.mkdir(parents=True, exist_ok=True)
os.chmod(CA_DIR, 0o700)
state = load_state()
if not (CA_DIR / "ca.key").exists():
key, cert = new_ca("MTUSI lab7 local CA")
write(CA_DIR / "ca.key", pem_key(key), 0o600)
write(PUB_DIR / "ca.crt", pem_cert(cert))
state = {"issued": {}, "revoked": []}
print("CA created: secrets/tls/ca/ca.crt (public), secrets/ca/ca.key (private, operator only)")
ca_key, ca_cert = load_ca()
for identity in IDENTITIES:
path = TLS_DIR / identity / "tls.crt"
if path.exists():
cert = x509.load_pem_x509_certificate(path.read_bytes())
fresh = cert.not_valid_after_utc - now() > dt.timedelta(days=RENEW_BEFORE_DAYS)
if fresh and cert.issuer == ca_cert.subject:
continue
issue(identity, None, state)
# Negative-test material: never mounted into services.
if not (TEST_DIR / "intruder" / "tls.crt").exists():
store_leaf(TEST_DIR / "intruder", *leaf(ca_key, ca_cert, "intruder", []))
rogue_key, rogue_cert = new_ca("Rogue CA (negative tests)")
write(TEST_DIR / "rogue-ca" / "ca.crt", pem_cert(rogue_cert))
store_leaf(TEST_DIR / "rogue-lb", *leaf(rogue_key, rogue_cert, "lb", LOCAL))
store_leaf(TEST_DIR / "lb-expired", *leaf(ca_key, ca_cert, "lb", LOCAL,
not_before=now() - dt.timedelta(days=2),
not_after=now() - dt.timedelta(days=1)))
print("test certificates: secrets/tls-test/{intruder,rogue-lb,lb-expired,rogue-ca}")
revoked = write_crl(ca_key, ca_cert, state)
save_state(state)
print(f"CRL signed ({revoked} revoked serials, valid {CRL_DAYS} days). Private keys were not printed.")
def cmd_issue(args):
if args.identity not in IDENTITIES:
sys.exit(f"unknown identity {args.identity}; known: {', '.join(IDENTITIES)}")
state = load_state()
issue(args.identity, args.days, state)
save_state(state)
def cmd_revoke(args):
state = load_state()
serial = args.serial.upper().lstrip("0") or "0"
if state["issued"].get(args.identity, {}).get("serial") == serial:
sys.exit("refusing to revoke the CURRENT certificate of this identity: issue a new one first")
if not any(r["serial"] == serial for r in state["revoked"]):
state["revoked"].append({"identity": args.identity, "serial": serial, "at": now().isoformat()})
ca_key, ca_cert = load_ca()
count = write_crl(ca_key, ca_cert, state)
save_state(state)
print(f"revoked {args.identity} serial {serial}; CRL now lists {count} serials")
def cmd_revoke_previous(args):
"""Отозвать ПРЕДЫДУЩИЙ сертификат identity (после того как сервис перешёл на новый)."""
state = load_state()
previous = state["issued"].get(args.identity, {}).get("previous")
if not previous:
sys.exit(f"{args.identity}: no previous certificate recorded (run issue first)")
args.serial = previous
cmd_revoke(args)
def cmd_crl(_args):
state = load_state()
ca_key, ca_cert = load_ca()
print(f"CRL re-signed: {write_crl(ca_key, ca_cert, state)} revoked serials")
def cmd_show(_args):
state = load_state()
for identity, item in sorted(state["issued"].items()):
print(f"{identity:15} serial {item['serial']:>40} until {item['not_after'][:16]}")
for item in state["revoked"]:
print(f"revoked: {item['identity']} {item['serial']} at {item['at'][:19]}")
def main():
parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
sub = parser.add_subparsers(dest="command", required=True)
sub.add_parser("init").set_defaults(fn=cmd_init)
p = sub.add_parser("issue")
p.add_argument("identity")
p.add_argument("--days", type=int)
p.set_defaults(fn=cmd_issue)
p = sub.add_parser("revoke")
p.add_argument("identity")
p.add_argument("--serial", required=True)
p.set_defaults(fn=cmd_revoke)
p = sub.add_parser("revoke-previous")
p.add_argument("identity")
p.set_defaults(fn=cmd_revoke_previous)
sub.add_parser("crl").set_defaults(fn=cmd_crl)
sub.add_parser("show").set_defaults(fn=cmd_show)
args = parser.parse_args()
args.fn(args)
if __name__ == "__main__":
main()