Certbot is a production-grade Python CLI tool and library for automating TLS certificate lifecycle management via the ACME protocol (RFC 8555). It obtains, renews, revokes, and deploys certificates from Let's Encrypt and other ACME-compliant CAs. The project uses a plugin-based architecture with authenticators (HTTP-01, DNS-01, standalone) and installers (Apache, Nginx, webroot) that are discovered via Python entry points. Key internal modules handle certificate lineage storage, renewal scheduling with ARI (draft-ietf-acme-ari), configuration rollback, and cross-platform OS compatibility. The repository also includes a reusable ACME protocol library (`acme`), extensive unit and integration tests (Pebble-based), and packaging for snaps, Docker, and pip. While highly polished and actively maintained, the codebase contains some deprecated shims and complex parser implementations for Apache and Nginx.
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.
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.
This is the Dogtag PKI (Red Hat Certificate System) codebase, a comprehensive enterprise-grade Public Key Infrastructure server suite. It provides multiple subsystems: Certificate Authority (CA) for certificate lifecycle management, Key Recovery Authority (KRA) for key archival and recovery, Online Certificate Status Protocol (OCSP) responder, Token Key Service (TKS) for smart card key handling, Token Processing System (TPS) for token management, and ACME/EST responders for automated certificate enrollment. The system exposes REST APIs (both JAX-RS v1 and servlet-based v2), a rich CLI toolset (Java and Python), and a legacy Swing admin console (deprecated). Backend storage primarily uses LDAP (389 Directory Server) for certificates, requests, and configuration, with PostgreSQL optionally used for ACME realms. The architecture follows a modular monolith pattern: each PKI subsystem runs as a separate Java web application deployed on Apache Tomcat, sharing common libraries from base/common and base/server. Cryptographic operations are handled via NSS (Network Security Services) and JSS (Java Security Services). Key patterns include a ConfigStore hierarchy for type-safe configuration access, a JSONSerializer interface for consistent data serialization, a CommandCLI base class for building CLI commands, and a policy/profile framework for certificate issuance rules. The codebase demonstrates strong engineering with extensive test coverage (unit, integration, CI workflows), Docker support, and versioned upgrade scripts. While the codebase is actively maintained with frequent commits and a comprehensive CI pipeline, it shows signs of technical drift: a large volume of deprecated Swing console code marked for removal, persistent use of legacy com.netscape package names alongside newer org.dogtagpki packages, and a polyglot codebase (Java, Python, native C++ for TPS client) that increases maintenance complexity. The quality is solid overall with well-separated concerns and reusable patterns, though the sheer scale and historical accumulation of components prevent it from being considered exceptional.
Certimate is a self-hosted SSL certificate automation tool that manages the full lifecycle of TLS certificates: issuance via ACME protocol, deployment to a vast array of cloud providers (CDN, WAF, load balancers, object storage, hosting panels), and notification via chat bots and email. The system is a single-binary application with an embedded PocketBase backend (SQLite) and a React frontend. The backend is written in a Go-like language and exposes REST APIs for managing certificates, workflows, and settings. The frontend provides a visual workflow designer for creating automation pipelines with nodes for ACME issuance, deployment, upload, monitoring, and notification. Architecture: The application is built around a plugin-style provider architecture. Core interfaces (Deployer, Certmgr, Notifier, ACMEChallenger) are implemented by dozens of providers for different cloud services. A workflow engine executes directed acyclic graphs of nodes, with support for conditions, try/catch, delays, and parallel branches. The system uses PocketBase for persistence, cron-based scheduling, and admin authentication. The UI is built with React, Ant Design, and a flow editor library. Key entry points: main.go (CLI entry), cmd/serve_*.go (server startup), internal/rest/handlers/ (REST endpoints), internal/workflow/engine/ (workflow execution), internal/certacme/ (ACME client), internal/certmgmt/deployers/ (deployment registry), internal/notify/ (notification service). Data flows: User configures access credentials and workflows via UI. Workflows are scheduled via cron and executed by the engine, which calls ACME challengers to issue certificates, then deployers to install them, and notifiers to send alerts. Certificate and workflow state is persisted in PocketBase. External dependencies: PocketBase for storage and admin auth, lego (go-acme) for ACME protocol, dozens of cloud provider SDKs (Alibaba, AWS, Tencent, Huawei, etc.), and various third-party APIs for DNS challenges and deployment. The project also includes trimmed/patched copies of several SDKs to reduce dependency footprint.
This repository is a curated list of free online courses and certifications in IT, computer science, design, and business. It is not a software application or data pipeline. The core content is a single README.md file containing a large table of courses organized by category (e.g., Artificial Intelligence, Back-End, Cloud Computing) with columns for course name, provider, level, duration, and reward type (badge or certificate). Supporting files include contribution guidelines, issue templates, a code of conduct, and a GitHub Actions workflow that periodically checks for broken markdown links. There is no executable code, no API, no data transformations, and no reusable software components. The project's value lies entirely in its curated content and community-driven maintenance. From a software engineering perspective, the repository is trivial; its quality score reflects the absence of code rather than the quality of the list itself.