Files
unshackle/tests/remote/unit/test_key_identity.py
T
imSp4rky f1e4081313 feat(serve): per-api-key cdm and service config with server-side identity cache
serve.users.<key>.cdm and service_config give each API key its own device and service config. Service.IDENTITY_CACHE keys route to a per-key directory that clients never receive
2026-11-16 13:31:17 -07:00

190 lines
9.3 KiB
Python

"""An API key's own cdm and service_config entries, and the identity cache a server device keeps per key."""
import asyncio
import base64
import json
import zlib
from types import SimpleNamespace
import pytest
from unshackle.core.api import handlers
from unshackle.core.api.errors import APIError
from unshackle.core.api.input_bridge import AuthStatus
from unshackle.core.api.session_store import get_session_store
from unshackle.core.config import config
@pytest.fixture
def server(monkeypatch, tmp_path):
monkeypatch.setattr(config, "cdm", {"EXAMPLE": {"widevine": "shared_wv", "playready": "shared_pr"}, "OTHER": "x"})
monkeypatch.setattr(config.directories, "cache", tmp_path)
monkeypatch.setattr(handlers.Services, "get_tag", staticmethod(lambda tag: tag.upper()))
return tmp_path
def test_a_key_entry_replaces_the_whole_server_entry(server):
user = {"cdm": {"example": "own_pr"}}
assert handlers.key_cdm_config(user).cdm == {"OTHER": "x", "example": "own_pr"}
assert handlers.configured_cdm_name("EXAMPLE", "widevine", handlers.key_cdm_config(user)) == "own_pr"
assert handlers.key_cdm_config({}) is config
def test_licence_device_comes_from_the_key_entry(server):
assert handlers.resolve_device_name({"cdm": {"EXAMPLE": "own"}}, "playready", "EXAMPLE") == "own"
assert handlers.resolve_device_name({}, "playready", "EXAMPLE") == "shared_pr"
def test_a_session_keeps_the_user_config_it_was_created_with(server, monkeypatch):
session = SimpleNamespace(user_config={"cdm": {"EXAMPLE": "pinned"}})
monkeypatch.setattr(handlers, "serve_user_config", lambda key: {"cdm": {"EXAMPLE": "reloaded"}})
assert handlers.session_user_config(session, None)["cdm"]["EXAMPLE"] == "pinned"
assert handlers.session_user_config(SimpleNamespace(), None)["cdm"]["EXAMPLE"] == "reloaded"
def test_the_key_block_beats_the_server_config_and_profile_sections(server, monkeypatch):
base = {"device_id": "server", "device_key": "server", "p1": {"device_id": "p1", "other": 1}, "urls": {"a": "b"}}
monkeypatch.setattr(handlers, "load_service_yaml", lambda service: json.loads(json.dumps(base)))
user = {"service_config": {"example": {"device_id": "key", "device_key": "key"}}}
merged = handlers.key_service_yaml("EXAMPLE", user)
assert merged["device_id"] == merged["device_key"] == "key"
assert merged["p1"] == {"device_id": "key", "other": 1}
assert merged["urls"] == {"a": "b"}
assert handlers.key_service_yaml("EXAMPLE", {})["device_id"] == "server"
assert handlers.key_owns_identity(user, "EXAMPLE") and not handlers.key_owns_identity(user, "OTHER")
class _Service:
IDENTITY_CACHE = ("keys/",)
def test_identity_keys_live_in_the_api_key_directory_and_never_reach_the_client(server):
cache = handlers.keyed_cache("_s", _Service(), "EXAMPLE", "k", {}, temporary=True)
cache.get("keys/device1").set("keys")
cache.get("tokens").set("login")
assert set(handlers.collect_cache_files("_s")) == {"tokens"}
assert list((server / "_identity").rglob("device1.json"))
assert handlers.keyed_cache("_t", _Service(), "EXAMPLE", "k", {}, True).get("keys/device1").data == "keys"
text = base64.b64encode(zlib.compress(b'{"data": "planted"}')).decode("ascii")
handlers.write_client_cache({"keys/device1": text}, "_s")
assert cache.get("keys/device1").data == "keys"
def test_a_lasting_cache_keeps_identity_keys_apart_only_for_a_key_with_its_own_identity(server):
own = {"service_config": {"EXAMPLE": {"device_id": "key"}}}
assert handlers.keyed_cache("_accounts/EXAMPLE/p", _Service(), "EXAMPLE", "k", {}).route is None
assert handlers.keyed_cache("_accounts/EXAMPLE/p", _Service(), "EXAMPLE", "k", own).route is not None
assert handlers.keyed_cache("_s", object(), "EXAMPLE", "k", own, temporary=True).route is None
def test_a_job_is_refused_for_a_key_with_its_own_identity(server, monkeypatch):
monkeypatch.setattr(handlers, "server_cdm_allowed", lambda request, service: True)
monkeypatch.setattr(handlers, "server_cdm_max_height", lambda request, service: None)
monkeypatch.setattr(handlers, "serve_user_config", lambda key: {"cdm": {"EXAMPLE": "own"}})
with pytest.raises(APIError, match="its own"):
handlers.enforce_download_gates({"service": "EXAMPLE"})
@pytest.mark.parametrize(
"user_cfg, problem",
[
({"services": {"EXAMPLE": {}}}, "list of service tags"),
({"cdm": "dev"}, "mapping of service tag"),
({"cdm": {"default": "dev"}}, "a key has no default entry"),
({"service_config": {"DEFAULT": {"device_id": "x"}}}, "a key has no default entry"),
({"cdm": {"EXAMPLE": {"widevine": "dev", "tiers": "x"}}}, "device name or a widevine/playready/default"),
({"cdm": {"EXAMPLE": "missing"}}, "no CDM device named 'missing'"),
({"service_config": {"EXAMPLE": "device_id"}}, "mapping of config key"),
],
)
def test_bad_key_config_is_refused_at_load(server, monkeypatch, user_cfg, problem):
monkeypatch.setattr(handlers.Services, "get_tags", staticmethod(lambda: ["EXAMPLE"]))
assert problem in handlers.key_config_error("serve.users.u", user_cfg)
def test_a_known_device_passes_validation(server, monkeypatch):
monkeypatch.setattr(handlers.Services, "get_tags", staticmethod(lambda: ["EXAMPLE"]))
monkeypatch.setattr(handlers, "detect_cdm_type", lambda name, cfg: "playready")
assert handlers.key_config_error("u", {"cdm": {"EXAMPLE": {"playready": "dev"}}, "service_config": {}}) is None
assert handlers.key_config_error("u", {"cdm": {"EXAMPLE": {"default": "dev"}}, "service_config": None}) is None
assert handlers.key_config_error("u", {"cdm": {"EXAMPLE": {"widevine": "dev"}}}) is not None
@pytest.mark.parametrize(
"server_cdm, sent, own, returned",
[
(True, {}, True, {"tokens", "keys/planted"}),
(False, {}, True, {"tokens", "keys/planted"}),
(False, {"cdm_type": "playready", "cdm_relay": True}, True, {"tokens", "keys/planted"}),
(False, {"cdm_type": "playready", "cdm_relay": True}, False, {"tokens", "keys/device1", "keys/planted"}),
],
)
def test_a_session_keeps_identity_keys_from_the_client_unless_the_identity_is_the_clients(
server, monkeypatch, server_cdm, sent, own, returned
):
class Service(_Service):
_input_bridge = log = cache = None
def authenticate(self, cookies, credential):
self.cache.get("keys/device1").set("identity")
self.cache.get("tokens").set("login")
user = {"service_config": {"EXAMPLE": {"device_id": "key"}}} if own else {}
text = base64.b64encode(zlib.compress(b'{"data": "x"}')).decode("ascii")
monkeypatch.setattr(handlers, "validate_service", lambda service, request=None: service)
monkeypatch.setattr(handlers, "resolve_handler_proxy", lambda *args: (None, []))
monkeypatch.setattr(handlers, "server_account_for", lambda *args: False)
monkeypatch.setattr(handlers, "serve_user_config", lambda key: user)
monkeypatch.setattr(handlers, "choose_session_cdm", lambda *args: (server_cdm, None))
monkeypatch.setattr(handlers.Services, "load", lambda service: Service)
monkeypatch.setattr(handlers, "create_service_instance", lambda *args, **kwargs: (Service(), None, None))
async def run():
data = {"service": "EXAMPLE", "title_id": "t", "cookies": "x", "cache": {"keys/planted": text}, **sent}
response = await handlers.session_create_handler(data)
session = get_session_store().peek(json.loads(response.body)["session_id"])
try:
for _ in range(250):
if session.auth_status != AuthStatus.AUTHENTICATING:
break
await asyncio.sleep(0.02)
return session, set(handlers.collect_cache_files(session.cache_tag))
finally:
await get_session_store().delete(session.session_id)
session, sent_back = asyncio.run(run())
assert session.user_config is user
assert sent_back == returned
def test_a_reload_checks_key_devices_against_the_new_config(server, monkeypatch):
monkeypatch.setattr(handlers.Services, "get_tags", staticmethod(lambda: ["EXAMPLE"]))
fresh = SimpleNamespace(remote_cdm=[{"name": "new_remote", "device_type": "PLAYREADY"}])
user = {"cdm": {"EXAMPLE": "new_remote"}}
assert handlers.key_config_error("u", user, fresh) is None
assert handlers.key_config_error("u", user) is not None
def test_a_block_value_reaches_only_plain_values_of_other_sections(server, monkeypatch):
base = {"p1": {"device_id": "p1", "headers": {"a": "b"}}, "device_key": "server"}
monkeypatch.setattr(handlers, "load_service_yaml", lambda service: json.loads(json.dumps(base)))
block = {"device_id": "key", "headers": {"c": "d"}, "device_key": {"nested": 1}}
merged = handlers.key_service_yaml("EXAMPLE", {"service_config": {"EXAMPLE": block}})
assert merged["p1"] == {"device_id": "key", "headers": {"a": "b"}}
assert merged["device_key"] == {"nested": 1}
def test_a_removed_key_loses_its_identity_cache(server):
handlers.keyed_cache("_s", _Service(), "EXAMPLE", "gone", {}, True).get("keys/device1").set("keys")
handlers.keyed_cache("_s", _Service(), "EXAMPLE", "kept", {}, True).get("keys/device1").set("keys")
handlers.drop_identity_cache({"gone"})
assert not (server / "_identity" / handlers.key_namespace("gone")).exists()
assert (server / "_identity" / handlers.key_namespace("kept")).exists()