dilithium_test.go

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

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