forked from mtusi2026/mtusi2026lab7
285 lines
13 KiB
Python
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()
|