torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use std::path::Path;

use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey};
use sha2::{Digest, Sha512};

use crate::bencode::encode;
use crate::bencode::BencodeValue;
use crate::error::{Error, Result};

pub const PUBLIC_KEY_LEN: usize = 32;
pub const SIGNATURE_LEN: usize = 64;
pub const SEED_LEN: usize = 32;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TorrentSignature {
    pub public_key: [u8; PUBLIC_KEY_LEN],
    pub signature: [u8; SIGNATURE_LEN],
}

impl TorrentSignature {
    pub fn to_bencode(&self) -> BencodeValue {
        use std::collections::BTreeMap;
        BencodeValue::Dict(BTreeMap::from([
            (
                b"pubkey".to_vec(),
                BencodeValue::Bytes(self.public_key.to_vec()),
            ),
            (
                b"sig".to_vec(),
                BencodeValue::Bytes(self.signature.to_vec()),
            ),
        ]))
    }

    pub fn from_bencode(value: &BencodeValue) -> Result<Self> {
        let public_key = value
            .dict_get_str("pubkey")
            .or_else(|| value.dict_get(b"public key".as_ref()))
            .and_then(|v| v.as_bytes())
            .ok_or_else(|| Error::Integrity("signature missing pubkey".into()))?;
        let signature = value
            .dict_get_str("sig")
            .or_else(|| value.dict_get(b"signature".as_ref()))
            .and_then(|v| v.as_bytes())
            .ok_or_else(|| Error::Integrity("signature missing sig".into()))?;

        if public_key.len() != PUBLIC_KEY_LEN {
            return Err(Error::Integrity("invalid signature public key length".into()));
        }
        if signature.len() != SIGNATURE_LEN {
            return Err(Error::Integrity("invalid signature length".into()));
        }

        let mut pk = [0u8; PUBLIC_KEY_LEN];
        pk.copy_from_slice(public_key);
        let mut sig = [0u8; SIGNATURE_LEN];
        sig.copy_from_slice(signature);
        Ok(Self {
            public_key: pk,
            signature: sig,
        })
    }
}

pub fn signing_key_from_seed(seed: &[u8; SEED_LEN]) -> SigningKey {
    SigningKey::from_bytes(seed)
}

pub fn load_signing_key(path: &Path) -> Result<SigningKey> {
    let raw = std::fs::read(path)?;
    if raw.len() == SEED_LEN {
        let mut seed = [0u8; SEED_LEN];
        seed.copy_from_slice(&raw);
        return Ok(signing_key_from_seed(&seed));
    }
    if raw.len() == PUBLIC_KEY_LEN + SEED_LEN {
        let mut seed = [0u8; SEED_LEN];
        seed.copy_from_slice(&raw[PUBLIC_KEY_LEN..]);
        return Ok(signing_key_from_seed(&seed));
    }
    Err(Error::Integrity(format!(
        "signing key file must be {SEED_LEN} or {} bytes",
        PUBLIC_KEY_LEN + SEED_LEN
    )))
}

pub fn sign_info_dict(info: &BencodeValue, key: &SigningKey) -> TorrentSignature {
    let message = encode(info);
    let signature = key.sign(&message);
    TorrentSignature {
        public_key: key.verifying_key().to_bytes(),
        signature: signature.to_bytes(),
    }
}

pub fn verify_info_dict(info: &BencodeValue, signature: &TorrentSignature) -> Result<()> {
    let message = encode(info);
    let public_key = VerifyingKey::from_bytes(&signature.public_key)
        .map_err(|err| Error::Integrity(format!("invalid signing public key: {err}")))?;
    let sig = Signature::from_bytes(&signature.signature);
    public_key
        .verify(&message, &sig)
        .map_err(|_| Error::Integrity("torrent info signature verification failed".into()))
}

pub fn derive_signing_seed(passphrase: &str, info_hash: &[u8; 20]) -> [u8; SEED_LEN] {
    let mut hasher = Sha512::new();
    hasher.update(b"torrentdht-signing-v1");
    hasher.update(passphrase.as_bytes());
    hasher.update(info_hash);
    let digest = hasher.finalize();
    let mut seed = [0u8; SEED_LEN];
    seed.copy_from_slice(&digest[..SEED_LEN]);
    seed
}

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

    #[test]
    fn signs_and_verifies_info_dict() {
        let info = BencodeValue::Dict(BTreeMap::from([(
            b"name".to_vec(),
            BencodeValue::Bytes(b"test".to_vec()),
        )]));
        let seed = [7u8; SEED_LEN];
        let key = signing_key_from_seed(&seed);
        let signature = sign_info_dict(&info, &key);
        verify_info_dict(&info, &signature).expect("verify");
    }

    #[test]
    fn rejects_tampered_info() {
        let info = BencodeValue::Dict(BTreeMap::from([(
            b"name".to_vec(),
            BencodeValue::Bytes(b"test".to_vec()),
        )]));
        let key = signing_key_from_seed(&[1u8; SEED_LEN]);
        let signature = sign_info_dict(&info, &key);
        let tampered = BencodeValue::Dict(BTreeMap::from([(
            b"name".to_vec(),
            BencodeValue::Bytes(b"tampered".to_vec()),
        )]));
        assert!(verify_info_dict(&tampered, &signature).is_err());
    }
}