From 46fb3e7adfccd9c78c62831524ed85e66c430053 Mon Sep 17 00:00:00 2001 From: chu23465 <130033130+chu23465@users.noreply.github.com> Date: Tue, 29 Apr 2025 12:35:39 +0530 Subject: [PATCH] Netflix changes, add delay for subs --- vinetrimmer/commands/dl.py | 2 + vinetrimmer/config/Services/netflix.yml | 2 +- vinetrimmer/key_store.db | Bin 409600 -> 430080 bytes vinetrimmer/services/netflix.py | 3 +- vinetrimmer/utils/MSL/__init__.py | 2 +- vinetrimmer/utils/gen_esn.py | 92 +++++++++++++++++++++++- 6 files changed, 96 insertions(+), 5 deletions(-) diff --git a/vinetrimmer/commands/dl.py b/vinetrimmer/commands/dl.py index da9b9c8..859a330 100644 --- a/vinetrimmer/commands/dl.py +++ b/vinetrimmer/commands/dl.py @@ -505,6 +505,8 @@ def result(ctx, service, quality, closest_resolution, range_, wanted, alang, sla if service: save_cookies(service_name, service, ctx.obj.profile) + if isinstance(track, TextTrack): + time.sleep(5) # Sleep 5 seconds before downloading each subtitle track to avoid 403 errors track.download(directories.temp, headers=service.session.headers, proxy=proxy) log.info(" + Downloaded") if isinstance(track, VideoTrack) and track.needs_ccextractor_first and not no_subs: diff --git a/vinetrimmer/config/Services/netflix.yml b/vinetrimmer/config/Services/netflix.yml index 4fe4650..fd56a0d 100644 --- a/vinetrimmer/config/Services/netflix.yml +++ b/vinetrimmer/config/Services/netflix.yml @@ -9,7 +9,7 @@ certificate: | p+itdt3a9mVFc7/ZL4xpraYdQvOwP5LmXj9galK3s+eQJ7bkX6cCi+2X+iBmCMx4R0XJ3/1gxiM5LiStibCnfInub1nNgJDojxFA3jH/IuUcblEf/5Y0s 1SzokBnR8V0KbA== -payload_challenge: "<?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><RevocationLists><RevListInfo><ListID>ioydTlK2p0WXkWklprR5Hw==</ListID><Version>13</Version></RevListInfo><RevListInfo><ListID>gC4IKKPHsUCCVhnlttibJw==</ListID><Version>11</Version></RevListInfo><RevListInfo><ListID>Ef/RUojT3U6Ct2jqTCChbA==</ListID><Version>70</Version></RevListInfo></RevocationLists><LicenseNonce>snAUgsivzobn5NLm0InhPw==</LicenseNonce><ClientTime>1697307765</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>FcA7KarXYLJZhV1hBAfB9hNhtXvEQHsocesGumfJPQBqG//rTad3p8lKBAddm8fpMDniyzSr9FD59AHIFE9d7o8vsq8PQLYVLic7sI6AIdzPJEE/fbKYKMGlxXJvQvfnGTOEGKrx3zZWcLALQi1RG0DmAvlRwtwG9dSF/g52abY=</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>LwV27DMVLcMzs4q0kbqVBDyXdVENSq1qKuJ/1VUCx9s=</DigestValue></Reference></SignedInfo><SignatureValue>ynPo1yJ7XTpXh1ZGtwNIKsxaY4wtwbxr2P87W70417odNyunpQv4upIIFhOA2xFDoRCBDvAV3A42oSR77HNNqA==</SignatureValue><KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#"><KeyValue><ECCKeyValue><PublicKey>WcrUewuBD+MOkh16EtbfNC/ZoVJ39csFqRT4AQZaIv5duwaf1fs4tjzsIiOA9ceEHTKY3eLJBVW4+TXkGTl4IA==</PublicKey></ECCKeyValue></KeyValue></KeyInfo></Signature></Challenge></challenge></AcquireLicense></soap:Body></soap:Envelope>" +payload_challenge: "<?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>3.0.0.4019</CLIENTVERSION></CLIENTINFO><RevocationLists><RevListInfo><ListID>ioydTlK2p0WXkWklprR5Hw==</ListID><Version>14</Version></RevListInfo><RevListInfo><ListID>Ef/RUojT3U6Ct2jqTCChbA==</ListID><Version>76</Version></RevListInfo></RevocationLists><LicenseNonce>ovn5nizFQhbVTq1Iy5YNcg==</LicenseNonce><ClientTime>1723790009</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>S7vPFtGTTO+0EFx6NQlvJcBzrb4pRGWP3XwgMDcUSOvzx0i316I/s+wzspLPwypzBAszk0xr8vHzjAOJk98BNZreWy5ACOQ8gC1eecBWqBo9pFAFU1csLlhefrhfjqBvhGEKuEU7jOtNjqgv8pT9XG6WTF5hGxGoM+JLhFFwmIg=</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>VjEjLfehEpIpUCEwlFlZRd95LeofO1bbLf+af62Iujw=</DigestValue></Reference></SignedInfo><SignatureValue>gNyenodbOZaoxKVifbuZ6IQnCmg5U1rmzcZwdDg01/0lFQVJ5MkdyKrH6Zov8wnSiRSVAXJTmK9u0DorXtABaA==</SignatureValue><KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#"><KeyValue><ECCKeyValue><PublicKey>GOYVnn5+JE5UrQ6fcmCbK7EGA7mvidJt7aaCYjhnqZ3NZjU4Zf44jK3s37oRDP2JpJyGw59Olx2YfML32fkxxg==</PublicKey></ECCKeyValue></KeyValue></KeyInfo></Signature></Challenge></challenge></AcquireLicense></soap:Body></soap:Envelope>" esn_map: diff --git a/vinetrimmer/key_store.db b/vinetrimmer/key_store.db index a7581279fd6df8cfd3a88bdc9b153614329353cf..6eecdeca4c7fc0a57ba675e438b3dcc1609ececc 100644 GIT binary patch delta 464 zcmZo@kZf2WH9=bND+2>VCJ@5_$3z`t;javO$&9Q(Ax8e+Ac;)=-xG_}*cewZRx(yj zR&=<{rYp%N?kGLEkXb@JFSR5sC$l2n2+By;m4L|!!sHC0jI_%?qbsFj-)9qbu_qHH#V?G(kZlQWd{ z-sank_ZV3?Lz(|<-pl+H#9|WOyo_}{GaLU827QRBn~OPn*_3#Jj^kzj%D{h-PlNX} z?>-)N?tk1@xg5EqI6rd)bEvR?1-j-kJCPyajNzJQS#fr8X=%nb!IH$JoK&bhluC6D za&-)GRS0o(@^Mvw3U2<$na4Oeo7sQ!4aUiglLJ_TH}7Je#yHuVJ$v(F))kDCLpk*U DDRPKf delta 90 zcmZozAl1+yIYCp k3ghN%<_SEk93b^g0&N0}Z30Yf0?cg!ENud;%LLdA0HH?{>Hq)$ diff --git a/vinetrimmer/services/netflix.py b/vinetrimmer/services/netflix.py index 78bf9ba..2020a04 100644 --- a/vinetrimmer/services/netflix.py +++ b/vinetrimmer/services/netflix.py @@ -18,7 +18,6 @@ from vinetrimmer.utils.MSL import MSL from vinetrimmer.utils.MSL.schemes import KeyExchangeSchemes, EntityAuthenticationSchemes from vinetrimmer.utils.MSL.schemes.UserAuthentication import UserAuthentication from vinetrimmer.utils.gen_esn import chrome_esn_generator, android_esn_generator, playready_esn_generator -from vinetrimmer.utils.widevine.device import LocalDevice, RemoteDevice from vinetrimmer.vendor.pymp4.parser import Box from vinetrimmer.utils.gen_esn import chrome_esn_generator @@ -185,7 +184,7 @@ class Netflix(BaseService): is_android_l3 = False try: if hasattr(self.cdm, 'device') and hasattr(self.cdm.device, 'security_level') and hasattr(self.cdm.device, 'type'): - is_android_l3 = (self.cdm.device.security_level == 3 and self.cdm.device.type == LocalDevice.Types.ANDROID) + is_android_l3 = (self.cdm.device.security_level == 3 and self.cdm.device.type == DeviceTypes.ANDROID) except AttributeError: pass diff --git a/vinetrimmer/utils/MSL/__init__.py b/vinetrimmer/utils/MSL/__init__.py index 4d57a81..021892e 100644 --- a/vinetrimmer/utils/MSL/__init__.py +++ b/vinetrimmer/utils/MSL/__init__.py @@ -26,7 +26,6 @@ from vinetrimmer.utils.MSL.schemes import KeyExchangeSchemes from vinetrimmer.utils.MSL.schemes.EntityAuthentication import EntityAuthentication from vinetrimmer.utils.MSL.schemes.PlayReadyKeyExchangeScheme import PlayReady as PlayReadyScheme from vinetrimmer.utils.MSL.schemes.KeyExchangeRequest import KeyExchangeRequest -from vinetrimmer.utils.widevine.device import RemoteDevice from vinetrimmer.utils.gen_esn import chrome_esn_generator, android_esn_generator, playready_esn_generator from requests.adapters import HTTPAdapter from requests.packages.urllib3.poolmanager import PoolManager @@ -194,6 +193,7 @@ class MSL: key_data = key_response_data["keydata"] if scheme == KeyExchangeSchemes.Widevine: + from vinetrimmer.utils.widevine.device import RemoteDevice if isinstance(cdm.device, RemoteDevice): msl_keys.encryption, msl_keys.sign = cdm.device.exchange( cdm.sessions[msl_keys.cdm_session], diff --git a/vinetrimmer/utils/gen_esn.py b/vinetrimmer/utils/gen_esn.py index e01e112..7131a5f 100644 --- a/vinetrimmer/utils/gen_esn.py +++ b/vinetrimmer/utils/gen_esn.py @@ -52,4 +52,94 @@ def edge_esn_generator(): with open(esn_file, 'r') as f: esn = f.read() - return esn \ No newline at end of file + return esn + + +def playready_esn_generator(): + # Lista di modelli di TV e dispositivi PlayReady + tv_models = [ + "HE55A7000EUWTS", # Hisense + "KD55X85J", # Sony + "UN55TU7000", # Samsung + "OLED55C1", # LG + "55PUS7805", # Philips + "55R635", # TCL + "L55M5-Z2", # Xiaomi + ] + + # Lista di produttori + manufacturers = [ + "HISENSE", + "SONY", + "SAMSUNG", + "LG", + "PHILIPS", + "TCL", + "XIAOMI" + ] + + # Scegli un produttore e un modello casualmente + manufacturer = random.choice(manufacturers) + model = random.choice(tv_models) + + esn_file = '.esn_playready' + + def gen_file(): + # Crea un ESN nel formato NFANDROID1-PRN-[MANUFACTURER]-[MODEL] + esn = f"NFANDROID1-PRN-{manufacturer}-{model}" + with open(esn_file, 'w') as file: + file.write(esn) + + if not os.path.isfile(esn_file): + log.warning("Generating a new PlayReady ESN") + gen_file() + + file_datetime = datetime.fromtimestamp(os.path.getmtime(esn_file)) + time_diff = datetime.now() - file_datetime + if time_diff > timedelta(hours=6): + log.warning("Old ESN detected, Generating a new PlayReady ESN") + gen_file() + + with open(esn_file, 'r') as f: + esn = f.read() + + return esn + +def android_esn_generator(): + # Parametri per dispositivi Android + manufacturers = ["SAMSUNG", "ONEPLUS", "XIAOMI", "MOTOROLA", "GOOGLE", "NVIDIA"] + models = [ + "SM-T865", "SM-G975F", "SM-N975F", # Samsung + "IN2020", "KB2000", "LE2100", # OnePlus + "M2007J3SG", "M2004J19C", "M2102J20SG", # Xiaomi + "Pixel 5", "Pixel 6 Pro", "Pixel 7", # Google + "SHIELD Android TV", "SHIELD Pro" # NVIDIA + ] + + # Genera una stringa casuale alfanumerica per l'ID del dispositivo + device_id = "".join(random.choice("0123456789ABCDEF") for _ in range(16)) + + esn_file = '.esn_android' + + def gen_file(): + manufacturer = random.choice(manufacturers) + model = random.choice(models) + # Formato ESN per Android: NFANDROID1-PRV-[build info]-[device ID]-[model] + esn = f"NFANDROID1-PRV-{manufacturer[:4]}{random.randint(1000,9999)}-{device_id}-{model}" + with open(esn_file, 'w') as file: + file.write(esn) + + if not os.path.isfile(esn_file): + log.warning("Generating a new Android ESN") + gen_file() + + file_datetime = datetime.fromtimestamp(os.path.getmtime(esn_file)) + time_diff = datetime.now() - file_datetime + if time_diff > timedelta(hours=6): + log.warning("Old ESN detected, Generating a new Android ESN") + gen_file() + + with open(esn_file, 'r') as f: + esn = f.read() + + return esn