use super::*;
#[test]
fn test_generate_self_signed_cert() {
let cert = generate_self_signed_cert("pkc-node-test").unwrap();
assert!(!cert.cert_der.is_empty());
assert!(!cert.key_der.is_empty());
assert_eq!(cert.subject, "pkc-node-test");
}
#[test]
fn test_generate_different_certs_have_different_keys() {
let cert1 = generate_self_signed_cert("node-1").unwrap();
let cert2 = generate_self_signed_cert("node-2").unwrap();
assert_ne!(cert1.cert_der, cert2.cert_der);
assert_ne!(cert1.key_der, cert2.key_der);
}
#[tokio::test]
async fn test_quic_server_binds_to_port() {
let cert = generate_self_signed_cert("test-server").unwrap();
let server = QuicEndpoint::new_server(0, &cert).unwrap();
let addr = server.local_addr().unwrap();
assert_eq!(addr.ip().to_string(), "127.0.0.1");
assert!(addr.port() > 0);
server.close();
}
#[tokio::test]
async fn test_quic_client_creates() {
let client = QuicEndpoint::new_client().unwrap();
let addr = client.local_addr().unwrap();
assert_eq!(addr.ip().to_string(), "127.0.0.1");
assert!(addr.port() > 0);
client.close();
}
#[tokio::test]
async fn test_quic_round_trip_send_recv() {
let cert = generate_self_signed_cert("round-trip-test").unwrap();
let server = QuicEndpoint::new_server(0, &cert).unwrap();
let server_addr = server.local_addr().unwrap();
let client = QuicEndpoint::new_client().unwrap();
let server_handle = tokio::spawn(async move {
let conn = server.accept().await.unwrap();
let (data, send_stream, _recv_stream) = conn.recv_bi().await.unwrap();
assert_eq!(data, b"hello quic");
conn.respond(send_stream, b"echo: hello quic").await.unwrap();
let _ = conn.conn.closed().await;
});
let conn = client.connect(&server_addr.to_string(), "round-trip-test").await.unwrap();
let (mut send_stream, mut recv_stream) = conn.conn
.open_bi()
.await
.unwrap();
send_stream.write_all(b"hello quic").await.unwrap();
send_stream.finish().unwrap();
let response = recv_stream.read_to_end(1024 * 1024).await.unwrap();
assert_eq!(response, b"echo: hello quic");
server_handle.await.unwrap();
client.close();
}
#[tokio::test]
async fn test_quic_large_message_round_trip() {
let cert = generate_self_signed_cert("large-msg-test").unwrap();
let server = QuicEndpoint::new_server(0, &cert).unwrap();
let server_addr = server.local_addr().unwrap();
let client = QuicEndpoint::new_client().unwrap();
let large_message = vec![0xABu8; 1024 * 1024];
let large_message_clone = large_message.clone();
let server_handle = tokio::spawn(async move {
let conn = server.accept().await.unwrap();
let (data, send_stream, _) = conn.recv_bi().await.unwrap();
assert_eq!(data.len(), large_message_clone.len());
conn.respond(send_stream, &large_message_clone).await.unwrap();
let _ = conn.conn.closed().await;
});
let conn = client.connect(&server_addr.to_string(), "large-msg-test").await.unwrap();
let (mut send_stream, mut recv_stream) = conn.conn
.open_bi()
.await
.unwrap();
send_stream.write_all(&large_message).await.unwrap();
send_stream.finish().unwrap();
let response = recv_stream.read_to_end(2 * 1024 * 1024).await.unwrap();
assert_eq!(response.len(), 1024 * 1024);
server_handle.await.unwrap();
client.close();
}
#[tokio::test]
async fn test_quic_concurrent_streams() {
let cert = generate_self_signed_cert("concurrent-test").unwrap();
let server = QuicEndpoint::new_server(0, &cert).unwrap();
let server_addr = server.local_addr().unwrap();
let client = QuicEndpoint::new_client().unwrap();
let server_handle = tokio::spawn(async move {
let conn = server.accept().await.unwrap();
for _ in 0..3 {
let (data, send_stream, _) = conn.recv_bi().await.unwrap();
let response = format!("response-{}", String::from_utf8_lossy(&data));
conn.respond(send_stream, response.as_bytes()).await.unwrap();
}
let _ = conn.conn.closed().await;
});
let conn = client.connect(&server_addr.to_string(), "concurrent-test").await.unwrap();
let mut responses = Vec::new();
for i in 0..3 {
let (mut send_stream, mut recv_stream) = conn.conn
.open_bi()
.await
.unwrap();
let msg = format!("stream-{}", i);
send_stream.write_all(msg.as_bytes()).await.unwrap();
send_stream.finish().unwrap();
let response = recv_stream.read_to_end(1024 * 1024).await.unwrap();
responses.push(String::from_utf8(response).unwrap());
}
assert_eq!(responses.len(), 3);
for r in &responses {
assert!(r.starts_with("response-stream-"));
}
server_handle.await.unwrap();
client.close();
}
#[tokio::test]
async fn test_quic_handshake_round_trip() {
use ed25519_dalek::{SigningKey, VerifyingKey, Signer, Verifier};
use ed25519_dalek::pkcs8::{EncodePublicKey, EncodePrivateKey};
use pkcs8::LineEnding;
let signing_key = SigningKey::generate(&mut rand::rngs::OsRng);
let verifying_key = VerifyingKey::from(&signing_key);
let _public_key_pem = verifying_key.to_public_key_pem(LineEnding::LF).unwrap();
let _private_key_pem = signing_key
.to_pkcs8_pem(LineEnding::LF)
.unwrap()
.to_string();
let did = "did:pkc:test:handshake";
let cert = generate_self_signed_cert("handshake-server").unwrap();
let server = QuicEndpoint::new_server(0, &cert).unwrap();
let server_addr = server.local_addr().unwrap();
let server_handle = tokio::spawn(async move {
let conn = server.accept().await.unwrap();
let (mut send_stream, _) = conn.conn
.open_bi()
.await
.unwrap();
let nonce = crate::discovery_engine::encode_hex(
&crate::discovery_engine::generate_random_bytes_pub(16),
);
let challenge = serde_json::json!({
"type": "challenge",
"nonce": nonce,
});
let challenge_bytes = serde_json::to_vec(&challenge).unwrap();
send_stream.write_all(&challenge_bytes).await.unwrap();
send_stream.finish().unwrap();
let (mut send_stream2, mut recv_stream2) = conn.conn
.accept_bi()
.await
.unwrap();
let response_buf = recv_stream2.read_to_end(1024 * 1024).await.unwrap();
let response: serde_json::Value = serde_json::from_slice(&response_buf).unwrap();
assert_eq!(response["type"], "response");
assert_eq!(response["did"], did);
let sig_hex = response["signature"].as_str().unwrap();
let sig_bytes = crate::discovery_engine::decode_hex(sig_hex).unwrap();
let signature = ed25519_dalek::Signature::from_slice(&sig_bytes).unwrap();
assert!(verifying_key.verify(nonce.as_bytes(), &signature).is_ok());
let auth = serde_json::json!({"status": "authorized", "did": did});
let auth_bytes = serde_json::to_vec(&auth).unwrap();
send_stream2.write_all(&auth_bytes).await.unwrap();
send_stream2.finish().unwrap();
let _ = conn.conn.closed().await;
});
let client = QuicEndpoint::new_client().unwrap();
let conn = client.connect(&server_addr.to_string(), "handshake-server").await.unwrap();
let (_, mut recv_stream) = conn.conn
.accept_bi()
.await
.unwrap();
let challenge_buf = recv_stream.read_to_end(1024 * 1024).await.unwrap();
let challenge: serde_json::Value = serde_json::from_slice(&challenge_buf).unwrap();
assert_eq!(challenge["type"], "challenge");
let nonce = challenge["nonce"].as_str().unwrap().to_string();
let signature = signing_key.sign(nonce.as_bytes());
let sig_hex = hex::encode(signature.to_bytes());
let (mut send_stream, mut recv_stream) = conn.conn
.open_bi()
.await
.unwrap();
let response = serde_json::json!({
"type": "response",
"did": did,
"signature": sig_hex,
});
let response_bytes = serde_json::to_vec(&response).unwrap();
send_stream.write_all(&response_bytes).await.unwrap();
send_stream.finish().unwrap();
let auth_buf = recv_stream.read_to_end(1024 * 1024).await.unwrap();
let auth: serde_json::Value = serde_json::from_slice(&auth_buf).unwrap();
assert_eq!(auth["status"], "authorized");
assert_eq!(auth["did"], did);
server_handle.await.unwrap();
client.close();
}
#[test]
fn test_dangerous_client_crypto_creates() {
ensure_crypto_provider();
let _config = build_dangerous_client_crypto();
}