diff --git a/unshackle/services/Netflix/MSL/__init__.py b/unshackle/services/Netflix/MSL/__init__.py index b549630..3b65d4d 100644 --- a/unshackle/services/Netflix/MSL/__init__.py +++ b/unshackle/services/Netflix/MSL/__init__.py @@ -129,20 +129,20 @@ class MSL: raise Exception("- No CDM available") cdm.parse_license(msl_keys.cdm_session, key_data["cdmkeyresponse"]) keys = cdm.get_keys(msl_keys.cdm_session) - cls.log.info(f"Keys: {keys}") + cls.log.debug(f"Keys: {keys}") encryption_key = MSL.get_widevine_key( kid=base64.b64decode(key_data["encryptionkeyid"]), keys=keys, permissions=["allow_encrypt", "allow_decrypt"] ) msl_keys.encryption = encryption_key - cls.log.info(f"Encryption key: {encryption_key}") + cls.log.debug(f"Encryption key: {encryption_key}") sign = MSL.get_widevine_key( kid=base64.b64decode(key_data["hmackeyid"]), keys=keys, permissions=["allow_sign", "allow_signature_verify"] ) - cls.log.info(f"Sign key: {sign}") + cls.log.debug(f"Sign key: {sign}") msl_keys.sign = sign elif scheme == KeyExchangeSchemes.AsymmetricWrapped: @@ -244,7 +244,7 @@ class MSL: @classmethod def get_widevine_key(cls, kid, keys: list[Key], permissions): - cls.log.info(f"KID: {Key.kid_to_uuid(kid)}") + cls.log.debug(f"KID: {Key.kid_to_uuid(kid)}") for key in keys: # cls.log.info(f"KEY: {key.kid_to_uuid}") if key.kid != Key.kid_to_uuid(kid): @@ -258,10 +258,10 @@ class MSL: return key.key return None - def send_message(self, endpoint, params, application_data, userauthdata=None): + def send_message(self, endpoint, params, application_data, userauthdata=None, headers=None, unwrap_result=True): message = self.create_message(application_data, userauthdata) - res = self.session.post(url=endpoint, data=message, params=params) - header, payload_data = self.parse_message(res.text) + res = self.session.post(url=endpoint, data=message, params=params, headers=headers) + header, payload_data = self.parse_message(res.text, unwrap_result=unwrap_result) if "errordata" in header: raise Exception( "- MSL response message contains an error: {}".format( @@ -302,7 +302,7 @@ class MSL: return message - def decrypt_payload_chunks(self, payload_chunks): + def decrypt_payload_chunks(self, payload_chunks, unwrap_result=True): """ Decrypt and extract data from payload chunks @@ -310,7 +310,6 @@ class MSL: :return: json object """ raw_data = "" - for payload_chunk in payload_chunks: # todo ; verify signature of payload_chunk["signature"] against payload_chunk["payload"] # expecting base64-encoded json string @@ -344,10 +343,12 @@ class MSL: self.log.critical(f"- {error}") raise Exception(f"- MSL response message contains an error: {error}") # sys.exit(1) + self.log.debug(f"Payload Chunks: {data}") + if unwrap_result: + return data["result"] + return data - return data["result"] - - def parse_message(self, message): + def parse_message(self, message, unwrap_result=True): """ Parse an MSL message into a header and list of payload chunks @@ -359,7 +360,7 @@ class MSL: header = parsed_message[0] encrypted_payload_chunks = parsed_message[1:] if len(parsed_message) > 1 else [] if encrypted_payload_chunks: - payload_chunks = self.decrypt_payload_chunks(encrypted_payload_chunks) + payload_chunks = self.decrypt_payload_chunks(encrypted_payload_chunks, unwrap_result=unwrap_result) else: payload_chunks = {} diff --git a/unshackle/services/Netflix/MSL/schemes/UserAuthentication.py b/unshackle/services/Netflix/MSL/schemes/UserAuthentication.py index 15dabb2..83f1a64 100644 --- a/unshackle/services/Netflix/MSL/schemes/UserAuthentication.py +++ b/unshackle/services/Netflix/MSL/schemes/UserAuthentication.py @@ -31,6 +31,19 @@ class UserAuthentication(MSLObject): } ) + @classmethod + def UserIDToken(cls, token_data, signature, master_token): + return cls( + scheme=UserAuthenticationSchemes.UserIDToken, + authdata={ + "useridtoken": { + "tokendata": token_data, + "signature": signature + }, + "mastertoken": master_token + } + ) + @classmethod def NetflixIDCookies(cls, netflixid, securenetflixid): """ diff --git a/unshackle/services/Netflix/MSL/schemes/__init__.py b/unshackle/services/Netflix/MSL/schemes/__init__.py index a1f61d7..08b4f97 100644 --- a/unshackle/services/Netflix/MSL/schemes/__init__.py +++ b/unshackle/services/Netflix/MSL/schemes/__init__.py @@ -15,6 +15,7 @@ class EntityAuthenticationSchemes(Scheme): class UserAuthenticationSchemes(Scheme): """https://github.com/Netflix/msl/wiki/User-Authentication-%28Configuration%29""" EmailPassword = "EMAIL_PASSWORD" + UserIDToken = "USER_ID_TOKEN" NetflixIDCookies = "NETFLIXID" diff --git a/unshackle/services/Netflix/__init__.py b/unshackle/services/Netflix/__init__.py index a4dc436..81a7420 100644 --- a/unshackle/services/Netflix/__init__.py +++ b/unshackle/services/Netflix/__init__.py @@ -20,6 +20,8 @@ from pymp4.parser import Box from pywidevine import PSSH, Cdm as WidevineCDM, DeviceTypes from pyplayready import PSSH as PlayReadyPSSH import requests +from Cryptodome.Cipher import AES +from Cryptodome.Util.Padding import unpad from langcodes import Language from unshackle.core.constants import AnyTrack @@ -60,6 +62,7 @@ class Netflix(Service): "es": "es-419", "pt": "pt-PT", } + ANDROID_CONFIG_ENDPOINT = "https://android.prod.ftl.netflix.com/nq/androidui/samurai/v1/config" @staticmethod @click.command(name="Netflix", short_help="https://netflix.com") @@ -481,14 +484,166 @@ class Netflix(Service): securenetflixid=cookie["SecureNetflixId"] ) else: - # Android like way login to Netflix using email and password if not self.credential: - raise Exception(" - Credentials are required for Android CDMs, and none were provided.") - self.userauthdata = UserAuthentication.EmailPassword( - email=self.credential.username, - password=self.credential.password + raise click.ClickException("Android sign-in requires credentials.") + self.userauthdata = self.get_android_userauthdata() + + def get_android_userauthdata(self) -> UserAuthentication: + token_cache = self.get_android_user_token_cache() + token_data = token_cache.data if token_cache and isinstance(token_cache.data, dict) else None + + if not token_data or not token_data.get("tokendata") or not token_data.get("signature"): + self.log.info("Requesting Android useridtoken") + token_data = self.fetch_android_user_id_token() + token_cache.set(token_data, expiration=self.resolve_android_token_expiration(token_data)) + else: + self.log.info("Using cached Android useridtoken") + + return UserAuthentication.UserIDToken( + token_data=token_data["tokendata"], + signature=token_data["signature"], + master_token=self.msl.keys.mastertoken + ) + + def get_android_user_token_cache(self): + return self.cache.get(f"ANDROID_USER_ID_TOKEN/{self.credential.sha1}/{self.esn.data['esn']}") + + def fetch_android_user_id_token(self) -> dict: + try: + header, payload_data = self.msl.send_message( + endpoint=self.ANDROID_CONFIG_ENDPOINT, + params=self.build_android_sign_in_query(), + application_data="", + headers=self.build_android_sign_in_headers(), + unwrap_result=False ) - self.log.info(f"userauthdata: {self.userauthdata}") + except Exception as exc: + raise click.ClickException(f"Android sign-in request failed: {exc}") from exc + header_data = self.decrypt_android_header(header["headerdata"]) + tokens = header_data.get("useridtoken") + if not tokens: + self.log.debug(f"Android sign-in header keys: {list(header_data.keys())}") + sign_in_value = self.extract_android_sign_in_value(payload_data) + error_code = self.extract_android_sign_in_error_code(sign_in_value) + if error_code: + raise click.ClickException(f"Android sign-in failed: {error_code}") + raise click.ClickException("Android sign-in did not return a useridtoken.") + return tokens + + @staticmethod + def extract_android_sign_in_value(payload_data: dict) -> Optional[dict]: + if not isinstance(payload_data, dict): + return None + json_graph = payload_data.get("jsonGraph") + if not isinstance(json_graph, dict): + return None + sign_in_verify = json_graph.get("signInVerify") + if not isinstance(sign_in_verify, dict): + return None + value = sign_in_verify.get("value") + return value if isinstance(value, dict) else None + + @staticmethod + def extract_android_sign_in_error_code(sign_in_value: Optional[dict]) -> Optional[str]: + if not isinstance(sign_in_value, dict): + return None + fields = sign_in_value.get("fields") + if not isinstance(fields, dict): + return None + error_code = fields.get("errorCode") + if not isinstance(error_code, dict): + return None + value = error_code.get("value") + return value if isinstance(value, str) and value else None + + def build_android_sign_in_query(self) -> dict: + cookie = self.session.cookies.get_dict() + return { + "api": "33", + "appType": "samurai", + "appVer": "62902", + "appVersion": "9.18.0", + "chipset": "sm6150", + "chipsetHardware": "qcom", + "clientAppState": "FOREGROUND", + "clientAppVersionState": "NORMAL", + "countryCode": "+385", + "countryIsoCode": "HR", + "ctgr": "phone", + "dbg": "false", + "deviceLocale": "hr", + "devmod": "samsung_SM-A705FN", + "ffbc": "phone", + "flwssn": "c3100219-d002-40c5-80a7-055c00407246", + "installType": "regular", + "isAutomation": "false", + "isConsumptionOnly": "true", + "isNetflixPreloaded": "false", + "isPlayBillingEnabled": "true", + "isStubInSystemPartition": "false", + "lackLocale": "false", + "landingOrigin": "https://www.netflix.com", + "mId": "SAMSUSM-A705FNS", + "memLevel": "HIGH", + "method": "get", + "mnf": "samsung", + "model": "SM-A705FN", + "netflixClientPlatform": "androidNative", + "netflixId": cookie["NetflixId"], + "networkType": "wifi", + "osBoard": "sm6150", + "osDevice": "a70q", + "osDisplay": "TQ1A.230205.002", + "password": self.credential.password, + "path": "[\"signInVerify\"]", + "pathFormat": "hierarchical", + "platform": "android", + "preloadSignupRoValue": "", + "progressive": "false", + "qlty": "hd", + "recaptchaResponseTime": 244, + "recaptchaResponseToken": "", + "responseFormat": "json", + "roBspVer": "Q6150-17263-1", + "secureNetflixId": cookie["SecureNetflixId"], + "sid": "7176", + "store": "google", + "userLoginId": self.credential.username + } + + def build_android_sign_in_headers(self) -> dict: + return { + "X-Netflix.Request.NqTracking": "VerifyLoginMslRequest", + "X-Netflix.Client.Request.Name": "VerifyLoginMslRequest", + "X-Netflix.Request.Client.Context": "{\"appState\":\"foreground\"}", + "X-Netflix-Esn": self.esn.data["esn"], + "X-Netflix.EsnPrefix": "NFANDROID1-PRV-P-", + "X-Netflix.msl-header-friendly-client": "true", + "content-encoding": "msl_v1" + } + + def decrypt_android_header(self, encrypted_header_b64: str) -> dict: + encrypted_header = json.loads(base64.b64decode(encrypted_header_b64)) + iv = base64.b64decode(encrypted_header["iv"]) + ciphertext = base64.b64decode(encrypted_header["ciphertext"]) + cipher = AES.new(self.msl.keys.encryption, AES.MODE_CBC, iv) + decrypted = unpad(cipher.decrypt(ciphertext), AES.block_size) + return json.loads(decrypted.decode("utf-8")) + + def resolve_android_token_expiration(self, token_data: dict): + for source in (token_data, self.msl.keys.mastertoken): + if not isinstance(source, dict): + continue + tokendata = source.get("tokendata") + if not tokendata: + continue + try: + parsed = json.loads(base64.b64decode(tokendata).decode("utf-8")) + except (TypeError, ValueError, json.JSONDecodeError): + continue + if parsed.get("expiration"): + return parsed["expiration"] + return None def get_profiles(self): diff --git a/unshackle/services/Netflix/config.yaml b/unshackle/services/Netflix/config.yaml index d904457..a872f28 100644 --- a/unshackle/services/Netflix/config.yaml +++ b/unshackle/services/Netflix/config.yaml @@ -11,12 +11,18 @@ certificate: | payload_challenge: "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" payload_challenge_pr: "<?xml version="1.0" encoding="utf-8"?><soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"><soap:Body><AcquireLicense xmlns="http://schemas.microsoft.com/DRM/2007/03/protocols"><challenge><Challenge xmlns="http://schemas.microsoft.com/DRM/2007/03/protocols/messages"><LA xmlns="http://schemas.microsoft.com/DRM/2007/03/protocols" Id="SignedData" xml:space="preserve"><Version>4</Version><ContentHeader><WRMHEADER xmlns="http://schemas.microsoft.com/DRM/2007/03/PlayReadyHeader" version="4.2.0.0"><DATA><PROTECTINFO><KIDS><KID ALGID="AESCTR" VALUE="AAAAAMYExIEAAAAAAAAAAA=="></KID></KIDS></PROTECTINFO><LA_URL>http://capprsvr06/silverlight5/rightsmanager.asmx</LA_URL><LUI_URL>http://capprsvr06/silverlight5/rightsmanager.asmx</LUI_URL><DECRYPTORSETUP>ONDEMAND</DECRYPTORSETUP></DATA></WRMHEADER></ContentHeader><CLIENTINFO><CLIENTVERSION>10.0.16384.10011</CLIENTVERSION></CLIENTINFO><LicenseNonce>2wpHvxrtvGAWMHf/UHGhdg==</LicenseNonce><ClientTime>1742927921</ClientTime><EncryptedData xmlns="http://www.w3.org/2001/04/xmlenc#" Type="http://www.w3.org/2001/04/xmlenc#Element"><EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes128-cbc"></EncryptionMethod><KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#"><EncryptedKey xmlns="http://www.w3.org/2001/04/xmlenc#"><EncryptionMethod Algorithm="http://schemas.microsoft.com/DRM/2007/03/protocols#ecc256"></EncryptionMethod><KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#"><KeyName>WMRMServer</KeyName></KeyInfo><CipherData><CipherValue>YlEXdgVUxlkbwigEGwDIBBFWiBybSgIDozY+G9x31xFGsnnyKJ9GBUdsHkzvHLiYFply25UJrvRUT7tOve96HriocKg+hHfp1WtOFhEjI2dXpyk4jfcKmCFiQ7w/LzCNPTVHAWIb4Yvg3lmqg6S5GWXIh08DZVwm7SV6d7GNbLQ=</CipherValue></CipherData></EncryptedKey></KeyInfo><CipherData><CipherValue>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</CipherValue></CipherData></EncryptedData></LA><Signature xmlns="http://www.w3.org/2000/09/xmldsig#"><SignedInfo xmlns="http://www.w3.org/2000/09/xmldsig#"><CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"></CanonicalizationMethod><SignatureMethod Algorithm="http://schemas.microsoft.com/DRM/2007/03/protocols#ecdsa-sha256"></SignatureMethod><Reference URI="#SignedData"><DigestMethod Algorithm="http://schemas.microsoft.com/DRM/2007/03/protocols#sha256"></DigestMethod><DigestValue>br1PtJ3OjeDZSJ8BXVLrydHfytZh8N7RENDBe2gLsVs=</DigestValue></Reference></SignedInfo><SignatureValue>SYIPsr443B4koBXhViEKqLYPsVM65Er0a27SA1VkxMnfwc300o7R+SmJFud540lMNx77/vPEBbZxuKeji5friw==</SignatureValue><KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#"><KeyValue><ECCKeyValue><PublicKey>Xo25Q2ub9RjCg6mZyGGXzZd/6GlWS6JmuxttF/oYyDywe7M4fbnC6s8AVjwe/n/9uBjINCthICqkixZliKl7qA==</PublicKey></ECCKeyValue></KeyValue></KeyInfo></Signature></Challenge></challenge></AcquireLicense></soap:Body></soap:Envelope>" +playready_esn: "NFANDROID2-PRV-REFPLUSCOQ4KT51PGTV-MGK000000043430" +playready_kdekdh: + - "5VMBpSpvyiwQPdaZ99PX6Q==" + - "u8ldDaWPL7kFW7hkc84/QN4yDxnbeHAw13Uk7uu50EE=" + esn_map: # key map of CDM WVD `SystemID = 'ESN you want to use for that CDM WVD'` 8159: "NFANDROID1-PRV-P-GOOGLEPIXEL" 8131: "HISETVK84500000000000000000000000007401422" - 22590: "NFANDROID1-PXA-P-L3-XIAOMM2102J20SG-22590-0202084EBTP55D0HO2TOCSM3VR9MOSTTJT2L97EKVN9E8PFA1QQ439QC70QTTTV82LC7KUSD3O0HUB0HKH51DH0N7A7GFJKSJ5S6FFE0" + 22590: "NFANDROID1-PXA-P-L3-XIAOMM2102J20SG-22590-020NTB086HJPGG70MDDMR0306MR0NNO5G3DJGFCKS9HJF58ER9QA21VFG4I0246JRN6TF16L9I627EPK708SH42UUMG1ASFVG20F3" 12063: "NFANDROID1-PRV-P-SHENZHENKTC-49B1U-12063-2PAENERYJWY35H7F24163TMUCBBA4VRHQ2XZX4OBU4MUTKYFW50BMFBVGTUMN6IM0" + 7110: "NFANDROID1-PRV-P-MSD6886602GUHDANDROIDTV-HISENHISMARTTV-A4-7110-D34E1ECACCDBE518DBA0CCE8A4D1D48248ACB5C1A2BAEB2ADFF1040C5AE3FF42" endpoints: website: "https://www.netflix.com/nq/website/memberapi/{build_id}/pathEvaluator" manifest: "https://www.netflix.com/msl/playapi/cadmium/licensedmanifest/1" @@ -27,7 +33,7 @@ endpoints: configuration: drm_system: "widevine" # chrome and android: widevine, edge: playready - drm_version: 30 # widevine: 25, playready: 30 + drm_version: 25 # widevine: 25, playready: 30 supported_hdcp_versions: ["2.2"] # 720p-max: 1.4, chrome: empty, 4k: 2.2 is_hdcp_engaged: false # chrome: false diff --git a/unshackle/unshackle.yaml b/unshackle/unshackle.yaml index 8b54828..df50b84 100644 --- a/unshackle/unshackle.yaml +++ b/unshackle/unshackle.yaml @@ -64,7 +64,7 @@ directories: cache: Cache # cookies: Cookies dcsl: DCSL # Device Certificate Status List - downloads: Downloads + downloads: /home/kenzuya/Mounts/ketuakenzuya/Downloads/ logs: Logs temp: Temp # wvds: WVDs @@ -79,7 +79,7 @@ directories: # Pre-define which Widevine or PlayReady device to use for each Service cdm: # Global default CDM device (fallback for all services/profiles) - default: chromecdm + default: lg_50ut73006la.cekukh_17.0.0_22163355_7110_l1 # Direct service-specific CDM DIFFERENT_EXAMPLE: PRD_1