Files
ecs-relay-service/host-code/relay/crypto.py
T

141 lines
6.4 KiB
Python

"""Signed ephemeral X25519 envelopes. The router never receives plaintext keys."""
import base64
import hashlib
import json
import secrets
import time
from datetime import datetime, timedelta, timezone
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ed25519, x25519
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID
def b64(data: bytes) -> str:
return base64.urlsafe_b64encode(data).decode()
def unb64(data: str) -> bytes:
return base64.b64decode(data.encode(), altchars=b"-_", validate=True)
def canonical(data: dict) -> bytes:
return json.dumps(data, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
def raw_public(key) -> str:
return b64(key.public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw))
def pem_private(key) -> bytes:
return key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
serialization.NoEncryption())
def load_private(path):
protected = path.with_name(path.name + ".dpapi")
if protected.is_file():
from .windows_keys import unprotect
data = unprotect(protected.read_bytes())
else:
data = path.read_bytes()
return serialization.load_pem_private_key(data, password=None)
def load_public(path):
return serialization.load_pem_public_key(path.read_bytes())
def fingerprint(pem: str) -> str:
return x509.load_pem_x509_certificate(pem.encode()).fingerprint(hashes.SHA256()).hex()
def verify_device(pem: str, ca_pem: bytes, host_id: str):
"""v1 deliberately accepts only directly issued Ed25519 device certificates."""
cert = x509.load_pem_x509_certificate(pem.encode())
ca = x509.load_pem_x509_certificate(ca_pem)
now = datetime.now(timezone.utc)
if not (ca.not_valid_before_utc <= now <= ca.not_valid_after_utc):
raise ValueError("expired CA")
if not ca.extensions.get_extension_for_class(x509.BasicConstraints).value.ca:
raise ValueError("not a CA")
cert.verify_directly_issued_by(ca)
if not (cert.not_valid_before_utc <= now <= cert.not_valid_after_utc):
raise ValueError("expired certificate")
if cert.extensions.get_extension_for_class(x509.BasicConstraints).value.ca:
raise ValueError("CA cannot be used as device")
if ExtendedKeyUsageOID.CLIENT_AUTH not in cert.extensions.get_extension_for_class(x509.ExtendedKeyUsage).value:
raise ValueError("clientAuth missing")
names = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value
if names.get_values_for_type(x509.UniformResourceIdentifier) != [f"urn:hainuo:host:{host_id}"]:
raise ValueError("host identity mismatch")
public = cert.public_key()
if not isinstance(public, ed25519.Ed25519PublicKey):
raise ValueError("v1 requires Ed25519 device key")
return public
def sign(data: dict, key) -> dict:
return {**data, "signature": b64(key.sign(canonical(data)))}
def verified(data: dict, key) -> dict:
body = {k: v for k, v in data.items() if k != "signature"}
key.verify(unb64(data["signature"]), canonical(body))
return body
def seal(payload: dict, recipient_public: str, signer, *, host_id: str, session_id: str) -> dict:
ephemeral = x25519.X25519PrivateKey.generate()
header = {"v": 1, "host_id": host_id, "session_id": session_id,
"ts": int(time.time()), "nonce": b64(secrets.token_bytes(12)),
"ephemeral": raw_public(ephemeral.public_key())}
shared = ephemeral.exchange(x25519.X25519PublicKey.from_public_bytes(unb64(recipient_public)))
key = HKDF(algorithm=hashes.SHA256(), length=32, salt=session_id.encode(),
info=b"hainuo-relay-envelope-v1").derive(shared)
cipher = AESGCM(key).encrypt(unb64(header["nonce"]), canonical(payload), canonical(header))
return sign({**header, "ciphertext": b64(cipher)}, signer)
def open_envelope(envelope: dict, recipient_private, sender_public, *, host_id: str, session_id: str) -> dict:
body = verified(envelope, sender_public)
if body["v"] != 1 or body["host_id"] != host_id or body["session_id"] != session_id:
raise ValueError("wrong destination/session")
if abs(time.time() - body["ts"]) > 90:
raise ValueError("expired envelope")
header = {k: v for k, v in body.items() if k != "ciphertext"}
shared = recipient_private.exchange(x25519.X25519PublicKey.from_public_bytes(unb64(body["ephemeral"])))
key = HKDF(algorithm=hashes.SHA256(), length=32, salt=session_id.encode(),
info=b"hainuo-relay-envelope-v1").derive(shared)
plain = AESGCM(key).decrypt(unb64(body["nonce"]), unb64(body["ciphertext"]), canonical(header))
return json.loads(plain)
def issue_ca():
key = ed25519.Ed25519PrivateKey.generate()
name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "Hainuo device test CA")])
now = datetime.now(timezone.utc)
cert = (x509.CertificateBuilder().subject_name(name).issuer_name(name)
.public_key(key.public_key()).serial_number(x509.random_serial_number())
.not_valid_before(now - timedelta(minutes=5)).not_valid_after(now + timedelta(days=3650))
.add_extension(x509.BasicConstraints(ca=True, path_length=0), critical=True)
.add_extension(x509.KeyUsage(False, False, False, False, False, True, True, False, False), critical=True)
.sign(key, algorithm=None))
return key, cert
def issue_device(ca_key, ca_cert, host_id: str, public_key, days=30):
now = datetime.now(timezone.utc)
return (x509.CertificateBuilder()
.subject_name(x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, host_id)]))
.issuer_name(ca_cert.subject).public_key(public_key)
.serial_number(x509.random_serial_number())
.not_valid_before(now - timedelta(minutes=5)).not_valid_after(now + timedelta(days=days))
.add_extension(x509.BasicConstraints(ca=False, path_length=None), critical=True)
.add_extension(x509.SubjectAlternativeName([x509.UniformResourceIdentifier(f"urn:hainuo:host:{host_id}")]), critical=False)
.add_extension(x509.ExtendedKeyUsage([ExtendedKeyUsageOID.CLIENT_AUTH]), critical=False)
.sign(ca_key, algorithm=None))