[YouTube] Fix buffering by decoding n parameter of stream urls

extractor/src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeJavaScriptExtractor.java

@@ -0,0 +1,105 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
+import org.schabi.newpipe.extractor.NewPipe;
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.localization.Localization;
+import org.schabi.newpipe.extractor.utils.Parser;
+
+import javax.annotation.Nonnull;
+
+/**
+ * YouTube restricts streaming their media in multiple ways by requiring clients to apply a cipher function
+ * on parameters of requests.
+ * The cipher function is sent alongside as a JavaScript function.
+ * <p>
+ * This class handling fetching the JavaScript file in order to allow other classes to extract the needed functions.
+ */
+public class YoutubeJavaScriptExtractor {
+
+    private static final String HTTPS = "https:";
+    private static String cachedJavaScriptCode;
+
+    private YoutubeJavaScriptExtractor() {
+    }
+
+    /**
+     * Extracts the JavaScript file. The result is cached, so subsequent calls use the result of previous calls.
+     *
+     * @param videoId Does not influence the result, but a valid video id may help in the chance that YouTube tracks it.
+     * @return The whole javascript file as a string.
+     * @throws ParsingException If the extraction failed.
+     */
+    @Nonnull
+    public static String extractJavaScriptCode(String videoId) throws ParsingException {
+        if (cachedJavaScriptCode == null) {
+            final String playerJsUrl = YoutubeJavaScriptExtractor.cleanJavaScriptUrl(
+                    YoutubeJavaScriptExtractor.extractJavaScriptUrl(videoId));
+            cachedJavaScriptCode = YoutubeJavaScriptExtractor.downloadJavaScriptCode(playerJsUrl);
+        }
+
+        return cachedJavaScriptCode;
+    }
+
+    /**
+     * Same as {@link YoutubeJavaScriptExtractor#extractJavaScriptCode(String)} but with a constant value for videoId.
+     * Possible because the videoId has no influence on the result.
+     * <p>
+     * In the off chance that YouTube tracks with which video id the request is made, it may make sense to pass in
+     * video ids.
+     */
+    @Nonnull
+    public static String extractJavaScriptCode() throws ParsingException {
+        return extractJavaScriptCode("d4IGg5dqeO8");
+    }
+
+    private static String extractJavaScriptUrl(String videoId) throws ParsingException {
+        try {
+            final String embedUrl = "https://www.youtube.com/embed/" + videoId;
+            final String embedPageContent = NewPipe.getDownloader()
+                    .get(embedUrl, Localization.DEFAULT).responseBody();
+
+            try {
+                final String assetsPattern = "\"assets\":.+?\"js\":\\s*(\"[^\"]+\")";
+                return Parser.matchGroup1(assetsPattern, embedPageContent)
+                        .replace("\\", "").replace("\"", "");
+            } catch (final Parser.RegexException ex) {
+                // playerJsUrl is still available in the file, just somewhere else TODO
+                // it is ok not to find it, see how that's handled in getDeobfuscationCode()
+                final Document doc = Jsoup.parse(embedPageContent);
+                final Elements elems = doc.select("script").attr("name", "player_ias/base");
+                for (final Element elem : elems) {
+                    if (elem.attr("src").contains("base.js")) {
+                        return elem.attr("src");
+                    }
+                }
+            }
+
+        } catch (final Exception i) {
+            throw new ParsingException("Embedded info did not provide YouTube player js url");
+        }
+        throw new ParsingException("Embedded info did not provide YouTube player js url");
+    }
+
+    private static String cleanJavaScriptUrl(String playerJsUrl) {
+        if (playerJsUrl.startsWith("//")) {
+            return HTTPS + playerJsUrl;
+        } else if (playerJsUrl.startsWith("/")) {
+            // sometimes https://www.youtube.com part has to be added manually
+            return HTTPS + "//www.youtube.com" + playerJsUrl;
+        } else {
+            return playerJsUrl;
+        }
+    }
+
+    private static String downloadJavaScriptCode(String playerJsUrl) throws ParsingException {
+        try {
+            return NewPipe.getDownloader().get(playerJsUrl, Localization.DEFAULT).responseBody();
+        } catch (Exception e) {
+            throw new ParsingException("Could not get player js code from url: " + playerJsUrl);
+        }
+    }
+}

extractor/src/main/java/org/schabi/newpipe/extractor/services/youtube/YoutubeThrottlingDecrypter.java

@@ -0,0 +1,95 @@
+package org.schabi.newpipe.extractor.services.youtube;
+
+import org.schabi.newpipe.extractor.exceptions.ParsingException;
+import org.schabi.newpipe.extractor.utils.JavaScript;
+import org.schabi.newpipe.extractor.utils.Parser;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * <p>
+ * YouTube's media is protected with a cipher, which modifies the "n" query parameter of it's video playback urls.
+ * This class handles extracting that "n" query parameter, applying the cipher on it and returning the resulting url
+ * which is not throttled.
+ * </p>
+ *
+ * <p>
+ * https://r5---sn-4g5ednsz.googlevideo.com/videoplayback?n=VVF2xyZLVRZZxHXZ&other=other
+ * </p>
+ * becomes
+ * <p>
+ * https://r5---sn-4g5ednsz.googlevideo.com/videoplayback?n=iHywZkMipkszqA&other=other
+ * </p>
+ */
+public class YoutubeThrottlingDecrypter {
+
+    private static final String N_PARAM_REGEX = "[&?]n=([^&]+)";
+    private static final Map<String, String> nParams = new HashMap<>();
+
+    private final String functionName;
+    private final String function;
+
+    /**
+     * <p>
+     * Use this if you care about the off chance that YouTube tracks with which videoId the cipher is requested.
+     * </p>
+     * Otherwise use the no-arg constructor which uses a constant value.
+     */
+    public YoutubeThrottlingDecrypter(String videoId) throws ParsingException {
+        final String playerJsCode = YoutubeJavaScriptExtractor.extractJavaScriptCode(videoId);
+
+        functionName = parseDecodeFunctionName(playerJsCode);
+        function = parseDecodeFunction(playerJsCode, functionName);
+    }
+
+    public YoutubeThrottlingDecrypter() throws ParsingException {
+        final String playerJsCode = YoutubeJavaScriptExtractor.extractJavaScriptCode();
+
+        functionName = parseDecodeFunctionName(playerJsCode);
+        function = parseDecodeFunction(playerJsCode, functionName);
+    }
+
+    private String parseDecodeFunctionName(String playerJsCode) throws Parser.RegexException {
+        Pattern pattern = Pattern.compile("b=a\\.get\\(\"n\"\\)\\)&&\\(b=(\\w+)\\(b\\),a\\.set\\(\"n\",b\\)");
+        return Parser.matchGroup1(pattern, playerJsCode);
+    }
+
+    private String parseDecodeFunction(String playerJsCode, String functionName) throws Parser.RegexException {
+        Pattern functionPattern = Pattern.compile(functionName + "=function(.*?;)\n", Pattern.DOTALL);
+        return  "function " + functionName + Parser.matchGroup1(functionPattern, playerJsCode);
+    }
+
+    public String apply(String url) throws Parser.RegexException {
+        if (containsNParam(url)) {
+            String oldNParam = parseNParam(url);
+            String newNParam = decryptNParam(oldNParam);
+            return replaceNParam(url, oldNParam, newNParam);
+        } else {
+            return url;
+        }
+    }
+
+    private boolean containsNParam(String url) {
+        return Parser.isMatch(N_PARAM_REGEX, url);
+    }
+
+    private String parseNParam(String url) throws Parser.RegexException {
+        Pattern nValuePattern = Pattern.compile(N_PARAM_REGEX);
+        return Parser.matchGroup1(nValuePattern, url);
+    }
+
+    private String decryptNParam(String nParam) {
+        if (nParams.containsKey(nParam)) {
+            return nParams.get(nParam);
+        }
+        final String decryptedNParam = JavaScript.run(function, functionName, nParam);
+        nParams.put(nParam, decryptedNParam);
+        return decryptedNParam;
+    }
+
+    private String replaceNParam(String url, String oldValue, String newValue) {
+        return url.replace(oldValue, newValue);
+    }
+}

extractor/src/main/java/org/schabi/newpipe/extractor/services/youtube/extractors/YoutubeStreamExtractor.java

@@ -4,10 +4,6 @@
 import com.grack.nanojson.JsonObject;
 import com.grack.nanojson.JsonParser;
 import com.grack.nanojson.JsonParserException;
-import org.jsoup.Jsoup;
-import org.jsoup.nodes.Document;
-import org.jsoup.nodes.Element;
-import org.jsoup.select.Elements;
 import org.mozilla.javascript.Context;
 import org.mozilla.javascript.Function;
 import org.mozilla.javascript.ScriptableObject;
@@ -24,7 +20,9 @@
 import org.schabi.newpipe.extractor.localization.TimeAgoParser;
 import org.schabi.newpipe.extractor.localization.TimeAgoPatternsManager;
 import org.schabi.newpipe.extractor.services.youtube.ItagItem;
+import org.schabi.newpipe.extractor.services.youtube.YoutubeJavaScriptExtractor;
 import org.schabi.newpipe.extractor.services.youtube.YoutubeParsingHelper;
+import org.schabi.newpipe.extractor.services.youtube.YoutubeThrottlingDecrypter;
 import org.schabi.newpipe.extractor.services.youtube.linkHandler.YoutubeChannelLinkHandlerFactory;
 import org.schabi.newpipe.extractor.stream.*;
 import org.schabi.newpipe.extractor.utils.JsonUtils;
@@ -79,13 +77,10 @@ public static class DeobfuscateException extends ParsingException {
 
     @Nullable
     private static String cachedDeobfuscationCode = null;
-    @Nullable
-    private String playerJsUrl = null;
-
-    private JsonArray initialAjaxJson;
-    private JsonObject initialData;
     @Nonnull
     private final Map<String, String> videoInfoPage = new HashMap<>();
+    private JsonArray initialAjaxJson;
+    private JsonObject initialData;
     private JsonObject playerResponse;
     private JsonObject videoPrimaryInfoRenderer;
     private JsonObject videoSecondaryInfoRenderer;
@@ -525,11 +520,15 @@ public List<AudioStream> getAudioStreams() throws ExtractionException {
     public List<VideoStream> getVideoStreams() throws ExtractionException {
         assertPageFetched();
         final List<VideoStream> videoStreams = new ArrayList<>();
+        final YoutubeThrottlingDecrypter throttlingDecrypter = new YoutubeThrottlingDecrypter(getId());
 
         try {
             for (final Map.Entry<String, ItagItem> entry : getItags(FORMATS, ItagItem.ItagType.VIDEO).entrySet()) {
                 final ItagItem itag = entry.getValue();
-                final VideoStream videoStream = new VideoStream(entry.getKey(), false, itag);
+                String url = entry.getKey();
+                url = throttlingDecrypter.apply(url);
+
+                final VideoStream videoStream = new VideoStream(url, false, itag);
                 if (!Stream.containSimilarStream(videoStream, videoStreams)) {
                     videoStreams.add(videoStream);
                 }
@@ -797,38 +796,6 @@ private void fetchVideoInfoPage() throws ParsingException, ReCaptchaException, I
         }
     }
 
-    @Nonnull
-    private String getEmbeddedInfoStsAndStorePlayerJsUrl() {
-        try {
-            final String embedUrl = "https://www.youtube.com/embed/" + getId();
-            final String embedPageContent = NewPipe.getDownloader()
-                    .get(embedUrl, getExtractorLocalization()).responseBody();
-
-            try {
-                final String assetsPattern = "\"assets\":.+?\"js\":\\s*(\"[^\"]+\")";
-                playerJsUrl = Parser.matchGroup1(assetsPattern, embedPageContent)
-                        .replace("\\", "").replace("\"", "");
-            } catch (final Parser.RegexException ex) {
-                // playerJsUrl is still available in the file, just somewhere else TODO
-                // it is ok not to find it, see how that's handled in getDeobfuscationCode()
-                final Document doc = Jsoup.parse(embedPageContent);
-                final Elements elems = doc.select("script").attr("name", "player_ias/base");
-                for (final Element elem : elems) {
-                    if (elem.attr("src").contains("base.js")) {
-                        playerJsUrl = elem.attr("src");
-                        break;
-                    }
-                }
-            }
-
-            // Get embed sts
-            return Parser.matchGroup1("\"sts\"\\s*:\\s*(\\d+)", embedPageContent);
-        } catch (final Exception i) {
-            // if it fails we simply reply with no sts as then it does not seem to be necessary
-            return "";
-        }
-    }
-
     private String getDeobfuscationFuncName(final String playerCode) throws DeobfuscateException {
         Parser.RegexException exception = null;
         for (final String regex : REGEXES) {
@@ -843,11 +810,10 @@ private String getDeobfuscationFuncName(final String playerCode) throws Deobfusc
         throw new DeobfuscateException("Could not find deobfuscate function with any of the given patterns.", exception);
     }
 
-    private String loadDeobfuscationCode(@Nonnull final String playerJsUrl)
+    private String loadDeobfuscationCode()
             throws DeobfuscateException {
         try {
-            final String playerCode = NewPipe.getDownloader()
-                    .get(playerJsUrl, getExtractorLocalization()).responseBody();
+            final String playerCode = YoutubeJavaScriptExtractor.extractJavaScriptCode(getId());
             final String deobfuscationFunctionName = getDeobfuscationFuncName(playerCode);
 
             final String functionPattern = "("
@@ -866,8 +832,6 @@ private String loadDeobfuscationCode(@Nonnull final String playerJsUrl)
                     "function " + DEOBFUSCATION_FUNC_NAME + "(a){return " + deobfuscationFunctionName + "(a);}";
 
             return helperObject + deobfuscateFunction + callerFunction;
-        } catch (final IOException ioe) {
-            throw new DeobfuscateException("Could not load deobfuscate function", ioe);
         } catch (final Exception e) {
             throw new DeobfuscateException("Could not parse deobfuscate function ", e);
         }
@@ -876,24 +840,7 @@ private String loadDeobfuscationCode(@Nonnull final String playerJsUrl)
     @Nonnull
     private String getDeobfuscationCode() throws ParsingException {
         if (cachedDeobfuscationCode == null) {
-            if (playerJsUrl == null) {
-                // the currentPlayerJsUrl was not found in any page fetched so far and there is
-                // nothing cached, so try fetching embedded info
-                getEmbeddedInfoStsAndStorePlayerJsUrl();
-                if (playerJsUrl == null) {
-                    throw new ParsingException(
-                            "Embedded info did not provide YouTube player js url");
-                }
-            }
-
-            if (playerJsUrl.startsWith("//")) {
-                playerJsUrl = HTTPS + playerJsUrl;
-            } else if (playerJsUrl.startsWith("/")) {
-                // sometimes https://www.youtube.com part has to be added manually
-                playerJsUrl = HTTPS + "//www.youtube.com" + playerJsUrl;
-            }
-
-            cachedDeobfuscationCode = loadDeobfuscationCode(playerJsUrl);
+            cachedDeobfuscationCode = loadDeobfuscationCode();
         }
         return cachedDeobfuscationCode;
     }

extractor/src/main/java/org/schabi/newpipe/extractor/utils/JavaScript.java

@@ -0,0 +1,27 @@
+package org.schabi.newpipe.extractor.utils;
+
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Function;
+import org.mozilla.javascript.ScriptableObject;
+
+public class JavaScript {
+
+    private JavaScript() {
+    }
+
+    public static String run(String function, String functionName, String... parameters) {
+        try {
+            Context context = Context.enter();
+            context.setOptimizationLevel(-1);
+            ScriptableObject scope = context.initSafeStandardObjects();
+
+            context.evaluateString(scope, function, functionName, 1, null);
+            Function jsFunction = (Function) scope.get(functionName, scope);
+            Object result = jsFunction.call(context, scope, scope, parameters);
+            return result.toString();
+        } finally {
+            Context.exit();
+        }
+    }
+
+}