use crate::error::{NetError, Result};
use crate::node::{Message, Node};
use crate::profile::Profile;
use libp2p::{Multiaddr, PeerId};
use weirdnet_keys::{Key32, Sealed};
use zeroize::Zeroizing;
pub trait Envelope: Message {
fn sealed(exchange: String, sealed: Sealed) -> Self;
}
pub trait Reply: Message {
fn sealed(sealed: Sealed) -> Self;
fn into_sealed(self) -> std::result::Result<Sealed, Self>;
}
pub enum Answered<R> {
Opened(Zeroizing<Vec<u8>>),
Other(R),
}
pub struct Exchange<'a> {
pub id: &'a str,
pub key: &'a Key32,
pub peer: PeerId,
}
pub fn call<Q: Envelope, R: Reply>(p: &Profile, node: &Node<Q, R>, x: &Exchange, addrs: &[Multiaddr], plain: &[u8]) -> Result<Answered<R>> {
let me = node.peer_id();
let sealed = p.seal_msg(x.key, x.id, &me, &x.peer, plain)?;
Ok(match node.request(x.peer, addrs, Q::sealed(x.id.to_string(), sealed))?.into_sealed() {
Ok(s) => Answered::Opened(p.open_msg(x.key, x.id, &x.peer, &me, &s)?),
Err(other) => Answered::Other(other),
})
}
pub trait Exchanges {
type Exchange;
type Error: From<NetError>;
fn exchange(&self, id: &str) -> std::result::Result<Option<Self::Exchange>, Self::Error>;
fn active(x: &Self::Exchange) -> bool;
fn peer(x: &Self::Exchange) -> Option<&str>;
fn key(&self, x: &Self::Exchange) -> std::result::Result<Option<Key32>, Self::Error>;
}
pub fn serve<S: Exchanges>(
p: &Profile,
store: &mut S,
local: &PeerId,
from: &PeerId,
exchange: &str,
sealed: &Sealed,
answer: impl FnOnce(&mut S, &S::Exchange, &[u8]) -> std::result::Result<Vec<u8>, S::Error>,
) -> std::result::Result<Sealed, S::Error> {
let x = store.exchange(exchange)?.ok_or_else(|| NetError::invalid("exchange", "unknown exchange"))?;
if !S::active(&x) {
return Err(NetError::invalid("exchange", "this exchange is not active (revoked or never completed)").into());
}
if S::peer(&x) != Some(&from.to_string()) {
return Err(NetError::invalid("exchange", "this exchange belongs to another node").into());
}
let id = exchange.to_string();
let key = store.key(&x)?.ok_or_else(|| NetError::invalid("exchange", "no key"))?;
let plain = p.open_msg(&key, &id, from, local, sealed)?;
let out = answer(store, &x, &plain)?;
Ok(p.seal_msg(&key, &id, local, from, &out)?)
}
use chacha20poly1305::aead::{Aead, KeyInit, Payload};
use chacha20poly1305::{XChaCha20Poly1305, XNonce};
use futures::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
const MAGIC: &[u8; 5] = b"WNSS1";
const OK: u8 = 0;
const REFUSED: u8 = 1;
const KIND_DATA: u8 = 0;
const KIND_FIN: u8 = 1;
const TAG: usize = 16;
pub const MAX_SEALED_FRAME: usize = 64 * 1024;
pub struct SealedStream<S> {
inner: S,
id: [u8; 32],
label: String,
send: XChaCha20Poly1305,
recv: XChaCha20Poly1305,
sent: u64,
got: u64,
done_writing: bool,
done_reading: bool,
}
impl<S> std::fmt::Debug for SealedStream<S> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SealedStream").field("sent", &self.sent).field("got", &self.got).finish()
}
}
fn stream_label(p: &Profile) -> String {
format!("{}/stream", p.msg_aad)
}
fn direction_key(label: &str, key: &Key32, id: &[u8; 32], exchange: &str, from: &PeerId, to: &PeerId) -> Result<XChaCha20Poly1305> {
let info = format!("{label}/key|{exchange}|{from}|{to}");
let k = weirdnet_keys::kdf::hkdf(&key.0, Some(id), info.as_bytes())?;
Ok(XChaCha20Poly1305::new((&k.0).into()))
}
fn io_err(e: std::io::Error) -> NetError {
NetError::Network(format!("sealed stream: {e}"))
}
fn crypto(m: &str) -> NetError {
NetError::Crypto(format!("sealed stream: {m}"))
}
impl<S> SealedStream<S> {
fn new(p: &Profile, inner: S, key: &Key32, id: [u8; 32], exchange: &str, local: &PeerId, peer: &PeerId) -> Result<Self> {
let label = stream_label(p);
Ok(Self {
send: direction_key(&label, key, &id, exchange, local, peer)?,
recv: direction_key(&label, key, &id, exchange, peer, local)?,
inner,
id,
label,
sent: 0,
got: 0,
done_writing: false,
done_reading: false,
})
}
fn aad(&self, seq: u64, kind: u8) -> Vec<u8> {
let mut a = Vec::with_capacity(self.label.len() + 42);
a.extend_from_slice(self.label.as_bytes());
a.push(b'|');
a.extend_from_slice(&self.id);
a.extend_from_slice(&seq.to_be_bytes());
a.push(kind);
a
}
fn nonce(seq: u64, kind: u8) -> XNonce {
let mut n = [0u8; 24];
n[..8].copy_from_slice(&seq.to_be_bytes());
n[8] = kind;
*XNonce::from_slice(&n)
}
pub fn id(&self) -> &[u8; 32] {
&self.id
}
pub fn get_ref(&self) -> &S {
&self.inner
}
}
impl<S: AsyncRead + AsyncWrite + Unpin> SealedStream<S> {
async fn frame(&mut self, kind: u8, plain: &[u8]) -> Result<()> {
let seq = self.sent;
let aad = self.aad(seq, kind);
let ct = self.send.encrypt(&Self::nonce(seq, kind), Payload { msg: plain, aad: &aad }).map_err(|_| crypto("sealing failed"))?;
let mut out = Vec::with_capacity(ct.len() + 5);
out.push(kind);
out.extend_from_slice(&(ct.len() as u32).to_be_bytes());
out.extend_from_slice(&ct);
self.inner.write_all(&out).await.map_err(io_err)?;
self.inner.flush().await.map_err(io_err)?;
self.sent += 1;
Ok(())
}
pub async fn send(&mut self, data: &[u8]) -> Result<()> {
if self.done_writing {
return Err(NetError::Network("sealed stream: already finished".into()));
}
for c in data.chunks(MAX_SEALED_FRAME) {
self.frame(KIND_DATA, c).await?;
}
Ok(())
}
pub async fn finish(&mut self) -> Result<()> {
if !self.done_writing {
self.frame(KIND_FIN, &[]).await?;
self.done_writing = true;
let _ = self.inner.close().await;
}
Ok(())
}
pub async fn recv(&mut self) -> Result<Option<Zeroizing<Vec<u8>>>> {
if self.done_reading {
return Ok(None);
}
let mut head = [0u8; 5];
match self.inner.read_exact(&mut head).await {
Ok(()) => {}
Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => return Err(crypto("the stream ended without its sealed end (truncated)")),
Err(e) => return Err(io_err(e)),
}
let kind = head[0];
let n = u32::from_be_bytes(head[1..].try_into().unwrap()) as usize;
if kind > KIND_FIN || !(TAG..=MAX_SEALED_FRAME + TAG).contains(&n) {
return Err(crypto("bad frame"));
}
let mut ct = vec![0u8; n];
self.inner.read_exact(&mut ct).await.map_err(io_err)?;
let seq = self.got;
let aad = self.aad(seq, kind);
let plain = self
.recv
.decrypt(&Self::nonce(seq, kind), Payload { msg: &ct, aad: &aad })
.map_err(|_| crypto("a frame failed to authenticate (tampered, reordered or replayed)"))?;
self.got += 1;
if kind == KIND_FIN {
if !plain.is_empty() {
return Err(crypto("bad end frame"));
}
self.done_reading = true;
return Ok(None);
}
Ok(Some(Zeroizing::new(plain)))
}
pub async fn read_to_end(&mut self) -> Result<Zeroizing<Vec<u8>>> {
let mut all = Zeroizing::new(Vec::new());
while let Some(b) = self.recv().await? {
all.extend_from_slice(&b);
}
Ok(all)
}
}
async fn read_hello<S: AsyncRead + Unpin>(s: &mut S) -> Result<(String, [u8; 16])> {
let mut m = [0u8; 7];
s.read_exact(&mut m).await.map_err(io_err)?;
if &m[..5] != MAGIC {
return Err(NetError::invalid("sealed stream", "not a sealed stream"));
}
let n = u16::from_be_bytes([m[5], m[6]]) as usize;
if n == 0 || n > 256 {
return Err(NetError::invalid("sealed stream", "bad exchange id"));
}
let mut id = vec![0u8; n];
s.read_exact(&mut id).await.map_err(io_err)?;
let mut nonce = [0u8; 16];
s.read_exact(&mut nonce).await.map_err(io_err)?;
let id = String::from_utf8(id).map_err(|_| NetError::invalid("sealed stream", "bad exchange id"))?;
Ok((id, nonce))
}
fn stream_id(opener: &[u8; 16], acceptor: &[u8; 16]) -> [u8; 32] {
let mut id = [0u8; 32];
id[..16].copy_from_slice(opener);
id[16..].copy_from_slice(acceptor);
id
}
pub async fn open_stream<S: AsyncRead + AsyncWrite + Unpin>(p: &Profile, mut s: S, local: &PeerId, x: &Exchange<'_>) -> Result<SealedStream<S>> {
if x.id.is_empty() || x.id.len() > 256 {
return Err(NetError::invalid("sealed stream", "bad exchange id"));
}
let mine: [u8; 16] = weirdnet_keys::random_bytes()?;
let mut hello = Vec::with_capacity(23 + x.id.len());
hello.extend_from_slice(MAGIC);
hello.extend_from_slice(&(x.id.len() as u16).to_be_bytes());
hello.extend_from_slice(x.id.as_bytes());
hello.extend_from_slice(&mine);
s.write_all(&hello).await.map_err(io_err)?;
s.flush().await.map_err(io_err)?;
let mut st = [0u8; 1];
s.read_exact(&mut st).await.map_err(io_err)?;
if st[0] != OK {
return Err(NetError::invalid("sealed stream", "the peer refused the exchange"));
}
let mut theirs = [0u8; 16];
s.read_exact(&mut theirs).await.map_err(io_err)?;
SealedStream::new(p, s, x.key, stream_id(&mine, &theirs), x.id, local, &x.peer)
}
pub async fn serve_stream<S: AsyncRead + AsyncWrite + Unpin, X: Exchanges>(
p: &Profile,
store: &X,
mut s: S,
local: &PeerId,
from: &PeerId,
) -> std::result::Result<(SealedStream<S>, X::Exchange), X::Error> {
let (exchange, theirs) = read_hello(&mut s).await?;
let refuse = |m: &'static str| NetError::invalid("exchange", m);
let check = || -> std::result::Result<(X::Exchange, Key32), X::Error> {
let x = store.exchange(&exchange)?.ok_or_else(|| refuse("unknown exchange"))?;
if !X::active(&x) {
return Err(refuse("this exchange is not active (revoked or never completed)").into());
}
if X::peer(&x) != Some(&from.to_string()) {
return Err(refuse("this exchange belongs to another node").into());
}
let key = store.key(&x)?.ok_or_else(|| refuse("no key"))?;
Ok((x, key))
};
match check() {
Ok((x, key)) => {
let mine: [u8; 16] = weirdnet_keys::random_bytes().map_err(NetError::from)?;
let mut out = vec![OK];
out.extend_from_slice(&mine);
s.write_all(&out).await.map_err(io_err)?;
s.flush().await.map_err(io_err)?;
let ss = SealedStream::new(p, s, &key, stream_id(&theirs, &mine), &exchange, local, from)?;
Ok((ss, x))
}
Err(e) => {
let _ = s.write_all(&[REFUSED]).await;
let _ = s.close().await;
Err(e)
}
}
}
#[cfg(test)]
mod stream_tests {
use super::*;
use crate::WEIRDNET;
use futures::executor::block_on;
use futures::io::Cursor;
use std::pin::Pin;
use std::task::{Context, Poll};
struct Pipe {
r: Cursor<Vec<u8>>,
w: Vec<u8>,
}
impl AsyncRead for Pipe {
fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut [u8]) -> Poll<std::io::Result<usize>> {
Pin::new(&mut self.r).poll_read(cx, buf)
}
}
impl AsyncWrite for Pipe {
fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8]) -> Poll<std::io::Result<usize>> {
Pin::new(&mut self.w).poll_write(cx, buf)
}
fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Poll::Ready(Ok(()))
}
fn poll_close(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Poll::Ready(Ok(()))
}
}
fn pipe(read: Vec<u8>) -> Pipe {
Pipe { r: Cursor::new(read), w: Vec::new() }
}
struct Setup {
key: Key32,
a: PeerId,
b: PeerId,
id: [u8; 32],
}
fn setup() -> Setup {
Setup { key: Key32::random().unwrap(), a: PeerId::random(), b: PeerId::random(), id: [7u8; 32] }
}
fn sent(s: &Setup, msgs: &[&[u8]]) -> Vec<u8> {
let mut tx = SealedStream::new(&WEIRDNET, pipe(vec![]), &s.key, s.id, "ex", &s.a, &s.b).unwrap();
block_on(async {
for m in msgs {
tx.send(m).await.unwrap();
}
tx.finish().await.unwrap();
});
tx.inner.w
}
fn read(s: &Setup, wire: Vec<u8>) -> Result<Vec<u8>> {
let mut rx = SealedStream::new(&WEIRDNET, pipe(wire), &s.key, s.id, "ex", &s.b, &s.a).unwrap();
block_on(rx.read_to_end()).map(|z| z.to_vec())
}
fn frames(wire: &[u8]) -> Vec<Vec<u8>> {
let mut out = Vec::new();
let mut i = 0;
while i < wire.len() {
let n = u32::from_be_bytes(wire[i + 1..i + 5].try_into().unwrap()) as usize;
out.push(wire[i..i + 5 + n].to_vec());
i += 5 + n;
}
out
}
#[test]
fn round_trip_and_large_writes_split() {
let s = setup();
let big = vec![9u8; MAX_SEALED_FRAME * 2 + 5];
let wire = sent(&s, &[b"one", &big]);
assert_eq!(frames(&wire).len(), 1 + 3 + 1);
assert!(!wire.windows(3).any(|w| w == b"one"), "plaintext on the wire");
assert_eq!(read(&s, wire).unwrap(), [b"one".as_slice(), &big].concat());
}
#[test]
fn tampering_reordering_replay_truncation_and_reflection_fail() {
let s = setup();
let wire = sent(&s, &[b"one", b"two", b"three"]);
let f = frames(&wire);
let join = |v: &[&Vec<u8>]| v.iter().flat_map(|x| x.iter().copied()).collect::<Vec<u8>>();
let mut flipped = wire.clone();
flipped[10] ^= 1;
assert!(read(&s, flipped).is_err(), "tampered");
assert!(read(&s, join(&[&f[1], &f[0], &f[2], &f[3]])).is_err(), "reordered");
assert!(read(&s, join(&[&f[0], &f[0], &f[1], &f[2], &f[3]])).is_err(), "replayed");
let e = read(&s, join(&[&f[0], &f[1], &f[2]])).unwrap_err();
assert!(e.to_string().contains("truncated"), "{e}");
assert!(read(&s, join(&[&f[0], &f[3]])).is_err(), "a frame dropped");
let mut me = SealedStream::new(&WEIRDNET, pipe(wire.clone()), &s.key, s.id, "ex", &s.a, &s.b).unwrap();
assert!(block_on(me.recv()).is_err(), "reflected");
let other = Setup { id: [8u8; 32], key: s.key.clone(), ..s };
assert!(read(&other, wire.clone()).is_err(), "another stream");
let s = Setup { id: other.id, ..other };
let mut ex = SealedStream::new(&WEIRDNET, pipe(sent(&s, &[b"x"])), &s.key, s.id, "other", &s.b, &s.a).unwrap();
assert!(block_on(ex.recv()).is_err(), "another exchange");
let w = sent(&s, &[b"x"]);
let mut rx = SealedStream::new(&WEIRDNET, pipe([w.clone(), w].concat()), &s.key, s.id, "ex", &s.b, &s.a).unwrap();
assert_eq!(&block_on(rx.recv()).unwrap().unwrap()[..], b"x");
assert!(block_on(rx.recv()).unwrap().is_none());
assert!(block_on(rx.recv()).unwrap().is_none());
let mut tx = SealedStream::new(&WEIRDNET, pipe(vec![]), &s.key, s.id, "ex", &s.a, &s.b).unwrap();
block_on(tx.finish()).unwrap();
assert!(block_on(tx.send(b"late")).is_err());
}
#[test]
fn oversized_frames_are_refused_before_reading_them() {
let s = setup();
let mut wire = vec![KIND_DATA];
wire.extend(((MAX_SEALED_FRAME + TAG + 1) as u32).to_be_bytes());
assert!(read(&s, wire).unwrap_err().to_string().contains("bad frame"));
}
}