mitmproxy is a production-grade, interactive HTTPS proxy that intercepts, inspects, modifies, and replays HTTP/1, HTTP/2, HTTP/3, WebSocket, TCP, UDP, DNS, and QUIC traffic. It supports multiple proxy modes (regular, transparent, reverse, upstream, SOCKS5, DNS, WireGuard, TUN, local) and provides three frontends: a console TUI (mitmproxy), a command-line dump tool (mitmdump), and a web UI (mitmweb). The architecture is event-driven with a sans-IO proxy layer design: protocol layers yield commands and events processed by an asyncio event loop. An extensive addon system allows users to extend functionality via lifecycle hooks, custom commands, and content views. The codebase is well-structured, heavily typed, and includes a comprehensive test suite with fuzzing and benchmarks. It is actively maintained with frequent releases and security patches.
Vigil is an open-source AI SOC (Security Operations Center) platform that orchestrates autonomous threat hunting, incident response, and case management through a multi-agent architecture. The system ingests security findings from SIEMs (Splunk, Elastic, Azure Sentinel), EDRs (CrowdStrike, Microsoft Defender), and other sources via Kafka or webhooks, then uses LLM-driven agents (hunt, root_cause, adjudicate, investigate, compose, chat) to analyze, enrich, and respond. A TypeScript agent layer with event-sourced ledgers and budget enforcement runs investigations, while a Python daemon handles polling, deduplication, and orchestration. The platform exposes its own tools via MCP (Model Context Protocol) and integrates with 30+ external security tools through a descriptor-based plugin system. The frontend is a React SPA with a setup wizard, dashboards, and case management UI. Deployment is via Docker Compose or Helm, with PostgreSQL, Redis, and optional Kafka as backing services.
Maltrail is a production-grade malicious traffic detection system that monitors network traffic in real-time, matching against a dynamic set of threat indicators (trails) and applying behavioral heuristics. It consists of two main components: a high-performance Rust sensor for packet capture and analysis, and a Python server for event intake, web dashboard, and API. The sensor uses libpcap for live capture or offline pcap replay, parses protocols (DNS, HTTP, TLS, QUIC), and performs trail matching and heuristic detection (port scanning, beaconing, DNS tunneling/exhaustion). Events are sent to the server via UDP or stored locally. The server provides a web UI for visualization, search, and management, supports remote logging to SIEMs (syslog, CEF, Logstash), and exposes a REST API for integration. The architecture is modular: the sensor is a multi-threaded Rust binary with lock-free metrics, memory-mapped trail stores, and fuzz-tested protocol parsers. The Python server handles configuration, trail updates from 40+ threat feeds, event logging, and the web interface. The system is designed for scalability with multi-worker capture, bounded memory heuristics, and efficient data structures (LRU caches, interned strings, hash tables). External dependencies include libpcap, SQLite, and various threat feed sources. The codebase demonstrates high craftsmanship with extensive testing (unit, integration, fuzz, parity tests between Rust and Python), CI/CD pipelines, and Docker/systemd deployment support.
nDPI is a production-grade open-source deep packet inspection (DPI) library written in C, developed primarily by ntop.org. It identifies hundreds of network protocols by inspecting packet payloads using static signatures, heuristics, state machines, and machine learning classifiers. The library extracts rich metadata (TLS fingerprints, DNS queries, HTTP headers, etc.), computes flow risks (malware, DGA, obfuscation, anomalies), and supports output serialization in JSON, CSV, or TLV formats. It is designed to be embedded into network monitoring applications such as ntopng, nProbe, and Wireshark (via a Lua extcap plugin), and also ships as a standalone CLI tool (ndpiReader) and Python bindings. The codebase is well-structured with a modular dissector pattern, extensive fuzzing infrastructure, and a comprehensive test suite. While the primary focus is on library reuse, it also contains research-grade components like DGA detection models (scikit-learn/TensorFlow) and time-series anomaly detection, giving it a hybrid character leaning heavily toward a software library.
OPNsense core is the central management and control plane for the OPNsense open-source firewall distribution. It implements a complete MVC web application (PHP) that provides a graphical user interface and RESTful API for configuring firewall rules, VPNs (IPsec, OpenVPN, WireGuard), DNS/DHCP services, traffic shaping, intrusion detection, captive portal, system settings, and monitoring. The backend relies on a custom daemon (`configd`) that executes actions via Unix socket, running Python and shell scripts for system-level operations (e.g., pfctl, ipfw, swanctl, wg). Configuration is stored in XML files and managed through an extensive model layer with field types, validators, and migrations. The system is deeply integrated with FreeBSD and uses FreeBSD-specific tools and kernel subsystems (pf, carp, netgraph). The architecture is a monolithic PHP MVC framework (originally based on Phalcon, now with a custom dispatcher) with a clear separation: controllers handle HTTP requests, models manage XML-based configuration, and views are Volt templates. The API controllers extend `ApiMutableModelControllerBase` and provide standard CRUD operations plus service actions (start, stop, reconfigure). System scripts are organized under `src/opnsense/scripts/` and are invoked by configd or system hooks. Dashboard widgets (JavaScript) fetch real-time data via API endpoints or event streams. External dependencies include FreeBSD base system tools, PHP (with Phalcon or custom replacement), Python 3, and libraries like ujson, requests. Key entry points are the web UI (`/index.php`), the API (`/api.php`), and the configd daemon (`configd.py`). Data flows primarily from user input through controllers to model validation, then to configd actions that generate configuration files (templates) or execute system commands. The system is actively maintained with frequent commits, extensive unit tests for both PHP and Python components, and a well-structured migration framework for upgrading configurations.
TrafficGuard is a Go-based CLI utility for network security that blocks known port scanners by configuring iptables/ip6tables and ipset. It downloads lists of malicious IP subnets, creates ipset sets, and configures firewall rules to drop traffic from these addresses. The tool includes optional logging with aggregation, automatic persistence of firewall rules across reboots via systemd services, and a comprehensive uninstall mechanism. It features intelligent integration with UFW (Uncomplicated Firewall) when present, with safeguards to prevent SSH lockout.
Outline Apps is a production-grade, open-source VPN ecosystem consisting of two primary applications: a cross-platform VPN client and a server manager. The client, built for Windows, macOS, Linux, Android, iOS, and the web, connects users to Shadowsocks-based proxy servers by creating a system TUN/TAP interface and relaying packets through a Go-based tun2socks core. It exposes a unified TypeScript UI across Electron, Cordova, Capacitor, and browser shells, with native VPN lifecycle management implemented in Go, Java/Kotlin, Swift/Objective-C, and C#. The server manager is an Electron/desktop and web application that provisions and administers Outline servers on DigitalOcean, Google Cloud, AWS Lightsail, and arbitrary Linux machines, including access-key management, bandwidth metrics, data limits, and OAuth-based cloud onboarding. The architecture is a monorepo that separates a Go networking core, TypeScript web UI layers, platform-specific native bridges, and an infrastructure library of shared utilities. The codebase demonstrates careful engineering in several areas: a composable YAML configuration registry for transport strategies (Shadowsocks, WebSocket, TCP/UDP, multi-hop), a generic IP routing table for split tunneling, structured cross-language error types, and a consistent method-channel abstraction for JavaScript-to-native IPC. Strong test coverage exists across Go packages, TypeScript modules, and native platform code, supported by an extensive CI matrix. However, the repository carries significant technical debt from an incomplete migration from Polymer to Lit, the coexistence of legacy Cordova and newer Capacitor mobile stacks, and numerous platform-specific build scripts. This is squarely an application repository, not a data or research project. The only data-related aspects are telemetry and anonymized usage metrics sent to Sentry and server-administrator-controlled collectors, which are operational concerns rather than research pipelines. Maintenance activity is current, with frequent commits, active issue triage, and a large contributor base, but the broad platform surface and legacy framework overlap make ongoing modernization costly.
Sniffnet is a cross-platform desktop GUI application for real-time network traffic monitoring and analysis, written in Rust using the Iced framework. It captures packets via pcap (live or from PCAP files) and also supports IPFIX flow collection over UDP. The application parses Ethernet, IP, TCP/UDP, ICMP, IGMP, ARP, and VLAN headers using a dedicated packet-parser library. It enriches captured traffic with geolocation (MaxMind GeoLite2 and IPinfo MMDB databases), ASN lookups, service identification (from a port-to-service map derived from nmap-services), and local process identification (via the listeners crate). The GUI provides multiple pages: an overview with live traffic charts and donut charts, an inspect page with a filterable and sortable connection table, a notifications page for alerts (thresholds, favorites, IP blacklists), and settings pages for themes, filters, and export. The application supports 25 languages, custom themes, and thumbnail mode for minimal monitoring. It is packaged for Linux (deb, rpm, AppImage), macOS (dmg), and Windows (msi), with CI/CD pipelines for cross-compilation and code signing.
T-Pot Community Edition (tpotce) is an all-in-one honeypot platform that orchestrates 20+ honeypots (e.g., cowrie, dionaea, conpot, heralding) alongside network security monitoring tools (p0f, Suricata, fatt) and the Elastic Stack (Elasticsearch, Logstash, Kibana) for centralized log storage, analysis, and real-time attack visualization. The system is deployed via Docker Compose with an Ansible-based installer supporting multiple Linux distributions. It offers several deployment flavors (standard, sensor, mini, LLM, tarpit, mobile) and supports a distributed Hive/Sensor architecture where remote sensors forward encrypted logs to a central Hive over HTTPS. Architecturally, each honeypot runs in an isolated container with read-only filesystems, non-root user, and dedicated networks. The ELK stack processes all telemetry: Logstash ingests JSON logs from persistent volumes, Elasticsearch indexes them, and Kibana provides dashboards and an attack map. A custom p0f (passive OS fingerprinting) fork is bundled and compiled from C source, demonstrating deep network-level analysis. The update and backup system (`update.sh`) is a robust, self-contained script that handles version pinning, configuration backups, Elasticsearch state exports, and image rollouts. The codebase includes a reusable test harness (`docker/_tests/lib/common.sh`) for validating individual honeypot containers with protocol-specific probes.
Firezone is a zero-trust network access platform providing secure remote access through VPN-like tunnels. The production system consists of a cloud-based management portal (Elixir/Phoenix), data-plane components (Rust gateways and relays), and native clients for macOS/iOS, Android, Windows, and Linux. The portal manages multi-tenant accounts, identity (OIDC, SAML, email OTP, X.509), access policies, device posture, and logs. It exposes a REST API (PortalAPI) for CRUD operations and WebSocket channels for real-time client/gateway connectivity. The Rust core (connlib) handles ICE/STUN/TURN connectivity, WireGuard tunnels, and eBPF-accelerated packet routing. PostgreSQL is used for persistence with logical replication for change data capture, Oban for background job processing, and Redis for caching/presence. External dependencies include identity providers (Entra, Okta, Google Workspace), device management systems (Intune, Defender, SentinelOne, etc.), log sinks (Splunk, Datadog, Elastic, S3), and billing (Stripe). The architecture separates the web admin interface (PortalWeb), REST API (PortalAPI), and internal ops (PortalOps) into distinct endpoints. Data-plane components (gateway, relay) communicate via WebSockets with the API to receive policy updates. Clients connect to relays using ICE/STUN/TURN. The system uses Phoenix PubSub for real-time updates and Postgres logical replication to propagate changes to connected clients and gateways. Key entry points: PortalWeb.Endpoint (admin UI), PortalAPI.Endpoint (REST/WebSocket for clients and gateways), PortalOps.Endpoint (ops dashboard). Rust binaries: firezone-gateway, firezone-relay, firezone-headless-client, firezone-gui-client. Mobile apps: Firezone iOS/macOS (Swift), Firezone Android (Kotlin).
JA4+ is a multi-protocol passive network fingerprinting suite that generates deterministic fingerprints for TLS, HTTP, SSH, TCP, DHCP, X.509, and latency characteristics. The repository provides four independent implementations: a Python reference library, a Rust CLI tool and library, a Wireshark post-dissector plugin, and a Zeek plugin (C++ BiF + Zeek scripts). All implementations share the same fingerprinting algorithm, test pcap files, and expected output snapshots, enabling cross-validation. The system processes raw packet captures (PCAP/PCAPNG) via tshark or direct packet parsing, extracts protocol handshake parameters (cipher suites, extensions, HTTP headers, SSH key exchange algorithms, TCP flags, DHCP options), normalizes them (GREASE removal, sorting, hashing), and outputs structured JA4+ fingerprints. External dependencies include tshark (for PCAP parsing in Python and Rust), Wireshark/Zeek APIs for plugins, and the ja4db.com database for fingerprint-to-software mapping. The architecture is a collection of standalone tools rather than a unified service, with each implementation optimized for its target environment (CLI, packet analyzer, network monitor). While primarily an application toolkit, the repository also includes research-oriented assets such as a fingerprint-to-software mapping CSV, technical documentation with diagrams, and a large corpus of real-world test traffic, making it a hybrid of production tooling and security research.
Proxelar is a high-performance, scriptable local traffic workbench for HTTP, HTTPS, and WebSocket debugging. It functions as a man-in-the-middle (MITM) proxy that can capture, inspect, intercept, modify, replay, and export traffic across multiple protocols (HTTP/1.1, HTTP/2, HTTP/3, WebSocket, SOCKS5, DNS, UDP, and WireGuard). The system is built as a Rust workspace with four crates: `proxelar-cli` (binary with TUI, terminal, and web GUI interfaces), `proxyapi` (core proxy engine with TLS interception, Lua scripting, addon system, route rules, and session export/import), `proxelar-proto` (transport-neutral HTTP core with sans-I/O parsers for HTTP/1 and HTTP/2), and `proxyapi_models` (shared data types for headers, sessions, and captured exchanges). It supports forward and reverse proxy modes, declarative JSON routing rules, Lua addons with SHA-256 verification, and exports to HAR, curl, and raw formats. The architecture is modular with clean dependency direction, extensive integration tests, performance benchmarks, and property-based testing. It is a production-quality developer tool comparable to mitmproxy or Charles Proxy, with a focus on performance, correctness, and extensibility.
This repository is the infrastructure-as-code backbone for Security Onion, a free and open Linux distribution for threat hunting, enterprise security monitoring, and log management. It contains over 1,700 files of SaltStack states, Jinja templates, shell scripts, and Python modules that orchestrate the deployment, configuration, and lifecycle management of a distributed grid of security monitoring nodes. The code manages the entire Elastic Stack (Elasticsearch, Logstash, Kibana), network sensors (Zeek, Suricata), file analysis (Strelka), endpoint monitoring (Elastic Fleet/Agent), authentication (Kratos/Hydra), messaging (Kafka/Redis), metrics (Telegraf/InfluxDB), and the Security Onion Console (SOC) web UI. It is not a standalone application but a deployment and configuration system that transforms a bare OS into a fully operational security operations center. The repository is actively maintained with frequent commits, versioned releases, and a large community. Key architecture patterns include role-based state inclusion via `allowed_states`, consistent Docker container management, Jinja-based configuration merging, and event-driven reactors for rule pushes. Notable reusable components include a self-contained threat intelligence analyzer framework, a YAML manipulation CLI tool, and polling-based beacons that avoid inotify leaks.
Zui (formerly Brim) is an Electron-based desktop application for network security monitoring and data exploration. It provides a graphical interface to query and visualize data stored in a Zed/SuperDB lake, with a focus on Zeek and Suricata log analysis. The application supports importing packet captures (pcap), structured logs (Zeek TSV, NDJSON, CSV, Parquet), and offers a rich query editor (Monaco), histogram, table/inspector views, and export workflows. The codebase is a monorepo (Yarn workspaces, Nx) with packages for type definitions (`superdb-types`), a Node.js client (`superdb-node-client`), sample data, and an e2e test framework (`app-player`). The architecture follows a domain-driven pattern with handlers and operations, a Redux store with versioned state migrations, and a plugin system for extensibility. While the application is actively maintained and functionally rich, it exhibits some technical drift due to a mix of legacy and modern patterns, a large migration history, and tight coupling between core and plugins.
V2Ray-core is a Go-based network proxy and tunneling platform designed to help users build private networks and bypass censorship. It functions as a modular proxy framework supporting multiple protocols (VMess, VLess, Trojan, SOCKS, HTTP, MTProto, Shadowsocks) and transport layers (TCP, mKCP, WebSocket, HTTP/2, QUIC, Domain Socket, XTLS). The architecture is highly modular: the core runtime manages features (dispatcher, router, DNS, stats, policy, log) as pluggable components, while proxy implementations and transports are registered via a global config-creator registry. Entry points are the main binary (v2ray) and a control utility (v2ctl) for config conversion, signing, and diagnostics. Data flows from inbound handlers through a dispatcher that routes connections by destination, protocol sniffing, and routing rules to outbound handlers, which then dial remote servers over the configured transport. External dependencies include gorilla/websocket, quic-go, miekg/dns, go-proxyprotocol, VSign for binary signing, and xtls/go for extended TLS. The codebase demonstrates strong engineering in its layered abstraction: common/ provides reusable, low-level primitives (buffered I/O with MultiBuffer, retry logic, crypto streams, session context, platform path handling), while features/ defines clean interfaces for routing, DNS, stats, and policy that the app/ layer implements. The transport layer is particularly well-designed, with each protocol isolated behind a common Dial/Listen interface and supporting pluggable packet headers for traffic obfuscation (e.g., faking WeChat video, SRTP, UTP, WireGuard, DTLS). The string matcher (strmatcher) uses a trie for domain matching and supports full, substring, keyword, and regex patterns with index-based grouping. The custom buf package provides a lightweight buffer pool and vectored I/O reader (readv) for performance. The error handling uses a structured errors package with path objects for source location. However, the repository shows signs of stagnation. The README explicitly redirects to v2fly/v2ray-core, indicating this is the legacy v2ray organization's repo. The last commit was in April 2026, but the go.mod targets Go 1.15 (released 2020), and many dependencies are pinned to pre-1.0 versions (quic-go v0.18.1, grpc v1.32.0, protobuf v1.25.0). The CI workflows have conditions like `if: github.repository != 'v2ray/v2ray-core'` suggesting they are disabled for this fork. The codebase contains extensive generated code (errors.generated.go, config.pb.go) and mock files. The XTLS integration references an external fork (xtls/go) rather than the standard crypto/tls. The custom Chacha20 implementation uses code generation for the core block function. While the architecture is sound, the dependency versions and Go version target are significantly behind current ecosystem standards.
This repository is a large collection of standalone Python scripts designed for the Termux environment on Android. It is marketed as an educational cybersecurity toolkit but contains functional phishing pages, credential harvesters, location trackers, camera/mic capture scripts, and a trojan for data exfiltration. The codebase also includes some legitimate utilities such as a password manager, file converter, network scanner, and backup tool. The architecture is highly fragmented: each script is self-contained with its own dependency auto-installation, Flask server, and cloudflared tunnel for public exposure. There is no shared module structure, and the code is heavily duplicated across English and Greek translations. The overall quality is low due to copy-paste patterns, hardcoded secrets, suppressed error logging, lack of testing, and reliance on external services like cloudflared. The repository poses significant legal and ethical risks due to its phishing and surveillance capabilities.