Skip to content

Commit b2e63c1

Browse files
Eruel6Mateusvff
Eruel6
authored and
Mateusvff
committed
fix: add MLDSA to benchmark
Signed-off-by: Mateus Franco <mateusfrancovinicius@gmail.com>
1 parent e4017b2 commit b2e63c1

1 file changed

Lines changed: 171 additions & 64 deletions

File tree

‎device/mlkem_bench_test.go‎

Lines changed: 171 additions & 64 deletions
Original file line numberDiff line numberDiff line change
@@ -94,6 +94,33 @@ func BenchmarkHandshakeWithMLKEM(b *testing.B) {
9494
b.Fatal(err)
9595
}
9696

97+
mldsaPubA, mldsaPrivA, err := GenerateMLDSAKeyPair()
98+
if err != nil {
99+
b.Fatal(err)
100+
}
101+
mldsaPubB, mldsaPrivB, err := GenerateMLDSAKeyPair()
102+
if err != nil {
103+
b.Fatal(err)
104+
}
105+
106+
devA.staticIdentity.Lock()
107+
copy(devA.staticIdentity.mldsaPrivateKey[:], mldsaPrivA)
108+
copy(devA.staticIdentity.mldsaPublicKey[:], mldsaPubA)
109+
devA.staticIdentity.Unlock()
110+
111+
devB.staticIdentity.Lock()
112+
copy(devB.staticIdentity.mldsaPrivateKey[:], mldsaPrivB)
113+
copy(devB.staticIdentity.mldsaPublicKey[:], mldsaPubB)
114+
devB.staticIdentity.Unlock()
115+
116+
peerB.handshake.mutex.Lock()
117+
copy(peerB.handshake.remoteMLDSAStatic[:], mldsaPubB)
118+
peerB.handshake.mutex.Unlock()
119+
120+
peerA.handshake.mutex.Lock()
121+
copy(peerA.handshake.remoteMLDSAStatic[:], mldsaPubA)
122+
peerA.handshake.mutex.Unlock()
123+
97124
relaxFlood := func() {
98125
peerA.handshake.mutex.Lock()
99126
peerA.handshake.lastInitiationConsumption = time.Now().Add(-10 * time.Second)
@@ -197,6 +224,33 @@ func BenchmarkHandshakeHybrid(b *testing.B) {
197224
b.Fatal("peer lookup failed (check IpcSet order)")
198225
}
199226

227+
mldsaPubA, mldsaPrivA, err := GenerateMLDSAKeyPair()
228+
if err != nil {
229+
b.Fatal(err)
230+
}
231+
mldsaPubB, mldsaPrivB, err := GenerateMLDSAKeyPair()
232+
if err != nil {
233+
b.Fatal(err)
234+
}
235+
236+
devA.staticIdentity.Lock()
237+
copy(devA.staticIdentity.mldsaPrivateKey[:], mldsaPrivA)
238+
copy(devA.staticIdentity.mldsaPublicKey[:], mldsaPubA)
239+
devA.staticIdentity.Unlock()
240+
241+
devB.staticIdentity.Lock()
242+
copy(devB.staticIdentity.mldsaPrivateKey[:], mldsaPrivB)
243+
copy(devB.staticIdentity.mldsaPublicKey[:], mldsaPubB)
244+
devB.staticIdentity.Unlock()
245+
246+
peerB.handshake.mutex.Lock()
247+
copy(peerB.handshake.remoteMLDSAStatic[:], mldsaPubB)
248+
peerB.handshake.mutex.Unlock()
249+
250+
peerA.handshake.mutex.Lock()
251+
copy(peerA.handshake.remoteMLDSAStatic[:], mldsaPubA)
252+
peerA.handshake.mutex.Unlock()
253+
200254
relax := func() {
201255
peerA.handshake.mutex.Lock()
202256
peerA.handshake.lastInitiationConsumption = time.Now().Add(-10 * time.Second)
@@ -250,78 +304,32 @@ func BenchmarkDataPlaneAEAD(b *testing.B) {
250304
devB.IpcSet(uapiCfg("mlkem_private_key", hex.EncodeToString(skBb)))
251305
devA.IpcSet(uapiCfg("public_key", hex.EncodeToString(peerB.handshake.remoteStatic[:]), "mlkem_public_key", hex.EncodeToString(pkBb)))
252306
devB.IpcSet(uapiCfg("public_key", hex.EncodeToString(peerA.handshake.remoteStatic[:]), "mlkem_public_key", hex.EncodeToString(pkAb)))
253-
254-
msg1, _ := devA.CreateMessageInitiation(peerB)
255-
devB.ConsumeMessageInitiation(msg1)
256-
msg2, _ := devB.CreateMessageResponse(peerA)
257-
devA.ConsumeMessageResponse(msg2)
258-
peerA.BeginSymmetricSession()
259-
peerB.BeginSymmetricSession()
260-
261-
keyA := peerA.keypairs.next.Load()
262-
keyB := peerB.keypairs.current
263-
msg := bytes.Repeat([]byte{0x42}, 128)
264-
var nonce [12]byte
265-
266-
b.ReportAllocs()
267-
b.SetBytes(int64(len(msg)))
268-
b.ResetTimer()
269-
for i := 0; i < b.N; i++ {
270-
out := keyA.send.Seal(nil, nonce[:], msg, nil)
271-
_, err := keyB.receive.Open(nil, nonce[:], out, nil)
272-
if err != nil {
273-
b.Fatal(err)
274-
}
275-
}
276-
}
277-
278-
func BenchmarkDataPlaneAEADHybrid(b *testing.B) {
279-
skA, _ := newPrivateKey()
280-
skB, _ := newPrivateKey()
281-
tunA := tuntest.NewChannelTUN()
282-
tunB := tuntest.NewChannelTUN()
283-
devA := NewDevice(tunA.TUN(), conn.NewDefaultBind(), NewLogger(LogLevelError, ""))
284-
devB := NewDevice(tunB.TUN(), conn.NewDefaultBind(), NewLogger(LogLevelError, ""))
285-
defer devA.Close()
286-
defer devB.Close()
287-
288-
if err := devA.IpcSet(uapiCfg("private_key", hex.EncodeToString(skA[:]))); err != nil {
307+
mldsaPubA, mldsaPrivA, err := GenerateMLDSAKeyPair()
308+
if err != nil {
289309
b.Fatal(err)
290310
}
291-
if err := devB.IpcSet(uapiCfg("private_key", hex.EncodeToString(skB[:]))); err != nil {
311+
mldsaPubB, mldsaPrivB, err := GenerateMLDSAKeyPair()
312+
if err != nil {
292313
b.Fatal(err)
293314
}
294315

295-
scheme := kyber1024.Scheme()
296-
pkA, skAkem, _ := scheme.GenerateKeyPair()
297-
pkB, skBkem, _ := scheme.GenerateKeyPair()
298-
pkAb, _ := pkA.MarshalBinary()
299-
pkBb, _ := pkB.MarshalBinary()
300-
skAb, _ := skAkem.MarshalBinary()
301-
skBb, _ := skBkem.MarshalBinary()
302-
303-
if err := devA.IpcSet(uapiCfg("mlkem_private_key", hex.EncodeToString(skAb))); err != nil {
304-
b.Fatal(err)
305-
}
306-
if err := devB.IpcSet(uapiCfg("mlkem_private_key", hex.EncodeToString(skBb))); err != nil {
307-
b.Fatal(err)
308-
}
316+
devA.staticIdentity.Lock()
317+
copy(devA.staticIdentity.mldsaPrivateKey[:], mldsaPrivA)
318+
copy(devA.staticIdentity.mldsaPublicKey[:], mldsaPubA)
319+
devA.staticIdentity.Unlock()
309320

310-
pkBNoise := skB.publicKey()
311-
pkANoise := skA.publicKey()
312-
if err := devA.IpcSet(uapiCfg("public_key", hex.EncodeToString(pkBNoise[:]), "mlkem_public_key", hex.EncodeToString(pkBb))); err != nil {
313-
b.Fatal(err)
314-
}
315-
if err := devB.IpcSet(uapiCfg("public_key", hex.EncodeToString(pkANoise[:]), "mlkem_public_key", hex.EncodeToString(pkAb))); err != nil {
316-
b.Fatal(err)
317-
}
321+
devB.staticIdentity.Lock()
322+
copy(devB.staticIdentity.mldsaPrivateKey[:], mldsaPrivB)
323+
copy(devB.staticIdentity.mldsaPublicKey[:], mldsaPubB)
324+
devB.staticIdentity.Unlock()
318325

319-
peerB := devA.LookupPeer(pkBNoise)
320-
peerA := devB.LookupPeer(pkANoise)
321-
if peerA == nil || peerB == nil {
322-
b.Fatal("peer lookup failed (check IpcSet order)")
323-
}
326+
peerB.handshake.mutex.Lock()
327+
copy(peerB.handshake.remoteMLDSAStatic[:], mldsaPubB)
328+
peerB.handshake.mutex.Unlock()
324329

330+
peerA.handshake.mutex.Lock()
331+
copy(peerA.handshake.remoteMLDSAStatic[:], mldsaPubA)
332+
peerA.handshake.mutex.Unlock()
325333
msg1, _ := devA.CreateMessageInitiation(peerB)
326334
devB.ConsumeMessageInitiation(msg1)
327335
msg2, _ := devB.CreateMessageResponse(peerA)
@@ -345,3 +353,102 @@ func BenchmarkDataPlaneAEADHybrid(b *testing.B) {
345353
}
346354
}
347355
}
356+
357+
func BenchmarkDataPlaneAEADHybrid(b *testing.B) {
358+
skA, _ := newPrivateKey()
359+
skB, _ := newPrivateKey()
360+
tunA := tuntest.NewChannelTUN()
361+
tunB := tuntest.NewChannelTUN()
362+
devA := NewDevice(tunA.TUN(), conn.NewDefaultBind(), NewLogger(LogLevelError, ""))
363+
devB := NewDevice(tunB.TUN(), conn.NewDefaultBind(), NewLogger(LogLevelError, ""))
364+
defer devA.Close()
365+
defer devB.Close()
366+
367+
if err := devA.IpcSet(uapiCfg("private_key", hex.EncodeToString(skA[:]))); err != nil {
368+
b.Fatal(err)
369+
}
370+
if err := devB.IpcSet(uapiCfg("private_key", hex.EncodeToString(skB[:]))); err != nil {
371+
b.Fatal(err)
372+
}
373+
374+
scheme := kyber1024.Scheme()
375+
pkA, skAkem, _ := scheme.GenerateKeyPair()
376+
pkB, skBkem, _ := scheme.GenerateKeyPair()
377+
pkAb, _ := pkA.MarshalBinary()
378+
pkBb, _ := pkB.MarshalBinary()
379+
skAb, _ := skAkem.MarshalBinary()
380+
skBb, _ := skBkem.MarshalBinary()
381+
382+
if err := devA.IpcSet(uapiCfg("mlkem_private_key", hex.EncodeToString(skAb))); err != nil {
383+
b.Fatal(err)
384+
}
385+
if err := devB.IpcSet(uapiCfg("mlkem_private_key", hex.EncodeToString(skBb))); err != nil {
386+
b.Fatal(err)
387+
}
388+
389+
pkBNoise := skB.publicKey()
390+
pkANoise := skA.publicKey()
391+
if err := devA.IpcSet(uapiCfg("public_key", hex.EncodeToString(pkBNoise[:]), "mlkem_public_key", hex.EncodeToString(pkBb))); err != nil {
392+
b.Fatal(err)
393+
}
394+
if err := devB.IpcSet(uapiCfg("public_key", hex.EncodeToString(pkANoise[:]), "mlkem_public_key", hex.EncodeToString(pkAb))); err != nil {
395+
b.Fatal(err)
396+
}
397+
398+
peerB := devA.LookupPeer(pkBNoise)
399+
peerA := devB.LookupPeer(pkANoise)
400+
if peerA == nil || peerB == nil {
401+
b.Fatal("peer lookup failed (check IpcSet order)")
402+
}
403+
404+
mldsaPubA, mldsaPrivA, err := GenerateMLDSAKeyPair()
405+
if err != nil {
406+
b.Fatal(err)
407+
}
408+
mldsaPubB, mldsaPrivB, err := GenerateMLDSAKeyPair()
409+
if err != nil {
410+
b.Fatal(err)
411+
}
412+
413+
devA.staticIdentity.Lock()
414+
copy(devA.staticIdentity.mldsaPrivateKey[:], mldsaPrivA)
415+
copy(devA.staticIdentity.mldsaPublicKey[:], mldsaPubA)
416+
devA.staticIdentity.Unlock()
417+
418+
devB.staticIdentity.Lock()
419+
copy(devB.staticIdentity.mldsaPrivateKey[:], mldsaPrivB)
420+
copy(devB.staticIdentity.mldsaPublicKey[:], mldsaPubB)
421+
devB.staticIdentity.Unlock()
422+
423+
peerB.handshake.mutex.Lock()
424+
copy(peerB.handshake.remoteMLDSAStatic[:], mldsaPubB)
425+
peerB.handshake.mutex.Unlock()
426+
427+
peerA.handshake.mutex.Lock()
428+
copy(peerA.handshake.remoteMLDSAStatic[:], mldsaPubA)
429+
peerA.handshake.mutex.Unlock()
430+
431+
msg1, _ := devA.CreateMessageInitiation(peerB)
432+
devB.ConsumeMessageInitiation(msg1)
433+
msg2, _ := devB.CreateMessageResponse(peerA)
434+
devA.ConsumeMessageResponse(msg2)
435+
peerA.BeginSymmetricSession()
436+
peerB.BeginSymmetricSession()
437+
438+
keyA := peerA.keypairs.next.Load()
439+
keyB := peerB.keypairs.current
440+
msg := bytes.Repeat([]byte{0x42}, 128)
441+
var nonce [12]byte
442+
443+
b.ReportAllocs()
444+
b.SetBytes(int64(len(msg)))
445+
b.ResetTimer()
446+
for i := 0; i < b.N; i++ {
447+
out := keyA.send.Seal(nil, nonce[:], msg, nil)
448+
_, err := keyB.receive.Open(nil, nonce[:], out, nil)
449+
if err != nil {
450+
b.Fatal(err)
451+
}
452+
}
453+
}
454+

0 commit comments

Comments
 (0)