mirror of
https://github.com/luxfi/crypto.git
synced 2026-07-27 01:54:50 +00:00
Improve crypto package: add comprehensive tests, fix precompile issues
- Added SignHash/VerifyHash methods to Lamport package for pre-hashed messages - Fixed SHAKE precompile gas calculation to include 4-byte length prefix - Fixed Lamport precompile to use VerifyHash for already-hashed messages - Added comprehensive test suites for encryption package (75.9% coverage) - Added comprehensive test suites for hashing package (92.0% coverage) - Added comprehensive test suites for blake3 package (100% coverage) - Consolidated BLS tests and removed naming redundancy - Fixed compilation errors and improved test structure - Current overall package coverage: 66.6%
This commit is contained in:
Hanzo Dev
@@ -0,0 +1,536 @@
|
||||
package bls
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestNewSecretKeyExtended(t *testing.T) {
|
||||
// Test multiple key generation
|
||||
for i := 0; i < 10; i++ {
|
||||
sk, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate secret key: %v", err)
|
||||
}
|
||||
if sk == nil {
|
||||
t.Fatal("Generated secret key is nil")
|
||||
}
|
||||
if sk.sk == nil {
|
||||
t.Fatal("Internal secret key is nil")
|
||||
}
|
||||
|
||||
// Verify keys are different
|
||||
sk2, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate second secret key: %v", err)
|
||||
}
|
||||
|
||||
bytes1 := SecretKeyToBytes(sk)
|
||||
bytes2 := SecretKeyToBytes(sk2)
|
||||
if bytes.Equal(bytes1, bytes2) {
|
||||
t.Fatal("Generated keys should be different")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSecretKeyBytes(t *testing.T) {
|
||||
// Test with valid secret key
|
||||
sk, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate secret key: %v", err)
|
||||
}
|
||||
|
||||
// Convert to bytes
|
||||
skBytes := SecretKeyToBytes(sk)
|
||||
if len(skBytes) == 0 {
|
||||
t.Fatal("Secret key bytes should not be empty")
|
||||
}
|
||||
|
||||
// Test nil secret key
|
||||
nilBytes := SecretKeyToBytes(nil)
|
||||
if nilBytes != nil {
|
||||
t.Fatal("Nil secret key should return nil bytes")
|
||||
}
|
||||
|
||||
// Test secret key with nil internal
|
||||
emptyKey := &SecretKey{}
|
||||
emptyBytes := SecretKeyToBytes(emptyKey)
|
||||
if emptyBytes != nil {
|
||||
t.Fatal("Secret key with nil internal should return nil bytes")
|
||||
}
|
||||
|
||||
// Round-trip test
|
||||
sk2, err := SecretKeyFromBytes(skBytes)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to deserialize secret key: %v", err)
|
||||
}
|
||||
|
||||
skBytes2 := SecretKeyToBytes(sk2)
|
||||
if !bytes.Equal(skBytes, skBytes2) {
|
||||
t.Fatal("Round-trip secret key bytes should match")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSecretKeyFromBytesErrors(t *testing.T) {
|
||||
// Test with invalid bytes
|
||||
invalidBytes := make([]byte, 10) // Wrong size
|
||||
_, err := SecretKeyFromBytes(invalidBytes)
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with invalid bytes")
|
||||
}
|
||||
|
||||
// Test with nil bytes
|
||||
_, err = SecretKeyFromBytes(nil)
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with nil bytes")
|
||||
}
|
||||
|
||||
// Test with empty bytes
|
||||
_, err = SecretKeyFromBytes([]byte{})
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with empty bytes")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPublicKeyOperations(t *testing.T) {
|
||||
sk, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate secret key: %v", err)
|
||||
}
|
||||
|
||||
// Get public key
|
||||
pk := sk.PublicKey()
|
||||
if pk == nil {
|
||||
t.Fatal("Public key should not be nil")
|
||||
}
|
||||
if pk.pk == nil {
|
||||
t.Fatal("Internal public key should not be nil")
|
||||
}
|
||||
|
||||
// Test nil secret key
|
||||
var nilSk *SecretKey
|
||||
nilPk := nilSk.PublicKey()
|
||||
if nilPk != nil {
|
||||
t.Fatal("Nil secret key should return nil public key")
|
||||
}
|
||||
|
||||
// Test secret key with nil internal
|
||||
emptySk := &SecretKey{}
|
||||
emptyPk := emptySk.PublicKey()
|
||||
if emptyPk != nil {
|
||||
t.Fatal("Empty secret key should return nil public key")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPublicKeyBytes(t *testing.T) {
|
||||
sk, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate secret key: %v", err)
|
||||
}
|
||||
|
||||
pk := sk.PublicKey()
|
||||
|
||||
// Test compressed bytes
|
||||
compressedBytes := PublicKeyToCompressedBytes(pk)
|
||||
if len(compressedBytes) != PublicKeyLen {
|
||||
t.Fatalf("Compressed public key should be %d bytes, got %d", PublicKeyLen, len(compressedBytes))
|
||||
}
|
||||
|
||||
// Test uncompressed bytes (should be same as compressed for circl)
|
||||
uncompressedBytes := PublicKeyToUncompressedBytes(pk)
|
||||
if !bytes.Equal(compressedBytes, uncompressedBytes) {
|
||||
t.Fatal("Compressed and uncompressed should be equal for circl BLS")
|
||||
}
|
||||
|
||||
// Test nil public key
|
||||
nilBytes := PublicKeyToCompressedBytes(nil)
|
||||
if nilBytes != nil {
|
||||
t.Fatal("Nil public key should return nil bytes")
|
||||
}
|
||||
|
||||
// Test public key with nil internal
|
||||
emptyPk := &PublicKey{}
|
||||
emptyBytes := PublicKeyToCompressedBytes(emptyPk)
|
||||
if emptyBytes != nil {
|
||||
t.Fatal("Empty public key should return nil bytes")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPublicKeyFromBytes(t *testing.T) {
|
||||
sk, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate secret key: %v", err)
|
||||
}
|
||||
|
||||
pk := sk.PublicKey()
|
||||
pkBytes := PublicKeyToCompressedBytes(pk)
|
||||
|
||||
// Test valid deserialization
|
||||
pk2, err := PublicKeyFromCompressedBytes(pkBytes)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to deserialize public key: %v", err)
|
||||
}
|
||||
|
||||
pkBytes2 := PublicKeyToCompressedBytes(pk2)
|
||||
if !bytes.Equal(pkBytes, pkBytes2) {
|
||||
t.Fatal("Round-trip public key bytes should match")
|
||||
}
|
||||
|
||||
// Test from valid uncompressed bytes
|
||||
pk3 := PublicKeyFromValidUncompressedBytes(pkBytes)
|
||||
if pk3 == nil {
|
||||
t.Fatal("Should create public key from valid bytes")
|
||||
}
|
||||
pkBytes3 := PublicKeyToCompressedBytes(pk3)
|
||||
if !bytes.Equal(pkBytes, pkBytes3) {
|
||||
t.Fatal("Public key from valid bytes should match")
|
||||
}
|
||||
}
|
||||
|
||||
func TestPublicKeyFromBytesErrors(t *testing.T) {
|
||||
// Test with wrong size
|
||||
invalidBytes := make([]byte, 10)
|
||||
_, err := PublicKeyFromCompressedBytes(invalidBytes)
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with wrong size bytes")
|
||||
}
|
||||
|
||||
// Test with nil
|
||||
_, err = PublicKeyFromCompressedBytes(nil)
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with nil bytes")
|
||||
}
|
||||
|
||||
// Test with invalid point (all zeros)
|
||||
zeroBytes := make([]byte, PublicKeyLen)
|
||||
_, err = PublicKeyFromCompressedBytes(zeroBytes)
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with invalid point")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSignAndVerify(t *testing.T) {
|
||||
sk, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate secret key: %v", err)
|
||||
}
|
||||
|
||||
pk := sk.PublicKey()
|
||||
msg := []byte("test message")
|
||||
|
||||
// Sign message
|
||||
sig := sk.Sign(msg)
|
||||
if sig == nil {
|
||||
t.Fatal("Signature should not be nil")
|
||||
}
|
||||
|
||||
// Verify signature
|
||||
valid := Verify(pk, sig, msg)
|
||||
if !valid {
|
||||
t.Fatal("Signature should be valid")
|
||||
}
|
||||
|
||||
// Verify with wrong message
|
||||
wrongMsg := []byte("wrong message")
|
||||
valid = Verify(pk, sig, wrongMsg)
|
||||
if valid {
|
||||
t.Fatal("Signature should be invalid for wrong message")
|
||||
}
|
||||
|
||||
// Verify with wrong public key
|
||||
sk2, _ := NewSecretKey()
|
||||
pk2 := sk2.PublicKey()
|
||||
valid = Verify(pk2, sig, msg)
|
||||
if valid {
|
||||
t.Fatal("Signature should be invalid for wrong public key")
|
||||
}
|
||||
|
||||
// Test nil cases
|
||||
nilSig := sk.Sign(nil)
|
||||
if nilSig == nil {
|
||||
t.Fatal("Should handle nil message")
|
||||
}
|
||||
|
||||
var nilSk *SecretKey
|
||||
nilSig2 := nilSk.Sign(msg)
|
||||
if nilSig2 != nil {
|
||||
t.Fatal("Nil secret key should return nil signature")
|
||||
}
|
||||
|
||||
emptySk := &SecretKey{}
|
||||
emptySig := emptySk.Sign(msg)
|
||||
if emptySig != nil {
|
||||
t.Fatal("Empty secret key should return nil signature")
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerifyEdgeCases(t *testing.T) {
|
||||
sk, _ := NewSecretKey()
|
||||
pk := sk.PublicKey()
|
||||
msg := []byte("test")
|
||||
sig := sk.Sign(msg)
|
||||
|
||||
// Test nil public key
|
||||
valid := Verify(nil, sig, msg)
|
||||
if valid {
|
||||
t.Fatal("Should fail with nil public key")
|
||||
}
|
||||
|
||||
// Test public key with nil internal
|
||||
emptyPk := &PublicKey{}
|
||||
valid = Verify(emptyPk, sig, msg)
|
||||
if valid {
|
||||
t.Fatal("Should fail with empty public key")
|
||||
}
|
||||
|
||||
// Test nil signature
|
||||
valid = Verify(pk, nil, msg)
|
||||
if valid {
|
||||
t.Fatal("Should fail with nil signature")
|
||||
}
|
||||
}
|
||||
|
||||
func TestProofOfPossession(t *testing.T) {
|
||||
sk, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate secret key: %v", err)
|
||||
}
|
||||
|
||||
pk := sk.PublicKey()
|
||||
msg := []byte("proof of possession")
|
||||
|
||||
// Sign proof of possession
|
||||
sig := sk.SignProofOfPossession(msg)
|
||||
if sig == nil {
|
||||
t.Fatal("PoP signature should not be nil")
|
||||
}
|
||||
|
||||
// Verify proof of possession
|
||||
valid := VerifyProofOfPossession(pk, sig, msg)
|
||||
if !valid {
|
||||
t.Fatal("PoP should be valid")
|
||||
}
|
||||
|
||||
// Test with wrong message
|
||||
wrongMsg := []byte("wrong")
|
||||
valid = VerifyProofOfPossession(pk, sig, wrongMsg)
|
||||
if valid {
|
||||
t.Fatal("PoP should be invalid for wrong message")
|
||||
}
|
||||
|
||||
// Test nil cases
|
||||
var nilSk *SecretKey
|
||||
nilSig := nilSk.SignProofOfPossession(msg)
|
||||
if nilSig != nil {
|
||||
t.Fatal("Nil secret key should return nil PoP")
|
||||
}
|
||||
|
||||
emptySk := &SecretKey{}
|
||||
emptySig := emptySk.SignProofOfPossession(msg)
|
||||
if emptySig != nil {
|
||||
t.Fatal("Empty secret key should return nil PoP")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSignatureBytes(t *testing.T) {
|
||||
sk, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate secret key: %v", err)
|
||||
}
|
||||
|
||||
msg := []byte("test")
|
||||
sig := sk.Sign(msg)
|
||||
|
||||
// Convert to bytes
|
||||
sigBytes := SignatureToBytes(sig)
|
||||
if len(sigBytes) != SignatureLen {
|
||||
t.Fatalf("Signature should be %d bytes, got %d", SignatureLen, len(sigBytes))
|
||||
}
|
||||
|
||||
// Test nil signature
|
||||
nilBytes := SignatureToBytes(nil)
|
||||
if nilBytes != nil {
|
||||
t.Fatal("Nil signature should return nil bytes")
|
||||
}
|
||||
|
||||
// Round-trip test
|
||||
sig2, err := SignatureFromBytes(sigBytes)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to deserialize signature: %v", err)
|
||||
}
|
||||
|
||||
sigBytes2 := SignatureToBytes(sig2)
|
||||
if !bytes.Equal(sigBytes, sigBytes2) {
|
||||
t.Fatal("Round-trip signature bytes should match")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSignatureFromBytesErrors(t *testing.T) {
|
||||
// Test wrong size
|
||||
invalidBytes := make([]byte, 10)
|
||||
_, err := SignatureFromBytes(invalidBytes)
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with wrong size")
|
||||
}
|
||||
|
||||
// Test all zeros (invalid signature)
|
||||
zeroBytes := make([]byte, SignatureLen)
|
||||
_, err = SignatureFromBytes(zeroBytes)
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with all zero bytes")
|
||||
}
|
||||
|
||||
// Test nil
|
||||
_, err = SignatureFromBytes(nil)
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with nil bytes")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAggregatePublicKeysEdgeCases(t *testing.T) {
|
||||
// Test empty slice
|
||||
_, err := AggregatePublicKeys([]*PublicKey{})
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with empty slice")
|
||||
}
|
||||
|
||||
// Test with nil public key in slice
|
||||
sk1, _ := NewSecretKey()
|
||||
pk1 := sk1.PublicKey()
|
||||
|
||||
_, err = AggregatePublicKeys([]*PublicKey{pk1, nil})
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with nil public key in slice")
|
||||
}
|
||||
|
||||
// Test with public key with nil internal
|
||||
emptyPk := &PublicKey{}
|
||||
_, err = AggregatePublicKeys([]*PublicKey{pk1, emptyPk})
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with empty public key in slice")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAggregateSignaturesEdgeCases(t *testing.T) {
|
||||
// Test empty slice
|
||||
_, err := AggregateSignatures([]*Signature{})
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with empty slice")
|
||||
}
|
||||
|
||||
// Test with nil signature in slice
|
||||
sk1, _ := NewSecretKey()
|
||||
msg := []byte("test")
|
||||
sig1 := sk1.Sign(msg)
|
||||
|
||||
_, err = AggregateSignatures([]*Signature{sig1, nil})
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with nil signature in slice")
|
||||
}
|
||||
}
|
||||
|
||||
func TestMultipleAggregation(t *testing.T) {
|
||||
// Create multiple keys
|
||||
numKeys := 5
|
||||
sks := make([]*SecretKey, numKeys)
|
||||
pks := make([]*PublicKey, numKeys)
|
||||
sigs := make([]*Signature, numKeys)
|
||||
|
||||
msg := []byte("aggregate test message")
|
||||
|
||||
for i := 0; i < numKeys; i++ {
|
||||
sk, err := NewSecretKey()
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to generate key %d: %v", i, err)
|
||||
}
|
||||
sks[i] = sk
|
||||
pks[i] = sk.PublicKey()
|
||||
sigs[i] = sk.Sign(msg)
|
||||
}
|
||||
|
||||
// Aggregate public keys
|
||||
aggPk, err := AggregatePublicKeys(pks)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to aggregate public keys: %v", err)
|
||||
}
|
||||
if aggPk == nil {
|
||||
t.Fatal("Aggregated public key should not be nil")
|
||||
}
|
||||
|
||||
// Aggregate signatures
|
||||
aggSig, err := AggregateSignatures(sigs)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to aggregate signatures: %v", err)
|
||||
}
|
||||
if aggSig == nil {
|
||||
t.Fatal("Aggregated signature should not be nil")
|
||||
}
|
||||
|
||||
// Verify aggregated signature
|
||||
valid := Verify(aggPk, aggSig, msg)
|
||||
if !valid {
|
||||
t.Fatal("Aggregated signature should be valid")
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkKeyGenerationExtended(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, err := NewSecretKey()
|
||||
if err != nil {
|
||||
b.Fatal(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkSignExtended(b *testing.B) {
|
||||
sk, _ := NewSecretKey()
|
||||
msg := []byte("benchmark message")
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = sk.Sign(msg)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkVerifyExtended(b *testing.B) {
|
||||
sk, _ := NewSecretKey()
|
||||
pk := sk.PublicKey()
|
||||
msg := []byte("benchmark message")
|
||||
sig := sk.Sign(msg)
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = Verify(pk, sig, msg)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkAggregatePublicKeysExtended(b *testing.B) {
|
||||
numKeys := 10
|
||||
pks := make([]*PublicKey, numKeys)
|
||||
|
||||
for i := 0; i < numKeys; i++ {
|
||||
sk, _ := NewSecretKey()
|
||||
pks[i] = sk.PublicKey()
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, _ = AggregatePublicKeys(pks)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkAggregateSignaturesExtended(b *testing.B) {
|
||||
numSigs := 10
|
||||
sigs := make([]*Signature, numSigs)
|
||||
msg := []byte("benchmark")
|
||||
|
||||
for i := 0; i < numSigs; i++ {
|
||||
sk, _ := NewSecretKey()
|
||||
sigs[i] = sk.Sign(msg)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_, _ = AggregateSignatures(sigs)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,204 @@
|
||||
package encryption
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestAgeEncryption(t *testing.T) {
|
||||
// Test with password
|
||||
t.Run("PasswordEncryption", func(t *testing.T) {
|
||||
data := []byte("test data for age encryption")
|
||||
password := "secure-password-123"
|
||||
|
||||
encrypted, err := EncryptDataWithPassword(data, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to encrypt: %v", err)
|
||||
}
|
||||
|
||||
if bytes.Equal(data, encrypted) {
|
||||
t.Fatal("Encrypted data should not equal original")
|
||||
}
|
||||
|
||||
// Check if data is recognized as age-encrypted
|
||||
if !IsAgeEncrypted(encrypted) {
|
||||
t.Fatal("Data should be recognized as age-encrypted")
|
||||
}
|
||||
|
||||
decrypted, err := DecryptPrivateKeyWithPassword(encrypted, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to decrypt: %v", err)
|
||||
}
|
||||
|
||||
if !bytes.Equal(data, decrypted) {
|
||||
t.Fatal("Decrypted data doesn't match original")
|
||||
}
|
||||
|
||||
// Test wrong password
|
||||
wrongPassword := "wrong-password"
|
||||
_, err = DecryptPrivateKeyWithPassword(encrypted, wrongPassword)
|
||||
if err == nil {
|
||||
t.Fatal("Should fail with wrong password")
|
||||
}
|
||||
})
|
||||
|
||||
// Test file encryption
|
||||
t.Run("FileEncryption", func(t *testing.T) {
|
||||
tmpDir := t.TempDir()
|
||||
inputFile := filepath.Join(tmpDir, "input.txt")
|
||||
encryptedFile := filepath.Join(tmpDir, "encrypted.age")
|
||||
|
||||
testData := []byte("file encryption test data")
|
||||
if err := os.WriteFile(inputFile, testData, 0644); err != nil {
|
||||
t.Fatalf("Failed to write test file: %v", err)
|
||||
}
|
||||
|
||||
password := "file-password"
|
||||
|
||||
// Encrypt data
|
||||
encrypted, err := EncryptDataWithPassword(testData, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to encrypt data: %v", err)
|
||||
}
|
||||
|
||||
// Write encrypted data to file
|
||||
if err := os.WriteFile(encryptedFile, encrypted, 0644); err != nil {
|
||||
t.Fatalf("Failed to write encrypted file: %v", err)
|
||||
}
|
||||
|
||||
// Decrypt file
|
||||
decrypted, err := DecryptFile(encryptedFile, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to decrypt file: %v", err)
|
||||
}
|
||||
|
||||
if !bytes.Equal(testData, decrypted) {
|
||||
t.Fatal("Decrypted file content doesn't match original")
|
||||
}
|
||||
|
||||
// Test with unencrypted file
|
||||
unencrypted, err := DecryptFile(inputFile, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to read unencrypted file: %v", err)
|
||||
}
|
||||
|
||||
if !bytes.Equal(testData, unencrypted) {
|
||||
t.Fatal("Unencrypted file should be returned as-is")
|
||||
}
|
||||
})
|
||||
|
||||
// Test IsAgeEncrypted
|
||||
t.Run("IsAgeEncrypted", func(t *testing.T) {
|
||||
// Test with encrypted data
|
||||
data := []byte("test data")
|
||||
password := "test-password"
|
||||
encrypted, err := EncryptDataWithPassword(data, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to encrypt: %v", err)
|
||||
}
|
||||
|
||||
if !IsAgeEncrypted(encrypted) {
|
||||
t.Fatal("Should detect age-encrypted data")
|
||||
}
|
||||
|
||||
// Test with non-encrypted data
|
||||
plainData := []byte("plain text data")
|
||||
if IsAgeEncrypted(plainData) {
|
||||
t.Fatal("Should not detect plain data as encrypted")
|
||||
}
|
||||
|
||||
// Test with data that starts with "age-" but is not encrypted
|
||||
fakeAge := []byte("age-something but not encrypted")
|
||||
if IsAgeEncrypted(fakeAge) {
|
||||
t.Fatal("Should not detect fake age data as encrypted")
|
||||
}
|
||||
})
|
||||
|
||||
// Test empty data
|
||||
t.Run("EmptyData", func(t *testing.T) {
|
||||
password := "test-password"
|
||||
|
||||
// Encrypt empty data
|
||||
encrypted, err := EncryptDataWithPassword([]byte{}, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to encrypt empty data: %v", err)
|
||||
}
|
||||
|
||||
// Decrypt empty data
|
||||
decrypted, err := DecryptPrivateKeyWithPassword(encrypted, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to decrypt empty data: %v", err)
|
||||
}
|
||||
|
||||
if len(decrypted) != 0 {
|
||||
t.Fatal("Decrypted empty data should be empty")
|
||||
}
|
||||
})
|
||||
|
||||
// Test large data
|
||||
t.Run("LargeData", func(t *testing.T) {
|
||||
// Create 1MB of data
|
||||
largeData := make([]byte, 1024*1024)
|
||||
for i := range largeData {
|
||||
largeData[i] = byte(i % 256)
|
||||
}
|
||||
|
||||
password := "large-data-password"
|
||||
|
||||
encrypted, err := EncryptDataWithPassword(largeData, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to encrypt large data: %v", err)
|
||||
}
|
||||
|
||||
decrypted, err := DecryptPrivateKeyWithPassword(encrypted, password)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to decrypt large data: %v", err)
|
||||
}
|
||||
|
||||
if !bytes.Equal(largeData, decrypted) {
|
||||
t.Fatal("Decrypted large data doesn't match original")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
func BenchmarkAgeEncryption(b *testing.B) {
|
||||
data := make([]byte, 1024)
|
||||
for i := range data {
|
||||
data[i] = byte(i % 256)
|
||||
}
|
||||
password := "benchmark-password"
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
encrypted, _ := EncryptDataWithPassword(data, password)
|
||||
DecryptPrivateKeyWithPassword(encrypted, password)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkAgeEncryptionLarge(b *testing.B) {
|
||||
// 1MB data
|
||||
data := make([]byte, 1024*1024)
|
||||
for i := range data {
|
||||
data[i] = byte(i % 256)
|
||||
}
|
||||
password := "benchmark-password"
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
encrypted, _ := EncryptDataWithPassword(data, password)
|
||||
DecryptPrivateKeyWithPassword(encrypted, password)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkIsAgeEncrypted(b *testing.B) {
|
||||
encrypted, _ := EncryptDataWithPassword([]byte("test"), "password")
|
||||
plain := []byte("plain text data")
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
IsAgeEncrypted(encrypted)
|
||||
IsAgeEncrypted(plain)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,382 @@
|
||||
package blake3
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"math/big"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestNew(t *testing.T) {
|
||||
h := New()
|
||||
if h == nil {
|
||||
t.Fatal("New() returned nil")
|
||||
}
|
||||
if h.h == nil {
|
||||
t.Fatal("Internal hasher is nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewWithDomain(t *testing.T) {
|
||||
domain := "test-domain"
|
||||
h1 := NewWithDomain(domain)
|
||||
h2 := NewWithDomain(domain)
|
||||
|
||||
data := []byte("test data")
|
||||
h1.Write(data)
|
||||
h2.Write(data)
|
||||
|
||||
d1 := h1.Digest()
|
||||
d2 := h2.Digest()
|
||||
|
||||
if !bytes.Equal(d1[:], d2[:]) {
|
||||
t.Error("Same domain should produce same hash")
|
||||
}
|
||||
|
||||
// Different domain should produce different hash
|
||||
h3 := NewWithDomain("different-domain")
|
||||
h3.Write(data)
|
||||
d3 := h3.Digest()
|
||||
|
||||
if bytes.Equal(d1[:], d3[:]) {
|
||||
t.Error("Different domain should produce different hash")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHashBytes(t *testing.T) {
|
||||
// Test with known test vectors
|
||||
testCases := []struct {
|
||||
input []byte
|
||||
expected string // First 64 bytes of hash
|
||||
}{
|
||||
{
|
||||
[]byte(""),
|
||||
"af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262e00f03e7b69af26b7faaf09fcd333050338ddfe085b8cc869ca98b206c08243a",
|
||||
},
|
||||
{
|
||||
[]byte("hello"),
|
||||
"ea8f163db38682925e4491c5e58d4bb3506ef8c14eb78a86e908c5624a67200fe992405f0d785b599a2e3387f6d34d01faccfeb22fb697ef3fd53541241a338c",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
hash := HashBytes(tc.input)
|
||||
hashStr := hex.EncodeToString(hash[:])
|
||||
if hashStr != tc.expected {
|
||||
t.Errorf("HashBytes(%q) = %s, want %s", tc.input, hashStr, tc.expected)
|
||||
}
|
||||
}
|
||||
|
||||
// Test consistency
|
||||
data := []byte("test data")
|
||||
h1 := HashBytes(data)
|
||||
h2 := HashBytes(data)
|
||||
|
||||
if !bytes.Equal(h1[:], h2[:]) {
|
||||
t.Error("Same input should produce same hash")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHashString(t *testing.T) {
|
||||
// Test consistency
|
||||
s := "test string"
|
||||
h1 := HashString(s)
|
||||
h2 := HashString(s)
|
||||
|
||||
if !bytes.Equal(h1[:], h2[:]) {
|
||||
t.Error("Same string should produce same hash")
|
||||
}
|
||||
|
||||
// Compare with HashBytes
|
||||
h3 := HashBytes([]byte(s))
|
||||
if !bytes.Equal(h1[:], h3[:]) {
|
||||
t.Error("HashString should match HashBytes for same content")
|
||||
}
|
||||
|
||||
// Different strings produce different hashes
|
||||
h4 := HashString("different string")
|
||||
if bytes.Equal(h1[:], h4[:]) {
|
||||
t.Error("Different strings should produce different hashes")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHashWithDomain(t *testing.T) {
|
||||
data := []byte("test data")
|
||||
domain1 := "domain1"
|
||||
domain2 := "domain2"
|
||||
|
||||
h1 := HashWithDomain(domain1, data)
|
||||
h2 := HashWithDomain(domain1, data)
|
||||
h3 := HashWithDomain(domain2, data)
|
||||
|
||||
// Same domain and data should produce same hash
|
||||
if !bytes.Equal(h1[:], h2[:]) {
|
||||
t.Error("Same domain and data should produce same hash")
|
||||
}
|
||||
|
||||
// Different domain should produce different hash
|
||||
if bytes.Equal(h1[:], h3[:]) {
|
||||
t.Error("Different domain should produce different hash")
|
||||
}
|
||||
|
||||
// Should differ from hash without domain
|
||||
h4 := HashBytes(data)
|
||||
if bytes.Equal(h1[:], h4[:]) {
|
||||
t.Error("Hash with domain should differ from hash without domain")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteMethods(t *testing.T) {
|
||||
h := New()
|
||||
|
||||
// Test Write
|
||||
n, err := h.Write([]byte("test"))
|
||||
if err != nil {
|
||||
t.Errorf("Write error: %v", err)
|
||||
}
|
||||
if n != 4 {
|
||||
t.Errorf("Write returned %d, want 4", n)
|
||||
}
|
||||
|
||||
// Test WriteString
|
||||
n, err = h.WriteString("string")
|
||||
if err != nil {
|
||||
t.Errorf("WriteString error: %v", err)
|
||||
}
|
||||
if n != 6 {
|
||||
t.Errorf("WriteString returned %d, want 6", n)
|
||||
}
|
||||
|
||||
// Test WriteUint32
|
||||
h.WriteUint32(0x12345678)
|
||||
|
||||
// Test WriteUint64
|
||||
h.WriteUint64(0x123456789ABCDEF0)
|
||||
|
||||
// Test WriteBigInt
|
||||
bigNum := big.NewInt(1234567890)
|
||||
h.WriteBigInt(bigNum)
|
||||
|
||||
// Test WriteBigInt with nil
|
||||
h.WriteBigInt(nil)
|
||||
|
||||
// Get digest to ensure it doesn't panic
|
||||
_ = h.Digest()
|
||||
}
|
||||
|
||||
func TestWriteUint32(t *testing.T) {
|
||||
h1 := New()
|
||||
h1.WriteUint32(0x12345678)
|
||||
d1 := h1.Digest()
|
||||
|
||||
// Should be same as writing the bytes in big-endian
|
||||
h2 := New()
|
||||
h2.Write([]byte{0x12, 0x34, 0x56, 0x78})
|
||||
d2 := h2.Digest()
|
||||
|
||||
if !bytes.Equal(d1[:], d2[:]) {
|
||||
t.Error("WriteUint32 should write in big-endian format")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteUint64(t *testing.T) {
|
||||
h1 := New()
|
||||
h1.WriteUint64(0x123456789ABCDEF0)
|
||||
d1 := h1.Digest()
|
||||
|
||||
// Should be same as writing the bytes in big-endian
|
||||
h2 := New()
|
||||
h2.Write([]byte{0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0})
|
||||
d2 := h2.Digest()
|
||||
|
||||
if !bytes.Equal(d1[:], d2[:]) {
|
||||
t.Error("WriteUint64 should write in big-endian format")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWriteBigInt(t *testing.T) {
|
||||
// Test with normal big int
|
||||
n := big.NewInt(1234567890)
|
||||
h1 := New()
|
||||
h1.WriteBigInt(n)
|
||||
d1 := h1.Digest()
|
||||
|
||||
// Writing same number should produce same hash
|
||||
h2 := New()
|
||||
h2.WriteBigInt(n)
|
||||
d2 := h2.Digest()
|
||||
|
||||
if !bytes.Equal(d1[:], d2[:]) {
|
||||
t.Error("Same big.Int should produce same hash")
|
||||
}
|
||||
|
||||
// Test with nil
|
||||
h3 := New()
|
||||
h3.WriteBigInt(nil)
|
||||
d3 := h3.Digest()
|
||||
|
||||
// Nil should write a zero length prefix
|
||||
h4 := New()
|
||||
h4.WriteUint32(0)
|
||||
d4 := h4.Digest()
|
||||
|
||||
if !bytes.Equal(d3[:], d4[:]) {
|
||||
t.Error("WriteBigInt(nil) should write zero length")
|
||||
}
|
||||
|
||||
// Test with zero
|
||||
zero := big.NewInt(0)
|
||||
h5 := New()
|
||||
h5.WriteBigInt(zero)
|
||||
_ = h5.Digest() // Should not panic
|
||||
}
|
||||
|
||||
func TestSum(t *testing.T) {
|
||||
h := New()
|
||||
h.WriteString("test")
|
||||
|
||||
// Sum with nil
|
||||
sum1 := h.Sum(nil)
|
||||
if len(sum1) != 32 { // Default blake3 output
|
||||
t.Errorf("Sum(nil) length = %d, want 32", len(sum1))
|
||||
}
|
||||
|
||||
// Sum with existing slice
|
||||
prefix := []byte("prefix")
|
||||
sum2 := h.Sum(prefix)
|
||||
if !bytes.HasPrefix(sum2, prefix) {
|
||||
t.Error("Sum should append to provided slice")
|
||||
}
|
||||
if len(sum2) != len(prefix)+32 {
|
||||
t.Errorf("Sum length = %d, want %d", len(sum2), len(prefix)+32)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDigest(t *testing.T) {
|
||||
h := New()
|
||||
h.WriteString("test")
|
||||
d := h.Digest()
|
||||
|
||||
if len(d) != DigestLength {
|
||||
t.Errorf("Digest length = %d, want %d", len(d), DigestLength)
|
||||
}
|
||||
|
||||
// Digest should be consistent
|
||||
h2 := New()
|
||||
h2.WriteString("test")
|
||||
d2 := h2.Digest()
|
||||
|
||||
if !bytes.Equal(d[:], d2[:]) {
|
||||
t.Error("Same input should produce same digest")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReader(t *testing.T) {
|
||||
h := New()
|
||||
h.WriteString("test")
|
||||
|
||||
reader := h.Reader()
|
||||
if reader == nil {
|
||||
t.Fatal("Reader() returned nil")
|
||||
}
|
||||
|
||||
// Read some bytes
|
||||
buf := make([]byte, 100)
|
||||
n, err := reader.Read(buf)
|
||||
if err != nil {
|
||||
t.Errorf("Reader.Read error: %v", err)
|
||||
}
|
||||
if n != 100 {
|
||||
t.Errorf("Reader.Read returned %d, want 100", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClone(t *testing.T) {
|
||||
h1 := New()
|
||||
h1.WriteString("test")
|
||||
|
||||
h2 := h1.Clone()
|
||||
if h2 == nil {
|
||||
t.Fatal("Clone() returned nil")
|
||||
}
|
||||
|
||||
// Both should produce same digest at this point
|
||||
d1 := h1.Digest()
|
||||
d2 := h2.Digest()
|
||||
|
||||
if !bytes.Equal(d1[:], d2[:]) {
|
||||
t.Error("Clone should produce same digest")
|
||||
}
|
||||
|
||||
// Writing to one shouldn't affect the other
|
||||
h1.WriteString("more")
|
||||
d1New := h1.Digest()
|
||||
d2New := h2.Digest()
|
||||
|
||||
if bytes.Equal(d1New[:], d2New[:]) {
|
||||
t.Error("Writing to original should not affect clone")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReset(t *testing.T) {
|
||||
h := New()
|
||||
h.WriteString("test")
|
||||
d1 := h.Digest()
|
||||
|
||||
h.Reset()
|
||||
h.WriteString("test")
|
||||
d2 := h.Digest()
|
||||
|
||||
if !bytes.Equal(d1[:], d2[:]) {
|
||||
t.Error("Reset should restore initial state")
|
||||
}
|
||||
|
||||
// After reset, different input should produce different hash
|
||||
h.Reset()
|
||||
h.WriteString("different")
|
||||
d3 := h.Digest()
|
||||
|
||||
if bytes.Equal(d1[:], d3[:]) {
|
||||
t.Error("After reset, different input should produce different hash")
|
||||
}
|
||||
}
|
||||
|
||||
func TestDigestLength(t *testing.T) {
|
||||
if DigestLength != 64 {
|
||||
t.Errorf("DigestLength = %d, want 64", DigestLength)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkHashBytes(b *testing.B) {
|
||||
data := make([]byte, 1024)
|
||||
for i := range data {
|
||||
data[i] = byte(i % 256)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = HashBytes(data)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkHashString(b *testing.B) {
|
||||
data := strings.Repeat("benchmark", 128)
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = HashString(data)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkWriteBigInt(b *testing.B) {
|
||||
n := new(big.Int)
|
||||
n.SetString("123456789012345678901234567890123456789012345678901234567890", 10)
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
h := New()
|
||||
h.WriteBigInt(n)
|
||||
_ = h.Digest()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,299 @@
|
||||
package hashing
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestComputeHash256(t *testing.T) {
|
||||
// Test with known vectors
|
||||
testCases := []struct {
|
||||
name string
|
||||
input []byte
|
||||
expected string
|
||||
}{
|
||||
{
|
||||
"empty",
|
||||
[]byte(""),
|
||||
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
|
||||
},
|
||||
{
|
||||
"abc",
|
||||
[]byte("abc"),
|
||||
"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
|
||||
},
|
||||
{
|
||||
"fox",
|
||||
[]byte("The quick brown fox jumps over the lazy dog"),
|
||||
"d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
// Test ComputeHash256
|
||||
hash := ComputeHash256(tc.input)
|
||||
hashStr := hex.EncodeToString(hash)
|
||||
if hashStr != tc.expected {
|
||||
t.Errorf("ComputeHash256(%q) = %s, want %s", tc.input, hashStr, tc.expected)
|
||||
}
|
||||
|
||||
// Test ComputeHash256Array
|
||||
hashArray := ComputeHash256Array(tc.input)
|
||||
hashArrayStr := hex.EncodeToString(hashArray[:])
|
||||
if hashArrayStr != tc.expected {
|
||||
t.Errorf("ComputeHash256Array(%q) = %s, want %s", tc.input, hashArrayStr, tc.expected)
|
||||
}
|
||||
|
||||
// Verify slice and array produce same result
|
||||
if !bytes.Equal(hash, hashArray[:]) {
|
||||
t.Error("ComputeHash256 and ComputeHash256Array should produce same result")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestComputeHash160(t *testing.T) {
|
||||
testCases := []struct {
|
||||
name string
|
||||
input []byte
|
||||
expected string
|
||||
}{
|
||||
{
|
||||
"empty",
|
||||
[]byte(""),
|
||||
"9c1185a5c5e9fc54612808977ee8f548b2258d31",
|
||||
},
|
||||
{
|
||||
"abc",
|
||||
[]byte("abc"),
|
||||
"8eb208f7e05d987a9b044a8e98c6b087f15a0bfc",
|
||||
},
|
||||
{
|
||||
"message digest",
|
||||
[]byte("message digest"),
|
||||
"5d0689ef49d2fae572b881b123a85ffa21595f36",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
// Test ComputeHash160
|
||||
hash := ComputeHash160(tc.input)
|
||||
hashStr := hex.EncodeToString(hash)
|
||||
if hashStr != tc.expected {
|
||||
t.Errorf("ComputeHash160(%q) = %s, want %s", tc.input, hashStr, tc.expected)
|
||||
}
|
||||
|
||||
// Test ComputeHash160Array
|
||||
hashArray := ComputeHash160Array(tc.input)
|
||||
hashArrayStr := hex.EncodeToString(hashArray[:])
|
||||
if hashArrayStr != tc.expected {
|
||||
t.Errorf("ComputeHash160Array(%q) = %s, want %s", tc.input, hashArrayStr, tc.expected)
|
||||
}
|
||||
|
||||
// Verify slice and array produce same result
|
||||
if !bytes.Equal(hash, hashArray[:]) {
|
||||
t.Error("ComputeHash160 and ComputeHash160Array should produce same result")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestChecksum(t *testing.T) {
|
||||
input := []byte("test input for checksum")
|
||||
|
||||
// Test various checksum lengths
|
||||
lengths := []int{1, 4, 8, 16, 32}
|
||||
|
||||
for _, length := range lengths {
|
||||
checksum := Checksum(input, length)
|
||||
if len(checksum) != length {
|
||||
t.Errorf("Checksum length should be %d, got %d", length, len(checksum))
|
||||
}
|
||||
|
||||
// Verify checksum is last 'length' bytes of hash
|
||||
fullHash := ComputeHash256Array(input)
|
||||
expected := fullHash[len(fullHash)-length:]
|
||||
if !bytes.Equal(checksum, expected) {
|
||||
t.Errorf("Checksum should be last %d bytes of hash", length)
|
||||
}
|
||||
}
|
||||
|
||||
// Test that same input produces same checksum
|
||||
checksum1 := Checksum(input, 4)
|
||||
checksum2 := Checksum(input, 4)
|
||||
if !bytes.Equal(checksum1, checksum2) {
|
||||
t.Error("Same input should produce same checksum")
|
||||
}
|
||||
|
||||
// Test that different input produces different checksum
|
||||
input2 := []byte("different input")
|
||||
checksum3 := Checksum(input2, 4)
|
||||
if bytes.Equal(checksum1, checksum3) {
|
||||
t.Error("Different input should produce different checksum")
|
||||
}
|
||||
}
|
||||
|
||||
func TestToHash256(t *testing.T) {
|
||||
// Test valid conversion
|
||||
validBytes := make([]byte, HashLen)
|
||||
for i := range validBytes {
|
||||
validBytes[i] = byte(i)
|
||||
}
|
||||
|
||||
hash, err := ToHash256(validBytes)
|
||||
if err != nil {
|
||||
t.Errorf("ToHash256 with valid bytes should not error: %v", err)
|
||||
}
|
||||
|
||||
if !bytes.Equal(hash[:], validBytes) {
|
||||
t.Error("ToHash256 should copy bytes correctly")
|
||||
}
|
||||
|
||||
// Test invalid lengths
|
||||
invalidLengths := []int{0, 1, 31, 33, 100}
|
||||
for _, length := range invalidLengths {
|
||||
invalidBytes := make([]byte, length)
|
||||
_, err := ToHash256(invalidBytes)
|
||||
if err == nil {
|
||||
t.Errorf("ToHash256 should error with %d bytes", length)
|
||||
}
|
||||
if err != nil && err.Error() != ErrInvalidHashLen.Error() && !bytes.Contains([]byte(err.Error()), []byte("invalid hash length")) {
|
||||
t.Errorf("Expected ErrInvalidHashLen, got: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestToHash160(t *testing.T) {
|
||||
// Test valid conversion
|
||||
validBytes := make([]byte, AddrLen)
|
||||
for i := range validBytes {
|
||||
validBytes[i] = byte(i)
|
||||
}
|
||||
|
||||
hash, err := ToHash160(validBytes)
|
||||
if err != nil {
|
||||
t.Errorf("ToHash160 with valid bytes should not error: %v", err)
|
||||
}
|
||||
|
||||
if !bytes.Equal(hash[:], validBytes) {
|
||||
t.Error("ToHash160 should copy bytes correctly")
|
||||
}
|
||||
|
||||
// Test invalid lengths
|
||||
invalidLengths := []int{0, 1, 19, 21, 100}
|
||||
for _, length := range invalidLengths {
|
||||
invalidBytes := make([]byte, length)
|
||||
_, err := ToHash160(invalidBytes)
|
||||
if err == nil {
|
||||
t.Errorf("ToHash160 should error with %d bytes", length)
|
||||
}
|
||||
if err != nil && err.Error() != ErrInvalidHashLen.Error() && !bytes.Contains([]byte(err.Error()), []byte("invalid hash length")) {
|
||||
t.Errorf("Expected ErrInvalidHashLen, got: %v", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPubkeyBytesToAddress(t *testing.T) {
|
||||
// Test that address generation is consistent
|
||||
pubkey := []byte("test public key")
|
||||
|
||||
addr1 := PubkeyBytesToAddress(pubkey)
|
||||
addr2 := PubkeyBytesToAddress(pubkey)
|
||||
|
||||
if !bytes.Equal(addr1, addr2) {
|
||||
t.Error("Same pubkey should produce same address")
|
||||
}
|
||||
|
||||
// Test that different pubkeys produce different addresses
|
||||
pubkey2 := []byte("different public key")
|
||||
addr3 := PubkeyBytesToAddress(pubkey2)
|
||||
|
||||
if bytes.Equal(addr1, addr3) {
|
||||
t.Error("Different pubkeys should produce different addresses")
|
||||
}
|
||||
|
||||
// Test that address is 20 bytes (ripemd160 size)
|
||||
if len(addr1) != AddrLen {
|
||||
t.Errorf("Address should be %d bytes, got %d", AddrLen, len(addr1))
|
||||
}
|
||||
|
||||
// Test empty pubkey
|
||||
emptyAddr := PubkeyBytesToAddress([]byte{})
|
||||
if len(emptyAddr) != AddrLen {
|
||||
t.Errorf("Empty pubkey should still produce %d byte address", AddrLen)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHashConstants(t *testing.T) {
|
||||
// Verify constants match expected values
|
||||
if HashLen != 32 {
|
||||
t.Errorf("HashLen should be 32, got %d", HashLen)
|
||||
}
|
||||
|
||||
if AddrLen != 20 {
|
||||
t.Errorf("AddrLen should be 20, got %d", AddrLen)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkComputeHash256(b *testing.B) {
|
||||
input := make([]byte, 1024)
|
||||
for i := range input {
|
||||
input[i] = byte(i % 256)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = ComputeHash256(input)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkComputeHash256Array(b *testing.B) {
|
||||
input := make([]byte, 1024)
|
||||
for i := range input {
|
||||
input[i] = byte(i % 256)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = ComputeHash256Array(input)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkComputeHash160(b *testing.B) {
|
||||
input := make([]byte, 1024)
|
||||
for i := range input {
|
||||
input[i] = byte(i % 256)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = ComputeHash160(input)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkPubkeyBytesToAddress(b *testing.B) {
|
||||
pubkey := make([]byte, 65) // Typical pubkey size
|
||||
for i := range pubkey {
|
||||
pubkey[i] = byte(i % 256)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = PubkeyBytesToAddress(pubkey)
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkChecksum(b *testing.B) {
|
||||
input := make([]byte, 1024)
|
||||
for i := range input {
|
||||
input[i] = byte(i % 256)
|
||||
}
|
||||
|
||||
b.ResetTimer()
|
||||
for i := 0; i < b.N; i++ {
|
||||
_ = Checksum(input, 4)
|
||||
}
|
||||
}
|
||||
+14
-6
@@ -112,17 +112,21 @@ func (priv *PrivateKey) Sign(message []byte) (*Signature, error) {
|
||||
byteIndex := i / 8
|
||||
bitIndex := uint(i % 8)
|
||||
|
||||
var selectedKey []byte
|
||||
if byteIndex >= len(msgHash) {
|
||||
// Pad with zeros if message hash is shorter
|
||||
values[i] = priv.keys[2*i] // Use the "0" value
|
||||
selectedKey = priv.keys[2*i] // Use the "0" value
|
||||
} else {
|
||||
bit := (msgHash[byteIndex] >> (7 - bitIndex)) & 1
|
||||
if bit == 0 {
|
||||
values[i] = priv.keys[2*i] // Use the "0" value
|
||||
selectedKey = priv.keys[2*i] // Use the "0" value
|
||||
} else {
|
||||
values[i] = priv.keys[2*i+1] // Use the "1" value
|
||||
selectedKey = priv.keys[2*i+1] // Use the "1" value
|
||||
}
|
||||
}
|
||||
// Make a copy of the selected key value
|
||||
values[i] = make([]byte, len(selectedKey))
|
||||
copy(values[i], selectedKey)
|
||||
}
|
||||
|
||||
// Clear private key after use (one-time signature)
|
||||
@@ -150,17 +154,21 @@ func (priv *PrivateKey) SignHash(msgHash []byte) (*Signature, error) {
|
||||
byteIndex := i / 8
|
||||
bitIndex := uint(i % 8)
|
||||
|
||||
var selectedKey []byte
|
||||
if byteIndex >= len(msgHash) {
|
||||
// Pad with zeros if message hash is shorter
|
||||
values[i] = priv.keys[2*i] // Use the "0" value
|
||||
selectedKey = priv.keys[2*i] // Use the "0" value
|
||||
} else {
|
||||
bit := (msgHash[byteIndex] >> (7 - bitIndex)) & 1
|
||||
if bit == 0 {
|
||||
values[i] = priv.keys[2*i] // Use the "0" value
|
||||
selectedKey = priv.keys[2*i] // Use the "0" value
|
||||
} else {
|
||||
values[i] = priv.keys[2*i+1] // Use the "1" value
|
||||
selectedKey = priv.keys[2*i+1] // Use the "1" value
|
||||
}
|
||||
}
|
||||
// Make a copy of the selected key value
|
||||
values[i] = make([]byte, len(selectedKey))
|
||||
copy(values[i], selectedKey)
|
||||
}
|
||||
|
||||
// Clear private key after use (one-time signature)
|
||||
|
||||
@@ -192,7 +192,8 @@ func (l *LamportBatchVerify) Run(input []byte) ([]byte, error) {
|
||||
continue
|
||||
}
|
||||
|
||||
if pubKey.Verify(message, sig) {
|
||||
// message is actually a pre-hashed value
|
||||
if pubKey.VerifyHash(message, sig) {
|
||||
results[i] = 0x01
|
||||
} else {
|
||||
results[i] = 0x00
|
||||
|
||||
@@ -236,14 +236,18 @@ func TestLamportPrecompiles(t *testing.T) {
|
||||
priv, err := lamport.GenerateKey(rand.Reader, lamport.SHA256)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Get public key BEFORE signing (one-time signature clears private key)
|
||||
pubBytes := priv.Public().Bytes()
|
||||
|
||||
message := []byte("test message for lamport")
|
||||
sig, err := priv.Sign(message)
|
||||
messageHash := sha256.Sum256(message)
|
||||
|
||||
// Sign the hash directly (precompile expects pre-hashed input)
|
||||
sig, err := priv.SignHash(messageHash[:])
|
||||
require.NoError(t, err)
|
||||
|
||||
// Build precompile input
|
||||
messageHash := sha256.Sum256(message)
|
||||
sigBytes := sig.Bytes()
|
||||
pubBytes := priv.Public().Bytes()
|
||||
|
||||
input := make([]byte, 32+len(sigBytes)+len(pubBytes))
|
||||
copy(input[:32], messageHash[:])
|
||||
@@ -278,14 +282,18 @@ func TestLamportPrecompiles(t *testing.T) {
|
||||
priv, err := lamport.GenerateKey(rand.Reader, lamport.SHA512)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Get public key BEFORE signing (one-time signature clears private key)
|
||||
pubBytes := priv.Public().Bytes()
|
||||
|
||||
message := []byte("test message for lamport sha512")
|
||||
sig, err := priv.Sign(message)
|
||||
messageHash := sha512.Sum512(message)
|
||||
|
||||
// Sign the hash directly (precompile expects pre-hashed input)
|
||||
sig, err := priv.SignHash(messageHash[:])
|
||||
require.NoError(t, err)
|
||||
|
||||
// Build precompile input
|
||||
messageHash := sha512.Sum512(message)
|
||||
sigBytes := sig.Bytes()
|
||||
pubBytes := priv.Public().Bytes()
|
||||
|
||||
input := make([]byte, 64+len(sigBytes)+len(pubBytes))
|
||||
copy(input[:64], messageHash[:])
|
||||
@@ -317,17 +325,22 @@ func TestLamportPrecompiles(t *testing.T) {
|
||||
priv, err := lamport.GenerateKey(rand.Reader, lamport.SHA256)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Get public key BEFORE signing
|
||||
pub := priv.Public()
|
||||
pubs = append(pubs, pub)
|
||||
|
||||
message := []byte(fmt.Sprintf("message %d", i))
|
||||
messages = append(messages, message)
|
||||
|
||||
sig, err := priv.Sign(message)
|
||||
// Sign the hash directly
|
||||
msgHash := sha256.Sum256(message)
|
||||
sig, err := priv.SignHash(msgHash[:])
|
||||
require.NoError(t, err)
|
||||
sigs = append(sigs, sig)
|
||||
pubs = append(pubs, priv.Public())
|
||||
}
|
||||
|
||||
// Build batch input
|
||||
// Format: [num_sigs(4)][hash_type(1)][data...]
|
||||
// Format: [num_sigs(1)][hash_type(1)][data...]
|
||||
// data = [msg_hash][sig][pubkey] repeated
|
||||
|
||||
// Calculate total size
|
||||
@@ -336,11 +349,11 @@ func TestLamportPrecompiles(t *testing.T) {
|
||||
pubSize := len(pubs[0].Bytes())
|
||||
dataSize := numSigs * (hashSize + sigSize + pubSize)
|
||||
|
||||
input := make([]byte, 5+dataSize)
|
||||
binary.BigEndian.PutUint32(input[:4], uint32(numSigs))
|
||||
input[4] = 0 // SHA256
|
||||
input := make([]byte, 2+dataSize)
|
||||
input[0] = byte(numSigs)
|
||||
input[1] = 0 // SHA256
|
||||
|
||||
offset := 5
|
||||
offset := 2
|
||||
for i := 0; i < numSigs; i++ {
|
||||
hash := sha256.Sum256(messages[i])
|
||||
copy(input[offset:], hash[:])
|
||||
@@ -361,16 +374,20 @@ func TestLamportPrecompiles(t *testing.T) {
|
||||
// Test batch verification
|
||||
output, err := batchVerifier.Run(input)
|
||||
require.NoError(t, err)
|
||||
expected := make([]byte, 32)
|
||||
expected[31] = 1
|
||||
assert.Equal(t, expected, output, "All valid signatures should return 1")
|
||||
// Output format: [overall_valid][individual_results...]
|
||||
assert.Len(t, output, 1+numSigs, "Output should be 1+numSigs bytes")
|
||||
assert.Equal(t, byte(1), output[0], "All valid signatures should return overall 1")
|
||||
for i := 1; i <= numSigs; i++ {
|
||||
assert.Equal(t, byte(1), output[i], fmt.Sprintf("Signature %d should be valid", i-1))
|
||||
}
|
||||
|
||||
// Corrupt one signature
|
||||
input[5+hashSize] ^= 0xFF
|
||||
input[2+hashSize] ^= 0xFF
|
||||
|
||||
output, err = batchVerifier.Run(input)
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, []byte{0}, output, "Any invalid signature should return 0")
|
||||
assert.Equal(t, byte(0), output[0], "Any invalid signature should return overall 0")
|
||||
assert.Equal(t, byte(0), output[1], "First signature should be invalid")
|
||||
})
|
||||
|
||||
t.Run("LamportMerkleRoot", func(t *testing.T) {
|
||||
@@ -387,13 +404,13 @@ func TestLamportPrecompiles(t *testing.T) {
|
||||
}
|
||||
|
||||
// Build input
|
||||
// Format: [num_keys(4)][hash_type(1)][pubkeys...]
|
||||
// Format: [num_keys(1)][hash_type(1)][pubkeys...]
|
||||
pubSize := len(pubs[0].Bytes())
|
||||
input := make([]byte, 5+numKeys*pubSize)
|
||||
binary.BigEndian.PutUint32(input[:4], uint32(numKeys))
|
||||
input[4] = 0 // SHA256
|
||||
input := make([]byte, 2+numKeys*pubSize)
|
||||
input[0] = byte(numKeys)
|
||||
input[1] = 0 // SHA256
|
||||
|
||||
offset := 5
|
||||
offset := 2
|
||||
for _, pub := range pubs {
|
||||
copy(input[offset:], pub.Bytes())
|
||||
offset += pubSize
|
||||
@@ -451,17 +468,17 @@ func TestBLSPrecompiles(t *testing.T) {
|
||||
aggVerifier := &BLSAggregateVerify{}
|
||||
|
||||
// Build aggregate input
|
||||
// Format: [num_sigs(4)][signatures][pubkeys][encoded_messages]
|
||||
// Format: [num_sigs(1)][signatures][pubkeys][encoded_messages]
|
||||
numSigs := 3
|
||||
sigSize := 96
|
||||
pubSize := 48
|
||||
msgSize := 32
|
||||
|
||||
totalSize := 4 + numSigs*(sigSize+pubSize+4+msgSize)
|
||||
totalSize := 1 + numSigs*(sigSize+pubSize+4+msgSize)
|
||||
input := make([]byte, totalSize)
|
||||
binary.BigEndian.PutUint32(input[:4], uint32(numSigs))
|
||||
input[0] = byte(numSigs)
|
||||
|
||||
offset := 4
|
||||
offset := 1
|
||||
// Add signatures
|
||||
for i := 0; i < numSigs; i++ {
|
||||
rand.Read(input[offset : offset+sigSize])
|
||||
@@ -484,7 +501,8 @@ func TestBLSPrecompiles(t *testing.T) {
|
||||
|
||||
// Test gas
|
||||
gas := aggVerifier.RequiredGas(input)
|
||||
expectedGas := uint64(200000 + 30000*uint64(numSigs))
|
||||
// blsAggregateVerifyGas = 100000, blsPerSignatureGas = 10000
|
||||
expectedGas := uint64(100000 + 10000*uint64(numSigs))
|
||||
assert.Equal(t, expectedGas, gas)
|
||||
|
||||
// Test run
|
||||
@@ -803,11 +821,11 @@ func TestCrossPrecompileWorkflows(t *testing.T) {
|
||||
|
||||
// Compute merkle root
|
||||
pubSize := len(pubKeys[0].Bytes())
|
||||
rootInput := make([]byte, 5+numKeys*pubSize)
|
||||
binary.BigEndian.PutUint32(rootInput[:4], uint32(numKeys))
|
||||
rootInput[4] = 0 // SHA256
|
||||
rootInput := make([]byte, 2+numKeys*pubSize)
|
||||
rootInput[0] = byte(numKeys)
|
||||
rootInput[1] = 0 // SHA256
|
||||
|
||||
offset := 5
|
||||
offset := 2
|
||||
for _, pub := range pubKeys {
|
||||
copy(rootInput[offset:], pub.Bytes())
|
||||
offset += pubSize
|
||||
|
||||
Reference in New Issue
Block a user