#![allow(unused_imports)]
use super::*;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HandshakeRole {
Initiator,
Responder,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HandshakePhase {
Initial,
Msg1Sent,
Msg1Received,
Msg2Sent,
Msg2Received,
Completed,
Terminated,
}
pub struct HandshakePayloadResult {
pub remote_did: Option<String>,
pub remote_ed25519_public: Option<[u8; 32]>,
pub remote_x25519_public: Option<[u8; 32]>,
pub extra_payload: Vec<u8>,
}
pub struct NoiseHandshakeState {
pub role: HandshakeRole,
pub local_identity: SovereignNodeIdentity,
pub symmetric: NoiseSymmetricState,
pub exchange_ed25519: bool,
phase: HandshakePhase,
local_ephemeral_secret: Option<X25519StaticSecret>,
local_ephemeral_public: Option<[u8; 32]>,
remote_ephemeral_public: Option<[u8; 32]>,
remote_static_x25519: Option<[u8; 32]>,
remote_static_ed25519: Option<[u8; 32]>,
remote_did: Option<String>,
session: Option<NoiseTransportSession>,
}
impl NoiseHandshakeState {
pub fn new(role: HandshakeRole, local_identity: SovereignNodeIdentity, exchange_ed25519: bool) -> Self {
Self {
role,
local_identity,
symmetric: NoiseSymmetricState::new(NOISE_PROTOCOL_NAME),
exchange_ed25519,
phase: HandshakePhase::Initial,
local_ephemeral_secret: None,
local_ephemeral_public: None,
remote_ephemeral_public: None,
remote_static_x25519: None,
remote_static_ed25519: None,
remote_did: None,
session: None,
}
}
pub fn phase(&self) -> HandshakePhase {
self.phase
}
pub fn remote_did(&self) -> Option<&str> {
self.remote_did.as_deref()
}
pub fn write_message1(&mut self, extra_payload: &[u8]) -> Result<Vec<u8>, String> {
if self.role != HandshakeRole::Initiator || self.phase != HandshakePhase::Initial {
return Err("Cannot write message 1 in current phase".into());
}
let mut rng = OsRng;
let mut seed = [0u8; 32];
rand::RngCore::fill_bytes(&mut rng, &mut seed);
let secret = X25519StaticSecret::from(seed);
let pubkey = X25519PublicKey::from(&secret).to_bytes();
self.symmetric.mix_hash(&pubkey);
let payload_ct = self.symmetric.encrypt_and_hash(extra_payload)?;
let mut msg1 = Vec::with_capacity(32 + payload_ct.len());
msg1.extend_from_slice(&pubkey);
msg1.extend_from_slice(&payload_ct);
self.local_ephemeral_secret = Some(secret);
self.local_ephemeral_public = Some(pubkey);
self.phase = HandshakePhase::Msg1Sent;
Ok(msg1)
}
pub fn read_message1(&mut self, msg1: &[u8]) -> Result<HandshakePayloadResult, String> {
if self.role != HandshakeRole::Responder || self.phase != HandshakePhase::Initial {
self.terminate_and_zeroize();
return Err("Cannot read message 1 in current phase".into());
}
if msg1.len() < 32 {
self.terminate_and_zeroize();
return Err("Message 1 too short".into());
}
let mut remote_e = [0u8; 32];
remote_e.copy_from_slice(&msg1[..32]);
self.symmetric.mix_hash(&remote_e);
let extra_payload = match self.symmetric.decrypt_and_hash(&msg1[32..]) {
Ok(pt) => pt,
Err(e) => {
self.terminate_and_zeroize();
return Err(e);
}
};
self.remote_ephemeral_public = Some(remote_e);
self.phase = HandshakePhase::Msg1Received;
Ok(HandshakePayloadResult {
remote_did: None,
remote_ed25519_public: None,
remote_x25519_public: None,
extra_payload,
})
}
pub fn write_message2(&mut self, extra_payload: &[u8]) -> Result<Vec<u8>, String> {
if self.role != HandshakeRole::Responder || self.phase != HandshakePhase::Msg1Received {
return Err("Cannot write message 2 in current phase".into());
}
let remote_e_bytes = match self.remote_ephemeral_public {
Some(b) => b,
None => return Err("Missing remote ephemeral public key".into()),
};
let mut rng = OsRng;
let mut seed = [0u8; 32];
rand::RngCore::fill_bytes(&mut rng, &mut seed);
let secret = X25519StaticSecret::from(seed);
let pubkey = X25519PublicKey::from(&secret).to_bytes();
self.symmetric.mix_hash(&pubkey);
let remote_e = X25519PublicKey::from(remote_e_bytes);
let ee = secret.diffie_hellman(&remote_e);
self.symmetric.mix_key(ee.as_bytes());
let encrypted_sr = self.symmetric.encrypt_and_hash(&self.local_identity.x25519_public_key)?;
let es = self.local_identity.x25519_secret.diffie_hellman(&remote_e);
self.symmetric.mix_key(es.as_bytes());
let payload = if self.exchange_ed25519 {
let sig = self.local_identity.sign(&self.symmetric.h);
let mut p = Vec::with_capacity(32 + 64 + extra_payload.len());
p.extend_from_slice(&self.local_identity.ed25519_public_key);
p.extend_from_slice(&sig);
p.extend_from_slice(extra_payload);
p
} else {
extra_payload.to_vec()
};
let encrypted_payload = self.symmetric.encrypt_and_hash(&payload)?;
let mut msg2 = Vec::with_capacity(32 + encrypted_sr.len() + encrypted_payload.len());
msg2.extend_from_slice(&pubkey);
msg2.extend_from_slice(&encrypted_sr);
msg2.extend_from_slice(&encrypted_payload);
self.local_ephemeral_secret = Some(secret);
self.local_ephemeral_public = Some(pubkey);
self.phase = HandshakePhase::Msg2Sent;
Ok(msg2)
}
pub fn read_message2(&mut self, msg2: &[u8]) -> Result<HandshakePayloadResult, String> {
if self.role != HandshakeRole::Initiator || self.phase != HandshakePhase::Msg1Sent {
self.terminate_and_zeroize();
return Err("Cannot read message 2 in current phase".into());
}
if msg2.len() < 32 + 32 + NOISE_TAGLEN {
self.terminate_and_zeroize();
return Err("Message 2 too short".into());
}
let local_e_secret = match self.local_ephemeral_secret.as_ref() {
Some(s) => s,
None => return Err("Missing local ephemeral secret".into()),
};
let mut remote_e = [0u8; 32];
remote_e.copy_from_slice(&msg2[..32]);
self.symmetric.mix_hash(&remote_e);
let remote_e_pub = X25519PublicKey::from(remote_e);
let ee = local_e_secret.diffie_hellman(&remote_e_pub);
self.symmetric.mix_key(ee.as_bytes());
let sr_pub = match self.symmetric.decrypt_and_hash(&msg2[32..32 + 48]) {
Ok(pt) => pt,
Err(e) => {
self.terminate_and_zeroize();
return Err(e);
}
};
let mut sr_arr = [0u8; 32];
sr_arr.copy_from_slice(&sr_pub);
let sr_xpub = X25519PublicKey::from(sr_arr);
let es = local_e_secret.diffie_hellman(&sr_xpub);
self.symmetric.mix_key(es.as_bytes());
let h_snapshot = self.symmetric.h;
let payload_pt = match self.symmetric.decrypt_and_hash(&msg2[80..]) {
Ok(pt) => pt,
Err(e) => {
self.terminate_and_zeroize();
return Err(e);
}
};
let mut remote_did = None;
let mut remote_ed25519 = None;
let extra_payload = if self.exchange_ed25519 {
if payload_pt.len() < 96 {
self.terminate_and_zeroize();
return Err("Missing Ed25519 authentication in payload".into());
}
let mut ed_pub = [0u8; 32];
ed_pub.copy_from_slice(&payload_pt[..32]);
let mut sig = [0u8; 64];
sig.copy_from_slice(&payload_pt[32..96]);
if !SovereignNodeIdentity::verify_signature(&ed_pub, &h_snapshot, &sig) {
self.terminate_and_zeroize();
return Err("Responder Ed25519 signature verification failed (INV-257-01)".into());
}
let did_str = format!("did:pkc:{}", bs58::encode(&ed_pub).into_string());
remote_did = Some(did_str.clone());
self.remote_did = Some(did_str);
remote_ed25519 = Some(ed_pub);
self.remote_static_ed25519 = Some(ed_pub);
payload_pt[96..].to_vec()
} else {
payload_pt
};
self.remote_ephemeral_public = Some(remote_e);
self.remote_static_x25519 = Some(sr_arr);
self.phase = HandshakePhase::Msg2Received;
Ok(HandshakePayloadResult {
remote_did,
remote_ed25519_public: remote_ed25519,
remote_x25519_public: Some(sr_arr),
extra_payload,
})
}
pub fn write_message3(&mut self, extra_payload: &[u8]) -> Result<Vec<u8>, String> {
if self.role != HandshakeRole::Initiator || self.phase != HandshakePhase::Msg2Received {
return Err("Cannot write message 3 in current phase".into());
}
let remote_e_bytes = match self.remote_ephemeral_public {
Some(b) => b,
None => return Err("Missing remote ephemeral public key".into()),
};
let encrypted_si = self.symmetric.encrypt_and_hash(&self.local_identity.x25519_public_key)?;
let remote_e = X25519PublicKey::from(remote_e_bytes);
let se = self.local_identity.x25519_secret.diffie_hellman(&remote_e);
self.symmetric.mix_key(se.as_bytes());
let payload = if self.exchange_ed25519 {
let sig = self.local_identity.sign(&self.symmetric.h);
let mut p = Vec::with_capacity(32 + 64 + extra_payload.len());
p.extend_from_slice(&self.local_identity.ed25519_public_key);
p.extend_from_slice(&sig);
p.extend_from_slice(extra_payload);
p
} else {
extra_payload.to_vec()
};
let encrypted_payload = self.symmetric.encrypt_and_hash(&payload)?;
let mut msg3 = Vec::with_capacity(encrypted_si.len() + encrypted_payload.len());
msg3.extend_from_slice(&encrypted_si);
msg3.extend_from_slice(&encrypted_payload);
let (c1, c2) = self.symmetric.split();
let remote_pub = self.remote_static_x25519.unwrap_or([0u8; 32]);
let remote_did = self.remote_did.clone().unwrap_or_else(|| {
format!("did:pkc:{}", bs58::encode(&remote_pub).into_string())
});
self.session = Some(NoiseTransportSession::new(
c1,
c2,
self.symmetric.h,
self.local_identity.clone(),
remote_pub,
remote_did,
));
self.phase = HandshakePhase::Completed;
Ok(msg3)
}
pub fn read_message3(&mut self, msg3: &[u8]) -> Result<HandshakePayloadResult, String> {
if self.role != HandshakeRole::Responder || self.phase != HandshakePhase::Msg2Sent {
self.terminate_and_zeroize();
return Err("Cannot read message 3 in current phase".into());
}
if msg3.len() < 48 {
self.terminate_and_zeroize();
return Err("Message 3 too short".into());
}
let local_e_secret = match self.local_ephemeral_secret.as_ref() {
Some(s) => s,
None => return Err("Missing local ephemeral secret".into()),
};
let si_pub = match self.symmetric.decrypt_and_hash(&msg3[..48]) {
Ok(pt) => pt,
Err(e) => {
self.terminate_and_zeroize();
return Err(e);
}
};
let mut si_arr = [0u8; 32];
si_arr.copy_from_slice(&si_pub);
let si_xpub = X25519PublicKey::from(si_arr);
let se = local_e_secret.diffie_hellman(&si_xpub);
self.symmetric.mix_key(se.as_bytes());
let h_snapshot = self.symmetric.h;
let payload_pt = match self.symmetric.decrypt_and_hash(&msg3[48..]) {
Ok(pt) => pt,
Err(e) => {
self.terminate_and_zeroize();
return Err(e);
}
};
let mut remote_did = None;
let mut remote_ed25519 = None;
let extra_payload = if self.exchange_ed25519 {
if payload_pt.len() < 96 {
self.terminate_and_zeroize();
return Err("Missing Ed25519 authentication in payload".into());
}
let mut ed_pub = [0u8; 32];
ed_pub.copy_from_slice(&payload_pt[..32]);
let mut sig = [0u8; 64];
sig.copy_from_slice(&payload_pt[32..96]);
if !SovereignNodeIdentity::verify_signature(&ed_pub, &h_snapshot, &sig) {
self.terminate_and_zeroize();
return Err("Initiator Ed25519 signature verification failed (INV-257-01)".into());
}
let did_str = format!("did:pkc:{}", bs58::encode(&ed_pub).into_string());
remote_did = Some(did_str.clone());
self.remote_did = Some(did_str);
remote_ed25519 = Some(ed_pub);
self.remote_static_ed25519 = Some(ed_pub);
payload_pt[96..].to_vec()
} else {
payload_pt
};
self.remote_static_x25519 = Some(si_arr);
let (c1, c2) = self.symmetric.split();
let remote_pub = si_arr;
let final_remote_did = self.remote_did.clone().unwrap_or_else(|| {
format!("did:pkc:{}", bs58::encode(&remote_pub).into_string())
});
self.session = Some(NoiseTransportSession::new(
c2, c1, self.symmetric.h,
self.local_identity.clone(),
remote_pub,
final_remote_did,
));
self.phase = HandshakePhase::Completed;
Ok(HandshakePayloadResult {
remote_did,
remote_ed25519_public: remote_ed25519,
remote_x25519_public: Some(si_arr),
extra_payload,
})
}
pub fn into_session(mut self) -> Result<NoiseTransportSession, String> {
self.session.take().ok_or_else(|| "Session not established".into())
}
pub fn terminate_and_zeroize(&mut self) {
self.phase = HandshakePhase::Terminated;
self.symmetric.zeroize();
self.local_ephemeral_secret = None;
self.local_ephemeral_public = None;
if let Some(ref mut sess) = self.session {
sess.terminate_and_zeroize();
}
}
}