Keycloak is a production-grade open-source Identity and Access Management (IAM) server. In production it provides authentication and authorization for applications via OIDC/OAuth2, SAML, and emerging standards including OID4VC verifiable credentials (SD-JWT, mdoc, LDP), Shared Signals Framework (SSF/CAEP/RISC), WebAuthn passkeys, and CIBA. The server is a modular Java monolith running on Quarkus, exposing REST admin APIs (v1 plus a feature-gated v2), protocol endpoints, and React-based admin/account consoles, with a Kubernetes operator for managed deployment and CLI tools (kc.sh, kcadm.sh, kcreg.sh). The architecture is built around a pervasive SPI/provider-factory pattern: nearly every subsystem (authentication flows, password hashing, event listeners, user storage federation, token introspection, crypto providers, theme selection) is pluggable via ProviderFactory + Spi interfaces, making the system highly extensible. Persistence uses JPA/Hibernate with Liquibase migrations across PostgreSQL, MySQL, MariaDB, Oracle, and MSSQL; distributed caching and cluster events use Infinispan. The codebase also ships Java and TypeScript admin client libraries and legacy WildFly SAML adapters. Primary data flows: browser/device authentication flows produce signed tokens (access, refresh, ID, userinfo) via pluggable crypto providers (BouncyCastle, FIPS 140-2, Elytron); user/session state flows between the database and Infinispan caches with invalidation events; identity brokering federates users from LDAP, Kerberos, and social IdPs; admin operations emit admin and audit events. Test infrastructure is extensive: a new JUnit 5 test framework with DI annotations coexists with a legacy Arquillian suite (migration in progress), plus Playwright e2e tests for the admin UI. This is purely an application repository - no data pipelines or research artifacts. Notable reusable components include a self-contained SD-JWT implementation, a JOSE/JWS/JWK library, and generic utilities (PathMatcher, Retry) that could be extracted into other Java projects with minimal modification.
Better Auth is a framework-agnostic authentication and authorization framework for TypeScript, designed as a monorepo with a core library, multiple database adapters (Drizzle, Prisma, Kysely, MongoDB, in-memory), client SDKs (React, Vue, Svelte, Solid, Expo, Electron), and a plugin ecosystem. It supports email/password, OAuth2/OIDC, SAML, SCIM, passkeys, 2FA, phone number OTP, and more. The architecture is modular: the core package provides the `betterAuth()` function, which configures plugins, database adapters, and social providers, and exposes a REST API for authentication flows. Client libraries use nanostores for reactive state management. The CLI offers project scaffolding, migration generation, and schema validation. External dependencies include jose for JWT, zod for validation, and various ORMs for database access. The codebase is well-tested with unit, integration, and e2e tests across all packages, and includes a release tooling package with AI-assisted changelog generation.
Authorizer is a self-hosted, production-grade authentication and authorization server written in Go. It implements OAuth 2.0 / OIDC, SAML IdP/SP, SCIM 2.0, WebAuthn/passkeys, TOTP, email/SMS OTP, and fine-grained authorization via an embedded OpenFGA engine. The architecture is transport-agnostic: a shared service layer (internal/service) is called by GraphQL resolvers, gRPC handlers, and HTTP handlers (Gin). It supports multiple storage backends (SQL, MongoDB, Cassandra, DynamoDB, Couchbase, ArangoDB) via a unified storage.Provider interface, plus Redis and in-memory stores for sessions and caching. The system includes a React admin dashboard, an end-user login SPA, and an MCP (Model Context Protocol) server for AI tool exposure. Security is a primary focus, with extensive regression tests for CVEs, SSRF protection, constant-time comparisons, and audit logging.
Hanko is a production-grade, self-hostable authentication and identity platform written primarily in Go. The backend exposes public, admin, and management HTTP APIs plus a CLI for migrations, user import/export, JWK/JWT management, and config schema generation. Authentication is implemented as a custom state-machine engine (flowpilot) driving login, registration, password/passkey/MFA/third-party OAuth/SAML flows, backed by JWT sessions, device trust, webhooks, audit logs, and rate limiting. The persistence layer uses gobuffalo/pop with a broad set of per-entity persister interfaces and roughly 65 Fizz migrations covering users, emails, credentials, sessions, tenants, organizations, roles, SAML providers, and webhooks. The frontend is split into a TypeScript SDK (`@teamhanko/hanko-frontend-sdk`) and Preact-based web components (`@teamhanko/hanko-elements`) that render flow states into embeddable `<hanko-auth>` and `<hanko-profile>` elements. The repository also contains a quickstart Go server, framework examples for React, Vue, Angular, Next.js, and Express, Playwright e2e tests, Docker Compose stacks, and Kubernetes manifests. Data flows through Echo routers into flowpilot actions/hooks, which validate inputs, persist state, issue sessions, and trigger webhook events; PostgreSQL, Redis, SMTP, and external OAuth/SAML providers are the primary external dependencies. Overall the codebase is well-structured and heavily tested, with sophisticated security handling around redirect validation, account linking, multi-tenant isolation, and webhook signing. The main friction points are the custom flowpilot framework's learning curve, a very large configuration surface, duplicated example code, and some stale example/e2e toolchains relative to the core Go and Node versions.
GoTrue is a self-contained user registration and authentication API written in Go. It provides endpoints for signup, login (via email/password or OAuth2 providers like GitHub, GitLab, Google, Bitbucket, Facebook), token refresh, password recovery, email verification, and user management (CRUD for admin users). The architecture is a monolithic HTTP API using the chi router, backed by a MySQL database (via pop/v5 ORM) and a configurable mailer (SMTP or noop). It supports both single-tenant and multi-tenant deployments, with JWT-based authentication (HS256) and optional SAML SSO. The codebase is well-organized into packages: api for HTTP handlers, models for database entities, conf for configuration, mailer for email sending, and crypto for security utilities. It includes extensive unit tests and integration tests using a MySQL test database.
buji-pac4j is a bridge library that integrates pac4j (a comprehensive security library supporting OAuth, CAS, SAML, OpenID Connect, etc.) with Apache Shiro. It automatically pushes pac4j authentication and authorization profiles into the Shiro security context, allowing developers to use pac4j's wide range of authentication mechanisms while leveraging Shiro for authorization and session management. The bridge is implemented as a set of classes that adapt pac4j's session store, profile manager, and framework adapter to Shiro's APIs, plus a custom Realm, SubjectFactory, and Token. It includes sophisticated logic to avoid unnecessary session renewal when the same user's profiles are updated (e.g., after token refresh), demonstrating deep understanding of both frameworks' internals. The library is production-ready, actively maintained, and used in legacy applications that want to adopt pac4j without fully migrating away from Shiro.
gimme-aws-creds is a Python CLI tool for obtaining temporary AWS and Alibaba Cloud credentials via Okta SAML authentication. It supports both Okta Classic and Identity Engine flows, handles multiple MFA methods (push, TOTP, hardware tokens, SMS, email, FIDO2/WebAuthn, Duo), and exchanges SAML assertions for temporary cloud credentials. The tool outputs credentials in various formats (export, JSON, Windows PowerShell) or writes them to standard credential files (~/.aws/credentials, ~/.aliyun/config.json). The application features a modular architecture with separate modules for Okta authentication (okta_classic.py, okta_identity_engine.py), cloud provider resolution (aws.py, alibaba_cloud.py), configuration management (config.py), MFA handling (duo.py, u2f.py, webauthn.py), and shared utilities (common.py, ui.py, debug_formatter.py). Key entry points include bin/gimme-aws-creds (main executable) and platform-specific wrappers. Data flows involve parsing configuration/authentication options, performing Okta authentication with MFA, extracting SAML assertions, assuming cloud roles via STS APIs, and formatting output. Notable reusable components include a flexible configuration system with inheritance and source tracking (config.py), isolated SAML parsing utilities (common.py), a UI abstraction layer for testability (ui.py), and a secure HTTP logging formatter that automatically redacts sensitive data (debug_formatter.py). The project is actively maintained but shows medium technical drift due to platform-specific WebAuthn dependencies requiring older Python versions on Windows and the complexity of maintaining compatibility with multiple authentication systems and cloud providers.
MaxKey is an enterprise-grade Identity and Access Management (IAM) / Single Sign-On (SSO) platform written in Java (Spring Boot) with Angular frontends. It supports a comprehensive set of authentication protocols (OAuth 2.0/OpenID Connect, SAML 2.0, CAS, JWT, form-based, token-based) and identity federation standards (SCIM 2.0, LDAP, Active Directory). The codebase is organized as a multi-module Maven project with clear separation between authentication providers, protocol implementations, persistence layer, and web UIs. Architecturally, it follows a service-oriented model with a custom OAuth2 stack (derived from Spring Security OAuth), MyBatis JPA for persistence, and Redis/Caffeine for caching. The frontends are built on NG-ALAIN (Angular 17) and share a common base for user portal and admin console. While the system is functionally rich and actively maintained, it contains some duplicated code across modules and relies on a legacy OAuth2 implementation that has been superseded by Spring Security 5+. The crypto utilities, OTP infrastructure, and adapter patterns are well-structured and demonstrate non-obvious craftsmanship.
This repository is a Payload CMS authentication plugin (payload-auth-plugin) that provides OAuth2, OIDC, password, and passkey authentication strategies. It is designed to be used with Payload CMS v3+ and integrates deeply with Payload's admin panel and frontend via custom API endpoints, collection field injection, and a client-side library. The plugin supports multiple providers (Google, GitHub, Apple, etc.) via a clean provider factory pattern and manages its own session cookies, credential hashing (PBKDF2), and account linking. The architecture is a plugin that hooks into Payload's lifecycle, extending the CMS with authentication endpoints and database collections. The example application (examples/with-website/) demonstrates a full Payload CMS + Next.js website with admin and public authentication flows. Despite being pre-1.0, the codebase exhibits solid engineering patterns: strategy pattern for endpoint registration, collection helper functions that merge user-defined configs, and a reusable AuthClient class for browser-side authentication. However, it lacks automated tests, has several FIXME comments in passkey and password protocols, and is tightly coupled to Payload's internal DB and cookie mechanisms, which introduces technical drift risk as Payload evolves. The plugin is actively maintained with frequent releases and a changelog documenting 50+ versions.