ant-quic 0.3.0

QUIC transport protocol with advanced NAT traversal for P2P networks
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

#!/usr/bin/env -S cargo +stable script
//! Test script to verify Raw Public Keys implementation
//! 
//! This standalone test verifies that:
//! 1. Ed25519 key generation works
//! 2. SubjectPublicKeyInfo encoding/decoding works  
//! 3. Certificate type negotiation works
//! 4. TLS integration compiles

use ant_quic::crypto::raw_public_keys::{
    RawPublicKeyVerifier, RawPublicKeyResolver, create_ed25519_subject_public_key_info,
    RawPublicKeyConfigBuilder, utils::*,
};
use ant_quic::crypto::tls_extensions::{
    CertificateType, CertificateTypeList, CertificateTypePreferences, NegotiationResult,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔐 Testing Raw Public Keys Implementation");
    
    // Test 1: Key generation
    println!("\n1. Testing Ed25519 key generation...");
    let (private_key, public_key) = generate_ed25519_keypair();
    let key_bytes = public_key_to_bytes(&public_key);
    println!("✅ Generated Ed25519 keypair: {}", hex::encode(&key_bytes));
    
    // Test 2: SubjectPublicKeyInfo encoding
    println!("\n2. Testing SubjectPublicKeyInfo encoding...");
    let spki = create_ed25519_subject_public_key_info(&public_key);
    println!("✅ Created SPKI ({} bytes): {}", spki.len(), hex::encode(&spki[..20]));
    assert_eq!(spki.len(), 44, "SPKI should be 44 bytes");
    
    // Test 3: Certificate type negotiation
    println!("\n3. Testing certificate type negotiation...");
    let rpk_list = CertificateTypeList::raw_public_key_only();
    let mixed_list = CertificateTypeList::prefer_raw_public_key();
    
    let negotiated = rpk_list.negotiate(&mixed_list);
    assert_eq!(negotiated, Some(CertificateType::RawPublicKey));
    println!("✅ Certificate type negotiation: {:?}", negotiated);
    
    // Test 4: Preferences and results
    println!("\n4. Testing preferences and negotiation results...");
    let prefs = CertificateTypePreferences::prefer_raw_public_key();
    let result = prefs.negotiate(
        Some(&mixed_list),
        Some(&mixed_list),
    )?;
    
    println!("✅ Negotiation result: client={}, server={}", 
             result.client_cert_type, result.server_cert_type);
    assert!(result.is_raw_public_key_only());
    
    // Test 5: Config builder
    println!("\n5. Testing configuration builder...");
    let config_builder = RawPublicKeyConfigBuilder::new()
        .add_trusted_key(key_bytes)
        .with_server_key(private_key.clone())
        .enable_certificate_type_extensions();
    
    println!("✅ Created configuration builder");
    
    // Test 6: TLS configs (this verifies integration compiles)
    println!("\n6. Testing TLS configuration creation...");
    let client_config = config_builder.clone().build_client_config();
    let server_config = config_builder.build_server_config();
    
    match (&client_config, &server_config) {
        (Ok(_), Ok(_)) => println!("✅ Successfully created TLS client and server configs"),
        (Err(e), _) => println!("❌ Client config failed: {}", e),
        (_, Err(e)) => println!("❌ Server config failed: {}", e),
    }
    
    // Test 7: Verifier creation
    println!("\n7. Testing verifier creation...");
    let verifier = RawPublicKeyVerifier::new(vec![key_bytes]);
    println!("✅ Created RPK verifier with trusted key");
    
    let any_verifier = RawPublicKeyVerifier::allow_any();
    println!("✅ Created RPK verifier allowing any key (dev mode)");
    
    // Test 8: Resolver creation
    println!("\n8. Testing resolver creation...");
    let resolver = RawPublicKeyResolver::new(private_key);
    match resolver {
        Ok(_) => println!("✅ Created RPK resolver"),
        Err(e) => println!("❌ Resolver creation failed: {}", e),
    }
    
    println!("\n🎉 All Raw Public Keys tests completed successfully!");
    println!("✅ Key generation works");
    println!("✅ SPKI encoding works");  
    println!("✅ Certificate type negotiation works");
    println!("✅ TLS integration compiles");
    println!("✅ Component creation works");
    
    Ok(())
}