aggiornato cloudscraper

lib/cloudscraper/__init__.py

@@ -55,7 +55,7 @@ except ImportError:
 
 # ------------------------------------------------------------------------------- #
 
-__version__ = '1.2.35'
+__version__ = '1.2.36'
 
 # ------------------------------------------------------------------------------- #
 
@@ -78,6 +78,7 @@ class CipherSuiteAdapter(HTTPAdapter):
         if not self.ssl_context:
             self.ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
             self.ssl_context.set_ciphers(self.cipherSuite)
+            self.ssl_context.set_ecdh_curve('prime256v1')
             self.ssl_context.options |= (ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1)
 
         super(CipherSuiteAdapter, self).__init__(**kwargs)
@@ -256,7 +257,7 @@ class CloudScraper(Session):
                 resp.headers.get('Server', '').startswith('cloudflare')
                 and resp.status_code in [429, 503]
                 and re.search(
-                    r'<form id="challenge-form" action="/.*?__cf_chl_jschl_tk__=\S+"',
+                    r'<form .*?="challenge-form" action="/.*?__cf_chl_jschl_tk__=\S+"',
                     resp.text,
                     re.M | re.DOTALL
                 )
@@ -347,6 +348,8 @@ class CloudScraper(Session):
             )
 
         if self.is_reCaptcha_Challenge(resp) or self.is_IUAM_Challenge(resp):
+            if self.debug:
+                print('Detected Challenge.')
             return True
 
         return False
@@ -358,7 +361,8 @@ class CloudScraper(Session):
     def IUAM_Challenge_Response(self, body, url, interpreter):
         try:
             formPayload = re.search(
-                r'<form (?P<form>id="challenge-form" action="(?P<challengeUUID>.*?'
+                r'<form (?P<form>.*?="challenge-form" '
+                r'action="(?P<challengeUUID>.*?'
                 r'__cf_chl_jschl_tk__=\S+)"(.*?)</form>)',
                 body,
                 re.M | re.DOTALL
@@ -412,7 +416,7 @@ class CloudScraper(Session):
     def reCaptcha_Challenge_Response(self, provider, provider_params, body, url):
         try:
             formPayload = re.search(
-                r'<form class="challenge-form" (?P<form>id="challenge-form" '
+                r'<form (?P<form>.*?="challenge-form" '
                 r'action="(?P<challengeUUID>.*?__cf_chl_captcha_tk__=\S+)"(.*?)</form>)',
                 body,
                 re.M | re.DOTALL

lib/cloudscraper/interpreters/encapsulated.py

@@ -9,15 +9,13 @@ def template(body, domain):
 
     try:
         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
+            r'setTimeout\(function\(\){\s+(.*?a\.value = \S+)',
+            body,
+            re.M | re.S
         ).group(1)
     except Exception:
         raise ValueError('Unable to identify Cloudflare IUAM Javascript on website. {}'.format(BUG_REPORT))
 
-    js = re.sub(r'\s{2,}', ' ', js, flags=re.MULTILINE | re.DOTALL).replace('\'; 121\'', '')
-    js += '\na.value;'
-
     jsEnv = '''
         String.prototype.italics=function(str) {{return "<i>" + this + "</i>";}};
         var document = {{

lib/cloudscraper/interpreters/native.py

@@ -1,21 +1,95 @@
 from __future__ import absolute_import
 
+import ast
 import re
 import operator as op
+import pyparsing
 
 from ..exceptions import CloudflareSolveError
 from . import JavaScriptInterpreter
 
 # ------------------------------------------------------------------------------- #
 
+_OP_MAP = {
+    ast.Add: op.add,
+    ast.Sub: op.sub,
+    ast.Mult: op.mul,
+    ast.Div: op.truediv,
+    ast.Invert: op.neg,
+}
+
+# ------------------------------------------------------------------------------- #
+
+
+class Calc(ast.NodeVisitor):
+
+    def visit_BinOp(self, node):
+        return _OP_MAP[type(node.op)](self.visit(node.left), self.visit(node.right))
+
+    # ------------------------------------------------------------------------------- #
+
+    def visit_Num(self, node):
+        return node.n
+
+    # ------------------------------------------------------------------------------- #
+
+    def visit_Expr(self, node):
+        return self.visit(node.value)
+
+    # ------------------------------------------------------------------------------- #
+
+    @classmethod
+    def doMath(cls, expression):
+        tree = ast.parse(expression)
+        calc = cls()
+        return calc.visit(tree.body[0])
+
+# ------------------------------------------------------------------------------- #
+
+
+class Parentheses(object):
+
+    def fix(self, s):
+        res = []
+        self.visited = set([s])
+        self.dfs(s, self.invalid(s), res)
+        return res
+
+    # ------------------------------------------------------------------------------- #
+
+    def dfs(self, s, n, res):
+        if n == 0:
+            res.append(s)
+            return
+        for i in range(len(s)):
+            if s[i] in ['(', ')']:
+                s_new = s[:i] + s[i + 1:]
+                if s_new not in self.visited and self.invalid(s_new) < n:
+                    self.visited.add(s_new)
+                    self.dfs(s_new, self.invalid(s_new), res)
+
+    # ------------------------------------------------------------------------------- #
+
+    def invalid(self, s):
+        plus = minus = 0
+        memo = {"(": 1, ")": -1}
+        for c in s:
+            plus += memo.get(c, 0)
+            minus += 1 if plus < 0 else 0
+            plus = max(0, plus)
+        return plus + minus
+
+# ------------------------------------------------------------------------------- #
+
 
 class ChallengeInterpreter(JavaScriptInterpreter):
 
     def __init__(self):
         super(ChallengeInterpreter, self).__init__('native')
 
+    # ------------------------------------------------------------------------------- #
+
     def eval(self, body, domain):
-        # ------------------------------------------------------------------------------- #
 
         operators = {
             '+': op.add,
@@ -26,18 +100,29 @@ class ChallengeInterpreter(JavaScriptInterpreter):
 
         # ------------------------------------------------------------------------------- #
 
+        def flatten(l):
+            return sum(map(flatten, l), []) if isinstance(l, list) else [l]
+
+        # ------------------------------------------------------------------------------- #
+
         def jsfuckToNumber(jsFuck):
-            t = ''
+            # "Clean Up" JSFuck
+            jsFuck = jsFuck.replace('!+[]', '1').replace('!![]', '1').replace('[]', '0')
+            jsFuck = jsFuck.lstrip('+').replace('(+', '(').replace(' ', '')
+            jsFuck = Parentheses().fix(jsFuck)[0]
 
-            split_numbers = re.compile(r'-?\d+').findall
+            # Hackery Parser for Math
+            stack = []
+            bstack = []
+            for i in flatten(pyparsing.nestedExpr().parseString(jsFuck).asList()):
+                if i == '+':
+                    stack.append(bstack)
+                    bstack = []
+                    continue
+                bstack.append(i)
+            stack.append(bstack)
 
-            for i in re.findall(
-                r'\((?:\d|\+|\-)*\)',
-                jsFuck.replace('!+[]', '1').replace('!![]', '1').replace('[]', '0').lstrip('+').replace('(+', '(')
-            ):
-                t = '{}{}'.format(t, sum(int(x) for x in split_numbers(i)))
-
-            return int(t)
+            return int(''.join([str(Calc.doMath(''.join(i))) for i in stack]))
 
         # ------------------------------------------------------------------------------- #
 
@@ -45,6 +130,7 @@ class ChallengeInterpreter(JavaScriptInterpreter):
             jsfuckMath = payload.split('/')
             if needle in jsfuckMath[1]:
                 expression = re.findall(r"^(.*?)(.)\(function", jsfuckMath[1])[0]
+
                 expression_value = operators[expression[1]](
                     float(jsfuckToNumber(expression[0])),
                     float(ord(domain[jsfuckToNumber(jsfuckMath[1][
@@ -118,7 +204,7 @@ class ChallengeInterpreter(JavaScriptInterpreter):
 
         return challengeSolve(body, domain)
 
-
 # ------------------------------------------------------------------------------- #
 
+
 ChallengeInterpreter()