stryx-cli 0.1.0__py3-none-any.whl

stryx/utils/evidence.py

@@ -0,0 +1,109 @@
+"""Evidence and Finding data models -- the core data types for all scan results.
+
+Every scanner MUST produce Findings with populated Evidence. This is enforced
+at the data-model level: constructing a Finding without Evidence raises ValueError.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+
+class Severity(StrEnum):
+    """Severity levels for findings."""
+
+    CRITICAL = "critical"
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+    INFO = "info"
+
+
+@dataclass
+class Evidence:
+    """Evidence supporting a security finding.
+
+    Every Finding MUST contain a non-empty Evidence. This ensures no
+    heuristic-only findings are reported without supporting data.
+    """
+
+    request_method: str
+    request_url: str
+    request_headers: dict[str, str] = field(default_factory=dict)
+    request_body: str | None = None
+    response_status: int = 0
+    response_headers: dict[str, str] = field(default_factory=dict)
+    response_body: str = ""
+    response_snippet: str = ""
+    payload: str = ""
+    confidence: float = 0.0  # 0.0 to 1.0
+
+    def __post_init__(self) -> None:
+        if not self.request_method or not self.request_url:
+            raise ValueError("Evidence must have request_method and request_url")
+        if not self.response_snippet and self.response_body:
+            # Auto-generate snippet from response body
+            self.response_snippet = self.response_body[:500]
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for serialization."""
+        return {
+            "request_method": self.request_method,
+            "request_url": self.request_url,
+            "request_headers": self.request_headers,
+            "request_body": self.request_body,
+            "response_status": self.response_status,
+            "response_headers": self.response_headers,
+            "response_body": self.response_body[:2000],  # cap for storage
+            "response_snippet": self.response_snippet,
+            "payload": self.payload,
+            "confidence": self.confidence,
+        }
+
+
+@dataclass
+class Finding:
+    """A security finding with mandatory evidence.
+
+    This is the universal output type for all scanners. No scanner may emit
+    a Finding without populated Evidence -- this is enforced by __post_init__.
+    """
+
+    title: str
+    severity: Severity
+    evidence: Evidence
+    description: str = ""
+    remediation: str = ""
+    cwe: str = ""
+    owasp: str = ""
+    endpoint: str = ""
+    scanner: str = ""
+    tags: list[str] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        if not self.evidence:
+            raise ValueError(
+                f"Finding '{self.title}' has no evidence. "
+                "All findings MUST include supporting Evidence."
+            )
+        if self.evidence.confidence < 0.0 or self.evidence.confidence > 1.0:
+            raise ValueError("Confidence must be between 0.0 and 1.0")
+        if not self.endpoint:
+            self.endpoint = self.evidence.request_url
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        return {
+            "title": self.title,
+            "severity": self.severity.value,
+            "description": self.description,
+            "remediation": self.remediation,
+            "cwe": self.cwe,
+            "owasp": self.owasp,
+            "endpoint": self.endpoint,
+            "scanner": self.scanner,
+            "tags": self.tags,
+            "evidence": self.evidence.to_dict(),
+        }

stryx/utils/http_client.py

@@ -0,0 +1,159 @@
+"""Async HTTP client wrapper with session cookies, rate limiting, and evidence collection."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from stryx.utils.evidence import Evidence
+from stryx.utils.rate_limiter import RateLimiter
+
+
+class HttpClient:
+    """Async HTTP client with session cookie jar, rate limiting, and evidence collection.
+
+    Maintains cookies across requests (Set-Cookie responses update the jar)
+    so authenticated sessions persist naturally.
+    """
+
+    def __init__(
+        self,
+        timeout: int = 10,
+        proxy: str | None = None,
+        rate_limit: int | None = None,
+        headers: dict[str, str] | None = None,
+        cookies: str | None = None,
+    ):
+        self.timeout = timeout
+        self.proxy = proxy
+        self.base_headers = headers or {}
+        self.rate_limiter = RateLimiter(rate_limit) if rate_limit else None
+        self._cookie_jar: dict[str, str] = {}
+
+        # Parse initial cookies from string
+        if cookies:
+            for pair in cookies.split(";"):
+                if "=" in pair:
+                    k, v = pair.split("=", 1)
+                    self._cookie_jar[k.strip()] = v.strip()
+
+    def _format_cookies(self) -> str:
+        """Format cookie jar as Cookie header string."""
+        return "; ".join(f"{k}={v}" for k, v in self._cookie_jar.items())
+
+    def _update_cookies_from_response(self, response: httpx.Response) -> None:
+        """Extract Set-Cookie headers and update the jar."""
+        for cookie in response.cookies.items():
+            self._cookie_jar[cookie[0]] = cookie[1]
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str] | None = None,
+        body: str | None = None,
+        json_data: dict | None = None,
+        cookies: dict[str, str] | None = None,
+        follow_redirects: bool = True,
+    ) -> tuple[httpx.Response, Evidence]:
+        """Make an HTTP request and return response with Evidence.
+
+        Cookies from the jar are sent automatically. Set-Cookie responses
+        update the jar for subsequent requests (session persistence).
+        """
+        if self.rate_limiter:
+            await self.rate_limiter.acquire()
+
+        merged_headers = dict(self.base_headers)
+        if headers:
+            merged_headers.update(headers)
+
+        # Merge explicit cookies into jar
+        if cookies:
+            self._cookie_jar.update(cookies)
+
+        request_headers = dict(merged_headers)
+
+        # Add cookies from jar
+        cookie_str = self._format_cookies()
+        if cookie_str:
+            merged_headers["Cookie"] = cookie_str
+
+        kwargs: dict[str, Any] = {
+            "timeout": httpx.Timeout(self.timeout),
+            "follow_redirects": follow_redirects,
+            "verify": False,
+        }
+        if self.proxy:
+            kwargs["proxy"] = self.proxy
+
+        try:
+            async with httpx.AsyncClient(**kwargs) as client:
+                response = await client.request(
+                    method=method,
+                    url=url,
+                    headers=merged_headers,
+                    content=body,
+                    json=json_data,
+                )
+
+                # Update cookie jar from response
+                self._update_cookies_from_response(response)
+
+                response_headers = dict(response.headers)
+                response_text = response.text
+
+                evidence = Evidence(
+                    request_method=method,
+                    request_url=url,
+                    request_headers=request_headers,
+                    request_body=body,
+                    response_status=response.status_code,
+                    response_headers=response_headers,
+                    response_body=response_text,
+                    response_snippet=response_text[:500],
+                    confidence=0.0,
+                )
+                return response, evidence
+
+        except httpx.RequestError as e:
+            evidence = Evidence(
+                request_method=method,
+                request_url=url,
+                request_headers=request_headers,
+                request_body=body,
+                response_status=0,
+                response_body=str(e),
+                response_snippet=str(e)[:500],
+                confidence=0.0,
+            )
+            error_response = httpx.Response(
+                status_code=0,
+                request=httpx.Request(method=method, url=url),
+            )
+            return error_response, evidence
+
+    async def get(self, url: str, **kwargs: Any) -> tuple[httpx.Response, Evidence]:
+        """Send GET request."""
+        return await self.request("GET", url, **kwargs)
+
+    async def post(self, url: str, **kwargs: Any) -> tuple[httpx.Response, Evidence]:
+        """Send POST request."""
+        return await self.request("POST", url, **kwargs)
+
+    async def put(self, url: str, **kwargs: Any) -> tuple[httpx.Response, Evidence]:
+        """Send PUT request."""
+        return await self.request("PUT", url, **kwargs)
+
+    async def delete(self, url: str, **kwargs: Any) -> tuple[httpx.Response, Evidence]:
+        """Send DELETE request."""
+        return await self.request("DELETE", url, **kwargs)
+
+    async def head(self, url: str, **kwargs: Any) -> tuple[httpx.Response, Evidence]:
+        """Send HEAD request."""
+        return await self.request("HEAD", url, **kwargs)
+
+    async def patch(self, url: str, **kwargs: Any) -> tuple[httpx.Response, Evidence]:
+        """Send PATCH request."""
+        return await self.request("PATCH", url, **kwargs)

stryx/utils/logging.py

@@ -0,0 +1,51 @@
+"""Logging configuration for STRYX using Rich."""
+
+from __future__ import annotations
+
+import logging
+
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.theme import Theme
+
+# Custom theme for STRYX
+STRYX_THEME = Theme({
+    "info": "cyan",
+    "warning": "yellow",
+    "error": "bold red",
+    "critical": "bold white on red",
+    "success": "bold green",
+    "severity.critical": "bold red",
+    "severity.high": "red",
+    "severity.medium": "yellow",
+    "severity.low": "blue",
+    "severity.info": "dim",
+})
+
+console = Console(theme=STRYX_THEME)
+
+
+def setup_logging(level: str = "INFO") -> logging.Logger:
+    """Configure Rich-based logging for STRYX."""
+    logger = logging.getLogger("stryx")
+    if logger.handlers:
+        return logger
+
+    logger.setLevel(getattr(logging, level.upper(), logging.INFO))
+
+    handler = RichHandler(
+        console=console,
+        show_path=False,
+        show_time=True,
+        markup=True,
+        rich_tracebacks=True,
+    )
+    handler.setFormatter(logging.Formatter("%(message)s"))
+    logger.addHandler(handler)
+
+    return logger
+
+
+def get_logger(name: str = "stryx") -> logging.Logger:
+    """Get a named logger under the stryx namespace."""
+    return logging.getLogger(f"stryx.{name}" if name != "stryx" else "stryx")

stryx/utils/rate_limiter.py

@@ -0,0 +1,37 @@
+"""Async rate limiter for controlling request frequency."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from collections import deque
+
+
+class RateLimiter:
+    """Token-bucket style async rate limiter.
+
+    Limits to `max_requests` requests per `window_seconds` period.
+    """
+
+    def __init__(self, max_requests: int = 20, window_seconds: float = 1.0):
+        self.max_requests = max_requests
+        self.window_seconds = window_seconds
+        self._timestamps: deque[float] = deque()
+        self._lock = asyncio.Lock()
+
+    async def acquire(self) -> None:
+        """Wait until a request slot is available."""
+        async with self._lock:
+            now = time.monotonic()
+            # Remove expired timestamps
+            while self._timestamps and self._timestamps[0] <= now - self.window_seconds:
+                self._timestamps.popleft()
+
+            if len(self._timestamps) >= self.max_requests:
+                # Wait until the oldest request expires
+                wait_time = self._timestamps[0] + self.window_seconds - now
+                if wait_time > 0:
+                    await asyncio.sleep(wait_time)
+                self._timestamps.popleft()
+
+            self._timestamps.append(time.monotonic())

stryx_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: stryx-cli
+Version: 0.1.0
+Summary: AI-Powered Dynamic Application Security Testing (DAST) -- part of the MEDUSA security platform
+Author-email: Akhilesh Varma <akhverm@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/Medusa-Security/stryx
+Project-URL: Repository, https://github.com/Medusa-Security/stryx
+Project-URL: Issues, https://github.com/Medusa-Security/stryx/issues
+Project-URL: Documentation, https://github.com/Medusa-Security/stryx/blob/main/docs/USAGE.md
+Project-URL: Changelog, https://github.com/Medusa-Security/stryx/blob/main/CHANGELOG.md
+Keywords: security,dast,dynamic-analysis,vulnerability-scanner,penetration-testing,web-security,api-security,owasp,sast,application-security
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: System :: Networking
+Classifier: Framework :: AsyncIO
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click<9,>=8.1
+Requires-Dist: rich<14,>=13.0
+Requires-Dist: httpx[socks]<1,>=0.25
+Requires-Dist: pydantic<3,>=2.0
+Requires-Dist: pyyaml<7,>=6.0
+Requires-Dist: jinja2<4,>=3.1
+Requires-Dist: openai<2,>=1.0
+Requires-Dist: anthropic<1,>=0.25
+Requires-Dist: groq<1,>=0.4
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: fastapi>=0.100; extra == "dev"
+Requires-Dist: uvicorn>=0.20; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Provides-Extra: xml
+Requires-Dist: lxml<6,>=4.9; extra == "xml"
+Provides-Extra: all
+Requires-Dist: stryx[xml]; extra == "all"
+Dynamic: license-file
+
+# STRYX
+
+**AI-Powered Dynamic Application Security Testing (DAST)**
+
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![Python Version](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![Build Status](https://github.com/medusa-Security/stryx/actions/workflows/ci.yml/badge.svg)](https://github.com/medusa-Security/stryx/actions)
+
+STRYX is a developer-first, AI-assisted DAST engine that crawls, maps, and tests the live attack surface of web applications. It discovers hidden endpoints, simulates real attacker behavior, and detects exploitable vulnerabilities with minimal false positives. Every finding carries full evidence (request, response, status code, payload, confidence score) -- no heuristic-only results.
+
+**Design philosophy: high signal, low noise.**
+
+## How It Fits Into MEDUSA
+
+- **Remy** -- SAST, analyzes source code pre-deployment.
+- **STRYX** -- DAST, validates a running application's live attack surface and exploitability.
+- **MEDUSA** -- Aggregates findings from both, correlates static and runtime issues, estimates business impact, provides centralized security management.
+
+## Architecture
+
+```
+CLI -> Configuration -> Attack Orchestrator -> { Endpoint Discovery }
+                                                        |
+                                         Authentication Engine
+                                         Authorization Engine
+                                         Injection Engine
+                                         API Fuzzer
+                                         AI Attack Planner
+                                         Evidence Collector
+                                         Report Generator
+                                                        |
+                                              Target Application
+```
+
+## Installation
+
+```bash
+# From PyPI
+pip install stryx
+
+# From source
+git clone https://github.com/medusa-Security/stryx.git
+cd stryx
+pip install -e .
+```
+
+## Quickstart
+
+```bash
+# Run a full scan
+stryx scan http://localhost:8000
+
+# Output:
+# STRYX Scan Results
+# Target: http://localhost:8000
+# Total Findings: 3
+# Breakdown: CRITICAL: 1 | HIGH: 1 | MEDIUM: 1
+```
+
+## Core Modules
+
+| Module | Purpose |
+|--------|---------|
+| Endpoint Discovery | Crawls targets, extracts APIs from OpenAPI/Swagger, sitemaps, JS files, GraphQL |
+| Authentication Scanner | Tests missing auth, weak JWTs, session fixation, cookie security |
+| Authorization Scanner | Tests IDOR, privilege escalation, admin access, multi-tenant escape |
+| Injection Engine | SQL, NoSQL, command, SSRF, path traversal, XXE, SSTI, LDAP injection |
+| API Fuzzer | Parameter mutation, boundary values, type confusion, nested JSON |
+| CORS Scanner | Detects misconfigured CORS policies and origin reflection |
+| GraphQL Scanner | Tests introspection exposure, query depth limiting |
+| AI Attack Planner | Constructs multi-step attack chains across findings |
+| Evidence Engine | Enforces evidence requirements on every finding |
+
+## CLI Reference
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `stryx scan <url>` | Run full security scan |
+| `stryx crawl <url>` | Crawl and discover endpoints |
+| `stryx auth <url>` | Run authentication tests |
+| `stryx fuzz <url>` | Run API fuzzing tests |
+| `stryx report <url>` | Generate reports |
+| `stryx config` | View/update configuration |
+| `stryx providers` | List supported AI providers |
+| `stryx update` | Update STRYX |
+
+### Flags
+
+| Flag | Description |
+|------|-------------|
+| `--deep` | Enable deep scanning |
+| `--json <file>` | Output JSON report |
+| `--html <file>` | Output HTML report |
+| `--markdown <file>` | Output Markdown report |
+| `--threads <n>` | Concurrent threads (1-200) |
+| `--timeout <s>` | HTTP timeout in seconds |
+| `--headers <json>` | Custom headers |
+| `--cookies <str>` | Authentication cookies |
+| `--proxy <url>` | HTTP proxy |
+| `--wordlist <file>` | Custom wordlist |
+| `--rate <n>` | Requests per second limit |
+
+## Configuration
+
+```yaml
+provider: groq
+model: llama-3.3-70b-versatile
+threads: 20
+timeout: 10
+crawl_depth: 5
+respect_robots: false
+ai_attack_planning: true
+modules:
+  auth: true
+  authorization: true
+  injection: true
+  fuzzing: true
+```
+
+Supported AI providers: Groq, OpenAI, Anthropic, OpenRouter, Ollama, XAI, NVIDIA NIM.
+
+## Sample Report
+
+```
++--------------------------------------------------------------------+
+| STRYX Scan Results                                                 |
+| Target: http://localhost:8000                                      |
+| Total Findings: 3                                                  |
+| Breakdown: CRITICAL: 1 | HIGH: 1 | MEDIUM: 1                     |
++--------------------------------------------------------------------+
+
+[#] [CRITICAL] Unauthenticated access to /admin
+    Endpoint: http://localhost:8000/admin
+    CWE: CWE-306 | Scanner: auth
+    Confidence: 70%
+    Evidence: GET http://localhost:8000/admin -> 200
+```
+
+## Roadmap
+
+### v0.1 (this build)
+
+- [ ] HTTP crawler
+- [ ] Endpoint discovery
+- [ ] Authentication scanning
+- [ ] Authorization testing
+- [ ] Basic injection testing
+- [ ] JSON/HTML reports
+
+### v0.5
+
+- [ ] Browser automation
+- [ ] GraphQL support
+- [ ] Multi-threaded fuzzing
+- [ ] AI attack planning
+- [ ] Custom payloads
+- [ ] Plugin SDK
+
+### v1.0
+
+- [ ] Autonomous attack chaining
+- [ ] Headless browser exploitation
+- [ ] CI/CD integration
+- [ ] Distributed scanning
+- [ ] Cloud dashboards (MEDUSA integration)
+- [ ] AI-powered exploit reasoning
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## Security Policy
+
+See [SECURITY.md](SECURITY.md) for reporting vulnerabilities in STRYX itself.
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE).
+
+## Author
+
+Built by Akhilesh Varma (ak495867) under Medusa Security.

stryx_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,74 @@
+stryx/__init__.py,sha256=S_izSu_FrzL4EFF0E2_Nd_hNYoTBgxL4zpdAVygT55A,1156
+stryx/cli.py,sha256=Et1hU9UhYQVTYkmaYs6kqhHrlgM0LmQQg3TvGyiLDl8,24111
+stryx/orchestrator.py,sha256=hdERxQQ64MR-7nZHeHqI0s854yARRj04sGuIKIFkm_0,13485
+stryx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stryx/ai/__init__.py,sha256=N4agk2G5KbVO9_uGLJyzjkGVIOOzmv-McDCYFY7fKhc,132
+stryx/ai/attack_planner.py,sha256=BhEo3EtyZDEreHPulysJYC6E6aHusrXJ3XufghNFzgI,7331
+stryx/ai/payload_generator.py,sha256=F88a9nHzCXkIhnVXhJdM4PA655Mhx4FwnP2q7Z9oH7U,6705
+stryx/ai/prompts.py,sha256=Ip8tvSygFDfZeXjewxCoa39PJ93JnndzNAlAnoZSq-Y,2931
+stryx/ai/providers.py,sha256=bO5tbN0wriRUGwlJCqYSFfVnExIW31vyp3xxHTbuJFM,9067
+stryx/attacks/__init__.py,sha256=O44X9KOBHdXnFbpakiZihAncrrSqmiJ-fxeRdoH6sHQ,193
+stryx/attacks/attack_chain.py,sha256=0zHEAAbeMiKty5SleVTJv9cE_VJBpkG2mRxE87r0Jh0,4123
+stryx/attacks/replay.py,sha256=wbNFPv1ZswXxAnbKkvfuwIytOgPY8wxyTB7SrYaz0Fc,7024
+stryx/auth/__init__.py,sha256=QgMP1kRWoVXpyzJzQaR6bsLOi5w8_fyckwUanAALE5k,55
+stryx/auth/session_manager.py,sha256=wtXoabxwe_hJ9YdVZh9jj_kSa8I2-CRAK9YjrtdFSnM,12803
+stryx/comparison/__init__.py,sha256=sGfy6rwPOo9bd5oV0Rs2KDPKYBS6Ehr4FXHknyY3a_Y,67
+stryx/comparison/differ.py,sha256=koUzauoMiZifVyDpnPXhvXUEJlwTXsUZ--l0n9rOe18,8895
+stryx/config/__init__.py,sha256=R_mHNoQOEqY61KAnI-btysnSzpBm4_rwayR11DwgKAY,219
+stryx/config/default_config.yaml,sha256=HkaAX1F5QL1xM1lrvIdbL95kMDG8HKGXMFqQA6ypPuI,206
+stryx/config/loader.py,sha256=KSgzJO03-xAzBJXKXhWO4-ytAu6Oj2RI4VDdkW_Mg7U,3864
+stryx/config/schema.py,sha256=LtBY0oT0DbHorcGgjk8GdxCb8DedUWkpXediOewdX7s,2642
+stryx/crawler/__init__.py,sha256=7aX59WiOKvIJhiu-IviCvUSEyjpTBfoBDY48U0i8BzE,171
+stryx/crawler/discovery.py,sha256=BwgRNpcY7mBajldqIIV5bVBat29T7BVRRE5BiqZizxU,6223
+stryx/crawler/graphql_discovery.py,sha256=wJfK_QSjFkkKLUPWxJsRmhmxV2g33ndNfJH7gstVOMU,2590
+stryx/crawler/html_crawler.py,sha256=DGkPucwBX3xkqpX1t9YzEVJJqyo-TP-1eDj_zZhBVF0,10395
+stryx/crawler/js_endpoints.py,sha256=AVKrS5m-D636xGgYxXAgWveVk8ulGFJ-pB25qy3Fp8I,6463
+stryx/crawler/openapi.py,sha256=tus4jYhezh9pItFHXshEiwKwfRlo61NErUZLf47YSxA,2466
+stryx/crawler/sitemap.py,sha256=yiR1i2DnYrFeNuzk-gfTFr0DSzSEOWVdL_8SOFCXRak,3214
+stryx/payloads/cmdi.txt,sha256=hMMuUgc2_aOOPEEegyAXN4q_fvEh-I0k6HHbZFKteow,462
+stryx/payloads/header_injection.txt,sha256=mohHBpMdv6xGWDn62SzS3gXMdmX4Oow7rbTbzAc1AXI,599
+stryx/payloads/ldap.txt,sha256=FvyGR4mUbl6wpWkCWLUPp237nS8pLLs5pc5-IhOOwNY,351
+stryx/payloads/nosqli.txt,sha256=hpBlSHImpoLRErpk5JPLC8v0x-CjSgppPHrJHUf6mBU,617
+stryx/payloads/open_redirect.txt,sha256=AkudcGqfeLxA37_l0mr-QNbqh3mXHjPGF2CpvaYTMVE,424
+stryx/payloads/path_traversal.txt,sha256=sTld--0__8f_QPvAdbMt3zK9sMXx-rJSLjdVg6DMV_c,647
+stryx/payloads/sqli.txt,sha256=ctDMdoakCn8WbIqkBIcopZLtUcrerEtObxyaOd_-j4c,936
+stryx/payloads/ssrf.txt,sha256=sfXyI856nZ4_udEr6OuJmMOM_1JJ_dAAZMXTTY3jO7Q,637
+stryx/payloads/ssti.txt,sha256=x4g7N8KGp0MJXmO3pWYwcYTyjRwDITkxnt9OqKvMkvM,813
+stryx/payloads/xss.txt,sha256=Co0_Q7H9VDj4Ahem7QQriqmZ12VXTP4QtU5vhLBLvf0,1814
+stryx/payloads/xxe.txt,sha256=NkzyZ3aHjMK6Osf4zbhwMkKmMGoHksgZQh3Gz_Oq5Vg,1395
+stryx/plugins/__init__.py,sha256=ypeTW9tc68QqwcnpG09_xl2w6W2Zt6nYsJfP73gVFE0,178
+stryx/plugins/base.py,sha256=6Wz7HR2gUk5p1a37FV2iiFdsm4qgKhdiys12i51WqN4,2335
+stryx/policy/__init__.py,sha256=qoY4uVnwSqVw7bjo8t6st54i8NXizsek714KzseNj0M,45
+stryx/policy/engine.py,sha256=mEOVlF15mQ2EFDvjW-KwxMqGZ47ICNRIj6GA9bGt5Y8,6733
+stryx/reports/__init__.py,sha256=jUHz6kg7J_5h78SAS71FAWUFZ-PTqp09SEaDfgGImFM,127
+stryx/reports/generator.py,sha256=Z7iZJVvYYexj8y6M947rH2cHWPhlvAkfALlT3dielqI,4245
+stryx/reports/json_report.py,sha256=L2dFNkuXImvEN66EreYuMmIs-wdp-ELPp4sbLFZloko,2458
+stryx/reports/markdown_report.py,sha256=oYthgmWR25gJR_j7CqJQ6CUqhfWAgVNAD_J3LkRVmsw,3750
+stryx/reports/sarif_report.py,sha256=FavrrnlppE1Ke4093kRl0dVYDsDscgiXtGWmfeBoPI8,6910
+stryx/reports/terminal_report.py,sha256=fsl634ZLrC5X8QLemmVv_NQa9XoNyKo_AQL_sEp37Oo,4893
+stryx/reports/templates/report.html.j2,sha256=UD3YAdly4uJKCXO3ro2tAm083cjZVSPw6R-UIEjYKuw,8480
+stryx/scanners/__init__.py,sha256=0Hmecn71GmRO3Di53ty4IrZE_6jB43GWOWndUnY-8_Q,478
+stryx/scanners/auth.py,sha256=xh51nxCl9a8CXP3qEbf7JUdIDsB2a-Qzf1tOo_oYmec,17078
+stryx/scanners/authorization.py,sha256=Hl_I2LmlPfpVgp4ZIcVA1nk72qcBqp_SLBssF235rmQ,8113
+stryx/scanners/blind.py,sha256=M3h3ELkefwbpkqv0dUTzJn3P63_TyUvxgva1fzGpPEU,14009
+stryx/scanners/cloud_ssrf.py,sha256=McINdyoaKRYu5Hv3yOxKFk_ppissdiQV0N5GfChNNDk,8137
+stryx/scanners/cors.py,sha256=Y5PC6lrLtwpYi3mVsHgF3aipDbGIBXPq9xBGhNRWzTw,5869
+stryx/scanners/dependencies.py,sha256=V1ly0-3TsQYA4LcVLdvDm2Zvr7CkizCUlQxzeBcET5k,12191
+stryx/scanners/disclosure.py,sha256=FWjYgUoSRTKkosTmT8Pygi0xqoSkrs4aJ82Ys1QfhaU,15342
+stryx/scanners/fuzz.py,sha256=vkrSDmFtiymUPTm1g_42kCsl9jp2BoCqc9i40I5SJiI,15279
+stryx/scanners/graphql.py,sha256=Ux71PFtPfF_IREdvOYH7vSdkgSRqkH6wF9tmm7EZtsU,12244
+stryx/scanners/injection.py,sha256=Xoi0BUNMXTX4_wSlYg9gPgcR3F5Wcdw-AW7_ujw0y8o,19129
+stryx/scanners/race.py,sha256=lTX1utTq8Fd78YfEN6jOBKdTZcAEOkFJbq8pIPR2gu4,9894
+stryx/signatures/framework_fingerprints.yaml,sha256=pdh_upEFMh7trgRCkqDHeN7aiPDLX5mN8iUgpN5qBcw,2479
+stryx/signatures/known_vulns.yaml,sha256=WW4hqJKHp-E-MGK3RcjcW2_tYIBCnpxsybe7xiYya3g,6309
+stryx/utils/__init__.py,sha256=43l-UFX8ifc9dF7DSRUoMyD1kSxqCQRnLjyd-sL3f70,245
+stryx/utils/evidence.py,sha256=WbcqPh_GKbuEibP97qKL8jiy6nYj02ulMBQ4W5efAZA,3598
+stryx/utils/http_client.py,sha256=Mmd2OLGwwPxqdf8D4aDzLttzgpunEKDyUgdR3d8kyOY,5612
+stryx/utils/logging.py,sha256=ttmZBCrBO9HEfxyH4_IoFRoKZpPx2kRIPVKZauYoeNs,1304
+stryx/utils/rate_limiter.py,sha256=L6H_xq-KYapoh4WRpOK08gT-irRnNKbj2Dcy138QXic,1251
+stryx_cli-0.1.0.dist-info/licenses/LICENSE,sha256=Ey3jWLx-ooBQMHASeVds3kmg6D6Ecakbg76Sev2_bPc,10765
+stryx_cli-0.1.0.dist-info/METADATA,sha256=jiNW8yYaDXNabi5-e6b2fKaMlZrtQVN3efIR4giXTh4,8345
+stryx_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+stryx_cli-0.1.0.dist-info/entry_points.txt,sha256=yD7annfJT3nYuGQAQ2LmhByIZtTcl68xGXgH3eX7vaQ,41
+stryx_cli-0.1.0.dist-info/top_level.txt,sha256=IAEyYP-Fs3MI8cybsIUFdFESepI90IKy7xqmkabIyzI,6
+stryx_cli-0.1.0.dist-info/RECORD,,

stryx_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stryx_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stryx = stryx.cli:main