use zeroize::Zeroizing;
use crate::error::{LinkError, Result};
use crate::keys::{KEY_LEN, PublicKey, StaticKeypair};
use crate::message::Message;
use crate::pairing::{PSK_LEN, PairingOffer};
pub const PAIRING_PATTERN: &str = "Noise_IKpsk2_25519_ChaChaPoly_BLAKE2s";
pub const RECONNECT_PATTERN: &str = "Noise_KK_25519_ChaChaPoly_BLAKE2s";
pub const MAX_NOISE_MESSAGE: usize = 65_535;
pub const MAX_PLAINTEXT: usize = MAX_NOISE_MESSAGE - 16;
pub const MAX_HANDSHAKE_PAYLOAD: usize = 1_024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HandshakeKind {
Pairing,
Reconnect,
}
impl HandshakeKind {
fn tag(self) -> u8 {
match self {
HandshakeKind::Pairing => b'P',
HandshakeKind::Reconnect => b'R',
}
}
}
fn prologue(version: u16, kind: HandshakeKind) -> [u8; 9] {
let mut out = [0u8; 9];
out[..6].copy_from_slice(b"iwlink");
out[6..8].copy_from_slice(&version.to_be_bytes());
out[8] = kind.tag();
out
}
fn params(pattern: &str) -> Result<snow::params::NoiseParams> {
pattern
.parse()
.map_err(|_| LinkError::Handshake("noise parameters".into()))
}
pub struct Handshake {
state: snow::HandshakeState,
kind: HandshakeKind,
version: u16,
}
impl Handshake {
pub fn pairing_initiator(
local: &StaticKeypair,
offer: &PairingOffer,
version: u16,
now: i64,
) -> Result<Handshake> {
if offer.is_expired(now) {
return Err(LinkError::OfferExpired);
}
if version > offer.version || !crate::VersionRange::LOCAL.contains(version) {
return Err(LinkError::VersionMismatch);
}
let kind = HandshakeKind::Pairing;
let prologue = prologue(version, kind);
let state = snow::Builder::new(params(PAIRING_PATTERN)?)
.prologue(&prologue)?
.local_private_key(local.secret_bytes())?
.remote_public_key(offer.helper_public.as_bytes())?
.psk(2, &offer.psk)?
.build_initiator()?;
Ok(Handshake {
state,
kind,
version,
})
}
pub fn pairing_responder(
local: &StaticKeypair,
psk: &[u8; PSK_LEN],
version: u16,
) -> Result<Handshake> {
if !crate::VersionRange::LOCAL.contains(version) {
return Err(LinkError::VersionMismatch);
}
let kind = HandshakeKind::Pairing;
let prologue = prologue(version, kind);
let state = snow::Builder::new(params(PAIRING_PATTERN)?)
.prologue(&prologue)?
.local_private_key(local.secret_bytes())?
.psk(2, psk)?
.build_responder()?;
Ok(Handshake {
state,
kind,
version,
})
}
pub fn reconnect_initiator(
local: &StaticKeypair,
helper: &PublicKey,
version: u16,
) -> Result<Handshake> {
Self::reconnect(local, helper, version, true)
}
pub fn reconnect_responder(
local: &StaticKeypair,
phone: &PublicKey,
version: u16,
) -> Result<Handshake> {
Self::reconnect(local, phone, version, false)
}
fn reconnect(
local: &StaticKeypair,
remote: &PublicKey,
version: u16,
initiator: bool,
) -> Result<Handshake> {
if !crate::VersionRange::LOCAL.contains(version) {
return Err(LinkError::VersionMismatch);
}
let kind = HandshakeKind::Reconnect;
let prologue = prologue(version, kind);
let builder = snow::Builder::new(params(RECONNECT_PATTERN)?)
.prologue(&prologue)?
.local_private_key(local.secret_bytes())?
.remote_public_key(remote.as_bytes())?;
let state = if initiator {
builder.build_initiator()?
} else {
builder.build_responder()?
};
Ok(Handshake {
state,
kind,
version,
})
}
pub fn kind(&self) -> HandshakeKind {
self.kind
}
pub fn version(&self) -> u16 {
self.version
}
pub fn is_my_turn(&self) -> bool {
self.state.is_my_turn()
}
pub fn is_finished(&self) -> bool {
self.state.is_handshake_finished()
}
pub fn write(&mut self, payload: &[u8]) -> Result<Vec<u8>> {
if payload.len() > MAX_HANDSHAKE_PAYLOAD {
return Err(LinkError::TooLarge);
}
let mut out = vec![0u8; MAX_NOISE_MESSAGE];
let n = self.state.write_message(payload, &mut out)?;
out.truncate(n);
Ok(out)
}
pub fn read(&mut self, message: &[u8]) -> Result<Vec<u8>> {
if message.len() > MAX_NOISE_MESSAGE {
return Err(LinkError::TooLarge);
}
let mut out = vec![0u8; MAX_NOISE_MESSAGE];
let n = self.state.read_message(message, &mut out)?;
out.truncate(n);
if out.len() > MAX_HANDSHAKE_PAYLOAD {
return Err(LinkError::TooLarge);
}
Ok(out)
}
pub fn finish(self) -> Result<Established> {
if !self.state.is_handshake_finished() {
return Err(LinkError::Handshake("handshake not finished".into()));
}
let remote_static = self
.state
.get_remote_static()
.ok_or_else(|| LinkError::Handshake("no remote static key".into()))
.and_then(PublicKey::from_slice)?;
let hash = self.state.get_handshake_hash();
let handshake_hash: [u8; KEY_LEN] = hash
.get(..KEY_LEN)
.and_then(|h| h.try_into().ok())
.ok_or_else(|| LinkError::Handshake("handshake hash length".into()))?;
let version = self.version;
let transport = self.state.into_transport_mode()?;
Ok(Established {
session: Session { transport, version },
remote_static,
handshake_hash,
})
}
}
impl std::fmt::Debug for Handshake {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Handshake")
.field("kind", &self.kind)
.field("version", &self.version)
.field("finished", &self.is_finished())
.finish_non_exhaustive()
}
}
#[derive(Debug)]
pub struct Established {
pub session: Session,
pub remote_static: PublicKey,
pub handshake_hash: [u8; KEY_LEN],
}
pub struct Session {
transport: snow::TransportState,
version: u16,
}
impl Session {
pub fn version(&self) -> u16 {
self.version
}
pub fn seal(&mut self, plaintext: &[u8]) -> Result<Vec<u8>> {
if plaintext.len() > MAX_PLAINTEXT {
return Err(LinkError::TooLarge);
}
let mut out = vec![0u8; plaintext.len() + 16];
let n = self.transport.write_message(plaintext, &mut out)?;
out.truncate(n);
Ok(out)
}
pub fn open(&mut self, ciphertext: &[u8]) -> Result<Zeroizing<Vec<u8>>> {
if ciphertext.len() > MAX_NOISE_MESSAGE {
return Err(LinkError::TooLarge);
}
if ciphertext.len() < 16 {
return Err(LinkError::Decrypt);
}
let mut out = Zeroizing::new(vec![0u8; ciphertext.len()]);
let n = self
.transport
.read_message(ciphertext, &mut out)
.map_err(|_| LinkError::Decrypt)?;
out.truncate(n);
Ok(out)
}
pub fn seal_message(&mut self, message: &Message) -> Result<Vec<u8>> {
let plaintext = message.encode()?;
self.seal(&plaintext)
}
pub fn open_message(&mut self, ciphertext: &[u8]) -> Result<Message> {
let plaintext = self.open(ciphertext)?;
Message::decode(&plaintext)
}
}
impl std::fmt::Debug for Session {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Session")
.field("version", &self.version)
.finish_non_exhaustive()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::pairing::{HelperId, confirmation_code};
const NOW: i64 = 10_000;
fn run(mut phone: Handshake, mut helper: Handshake) -> Result<(Established, Established)> {
let m1 = phone.write(b"phone")?;
assert_eq!(helper.read(&m1)?, b"phone");
let m2 = helper.write(b"helper")?;
assert_eq!(phone.read(&m2)?, b"helper");
Ok((phone.finish()?, helper.finish()?))
}
struct Pairing {
helper_keys: StaticKeypair,
phone_keys: StaticKeypair,
offer: PairingOffer,
}
fn pairing() -> Pairing {
let helper_keys = StaticKeypair::generate().unwrap();
let offer = PairingOffer::create(
HelperId::generate().unwrap(),
helper_keys.public(),
"Mac",
NOW,
)
.unwrap();
Pairing {
helper_keys,
phone_keys: StaticKeypair::generate().unwrap(),
offer,
}
}
#[test]
fn pairing_then_reconnect() {
let p = pairing();
let phone = Handshake::pairing_initiator(&p.phone_keys, &p.offer, 1, NOW).unwrap();
let helper = Handshake::pairing_responder(&p.helper_keys, &p.offer.psk, 1).unwrap();
let (mut a, mut b) = run(phone, helper).unwrap();
assert_eq!(a.remote_static, p.helper_keys.public());
assert_eq!(b.remote_static, p.phone_keys.public());
assert_eq!(
confirmation_code(&a.handshake_hash),
confirmation_code(&b.handshake_hash)
);
let sealed = a.session.seal(b"to helper").unwrap();
assert_eq!(b.session.open(&sealed).unwrap().as_slice(), b"to helper");
let sealed = b.session.seal(b"to phone").unwrap();
assert_eq!(a.session.open(&sealed).unwrap().as_slice(), b"to phone");
let phone =
Handshake::reconnect_initiator(&p.phone_keys, &p.helper_keys.public(), 1).unwrap();
let helper =
Handshake::reconnect_responder(&p.helper_keys, &p.phone_keys.public(), 1).unwrap();
let (mut a, mut b) = run(phone, helper).unwrap();
let sealed = a.session.seal(b"again").unwrap();
assert_eq!(b.session.open(&sealed).unwrap().as_slice(), b"again");
}
#[test]
fn wrong_psk_fails() {
let p = pairing();
let phone = Handshake::pairing_initiator(&p.phone_keys, &p.offer, 1, NOW).unwrap();
let helper = Handshake::pairing_responder(&p.helper_keys, &[0u8; PSK_LEN], 1).unwrap();
assert!(run(phone, helper).is_err());
}
#[test]
fn wrong_helper_key_fails() {
let p = pairing();
let impostor = StaticKeypair::generate().unwrap();
let phone = Handshake::pairing_initiator(&p.phone_keys, &p.offer, 1, NOW).unwrap();
let helper = Handshake::pairing_responder(&impostor, &p.offer.psk, 1).unwrap();
assert!(run(phone, helper).is_err());
}
#[test]
fn expired_offer_is_refused() {
let p = pairing();
let late = p.offer.expires_at;
assert_eq!(
Handshake::pairing_initiator(&p.phone_keys, &p.offer, 1, late).unwrap_err(),
LinkError::OfferExpired
);
}
#[test]
fn reconnect_with_an_unknown_phone_fails() {
let p = pairing();
let stranger = StaticKeypair::generate().unwrap();
let phone = Handshake::reconnect_initiator(&stranger, &p.helper_keys.public(), 1).unwrap();
let helper =
Handshake::reconnect_responder(&p.helper_keys, &p.phone_keys.public(), 1).unwrap();
assert!(run(phone, helper).is_err());
}
#[test]
fn reconnect_to_an_impostor_helper_fails() {
let p = pairing();
let impostor = StaticKeypair::generate().unwrap();
let phone =
Handshake::reconnect_initiator(&p.phone_keys, &p.helper_keys.public(), 1).unwrap();
let helper = Handshake::reconnect_responder(&impostor, &p.phone_keys.public(), 1).unwrap();
assert!(run(phone, helper).is_err());
}
#[test]
fn version_disagreement_fails() {
assert_ne!(
prologue(1, HandshakeKind::Pairing),
prologue(2, HandshakeKind::Pairing)
);
assert_ne!(
prologue(1, HandshakeKind::Pairing),
prologue(1, HandshakeKind::Reconnect)
);
let p = pairing();
assert_eq!(
Handshake::reconnect_initiator(&p.phone_keys, &p.helper_keys.public(), 99).unwrap_err(),
LinkError::VersionMismatch
);
}
#[test]
fn replayed_first_message_gives_the_attacker_nothing() {
let p = pairing();
let mut phone =
Handshake::reconnect_initiator(&p.phone_keys, &p.helper_keys.public(), 1).unwrap();
let m1 = phone.write(b"").unwrap();
let mut helper =
Handshake::reconnect_responder(&p.helper_keys, &p.phone_keys.public(), 1).unwrap();
helper.read(&m1).unwrap();
let m2 = helper.write(b"").unwrap();
let mut second_phone =
Handshake::reconnect_initiator(&p.phone_keys, &p.helper_keys.public(), 1).unwrap();
second_phone.write(b"").unwrap();
assert!(
second_phone.read(&m2).is_err(),
"a different session must not accept m2"
);
}
fn sessions() -> (Session, Session) {
let p = pairing();
let phone = Handshake::pairing_initiator(&p.phone_keys, &p.offer, 1, NOW).unwrap();
let helper = Handshake::pairing_responder(&p.helper_keys, &p.offer.psk, 1).unwrap();
let (a, b) = run(phone, helper).unwrap();
(a.session, b.session)
}
#[test]
fn tampered_transport_message_fails() {
let (mut a, mut b) = sessions();
let mut sealed = a.seal(b"hello").unwrap();
sealed[0] ^= 1;
assert_eq!(b.open(&sealed).unwrap_err(), LinkError::Decrypt);
}
#[test]
fn reordered_transport_messages_fail() {
let (mut a, mut b) = sessions();
let _first = a.seal(b"one").unwrap();
let second = a.seal(b"two").unwrap();
assert_eq!(b.open(&second).unwrap_err(), LinkError::Decrypt);
}
#[test]
fn replayed_transport_message_fails() {
let (mut a, mut b) = sessions();
let sealed = a.seal(b"once").unwrap();
b.open(&sealed).unwrap();
assert_eq!(b.open(&sealed).unwrap_err(), LinkError::Decrypt);
}
#[test]
fn messages_round_trip_through_a_session() {
let (mut a, mut b) = sessions();
let sealed = a.seal_message(&Message::Ping).unwrap();
assert_eq!(b.open_message(&sealed).unwrap(), Message::Ping);
}
#[test]
fn oversized_input_is_refused() {
let p = pairing();
let mut phone = Handshake::pairing_initiator(&p.phone_keys, &p.offer, 1, NOW).unwrap();
assert_eq!(
phone
.write(&vec![0u8; MAX_HANDSHAKE_PAYLOAD + 1])
.unwrap_err(),
LinkError::TooLarge
);
}
#[test]
fn finish_before_the_end_is_refused() {
let p = pairing();
let phone = Handshake::pairing_initiator(&p.phone_keys, &p.offer, 1, NOW).unwrap();
assert!(phone.finish().is_err());
}
}