v/vlib/crypto/ecdsa/ecdsa_test.v

// vtest build: present_openssl? && !(openbsd && gcc) && !(sanitize-memory-clang || docker-ubuntu-musl)
module ecdsa

fn test_ecdsa() {
	// Generate key pair
	pub_key, priv_key := generate_key() or { panic(err) }

	// Sign a message
	message := 'Hello, ECDSA!'.bytes()
	signature := priv_key.sign(message) or { panic(err) }

	// Verify the signature
	is_valid := pub_key.verify(message, signature) or { panic(err) }
	println('Signature valid: ${is_valid}')
	assert is_valid

	priv_key.free()
	pub_key.free()
}

fn test_ecdsa_signing_with_recommended_hash_options() {
	// Generate key pair
	pub_key, priv_key := generate_key() or { panic(err) }

	// Sign a message
	message := 'Hello, ECDSA!'.bytes()
	signature := priv_key.sign(message) or { panic(err) }

	// Verify the signature
	is_valid := pub_key.verify(message, signature) or { panic(err) }
	println('Signature valid: ${is_valid}')
	assert is_valid
	pub_key.free()
	priv_key.free()
}

fn test_generate_key() ! {
	// Test key generation with high level opaque
	pub_key, priv_key := generate_key() or { panic(err) }
	assert pub_key.evpkey != unsafe { nil }
	assert priv_key.evpkey != unsafe { nil }

	priv_key.free()
	pub_key.free()
}

fn test_new_key_from_seed() ! {
	// Test generating a key from a seed
	seed := [u8(1), 2, 3, 4, 5]
	priv_key := new_key_from_seed(seed) or { panic(err) }
	retrieved_seed := priv_key.bytes() or { panic(err) }
	assert seed == retrieved_seed
	priv_key.free()
}

fn test_new_key_from_seed_with_leading_zeros_bytes() ! {
	// Test generating a key from a seed
	seed := [u8(0), u8(1), 2, 3, 4, 5]
	priv_key := new_key_from_seed(seed) or { panic(err) }
	retrieved_seed := priv_key.bytes() or { panic(err) }
	assert seed == retrieved_seed
	priv_key.free()
}

fn test_sign_and_verify() ! {
	// Test signing and verifying a message
	pub_key, priv_key := generate_key() or { panic(err) }
	message := 'Test message'.bytes()
	signature := priv_key.sign(message) or { panic(err) }
	is_valid := pub_key.verify(message, signature) or { panic(err) }
	assert is_valid

	priv_key.free()
	pub_key.free()
}

fn test_seed() ! {
	// Test retrieving the seed from a private key
	pub_key, priv_key := generate_key() or { panic(err) }
	seed := priv_key.bytes() or { panic(err) }
	assert seed.len > 0
	priv_key.free()
	pub_key.free()
}

fn test_public_key() ! {
	// Test getting the public key from a private key
	pubkk, priv_key := generate_key() or { panic(err) }
	pub_key1 := priv_key.public_key() or { panic(err) }
	pub_key2, privkk := generate_key() or { panic(err) }
	assert !pub_key1.equal(pub_key2)

	pubkk.free()
	privkk.free()
	priv_key.free()
	pub_key1.free()
	pub_key2.free()
}

fn test_private_key_equal() ! {
	// Test private key equality
	pbk, priv_key1 := generate_key() or { panic(err) }
	seed := priv_key1.bytes() or { panic(err) }
	priv_key2 := new_key_from_seed(seed) or { panic(err) }
	assert priv_key1.equal(priv_key2)

	pbk.free()
	priv_key1.free()
	priv_key2.free()
}

fn test_private_key_equality_on_different_curve() ! {
	// default group
	pbk, priv_key1 := generate_key() or { panic(err) }
	seed := priv_key1.bytes() or { panic(err) }
	// using different group
	priv_key2 := new_key_from_seed(seed, nid: .secp384r1) or { panic(err) }
	assert !priv_key1.equal(priv_key2)
	pbk.free()
	priv_key1.free()
	priv_key2.free()
}

fn test_public_key_equal() ! {
	// Test public key equality
	pbk, priv_key := generate_key() or { panic(err) }
	pub_key1 := priv_key.public_key() or { panic(err) }
	pub_key2 := priv_key.public_key() or { panic(err) }
	assert pub_key1.equal(pub_key2)
	pbk.free()
	priv_key.free()
	pub_key1.free()
	pub_key2.free()
}

fn test_sign_with_new_key_from_seed() ! {
	// Test signing with a key generated from a seed
	seed := [u8(10), 20, 30, 40, 50]
	priv_key := new_key_from_seed(seed) or { panic(err) }
	message := 'Another test message'.bytes()
	signature := priv_key.sign(message) or { panic(err) }
	pub_key := priv_key.public_key() or { panic(err) }
	is_valid := pub_key.verify(message, signature) or { panic(err) }
	assert is_valid
	priv_key.free()
	pub_key.free()
}

fn test_invalid_signature() ! {
	// Test verifying an invalid signature
	pub_key, pvk := generate_key() or { panic(err) }
	message := 'Test message'.bytes()
	invalid_signature := [u8(1), 2, 3] // Deliberately invalid
	result := pub_key.verify(message, invalid_signature) or {
		// Expecting verification to fail
		assert err.msg() == 'Failed to verify signature'
		pub_key.free()
		pvk.free()
		return
	}
	assert !result
	pub_key.free()
	pvk.free()
}

fn test_different_keys_not_equal() ! {
	// Test that different keys are not equal
	pbk1, priv_key1 := generate_key() or { panic(err) }
	pbk2, priv_key2 := generate_key() or { panic(err) }
	assert !priv_key1.equal(priv_key2)
	pbk1.free()
	pbk2.free()
	priv_key1.free()
	priv_key2.free()
}

fn test_private_key_new() ! {
	priv_key := PrivateKey.new()!
	assert priv_key.ks_flag == .fixed
	size := evp_key_size(priv_key.evpkey)!
	assert size == 32
	pubkey := priv_key.public_key()!

	message := 'Another test message'.bytes()
	signature := priv_key.sign(message)!
	is_valid := pubkey.verify(message, signature)!
	assert is_valid

	// new private key
	seed := priv_key.bytes()!
	priv_key2 := new_key_from_seed(seed)!
	pubkey2 := priv_key2.public_key()!
	assert priv_key.equal(priv_key2)
	assert pubkey.equal(pubkey2)
	is_valid2 := pubkey2.verify(message, signature)!
	assert is_valid2

	// generates new key with different curve
	priv_key3 := new_key_from_seed(seed, nid: .secp384r1)!
	pubkey3 := priv_key3.public_key()!
	assert !priv_key3.equal(priv_key2)
	assert !pubkey3.equal(pubkey2)
	is_valid3 := pubkey3.verify(message, signature)!
	assert !is_valid3

	priv_key.free()
	priv_key2.free()
	priv_key3.free()
	pubkey.free()
	pubkey2.free()
	pubkey3.free()
}

// See https://discord.com/channels/592103645835821068/592114487759470596/1334319744098107423
fn test_key_with_msg_exceed_key_size() ! {
	pv := PrivateKey.new()!
	msg := 'a'.repeat(200).bytes()
	opt := SignerOpts{
		hash_config: .with_no_hash
	}
	signed := pv.sign(msg, opt)!
	pb := pv.public_key()!

	// should be verified
	st := pb.verify(msg, signed, opt)!
	assert st

	// different msg should not be verified
	other_msg := 'a'.repeat(392).bytes()
	ds := pb.verify(other_msg, signed, opt)!
	// This should assert to false.
	assert !ds

	pv.free()
	pb.free()
}