schnorr48 0.1.0

48-byte Schnorr signatures over Ed25519 (truncated challenge for bandwidth efficiency)
Documentation
//! 48-byte Schnorr signatures over Ed25519.
//!
//! This crate provides bandwidth-efficient Schnorr signatures using a truncated
//! 16-byte challenge instead of the standard 32-byte hash. This saves 16 bytes
//! per signature (48 bytes vs 64 bytes) while maintaining ~128-bit security.
//!
//! # Format
//!
//! ```text
//! signature = e (16 bytes) || s (32 bytes)
//! ```
//!
//! Where:
//! - `e` is the truncated SHA-512 challenge (first 16 bytes)
//! - `s` is the full 32-byte scalar response
//!
//! # Example
//!
//! ```
//! use schnorr48::{Seed, derive_keypair, sign, verify};
//!
//! // Generate keypair from seed
//! let seed = Seed::new([0u8; 32]);
//! let (privkey, pubkey) = derive_keypair(&seed);
//!
//! // Sign a message
//! let message = b"hello world";
//! let signature = sign(&privkey, &pubkey, message);
//!
//! // Verify
//! assert!(verify(&pubkey, message, &signature));
//! ```
//!
//! # Security
//!
//! - Deterministic nonces (RFC 6979 style) prevent nonce reuse
//! - Constant-time scalar operations via `curve25519-dalek`
//! - Rejects identity points, low-order points, and non-canonical scalars
//! - Key material zeroized on drop
//!
//! # no_std
//!
//! This crate is `#![no_std]` compatible. It requires `alloc` for the
//! `curve25519-dalek` dependency.

#![no_std]
#![forbid(unsafe_code)]
#![cfg_attr(docsrs, feature(doc_cfg))]

extern crate alloc;

mod keys;

pub use keys::{PrivateKey, PublicKey, Seed};

use curve25519_dalek::{
    constants::ED25519_BASEPOINT_POINT, edwards::CompressedEdwardsY, scalar::Scalar,
    traits::IsIdentity,
};
use sha2::{Digest, Sha512};
use subtle::ConstantTimeEq;

/// Length of a Schnorr48 signature in bytes.
pub const SIGNATURE_LEN: usize = 48;

/// Derive an Ed25519 keypair from a seed.
///
/// Returns `(privkey, pubkey)`:
/// - `privkey` — clamped Ed25519 scalar (little-endian)
/// - `pubkey`  — compressed Ed25519 point
pub fn derive_keypair(seed: &Seed) -> (PrivateKey, PublicKey) {
    let hash = Sha512::digest(seed.as_bytes());
    let privkey_bytes = clamp(hash[..32].try_into().unwrap());
    let priv_scalar = Scalar::from_bytes_mod_order(privkey_bytes);
    let pubkey_bytes = (priv_scalar * ED25519_BASEPOINT_POINT)
        .compress()
        .to_bytes();
    (PrivateKey::new(privkey_bytes), PublicKey::new(pubkey_bytes))
}

/// Sign a message. Returns 48-byte signature `e[16] || s[32]`.
///
/// The nonce is deterministic: `H(privkey || msg)` to prevent nonce reuse.
pub fn sign(privkey: &PrivateKey, pubkey: &PublicKey, msg: &[u8]) -> [u8; SIGNATURE_LEN] {
    // 1. Deterministic nonce: r = SHA-512(privkey || msg) mod L
    let nonce_hash = Sha512::new()
        .chain_update(privkey.as_bytes())
        .chain_update(msg)
        .finalize();
    let r = Scalar::from_bytes_mod_order_wide(&nonce_hash.into());

    // 2. Commitment: R = r * B
    let r_bytes = (r * ED25519_BASEPOINT_POINT).compress().to_bytes();

    // 3. Challenge: e = SHA-512(R || pubkey || msg)[..16]
    let e_hash = Sha512::new()
        .chain_update(r_bytes)
        .chain_update(pubkey.as_bytes())
        .chain_update(msg)
        .finalize();
    let e: [u8; 16] = e_hash[..16].try_into().unwrap();

    // 4. Extend 16-byte challenge to 32-byte scalar (zero-padded, little-endian)
    let mut e_extended = [0u8; 32];
    e_extended[..16].copy_from_slice(&e);
    let e_scalar = Scalar::from_bytes_mod_order(e_extended);

    // 5. s = (r + e * privkey) mod L
    let priv_scalar = Scalar::from_bytes_mod_order(*privkey.as_bytes());
    let s = r + e_scalar * priv_scalar;

    let mut sig = [0u8; SIGNATURE_LEN];
    sig[..16].copy_from_slice(&e);
    sig[16..].copy_from_slice(s.as_bytes());
    sig
}

/// Verify a 48-byte signature. Returns `true` if valid.
///
/// Defense-in-depth checks:
/// - Rejects non-canonical scalars (s >= L)
/// - Rejects zero scalars (s == 0)
/// - Rejects identity point as pubkey
/// - Rejects low-order/torsion points as pubkey
pub fn verify(pubkey: &PublicKey, msg: &[u8], sig: &[u8; SIGNATURE_LEN]) -> bool {
    // 1. Parse: e (16 bytes) || s (32 bytes)
    let e_received: [u8; 16] = sig[..16].try_into().unwrap();
    let s_bytes: [u8; 32] = sig[16..].try_into().unwrap();

    // 2. s must be canonical (< L) and non-zero
    let s: Scalar = match Scalar::from_canonical_bytes(s_bytes).into() {
        Some(s) => s,
        None => return false,
    };
    if s == Scalar::ZERO {
        return false;
    }

    // 3. Decompress public key and reject identity/low-order points
    let pubkey_point = match CompressedEdwardsY(*pubkey.as_bytes()).decompress() {
        Some(p) if !p.is_identity() && p.is_torsion_free() => p,
        _ => return false,
    };

    // 4. Extend 16-byte challenge to 32-byte scalar
    let mut e_extended = [0u8; 32];
    e_extended[..16].copy_from_slice(&e_received);
    let e_scalar = Scalar::from_bytes_mod_order(e_extended);

    // 5. R' = s*B - e*pubkey
    let sb = s * ED25519_BASEPOINT_POINT;
    let epk = e_scalar * pubkey_point;
    let r_prime = (sb - epk).compress();

    // 6. Recompute challenge and compare (constant-time)
    let e_check = Sha512::new()
        .chain_update(r_prime.as_bytes())
        .chain_update(pubkey.as_bytes())
        .chain_update(msg)
        .finalize();

    e_check[..16].ct_eq(&e_received).into()
}

fn clamp(mut bytes: [u8; 32]) -> [u8; 32] {
    bytes[0] &= 248;
    bytes[31] &= 127;
    bytes[31] |= 64;
    bytes
}

#[cfg(test)]
mod tests {
    use super::*;

    fn hex(s: &str) -> alloc::vec::Vec<u8> {
        (0..s.len())
            .step_by(2)
            .map(|i| u8::from_str_radix(&s[i..i + 2], 16).unwrap())
            .collect()
    }

    fn arr32(v: &[u8]) -> [u8; 32] {
        v.try_into().expect("expected 32 bytes")
    }

    fn arr48(v: &[u8]) -> [u8; 48] {
        v.try_into().expect("expected 48 bytes")
    }

    #[test]
    fn derive_vector1() {
        let seed = Seed::new(arr32(&hex(
            "0000000000000000000000000000000000000000000000000000000000000000",
        )));
        let (priv_got, pub_got) = derive_keypair(&seed);
        assert_eq!(
            *priv_got.as_bytes(),
            arr32(&hex("5046adc1dba838867b2bbbfdd0c3423e58b57970b5267a90f57960924a87f156"))
        );
        assert_eq!(
            *pub_got.as_bytes(),
            arr32(&hex("3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29"))
        );
    }

    #[test]
    fn derive_vector2() {
        let seed = Seed::new(arr32(&hex(
            "deadbeefcafebabedeadbeefcafebabedeadbeefcafebabedeadbeefcafebabe",
        )));
        let (priv_got, pub_got) = derive_keypair(&seed);
        assert_eq!(
            *priv_got.as_bytes(),
            arr32(&hex("50b8c29238a8403e0ac69e23d47b9184c371a92460d518351b099944bbdfa867"))
        );
        assert_eq!(
            *pub_got.as_bytes(),
            arr32(&hex("9d7725e28403e00e9ee54f9b14c868faf99b4b2fafa936eda28f8ae40207780d"))
        );
    }

    const VECTORS: &[(&str, &str, &str, &str)] = &[
        (
            "5046adc1dba838867b2bbbfdd0c3423e58b57970b5267a90f57960924a87f156",
            "3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da29",
            "",
            "26f70691bbde0c1e8becc00e7e7663cb6b72364b6ea208fdabef226c5b0d07cec9c661fd69671981ca40277598ea9c01",
        ),
        (
            "50b8c29238a8403e0ac69e23d47b9184c371a92460d518351b099944bbdfa867",
            "9d7725e28403e00e9ee54f9b14c868faf99b4b2fafa936eda28f8ae40207780d",
            "74657374",
            "c9bec10578943fc8d453252fb262fa03ad2220609d98dda4b561d4b02281f1e8706676c26685a806d6e0d74f345e2009",
        ),
        (
            "b0829ce3ccf1d8edd5da1132d46271b0169f58b6414fd263d3c98da627170f5e",
            "207a067892821e25d770f1fba0c47c11ff4b813e54162ece9eb839e076231ab6",
            "54686520717569636b2062726f776e20666f78206a756d7073206f76657220746865206c617a7920646f67",
            "e15b69ed5bd6fccc6c624431eb1bb08341ba571158da31249ac72a28af7f77ea0534b94cc1f8650dead98ccae16ec803",
        ),
    ];

    #[test]
    fn sign_matches_vectors() {
        for (i, (privkey_hex, pubkey_hex, msg_hex, sig_hex)) in VECTORS.iter().enumerate() {
            let privkey = PrivateKey::new(arr32(&hex(privkey_hex)));
            let pubkey = PublicKey::new(arr32(&hex(pubkey_hex)));
            let msg = hex(msg_hex);
            let expected = hex(sig_hex);
            let got = sign(&privkey, &pubkey, &msg);
            assert_eq!(got.as_ref(), expected.as_slice(), "vector {i} sign mismatch");
        }
    }

    #[test]
    fn verify_valid_vectors() {
        for (i, (_, pubkey_hex, msg_hex, sig_hex)) in VECTORS.iter().enumerate() {
            let pubkey = PublicKey::new(arr32(&hex(pubkey_hex)));
            let msg = hex(msg_hex);
            let sig = arr48(&hex(sig_hex));
            assert!(verify(&pubkey, &msg, &sig), "vector {i} verify rejected");
        }
    }

    #[test]
    fn invalid_wrong_message() {
        let pubkey = PublicKey::new(arr32(&hex(
            "9d7725e28403e00e9ee54f9b14c868faf99b4b2fafa936eda28f8ae40207780d",
        )));
        let msg = hex("77726f6e67");
        let sig = arr48(&hex("c9bec10578943fc8d453252fb262fa03ad2220609d98dda4b561d4b02281f1e8706676c26685a806d6e0d74f345e2009"));
        assert!(!verify(&pubkey, &msg, &sig));
    }

    #[test]
    fn invalid_identity_point_pubkey() {
        let pubkey = PublicKey::new(arr32(&hex(
            "0100000000000000000000000000000000000000000000000000000000000000",
        )));
        let msg = hex("74657374");
        let sig = arr48(&hex("c9bec10578943fc8d453252fb262fa03ad2220609d98dda4b561d4b02281f1e8706676c26685a806d6e0d74f345e2009"));
        assert!(!verify(&pubkey, &msg, &sig));
    }

    #[test]
    fn invalid_zero_s() {
        let pubkey = PublicKey::new(arr32(&hex(
            "9d7725e28403e00e9ee54f9b14c868faf99b4b2fafa936eda28f8ae40207780d",
        )));
        let msg = hex("74657374");
        let sig = arr48(&hex("c9bec10578943fc8d453252fb262fa030000000000000000000000000000000000000000000000000000000000000000"));
        assert!(!verify(&pubkey, &msg, &sig));
    }

    #[test]
    fn roundtrip() {
        let seed = Seed::new([42u8; 32]);
        let (privkey, pubkey) = derive_keypair(&seed);
        let msg = b"test message";
        let sig = sign(&privkey, &pubkey, msg);
        assert!(verify(&pubkey, msg, &sig));
        assert!(!verify(&pubkey, b"wrong", &sig));
    }
}