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());
}
}