use hmac::{Hmac, Mac};
use rustls::pki_types::CertificateDer;
use sha2::{Digest, Sha256};
use crate::error::{Error, Result};
use crate::secure::credentials::{CredentialBundle, CredentialMode};
use crate::secure::env::SecureEnv;
use crate::secure::policy::{
Approval, HandshakeOffer, Identity, RatchetContext, SecurePolicy,
};
use crate::secure::tls::TlsMaterial;
type HmacSha256 = Hmac<Sha256>;
const OFFER_MAGIC: &[u8] = b"tdht-env-v3";
const OFFER_MAC_DOMAIN: &[u8] = b"torrentdht-env-offer-v3";
const OFFER_MAC_LEN: usize = 32;
const MAX_NETWORK_ID_LEN: usize = 1024;
pub struct EnvSecurePolicy {
identity: Identity,
handshake_key: zeroize::Zeroizing<Vec<u8>>,
local_leaf_cert_hash: [u8; 32],
}
impl EnvSecurePolicy {
pub fn from_env() -> Result<Self> {
let tls = SecureEnv::tls_from_env()?;
Self::from_env_with_tls(&tls)
}
pub fn from_env_with_tls(tls: &TlsMaterial) -> Result<Self> {
let network_id = SecureEnv::network_id().ok_or_else(|| {
Error::Secure(format!(
"missing env {} (required for secure sessions)",
SecureEnv::NETWORK_ID
))
})?;
let handshake_key = SecureEnv::handshake_key().ok_or_else(|| {
Error::Secure(format!(
"missing env {} (required for secure sessions)",
SecureEnv::HANDSHAKE_KEY
))
})?;
let leaf = tls.cert_chain.first().ok_or_else(|| {
Error::Secure("TLS certificate chain is empty".into())
})?;
Self::new(network_id.into_bytes(), handshake_key, leaf.as_ref())
}
pub fn new(
network_id: impl Into<Vec<u8>>,
handshake_key: impl Into<Vec<u8>>,
leaf_cert_der: &[u8],
) -> Result<Self> {
let network_id = network_id.into();
let handshake_key = zeroize::Zeroizing::new(handshake_key.into());
if network_id.is_empty() {
return Err(Error::Secure("network id must not be empty".into()));
}
if network_id.len() > MAX_NETWORK_ID_LEN {
return Err(Error::Secure("network id too long".into()));
}
if network_id.len() < SecureEnv::MIN_NETWORK_ID_LEN {
return Err(Error::Secure(format!(
"network id must be at least {} bytes (got {})",
SecureEnv::MIN_NETWORK_ID_LEN,
network_id.len()
)));
}
if handshake_key.is_empty() {
return Err(Error::Secure("handshake key must not be empty".into()));
}
if handshake_key.len() < SecureEnv::MIN_HANDSHAKE_KEY_LEN {
return Err(Error::Secure(format!(
"handshake key must be at least {} bytes (got {})",
SecureEnv::MIN_HANDSHAKE_KEY_LEN,
handshake_key.len()
)));
}
if leaf_cert_der.is_empty() {
return Err(Error::Secure("leaf certificate DER must not be empty".into()));
}
Ok(Self {
identity: Identity::new("env", network_id),
handshake_key,
local_leaf_cert_hash: leaf_cert_hash(leaf_cert_der),
})
}
pub fn handshake_key(&self) -> &[u8] {
&self.handshake_key
}
fn network_label(&self) -> String {
String::from_utf8_lossy(&self.identity.bytes).into_owned()
}
fn offer_mac(&self, network_id: &[u8], leaf_hash: &[u8; 32]) -> Result<[u8; OFFER_MAC_LEN]> {
let mut mac = HmacSha256::new_from_slice(&self.handshake_key)
.map_err(|_| Error::Secure("invalid handshake key for HMAC".into()))?;
mac.update(OFFER_MAC_DOMAIN);
mac.update(network_id);
mac.update(leaf_hash);
let result = mac.finalize().into_bytes();
let mut out = [0u8; OFFER_MAC_LEN];
out.copy_from_slice(&result);
Ok(out)
}
fn build_offer_payload(&self) -> Result<Vec<u8>> {
let network_id = &self.identity.bytes;
let mac = self.offer_mac(network_id, &self.local_leaf_cert_hash)?;
let mut payload =
Vec::with_capacity(OFFER_MAGIC.len() + 2 + network_id.len() + OFFER_MAC_LEN);
payload.extend_from_slice(OFFER_MAGIC);
let len = u16::try_from(network_id.len())
.map_err(|_| Error::Secure("network id too long".into()))?;
payload.extend_from_slice(&len.to_be_bytes());
payload.extend_from_slice(network_id);
payload.extend_from_slice(&mac);
Ok(payload)
}
fn parse_offer(payload: &[u8]) -> Result<(Vec<u8>, [u8; OFFER_MAC_LEN])> {
let magic_len = OFFER_MAGIC.len();
let min = magic_len + 2 + OFFER_MAC_LEN;
if payload.len() < min {
return Err(Error::Secure("handshake offer truncated".into()));
}
if &payload[..magic_len] != OFFER_MAGIC {
return Err(Error::Secure("handshake offer version/magic mismatch".into()));
}
let id_len = u16::from_be_bytes([payload[magic_len], payload[magic_len + 1]]) as usize;
if id_len == 0 || id_len > MAX_NETWORK_ID_LEN {
return Err(Error::Secure("handshake offer has invalid network id length".into()));
}
let id_start = magic_len + 2;
let id_end = id_start.checked_add(id_len).ok_or_else(|| {
Error::Secure("handshake offer length overflow".into())
})?;
let mac_end = id_end.checked_add(OFFER_MAC_LEN).ok_or_else(|| {
Error::Secure("handshake offer length overflow".into())
})?;
if payload.len() != mac_end {
return Err(Error::Secure("handshake offer has trailing or missing bytes".into()));
}
let network_id = payload[id_start..id_end].to_vec();
let mut mac = [0u8; OFFER_MAC_LEN];
mac.copy_from_slice(&payload[id_end..mac_end]);
Ok((network_id, mac))
}
}
impl SecurePolicy for EnvSecurePolicy {
fn identity(&self) -> Identity {
self.identity.clone()
}
fn handshake_offer(&self) -> Result<HandshakeOffer> {
Ok(HandshakeOffer {
payload: self.build_offer_payload()?,
})
}
fn approve_peer(
&self,
peer_offer: &HandshakeOffer,
peer_certs: &[CertificateDer<'static>],
) -> Result<Approval> {
let leaf = peer_certs.first().ok_or_else(|| {
Error::Secure("peer mTLS leaf certificate required for approval".into())
})?;
let peer_leaf_hash = leaf_cert_hash(leaf.as_ref());
let (peer_network_id, peer_mac) = Self::parse_offer(&peer_offer.payload)?;
if !constant_time_eq(&peer_network_id, &self.identity.bytes) {
return Err(Error::Secure(
"peer handshake offer rejected (network id mismatch)".into(),
));
}
let expected_mac = self.offer_mac(&peer_network_id, &peer_leaf_hash)?;
if !constant_time_eq(&peer_mac, &expected_mac) {
return Err(Error::Secure(
"peer handshake offer rejected (authenticator/cert mismatch)".into(),
));
}
Ok(Approval {
peer_label: format!("env:{}", self.network_label()),
notes: Vec::new(),
})
}
fn ratchet(&self, _ctx: &RatchetContext) -> Result<()> {
Ok(())
}
fn credential_mode(&self) -> CredentialMode {
CredentialMode::SealedChannel
}
fn local_credentials(&self) -> Result<CredentialBundle> {
Ok(CredentialBundle::new(format!(
"env-member:{}",
self.network_label()
)))
}
}
fn leaf_cert_hash(der: &[u8]) -> [u8; 32] {
let digest = Sha256::digest(der);
let mut out = [0u8; 32];
out.copy_from_slice(&digest);
out
}
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
if a.len() != b.len() {
return false;
}
let mut diff = 0u8;
for (x, y) in a.iter().zip(b.iter()) {
diff |= x ^ y;
}
diff == 0
}
#[cfg(test)]
mod tests {
use super::*;
const NET_A: &[u8] = b"network-a-abcdef"; const NET_B: &[u8] = b"network-b-abcdef";
const KEY: &[u8] = b"0123456789abcdef0123456789abcdef"; const KEY_OTHER: &[u8] = b"fedcba9876543210fedcba9876543210";
const LEAF_A: &[u8] = b"test-leaf-cert-a-der-bytes!!!!!!";
const LEAF_B: &[u8] = b"test-leaf-cert-b-der-bytes!!!!!!";
fn certs(leaf: &'static [u8]) -> Vec<CertificateDer<'static>> {
vec![CertificateDer::from(leaf)]
}
#[test]
fn rejects_foreign_network_id() {
let local = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
let foreign = EnvSecurePolicy::new(NET_B, KEY, LEAF_B).expect("policy");
let offer = foreign.handshake_offer().expect("offer");
assert!(local.approve_peer(&offer, &certs(LEAF_B)).is_err());
}
#[test]
fn accepts_matching_network_key_and_cert() {
let a = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
let b = EnvSecurePolicy::new(NET_A, KEY, LEAF_B).expect("policy");
let offer = b.handshake_offer().expect("offer");
let approval = a.approve_peer(&offer, &certs(LEAF_B)).expect("approve");
assert_eq!(approval.peer_label, "env:network-a-abcdef");
assert!(!approval.peer_label.contains("shared-key"));
}
#[test]
fn rejects_cert_swap() {
let a = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
let b = EnvSecurePolicy::new(NET_A, KEY, LEAF_B).expect("policy");
let offer = b.handshake_offer().expect("offer");
assert!(a.approve_peer(&offer, &certs(LEAF_A)).is_err());
}
#[test]
fn rejects_missing_peer_certs() {
let a = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
let b = EnvSecurePolicy::new(NET_A, KEY, LEAF_B).expect("policy");
let offer = b.handshake_offer().expect("offer");
assert!(a.approve_peer(&offer, &[]).is_err());
}
#[test]
fn rejects_wrong_handshake_key() {
let local = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
let foreign = EnvSecurePolicy::new(NET_A, KEY_OTHER, LEAF_B).expect("policy");
let offer = foreign.handshake_offer().expect("offer");
assert!(local.approve_peer(&offer, &certs(LEAF_B)).is_err());
}
#[test]
fn rejects_substring_key_spoof() {
let local = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
let spoof = HandshakeOffer {
payload: b"torrentdht-env-v1:evil:secret".to_vec(),
};
assert!(local.approve_peer(&spoof, &certs(LEAF_A)).is_err());
}
#[test]
fn offer_does_not_contain_raw_handshake_key() {
let policy = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
let offer = policy.handshake_offer().expect("offer");
assert!(
!offer
.payload
.windows(KEY.len())
.any(|w| w == KEY),
"raw handshake key must not appear in offer"
);
assert!(offer.payload.starts_with(OFFER_MAGIC));
}
#[test]
fn credentials_do_not_echo_handshake_key() {
let policy = EnvSecurePolicy::new(NET_A, KEY, LEAF_A).expect("policy");
let creds = policy.local_credentials().expect("creds");
assert_eq!(creds.bytes, b"env-member:network-a-abcdef");
assert!(!creds.bytes.windows(KEY.len()).any(|w| w == KEY));
}
#[test]
fn rejects_empty_network_id_and_key() {
assert!(EnvSecurePolicy::new(b"", KEY, LEAF_A).is_err());
assert!(EnvSecurePolicy::new(NET_A, b"", LEAF_A).is_err());
assert!(EnvSecurePolicy::new(b"short", KEY, LEAF_A).is_err());
assert!(EnvSecurePolicy::new(NET_A, b"short-key", LEAF_A).is_err());
assert!(EnvSecurePolicy::new(NET_A, KEY, b"").is_err());
}
}