forked from mtusi2026/mtusi2026lab7
335 lines
18 KiB
Python
335 lines
18 KiB
Python
"""Локальный учебный 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())
|