clm-kernel 0.0.17

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
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);

        // 1. Initiator -> Responder
        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");

        // 2. Responder -> Initiator
        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");

        // 3. Initiator -> Responder
        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");

        // Transport
        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);

        // Alice -> Bob frame
        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");

        // Bob -> Alice frame
        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");

        // Tampering test (INV-257-01)
        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);
    }