Lib.rs

curve25519-dalek

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

blake3

the BLAKE3 hash function

rustls

Rustls is a modern TLS library written in Rust

digest

Traits for cryptographic hash functions

aes

Pure Rust implementation of the Advanced Encryption Standard (a.k.a. Rijndael) including support for AES in counter mode (a.k.a. AES-CTR)

x25519-dalek

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

sha2

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

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

pem

Parse and encode PEM-encoded data

rsa

Pure Rust RSA implementation

tiny-keccak

An implementation of Keccak derived functions

siphasher

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

recrypt

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

sha-1

SHA-1 hash function

bcrypt

Easily hash and verify passwords using bcrypt

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

bls12_381

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

subtle

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

openssl-sys

FFI bindings to OpenSSL

cryptoxide

pure implementation of various common modern cryptographic algorithms, WASM compatible

secp256k1

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

orion

Usable, easy and safe pure-Rust crypto

blstrs

High performance implementation of BLS12 381

djangohashers

A Rust port of the password primitives used in Django project

kbs2

A secret manager backed by age

sodiumoxide

Fast cryptographic library for Rust (bindings to libsodium)

sequoia-openpgp

OpenPGP data types and associated machinery

snow

A pure-rust implementation of the Noise Protocol Framework

rust-argon2

Rust implementation of the Argon2 password hashing function

webpki

Web PKI X.509 Certificate Verification

hpke

An implementation of the HPKE hybrid encryption standard in pure Rust

sha1collisiondetection

SHA-1 hash function with collision detection and mitigation

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…

ed25519-dalek

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

bao

an implementation of BLAKE3 verified streaming

http-signature-normalization-actix

An HTTP Signatures library that leaves the signing to you

bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

rage

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

security-framework

Security.framework bindings for macOS and iOS

cocoon

A simple protected container with strong encryption and format validation

dusk-jubjub

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

tari_bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

gpgme

GPGme bindings for Rust

ring

Safe, fast, small crypto using Rust

ed25519-dalek-blake3

fork ed25519-dalek , replace sha512 to blake3

curve25519-dalek-ng

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

sigma_fun

A framework for making Sigma protocols fun!

pact_verifier_cli

Standalone pact verifier for provider pact verification

ark-r1cs-std

A standard library for constraint system gadgets

tss-esapi

Rust-native wrapper around TSS 2.0 Enhanced System API

block-modes

Block cipher modes of operation

gridiron

Rust finite field library with fixed size multi-word values

crypto_api_chachapoly

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

minisign

A crate to sign files and verify signatures

vsss-rs

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

c2-chacha

The ChaCha family of stream ciphers

boring

BoringSSL bindings

ed25519-compact

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

ark-std

A library for no_std compatibility

paillier-common

paillier over bigint traits provided by rust-bigint

pqcrypto

Post-Quantum cryptographic primitives

google-authenticator

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

sheesy-cli

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

authenticator

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

pgp

OpenPGP implementation in Rust

hc_seed_bundle

SeedBundle parsing and generation library

roughenough

A Roughtime secure time sync server and client written in Rust

tindercrypt

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

nettle

Rust bindings for the Nettle cryptographic library

substrate-bn

Pairing cryptography with the Barreto-Naehrig curve

secp256k1-zkp

Rust bindings for the libsecp256k1-zkp library

ursa

This is the shared crypto library for Hyperledger components

dgc

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

ockam_core

Core types of the Ockam library

blake2

BLAKE2 hash functions

ark-serialize

A library for serializing types in the arkworks ecosystem

kuska-handshake

Secure Scuttlebutt handshake + boxstream library

enc_file

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

ppv-lite86

Implementation of the crypto-simd API for x86

blsttc

Pairing threshold cryptography

redact-client

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

sha256

sha256 crypto digest

sidh

An efficient supersingular isogeny-based cryptography library

picky

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

ockam_vault

A software-only Ockam Vault implementation

rustgenhash

A tool to generate hashes from the command line

pqcrypto-sphincsplus

Post-Quantum Signature Scheme sphincsplus

ensync

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

concrete

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

lair_keystore_api

secret lair private keystore API library

blake2-rfc

A pure Rust implementation of BLAKE2 based on RFC 7693

argon2rs

The pure Rust password hashing library that runs on Argon2

ed448-goldilocks

A pure-Rust implementation of Ed448 and Curve448 and Decaf

selenite

A Crate For Post-Quantum Cryptography Certificates Built on PQcrypto

enocoro128v2

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

medallion

JWT library for rust using serde, serde_json and openssl

fdh

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

jwt-compact

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

matrix-sdk-crypto

Matrix encryption library

serde-encrypt

Encrypts all the Serialize

concrete-core

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

age

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

kzen-paillier

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

zeropool-bn

Pairing cryptography with the Barreto-Naehrig curve

merkletree

Light merkle tree implementation with SPV support and dependency agnostic

sha3sum

sha3sum - compute and check SHA3 message digest

tapyrus

General purpose library for using and interoperating with Tapyrus

efficient-sm2

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

winter-crypto

Cryptographic library for the Winterfell STARK prover/verifier

winter-math

Math library for the Winterfell STARK prover/verifier

spartan

High-speed zkSNARKs without trusted setup

ansivault

CLI tool ansible-vault 1.1 implementation

threema-gateway

A client library for the Threema Gateway

shadowsocks-crypto

Shadowsocks Crypto

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

tor-llcrypto

Low level cryptography wrappers used by Tor

secrets

Protected-access memory for cryptographic secrets

tink-awskms

AWS-KMS integration for Rust port of Google’s Tink cryptography library

rinkey

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

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.

sct

Certificate transparency SCT verification library

pbkdf2

Generic implementation of PBKDF2

libsm

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

aws-nitro-enclaves-cose

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

macaroon

Fully functional implementation of macaroons in Rust

tuf

Library for The Update Framework (TUF)

constant_time_eq

Compares two equal-sized byte strings in constant time

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

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.

double-ratchet-2

Implementation of Double Ratchet as specified by Signal

cose-rust

COSE Rust implementation

http-signature-normalization-reqwest

An HTTP Signatures library that leaves the signing to you

votate-ed25519-dalek

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

x509-certificate

X.509 certificate parser and utility functionality

strobe-rs

An implementation of the Strobe protocol framework in pure Rust

rust-cryptoauthlib

Rust wrappers for CryptoAuthentication Library bindings

short-crypt

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

in-toto

Library for in-toto

p12

pure rust pkcs12 tool

ironoxide

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

winter-prover

Winterfell STARK prover

fuzzytags

a probabilistic cryptographic structure for metadata resistant tagging

plonk-jubjub

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

crypto-hash

A wrapper for OS-level cryptographic hash functions

pqcrypto-sphincsplus-wasi

Post-Quantum Signature Scheme sphincsplus with WASM/WASI support

ruma-signatures

Digital signatures according to the Matrix specification

oid

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

shamirsecretsharing

Shamir secret sharing library for Rust

merlin

Composable proof transcripts for public-coin arguments of knowledge

secret-tree

Hierarchical secret derivation with Blake2b

psa-crypto

Wrapper around the PSA Cryptography API

botan

Rust wrapper for Botan cryptography library

ff-uint

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

dusk-blindbid

BlindBid protocol implementation with PLONK ZKProofs backend

sequoia-octopus-librnp

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

mundane

Cryptography which is easy to use and hard to misuse

ark-ec

A library for elliptic curves and pairings

json-digest

Allow selective masking of JSON subdocuments for privacy, preserving the digest of the whole document

mbedtls-sys-auto

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

tari_crypto

Tari Cryptography library

merkle-tree-bulletin-board

A public bulletin board based upon Merkle trees

chacha20poly1305

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

crypt4gh

Encryption and decryption implementation of the Crypt4GH encryption format

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

ed25519-dalek-fiat

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

libsodium-sys

FFI binding to libsodium

webb-bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

hbs-lms

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

fsextra

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

signature

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

cryptographic-message-syntax

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

eccoxide

elliptic curve cryptography (ECC) framework

dup-crypto

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

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)…

rustls-pemfile

Basic .pem file parser for keys and certificates

evpkdf

Rust implementation of OpenSSL EVP_bytesToKey function

blake2b-rs

Rust bindings for the official Blake2b C implementation

salty

Small, sweet, swift Ed25519 signatures for microcontrollers

safecloset

Secret Keeper

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

const-sha1

A sha1 implementation for use in const contexts

rust-bigint

Common traits and methods for multiple BigInt implementations

spiffe

Rust client library implementation for SPIFFE

opentls

TLS connections with OpenSSL

cashweb-secp256k1

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

tmkms

Tendermint Key Management System: provides isolated, optionally HSM-backed signing key management for Tendermint applications including validators, oracles, IBC relayers, and other transaction signing applications

ockam_vault_core

The Ockam Vault trait

kuska-sodiumoxide

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

r1cs

A library for building R1CS gadgets

cryptostream

Transparent encryption and decryption for Read and Write streams

xts-mode

XTS block mode implementation in rust

unknown_order

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

hmac-sha

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

psa-crypto-sys

Wrapper around the PSA Cryptography API

schnorrkel

Schnorr VRF, signatures, etc. using the Ristretto group

chacha20stream

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

ark-relations

A library for rank-one constraint systems

hc_utils

Helper functions for holochain hdk development

pwhash

A collection of password hashing routines in pure Rust

wascap

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

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…

ockam

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

dryoc

dryoc is a pure-Rust general-purpose cryptography library

lea

Lightweight Encryption Algorithm (LEA)

did-pkh

did:pkh DID method, using the ssi crate

wedpr_l_libsm

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

libargon2-sys

Rust bindings for Argon2

gluac-rs

Rust Crate for compiling Garry’s Mod Lua into bytecode

winternitz-ots

A Rust Library For Interacting With Winternitz One-Time Signatures, a Hash-Based, Post-Quantum Digital Signature Scheme Based On Lamport Signatures. This implementation uses the hash function Blake2b for all hashing…

reddsa

A standalone implementation of the RedDSA signature scheme

kzg

a simple implementation of the KZG polynomial commitment scheme

scorex_crypto_avltree

Implementation of cryptographically authenticated dictionary based on AVL tree

pgen

Passphrase Generator

libaes

AES cipher in safe Rust with no dependencies

crypto2

cryptographic algorithms

xpring

Rust client-side library for the XRP Ledger

sgx_pkix

TLS Certificate encoding and decoding helpers for the SGX environment

crypto_api_osrandom

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

x25519-dalek-ng

fork x25519-dalek , update rand_core

reed-solomon

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

wycheproof

Wycheproof test vectors

fiat-crypto

Fiat-crypto generated Rust

shasum

Print SHA checksums from STDIN, input file or directory

ocsp

An OCSP encoding/decoding lib for Rust

pqcrypto-kyber

Post-Quantum Key-Encapsulation Mechanism kyber

rabe-bn

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

akkorokamui

Kraken REST APIs HTTP client

yaca

Bindings for the YACA library

libtls

Rust bindings for LibreSSL’s libtls

curv-kzen

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

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)…

sshkeys

Rust library for parsing OpenSSH certificates and public keys

fpe

Format-preserving encryption

fog-crypto

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

devolutions-crypto

An abstraction layer for the cryptography used by Devolutions

pasetors

PASETO: Platform-Agnostic Security Tokens (in Rust)

gimli-permutation

Gimli: a cross-platform permutation

sha2-const

const fn implementation of the SHA-2 family of hash functions

deno_crypto

Web Cryptography API implementation for Deno

sha2raw

SHA-2 hash function

sss-rs

A secret sharing scheme implemented in Rust

minisign-verify

A small crate to verify Minisign signatures

helvetia

A library and API server that allows anonymous storage of secrets, with a simple rule; any user can create a secret using a token, and they can only access it using the same token

lhash

Minimal hashing library

rsa-der

Crate to encode and decode public RSA keys using DER

hmac-sha256

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

threshold-secret-sharing

A pure-Rust implementation of various threshold secret sharing schemes

botan-sys

FFI wrapper for Botan cryptography library

g2p

A crate to create types that implement fast finite field arithmetic

zkinterface

An implementation of zkInterface

ecdsa

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

ed25519-bip32

Ed25519 BIP32

chksum

Easy way to make checksum of single file or whole directory

said

Self-Addressing identifier library

arx-kw

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

kcapi-sys

Official low-level Rust bindings for libkcapi

hmac

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

pem-iterator

Iterate over PEM-encoded data

libthemis-src

Building native Themis library

vented

Event driven encrypted tcp communicaton

boring-sys

FFI bindings to BoringSSL

xcbc-rsa-fdh

RSA-FDH is a is provably secure blind-signing signature scheme that uses RSA and a full domain hash and support blind signing / blind signatures

bevy_assets_bundler

Assets Bundler for bevy, with content encryption support

irmaseal-curve

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

easy-hasher

Easy hashing library

winter-air

AIR components for the Winterfell STARK prover/verifier

class_group

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

xcbc-fdh

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

aligned-cmov

Fast constant-time conditional moves of aligned bytes

redact-crypto

Crypto abstractions for the Redact framework

barebones-x509

Low-level X.509 parsing and signature verification library

lamport_sigs

Implementation of the Lamport one-time signature scheme

keccak-rust

Keccak implementation in Rust

digestify

Verify a file against a digest/hash/checksum

sharks

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

pumpkin

A cryptographically secure prime number generator

b2sum-rs

A Rust Library For Computing The Blake2b Hash of Files with any given Digest Size

threshold_crypto

Pairing threshold cryptography

tink-gcpkms

AWS-KMS integration for Rust port of Google’s Tink cryptography library

openpgp-ca

OpenPGP CA is a tool for managing and certifying OpenPGP keys

age-plugin

[BETA] API for writing age plugins

miden-air

Algebraic intermediate representation of Miden VM processor

parity-subtle

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

umbral-pre

Implementation of Umbral proxy reencryption algorithm

monocypher

Bindings for the monocypher C library

rotcipher

ROT Cipher implementation in rust, rot1 to rot25

ssb-crypto

Crypto primitives used by Secure Scuttlebutt

mozilla/neqo-crypto

merkle_light

Light merkle tree implementation with SPV support and dependency agnostic

redjubjub

A standalone implementation of the RedJubjub signature scheme

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

askar-crypto

Hyperledger Aries Askar cryptography

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

iso8583_rs

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

rustls-acme

TLS certificate management and serving using rustls

mrkl

Generic, minimalist, parallelizable Merkle tree

hard

Security hardened buffers for Rust based on libsodium

thieves-cant

A Rust implementation of the Solitaire Cipher designed by Bruce Schneier

merklebtree

Merkle Btree implementation

bundy

Bundy data signing and verification library

grammers-crypto

Several cryptographic utilities to work with Telegram’s data

x25519-dalek-fiat

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

plonk-bls12_381

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

argonautica

Idiomatic Argon2 password hashing for Rust

oath

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

gmsm

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

libthemis-sys

FFI binding to libthemis

evercrypt-sys

FFI binding to HACL/Evercrypt

rust-clacc

Rust implementanion of a CL universal accumulator

consistenttime

Constant time operations for crypto libraries

litcrypt

Let’s encrypt your string statically during compile time

cdc

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

tweetnacl-sys

tweetnacl & FFI bindings to it

chbs

A crate providing secure passphrase generation based on a wordlist

x3dh-ke

Implementation of X3DH

balanced-tree-index

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

dumb-crypto

Dumb, but easily verifiable implementations of crypto algorithms

kestrel-crypto

Cryptography backend for Kestrel

classic_crypto

Encrypt, decrypt and solve classical ciphers with any charset

napa

A simple and secure command line password manager

cfs_openpgp

cfs_openpgp generates a valid OpenPGP certificate based on the username, email, and secret you provide. Though the ASCII-armored representation of the cert will differ, the same input should…

common-crypto

Bindings to Apple’s Common Crypto library

sequoia-sq

Command-line frontends for Sequoia

lsx

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

speck

Implementation of the SPECK block cipher

dusk-hamt

HAMT datatructure for microkelvin

ark-poly

A library for efficient polynomial arithmetic via FFTs over finite fields

lair_keystore_client

client connector to secret lair private keystore

smtree

SMTree is a flexible sparse tree accumulator that can support various tree types via traits for custom node-merging (i.e., Merkle tree hashes) and tree-padding logic. The api supports…

clear_on_drop

Helpers for clearing sensitive data on the stack and heap

tink-daead

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

encrypted_id

Encryption and Decryption

parsec-service

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

rsign2

A command-line tool to sign files and verify signatures

gpp_decrypt

Decrypts the cpassword from Group Policy Preference files (Groups.xml)

cifra

Console command to crypt and decrypt texts using classic methods

binary-ff1

Optimized Rust implementation of FF1 encryption with radix 2

digest-hash

Cryptography-grade data structure hashing

bc4py_hash

bc4py crypto hash functions library

secret_sealing

A simple toolkit that provides wrappers and re-exports for modern cryptographic algorithms

elliptic-curve-flow

General purpose Elliptic Curve Cryptography (ECC) Modified for use with the flow-rust-sdk package

privatebox

A small and easy to use API to encrypt your data

rust-elgamal

A straightforward implementation of ElGamal homomorphic encryption using the ristretto255 elliptic curve group

eva-crypto

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

signature_bbs_plus

The Ockam BBS+ signature impementation

merkle-log

An implementation of the “Merkle Tree-Structured Log” defined in the paper “Transparent Logs for Skeptical Clients.” https://research.swtch.com/tlog

shielded

Shielded Memory. Memory protection from speculation and side-channel attacks like Spectre, Meltdown, Rowhammer and Rambleed.

pqcrypto-classicmceliece-wasi

Post-Quantum Key-Encapsulation Mechanism classicmceliece with WASM/WASI support

ironcore-search-helpers

Search helpers for working with encrypted values, particularly on the IronCore platform

witnet-bn

Pairing cryptography with the Barreto-Naehrig curve

crypto_api_blake2

Implements Blake2b for crypto_api

libpaillier

The Paillier cryptosystem is a public key crytosystem based on composite degree residuosity classes. Paillier ciphertexts are homorphic in that the can be added

paillier

A pure-Rust implementation of the Paillier encryption scheme

rsa-fdh

RSA-FDH is a is provably secure blind-signing signature scheme that uses RSA and a full domain hash and support blind signing / blind signatures

aez

Rust wrapper for AEZ wide block cipher written in C

cracken

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

ssclient

SecureStore client for managing user secrets

Cupcake

An implementation of a lattice-based additive homomorphic encryption scheme

nettle-sys

Low-level Rust bindings for the Nettle cryptographic library

yggdrasil-keys

Quickly generate yggdrasil keys

vdf

An implementation of Verifiable Delay Functions (VDFs) in Rust

xxblake3

encryption and decryption based on xxh3 and blake3

cryptohelpers

Collection of helpers and simplifying functions for cryptography things

picnic-bindings

Bindings for the Picnic digital signature scheme

nacl

Rust version of NaCl Cryptographic library with Scrypt added

timing-shield

Comprehensive timing leak protection for Rust

arcturus

Implementation of Arcturus zero-knowledge proofs for confidential transactions

sequoia-sqv

A simple OpenPGP signature verification program

hpke-rs-crypto

Traits and types for HPKE crypto backends

crypter

A AES-GCM 256 encryption and decryption library

bacon-cipher

An implementation of the Bacon’s cipher

http-signature-normalization

An HTTP Signatures library that leaves the signing to you

dock_crypto_utils

Common code for Dock’s crypto libraries

botan-src

Sources of Botan cryptography library

winter-fri

Implementation of FRI protocol for the Winterfell STARK prover/verifier

miden-verifier

Miden VM execution verifier

a0kzg

ZKG polinomial commitments playground

ct-codecs

Constant-time hex and base64 codecs from libsodium reimplemented in Rust

kerberos_crypto

Cryptography algorithms for Kerberos

b2sum-rust

A Rust Library For Computing The Blake2b Hash of Files with any given Digest Size

lair_keystore

secret lair private keystore

acme-client

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

luno-rs

A lightweight Rust wrapper for Luno API

blakeout

Memory hard hashing algorithm based on Blake2s

concrete-commons

Common tools for the concrete FHE library

bitcheck

A simple script to perform md5 and sha1 hash check on ArchLabs Images

libkrypton

toy crypto lib

x509-signature

Low-level X.509 parsing and signature verification library

bulk-gcd

Fast parallel bulk GCD computation for finding weak RSA keys in a set

encrypt-rs

Envelope encryption with secret-keepers

blake-hash

BLAKE hash functions

h_encrypt

A simple encrpytion/decryption library

estel_secp256k1

ECDSA signature and verification implementation

groestlcoin

General groestlcoin library for using and interoperating with Groestlcoin

noise-protocol

Noise Protocol Framework implementation

fraunhofer-aisec/rabe

ABE Schemes implemented in rust

rust_srp

rust secure remote password authentication flow

wireguard-vanity-address

Find Wireguard VPN keypairs with a specific readable string

abrute

AESCrypt Brute force attempter

secretbox

Rust implementation of the secretbox encryption algorithm

ossuary

Library for establishing secure communication channels between two hosts

eme-mode

EME block cipher mode of operation

keccakf

An implementation of the keccak-F[1600,800,400,200]

cellar-core

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

nettfiske

Detect Phishing fetching Certificate Transparency Logs

runkr

A Rust Bunkr client

ark-nonnative-field

Constraints for nonnative field gadgets

etebase

A Rust client library for Etebase

k-anon-hash

A simple wrapper around the sha2 crate for K-Anonymous SHA256

keynesis

General purpose key management and associated cryptographic protocols

sphinxcrypto

Sphinx cryptographic packet format library

x448

A pure-Rust implementation of X448

gpgme-sys

Raw bindings for gpgme

ark-algebra-intro

Introduction to arkworks algebra APIs

verenc

An implementation of Camenisch Shoup verifiable encryption and decryption of discrete logs

assemblylift-iomod-crypto-guest

AssemblyLift Crypto IOmod (guest)

gimli-hash

The Gimli-permutation based Hash

zerocaf

A pure-Rust implementation of elliptic curve operations over the Doppio-curve

xoodoo

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

vep

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

double-ratchet

Double Ratchet key management for exchanging encrypted messages between two parties

trezor-crypto

Rust bindings for the trezor crypto libraries

eaglesong

A Rust Library of Eaglesong Hash Function

c-certitude

C-ABI for certificate validation logic for OS X and Windows

rust_sodium-sys

Raw bindings to libsodium

bn

Pairing cryptography with the Barreto-Naehrig curve

ecdsa-flow

Signature and elliptic curve types providing interoperable support for the Elliptic Curve Digital Signature Algorithm (ECDSA)

xoodyak

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

acmev02

ACME client library to issue, renew and revoke TLS certificates