Decipher Performance Enhancement

Removed unnecessary code duplication in Decipherer.cs
Added a loop breakout when all three functions have been determined.
Rearranged the code so that operations is determined once and applied to
each encrypted signature instead. This should greatly improve the
performance of the decipher as it won't have to run though all the loops
each time to decrypt a video/url.
Renamed some variables and comments to clear up some of the trial fix I
made.

Author: Cyanoth

YoutubeExtractor/YoutubeExtractor/Decipherer.cs

@@ -7,84 +7,54 @@ namespace YoutubeExtractor
 {
     internal static class Decipherer
     {
-        public static string DecipherWithVersion(string cipher, string cipherVersion)
+        public static string DecipherOperations(string cipherVersion)
         {
-            // NB: We intentionally don't cache the operations as it seems that the same operation
-            //     doesn't work if the URL below isn't called
-
             string jsUrl = string.Format("http://s.ytimg.com/yts/jsbin/html5player-{0}.js", cipherVersion);
             string js = HttpHelper.DownloadString(jsUrl);
 
             //Find "C" in this: var A = B.sig||C (B.s)
             string functNamePattern = @"\.sig\s*\|\|(\w+)\(";
             var funcName = Regex.Match(js, functNamePattern).Groups[1].Value;
-
-            //Match nested angle braces
-            string funcBodyPattern = @"(?<brace>{([^{}]| ?(brace))*})";
-            //Match the function function_name (that has one argument)
+            string funcBodyPattern = @"(?<brace>{([^{}]| ?(brace))*})";  //Match nested angle braces
             string funcPattern = string.Format(@"{0}\(\w+\){1}", funcName, funcBodyPattern);
-            var funcBody = Regex.Match(js, funcPattern).Groups["brace"].Value;
-            var lines = funcBody.Split(';');
-
-            string operations = "";
+            var funcBody = Regex.Match(js, funcPattern).Groups["brace"].Value; //Entire sig function
+            var lines = funcBody.Split(';'); //Each line in sig function
 
-
-            //CYNAO - 07/08/2014, Test Fix
-            /* The previous algoritms used a.splice(), where the decipher used the method (.splice()), however it seems the new algoritm 
-             * renames the method to random but unique characters (example ab.dc() = splice). This code determines what each method code is,
-             * as it is defined once using the original name.
-             */
-            string id_Reverse = ""  , id_Slice = "" , id_CharSwap = ""; //Holds the new method name for each.
+            string id_Reverse = "", id_Slice = "", id_CharSwap = ""; //Hold name for each method
             string functionIdentifier = "";
+            string operations = "";
 
-            string functIDPattern = @"\w+:\bfunction\b";  //Define as "NB:function(a,b)" where nb can be the three ciphers
-            var funcID = Regex.Match(js, functIDPattern).Groups[1].Value;
-
-            ///CODE ADDITION: Get the three ciphers by finding the definition
+            //Match the code with each function. Only runs till all three are defined.
             foreach (var line in lines.Skip(1).Take(lines.Length - 2))
             {
-                string newVarName; //Previous algoritms used to be just "a." - now stores temp var name as its uneccessary
-                int locOfDot, locOfBracket, functionIDLength; 
-                locOfDot = line.IndexOf("."); // NB.AC( - gets location of the dot.
-                locOfBracket = line.IndexOf("("); //NB.AC( - gets location of the bracet
-                functionIDLength = locOfBracket - (locOfDot + 1);
-                newVarName = line.Substring(0, locOfDot);
-                functionIdentifier = line.Substring(locOfDot + 1, functionIDLength); //leaving us with the function AC
-
-                //This is what the definitions currently look like, could be changed so the regex needs improving. Messy fix.
-                string tempReverse = string.Format(@"{0}:\bfunction\b\(\w+\)", functionIdentifier); //Reverse only one that doesnt have two parameters
-                string tempSlice = string.Format(@"{0}:\bfunction\b\([a],b\).(\breturn\b)?.?\w+\.", functionIdentifier); //Regex for slice (return or not)
-                string tempCharSwap = string.Format(@"{0}:\bfunction\b\(\w+\,\w\).\bvar\b.\bc=a\b", functionIdentifier); //Regex for the char swap.
-                                
+                if (!string.IsNullOrEmpty(id_Reverse) && !string.IsNullOrEmpty(id_Slice) &&
+                 !string.IsNullOrEmpty(id_CharSwap)) { break; } //Break out if all defined.
+
+                functionIdentifier = getFunctionFromLine(line);
+                string re_Reverse = string.Format(@"{0}:\bfunction\b\(\w+\)", functionIdentifier); //Regex for reverse (one parameter)
+                string re_Slice = string.Format(@"{0}:\bfunction\b\([a],b\).(\breturn\b)?.?\w+\.", functionIdentifier); //Regex for slice (return or not)
+                string re_Swap = string.Format(@"{0}:\bfunction\b\(\w+\,\w\).\bvar\b.\bc=a\b", functionIdentifier); //Regex for the char swap.
+
                 Match me;
-                if ((me = Regex.Match(js, tempReverse)).Success)
+                if ((me = Regex.Match(js, re_Reverse)).Success)
                 { id_Reverse = functionIdentifier; } //If def matched the regex for reverse then the current function is a defined as the reverse cipher
 
-                if ((me = Regex.Match(js, tempSlice)).Success)
+                if ((me = Regex.Match(js, re_Slice)).Success)
                 { id_Slice = functionIdentifier; } //If def matched the regex for slice then the current function is defined as the slice cipher.
 
-                if ((me = Regex.Match(js, tempCharSwap)).Success)
+                if ((me = Regex.Match(js, re_Swap)).Success)
                 { id_CharSwap = functionIdentifier; } //If def matched the regex for charSwap then the current function is defined as swap cipher.
 
             }
 
-
             foreach (var line in lines.Skip(1).Take(lines.Length - 2))
             {
                 Match m;
-                ///DUPLICATE CODE! Improve. 
-                int locOfDot; int locOfBracket; int functionIDLength;
-                locOfDot = line.IndexOf(".");
-                locOfBracket = line.IndexOf("(");
-                functionIDLength = locOfBracket - (locOfDot + 1);
-                functionIdentifier = line.Substring(locOfDot + 1, functionIDLength); //Just needed this (define it as a member?)
-
-                string newSliceIDRegex = string.Format(@"(?<index>\d+)\)+", functionIdentifier);
+                functionIdentifier = getFunctionFromLine(line);
 
                 if ((m = Regex.Match(line, @"\(\w+,(?<index>\d+)\)")).Success && functionIdentifier == id_CharSwap)
                 { operations += "w" + m.Groups["index"].Value + " "; } //Character swap regex appears to be the same as before
 
-
                 if ((m = Regex.Match(line, @"\(\w+,(?<index>\d+)\)")).Success && functionIdentifier == id_Slice)
                 { operations += "s" + m.Groups["index"].Value + " "; } //Slice appears to have changed the index location???
                 //Could be wrong and the regex needs improving, seems to work on the latest algorithm though.
@@ -93,9 +63,29 @@ public static string DecipherWithVersion(string cipher, string cipherVersion)
                 { operations += "r "; } //Reverse operation, no regex required
 
             }
+
             operations = operations.Trim();
+            Console.WriteLine(operations);
+            return operations;
+
+        }
+
+        public static string DecipherWithOperations(string cipher, string operations)
+        {
+            if (string.IsNullOrEmpty(operations))
+            { throw new NotImplementedException("No valid cipher operations found."); }
+
+            return operations.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries)
+                .Aggregate(cipher, ApplyOperation);
+        }
 
-            return DecipherWithOperations(cipher, operations);
+
+        private static string getFunctionFromLine(string currentLine)
+        {
+            Regex matchFunctionReg = new Regex(@"\w+\.(?<functionID>\w+)\("); //lc.ac(b,c) want ac.
+            Match rgMatch = matchFunctionReg.Match(currentLine);
+            string matchedFunction = rgMatch.Groups["functionID"].Value;
+            return matchedFunction; //return 'ac'
         }
 
         private static string ApplyOperation(string cipher, string op)
@@ -104,7 +94,7 @@ private static string ApplyOperation(string cipher, string op)
             {
                 case 'r':
                     return new string(cipher.ToCharArray().Reverse().ToArray());
-                        
+
                 case 'w':
                     {
                         int index = GetOpIndex(op);
@@ -122,11 +112,6 @@ private static string ApplyOperation(string cipher, string op)
             }
         }
 
-        private static string DecipherWithOperations(string cipher, string operations)
-        {
-            return operations.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries)
-                .Aggregate(cipher, ApplyOperation);
-        }
 
         private static int GetOpIndex(string op)
         {

YoutubeExtractor/YoutubeExtractor/DownloadUrlResolver.cs

@@ -24,7 +24,7 @@ public static class DownloadUrlResolver
         /// <exception cref="YoutubeParseException">
         /// There was an error while deciphering the signature.
         /// </exception>
-        public static void DecryptDownloadUrl(VideoInfo videoInfo)
+        public static void DecryptDownloadUrl(VideoInfo videoInfo, string operations)
         {
             IDictionary<string, string> queries = HttpHelper.ParseQueryString(videoInfo.DownloadUrl);
 
@@ -36,7 +36,10 @@ public static void DecryptDownloadUrl(VideoInfo videoInfo)
 
                 try
                 {
-                    decrypted = GetDecipheredSignature(videoInfo.HtmlPlayerVersion, encryptedSignature);
+                    if (encryptedSignature.Length == CorrectSignatureLength)
+                    { decrypted = encryptedSignature; } //Doesn't require decrypting
+                    else
+                    { decrypted = Decipherer.DecipherWithOperations(encryptedSignature, operations); } //Use operations get decrypted cipher
                 }
 
                 catch (Exception ex)
@@ -94,14 +97,17 @@ public static IEnumerable<VideoInfo> GetDownloadUrls(string videoUrl, bool decry
                 IEnumerable<VideoInfo> infos = GetVideoInfos(downloadUrls, videoTitle).ToList();
 
                 string htmlPlayerVersion = GetHtml5PlayerVersion(json);
+                string operations = ""; //Same operations for the same html5Player
 
                 foreach (VideoInfo info in infos)
                 {
                     info.HtmlPlayerVersion = htmlPlayerVersion;
 
                     if (decryptSignature && info.RequiresDecryption)
                     {
-                        DecryptDownloadUrl(info);
+                        if (string.IsNullOrEmpty(operations)) //Get operations if we don't
+                        { operations = Decipherer.DecipherOperations(htmlPlayerVersion); }
+                        DecryptDownloadUrl(info, operations);
                     }
                 }
 
@@ -213,16 +219,6 @@ private static string GetAdaptiveStreamMap(JObject json)
             return streamMap.ToString();
         }
 
-        private static string GetDecipheredSignature(string htmlPlayerVersion, string signature)
-        {
-            if (signature.Length == CorrectSignatureLength)
-            {
-                return signature;
-            }
-
-            return Decipherer.DecipherWithVersion(signature, htmlPlayerVersion);
-        }
-
         private static string GetHtml5PlayerVersion(JObject json)
         {
             var regex = new Regex(@"html5player-(.+?)\.js");