#cryptography

RISC Zero is a zero-knowledge verifiable general computing platform based on zk-STARKs and the RISC-V microarchitecture.

OpenPGP implemented in pure Rust, permissively licensed

Surfpool is where developers start their Solana journey.

Rust SDK for the Machine Payments Protocol

An implementation of Messaging Layer Security (RFC 9420)

Multi-protocol passive fingerprinting library: TCP/HTTP (p0f-style) + TLS (JA4-style) analysis in Rust

TypeScript framework for zk-SNARKs and zkApps

Use Rustls from any language

:lock: Trezor Firmware Monorepo

Go implementation of Waves node, libraries and tools for Waves blockchain

Implementation of the Zcash Orchard Protocol

Zcash Improvement Proposals

Cryptography-oriented big integer library with constant-time, stack-allocated (no_std-friendly) implementations of modern formulas

AWS Encryption SDK for Javascript and Node.js

ShangMi (SM) cipher suites for Go (Go语言商用密码软件)

Python 3 bindings for liboqs

The IAM layer for AI agents: cryptographic identity, capability authorization, and audit trails for non-human identities. Open source.

Rust library for building and interacting with AWS Nitro enclaves.

Rust Implementation of CoRIM (Concise Reference Integrity Manifest)

Core Rust and Haskell libraries used by various components of the Concordium blockchain, as well as some tools used for testing and development.

A modular JWT library for Go, based on IANA specifications.

A pure-Rust implementation of group operations on Ristretto and Curve25519

Encrypted secrets manager for developers and agents.

High performance EraVM for zkSync.

TSS 2.0 Enhanced System API (ESAPI) Rust wrapper

Portable signed records for automated interactions.

An open protocol for per-public-key backends for censorship resistant web applications.

OpenSSL bindings for Rust

Async TLS for the Tokio runtime

cairo-vm is a Rust implementation of the Cairo VM. Cairo (CPU Algebraic Intermediate Representation) is a programming language for writing provable programs, where one party can prove to another that a certain computation was executed correctly without the need for this party to re-execute the same program.