हाउ टू सॉल्व एवीएस कैप्चा / चुनौती पायथन के साथ

pip install capsolver requests beautifulsoup4

import capsolver
import requests
from bs4 import BeautifulSoup
import re
from urllib.parse import urlparse

# -------------------कृपया इन मानों को संशोधित करें-------------------
# अपने प्रॉक्सी विवरण, प्रारूप: http://यूजरनाम:पासवर्ड@आईपी:पोर्ट
PROXY = "http://यूजरनाम:पासवर्ड@आईपी:पोर्ट"
# लक्षित वेबसाइट का URL जिसके लिए आप AWS WAF को हल करना चाहते हैं
PAGE_URL = "https://www.आपकी-एवएस-सुरक्षित-वेबसाइट.com"
# CapSolver डैशबोर्ड से अपनी API कुंजी
CAPSOLVER_API_KEY = "अपनी_API_कुंजी"
# ----------------------------------------------------------------

def solve_aws_waf(is_captcha_challenge, **kwargs):
    """
    CapSolver के उपयोग से AWS WAF चुनौति या कैप्चा हल करता है।
    :param is_captcha_challenge: कैप्चा (405 स्थिति कोड) के लिए सही, जावास्क्रिप्ट चुनौति (202 स्थिति कोड) के लिए गलत।
    :param kwargs: हल करने के लिए आवश्यक पैरामीटर।
    :return: समाधान ऑब्जेक्ट, असफलता पर None।
    """
    task_type = "AntiAwsWafTask" if is_captcha_challenge else "AntiAwsWafTaskProxyLess"
    print(f"'{task_type}' कार्य बना रहे हैं...")
    
    task_payload = {
        "type": task_type,
        "websiteURL": PAGE_URL,
    }
    
    # चुनौति प्रकार के आधार पर विशिष्ट पैरामीटर जोड़ें
    if is_captcha_challenge:
        # कैप्चा चुनौतियों के लिए, awsKey, awsIv, awsContext की आवश्यकता होती है
        task_payload.update({
            "awsKey": kwargs.get("awsKey"),
            "awsIv": kwargs.get("awsIv"),
            "awsContext": kwargs.get("awsContext"),
            "awsChallengeJS": kwargs.get("awsChallengeJS"),
            "proxy": PROXY
        })
    else:
        # जावास्क्रिप्ट चुनौतियों के लिए, केवल awsChallengeJS URL की आवश्यकता होती है
        task_payload["awsChallengeJS"] = kwargs.get("awsChallengeJS")

    try:
        solution = capsolver.solve(task_payload)
        if solution and solution.get("errorId", 0) == 0:
            print("समाधान सफलतापूर्वक प्राप्त कर लिया गया!")
            return solution
        else:
            error_desc = solution.get('errorDescription', 'अज्ञात त्रुटि') if solution else 'अज्ञात त्रुटि'
            print(f"कार्य हल करने में असफल: {error_desc}")
            return None
    except Exception as e:
        print(f"CapSolver कॉल करते समय एक अपवाद घटित हुआ: {e}")
        return None

def main():
    """पूरी प्रक्रिया के निष्पादन के लिए मुख्य कार्य।"""
    capsolver.api_key = CAPSOLVER_API_KEY
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
    }

    print(f"प्रयास कर रहे हैं: {PAGE_URL}")
    response = session.get(PAGE_URL, headers=headers)
    print(f"प्राप्त स्थिति कोड: {response.status_code}")

    solution = None
    
    # परिदृश्य 1: AWS जावास्क्रिप्ट चुनौति का प्रबंधन (स्थिति कोड 202)
    if response.status_code == 202:
        print("AWS जावास्क्रिप्ट चुनौति पहचान ली गई।")
        soup = BeautifulSoup(response.content, 'html.parser')
        script_tag = soup.find('script', {'src': re.compile(r'token\.awswaf\.com')})
        if script_tag:
            challenge_js_url = script_tag['src']
            print(f"चुनौति जावास्क्रिप्ट यूआरएल पाया गया: {challenge_js_url}")
            solution = solve_aws_waf(is_captcha_challenge=False, awsChallengeJS=challenge_js_url)
        else:
            print("त्रुटि: AWS चुनौति स्क्रिप्ट नहीं मिली।")

    # परिदृश्य 2: AWS कैप्चा का प्रबंधन (स्थिति कोड 405)
    elif response.status_code == 405:
        print("AWS कैप्चा पहचान ली गई।")
        soup = BeautifulSoup(response.content, 'html.parser')
        script_tag = soup.find('script', {'src': re.compile(r'token\.awswaf\.com')})
        script_text_tag = soup.find('script', string=re.compile('.*key.*'))
        
        if script_tag and script_text_tag:
            challenge_js_url = script_tag['src']
            script_text = script_text_tag.string
            
            key = re.search(r'"key":"(.*?)"', script_text).group(1)
            iv = re.search(r'"iv":"(.*?)"', script_text).group(1)
            context = re.search(r'"context":"(.*?)"', script_text).group(1)
            
            print(f"अनुक्रम निकाले गए: Key={key[:5]}..., IV={iv[:5]}..., Context={context[:5]}...")
            solution = solve_aws_waf(
                is_captcha_challenge=True,
                awsKey=key,
                awsIv=iv,
                awsContext=context,
                awsChallengeJS=challenge_js_url
            )
        else:
            print("त्रुटि: पृष्ठ से सभी आवश्यक कैप्चा पैरामीटर निकालने में असफल।")

    # यदि समाधान सफल रहा, कुकी सेट करें और फिर से मांग करें
    if solution and solution.get("cookie"):
        aws_token = solution["cookie"]
        print(f"सफलतापूर्वक एवएस-वाफ-टोकन प्राप्त किया गया: {aws_token[:30]}...")
        
        domain = f".{urlparse(PAGE_URL).netloc}"
        session.cookies.set("aws-waf-token", aws_token, domain=domain)
        
        print("कुकी सेट कर रहे हैं। फिर से मांग कर रहे हैं...")
        final_response = session.get(PAGE_URL, headers=headers)
        print(f"अंतिम मांग स्थिति कोड: {final_response.status_code}")
        
        if final_response.status_code == 200:
            print("एवएस डब्ल्यूएफ बर्बाद कर दिया गया!")
            # print(final_response.text) # अपने पृष्ठ सामग्री देखने के लिए अनकमेंट करें
        else:
            print("कुकी सेट करने के बाद मांग असफल रही। टोकन या प्रॉक्सी जांचें।")
    else:
        print("एवएस डब्ल्यूएफ बर्बाद करने में असफल। बाहर निकल रहे हैं।")

if __name__ == "__main__":
    main()