dilithium_test.go

Documentation: github.com/cloudflare/circl/sign/dilithium/mode3aes/internal

     1  // Code generated from mode3/internal/dilithium_test.go by gen.go
     2  
     3  package internal
     4  
     5  import (
     6  	"encoding/binary"
     7  	"testing"
     8  
     9  	"github.com/cloudflare/circl/sign/dilithium/internal/common"
    10  )
    11  
    12  // Checks whether p is normalized.  Only used in tests.
    13  func PolyNormalized(p *common.Poly) bool {
    14  	p2 := *p
    15  	p2.Normalize()
    16  	return p2 == *p
    17  }
    18  
    19  func BenchmarkSkUnpack(b *testing.B) {
    20  	var buf [PrivateKeySize]byte
    21  	var sk PrivateKey
    22  	for i := 0; i < b.N; i++ {
    23  		sk.Unpack(&buf)
    24  	}
    25  }
    26  
    27  func BenchmarkPkUnpack(b *testing.B) {
    28  	var buf [PublicKeySize]byte
    29  	var pk PublicKey
    30  	for i := 0; i < b.N; i++ {
    31  		pk.Unpack(&buf)
    32  	}
    33  }
    34  
    35  func BenchmarkVerify(b *testing.B) {
    36  	// Note that the expansion of the matrix A is done at Unpacking/Keygen
    37  	// instead of at the moment of verification (as in the reference
    38  	// implementation.)
    39  	var seed [32]byte
    40  	var msg [8]byte
    41  	var sig [SignatureSize]byte
    42  	pk, sk := NewKeyFromSeed(&seed)
    43  	SignTo(sk, msg[:], sig[:])
    44  	b.ResetTimer()
    45  	for i := 0; i < b.N; i++ {
    46  		// We should generate a new signature for every verify attempt,
    47  		// as this influences the time a little bit.  This difference, however,
    48  		// is small and generating a new signature in between creates a lot
    49  		// pressure on the allocator which makes an accurate measurement hard.
    50  		Verify(pk, msg[:], sig[:])
    51  	}
    52  }
    53  
    54  func BenchmarkSign(b *testing.B) {
    55  	// Note that the expansion of the matrix A is done at Unpacking/Keygen
    56  	// instead of at the moment of signing (as in the reference implementation.)
    57  	var seed [32]byte
    58  	var msg [8]byte
    59  	var sig [SignatureSize]byte
    60  	_, sk := NewKeyFromSeed(&seed)
    61  	b.ResetTimer()
    62  	for i := 0; i < b.N; i++ {
    63  		binary.LittleEndian.PutUint64(msg[:], uint64(i))
    64  		SignTo(sk, msg[:], sig[:])
    65  	}
    66  }
    67  
    68  func BenchmarkGenerateKey(b *testing.B) {
    69  	var seed [32]byte
    70  	for i := 0; i < b.N; i++ {
    71  		binary.LittleEndian.PutUint64(seed[:], uint64(i))
    72  		NewKeyFromSeed(&seed)
    73  	}
    74  }
    75  
    76  func BenchmarkPublicFromPrivate(b *testing.B) {
    77  	var seed [32]byte
    78  	for i := 0; i < b.N; i++ {
    79  		b.StopTimer()
    80  		binary.LittleEndian.PutUint64(seed[:], uint64(i))
    81  		_, sk := NewKeyFromSeed(&seed)
    82  		b.StartTimer()
    83  		sk.Public()
    84  	}
    85  }
    86  
    87  func TestSignThenVerifyAndPkSkPacking(t *testing.T) {
    88  	var seed [common.SeedSize]byte
    89  	var sig [SignatureSize]byte
    90  	var msg [8]byte
    91  	var pkb [PublicKeySize]byte
    92  	var skb [PrivateKeySize]byte
    93  	var pk2 PublicKey
    94  	var sk2 PrivateKey
    95  	for i := uint64(0); i < 100; i++ {
    96  		binary.LittleEndian.PutUint64(seed[:], i)
    97  		pk, sk := NewKeyFromSeed(&seed)
    98  		if !sk.Equal(sk) {
    99  			t.Fatal()
   100  		}
   101  		for j := uint64(0); j < 10; j++ {
   102  			binary.LittleEndian.PutUint64(msg[:], j)
   103  			SignTo(sk, msg[:], sig[:])
   104  			if !Verify(pk, msg[:], sig[:]) {
   105  				t.Fatal()
   106  			}
   107  		}
   108  		pk.Pack(&pkb)
   109  		pk2.Unpack(&pkb)
   110  		if !pk.Equal(&pk2) {
   111  			t.Fatal()
   112  		}
   113  		sk.Pack(&skb)
   114  		sk2.Unpack(&skb)
   115  		if !sk.Equal(&sk2) {
   116  			t.Fatal()
   117  		}
   118  	}
   119  }
   120  
   121  func TestPublicFromPrivate(t *testing.T) {
   122  	var seed [common.SeedSize]byte
   123  	for i := uint64(0); i < 100; i++ {
   124  		binary.LittleEndian.PutUint64(seed[:], i)
   125  		pk, sk := NewKeyFromSeed(&seed)
   126  		pk2 := sk.Public()
   127  		if !pk.Equal(pk2) {
   128  			t.Fatal()
   129  		}
   130  	}
   131  }
   132  
   133  func TestGamma1Size(t *testing.T) {
   134  	var expected int
   135  	switch Gamma1Bits {
   136  	case 17:
   137  		expected = 576
   138  	case 19:
   139  		expected = 640
   140  	}
   141  	if expected != PolyLeGamma1Size {
   142  		t.Fatal()
   143  	}
   144  }
   145
View as plain text