Trivy is a comprehensive, production-grade security scanner for container images, filesystems, Git repositories, Kubernetes clusters, cloud infrastructure (IaC), and virtual machines. It detects vulnerabilities in OS packages and language-specific dependencies, scans for IaC misconfigurations (Terraform, CloudFormation, ARM, Ansible, Helm, Dockerfile), secrets, and license compliance. The architecture is modular: a CLI entry point (`cmd/trivy/main.go`) orchestrates scanning via a file analysis engine (`pkg/fanal`), dependency parsers (`pkg/dependency/parser`), vulnerability detectors (`pkg/detector`), IaC scanners with Rego-based policies (`pkg/iac`), and multiple output formats (JSON, SARIF, CycloneDX, SPDX, table, etc.). It supports client-server mode via gRPC, a plugin system, WASM modules, and VEX/SBOM attestation integration. The codebase is well-structured with clear separation of concerns, extensive test coverage, and many reusable utility packages (parallel processing, generic sets, caching, version constraints, license expression parsing). It is actively maintained with frequent releases and a large community.
Falco is a cloud-native runtime security daemon that monitors Linux system calls, Kubernetes audit logs, and plugin-supplied events in real time. It applies a flexible rule engine to detect anomalous behavior and generates alerts via multiple output channels (stdout, file, syslog, HTTP, program). The codebase is a monolithic C++ application with a modular internal architecture: a sequenced action pipeline (app/app.cpp) drives startup, configuration, plugin loading, rule compilation, event processing, and output dispatch. The rule engine (userspace/engine/) parses YAML rule definitions, resolves macros and filters, indexes rules by event type, and matches events efficiently. The output subsystem uses a thread-safe worker queue with a watchdog. Falco supports hot-reload via inotify file watching and a Unix socket control endpoint. It is deployed as a Helm chart on Kubernetes (DaemonSet/Deployment) and is packaged as DEB, RPM, and Docker images. The repository includes extensive unit tests (Google Test), end-to-end event generator tests, and CI/CD pipelines for building, testing, and publishing. External dependencies include falcosecurity/libs (sinsp), falcoctl, OpenSSL, cURL, yaml-cpp, and jemalloc. The architecture demonstrates strong engineering practices with clean abstractions (indexed_vector, atomic_signal_handler, yaml_helper) and composable action steps.
Syft is a production-grade CLI tool and Go library for generating Software Bills of Materials (SBOMs) from container images, filesystems, directories, and OCI artifacts. It detects and catalogs packages across 40+ ecosystems (Alpine, Debian, RPM, Python, Java, Go, Ruby, Rust, JavaScript, .NET, etc.) by parsing lockfiles, package databases, binary metadata, and source manifests. The tool outputs SBOMs in multiple formats including CycloneDX (JSON/XML), SPDX (JSON/tag-value), Syft JSON, and GitHub Dependency Snapshots, with version-aware encoding and decoding. Architecturally, Syft uses a modular cataloger system where each ecosystem implements a `generic.Cataloger` with parser functions registered by file globs or MIME types. A task-based pipeline orchestrates file indexing, package cataloging, dependency resolution, and relationship linking. The system supports both library integration via `syft.CreateSBOM()` and a CLI with cobra commands (`scan`, `attest`, `convert`, `cataloger`). A bubbletea-based TUI provides real-time progress feedback during image pulls and cataloging. External dependencies include `stereoscope` for container image access, `cosign` for attestation signing, and `go-partybus` for event-driven UI. Key entry points include `cmd/syft/main.go` (CLI), `syft/create_sbom.go` (library API), `syft/get_source.go` (source resolution), and the format encoders/decoders in `syft/format/`. The codebase demonstrates strong engineering practices: extensive test coverage (unit, integration, snapshot), CI/CD with GitHub Actions, auto-generated JSON schemas, and drift-check scripts for capabilities and schema. Notable reusable components include the generic cataloger framework, the dependency resolver, and the file resolver abstraction.
Sysdig is a mature, open-source system monitoring and troubleshooting CLI tool that instruments the Linux kernel to capture system calls and other OS events. It provides a rich curses-based interactive UI (csysdig) and an extensible Lua chisel framework for real-time analysis of CPU, I/O, network, security, and container metrics. The codebase is predominantly C++ with a Lua scripting layer, and includes a comprehensive plugin system for alternative event sources (e.g., gVisor, custom plugins). It also ships a large set of kernel driver build configurations (driverkit) for supporting many Linux distributions and kernel versions. The architecture is a classic CLI application with a modular design: libsinsp for event introspection, chisels for analysis, and a curses UI for visualization. The project is actively maintained by the Sysdig team and the Falco community, with regular commits and CI pipelines.
Tracee is a runtime security and observability tool that uses eBPF to trace system events and detect threats. It consists of multiple Go binaries: a main security agent (`tracee`) that loads eBPF programs, collects kernel events, and runs detection rules; a gRPC client (`traceectl`) for remote management; an event generator (`evt`) for stress testing; and a Kubernetes operator. The architecture is modular with a clear separation between eBPF event collection, event derivation and enrichment pipelines, data stores (process tree, container info, DNS cache, kernel symbols), a detection engine supporting both Go signatures and YAML-based rules using CEL expressions, and filtering/policy subsystems. The system operates as a daemon with HTTP/gRPC endpoints for metrics, health, and streaming event output, and integrates deeply with Kubernetes via CRDs and controllers. The codebase demonstrates strong engineering with clean abstractions (filter interfaces, data store registries, event derivation framework), reusable utility packages (bucketcache, changelog, string interning, fuzzy parsing), and comprehensive testing including unit, integration, and e2e tests. However, it exhibits technical drift in areas like multiple Go modules with `replace` directives, hardcoded kernel version checks in eBPF probe logic, legacy signature conversion code planned for removal, and some global mutable state. The eBPF C code is complex and kernel-version-sensitive, requiring ongoing maintenance. Overall, it is a well-crafted, production-grade security tool suitable for container and Kubernetes environments.
vexctl is a command-line tool for creating, applying, and attesting VEX (Vulnerability Exploitability eXchange) data. It is built as a single binary using Cobra for CLI, with subcommands for creating VEX documents, merging them, filtering SARIF scanner results, generating attestations, and validating documents against the OpenVEX specification. The tool integrates with Sigstore for keyless signing and supports multiple VEX formats (OpenVEX native, CSAF, CycloneDX). It can attach VEX attestations to container images via OCI referrers API or legacy tag layout. The architecture follows a clean separation of concerns: CLI handlers in `internal/cmd/` delegate to a core library in `pkg/ctl/`, which uses an interface (`Implementation`) for testability. The `pkg/attestation/` package handles in-toto attestations and Sigstore signing independently. The codebase demonstrates strong engineering practices with dependency injection, options struct patterns, and comprehensive test data. While primarily an application, it also processes vulnerability data (SARIF, VEX documents) and includes validation logic that could be reused in other security tooling.
CDK (Container Docker/Kubernetes Exploitation Toolkit) is a Go-based CLI penetration testing tool designed for container and Kubernetes environments. It evaluates security posture by running extensive checks against container runtime configurations, K8s API permissions, cloud metadata, and kernel exploit possibilities. It then executes a plethora of exploits covering container escape (cgroups, mount, eBPF, runc/containerd CVEs), K8s credential access (secrets, configmaps, tokens), persistence (backdoor daemonsets, cronjobs, shadow API server), privilege escalation (service account token theft, CVE-2026-31431), and remote control (reverse shells, kubelet exec). The binary bundles stripped-down versions of common tools (kubectl, netcat, vi, etc.) for post-exploitation use. The architecture follows a plugin pattern where exploits register themselves via init(), and evaluation uses a category-based check system. The codebase shows signs of organic growth with some legacy cruft (deprecated auto-escape task, commented-out code, future-dated CVEs) and moderate technical debt (global mutable state, panics, outdated Go idioms), but remains functional and actively maintained for penetration testers and security researchers.