Lib.rs

curve25519-dalek

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

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)

rustls

Rustls is a modern TLS library written in Rust

sodiumoxide

Fast cryptographic library for Rust (bindings to libsodium)

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…

pem

Parse and encode PEM-encoded data

tiny-keccak

An implementation of Keccak derived functions

ed25519-dalek

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

openssl

OpenSSL bindings

webpki

Web PKI X.509 Certificate Verification

bcrypt

Easily hash and verify passwords using bcrypt

bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

sha2

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

ecdsa

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

snow

A pure-rust implementation of the Noise Protocol Framework

sequoia-openpgp

OpenPGP data types and associated machinery

siphasher

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

secp256k1

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

secret-service

Library to interface with Secret Service API

x25519-dalek

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

ring

Safe, fast, small crypto using Rust

bls12_381

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

djangohashers

A Rust port of the password primitives used in Django project

rust-argon2

Rust implementation of the Argon2 password hashing function

openssl-sys

FFI bindings to OpenSSL

blake3

the BLAKE3 hash function

cryptoxide

pure implementation of various common modern cryptographic algorithms, WASM compatible

security-framework

Security.framework bindings for macOS and iOS

minisign

A crate to sign files and verify signatures

ursa

This is the shared crypto library for Hyperledger components

tink-daead

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

ed25519-dalek-fiat

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

recrypt

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

zkinterface

An implementation of zkInterface

dusk-jubjub

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

blake2-rfc

A pure Rust implementation of BLAKE2 based on RFC 7693

ark-std

A library for no_std compatibility

pqcrypto

Post-Quantum cryptographic primitives

ark-serialize

A library for serializing types in the arkworks ecosystem

merkletree

Light merkle tree implementation with SPV support and dependency agnostic

c2-chacha

The ChaCha family of stream ciphers

elliptic-curve

General purpose Elliptic Curve Cryptography (ECC) support, including types and traits for representing various elliptic curve forms, scalars, points, and public/secret keys composed thereof

threshold_crypto

Pairing threshold cryptography

constant_time_eq

Compares two equal-sized byte strings in constant time

picky

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

sheesy-cli

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

schnorrkel

Schnorr VRF, signatures, etc. using the Ristretto group

tss-esapi

Rust-native wrapper around TSS 2.0 Enhanced System API

pgp

OpenPGP implementation in Rust

keyring

Cross-platform library for managing passwords

orion

Usable, easy and safe pure-Rust crypto

kbs2

A secret manager backed by age

roughenough

A Roughtime secure time sync server and client written in Rust

merlin

Composable proof transcripts for public-coin arguments of knowledge

tindercrypt

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

gridiron

Rust finite field library with fixed size multi-word values

oid

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

sha1collisiondetection

SHA-1 hash function with collision detection and mitigation

sha-1

SHA-1 hash function

pwhash

A collection of password hashing routines in pure Rust

short-crypt

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

http-signature-normalization-actix

An HTTP Signatures library that leaves the signing to you

chbs

A crate providing secure passphrase generation based on a wordlist

strobe-rs

An implementation of the Strobe protocol framework in pure Rust

substrate-bn

Pairing cryptography with the Barreto-Naehrig curve

google-authenticator

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

authenticator

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

sct

Certificate transparency SCT verification library

polyval

POLYVAL is a GHASH-like universal hash over GF(2^128) useful for constructing a Message Authentication Code (MAC)

gpgme

GPGme bindings for Rust

ppv-lite86

Implementation of the crypto-simd API for x86

medallion

JWT library for rust using serde, serde_json and openssl

tari_crypto

Tari Cryptography library

secrets

Protected-access memory for cryptographic secrets

enc_file

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

ark-relations

A library for rank-one constraint systems

webb-bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

sharks

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

crypto_api_chachapoly

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

bcrypt-pbkdf

bcrypt-pbkdf password-based key derivation function

yubihsm

Pure Rust client for YubiHSM2 devices with support for HTTP and USB-based access to the device. Supports most HSM functionality including ECDSA, Ed25519, HMAC, and RSA.

blstrs

High performance implementation of BLS12 381

threema-gateway

A client library for the Threema Gateway

boring

BoringSSL bindings

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

pbkdf2

Generic implementation of PBKDF2

block-buffer

Fixed size buffer for block processing of data

aes-gcm-siv

Pure Rust implementation of the AES-GCM-SIV Misuse-Resistant Authenticated Encryption Cipher (RFC 8452) with optional architecture-specific hardware acceleration

subtle

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

ed25519-dalek-blake3

fork ed25519-dalek , replace sha512 to blake3

ensync

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

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

tink-gcpkms

AWS-KMS integration 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

zeropool-bn

Pairing cryptography with the Barreto-Naehrig curve

sigma_fun

A framework for making Sigma protocols fun!

crypto-hash

A wrapper for OS-level cryptographic hash functions

fuzzytags

a probabilistic cryptographic structure for metadata resistant tagging

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…

rustgenhash

A tool to generate hashes from the command line

cashweb-secp256k1

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

concrete

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

branca

Authenticated encrypted API tokens for Rust. A secure alternative to JWT.

hdk

The Holochain HDK

curve25519-dalek-ng

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

ockam_core

Core types of the Ockam library

ruma-signatures

Digital signatures according to the Matrix specification

libsodium-sys

FFI binding to libsodium

serde-encrypt

Encrypts all the Serialize

secp256k1-zkp

Rust bindings for the libsecp256k1-zkp library

secret-tree

Hierarchical secret derivation with Blake2b

ed448-goldilocks

A pure-Rust implementation of Ed448 and Curve448 and Decaf

wascap

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

shamirsecretsharing

Shamir secret sharing library for Rust

sha3sum

sha3sum - compute and check SHA3 message digest

psa-crypto

Wrapper around the PSA Cryptography API

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.

argon2rs

The pure Rust password hashing library that runs on Argon2

shadowsocks-crypto

Shadowsocks Crypto

tapyrus

General purpose library for using and interoperating with Tapyrus

cocoon

A simple protected container with strong encryption and format validation

xoodyak

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

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

arx-kw

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

chacha20poly1305

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

x25519-dalek-fiat

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

spartan

High-speed zkSNARKs without trusted setup

cellar-core

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

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.

sha256

sha256 crypto digest

dup-crypto

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

aligned-cmov

Fast constant-time conditional moves of aligned bytes

dusk-blindbid

BlindBid protocol implementation with PLONK ZKProofs backend

enocoro128v2

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

hypercore

Secure, distributed, append-only log

grammers-crypto

Several cryptographic utilities to work with Telegram’s data

sgx_pkix

TLS Certificate encoding and decoding helpers for the SGX environment

botan

Rust wrapper for Botan cryptography library

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…

ansivault

ansible-vault 1.1 rust implementation

shasum

Print SHA checksums from STDIN, input file or directory

hpke

An implementation of the HPKE hybrid encryption standard in pure Rust

ecies

Elliptic Curve Integrated Encryption Scheme for secp256k1 in Rust

pgen

Passphrase Generator

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

cryptostream

Transparent encryption and decryption for Read and Write streams

lair_keystore_client

client connector to secret lair private keystore

double-ratchet-2

Implementation of Double Ratchet as specified by Signal

r1cs

A library for building R1CS gadgets

clear_on_drop

Helpers for clearing sensitive data on the stack and heap

libtls

Rust bindings for LibreSSL’s libtls

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

bee-crypto

Cryptographic primitives of the IOTA protocol

substrate-bip39

Converting BIP39 entropy to valid Substrate (sr25519) SecretKeys

holo_hash

hashing helpers supporting dht sharding

forest_crypto

Filecoin crypto utilities for use in Forest

kuska-sodiumoxide

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

nash-protocol

state management and cryptography for interacting with nash exchange protocol

parsec-service

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

xpring

Rust client-side library for the XRP Ledger

libargon2-sys

Rust bindings for Argon2

age

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

nettle

Rust bindings for the Nettle cryptographic library

argonautica

Idiomatic Argon2 password hashing for Rust

crypt4gh

Encryption and decryption implementation of the Crypt4GH encryption format

rooster

A simple password manager for geeks

x509-certificate

X.509 certificate parser and utility functionality

jwt-compact

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

blake2

BLAKE2 hash functions

selenite

A Crate For Post-Quantum Cryptography Certificates Built on PQcrypto

digestify

Verify a file against a digest/hash/checksum

efficient-sm2

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

redjubjub

A standalone implementation of the RedJubjub signature scheme

oath

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

hips

Manage secrets alongside your code

tink-proto

Protocol buffer message definitions for Rust port of Google’s Tink cryptography library

openpgp-ca

OpenPGP CA is a tool for managing and certifying OpenPGP keys

const-sha1

A sha1 implementation for use in const contexts

crypto2

cryptographic algorithms

sshkeys

Rust library for parsing OpenSSH certificates and public keys

evercrypt-sys

FFI binding to HACL/Evercrypt

opentls

TLS connections with OpenSSL

ark-nonnative-field

Constraints for nonnative field gadgets

opaque-ke

An implementation of the OPAQUE password-authenticated key exchange protocol

b2sum-rust

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

blake2b-rs

Rust bindings for the official Blake2b C implementation

aws-nitro-enclaves-cose

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

cryptographic-message-syntax

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

classic_crypto

Encrypt, decrypt and solve classical ciphers with any charset

aes-gcm

Pure Rust implementation of the AES-GCM (Galois/Counter Mode) Authenticated Encryption with Associated Data (AEAD) Cipher with optional architecture-specific hardware acceleration

hmac

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

pqcrypto-sphincsplus

Post-Quantum Signature Scheme sphincsplus

timing-shield

Comprehensive timing leak protection for Rust

common-crypto

Bindings to Apple’s Common Crypto library

kzen-paillier

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

rabe-bn

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

fiat-crypto

Fiat-crypto generated Rust

sequoia-sq

Command-line frontends for Sequoia

ark-ff

A library for finite fields

ssb-crypto

Crypto primitives used by Secure Scuttlebutt

lea

Lightweight Encryption Algorithm (LEA)

threshold-secret-sharing

A pure-Rust implementation of various threshold secret sharing schemes

botan-sys

FFI wrapper for Botan cryptography library

libthemis-sys

FFI binding to libthemis

sha2raw

SHA-2 hash function

easy-hasher

Easy hashing library

gimli-permutation

Gimli: a cross-platform permutation

shielded

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

encrypted_id

Encryption and Decryption

paillier-common

paillier over bigint traits provided by rust-bigint

mundane

Cryptography which is easy to use and hard to misuse

xsalsa20poly1305

Pure Rust implementation of the XSalsa20Poly1305 (a.k.a. NaCl crypto_secretbox) authenticated encryption algorithm

salty

Small, sweet, swift Ed25519 signatures for microcontrollers

ockam

Ockam is a library for building devices that communicate securely, privately and trustfully with cloud services and other devices

speck

Implementation of the SPECK block cipher

chacha20stream

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

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

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…

rust-crypto

A (mostly) pure-Rust implementation of various common cryptographic algorithms

unknown_order

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

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

yaca

Bindings for the YACA library

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

pem-iterator

Iterate over PEM-encoded data

ed25519-bip32

Ed25519 BIP32

g2p

A crate to create types that implement fast finite field arithmetic

yubikey-piv

Pure Rust host-side driver for the YubiKey Personal Identity Verification (PIV) application providing general-purpose public-key signing and encryption with hardware-backed private keys for RSA (2048/1024)…

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…

lamport_sigs

Implementation of the Lamport one-time signature scheme

keccak-rust

Keccak implementation in Rust

rustls-pemfile

Basic .pem file parser for keys and certificates

rand_pwd

Generate random password

tbn

Pairing cryptography with the Barreto-Naehrig curve

x509-signature

Low-level X.509 parsing and signature verification library

rust-cryptoauthlib

Rust wrappers for CryptoAuthentication Library bindings

blakeout

Memory hard hashing algorithm based on Blake2s

rust-elgamal

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

merklebtree

Merkle Btree implementation

sss-rs

A secret sharing scheme implemented in Rust

sequoia-octopus-librnp

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

ansible-vault

encrypt and decrypt ansible vault

http-signature-normalization

An HTTP Signatures library that leaves the signing to you

pumpkin

A cryptographically secure prime number generator

deno_crypto

Web Cryptography API implementation for Deno

blake-hash

BLAKE hash functions

vented

Event driven encrypted tcp communicaton

reed-solomon

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

devolutions-crypto

An abstraction layer for the cryptography used by Devolutions

sequoia-sqv

A simple OpenPGP signature verification program

libaes

AES cipher in safe Rust with no dependencies

gluac-rs

Rust Crate for compiling Garry’s Mod Lua into bytecode

sapio-secp256k1

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

balanced-tree-index

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

mozilla/neqo-crypto

boring-sys

FFI bindings to BoringSSL

single_use_seals

Single-use-seals foundation API. For bitcoin-specific implementation check bp-seals

block-modes

Block cipher modes of operation

ironoxide

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

monocypher

Bindings for the monocypher C library

cdc

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

consistenttime

Constant time operations for crypto libraries

fog-crypto

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

iso8583_rs

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

libsignal-protocol-sys

*-sys crate for the libsignal-protocol-c library

botan-src

Sources of Botan cryptography library

ed25519-dalek-blake2-feeless

A fork of ed25519-dalek specifically for the feeless (Nano cryptocurrency) crate, supporting blake2b in some functions

ftx

Unofficial API Binding for the FTX Exchange

thieves-cant

A Rust implementation of the Solitaire Cipher designed by Bruce Schneier

lhash

Minimal hashing library

privatebox

A small and easy to use API to encrypt your data

luno-rs

A lightweight Rust wrapper for Luno API

nettfiske

Detect Phishing fetching Certificate Transparency Logs

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

encrypt-rs

Envelope encryption with secret-keepers

vdf

An implementation of Verifiable Delay Functions (VDFs) in Rust

hkdf

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

mrkl

Generic, minimalist, parallelizable Merkle tree

checkpwn_lib

Library to interact with the HIBP API

dumb-crypto

Dumb, but easily verifiable implementations of crypto algorithms

dryoc

dryoc is a pure-Rust general-purpose cryptography library

noise-protocol

Noise Protocol Framework implementation

merkle_light

Light merkle tree implementation with SPV support and dependency agnostic

wedpr_l_libsm

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

akkorokamui

Kraken REST APIs HTTP client

hmac-sha256

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

aez

Rust wrapper for AEZ wide block cipher written in C

bacon-cipher

An implementation of the Bacon’s cipher

fraunhofer-aisec/rabe

ABE Schemes implemented in rust

merkle-log

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

etebase

A Rust client library for Etebase

xoodoo

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

pasetors

PASETO: Platform-Agnostic Security Tokens (in Rust)

minisign-verify

A small crate to verify Minisign signatures

static-dh-ecdh

Pure Rust implementations of static Diffie-Hellman and elliptic curve Diffie-Hellman key-exchange

x25519-dalek-ng

fork x25519-dalek , update rand_core

ed25519-dalek-blake2b

fork ed25519-dalek , replace sha512 to blake2b

eva-crypto

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

cienli

CiEnLi is a library of historical ciphers implemented in rust

crypto_box

Pure Rust implementation of NaCl’s crypto_box public-key authenticated encryption primitive which combines the X25519 Elliptic Curve Diffie-Hellman function and the XSalsa20Poly1305 authenticated encryption cipher

chbs_password_checker

Password Strength Checker

digest-hash

Cryptography-grade data structure hashing

aries-askar

Hyperledger Aries Askar secure storage

lsx

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

paillier

A pure-Rust implementation of the Paillier encryption scheme

tweetnacl-sys

tweetnacl & FFI bindings to it

serde-encrypt-core

Encrypts all the Serialize

ripemd256

RIPEMD-256 hash function

yggdrasil-keys

Quickly generate yggdrasil keys

enigma-tools-u

Tools used by the untrusted part of the Enigma core and Principal node

Cupcake

An implementation of a lattice-based additive homomorphic encryption scheme

themis

High-level cryptographic services for storage and messaging

ark-marlin

A library for the Marlin preprocessing zkSNARK

dusk-hamt

HAMT datatructure for microkelvin

rustls-acme

TLS certificate management and serving using rustls

libsm

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

bitcheck

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

cipher-crypt

A cryptographic tomb of ciphers forgotten by time

des

DES and Triple DES (3DES, TDES) block ciphers implementation

witnet-bn

Pairing cryptography with the Barreto-Naehrig curve

ockam_vault_core

The Ockam Vault trait

acme-client

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

tss-esapi-sys

FFI wrapper around TSS 2.0 Enhanced System API

securestore

SecureStore API for creating or decrypting user secrets

bulk-gcd

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

stdtx

Extensible schema-driven Cosmos StdTx builder and Amino serializer

bundy

Bundy data signing and verification library

wireguard-vanity-address

Find Wireguard VPN keypairs with a specific readable string

arcturus

Implementation of Arcturus zero-knowledge proofs for confidential transactions

sec-store

Simple encrypted storage

caramel-client

A caramel client, to generate keys, requests and fetch updated certificates from a caramel server

passwors

Passwors is a simple password handling library that utilises Rust’s type system to enfore better password handling. Use it as a basic building block for more complex authentication systems.

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

pqcrypto-kyber

Post-Quantum Key-Encapsulation Mechanism kyber

ring-fork-dtool

Extended ring lib by dtool

djpass

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

kerberos_crypto

Cryptography algorithms for Kerberos

rust-clacc

Rust implementanion of a CL universal accumulator

tink-aead

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

ossuary

Library for establishing secure communication channels between two hosts

abrute

AESCrypt Brute force attempter

groestlcoin

General groestlcoin library for using and interoperating with Groestlcoin

zerocaf

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

portal-client

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

bcrypt-wasm

Easily hash and verify passwords using bcrypt

curve25519-dalek-fiat

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

sidh

An efficient supersingular isogeny-based cryptography library

rusterpassword

An implementation of the Master Password algorithm

fcp_cryptoauth

Implementation of the Futuristic Connectivity Protocol’s CryptoAuth layer (cryptographic authentication and encryption over unreliable channels)

pkcs11-uri

PKCS #11 URI parser

x448

A pure-Rust implementation of X448

cryptohelpers

Collection of helpers and simplifying functions for cryptography things

sphinxcrypto

Sphinx cryptographic packet format library

saltlick

A library for encrypting and decrypting file streams using libsodium

signature_bbs_plus

The Ockam BBS+ signature impementation

rust_sodium-sys

Raw bindings to libsodium

nettle-sys

Low-level Rust bindings for the Nettle cryptographic library

eaglesong

A Rust Library of Eaglesong Hash Function

yobicrypto

The Yobicash cryptographyc toolkit

keccakf

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

gimli-hash

The Gimli-permutation based Hash

matrix-sdk-crypto

Matrix encryption library

runkr

A Rust Bunkr client

slowlock

SlowLock convenience wrapper for processing cipher password with a proof of work function

evilsha

Unsecure SHA 2 implementation

signature

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

lib3h_sodium

lib3h libsodium wrapper providing memory secure api access

rust_srp

rust secure remote password authentication flow

eccoxide

elliptic curve cryptography (ECC) framework

noise-rust-crypto

Wrappers of dalek and RustCrypto crates for noise-protocol

octavo-digest

Octavo - Cryptographic Hash Functions. WARNING!!! Not suitable for production

gnir

Automated mirror of ring - Safe, fast, small crypto using Rust

libyobicash

The Yobicash cryptocurrency library

libtls-sys

FFI bindings for LibreSSL’s libtls

argon2-sys

Bindings to the argon2 C reference implementation

sha3

SHA-3 (Keccak) hash function

redact-crypto

Crypto abstractions for the Redact framework

gpgme-sys

Raw bindings for gpgme

hash2curve

Traits and algorithms for hashing arbitrary values to curve group element

diem/diem-crypto

Diem diem-crypto

c-certitude

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

zeroize_derive

Custom derive support for zeroize

bustabit

The utility for verification of Bustabit games

ibe

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

mpw-rs

Master Password is an algorithm used to generate unique passwords for websites, email accounts, or anything else based only on easily reproducible input

wedpr_l_crypto_hash_sm3

Library of WeDPR shared Hash Function implement by sm3

ecies-ed25519

ECIES on Twisted Edwards Curve25519 using AES-GCM and HKDF-SHA256

hrp

generate human-readable passwords

secret-keeper-cloudkms

CloudKMS SecretKeeper, an integration with Google Cloud KMS for https://crates.io/crates/secret-keeper

concrete-core

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

benaloh-challenge

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

ark-r1cs-std

A standard library for constraint system gadgets

easy_password

Easy password hashing (includes bcrypt)

double-ratchet

Double Ratchet key management for exchanging encrypted messages between two parties

blindsign

A package for creating blind signatures cryptography ECC

rabe

ABE Schemes implemented in rust

nobsign

A simple but effective sign library, written in Rust

bn

Pairing cryptography with the Barreto-Naehrig curve

http-signature-normalization-reqwest

An HTTP Signatures library that leaves the signing to you

commoncrypto

Idiomatic Rust wrappers for Mac OS X’s CommonCrypto library

rust-keylock-ui

A password manager with goals to be Secure, Simple to use, Portable and Extensible

nkeys

Rust implementation of the NATS nkeys library

symbol-crypto-core

Complete Symbol & Nis1 blockchain crypto library implementation

x3dh-ke

Implementation of X3DH

lioness

Lioness wide block cipher

dusk-pki

A library that holds the types and functions required to perform keys operations in Dusk

ark-poly-commit

A library for constructing polynomial commitment schemes for use in zkSNARKs

cryptobox

A KISS CLI-wrapper around libsodium’s cryptobox_easy

pkix

TLS Certificate encoding and decoding helpers

rugenere

Vigenère cipher tool written in rust that can encode, decode and store and read from files

curve25519-dalek-organism

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

age-core

[BETA] Common functions used across the age crates

tb-openpgp-certs

A tool to interact with TB78 (and later) OpenPGP cert storage

tink-awskms

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

commit_verify

Commit-verify API for client-side validation

kync

KyNc – a generic API for key encapsulation and a Rust interface to KyNc-plugins

aes_frast

An easy-to-use lib for AES encryption and decryption, coded in pure safe Rust-lang

psa-crypto-sys

Wrapper around the PSA Cryptography API

ark-ec

A library for elliptic curves and pairings

redactedsecret

This is a fork of the official Secrecy crate [https://github.com/iqlusioninc/crates/] Wrapper types and traits for secret management which help ensure they aren’t accidentally copied…

ssb-vanity

Generate vanity keys for Secure Scuttlebutt

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…

keynesis

General purpose key management and associated cryptographic protocols

streamsha

A streamed, resumable SHA (Secure Hashing Algorithm) library

tx-padding

A block padding scheme with prepended random bytes and trailing zeros

diem-crypto

Diem diem-crypto

tokio-libtls

Tokio bindings for LibreSSL’s libtls

keyplace

Keyplace - server assisted key derivation for humans

k-anon-hash

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

evilrng

Unsecure random number source

nash-mpc