Pure Rust cryptography. Hardware-accelerated. Zero dependencies.

Minimal install:

[dependencies]
rscrypto = { version = "0.1", default-features = false, features = ["crc32"] }

Targeted bundle installs:

[dependencies]
# MACs only
rscrypto = { version = "0.1", default-features = false, features = ["macs"] }

# Signatures only
rscrypto = { version = "0.1", default-features = false, features = ["signatures"] }

# X25519 only
rscrypto = { version = "0.1", default-features = false, features = ["key-exchange"] }

Full install:

[dependencies]
rscrypto = { version = "0.1", features = ["full"] }

Feature selection rules:

• Pick a leaf when size matters most: crc32, sha2, hmac, hkdf, ed25519, x25519, chacha20poly1305, etc.
• Pick a bundle when you want the whole category: checksums, crypto-hashes, fast-hashes, hashes, macs, kdfs, signatures, key-exchange, auth, aead, full.
• Keep default = ["std"] unless you explicitly need no_std.

use rscrypto::{
  Aead, Blake3, Checksum, ChaCha20Poly1305, ChaCha20Poly1305Key, Crc32C, Digest,
  Ed25519Keypair, Ed25519SecretKey, HkdfSha256, HmacSha256, Kmac256, Mac,
  Sha256, Shake256, X25519SecretKey, Xof, Xxh3, aead::Nonce96,
};

// Checksum
let crc = Crc32C::checksum(b"data");

// Digest (one-shot and streaming)
let hash = Sha256::digest(b"data");
let mut h = Sha256::new();
h.update(b"da"); h.update(b"ta");
assert_eq!(h.finalize(), hash);

// HMAC
let tag = HmacSha256::mac(b"key", b"data");
assert!(HmacSha256::verify_tag(b"key", b"data", &tag).is_ok());

// HKDF
let mut okm = [0u8; 32];
HkdfSha256::new(b"salt", b"ikm").expand(b"info", &mut okm)?;

// XOF
let mut xof = Shake256::xof(b"data");
let mut out = [0u8; 64];
xof.squeeze(&mut out);

// KMAC256
let mut kmac = Kmac256::new(b"key", b"domain=v1");
kmac.update(b"data");
let mut tag32 = [0u8; 32];
kmac.finalize_into(&mut tag32);

// Ed25519
let kp = Ed25519Keypair::from_secret_key(Ed25519SecretKey::from_bytes([7u8; 32]));
let sig = kp.sign(b"data");
assert!(kp.public_key().verify(b"data", &sig).is_ok());

// X25519
let alice = X25519SecretKey::from_bytes([7u8; 32]);
let bob = X25519SecretKey::from_bytes([9u8; 32]);
assert_eq!(alice.diffie_hellman(&bob.public_key())?, bob.diffie_hellman(&alice.public_key())?);

// AEAD
let cipher = ChaCha20Poly1305::new(&ChaCha20Poly1305Key::from_bytes([0x11; 32]));
let nonce = Nonce96::from_bytes([0x22; 12]);
let mut buf = *b"data";
let tag = cipher.encrypt_in_place(&nonce, b"aad", &mut buf);
cipher.decrypt_in_place(&nonce, b"aad", &mut buf, &tag)?;
assert_eq!(&buf, b"data");

// Fast hashes (non-cryptographic)
let _ = Xxh3::hash(b"data");
let _ = rscrypto::RapidHash::hash(b"data");
# Ok::<(), Box<dyn std::error::Error>>(())

Single-crate crypto and checksum toolbox. No C FFI, no vendored C/C++, no_std first. Portable fallback is authoritative; ISA-specific kernels are accelerators, not separate APIs.

• Checksums use Type::checksum(data) plus new / update / finalize / reset.
• Fixed-output digests use Type::digest(data); XOFs use Type::xof(data) and finalize_xof().
• MACs use Type::mac(key, data) and Type::verify_tag(key, data, tag); KMAC uses finalize_into because output length is caller-chosen.
• HKDF uses new(salt, ikm) followed by expand / expand_array, with one-shot derive / derive_array.
• Signature, key-exchange, nonce, key, and tag wrappers round-trip through from_bytes / to_bytes / as_bytes.
• AEADs use encrypt / decrypt for combined buffers and encrypt_in_place / decrypt_in_place for detached-tag flows.

Each cipher has typed *Key and *Tag wrappers. Nonces: Nonce96, Nonce128, Nonce192, Nonce256 in rscrypto::aead.

auth enables macs, kdfs, signatures, and key-exchange.

XOF readers: Shake128XofReader, Shake256XofReader, Blake3XofReader, AsconXofReader, AsconCxof128Reader, Cshake256XofReader.

All implement ChecksumCombine for parallel CRC folding.

RapidHashFast64 / RapidHashFast128 available under rscrypto::hashes::fast.

[dependencies]
rscrypto = { version = "0.1", default-features = false, features = ["crc32"] }

Without std, runtime detection and I/O adapters are unavailable. Compile-time feature detection and portable fallbacks remain.

src/
├── lib.rs
├── aead/               # AEAD ciphers (AES-GCM, ChaCha20, AEGIS, Ascon)
├── auth/               # HMAC, HKDF, KMAC, Ed25519, X25519
├── checksum/           # CRC families, config, buffered, introspection
│   ├── crc16/
│   ├── crc24/
│   ├── crc32/          # CRC-32 IEEE + Castagnoli
│   └── crc64/          # CRC-64/XZ + NVME (canonical reference)
├── hashes/
│   ├── crypto/         # SHA-2, SHA-3, SHAKE, Blake3, Ascon, cSHAKE
│   │   ├── blake3/
│   │   ├── sha256/
│   │   └── sha512/
│   └── fast/           # XXH3, RapidHash (non-cryptographic)
├── platform/           # CPU detection, SIMD dispatch
└── traits/             # Checksum, Digest, Mac, Xof, FastHash, Aead, ct

CI platforms: x86_64 + aarch64 Linux, x86_64 + aarch64 Windows, IBM Z (s390x), IBM POWER10 (ppc64le). no_std targets: thumbv6m, riscv32, aarch64-none, x86_64-none, wasm32.

Fuzz targets by category: 6 AEAD (roundtrip + forgery + oracle), 4 auth (Ed25519/HMAC/HKDF/KMAC with oracle differential), 5 hash (chunk-split + reset + oracle), 2 Blake3 keyed/derive, 1 CRC combine, 2 fast hash.

MIT OR Apache-2.0