Authentication

OpenPGP data types and associated machinery

Pure Rust implementation of SSH key file format decoders/encoders as described in RFC4251/RFC4253 and OpenSSH key formats, as well as "sshsig" signatures and certificates (including certificate validation and certificate authority support), with further support for the `authorized_keys` and `known_hosts` file formats.

Pure Rust implementation of the SHA-crypt password hashing algorithm based on SHA-256/SHA-512 as implemented by the POSIX crypt C library, including support for generating and verifying password hash strings in the Modular Crypt Format

Scrypt password-based key derivation function

The Rust SASL framework, aimed at both middleware-style protocol implementation and application code. Designed to make SASL authentication simple and safe while handing as much control to the user as possible.

Traits which describe the functionality of password hashing algorithms, with optional support for a `no_std`/`no_alloc`-friendly implementation of the PHC string format, as well as generic support for other formats (e.g. Modular Crypt Format)

Webauthn Framework for Rust Web Servers

Generic implementation of PBKDF2

Pure Rust implementation of the Argon2 password hashing function with support for the Argon2d, Argon2i, and Argon2id algorithmic variants

bcrypt-pbkdf password-based key derivation function

DPoP (RFC 9449) implementation for TurboMCP with HSM support

Signing HTTP requests for AWS, Azure, Google, Huawei, Aliyun, Tencent and Oracle services

Pure Rust implementation of SSH data type decoders/encoders as described in RFC4251

Password authentication library with a focus on simplicity and ease-of-use, including support for Argon2, PBKDF2, and scrypt password hashing algorithms

OAuth 2.1 and authentication for TurboMCP with MCP protocol compliance

Authenticated port knocking - Seccomp wrapper

Pure Rust implementation of the Balloon password hashing function

Generate signatures over Turnkey API requests using a P-256 key.

Umbrella crate re-exporting Greentic secrets spec, core runtime, and optional providers.

Authenticated port knocking - Firewall backend communication protocol

Authenticated port knocking - Systemd support

Pubky SDK

Reads a user's docker credentials from config

Pure Rust implementation of the Modular Crypt Format (MCF) which is used to store password hashes in the form `${id}$...`

A set of tools designed to help canister developers integrate vetKeys into their Internet Computer (ICP) applications

Shared traits and types for Greentic secrets backends.

Webauthn Specification Bindings

Core SPIFFE identity types and Workload API sources

RFC-compliant TOTP implementation with ease of use as a goal and additionnal QoL features.

Type-safe Twitch OAuth 2.0 authentication library with CSRF protection and full scope support

Access control and authentication for Rust Agent Development Kit (ADK-Rust)

Stytch Rust client

Core runtime and backend orchestration for Greentic secrets.

Canonical traits and data models for Greentic secrets (read/write, versioning, metadata).

Types and struct in common between Pubky client and homeserver

A certificate database interface.

Typed newtype identifiers (UserId, TraceId, AgentId, McpServerId…) for systemprompt.io AI governance infrastructure. Enforces type-safe IDs across every boundary in the MCP governance pipeline.

Authenticated port knocking - Wire protocol

Authenticated port knocking - Configuration parser

Pure Rust implementation of the Secure Remote Password (SRP) password-authenticated key exchange (PAKE) algorithm as described in RFC5054. Built on `crypto-bigint`, a mathematical library designed with constant-time algorithms.

A type-driven, ergonomic alternative to JWT for secure stateless PASETO tokens.

Google cloud platform (GCP) authentication using default and custom service accounts

Pubky core's homeserver.

End-to-end encryption and mutual authentication for distributed applications.

PASETO: Platform-Agnostic Security Tokens (in Rust)

Authentication for `git2`

Trait to extend reqwest for digest auth flow.

The SPAKE2 password-authenticated key-exchange algorithm.

An implementation of the RPM PGP interface using Sequoia.

A Rust library for handling Entity Resource Names (ERNs), providing type-safe, hierarchical, and k-sortable resource identifiers for distributed systems and more.