use chacha20poly1305::{
aead::{Aead, KeyInit, Payload},
ChaCha20Poly1305, Key, Nonce,
};
use ed25519_dalek::{Signature, Signer, SigningKey, Verifier, VerifyingKey};
use rand::rngs::OsRng;
use x25519_dalek::{PublicKey as X25519PublicKey, StaticSecret as X25519StaticSecret};
use zeroize::Zeroize;
pub const NOISE_PROTOCOL_NAME: &str = "Noise_XX_25519_ChaChaPoly_BLAKE3";
pub const NOISE_HASHLEN: usize = 32;
pub const NOISE_BLOCKLEN: usize = 64;
pub const NOISE_KEYLEN: usize = 32;
pub const NOISE_TAGLEN: usize = 16;
pub const NOISE_NONCELEN: usize = 12;
pub const NOISE_FRAME_HEADER_LEN: usize = 2;
pub fn blake3_digest(data: &[u8]) -> [u8; 32] {
let hash = blake3::hash(data);
*hash.as_bytes()
}
pub fn hmac_blake3(key: &[u8], data: &[u8]) -> [u8; 32] {
let mut k = [0u8; NOISE_BLOCKLEN];
if key.len() > NOISE_BLOCKLEN {
let digest = blake3_digest(key);
k[..32].copy_from_slice(&digest);
} else {
k[..key.len()].copy_from_slice(key);
}
let mut ipad = [0u8; NOISE_BLOCKLEN];
let mut opad = [0u8; NOISE_BLOCKLEN];
for i in 0..NOISE_BLOCKLEN {
ipad[i] = k[i] ^ 0x36;
opad[i] = k[i] ^ 0x5c;
}
let mut inner_input = Vec::with_capacity(NOISE_BLOCKLEN + data.len());
inner_input.extend_from_slice(&ipad);
inner_input.extend_from_slice(data);
let inner_hash = blake3_digest(&inner_input);
let mut outer_input = Vec::with_capacity(NOISE_BLOCKLEN + 32);
outer_input.extend_from_slice(&opad);
outer_input.extend_from_slice(&inner_hash);
blake3_digest(&outer_input)
}
pub fn hkdf2(ck: &[u8; 32], ikm: &[u8]) -> ([u8; 32], [u8; 32]) {
let prk = hmac_blake3(ck, ikm);
let out1 = hmac_blake3(&prk, &[0x01]);
let mut info2 = Vec::with_capacity(33);
info2.extend_from_slice(&out1);
info2.push(0x02);
let out2 = hmac_blake3(&prk, &info2);
(out1, out2)
}
pub fn hkdf3(ck: &[u8; 32], ikm: &[u8]) -> ([u8; 32], [u8; 32], [u8; 32]) {
let prk = hmac_blake3(ck, ikm);
let out1 = hmac_blake3(&prk, &[0x01]);
let mut info2 = Vec::with_capacity(33);
info2.extend_from_slice(&out1);
info2.push(0x02);
let out2 = hmac_blake3(&prk, &info2);
let mut info3 = Vec::with_capacity(33);
info3.extend_from_slice(&out2);
info3.push(0x03);
let out3 = hmac_blake3(&prk, &info3);
(out1, out2, out3)
}
#[derive(Clone)]
pub struct SovereignNodeIdentity {
pub did: String,
pub ed25519_public_key: [u8; 32],
pub ed25519_private_key: [u8; 32],
pub x25519_public_key: [u8; 32],
pub x25519_private_key: [u8; 32],
signing_key: SigningKey,
x25519_secret: X25519StaticSecret,
}
impl SovereignNodeIdentity {
pub fn generate() -> Self {
let mut seed = [0u8; 32];
let mut rng = OsRng;
rand::RngCore::fill_bytes(&mut rng, &mut seed);
Self::from_seed(&seed)
}
pub fn from_seed(seed: &[u8; 32]) -> Self {
let mut ed_input = Vec::with_capacity(44);
ed_input.extend_from_slice(seed);
ed_input.extend_from_slice(b"ed25519:seed");
let ed_seed = blake3_digest(&ed_input);
let mut x_input = Vec::with_capacity(42);
x_input.extend_from_slice(seed);
x_input.extend_from_slice(b"x25519:seed");
let x_seed = blake3_digest(&x_input);
let signing_key = SigningKey::from_bytes(&ed_seed);
let verifying_key = signing_key.verifying_key();
let ed_pub = verifying_key.to_bytes();
let x_secret = X25519StaticSecret::from(x_seed);
let x_pub = X25519PublicKey::from(&x_secret).to_bytes();
let did = format!("did:pkc:{}", bs58::encode(&ed_pub).into_string());
Self {
did,
ed25519_public_key: ed_pub,
ed25519_private_key: ed_seed,
x25519_public_key: x_pub,
x25519_private_key: x_seed,
signing_key,
x25519_secret: x_secret,
}
}
pub fn sign(&self, message: &[u8]) -> [u8; 64] {
let sig: Signature = self.signing_key.sign(message);
sig.to_bytes()
}
pub fn did_to_public_key(did: &str) -> Result<[u8; 32], String> {
if !did.starts_with("did:pkc:") {
return Err(format!("Invalid DID prefix for '{}'", did));
}
let rest = &did["did:pkc:".len()..];
let bytes = if rest.starts_with('z') {
let decoded = bs58::decode(&rest[1..]).into_vec().map_err(|e| e.to_string())?;
if decoded.len() >= 2 && decoded[0] == 0xed && decoded[1] == 0x01 {
decoded[2..].to_vec()
} else {
decoded
}
} else {
bs58::decode(rest).into_vec().map_err(|e| e.to_string())?
};
if bytes.len() != 32 {
return Err(format!("Invalid public key length from DID: {}", bytes.len()));
}
let mut arr = [0u8; 32];
arr.copy_from_slice(&bytes);
Ok(arr)
}
pub fn public_key_to_did(pubkey: &[u8; 32]) -> String {
format!("did:pkc:{}", bs58::encode(pubkey).into_string())
}
pub fn verify(&self, message: &[u8], signature: &[u8; 64]) -> bool {
Self::verify_signature(&self.ed25519_public_key, message, signature)
}
pub fn verify_signature(public_key: &[u8; 32], message: &[u8], signature: &[u8; 64]) -> bool {
if let Ok(vk) = VerifyingKey::from_bytes(public_key) {
let sig = Signature::from_bytes(signature);
vk.verify(message, &sig).is_ok()
} else {
false
}
}
pub fn diffie_hellman(&self, peer_x25519_public: &[u8; 32]) -> [u8; 32] {
let peer_pub = X25519PublicKey::from(*peer_x25519_public);
*self.x25519_secret.diffie_hellman(&peer_pub).as_bytes()
}
}
#[derive(Clone, Default)]
pub struct NoiseCipherState {
pub key: Option<[u8; 32]>,
pub nonce: u64,
}
impl NoiseCipherState {
pub fn new() -> Self {
Self { key: None, nonce: 0 }
}
pub fn initialize_key(&mut self, key: Option<[u8; 32]>) {
self.key = key;
self.nonce = 0;
}
pub fn has_key(&self) -> bool {
self.key.is_some()
}
pub fn encrypt_with_ad(&mut self, ad: &[u8], plaintext: &[u8]) -> Result<Vec<u8>, String> {
let key_bytes = match self.key {
Some(k) => k,
None => return Ok(plaintext.to_vec()),
};
let key = Key::from(key_bytes);
let cipher = ChaCha20Poly1305::new(&key);
let mut nonce_bytes = [0u8; NOISE_NONCELEN];
nonce_bytes[4..12].copy_from_slice(&self.nonce.to_be_bytes());
let nonce = Nonce::from(nonce_bytes);
let payload = Payload { msg: plaintext, aad: ad };
let ciphertext = cipher
.encrypt(&nonce, payload)
.map_err(|e| format!("ChaCha20Poly1305 encryption failed: {}", e))?;
self.nonce += 1;
Ok(ciphertext)
}
pub fn decrypt_with_ad(&mut self, ad: &[u8], ciphertext: &[u8]) -> Result<Vec<u8>, String> {
let key_bytes = match self.key {
Some(k) => k,
None => return Ok(ciphertext.to_vec()),
};
if ciphertext.len() < NOISE_TAGLEN {
self.zeroize();
return Err(format!("Ciphertext too short: {} < {}", ciphertext.len(), NOISE_TAGLEN));
}
let key = Key::from(key_bytes);
let cipher = ChaCha20Poly1305::new(&key);
let mut nonce_bytes = [0u8; NOISE_NONCELEN];
nonce_bytes[4..12].copy_from_slice(&self.nonce.to_be_bytes());
let nonce = Nonce::from(nonce_bytes);
let payload = Payload { msg: ciphertext, aad: ad };
let plaintext = cipher
.decrypt(&nonce, payload)
.map_err(|e| {
self.zeroize();
format!("MAC verification failed: {} (INV-257-01)", e)
})?;
self.nonce += 1;
Ok(plaintext)
}
pub fn zeroize(&mut self) {
if let Some(ref mut k) = self.key {
k.zeroize();
}
self.key = None;
self.nonce = 0;
}
}
#[derive(Clone)]
pub struct NoiseSymmetricState {
pub cipher: NoiseCipherState,
pub ck: [u8; 32],
pub h: [u8; 32],
}
impl NoiseSymmetricState {
pub fn new(protocol_name: &str) -> Self {
let mut h = [0u8; 32];
let name_bytes = protocol_name.as_bytes();
if name_bytes.len() <= 32 {
h[..name_bytes.len()].copy_from_slice(name_bytes);
} else {
h = blake3_digest(name_bytes);
}
let ck = h;
Self {
cipher: NoiseCipherState::new(),
ck,
h,
}
}
pub fn mix_key(&mut self, ikm: &[u8]) {
let (next_ck, temp_k) = hkdf2(&self.ck, ikm);
self.ck = next_ck;
self.cipher.initialize_key(Some(temp_k));
}
pub fn mix_hash(&mut self, data: &[u8]) {
let mut input = Vec::with_capacity(self.h.len() + data.len());
input.extend_from_slice(&self.h);
input.extend_from_slice(data);
self.h = blake3_digest(&input);
}
pub fn mix_key_and_hash(&mut self, ikm: &[u8]) {
let (next_ck, temp_h, temp_k) = hkdf3(&self.ck, ikm);
self.ck = next_ck;
self.mix_hash(&temp_h);
self.cipher.initialize_key(Some(temp_k));
}
pub fn encrypt_and_hash(&mut self, plaintext: &[u8]) -> Result<Vec<u8>, String> {
let ciphertext = self.cipher.encrypt_with_ad(&self.h, plaintext)?;
self.mix_hash(&ciphertext);
Ok(ciphertext)
}
pub fn decrypt_and_hash(&mut self, ciphertext: &[u8]) -> Result<Vec<u8>, String> {
let plaintext = self.cipher.decrypt_with_ad(&self.h, ciphertext)?;
self.mix_hash(ciphertext);
Ok(plaintext)
}
pub fn split(&mut self) -> (NoiseCipherState, NoiseCipherState) {
let (k1, k2) = hkdf2(&self.ck, &[]);
let mut c1 = NoiseCipherState::new();
c1.initialize_key(Some(k1));
let mut c2 = NoiseCipherState::new();
c2.initialize_key(Some(k2));
(c1, c2)
}
pub fn zeroize(&mut self) {
self.ck.zeroize();
self.h.zeroize();
self.cipher.zeroize();
}
}
#[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);
extra_payload = payload_pt[96..].to_vec();
} else {
extra_payload = 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);
extra_payload = payload_pt[96..].to_vec();
} else {
extra_payload = 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();
}
}
}
pub struct NoiseTransportSession {
pub send_cipher: NoiseCipherState,
pub recv_cipher: NoiseCipherState,
pub handshake_hash: [u8; 32],
pub local_identity: SovereignNodeIdentity,
pub remote_static_public: [u8; 32],
pub remote_did: String,
pub is_terminated: bool,
}
impl NoiseTransportSession {
pub fn new(
send_cipher: NoiseCipherState,
recv_cipher: NoiseCipherState,
handshake_hash: [u8; 32],
local_identity: SovereignNodeIdentity,
remote_static_public: [u8; 32],
remote_did: String,
) -> Self {
Self {
send_cipher,
recv_cipher,
handshake_hash,
local_identity,
remote_static_public,
remote_did,
is_terminated: false,
}
}
pub fn encrypt_frame(&mut self, plaintext: &[u8]) -> Result<Vec<u8>, String> {
if self.is_terminated {
return Err("Cannot operate on terminated Noise transport session".into());
}
let current_nonce = self.send_cipher.nonce;
let mut nonce_bytes = [0u8; NOISE_NONCELEN];
nonce_bytes[4..12].copy_from_slice(¤t_nonce.to_be_bytes());
let ciphertext_with_tag = self.send_cipher.encrypt_with_ad(&[], plaintext)?;
let payload_len = NOISE_NONCELEN + ciphertext_with_tag.len();
if payload_len > 0xffff {
return Err(format!("Frame payload exceeds 65535 bytes: {}", payload_len));
}
let mut frame = Vec::with_capacity(NOISE_FRAME_HEADER_LEN + payload_len);
frame.extend_from_slice(&(payload_len as u16).to_be_bytes());
frame.extend_from_slice(&nonce_bytes);
frame.extend_from_slice(&ciphertext_with_tag);
Ok(frame)
}
pub fn decrypt_frame(&mut self, frame: &[u8]) -> Result<Vec<u8>, String> {
if self.is_terminated {
return Err("Cannot operate on terminated Noise transport session".into());
}
if frame.len() < NOISE_FRAME_HEADER_LEN + NOISE_NONCELEN + NOISE_TAGLEN {
self.terminate_and_zeroize();
return Err(format!("Frame too short: {} < 30 (INV-257-01)", frame.len()));
}
let payload_len = u16::from_be_bytes([frame[0], frame[1]]) as usize;
if frame.len() < NOISE_FRAME_HEADER_LEN + payload_len {
self.terminate_and_zeroize();
return Err(format!("Truncated frame: expected {}, got {}", NOISE_FRAME_HEADER_LEN + payload_len, frame.len()));
}
let mut nonce_counter_bytes = [0u8; 8];
nonce_counter_bytes.copy_from_slice(&frame[NOISE_FRAME_HEADER_LEN + 4..NOISE_FRAME_HEADER_LEN + 12]);
let frame_nonce = u64::from_be_bytes(nonce_counter_bytes);
if frame_nonce != self.recv_cipher.nonce {
self.terminate_and_zeroize();
return Err(format!(
"Replay or out-of-order frame: expected nonce {}, got {} (INV-257-01)",
self.recv_cipher.nonce, frame_nonce
));
}
let ct_with_tag = &frame[NOISE_FRAME_HEADER_LEN + NOISE_NONCELEN..NOISE_FRAME_HEADER_LEN + payload_len];
match self.recv_cipher.decrypt_with_ad(&[], ct_with_tag) {
Ok(pt) => Ok(pt),
Err(e) => {
self.terminate_and_zeroize();
Err(e)
}
}
}
pub fn terminate_and_zeroize(&mut self) {
self.is_terminated = true;
self.send_cipher.zeroize();
self.recv_cipher.zeroize();
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_sovereign_identity_generation_and_signing() {
let alice = SovereignNodeIdentity::generate();
assert!(alice.did.starts_with("did:pkc:"));
let msg = b"test rust signature";
let sig = alice.sign(msg);
assert!(alice.verify(msg, &sig));
let mut bad_msg = msg.to_vec();
bad_msg[0] ^= 0xff;
assert!(!alice.verify(&bad_msg, &sig));
}
#[test]
fn test_x25519_diffie_hellman_symmetric() {
let alice = SovereignNodeIdentity::generate();
let bob = SovereignNodeIdentity::generate();
let s1 = alice.diffie_hellman(&bob.x25519_public_key);
let s2 = bob.diffie_hellman(&alice.x25519_public_key);
assert_eq!(s1, s2);
}
#[test]
fn test_noise_xx_handshake_and_transport_framing() {
let alice = SovereignNodeIdentity::generate();
let bob = SovereignNodeIdentity::generate();
let mut initiator = NoiseHandshakeState::new(HandshakeRole::Initiator, alice.clone(), true);
let mut responder = NoiseHandshakeState::new(HandshakeRole::Responder, bob.clone(), true);
let msg1 = initiator.write_message1(b"ping-1").expect("msg1 write");
let res1 = responder.read_message1(&msg1).expect("msg1 read");
assert_eq!(res1.extra_payload, b"ping-1");
let msg2 = responder.write_message2(b"pong-2").expect("msg2 write");
let res2 = initiator.read_message2(&msg2).expect("msg2 read");
assert_eq!(res2.remote_did.as_deref(), Some(bob.did.as_str()));
assert_eq!(res2.extra_payload, b"pong-2");
let msg3 = initiator.write_message3(b"ack-3").expect("msg3 write");
let res3 = responder.read_message3(&msg3).expect("msg3 read");
assert_eq!(res3.remote_did.as_deref(), Some(alice.did.as_str()));
assert_eq!(res3.extra_payload, b"ack-3");
let mut alice_session = initiator.into_session().expect("alice session");
let mut bob_session = responder.into_session().expect("bob session");
assert_eq!(alice_session.handshake_hash, bob_session.handshake_hash);
let frame = alice_session.encrypt_frame(b"secure conversational payload").expect("encrypt");
let pt = bob_session.decrypt_frame(&frame).expect("decrypt");
assert_eq!(pt, b"secure conversational payload");
let reply_frame = bob_session.encrypt_frame(b"response payload").expect("encrypt reply");
let reply_pt = alice_session.decrypt_frame(&reply_frame).expect("decrypt reply");
assert_eq!(reply_pt, b"response payload");
let mut bad_frame = alice_session.encrypt_frame(b"tamper test").expect("enc");
bad_frame[20] ^= 0xaa;
assert!(bob_session.decrypt_frame(&bad_frame).is_err());
assert!(bob_session.is_terminated);
}
}