thehardwarestore.ai

Shopify/shopify_app is a Ruby on Rails engine gem (v23.0.3, MIT) that provides the foundational integration layer for building Shopify Apps. It handles OAuth 2.0 authentication with both legacy and new embedded-API token exchange flows, session management (online/offline with access scopes), webhook registration and verification, script tag management, billing, and App Bridge support. The gem ships with dozens of Rails generators to scaffold models, controllers, jobs, views, and routes tailored to embedded and non-embedded app patterns. Architecture is a mounted engine with mixin-based controller concerns (e.g., LoginProtection, EnsureHasSession, WebhookVerification) and configurable session storage backends (default ActiveRecord via host app models, with in-memory stores for development). Key data flows: the app directs users through Shopify OAuth, stores session tokens (with automatic refresh for expiring tokens), then uses the Shopify API (via shopify_api gem) for authenticated calls. The codebase demonstrates disciplined Rails engine design, robust security practices (HMAC verification, CSP, CSRF protection, sanitized redirects), and strong test coverage with 300+ test files. Notable craftsmanship includes the session storage mixins (ShopSessionStorage, UserSessionStorage) that separate concerns via method injection, the access-scope verification strategies, and the full-page redirect pattern for embedded apps. Maintenance is active—despite some doc-coverage inconsistencies (e.g., deprecated modules still tested) and two coexisting auth strategies that add conditional complexity, the gem tracks modern Shopify API versions and Ruby/Rails requirements (>= 3.2 / >= 7.1). The large generator surface and i18n support (20 locales) show attention to developer experience.

This repository implements an MCP (Model Context Protocol) server that bridges AI assistants with SearXNG, a privacy-respecting metasearch engine. It exposes four primary tools: `searxng_web_search` for web queries, `searxng_search_suggestions` for autocomplete, `searxng_instance_info` for capability discovery, and `web_url_read` for fetching and converting web pages to markdown. The server runs in two transport modes: STDIO (default) for simple MCP integration, and HTTP for stateful/stateless remote access with optional OAuth and static bearer authentication. The architecture is modular and security-focused. Core modules include a proxy layer with per-type agent selection, SSRF protection via private IP blocking and DNS rebinding detection, a browser solver chain (FlareSolverr/Byparr) for challenge solving, worker-threaded PDF extraction, and multi-instance failover/fanout for SearXNG replicas. All credential-bearing output (logs, errors, MCP resources) is redacted by a centralized sanitizer. Extensive environment-variable configuration (~40+ knobs) controls caching, timeouts, rate limiting, TLS, and result formatting. Highlights include a strict integer parser that rejects unsafe or malformed values, an LFU cache with age tie-breakers and configurable TTL, and a comprehensive URL security module covering both IPv4 and IPv6 private ranges. The test suite achieves over 90% line coverage and includes integration, unit, fuzz, and e2e tests, with documentation tests that verify README and configuration docs match source contracts. The project is actively maintained with frequent releases, pinned dependencies, and a verification gate that enforces zero-vulnerability audits before publishing.

This repository is the canonical source for **OpenClaw Agent Skills**, a collection of portable, reusable agent workflows (skills) for coding agents such as Claude Code, Codex, Pi, and OpenClaw. The primary deliverable is not a standalone application but a set of self-contained skills that provide automated code review (autoreview), redacted session publication (beam), session transcript provenance (agent-transcript), local session viewing (session-viewer), behavior validation (behavior-validator), and remote test orchestration (crabbox). Each skill lives under `skills/<name>/` with a required `SKILL.md` file and auxiliary scripts, tests, and references. The repository also includes cross-platform installer (`scripts/install-skills`) and validator (`scripts/validate-skills`) scripts that support symlink or copy installation into agent skill directories. Architecturally, the skills are independent of each other and are consumed by agents via direct symlink/copy. The most complex skill is `autoreview`, which performs a full AI-driven code review pipeline: capture git diff/commit/working-tree state, build a review prompt with evidence, invoke one of several engines (Codex, Claude, Amp, Pi) via subprocess, parse structured JSON reports, and produce a final review result with security hardening (isolation probes, credential scanning, terminal escape prevention). The `autoreview` script is monolithic (~80k tokens) but contains reusable patterns for safe subprocess environment sanitization, git diff collection, JSON extraction from noisy output, and engine isolation verification. The `session-viewer` skill provides a polished local HTML renderer for agent session JSONL files, with importers for multiple session formats. The `beam` skill focuses on redacted publication of coding sessions to a read-only catalog. The codebase demonstrates high engineering craftsmanship: extensive test coverage (Python unittest, Jest for TypeScript, shell-based harness), security-conscious patterns (symlink validation, stat-preserving writes, process group signal handling, environment sanitization), and cross-platform support (Windows, macOS, Linux via CI). The test suite is especially thorough for `autoreview`, covering edge cases like CRLF handling, binary files, merge commits, worktrees, shallow clones, and sensitive path patterns. The installer pattern (symlink for development, copy for vendored snapshots) is designed to minimize drift while allowing zero-setup downstream usage. Overall, the repository is actively maintained, uses modern tooling (Python 3.14, Node 26, TypeScript 7), and is well-suited for teams adopting agent-assisted development workflows who need reusable, vetted skill definitions.

Sqlvet is a static analysis CLI tool for Go projects that scans raw SQL queries embedded in Go source code to detect potential runtime errors at build time. It uses Go's SSA (Static Single Assignment) representation and call graph analysis to trace SQL query strings through function calls, handling common patterns like string concatenation, functions returning query strings, and pass-through functions like sqlx.Rebind. Extracted queries are parsed with a PostgreSQL grammar (via pg_query_go) to validate syntax, table/column names against a schema, and detect unsafe dynamic SQL that could lead to injection. The tool supports custom SQL function matchers via TOML configuration, allowing users to extend analysis to their own wrapper libraries. The architecture is a single Go binary with modular packages for configuration, schema parsing, query extraction, and SQL validation, with comprehensive test coverage including integration tests using real Go packages.

x64dbg is an open-source binary debugger for Windows targeting malware analysis and reverse engineering. The architecture is a three-layer system: a GUI layer (Qt-based Windows application), a bridge layer (C API for communication), and a debugger core layer (TitanEngine/GleeBug/StaticEngine backends). The debugger supports x86 and x64 processes with comprehensive features including conditional breakpoints, memory analysis, symbol handling, and an extensive plugin SDK. The codebase demonstrates strong engineering in several areas. The analysis engine implements multiple analysis passes (linear, recursive, control flow, xrefs) with a clean pass-based architecture. The command system uses a flexible registration pattern with consistent error handling. The bridge layer provides a well-defined C API surface for plugins with careful attention to thread safety and marshaling between GUI and debugger threads. Recent development shows active work on Linux support (ElfBug debugger), cross-platform tools (hex viewer, minidump analyzer, remote table), and a comprehensive test framework with headless testing infrastructure. The test system uses convention-based test discovery with script-driven scenarios and plugin-based assertions. Technical debt includes some outdated documentation (docs reference Python 2.7 for CHM generation), mixed use of Qt versions (5.12+ required but some paths reference older configurations), and the inherent complexity of maintaining both Windows debugger and cross-platform analysis tools in one repository. The dependency on precompiled libraries (TitanEngine, Zydis, XEDParse) creates build complexity but is managed through CMake.

Algo VPN is a deployment tool that automates the setup of a personal VPN server on cloud providers or local Ubuntu machines. It uses Ansible to provision a hardened server running strongSwan (IKEv2/IPsec) and WireGuard, with optional DNS encryption via dnscrypt-proxy and privacy enhancements like log rotation and history clearing. The architecture is a set of Ansible playbooks and roles, orchestrated by a shell script entry point (`algo`) that invokes `ansible-playbook`. Cloud provisioning is handled by provider-specific roles (AWS EC2, DigitalOcean, Azure, GCE, etc.), while server configuration roles handle system hardening, PKI certificate generation, VPN service configuration, and client profile generation (mobileconfig, WireGuard .conf, QR codes). The system is designed for security and privacy: it uses strong crypto defaults (ECC secp384r1), minimal logging, and unattended upgrades. External dependencies include Ansible, community.crypto collection, cloud provider SDKs, and the dnscrypt-proxy package. The primary data flow is: user edits `config.cfg` → Ansible playbook runs → cloud VM is created → server is configured with VPN services → client configuration files are generated and stored locally. User management (add/revoke) is handled by a separate playbook. The repository includes extensive unit, integration, and end-to-end tests, with Docker-based integration testing and CI/CD via GitHub Actions.

Gitleaks is a command-line secret detection tool written in Go that scans for sensitive information like API keys, tokens, and passwords in git repositories, directories, files, and stdin. It features a modular architecture with separate components for configuration loading, source abstraction (file/git/archive handling), detection logic with multi-layer decoding, rule-based matching, and flexible reporting. The tool uses a Cobra-based CLI interface with commands for different scan modes and supports output formats including JSON, CSV, JUnit, SARIF, and custom templates. Key strengths include its pluggable decoder pipeline for handling encoded secrets, configurable rule system with entropy checks and keyword filtering, and sophisticated allowlist mechanism for reducing false positives. While actively maintained for security patches, the project is feature-complete with ongoing dependency management challenges due to its extensive rule set and reliance on unstable packages like golang.org/x/exp.

This repository implements 'lego', a production-grade ACME client written in Go for automating SSL/TLS certificate issuance and renewal with Let's Encrypt and other ACME-compliant Certificate Authorities. The system operates as both a CLI tool and a reusable library, supporting the full ACME protocol (RFC 8555) including account registration, order creation, challenge solving (HTTP-01, DNS-01, TLS-ALPN-01, and experimental DNS-PERSIST-01), certificate download, and lifecycle management (renewal, revocation, archival). Architecturally, the codebase is modular: a core ACME API client (`acme/api/`) handles protocol interactions; challenge solvers (`challenge/`) implement domain validation strategies; a plugin-style DNS provider system (`providers/dns/`) integrates with over 200 DNS service APIs for automated DNS-01 challenge resolution; a CLI layer (`cmd/`) provides subcommands for run, certificates, accounts, archives, and migration; and storage (`cmd/internal/storage/`) persists certificates, keys, and account data to disk. Configuration is via YAML files, environment variables, and dotenv files. Key entry points include `main.go` (application start), `cmd/cmd_root.go` (CLI root command), and `lego/client.go` (library entry point). The primary data flow involves the user specifying domains and challenge type, the client interacting with the ACME CA to create orders and solve challenges (e.g., creating a DNS TXT record via a provider API), and finally downloading and storing the issued certificate. External dependencies include the ACME CA servers, the DNS provider APIs, and optionally an HTTP server for HTTP-01 challenges. The codebase demonstrates strong engineering practices with extensive unit and end-to-end testing, a consistent provider interface, and several well-designed internal utilities (HTTP mock server, retry/polling, error wrappers). However, the large number of DNS providers introduces boilerplate duplication and potential API drift, and the project uses a custom Go-like language dialect that may pose tooling and onboarding risks.

wgcf is an unofficial, cross-platform command-line tool for Cloudflare WARP. It reverse-engineers the official Android client's undocumented API to register WARP accounts, bind license keys, and emit ready-to-use WireGuard profiles. The codebase is organized as a Cobra-based CLI with distinct subcommands (register, update, generate, status, trace), a Viper-backed TOML config layer, a custom OpenAPI-generated API client for api.cloudflareclient.com, and a dedicated WireGuard profile generator. Its most distinctive piece is a uTLS-based HTTP transport that replicates the exact TLS ClientHello of Cloudflare's Android app, allowing the tool to pass server-side fingerprint checks. The OpenAPI specification is actively maintained and version-pinned to WARP build 5641, with generated Go client code that should be regenerated when the spec changes. This is a pure application repository; the only data-like artifacts are the OpenAPI contract and schema models, which serve the client rather than enable research or analytics.

zrok is a production-grade, self-hostable secure resource sharing platform built on OpenZiti overlay networking. It enables users to share web services, files, TCP/UDP tunnels, and VPN connections through firewalls and NAT without requiring inbound connectivity. The system supports both public and private sharing modes, OAuth authentication (GitHub, Google, OIDC), and includes a full REST API (v2), a CLI tool (`zrok2`), a React web console, a background agent daemon with gRPC remote control, and SDKs in Go, Python, and Node.js. Architecturally, zrok follows a controller-agent pattern. The controller is a Go REST server that manages accounts, environments, shares, accesses, frontends, namespaces, organizations, and bandwidth limits. It uses SQLite3 or PostgreSQL for persistence with versioned migrations, and integrates with InfluxDB for usage metrics and RabbitMQ (AMQP) for dynamic proxy mapping updates. The agent runs as a background process on the user's machine, managing child processes for each share/access and exposing a gRPC API for remote management. Frontend proxies (public, dynamic, socks, Caddy) handle incoming traffic with OAuth, basic auth, and interstitial pages. Key entry points include the CLI commands under `cmd/zrok2/` (e.g., `share`, `access`, `enable`, `admin`), the controller REST handlers in `controller/`, the agent gRPC service in `agent/agentGrpc/`, and the SDK packages in `sdk/golang/sdk`, `sdk/python/src/zrok2`, and `sdk/nodejs/sdk`. The system also includes a canary testing framework for continuous health validation and a comprehensive metrics/limits engine for bandwidth enforcement. External dependencies include OpenZiti (overlay network), InfluxDB (metrics), RabbitMQ (messaging), Caddy (optional web server), and various OAuth providers. The project is actively maintained with frequent commits, automated CI/CD, and multi-platform release pipelines (Linux, macOS, Windows, Docker).

This is an Android PDF viewer application built with Jetpack Compose that uses Mozilla's pdf.js library for rendering. The app displays PDFs in a sandboxed WebView with strict security policies, handles encrypted PDFs, provides navigation controls, outline viewing, document properties, and various UI features like zoom, rotation, and text layer visibility. The architecture follows MVVM with a ViewModel managing state and a Compose UI layer. The app uses content providers to securely load PDF content without granting the WebView access to files or network.

chasquid is a production-grade SMTP (email) server written in Go, focusing on simplicity, security, and ease of operation. It handles incoming and outgoing email with full support for modern email security standards including STARTTLS, DKIM signing and verification, SPF checking, MTA-STS enforcement, and per-domain security level tracking. The server architecture is modular: the main daemon delegates SMTP protocol handling to the internal/smtpsrv package, manages a persistent email queue via internal/queue, performs alias resolution with hooks via internal/aliases, and delivers mail either locally through an LMTP-based MDA (cmd/mda-lmtp) or remotely via SMTP courier with TLS and MX fallback. Authentication integrates with Dovecot or a local user database using scrypt password hashing. Configuration is defined via protobuf text format, supporting hot reload of domains, users, and aliases without restart. The repository includes CLI tools for administration (chasquid-util), SMTP connectivity checking (smtp-check), and Dovecot authentication testing (dovecot-auth-cli). A comprehensive test suite covers unit, integration, and fuzz tests, with test data for DKIM, SPF, aliases, and various protocol edge cases. The repository also provides a Dockerfile for containerized deployment and extensive documentation in Markdown and man pages. While primarily an application, the codebase contains several well-designed internal packages that could be extracted for reuse, such as the network tracing library, safe I/O utilities, and OpenMetrics exporter.

Infisical is an open-source end-to-end encrypted secrets management platform used to centralize, secure, and sync secrets across teams and infrastructure. The codebase is structured as a multi-service application with a primary Node.js/TypeScript backend (REST API using Fastify) and a newer Go backend implementing core platform services (authentication, permission evaluation, KMS, audit logging, secret manager). The frontend is a React SPA built with Vite and TanStack Router. The system supports self-hosted (Docker, Helm) and cloud-deployed modes. It provides a rich set of capabilities including dynamic secrets, secret rotation, approval workflows, machine identity federation (AWS, Azure, GCP, Kubernetes, OIDC), PKI management (internal and external CAs), privileged access management (PAM), secret scanning, audit logging, and extensive integration syncs. The architecture follows a modular service-oriented pattern with clear separation of concerns, extensive use of dependency injection and factory patterns for extensibility.

TruffleHog is a comprehensive, actively maintained secret scanning tool written in Go. It detects exposed credentials, API keys, tokens, and other sensitive information across a wide range of sources including Git repositories, cloud storage (S3, GCS), Docker images, CI/CD systems (Jenkins, Travis CI, CircleCI), and many third-party services. The architecture is modular: a core engine orchestrates scanning from various sources, a large library of over 700 detectors (each implementing a standard interface) identifies secrets using regex patterns and Aho-Corasick pre-filtering, and optional HTTP-based verification confirms whether discovered secrets are still valid. The tool also includes a terminal UI (Bubble Tea), a permissions analyzer for deeper credential assessment, and output formats like JSON, SARIF, and GitHub Actions annotations. External dependencies include cloud SDKs, database drivers, and numerous third-party API clients, but the core scanning logic is self-contained and well-structured.

Aya is a Rust framework for developing, loading, and managing eBPF (extended Berkeley Packet Filter) programs. It provides a pure-Rust alternative to libbpf and bcc, allowing developers to write eBPF programs in Rust without leaving the language ecosystem. The framework supports various eBPF program types (XDP, socket filters, tracepoints, kprobes, uprobes, LSM, etc.) and map types (arrays, hash maps, perf event arrays, ring buffers, etc.), with strong emphasis on type safety and developer experience. Aya implements BTF (BPF Type Format) support for compile-once-run-everywhere portability across kernel versions and provides procedural macros to reduce boilerplate when defining eBPF entities. The architecture consists of multiple crates separating userspace and kernel-space concerns, with extensive integration tests validating functionality against actual kernels.

Yelp/detect-secrets is a production-grade Python library and CLI tool for detecting secrets, API keys, tokens, and other sensitive strings in source code. It operates primarily through a baseline file (`.secrets.baseline`) that records discovered secrets, enabling incremental scanning, pre-commit hook integration, and audit workflows. The tool uses a plugin-driven architecture with over 25 built-in detectors (regex-, entropy-, and keyword-based), plus configurable filters (heuristic, allowlist, word list, gibberish) to reduce false positives. Key operational flows include scanning a codebase to create or update a baseline, running as a pre-commit hook to block new secrets, and an interactive audit mode for labeling secrets as true or false positives. The architecture is modular with clear separation of concerns: plugins define detection logic, filters post-process results, settings manage global configuration, and transformers handle non-standard file formats (YAML, INI). The library also supports network verification for some secret types, automatic baseline upgrades across format versions, and custom plugin/filter injection. It is actively maintained with CI across Python 3.9-3.13 and three operating systems.

This is a Kubernetes-native security operator that automates vulnerability scanning, configuration auditing, secret scanning, RBAC assessment, infrastructure assessment, and compliance reporting for container workloads. It uses Aqua Security's Trivy as the scanning engine and stores results as custom resource definitions (VulnerabilityReport, ConfigAuditReport, ExposedSecretReport, RbacAssessmentReport, InfraAssessmentReport, SbomReport, ClusterComplianceReport). The operator runs as a controller-manager pod, watches Kubernetes resources, and creates scan jobs in-cluster. It supports multiple scan modes (standalone, client/server, filesystem, rootfs) and integrates with Prometheus for metrics, webhooks for alerting, and OPA/Rego for configurable policy evaluation. The codebase is well-structured with a plugin architecture for scanning, builder patterns for report generation, and extensive test coverage including unit, envtest, integration, and e2e tests.

Bouncy Castle for .NET is a comprehensive, production-grade cryptographic library providing implementations of a vast range of symmetric and asymmetric ciphers, hash functions, message authentication codes, digital signatures, key agreement protocols, key encapsulation mechanisms (including post-quantum schemes like ML-KEM, ML-DSA, SLH-DSA), secure random number generation (NIST SP 800-90A DRBG), and ASN.1 encoding/decoding (DER, BER, DL). It supports high-level protocol implementations for TLS/DTLS (client and server, including PSK, SRP, and post-quantum key exchange), OpenPGP (RFC 4880/9580), CMS (Cryptographic Message Syntax), CMP, CRMF, OCSP, TSP, and X.509 certificate generation and validation. The library is designed as a class library with a monolithic architecture organized into namespaces (Org.BouncyCastle.Crypto, .Asn1, .Tls, .Bcpg, .Cms, etc.), exposing both low-level primitives and high-level builders. It targets multiple .NET runtimes with conditional compilation for hardware intrinsics (AES-NI, PCLMULQDQ, SSE/AVX) and Span<T> support. The codebase is actively maintained, with ongoing migration from older algorithm names (e.g., Dilithium → ML-DSA) and extensive use of factory patterns and interface-based abstractions, making it a solid foundation for secure application development.

This repository provides the `honggfuzz` Rust crate, which integrates Google's Honggfuzz fuzzer with Rust. It offers a library with a `fuzz` function and `fuzz!` macro for defining fuzz targets, and two cargo subcommands (`cargo hfuzz` and `cargo honggfuzz`) for building with fuzzing instrumentation and running the fuzzer. The crate handles persistent fuzzing, conditional compilation via `cfg(fuzzing)`, and supports both raw byte slices and structured inputs via the `arbitrary` crate. The build script compiles the Honggfuzz C library from a submodule and links it statically. The codebase is well-structured, with clear separation between the library, CLI tools, and build infrastructure, and demonstrates thoughtful engineering for a security testing tool.