"""Локальный учебный PKI оператора (lab7): корневой CA, сертификаты сервисов, ротация, отзыв (CRL). Запускает ОПЕРАТОР на своей машине (не контейнер приложения): python -m pip install -r requirements-ops.txt # cryptography python scripts/pki.py init # CA + все сертификаты сервисов + тестовые (идемпотентно) python scripts/pki.py status # сроки, серийные номера, отозванные python scripts/pki.py rotate lb # новый leaf той же identity, старый -> secrets/pki/lb/previous/ python scripts/pki.py revoke lb --previous # отозвать предыдущий leaf (CRL), текущий остаётся python scripts/pki.py crl # перевыпустить CRL (nextUpdate через CRL_DAYS) Раскладка (вся папка secrets/ в .gitignore, ничего отсюда не коммитится и не попадает в образ): secrets/pki/ca/ca.key закрытый ключ CA — ТОЛЬКО у оператора, ни в один контейнер не монтируется secrets/pki/ca/revoked.json серийные номера отозванных сертификатов (источник для CRL) secrets/pki/public/ca.crt корневой сертификат: его можно раздавать (клиенты, тесты, браузер) secrets/pki/public/crl.pem список отзыва, подписан CA; его читают API, HAProxy, OpenBao cert auth secrets/pki//tls.crt leaf-сертификат сервиса, tls.key — его ключ, tls.pem — crt+key (HAProxy) secrets/pki/test/... сертификаты ТОЛЬКО для отрицательных тестов (чужой CA, чужая identity, истёкший) Идентичность сервиса = Subject CN (и URI SAN spiffe://messenger.lab/). Её проверяют получатели: API пускает только CN=lb, otel-gate — только CN приложений, RabbitMQ сопоставляет CN с пользователем, OpenBao cert auth выдаёт policy по CN. «Подписан нашим CA» — необходимое, но не достаточное условие. Ключи — ECDSA P-256. Leaf живёт LEAF_DAYS (по умолчанию 30 суток), CA — CA_DAYS (365). Значения ключей скрипт не печатает. """ import argparse import datetime as dt import ipaddress import json import os import shutil 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(__file__).resolve().parents[1] PKI = Path(os.environ.get("PKI_DIR", ROOT / "secrets" / "pki")) CA_DIR, PUBLIC, TEST = PKI / "ca", PKI / "public", PKI / "test" TRUST_DOMAIN = "messenger.lab" CA_DAYS = int(os.environ.get("CA_DAYS", "365")) LEAF_DAYS = int(os.environ.get("LEAF_DAYS", "30")) CRL_DAYS = int(os.environ.get("CRL_DAYS", "30")) SERVER, CLIENT = "server", "client" # identity -> (DNS-имена сервера, роли). Имена DNS = имена сервисов в compose.yaml. LOCAL = ["localhost"] LOCAL_IP = ["127.0.0.1", "::1"] IDENTITIES = { # внешний вход: сертификат, который видит клиент (браузер/тесты) на https://localhost:8443 "ingress": (["localhost", "lb"], LOCAL_IP, {SERVER}), # клиентский сертификат балансировщика для mTLS LB -> API (единственная разрешённая identity у API) "lb": ([], [], {CLIENT}), "api": (["api"], [], {SERVER, CLIENT}), "worker": ([], [], {CLIENT}), "dispatcher": ([], [], {CLIENT}), "janitor": ([], [], {CLIENT}), "migrate": ([], [], {CLIENT}), "s3-init": ([], [], {CLIENT}), "postgres": (["postgres"], [], {SERVER}), "redis": (["redis"], [], {SERVER, CLIENT}), # client: healthcheck redis-cli внутри контейнера "s3": (["s3"], [], {SERVER, CLIENT}), # client: внутренний gRPC SeaweedFS (security.toml) "rabbitmq": (["rabbitmq"], [], {SERVER}), "otel-collector": (["otel-collector", "otel-gate"], [], {SERVER, CLIENT}), "prometheus": (["prometheus"] + LOCAL, LOCAL_IP, {SERVER, CLIENT}), "loki": (["loki"] + LOCAL, LOCAL_IP, {SERVER, CLIENT}), "tempo": (["tempo"] + LOCAL, LOCAL_IP, {SERVER, CLIENT}), "grafana": (["grafana"] + LOCAL, LOCAL_IP, {SERVER, CLIENT}), "openbao": (["openbao"] + LOCAL, LOCAL_IP, {SERVER}), # оператор/скрипты доказательств: чтение Prometheus/Loki/Tempo, отрицательные тесты "operator": ([], [], {CLIENT}), } def now() -> dt.datetime: return dt.datetime.now(dt.timezone.utc) def write(path: Path, data: bytes, private: bool = False) -> None: path.parent.mkdir(parents=True, exist_ok=True) # Запись в тот же inode (а не replace): файл может быть смонтирован в контейнер по отдельности. with open(path, "wb") as file: file.write(data) # 0644: ключ сервиса читает пользователь контейнера (не root, другой uid). От остальных пользователей # хоста ключи закрывает каталог secrets/ (0700, см. protect()). path.chmod(0o600 if private else 0o644) def protect() -> None: for directory in (PKI.parent, PKI, CA_DIR): if directory.exists(): directory.chmod(0o700) if (CA_DIR / "ca.key").exists(): (CA_DIR / "ca.key").chmod(0o600) def new_key() -> ec.EllipticCurvePrivateKey: return ec.generate_private_key(ec.SECP256R1()) def key_pem(key) -> bytes: return key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption()) def cert_pem(cert) -> bytes: return cert.public_bytes(serialization.Encoding.PEM) def load_ca(): key = serialization.load_pem_private_key((CA_DIR / "ca.key").read_bytes(), None) cert = x509.load_pem_x509_certificate((PUBLIC / "ca.crt").read_bytes()) return key, cert def make_ca(common_name: str, days: int): key = new_key() name = x509.Name([x509.NameAttribute(NameOID.ORGANIZATION_NAME, "MTUSI messenger lab"), 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=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 make_leaf(identity: str, dns: list, ips: list, roles: set, ca_key, ca_cert, *, not_before: dt.datetime | None = None, not_after: dt.datetime | None = None): key = new_key() start = not_before or (now() - dt.timedelta(minutes=5)) end = not_after or (now() + dt.timedelta(days=LEAF_DAYS)) sans = [x509.UniformResourceIdentifier(f"spiffe://{TRUST_DOMAIN}/{identity}")] sans += [x509.DNSName(name) for name in dns] sans += [x509.IPAddress(ipaddress.ip_address(ip)) for ip in ips] usages = [] if SERVER in roles: usages.append(ExtendedKeyUsageOID.SERVER_AUTH) if CLIENT in roles: usages.append(ExtendedKeyUsageOID.CLIENT_AUTH) cert = (x509.CertificateBuilder() .subject_name(x509.Name([x509.NameAttribute(NameOID.ORGANIZATION_NAME, "MTUSI messenger lab"), 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(start).not_valid_after(end) .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(usages), critical=False) .add_extension(x509.SubjectAlternativeName(sans), critical=False) .add_extension(x509.AuthorityKeyIdentifier.from_issuer_public_key(ca_cert.public_key()), critical=False) .sign(ca_key, hashes.SHA256())) return key, cert def store_leaf(directory: Path, key, cert) -> None: write(directory / "tls.key", key_pem(key), private=False) write(directory / "tls.crt", cert_pem(cert)) write(directory / "tls.pem", cert_pem(cert) + key_pem(key)) # HAProxy: сертификат и ключ одним файлом def issue(identity: str, ca_key, ca_cert, directory: Path | None = None) -> x509.Certificate: dns, ips, roles = IDENTITIES[identity] key, cert = make_leaf(identity, dns, ips, roles, ca_key, ca_cert) store_leaf(directory or PKI / identity, key, cert) return cert def revoked() -> dict: path = CA_DIR / "revoked.json" return json.loads(path.read_text(encoding="utf-8")) if path.exists() else {} def write_crl(ca_key, ca_cert) -> None: builder = (x509.CertificateRevocationListBuilder().issuer_name(ca_cert.subject) .last_update(now() - dt.timedelta(minutes=5)).next_update(now() + dt.timedelta(days=CRL_DAYS)) .add_extension(x509.CRLNumber(int(now().timestamp())), critical=False)) for serial, info in revoked().items(): builder = builder.add_revoked_certificate( x509.RevokedCertificateBuilder().serial_number(int(serial, 16)) .revocation_date(dt.datetime.fromisoformat(info["revoked_at"])).build()) write(PUBLIC / "crl.pem", builder.sign(ca_key, hashes.SHA256()).public_bytes(serialization.Encoding.PEM)) # ca-bundle для сервисов, которым CRL передаётся вместе с CA одним файлом (не используется сейчас) def make_test_material(ca_key, ca_cert) -> list: """Сертификаты ТОЛЬКО для отрицательных тестов. Ни один сервис их не принимает как свои.""" made = [] if not (TEST / "rogue-ca" / "ca.crt").exists(): rogue_key, rogue_cert = make_ca("Rogue CA (negative tests)", 30) write(TEST / "rogue-ca" / "ca.key", key_pem(rogue_key)) write(TEST / "rogue-ca" / "ca.crt", cert_pem(rogue_cert)) made.append("test/rogue-ca") rogue_key = serialization.load_pem_private_key((TEST / "rogue-ca" / "ca.key").read_bytes(), None) rogue_cert = x509.load_pem_x509_certificate((TEST / "rogue-ca" / "ca.crt").read_bytes()) plans = { # тот же CN, что у настоящего LB/сервисов, но подписан чужим CA "rogue-lb": lambda: make_leaf("lb", [], [], {CLIENT}, rogue_key, rogue_cert), "rogue-worker": lambda: make_leaf("worker", [], [], {CLIENT}, rogue_key, rogue_cert), # чужой сервер с правильным именем: клиент должен отвергнуть (не наш CA) "rogue-server": lambda: make_leaf("api", ["api", "localhost", "postgres", "redis", "s3", "rabbitmq", "otel-collector", "openbao"], LOCAL_IP, {SERVER}, rogue_key, rogue_cert), # подписан НАШИМ CA, но identity, которой нигде ничего не разрешено "intruder": lambda: make_leaf("intruder", ["intruder"], [], {SERVER, CLIENT}, ca_key, ca_cert), # наш CA, CN=lb, но срок действия уже истёк "expired-lb": lambda: make_leaf("lb", [], [], {CLIENT}, ca_key, ca_cert, not_before=now() - dt.timedelta(days=10), not_after=now() - dt.timedelta(days=1)), } for name, plan in plans.items(): if not (TEST / name / "tls.crt").exists(): key, cert = plan() store_leaf(TEST / name, key, cert) made.append(f"test/{name}") return made def cmd_init(_args) -> int: created = [] if not (CA_DIR / "ca.key").exists(): ca_key, ca_cert = make_ca("MTUSI messenger lab root CA", CA_DAYS) write(CA_DIR / "ca.key", key_pem(ca_key), private=True) write(PUBLIC / "ca.crt", cert_pem(ca_cert)) created.append("ca") ca_key, ca_cert = load_ca() for identity in IDENTITIES: if not (PKI / identity / "tls.crt").exists(): issue(identity, ca_key, ca_cert) created.append(identity) created += make_test_material(ca_key, ca_cert) if not (PUBLIC / "crl.pem").exists() or created: write_crl(ca_key, ca_cert) protect() print("pki: created " + (", ".join(created) if created else "nothing (all present)") + f"; CA certificate: {PUBLIC / 'ca.crt'} (keys are not printed)") return 0 def describe(path: Path) -> str: cert = x509.load_pem_x509_certificate(path.read_bytes()) left = (cert.not_valid_after_utc - now()).total_seconds() / 86400 serial = format(cert.serial_number, "x") state = "REVOKED" if serial in revoked() else ("EXPIRED" if left < 0 else f"{left:.1f} d left") cn = cert.subject.get_attributes_for_oid(NameOID.COMMON_NAME)[0].value return f"CN={cn:<15} serial={serial[:16]}… not_after={cert.not_valid_after_utc:%Y-%m-%d %H:%M}Z {state}" def cmd_status(_args) -> int: print(f"CA: {describe(PUBLIC / 'ca.crt')}") for identity in IDENTITIES: path = PKI / identity / "tls.crt" if path.exists(): print(f" {identity:<15} {describe(path)}") previous = PKI / identity / "previous" / "tls.crt" if previous.exists(): print(f" {identity + ' (prev)':<15} {describe(previous)}") crl = x509.load_pem_x509_crl((PUBLIC / "crl.pem").read_bytes()) print(f"CRL: {len(list(crl))} revoked, next update {crl.next_update_utc:%Y-%m-%d}") return 0 def cmd_rotate(args) -> int: """Новый leaf той же identity. Старый остаётся действительным до явного revoke (плавная замена).""" ca_key, ca_cert = load_ca() directory = PKI / args.identity if (directory / "tls.crt").exists(): previous = directory / "previous" previous.mkdir(exist_ok=True) for name in ("tls.crt", "tls.key", "tls.pem"): shutil.copyfile(directory / name, previous / name) cert = issue(args.identity, ca_key, ca_cert) protect() print(f"pki: {args.identity} rotated, new serial {format(cert.serial_number, 'x')[:16]}…, " f"previous kept in {directory / 'previous'} until revoke") return 0 def cmd_revoke(args) -> int: ca_key, ca_cert = load_ca() if args.serial: serial = args.serial.lower() name = args.identity or "manual" else: path = PKI / args.identity / ("previous" if args.previous else "") / "tls.crt" cert = x509.load_pem_x509_certificate(path.read_bytes()) serial, name = format(cert.serial_number, "x"), args.identity data = revoked() data[serial] = {"identity": name, "revoked_at": now().isoformat()} (CA_DIR / "revoked.json").write_text(json.dumps(data, indent=2), encoding="utf-8") write_crl(ca_key, ca_cert) protect() print(f"pki: revoked {name} serial {serial[:16]}…; CRL updated ({len(data)} revoked)") return 0 def cmd_crl(_args) -> int: ca_key, ca_cert = load_ca() write_crl(ca_key, ca_cert) print(f"pki: CRL re-signed, next update in {CRL_DAYS} d") return 0 def main() -> int: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) sub = parser.add_subparsers(dest="command", required=True) sub.add_parser("init").set_defaults(func=cmd_init) sub.add_parser("status").set_defaults(func=cmd_status) sub.add_parser("crl").set_defaults(func=cmd_crl) rotate = sub.add_parser("rotate") rotate.add_argument("identity", choices=sorted(IDENTITIES)) rotate.set_defaults(func=cmd_rotate) revoke = sub.add_parser("revoke") revoke.add_argument("identity", nargs="?", choices=sorted(IDENTITIES)) revoke.add_argument("--previous", action="store_true", help="revoke the leaf kept by the last rotate") revoke.add_argument("--serial", help="hex serial instead of identity") revoke.set_defaults(func=cmd_revoke) args = parser.parse_args() if args.command == "revoke" and not (args.identity or args.serial): parser.error("revoke needs an identity or --serial") return args.func(args) if __name__ == "__main__": sys.exit(main())