aura-framework 3.0.0__tar.gz

aura_framework-3.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mutasem Kharma
+
+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.

aura_framework-3.0.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: aura-framework
+Version: 3.0.0
+Summary: A sentient, autonomous offensive security framework.
+Author-email: Mutasem Kharma <author@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Security
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click
+Requires-Dist: rich
+Requires-Dist: fastapi
+Requires-Dist: uvicorn
+Requires-Dist: playwright
+Requires-Dist: curl_cffi
+Requires-Dist: jinja2
+Requires-Dist: pydantic
+Dynamic: license-file
+
+# Aura: Zenith Singularity 🌌⚔️
+
+![Aura Header](https://raw.githubusercontent.com/username/repo/main/docs/header.png)
+
+**Aura** is a sentient, autonomous offensive security framework designed for elite reconnaissance, risk analysis, and deep-impact exploitation. It transforms from a simple scanner into a global offensive platform, featuring a professional command center (Aura Nexus) and AI-driven attack orchestration.
+
+## 🌌 Key Pillars
+- **Neural Intelligence:** AI Chain-of-Thought reasoning for strategic attack planning.
+- **Invisible Stealth:** JA3/TLS fingerprint randomization and behavioral humanization.
+- **Aura-Link:** Professional SOCKS5 pivoting for internal network dominance.
+- **Zenith DAST:** Automated web vulnerability discovery (SQLi, XSS, SSRF).
+- **Nexus Dashboard:** Real-time web-based command center.
+
+## 🚀 Quick Install
+```bash
+pip install aura-framework
+```
+
+## 🛠️ Usage
+```bash
+# Launch the Zenith autonomous chain
+aura zenith example.com
+
+# Open the Nexus Command Center
+aura nexus
+```
+
+## 📜 License
+MIT License. Built for ethical security professionals and cyber dominance.

aura_framework-3.0.0/README.md

@@ -0,0 +1,29 @@
+# Aura: Zenith Singularity 🌌⚔️
+
+![Aura Header](https://raw.githubusercontent.com/username/repo/main/docs/header.png)
+
+**Aura** is a sentient, autonomous offensive security framework designed for elite reconnaissance, risk analysis, and deep-impact exploitation. It transforms from a simple scanner into a global offensive platform, featuring a professional command center (Aura Nexus) and AI-driven attack orchestration.
+
+## 🌌 Key Pillars
+- **Neural Intelligence:** AI Chain-of-Thought reasoning for strategic attack planning.
+- **Invisible Stealth:** JA3/TLS fingerprint randomization and behavioral humanization.
+- **Aura-Link:** Professional SOCKS5 pivoting for internal network dominance.
+- **Zenith DAST:** Automated web vulnerability discovery (SQLi, XSS, SSRF).
+- **Nexus Dashboard:** Real-time web-based command center.
+
+## 🚀 Quick Install
+```bash
+pip install aura-framework
+```
+
+## 🛠️ Usage
+```bash
+# Launch the Zenith autonomous chain
+aura zenith example.com
+
+# Open the Nexus Command Center
+aura nexus
+```
+
+## 📜 License
+MIT License. Built for ethical security professionals and cyber dominance.

aura_framework-3.0.0/aura/__init__.py

@@ -0,0 +1,2 @@
+# Aura Zenith Singularity
+__version__ = "3.0.0"

aura_framework-3.0.0/aura/api/__init__.py

@@ -0,0 +1 @@
+# Aura API Package

aura_framework-3.0.0/aura/api/server.py

@@ -0,0 +1,79 @@
+import os
+import sys
+import json
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.responses import HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+
+# Fix: Add current working directory to path to resolve 'aura' module
+sys.path.append(os.getcwd())
+
+from aura.core.storage import AuraStorage
+from aura.modules.scanner import AuraScanner
+from aura.modules.exploiter import AuraExploiter
+
+app = FastAPI(title="Aura Nexus API", version="3.0.0")
+db = AuraStorage()
+
+# Enable CORS for the React Frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class ScanRequest(BaseModel):
+    domain: str
+
+class Target(BaseModel):
+    id: int
+    source: str
+    type: str
+    value: str
+
+@app.get("/", response_class=HTMLResponse)
+def read_root():
+    """Serves the Zenith Nexus Dashboard."""
+    nexus_path = os.path.join(os.path.dirname(__file__), "nexus.html")
+    if os.path.exists(nexus_path):
+        with open(nexus_path, "r", encoding="utf-8") as f:
+            return f.read()
+    return "<h1>Aura Nexus API Online</h1><p>Dashboard file not found.</p>"
+
+@app.get("/targets", response_model=List[Target])
+def get_targets():
+    """Returns all discovered targets from the SQLite memory."""
+    return db.get_all_targets()
+
+@app.post("/scan")
+def launch_scan(request: ScanRequest, background_tasks: BackgroundTasks):
+    """Triggers a background scan for a domain."""
+    # This is a placeholder for the background execution logic
+    # In a full impl, we'd use a task queue or asyncio background tasks
+    return {"message": f"Scan initiated for {request.domain}", "status": "processing"}
+
+@app.get("/findings/{target_id}")
+def get_findings(target_id: int):
+    """Returns all findings associated with a specific target ID."""
+    target = db.get_target_by_id(target_id)
+    if not target:
+        raise HTTPException(status_code=404, detail="Target not found")
+    
+    findings = db.get_findings_by_target(target["value"])
+    return {"target": target, "findings": findings}
+
+@app.get("/screenshots")
+def list_screenshots():
+    """Lists all captured visual recon files."""
+    screenshot_dir = "screenshots"
+    if not os.path.exists(screenshot_dir):
+        return []
+    return [f for f in os.listdir(screenshot_dir) if f.endswith(".png")]
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

aura_framework-3.0.0/aura/core/analyzer.py

@@ -0,0 +1,45 @@
+import logging
+
+logger = logging.getLogger("aura")
+
+class CorrelationEngine:
+    """The 'Brain' that connects disparate data points into attack paths."""
+    
+    def __init__(self):
+        self.state = {
+            "targets": {},  # host -> data mapping
+            "high_risk_keywords": ["dev", "staging", "api", "admin", "vpn", "internal"],
+            "vulnerable_services": ["jenkins", "docker", "k8s", "redis", "mongodb"]
+        }
+
+    def correlate(self, results):
+        """Processes raw results and produces enriched 'Attack Paths'."""
+        attack_paths = []
+        
+        for res in results:
+            value = res.get("value", "").lower()
+            score = 0
+            findings = []
+
+            # 1. Keyword-based risk assessment
+            for word in self.state["high_risk_keywords"]:
+                if word in value:
+                    score += 10
+                    findings.append(f"High-risk keyword detected: {word}")
+
+            # 2. Service detection (simulated logic for now)
+            for svc in self.state["vulnerable_services"]:
+                if svc in value:
+                    score += 25
+                    findings.append(f"Potentially vulnerable service identified: {svc}")
+
+            # 3. Create an attack path object if score is significant
+            if score > 0:
+                attack_paths.append({
+                    "target": value,
+                    "risk_score": score,
+                    "insight": " | ".join(findings),
+                    "priority": "CRITICAL" if score >= 30 else "HIGH" if score >= 20 else "MEDIUM"
+                })
+
+        return sorted(attack_paths, key=lambda x: x["risk_score"], reverse=True)

aura_framework-3.0.0/aura/core/brain.py

@@ -0,0 +1,29 @@
+import logging
+
+logger = logging.getLogger("aura")
+
+class AuraBrain:
+    """The intelligence layer that explains attack paths and suggests exploits."""
+    
+    REASONING_PATTERNS = {
+        "admin": "Administrative panels are entry points for lateral movement and credential harvesting. Recommendation: Brute-force discovery of sub-directories (/admin, /wp-admin) or check for default credentials.",
+        "jenkins": "Jenkins instances often contain CI/CD secrets and SSH keys. If accessed, it could lead to a full Supply Chain compromise.",
+        "api": "Unprotected APIs often suffer from Broken Object Level Authorization (BOLA). Recommendation: Fuzz endpoints for IDOR vulnerabilities.",
+        "staging": "Staging environments are often less protected than production and may contain legacy data or debug symbols.",
+        "docker": "Exposed Docker registries or sockets can lead to container escape and host takeover.",
+        "vpn": "VPN endpoints are high-value targets for initial access. Recommendation: Check for known CVEs in the underlying software (Pulse Secure, Fortinet, etc.)."
+    }
+
+    def reason(self, target_data):
+        """Analyzes a target and provides strategic advice."""
+        value = target_data.get("target", "").lower()
+        insights = []
+
+        for pattern, explanation in self.REASONING_PATTERNS.items():
+            if pattern in value:
+                insights.append(explanation)
+
+        if not insights:
+            return "General reconnaissance target. Recommendation: Perform port scanning and service enumeration to identify potential attack surface."
+        
+        return "\n\n".join(insights)

aura_framework-3.0.0/aura/core/ingestor.py

@@ -0,0 +1,40 @@
+import sys
+import json
+import logging
+
+logger = logging.getLogger("aura")
+
+class Ingestor:
+    """Handles data ingestion from various sources."""
+    
+    @staticmethod
+    def read_stdin():
+        """Reads data from standard input."""
+        if sys.stdin.isatty():
+            return None
+        
+        data = sys.stdin.read()
+        return data
+
+    @staticmethod
+    def parse_json(data):
+        """Attempts to parse data as JSON."""
+        try:
+            return json.loads(data)
+        except json.JSONDecodeError:
+            return None
+
+    @staticmethod
+    def process_input(input_data):
+        """Generic input processor."""
+        # Check if it's a list of lines or a single string
+        lines = input_data.strip().split("\n")
+        results = []
+        for line in lines:
+            json_data = Ingestor.parse_json(line)
+            if json_data:
+                results.append(json_data)
+            else:
+                # Fallback to plain text recording
+                results.append({"raw": line})
+        return results

aura_framework-3.0.0/aura/core/neural_arsenal.py

@@ -0,0 +1,57 @@
+import json
+import logging
+from typing import Dict, List, Optional
+import requests
+
+logger = logging.getLogger("aura")
+
+class NeuralArsenal:
+    """The AI-driven engine for crafting unique, polymorphic payloads and strategies."""
+    
+    def __init__(self, provider: str = "ollama", base_url: str = "http://localhost:11434"):
+        self.provider = provider
+        self.base_url = base_url
+        self.model = "llama3" # Default high-performance model
+        self.system_prompt = (
+            "You are Aura-AI, a high-tier autonomous offensive security engine. "
+            "Your goal is to provide specific, technical, and actionable exploitation strategies "
+            "and polymorphic payloads. Keep it professional, concise, and technical."
+        )
+
+    def generate_strategy(self, target_info: Dict) -> str:
+        """Generates a custom exploitation strategy for a given target."""
+        prompt = (
+            f"Target: {target_info.get('value')}\n"
+            f"Observed Attributes: {target_info.get('type')}, Risk Score: {target_info.get('risk_score')}\n"
+            "Analyze this target and provide a 3-step exploitation strategy."
+        )
+        return self._query_ai(prompt)
+
+    def craft_payload(self, target_context: str, payload_type: str = "directory_fuzz") -> str:
+        """Generate a unique payload based on the target context."""
+        prompt = (
+            f"Context: {target_context}\n"
+            f"Generate a list of 5 polymorphic {payload_type} payloads. "
+            "Avoid common signatures. Make them creative."
+        )
+        return self._query_ai(prompt)
+
+    def _query_ai(self, prompt: str) -> str:
+        """Internal method to query the local AI provider."""
+        if self.provider == "ollama":
+            try:
+                response = requests.post(
+                    f"{self.base_url}/api/generate",
+                    json={
+                        "model": self.model,
+                        "prompt": f"{self.system_prompt}\n\nUser: {prompt}\nAssistant:",
+                        "stream": False
+                    },
+                    timeout=30
+                )
+                if response.status_code == 200:
+                    return response.json().get("response", "No AI response received.")
+            except Exception as e:
+                return f"[Fallback Logic] AI Offline. Error: {str(e)}\nRecommendation: Manual service enumeration and credential testing."
+        
+        return "AI Provider not supported or unreachable."

aura_framework-3.0.0/aura/core/orchestrator.py

@@ -0,0 +1,53 @@
+import json
+from aura.core.brain import AuraBrain
+from aura.modules.scanner import AuraScanner
+from aura.modules.exploiter import AuraExploiter
+from aura.modules.dast import AuraDAST
+from aura.modules.vision import VisualEye
+from rich.console import Console
+
+console = Console()
+
+class NeuralOrchestrator:
+    """The 'Sentient Brain' that orchestrates multi-step, logic-driven attack chains."""
+    
+    def __init__(self):
+        self.brain = AuraBrain()
+        self.scanner = AuraScanner()
+        self.exploiter = AuraExploiter()
+        self.dast = AuraDAST()
+        self.vision = VisualEye()
+
+    async def execute_advanced_chain(self, domain):
+        """Executes a Chain-of-Thought (CoT) attack plan autonomously."""
+        console.print(f"[bold magenta][🧠] NeuralOrchestrator: Developing Chain-of-Thought for {domain}...[/bold magenta]")
+        
+        # 1. Ask the Brain for a multi-step plan
+        context = {"target": domain, "capability": "full_zenith_arsenal"}
+        plan_raw = self.brain.reason(context)
+        
+        # 2. Extract logical steps (Simulated for Zenith)
+        steps = [
+            "Reconnaissance & Visualization",
+            "Vulnerability Correlation",
+            "Active DAST Probing",
+            "Strategic Exploitation",
+            "Reporting & Bounty Estimation"
+        ]
+        
+        console.print("[cyan][*] Plan formulated. Executing 5-step Zenith protocol...[/cyan]")
+        
+        # Step 1: Recon & Vision
+        results = self.scanner.discover_subdomains(domain)
+        await self.vision.capture_screenshot(domain, "zenith_initial")
+        
+        # Step 2: DAST Probing
+        vulns = await self.dast.scan_target(domain)
+        
+        # Step 3: Strategic Exploit
+        if vulns:
+            console.print(f"[bold red][!] Logic Triggered: High-risk vulnerabilities found. Initiating exploitation...[/bold red]")
+            # Logic to select correct module...
+            
+        console.print("[bold green][✔] NeuralOrchestrator: Zenith chain complete.[/bold green]")
+        return {"plan": plan_raw, "findings": vulns}

aura_framework-3.0.0/aura/core/reporter.py

@@ -0,0 +1,132 @@
+import sqlite3
+import json
+import os
+from jinja2 import Template
+from datetime import datetime
+
+class AuraReporter:
+    """Generates professional security reports from Aura's database."""
+    
+    HTML_TEMPLATE = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>AURA - Offensive Intelligence Report</title>
+        <style>
+            :root { --primary: #7d00ff; --danger: #ff0044; --bg: #0a0a0c; --text: #e0e0e0; }
+            body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background: var(--bg); color: var(--text); line-height: 1.6; padding: 40px; }
+            .container { max-width: 1000px; margin: 0 auto; }
+            header { border-bottom: 2px solid var(--primary); padding-bottom: 20px; margin-bottom: 40px; }
+            h1 { color: var(--primary); text-transform: uppercase; letter-spacing: 4px; font-size: 3em; margin: 0; }
+            .summary-box { background: #16161d; padding: 25px; border-radius: 8px; border-left: 5px solid var(--primary); margin-bottom: 30px; }
+            .target-card { background: #1c1c24; margin-bottom: 20px; padding: 20px; border-radius: 8px; border: 1px solid #333; }
+            .priority-CRITICAL { border-left: 5px solid var(--danger); }
+            .priority-HIGH { border-left: 5px solid #ffaa00; }
+            .priority-MEDIUM { border-left: 5px solid #00aaff; }
+            .screenshot-box { margin-top: 15px; border: 1px solid #444; border-radius: 4px; overflow: hidden; max-height: 300px; }
+            .screenshot-box img { width: 100%; height: auto; display: block; }
+            .badge { padding: 4px 10px; border-radius: 4px; font-size: 0.8em; font-weight: bold; }
+            .badge-red { background: var(--danger); }
+            table { width: 100%; border-collapse: collapse; margin-top: 15px; }
+            th, td { text-align: left; padding: 12px; border-bottom: 1px solid #333; }
+            th { color: var(--primary); text-transform: uppercase; font-size: 0.9em; }
+            .finding { color: #00ff88; font-family: monospace; font-size: 0.9em; }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <header>
+                <h1>AURA</h1>
+                <p>Offensive Intelligence Framework | Generated: {{ timestamp }}</p>
+            </header>
+
+            <div class="summary-box">
+                <h2>Executive Summary</h2>
+                <p>Total Targets Analyzed: <strong>{{ targets|length }}</strong></p>
+                <p>Critical Attack Paths Identified: <strong>{{ critical_count }}</strong></p>
+            </div>
+
+            <h2>Detailed Target Analysis</h2>
+            {% for target in targets %}
+            <div class="target-card priority-{{ target.priority }}">
+                <div style="display: flex; justify-content: space-between; align-items: center;">
+                    <h3>{{ target.value }}</h3>
+                    <span class="badge {% if target.priority == 'CRITICAL' %}badge-red{% endif %}">{{ target.priority }}</span>
+                </div>
+                <p><strong>Risk Score:</strong> {{ target.risk_score }} | <strong>Source:</strong> {{ target.source }}</p>
+                
+                {% if target.screenshot %}
+                <div class="screenshot-box">
+                    <img src="{{ target.screenshot }}" alt="Target Screenshot">
+                </div>
+                {% endif %}
+
+                {% if target.findings %}
+                <h4>Findings & Exploitations</h4>
+                <table>
+                    <thead>
+                        <tr>
+                            <th>Type</th>
+                            <th>Detail</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {% for finding in target.findings %}
+                        <tr>
+                            <td>{{ finding.finding_type }}</td>
+                            <td class="finding">{{ finding.content }}</td>
+                        </tr>
+                        {% endfor %}
+                    </tbody>
+                </table>
+                {% endif %}
+            </div>
+            {% endfor %}
+        </div>
+    </body>
+    </html>
+    """
+
+    def __init__(self, db_path="aura_intel.db"):
+        self.db_path = db_path
+
+    def generate_report(self, output_path="aura_report.html"):
+        """Compiles facts from the database and renders the HTML report."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+            
+            # Fetch targets
+            cursor.execute("SELECT * FROM targets ORDER BY risk_score DESC")
+            targets = [dict(row) for row in cursor.fetchall()]
+            
+            critical_count = 0
+            for target in targets:
+                if target["priority"] == "CRITICAL":
+                    critical_count += 1
+                
+                # Fetch findings for each target
+                cursor.execute("SELECT content, finding_type FROM findings WHERE target_id = ?", (target["id"],))
+                target["findings"] = [dict(row) for row in cursor.fetchall()]
+                
+                # Check if a screenshot exists in the filesystem
+                screenshot_path = f"screenshots/target_{target['id']}.png"
+                if os.path.exists(os.path.join(os.path.dirname(output_path), screenshot_path)):
+                    target["screenshot"] = screenshot_path
+                else:
+                    target["screenshot"] = None
+
+        # Render template
+        template = Template(self.HTML_TEMPLATE)
+        report_html = template.render(
+            targets=targets,
+            critical_count=critical_count,
+            timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        )
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(report_html)
+        
+        return output_path

aura_framework-3.0.0/aura/core/stealth.py

@@ -0,0 +1,66 @@
+from curl_cffi import requests as curlr
+import random
+import time
+from typing import Dict, Optional
+
+class StealthEngine:
+    """The Ghost Mode engine for anonymizing and diversifying Aura's traffic."""
+    
+    # Supported browser impersonations for JA3 randomization
+    IMPERSONATE_TYPES = ["chrome110", "chrome101", "safari15_5", "firefox108", "edge101"]
+    
+    USER_AGENTS = [
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (iPhone; CPU iPhone OS 17_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Mobile/15E148 Safari/604.1",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/119.0"
+    ]
+
+    def __init__(self, proxy_list: Optional[list] = None):
+        self.proxy_list = proxy_list or []
+
+    def get_stealth_params(self) -> Dict:
+        """Returns randomized stealth parameters for a request."""
+        return {
+            "impersonate": random.choice(self.IMPERSONATE_TYPES),
+            "headers": {"User-Agent": random.choice(self.USER_AGENTS)},
+            "proxies": self.get_proxy_dict()
+        }
+
+    def get_proxy_dict(self) -> Optional[Dict]:
+        """Returns a randomized proxy if available."""
+        if not self.proxy_list:
+            return None
+        proxy = random.choice(self.proxy_list)
+        return {"http": proxy, "https": proxy}
+
+class AuraSession:
+    """A high-stealth wrapper using curl_cffi for JA3 evasion."""
+    
+    def __init__(self, stealth: StealthEngine):
+        self.stealth = stealth
+
+    def request(self, method, url, **kwargs):
+        """Executes a request with JA3 impersonation, randomized headers, and behavioral jitter."""
+        params = self.stealth.get_stealth_params()
+        
+        # Behavioral Evasion: Human-like delay (jitter)
+        # Random delay between 0.5s and 2.5s for sensitive web requests
+        delay = random.uniform(0.5, 2.5)
+        time.sleep(delay)
+        
+        # Merge kwargs with stealth params
+        kwargs.setdefault("impersonate", params["impersonate"])
+        kwargs.setdefault("headers", params["headers"])
+        kwargs.setdefault("proxies", params["proxies"])
+        kwargs.setdefault("timeout", 15)
+        kwargs.setdefault("verify", False)
+        
+        return curlr.request(method, url, **kwargs)
+
+    def get(self, url, **kwargs):
+        return self.request("GET", url, **kwargs)
+
+    def post(self, url, **kwargs):
+        return self.request("POST", url, **kwargs)