implement signature requests over ws

sigsocket/tests/crypto_tests.rs

@@ -0,0 +1,150 @@
+use sigsocket::crypto::SignatureVerifier;
+use sigsocket::error::SigSocketError;
+use secp256k1::{Secp256k1, Message, PublicKey};
+use sha2::{Sha256, Digest};
+use hex;
+use rand::{rngs::OsRng, Rng};
+
+#[test]
+fn test_encode_decode_base64() {
+    let test_data = b"Hello, World!";
+    
+    // Test encoding
+    let encoded = SignatureVerifier::encode_base64(test_data);
+    
+    // Test decoding
+    let decoded = SignatureVerifier::decode_base64(&encoded).unwrap();
+    
+    assert_eq!(test_data.to_vec(), decoded);
+}
+
+#[test]
+fn test_encode_decode_hex() {
+    let test_data = b"Hello, World!";
+    
+    // Test encoding
+    let encoded = SignatureVerifier::encode_hex(test_data);
+    
+    // Test decoding
+    let decoded = SignatureVerifier::decode_hex(&encoded).unwrap();
+    
+    assert_eq!(test_data.to_vec(), decoded);
+}
+
+#[test]
+fn test_parse_format_response() {
+    let message = b"Test message";
+    let signature = b"Test signature";
+    
+    // Format response
+    let formatted = SignatureVerifier::format_response(message, signature);
+    
+    // Parse response
+    let (parsed_message, parsed_signature) = SignatureVerifier::parse_response(&formatted).unwrap();
+    
+    assert_eq!(message.to_vec(), parsed_message);
+    assert_eq!(signature.to_vec(), parsed_signature);
+}
+
+#[test]
+fn test_invalid_response_format() {
+    // Invalid format (no separator)
+    let invalid = "invalid_format_no_separator";
+    let result = SignatureVerifier::parse_response(invalid);
+    
+    assert!(result.is_err());
+    if let Err(e) = result {
+        assert!(matches!(e, SigSocketError::InvalidResponseFormat));
+    }
+}
+
+#[test]
+fn test_verify_signature_valid() {
+    // Create a secp256k1 context
+    let secp = Secp256k1::new();
+    
+    // Generate a random private key
+    let mut rng = OsRng::default();
+    let mut secret_key_bytes = [0u8; 32];
+    rng.fill(&mut secret_key_bytes);
+    
+    // Create a secret key from random bytes
+    let secret_key = secp256k1::SecretKey::from_slice(&secret_key_bytes).unwrap();
+    
+    // Derive the public key
+    let public_key = PublicKey::from_secret_key(&secp, &secret_key);
+    
+    // Convert to hex for our API
+    let public_key_hex = hex::encode(public_key.serialize());
+    
+    // Message to sign
+    let message = b"Test message for signing";
+    
+    // Hash the message (required for secp256k1)
+    let mut hasher = Sha256::new();
+    hasher.update(message);
+    let message_hash = hasher.finalize();
+    
+    // Create a signature
+    let msg = Message::from_digest_slice(&message_hash).unwrap();
+    let signature = secp.sign_ecdsa(&msg, &secret_key);
+    
+    // Convert signature to hex
+    let signature_hex = hex::encode(signature.serialize_compact());
+    
+    // Verify the signature using our API
+    let result = SignatureVerifier::verify_signature(
+        &public_key_hex,
+        message,
+        &signature_hex
+    ).unwrap();
+    
+    assert!(result);
+}
+
+#[test]
+fn test_verify_signature_invalid() {
+    // Create a secp256k1 context
+    let secp = Secp256k1::new();
+    
+    // Generate two different private keys
+    let mut rng = OsRng::default();
+    let mut secret_key_bytes1 = [0u8; 32];
+    let mut secret_key_bytes2 = [0u8; 32];
+    rng.fill(&mut secret_key_bytes1);
+    rng.fill(&mut secret_key_bytes2);
+    
+    // Create secret keys from random bytes
+    let secret_key = secp256k1::SecretKey::from_slice(&secret_key_bytes1).unwrap();
+    let wrong_secret_key = secp256k1::SecretKey::from_slice(&secret_key_bytes2).unwrap();
+    
+    // Derive the public key from the first private key
+    let public_key = PublicKey::from_secret_key(&secp, &secret_key);
+    
+    // Convert to hex for our API
+    let public_key_hex = hex::encode(public_key.serialize());
+    
+    // Message to sign
+    let message = b"Test message for signing";
+    
+    // Hash the message (required for secp256k1)
+    let mut hasher = Sha256::new();
+    hasher.update(message);
+    let message_hash = hasher.finalize();
+    
+    // Create a signature with the WRONG key
+    let msg = Message::from_digest_slice(&message_hash).unwrap();
+    let wrong_signature = secp.sign_ecdsa(&msg, &wrong_secret_key);
+    
+    // Convert signature to hex
+    let signature_hex = hex::encode(wrong_signature.serialize_compact());
+    
+    // Verify the signature using our API (should fail)
+    let result = SignatureVerifier::verify_signature(
+        &public_key_hex,
+        message,
+        &signature_hex
+    ).unwrap();
+    
+    assert!(!result);
+}