mirror of
https://github.com/sonr-io/crypto.git
synced 2026-01-12 04:09:13 +00:00
94 lines
2.3 KiB
Go
94 lines
2.3 KiB
Go
// Package curves provides integration tests for elliptic curve support
|
|
package curves
|
|
|
|
import (
|
|
"crypto/elliptic"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/sonr-io/crypto/core"
|
|
)
|
|
|
|
// TestAdditionalCurveSupport tests the new curve support in hash.go
|
|
func TestAdditionalCurveSupport(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
curve elliptic.Curve
|
|
expectedSecurity int
|
|
expectedL int
|
|
}{
|
|
{
|
|
name: "P-256",
|
|
curve: elliptic.P256(),
|
|
expectedSecurity: 128,
|
|
expectedL: 48,
|
|
},
|
|
{
|
|
name: "P-384",
|
|
curve: elliptic.P384(),
|
|
expectedSecurity: 192,
|
|
expectedL: 72,
|
|
},
|
|
{
|
|
name: "P-521",
|
|
curve: elliptic.P521(),
|
|
expectedSecurity: 256,
|
|
expectedL: 98,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
// Test Hash function with the curve
|
|
msg := []byte("test message for curve support")
|
|
result, err := core.Hash(msg, tt.curve)
|
|
|
|
require.NoError(t, err, "Hash should succeed for %s", tt.name)
|
|
require.NotNil(t, result, "Hash result should not be nil for %s", tt.name)
|
|
|
|
// Verify the result is a valid big integer
|
|
require.Greater(t, result.BitLen(), 0, "Hash result should have non-zero bit length")
|
|
})
|
|
}
|
|
}
|
|
|
|
// BenchmarkHashWithCurves benchmarks the hash function with different curves
|
|
func BenchmarkHashWithCurves(b *testing.B) {
|
|
curves := []struct {
|
|
name string
|
|
curve elliptic.Curve
|
|
}{
|
|
{"P256", elliptic.P256()},
|
|
{"P384", elliptic.P384()},
|
|
{"P521", elliptic.P521()},
|
|
}
|
|
|
|
msg := []byte("benchmark message for hash function")
|
|
|
|
for _, c := range curves {
|
|
b.Run(c.name, func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
_, _ = core.Hash(msg, c.curve)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestBackwardCompatibility ensures old curves still work
|
|
func TestBackwardCompatibility(t *testing.T) {
|
|
// Test that P-256 still works as before
|
|
msg := []byte("backward compatibility test")
|
|
|
|
result256, err := core.Hash(msg, elliptic.P256())
|
|
require.NoError(t, err)
|
|
require.NotNil(t, result256)
|
|
|
|
// Test with same message multiple times for consistency
|
|
for i := 0; i < 10; i++ {
|
|
result, err := core.Hash(msg, elliptic.P256())
|
|
require.NoError(t, err)
|
|
require.Equal(t, result256.Cmp(result), 0, "Hash should be consistent")
|
|
}
|
|
}
|