././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617697432.1938138 cfscrape-2.1.1/0002755000174500001730000000000000000000000013020 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617697430.0 cfscrape-2.1.1/LICENSE0000644000174500001730000000206100000000000014022 0ustar00janitorsbuildThe MIT License (MIT) Copyright (c) 2015 Anorov Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617697430.0 cfscrape-2.1.1/MANIFEST.in0000644000174500001730000000003200000000000014547 0ustar00janitorsbuildinclude LICENSE README.md ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617697432.1938138 cfscrape-2.1.1/PKG-INFO0000644000174500001730000003042600000000000014120 0ustar00janitorsbuildMetadata-Version: 2.1 Name: cfscrape Version: 2.1.1 Summary: A simple Python module to bypass Cloudflare's anti-bot page. See https://github.com/Anorov/cloudflare-scrape for more information. Home-page: https://github.com/Anorov/cloudflare-scrape Author: Anorov Author-email: anorov.vorona@gmail.com License: UNKNOWN Description: cloudflare-scrape ================= A simple Python module to bypass Cloudflare's anti-bot page (also known as "I'm Under Attack Mode", or IUAM), implemented with [Requests](https://github.com/kennethreitz/requests). Python versions 2.6 - 3.7 are supported. Cloudflare changes their techniques periodically, so I will update this repo frequently. This can be useful if you wish to scrape or crawl a website protected with Cloudflare. Cloudflare's anti-bot page currently just checks if the client supports JavaScript, though they may add additional techniques in the future. Due to Cloudflare continually changing and hardening their protection page, cloudflare-scrape requires Node.js to solve JavaScript challenges. This allows the script to easily impersonate a regular web browser without explicitly deobfuscating and parsing Cloudflare's JavaScript. Note: This only works when regular Cloudflare anti-bots is enabled (the "Checking your browser before accessing..." loading page). If there is a reCAPTCHA challenge, you're out of luck. Thankfully, the JavaScript check page is much more common. For reference, this is the default message Cloudflare uses for these sorts of pages: Checking your browser before accessing website.com. This process is automatic. Your browser will redirect to your requested content shortly. Please allow up to 5 seconds... Any script using cloudflare-scrape will sleep for 5 seconds for the first visit to any site with Cloudflare anti-bots enabled, though no delay will occur after the first request. Installation ============ Simply run `pip install cfscrape`. You can upgrade with `pip install -U cfscrape`. The PyPI package is at https://pypi.python.org/pypi/cfscrape/ Alternatively, clone this repository and run `python setup.py install`. Node.js dependency ============ [Node.js](https://nodejs.org/) version 10 or above is required to interpret Cloudflare's obfuscated JavaScript challenge. Your machine may already have Node installed (check with `node -v`). If not, you can install it with `apt-get install nodejs` on Ubuntu >= 18.04 and Debian >= 9 and `brew install node` on macOS. Otherwise, you can get it from [Node's download page](https://nodejs.org/en/download/) or [their package manager installation page](https://nodejs.org/en/download/package-manager/). Updates ======= Cloudflare regularly modifies their anti-bot protection page and improves their bot detection capabilities. If you notice that the anti-bot page has changed, or if this module suddenly stops working, please create a GitHub issue so that I can update the code accordingly. * Many issues are a result of users not updating to the latest release of this project. Before filing an issue, please run the following command to update cloudflare-scrape to the latest version: ``` pip install -U cfscrape ``` If you are still encountering a problem, create a GitHub issue and please include: * The version number from `pip show cfscrape`. * The relevant code snippet that's experiencing an issue or raising an exception. * The full exception and traceback, if applicable. * The URL of the Cloudflare-protected page which the script does not work on. * A Pastebin or Gist containing the HTML source of the protected page. If you've upgraded and are still experiencing problems, **[click here to create a GitHub issue and fill out the pertinent information](https://github.com/Anorov/cloudflare-scrape/issues/new?assignees=&labels=bug&template=bug-report-template.md&title=)**. Usage ===== The simplest way to use cloudflare-scrape is by calling `create_scraper()`. ```python import cfscrape scraper = cfscrape.create_scraper() # returns a CloudflareScraper instance # Or: scraper = cfscrape.CloudflareScraper() # CloudflareScraper inherits from requests.Session print scraper.get("http://somesite.com").content # => "..." ``` That's it. Any requests made from this session object to websites protected by Cloudflare anti-bot will be handled automatically. Websites not using Cloudflare will be treated normally. You don't need to configure or call anything further, and you can effectively treat all websites as if they're not protected with anything. You use cloudflare-scrape exactly the same way you use Requests. (`CloudflareScraper` works identically to a Requests `Session` object.) Just instead of calling `requests.get()` or `requests.post()`, you call `scraper.get()` or `scraper.post()`. Consult [Requests' documentation](http://docs.python-requests.org/en/latest/user/quickstart/) for more information. ## Options ### Existing session If you already have an existing Requests session, you can pass it to `create_scraper()` to continue using that session. ```python session = requests.session() session.headers = ... scraper = cfscrape.create_scraper(sess=session) ``` Unfortunately, not all of Requests' session attributes are easily transferable, so if you run into problems with this, you should replace your initial `sess = requests.session()` call with `sess = cfscrape.create_scraper()`. ### Delays Normally, when a browser is faced with a Cloudflare IUAM challenge page, Cloudflare requires the browser to wait 5 seconds before submitting the challenge answer. If a website is under heavy load, sometimes this may fail. One solution is to increase the delay (perhaps to 10 or 15 seconds, depending on the website). If you would like to override this delay, pass the `delay` keyword argument to `create_scraper()` or `CloudflareScraper()`. There is no need to override this delay unless cloudflare-scrape generates an error recommending you increase the delay. ```python scraper = cfscrape.create_scraper(delay=10) ``` ## Integration It's easy to integrate cloudflare-scrape with other applications and tools. Cloudflare uses two cookies as tokens: one to verify you made it past their challenge page and one to track your session. To bypass the challenge page, simply include both of these cookies (with the appropriate user-agent) in all HTTP requests you make. To retrieve just the cookies (as a dictionary), use `cfscrape.get_tokens()`. To retrieve them as a full `Cookie` HTTP header, use `cfscrape.get_cookie_string()`. `get_tokens` and `get_cookie_string` both accept Requests' usual keyword arguments (like `get_tokens(url, proxies={"http": "socks5://localhost:9050"})`). Please read [Requests' documentation on request arguments](http://docs.python-requests.org/en/master/api/#requests.Session.request) for more information. *User-Agent Handling* The two integration functions return a tuple of `(cookie, user_agent_string)`. **You must use the same user-agent string for obtaining tokens and for making requests with those tokens, otherwise Cloudflare will flag you as a bot.** That means you have to pass the returned `user_agent_string` to whatever script, tool, or service you are passing the tokens to (e.g. curl, or a specialized scraping tool), and it must use that passed user-agent when it makes HTTP requests. If your tool already has a particular user-agent configured, you can make cloudflare-scrape use it with `cfscrape.get_tokens("http://somesite.com/", user_agent="User-Agent Here")` (also works for `get_cookie_string`). Otherwise, a randomly selected user-agent will be used. -------------------------------------------------------------------------------- ### Integration examples Remember, you must always use the same user-agent when retrieving or using these cookies. These functions all return a tuple of `(cookie_dict, user_agent_string)`. **Retrieving a cookie dict through a proxy** `get_tokens` is a convenience function for returning a Python dict containing Cloudflare's session cookies. For demonstration, we will configure this request to use a proxy. (Please note that if you request Cloudflare clearance tokens through a proxy, you must always use the same proxy when those tokens are passed to the server. Cloudflare requires that the challenge-solving IP and the visitor IP stay the same.) If you do not wish to use a proxy, just don't pass the `proxies` keyword argument. These convenience functions support all of Requests' normal keyword arguments, like `params`, `data`, and `headers`. ```python import cfscrape proxies = {"http": "http://localhost:8080", "https": "http://localhost:8080"} tokens, user_agent = cfscrape.get_tokens("http://somesite.com", proxies=proxies) print tokens # => {'cf_clearance': 'c8f913c707b818b47aa328d81cab57c349b1eee5-1426733163-3600', '__cfduid': 'dd8ec03dfdbcb8c2ea63e920f1335c1001426733158'} ``` **Retrieving a cookie string** `get_cookie_string` is a convenience function for returning the tokens as a string for use as a `Cookie` HTTP header value. This is useful when crafting an HTTP request manually, or working with an external application or library that passes on raw cookie headers. ```python import cfscrape request = "GET / HTTP/1.1\r\n" cookie_value, user_agent = cfscrape.get_cookie_string("http://somesite.com") request += "Cookie: %s\r\nUser-Agent: %s\r\n" % (cookie_value, user_agent) print request # GET / HTTP/1.1\r\n # Cookie: cf_clearance=c8f913c707b818b47aa328d81cab57c349b1eee5-1426733163-3600; __cfduid=dd8ec03dfdbcb8c2ea63e920f1335c1001426733158 # User-Agent: Some/User-Agent String ``` **curl example** Here is an example of integrating cloudflare-scrape with curl. As you can see, all you have to do is pass the cookies and user-agent to curl. ```python import subprocess import cfscrape # With get_tokens() cookie dict: # tokens, user_agent = cfscrape.get_tokens("http://somesite.com") # cookie_arg = "cf_clearance=%s; __cfduid=%s" % (tokens["cf_clearance"], tokens["__cfduid"]) # With get_cookie_string() cookie header; recommended for curl and similar external applications: cookie_arg, user_agent = cfscrape.get_cookie_string("http://somesite.com") # With a custom user-agent string you can optionally provide: # ua = "Scraping Bot" # cookie_arg, user_agent = cfscrape.get_cookie_string("http://somesite.com", user_agent=ua) result = subprocess.check_output(["curl", "--cookie", cookie_arg, "-A", user_agent, "http://somesite.com"]) ``` Trimmed down version. Prints page contents of any site protected with Cloudflare, via curl. (Warning: `shell=True` can be dangerous to use with `subprocess` in real code.) ```python url = "http://somesite.com" cookie_arg, user_agent = cfscrape.get_cookie_string(url) cmd = "curl --cookie {cookie_arg} -A {user_agent} {url}" print(subprocess.check_output(cmd.format(cookie_arg=cookie_arg, user_agent=user_agent, url=url), shell=True)) ``` Keywords: cloudflare,scraping Platform: UNKNOWN Description-Content-Type: text/markdown ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617697430.0 cfscrape-2.1.1/README.md0000644000174500001730000002461300000000000014303 0ustar00janitorsbuildcloudflare-scrape ================= A simple Python module to bypass Cloudflare's anti-bot page (also known as "I'm Under Attack Mode", or IUAM), implemented with [Requests](https://github.com/kennethreitz/requests). Python versions 2.6 - 3.7 are supported. Cloudflare changes their techniques periodically, so I will update this repo frequently. This can be useful if you wish to scrape or crawl a website protected with Cloudflare. Cloudflare's anti-bot page currently just checks if the client supports JavaScript, though they may add additional techniques in the future. Due to Cloudflare continually changing and hardening their protection page, cloudflare-scrape requires Node.js to solve JavaScript challenges. This allows the script to easily impersonate a regular web browser without explicitly deobfuscating and parsing Cloudflare's JavaScript. Note: This only works when regular Cloudflare anti-bots is enabled (the "Checking your browser before accessing..." loading page). If there is a reCAPTCHA challenge, you're out of luck. Thankfully, the JavaScript check page is much more common. For reference, this is the default message Cloudflare uses for these sorts of pages: Checking your browser before accessing website.com. This process is automatic. Your browser will redirect to your requested content shortly. Please allow up to 5 seconds... Any script using cloudflare-scrape will sleep for 5 seconds for the first visit to any site with Cloudflare anti-bots enabled, though no delay will occur after the first request. Installation ============ Simply run `pip install cfscrape`. You can upgrade with `pip install -U cfscrape`. The PyPI package is at https://pypi.python.org/pypi/cfscrape/ Alternatively, clone this repository and run `python setup.py install`. Node.js dependency ============ [Node.js](https://nodejs.org/) version 10 or above is required to interpret Cloudflare's obfuscated JavaScript challenge. Your machine may already have Node installed (check with `node -v`). If not, you can install it with `apt-get install nodejs` on Ubuntu >= 18.04 and Debian >= 9 and `brew install node` on macOS. Otherwise, you can get it from [Node's download page](https://nodejs.org/en/download/) or [their package manager installation page](https://nodejs.org/en/download/package-manager/). Updates ======= Cloudflare regularly modifies their anti-bot protection page and improves their bot detection capabilities. If you notice that the anti-bot page has changed, or if this module suddenly stops working, please create a GitHub issue so that I can update the code accordingly. * Many issues are a result of users not updating to the latest release of this project. Before filing an issue, please run the following command to update cloudflare-scrape to the latest version: ``` pip install -U cfscrape ``` If you are still encountering a problem, create a GitHub issue and please include: * The version number from `pip show cfscrape`. * The relevant code snippet that's experiencing an issue or raising an exception. * The full exception and traceback, if applicable. * The URL of the Cloudflare-protected page which the script does not work on. * A Pastebin or Gist containing the HTML source of the protected page. If you've upgraded and are still experiencing problems, **[click here to create a GitHub issue and fill out the pertinent information](https://github.com/Anorov/cloudflare-scrape/issues/new?assignees=&labels=bug&template=bug-report-template.md&title=)**. Usage ===== The simplest way to use cloudflare-scrape is by calling `create_scraper()`. ```python import cfscrape scraper = cfscrape.create_scraper() # returns a CloudflareScraper instance # Or: scraper = cfscrape.CloudflareScraper() # CloudflareScraper inherits from requests.Session print scraper.get("http://somesite.com").content # => "..." ``` That's it. Any requests made from this session object to websites protected by Cloudflare anti-bot will be handled automatically. Websites not using Cloudflare will be treated normally. You don't need to configure or call anything further, and you can effectively treat all websites as if they're not protected with anything. You use cloudflare-scrape exactly the same way you use Requests. (`CloudflareScraper` works identically to a Requests `Session` object.) Just instead of calling `requests.get()` or `requests.post()`, you call `scraper.get()` or `scraper.post()`. Consult [Requests' documentation](http://docs.python-requests.org/en/latest/user/quickstart/) for more information. ## Options ### Existing session If you already have an existing Requests session, you can pass it to `create_scraper()` to continue using that session. ```python session = requests.session() session.headers = ... scraper = cfscrape.create_scraper(sess=session) ``` Unfortunately, not all of Requests' session attributes are easily transferable, so if you run into problems with this, you should replace your initial `sess = requests.session()` call with `sess = cfscrape.create_scraper()`. ### Delays Normally, when a browser is faced with a Cloudflare IUAM challenge page, Cloudflare requires the browser to wait 5 seconds before submitting the challenge answer. If a website is under heavy load, sometimes this may fail. One solution is to increase the delay (perhaps to 10 or 15 seconds, depending on the website). If you would like to override this delay, pass the `delay` keyword argument to `create_scraper()` or `CloudflareScraper()`. There is no need to override this delay unless cloudflare-scrape generates an error recommending you increase the delay. ```python scraper = cfscrape.create_scraper(delay=10) ``` ## Integration It's easy to integrate cloudflare-scrape with other applications and tools. Cloudflare uses two cookies as tokens: one to verify you made it past their challenge page and one to track your session. To bypass the challenge page, simply include both of these cookies (with the appropriate user-agent) in all HTTP requests you make. To retrieve just the cookies (as a dictionary), use `cfscrape.get_tokens()`. To retrieve them as a full `Cookie` HTTP header, use `cfscrape.get_cookie_string()`. `get_tokens` and `get_cookie_string` both accept Requests' usual keyword arguments (like `get_tokens(url, proxies={"http": "socks5://localhost:9050"})`). Please read [Requests' documentation on request arguments](http://docs.python-requests.org/en/master/api/#requests.Session.request) for more information. *User-Agent Handling* The two integration functions return a tuple of `(cookie, user_agent_string)`. **You must use the same user-agent string for obtaining tokens and for making requests with those tokens, otherwise Cloudflare will flag you as a bot.** That means you have to pass the returned `user_agent_string` to whatever script, tool, or service you are passing the tokens to (e.g. curl, or a specialized scraping tool), and it must use that passed user-agent when it makes HTTP requests. If your tool already has a particular user-agent configured, you can make cloudflare-scrape use it with `cfscrape.get_tokens("http://somesite.com/", user_agent="User-Agent Here")` (also works for `get_cookie_string`). Otherwise, a randomly selected user-agent will be used. -------------------------------------------------------------------------------- ### Integration examples Remember, you must always use the same user-agent when retrieving or using these cookies. These functions all return a tuple of `(cookie_dict, user_agent_string)`. **Retrieving a cookie dict through a proxy** `get_tokens` is a convenience function for returning a Python dict containing Cloudflare's session cookies. For demonstration, we will configure this request to use a proxy. (Please note that if you request Cloudflare clearance tokens through a proxy, you must always use the same proxy when those tokens are passed to the server. Cloudflare requires that the challenge-solving IP and the visitor IP stay the same.) If you do not wish to use a proxy, just don't pass the `proxies` keyword argument. These convenience functions support all of Requests' normal keyword arguments, like `params`, `data`, and `headers`. ```python import cfscrape proxies = {"http": "http://localhost:8080", "https": "http://localhost:8080"} tokens, user_agent = cfscrape.get_tokens("http://somesite.com", proxies=proxies) print tokens # => {'cf_clearance': 'c8f913c707b818b47aa328d81cab57c349b1eee5-1426733163-3600', '__cfduid': 'dd8ec03dfdbcb8c2ea63e920f1335c1001426733158'} ``` **Retrieving a cookie string** `get_cookie_string` is a convenience function for returning the tokens as a string for use as a `Cookie` HTTP header value. This is useful when crafting an HTTP request manually, or working with an external application or library that passes on raw cookie headers. ```python import cfscrape request = "GET / HTTP/1.1\r\n" cookie_value, user_agent = cfscrape.get_cookie_string("http://somesite.com") request += "Cookie: %s\r\nUser-Agent: %s\r\n" % (cookie_value, user_agent) print request # GET / HTTP/1.1\r\n # Cookie: cf_clearance=c8f913c707b818b47aa328d81cab57c349b1eee5-1426733163-3600; __cfduid=dd8ec03dfdbcb8c2ea63e920f1335c1001426733158 # User-Agent: Some/User-Agent String ``` **curl example** Here is an example of integrating cloudflare-scrape with curl. As you can see, all you have to do is pass the cookies and user-agent to curl. ```python import subprocess import cfscrape # With get_tokens() cookie dict: # tokens, user_agent = cfscrape.get_tokens("http://somesite.com") # cookie_arg = "cf_clearance=%s; __cfduid=%s" % (tokens["cf_clearance"], tokens["__cfduid"]) # With get_cookie_string() cookie header; recommended for curl and similar external applications: cookie_arg, user_agent = cfscrape.get_cookie_string("http://somesite.com") # With a custom user-agent string you can optionally provide: # ua = "Scraping Bot" # cookie_arg, user_agent = cfscrape.get_cookie_string("http://somesite.com", user_agent=ua) result = subprocess.check_output(["curl", "--cookie", cookie_arg, "-A", user_agent, "http://somesite.com"]) ``` Trimmed down version. Prints page contents of any site protected with Cloudflare, via curl. (Warning: `shell=True` can be dangerous to use with `subprocess` in real code.) ```python url = "http://somesite.com" cookie_arg, user_agent = cfscrape.get_cookie_string(url) cmd = "curl --cookie {cookie_arg} -A {user_agent} {url}" print(subprocess.check_output(cmd.format(cookie_arg=cookie_arg, user_agent=user_agent, url=url), shell=True)) ``` ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1617697432.1938138 cfscrape-2.1.1/cfscrape/0002755000174500001730000000000000000000000014606 5ustar00janitorsbuild././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1617697430.0 cfscrape-2.1.1/cfscrape/__init__.py0000644000174500001730000004076700000000000016733 0ustar00janitorsbuild# -*- coding: utf-8 -*- import logging import random import re import ssl import subprocess import copy import time import os from base64 import b64encode from collections import OrderedDict from requests.sessions import Session from requests.adapters import HTTPAdapter from requests.compat import urlparse, urlunparse from requests.exceptions import RequestException from urllib3.util.ssl_ import create_urllib3_context, DEFAULT_CIPHERS from .user_agents import USER_AGENTS __version__ = "2.1.1" DEFAULT_USER_AGENT = random.choice(USER_AGENTS) DEFAULT_HEADERS = OrderedDict( ( ("Host", None), ("Connection", "keep-alive"), ("Upgrade-Insecure-Requests", "1"), ("User-Agent", DEFAULT_USER_AGENT), ( "Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8", ), ("Accept-Language", "en-US,en;q=0.9"), ("Accept-Encoding", "gzip, deflate"), ) ) BUG_REPORT = """\ Cloudflare may have changed their technique, or there may be a bug in the script. Please read https://github.com/Anorov/cloudflare-scrape#updates, then file a \ bug report at https://github.com/Anorov/cloudflare-scrape/issues."\ """ ANSWER_ACCEPT_ERROR = """\ The challenge answer was not properly accepted by Cloudflare. This can occur if \ the target website is under heavy load, or if Cloudflare is experiencing issues. You can potentially resolve this by increasing the challenge answer delay (default: 8 seconds). \ For example: cfscrape.create_scraper(delay=15) If increasing the delay does not help, please open a GitHub issue at \ https://github.com/Anorov/cloudflare-scrape/issues\ """ # Remove a few problematic TLSv1.0 ciphers from the defaults DEFAULT_CIPHERS += ":!ECDHE+SHA:!AES128-SHA:!AESCCM:!DHE:!ARIA" class CloudflareAdapter(HTTPAdapter): """ HTTPS adapter that creates a SSL context with custom ciphers """ def get_connection(self, *args, **kwargs): conn = super(CloudflareAdapter, self).get_connection(*args, **kwargs) if conn.conn_kw.get("ssl_context"): conn.conn_kw["ssl_context"].set_ciphers(DEFAULT_CIPHERS) else: context = create_urllib3_context(ciphers=DEFAULT_CIPHERS) conn.conn_kw["ssl_context"] = context return conn class CloudflareError(RequestException): pass class CloudflareCaptchaError(CloudflareError): pass class CloudflareScraper(Session): def __init__(self, *args, **kwargs): self.delay = kwargs.pop("delay", None) # Use headers with a random User-Agent if no custom headers have been set headers = OrderedDict(kwargs.pop("headers", DEFAULT_HEADERS)) # Set the User-Agent header if it was not provided headers.setdefault("User-Agent", DEFAULT_USER_AGENT) super(CloudflareScraper, self).__init__(*args, **kwargs) # Define headers to force using an OrderedDict and preserve header order self.headers = headers self.org_method = None self.mount("https://", CloudflareAdapter()) @staticmethod def is_cloudflare_iuam_challenge(resp): return ( resp.status_code in (503, 429) and resp.headers.get("Server", "").startswith("cloudflare") and b"jschl_vc" in resp.content and b"jschl_answer" in resp.content ) @staticmethod def is_cloudflare_captcha_challenge(resp): return ( resp.status_code == 403 and resp.headers.get("Server", "").startswith("cloudflare") and b"/cdn-cgi/l/chk_captcha" in resp.content ) def request(self, method, url, *args, **kwargs): resp = super(CloudflareScraper, self).request(method, url, *args, **kwargs) # Check if Cloudflare captcha challenge is presented if self.is_cloudflare_captcha_challenge(resp): self.handle_captcha_challenge(resp, url) # Check if Cloudflare anti-bot "I'm Under Attack Mode" is enabled if self.is_cloudflare_iuam_challenge(resp): resp = self.solve_cf_challenge(resp, **kwargs) return resp def cloudflare_is_bypassed(self, url, resp=None): cookie_domain = ".{}".format(urlparse(url).netloc) return ( self.cookies.get("cf_clearance", None, domain=cookie_domain) or (resp and resp.cookies.get("cf_clearance", None, domain=cookie_domain)) ) def handle_captcha_challenge(self, resp, url): error = ( "Cloudflare captcha challenge presented for %s (cfscrape cannot solve captchas)" % urlparse(url).netloc ) if ssl.OPENSSL_VERSION_NUMBER < 0x10101000: error += ". Your OpenSSL version is lower than 1.1.1. Please upgrade your OpenSSL library and recompile Python." raise CloudflareCaptchaError(error, response=resp) def solve_cf_challenge(self, resp, **original_kwargs): start_time = time.time() body = resp.text parsed_url = urlparse(resp.url) domain = parsed_url.netloc challenge_form = re.search(r'\',body, flags=re.S).group(0) # find challenge form method = re.search(r'method=\"(.*?)\"', challenge_form, flags=re.S).group(1) if self.org_method is None: self.org_method = resp.request.method submit_url = "%s://%s%s" % (parsed_url.scheme, domain, re.search(r'action=\"(.*?)\"', challenge_form, flags=re.S).group(1).split('?')[0]) cloudflare_kwargs = copy.deepcopy(original_kwargs) headers = cloudflare_kwargs.setdefault("headers", {}) headers["Referer"] = resp.url try: cloudflare_kwargs["params"] = dict() cloudflare_kwargs["data"] = dict() if len(re.search(r'action=\"(.*?)\"', challenge_form, flags=re.S).group(1).split('?')) != 1: for param in re.search(r'action=\"(.*?)\"', challenge_form, flags=re.S).group(1).split('?')[1].split('&'): cloudflare_kwargs["params"].update({param.split('=')[0]:param.split('=')[1]}) for input_ in re.findall(r'\|\<\/input\>)', challenge_form, flags=re.S): if re.search(r'name=\"(.*?)\"',input_, flags=re.S).group(1) != 'jschl_answer': if method == 'POST': cloudflare_kwargs["data"].update({re.search(r'name=\"(.*?)\"',input_, flags=re.S).group(1): re.search(r'value=\"(.*?)\"',input_, flags=re.S).group(1)}) elif method == 'GET': cloudflare_kwargs["params"].update({re.search(r'name=\"(.*?)\"',input_, flags=re.S).group(1): re.search(r'value=\"(.*?)\"',input_, flags=re.S).group(1)}) if method == 'POST': for k in ("jschl_vc", "pass"): if k not in cloudflare_kwargs["data"]: raise ValueError("%s is missing from challenge form" % k) elif method == 'GET': for k in ("jschl_vc", "pass"): if k not in cloudflare_kwargs["params"]: raise ValueError("%s is missing from challenge form" % k) except Exception as e: # Something is wrong with the page. # This may indicate Cloudflare has changed their anti-bot # technique. If you see this and are running the latest version, # please open a GitHub issue so I can update the code accordingly. raise ValueError( "Unable to parse Cloudflare anti-bot IUAM page: %s %s" % (e, BUG_REPORT) ) # Solve the Javascript challenge answer, delay = self.solve_challenge(body, domain) if method == 'POST': cloudflare_kwargs["data"]["jschl_answer"] = answer elif method == 'GET': cloudflare_kwargs["params"]["jschl_answer"] = answer # Requests transforms any request into a GET after a redirect, # so the redirect has to be handled manually here to allow for # performing other types of requests even as the first request. cloudflare_kwargs["allow_redirects"] = False # Cloudflare requires a delay before solving the challenge time.sleep(max(delay - (time.time() - start_time), 0)) # Send the challenge response and handle the redirect manually redirect = self.request(method, submit_url, **cloudflare_kwargs) if "Location" in redirect.headers: redirect_location = urlparse(redirect.headers["Location"]) if not redirect_location.netloc: redirect_url = urlunparse( ( parsed_url.scheme, domain, redirect_location.path, redirect_location.params, redirect_location.query, redirect_location.fragment, ) ) return self.request(method, redirect_url, **original_kwargs) return self.request(method, redirect.headers["Location"], **original_kwargs) elif "Set-Cookie" in redirect.headers: if 'cf_clearance' in redirect.headers['Set-Cookie']: resp = self.request(self.org_method, submit_url, cookies = redirect.cookies) return resp else: return self.request(method, submit_url, **original_kwargs) else: resp = self.request(self.org_method, submit_url, **cloudflare_kwargs) return resp def solve_challenge(self, body, domain): try: all_scripts = re.findall(r'\