Lib.rs

rustls

Rustls is a modern TLS library written in Rust

blake3

the BLAKE3 hash function

digest

Traits for cryptographic hash functions

curve25519-dalek

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

aes

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

pem

Parse and encode PEM-encoded data

rsa

Pure Rust RSA implementation

x25519-dalek

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

k256

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

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…

openssl

OpenSSL bindings

secp256k1

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

openssl-sys

FFI bindings to OpenSSL

subtle

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

sequoia-openpgp

OpenPGP data types and associated machinery

orion

Usable, easy and safe pure-Rust crypto

cryptoxide

pure implementation of various common modern cryptographic algorithms, WASM compatible

tiny-keccak

An implementation of Keccak derived functions

s2n-tls

A C99 implementation of the TLS/SSL protocols

recrypt

A pure-Rust implementation of Transform Encryption, a Proxy Re-encryption scheme

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

snow

A pure-rust implementation of the Noise Protocol Framework

hpke

An implementation of the HPKE hybrid encryption standard (RFC 9180) in pure Rust

siphasher

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

djangohashers

A Rust port of the password primitives used in Django project

rage

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

schnorrkel

Schnorr VRF, signatures, etc. using the Ristretto group

boring

BoringSSL bindings

sha2

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

bcrypt

Easily hash and verify passwords using bcrypt

sheesy-cli

The ‘share-secrets-safely’ CLI to interact with GPG/pass-like vaults

dusk-jubjub

Dusk’s fork of the implementation of the Jubjub elliptic curve group

chacha20poly1305

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

rustls-pemfile

Basic .pem file parser for keys and certificates

constant_time_eq

Compares two equal-sized byte strings in constant time

ed25519-compact

A small, self-contained, wasm-friendly Ed25519 implementation

sha1collisiondetection

SHA-1 hash function with collision detection and mitigation

ed25519-dalek

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

http-signature-normalization-actix

An HTTP Signatures library that leaves the signing to you

hmac

Generic implementation of Hash-based Message Authentication Code (HMAC)

rust-argon2

Rust implementation of the Argon2 password hashing function

bls12_381

Implementation of the BLS12-381 pairing-friendly elliptic curve construction

blstrs

High performance implementation of BLS12 381

vsss-rs

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

sequoia-sq

Command-line frontends for Sequoia

tss-esapi

Rust-native wrapper around TSS 2.0 Enhanced System API

roughenough

A Roughtime secure time sync server and client written in Rust

security-framework

Security.framework bindings for macOS and iOS

zeropool-bn

Pairing cryptography with the Barreto-Naehrig curve

kbs2

A secret manager backed by age

secrets

Protected-access memory for cryptographic secrets

ppv-lite86

Implementation of the crypto-simd API for x86

picky

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

bao

an implementation of BLAKE3 verified streaming

gridiron

Rust finite field library with fixed size multi-word values

tindercrypt

Data encryption with symmetric cryptographic keys or passwords/passphrases, and self-contained encryption metadata

serde-encrypt

Encrypts all the Serialize

gpgme

GPGme bindings for Rust

dusk-poseidon

Implementation of Poseidon hash algorithm over the Bls12-381 Scalar field

coset

Set of types for supporting COSE

strobe-rs

An implementation of the Strobe protocol framework in pure Rust

ockam_core

Core types of the Ockam library

short-crypt

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

pact_verifier_cli

Standalone pact verifier for provider pact verification

der

Pure Rust embedded-friendly implementation of the Distinguished Encoding Rules (DER) for Abstract Syntax Notation One (ASN.1) as described in ITU X.690 with full support for heapless no_std targets

webpki

Web PKI X.509 Certificate Verification

libsodium-sys

FFI binding to libsodium

ring

Safe, fast, small crypto using Rust

ed25519-dalek-blake3

fork ed25519-dalek , replace sha512 to blake3

enc_file

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

sha256

sha256 crypto digest

ockam_transport_websocket

WebSocket Transport for the Ockam Routing Protocol

merkletree

Light merkle tree implementation with SPV support and dependency agnostic

hc_seed_bundle

SeedBundle parsing and generation library

winter-crypto

Cryptographic library for the Winterfell STARK prover/verifier

reddsa

A standalone implementation of the RedDSA signature scheme

pqcrypto

Post-Quantum cryptographic primitives

winter-math

Math library for the Winterfell STARK prover/verifier

rusty_paseto

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

x509-certificate

X.509 certificate parser and utility functionality

aligned-cmov

Fast constant-time conditional moves of aligned bytes

sigma_fun

A framework for making Sigma protocols fun!

threema-gateway

A client library for the Threema Gateway

olm-sys

Low level binding for libolm

google-authenticator

This Rust crate can be used to interact with the Google Authenticator mobile app for 2-factor-authentication

ensync

A flexible ENcrypted file SYNChroniser suitable for uses where the central location is not fully trusted

concrete-core

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

shadowsocks-crypto

Shadowsocks Crypto

crypto_api_chachapoly

An implementation of ChaCha20-IETF, Poly1305 and ChachaPoly-IETF for crypto_api

ed448-goldilocks

A pure-Rust implementation of Ed448 and Curve448 and Decaf

medallion

JWT library for rust using serde, serde_json and openssl

balanced-tree-index

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

sidh

An efficient supersingular isogeny-based cryptography library

pqcrypto-kyber

Post-Quantum Key-Encapsulation Mechanism kyber

kestrel-cli

Kestrel file encryption program

authenticator

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

selenite

A Crate For Post-Quantum Cryptography Certificates Built on PQcrypto

chacha20

The ChaCha20 stream cipher (RFC 8439) implemented in pure Rust using traits from the RustCrypto cipher crate, with optional architecture-specific hardware acceleration (AVX2, SSE2)…

cryptographic-message-syntax

A pure Rust implementation of Crypographic Message Syntax (RFC 5652)

rabe-bn

Pairing cryptography with the Barreto-Naehrig curve. Update to use latest rand and serde crates.

enocoro128v2

Safe, embedded-friendly Enocoro-128 (Version 2) stream cipher. Verified using Hitachi’s official test vectors.

groestlcoin

General groestlcoin library for using and interoperating with Groestlcoin

kzen-paillier

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

paillier-common

paillier over bigint traits provided by rust-bigint

bls_bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

ockam

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

cosmian_crypto_base

Crypto lib for hybrid encryption and pure crypto primitives

kuska-handshake

Secure Scuttlebutt handshake + boxstream library

substrate-bn

Pairing cryptography with the Barreto-Naehrig curve

ironoxide

A pure-Rust SDK for accessing IronCore’s privacy platform

blake2-rfc

A pure Rust implementation of BLAKE2 based on RFC 7693

napa

A simple and secure command line password manager

nkeys

Rust implementation of the NATS nkeys library

sequoia-octopus-librnp

Reimplementation of RNP’s interface using Sequoia for use with Thunderbird

hmac-sha256

A small, self-contained SHA256 and HMAC-SHA256 implementation

sha3sum

sha3sum - compute and check SHA3 message digest

spartan

High-speed zkSNARKs without trusted setup

jwt-compact

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

themis

High-level cryptographic services for storage and messaging

xts-mode

XTS block mode implementation in rust

secret-tree

Hierarchical secret derivation with Blake2b

tor-llcrypto

Low level cryptography wrappers used by Tor

lair_keystore

secret lair private keystore

ark-poly

A library for efficient polynomial arithmetic via FFTs over finite fields

mpvss-rs

A Simple Publicly Verifiable Secret Sharing Library

c2-chacha

The ChaCha family of stream ciphers

argon2rs

The pure Rust password hashing library that runs on Argon2

tari_bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

randomorg

A random.org client library. The randomness comes from atmospheric noise, which for many purposes is better than the pseudo-random number algorithms typically used in computer programs.

tor-checkable

Types to ensure that signed or time-bound data is validated before use

efficient-sm2

A Rust Library of China’s Standards of Signature Algorithms (SM2)

cocoon

A simple protected container with strong encryption and format validation

psa-crypto-sys

Wrapper around the PSA Cryptography API

s2n-tls-tokio

An implementation of TLS streams for Tokio built on top of s2n-tls

dgc

A parser and validator for the EU Digital Green Certificate (dgc) a.k.a. greenpass

p12

pure rust pkcs12 tool

simple-ssl-acme-cloudflare

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

winter-air

AIR components for the Winterfell STARK prover/verifier

safecloset

Secret Keeper

cdc

A library for performing Content-Defined Chunking (CDC) on data streams

snowstorm

A minimalistic encryption protocol based on Noise protocol (snow)

ibe

Identity Based Encryption schemes on the BLS12-381 pairing-friendly elliptic curve

zkinterface

An implementation of zkInterface

sshkeys

Rust library for parsing OpenSSH certificates and public keys

crypt4gh

Encryption and decryption implementation of the Crypt4GH encryption format

mbedtls-sys-auto

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

redjubjub

A standalone implementation of the RedJubjub signature scheme

krill

Resource Public Key Infrastructure (RPKI) daemon

signature

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

ark-groth16

An implementation of the Groth 2016 zkSNARK proof system

tink-mac

MAC functionality for Rust port of Google’s Tink cryptography library

fdh

Full Domain Hash (FDH) for extending the size of a hash digest to an arbitrary length

irmaseal-curve

Fork of the BLS12-381 pairing-friendly elliptic curve construction for IRMAseal

boring-sys

FFI bindings to BoringSSL

mc-oblivious-map

Implementation of Oblivious Hash Map data structures on top of Oblivious RAM

abrute

AESCrypt Brute force attempter

chbs

A crate providing secure passphrase generation based on a wordlist

ff-uint

Library for building and interfacing with fixed-sized integers and finite fields

macaroon

Fully functional implementation of macaroons in Rust

ciphercore-base

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

s2n-tls-sys

A C99 implementation of the TLS/SSL protocols

zk-paillier

Collection of Paillier cryptosystem zero knowledge proofs written in Rust

ockam_node

Ockam Node implementation crate

paspio

A password entropy calculator

bevy_assets_bundler

Assets Bundler for bevy, with content encryption support

win-crypto-ng

Safe bindings to Windows Cryptography API: Next Generation

xxxdh

Pure Rust X3DH key exchange protocol implementation

http-signature-normalization-reqwest

An HTTP Signatures library that leaves the signing to you

minisign

A crate to sign files and verify signatures

crypto-hash

A wrapper for OS-level cryptographic hash functions

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…

tapyrus

General purpose library for using and interoperating with Tapyrus

mundane

Cryptography which is easy to use and hard to misuse

arrow-digest

Stable hashes for Apache Arrow

oid

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

smcrypto

A Rust Implementation of China’s Standards of Encryption Algorithms(SM2/SM3/SM4)

ed25519-dalek-fiat

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

argonautica

Idiomatic Argon2 password hashing for Rust

redact-client

Receives request for private data and decrypts it to display securely in browser

curv-kzen

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

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

libaes

AES cipher in safe Rust with no dependencies

halo2_proofs

Fast PLONK-based zero-knowledge proving system with no trusted setup

blsttc

Pairing threshold cryptography

did-pkh

did:pkh DID method, using the ssi crate

portal-lib

A Secure file transfer library, written in Rust. The library utilizes SPAKE2 for key negotiation over an insecure channel, and ChaCha20Poly1305 Authenticated Encryption to encrypt…

ansivault

CLI tool ansible-vault 1.1 implementation

spiffe

Rust client library implementation for SPIFFE

ootp

OOTP (Open One-time Password) is a supports multiple programming languages. The generated one-time passwords are fully compliant with HOTP (HMAC-based One-time Password) and TOTP (Time-based One-time Password)…

minisign-verify

A small crate to verify Minisign signatures

parsec-service

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

botan

Rust wrapper for Botan cryptography library

aws-nitro-enclaves-cose

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

etebase

A Rust client library for Etebase

r1cs

A library for building R1CS gadgets

ruma-signatures

Digital signatures according to the Matrix specification

clear_on_drop

Helpers for clearing sensitive data on the stack and heap

tuf

Library for The Update Framework (TUF)

alkali

Safe Rust bindings to the Sodium cryptographic library

matrix-sdk-crypto

Matrix encryption library

bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

const-sha1

A sha1 implementation for use in const contexts

ed25519-bip32

Ed25519 BIP32

cryptostream

Transparent encryption and decryption for Read and Write streams

pkix

TLS Certificate encoding and decoding helpers

cracken

a fast password wordlist generator, Smartlist creation and password hybrid-mask analysis tool

rustgenhash

A tool to generate hashes from the command line

salty

Small, sweet, swift Ed25519 signatures for microcontrollers

pqcrypto-sphincsplus

Post-Quantum Signature Scheme sphincsplus

plonk-jubjub

Dusk’s fork of the implementation of the Jubjub elliptic curve group

gimli-permutation

Gimli: a cross-platform permutation

age-plugin

[BETA] API for writing age plugins

libcryptsetup-rs

High level Rust bindings for libcryptsetup

rust_keylock_shell

Shell access to the rust-keylock. rust-keylock is a password manager with goals to be Secure, Simple to use, Portable and Extensible.

libsm

A Rust Library of China’s Standards of Encryption Algorithms (SM2/3/4)

in-toto

Library for in-toto

xotp

An easy-to-use library for HOTP and TOTP authentication

chacha20stream

A writable wrapper stream for encryption and decryption with the stream cipher chacha20_poly1305

cose-rust

COSE Rust implementation

hpke-dispatch

runtime algorithmic selection for hybrid public key encryption

vodozemac

A Rust implementation of Olm and Megolm

libargon2-sys

Rust bindings for Argon2

rcrypt

A compact hashing/salting library based on bcrypt with smaller hashes

secp256k1-zkp

Rust bindings for the libsecp256k1-zkp library

paillier

A pure-Rust implementation of the Paillier encryption scheme

mcircuit

A library of tools for working with arithmetic circuits on generic fields

sct

Certificate transparency SCT verification library

fiat-crypto

Fiat-crypto generated Rust

fog-crypto

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

kuska-sodiumoxide

Fast cryptographic library for Rust (bindings to libsodium), with conversion from ed25519 to curve25519

async-acme

async ACME client for tls-alpn-01 challenge

sodiumoxide

Fast cryptographic library for Rust (bindings to libsodium)

mod_vig

cli for a modernized Vigenere algorithm

umbral-pre

Implementation of Umbral proxy reencryption algorithm

signify

Command-line implementation of the signify signature scheme

shamirsecretsharing

Shamir secret sharing library for Rust

checkpwn_lib

Library to interact with the HIBP API

askar-crypto

Hyperledger Aries Askar cryptography

pwhash

A collection of password hashing routines in pure Rust

dryoc

dryoc is a pure-Rust general-purpose cryptography library

pgen

Passphrase Generator

ark-nonnative-field

Constraints for nonnative field gadgets

blake2b-rs

Rust bindings for the official Blake2b C implementation

fuzzytags

a probabilistic cryptographic structure for metadata resistant tagging

devolutions-crypto

An abstraction layer for the cryptography used by Devolutions

pasetors

PASETO: Platform-Agnostic Security Tokens (in Rust)

legogroth16

An implementation of the LegoGroth16, the Legosnark variant of Groth16 zkSNARK proof system

merkle-tree-bulletin-board

A public bulletin board based upon Merkle trees

fsextra

fsextra is a collection of extensions to simplify working with Unix-based filesystems. With support for cryptographic operations (encryption, hashing)

uniqueid

Generates a unique hash/identifier for a system given a set of parameters

double-ratchet-2

Implementation of Double Ratchet as specified by Signal

aleph-bft-crypto

Utilities for node addressing and message signing in the aleph-bft package

pgp

OpenPGP implementation in Rust

better-blockmap

Generate better blockmap files for electron-builder

crypto_api_osrandom

An interface to the OS’ secure random number generator for crypto_api

hkd32

HMAC-based Hierarchical Key Derivation: deterministically derive a hierarchy of symmetric keys from initial keying material through repeated applications of the Hash-based Message Authentication Code…

sequoia-sqv

A simple OpenPGP signature verification program

tink-daead

Deterministic AEAD functionality for Rust port of Google’s Tink cryptography library

ntrust-native

Pure rust implementation of the PQC scheme Saber

tss-esapi-sys

FFI wrapper around TSS 2.0 Enhanced System API

tc_tea

Rusty implementation of Tencent’s varient of TEA (tc_tea)

reed-solomon

Reed-Solomon BCH encoder and decoder with support of no_std environment

skipjack

A straight-line implementation of Skipjack in Rust

crypto-pair

Parse exchange-specific symbols to unified format

lamport_ots

A Rust implementation of Leslie Lamport’s one-time signature scheme

risc0-zkvm-verify

RISC Zero zero-knowledge proof system core crate

rust-bigint

Common traits and methods for multiple BigInt implementations

concrete

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

kzg

a simple implementation of the KZG polynomial commitment scheme

miden

Miden virtual machine

bacon-cipher

An implementation of the Bacon’s cipher

threshold-secret-sharing

A pure-Rust implementation of various threshold secret sharing schemes

rustls-acme

TLS certificate management and serving using rustls

g2p

A crate to create types that implement fast finite field arithmetic

yaca

Bindings for the YACA library

kcapi-sys

Official low-level Rust bindings for libkcapi

rinkey

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

sha2raw

SHA-2 hash function

sha1

SHA-1 hash function

rust_utilities

Utilities for Rust

picnic-bindings

Bindings for the Picnic digital signature scheme

lair_keystore_api

secret lair private keystore API library

acme-client

Easy to use ACME client library to issue, renew and revoke TLS certificates

wycheproof

Wycheproof test vectors

winter-verifier

Winterfell STARK verifier

tor-hash-passwd

Tor control port password encryption and decryption

cross-krb5

Safe cross platform Kerberos v5 interface

chksum-cli

Easy way to make checksum of single file or whole directory

pem-iterator

Iterate over PEM-encoded data

litcrypt

Let’s encrypt your string statically during compile time

classic-mceliece-rust

Pure rust implementation of the PQC scheme Classic McEliece

eccoxide

elliptic curve cryptography (ECC) framework

arx-kw

An implementation of the ARX-KW-8-2-4 Key Wrap constructions

wcb

WebCrypto compatible encryption CLI

mmr-crypto-primitives

ark-crypto-primitives fork: mmr gadget implement

paq

paq files to hash

speck

Implementation of the SPECK block cipher

fides

Fides is a library for hashing with blake3, asymmetric cryptography on curve 25519, symmetric cryptography with chacha20poly1305 and merkle tree functions

dup-crypto

Manage cryptographic operations for DUniter Protocols and the Duniter eco-system most broadly

precrypt

Cli wrapper for the umbral-pre proxy re-encryption library with parallel processing

umbral-rs

A pure-Rust implementation of the Umbral threshold Proxy Re-encryption scheme

deno_crypto

Web Cryptography API implementation for Deno

p256

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

lamport_sigs

Implementation of the Lamport one-time signature scheme

blake3-proof-of-work

A basic proof of work scheme using the blake3 hash function

sharks

Fast, small and secure Shamir’s Secret Sharing library crate

ockam_transport_ble

Bluetooth Low Energy (BLE) Transport for the Ockam Routing Protocol

winter-fri

Implementation of FRI protocol for the Winterfell STARK prover/verifier

botan-sys

FFI wrapper for Botan cryptography library

sodalite

Tweetnacl in pure rust with no std dependency

EasyCrypto

A simple crypto crate aim at usability

async-hash

Traits and helper functions for SHA256 hashing of async data types

wascap

Wascap - WebAssembly Standard Capabilities. Library for extracting, embedding, and validating claims

risc0-zkvm-serde

RISC Zero zero-knowledge VM serde crate

vep

Variable-length Expansion Pass function. ( i.e. short password to long hashed password )

gimli-hash

The Gimli-permutation based Hash

mc-oblivious-ram

Implementations of Oblivious RAM data structures

rabe

ABE Schemes implemented in rust

votate-ed25519-dalek

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

signature_bbs_plus

The Ockam BBS+ signature impementation

rotcipher

ROT Cipher implementation in rust, rot1 to rot25

evpkdf

Rust implementation of OpenSSL EVP_bytesToKey function

unknown_order

A crate for working with finite fields where the modulus is of unknown order, typtical for RSA, Paillier, Hyperelliptic curves, etc

ark-bls12-381

The BLS12-381 pairing-friendly elliptic curve

libtls

Rust bindings for LibreSSL’s libtls

fraunhofer-aisec/rabe

ABE Schemes implemented in rust

crypto2

cryptographic algorithms

mozilla/neqo-crypto

ssb-crypto

Crypto primitives used by Secure Scuttlebutt

x25519-dalek-fiat

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

easy-hasher

Easy hashing library

hotboot

Secure private data with a weak secret, using as a protection access control of the system and defense especially designed against cold-boot attacks

pumpkin

A cryptographically secure prime number generator

libthemis-sys

FFI binding to libthemis

starkware-crypto-sys

Rust FFI bindings for StarkWare’s crypto-cpp library

wedpr_l_bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

vented

Event driven encrypted tcp communicaton

chksm

A multipurpose rust library for use in my projects

mrkl

Generic, minimalist, parallelizable Merkle tree

pbkdf2

Generic implementation of PBKDF2

rust-clacc

Rust implementanion of a CL universal accumulator

ucan

Implement UCAN-based authorization with conciseness and ease!

merklebtree

Merkle Btree implementation

class_group

Rust library for building IQC: cryptography based on class groups (Cl) of imaginary quadratic orders

keynesis

General purpose key management and associated cryptographic protocols

hmac-sha

Minimal wrapper of HMAC-SHA-{1,2,3} in Rust

ed25519

Edwards Digital Signature Algorithm (EdDSA) over Curve25519 (as specified in RFC 8032) support library providing signature type definitions and PKCS#8 private key decoding/encoding support

rust-cryptoauthlib

Rust wrappers for CryptoAuthentication Library bindings

djpass

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

cde

A universal encoding scheme for all cryptographic data

xoodyak

Xoodyak / Xoodoo - A versatile cryptographic scheme that can be used for hashing, encryption, MAC computation and authenticated encryption

aead-io

A wrapper around Write/Read interfaces with AEAD

ocsp

An OCSP encoding/decoding lib for Rust

cellar-core

A password tool for user to derive a large amount of application passwords deterministically based on a passphrase. Cryptographically strong.

evercrypt-sys

FFI binding to HACL/Evercrypt

dusk-hamt

HAMT datatructure for microkelvin

tinydtls-sys

Raw bindings to the TinyDTLS library

encryption-macros

This crate provides macros to xor strings decaritive or automaticly at compiletime and atomaticly decode the at run time

ecdsa

Pure Rust implementation of the Elliptic Curve Digital Signature Algorithm (ECDSA) as specified in FIPS 186-4 (Digital Signature Standard)

vdf

An implementation of Verifiable Delay Functions (VDFs) in Rust

hbs-lms

Pure Rust implementation of the Leighton Micali Signature scheme with support for key generation, signature generation and verification

xcbc-fdh

Full Domain Hash (FDH) for extending the size of a hash digest to an arbitrary length

lea

Lightweight Encryption Algorithm (LEA)

dumb-crypto

Dumb, but easily verifiable implementations of crypto algorithms

consistenttime

Constant time operations for crypto libraries

ratchet-x2

Pure Rust Double Ratchet protocol implementation

groestlcoin_hashes

Hash functions used by rust-groestlcoin which support rustc 1.29.0

saver

SAVER SNARK-friendly, Additively-homomorphic, and Verifiable Encryption and decryption with Rerandomization

randompass

🔑 A simple static password generator

aef

Util for file encryption

atms

An Ad-hoc Threshold MultiSignature primitive on Bls12-381

sss-rs

A secret sharing scheme implemented in Rust

oath

An implementation of OATH algorithms in Rust. Includes TOTP, HOTP, and OCRA.

nacl

Rust version of NaCl Cryptographic library with Scrypt added

eznacl

A wrapper around NaCl which makes working with cryptography even easier

nucypher-core

Nucypher network core datastructures

opentls

TLS connections with OpenSSL

authenticator-rs

The rust implementation for google authenticator with 2fa authentication

lsx

A pure, safe Rust implementation of the Twofish block cipher and the SHA-256 cryptographic hash function

pkcs11-uri

PKCS #11 URI parser

sequoia-wot

An implementation of OpenPGP’s web of trust

sgx_pkix

TLS Certificate encoding and decoding helpers for the SGX environment

said

Self-Addressing identifier library

xxblake3

encryption and decryption based on xxh3 and blake3

lhash

Minimal hashing library

extended-tea

XTEA (eXtended TEA), a block cipher designed to correct weaknesses in TEA

sidefuzz

Fuzzer to automatically find side-channel (timing) vulnerabilities

iso8583_rs

A library to define/parse/assemble and send/receive (via TCP) an ISO8583 message

common-crypto

Bindings to Apple’s Common Crypto library

noise-rust-crypto

Wrappers of dalek and RustCrypto crates for noise-protocol

monocypher

Bindings for the monocypher C library

eva-crypto

Prototype level implementations of some encryption algorithms, with some generic traits

htpasswd-verify

Verify hashes stored in apache’s htpasswd file

fastmurmur3

Fast murmur3 hash, with the benchmarks to prove it

digest-hash

Cryptography-grade data structure hashing

btcturk

Unofficial BtcTurk exchange API bindings

boo-hoo

An implementation of ZKBoo

libtls-sys

FFI bindings for LibreSSL’s libtls

curve25519-dalek-ng

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

keccak-rust

Keccak implementation in Rust

x509-signature

Low-level X.509 parsing and signature verification library

serde-encrypt-core

Encrypts all the Serialize

scorex_crypto_avltree

Implementation of cryptographically authenticated dictionary based on AVL tree

redact-crypto

Crypto abstractions for the Redact framework

rsign2

A command-line tool to sign files and verify signatures

binary-ff1

Optimized Rust implementation of FF1 encryption with radix 2

aez

Rust wrapper for AEZ wide block cipher written in C

bundy

Bundy data signing and verification library

http-signature-normalization

An HTTP Signatures library that leaves the signing to you

Cupcake

An implementation of a lattice-based additive homomorphic encryption scheme

rusty-saber

Pure rust implementation of the PQC scheme Saber