11#include <botan/internal/hybrid_public_key.h>
13#include <botan/assert.h>
14#include <botan/ec_group.h>
15#include <botan/pk_algs.h>
16#include <botan/pk_options_readers.h>
17#include <botan/internal/buffer_slicer.h>
18#include <botan/internal/buffer_stuffer.h>
19#include <botan/internal/concat_util.h>
20#include <botan/internal/hybrid_kem_ops.h>
21#include <botan/internal/kex_to_kem_adapter.h>
22#include <botan/internal/stl_util.h>
30std::vector<std::pair<std::string, std::string>> algorithm_specs_for_group(
Group_Params group) {
33 switch(group.code()) {
45 case Group_Params::HYBRID_X25519_ML_KEM_768:
46 return {{
"ML-KEM",
"ML-KEM-768"}, {
"X25519",
"X25519"}};
47 case Group_Params::HYBRID_SECP256R1_ML_KEM_768:
48 return {{
"ECDH",
"secp256r1"}, {
"ML-KEM",
"ML-KEM-768"}};
49 case Group_Params::HYBRID_SECP384R1_ML_KEM_1024:
50 return {{
"ECDH",
"secp384r1"}, {
"ML-KEM",
"ML-KEM-1024"}};
52 case Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS:
53 return {{
"X25519",
"X25519"}, {
"FrodoKEM",
"eFrodoKEM-640-SHAKE"}};
54 case Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS:
55 return {{
"X25519",
"X25519"}, {
"FrodoKEM",
"eFrodoKEM-640-AES"}};
56 case Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS:
57 return {{
"X448",
"X448"}, {
"FrodoKEM",
"eFrodoKEM-976-SHAKE"}};
58 case Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS:
59 return {{
"X448",
"X448"}, {
"FrodoKEM",
"eFrodoKEM-976-AES"}};
61 case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS:
62 return {{
"ECDH",
"secp256r1"}, {
"FrodoKEM",
"eFrodoKEM-640-SHAKE"}};
63 case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS:
64 return {{
"ECDH",
"secp256r1"}, {
"FrodoKEM",
"eFrodoKEM-640-AES"}};
66 case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS:
67 return {{
"ECDH",
"secp384r1"}, {
"FrodoKEM",
"eFrodoKEM-976-SHAKE"}};
68 case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS:
69 return {{
"ECDH",
"secp384r1"}, {
"FrodoKEM",
"eFrodoKEM-976-AES"}};
71 case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS:
72 return {{
"ECDH",
"secp521r1"}, {
"FrodoKEM",
"eFrodoKEM-1344-SHAKE"}};
73 case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS:
74 return {{
"ECDH",
"secp521r1"}, {
"FrodoKEM",
"eFrodoKEM-1344-AES"}};
81std::vector<AlgorithmIdentifier> algorithm_identifiers_for_group(
Group_Params group) {
84 const auto specs = algorithm_specs_for_group(group);
85 std::vector<AlgorithmIdentifier> result;
86 result.reserve(specs.size());
95 for(
const auto& spec : specs) {
96 if(spec.first ==
"ECDH") {
106std::vector<size_t> public_key_lengths_for_group(
Group_Params group) {
113 switch(group.code()) {
114 case Group_Params::HYBRID_X25519_ML_KEM_768:
116 case Group_Params::HYBRID_SECP256R1_ML_KEM_768:
118 case Group_Params::HYBRID_SECP384R1_ML_KEM_1024:
121 case Group_Params::HYBRID_X25519_eFRODOKEM_640_SHAKE_OQS:
122 case Group_Params::HYBRID_X25519_eFRODOKEM_640_AES_OQS:
125 case Group_Params::HYBRID_X448_eFRODOKEM_976_SHAKE_OQS:
126 case Group_Params::HYBRID_X448_eFRODOKEM_976_AES_OQS:
129 case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_SHAKE_OQS:
130 case Group_Params::HYBRID_SECP256R1_eFRODOKEM_640_AES_OQS:
133 case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_SHAKE_OQS:
134 case Group_Params::HYBRID_SECP384R1_eFRODOKEM_976_AES_OQS:
137 case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_SHAKE_OQS:
138 case Group_Params::HYBRID_SECP521R1_eFRODOKEM_1344_AES_OQS:
146std::vector<std::unique_ptr<Public_Key>> convert_kex_to_kem_pks(std::vector<std::unique_ptr<Public_Key>> pks) {
147 std::vector<std::unique_ptr<Public_Key>> result;
148 std::transform(pks.begin(), pks.end(), std::back_inserter(result), [](
auto& key) -> std::unique_ptr<Public_Key> {
149 BOTAN_ARG_CHECK(key != nullptr,
"Public key list contains a nullptr");
150 if(key->supports_operation(PublicKeyOperation::KeyAgreement) &&
151 !key->supports_operation(PublicKeyOperation::KeyEncapsulation)) {
152 return std::make_unique<KEX_to_KEM_Adapter_PublicKey>(std::move(key));
154 return std::move(key);
160std::vector<std::unique_ptr<Private_Key>> convert_kex_to_kem_sks(std::vector<std::unique_ptr<Private_Key>> sks) {
161 std::vector<std::unique_ptr<Private_Key>> result;
162 std::transform(sks.begin(), sks.end(), std::back_inserter(result), [](
auto& key) -> std::unique_ptr<Private_Key> {
163 BOTAN_ARG_CHECK(key != nullptr,
"Private key list contains a nullptr");
164 if(key->supports_operation(PublicKeyOperation::KeyAgreement) &&
165 !key->supports_operation(PublicKeyOperation::KeyEncapsulation)) {
166 auto* ka_key = dynamic_cast<PK_Key_Agreement_Key*>(key.get());
167 BOTAN_ASSERT_NONNULL(ka_key);
169 return std::make_unique<KEX_to_KEM_Adapter_PrivateKey>(std::unique_ptr<PK_Key_Agreement_Key>(ka_key));
171 return std::move(key);
177template <
typename KEM_Operation>
178void concat_secret_combiner(KEM_Operation& op,
179 std::span<uint8_t> out_shared_secret,
180 const std::vector<secure_vector<uint8_t>>& shared_secrets,
181 size_t desired_shared_key_len) {
182 BOTAN_ARG_CHECK(out_shared_secret.size() == op.shared_key_length(desired_shared_key_len),
183 "Invalid output buffer size");
185 BufferStuffer shared_secret_stuffer(out_shared_secret);
186 for(
const auto& ss : shared_secrets) {
187 shared_secret_stuffer.append(ss);
192template <
typename KEM_Operation>
193size_t concat_shared_key_length(
const std::vector<KEM_Operation>& operation) {
195 operation,
size_t(0), [](
size_t acc,
const auto& op) {
return acc + op.shared_key_length(0 ); });
199class Hybrid_TLS_KEM_Encryptor final :
public KEM_Encryption_with_Combiner {
201 Hybrid_TLS_KEM_Encryptor(
const std::vector<std::unique_ptr<Public_Key>>& public_keys, std::string_view provider) :
202 KEM_Encryption_with_Combiner(public_keys, provider) {}
204 void combine_shared_secrets(std::span<uint8_t> out_shared_secret,
205 const std::vector<secure_vector<uint8_t>>& shared_secrets,
206 const std::vector<std::vector<uint8_t>>& ,
207 size_t desired_shared_key_len,
208 std::span<const uint8_t> )
override {
209 concat_secret_combiner(*
this, out_shared_secret, shared_secrets, desired_shared_key_len);
212 size_t shared_key_length(
size_t )
const override {
213 return concat_shared_key_length(encryptors());
218class Hybrid_TLS_KEM_Decryptor final :
public KEM_Decryption_with_Combiner {
220 Hybrid_TLS_KEM_Decryptor(
const std::vector<std::unique_ptr<Private_Key>>& private_keys,
221 RandomNumberGenerator& rng,
222 const std::string_view provider) :
223 KEM_Decryption_with_Combiner(private_keys, rng, provider) {}
225 void combine_shared_secrets(std::span<uint8_t> out_shared_secret,
226 const std::vector<secure_vector<uint8_t>>& shared_secrets,
227 const std::vector<std::vector<uint8_t>>& ,
228 size_t desired_shared_key_len,
229 std::span<const uint8_t> )
override {
230 concat_secret_combiner(*
this, out_shared_secret, shared_secrets, desired_shared_key_len);
233 size_t shared_key_length(
size_t )
const override {
234 return concat_shared_key_length(decryptors());
241 Group_Params group, std::span<const uint8_t> concatenated_public_keys) {
243 const auto public_key_lengths = public_key_lengths_for_group(group);
244 auto alg_ids = algorithm_identifiers_for_group(group);
247 const auto expected_public_keys_length =
248 reduce(public_key_lengths,
size_t(0), [](
size_t acc,
size_t len) {
return acc + len; });
249 if(expected_public_keys_length != concatenated_public_keys.size()) {
250 throw Decoding_Error(
"Concatenated public values have an unexpected length");
253 BufferSlicer public_key_slicer(concatenated_public_keys);
254 std::vector<std::unique_ptr<Public_Key>> pks;
255 pks.reserve(alg_ids.size());
256 for(
size_t idx = 0; idx < alg_ids.size(); ++idx) {
257 pks.emplace_back(
load_public_key(alg_ids[idx], public_key_slicer.
take(public_key_lengths[idx])));
260 return std::make_unique<Hybrid_KEM_PublicKey>(std::move(pks));
299 return reduce(
public_keys(), std::vector<uint8_t>(), [](
auto pkb,
const auto& key) {
300 return concat(pkb, key->raw_public_key_bits());
318 return std::make_unique<Hybrid_TLS_KEM_Encryptor>(
public_keys(), options.
provider().value_or(
""));
323 const auto algo_spec = algorithm_specs_for_group(group);
326 for(
const auto& spec : algo_spec) {
329 return std::make_unique<Hybrid_KEM_PrivateKey>(std::move(
private_keys));
340 return std::make_unique<Hybrid_TLS_KEM_Decryptor>(
private_keys(), rng, options.
provider().value_or(
""));
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_ARG_CHECK(expr, msg)
std::span< const uint8_t > take(const size_t count)
static EC_Group from_name(std::string_view name)
std::vector< uint8_t > DER_encode(EC_Group_Encoding form) const
const std::vector< std::unique_ptr< Private_Key > > & private_keys() const
Hybrid_PrivateKey(const Hybrid_PrivateKey &)=delete
static std::vector< std::unique_ptr< Public_Key > > extract_public_keys(const std::vector< std::unique_ptr< Private_Key > > &private_keys)
Hybrid_PublicKey(std::vector< std::unique_ptr< Public_Key > > public_keys)
Constructor for a list of multiple KEM public keys.
std::vector< std::unique_ptr< Private_Key > > generate_other_sks_from_pks(RandomNumberGenerator &rng) const
Helper function for generate_another. Generate a new private key for each public key in this hybrid k...
const std::vector< std::unique_ptr< Public_Key > > & public_keys() const
bool using_raw_shared_key() const
const std::optional< std::string > & provider() const
constexpr bool is_pqc_hybrid() const
static std::unique_ptr< Hybrid_KEM_PrivateKey > generate_from_group(Group_Params group, RandomNumberGenerator &rng)
std::unique_ptr< PK_Ops::KEM_Decryption > _create_kem_decryption_op(RandomNumberGenerator &rng, const PK_KEM_Options_Reader &options) const override
Hybrid_KEM_PrivateKey(std::vector< std::unique_ptr< Private_Key > > private_keys)
AlgorithmIdentifier algorithm_identifier() const override
std::vector< uint8_t > raw_public_key_bits() const override
Hybrid_KEM_PublicKey(std::vector< std::unique_ptr< Public_Key > > pks)
static std::unique_ptr< Hybrid_KEM_PublicKey > load_for_group(Group_Params group, std::span< const uint8_t > concatenated_public_values)
std::unique_ptr< Private_Key > generate_another(RandomNumberGenerator &rng) const final
std::string algo_name() const override
std::vector< uint8_t > public_key_bits() const override
std::unique_ptr< PK_Ops::KEM_Encryption > _create_kem_encryption_op(const PK_KEM_Options_Reader &options) const override
std::unique_ptr< Private_Key > create_private_key(std::string_view alg_name, RandomNumberGenerator &rng, std::string_view params, std::string_view provider)
constexpr auto concat(Rs &&... ranges)
RetT reduce(const std::vector< KeyT > &keys, RetT acc, ReducerT reducer)
std::unique_ptr< Public_Key > load_public_key(const AlgorithmIdentifier &alg_id, std::span< const uint8_t > key_bits)