feat(remote): verify server-CDM vault keys on the client and report bad pairs

The licence response lists KIDs a server vault supplied, the client proves them with the decode check, and a bad pair goes to the new session keys/bad route so the server flags its own row. Client vault keys go first over --remote, and the dashboard health warns when no SQLite vault can store flags.
This commit is contained in:
imSp4rky
2026-09-12 15:13:08 -06:00
parent 7c82282813
commit a7d6791136
21 changed files with 579 additions and 37 deletions
+13
View File
@@ -351,6 +351,19 @@ async def test_health_vault_probe_tolerates_api_vault_rejecting_the_probe(aiohtt
assert checks["vault:t"]["status"] == "ok", checks["vault:t"]
def test_health_warns_without_a_sqlite_vault_to_store_flags(monkeypatch) -> None:
from unshackle.core.api.handlers import run_health_checks
monkeypatch.setattr(config, "proxy_providers", {})
monkeypatch.setattr(
config, "key_vaults", [{"type": "API", "name": "shared", "uri": "http://127.0.0.1:9", "token": "t"}]
)
assert {c["id"]: c for c in run_health_checks()}["bad_keys"]["status"] == "warn"
monkeypatch.setattr(config, "key_vaults", [])
assert {c["id"]: c for c in run_health_checks()}["bad_keys"]["status"] == "ok"
def test_health_proxy_probe_reports_a_provider_that_fails_to_build(monkeypatch) -> None:
from unshackle.core.api.handlers import run_health_checks
@@ -46,13 +46,14 @@ async def _run_batch(monkeypatch, tracks, cdm_type, calls):
session = SimpleNamespace(
service_tag="EXAMPLE",
service_instance=SimpleNamespace(),
served_keys={},
tracks=SimpleNamespace(get=tracks.get),
)
async def fake_get_session(session_id, request):
return session
def fake_single(service, title, track, pssh_str, drm_type, request):
def fake_single(service, title, track, pssh_str, drm_type, request, sources=None):
calls.append((pssh_str, drm_type))
return {"00" * 16: "key"}
@@ -79,6 +79,7 @@ async def test_single_track_path_keeps_siblings(env, monkeypatch):
session = SimpleNamespace(
service_tag="EX",
service_instance=SimpleNamespace(),
served_keys={},
tracks=SimpleNamespace(get={"vid": track}.get),
log_buffer=None,
)
@@ -112,6 +113,7 @@ async def test_batch_cache_does_not_starve_second_track(env, monkeypatch):
session = SimpleNamespace(
service_tag="EX",
service_instance=SimpleNamespace(),
served_keys={},
tracks=SimpleNamespace(get=tracks.get),
log_buffer=None,
)
@@ -142,6 +144,7 @@ async def test_no_pssh_tells_the_client_why(env, monkeypatch):
session = SimpleNamespace(
service_tag="EX",
service_instance=SimpleNamespace(),
served_keys={},
tracks=SimpleNamespace(get={"vid": track}.get),
log_buffer=buf,
)
@@ -0,0 +1,134 @@
"""A server vault key is unproven until the client decodes with it.
Over --remote with server_cdm the server never sees a segment, so the client holds a
vault-sourced key back from its own vaults, checks the decode, and reports a bad pair to
the server. The client never learns which server vault answered: the server keeps the
name on its served-key record and flags the row itself, only for a pair it served.
"""
import json
from types import SimpleNamespace
from uuid import UUID
import pytest
from unshackle.core.api import handlers
from unshackle.core.api.errors import APIError
from unshackle.core.api.session_store import SessionEntry
from unshackle.core.remote_service import RemoteService, ServerVault
pytestmark = pytest.mark.unit
KID = UUID("161219ec3df64e0eadbb3827c0ccc46d")
CDM_KID = UUID("43de497c6d1945f49acc2951696ec628")
def remote_service() -> RemoteService:
svc = RemoteService.__new__(RemoteService)
svc.server_vault_keys = {}
svc.server_vault = ServerVault(svc)
svc._session_id = "sess"
svc.log = SimpleNamespace(warning=lambda *a, **k: None)
return svc
def test_client_marks_vault_keys_and_forgets_cdm_keys():
svc = remote_service()
svc.note_vault_keys({KID.hex: "v", CDM_KID.hex: "c"}, {KID.hex})
assert svc.server_vault_keys == {KID: "v"}
# a re-licence that came from the CDM clears the marker
svc.note_vault_keys({KID.hex: "v2"}, set())
assert svc.server_vault_keys == {}
def test_report_bad_posts_only_the_pair():
svc = remote_service()
posted: list = []
svc.client = SimpleNamespace(post_optional=lambda ep, data: posted.append((ep, data)) or {})
svc.server_vault.report_bad(KID, "v")
assert posted == [("/api/session/sess/keys/bad", {"kid": KID.hex, "key": "v"})]
class _Vault:
local = True
def __init__(self):
self.flagged: list = []
def flag_bad_key(self, service, kid, key, source):
self.flagged.append((service, kid, key, source))
@pytest.fixture
def session(monkeypatch):
entry = SessionEntry(session_id="sess", service_tag="SVC", service_instance=SimpleNamespace())
handlers.note_served_keys(entry, {KID.hex: "v", CDM_KID.hex: "c"}, {KID.hex: "sqlite"})
assert entry.served_keys == {KID.hex: ("v", "sqlite"), CDM_KID.hex: ("c", "cdm")}
async def validated(session_id, request):
return entry
monkeypatch.setattr(handlers, "get_validated_session", validated)
monkeypatch.setattr(handlers, "require_authenticated", lambda s: None)
vault = _Vault()
monkeypatch.setattr(handlers, "load_server_vaults", lambda name: SimpleNamespace(vaults=[vault], service="SVC"))
return entry, vault
async def test_server_flags_a_served_pair_with_its_own_vault_name(session):
entry, vault = session
resp = await handlers.session_bad_key_handler({"kid": KID.hex, "key": "v"}, "sess")
assert resp.status == 200
assert vault.flagged == [("SVC", KID, "v", "sqlite")]
assert KID.hex not in entry.served_keys
with pytest.raises(APIError):
await handlers.session_bad_key_handler({"kid": CDM_KID.hex, "key": "nope"}, "sess")
assert len(vault.flagged) == 1
class _WV:
def __init__(self, b64, kids):
self._pssh = SimpleNamespace(dumps=lambda: b64)
self.kids = kids
_WV.__name__ = "Widevine"
async def test_batch_reports_vault_keys_from_the_init_segment_pssh(monkeypatch):
"""A vault hit on the init-segment PSSH retry must reach `vault_keys` like a manifest one."""
track = SimpleNamespace(id="vid", drm=[_WV("manifest", [KID])], get_key_id=lambda init: CDM_KID)
session = SessionEntry(session_id="sess", service_tag="SVC", service_instance=SimpleNamespace())
session.tracks = {"vid": track}
async def validated(sid, req):
return session
def fake_single(service, title, track, pssh_str, drm_type, request, sources=None):
if pssh_str == "init":
sources[CDM_KID.hex] = "sqlite"
return {CDM_KID.hex: "v"}
return {KID.hex: "c"}
monkeypatch.setattr(handlers, "get_validated_session", validated)
monkeypatch.setattr(handlers, "server_cdm_allowed", lambda request, tag: True)
monkeypatch.setattr(handlers, "ensure_track_drm", lambda track, session=None, init_data=None: None)
monkeypatch.setattr(handlers, "find_title_for_track", lambda tid, session: SimpleNamespace())
monkeypatch.setattr(handlers, "detect_cdm_type_for_service", lambda tag, cfg: "widevine")
monkeypatch.setattr(handlers, "fetch_init_segment", lambda track, sess: b"init")
monkeypatch.setattr(
handlers, "drm_from_init_segment", lambda track, session=None, init_data=None: [_WV("init", [CDM_KID])]
)
monkeypatch.setattr(handlers, "handle_single_server_cdm", fake_single)
monkeypatch.setattr(handlers.config, "serve", {"users": {}}, raising=False)
resp = await handlers.session_license_handler(
{"mode": "server_cdm", "track_ids": ["vid"], "drm_type": "widevine"}, "sess", None
)
payload = json.loads(resp.body)
assert payload["keys"] == {"vid": {CDM_KID.hex: "v"}}
assert payload["vault_keys"] == [CDM_KID.hex]
assert session.served_keys == {CDM_KID.hex: ("v", "sqlite")}
@@ -102,6 +102,7 @@ def _session(tracks: dict, buf=None):
session = SimpleNamespace(
service_tag="EX",
service_instance=SimpleNamespace(),
served_keys={},
tracks=SimpleNamespace(get=tracks.get),
log_buffer=buf,
)
@@ -98,13 +98,15 @@ def test_widevine_still_uses_vault_shortcut(monkeypatch):
monkeypatch.setattr(drm_mod, "Widevine", _FakeWidevine)
monkeypatch.setattr(handlers, "ensure_track_drm", lambda track, session=None, init_data=None: None)
monkeypatch.setattr(handlers, "resolve_device_name", lambda *a, **k: "dev")
monkeypatch.setattr(handlers, "check_vaults", lambda kids, name: {kid.hex: "vaultkey"})
monkeypatch.setattr(handlers, "check_vaults", lambda kids, name: ({kid.hex: "vaultkey"}, {kid.hex: "sqlite"}))
monkeypatch.setattr(handlers.config, "serve", {"users": {}}, raising=False)
sources: dict = {}
keys = handlers.handle_single_server_cdm(
SimpleNamespace(), SimpleNamespace(), SimpleNamespace(), PSSH_B64, "widevine", None
SimpleNamespace(), SimpleNamespace(), SimpleNamespace(), PSSH_B64, "widevine", None, sources
)
assert keys == {kid.hex: "vaultkey"}
assert sources == {kid.hex: "sqlite"} # the server keeps the name; the client only learns it is vault output
async def test_batch_shares_full_bundle_per_pssh(monkeypatch):
@@ -118,6 +120,7 @@ async def test_batch_shares_full_bundle_per_pssh(monkeypatch):
session = SimpleNamespace(
service_tag="EXAMPLE",
service_instance=SimpleNamespace(),
served_keys={},
tracks=SimpleNamespace(get=tracks.get),
)
@@ -128,7 +131,7 @@ async def test_batch_shares_full_bundle_per_pssh(monkeypatch):
bundle_a = {REAL.hex: "k_real", PSSH_KID.hex: "k_pssh", OTHER.hex: "k_other"}
bundle_b = {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa": "k_b"}
def fake_single(service, title, track, pssh_str, drm_type, request):
def fake_single(service, title, track, pssh_str, drm_type, request, sources=None):
calls.append(pssh_str)
return dict(bundle_a) if pssh_str == pssh_a else dict(bundle_b)
@@ -28,6 +28,7 @@ class FakeVaults:
self.added: dict = {}
self.pushes: list = []
self.replicated: list = []
self.sources: dict = {}
def __len__(self):
return 1
@@ -130,6 +131,37 @@ def test_vault_hits_wait_for_the_decrypt_before_replicating():
assert vaults.added == {}
def test_server_vault_keys_are_held_back_until_verified():
"""A key the server took from its vault is sourced like a local vault hit and not pushed yet."""
from unshackle.core.remote_service import ServerVault
vaults = FakeVaults()
cmd = make_cmd(vaults)
remote = cmd._remote_service
remote.server_vault_keys = {CACHED: "k_cached"}
stub = ServerVault(remote)
remote.server_vault = stub
drm = FakeWidevine([CACHED, NEW])
def licence(**kwargs):
drm.content_keys.update({CACHED: "k_cached", NEW: "k_new"})
prepare(cmd, drm, licence, NEW)
cmd.wait_vault_writes()
assert vaults.added == {NEW: "k_new"}
assert vaults.sources == {CACHED: ("k_cached", stub)}
# the batch path caches at its own call site and must hold the same key back
drm2 = FakeWidevine([CACHED])
drm2.content_keys = {CACHED: "k_cached"}
dl.LICENSE_KEY_CACHE.clear()
cmd.cache_resolved_keys(SimpleNamespace(tracks=[SimpleNamespace(drm=[drm2])]))
cmd.wait_vault_writes()
assert vaults.added == {NEW: "k_new"}
def test_tracks_sharing_one_drm_licence_and_push_once():
"""Two tracks on the same DRM run at the same time; the second must find the first one's keys."""
vaults = FakeVaults()
@@ -171,3 +203,21 @@ def test_cdm_only_still_reuses_keys_from_the_run_cache():
assert len(calls) == 1
assert vaults.pushes == [{NEW: "k_new"}]
def test_cdm_only_trusts_server_vault_keys():
"""--cdm-only skips the vault checks, so a server vault key is not sourced for a decode check."""
from unshackle.core.remote_service import ServerVault
vaults = FakeVaults()
cmd = make_cmd(vaults)
remote = cmd._remote_service
remote.server_vault_keys = {CACHED: "k_cached"}
remote.server_vault = ServerVault(remote)
drm = FakeWidevine([CACHED])
prepare(cmd, drm, lambda **kw: drm.content_keys.update({CACHED: "k_cached"}), CACHED, cdm_only=True)
cmd.wait_vault_writes()
assert vaults.sources == {}
assert dl.LICENSE_KEY_CACHE == {CACHED: "k_cached"}