Lib.rs

rustls

modern TLS library written in Rust

curve25519-dalek

pure-Rust implementation of group operations on ristretto255 and Curve25519

blake3

hash function

ed25519-dalek

Fast and efficient ed25519 EdDSA key generations, signing, and verification in pure Rust

rsa

Pure Rust RSA implementation

sha2

Pure Rust implementation of the SHA-2 hash function family including SHA-224, SHA-256, SHA-384, and SHA-512

x25519-dalek

X25519 elliptic curve Diffie-Hellman key exchange in pure-Rust, using curve25519-dalek

openssl

bindings

webpki-roots

Mozilla's CA root certificates for use with webpki

aes

Pure Rust implementation of the Advanced Encryption Standard (a.k.a. Rijndael)

ark-ff

finite fields

tiny-keccak

Keccak derived functions

rcgen

X.509 certificate generator

subtle

Pure-Rust traits and utilities for constant-time cryptographic implementations

zeroize

Securely clear secrets from memory with a simple trait built on stable Rust primitives which guarantee memory is zeroed using an operation will not be 'optimized away' by the compiler…

ark-ec

elliptic curves and pairings

secp256k1

wrapper library for Pieter Wuille’s libsecp256k1. Implements ECDSA and BIP 340 signatures for the SECG elliptic curve group secp256k1 and related utilities.

pem

Parse and encode PEM-encoded data

bcrypt

Easily hash and verify passwords using bcrypt

openssl-probe

helping to find SSL certificate locations on the system for OpenSSL

openssl-sys

FFI bindings to OpenSSL

siphasher

SipHash-2-4, SipHash-1-3 and 128-bit variants in pure Rust

secrecy

Wrapper types and traits for secret management which help ensure they aren't accidentally copied, logged, or otherwise exposed (as much as possible), and also ensure secrets are securely wiped from memory when dropped

sha256

crypto digest

aws-sigv4

SigV4 signer for HTTP requests and Event Stream messages

orion

Usable, easy and safe pure-Rust crypto

s2n-quic

IETF QUIC protocol

sequoia-openpgp

OpenPGP data types and associated machinery

vsss-rs

Verifiable Secret Sharing Schemes for splitting, combining and verifying secret shares

neptune

Poseidon hashing over BLS12-381 for Filecoin

k256

secp256k1 elliptic curve library written in pure Rust with support for ECDSA signing/verification/public-key recovery, Taproot Schnorr signatures (BIP340), Elliptic Curve Diffie-Hellman (ECDH)…

ark-serialize

serializing types in the arkworks ecosystem

constant_time_eq

Compares two equal-sized byte strings in constant time

bls12_381

BLS12-381 pairing-friendly elliptic curve construction

cosmian_crypto_core

Cosmian base cryptographic library

libp2p-identity

Data structures and algorithms for identifying peers in libp2p

boring

BoringSSL bindings

blst

Bindings for blst BLS12-381 library

digest

Traits for cryptographic hash functions and message authentication codes

pact_verifier_cli

Standalone pact verifier for provider pact verification

rustls-webpki

Web PKI X.509 Certificate Verification

snow

pure-rust implementation of the Noise Protocol Framework

jwt-compact

Minimalistic JWT implementation with focus on type safety and secure cryptographic primitives

ed25519-compact

small, self-contained, wasm-friendly Ed25519 implementation

classic-mceliece-rust

Pure rust implementation of the PQC scheme Classic McEliece

curve25519-dalek-ng

pure-Rust implementation of group operations on ristretto255 and Curve25519

risc0-tools

RISC Zero devtools

nu-plugin

Functionality for building Nushell plugins

pqc_kyber

post-quantum Kyber KEM algorithm

mbedtls

Idiomatic Rust wrapper for MbedTLS, allowing you to use MbedTLS with only safe code while being able to use such great Rust features like error handling and closures. Building on MbedTLS's focus on embedded use…

coset

Set of types for supporting COSE

rage

[BETA] A simple, secure, and modern encryption tool

aws-lc-rs

cryptographic library using AWS-LC for its cryptographic operations. This library strives to be API-compatible with the popular Rust library named ring.

w3f-bls

Aggregate BLS-like signatures

minisign

sign files and verify signatures

picky-asn1-x509

ASN1 types defined by X.509 related RFCs

rust-argon2

Argon2 password hashing function

sha1collisiondetection

SHA-1 hash function with collision detection and mitigation

winter-crypto

Cryptographic library for the Winterfell STARK prover/verifier

schnorrkel

Schnorr VRF, signatures, etc. using the Ristretto group

tokio-boring

SSL streams for Tokio backed by BoringSSL

c2patool

displaying and creating C2PA manifests

tokio-openssl

SSL streams for Tokio backed by OpenSSL

ssh-rs

In addition to encryption library, pure RUST implementation of SSH-2.0 client protocol

pgp

OpenPGP implementation in Rust

ring

Safe, fast, small crypto using Rust

curve25519-dalek-ml

pure-Rust implementation of group operations on ristretto255 and Curve25519

tss-esapi

Rust-native wrapper around TSS 2.0 Enhanced System API

keepass

.kdbx database file parser

winter-math

Math library for the Winterfell STARK prover/verifier

djangohashers

port of the password primitives used in Django project

russh

client and server SSH library

cosmian_findex

Symmetric Searchable Encryption

pgen

Passphrase Generator

bnum

Arbitrary, fixed size numeric types that extend the functionality of primitive numeric types

picky

Portable X.509, PKI, JOSE and HTTP signature implementation

tfhe

TFHE-rs is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE

kbs2

secret manager backed by age

openssh-keys

read and write OpenSSH public keys

magic-crypt

MagicCrypt is a Java/PHP/NodeJS/Rust library to encrypt/decrpyt strings, files, or data, using Data Encryption Standard(DES) or Advanced Encryption Standard(AES) algorithms. It supports CBC block cipher mode…

napa

secure command line password manager

x509-certificate

X.509 certificate parser and utility functionality

bls12_381_plus

BLS12-381 pairing-friendly elliptic curve construction. This is a fork from zkcrypto/bls12_381 but adds hash to curve and multiexponentiation methods as well as enables multi-pairing without the allocator requirement

risc0-r0vm

RISC Zero zero-knowledge VM executable

kestrel-cli

Kestrel file encryption program

base64ct

Pure Rust implementation of Base64 (RFC 4648) which avoids any usages of data-dependent branches/LUTs and thereby provides portable "best effort" constant-time operation and embedded-friendly no_std support

nkeys

NATS nkeys library

win-crypto-ng

Safe bindings to Windows Cryptography API: Next Generation

mla

Multi Layer Archive - A pure rust encrypted and compressed archive file format

ockam_core

Core types of the Ockam library

iroh-blake3

BLAKE3 hash function

bls-signatures

Aggregate BLS Signatures

fiat-crypto

generated Rust

shotgun

Minimal X screenshot utility

fernet

in Rust

safecloset

Secret Keeper

self_encryption

Self encrypting files (convergent encryption plus obfuscation)

ockam_node

Ockam [Ockam][main-ockam-crate-link] Node and is intended for use by crates that provide features and add-ons to the main [Ockam][main-ockam-crate-link] library. The main [Ockam][main-ockam-crate-link]…

ark-std

no_std compatibility

merlin

Composable proof transcripts for public-coin arguments of knowledge

odoh-rs

Oblivious DNS over HTTPS (ODoH) protocol version 1

blsttc

Pairing threshold cryptography

cryptoxide

pure implementation of various common modern cryptographic algorithms, WASM compatible

parsec-service

language-agnostic API to secure services in a platform-agnostic way

hpke

hybrid encryption standard (RFC 9180) in pure Rust

dee

cli for drand, with support for timelock encryption

deno_crypto

Web Cryptography API implementation for Deno

ssh-gpg-agent

SSH agent implementation that transparently supports PGP encrypted private SSH keys

nova-snark

Recursive zkSNARKs without trusted setup

rooster

password manager

ark-bls12-381

BLS12-381 pairing-friendly elliptic curve

hmac-sha1

wrapper around the RustCrypto hmac and sha1 crates for simple HMAC-SHA1 generation

gix-object

Immutable and mutable git objects with decoding and encoding support

secret-vault

secure vault to store securely application secrets in memory from Google/AWS/K8S and environment variables

warg-crypto

collection of cryptographic primitives for Warg registries

c2-chacha

ChaCha family of stream ciphers

pairing

Pairing-friendly elliptic curve library

kzen-paillier

Efficient pure-Rust library for the Paillier partially homomorphic encryption scheme

arrow-digest

Stable hashes for Apache Arrow

webpki

Web PKI X.509 Certificate Verification

wei

system

rattler_digest

used by rattler crates to compute different hashes from different sources

authenticator

interacting with CTAP1/2 security keys for Web Authentication. Used by Firefox.

signify

Command-line implementation of the signify signature scheme

cose-rust

COSE Rust implementation

winter-prover

Winterfell STARK prover

sodoken

libsodium wrapper providing tokio safe memory secure api access

rusty_paseto

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

hpke-dispatch

runtime algorithmic selection for hybrid public key encryption

siwe

EIP-4361: Sign In With Ethereum

blockset

command line tool

tor-proto

Asynchronous client-side implementation of the central Tor network protocols

vrf

Fast and extensible Verifiable Random Function (VRF) library; currently supporting secp256k1, secp256r1 and sect163k1 curves

s2n-tls

C99 implementation of the TLS/SSL protocols

fomat-macros

Alternative syntax for print/write/format-like macros with a small templating language

elastic-elgamal

ElGamal encryption and related zero-knowledge proofs with pluggable crypto backend

shadowsocks-crypto

Shadowsocks Crypto

lockstitch

incremental, stateful cryptographic primitive for symmetric-key cryptographic operations in complex protocols

enc_file

Encrypt / decrypt files or calculate hash from the command line. Warning: Don't use for anything important, use VeraCrypt or similar instead.

ece

Encrypted Content-Encoding for HTTP Rust implementation

dexios

Secure, fast and authenticated command-line encryption of files with modern algorithms and an audited encryption backend

aws-smithy-eventstream

Event stream logic for smithy-rs

gst-plugin-sodium

GStreamer plugin for libsodium-based file encryption and decryption

vodozemac

Olm and Megolm

fleek-blake3

BLAKE3 hash function forked for Fleek Network

crrl

cryptographic research

dryoc

Don't Roll Your Own Crypto: pure-Rust, hard to misuse cryptography library

askar-crypto

Hyperledger Aries Askar cryptography

d3xs-bridge

Physical access control (bridge)

http-signature-normalization-actix

HTTP Signatures library that leaves the signing to you

sorted-iter

Typesafe extensions for sorted iterators, including set and relational operations

ecb

Electronic Codebook (ECB) block cipher mode of operation

cryptoki

Rust-native wrapper around the PKCS #11 API

cesride

Cryptographic primitives for use with Composable Event Streaming Representation (CESR)

cocoon

protected container with strong encryption and format validation

zff

interact with zff, a file format for forensic images

inspect-cert-chain

OpenSSL-like text output for debugging certificate chains

miden-crypto

Miden Cryptographic primitives

devolutions-crypto

abstraction layer for the cryptography used by Devolutions

noise-protocol

Noise Protocol Framework implementation

sigma_fun

framework for making Sigma protocols fun!

ast-grep-lsp

Search and Rewrite code at large scale using precise AST pattern

g2p

create types that implement fast finite field arithmetic

triton-vm

virtual machine that comes with Algebraic Execution Tables (AET) and Arithmetic Intermediate Representations (AIR) for use in combination with a STARK proof system to allow proving…

p12

pure rust pkcs12 tool

p256

Pure Rust implementation of the NIST P-256 (a.k.a. secp256r1, prime256v1) elliptic curve as defined in SP 800-186, with support for ECDH, ECDSA signing/verification, and general purpose curve arithmetic

mercy

open-source Rust crate and CLI for building cybersecurity tools, assessment projects, and testing infrastructure

pqcrypto-sphincsplus

Post-Quantum Signature Scheme sphincsplus

binstalk-fetchers

binstall fetchers

osshkeys

read and write OpenSSH public and private keys

botan

wrapper for Botan cryptography library

merkle-search-tree

data structure for efficient state-based CRDT replication and anti-entropy

libsm

China's Standards of Encryption Algorithms (SM2/3/4)

sha3sum

- compute and check SHA3 message digest

biscuit-cli

CLI to manipulate biscuit tokens

curve25519-parser

Curve25519 Parser - DER/PEM parser for OpenSSL Ed25519 / X25519 keys

royalguard

Secure Ergonomic Command Line Password Manager. Free Forever. Made with ❤️ using 🦀

bitwarden-api-api

Api bindings for the Bitwarden API

jaws

JSON Algorithms and Web Signing

sunscreen

Fully Homomorphic Encryption (FHE) compiler supporting the Brakerski/Fan-Vercauteren (BFV) scheme

cryptographic-message-syntax

pure Rust implementation of Crypographic Message Syntax (RFC 5652)

trust-graph

trust graph

tor-llcrypto

Low level cryptography wrappers used by Tor

mbedtls-sys-auto

bindings for MbedTLS. This version generates the correct bindings at compile time using bindgen

dusk-bls12_381

Fork of the implementation of the BLS12-381 pairing-friendly elliptic curve construction with some extra tooling needed by the Dusk team

ledger_device_sdk

Ledger device Rust SDK

concrete

fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE

threema-gateway

client library for the Threema Gateway

ironhide

easily encrypt and decrypt files to users and groups. Similar to GPG, but usable at scale.

ic_bls12_381

BLS12-381 pairing-friendly elliptic curve construction

bertie

Minimal TLS 1.3 implementation

pasetors

PASETO: Platform-Agnostic Security Tokens (in Rust)

sss-rs

secret sharing scheme implemented in Rust

rasn-pkix

Data types for handling Public Key Infrastructure (PKIX) objects

aruna-file

component for encrypting / compressing .aruna files, including specification

memsecurity

Securely hold secrets in memory and protect them against cross-protection-boundary readout via microarchitectural, via attacks on physical layout, and via coldboot attacks

kyberlib

Robust Rust Library for CRYSTALS-Kyber Post-Quantum Cryptography

oqs

interface to Open-Quantum-Safe's liboqs

tink-aead

AEAD functionality for Rust port of Google's Tink cryptography library

win-crypto

Safe bindings to Windows Cryptography API: Next Generation

secp256k1-sys

FFI for Pieter Wuille’s libsecp256k1 library

miden-vm

Miden virtual machine

vls-protocol

implementing a Lightning signer, which externalizes and secures cryptographic operations

wsts

Weighted Schnorr Threshold Signatures, based on FROST

k8-config

Read Kubernetes config

rsign2

command-line tool to sign files and verify signatures

hkdf

HMAC-based Extract-and-Expand Key Derivation Function (HKDF)

turboshake

family of extendable output functions based on keccak-p[1600, 12] permutation

fastmurmur3

Fast non-cryptographic hash, with the benchmarks to prove it

tiny-merkle

tiny merkle tree library for Ethereum

gpgme

bindings for Rust

azure_svc_keyvault

generated REST API bindings

krill

Resource Public Key Infrastructure (RPKI) daemon

ppv-lite86

crypto-simd API for x86

fedimint-threshold-crypto

Pairing threshold cryptography (Fedimint fork)

openmls

Messaging Layer Security (MLS) protocol, as defined in RFC 9420

chbs

providing secure passphrase generation based on a wordlist

decanter

implements basic cryptographic primitives native to the ecosystem

aws-lc-sys

AWS-LC is a general-purpose cryptographic library maintained by the AWS Cryptography team for AWS and their customers. It іs based on code from the Google BoringSSL project and the OpenSSL project.

qiniu-upload-manager

Qiniu Upload Manager for Rust

sct

Certificate transparency SCT verification library

stegano

ultimate steganography swiss knife army CLI tool

hpke-rs

HPKE Implementation

secp256k1-zkp

bindings for the libsecp256k1-zkp library

ciphercore-base

base package of CipherCore: computation graphs API, Secure MPC Compiler, utilities for graph evaluation and inspection

cait-sith

Threshold ECDSA via Triples

submap

B-Tree map for pub/sub services

az-snp-vtpm

vTPM based SEV-SNP attestation for Azure Confidential VMs

bbjwt

well documented JWT validation library, mainly for validating OpenID Connect ID Tokens

sp-ark-models

substrate replacement model for bls12 of ark-ec

narrowlink-client

Narrowlink Client

didcomm

DIDComm for Rust

oniongen-rs

v3 .onion vanity URL generator written in Rust

clear_on_drop

Helpers for clearing sensitive data on the stack and heap

rinkey

Keyset manipulation command-line tool for Rust port of Google's Tink cryptography library

frost-core

Types and traits to support implementing Flexible Round-Optimized Schnorr Threshold signature schemes (FROST)

psa-crypto

Wrapper around the PSA Cryptography API

ripasso

password manager that uses the file format of the standard unix password manager 'pass'

msecret

reference implementation of MSecret key derivation, written in pure Rust. Includes a helpful command-line utility

fog-crypto

signing & encryption easier for small, independent blocks of bytes. Primary use-case is the fog-pack crate.

sigstore

experimental crate to interact with sigstore

sha2raw

SHA-2 hash function

zeropool-bn

Pairing cryptography with the Barreto-Naehrig curve

bitwark

Empowering secure digital interactions with robust binary token management and dynamic rolling keys

secapi

bindings

urlpattern

rust-urlpattern is a Rust implementation of the URLPattern standard

halo2-ecc

In-circuit elliptic curve library for halo2

chksum-hash

cryptography library that provides an interface for calculating hash digests using both batch and stream computation

ssh-vault

encrypt/decrypt using ssh keys

wdcrypt

CLI to encrypt the current working directory with Fernet encryption

strobe-rs

Strobe protocol framework in pure Rust

reddsa

standalone implementation of the RedDSA signature scheme

did-key

did:key method

sgx_pkix

TLS Certificate encoding and decoding helpers for the SGX environment

crtshmon

Monitor crt.sh for new certificates

bellpepper

Gadgets for a SNARK Circuit library

spiffe

client library implementation for SPIFFE

dco3_crypto

Symmetric and asymmetric encryption for DRACOON in Rust

xoofff

Farfalle with Xoodoo: Parallel Permutation-based Cryptography

ockam

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

rnacos

Nacos server re-implemented in Rust

lair_keystore

secret lair private keystore

xts-mode

XTS block mode implementation in rust

mls-rs

Messaging Layer Security (RFC 9420)

oid

Rust-native library for building, parsing, and formating Object Identifiers (OIDs)

truelayer-signing

Produce & verify TrueLayer API requests signatures

spg

secure password generator over CLI

hsh

Quantum-Resistant Cryptographic Hash Library for Password Encryption and Verification in Rust

ciphercore-utils

Convenience functions and wrappers used by CipherCore crates

salty

Small, sweet, swift Ed25519 signatures for microcontrollers

substrate-bn

Pairing cryptography with the Barreto-Naehrig curve

nuts-container

secure storage library

smpl_jwt

Very simple JWT generation lib

umbral-pre

Umbral proxy reencryption algorithm

double-ratchet-rs

pure Rust implementation of the Double Ratchet algorithm as described by Signal

ed448-goldilocks

pure-Rust implementation of Ed448 and Curve448 and Decaf

rustpad

Multi-threaded Padding Oracle attacks against any service

ntrulp

Pure implementation of high-security prime-degree large-Galois-group inert-modulus ideal-lattice-based cryptography

runrs

Run Rust Scripts

zkmemory

universal memory prover in Zero-Knowledge Proof

mpvss-rs

Publicly Verifiable Secret Sharing Library

ruma-signatures

Digital signatures according to the Matrix specification

capycrypt

complete Rust cryptosystem implementing NIST FIPS 202 & NIST FIPS 197 paired with a variety of Edwards curves. An academic exercise in cryptographic algorithm design.

ed-daemon

docker based container deployment

miden-air

Algebraic intermediate representation of Miden VM processor

short-crypt

ShortCrypt is a very simple encryption library, which aims to encrypt any data into something random at first glance

generic-ec

General elliptic curve cryptography

gix-date

gitoxide project parsing dates the way git does

roughenough

Roughtime secure time sync server and client written in Rust

sha1

SHA-1 hash function

crypto-primes

Random prime number generation and primality checking library

mc-oblivious-ram

Implementations of Oblivious RAM data structures

rtorrent-xmlrpc-bindings

XMLRPC API bindings for rtorrent

aprs-parser

APRS message parser for Rust

secret-vault-value

secure and serializable type to store and control secret/sensitive values

efficient-sm2

China's Standards of Signature Algorithms (SM2)

loopring_sign

generates an eddsa signature for loopring

rbw

Unofficial Bitwarden CLI

mkserial

Serial number generator for X.509 certificates

simple-ssl-acme-cloudflare

SSL with ACME and CloudFlare is a tool to simply apply SSL certificates by using OpenSSL and ACME via CloudFlare DNS

mpc-relay

Noise protocol websocket relay for MPC/TSS applications

cableguard

WireGuard® protocol that uses rich online digital tokens for configuration and mutual authentication

secrets

Protected-access memory for cryptographic secrets

rdedup

Data deduplication with compression and public key encryption. - binary

gitbom

experimental implementation of gitbom in Rust

glass_pumpkin

cryptographically secure prime number generator based on rust's own num-bigint and num-integer

chacha20poly1305

Pure Rust implementation of the ChaCha20Poly1305 Authenticated Encryption with Additional Data Cipher (RFC 8439) with optional architecture-specific hardware acceleration. Also contains…

multihash-codetable

Default multihash code-table with cryptographically secure hash implementations

scryptenc

scrypt encrypted data format

libqabu

auditable and versitile Rust cryptography library

balanced-tree-index

constant-time manipulation of a complete binary tree with a flat in-memory representation

sframe

pure rust implementation of SFrame draft-ietf-sframe-enc-03

warg-cli

warg registry command line interface

cosmian_cover_crypt

Key Policy attribute encryption based on subset cover

miracl_core_bls12381

code of https://github.com/miracl/core (miracl_core) for curve BLS 12-381

aws-nitro-enclaves-cose

aims to provide a safe Rust implementation of COSE, with COSE Sign1 currently implemented

gldf-sign

command-line tool to sign GLDF files and verify GLDF signatures, based on minisign

hmac-sha512

small, self-contained SHA512, HMAC-SHA512, SHA384 and HMAC-SHA384 implementation

kms-aead

KMS/AEAD envelope encryption for GCP/AWS KMS and Ring AEAD encryption

surrealdb-jsonwebtoken

Temporary jsonwebtoken fork with Wasm support

grammers-crypto

Several cryptographic utilities to work with Telegram's data

bellman

zk-SNARK library

mozilla/jwcrypto

Firefox Application Services

turnstile

One-way encryption

rust-clacc

implementanion of a CL universal accumulator

wasefire-stub

Stubs for the Wasefire applet API

gitoid

experimental implementation of gitoids in Rust

xxxdh

Pure Rust X3DH key exchange protocol implementation

native-pkcs11-keychain

native-pkcs11 backend for macos keychain

rpm-sequoia

RPM PGP interface using Sequoia

etebase

client library for Etebase

chik-bls

BLS signature, verification and aggregation funcions for the Chik blockchain

playfair_cipher

Playfair cipher as described at <https://en.wikipedia.org/wiki/Playfair_cipher> and Four square ad described at <https://en.wikipedia.org/wiki/Four-square_cipher>

citadel_pqcrypto

Lower-level cryptographic library for the Citadel Protocol

curv-kzen

Curv contains an extremely simple interface to onboard new elliptic curves. Use this library for general purpose elliptic curve cryptography

apple-codesign

Pure Rust interface to code signing on Apple platforms

openpgp-card-tools

inspecting and configuring OpenPGP cards

keyutils

interface to the Linux keyring

u144

Unsigned Integer 144 bits

flexible-transcript

transcript trait definition, along with viable options

libaes

AES cipher in safe Rust with no dependencies

oberon

multi-factor zero-knowledge capable token without requiring email, SMS, or authenticator apps. The proof of token validity is only 96 bytes while the token itself is only 48 bytes

yacme

ACME client

tiny-encrypt

tiny file encrypt tool

ockam_transport_websocket

WebSocket Transport for the Ockam Routing Protocol

ark-poly

efficient polynomial arithmetic via FFTs over finite fields

winter-air

AIR components for the Winterfell STARK prover/verifier

e2e-irc

IRC bouncer that can send encrypted messages

age

[BETA] A simple, secure, and modern encryption library

tari_bulletproofs

pure-Rust implementation of Bulletproofs using Ristretto

blsful

BLS signature implementation according to the IETF spec on the BLS12-381 curve

dusk-schnorr

pure-Rust implementation of Schnorr signatures with a PLONK circuit module additionally

acvm_stdlib

ACVM standard library

nethsm-sdk-rs

SDK to communicate with Nitrokey NetHSM

ml-kem-rs

FIPS 203 (draft): Module-Lattice-Based Key-Encapsulation Mechanism

async-acme

async ACME client for tls-alpn-01 challenge

ed25519-consensus

Ed25519 suitable for use in consensus-critical contexts

gm-rs

China's Standards of Encryption Algorithms(SM2/SM3/SM4)

bulletproofs

pure-Rust implementation of Bulletproofs using Ristretto

bjorn-acme

Building blocks for an ACME server

sheesy-cli

'share-secrets-safely' CLI to interact with GPG/pass-like vaults

blake2b-rs

bindings for the official Blake2b C implementation

libecvrf

ECVRF that's friendly with EVM, based on curve secp256k1 and keccak256

s2n-tls-tokio

TLS streams for Tokio built on top of s2n-tls

nova-scotia

Middleware to compile Circom circuits to Nova zkSNARK scheme

fhe

Fully Homomorphic Encryption in Rust

serde-encrypt

Encrypts all the Serialize

ncryptf-rs

Secure API authentication and end to end encryption

bupstash

Easy and efficient encrypted backups

circom-scotia

Middleware to compile Circom circuits to Bellperson

crypto-hash

wrapper for OS-level cryptographic hash functions

mas-iana

IANA registry data for JOSE and OAuth 2.0

sop

Interface for the Stateless OpenPGP Interface

x509-verify

Pure Rust library that verifies X.509 signatures based on the algorithm identifiers

mozilla/neqo-crypto

benaloh-challenge

Implements the Benaloh Challenge (also known as an Interactive Device Challenge), a crytographic technique to ensure the honesty of an untrusted device

rusty_paserk

Platform Agnostic Serializable Keys (PASERK) is an extension on PASETO for key management

stack_epic_keychain

Chain implementation for epic, a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format

bounds

interact with bounded and unbounded ranges

envelopers

very simple envelope encryption library using aes-gcm

rs-password-utils

Password utilities, writen in Rust

did-pkh

did:pkh DID method, using the ssi crate

argon2rs

pure Rust password hashing library that runs on Argon2

secured

lightweight, easy-to-use Rust package for file encryption and decryption, suitable for both CLI and library integration in Rust applications

encrypto_rsa

stunning-encrypto is cross platform end-to-end encryption dependency

kuznechik

Synchronous encryption algorithm "Kuznechik" (GOST R 34.12-2015, GOST R 34.13-2015)

cggmp21

TSS ECDSA implementation based on CGGMP21 paper

product-os-security

Product OS : Security provides a suite of helper tools to easily perform cryptograhpic operations including generating hashes, encrypting and decryting content

envio

command-line tool that simplifies the management of environment variables across multiple profiles. It allows users to easily switch between different configurations and apply them to their current environment…

djpass

command-line tool to generate and verify passwords used in Django project

risc0-zkvm

RISC Zero zero-knowledge VM

http-signature-normalization-reqwest

HTTP Signatures library that leaves the signing to you

cmn

accessing a collection of mathematical and cryptographic constants

paillier-common

paillier over bigint traits provided by rust-bigint

merkle-sdk

seamless integration with Merkle's services

cretrit

Flexible Order-Revealing Encryption library

qs-lite

QSocket liteweight beacon

digestible

more dynamic Hash and Hasher trait for Rust

oci-registry-client

async client for Docker Registry HTTP V2 protocol

hashes

cryptographic hash function algorithms

nettext

text-based data format for cryptographic network protocols

deno_tls

TLS for Deno

ntcip

NTCIP: National Transportation Communications for ITS Protocol

twenty-first

Collection of mathematics routines and cryptography for the twenty-first century

flek

Rustacean implementation of my own algorithms to check for password security

concrete-core

Concrete is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE

signature

Traits for cryptographic signature algorithms (e.g. ECDSA, Ed25519)

winter-verifier

Winterfell STARK verifier