Easy-RSA is a CLI utility for managing a Public Key Infrastructure (PKI) Certificate Authority (CA). It provides a shell-based interface to create and manage CA certificates, sign certificate requests, generate revocation lists, and produce OpenVPN inline configuration files. The core logic is implemented in a single POSIX shell script (easyrsa3/easyrsa) that wraps OpenSSL commands. It supports RSA, EC, and Edwards curve algorithms, multiple certificate types (server, client, CA, code-signing, email), and is designed for both interactive and batch operation. The tool is tightly coupled with OpenSSL and optionally OpenVPN for TLS key generation. It is a mature, actively maintained project with a comprehensive feature set and strong adherence to shell scripting standards.
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.
https-localhost is a developer tool that runs an HTTPS server on localhost using locally-trusted SSL certificates. It downloads the mkcert binary appropriate for the host OS/architecture, executes it to install a local CA into system/browser trust stores, and generates per-host certificates. The resulting HTTPS server can either serve static files from a directory or act as a reverse proxy to an existing HTTP/HTTPS server, with optional HTTP-to-HTTPS redirection. It ships as both a global CLI (the `serve` binary) and a programmatic API (`createServer()`, `getCerts()`). Architecturally it is a small, well-separated set of ES modules built directly on Node's built-in http/https servers with no framework dependency. The router dispatches between a static file handler and a proxy handler; CORS headers are applied globally; environment/CLI configuration is validated through a zod schema where CLI flags take precedence over environment variables. External runtime dependencies are deliberately minimal: only `mrmime` for MIME lookup and `zod` for config validation, plus the downloaded mkcert binary. The static handler is the strongest piece: it implements path-traversal sanitization, ETag/Last-Modified conditional requests, byte-range responses (206/416), HEAD/OPTIONS support, directory index serving with query-preserving trailing-slash redirects, and custom 404.html lookup. The proxy handler strips hop-by-hop headers, injects X-Forwarded-* headers, tunnels WebSocket upgrades, and cleanly returns 502 when upstreams fail or die mid-response. Test coverage is comprehensive and genuinely exercises real sockets: unit tests for env parsing and certificate lifecycle, integration tests for static serving and proxying, CLI spawn tests, and edge-case tests for malformed percent-encoding, CORS preflight without upstream contact, and client hang prevention. CI runs a matrix across Ubuntu/macOS and Node 24/26 with strict type-aware linting, dead-code detection (knip), and formatting checks. Minor weaknesses: synchronous fs calls in the static handler (fine for a dev tool), a `process.exit()` call inside library code for unsupported platforms, minimal error handling in the mkcert download routine (only follows 302s, ignores non-2xx statuses), and no Windows CI coverage despite Windows-specific code paths.
acme.sh is a pure shell (POSIX sh) ACME protocol client for automated TLS/SSL certificate lifecycle management. It supports multiple Certificate Authorities (Let's Encrypt, ZeroSSL, Google, SSL.com, Actalis) and provides a wide range of validation methods including HTTP-01 (webroot, standalone, Apache, Nginx), DNS-01 (via 150+ DNS provider APIs), and TLS-ALPN-01. The tool is designed for unattended cron-based renewal and includes deploy hooks for installing certificates into various services (web servers, routers, firewalls, etc.) and notification hooks for alerting on renewal outcomes. The architecture is a monolithic shell script (acme.sh) that sources plugin modules from dnsapi/, deploy/, and notify/ directories. Each plugin follows a consistent function naming convention (e.g., dns_<provider>_add/rm, <target>_deploy, <service>_send) and uses shared internal helpers for HTTP requests, credential persistence, and JSON/XML parsing. The project emphasizes cross-platform compatibility (Linux, macOS, BSDs, Solaris, Windows/Cygwin) and avoids external dependencies beyond curl/wget and openssl. Key features include ECDSA and RSA key support, wildcard certificates, OCSP Must-Staple, External Account Binding (EAB), ACME Renewal Information (ARI, RFC 9773), and automatic upgrade. The codebase is well-tested across 20+ operating systems via GitHub Actions CI, using both Pebble test servers and real CAs. While the monolithic core script is large (~4000 lines), the plugin architecture enables easy extension for new DNS providers, deployment targets, and notification channels.
Deskflow is a free and open-source keyboard and mouse sharing utility (software KVM without video) that allows one computer's keyboard, mouse, and trackpad to control multiple computers over a network. It uses a client-server architecture with a core process handling input forwarding and network protocol, a daemon for Windows service/UAC support, and a Qt-based GUI for configuration. The system supports TLS encryption, clipboard sharing, and multiple platforms including Windows, macOS, Linux (X11 and Wayland). It implements a custom binary protocol with version negotiation (1.0-1.8) and provides platform-specific backends for input capture and injection. The codebase is well-structured with clean abstractions, extensive unit tests, and CI/CD pipelines, though it carries some legacy code from its Synergy/Barrier origins.
Athenz is an open-source, fine-grained authorization and identity management platform designed for zero-trust environments. It provides centralized (ZMS) and decentralized (ZTS) services for issuing short-lived X.509 certificates, managing role-based access control (RBAC), and enforcing policies across multi-cloud and on-premise infrastructures. The system supports AWS, GCP, Azure, and Kubernetes workloads through pluggable attestation validators and credential providers, enabling service-to-service authentication and authorization without shared secrets. Architecturally, Athenz comprises three core servers: ZMS (management service for domains, roles, policies), ZTS (token service for certificates, OAuth2 tokens, SSH certs), and MSD (micro-segmentation for network policy management). A React/Next.js UI provides administrative management, while client libraries in Java, Go, and Node.js enable integration. The codebase is organized into modular Maven submodules with RDL-generated data models, extensive unit/integration tests, and Docker/Kubernetes deployment artifacts. Key patterns include factory-based dependency injection (e.g., cert signers, private key stores, notification services), dynamic configuration reloading, and composite validators for cloud attestation. This is a production-grade application with clean abstractions, well-defined interfaces, and significant test coverage. While the codebase contains some generated boilerplate and cloud-specific implementations that may drift, the core libraries and utility classes are reusable and demonstrate strong engineering practices.
Xray-core is a production-grade network proxy framework written in Go. It implements a wide range of proxy protocols (VMess, VLESS, Shadowsocks, Trojan, Hysteria, WireGuard, SOCKS, HTTP) and transport layers (TCP, WebSocket, gRPC, KCP, SplitHTTP, HTTPUpgrade, QUIC) with advanced obfuscation techniques (Noise, Sudoku, XMC, Realm) for censorship circumvention. The architecture is modular, with pluggable inbound/outbound handlers, a rule-based router with domain/IP/port/protocol matching, a DNS subsystem supporting multiple upstreams (DoH, DoQ, TCP, UDP, FakeDNS), and an observatory for health-based load balancing. Configuration is via JSON/protobuf, and runtime management is exposed through gRPC APIs. The codebase is extensive, well-tested (unit and integration scenarios), and leverages Go's concurrency primitives heavily for performance. However, it includes experimental transports and deprecated features (e.g., legacy Shadowsocks, xtls security), indicating ongoing evolution and some technical drift in the ecosystem.
This repository is a toolchain for generating Apple Configuration Profiles (.mobileconfig) that configure DNS over HTTPS (DoH) and DNS over TLS (DoT) on iOS, iPadOS, and macOS devices. It maintains a curated registry of public encrypted DNS providers (e.g., AdGuard, Cloudflare, Quad9, CleanBrowsing) with metadata such as server addresses, filtering capabilities, and region. The build pipeline reads provider definitions from JSON files under src/, generates unsigned profiles in profiles/, optionally signs them with CMS digital signatures using a user-provided ECC certificate, and places signed versions in signed/. It also produces multi-language README files (English, Simplified Chinese, Traditional Chinese) with provider tables and installation links. The architecture is a set of TypeScript scripts executed via npm commands (build, sign, new, test). There is no runtime server or daemon; the output is static files intended for manual installation by end users. The interactive CLI (npm run new) guides users through creating new provider profiles with validation and optional signing. The codebase demonstrates solid engineering practices: deterministic UUIDs (v5) for stable profile identifiers, CMS signing with both Node.js crypto and OpenSSL parity tests, and a modular design that separates provider data, language templates, and build logic. While the repository is primarily a build tool, it also serves as a reference for encrypted DNS provider capabilities and a practical solution for deploying encrypted DNS on Apple devices. The signed profiles provide authenticity verification, and the multi-language support broadens accessibility. The code is well-structured and maintainable, though it relies on external certificates for signing and manual updates to provider data when server endpoints change.
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 provides Rust bindings to Apple's Security.framework, enabling safe access to Keychain services and TLS/SSL functionality. It consists of a safe wrapper crate (`security-framework`) built upon raw FFI bindings (`security-framework-sys`), with platform-specific implementations for macOS. The library employs idiomatic Rust patterns such as the builder pattern for configuration, Core Foundation type wrappers for automatic memory management, and zero-cost abstractions using `PhantomData`. Examples demonstrate TLS client connections and Keychain password operations. The architecture separates unsafe FFI bindings (generated via `ctest2` from Apple headers) from safe abstractions. Key components include Keychain item management (search/add/update/delete), SSL/TLS client/server contexts, certificate handling, and cryptographic transforms. The project is actively maintained with recent commits, includes test harnesses for iOS and system validation, and shows awareness of API evolution through deprecation markers.
This Rust codebase is an LLM inference proxy and tool-routing gateway. It exposes an OpenAI-compatible HTTP API (`/v1/chat/completions`, `/v1/models`) and forwards requests to multiple upstream LLM providers (OpenAI, Anthropic via direct/Bedrock, Vertex AI, vLLM DeepSeek, TokenHub) through a unified Provider trait. A QUIC server (s2n-quic, TLS 1.3) accepts connections from serverless tools written in Go or Node.js; the agent loop performs multi-round tool calling, invokes registered tools, and streams results back in SSE format. A separate model API proxy layer handles non-chat endpoint shapes (messages, responses, generateContent) with usage extraction and injection. Architecturally, the system is a Rust CLI binary (`yomo`) with three subcommands: `serve` starts the HTTP API and QUIC zipper, `init` scaffolds serverless tool projects, and `run` launches a tool subprocess and connects it to the zipper. Tool registration is done at runtime over QUIC and stored in-memory, so state is lost on restart. The HTTP layer is Axum, auth is bearer-token, and observability uses OpenTelemetry. The serverless execution model is subprocess-based: it creates temporary directories, runs `npm install`/`go mod tidy`, and exchanges metadata over stdout. Reusable engineering exists in the framing protocol (`io`), streaming SSE mappers, usage aggregation logic, TLS configuration, and provider error separation. However, the provider implementations are duplicated and brittle to upstream API drift; hard-coded model limits, ephemeral tool state, and near-empty serverless stubs reduce long-term maintainability. No integration tests against real upstream APIs were found in the reviewed surface.
Cloudflare's CFSSL is a comprehensive PKI/TLS toolkit written in Go, providing both a command-line interface and an HTTP API server for certificate lifecycle management. It handles certificate signing, chain bundling, revocation (CRL/OCSP), TLS scanning, key generation, CSR creation, and CA initialization. The system is modular, with separate packages for CLI commands, API handlers, signers (local/remote), certificate database abstraction (SQLite/MySQL/PostgreSQL), a bundler with chain optimization, an OCSP responder, a TLS scanner, and a transport layer for automated mutual TLS. It uses interface-based design for pluggable backends (signers, database accessors, key providers, trust stores) and includes features like multi-root CA support, pre-issuance linting via zlint, certificate transparency embedding, ubiquity scoring for chain selection, IP whitelisting, HMAC authentication, Prometheus metrics, and post-quantum cryptography (ML-DSA). The codebase also contains custom cryptographic implementations (MD5, SHA-1, SHA-256, SHA-512) with assembly-optimized blocks for performance. While actively maintained with CI/CD and extensive tests, some components show technical drift (pinned Go 1.27, forked TLS library, legacy algorithm support).
Firefly is a high-performance asynchronous networking framework for the JVM, written in Java and Kotlin. It provides a comprehensive set of I/O primitives including HTTP/1.1, HTTP/2, WebSocket (RFC 6455), TCP, and UDP, with both client and server implementations. The framework is designed around Kotlin coroutines and Java NIO2 (AIO), offering non-blocking, backpressure-aware streams and a router-based HTTP server with support for content negotiation, CORS, static file serving, and HTTP/2 upgrade. It also includes built-in SLF4J logging with XML configuration, a JSON serialization service, a WeChat enterprise bot module, and a JNI helper for native code integration. The codebase is modular (firefly-common, firefly-net, firefly-slf4j, firefly-serialization, firefly-wechat, firefly-example) and demonstrates deep protocol-level craftsmanship with custom HPACK, Huffman coding, and state-machine parsers. While primarily a library for building network services, it also serves as a reference implementation for protocol handling on the JVM.
This repository provides a comprehensive, modular set of Bash scripts to automate the installation and configuration of Apache Guacamole—an open-source remote desktop gateway. The primary orchestrator '1-setup.sh' handles interactive prompts and silent install variables to deploy Guacamole server and client from source, integrate MySQL/MariaDB as the backend database, set up Nginx as a reverse proxy, and optionally configure TLS (self-signed or Let's Encrypt), multi-factor authentication (TOTP, Duo, LDAP), and extra UI features like quick-connect and session recording storage. The scripts are well-structured with extensive error checking, logging, distro-specific workarounds, and support for modular post-install add-ons. Though not a library for reuse, the code demonstrates solid shell scripting craftsmanship, security hardening (fail2ban integration, firewall rules), and separation of concerns. The repository serves as a turnkey deployment toolkit for production-grade Guacamole environments.
testssl.sh is a mature, command-line Bash tool for comprehensive TLS/SSL security auditing of network services. It tests cipher support, protocol versions (SSLv2 through TLS 1.3), cryptographic vulnerabilities (Heartbleed, CCS, ROBOT, BEAST, POODLE, LOGJAM, FREAK, and many others), certificate validation, HTTP security headers, and STARTTLS on a wide range of protocols. The tool works by performing socket-level TLS handshakes and comparing results against embedded data files. It also includes a client simulation feature that replays ClientHellos from over 100 real-world browsers and libraries to detect server behavior differences. The architecture is a single large Bash script (testssl.sh) with supporting data files under etc/ and utility scripts in utils/. It is driven by command-line options and environment variables, producing output in terminal color, JSON, CSV, HTML, and log formats. The project has active maintenance with a thorough test suite and CI pipelines, though some data sources (e.g., SSL Labs API) are deprecated, and the client simulation data requires manual updates.
This repository is a configuration-only bundle for the cryptostorm VPN service, providing OpenVPN client configuration files (.ovpn) organized by cryptographic method (RSA, ECC, Ed25519, Ed448, and post-quantum ML-DSA-87) and server location. Despite having no application source code, the repo is classified as an application because it delivers ready-to-use configuration templates for a network service. The configs are well-structured, with extensive inline comments explaining security choices, cipher performance, and usage instructions. Each .ovpn file follows a consistent template with embedded CA certificates and shared tls-crypt/tls-auth keys. The repository serves as a distribution point for end-users to connect to cryptostorm servers, with a focus on transparency and user education.
This repository provides documentation and automation scripts for setting up a Kubernetes cluster from scratch using VirtualBox. It includes shell scripts for creating and configuring VM images with cloud-init, configuration files for various Kubernetes components (etcd, control plane, worker nodes, HAProxy load balancers), and detailed documentation explaining the setup process. The repository serves as an educational guide for understanding Kubernetes infrastructure components and how they interact, rather than a deployable application itself. The main value lies in the well-structured automation scripts and comprehensive documentation that walk users through building a complete Kubernetes cluster with high availability features.
cloudflare/tls-tris is a Go library that extends the standard library's crypto/tls package with experimental TLS 1.3 support, post-quantum key exchange (SIDH, SIKE, and hybrids), delegated credentials, and 0-RTT. It is not a standalone package; it replaces the Go standard library's crypto/tls via a patched GOROOT. The library implements full client and server TLS 1.3 handshakes, record layer processing, session ticketing, and provides APIs consistent with the standard Go tls package (tls.Config, tls.Conn, tls.Dial). The codebase is derived from Go 1.10-era crypto/tls with extensive modifications. It includes integration with Cloudflare's SIDH library for post-quantum cryptography and supports hybrid key exchange combining X25519 with SIDH or SIKE. The repository contains comprehensive test infrastructure including golden test data files, BoringSSL test suite runner (bogo), Docker-based interop testing against other TLS implementations (NSS, picotls, mint), and Caddy integration examples. However, the TLS 1.3 implementation is based on early IETF drafts (draft-18, -21, -22, -28) and is not compliant with the final RFC 8446. The post-quantum algorithms SIDH and SIKE have been broken by the Castryck-Decru attack; this code is cryptographically obsolete. The library requires a custom Go toolchain (patched from Go 1.10) and cannot be vendored or used as a standard Go module, making it incompatible with modern Go development workflows.
XX-Net is a desktop application for circumventing internet censorship, primarily targeting the Great Firewall of China. It operates as a multi-protocol proxy client that supports Google App Engine (GAE) fronting, custom X-Tunnel, Cloudflare, CloudFront, and direct connections. The system consists of a launcher with a web-based control panel, a smart router for DNS and traffic routing, and multiple frontend modules that implement various obfuscation and tunneling techniques. The codebase is a large, monolithic Python 2/3 project with heavy use of vendored libraries (tlslite, hyper, ecdsa, asn1crypto, dnslib) for custom TLS, HTTP/2, and cryptographic operations. It is not a data research project; it is a pure application focused on network proxy functionality.