use std::net::SocketAddr;
use std::sync::Arc;
use serde::{Serialize, Deserialize};
fn ensure_crypto_provider() {
let _ = rustls::crypto::ring::default_provider().install_default();
}
pub struct TlsCertificate {
pub cert_der: Vec<u8>,
pub key_der: Vec<u8>,
pub subject: String,
}
pub fn generate_self_signed_cert(subject: &str) -> Result<TlsCertificate, String> {
use rcgen::{CertificateParams, KeyPair, PKCS_ED25519};
let params = CertificateParams::new(vec![subject.to_string()])
.map_err(|e| format!("Failed to create cert params: {}", e))?;
let key_pair = KeyPair::generate_for(&PKCS_ED25519)
.map_err(|e| format!("Failed to generate key pair: {}", e))?;
let cert = params.self_signed(&key_pair)
.map_err(|e| format!("Failed to self-sign certificate: {}", e))?;
let cert_der = cert.der().to_vec();
let key_der = key_pair.serialize_der();
Ok(TlsCertificate {
cert_der,
key_der,
subject: subject.to_string(),
})
}
pub struct QuicEndpoint {
endpoint: quinn::Endpoint,
#[allow(dead_code)]
server_config: Option<quinn::ServerConfig>,
}
impl QuicEndpoint {
pub fn new_server(port: u16, cert: &TlsCertificate) -> Result<Self, String> {
ensure_crypto_provider();
let server_crypto = build_server_crypto(cert)?;
let server_config = quinn::ServerConfig::with_crypto(Arc::new(server_crypto));
let bind_addr: SocketAddr = format!("127.0.0.1:{}", port)
.parse()
.map_err(|e| format!("Invalid bind address: {}", e))?;
let endpoint = quinn::Endpoint::server(server_config.clone(), bind_addr)
.map_err(|e| format!("Failed to bind QUIC endpoint to {}: {}", bind_addr, e))?;
Ok(Self {
endpoint,
server_config: Some(server_config),
})
}
pub fn new_client() -> Result<Self, String> {
ensure_crypto_provider();
let bind_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
let endpoint = quinn::Endpoint::client(bind_addr)
.map_err(|e| format!("Failed to create client endpoint: {}", e))?;
Ok(Self {
endpoint,
server_config: None,
})
}
pub fn new_client_with_config() -> Result<Self, String> {
ensure_crypto_provider();
let bind_addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
let endpoint = quinn::Endpoint::client(bind_addr)
.map_err(|e| format!("Failed to create client endpoint: {}", e))?;
Ok(Self {
endpoint,
server_config: None,
})
}
pub async fn connect(&self, addr: &str, server_name: &str) -> Result<QuicConnection, String> {
ensure_crypto_provider();
let client_crypto = build_dangerous_client_crypto();
let quic_client_config = quinn::crypto::rustls::QuicClientConfig::try_from(client_crypto)
.map_err(|e| format!("Failed to create QUIC client config: {}", e))?;
let client_config = quinn::ClientConfig::new(Arc::new(quic_client_config));
let socket_addr: SocketAddr = addr
.parse()
.map_err(|e| format!("Invalid server address {}: {}", addr, e))?;
let connection = self.endpoint
.connect_with(client_config, socket_addr, server_name)
.map_err(|e| format!("Failed to initiate connection: {}", e))?
.await
.map_err(|e| format!("QUIC connection failed: {}", e))?;
Ok(QuicConnection { conn: connection })
}
pub async fn accept(&self) -> Result<QuicConnection, String> {
let incoming = self.endpoint.accept()
.await
.ok_or_else(|| "No incoming QUIC connection".to_string())?;
let connection = incoming.await
.map_err(|e| format!("Failed to accept QUIC connection: {}", e))?;
Ok(QuicConnection { conn: connection })
}
pub fn local_addr(&self) -> Result<SocketAddr, String> {
self.endpoint.local_addr()
.map_err(|e| format!("Failed to get local addr: {}", e))
}
pub fn close(&self) {
self.endpoint.close(0u32.into(), b"shutdown");
}
pub async fn accept_with_cancellation(
&self,
token: &tokio_util::sync::CancellationToken,
) -> Result<Option<QuicConnection>, String> {
tokio::select! {
_ = token.cancelled() => Ok(None),
res = self.accept() => res.map(Some),
}
}
pub async fn run_accept_loop<F, Fut>(
&self,
token: tokio_util::sync::CancellationToken,
handler: F,
) -> Result<(), String>
where
F: Fn(QuicConnection) -> Fut + Send + Sync + 'static,
Fut: std::future::Future<Output = ()> + Send + 'static,
{
loop {
tokio::select! {
_ = token.cancelled() => {
self.close();
break;
}
res = self.accept() => {
match res {
Ok(conn) => {
tokio::spawn(handler(conn));
}
Err(e) => {
if token.is_cancelled() {
break;
}
return Err(e);
}
}
}
}
}
Ok(())
}
}
pub struct QuicConnection {
pub conn: quinn::Connection,
}
impl QuicConnection {
pub async fn send(&self, data: &[u8]) -> Result<Vec<u8>, String> {
let (mut send_stream, mut recv_stream) = self.conn
.open_bi()
.await
.map_err(|e| format!("Failed to open bidirectional stream: {}", e))?;
send_stream.write_all(data)
.await
.map_err(|e| format!("Failed to write to QUIC stream: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish send stream: {}", e))?;
let response = recv_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read response from QUIC stream: {}", e))?;
Ok(response)
}
pub async fn send_one_way(&self, data: &[u8]) -> Result<(), String> {
let mut send_stream = self.conn
.open_uni()
.await
.map_err(|e| format!("Failed to open unidirectional stream: {}", e))?;
send_stream.write_all(data)
.await
.map_err(|e| format!("Failed to write to QUIC stream: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish send stream: {}", e))?;
Ok(())
}
pub async fn recv_bi(&self) -> Result<(Vec<u8>, quinn::SendStream, quinn::RecvStream), String> {
let (send_stream, mut recv_stream) = self.conn
.accept_bi()
.await
.map_err(|e| format!("Failed to accept bidirectional stream: {}", e))?;
let data = recv_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read from QUIC stream: {}", e))?;
Ok((data, send_stream, recv_stream))
}
pub async fn respond(
&self,
mut send_stream: quinn::SendStream,
data: &[u8],
) -> Result<(), String> {
send_stream.write_all(data)
.await
.map_err(|e| format!("Failed to write response: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish response stream: {}", e))?;
Ok(())
}
pub fn remote_address(&self) -> SocketAddr {
self.conn.remote_address()
}
pub fn stable_id(&self) -> usize {
self.conn.stable_id()
}
pub fn close(&self, reason: &str) {
self.conn.close(0u32.into(), reason.as_bytes());
}
}
#[derive(Serialize)]
struct ChallengeMessage<'a> {
#[serde(rename = "type")]
msg_type: &'static str,
nonce: &'a str,
}
#[derive(Deserialize)]
struct ResponseMessage {
#[serde(rename = "type")]
msg_type: String,
did: String,
signature: String,
}
pub async fn perform_quic_handshake(
endpoint: &QuicEndpoint,
server_addr: &str,
server_name: &str,
did: &str,
private_key_pem: &str,
) -> Result<serde_json::Value, String> {
use ed25519_dalek::{SigningKey, Signer};
use ed25519_dalek::pkcs8::DecodePrivateKey;
let conn = endpoint.connect(server_addr, server_name).await?;
let (mut send_stream, mut recv_stream) = conn.conn
.open_bi()
.await
.map_err(|e| format!("Failed to open handshake stream: {}", e))?;
let challenge_buf = recv_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read challenge: {}", e))?;
let challenge_msg: serde_json::Value = serde_json::from_slice(&challenge_buf)
.map_err(|e| format!("Failed to parse challenge JSON: {}", e))?;
if challenge_msg["type"] != "challenge" {
return Err("Protocol mismatch: expected challenge message".to_string());
}
let nonce = challenge_msg["nonce"].as_str()
.ok_or_else(|| "Missing nonce in challenge message".to_string())?;
let signing_key = SigningKey::from_pkcs8_pem(private_key_pem)
.map_err(|e| format!("Failed to parse private key: {}", e))?;
let signature = signing_key.sign(nonce.as_bytes());
let signature_hex = hex::encode(signature.to_bytes());
let response = serde_json::json!({
"type": "response",
"did": did,
"signature": signature_hex,
});
let response_bytes = serde_json::to_vec(&response)
.map_err(|e| format!("Failed to serialize response: {}", e))?;
send_stream.write_all(&response_bytes)
.await
.map_err(|e| format!("Failed to write response: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish send stream: {}", e))?;
let auth_buf = recv_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read authorization: {}", e))?;
let auth_result: serde_json::Value = serde_json::from_slice(&auth_buf)
.map_err(|e| format!("Failed to parse authorization JSON: {}", e))?;
Ok(auth_result)
}
pub async fn handle_quic_handshake(
mut send_stream: quinn::SendStream,
mut recv_stream: quinn::RecvStream,
db_path: &str,
) -> Result<serde_json::Value, String> {
use ed25519_dalek::{VerifyingKey, Verifier, Signature};
use ed25519_dalek::pkcs8::DecodePublicKey;
let nonce = crate::discovery_engine::encode_hex(
&crate::discovery_engine::generate_random_bytes_pub(16),
);
let challenge = ChallengeMessage {
msg_type: "challenge",
nonce: &nonce,
};
let challenge_bytes = serde_json::to_vec(&challenge)
.map_err(|e| format!("Failed to serialize challenge: {}", e))?;
send_stream.write_all(&challenge_bytes)
.await
.map_err(|e| format!("Failed to send challenge: {}", e))?;
send_stream.finish()
.map_err(|e| format!("Failed to finish challenge stream: {}", e))?;
let response_buf = recv_stream.read_to_end(1024 * 1024)
.await
.map_err(|e| format!("Failed to read response: {}", e))?;
let response: ResponseMessage = serde_json::from_slice(&response_buf)
.map_err(|e| format!("Failed to parse response: {}", e))?;
if response.msg_type != "response" {
let rej = serde_json::json!({"status": "rejected", "reason": "invalid_protocol_step"});
return Ok(rej);
}
let agent_card = match crate::discovery_engine::get_agent_card_from_db_pub(db_path, &response.did) {
Ok(Some(card)) => card,
Ok(None) => {
return Ok(serde_json::json!({"status": "rejected", "reason": "unauthorized_did"}));
}
Err(_) => {
return Ok(serde_json::json!({"status": "rejected", "reason": "db_error"}));
}
};
let public_key = match VerifyingKey::from_public_key_pem(&agent_card.public_key) {
Ok(key) => key,
Err(_) => {
return Ok(serde_json::json!({"status": "rejected", "reason": "invalid_identity_profile"}));
}
};
let signature_bytes = match crate::discovery_engine::decode_hex(&response.signature) {
Ok(bytes) => bytes,
Err(_) => {
return Ok(serde_json::json!({"status": "rejected", "reason": "invalid_signature"}));
}
};
let signature = match Signature::from_slice(&signature_bytes) {
Ok(sig) => sig,
Err(_) => {
return Ok(serde_json::json!({"status": "rejected", "reason": "invalid_signature"}));
}
};
if public_key.verify(nonce.as_bytes(), &signature).is_err() {
return Ok(serde_json::json!({"status": "rejected", "reason": "invalid_signature"}));
}
Ok(serde_json::json!({
"status": "authorized",
"did": response.did,
"capabilities": agent_card.capabilities,
}))
}
fn build_server_crypto(cert: &TlsCertificate) -> Result<quinn::crypto::rustls::QuicServerConfig, String> {
let cert_chain = vec![rustls::pki_types::CertificateDer::from(cert.cert_der.clone())];
let private_key = rustls::pki_types::PrivateKeyDer::try_from(cert.key_der.clone())
.map_err(|e| format!("Failed to parse private key: {}", e))?;
let server_crypto = rustls::ServerConfig::builder()
.with_no_client_auth()
.with_single_cert(cert_chain, private_key)
.map_err(|e| format!("Failed to build server TLS config: {}", e))?;
let quic_server_config = quinn::crypto::rustls::QuicServerConfig::try_from(server_crypto)
.map_err(|e| format!("Failed to create QUIC server config: {}", e))?;
Ok(quic_server_config)
}
#[allow(dead_code)]
fn build_client_crypto() -> rustls::ClientConfig {
build_dangerous_client_crypto()
}
pub fn build_dangerous_client_crypto() -> rustls::ClientConfig {
use rustls::client::danger::ServerCertVerifier;
use std::sync::Arc;
#[derive(Debug)]
struct NoVerifier;
impl ServerCertVerifier for NoVerifier {
fn verify_server_cert(
&self,
_end_entity: &rustls::pki_types::CertificateDer<'_>,
_intermediates: &[rustls::pki_types::CertificateDer<'_>],
_server_name: &rustls::pki_types::ServerName<'_>,
_ocsp_response: &[u8],
_now: rustls::pki_types::UnixTime,
) -> Result<rustls::client::danger::ServerCertVerified, rustls::Error> {
Ok(rustls::client::danger::ServerCertVerified::assertion())
}
fn verify_tls12_signature(
&self,
_message: &[u8],
_cert: &rustls::pki_types::CertificateDer<'_>,
_dss: &rustls::DigitallySignedStruct,
) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
Ok(rustls::client::danger::HandshakeSignatureValid::assertion())
}
fn verify_tls13_signature(
&self,
_message: &[u8],
_cert: &rustls::pki_types::CertificateDer<'_>,
_dss: &rustls::DigitallySignedStruct,
) -> Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
Ok(rustls::client::danger::HandshakeSignatureValid::assertion())
}
fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
vec![
rustls::SignatureScheme::ED25519,
rustls::SignatureScheme::RSA_PSS_SHA256,
rustls::SignatureScheme::ECDSA_NISTP256_SHA256,
rustls::SignatureScheme::RSA_PKCS1_SHA256,
]
}
}
let config = rustls::ClientConfig::builder()
.dangerous()
.with_custom_certificate_verifier(Arc::new(NoVerifier))
.with_no_client_auth();
config
}
#[cfg(test)]
mod tests {
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();
}
#[test]
fn test_wasm_build_excludes_quic() {
assert!(true);
}
#[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();
}
}