X-Git-Url: https://code.delx.au/youtube-cgi/blobdiff_plain/7ee672be8998bfa85a8552f0e9c129d241e11f50..03c05f9c858e46d6caa63d4ca465375e153494ca:/youtube.cgi

diff --git a/youtube.cgi b/youtube.cgi
index ef7b608..33bb29a 100755
--- a/youtube.cgi
+++ b/youtube.cgi
@@ -148,26 +148,44 @@ def extract_js(script):
 
     return script[len(PREFIX):-len(SUFFIX)]
 
-def find_func_name(script):
+def find_cipher_func(script):
     FUNC_NAME = R"([a-zA-Z0-9$]+)"
+    DECODE_URI_COMPONENT = R"(\(decodeURIComponent)?"
     FUNC_PARAMS = R"(\([a-zA-Z,\.]+\.s\))"
     TERMINATOR = R"[,;\)]"
-    PATTERN = FUNC_NAME + FUNC_PARAMS + TERMINATOR
+    PATTERN = FUNC_NAME + DECODE_URI_COMPONENT + FUNC_PARAMS + TERMINATOR
 
     match = re.search(PATTERN, script)
     func_name = match.groups()[0]
     return func_name
 
-def decode_signature(js_url, signature):
+def find_url_func(script):
+    FUNC_NAME = R"([a-zA-Z0-9$]+)"
+    PATTERN = R"this\.url\s*=\s*" + FUNC_NAME + R"\s*\(\s*this\s*\)"
+
+    match = re.search(PATTERN, script)
+    func_name = match.groups()[0]
+    return func_name
+
+def decode_cipher_url(js_url, cipher):
+    cipher = urllib.parse.parse_qs(cipher)
+    args = [
+        cipher["url"][0],
+        cipher["sp"][0],
+        cipher["s"][0],
+    ]
+
     f = urlopen(js_url)
     script = f.read().decode("utf-8")
     f.close()
 
-    func_name = find_func_name(script)
+    cipher_func_name = find_cipher_func(script)
+    url_func_name = find_url_func(script)
 
     params = {
-        "func_name": func_name,
-        "signature": json.dumps(signature),
+        "cipher_func_name": cipher_func_name,
+        "url_func_name": url_func_name,
+        "args": json.dumps(args),
         "code": json.dumps(extract_js(script)),
     }
     p = subprocess.Popen(
@@ -180,72 +198,62 @@ def decode_signature(js_url, signature):
     js_decode_script = ("""
         const vm = require('vm');
 
-        const sandbox = {
-            location: {
-                hash: '',
-                href: '',
-                protocol: 'http:'
-            },
-            history: {
-                pushState: function(){}
-            },
-            document: {},
-            navigator: {
-                userAgent: ''
-            },
-            XMLHttpRequest: class XMLHttpRequest {},
-            matchMedia: () => ({matches: () => {}, media: ''}),
-            signature: %(signature)s,
-            transformed_signature: null,
-            g: function(){} // this is _yt_player
+        const fakeGlobal = {};
+        fakeGlobal.window = fakeGlobal;
+        fakeGlobal.location = {
+            hash: '',
+            host: 'www.youtube.com',
+            hostname: 'www.youtube.com',
+            href: 'https://www.youtube.com',
+            origin: 'https://www.youtube.com',
+            pathname: '/',
+            protocol: 'https:'
+        };
+        fakeGlobal.history = {
+            pushState: function(){}
         };
-        sandbox.window = sandbox;
+        fakeGlobal.document = {
+            location: fakeGlobal.location
+        };
+        fakeGlobal.document = {};
+        fakeGlobal.navigator = {
+            userAgent: ''
+        };
+        fakeGlobal.XMLHttpRequest = class XMLHttpRequest {};
+        fakeGlobal.matchMedia = () => ({matches: () => {}, media: ''});
+        fakeGlobal.result_url = null;
+        fakeGlobal.g = function(){}; // this is _yt_player
 
         const code_string = %(code)s + ';';
-        const exec_string = 'transformed_signature = %(func_name)s("", "MARKER", signature);';
-        vm.runInNewContext(code_string + exec_string, sandbox);
-
-        function findSignature(obj) {
-            if (typeof obj !== 'object') {
-                return;
-            }
-            for (const [key, value] of Object.entries(obj)) {
-                if (key === 'MARKER') {
-                    return value;
-                }
-                const result = findSignature(value);
-                if (result) {
-                    return result;
-                }
-            }
-        }
-        console.log(findSignature(sandbox.transformed_signature));
+        const exec_string = 'result_url = %(url_func_name)s(%(cipher_func_name)s(...%(args)s));';
+        vm.runInNewContext(code_string + exec_string, fakeGlobal);
+
+        console.log(fakeGlobal.result_url);
     """ % params)
 
     p.stdin.write(js_decode_script.encode("utf-8"))
     p.stdin.close()
 
-    transformed_signature = p.stdout.read().decode("utf-8").strip()
-    transformed_signature = urllib.parse.unquote(transformed_signature)
+    result_url = p.stdout.read().decode("utf-8").strip()
     if p.wait() != 0:
         raise Exception("js failed to execute: %d" % p.returncode)
 
-    return transformed_signature
+    return result_url
 
 def get_best_video(player_config):
-    url_data_list = player_config["args"]["url_encoded_fmt_stream_map"].split(",")
     js_url = player_config["assets"]["js"]
 
+    player_args = player_config["args"]
+    player_response = json.loads(player_args["player_response"])
+    formats = player_response["streamingData"]["formats"]
+
     best_url = None
     best_quality = None
     best_extension = None
-    for url_data in url_data_list:
-        url_data = urllib.parse.parse_qs(url_data)
-        mimetype = url_data["type"][0].split(";")[0]
-        quality = url_data["quality"][0]
+    for format_data in formats:
+        mimetype = format_data["mimeType"].split(";")[0]
+        quality = format_data["quality"]
 
-        if "stereo3d" in url_data:
-            continue
         if quality not in QUALITIES:
             continue
         if mimetype not in MIMETYPES:
@@ -257,17 +265,10 @@ def get_best_video(player_config):
         if best_quality is not None and quality < best_quality:
             continue
 
-        video_url = url_data["url"][0]
-        if "sig" in url_data:
-            signature = url_data["sig"][0]
-        elif "s" in url_data:
-            signature = decode_signature(js_url, url_data["s"][0])
+        if "signatureCipher" in format_data:
+            video_url = decode_cipher_url(js_url, format_data["signatureCipher"])
         else:
-            signature = None
-
-        if signature:
-            sp = url_data.get("sp", ["signature"])[0]
-            video_url = append_to_qs(video_url, {sp: signature})
+            video_url = format_data["url"]
 
         best_url = video_url
         best_quality = quality