From f9acb6d339c5cf3f491826caeed6c94f06b97cc7 Mon Sep 17 00:00:00 2001 From: David Stainton Date: Thu, 11 Feb 2021 22:53:36 +0000 Subject: [PATCH] Confirm go and rust Kybers are incompatible --- go/kyber/kyber_test.go | 40 +++++++++ go/noise/kyberXX_test.go | 12 +-- go/noise/noiseXX_test.go | 70 ++++++++++++++++ go/noise_echo_client/main.go | 112 +++++++++++++++++++++++++ rust/Cargo.toml | 8 +- rust/noise_echo_server/Cargo.toml | 11 +++ rust/noise_echo_server/src/main.rs | 127 +++++++++++++++++++++++++++++ rust/src/kyber.rs | 20 +++++ rust/src/noise.rs | 14 +--- 9 files changed, 395 insertions(+), 19 deletions(-) create mode 100644 go/noise/noiseXX_test.go create mode 100644 go/noise_echo_client/main.go create mode 100644 rust/noise_echo_server/Cargo.toml create mode 100644 rust/noise_echo_server/src/main.rs diff --git a/go/kyber/kyber_test.go b/go/kyber/kyber_test.go index 70617e2..ebd2649 100644 --- a/go/kyber/kyber_test.go +++ b/go/kyber/kyber_test.go @@ -2,6 +2,7 @@ package kyber import ( "crypto/rand" + "encoding/hex" "testing" "github.com/cloudflare/circl/kem/kyber/kyber1024" @@ -29,3 +30,42 @@ func TestKyber1024(t *testing.T) { require.Equal(t, aliceSharedSecret, sharedSecret) } + +func TestKyber1024Static(t *testing.T) { + /* + alicePubKey, alicePrivKey, err := kyber1024.GenerateKeyPair(rand.Reader) + require.NoError(t, err) + + alicePrivKeyBytes, err := alicePrivKey.MarshalBinary() + require.NoError(t, err) + + alicePubKeyBytes, err := alicePubKey.MarshalBinary() + require.NoError(t, err) + + t.Logf("alice private key: %x\n", alicePrivKeyBytes) + t.Logf("alice public key: %x\n", alicePubKeyBytes) + */ + + //alicePublicKeyBytes, err := hex.DecodeString("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") + //require.NoError(t, err) + alicePrivateKeyBytes, err := hex.DecodeString("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") + require.NoError(t, err) + + scheme := kyber1024.Scheme() + //alicePublicKey, err := scheme.UnmarshalBinaryPublicKey(alicePublicKeyBytes) + //require.NoError(t, err) + alicePrivateKeyVal, err := scheme.UnmarshalBinaryPrivateKey(alicePrivateKeyBytes) + require.NoError(t, err) + + ciphertext, err := hex.DecodeString("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") + require.NoError(t, err) + + aliceSharedSecret := make([]byte, kyber1024.SharedKeySize) + alicePrivateKey := alicePrivateKeyVal.(*kyber1024.PrivateKey) + alicePrivateKey.DecapsulateTo(aliceSharedSecret, ciphertext) + + bobSharedSecret, err := hex.DecodeString("f2832abba899148318c04c94cd690dd779c32b41fb0addc18d827cda7424c301") + require.NoError(t, err) + + require.Equal(t, aliceSharedSecret, bobSharedSecret) +} diff --git a/go/noise/kyberXX_test.go b/go/noise/kyberXX_test.go index 95c6865..b46beb6 100644 --- a/go/noise/kyberXX_test.go +++ b/go/noise/kyberXX_test.go @@ -35,28 +35,28 @@ func TestNoiseKyberXX(t *testing.T) { }) // -> e, e1 - msg, _, _, err := client.WriteMessage(nil, []byte("abc")) + msg, _, _, err := client.WriteMessage(nil, nil) require.NoError(t, err) t.Logf("msg 1 len is %d", len(msg)) res, _, _, err := server.ReadMessage(nil, msg) require.NoError(t, err) - require.Equal(t, string(res), "abc") + require.Equal(t, string(res), "") // <- e, ee, ekem1, s, es - msg, _, _, err = server.WriteMessage(nil, []byte("defg")) + msg, _, _, err = server.WriteMessage(nil, nil) require.NoError(t, err) t.Logf("msg 2 len is %d", len(msg)) res, _, _, err = client.ReadMessage(nil, msg) require.NoError(t, err) - require.Equal(t, string(res), "defg") + require.Equal(t, string(res), "") // -> s, se - msg, clientTx, clientRx, err := client.WriteMessage(nil, []byte("xyz")) + msg, clientTx, clientRx, err := client.WriteMessage(nil, nil) require.NoError(t, err) t.Logf("msg 3 len is %d", len(msg)) res, serverRx, serverTx, err := server.ReadMessage(nil, msg) require.NoError(t, err) - require.Equal(t, string(res), "xyz") + require.Equal(t, string(res), "") msg = clientTx.Encrypt(nil, nil, []byte("aleph")) res, err = serverRx.Decrypt(nil, nil, msg) diff --git a/go/noise/noiseXX_test.go b/go/noise/noiseXX_test.go new file mode 100644 index 0000000..2ca499c --- /dev/null +++ b/go/noise/noiseXX_test.go @@ -0,0 +1,70 @@ +package noise + +import ( + "crypto/rand" + "testing" + + "github.com/katzenpost/noise" + "github.com/stretchr/testify/require" +) + +func TestNoiseXX(t *testing.T) { + + clientStaticKeypair, err := noise.DH25519.GenerateKeypair(rand.Reader) + require.NoError(t, err) + + serverStaticKeypair, err := noise.DH25519.GenerateKeypair(rand.Reader) + require.NoError(t, err) + + cs := noise.NewCipherSuite(noise.DH25519, noise.CipherChaChaPoly, noise.HashBLAKE2b) + + client, err := noise.NewHandshakeState(noise.Config{ + CipherSuite: cs, + Random: rand.Reader, + Pattern: noise.HandshakeXX, + Initiator: true, + StaticKeypair: clientStaticKeypair, + }) + + server, err := noise.NewHandshakeState(noise.Config{ + CipherSuite: cs, + Random: rand.Reader, + Pattern: noise.HandshakeXX, + Initiator: false, + StaticKeypair: serverStaticKeypair, + }) + + // -> e + msg, _, _, err := client.WriteMessage(nil, nil) + require.NoError(t, err) + t.Logf("msg 1 len is %d", len(msg)) + res, _, _, err := server.ReadMessage(nil, msg) + require.NoError(t, err) + require.Equal(t, string(res), "") + + // <- e, ee, s, es + msg, _, _, err = server.WriteMessage(nil, nil) + require.NoError(t, err) + t.Logf("msg 2 len is %d", len(msg)) + res, _, _, err = client.ReadMessage(nil, msg) + require.NoError(t, err) + require.Equal(t, string(res), "") + + // -> s, se + msg, clientTx, clientRx, err := client.WriteMessage(nil, nil) + require.NoError(t, err) + t.Logf("msg 3 len is %d", len(msg)) + res, serverRx, serverTx, err := server.ReadMessage(nil, msg) + require.NoError(t, err) + require.Equal(t, string(res), "") + + msg = clientTx.Encrypt(nil, nil, []byte("aleph")) + res, err = serverRx.Decrypt(nil, nil, msg) + require.NoError(t, err) + require.Equal(t, string(res), "aleph") + + msg = serverTx.Encrypt(nil, nil, []byte("wubba")) + res, err = clientRx.Decrypt(nil, nil, msg) + require.NoError(t, err) + require.Equal(t, string(res), "wubba") +} diff --git a/go/noise_echo_client/main.go b/go/noise_echo_client/main.go new file mode 100644 index 0000000..128d2d3 --- /dev/null +++ b/go/noise_echo_client/main.go @@ -0,0 +1,112 @@ +package main + +import ( + "crypto/rand" + "encoding/binary" + "fmt" + "io" + "net" + + "github.com/katzenpost/noise" +) + +const ( + macLen = 16 + maxMsgLen = 65535 + msg2Len = 1680 + //msg2Len = 96 +) + +func main() { + clientStaticKeypair, err := noise.DH25519.GenerateKeypair(rand.Reader) + if err != nil { + panic(err) + } + cs := noise.NewCipherSuiteHFS(noise.DH25519, noise.CipherChaChaPoly, noise.HashBLAKE2b, noise.HFSKyber) + //cs := noise.NewCipherSuite(noise.DH25519, noise.CipherChaChaPoly, noise.HashBLAKE2b) + hs, err := noise.NewHandshakeState(noise.Config{ + CipherSuite: cs, + Random: rand.Reader, + Pattern: noise.HandshakeXXhfs, + //Pattern: noise.HandshakeXX, + Initiator: true, + StaticKeypair: clientStaticKeypair, + }) + + conn, err := net.Dial("tcp", "127.0.0.1:36669") + if err != nil { + panic(err) + } + + // -> e, e1 + msg1, _, _, err := hs.WriteMessage(nil, nil) + if err != nil { + panic(err) + } + fmt.Printf("msg1 len is %d\n", len(msg1)) + _, err = conn.Write(msg1) + if err != nil { + panic(err) + } + + // <- e, ee, ekem1, s, es + msg2 := make([]byte, msg2Len) + _, err = io.ReadFull(conn, msg2) + if err != nil { + panic(err) + } + fmt.Printf("msg2 len is %d\n", len(msg2)) + _, _, _, err = hs.ReadMessage(nil, msg2) + if err != nil { + panic(err) + } + + // -> s, se + msg3, tx, rx, err := hs.WriteMessage(nil, nil) + fmt.Printf("msg3 len is %d\n", len(msg3)) + _, err = conn.Write(msg3) + if err != nil { + panic(err) + } + + // send message + plaintext := []byte("hello Alice\n") + ctLen := macLen + len(plaintext) + fmt.Printf("ctLen is %d\n", ctLen) + var ctHdr [4]byte + binary.BigEndian.PutUint32(ctHdr[:], uint32(ctLen)) + toSend := make([]byte, 0, macLen+4+ctLen) + toSend = tx.Encrypt(toSend, nil, ctHdr[:]) + toSend = tx.Encrypt(toSend, nil, plaintext) + _, err = conn.Write(toSend) + if err != nil { + panic(err) + } + + // receive echoed message + var ctHdrCt [macLen + 4]byte + _, err = io.ReadFull(conn, ctHdrCt[:]) + if err != nil { + panic(err) + } + ctHdr2, err := rx.Decrypt(nil, nil, ctHdrCt[:]) + if err != nil { + panic(err) + } + ctLen2 := binary.BigEndian.Uint32(ctHdr2[:]) + if ctLen2 < macLen || ctLen2 > maxMsgLen { + panic("wtf") + } + fmt.Printf("ctLen2 is %d\n", ctLen2) + ct := make([]byte, ctLen2) + _, err = io.ReadFull(conn, ct) + if err != nil { + panic(err) + } + plaintext2, err := rx.Decrypt(nil, nil, ct) + if err != nil { + panic(err) + } + + fmt.Printf("received message: %s\n", plaintext2) +} diff --git a/rust/Cargo.toml b/rust/Cargo.toml index 9e9a155..86fe70b 100644 --- a/rust/Cargo.toml +++ b/rust/Cargo.toml @@ -4,10 +4,12 @@ version = "0.0.0" authors = ["David Stainton "] [dependencies] -snow = { version = "0.7.2", features = ["hfs", "pqclean_kyber1024"] } subtle = "2.4.0" +rustc-serialize = "0.3" +snow = { version = "0.7.2", features = ["hfs", "pqclean_kyber1024"] } ecdh_wrapper = "0.0.9" rand = "^0.4.2" -oqs = "0.2" #pqcrypto-classicmceliece = "0.1.1" -rust-sike = "0.2.0" \ No newline at end of file +rust-sike = "0.2.0" +oqs = "0.3.0" + diff --git a/rust/noise_echo_server/Cargo.toml b/rust/noise_echo_server/Cargo.toml new file mode 100644 index 0000000..ff57dc3 --- /dev/null +++ b/rust/noise_echo_server/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "noise_echo_server" +version = "0.0.1" +authors = ["David Stainton "] + +[dependencies] +snow = { path = "/home/user/code/snow", features = ["hfs", "oqs_kyber1024"] } +#snow = { git = "https://github.com/david415/snow", branch = "add_hfs_kyber_nist_round_three", features = ["hfs", "oqs_kyber1024"] } +ecdh_wrapper = { path = "/home/user/code/sphinx-cryptography/ecdh_wrapper" } +rand = "^0.4.2" +byteorder = "1.2.2" diff --git a/rust/noise_echo_server/src/main.rs b/rust/noise_echo_server/src/main.rs new file mode 100644 index 0000000..f95897d --- /dev/null +++ b/rust/noise_echo_server/src/main.rs @@ -0,0 +1,127 @@ + +extern crate rand; +extern crate ecdh_wrapper; +extern crate snow; +extern crate byteorder; + +use std::str; +use std::net::TcpListener; +use std::net::TcpStream; +use std::io::Read; +use std::io::Write; +use byteorder::{ByteOrder, BigEndian}; + +use rand::os::OsRng; + +use snow::Builder; +use snow::params::NoiseParams; + +use ecdh_wrapper::PrivateKey; + + +const NOISE_PARAMS: & str = "Noise_XXhfs_25519+Kyber1024_ChaChaPoly_BLAKE2b"; +//const NOISE_PARAMS: & str = "Noise_XX_25519_ChaChaPoly_BLAKE2b"; +const NOISE_MESSAGE_MAX_SIZE: usize = 65535; + +const NOISE_HANDSHAKE_MESSAGE1_SIZE: usize = 1600; +const NOISE_HANDSHAKE_MESSAGE2_SIZE: usize = 1680; +const NOISE_HANDSHAKE_MESSAGE3_SIZE: usize = 64; + +/* +const NOISE_HANDSHAKE_MESSAGE1_SIZE: usize = 32; +const NOISE_HANDSHAKE_MESSAGE2_SIZE: usize = 96; +const NOISE_HANDSHAKE_MESSAGE3_SIZE: usize = 64; +*/ + +const MAC_SIZE: usize = 16; +const NOISE_MESSAGE_HEADER_SIZE: usize = MAC_SIZE + 4; +const HEADER_SIZE: usize = 4; + + + +fn do_noise_handshake(mut stream: TcpStream, handshake_state: &mut snow::HandshakeState) -> TcpStream { + // -> e, e1 + let mut client_handshake1 = [0u8; NOISE_HANDSHAKE_MESSAGE1_SIZE]; + stream.read_exact(&mut client_handshake1).unwrap(); + let mut _msg = [0u8; NOISE_HANDSHAKE_MESSAGE1_SIZE]; + handshake_state.read_message(&client_handshake1, &mut _msg).unwrap(); + + // <- e, ee, ekem1, s, es + let mut mesg = [0u8; NOISE_HANDSHAKE_MESSAGE2_SIZE]; + handshake_state.write_message(b"", &mut mesg).unwrap(); + stream.write_all(&mesg).unwrap(); + + // -> s, se + let mut client_handshake2 = [0u8; NOISE_HANDSHAKE_MESSAGE3_SIZE]; + stream.read_exact(&mut client_handshake2).unwrap(); + let mut _msg2 = [0u8; NOISE_HANDSHAKE_MESSAGE3_SIZE]; + handshake_state.read_message(&client_handshake2, &mut _msg2).unwrap(); + + stream +} + +fn handle_client(stream: TcpStream, private_key: PrivateKey) { + let params: NoiseParams = NOISE_PARAMS.parse().unwrap(); + let mut hs = Builder::new(params) + .local_private_key(&private_key.to_vec()) + .build_responder() + .unwrap(); + let mut stream = do_noise_handshake(stream, &mut hs); + let mut transport = hs.into_transport_mode().unwrap(); + + loop { + let mut message_header_ciphertext = vec![0u8; NOISE_MESSAGE_HEADER_SIZE]; + match stream.read_exact(&mut message_header_ciphertext) { + Ok(()) => { + } + Err(err) => { + println!("connection was closed"); + break + } + } + let mut header = [0u8; HEADER_SIZE]; + transport.read_message(&message_header_ciphertext, &mut header).unwrap(); + let ciphertext_size = BigEndian::read_u32(&header); + let mut ciphertext = vec![0u8; ciphertext_size as usize]; + stream.read_exact(&mut ciphertext).unwrap(); + let mut plaintext = vec![0u8; ciphertext_size as usize - MAC_SIZE]; + transport.read_message(&ciphertext, &mut plaintext).unwrap(); + + println!("PLAINTEXT is: {}\n", str::from_utf8(&plaintext).unwrap()); + + let mut send_header_ciphertext = vec![0u8; MAC_SIZE + 4]; + // reuse "header" because it's the same big endian encoded length + transport.write_message(&header, &mut send_header_ciphertext).unwrap(); + let mut send_ciphertext = vec![0u8; ciphertext_size as usize]; + transport.write_message(&plaintext, &mut send_ciphertext).unwrap(); + let mut send_message_ciphertext = Vec::new(); + send_message_ciphertext.extend(send_header_ciphertext); + send_message_ciphertext.extend(send_ciphertext); + stream.write(&send_message_ciphertext).unwrap(); + } +} + +fn main() { + let mut rng = OsRng::new().unwrap(); + let private_key = PrivateKey::generate(&mut rng).unwrap(); + let public_key = private_key.public_key(); + let server_addr = "127.0.0.1:36669"; + + println!("public_key: {}", public_key.to_base64()); + println!("starting noise echo server, listening on {}...\n", server_addr); + + let listener = TcpListener::bind(server_addr.clone()).unwrap(); + + // XXX fix me: how to make it spawn new threads? + // private_key does not implement Copy trait + for stream in listener.incoming() { + match stream { + Ok(stream) => { + handle_client(stream, private_key.clone()); + } + Err(_) => { + println!("Error"); + } + } + } +} diff --git a/rust/src/kyber.rs b/rust/src/kyber.rs index 64d17de..8ea1b76 100644 --- a/rust/src/kyber.rs +++ b/rust/src/kyber.rs @@ -2,8 +2,11 @@ mod tests { extern crate oqs; + extern crate rustc_serialize; + use self::oqs::*; + use self::rustc_serialize::hex::{ToHex, FromHex}; #[test] fn basic_kyber_test() { @@ -13,4 +16,21 @@ mod tests { let a_kem_ss = kemalg.decapsulate(&kem_sk, &kem_ct).unwrap(); assert_eq!(a_kem_ss, b_kem_ss); } + + #[test] + fn static_kyber_test() { + let kemalg = kem::Kem::new(kem::Algorithm::Kyber1024).unwrap(); + + let alice_public_key_bytes = "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".from_hex().unwrap(); + let alice_private_key_bytes = "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".from_hex().unwrap(); + + let alice_public_key = kemalg.public_key_from_bytes(&alice_public_key_bytes).unwrap(); + let _alice_private_key = kemalg.secret_key_from_bytes(&alice_private_key_bytes).unwrap(); + + let (ciphertext, shared_secret) = kemalg.encapsulate(&alice_public_key).unwrap(); + + println!("Bob Kyber1024 KEM ciphertext: {}\n", ciphertext.into_vec().to_hex()); + + println!("Bob shared secret: {}\n", shared_secret.into_vec().to_hex()) + } } diff --git a/rust/src/noise.rs b/rust/src/noise.rs index aeab0e7..e240aa2 100644 --- a/rust/src/noise.rs +++ b/rust/src/noise.rs @@ -12,11 +12,9 @@ mod tests { use self::ecdh_wrapper::PrivateKey; use self::rand::os::OsRng; - pub const PROLOGUE: [u8;1] = [0u8;1]; - pub const PROLOGUE_SIZE: usize = 1; pub const NOISE_MESSAGE_MAX_SIZE: usize = 65535; pub const KEY_SIZE: usize = 32; - pub const NOISE_HANDSHAKE_MESSAGE1_SIZE: usize = PROLOGUE_SIZE + KEY_SIZE; + pub const NOISE_HANDSHAKE_MESSAGE1_SIZE: usize = KEY_SIZE; #[test] fn noise_kyber_test() { @@ -30,13 +28,11 @@ mod tests { let mut alice_hs = Builder::new(params.clone()) .local_private_key(&alice_private_key.to_vec()) .remote_public_key(&bob_public_key.to_vec()) - .prologue(&PROLOGUE) .build_initiator() .unwrap(); let mut bob_hs = Builder::new(params) .local_private_key(&bob_private_key.to_vec()) .remote_public_key(&alice_public_key.to_vec()) - .prologue(&PROLOGUE) .build_responder() .unwrap(); @@ -46,14 +42,12 @@ mod tests { let mut msg = [0u8; NOISE_MESSAGE_MAX_SIZE]; let len = alice_hs.write_message(b"", &mut msg).unwrap(); assert_eq!(len, 1600); - let mut client_handshake1 = [0u8; 1600+1]; - client_handshake1[0] = PROLOGUE[0]; - client_handshake1[PROLOGUE_SIZE..].copy_from_slice(&msg[..len]); + let mut client_handshake1 = [0u8; 1600]; + client_handshake1.copy_from_slice(&msg[..len]); // server side - assert_eq!(client_handshake1[0..PROLOGUE_SIZE].ct_eq(&PROLOGUE).unwrap_u8(), 1); let mut _msg1 = [0u8; NOISE_HANDSHAKE_MESSAGE1_SIZE]; - let len = bob_hs.read_message(&client_handshake1[PROLOGUE_SIZE..], &mut _msg1).unwrap(); + let len = bob_hs.read_message(&client_handshake1, &mut _msg1).unwrap(); assert_eq!(len, 0); let mut server_handshake1 = [0u8; 1680];