mleku
3966183137
This commit introduces two new files: `BENCHMARK_RESULTS.md` and `benchmark_results.txt`, which document the performance metrics of various cryptographic operations, including ECDSA signing, verification, and ECDH key exchange. The results provide insights into operation times, memory allocations, and comparisons with C implementations. Additionally, new test files for ECDSA and ECDH functionalities have been added, ensuring comprehensive coverage and validation of the implemented algorithms. This enhances the overall robustness and performance understanding of the secp256k1 implementation.
135 lines
2.6 KiB
Go
135 lines
2.6 KiB
Go
package p256k1
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
func TestSHA256(t *testing.T) {
|
|
// Test basic SHA-256 functionality
|
|
h := NewSHA256()
|
|
testData := []byte("For this sample, this 63-byte string will be used as input data")
|
|
h.Write(testData)
|
|
|
|
var result [32]byte
|
|
h.Finalize(result[:])
|
|
|
|
// Expected result from C selftest
|
|
expected := [32]byte{
|
|
0xf0, 0x8a, 0x78, 0xcb, 0xba, 0xee, 0x08, 0x2b, 0x05, 0x2a, 0xe0, 0x70, 0x8f, 0x32, 0xfa, 0x1e,
|
|
0x50, 0xc5, 0xc4, 0x21, 0xaa, 0x77, 0x2b, 0xa5, 0xdb, 0xb4, 0x06, 0xa2, 0xea, 0x6b, 0xe3, 0x42,
|
|
}
|
|
|
|
for i := 0; i < 32; i++ {
|
|
if result[i] != expected[i] {
|
|
t.Errorf("SHA-256 mismatch at byte %d: got 0x%02x, expected 0x%02x", i, result[i], expected[i])
|
|
}
|
|
}
|
|
|
|
h.Clear()
|
|
}
|
|
|
|
func TestHMACSHA256(t *testing.T) {
|
|
// Test HMAC-SHA256 with known test vectors
|
|
key := []byte("key")
|
|
message := []byte("The quick brown fox jumps over the lazy dog")
|
|
|
|
h := NewHMACSHA256(key)
|
|
h.Write(message)
|
|
|
|
var result [32]byte
|
|
h.Finalize(result[:])
|
|
|
|
// Basic test - just verify it produces output
|
|
allZero := true
|
|
for i := 0; i < 32; i++ {
|
|
if result[i] != 0 {
|
|
allZero = false
|
|
break
|
|
}
|
|
}
|
|
if allZero {
|
|
t.Error("HMAC-SHA256 produced all zeros")
|
|
}
|
|
|
|
h.Clear()
|
|
}
|
|
|
|
func TestRFC6979(t *testing.T) {
|
|
// Test RFC6979 nonce generation
|
|
key := []byte("test key for RFC6979")
|
|
rng := NewRFC6979HMACSHA256(key)
|
|
|
|
var nonce1 [32]byte
|
|
rng.Generate(nonce1[:])
|
|
|
|
// Generate more bytes
|
|
var nonce2 [32]byte
|
|
rng.Generate(nonce2[:])
|
|
|
|
// Nonces should be different
|
|
allSame := true
|
|
for i := 0; i < 32; i++ {
|
|
if nonce1[i] != nonce2[i] {
|
|
allSame = false
|
|
break
|
|
}
|
|
}
|
|
if allSame {
|
|
t.Error("RFC6979 produced identical nonces")
|
|
}
|
|
|
|
rng.Finalize()
|
|
rng.Clear()
|
|
}
|
|
|
|
func TestTaggedHash(t *testing.T) {
|
|
// Test tagged hash function
|
|
tag := []byte("BIP0340/challenge")
|
|
data := []byte("test data")
|
|
|
|
result := TaggedHash(tag, data)
|
|
|
|
// Verify it produces output
|
|
allZero := true
|
|
for i := 0; i < 32; i++ {
|
|
if result[i] != 0 {
|
|
allZero = false
|
|
break
|
|
}
|
|
}
|
|
if allZero {
|
|
t.Error("TaggedHash produced all zeros")
|
|
}
|
|
}
|
|
|
|
func TestHashToScalar(t *testing.T) {
|
|
hash := make([]byte, 32)
|
|
for i := 0; i < 32; i++ {
|
|
hash[i] = byte(i)
|
|
}
|
|
|
|
scalar, err := HashToScalar(hash)
|
|
if err != nil {
|
|
t.Fatalf("HashToScalar failed: %v", err)
|
|
}
|
|
if scalar == nil {
|
|
t.Fatal("HashToScalar returned nil")
|
|
}
|
|
}
|
|
|
|
func TestHashToField(t *testing.T) {
|
|
hash := make([]byte, 32)
|
|
for i := 0; i < 32; i++ {
|
|
hash[i] = byte(i)
|
|
}
|
|
|
|
field, err := HashToField(hash)
|
|
if err != nil {
|
|
t.Fatalf("HashToField failed: %v", err)
|
|
}
|
|
if field == nil {
|
|
t.Fatal("HashToField returned nil")
|
|
}
|
|
}
|
|
|