Lib.rs

curve25519-dalek

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

digest

Traits for cryptographic hash functions

rpassword

Read passwords in console applications

rustls

Rustls is a modern TLS library written in Rust

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…

ed25519-dalek

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

secp256k1

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

sodiumoxide

Fast cryptographic library for Rust (bindings to libsodium)

openssl

OpenSSL bindings

sha2

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

pem

Parse and encode PEM-encoded data

siphasher

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

webpki

Web PKI X.509 Certificate Verification

bcrypt

Easily hash and verify passwords using bcrypt

snow

A pure-rust implementation of the Noise Protocol Framework

ring

Safe, fast, small crypto using Rust

subtle

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

blake3

the BLAKE3 hash function

openssl-sys

FFI bindings to OpenSSL

sequoia-openpgp

OpenPGP data types and associated machinery

secret-service

Library to interface with Secret Service API

threshold_crypto

Pairing threshold cryptography

rust-argon2

Rust implementation of the Argon2 password hashing function

djangohashers

A Rust port of the password primitives used in Django project

seahash

A blazingly fast, portable hash function with proven statistical guarantees

minisign

A crate to sign files and verify signatures

tiny-keccak

An implementation of Keccak derived functions

security-framework

Security.framework bindings for macOS and iOS

zkinterface

An implementation of zkInterface

c2-chacha

The ChaCha family of stream ciphers

merlin

Composable proof transcripts for public-coin arguments of knowledge

polyval

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

recrypt

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

x25519-dalek

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

cryptoxide

pure implementation of various common modern cryptographic algorithms, WASM compatible

merkletree

Light merkle tree implementation with SPV support and dependency agnostic

pwhash

A collection of password hashing routines in pure Rust

orion

Usable, easy and safe pure-Rust crypto

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.

sha-1

SHA-1 hash function

blake2-rfc

A pure Rust implementation of BLAKE2 based on RFC 7693

sheesy-cli

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

chbs

A crate providing secure passphrase generation based on a wordlist

constant_time_eq

Compares two equal-sized byte strings in constant time

ursa

This is the shared crypto library for Hyperledger components

roughenough

A Roughtime secure time sync server and client written in Rust

strobe-rs

An implementation of the Strobe protocol framework in pure Rust

keyring

Cross-platform library for managing passwords

hmac

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

secrets

Protected-access memory for cryptographic secrets

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…

ppv-lite86

Implementation of the crypto-simd API for x86

gpgme

GPGme bindings for Rust

crypto_api_chachapoly

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

boomphf

Scalable and Efficient Minimal Perfect Hash Functions

pledge

Rust binding to OpenBSD’s pledge(2) interface

gridiron

Rust finite field library with fixed size multi-word values

argon2rs

The pure Rust password hashing library that runs on Argon2

tindercrypt

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

authenticator

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

secstr

A data type suitable for storing sensitive information such as passwords and private keys in memory, featuring constant time equality, mlock and zeroing out

branca

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

oid

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

fiat-crypto

Fiat-crypto generated Rust

tari_crypto

Tari Cryptography library

tss-esapi

Wrapper around TSS 2.0 Enhanced System API

sha1collisiondetection

SHA-1 hash function with collision detection and mitigation

kbs2

A secret manager backed by age

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

pgp

OpenPGP implementation in Rust

aes

Facade for AES (Rijndael) block ciphers implementations

mbedtls

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

tmkms

Tendermint Key Management System

bcrypt-pbkdf

bcrypt-pbkdf password-based key derivation function

blake2b-rs

Rust bindings for the official Blake2b C implementation

bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

schnorrkel

Schnorr VRF, signatures, etc. using the Ristretto group

clear_on_drop

Helpers for clearing sensitive data on the stack and heap

forest_crypto

Filecoin crypto utilities for use in Forest

enc_file

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

google-authenticator

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

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

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

murmur3

A rust implementation of Murmur3 hash

bls12_381

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

pqcrypto-sphincsplus

Post-Quantum Signature Scheme sphincsplus

psa-crypto

Wrapper around the PSA Cryptography API

cashweb-secp256k1

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

fdh

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

nkeys

Rust implementation of the NATS nkeys library

chacha20poly1305

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

kuska-sodiumoxide

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

pgen

Passphrase Generator

concrete

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

devolutions-crypto

An abstraction layer for the cryptography used by Devolutions

r1cs

A library for building R1CS gadgets

hypercore

Secure, distributed, append-only log

rinkey

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

enocoro128v2

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

selenite

A Crate For Post-Quantum Cryptography Certificates Built on PQcrypto

tarssh

A simple SSH tarpit server

dusk-jubjub

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

medallion

JWT library for rust using serde, serde_json and openssl

cocoon

A simple protected container with strong encryption and format validation

libtls

Rust bindings for LibreSSL’s libtls

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

secret_integers

Wrapping around Rust’s integers to allow only constant-time operations

http-signature-normalization-actix

An HTTP Signatures library that leaves the signing to you

cryptostream

Transparent encryption and decryption for Read and Write streams

arx-kw

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

lib3h_sodium

lib3h libsodium wrapper providing memory secure api access

mozilla/neqo-crypto

boring

BoringSSL bindings

botan

Rust wrapper for Botan cryptography library

crypto-hash

A wrapper for OS-level cryptographic hash functions

argonautica

Idiomatic Argon2 password hashing for Rust

short-crypt

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

stegbrute

Steganography brute-force tool

rooster

A simple password manager for geeks

libsodium-sys

FFI binding to libsodium

paillier-common

paillier over bigint traits provided by rust-bigint

secp256k1-zkp

Rust bindings for the libsecp256k1-zkp library

blstrs

High performance implementation of BLS12 381

ed25519-zebra

Zcash-flavored Ed25519 for use in Zebra

self_encryption

Self encrypting files (convergent encryption plus obfuscation)

ecies

Elliptic Curve Integrated Encryption Scheme for secp256k1 in Rust

unveil

Rust binding for OpenBSD’s unveil(2)

sodalite

Tweetnacl in pure rust with no std dependency

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.

age

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

keccak-hash

keccak-hash is a set of utility functions to facilitate working with Keccak hashes (256/512 bits long)

rustgenhash

A tool to generate hashes from the command line

ssb-crypto

Crypto primitives used by Secure Scuttlebutt

shasum

Print SHA checksums from STDIN, input file or directory

block-buffer

Fixed size buffer for block processing of data

salty

Small, sweet, swift Ed25519 signatures for microcontrollers

sigma_fun

A framework for making Sigma protocols fun!

zkp-u256

Performant implementation of 256-bit unsigned integers

xpring

Rust client-side library for the XRP Ledger

xts-mode

XTS block mode implementation in rust

ecdsa

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

oath

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

substrate-bip39

Converting BIP39 entropy to valid Substrate (sr25519) SecretKeys

sequoia-sqv

A simple OpenPGP signature verification program

sharks

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

wascap

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

hips

Manage secrets alongside your code

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.

wpscan-analyze

Analyzes wpscan json output and checks for vulnerabilities

mpvss-rs

A Simple Publicly Verifiable Secret Sharing Library

ids_service

Library that allows to generate unique Ids

rust-crypto

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

pwned

Simple Have I Been Pwned checker

mix_link

message oriented noise based cryptographic link layer for mixnets

sha3

SHA-3 (Keccak) hash function

signature

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

hash_ord

A rust lib contains OrdMap(avl tree) and HashMap(use avl to resolve collision);

libargon2-sys

Rust bindings for Argon2

shamirsecretsharing

Shamir secret sharing library for Rust

nstack

Arity 4 stack for the kelvin merkle toolkit

fasthash

A suite of non-cryptographic hash functions for Rust

sct

Certificate transparency SCT verification library

static-dh-ecdh

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

jwt-compact

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

themis

High-level cryptographic services for storage and messaging

x509-signature

Low-level X.509 parsing and signature verification library

nohash-hasher

An implementation of std::hash::Hasher which does not hash at all

secret-tree

Hierarchical secret derivation with Blake2b

ed25519-bip32

Ed25519 BIP32

hpke

An implementation of the HPKE hybrid encryption standard in pure Rust

bacon-cipher

An implementation of the Bacon’s cipher

speck

Implementation of the SPECK block cipher

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

fil-sapling-crypto

Cryptographic library for Zcash Sapling

tapyrus

General purpose library for using and interoperating with Tapyrus

botan-sys

FFI wrapper for Botan cryptography library

stdtx

Extensible schema-driven Cosmos StdTx builder and Amino serializer

reed-solomon

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

easy-hasher

Easy hashing library

paillier

A pure-Rust implementation of the Paillier encryption scheme

rand_pwd

Generate random password

matrix-sdk-crypto

Matrix encryption library

curve25519-dalek-organism

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

glass_pumpkin

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

crypt4gh

Encryption and decryption implementation of the Crypt4GH encryption format

dup-crypto

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

sha1

Minimal implementation of SHA1 for Rust

noise-protocol

Noise Protocol Framework implementation

blake-hash

BLAKE hash functions

rabe-bn

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

bitcoincore-rpc-async

RPC client library for the Bitcoin Core JSON-RPC API

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…

rsa_public_encrypt_pkcs1

RSA PKCS#1 encryption from ASN.1 DER encoded public key in pure Rust

merklebtree

Merkle Btree implementation

crypto2

cryptographic algorithms

witnet-bn

Pairing cryptography with the Barreto-Naehrig curve

nash-protocol

state management and cryptography for interacting with nash exchange protocol

acme-client

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

saturating_arithmetic

Proc macro #[saturateit] to rewrite operators into their saturating equivalents

encrypted_id

Encryption and Decryption

threshold-secret-sharing

A pure-Rust implementation of various threshold secret sharing schemes

hkdf

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

tink-proto

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

ed448-goldilocks

A pure-Rust implementation of Ed448 and Curve448 and Decaf

gimli-permutation

Gimli: a cross-platform permutation

zeropool-bn

Pairing cryptography with the Barreto-Naehrig curve

Gen_Prime

A way to transform a hash to a prime number

aes-gcm-siv

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

ruma-signatures

Digital signatures according to the Matrix specification

hash_combine

Hash library with simple combine method

refset

A non-owning HashSet

mundane

Cryptography which is easy to use and hard to misuse

vented

Event driven encrypted tcp communicaton

rust-elgamal

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

hacspec

The hacspec compiler

arcturus

Implementation of Arcturus zero-knowledge proofs for confidential transactions

yaca

Bindings for the YACA library

pem-iterator

Iterate over PEM-encoded data

aes-soft

AES (Rijndael) block ciphers bit-sliced implementation

lamport_sigs

Implementation of the Lamport one-time signature scheme

efficient-sm2

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

ensync

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

opentls

TLS connections with OpenSSL

pqcrypto-kyber

Post-Quantum Key-Encapsulation Mechanism kyber

nettfiske

Detect Phishing fetching Certificate Transparency Logs

curve25519-dalek-ng

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

kerberos_crypto

Cryptography algorithms for Kerberos

g2p

A crate to create types that implement fast finite field arithmetic

pumpkin

A cryptographically secure prime number generator

monocypher

Bindings for the monocypher C library

hc-vault

A simple crate to interact with hashicorp’s vault

encrypt-rs

Envelope encryption with secret-keepers

tea-soft

TEA block cipher

eva-crypto

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

spartan

High-speed zkSNARKs without trusted setup

lsx

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

etebase

A Rust client library for Etebase

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

luno-rs

A lightweight Rust wrapper for Luno API

ed25519-compact

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

cryptohelpers

Collection of helpers and simplifying functions for cryptography things

botan-src

Sources of for Botan cryptography library

ckb-crypto

The ckb crypto util

rusty-sandbox

rusty-sandbox

noise-rust-crypto

Wrappers of dalek and RustCrypto crates for noise-protocol

merkle-tree-stream

A stream that generates a merkle tree based on the incoming data

parsec-service

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

caramel-client

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

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…

cipher-crypt

A cryptographic tomb of ciphers forgotten by time

nix-base32

Provides a nix (as in NixOS) compatible base32 encoding

hash-table

Hash Table

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…

boring-sys

FFI bindings to BoringSSL

iso8583_rs

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

shoop

Shoop is a high-speed encrypted file transfer tool reminiscent of scp. It uses SSH to bootstrap authentication and encryption, then uses UDT (a reliable protocol from the 2000s) instead…

tari_bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

inet2_derive

Derivation macros for Internet2-based crates

consistenttime

Constant time operations for crypto libraries

enigma-tools-u

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

sthash

A very fast cryptographic hash function for large data

hash-roll

Rolling hashes & Content Defined Chunking (cdc)

scipr-lab/groth16

An implementation of the Groth 2016 zkSNARK proof system

thieves-cant

A Rust implementation of the Solitaire Cipher designed by Bruce Schneier

fs-verity

Produce fs-verity measurements in pure Rust, or access the Linux kernel APIs to freeze a file with fs-verity and get its digest

b2sum-rust

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

nettle

Rust bindings for the Nettle cryptographic library

akkorokamui

Kraken REST APIs HTTP client

lightspeed_hash

Hash functions

http-signature-normalization

An HTTP Signatures library that leaves the signing to you

ssdeep

A Rust wrapper for ssdeep

cdc

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

deno_crypto

Collection of WebCrypto APIs

mrkl

Generic, minimalist, parallelizable Merkle tree

libsignal-protocol-sys

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

shadowsocks-crypto

Shadowsocks Crypto

libthemis-sys

FFI binding to libthemis

securestore

SecureStore API for creating or decrypting user secrets

dumb-crypto

Dumb, but easily verifiable implementations of crypto algorithms

sss-rs

A secret sharing scheme implemented in Rust

eaglesong

A Rust Library of Eaglesong Hash Function

keynesis

General purpose key management and associated cryptographic protocols

vdf

An implementation of Verifiable Delay Functions (VDFs) in Rust

saltlick

A library for encrypting and decrypting file streams using libsodium

crypto-morse

Encoding and decoding morse code for unicode

opaque-ke

An implementation of the OPAQUE password-authenticated key exchange protocol

const-sha1

A sha1 implementation for use in const contexts

jhash

Rust implementation of Jenkins hash with 32-bit sized optimizations

ecies-ed25519

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

lib3h_crypto_api

lib3h abstract cryptography traits and data types

zkp-hash

Hash primitive used in zkp-stark

hal-elements

hal-elements: an Elements extension of hal

threefish-cipher

Threefish block cipher

precomputed-hash

A library intending to be a base dependency to expose a precomputed hash

cryptonote-raw-crypto

Cryptography Primitives for Cryptonote

groestlcoin

General groestlcoin library for using and interoperating with Groestlcoin

psa-crypto-sys

Wrapper around the PSA Cryptography API

digest-hash

Cryptography-grade data structure hashing

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

edcert

A crate which can be used to sign and verify content based on Ed25519

djpass

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

aez

Rust wrapper for AEZ wide block cipher written in C

sec-store

Simple encrypted storage

fraunhofer-aisec/rabe

ABE Schemes implemented in rust

frauth-ed25519-dalek

A fork of ed25519-dalek that addresses serde issues

tokio-libtls

Tokio bindings for LibreSSL’s libtls

sgx_crypto_helper

Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language

sgx_pkix

TLS Certificate encoding and decoding helpers for the SGX environment

aeonflux

Composable, lightweight, fast attribute-based anonymous credentials with infinite (aeon) rerandomised (flux) presentations using algebraic message authentication codes (aMACs), symmetric verifiable encryption…

ring-fork-dtool

Extended ring lib by dtool

sshkeys

Rust library for parsing OpenSSH certificates and public keys

schnorr

Schnorr Signatures

bee-crypto

Cryptographic primitives of the IOTA protocol

ironoxide

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

spake2

The SPAKE2 password-authenticated key-exchange algorithm

hrp

generate human-readable passwords

merkle-log

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

murmurhash64

Implementation of MurmurHash2 (64bit version)

xsalsa20poly1305

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

merkle_light

Light merkle tree implementation with SPV support and dependency agnostic

fawkes-crypto-pairing_ce

Pairing-friendly elliptic curve library

electric-capital/crypto-ecosystems

A taxonomy for open source cryptocurrency, blockchain, and decentralized ecosystems

benaloh-challenge

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

safe_crypto

A convenience library providing abstractions for cryptographic functions

hash2curve

A suite of hash to curve ECC algorithms

sequoia-keyring-linter

A linter for keyrings

chaos

Password metadata storage and xsalsa20 hasher

microkelvin

A library for tree traversal over annotated datastructures

gimli-hash

The Gimli-permutation based Hash

zeroize_derive

Custom derive support for zeroize

bitcheck

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

bulk-gcd

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

mozilla/rc_crypto

Firefox Application Services

rust-clacc

Rust implementanion of a CL universal accumulator

libtls-sys

FFI bindings for LibreSSL’s libtls

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

wedpr_l_libsm

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

streamsha

A streamed, resumable SHA (Secure Hashing Algorithm) library

aws-nitro-enclaves-cose

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

wireguard-vanity-address

Find Wireguard VPN keypairs with a specific readable string

ossuary

Library for establishing secure communication channels between two hosts

checkpwn_lib

Library to interact with the HIBP API

bls_acml

BLS signatures. 2 variations. Multi-signature, Threshold signature, batch verification support

eccoxide

elliptic curve cryptography (ECC) framework

hash-ids

a fast hashids (hashids.org) implementation

argentum_encryption_business

Business layer of encryption

assemblylift-iomod-crypto-guest

AssemblyLift Crypto IOmod (guest)

monocypher-sys

Bindgen generated bindings to the monocypher C library

json-digest

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

sha3sum

sha3sum - compute and check SHA3 message digest

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.

libaes

AES cipher in safe Rust with no dependencies

tweetnacl

A rust api for using tweetnacl

aes-keywrap-rs

AES Key Wrap for Rust (AES-KW, RFC 3394 / RFC 5649)

bn

Pairing cryptography with the Barreto-Naehrig curve

ntge

A cryptography CLI tool that supports file encryption, decryption, signing and verifying

nextcloud-passwords-client

Bindings to the nextcloud passwords HTTP API

pretty-hash

Output binary buffers as a nice, shortened hex string

cellar-core

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

abrute

AESCrypt Brute force attempter

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

password-as-service

a very poorly considered http/rest service

big-hash

Compute MD5, SHA256, and SHA512 hashes of data through the std::hash API

aries-askar

Hyperledger Aries Askar secure storage

stemflow

Access-control policy engine used by StemJail

tuf

Library for The Update Framework (TUF)

fog-crypto

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

gnir

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

sidh

An efficient supersingular isogeny-based cryptography library

yobicrypto

The Yobicash cryptographyc toolkit

gpgme-sys

Raw bindings for gpgme

pword

pword is a secure password generator that lets you create unique passwords for websites based on an easy to remember master phrase

scipr-lab/dpc

A library for decentralized private computation

endpointsecurity

Nice (ish) bindings for the EndpointSecurity framework on macOS

cryptobox

A KISS CLI-wrapper around libsodium’s cryptobox_easy

phaser

The cloud native security scanner ☁️

mod_exp

Crate for doing modular exponentiation efficiently

age-core

[BETA] Common functions used across the age crates

rugenere

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

x448

A pure-Rust implementation of X448

elgamal_ristretto

A pure-Rust implementation of ElGamal encryption using the Ristretto group over Curve25519

ibe

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

crypto_api

Defines a general purpose API for various cryptographic primitives

type_hash

Generate a hash for a Rust type. The primary use-case for this crate is for detecting differences in message types between versions of a crate. The TypeHash trait is implemented…

easy_ssl

this is a rust lib to create x509 ssl certificate and private key file via an api and can be used in other rust projects

keccakf

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

sha2raw

SHA-2 hash function

runkr

A Rust Bunkr client

capbac

Reference implementation for Capability-based Access Control model

double-ratchet

Double Ratchet key management for exchanging encrypted messages between two parties

c-certitude

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

olm

Native implementation of the Olm and Megolm cryptographic ratchets

tx-padding

A block padding scheme with prepended random bytes and trailing zeros

octavo-digest

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

crev-ed25519-dalek

Fork of ed25519-dalek for crev (until mainline is usable for us again)

rust-sike

Implementation of the key encapsulation mechanism (KEM) and public-key encryption (pke) schemes of the Supersingular Isogeny Key Encapsulation (SIKE) protocol

libyobicash

The Yobicash cryptocurrency library

ophelia-bls-amcl

ophelia bls

password-store

gopass wrapper library

in-toto

Library for in-toto

evercrypt-sys

FFI binding to HACL/Evercrypt

zerocaf

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

rust-hashcash

Rust hashcash algorithm implementation with sha3 support

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

compile-time-lua-bind-hash

A crate for doing compile-time hashing of lua constants

tink-mac

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

secret-keeper-cloudkms

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

timing-shield

Comprehensive timing leak protection for Rust

hsieh-hash

The Hsieh Hash or SuperFastHash function

pqcrypto

Post-Quantum cryptographic primitives

bustabit

The utility for verification of Bustabit games

lioness

Lioness wide block cipher

fortresscrypto

Cryptography helper library for fortress

ripemd128

RIPEMD-128 hash function

farmhash

Farmhash is a successor to Cityhash (also from Google). Farmhash, like Cityhash before it, use ideas from Austin Appleby’s MurmurHash.

autd-holo-gain

Holo (Multiple foci) Gain for AUTD

rpwg

Random password generator

tenrus

Travis Encryption in Rust

finally-block

Final block is a block that is executed when it dropped. It helps a user to write the deferred statements that should be executed even some statements return early

easy_password

Easy password hashing (includes bcrypt)

qhashfilefuture

Future for hashing single file

nash-mpc

MPC wallet library providing threshold signatures for Nash exchange

speck-rs

A nostd implementation of NSA’s lightweight block cipher Speck

inc-sha1

Incremental SHA-1 calculation

eip_1024

EIP-1024 encryption

blake2

BLAKE2 hash functions

message_verifier

Rust Message Verifier library compatible with Rails’ MessageVerifier and MessageEncryptor

rabe

ABE Schemes implemented in rust

iris-ng

Crate to make TIPC available in Rust

i2p_snow

A pure-rust implementation of the Noise Protocol Framework, with I2P Noise extensions

dkim

Complete DKIM library

dudect-bencher

An implementation of the DudeCT constant-time function tester

jch

Jump Consistent Hash for Rust

pwquality

Binding for pwquality

everrs

Bindings for the HACL*/EverCrypt crypto library

block-modes

Block cipher modes of operation

pkcs7

PKCS #7 padding

shaman

A pure-Rust, cross-platform implementation of various common hashing algorithms

grammers-crypto

Several cryptographic utilities to work with Telegram’s data

djb_hash

Rust library of commonly used Daniel J. Bernstein style hash functions.

commoncrypto

Idiomatic Rust wrappers for Mac OS X’s CommonCrypto library