schemes_test.go

Documentation: github.com/cloudflare/circl/kem/schemes

     1  package schemes_test
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"testing"
     7  
     8  	"github.com/cloudflare/circl/kem/schemes"
     9  )
    10  
    11  func TestCaseSensitivity(t *testing.T) {
    12  	if schemes.ByName("kyber512") != schemes.ByName("Kyber512") {
    13  		t.Fatal()
    14  	}
    15  }
    16  
    17  func BenchmarkGenerateKeyPair(b *testing.B) {
    18  	allSchemes := schemes.All()
    19  	for _, scheme := range allSchemes {
    20  		scheme := scheme
    21  		b.Run(scheme.Name(), func(b *testing.B) {
    22  			for i := 0; i < b.N; i++ {
    23  				_, _, _ = scheme.GenerateKeyPair()
    24  			}
    25  		})
    26  	}
    27  }
    28  
    29  func BenchmarkEncapsulate(b *testing.B) {
    30  	allSchemes := schemes.All()
    31  	for _, scheme := range allSchemes {
    32  		scheme := scheme
    33  		pk, _, _ := scheme.GenerateKeyPair()
    34  		b.Run(scheme.Name(), func(b *testing.B) {
    35  			for i := 0; i < b.N; i++ {
    36  				_, _, _ = scheme.Encapsulate(pk)
    37  			}
    38  		})
    39  	}
    40  }
    41  
    42  func BenchmarkDecapsulate(b *testing.B) {
    43  	allSchemes := schemes.All()
    44  	for _, scheme := range allSchemes {
    45  		scheme := scheme
    46  		pk, sk, _ := scheme.GenerateKeyPair()
    47  		ct, _, _ := scheme.Encapsulate(pk)
    48  		b.Run(scheme.Name(), func(b *testing.B) {
    49  			for i := 0; i < b.N; i++ {
    50  				_, _ = scheme.Decapsulate(sk, ct)
    51  			}
    52  		})
    53  	}
    54  }
    55  
    56  func TestApi(t *testing.T) {
    57  	allSchemes := schemes.All()
    58  	for _, scheme := range allSchemes {
    59  		scheme := scheme
    60  		t.Run(scheme.Name(), func(t *testing.T) {
    61  			if scheme == nil {
    62  				t.Fatal()
    63  			}
    64  
    65  			_ = scheme.SeedSize()
    66  			_ = scheme.EncapsulationSeedSize()
    67  
    68  			pk, sk, err := scheme.GenerateKeyPair()
    69  			if err != nil {
    70  				t.Fatal()
    71  			}
    72  
    73  			packedPk, err := pk.MarshalBinary()
    74  			if err != nil {
    75  				t.Fatal()
    76  			}
    77  
    78  			if len(packedPk) != scheme.PublicKeySize() {
    79  				t.Fatal()
    80  			}
    81  
    82  			packedSk, err := sk.MarshalBinary()
    83  			if err != nil {
    84  				t.Fatal()
    85  			}
    86  
    87  			if len(packedSk) != scheme.PrivateKeySize() {
    88  				t.Fatal()
    89  			}
    90  
    91  			pk2, err := scheme.UnmarshalBinaryPublicKey(packedPk)
    92  			if err != nil {
    93  				t.Fatal()
    94  			}
    95  
    96  			sk2, err := scheme.UnmarshalBinaryPrivateKey(packedSk)
    97  			if err != nil {
    98  				t.Fatal()
    99  			}
   100  
   101  			if !sk.Equal(sk2) {
   102  				t.Fatal()
   103  			}
   104  
   105  			if !pk.Equal(pk2) {
   106  				t.Fatal()
   107  			}
   108  
   109  			ct, ss, err := scheme.Encapsulate(pk2)
   110  			if err != nil {
   111  				t.Fatal(err)
   112  			}
   113  			if len(ct) != scheme.CiphertextSize() {
   114  				t.Fatal()
   115  			}
   116  			if len(ss) != scheme.SharedKeySize() {
   117  				t.Fatal()
   118  			}
   119  
   120  			ct3, ss3, err := scheme.Encapsulate(pk2)
   121  			if err != nil {
   122  				t.Fatal(err)
   123  			}
   124  			if bytes.Equal(ss3, ss) {
   125  				t.Fatal()
   126  			}
   127  			if bytes.Equal(ct3, ct) {
   128  				t.Fatal()
   129  			}
   130  
   131  			ss2, err := scheme.Decapsulate(sk2, ct)
   132  			if err != nil {
   133  				t.Fatal(err)
   134  			}
   135  			if !bytes.Equal(ss, ss2) {
   136  				t.Fatal()
   137  			}
   138  		})
   139  	}
   140  }
   141  
   142  func Example_schemes() {
   143  	// import "github.com/cloudflare/circl/kem/schemes"
   144  
   145  	for _, sch := range schemes.All() {
   146  		fmt.Println(sch.Name())
   147  	}
   148  	// Output:
   149  	// HPKE_KEM_P256_HKDF_SHA256
   150  	// HPKE_KEM_P384_HKDF_SHA384
   151  	// HPKE_KEM_P521_HKDF_SHA512
   152  	// HPKE_KEM_X25519_HKDF_SHA256
   153  	// HPKE_KEM_X448_HKDF_SHA512
   154  	// FrodoKEM-640-SHAKE
   155  	// Kyber512
   156  	// Kyber768
   157  	// Kyber1024
   158  	// Kyber512-X25519
   159  	// Kyber768-X25519
   160  	// Kyber768-X448
   161  	// Kyber1024-X448
   162  	// P256Kyber768Draft00
   163  }
   164
View as plain text