Actualizados 1

vidlox: Actualizado patrón
Actualización de código

plugin.video.alfa/core/cloudflare.py

@@ -10,7 +10,6 @@ import urlparse
 
 from platformcode import logger
 from decimal import Decimal
-from js2py.internals import seval
 
 
 class Cloudflare:
@@ -47,25 +46,50 @@ class Cloudflare:
                 logger.debug("Metodo #2 (headers): NO disponible")
                 self.header_data = {}
 
-
     def solve_cf(self, body, domain):
-        k = re.compile('<div style="display:none;visibility:hidden;" id=".*?">(.*?)<\/div>', re.DOTALL).findall(body)
+        js = re.search(
-        k1 = re.compile('function\(p\){var p = eval\(eval.*?atob.*?return \+\(p\)}\(\)', re.DOTALL).findall(body)
+            r"setTimeout\(function\(\){\s+(var s,t,o,p,b,r,e,a,k,i,n,g,f.+?\r?\n[\s\S]+?a\.value =.+?)\r?\n",
-        if k1:
+            body
-            body = body.replace(k1[0], k[0])
+        ).group(1)
-        js = re.search(r"setTimeout\(function\(\){\s+(var "
+
-                    "s,t,o,p,b,r,e,a,k,i,n,g,f.+?\r?\n[\s\S]+?a\.value =.+?)\r?\n", body).group(1)
         js = re.sub(r"a\.value = ((.+).toFixed\(10\))?", r"\1", js)
+        js = re.sub(r'(e\s=\sfunction\(s\)\s{.*?};)', '', js, flags=re.DOTALL|re.MULTILINE)
         js = re.sub(r"\s{3,}[a-z](?: = |\.).+", "", js).replace("t.length", str(len(domain)))
         js = js.replace('; 121', '')
-        reemplazar = re.compile('(?is)function\(p\)\{return eval.*?\+p\+"\)"\)}', re.DOTALL).findall(js)
-        if reemplazar:
-            js = js.replace(reemplazar[0],'t.charCodeAt')
         js = re.sub(r"[\n\\']", "", js)
-        js = 'a = {{}}; t = "{}";{}'.format(domain, js)
+        jsEnv = """
-        result = seval.eval_js_vm(js)
+        var t = "{domain}";
+        var g = String.fromCharCode;
+        o = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+        e = function(s) {{
+            s += "==".slice(2 - (s.length & 3));
+            var bm, r = "", r1, r2, i = 0;
+            for (; i < s.length;) {{
+                bm = o.indexOf(s.charAt(i++)) << 18 | o.indexOf(s.charAt(i++)) << 12 | (r1 = o.indexOf(s.charAt(i++))) << 6 | (r2 = o.indexOf(s.charAt(i++)));
+                r += r1 === 64 ? g(bm >> 16 & 255) : r2 === 64 ? g(bm >> 16 & 255, bm >> 8 & 255) : g(bm >> 16 & 255, bm >> 8 & 255, bm & 255);
+            }}
+            return r;
+        }};
+        function italics (str) {{ return '<i>' + this + '</i>'; }};
+        var document = {{
+            getElementById: function () {{
+                return {{'innerHTML': '{innerHTML}'}};
+            }}
+        }};
+        {js}
+        """
+        innerHTML = re.search('<div(?: [^<>]*)? id="([^<>]*?)">([^<>]*?)<\/div>', body , re.MULTILINE | re.DOTALL)
+        innerHTML = innerHTML.group(2).replace("'", r"\'") if innerHTML else ""
+        import js2py
+        from jsc import jsunc
+        js = jsunc(jsEnv.format(domain=domain, innerHTML=innerHTML, js=js))
+        def atob(s):
+            return base64.b64decode('{}'.format(s)).decode('utf-8')
+        js2py.disable_pyimport()
+        context = js2py.EvalJs({'atob': atob})
+        result = context.eval(js)
         return float(result)
-        
+
 
     @property
     def wait_time(self):

plugin.video.alfa/lib/js2py/translators/translating_nodes.py

@@ -155,7 +155,7 @@ def limited(func):
 inf = float('inf')
 
 
-def Literal(type, value, raw, regex=None):
+def Literal(type, value, raw, regex=None, comments=None):
     if regex:  # regex
         return 'JsRegExp(%s)' % repr(compose_regex(value))
     elif value is None:  # null
@@ -165,12 +165,12 @@ def Literal(type, value, raw, regex=None):
     return 'Js(%s)' % repr(value) if value != inf else 'Js(float("inf"))'
 
 
-def Identifier(type, name):
+def Identifier(type, name, comments=None):
     return 'var.get(%s)' % repr(name)
 
 
 @limited
-def MemberExpression(type, computed, object, property):
+def MemberExpression(type, computed, object, property, comments=None):
     far_left = trans(object)
     if computed:  # obj[prop] type accessor
         # may be literal which is the same in every case so we can save some time on conversion
@@ -183,12 +183,12 @@ def MemberExpression(type, computed, object, property):
     return far_left + '.get(%s)' % prop
 
 
-def ThisExpression(type):
+def ThisExpression(type, comments=None):
     return 'var.get(u"this")'
 
 
 @limited
-def CallExpression(type, callee, arguments):
+def CallExpression(type, callee, arguments, comments=None):
     arguments = [trans(e) for e in arguments]
     if callee['type'] == 'MemberExpression':
         far_left = trans(callee['object'])
@@ -210,14 +210,14 @@ def CallExpression(type, callee, arguments):
 # ========== ARRAYS ============
 
 
-def ArrayExpression(type, elements):  # todo fix null inside problem
+def ArrayExpression(type, elements, comments=None):  # todo fix null inside problem
     return 'Js([%s])' % ', '.join(trans(e) if e else 'None' for e in elements)
 
 
 # ========== OBJECTS =============
 
 
-def ObjectExpression(type, properties):
+def ObjectExpression(type, properties, comments=None):
     name = inline_stack.require('Object')
     elems = []
     after = ''
@@ -241,7 +241,7 @@ def ObjectExpression(type, properties):
     return name
 
 
-def Property(type, kind, key, computed, value, method, shorthand):
+def Property(type, kind, key, computed, value, method, shorthand, comments=None):
     if shorthand or computed:
         raise NotImplementedError(
             'Shorthand and Computed properties not implemented!')
@@ -256,7 +256,7 @@ def Property(type, kind, key, computed, value, method, shorthand):
 
 
 @limited
-def UnaryExpression(type, operator, argument, prefix):
+def UnaryExpression(type, operator, argument, prefix, comments=None):
     a = trans(
         argument, standard=True
     )  # unary involve some complex operations so we cant use line shorteners here
@@ -271,7 +271,7 @@ def UnaryExpression(type, operator, argument, prefix):
 
 
 @limited
-def BinaryExpression(type, operator, left, right):
+def BinaryExpression(type, operator, left, right, comments=None):
     a = trans(left)
     b = trans(right)
     # delegate to our friends
@@ -279,7 +279,7 @@ def BinaryExpression(type, operator, left, right):
 
 
 @limited
-def UpdateExpression(type, operator, argument, prefix):
+def UpdateExpression(type, operator, argument, prefix, comments=None):
     a = trans(
         argument, standard=True
     )  # also complex operation involving parsing of the result so no line length reducing here
@@ -287,7 +287,7 @@ def UpdateExpression(type, operator, argument, prefix):
 
 
 @limited
-def AssignmentExpression(type, operator, left, right):
+def AssignmentExpression(type, operator, left, right, comments=None):
     operator = operator[:-1]
     if left['type'] == 'Identifier':
         if operator:
@@ -319,12 +319,12 @@ six
 
 
 @limited
-def SequenceExpression(type, expressions):
+def SequenceExpression(type, expressions, comments=None):
     return reduce(js_comma, (trans(e) for e in expressions))
 
 
 @limited
-def NewExpression(type, callee, arguments):
+def NewExpression(type, callee, arguments, comments=None):
     return trans(callee) + '.create(%s)' % ', '.join(
         trans(e) for e in arguments)
 
@@ -332,7 +332,7 @@ def NewExpression(type, callee, arguments):
 @limited
 def ConditionalExpression(
         type, test, consequent,
-        alternate):  # caused plenty of problems in my home-made translator :)
+        alternate, comments=None):  # caused plenty of problems in my home-made translator :)
     return '(%s if %s else %s)' % (trans(consequent), trans(test),
                                    trans(alternate))
 
@@ -340,49 +340,49 @@ def ConditionalExpression(
 # ===========  STATEMENTS =============
 
 
-def BlockStatement(type, body):
+def BlockStatement(type, body, comments=None):
     return StatementList(
         body)  # never returns empty string! In the worst case returns pass\n
 
 
-def ExpressionStatement(type, expression):
+def ExpressionStatement(type, expression, comments=None):
     return trans(expression) + '\n'  # end expression space with new line
 
 
-def BreakStatement(type, label):
+def BreakStatement(type, label, comments=None):
     if label:
         return 'raise %s("Breaked")\n' % (get_break_label(label['name']))
     else:
         return 'break\n'
 
 
-def ContinueStatement(type, label):
+def ContinueStatement(type, label, comments=None):
     if label:
         return 'raise %s("Continued")\n' % (get_continue_label(label['name']))
     else:
         return 'continue\n'
 
 
-def ReturnStatement(type, argument):
+def ReturnStatement(type, argument, comments=None):
     return 'return %s\n' % (trans(argument)
                             if argument else "var.get('undefined')")
 
 
-def EmptyStatement(type):
+def EmptyStatement(type, comments=None):
     return 'pass\n'
 
 
-def DebuggerStatement(type):
+def DebuggerStatement(type, comments=None):
     return 'pass\n'
 
 
-def DoWhileStatement(type, body, test):
+def DoWhileStatement(type, body, test, comments=None):
     inside = trans(body) + 'if not %s:\n' % trans(test) + indent('break\n')
     result = 'while 1:\n' + indent(inside)
     return result
 
 
-def ForStatement(type, init, test, update, body):
+def ForStatement(type, init, test, update, body, comments=None):
     update = indent(trans(update)) if update else ''
     init = trans(init) if init else ''
     if not init.endswith('\n'):
@@ -398,7 +398,7 @@ def ForStatement(type, init, test, update, body):
     return result
 
 
-def ForInStatement(type, left, right, body, each):
+def ForInStatement(type, left, right, body, each, comments=None):
     res = 'for PyJsTemp in %s:\n' % trans(right)
     if left['type'] == "VariableDeclaration":
         addon = trans(left)  # make sure variable is registered
@@ -417,7 +417,7 @@ def ForInStatement(type, left, right, body, each):
     return res
 
 
-def IfStatement(type, test, consequent, alternate):
+def IfStatement(type, test, consequent, alternate, comments=None):
     # NOTE we cannot do elif because function definition inside elif statement would not be possible!
     IF = 'if %s:\n' % trans(test)
     IF += indent(trans(consequent))
@@ -427,7 +427,7 @@ def IfStatement(type, test, consequent, alternate):
     return IF + ELSE
 
 
-def LabeledStatement(type, label, body):
+def LabeledStatement(type, label, body, comments=None):
     # todo consider using smarter approach!
     inside = trans(body)
     defs = ''
@@ -448,7 +448,7 @@ def LabeledStatement(type, label, body):
     return defs + inside
 
 
-def StatementList(lis):
+def StatementList(lis, comments=None):
     if lis:  # ensure we don't return empty string because it may ruin indentation!
         code = ''.join(trans(e) for e in lis)
         return code if code else 'pass\n'
@@ -456,7 +456,7 @@ def StatementList(lis):
         return 'pass\n'
 
 
-def PyimportStatement(type, imp):
+def PyimportStatement(type, imp, comments=None):
     lib = imp['name']
     jlib = 'PyImport_%s' % lib
     code = 'import %s as %s\n' % (lib, jlib)
@@ -471,7 +471,7 @@ def PyimportStatement(type, imp):
     return code
 
 
-def SwitchStatement(type, discriminant, cases):
+def SwitchStatement(type, discriminant, cases, comments=None):
     #TODO there will be a problem with continue in a switch statement.... FIX IT
     code = 'while 1:\n' + indent('SWITCHED = False\nCONDITION = (%s)\n')
     code = code % trans(discriminant)
@@ -491,12 +491,12 @@ def SwitchStatement(type, discriminant, cases):
     return code
 
 
-def ThrowStatement(type, argument):
+def ThrowStatement(type, argument, comments=None):
     return 'PyJsTempException = JsToPyException(%s)\nraise PyJsTempException\n' % trans(
         argument)
 
 
-def TryStatement(type, block, handler, handlers, guardedHandlers, finalizer):
+def TryStatement(type, block, handler, handlers, guardedHandlers, finalizer, comments=None):
     result = 'try:\n%s' % indent(trans(block))
     # complicated catch statement...
     if handler:
@@ -516,13 +516,13 @@ def TryStatement(type, block, handler, handlers, guardedHandlers, finalizer):
     return result
 
 
-def LexicalDeclaration(type, declarations, kind):
+def LexicalDeclaration(type, declarations, kind, comments=None):
     raise NotImplementedError(
         'let and const not implemented yet but they will be soon! Check github for updates.'
     )
 
 
-def VariableDeclarator(type, id, init):
+def VariableDeclarator(type, id, init, comments=None):
     name = id['name']
     # register the name if not already registered
     Context.register(name)
@@ -531,21 +531,21 @@ def VariableDeclarator(type, id, init):
     return ''
 
 
-def VariableDeclaration(type, declarations, kind):
+def VariableDeclaration(type, declarations, kind, comments=None):
     code = ''.join(trans(d) for d in declarations)
     return code if code else 'pass\n'
 
 
-def WhileStatement(type, test, body):
+def WhileStatement(type, test, body, comments=None):
     result = 'while %s:\n' % trans(test) + indent(trans(body))
     return result
 
 
-def WithStatement(type, object, body):
+def WithStatement(type, object, body, comments=None):
     raise NotImplementedError('With statement not implemented!')
 
 
-def Program(type, body):
+def Program(type, body, comments=None):
     inline_stack.reset()
     code = ''.join(trans(e) for e in body)
     # here add hoisted elements (register variables and define functions)
@@ -559,7 +559,7 @@ def Program(type, body):
 
 
 def FunctionDeclaration(type, id, params, defaults, body, generator,
-                        expression):
+                        expression, comments=None):
     if generator:
         raise NotImplementedError('Generators not supported')
     if defaults:
@@ -610,7 +610,7 @@ def FunctionDeclaration(type, id, params, defaults, body, generator,
 
 
 def FunctionExpression(type, id, params, defaults, body, generator,
-                       expression):
+                       expression, comments=None):
     if generator:
         raise NotImplementedError('Generators not supported')
     if defaults:

plugin.video.alfa/lib/jsc.py

@@ -0,0 +1,83 @@
+MAPPING = {
+    'a': '(false+"")[1]',
+    'b': '([]["entries"]()+"")[2]',
+    'c': '([]["fill"]+"")[3]',
+    'd': '(undefined+"")[2]',
+    'e': '(true+"")[3]',
+    'f': '(false+"")[0]',
+    'g': '(false+[0]+String)[20]',
+    'h': '(+(101))["to"+String["name"]](21)[1]',
+    'i': '([false]+undefined)[10]',
+    'j': '([]["entries"]()+"")[3]',
+    'k': '(+(20))["to"+String["name"]](21)',
+    'l': '(false+"")[2]',
+    'm': '(Number+"")[11]',
+    'n': '(undefined+"")[1]',
+    'o': '(true+[]["fill"])[10]',
+    'p': '(+(211))["to"+String["name"]](31)[1]',
+    'q': '(+(212))["to"+String["name"]](31)[1]',
+    'r': '(true+"")[1]',
+    's': '(false+"")[3]',
+    't': '(true+"")[0]',
+    'u': '(undefined+"")[0]',
+    'v': '(+(31))["to"+String["name"]](32)',
+    'w': '(+(32))["to"+String["name"]](33)',
+    'x': '(+(101))["to"+String["name"]](34)[1]',
+    'y': '(NaN+[Infinity])[10]',
+    'z': '(+(35))["to"+String["name"]](36)',
+    'A': '(+[]+Array)[10]',
+    'B': '(+[]+Boolean)[10]',
+    'C': 'Function("return escape")()(("")["italics"]())[2]',
+    'D': 'Function("return escape")()([]["fill"])["slice"]("-1")',
+    'E': '(RegExp+"")[12]',
+    'F': '(+[]+Function)[10]',
+    'G': '(false+Function("return Date")()())[30]',
+    'I': '(Infinity+"")[0]',
+    'M': '(true+Function("return Date")()())[30]',
+    'N': '(NaN+"")[0]',
+    'O': '(NaN+Function("return{}")())[11]',
+    'R': '(+[]+RegExp)[10]',
+    'S': '(+[]+String)[10]',
+    'T': '(NaN+Function("return Date")()())[30]',
+    'U': '(NaN+Function("return{}")()["to"+String["name"]]["call"]())[11]',
+    ' ': '(NaN+[]["fill"])[11]',
+    '"': '("")["fontcolor"]()[12]',
+    '%': 'Function("return escape")()([]["fill"])[21]',
+    '&': '("")["link"](0+")[10]',
+    '(': '(undefined+[]["fill"])[22]',
+    ')': '([0]+false+[]["fill"])[20]',
+    '+': '(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[2]',
+    ',': '([]["slice"]["call"](false+"")+"")[1]',
+    '-': '(+(.+[0000000001])+"")[2]',
+    '.': '(+(+!+[]+[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+[!+[]+!+[]]+[+[]])+[])[+!+[]]',
+    '/': '(false+[0])["italics"]()[10]',
+    ':': '(RegExp()+"")[3]',
+    ';': '("")["link"](")[14]',
+    '<': '("")["italics"]()[0]',
+    '=': '("")["fontcolor"]()[11]',
+    '>': '("")["italics"]()[2]',
+    '?': '(RegExp()+"")[2]',
+    '[': '([]["entries"]()+"")[0]',
+    ']': '([]["entries"]()+"")[22]',
+    '{': '(true+[]["fill"])[20]',
+    '}': '([]["fill"]+"")["slice"]("-1")'
+}
+
+SIMPLE = {
+    'false': '![]',
+    'true': '!![]',
+    'undefined': '[][[]]',
+    'NaN': '+[![]]',
+    'Infinity': '+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]]+[+[]])'  # +"1e1000"
+}
+
+def jsunc(jscString):
+    
+    for key in sorted(MAPPING, key=lambda k: len(MAPPING[k]), reverse=True):
+        if MAPPING.get(key) in jscString:
+            jscString = jscString.replace(MAPPING.get(key), '"{}"'.format(key))
+    
+    for key in sorted(SIMPLE, key=lambda k: len(SIMPLE[k]), reverse=True):
+        if SIMPLE.get(key) in jscString:
+            jscString = jscString.replace(SIMPLE.get(key), '{}'.format(key))
+    return jscString

plugin.video.alfa/servers/vidlox.json

@@ -4,8 +4,8 @@
     "ignore_urls": [],
     "patterns": [
       {
-        "pattern": "(?i)(https://vidlox.(?:tv|me)/embed-.*?.html)",
+        "pattern": "(?i)(vidlox.(?:tv|me)/embed-\\w+)",
-        "url": "\\1"
+        "url": "https://\\1.html"
       }
     ]
   },