forked from mtusi2026/mtusi2026lab7
299 lines
15 KiB
Python
299 lines
15 KiB
Python
#!/usr/bin/env python3
|
||
"""lab7: локальная PKI учебного стенда (CA, leaf-сертификаты, CRL, ротация, отзыв).
|
||
|
||
Запуск (нужен пакет cryptography; он есть в образе приложения):
|
||
python scripts/pki.py init # CA + все leaf + пустой CRL (существующие не трогает)
|
||
python scripts/pki.py status # serial, срок, SAN всех сертификатов
|
||
python scripts/pki.py rotate lb-client # новый leaf (старый -> lb-client.prev.*), ключ тоже новый
|
||
python scripts/pki.py revoke lb-client # отозвать ПРЕДЫДУЩИЙ lb-client (.prev) -> crl.pem
|
||
python scripts/pki.py renew [--days 7] # перевыпустить всё, что истекает раньше чем через N дней
|
||
python scripts/pki.py crl # перевыпустить CRL (nextUpdate +30 дней)
|
||
|
||
Без Python-зависимостей на хосте (Windows):
|
||
docker compose --profile tools run --rm tools python scripts/pki.py init
|
||
|
||
Что где лежит (каталог secrets/ — в .gitignore, в образ не попадает: .dockerignore):
|
||
secrets/pki/ca.crt публичный сертификат CA — его можно раздавать (CA_FILE тестов)
|
||
secrets/pki/ca.key приватный ключ CA — ТОЛЬКО у оператора, ни в один контейнер не монтируется
|
||
secrets/pki/crl.pem список отзыва (читают API и mTLS-gates)
|
||
secrets/pki/<name>.crt/.key leaf; <name>.pem = cert + key (формат HAProxy)
|
||
secrets/pki/state.json журнал выпусков: serial, срок, кем заменён (без ключей)
|
||
|
||
Модель identities: одна identity = один сервис и одна роль. Сервер проверяет не только
|
||
цепочку CA, но и SAN/CN клиента по allowlist (API: только lb; broker/collector gate:
|
||
только api и worker). Сертификат intruder подписан тем же CA, но не входит ни в один
|
||
allowlist — им доказывается, что «доверенный CA» ещё не даёт прав.
|
||
"""
|
||
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]
|
||
DIR = Path(os.environ.get("PKI_DIR", str(ROOT / "secrets" / "pki")))
|
||
CA_DAYS = 3650
|
||
LEAF_DAYS = int(os.environ.get("PKI_LEAF_DAYS", "30"))
|
||
CRL_DAYS = 30
|
||
SERVER = "server"
|
||
CLIENT = "client"
|
||
|
||
# name -> (CN, DNS SAN, IP SAN, роли). CN совпадает с identity, которую проверяют allowlist.
|
||
LEAVES = {
|
||
# Внешний ingress: hostname/SAN, по которым клиент обращается к стенду.
|
||
"lb-public": ("localhost", ["localhost", "lb"], ["127.0.0.1", "::1"], [SERVER]),
|
||
# LB как клиент к API-репликам (единственная identity в allowlist API).
|
||
"lb-client": ("lb", ["lb"], [], [CLIENT]),
|
||
# API: сервер для LB (SAN api) и клиент к broker/collector/redis/postgres.
|
||
"api": ("api", ["api", "api-short-ttl"], [], [SERVER, CLIENT]),
|
||
# worker: только клиент (broker, collector, postgres).
|
||
"worker": ("worker", ["worker"], [], [CLIENT]),
|
||
"postgres": ("postgres", ["postgres"], [], [SERVER]),
|
||
# redis: сервер + клиент (Docker healthcheck внутри контейнера идёт по mTLS своим cert).
|
||
"redis": ("redis", ["redis"], [], [SERVER, CLIENT]),
|
||
# broker-gate слушает в сетевом namespace broker -> имя broker.
|
||
"broker": ("broker", ["broker"], [], [SERVER]),
|
||
"s3": ("s3", ["s3"], [], [SERVER]),
|
||
# Collector: сервер (gate, prometheus-экспортёр) и клиент к Loki/Tempo.
|
||
"otel-collector": ("otel-collector", ["otel-collector"], [], [SERVER, CLIENT]),
|
||
"loki": ("loki", ["loki"], [], [SERVER]),
|
||
"tempo": ("tempo", ["tempo"], [], [SERVER]),
|
||
# Prometheus: сервер для Grafana и клиент при scrape Collector.
|
||
"prometheus": ("prometheus", ["prometheus"], [], [SERVER, CLIENT]),
|
||
# Grafana: HTTPS для оператора (localhost) и клиент к data sources.
|
||
"grafana": ("grafana", ["grafana", "localhost"], ["127.0.0.1"], [SERVER, CLIENT]),
|
||
"openbao": ("openbao", ["openbao"], [], [SERVER]),
|
||
# Подписан тем же CA, НЕ входит ни в один allowlist (отрицательные тесты).
|
||
"intruder": ("intruder", ["intruder"], [], [SERVER, CLIENT]),
|
||
}
|
||
|
||
|
||
def now():
|
||
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), а не rename: Docker монтирует secrets как bind-mount
|
||
# отдельного файла, и работающий контейнер видит новое содержимое (CRL, ротация leaf)
|
||
# без пересоздания; atomic rename оставил бы в контейнере старый inode.
|
||
with open(path, "wb") as handle:
|
||
handle.write(data)
|
||
# Каталог secrets/ — 0700 у оператора. Файлы 0644: внутри контейнеров их читают
|
||
# непривилегированные пользователи с другими uid (haproxy, redis, appuser...).
|
||
# Исключение: PostgreSQL требует 0600 — entrypoint копирует ключ в tmpfs (infra/postgres).
|
||
os.chmod(path, 0o600 if private and os.environ.get("PKI_STRICT_MODE") else 0o644)
|
||
|
||
|
||
def load_state() -> dict:
|
||
path = DIR / "state.json"
|
||
return json.loads(path.read_text(encoding="utf-8")) if path.exists() else {"issued": [], "revoked": []}
|
||
|
||
|
||
def save_state(state: dict) -> None:
|
||
write(DIR / "state.json", json.dumps(state, indent=2, ensure_ascii=False).encode("utf-8"))
|
||
|
||
|
||
def new_key():
|
||
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():
|
||
cert = x509.load_pem_x509_certificate((DIR / "ca.crt").read_bytes())
|
||
key = serialization.load_pem_private_key((DIR / "ca.key").read_bytes(), password=None)
|
||
return cert, key
|
||
|
||
|
||
def init_ca() -> None:
|
||
if (DIR / "ca.crt").exists():
|
||
print("keep ca.crt")
|
||
return
|
||
key = new_key()
|
||
name = x509.Name([x509.NameAttribute(NameOID.ORGANIZATION_NAME, "MTUSI lab7"),
|
||
x509.NameAttribute(NameOID.COMMON_NAME, "Messenger Lab7 Root CA")])
|
||
ski = x509.SubjectKeyIdentifier.from_public_key(key.public_key())
|
||
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=True, key_cert_sign=True, crl_sign=True,
|
||
content_commitment=False, key_encipherment=False,
|
||
data_encipherment=False, key_agreement=False,
|
||
encipher_only=False, decipher_only=False), critical=True)
|
||
.add_extension(ski, critical=False)
|
||
.sign(key, hashes.SHA256()))
|
||
write(DIR / "ca.key", key_pem(key), private=True)
|
||
write(DIR / "ca.crt", cert_pem(cert))
|
||
print("create ca.crt (serial %x)" % cert.serial_number)
|
||
|
||
|
||
def issue(name: str) -> x509.Certificate:
|
||
cn, dns, ips, roles = LEAVES[name]
|
||
ca_cert, ca_key = load_ca()
|
||
key = new_key()
|
||
sans = [x509.DNSName(d) for d in dns] + [x509.IPAddress(ipaddress.ip_address(i)) for i in ips]
|
||
eku = []
|
||
if SERVER in roles:
|
||
eku.append(ExtendedKeyUsageOID.SERVER_AUTH)
|
||
if CLIENT in roles:
|
||
eku.append(ExtendedKeyUsageOID.CLIENT_AUTH)
|
||
cert = (x509.CertificateBuilder()
|
||
.subject_name(x509.Name([x509.NameAttribute(NameOID.ORGANIZATION_NAME, "MTUSI lab7"),
|
||
x509.NameAttribute(NameOID.COMMON_NAME, cn)]))
|
||
.issuer_name(ca_cert.subject).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=LEAF_DAYS))
|
||
.add_extension(x509.BasicConstraints(ca=False, path_length=None), critical=True)
|
||
.add_extension(x509.KeyUsage(digital_signature=True, key_encipherment=False, key_agreement=True,
|
||
content_commitment=False, data_encipherment=False,
|
||
key_cert_sign=False, crl_sign=False, encipher_only=False,
|
||
decipher_only=False), critical=True)
|
||
.add_extension(x509.ExtendedKeyUsage(eku), critical=False)
|
||
.add_extension(x509.SubjectAlternativeName(sans), critical=False)
|
||
.add_extension(x509.AuthorityKeyIdentifier.from_issuer_public_key(ca_key.public_key()), critical=False)
|
||
.sign(ca_key, hashes.SHA256()))
|
||
base = DIR / name
|
||
# Предыдущая версия сохраняется для отзыва (rotate -> revoke).
|
||
if (DIR / (name + ".crt")).exists():
|
||
for ext in (".crt", ".key", ".pem"):
|
||
src = DIR / (name + ext)
|
||
if src.exists():
|
||
shutil.copyfile(src, DIR / (name + ".prev" + ext))
|
||
write(base.with_suffix(".key"), key_pem(key), private=True)
|
||
write(base.with_suffix(".crt"), cert_pem(cert))
|
||
# HAProxy: один файл cert+key.
|
||
write(base.with_suffix(".pem"), cert_pem(cert) + key_pem(key), private=True)
|
||
state = load_state()
|
||
state["issued"].append({"name": name, "serial": "%x" % cert.serial_number, "cn": cn,
|
||
"not_after": cert.not_valid_after_utc.isoformat(), "issued_at": now().isoformat()})
|
||
save_state(state)
|
||
print("issue %-15s serial %x until %s" % (name, cert.serial_number, cert.not_valid_after_utc.date()))
|
||
return cert
|
||
|
||
|
||
def write_crl() -> None:
|
||
ca_cert, ca_key = load_ca()
|
||
state = load_state()
|
||
builder = (x509.CertificateRevocationListBuilder().issuer_name(ca_cert.subject)
|
||
.last_update(now() - dt.timedelta(minutes=1))
|
||
.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["revoked_at"])).build())
|
||
crl = builder.sign(ca_key, hashes.SHA256())
|
||
write(DIR / "crl.pem", crl.public_bytes(serialization.Encoding.PEM))
|
||
# HAProxy ожидает CRL рядом с CA в одном файле ca-file не обязательно; отдельный crl-file.
|
||
print("crl %d revoked serial(s), next update %s" % (len(state["revoked"]), crl.next_update_utc.date()))
|
||
|
||
|
||
def cmd_init(_args) -> None:
|
||
DIR.mkdir(parents=True, exist_ok=True)
|
||
try:
|
||
os.chmod(DIR.parent, 0o700)
|
||
except OSError:
|
||
pass
|
||
init_ca()
|
||
for name in LEAVES:
|
||
if (DIR / (name + ".crt")).exists():
|
||
print("keep %s" % name)
|
||
else:
|
||
issue(name)
|
||
if not (DIR / "crl.pem").exists():
|
||
write_crl()
|
||
|
||
|
||
def cmd_rotate(args) -> None:
|
||
for name in args.names:
|
||
if name not in LEAVES:
|
||
raise SystemExit("unknown identity %s; known: %s" % (name, ", ".join(LEAVES)))
|
||
issue(name)
|
||
print("next: перезапустить потребителя нового ключа (без пересборки образа), затем revoke")
|
||
|
||
|
||
def cmd_revoke(args) -> None:
|
||
state = load_state()
|
||
for name in args.names:
|
||
path = DIR / ((name + ".prev.crt") if not args.current else (name + ".crt"))
|
||
if not path.exists():
|
||
raise SystemExit("%s not found (rotate first, or use --current)" % path.name)
|
||
cert = x509.load_pem_x509_certificate(path.read_bytes())
|
||
serial = "%x" % cert.serial_number
|
||
if any(r["serial"] == serial for r in state["revoked"]):
|
||
print("already revoked %s %s" % (name, serial))
|
||
continue
|
||
state["revoked"].append({"name": name, "serial": serial, "revoked_at": now().isoformat()})
|
||
print("revoke %s serial %s" % (name, serial))
|
||
save_state(state)
|
||
write_crl()
|
||
|
||
|
||
def cmd_renew(args) -> None:
|
||
limit = now() + dt.timedelta(days=args.days)
|
||
for name in LEAVES:
|
||
path = DIR / (name + ".crt")
|
||
cert = x509.load_pem_x509_certificate(path.read_bytes())
|
||
if cert.not_valid_after_utc < limit:
|
||
issue(name)
|
||
write_crl()
|
||
|
||
|
||
def cmd_status(_args) -> None:
|
||
ca = x509.load_pem_x509_certificate((DIR / "ca.crt").read_bytes())
|
||
print("CA %s serial %x until %s" % (ca.subject.rfc4514_string(), ca.serial_number, ca.not_valid_after_utc.date()))
|
||
revoked = {r["serial"] for r in load_state()["revoked"]}
|
||
for name in LEAVES:
|
||
for suffix in ("", ".prev"):
|
||
path = DIR / (name + suffix + ".crt")
|
||
if not path.exists():
|
||
continue
|
||
cert = x509.load_pem_x509_certificate(path.read_bytes())
|
||
san = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value
|
||
serial = "%x" % cert.serial_number
|
||
print("%-20s serial %-40s until %s SAN=%s%s" % (
|
||
name + suffix, serial, cert.not_valid_after_utc.date(),
|
||
",".join(str(v.value) for v in san), " REVOKED" if serial in revoked else ""))
|
||
|
||
|
||
def main() -> None:
|
||
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
||
sub = parser.add_subparsers(dest="cmd", required=True)
|
||
sub.add_parser("init").set_defaults(fn=cmd_init)
|
||
sub.add_parser("status").set_defaults(fn=cmd_status)
|
||
sub.add_parser("crl").set_defaults(fn=lambda a: write_crl())
|
||
p = sub.add_parser("rotate")
|
||
p.add_argument("names", nargs="+")
|
||
p.set_defaults(fn=cmd_rotate)
|
||
p = sub.add_parser("revoke")
|
||
p.add_argument("names", nargs="+")
|
||
p.add_argument("--current", action="store_true", help="отозвать текущий, а не предыдущий сертификат")
|
||
p.set_defaults(fn=cmd_revoke)
|
||
p = sub.add_parser("renew")
|
||
p.add_argument("--days", type=int, default=7)
|
||
p.set_defaults(fn=cmd_renew)
|
||
args = parser.parse_args()
|
||
args.fn(args)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
sys.exit(main())
|