github/ml-kem
1
1
Fork 0
mirror of https://github.com/itzmeanjan/ml-kem.git synced 2026-01-09 15:47:55 -05:00
Code Issues Packages Projects Releases Wiki Activity

update kyber KEM benchmark routines, remove kyber PKE benchmark helper routines

Browse Source 
Signed-off-by: Anjan Roy <hello@itzmeanjan.in>
This commit is contained in:
Anjan Roy
2023-06-02 18:22:51 +04:00
parent 3f7a5fd932
commit 2892144772
4 changed files with 29 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
bench/main.cpp
View File

@@ -1,4 +1,4 @@
#include "bench/bench_kyber.hpp"
#include "bench/bench_kem.hpp"
auto compute_min = [](const std::vector<double>& v) -> double {
return *std::min_element(v.begin(), v.end());
@@ -8,91 +8,47 @@ auto compute_max = [](const std::vector<double>& v) -> double {
return *std::max_element(v.begin(), v.end());
};
// Register for benchmarking IND-CPA-secure Kyber Public Key Encryption
// Kyber512
BENCHMARK(bench_kyber::pke_keygen<2, 3>)
->Name("kyber512_pke_keygen")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::encrypt<2, 3, 2, 10, 4>)
->Name("kyber512_pke_encrypt")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::decrypt<2, 3, 2, 10, 4>)
->Name("kyber512_pke_decrypt")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
// Kyber768
BENCHMARK(bench_kyber::pke_keygen<3, 2>)
->Name("kyber768_pke_keygen")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::encrypt<3, 2, 2, 10, 4>)
->Name("kyber768_pke_encrypt")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::decrypt<3, 2, 2, 10, 4>)
->Name("kyber768_pke_decrypt")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
// Kyber1024
BENCHMARK(bench_kyber::pke_keygen<4, 2>)
->Name("kyber1024_pke_keygen")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::encrypt<4, 2, 2, 11, 5>)
->Name("kyber1024_pke_encrypt")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::decrypt<4, 2, 2, 11, 5>)
->Name("kyber1024_pke_decrypt")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
// Register for benchmarking IND-CCA2-secure Kyber Key Encapsulation Mechanism
// Kyber512
BENCHMARK(bench_kyber::kem_keygen<2, 3>)
->Name("kyber512_kem_keygen")
BENCHMARK(bench_kyber::keygen<2, 3>)
->Name("kyber512_keygen")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::encapsulate<2, 3, 2, 10, 4>)
->Name("kyber512_kem_encap")
->Name("kyber512_encap")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::decapsulate<2, 3, 2, 10, 4>)
->Name("kyber512_kem_decap")
->Name("kyber512_decap")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
// Kyber768
BENCHMARK(bench_kyber::kem_keygen<3, 2>)
->Name("kyber768_kem_keygen")
BENCHMARK(bench_kyber::keygen<3, 2>)
->Name("kyber768_keygen")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::encapsulate<3, 2, 2, 10, 4>)
->Name("kyber768_kem_encap")
->Name("kyber768_encap")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::decapsulate<3, 2, 2, 10, 4>)
->Name("kyber768_kem_decap")
->Name("kyber768_decap")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
// Kyber1024
BENCHMARK(bench_kyber::kem_keygen<4, 2>)
->Name("kyber1024_kem_keygen")
BENCHMARK(bench_kyber::keygen<4, 2>)
->Name("kyber1024_keygen")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::encapsulate<4, 2, 2, 11, 5>)
->Name("kyber1024_kem_encap")
->Name("kyber1024_encap")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);
BENCHMARK(bench_kyber::decapsulate<4, 2, 2, 11, 5>)
->Name("kyber1024_kem_decap")
->Name("kyber1024_decap")
->ComputeStatistics("min", compute_min)
->ComputeStatistics("max", compute_max);

32
include/bench/bench_kem_kyber.hpp → include/bench/bench_kem.hpp
View File

@@ -1,5 +1,5 @@
#pragma once
#include "kyber_kem.hpp"
#include "kem.hpp"
#include "utils.hpp"
#include <benchmark/benchmark.h>
@@ -9,11 +9,11 @@ namespace bench_kyber {
// Benchmarking IND-CCA2-secure Kyber KEM key generation algorithm
template<const size_t k, const size_t eta1>
void
kem_keygen(benchmark::State& state)
keygen(benchmark::State& state)
{
constexpr size_t slen = 32;
constexpr size_t pklen = kyber_utils::get_ccakem_public_key_len<k>();
constexpr size_t sklen = kyber_utils::get_ccakem_secret_key_len<k>();
constexpr size_t pklen = kyber_utils::get_kem_public_key_len<k>();
constexpr size_t sklen = kyber_utils::get_kem_secret_key_len<k>();
uint8_t* d = static_cast<uint8_t*>(std::malloc(slen));
uint8_t* z = static_cast<uint8_t*>(std::malloc(slen));
@@ -25,7 +25,7 @@ kem_keygen(benchmark::State& state)
prng.read(z, slen);
for (auto _ : state) {
ccakem::keygen<k, eta1>(d, z, pkey, skey);
kem::keygen<k, eta1>(d, z, pkey, skey);
benchmark::DoNotOptimize(d);
benchmark::DoNotOptimize(z);
@@ -52,9 +52,9 @@ void
encapsulate(benchmark::State& state)
{
constexpr size_t slen = 32;
constexpr size_t pklen = kyber_utils::get_ccakem_public_key_len<k>();
constexpr size_t sklen = kyber_utils::get_ccakem_secret_key_len<k>();
constexpr size_t ctlen = kyber_utils::get_ccakem_cipher_len<k, du, dv>();
constexpr size_t pklen = kyber_utils::get_kem_public_key_len<k>();
constexpr size_t sklen = kyber_utils::get_kem_secret_key_len<k>();
constexpr size_t ctlen = kyber_utils::get_kem_cipher_len<k, du, dv>();
constexpr size_t klen = 32;
uint8_t* d = static_cast<uint8_t*>(std::malloc(slen));
@@ -69,12 +69,12 @@ encapsulate(benchmark::State& state)
prng.read(d, slen);
prng.read(z, slen);
ccakem::keygen<k, eta1>(d, z, pkey, skey);
kem::keygen<k, eta1>(d, z, pkey, skey);
prng.read(m, slen);
for (auto _ : state) {
auto skdf = ccakem::encapsulate<k, eta1, eta2, du, dv>(m, pkey, cipher);
auto skdf = kem::encapsulate<k, eta1, eta2, du, dv>(m, pkey, cipher);
benchmark::DoNotOptimize(skdf);
skdf.read(sender_key, klen);
@@ -106,9 +106,9 @@ void
decapsulate(benchmark::State& state)
{
constexpr size_t slen = 32;
constexpr size_t pklen = kyber_utils::get_ccakem_public_key_len<k>();
constexpr size_t sklen = kyber_utils::get_ccakem_secret_key_len<k>();
constexpr size_t ctlen = kyber_utils::get_ccakem_cipher_len<k, du, dv>();
constexpr size_t pklen = kyber_utils::get_kem_public_key_len<k>();
constexpr size_t sklen = kyber_utils::get_kem_secret_key_len<k>();
constexpr size_t ctlen = kyber_utils::get_kem_cipher_len<k, du, dv>();
constexpr size_t klen = 32;
uint8_t* d = static_cast<uint8_t*>(std::malloc(slen));
@@ -124,15 +124,15 @@ decapsulate(benchmark::State& state)
prng.read(d, slen);
prng.read(z, slen);
ccakem::keygen<k, eta1>(d, z, pkey, skey);
kem::keygen<k, eta1>(d, z, pkey, skey);
prng.read(m, slen);
auto skdf = ccakem::encapsulate<k, eta1, eta2, du, dv>(m, pkey, cipher);
auto skdf = kem::encapsulate<k, eta1, eta2, du, dv>(m, pkey, cipher);
skdf.read(sender_key, klen);
for (auto _ : state) {
auto rkdf = ccakem::decapsulate<k, eta1, eta2, du, dv>(skey, cipher);
auto rkdf = kem::decapsulate<k, eta1, eta2, du, dv>(skey, cipher);
benchmark::DoNotOptimize(rkdf);
rkdf.read(receiver_key, klen);

4
include/bench/bench_kyber.hpp
View File

@@ -1,4 +0,0 @@
#pragma once
#include "bench_kem_kyber.hpp"
#include "bench_pke_kyber.hpp"

144
include/bench/bench_pke_kyber.hpp
View File

@@ -1,144 +0,0 @@
#pragma once
#include "kyber_pke.hpp"
#include "utils.hpp"
#include <benchmark/benchmark.h>
// Benchmark Kyber PQC suite implementation on CPU, using google-benchmark
namespace bench_kyber {
// Benchmarking IND-CPA-secure Kyber PKE key generation algorithm
template<const size_t k, const size_t eta1>
void
pke_keygen(benchmark::State& state)
{
constexpr size_t slen = 32;
constexpr size_t pklen = kyber_utils::get_cpapke_public_key_len<k>();
constexpr size_t sklen = kyber_utils::get_cpapke_secret_key_len<k>();
uint8_t* seed = static_cast<uint8_t*>(std::malloc(slen));
uint8_t* pkey = static_cast<uint8_t*>(std::malloc(pklen));
uint8_t* skey = static_cast<uint8_t*>(std::malloc(sklen));
prng::prng_t prng;
prng.read(seed, slen);
for (auto _ : state) {
cpapke::keygen<k, eta1>(seed, pkey, skey);
benchmark::DoNotOptimize(seed);
benchmark::DoNotOptimize(pkey);
benchmark::DoNotOptimize(skey);
benchmark::ClobberMemory();
}
state.SetItemsProcessed(state.iterations());
std::free(seed);
std::free(pkey);
std::free(skey);
}
// Benchmarking IND-CPA-secure Kyber public key encryption algorithm
template<const size_t k,
const size_t eta1,
const size_t eta2,
const size_t du,
const size_t dv>
void
encrypt(benchmark::State& state)
{
constexpr size_t slen = 32;
constexpr size_t pklen = kyber_utils::get_cpapke_public_key_len<k>();
constexpr size_t sklen = kyber_utils::get_cpapke_secret_key_len<k>();
constexpr size_t mlen = 32;
constexpr size_t enclen = kyber_utils::get_cpapke_cipher_len<k, du, dv>();
uint8_t* seed = static_cast<uint8_t*>(std::malloc(slen));
uint8_t* pkey = static_cast<uint8_t*>(std::malloc(pklen));
uint8_t* skey = static_cast<uint8_t*>(std::malloc(sklen));
uint8_t* rcoin = static_cast<uint8_t*>(std::malloc(mlen));
uint8_t* txt = static_cast<uint8_t*>(std::malloc(mlen));
uint8_t* enc = static_cast<uint8_t*>(std::malloc(enclen));
prng::prng_t prng;
prng.read(seed, slen);
cpapke::keygen<k, eta1>(seed, pkey, skey);
prng.read(txt, mlen);
prng.read(rcoin, mlen);
for (auto _ : state) {
cpapke::encrypt<k, eta1, eta2, du, dv>(pkey, txt, rcoin, enc);
benchmark::DoNotOptimize(pkey);
benchmark::DoNotOptimize(txt);
benchmark::DoNotOptimize(rcoin);
benchmark::DoNotOptimize(enc);
benchmark::ClobberMemory();
}
state.SetItemsProcessed(state.iterations());
std::free(seed);
std::free(pkey);
std::free(skey);
std::free(rcoin);
std::free(txt);
std::free(enc);
}
// Benchmarking IND-CPA-secure Kyber public key decryption algorithm
template<const size_t k,
const size_t eta1,
const size_t eta2,
const size_t du,
const size_t dv>
void
decrypt(benchmark::State& state)
{
constexpr size_t slen = 32;
constexpr size_t pklen = kyber_utils::get_cpapke_public_key_len<k>();
constexpr size_t sklen = kyber_utils::get_cpapke_secret_key_len<k>();
constexpr size_t mlen = 32;
constexpr size_t enclen = kyber_utils::get_cpapke_cipher_len<k, du, dv>();
uint8_t* seed = static_cast<uint8_t*>(std::malloc(slen));
uint8_t* pkey = static_cast<uint8_t*>(std::malloc(pklen));
uint8_t* skey = static_cast<uint8_t*>(std::malloc(sklen));
uint8_t* rcoin = static_cast<uint8_t*>(std::malloc(mlen));
uint8_t* txt = static_cast<uint8_t*>(std::malloc(mlen));
uint8_t* enc = static_cast<uint8_t*>(std::malloc(enclen));
uint8_t* dec = static_cast<uint8_t*>(std::malloc(mlen));
prng::prng_t prng;
prng.read(seed, slen);
cpapke::keygen<k, eta1>(seed, pkey, skey);
prng.read(txt, mlen);
prng.read(rcoin, mlen);
cpapke::encrypt<k, eta1, eta2, du, dv>(pkey, txt, rcoin, enc);
for (auto _ : state) {
cpapke::decrypt<k, du, dv>(skey, enc, dec);
benchmark::DoNotOptimize(skey);
benchmark::DoNotOptimize(enc);
benchmark::DoNotOptimize(dec);
benchmark::ClobberMemory();
}
state.SetItemsProcessed(state.iterations());
std::free(seed);
std::free(pkey);
std::free(skey);
std::free(rcoin);
std::free(txt);
std::free(enc);
std::free(dec);
}
}