use std::net::SocketAddr;
use std::sync::Arc;
use std::time::Duration;
use rustls::pki_types::{CertificateDer, ServerName};
use tokio::io::{AsyncRead, AsyncWrite};
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::{broadcast, mpsc, RwLock};
use tokio_rustls::{TlsAcceptor, TlsConnector};
use tracing::{debug, info, warn};
use crate::dht::DhtNode;
use crate::error::{Error, Result};
use crate::net::DialGate;
use crate::secure::credentials::{
read_frame, write_frame, CredentialBundle, CredentialChannel, CredentialMode,
};
use crate::secure::env::SecureEnv;
use crate::secure::peers::PeerEndpointStore;
use crate::secure::policy::{
Approval, HandshakeOffer, Handoff, HandoffNotice, PolicyHandle, RatchetContext, SecureTransport,
SessionBroken,
};
use crate::secure::tls::TlsMaterial;
#[derive(Clone)]
pub struct SecureNodeConfig {
pub listen_addr: SocketAddr,
pub peer_store: PeerEndpointStore,
pub handshake_key: Option<zeroize::Zeroizing<Vec<u8>>>,
pub reconnect_backoff_initial: Duration,
pub reconnect_backoff_max: Duration,
pub enable_dht: bool,
pub listen_dual_stack: bool,
pub block_private: bool,
pub connect_timeout: Duration,
pub tls_timeout: Duration,
pub handshake_timeout: Duration,
}
impl SecureNodeConfig {
pub fn from_env_defaults(listen: SocketAddr) -> Self {
let peer_store = SecureEnv::peer_store_path()
.map(PeerEndpointStore::new)
.unwrap_or_else(|| PeerEndpointStore::new("./.torrentdht/peers.kdl"));
Self {
listen_addr: SecureEnv::listen_addr()
.and_then(|s| s.parse().ok())
.unwrap_or(listen),
peer_store,
handshake_key: SecureEnv::handshake_key().map(zeroize::Zeroizing::new),
reconnect_backoff_initial: Duration::from_secs(1),
reconnect_backoff_max: Duration::from_secs(60),
enable_dht: true,
listen_dual_stack: true,
block_private: true,
connect_timeout: Duration::from_secs(5),
tls_timeout: Duration::from_secs(10),
handshake_timeout: Duration::from_secs(15),
}
}
}
pub struct SecureNode {
policy: PolicyHandle,
tls: TlsMaterial,
cfg: SecureNodeConfig,
dial_gate: DialGate,
dht: Option<Arc<DhtNode>>,
listener: RwLock<Option<TcpListener>>,
broken_tx: mpsc::UnboundedSender<SessionBroken>,
broken_rx: RwLock<Option<mpsc::UnboundedReceiver<SessionBroken>>>,
handoff_tx: RwLock<Option<mpsc::UnboundedSender<Handoff>>>,
handoff_notices: broadcast::Sender<HandoffNotice>,
}
impl SecureNode {
pub async fn from_env(
policy: PolicyHandle,
cfg: SecureNodeConfig,
dht: Option<Arc<DhtNode>>,
) -> Result<Arc<Self>> {
let tls = SecureEnv::tls_from_env()?;
Self::new(policy, tls, cfg, dht).await
}
pub async fn new(
policy: PolicyHandle,
tls: TlsMaterial,
cfg: SecureNodeConfig,
dht: Option<Arc<DhtNode>>,
) -> Result<Arc<Self>> {
let (broken_tx, broken_rx) = mpsc::unbounded_channel();
if let Some(dht) = &dht {
if cfg.enable_dht {
dht.register_swarm(&policy.network_dht_key()).await;
}
}
Ok(Arc::new(Self {
policy,
tls,
dial_gate: DialGate::from_block_private(cfg.block_private),
cfg,
dht,
listener: RwLock::new(None),
broken_tx,
broken_rx: RwLock::new(Some(broken_rx)),
handoff_tx: RwLock::new(None),
handoff_notices: broadcast::channel(64).0,
}))
}
pub async fn subscribe_handoffs(&self) -> Result<mpsc::UnboundedReceiver<Handoff>> {
let mut slot = self.handoff_tx.write().await;
if slot.is_some() {
return Err(Error::Secure(
"subscribe_handoffs: already subscribed (only one handoff consumer allowed)"
.into(),
));
}
let (tx, rx) = mpsc::unbounded_channel();
*slot = Some(tx);
Ok(rx)
}
pub fn subscribe_handoff_notices(&self) -> broadcast::Receiver<HandoffNotice> {
self.handoff_notices.subscribe()
}
fn publish_handoff_notice(&self, handoff: &Handoff) {
let _ = self.handoff_notices.send(handoff.notice());
}
pub fn signal_broken(&self, peer_addr: SocketAddr) {
let _ = self.broken_tx.send(SessionBroken {
peer_addr,
prefer_addr_only: false,
});
}
pub fn signal_broken_preferred(&self, peer_addr: SocketAddr) {
let _ = self.broken_tx.send(SessionBroken {
peer_addr,
prefer_addr_only: true,
});
}
pub fn broken_sender(&self) -> mpsc::UnboundedSender<SessionBroken> {
self.broken_tx.clone()
}
pub async fn dial(self: &Arc<Self>, addr: SocketAddr) -> Result<Handoff> {
let handoff = self.dial_and_handshake(addr, ip_server_name(addr)?, true).await?;
let _ = self.cfg.peer_store.remember(addr);
if let Some(dht) = &self.dht {
if self.cfg.enable_dht {
let _ = dht
.announce_peer(
&self.policy.network_dht_key(),
self.cfg.listen_addr.port(),
)
.await;
}
}
self.policy.on_handoff(&handoff);
self.publish_handoff_notice(&handoff);
Ok(handoff)
}
pub async fn dial_host_approved(self: &Arc<Self>, addr: SocketAddr) -> Result<Handoff> {
let handoff = self
.dial_and_handshake(addr, ip_server_name(addr)?, false)
.await?;
let _ = self.cfg.peer_store.remember(addr);
self.policy.on_handoff(&handoff);
self.publish_handoff_notice(&handoff);
Ok(handoff)
}
pub async fn dial_hostname(
self: &Arc<Self>,
host: &str,
addr: SocketAddr,
) -> Result<Handoff> {
let server_name = ServerName::try_from(host.to_owned()).map_err(|err| {
Error::Secure(format!("invalid TLS server name {host:?}: {err}"))
})?;
let handoff = self.dial_and_handshake(addr, server_name, true).await?;
let _ = self.cfg.peer_store.remember(addr);
self.policy.on_handoff(&handoff);
self.publish_handoff_notice(&handoff);
Ok(handoff)
}
pub async fn dial_hostname_host_approved(
self: &Arc<Self>,
host: &str,
addr: SocketAddr,
) -> Result<Handoff> {
let server_name = ServerName::try_from(host.to_owned()).map_err(|err| {
Error::Secure(format!("invalid TLS server name {host:?}: {err}"))
})?;
let handoff = self.dial_and_handshake(addr, server_name, false).await?;
let _ = self.cfg.peer_store.remember(addr);
self.policy.on_handoff(&handoff);
self.publish_handoff_notice(&handoff);
Ok(handoff)
}
pub async fn connect(self: &Arc<Self>) -> Result<Handoff> {
let mut candidates = self
.dial_gate
.filter(self.cfg.peer_store.load().unwrap_or_default());
if let Some(dht) = &self.dht {
if self.cfg.enable_dht {
match dht.get_peers(&self.policy.network_dht_key()).await {
Ok(peers) => {
for peer in self.dial_gate.filter(peers) {
if !candidates.contains(&peer) {
candidates.push(peer);
}
}
}
Err(err) => debug!(%err, "dht get_peers during connect"),
}
}
}
if candidates.is_empty() {
return Err(Error::Secure(
"no peer candidates (empty peer store and DHT)".into(),
));
}
let mut last_err = Error::Secure("all peer candidates failed".into());
for addr in candidates {
match self
.dial_and_handshake(addr, ip_server_name(addr)?, true)
.await
{
Ok(handoff) => {
let _ = self.cfg.peer_store.remember(addr);
if let Some(dht) = &self.dht {
let _ = dht
.announce_peer(
&self.policy.network_dht_key(),
self.cfg.listen_addr.port(),
)
.await;
}
self.policy.on_handoff(&handoff);
self.publish_handoff_notice(&handoff);
return Ok(handoff);
}
Err(err) => {
debug!(%err, %addr, "secure dial failed");
last_err = err;
}
}
}
Err(last_err)
}
pub async fn accept_once(self: &Arc<Self>) -> Result<Handoff> {
{
let mut guard = self.listener.write().await;
if guard.is_none() {
let listener = crate::net::bind_tcp(
self.cfg.listen_addr.port(),
self.cfg.listen_dual_stack,
)
.await?;
info!(addr = %listener.local_addr().unwrap_or(self.cfg.listen_addr), "secure node listening");
*guard = Some(listener);
}
}
let (stream, peer_addr) = {
let guard = self.listener.read().await;
let listener = guard
.as_ref()
.ok_or_else(|| Error::Secure("secure listener missing".into()))?;
listener.accept().await?
};
let handoff = self.accept_and_handshake(stream, peer_addr).await?;
let _ = self.cfg.peer_store.remember(peer_addr);
self.policy.on_handoff(&handoff);
self.publish_handoff_notice(&handoff);
Ok(handoff)
}
pub async fn run_reconnect_loop(self: Arc<Self>) -> Result<()> {
let mut rx = self
.broken_rx
.write()
.await
.take()
.ok_or_else(|| Error::Secure("reconnect loop already started".into()))?;
let mut backoff = self.cfg.reconnect_backoff_initial;
while let Some(broken) = rx.recv().await {
warn!(
peer = %broken.peer_addr,
prefer_addr_only = broken.prefer_addr_only,
"session broken; reconnecting"
);
let _ = self.cfg.peer_store.remember(broken.peer_addr);
let mut attempts_at_max = 0u8;
loop {
let result = if broken.prefer_addr_only {
let name = ip_server_name(broken.peer_addr)?;
self.dial_and_handshake(broken.peer_addr, name, false)
.await
.inspect(|_handoff| {
let _ = self.cfg.peer_store.remember(broken.peer_addr);
})
} else {
self.reconnect_peer(broken.peer_addr).await
};
match result {
Ok(handoff) => {
info!(peer = %handoff.peer_addr, "reconnect succeeded");
self.policy.on_handoff(&handoff);
self.publish_handoff_notice(&handoff);
if let Some(tx) = self.handoff_tx.read().await.as_ref() {
let _ = tx.send(handoff);
}
backoff = self.cfg.reconnect_backoff_initial;
break;
}
Err(err) => {
warn!(%err, retry_secs = backoff.as_secs(), "reconnect failed");
tokio::time::sleep(backoff).await;
if backoff >= self.cfg.reconnect_backoff_max && broken.prefer_addr_only {
attempts_at_max = attempts_at_max.saturating_add(1);
if attempts_at_max >= 3 {
warn!(
peer = %broken.peer_addr,
"prefer-addr reconnect gave up; healer may retry later"
);
backoff = self.cfg.reconnect_backoff_initial;
break;
}
}
backoff = (backoff * 2).min(self.cfg.reconnect_backoff_max);
}
}
}
}
Ok(())
}
async fn reconnect_peer(self: &Arc<Self>, preferred: SocketAddr) -> Result<Handoff> {
if let Ok(handoff) = self
.dial_and_handshake(preferred, ip_server_name(preferred)?, true)
.await
{
let _ = self.cfg.peer_store.remember(preferred);
return Ok(handoff);
}
self.connect().await
}
async fn dial_and_handshake(
self: &Arc<Self>,
addr: SocketAddr,
server_name: ServerName<'static>,
enforce_dial_gate: bool,
) -> Result<Handoff> {
if enforce_dial_gate {
self.dial_gate.ensure_dialable(addr)?;
}
let stream = tokio::time::timeout(self.cfg.connect_timeout, TcpStream::connect(addr))
.await
.map_err(|_| Error::Secure(format!("tcp connect timed out for {addr}")))?
.map_err(Error::from)?;
let connector = TlsConnector::from(Arc::new(self.tls.client_config()?));
let mut tls = tokio::time::timeout(
self.cfg.tls_timeout,
connector.connect(server_name, stream),
)
.await
.map_err(|_| Error::Secure(format!("mTLS client handshake timed out for {addr}")))?
.map_err(|err| {
Error::Secure(format!(
"mTLS client handshake for {addr}: {err} \
(IP dials require an IP SAN; use dial_hostname for DNS SAN certs)"
))
})?;
let peer_certs = peer_certs_from_client(&tls);
let (approval, credentials) = tokio::time::timeout(
self.cfg.handshake_timeout,
complete_session(
&self.policy,
&mut tls,
addr,
peer_certs,
self.cfg.handshake_key.as_deref().map(|v| v.as_slice()),
true,
),
)
.await
.map_err(|_| Error::Secure(format!("secure session handshake timed out for {addr}")))??;
Ok(Handoff {
peer_addr: addr,
peer_label: approval.peer_label.clone(),
local_identity: self.policy.identity(),
approval,
credentials,
transport: SecureTransport::Client(tls),
})
}
async fn accept_and_handshake(
self: &Arc<Self>,
stream: TcpStream,
peer_addr: SocketAddr,
) -> Result<Handoff> {
let acceptor = TlsAcceptor::from(Arc::new(self.tls.server_config()?));
let mut tls = tokio::time::timeout(self.cfg.tls_timeout, acceptor.accept(stream))
.await
.map_err(|_| {
Error::Secure(format!("mTLS server handshake timed out for {peer_addr}"))
})?
.map_err(|err| Error::Secure(format!("mTLS server handshake: {err}")))?;
let peer_certs = peer_certs_from_server(&tls);
let (approval, credentials) = tokio::time::timeout(
self.cfg.handshake_timeout,
complete_session(
&self.policy,
&mut tls,
peer_addr,
peer_certs,
self.cfg.handshake_key.as_deref().map(|v| v.as_slice()),
false,
),
)
.await
.map_err(|_| {
Error::Secure(format!(
"secure session handshake timed out for {peer_addr}"
))
})??;
Ok(Handoff {
peer_addr,
peer_label: approval.peer_label.clone(),
local_identity: self.policy.identity(),
approval,
credentials,
transport: SecureTransport::Server(tls),
})
}
}
async fn complete_session<S>(
policy: &PolicyHandle,
stream: &mut S,
peer_addr: SocketAddr,
peer_certs: Vec<CertificateDer<'static>>,
handshake_key: Option<&[u8]>,
initiator: bool,
) -> Result<(Approval, CredentialBundle)>
where
S: AsyncRead + AsyncWrite + Unpin,
{
let local_offer = policy.handshake_offer()?;
let peer_offer = if initiator {
write_frame(stream, &local_offer.payload).await?;
let remote = read_frame(stream).await?;
HandshakeOffer { payload: remote }
} else {
let remote = read_frame(stream).await?;
write_frame(stream, &local_offer.payload).await?;
HandshakeOffer { payload: remote }
};
let approval = policy.approve_peer(&peer_offer, &peer_certs)?;
let cert_ders: Vec<Vec<u8>> = peer_certs.iter().map(|c| c.as_ref().to_vec()).collect();
let ratchet_ctx = RatchetContext {
local_identity: policy.identity(),
peer_addr,
peer_offer: peer_offer.payload.clone(),
network_dht_key: policy.network_dht_key(),
peer_certificate_der: cert_ders,
};
policy.ratchet(&ratchet_ctx)?;
let salt = {
use sha2::{Digest, Sha256};
let mut hasher = Sha256::new();
hasher.update(policy.network_dht_key());
let mut parts = [&local_offer.payload, &peer_offer.payload];
parts.sort();
hasher.update(parts[0]);
hasher.update(parts[1]);
hasher.finalize().to_vec()
};
let key = handshake_key.ok_or_else(|| {
Error::Secure("handshake key required for sealed credential channel".into())
})?;
let mut channel = CredentialChannel::new(stream, key, &salt, initiator)?;
let credentials = {
let local = policy.local_credentials()?;
let remote_plain = if initiator {
channel.send_sealed(&local.bytes).await?;
channel.recv_sealed().await?
} else {
let remote = channel.recv_sealed().await?;
channel.send_sealed(&local.bytes).await?;
remote
};
match policy.credential_mode() {
CredentialMode::SealedChannel => CredentialBundle::new(remote_plain),
CredentialMode::HostManaged => policy.accept_remote_credentials(&remote_plain)?,
}
};
Ok((approval, credentials))
}
fn ip_server_name(addr: SocketAddr) -> Result<ServerName<'static>> {
match addr.ip() {
std::net::IpAddr::V4(v4) => Ok(ServerName::IpAddress(v4.into())),
std::net::IpAddr::V6(v6) => Ok(ServerName::IpAddress(v6.into())),
}
}
fn peer_certs_from_client(
tls: &tokio_rustls::client::TlsStream<TcpStream>,
) -> Vec<CertificateDer<'static>> {
tls.get_ref()
.1
.peer_certificates()
.map(|certs| certs.iter().map(|c| c.clone().into_owned()).collect())
.unwrap_or_default()
}
fn peer_certs_from_server(
tls: &tokio_rustls::server::TlsStream<TcpStream>,
) -> Vec<CertificateDer<'static>> {
tls.get_ref()
.1
.peer_certificates()
.map(|certs| certs.iter().map(|c| c.clone().into_owned()).collect())
.unwrap_or_default()
}