thehardwarestore.ai

Strix is an open-source, AI-powered penetration testing tool that orchestrates multiple LLM-driven agents to autonomously discover and validate security vulnerabilities in web applications, APIs, source code, and infrastructure. The system operates as a CLI application with three interface surfaces: a headless/non-interactive mode for CI/CD pipelines, a feature-rich Go Bubble Tea TUI for interactive scanning, and a local React web viewer for reviewing results. Scans run inside Docker sandboxes with a Caido interception proxy sidecar, allowing agents to execute shell commands, browse applications, modify requests, and apply patches. The architecture follows a multi-agent coordination pattern where a root agent delegates tasks to child agents, tracks coverage, manages budgets, and produces comprehensive reports including CVSS-scored vulnerabilities, proof-of-concept exploits, and fix recommendations. The codebase demonstrates strong engineering practices with extensive test coverage, atomic file operations, output bounding, MCP tool integration, and a sophisticated IPC protocol between the Python backend and Go TUI. Key features include: multi-agent orchestration with parent/child messaging and budget enforcement; Docker sandboxed execution with Caido proxy integration; support for multiple LLM providers (OpenAI, Anthropic, LiteLLM, Bedrock, etc.); MCP (Model Context Protocol) tool integration; SARIF and PDF report generation; cloud platform integration for managed scans; and a local web viewer with live transcript and vulnerability triage. The repository is primarily an application but includes data-oriented components like LLM cost tracking, coverage ledgers, and vulnerability deduplication using LLM-based comparison.

Decepticon is an autonomous AI-powered red team agent platform for offensive security engagements. It orchestrates multiple LLM-based agents (recon, exploit, AD, cloud, etc.) via LangGraph to execute complex, realistic attack chains against targets, with strict Rules of Engagement (RoE) enforcement, sandboxed execution, and human-in-the-loop approval. The system provides a web dashboard (Next.js), CLI (Ink), and MCP server for control and monitoring, and includes a plugin system for extensibility. It also features comprehensive benchmark frameworks for evaluating agent performance on security challenges. The architecture is a multi-service Docker Compose deployment with Python backend services, a Go launcher, Neo4j knowledge graph, and high isolation between management and sandbox networks. This is primarily a software application (automated red team orchestrator) with strong data/research elements such as knowledge graph persistence, benchmarking pipelines, and telemetry collection. The codebase demonstrates high craftsmanship with protocol-based plugin contracts, a well-structured middleware stack, and thorough testing, though the polyglot nature and dual client maintenance add complexity.

Shannon is an autonomous, white-box AI penetration testing platform that orchestrates multi-agent workflows via Temporal to analyze source code, identify attack vectors, and execute real exploits against running web applications. The system is structured as a pnpm monorepo with two primary applications: a CLI (`apps/cli`) that provides the user-facing interface for launching scans, and a worker (`apps/worker`) that runs the actual pentest pipeline inside Docker containers. The architecture follows a multi-agent pipeline pattern with 13 specialized agents (pre-recon, recon, 5 vulnerability analyzers, 5 exploiters, and a report generator) coordinated through Temporal workflows for reliability and resumability. The codebase demonstrates strong software engineering practices with a clear separation of concerns between Temporal orchestration (activities/workflows), pure domain logic (services), and infrastructure concerns. The worker implements a sophisticated DI container pattern, comprehensive audit logging with crash-safe append-only streams, and a custom error classification system that maps errors to Temporal retry behavior. The system supports multiple LLM providers (Anthropic direct, AWS Bedrock, Google Vertex AI, custom proxies) and implements defense-in-depth billing detection, git checkpointing for workspace rollback, and parallel agent execution with mutex-protected shared state. Key architectural strengths include the deterministic renderer pattern (MCP tool calls → markdown without LLM in the loop), the injectable provider interfaces for extensibility, and the sophisticated session management that enables resumable workspaces. The codebase uses TypeScript with strict compiler options, implements a Result type for explicit error handling, and maintains comprehensive type definitions. The CI/CD pipeline includes semantic releases, Docker image signing with cosign, and multi-platform builds. The system processes vulnerability queues through Zod-validated structured outputs and maintains forensic audit trails of all agent executions with timing, cost, and model metadata.

gosec is a production-grade static analysis security scanner for Go source code. It analyzes Go programs by traversing the AST and SSA representations to detect a wide range of security vulnerabilities, including SQL injection, command injection, path traversal, cross-site scripting (XSS), hardcoded credentials, weak cryptography, TLS misconfigurations, and more. The tool is distributed as a CLI binary, a Docker image, a GitHub Action, and a reusable Go library. The architecture is modular: a core analysis engine loads Go packages, applies AST-based rules and SSA-based analyzers, and runs a configurable taint analysis engine that tracks data flow from user-controlled sources to dangerous sinks. Results are output in multiple formats (text, JSON, SARIF, CSV, JUnit, HTML, SonarQube, golint, YAML). The tool also integrates with AI providers (OpenAI, Claude, Gemini, Atlas) to suggest automated fixes for detected vulnerabilities. Notable design highlights include a generic LRU cache for regex matching, a path-based rule exclusion filter, a comprehensive CWE knowledge base, and a well-abstracted taint analysis configuration system. The codebase demonstrates strong engineering practices with extensive test coverage, performance benchmarks, and CI/CD pipelines for release and scanning.

Nebula is a local-first security assessment workbench designed for penetration testing and red teaming operations. It functions as a desktop application built with a Tauri shell (Rust) wrapping a React/TypeScript frontend and a Python FastAPI backend sidecar. The system manages security engagements, scope policies, evidence collection, and AI-assisted analysis, emphasizing operator control, auditability, and data privacy through local-first execution and content-addressed artifact storage. The architecture follows a sidecar pattern where the Python Core service handles database operations (SQLite with Alembic), containerized command execution (Kali Linux via Docker/Podman), and AI provider integration. The frontend manages the UI state and terminal sessions via WebSocket. Key data flows involve user actions triggering API calls that validate against scope policies before executing commands in isolated containers, with all outputs stored as immutable artifacts for evidence integrity. The codebase demonstrates strong engineering practices with extensive test coverage (Pytest, Vitest, Playwright), a robust diagnostic system with secret redaction, and a policy engine for deterministic scope enforcement. It supports multiple AI providers and includes features for knowledge indexing, mission orchestration, and report generation. The project is actively maintained with recent commits and zero security alerts, though it is currently in alpha release.

Xonsh is a cross-platform, Python-powered interactive shell that combines Python syntax with shell subprocess commands. The codebase implements a full shell environment with a custom parser (PLY-based with version-specific extensions), an execution engine that compiles xonsh code to Python AST, a rich tab-completion system with multiple backends (bash, git, pip, python, custom completers), a pluggable history backend (JSON, SQLite), a prompt system with git status and virtualenv information, and a subprocess management layer with job control. It also includes CLI tools for formatting, linting, and interactive configuration (xonfig wizard and web UI). The architecture is monolithic with a clear module structure: parsers, executers, completers, prompts, history, procs, and shells. External dependencies include prompt_toolkit, pygments, and PLY (vendored). The repository is actively maintained with frequent releases, supports Python 3.10+, and has an extensive test suite. Some technical drift exists due to deprecated API shims, multiple parser versions, and LLM-generated tests, but the core is well-engineered.

This repository is a comprehensive, modular Android application security auditing framework designed for AI agents and security engineers. It automates the entire assessment lifecycle, from APK ingestion and static analysis to dynamic instrumentation, RASP (Runtime Application Self-Protection) detection and bypass, and professional reporting aligned with OWASP MASTG and MASVS v2 standards. The architecture is a well-organized toolkit of Python, Bash, and JavaScript (Frida) scripts, orchestrated by shell entry points and sharing a common library (`scripts/lib/`). Key capabilities include a 37+ script Frida arsenal for runtime manipulation, a Semgrep rule set for static vulnerability detection, a DRY bypass profile system for countering RASP solutions, and a weighted scoring engine for MASVS compliance. The codebase emphasizes modularity, schema-driven findings, and CI/CD integration. While the codebase demonstrates strong engineering practices and contains several genuinely reusable components (findings pipeline, Frida script templates, compliance scoring models), its heavy reliance on the rapidly evolving Android and Frida ecosystems introduces a medium level of technical drift. The presence of speculative content on unreleased Android versions and deprecated API references are noted risks. Overall, it is a high-quality, production-grade security toolkit that effectively bridges the gap between manual pentesting and automated security pipelines.

DefectDojo is an open-source application security posture management (ASPM) and vulnerability management platform. It ingests scan results from over 100 security tools (SAST, DAST, SCA, container, cloud, secrets, infrastructure) via a consistent parser interface, normalizes findings, deduplicates them, and tracks remediation workflows across engagements and products. The system is a Django monolith with a REST API (Django REST Framework), Celery async workers for imports, SLA enforcement, and JIRA/GitHub sync, PostgreSQL for persistence, and Valkey/Redis as the message broker. Key entry points include the Django admin UI, DRF API viewsets, and Celery task dispatchers. External dependencies are PostgreSQL, Redis/Valkey, and optional integrations with JIRA, Slack, Microsoft Teams, and SSO providers (LDAP, OAuth2, SAML). The repository includes a Pro edition layer with additional features (custom RBAC, audit logging, priority SLA) that coexist with the open-source core via feature flags and conditional imports. The codebase demonstrates strong engineering with a well-defined parser factory pattern, prefetch mixins for API efficiency, SSRF-safe HTTP clients, and a request-level caching system, though it carries some technical debt from an ongoing V3 location model migration and numerous deprecated endpoints slated for removal.

KubeHound is a security analysis tool for Kubernetes clusters that automatically models and computes attack paths. It collects Kubernetes resources (pods, roles, bindings, endpoints, nodes) via a live API or offline dump, transforms them into a property graph stored in JanusGraph (with MongoDB as an intermediate store), and computes privilege escalation and lateral movement paths mapped to MITRE ATT&CK techniques. The system exposes a CLI for local analysis and a gRPC API (KHaaS) for service-oriented deployments, with optional Jupyter notebooks for querying the graph using a custom Gremlin DSL. The architecture is modular: a collector abstraction handles rate-limited streaming from the Kubernetes API; an ingestion pipeline converts raw objects into normalized store models and graph vertices/edges; an edge registry defines over 20 attack types (e.g., PodExec, TokenSteal, ContainerEscape); and a graph builder executes Gremlin traversals to connect vertices into paths. Storage layers use asynchronous writers with micro-batching for high throughput, and an in-memory cache deduplicates identities and roles. Telemetry (Datadog APM, metrics, logs) is integrated throughout. While primarily an application, the repository includes experimental research components (exp/khaudit) for audit reports and MITRE Attack Flow conversion, plus Jupyter notebooks for interactive graph queries, giving it a hybrid character. The codebase demonstrates strong engineering practices: provider interfaces, test mocking, worker pools, retry logic, and comprehensive system tests against real Kind clusters. However, some areas (large cluster optimizations, experimental code, deprecated flags) indicate ongoing evolution and minor technical debt.

Pentest-Swarm-AI is an open-source autonomous penetration testing tool built on a stigmergic swarm architecture. It coordinates multiple LLM-driven specialist agents (recon, classifier, exploit, report) via a shared blackboard with pheromone decay, enabling emergent attack paths without a central planner. The system integrates 30+ external security tools (nmap, nuclei, sqlmap, etc.), multiple LLM providers (Claude, OpenAI, Ollama, Gemini, LM Studio), and bug bounty platforms (HackerOne, Bugcrowd, Intigriti) for automated scope import and report submission. The architecture is a multi-agent system with a scheduler that dispatches agents based on blackboard predicates and pheromone levels. Key entry points include a CLI (Cobra commands: scan, init, playbook, submit, etc.), an API server (Fiber), a WebSocket hub for live streaming, a Next.js web dashboard, and an MCP server for IDE integration. Data flows: agents write findings to the blackboard with pheromone weights; the scheduler reads the blackboard and triggers agents whose predicates match; agents read findings, process them, and write new findings, creating a stigmergic feedback loop. External dependencies include PostgreSQL with pgvector for durable blackboard storage, LLM API endpoints, and the installed security tool binaries. The codebase demonstrates high craftsmanship with clean abstractions (tool adapter pattern, LLM provider interface, blackboard interface), extensive testing (unit, integration, e2e, benchmarks, LLM eval), and safety features (scope enforcement, provenance signing, rate limiting, false-positive caching). It is actively maintained with recent commits, CI/CD pipelines, and community engagement.

This repository provides a collection of 52 specialized AI agent definitions for penetration testing and red team operations, designed to be used with Claude Code. It is distributed as a Claude Code plugin, with an interactive installer (install.sh), a SQLite findings database (db/findings.sh) for persisting engagement data, and a versioned migration system. The agents are defined as Markdown files with YAML frontmatter, each containing structured system prompts that enforce scope validation, OPSEC tagging, evidence handling, and MITRE ATT&CK mapping. The system includes a swarm orchestrator for multi-agent coordination, a scope guard for safety, and a two-tier safety model (advisory vs. Bash-capable agents). While primarily a configuration/instruction set rather than a traditional software application, it demonstrates strong engineering practices in prompt architecture, database schema design, and distribution automation. The repository is actively maintained with CI validation, shellcheck, and unit tests for the database scripts.

This repository is a community-maintained toolkit for Microsoft Defender for Cloud (MDC), providing automation, configuration, and operational assets to extend and manage MDC capabilities. It contains hundreds of Azure Policy definitions, Logic App playbooks, PowerShell scripts, Azure Workbooks, and infrastructure-as-code templates (ARM, Bicep, Terraform) for enabling security controls, remediating recommendations, exporting security data, and integrating with external systems like Azure DevOps, ServiceNow, and Microsoft Sentinel. The repository also includes a production-grade connector (MDC Recommendations to Azure DevOps) built with Python Durable Functions, managed identity authentication, and modular Bicep infrastructure. Architecturally, the repo is a collection of loosely coupled, deployable artifacts rather than a single application. The most sophisticated component is the MDC-to-ADO connector, which uses an HTTP-triggered Durable Function to orchestrate enrichment (via Azure Resource Graph, Microsoft Graph, and MDC APIs), deduplication, and work item creation/update in Azure DevOps. It employs a consistent client pattern with tenacity retry, token caching, and OpenTelemetry tracing. Other notable patterns include DeployIfNotExists Azure Policies that create security automations, Logic Apps with managed identity for alert response, and PowerShell scripts for bulk operations and cost estimation. While the repository is actively maintained and contains several high-quality, reusable components, it also exhibits technical drift: many artifacts reference the deprecated 'Azure Security Center' name, use preview API versions, or contain hardcoded placeholder values. The overall quality is functional but uneven, with some components being production-ready and others requiring manual configuration or updates. The repository is best suited for security engineers and cloud architects looking for battle-tested automation patterns and reference implementations for Microsoft Defender for Cloud.

This is an educational repository of Python scripts, mini-projects, and markdown guides for building LLM-based AI agents applied to cybersecurity. The code is organized into five progressive parts: foundational LLM/embeddings usage, prompt templates, prompt chaining, RAG over security data, and agentic workflows. It demonstrates multiple agent frameworks (LangChain, LangGraph, CrewAI, DeepAgents) and MCP server integrations for tools like nmap and Shodan. The dominant character is application/tutorial code rather than data research, although it bundles small datasets (CVE embeddings, sample RAG corpora) and commits Chroma vector stores for offline exercises. The repo is not a single deployable service; it is a collection of entry-point scripts and small frameworks. Architecture is a set of standalone examples with shared patterns: state graphs for orchestration, YAML-configured crews, MCP adapters, and RAG ingestion/query pipelines. Most scripts require OpenAI-compatible API keys and/or local tools such as nmap/Ollama. Simulated data and placeholder responses in some examples make it a learning environment rather than production security tooling. Maintenance is current but drift is moderate: some examples use deprecated langchain vectorstore imports, documentation is duplicated across subdirectories, several referenced files are missing, and hardcoded model strings like gpt-5.4-mini appear dated or fictional. There is no root-level automated test suite; only the Shodan MCP subproject contains tests. The strongest reusable patterns are the MCP server wrapping, LangGraph conditional-state orchestration, CrewAI declarative crew configuration, and the hierarchical SOC agent supervisor.