Files
mtusi2026lab7/scripts/pki.py
T

335 lines
18 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Локальный учебный 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/<identity>/tls.crt leaf-сертификат сервиса, tls.key — его ключ, tls.pem — crt+key (HAProxy)
secrets/pki/test/... сертификаты ТОЛЬКО для отрицательных тестов (чужой CA, чужая identity, истёкший)
Идентичность сервиса = Subject CN (и URI SAN spiffe://messenger.lab/<cn>). Её проверяют получатели:
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())