Lib.rs

curve25519-dalek

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

blake3

the BLAKE3 hash function

sha2

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

secp256k1

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

openssl

OpenSSL bindings

rcgen

Rust X.509 certificate generator

signature

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

webpki-roots

Mozilla's CA root certificates for use with webpki

pem

Parse and encode PEM-encoded data

rustls-pemfile

Basic .pem file parser for keys and certificates

ed25519-dalek

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

digest

Traits for cryptographic hash functions and message authentication codes

ark-ff

A library for finite fields

rsa

Pure Rust RSA implementation

x25519-dalek

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

ark-ec

A library for elliptic curves and pairings

ed25519-compact

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

tiny-keccak

An implementation of Keccak derived functions

group

Elliptic curve group traits and utilities

ed25519-zebra

Zcash-flavored Ed25519 for use in Zebra

cryptoxide

pure implementation of various common modern cryptographic algorithms, WASM compatible

s2n-tls

A C99 implementation of the TLS/SSL protocols

aes

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

pact_verifier_cli

Standalone pact verifier for provider pact verification

openssl-sys

FFI bindings to OpenSSL

sha1

SHA-1 hash function

bcrypt

Easily hash and verify passwords using bcrypt

vsss-rs

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

ckb-merkle-mountain-range

A generalized merkle mountain range implementation

boring

BoringSSL bindings

snow

A pure-rust implementation of the Noise Protocol Framework

security-framework

Security.framework bindings for macOS and iOS

b3sum

a command line implementation of the BLAKE3 hash function

constant_time_eq

Compares two equal-sized byte strings in constant time

hkdf

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

aws-sigv4

SigV4 signer for HTTP requests and Event Stream messages

sequoia-openpgp

OpenPGP data types and associated machinery

orion

Usable, easy and safe pure-Rust crypto

classic-mceliece-rust

Pure rust implementation of the PQC scheme Classic McEliece

blstrs

High performance implementation of BLS12 381

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

openssl-probe

Tool for helping to find SSL certificate locations on the system for OpenSSL

self_encryption

Self encrypting files (convergent encryption plus obfuscation)

siphasher

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

merkletree

Light merkle tree implementation with SPV support and dependency agnostic

lair_keystore

secret lair private keystore

blst

Bindings for blst BLS12-381 library

sha256

sha256 crypto digest

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

ark-std

A library for no_std compatibility

coset

Set of types for supporting COSE

minisign

A crate to sign files and verify signatures

chacha20poly1305

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

cosmian_crypto_core

Crypto lib for pure crypto primitives

concrete-core

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

bls12_381_plus

Implementation of the BLS12-381 pairing-friendly elliptic curve construction. This is a fork from zkcrypto/bls12_381 but adds hash to curve and multiexponentiation methods as well as…

bls12_381

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

kzen-paillier

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

winter-crypto

Cryptographic library for the Winterfell STARK prover/verifier

subtle

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

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

djangohashers

A Rust port of the password primitives used in Django project

dusk-jubjub

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

mla

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

curv-kzen

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

ockam_transport_ble

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

rust-argon2

Rust implementation of the Argon2 password hashing function

neptune

Poseidon hashing over BLS12-381 for Filecoin

jwt-compact

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

hpke

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

ark-poly

A library for efficient polynomial arithmetic via FFTs over finite fields

openssh-keys

read and write OpenSSH public keys

blsttc

Pairing threshold cryptography

sha1collisiondetection

SHA-1 hash function with collision detection and mitigation

x509-certificate

X.509 certificate parser and utility functionality

s2n-tls-sys

A C99 implementation of the TLS/SSL protocols

matrix-sdk-crypto

Matrix encryption library

ece

Encrypted Content-Encoding for HTTP Rust implementation

fiat-crypto

Fiat-crypto generated Rust

ockam

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

vrf

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

sigma_fun

A framework for making Sigma protocols fun!

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…

dexios

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

winter-prover

Winterfell STARK prover

russh

A client and server SSH library

secret-vault

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

ppv-lite86

Implementation of the crypto-simd API for x86

zeropool-bn

Pairing cryptography with the Barreto-Naehrig curve

sodoken

libsodium wrapper providing tokio safe memory secure api access

bao

an implementation of BLAKE3 verified streaming

leo-lang

The Leo programming language

picky-asn1-x509

Provides ASN1 types defined by X.509 related RFCs

ockam_core

Core types of the Ockam library

sheesy-cli

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

leo-ast

Abstract syntax tree (AST) for the Leo programming language

ecdsa

Pure Rust implementation of the Elliptic Curve Digital Signature Algorithm (ECDSA) as specified in FIPS 186-4 (Digital Signature Standard), providing RFC6979 deterministic signatures as well as support for added entropy

webpki

Web PKI X.509 Certificate Verification

winter-math

Math library for the Winterfell STARK prover/verifier

http-signature-normalization-actix

An HTTP Signatures library that leaves the signing to you

safecloset

Secret Keeper

spartan

High-speed zkSNARKs without trusted setup

shadowsocks-crypto

Shadowsocks Crypto

chbs

A crate providing secure passphrase generation based on a wordlist

p12

pure rust pkcs12 tool

authenticator

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

abe_gpsw

ABE GPSW scheme for BLS pairing implemented in rust

wdcrypt

CLI to encrypt the current working directory with Fernet encryption

arti

A rust implementation of the Tor privacy tools

sha3sum

sha3sum - compute and check SHA3 message digest

aef

Encrypted file archiver

pgp

OpenPGP implementation in Rust

enc_file

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

osshkeys

A library to read and write OpenSSH public and private keys

circomspect

A static analyzer and linter for the Circom zero-knowledge DSL

fernet

An implementation of fernet in Rust

blake2

BLAKE2 hash functions

cocoon

A simple protected container with strong encryption and format validation

kestrel-cli

Kestrel file encryption program

roughenough

A Roughtime secure time sync server and client written in Rust

wascap

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

concrete

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

base64ct

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

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

rustgenhash

A tool to generate hashes from the command line

strobe-rs

An implementation of the Strobe protocol framework in pure Rust

rusty_paseto

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

rustweb2

Rust-based web server

secp256k1-zkp

Rust bindings for the libsecp256k1-zkp library

recrypt

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

oqs

A Rusty interface to Open-Quantum-Safe's liboqs

xrc_cli

A cli for multi-threaded encryption/decryption of files/folder using bitwise xor

g2p

A crate to create types that implement fast finite field arithmetic

acme2

A Tokio and OpenSSL based ACMEv2 client

secrets

Protected-access memory for cryptographic secrets

ed25519-dalek-blake3

fork ed25519-dalek , replace sha512 to blake3

picky

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

truelayer-signing

Produce & verify TrueLayer API requests signatures

test-curve25519-dalek

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

deno_crypto

Web Cryptography API implementation for Deno

olm-sys

Low level binding for libolm

tss-esapi

Rust-native wrapper around TSS 2.0 Enhanced System API

ironhide

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

bls_bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

apple-codesign

Pure Rust interface to code signing on Apple platforms

tough-ssm

Implements AWS SSM as a key source for TUF signing keys

cylinder

Cylinder is a high-level cryptographic signing library

rinkey

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

rage

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

sequoia-wot

An implementation of OpenPGP's web of trust

evercrypt

Crypto library using formally verified code from HACL/Evercrypt

psa-crypto

Wrapper around the PSA Cryptography API

ockam_transport_websocket

WebSocket Transport for the Ockam Routing Protocol

lair_keystore_api

secret lair private keystore API library

parmesan

PARMESAN: Parallel ARithMEticS over tfhe ENcrypted data

s2n-quic-crypto

Internal crate used by s2n-quic

oberon

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

boomphf

Scalable and Efficient Minimal Perfect Hash Functions

cosmian_cover_crypt

Key Policy attribute encryption based on subset cover

ed25519-bip32

Ed25519 BIP32

tor-llcrypto

Low level cryptography wrappers used by Tor

tough-kms

Implements AWS KMS as a key source for TUF signing keys

gpgme

GPGme bindings for Rust

sgx_pkix

TLS Certificate encoding and decoding helpers for the SGX environment

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…

c2-chacha

The ChaCha family of stream ciphers

benaloh-challenge

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

curve25519-dalek-ng

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

clear_on_drop

Helpers for clearing sensitive data on the stack and heap

elastic-elgamal

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

lockstitch

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

hpke-dispatch

runtime algorithmic selection for hybrid public key encryption

openpgp-ca

OpenPGP CA is a tool for managing and certifying OpenPGP keys

napa

A simple and secure command line password manager

dusk-poseidon

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

krill

Resource Public Key Infrastructure (RPKI) daemon

libxlsxwriter-sys

Rust binding of libxlsxwriter

ensync

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

aws-sign-v4

Generate AWS Signature 4 headers easily

crrl

Library for cryptographic research

risc0-r0vm

RISC Zero zero-knowledge VM executable

publish-ws

Publish Workspace Packages

xts-mode

XTS block mode implementation in rust

substrate-bn

Pairing cryptography with the Barreto-Naehrig curve

noise-protocol

Noise Protocol Framework implementation

hmac-sha512

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

zk-paillier

Collection of Paillier cryptosystem zero knowledge proofs written in Rust

pasetors

PASETO: Platform-Agnostic Security Tokens (in Rust)

kbs2

A secret manager backed by age

umbral-pre

Implementation of Umbral proxy reencryption algorithm

rustls-webpki

Web PKI X.509 Certificate Verification

pairing

Pairing-friendly elliptic curve library

openssl-src

Source of OpenSSL and logic to build it

ncryptf-rs

Secure API authentication and end to end encryption

ring

Safe, fast, small crypto using Rust

ocsp

An OCSP encoding/decoding lib for Rust

merkle_light

Light merkle tree implementation with SPV support and dependency agnostic

winter-air

AIR components for the Winterfell STARK prover/verifier

botan

Rust wrapper for Botan cryptography library

dryoc

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

mpvss-rs

A Simple Publicly Verifiable Secret Sharing Library

vodozemac

A Rust implementation of Olm and Megolm

arrow-digest

Stable hashes for Apache Arrow

miden-air

Algebraic intermediate representation of Miden VM processor

pqcrypto-kyber

Post-Quantum Key-Encapsulation Mechanism kyber

mbedtls-sys-auto

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

cryptostream

Transparent encryption and decryption for Read and Write streams

double-ratchet-2

Implementation of Double Ratchet as specified by Signal

ark-serialize

A library for serializing types in the arkworks ecosystem

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

ed448-goldilocks

A pure-Rust implementation of Ed448 and Curve448 and Decaf

nu-command

Nushell's built-in commands

matrix-sdk-store-encryption

Helpers for encrypted storage keys for the Matrix SDK

xxblake3

encryption and decryption based on xxh3 and blake3

tari_crypto

Tari Cryptography library

avro-rs

Library for working with Apache Avro in Rust

serde-encrypt

Encrypts all the Serialize

tandem_http_client

HTTP client for the Tandem SMPC engine

merkle-tree-bulletin-board

A public bulletin board based upon Merkle trees

crypto-hash

A wrapper for OS-level cryptographic hash functions

aws-nitro-enclaves-cose

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

srisum

Compute and check subresource integrity digests

enocoro128v2

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

ciphercore-utils

Convenience functions and wrappers used by CipherCore crates

boring-sys

FFI bindings to BoringSSL

ic_bls12_381

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

redact-client

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

short-crypt

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

ssh-gpg-agent

An SSH agent implementation that transparently supports PGP encrypted private SSH keys

hashraccoon

MD5/SHA256 HASH ATTACK IN RUST

aligned-cmov

Fast constant-time conditional moves of aligned bytes

blake2-rfc

A pure Rust implementation of BLAKE2 based on RFC 7693

tindercrypt

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

zkinterface

An implementation of zkInterface

sidh

An efficient supersingular isogeny-based cryptography library

hyper-openssl

Hyper TLS support via OpenSSL

hips

Manage secrets alongside your code

gitoid

An experimental implementation of gitoids in Rust

nacl

Rust version of NaCl Cryptographic library with Scrypt added

bbjwt

A simple to use, well documented JWT validation library, mainly for validating OpenID Connect ID Tokens

oid

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

libsm

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

mc-oblivious-aes-gcm

WARNING: This crate is not intended for general use, you should use the official RustCrypto crate instead. Fork of RustCrypto's AES-GCM to provide a public CTR member, for use in a constant-time decrypt-in-place method

dgc

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

aws-lc-sys

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

cosmian_findex

Symmetric Searchable Encryption

gm-rs

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

rabe-bn

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

gpgrv

Pure-Rust implementation of gpgv, to verify gpg signatures

google-authenticator

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

bhttp

Binary HTTP messages (draft-ietf-httpbis-binary-message)

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

crypt4gh

Encryption and decryption implementation of the Crypt4GH encryption format

jwtk

JWT signing (JWS) and verification, with first class JWK and JWK Set (JWKS) support

bulletproofs

A pure-Rust implementation of Bulletproofs using Ristretto

vrf-mod

An extensible rust library for building VRF functionality with support for Elliptical Curve VRFs (secp256k1, secp256r1 curves)

bls-signatures

Aggregate BLS Signatures

rsa_ext

Pure Rust RSA implementation

cyfs-sha2

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

schnorrkel

Schnorr VRF, signatures, etc. using the Ristretto group

signify

Command-line implementation of the signify signature scheme

curve25519-parser

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

win-crypto-ng

Safe bindings to Windows Cryptography API: Next Generation

acme-redirect

Tiny http daemon that answers acme challenges and redirects everything else to https

locutus-dev

Locutus P2P development tools

ruma-signatures

Digital signatures according to the Matrix specification

winter-verifier

Winterfell STARK verifier

rust-clacc

Rust implementanion of a CL universal accumulator

secret-vault-value

Library provides a simple implementation of a secure and serializable type to store and control secret/sensitive values

dco3_crypto

Symmetric and asymmetric encryption for DRACOON in Rust

ironoxide

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

itsdangerous

Rust port of the popular itsdangerous python library for signing strings and sending them over untrusted channels

mercy

Mercy is a public Rust crate created to assist with building cybersecurity frameworks (offensive and defensive) and assessment tools. The goal is to create a sustainable crate to make…

snowstorm

A minimalistic encryption protocol based on Noise protocol (snow)

laminar-bcs

Binary Canonical Serialization (BCS)

sam_encrypt

A crate that provides a set of cryptographic primitives for building a proxy self re-encryption scheme

mcircuit

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

scicrypt

Lightweight cryptographic building blocks for proof of concept implementations in multi-party computation

easy_password

Easy password hashing (includes bcrypt)

pkix

TLS Certificate encoding and decoding helpers

ssh-keydump

Simple tool to inspect OpenSSH keys

decanter

This crate implements basic cryptographic primitives native to the ecosystem

eznacl

A wrapper around NaCl which makes working with cryptography even easier

hasher

Package hasher provides a Hasher trait

tls-api

TLS API without implementation

secret-tree

Hierarchical secret derivation with Blake2b

said

Self-Addressing identifier library

cloudfront_sign

Utility module for AWS CloudFront to generate signed URLs and cookies

ockam_node

Ockam Node implementation crate

clap-digest

clap and digest integration

fides

Fides is a library for cryptographic primitives

blake2b-rs

Rust bindings for the official Blake2b C implementation

askar-crypto

Hyperledger Aries Askar cryptography

simple-rijndael

Pure Rust, simple implementation of the rijndael-cbc algorithm for osu! score decryption or encryption

thotp

An RFC based implementation of TOTPs and HOTPs

ed25519-dalek-fiat

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

scsys-crypto

kms-aead

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

etebase

A Rust client library for Etebase

psa-crypto-sys

Wrapper around the PSA Cryptography API

gst-plugin-sodium

GStreamer plugin for libsodium-based file encryption and decryption

djpass

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

paspio

A password entropy calculator

schannel

Schannel bindings for rust, allowing SSL/TLS (e.g. https) without openssl

rust-cryptoauthlib

Rust wrappers for CryptoAuthentication Library bindings

tuf

Library for The Update Framework (TUF)

chksum-hash

Simple cryptography library that provides interface for calculating both batch and stream computation of hash digest

did-pkh

did:pkh DID method, using the ssi crate

sunscreen

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

mozilla/neqo-crypto

efficient-sm2

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

libaes

AES cipher in safe Rust with no dependencies

ark-relations

A library for rank-one constraint systems

cosmian_crypto_base

Crypto lib for hybrid encryption and pure crypto primitives

tfhe

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

leo-test-framework

The testing framework for the Leo programming language

sppark

Zero-knowledge template library

ssclient

SecureStore client for managing user secrets

num-sign

enum Sign { Positive = 1, Negative = -1 }

zeppelin_core

A library that implements a stream cipher based on Balloon hashing

hmac-sha256

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

fdh

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

async-hash

Traits and helper functions for SHA256 hashing of async data types

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.

nucypher-core

Nucypher network core datastructures

catherine

Catherine is a blue team security framework with an extensible module collection, various types of cryptographic processes, hexadecimal dumping and aggregation, malicious domain detection, and real-time database analysis

sfynx

General-purpose onion routing packet construction and processor based on Sphinx

cellar-core

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

cretrit

Flexible Order-Revealing Encryption library

http-signature-normalization-reqwest

An HTTP Signatures library that leaves the signing to you

keccakf

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

pqcrypto-falcon-wasi

Post-Quantum Signature Scheme falcon

ed25519-consensus

Ed25519 suitable for use in consensus-critical contexts

const-sha1

A sha1 implementation for use in const contexts

argon2rs

The pure Rust password hashing library that runs on Argon2

gridiron

Rust finite field library with fixed size multi-word values

envcrypt

Encrypt environment variables at compile-time and decrypt them at runtime

hashes

Rust implementation of cryptographic hash function algorithms

randompass

🔑 A simple static password generator

age

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

smcrypto

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

xor_cryptor

A encryption/decryption library using bitwise xor

paillier-lsc

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

tandem

Cryptographic Engine for Secure Multi-Party Computation using Garbled Circuits

mp4decrypt

Decrypt and split mp4 streams using Bento4

devolutions-crypto

An abstraction layer for the cryptography used by Devolutions

nkeys

Rust implementation of the NATS nkeys library

h_encrypt

A simple encrpytion/decryption library

sha2raw

SHA-2 hash function

r1cs

A library for building R1CS gadgets

mc-oblivious-map

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

ncr-crypto

A library for the cryptography used in the Minecraft No-Chat-Reports Mod

veldora

A command-line program to bruteforce zips, pdfs and some popular hashes

kcapi-sys

Official low-level Rust bindings for libkcapi

jpki-cli

Read certificates, sign and verify documents using your JPKI card

keysmith

Create keys or ids for data

gpwg

A good password generator

sshkeys

Rust library for parsing OpenSSH certificates and public keys

spiffe

Rust client library implementation for SPIFFE

md5-rs

A streamable MD5 implementation, using no_std

miden-verifier

Miden VM execution verifier

num-primes

A Rust Library For Generating Large Prime and Composite Numbers using num with a simplistic interface

reddsa

A standalone implementation of the RedDSA signature scheme

xc220b3

Quantum-safe stream encryption using XChaCha20 and BLAKE3 along with various other cryptographic primitives

tink-mac

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

themis

High-level cryptographic services for storage and messaging

ck-meow

An implementation of STROBE using KitTen

kes-summed-ed25519

Key Evolving Signature

botan-src

Sources of Botan cryptography library

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

vb_accumulator

Positive and universal bilinear map accumulator and proof of membership and non-membership protocol

digestify

Verify a file against a provided digest/hash/checksum

fog-crypto

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

acme-client

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

cienli

CiEnLi is a library of historical ciphers implemented in rust

libfortress

Fortress library

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…

tor-checkable

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

ncr

Rust implementation of chat encryption in the Minecraft mod No Chat Reports

s2n-quic-core

Internal crate used by s2n-quic

trezor-crypto

Rust bindings for the trezor crypto libraries

digifirma

Italian CIE P7M parser and signature checker

hashcom-rs

A fast, minimal but yet extensible framework for building and using hash commitment schemes

monacoin

General purpose library for using and interoperating with Monacoin and other cryptocurrencies

svp

Lattice sieving over the integers with arbitrary precision

tugger-windows-codesign

Code signing on Windows platforms

libcryptsetup-rs-sys

Low level bindings for libcryptsetup

k12sum

A command line implementation of the KangarooTwelve hash function

hmac-drbg

Pure Rust implementation of Hmac DRBG

cesride

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

passwordmaker-rs

Rust reimplementation of the PasswordMaker Pro algorithm. This is partially a port, partially written from scratch. Compatibility is a goal, but not guaranteed.

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

azalea-crypto

Cryptography features used in Minecraft

centipede

A scheme for instantiating KMS's with recovery

frauth-ed25519-dalek

A fork of ed25519-dalek that addresses serde issues

mozilla/rc_crypto

Firefox Application Services

groestlcoin_hashes

Hash functions used by rust-groestlcoin which support rustc 1.29.0

sss-rs

A secret sharing scheme implemented in Rust

clevis-pin-tpm2

Clevis TPM2 PIN with policy support

ansivault

CLI tool ansible-vault 1.1 implementation

kestrel-crypto

Cryptography backend for Kestrel

pgen

Passphrase Generator

amcl

The Apache Milagro Cryptographic Library (version 3)

horror

Cryptography helper library

irmaseal-curve

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

grammers-crypto

Several cryptographic utilities to work with Telegram's data

scryptenc

An implementation of the scrypt encrypted data format

miracl_amcl

The Apache Milagro Cryptographic Library (version 3.2)

crev-recursive-digest

Library implementing recursive digest for filesystem directories

balanced-tree-index

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

mim

MIM is a Hash Visualization algorithm utilising 4x4 colour matrixes. This provides a quick and easy method to compare fingerprints, e.g. SSH keys, x509 certs etc.

in-toto

Library for in-toto

paillier-common

paillier over bigint traits provided by rust-bigint

chksm

A multipurpose rust library for use in my projects

ece-native

Encrypted Content-Encoding (ECE) encryption and decryption implemented according to RFC8188

aes-prng

Pseudo-random number generator based on AES

sslenum

SSL certificate Extractor

pqcrypto

Post-Quantum cryptographic primitives