libcrux 0.0.4

The Formally Verified Cryptography Library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

#include <gtest/gtest.h>

#include <fstream>
#include <nlohmann/json.hpp>

#include "libcrux_mlkem768_portable.h"
#include "libcrux_sha3_portable.h"

using namespace std;

typedef vector<uint8_t> bytes;

template <typename T>
Eurydice_slice mk_slice(T *x, size_t len) {
  Eurydice_slice s = {0};
  s.ptr = (void *)x;
  s.len = len;
  return s;
}

Eurydice_borrow_slice_u8 mk_borrow_slice_u8(const uint8_t *x, size_t len) {
  Eurydice_borrow_slice_u8 s = {0};
  s.ptr = x;
  s.meta = len;
  return s;
}

Eurydice_mut_borrow_slice_u8 mk_mut_borrow_slice_u8(uint8_t *x, size_t len) {
  Eurydice_mut_borrow_slice_u8 s = {0};
  s.ptr = x;
  s.meta = len;
  return s;
}

// Not really random
void generate_random(uint8_t *output, uint32_t output_len) {
  for (size_t i = 0; i < output_len; i++) {
    output[i] = 13;
  }
}

vector<uint8_t> from_hex(const string &hex) {
  if (hex.length() % 2 == 1) {
    throw invalid_argument("Odd-length hex string");
  }

  int len = static_cast<int>(hex.length()) / 2;
  vector<uint8_t> out(len);
  for (int i = 0; i < len; i += 1) {
    string byte = hex.substr(2 * i, 2);
    out[i] = static_cast<uint8_t>(strtol(byte.c_str(), nullptr, 16));
  }

  return out;
}

string bytes_to_hex(const vector<uint8_t> &data) {
  stringstream hex(ios_base::out);
  hex.flags(ios::hex);
  for (const auto &byte : data) {
    hex << setw(2) << setfill('0') << int(byte);
  }
  return hex.str();
}

class KAT {
 public:
  bytes key_generation_seed;
  bytes sha3_256_hash_of_public_key;
  bytes sha3_256_hash_of_secret_key;
  bytes encapsulation_seed;
  bytes sha3_256_hash_of_ciphertext;
  bytes shared_secret;
};

vector<KAT> read_kats(string path) {
  ifstream kat_file(path);
  nlohmann::json kats_raw;
  kat_file >> kats_raw;

  vector<KAT> kats;

  // Read test group
  for (auto &kat_raw : kats_raw.items()) {
    auto kat_raw_value = kat_raw.value();

    kats.push_back(KAT{
        from_hex(kat_raw_value["key_generation_seed"]),
        from_hex(kat_raw_value["sha3_256_hash_of_public_key"]),
        from_hex(kat_raw_value["sha3_256_hash_of_secret_key"]),
        from_hex(kat_raw_value["encapsulation_seed"]),
        from_hex(kat_raw_value["sha3_256_hash_of_ciphertext"]),
        from_hex(kat_raw_value["shared_secret"]),
    });
  }

  return kats;
}