151 lines
4.4 KiB
Rust
151 lines
4.4 KiB
Rust
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);
|
|
}
|