#!/usr/bin/env python3

"""

ShadowPass - Example Usage Script

This script demonstrates various ways to use ShadowPass for

bypassing 40X HTTP errors.

WARNING: This tool is for authorized security testing only.

"""

import asyncio

import json

from shadowpass import ShadowPassClient, ShadowPassConfig

from shadowpass.evasion.headers import HeaderSpoofer

from shadowpass.evasion.techniques import EvasionEngine

from shadowpass.proxy.manager import ProxyManager

def example_basic_bypass():

"""Example: Basic bypass attempt."""

print("\n" + "="*60)

print("Example 1: Basic Bypass")

print("="*60)

# Create client with default settings

client = ShadowPassClient()

# Attempt bypass on a URL

url = "http://httpbin.org/status/403" # Returns 403 for testing

result = client.bypass(url)

print(f"URL: {result.url}")

print(f"Original Status: {result.original_status}")

print(f"Final Status: {result.final_status}")

print(f"Success: {result.success}")

print(f"Technique: {result.technique_used}")

print(f"Attempts: {result.attempts}")

print(f"Time: {result.time_taken:.2f}s")

client.close()

return result

def example_with_configuration():

"""Example: Bypass with custom configuration."""

print("\n" + "="*60)

print("Example 2: Custom Configuration")

print("="*60)

# Create custom configuration

config = ShadowPassConfig()

# Enable specific features

config.evasion.header_spoofing = True

config.evasion.method_tampering = True

config.evasion.path_fuzzing = True

config.evasion.user_agent_rotation = True

# Configure retry behavior

config.retry.max_retries = 10

config.retry.switch_technique_on_fail = True

# Configure rate limiting

config.rate_limit.enabled = True

config.rate_limit.requests_per_second = 2.0

config.rate_limit.exponential_backoff = True

# Create client with custom config

with ShadowPassClient(config) as client:

result = client.bypass(

url="http://httpbin.org/status/403",

method="GET",

headers={"Custom-Header": "test-value"}

)

print(f"Success: {result.success}")

print(f"Technique: {result.technique_used}")

# Get statistics

stats = client.get_statistics()

print(f"Total requests: {stats['total_requests']}")

print(f"Success rate: {stats['success_rate']:.1f}%")

def example_header_spoofing():

"""Example: Using header spoofer directly."""

print("\n" + "="*60)

print("Example 3: Header Spoofing")

print("="*60)

spoofer = HeaderSpoofer()

# Get a random user agent

ua = spoofer.get_random_user_agent()

print(f"Random User-Agent: {ua[:50]}...")

# Get internal IP for X-Forwarded-For

internal_ip = spoofer.get_random_internal_ip()

print(f"Internal IP for XFF: {internal_ip}")

# Generate bypass header sets

url = "http://example.com/admin"

header_sets = spoofer.get_bypass_headers_set(url)

print(f"\nGenerated {len(header_sets)} header sets for bypass")

print("\nFirst header set:")

for key, value in list(header_sets[0].items())[:5]:

print(f" {key}: {value[:50]}...")

def example_evasion_engine():

"""Example: Using the evasion engine."""

print("\n" + "="*60)

print("Example 4: Evasion Engine")

print("="*60)

engine = EvasionEngine()

url = "http://example.com/api/v1/admin"

# Generate bypass attempts

print(f"\nGenerating evasion attempts for: {url}")

print("\nFirst 10 attempts:")

for i, attempt in enumerate(engine.generate_attempts(url, max_attempts=10)):

print(f"\n Attempt {i+1}: {attempt.technique_name}")

print(f" Method: {attempt.method}")

print(f" URL: {attempt.url[:60]}...")

print(f" Description: {attempt.description}")

# Get quick bypasses (most effective techniques)

quick = engine.get_quick_bypasses(url)

print(f"\nQuick bypass techniques: {len(quick)} attempts ready")

def example_proxy_manager():

"""Example: Using the proxy manager."""

print("\n" + "="*60)

print("Example 5: Proxy Management")

print("="*60)

manager = ProxyManager()

# Add some proxies

proxies = [

"http://proxy1.example.com:8080",

"http://proxy2.example.com:8080",

"http://user:pass@proxy3.example.com:8080",

"socks5://socks.example.com:1080"

]

added = manager.add_proxies(proxies)

print(f"Added {added} proxies to pool")

# Get proxies using different strategies

print(f"\nNext proxy (rotation): {manager.get_next_proxy()}")

print(f"Random proxy: {manager.get_random_proxy()}")

# Get statistics

stats = manager.get_stats()

print(f"\nProxy pool stats:")

print(f" Total: {stats['total_proxies']}")

print(f" Active: {stats['active_proxies']}")

def example_batch_processing():

"""Example: Processing multiple URLs."""

print("\n" + "="*60)

print("Example 6: Batch Processing")

print("="*60)

urls = [

"http://httpbin.org/status/200",

"http://httpbin.org/status/403",

"http://httpbin.org/status/404",

"http://httpbin.org/status/401",

]

config = ShadowPassConfig()

config.rate_limit.requests_per_second = 1.0 # Be gentle with httpbin

with ShadowPassClient(config) as client:

results = []

for url in urls:

result = client.bypass(url)

results.append(result)

print(f"{url}: {result.original_status} -> {result.final_status} ({result.technique_used})")

# Get final statistics

stats = client.get_statistics()

print(f"\nBatch complete:")

print(f" Total: {stats['total_attempts']}")

print(f" Successful: {stats['successful_bypasses']}")

print(f" Success rate: {stats['success_rate']:.1f}%")

async def example_async_processing():

"""Example: Async batch processing."""

print("\n" + "="*60)

print("Example 7: Async Processing")

print("="*60)

urls = [

"http://httpbin.org/status/200",

"http://httpbin.org/status/403",

"http://httpbin.org/status/404",

]

with ShadowPassClient() as client:

print(f"Processing {len(urls)} URLs asynchronously...")

results = await client.bypass_async(urls, concurrency=3)

for result in results:

status = "✓" if result.success else "✗"

print(f" {status} {result.url}: {result.final_status}")

def example_save_config():

"""Example: Saving configuration."""

print("\n" + "="*60)

print("Example 8: Configuration Management")

print("="*60)

# Create a custom configuration

config = ShadowPassConfig()

# Customize settings

config.proxy.enabled = True

config.proxy.rotation_interval = 10

config.tor.enabled = False

config.evasion.header_spoofing = True

config.rate_limit.requests_per_second = 5.0

config.retry.max_retries = 5

# Save to file

config_dict = config.to_dict()

print("Configuration (as dict):")

print(json.dumps({

"proxy": config_dict["proxy"],

"evasion": config_dict["evasion"],

"rate_limit": config_dict["rate_limit"]

}, indent=2, default=str))

# Save to YAML (in production)

# config.save_yaml("my_config.yaml")

print("\nUse config.save_yaml('filename.yaml') to save configuration")

def main():

"""Run all examples."""

print("\n" + "#"*60)

print("# ShadowPass - Example Usage Script")

print("# For authorized security testing only")

print("#"*60)

# Run synchronous examples

example_basic_bypass()

example_with_configuration()

example_header_spoofing()

example_evasion_engine()

example_proxy_manager()

example_batch_processing()

example_save_config()

# Run async example

asyncio.run(example_async_processing())

print("\n" + "="*60)

print("All examples completed!")

print("="*60 + "\n")

if __name__ == "__main__":

main()