p256k1_signer_bench_test.go raw

   1  //go:build !js && !wasm && !tinygo && !wasm32
   2  
   3  package signer
   4  
   5  import (
   6  	"crypto/rand"
   7  	"testing"
   8  
   9  	"next.orly.dev/pkg/p256k1"
  10  )
  11  
  12  // BenchmarkP256K1Signer_Generate benchmarks key generation
  13  func BenchmarkP256K1Signer_Generate(b *testing.B) {
  14  	b.ReportAllocs()
  15  	for i := 0; i < b.N; i++ {
  16  		s := NewP256K1Signer()
  17  		if err := s.Generate(); err != nil {
  18  			b.Fatal(err)
  19  		}
  20  		s.Zero()
  21  	}
  22  }
  23  
  24  // BenchmarkP256K1Signer_InitSec benchmarks secret key initialization
  25  func BenchmarkP256K1Signer_InitSec(b *testing.B) {
  26  	// Pre-generate a secret key
  27  	sec := make([]byte, 32)
  28  	rand.Read(sec)
  29  	
  30  	b.ResetTimer()
  31  	b.ReportAllocs()
  32  	for i := 0; i < b.N; i++ {
  33  		s := NewP256K1Signer()
  34  		if err := s.InitSec(sec); err != nil {
  35  			b.Fatal(err)
  36  		}
  37  		s.Zero()
  38  	}
  39  }
  40  
  41  // BenchmarkP256K1Signer_InitPub benchmarks public key initialization
  42  func BenchmarkP256K1Signer_InitPub(b *testing.B) {
  43  	// Pre-generate a public key
  44  	kp, _ := p256k1.KeyPairGenerate()
  45  	xonly, _ := kp.XOnlyPubkey()
  46  	pub := xonly.Serialize()
  47  
  48  	b.ResetTimer()
  49  	b.ReportAllocs()
  50  	for i := 0; i < b.N; i++ {
  51  		s := NewP256K1Signer()
  52  		if err := s.InitPub(pub[:]); err != nil {
  53  			b.Fatal(err)
  54  		}
  55  		s.Zero()
  56  	}
  57  }
  58  
  59  // BenchmarkP256K1Signer_Sign benchmarks signing
  60  func BenchmarkP256K1Signer_Sign(b *testing.B) {
  61  	s := NewP256K1Signer()
  62  	if err := s.Generate(); err != nil {
  63  		b.Fatal(err)
  64  	}
  65  	defer s.Zero()
  66  
  67  	msg := make([]byte, 32)
  68  	rand.Read(msg)
  69  
  70  	b.ResetTimer()
  71  	b.ReportAllocs()
  72  	for i := 0; i < b.N; i++ {
  73  		if _, err := s.Sign(msg); err != nil {
  74  			b.Fatal(err)
  75  		}
  76  	}
  77  }
  78  
  79  // BenchmarkP256K1Signer_Verify benchmarks verification
  80  func BenchmarkP256K1Signer_Verify(b *testing.B) {
  81  	s := NewP256K1Signer()
  82  	if err := s.Generate(); err != nil {
  83  		b.Fatal(err)
  84  	}
  85  	defer s.Zero()
  86  
  87  	msg := make([]byte, 32)
  88  	rand.Read(msg)
  89  	sig, _ := s.Sign(msg)
  90  
  91  	b.ResetTimer()
  92  	b.ReportAllocs()
  93  	for i := 0; i < b.N; i++ {
  94  		if _, err := s.Verify(msg, sig); err != nil {
  95  			b.Fatal(err)
  96  		}
  97  	}
  98  }
  99  
 100  // BenchmarkP256K1Signer_ECDH benchmarks ECDH computation
 101  func BenchmarkP256K1Signer_ECDH(b *testing.B) {
 102  	s1 := NewP256K1Signer()
 103  	if err := s1.Generate(); err != nil {
 104  		b.Fatal(err)
 105  	}
 106  	defer s1.Zero()
 107  
 108  	s2 := NewP256K1Signer()
 109  	if err := s2.Generate(); err != nil {
 110  		b.Fatal(err)
 111  	}
 112  	defer s2.Zero()
 113  
 114  	pub2 := s2.Pub()
 115  
 116  	b.ResetTimer()
 117  	b.ReportAllocs()
 118  	for i := 0; i < b.N; i++ {
 119  		if _, err := s1.ECDH(pub2); err != nil {
 120  			b.Fatal(err)
 121  		}
 122  	}
 123  }
 124  
 125  // BenchmarkP256K1Signer_Pub benchmarks public key retrieval
 126  func BenchmarkP256K1Signer_Pub(b *testing.B) {
 127  	s := NewP256K1Signer()
 128  	if err := s.Generate(); err != nil {
 129  		b.Fatal(err)
 130  	}
 131  	defer s.Zero()
 132  
 133  	b.ResetTimer()
 134  	b.ReportAllocs()
 135  	for i := 0; i < b.N; i++ {
 136  		_ = s.Pub()
 137  	}
 138  }
 139  
 140  // BenchmarkP256K1Gen_Generate benchmarks Gen.Generate
 141  func BenchmarkP256K1Gen_Generate(b *testing.B) {
 142  	b.ReportAllocs()
 143  	for i := 0; i < b.N; i++ {
 144  		g := NewP256K1Gen()
 145  		if _, err := g.Generate(); err != nil {
 146  			b.Fatal(err)
 147  		}
 148  	}
 149  }
 150  
 151  // BenchmarkP256K1Gen_Negate benchmarks Gen.Negate
 152  func BenchmarkP256K1Gen_Negate(b *testing.B) {
 153  	g := NewP256K1Gen()
 154  	if _, err := g.Generate(); err != nil {
 155  		b.Fatal(err)
 156  	}
 157  
 158  	b.ResetTimer()
 159  	b.ReportAllocs()
 160  	for i := 0; i < b.N; i++ {
 161  		g.Negate()
 162  	}
 163  }
 164  
 165  // BenchmarkP256K1Gen_KeyPairBytes benchmarks Gen.KeyPairBytes
 166  func BenchmarkP256K1Gen_KeyPairBytes(b *testing.B) {
 167  	g := NewP256K1Gen()
 168  	if _, err := g.Generate(); err != nil {
 169  		b.Fatal(err)
 170  	}
 171  
 172  	b.ResetTimer()
 173  	b.ReportAllocs()
 174  	for i := 0; i < b.N; i++ {
 175  		_, _ = g.KeyPairBytes()
 176  	}
 177  }
 178  
 179