AWS WAF चुनौतियों का CapSolver से समाधान कैसे करें: 2025 में संपूर्ण मार्गदर्शिका

import requests
import re
import time

CAPSOLVER_API_KEY = "YOUR_CAPSOLVER_API_KEY"
CAPSOLVER_CREATE_TASK_ENDPOINT = "https://api.capsolver.com/createTask"
CAPSOLVER_GET_TASK_RESULT_ENDPOINT = "https://api.capsolver.com/getTaskResult"

WEBSITE_URL = "https://efw47fpad9.execute-api.us-east-1.amazonaws.com/latest" # Example URL

def solve_aws_waf_captcha_proxyless(website_url, capsolver_api_key):
    client = requests.Session()
    response = client.get(website_url)
    script_content = response.text

    key_match = re.search(r'"key":"([^"]+)"', script_content)
    iv_match = re.search(r'"iv":"([^"]+)"', script_content)
    context_match = re.search(r'"context":"([^"]+)"', script_content)
    jschallenge_match = re.search(r'<script.*?src="(.*?)".*?></script>', script_content)

    key = key_match.group(1) if key_match else None
    iv = iv_match.group(1) if iv_match else None
    context = context_match.group(1) if context_match else None
    jschallenge = jschallenge_match.group(1) if jschallenge_match else None

    if not all([key, iv, context, jschallenge]):
        print("Error: AWS WAF parameters not found in the page content.")
        return None

    task_payload = {
        "clientKey": capsolver_api_key,
        "task": {
            "type": "AntiAwsWafTaskProxyLess",
            "websiteURL": website_url,
            "awsKey": key,
            "awsIv": iv,
            "awsContext": context,
            "awsChallengeJS": jschallenge
        }
    }

    create_task_response = client.post(CAPSOLVER_CREATE_TASK_ENDPOINT, json=task_payload).json()
    task_id = create_task_response.get('taskId')

    if not task_id:
        print(f"Error creating CapSolver task: {create_task_response.get('errorId')}, {create_task_response.get('errorCode')}")
        return None

    print(f"CapSolver task created with ID: {task_id}")

    for _ in range(10):
        time.sleep(5)
        get_result_payload = {"clientKey": capsolver_api_key, "taskId": task_id}
        get_result_response = client.post(CAPSOLVER_GET_TASK_RESULT_ENDPOINT, json=get_result_payload).json()

        if get_result_response.get('status') == 'ready':
            aws_waf_token_cookie = get_result_response['solution']['cookie']
            print("CapSolver successfully solved the CAPTCHA.")
            return aws_waf_token_cookie
        elif get_result_response.get('status') == 'failed':
            print(f"CapSolver task failed: {get_result_response.get('errorId')}, {get_result_response.get('errorCode')}")
            return None

    print("CapSolver task timed out.")
    return None

# Example usage:
# aws_waf_token = solve_aws_waf_captcha_proxyless(WEBSITE_URL, CAPSOLVER_API_KEY)
# if aws_waf_token:
#     print(f"Received AWS WAF Token: {aws_waf_token}")
#     final_response = requests.get(WEBSITE_URL, cookies={"aws-waf-token": aws_waf_token})
#     print(final_response.text)

# ... (previous code for imports and parameter extraction)

    task_payload = {
        "clientKey": capsolver_api_key,
        "task": {
            "type": "AntiAwsWafTask", # Use AntiAwsWafTask for proxy support
            "websiteURL": website_url,
            "awsKey": key,
            "awsIv": iv,
            "awsContext": context,
            "awsChallengeJS": jschallenge,
            "proxy": "http:user:pass@ip:port" # Example: "http:your_user:[email protected]:8080"
        }
    }

# ... (rest of the code for creating task and getting result remains the same)

import requests
import re

WEBSITE_URL = "https://efw47fpad9.execute-api.us-east-1.amazonaws.com/latest"

response = requests.get(WEBSITE_URL)
script_content = response.text

if response.status_code == 405:
    key_match = re.search(r'"key":"([^"]+)"', script_content)
    iv_match = re.search(r'"iv":"([^"]+)"', script_content)
    context_match = re.search(r'"context":"([^"]+)"', script_content)
    # ... (extract jschallenge if present)

    key = key_match.group(1) if key_match else None
    iv = iv_match.group(1) if iv_match else None
    context = context_match.group(1) if context_match else None
    # ... (use these parameters with CapSolver)
else:
    print(f"Unexpected status code: {response.status_code}")

import requests
import re

WEBSITE_URL = "https://example.com/protected-202"

response = requests.get(WEBSITE_URL)
script_content = response.text

if response.status_code == 202:
    jschallenge_match = re.search(r'<script.*?src="(.*?challenge.js)".*?></script>', script_content)
    jschallenge = jschallenge_match.group(1) if jschallenge_match else None

    if jschallenge:
        # ... (use websiteURL and jschallenge with CapSolver)
        pass
    else:
        print("awsChallengeJS not found.")
else:
    print(f"Unexpected status code: {response.status_code}")

import capsolver
import base64
import requests
import re

capsolver.api_key = "YOUR_CAPSOLVER_API_KEY"

WEBSITE_URL = "https://example.com/aws-waf-image-challenge" # Example URL with image challenge

def solve_aws_waf_image_captcha(website_url, capsolver_api_key):
    # This part would involve scraping the page to get the base64 images and the question
    # For demonstration, let's assume we have them:
    # In a real scenario, you'd use a headless browser or advanced parsing to get these.
    # Example: response = requests.get(website_url)
    #          images_base64 = re.findall(r'data:image/png;base64,([a-zA-Z0-9+/=]+)', response.text)
    #          question_match = re.search(r'"question":"(aws:grid:[a-zA-Z]+)"', response.text)
    #          question = question_match.group(1) if question_match else "aws:grid:bed"

    # Placeholder for actual scraped data
    images_base64 = ["/9j/4AAQSkZJRgABAgAA...", "/9j/2wCEAAoHBwgH..."] # Replace with actual base64 images
    question = "aws:grid:bed" # Replace with actual question from the page

    if not images_base64 or not question:
        print("Error: Image data or question not found.")
        return None

    try:
        solution = capsolver.solve({
            "type": "AwsWafClassification",
            "websiteURL": website_url,
            "images": images_base64,
            "question": question
        })
        print("CapSolver successfully solved the image CAPTCHA.")
        return solution
    except Exception as e:
        print(f"CapSolver image task failed: {e}")
        return None

# Example usage:
# image_solution = solve_aws_waf_image_captcha(WEBSITE_URL, capsolver.api_key)
# if image_solution:

#     print(f"प्राप्त छवि समाधान: {image_solution}")
#     # समाधान में ग्रिड प्रकार के लिए 'ऑब्जेक्ट्स' होंगे, जो यह दर्शाता है कि किन छवियों का चयन करना है।

import capsolver
import base64

capsolver.api_key = "YOUR_CAPSOLVER_API_KEY"

WEBSITE_URL = "https://example.com/aws-waf-toycar-challenge" # उदाहरण URL

def solve_aws_waf_toycar_captcha(website_url, capsolver_api_key):
    # वास्तविक स्क्रैप किए गए डेटा के लिए प्लेसहोल्डर
    image_base64 = "/9j/4AAQSkZJRgABAgAA..." # वास्तविक बेस64 छवि से बदलें
    question = "aws:toycarcity:carcity"

    if not image_base64:
        print("त्रुटि: छवि डेटा नहीं मिला।")
        return None

    try:
        solution = capsolver.solve({
            "type": "AwsWafClassification",
            "websiteURL": website_url,
            "images": [image_base64],
            "question": question
        })
        print("CapSolver ने टॉय कार सिटी CAPTCHA को सफलतापूर्वक हल कर दिया।")
        return solution
    except Exception as e:
        print(f"CapSolver टॉय कार सिटी कार्य विफल: {e}")
        return None

# उदाहरण उपयोग:
# toycar_solution = solve_aws_waf_toycar_captcha(WEBSITE_URL, capsolver.api_key)
# if toycar_solution:
#     print(f"प्राप्त टॉय कार सिटी समाधान: {toycar_solution}")
#     # समाधान में x, y निर्देशांक के साथ 'box' होगा।

def get_aws_waf_params(website_url):
    client = requests.Session()
    response = client.get(website_url)
    script_content = response.text

    key_match = re.search(r'"key":"([^"]+)"', script_content)
    iv_match = re.search(r'"iv":"([^"]+)"', script_content)
    context_match = re.search(r'"context":"([^"]+)"', script_content)
    jschallenge_match = re.search(r'<script.*?src="(.*?)".*?></script>', script_content)

    return {
        "key": key_match.group(1) if key_match else None,
        "iv": iv_match.group(1) if iv_match else None,
        "context": context_match.group(1) if context_match else None,
        "jschallenge": jschallenge_match.group(1) if jschallenge_match else None
    }

def solve_aws_waf_with_retry(website_url, capsolver_api_key, max_retries=3):
    for attempt in range(max_retries):
        print(f"AWS WAF चुनौती को हल करने का प्रयास {attempt + 1}...")
        params = get_aws_waf_params(website_url)
        if not all(params.values()):
            print("सभी AWS WAF पैरामीटर निकालने में विफल। पुनः प्रयास कर रहा हूँ...")
            time.sleep(2) # पुनः प्रयास करने से पहले प्रतीक्षा करें
            continue

        # params का उपयोग करके task_payload का निर्माण करें और CapSolver पर भेजें
        # ... (समाधान 1 के समान, लेकिन गतिशील रूप से प्राप्त किए गए params का उपयोग करके)

        # CapSolver कॉल और परिणाम पुनर्प्राप्ति के लिए प्लेसहोल्डर
        # उदाहरण के लिए:
        # aws_waf_token = call_capsolver_api(website_url, capsolver_api_key, params)
        # if aws_waf_token:
        #     return aws_waf_token
        # else:
        #     print("CapSolver टोकन वापस करने में विफल रहा। पुनः प्रयास कर रहा हूँ...")
        #     time.sleep(5) # CapSolver कॉल को पुनः प्रयास करने से पहले प्रतीक्षा करें

    print("कई पुनः प्रयासों के बाद AWS WAF चुनौती को हल करने में विफल।")
    return None

# ... (आयात और API कुंजी सेटअप)

WEBSITE_URL = "https://example.com/challenge-js-only"

def solve_aws_waf_challenge_js(website_url, capsolver_api_key):
    client = requests.Session()
    response = client.get(website_url)
    script_content = response.text

    jschallenge_match = re.search(r'<script.*?src="(.*?challenge.js)".*?></script>', script_content)
    jschallenge = jschallenge_match.group(1) if jschallenge_match else None

    if not jschallenge:
        print("त्रुटि: awsChallengeJS नहीं मिला।")
        return None

    task_payload = {
        "clientKey": capsolver_api_key,
        "task": {
            "type": "AntiAwsWafTaskProxyLess",
            "websiteURL": website_url,
            "awsChallengeJS": jschallenge
        }
    }

    # ... (कार्य बनाने और परिणाम प्राप्त करने के लिए शेष कोड समाधान 1 के समान ही रहता है)

# ... (आयात और API कुंजी सेटअप)

WEBSITE_URL = "https://example.com/jsapi-challenge"

def solve_aws_waf_api_js(website_url, capsolver_api_key):
    client = requests.Session()
    response = client.get(website_url)
    script_content = response.text

    jsapi_match = re.search(r'<script.*?src="(.*?jsapi.js)".*?></script>', script_content)
    jsapi = jsapi_match.group(1) if jsapi_match else None

    if not jsapi:
        print("त्रुटि: awsApiJs नहीं मिला।")
        return None

    task_payload = {
        "clientKey": capsolver_api_key,
        "task": {
            "type": "AntiAwsWafTaskProxyLess",
            "websiteURL": website_url,
            "awsApiJs": jsapi
        }
    }

    # ... (कार्य बनाने और परिणाम प्राप्त करने के लिए शेष कोड समाधान 1 के समान ही रहता है)

# ... (आयात और API कुंजी सेटअप)

WEBSITE_URL = "https://example.com/problem-url-challenge"

def solve_aws_waf_problem_url(website_url, capsolver_api_key):
    client = requests.Session()
    response = client.get(website_url)
    script_content = response.text

    # awsProblemUrl कैसे खोजें इसका उदाहरण (यह भिन्न हो सकता है)
    problem_url_match = re.search(r'"problemUrl":"(https://.*?problem\?.*?)"', script_content)
    problem_url = problem_url_match.group(1) if problem_url_match else None

    if not problem_url:
        print("त्रुटि: awsProblemUrl नहीं मिला।")
        return None

    task_payload = {
        "clientKey": capsolver_api_key,
        "task": {
            "type": "AntiAwsWafTaskProxyLess",
            "websiteURL": website_url,
            "awsProblemUrl": problem_url
        }
    }

    # ... (कार्य बनाने और परिणाम प्राप्त करने के लिए शेष कोड समाधान 1 के समान ही रहता है)

A1: AWS WAF (वेब एप्लीकेशन फ़ायरवॉल) एक सुरक्षा सेवा है जो वेब एप्लिकेशन को सामान्य वेब एक्सप्लोइट्स से बचाती है। यह वैध मानव उपयोगकर्ताओं और स्वचालित बॉट्स के बीच अंतर करने के लिए अनुरोधों को चुनौती देती है, अक्सर CAPTCHA या JavaScript चुनौतियों का उपयोग करती है। यह वेब स्क्रैपिंग के लिए एक चुनौती पेश करती है क्योंकि स्वचालित स्क्रिप्ट मानव व्यवहार की नकल करने के लिए डिज़ाइन की गई हैं, लेकिन WAF विशेष रूप से इस तरह के ऑटोमेशन का पता लगाने और ब्लॉक करने के लिए डिज़ाइन किए गए हैं।

### Q2: CapSolver AWS WAF चुनौतियों को हल करने में कैसे मदद करता है?

A2: CapSolver एक AI-संचालित CAPTCHA समाधान सेवा है जो विभिन्न CAPTCHA प्रकारों को हल करने की प्रक्रिया को स्वचालित करती है, जिसमें AWS WAF द्वारा तैनात किए गए शामिल हैं। यह टोकन-आधारित चुनौतियों (aws-waf-token कुकीज़ उत्पन्न करना) और छवि पहचान चुनौतियों (दृश्य पहेलियों को हल करना) दोनों के लिए API प्रदान करता है, जिससे स्क्रैपर्स मैन्युअल हस्तक्षेप के बिना अपने अनुरोधों के साथ आगे बढ़ सकते हैं।

### Q3: क्या AWS WAF चुनौतियों के लिए वास्तविक समय पैरामीटर पार्सिंग आवश्यक है?

A3: हाँ, वास्तविक समय पैरामीटर पार्सिंग महत्वपूर्ण है। AWS WAF टोकन और चुनौती पैरामीटर में अक्सर कम जीवनकाल होता है। यदि ये पैरामीटर उपयोग किए जाने से पहले समाप्त हो जाते हैं, तो CapSolver एक त्रुटि वापस कर देगा। CapSolver को भेजने से पहले `key`, `iv`, `context`, `challengeJS`, या `awsProblemUrl` निकालने से यह सुनिश्चित होता है कि आप हमेशा नए, मान्य डेटा का उपयोग कर रहे हैं, जिससे आपके AWS WAF समाधान की सफलता दर में काफी वृद्धि होती है।

### Q4: क्या CapSolver JavaScript और इमेज-आधारित दोनों AWS WAF चुनौतियों को संभाल सकता है?

A4: हाँ, CapSolver दोनों को संभालने के लिए डिज़ाइन किया गया है। JavaScript चुनौतियों के लिए जिन्हें `aws-waf-token` उत्पन्न करने की आवश्यकता होती है, यह `AntiAwsWafTask` और `AntiAwsWafTaskProxyLess` कार्य प्रकार प्रदान करता है। छवि-आधारित CAPTCHA के लिए, जैसे ग्रिड या खिलौना कार शहर प्रकार, यह `AwsWafClassification` कार्य प्रकार प्रदान करता है, जो सही चयन या निर्देशांक देता है।

### Q5: AWS WAF के लिए CapSolver के साथ प्रॉक्सी का उपयोग करने के क्या लाभ हैं?

A5: CapSolver (AntiAwsWafTask के माध्यम से) के साथ प्रॉक्सी का उपयोग आपके वेब स्क्रैपिंग संचालन की मजबूती को बढ़ाता है। प्रॉक्सी IP पतों को घुमाने में मदद करते हैं, जिससे AWS WAF के लिए IP प्रतिष्ठा या दर सीमा के आधार पर आपके अनुरोधों का पता लगाना और ब्लॉक करना कठिन हो जाता है। यह बड़े पैमाने पर स्क्रैपिंग के लिए या आक्रामक एंटी-बॉट उपायों वाली वेबसाइटों को लक्षित करते समय विशेष रूप से फायदेमंद है, उच्च सफलता दर सुनिश्चित करता है और IP प्रतिबंधों को रोकता है।