From f5d49e0681095cfbccb6d27a7df8032712732b8a Mon Sep 17 00:00:00 2001 From: Fabian Albert Date: Tue, 14 May 2024 14:11:25 +0200 Subject: [PATCH 1/2] Abstraction layer for hybrid KEMs --- src/lib/pubkey/hybrid_kem/hybrid_kem.cpp | 84 +++++ src/lib/pubkey/hybrid_kem/hybrid_kem.h | 137 ++++++++ src/lib/pubkey/hybrid_kem/hybrid_kem_ops.cpp | 109 +++++++ src/lib/pubkey/hybrid_kem/hybrid_kem_ops.h | 141 ++++++++ src/lib/pubkey/hybrid_kem/info.txt | 20 ++ src/lib/pubkey/kex_to_kem_adapter/info.txt | 18 ++ .../kex_to_kem_adapter.cpp | 24 +- .../kex_to_kem_adapter}/kex_to_kem_adapter.h | 13 +- src/lib/tls/tls13_pqc/hybrid_public_key.cpp | 304 +++++++----------- src/lib/tls/tls13_pqc/hybrid_public_key.h | 49 +-- src/lib/tls/tls13_pqc/info.txt | 3 +- src/tests/test_tls_hybrid_kem_key.cpp | 75 +++-- 12 files changed, 710 insertions(+), 267 deletions(-) create mode 100644 src/lib/pubkey/hybrid_kem/hybrid_kem.cpp create mode 100644 src/lib/pubkey/hybrid_kem/hybrid_kem.h create mode 100644 src/lib/pubkey/hybrid_kem/hybrid_kem_ops.cpp create mode 100644 src/lib/pubkey/hybrid_kem/hybrid_kem_ops.h create mode 100644 src/lib/pubkey/hybrid_kem/info.txt create mode 100644 src/lib/pubkey/kex_to_kem_adapter/info.txt rename src/lib/{tls/tls13_pqc => pubkey/kex_to_kem_adapter}/kex_to_kem_adapter.cpp (93%) rename src/lib/{tls/tls13_pqc => pubkey/kex_to_kem_adapter}/kex_to_kem_adapter.h (88%) diff --git a/src/lib/pubkey/hybrid_kem/hybrid_kem.cpp b/src/lib/pubkey/hybrid_kem/hybrid_kem.cpp new file mode 100644 index 00000000000..e88c9fc5ab8 --- /dev/null +++ b/src/lib/pubkey/hybrid_kem/hybrid_kem.cpp @@ -0,0 +1,84 @@ +/** +* Abstraction for a combined KEM public and private key. +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert, René Meusel - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ +#include + +#include +#include +#include +#include +#include + +namespace Botan { + +Hybrid_PublicKey::Hybrid_PublicKey(std::vector> pks) : + m_pks(std::move(pks)), m_key_length(0), m_estimated_strength(0) { + BOTAN_ARG_CHECK(m_pks.size() >= 2, "List of public keys must include at least two keys"); + for(const auto& pk : m_pks) { + BOTAN_ARG_CHECK(pk != nullptr, "List of public keys contains a nullptr"); + BOTAN_ARG_CHECK(pk->supports_operation(PublicKeyOperation::KeyEncapsulation), + fmt("Public key type '{}' does not support key encapsulation", pk->algo_name()).c_str()); + m_key_length = std::max(m_key_length, pk->key_length()); + m_estimated_strength = std::max(m_estimated_strength, pk->estimated_strength()); + } +} + +bool Hybrid_PublicKey::check_key(RandomNumberGenerator& rng, bool strong) const { + return reduce(public_keys(), true, [&](bool ckr, const auto& key) { return ckr && key->check_key(rng, strong); }); +} + +std::vector Hybrid_PublicKey::raw_public_key_bits() const { + return reduce(public_keys(), std::vector(), [](auto pkb, const auto& key) { + return concat(pkb, key->raw_public_key_bits()); + }); +} + +bool Hybrid_PublicKey::supports_operation(PublicKeyOperation op) const { + return PublicKeyOperation::KeyEncapsulation == op; +} + +std::vector> Hybrid_PublicKey::generate_other_sks_from_pks( + RandomNumberGenerator& rng) const { + std::vector> new_private_keys; + new_private_keys.reserve(public_keys().size()); + for(const auto& pk : public_keys()) { + new_private_keys.push_back(pk->generate_another(rng)); + } + return new_private_keys; +} + +Hybrid_PrivateKey::Hybrid_PrivateKey(std::vector> private_keys) : + m_sks(std::move(private_keys)) { + BOTAN_ARG_CHECK(m_sks.size() >= 2, "List of secret keys must include at least two keys"); + for(const auto& sk : m_sks) { + BOTAN_ARG_CHECK(sk != nullptr, "List of secret keys contains a nullptr"); + BOTAN_ARG_CHECK(sk->supports_operation(PublicKeyOperation::KeyEncapsulation), + "Some provided secret key is not compatible with this hybrid wrapper"); + } +} + +secure_vector Hybrid_PrivateKey::private_key_bits() const { + throw Not_Implemented("Hybrid private keys cannot be serialized"); +} + +bool Hybrid_PrivateKey::check_key(RandomNumberGenerator& rng, bool strong) const { + return reduce(private_keys(), true, [&](bool ckr, const auto& key) { return ckr && key->check_key(rng, strong); }); +} + +std::vector> Hybrid_PrivateKey::extract_public_keys( + const std::vector>& private_keys) { + std::vector> public_keys; + public_keys.reserve(private_keys.size()); + for(const auto& sk : private_keys) { + BOTAN_ARG_CHECK(sk != nullptr, "List of private keys contains a nullptr"); + public_keys.push_back(sk->public_key()); + } + return public_keys; +} + +} // namespace Botan diff --git a/src/lib/pubkey/hybrid_kem/hybrid_kem.h b/src/lib/pubkey/hybrid_kem/hybrid_kem.h new file mode 100644 index 00000000000..d4f7e680bab --- /dev/null +++ b/src/lib/pubkey/hybrid_kem/hybrid_kem.h @@ -0,0 +1,137 @@ +/** +* Abstraction for a combined KEM public and private key. +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert, René Meusel - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#ifndef BOTAN_HYBRID_KEM_H_ +#define BOTAN_HYBRID_KEM_H_ + +#include +#include +#include + +#include +#include + +namespace Botan { + +/** + * @brief Abstraction for a combined KEM public key. + * + * Two or more KEM public keys are combined into a single KEM public key. Derived classes + * must implement the abstract methods to provide the encryption operation, e.g. by + * specifying how encryption results are combined to the ciphertext and how a KEM combiner + * is applied to derive the shared secret using the individual shared secrets, ciphertexts, + * and other context information. + */ +class BOTAN_TEST_API Hybrid_PublicKey : public virtual Public_Key { + public: + /** + * @brief Constructor for a list of multiple KEM public keys. + * + * To use KEX algorithms use the KEX_to_KEM_Adapter_PublicKey. + * @param public_keys List of public keys to combine + */ + explicit Hybrid_PublicKey(std::vector> public_keys); + + Hybrid_PublicKey(Hybrid_PublicKey&&) = default; + Hybrid_PublicKey(const Hybrid_PublicKey&) = delete; + Hybrid_PublicKey& operator=(Hybrid_PublicKey&&) = default; + Hybrid_PublicKey& operator=(const Hybrid_PublicKey&) = delete; + ~Hybrid_PublicKey() override = default; + + size_t estimated_strength() const override { return m_estimated_strength; } + + size_t key_length() const override { return m_key_length; } + + bool check_key(RandomNumberGenerator& rng, bool strong) const override; + + std::vector raw_public_key_bits() const override; + + /** + * @brief Return the public key bits of this hybrid key as the concatenated + * bytes of the individual public keys (without encoding). + * + * @return the public key bytes + */ + std::vector public_key_bits() const override { return raw_public_key_bits(); } + + bool supports_operation(PublicKeyOperation op) const override; + + /// @returns the public keys combined in this hybrid key + const std::vector>& public_keys() const { return m_pks; } + + protected: + // Default constructor used for virtual inheritance to prevent, that the derived class + // calls the constructor twice. + Hybrid_PublicKey() = default; + + std::vector> copy_public_keys() const; + + /** + * @brief Helper function for generate_another. Generate a new private key for each + * public key in this hybrid key. + */ + std::vector> generate_other_sks_from_pks(RandomNumberGenerator& rng) const; + + private: + std::vector> m_pks; + + size_t m_key_length; + size_t m_estimated_strength; +}; + +BOTAN_DIAGNOSTIC_PUSH +BOTAN_DIAGNOSTIC_IGNORE_INHERITED_VIA_DOMINANCE + +/** + * @brief Abstraction for a combined KEM private key. + * + * Two or more KEM private keys are combined into a single KEM private key. Derived classes + * must implement the abstract methods to provide the decryption operation, e.g. by + * specifying how a KEM combiner is applied to derive the shared secret using the + * individual shared secrets, ciphertexts, and other context information. + */ +class BOTAN_TEST_API Hybrid_PrivateKey : virtual public Private_Key { + public: + Hybrid_PrivateKey(const Hybrid_PrivateKey&) = delete; + Hybrid_PrivateKey& operator=(const Hybrid_PrivateKey&) = delete; + + Hybrid_PrivateKey(Hybrid_PrivateKey&&) = default; + Hybrid_PrivateKey& operator=(Hybrid_PrivateKey&&) = default; + + ~Hybrid_PrivateKey() override = default; + + /** + * @brief Constructor for a list of multiple KEM private keys. + * + * To use KEX algorithms use the KEX_to_KEM_Adapter_PrivateKey. + * @param private_keys List of private keys to combine + */ + Hybrid_PrivateKey(std::vector> private_keys); + + /// Disabled by default + secure_vector private_key_bits() const override; + + /// @returns the private keys combined in this hybrid key + const std::vector>& private_keys() const { return m_sks; } + + bool check_key(RandomNumberGenerator& rng, bool strong) const override; + + protected: + static std::vector> extract_public_keys( + const std::vector>& private_keys); + + private: + std::vector> m_sks; +}; + +BOTAN_DIAGNOSTIC_POP + +} // namespace Botan + +#endif diff --git a/src/lib/pubkey/hybrid_kem/hybrid_kem_ops.cpp b/src/lib/pubkey/hybrid_kem/hybrid_kem_ops.cpp new file mode 100644 index 00000000000..9687ded2043 --- /dev/null +++ b/src/lib/pubkey/hybrid_kem/hybrid_kem_ops.cpp @@ -0,0 +1,109 @@ +/** +* Abstraction for a combined KEM encryptors and decryptors. +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert, René Meusel - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ +#include + +#include + +namespace Botan { + +KEM_Encryption_with_Combiner::KEM_Encryption_with_Combiner(const std::vector>& public_keys, + std::string_view provider) : + m_encapsulated_key_length(0) { + m_encryptors.reserve(public_keys.size()); + for(const auto& pk : public_keys) { + const auto& newenc = m_encryptors.emplace_back(*pk, "Raw", provider); + m_encapsulated_key_length += newenc.encapsulated_key_length(); + } +} + +void KEM_Encryption_with_Combiner::kem_encrypt(std::span out_encapsulated_key, + std::span out_shared_key, + RandomNumberGenerator& rng, + size_t desired_shared_key_len, + std::span salt) { + BOTAN_ARG_CHECK(out_encapsulated_key.size() == encapsulated_key_length(), + "Encapsulated key output buffer has wrong size"); + BOTAN_ARG_CHECK(out_shared_key.size() == shared_key_length(desired_shared_key_len), + "Shared key output buffer has wrong size"); + + std::vector> shared_secrets; + shared_secrets.reserve(m_encryptors.size()); + + std::vector> ciphertexts; + ciphertexts.reserve(m_encryptors.size()); + + for(auto& encryptor : m_encryptors) { + auto [ct, ss] = KEM_Encapsulation::destructure(encryptor.encrypt(rng, 0 /* no KDF */)); + shared_secrets.push_back(std::move(ss)); + ciphertexts.push_back(std::move(ct)); + } + combine_ciphertexts(out_encapsulated_key, ciphertexts, salt); + combine_shared_secrets(out_shared_key, shared_secrets, ciphertexts, desired_shared_key_len, salt); +} + +void KEM_Encryption_with_Combiner::combine_ciphertexts(std::span out_ciphertext, + const std::vector>& ciphertexts, + std::span salt) { + BOTAN_ARG_CHECK(salt.empty(), "Salt not supported by this KEM"); + BOTAN_ARG_CHECK(ciphertexts.size() == m_encryptors.size(), "Invalid number of ciphertexts"); + BOTAN_ARG_CHECK(out_ciphertext.size() == encapsulated_key_length(), "Invalid output buffer size"); + BufferStuffer ct_stuffer(out_ciphertext); + for(size_t idx = 0; idx < ciphertexts.size(); idx++) { + BOTAN_ARG_CHECK(ciphertexts.at(idx).size() == m_encryptors.at(idx).encapsulated_key_length(), + "Invalid ciphertext length"); + ct_stuffer.append(ciphertexts.at(idx)); + } + BOTAN_ASSERT_NOMSG(ct_stuffer.full()); +} + +KEM_Decryption_with_Combiner::KEM_Decryption_with_Combiner( + const std::vector>& private_keys, + RandomNumberGenerator& rng, + std::string_view provider) : + m_encapsulated_key_length(0) { + m_decryptors.reserve(private_keys.size()); + for(const auto& sk : private_keys) { + const auto& newenc = m_decryptors.emplace_back(*sk, rng, "Raw", provider); + m_encapsulated_key_length += newenc.encapsulated_key_length(); + } +} + +void KEM_Decryption_with_Combiner::kem_decrypt(std::span out_shared_key, + std::span encapsulated_key, + size_t desired_shared_key_len, + std::span salt) { + BOTAN_ARG_CHECK(encapsulated_key.size() == encapsulated_key_length(), "Invalid encapsulated key length"); + BOTAN_ARG_CHECK(out_shared_key.size() == shared_key_length(desired_shared_key_len), "Invalid output buffer size"); + + std::vector> shared_secrets; + shared_secrets.reserve(m_decryptors.size()); + auto ciphertexts = split_ciphertexts(encapsulated_key); + BOTAN_ASSERT(ciphertexts.size() == m_decryptors.size(), "Correct number of ciphertexts"); + + for(size_t idx = 0; idx < m_decryptors.size(); idx++) { + shared_secrets.push_back(m_decryptors.at(idx).decrypt(ciphertexts.at(idx), 0 /* no KDF */)); + } + + combine_shared_secrets(out_shared_key, shared_secrets, ciphertexts, desired_shared_key_len, salt); +} + +std::vector> KEM_Decryption_with_Combiner::split_ciphertexts( + std::span concat_ciphertext) { + BOTAN_ARG_CHECK(concat_ciphertext.size() == encapsulated_key_length(), "Wrong ciphertext length"); + std::vector> ciphertexts; + ciphertexts.reserve(m_decryptors.size()); + BufferSlicer ct_slicer(concat_ciphertext); + for(const auto& decryptor : m_decryptors) { + ciphertexts.push_back(ct_slicer.copy_as_vector(decryptor.encapsulated_key_length())); + } + BOTAN_ASSERT_NOMSG(ct_slicer.empty()); + return ciphertexts; +} + +} // namespace Botan diff --git a/src/lib/pubkey/hybrid_kem/hybrid_kem_ops.h b/src/lib/pubkey/hybrid_kem/hybrid_kem_ops.h new file mode 100644 index 00000000000..0bf66273437 --- /dev/null +++ b/src/lib/pubkey/hybrid_kem/hybrid_kem_ops.h @@ -0,0 +1,141 @@ +/** +* Abstraction for a combined KEM encryptors and decryptors. +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert, René Meusel - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#ifndef BOTAN_HYBRID_KEM_OPS_H_ +#define BOTAN_HYBRID_KEM_OPS_H_ + +#include +#include +#include +#include + +#include +#include + +namespace Botan { + +/** + * @brief Abstract interface for a KEM encryption operation for KEM combiners. + * + * Multiple public keys are used to encapsulate shared secrets. These shared + * secrets (and maybe the ciphertexts and public keys) are combined using the + * KEM combiner to derive the final shared secret. + * + */ +class KEM_Encryption_with_Combiner : public PK_Ops::KEM_Encryption { + public: + KEM_Encryption_with_Combiner(const std::vector>& public_keys, + std::string_view provider); + + void kem_encrypt(std::span out_encapsulated_key, + std::span out_shared_key, + RandomNumberGenerator& rng, + size_t desired_shared_key_len, + std::span salt) final; + + /// The default implementation returns the sum of the encapsulated key lengths of the underlying KEMs. + size_t encapsulated_key_length() const override { return m_encapsulated_key_length; } + + protected: + /** + * @brief Defines how multiple ciphertexts are combined into a single ciphertext. + * + * The default implementation concatenates the ciphertexts. + * + * @param out_ciphertext The output buffer for the combined ciphertext + * @param ciphertexts The ciphertexts to combine + * @param salt The salt. In this default implementation the salt must be empty. + */ + virtual void combine_ciphertexts(std::span out_ciphertext, + const std::vector>& ciphertexts, + std::span salt); + + /** + * @brief Describes how the shared secrets are combined to derive the final shared secret. + * + * @param out_shared_secret the output buffer for the shared secret + * @param shared_secrets a list of shared secrets coreesponding to the public keys + * @param ciphertexts a list of encapsulated shared secrets + * @param desired_shared_key_len the desired shared key length + * @param salt the salt (input of kem_encrypt) + */ + virtual void combine_shared_secrets(std::span out_shared_secret, + const std::vector>& shared_secrets, + const std::vector>& ciphertexts, + size_t desired_shared_key_len, + std::span salt) = 0; + + std::vector& encryptors() { return m_encryptors; } + + const std::vector& encryptors() const { return m_encryptors; } + + private: + std::vector m_encryptors; + size_t m_encapsulated_key_length; +}; + +/** + * @brief Abstract interface for a KEM decryption operation for KEM combiners. + * + * Multiple private keys are used to decapsulate shared secrets from a combined + * ciphertext (concatenated in most cases). These shared + * secrets (and maybe the ciphertexts and public keys) are combined using the + * KEM combiner to derive the final shared secret. + */ +class KEM_Decryption_with_Combiner : public PK_Ops::KEM_Decryption { + public: + KEM_Decryption_with_Combiner(const std::vector>& private_keys, + RandomNumberGenerator& rng, + std::string_view provider); + + void kem_decrypt(std::span out_shared_key, + std::span encapsulated_key, + size_t desired_shared_key_len, + std::span salt) final; + + /// The default implementation returns the sum of the encapsulated key lengths of the underlying KEMs. + size_t encapsulated_key_length() const override { return m_encapsulated_key_length; } + + protected: + /** + * @brief Defines how the individual ciphertexts are extracted from the combined ciphertext. + * + * The default implementation splits concatenated ciphertexts. + * @param concat_ciphertext The combined ciphertext + * @returns The individual ciphertexts + */ + virtual std::vector> split_ciphertexts(std::span concat_ciphertext); + + /** + * @brief Describes how the shared secrets are combined to derive the final shared secret. + * + * @param out_shared_secret the output buffer for the shared secret + * @param shared_secrets a list of shared secrets coreesponding to the public keys + * @param ciphertexts the list of encapsulated shared secrets + * @param desired_shared_key_len the desired shared key length + * @param salt the salt (input of kem_decrypt) + */ + virtual void combine_shared_secrets(std::span out_shared_secret, + const std::vector>& shared_secrets, + const std::vector>& ciphertexts, + size_t desired_shared_key_len, + std::span salt) = 0; + + std::vector& decryptors() { return m_decryptors; } + + const std::vector& decryptors() const { return m_decryptors; } + + private: + std::vector m_decryptors; + size_t m_encapsulated_key_length; +}; + +} // namespace Botan + +#endif // BOTAN_HYBRID_KEM_OPS_H_ diff --git a/src/lib/pubkey/hybrid_kem/info.txt b/src/lib/pubkey/hybrid_kem/info.txt new file mode 100644 index 00000000000..f51fb9e8cd7 --- /dev/null +++ b/src/lib/pubkey/hybrid_kem/info.txt @@ -0,0 +1,20 @@ + +HYBRID_KEM -> 20240425 + + + +name -> "Hybrid KEM" +type -> "Internal" + + + +hybrid_kem.h + + + +hybrid_kem_ops.h + + + + + diff --git a/src/lib/pubkey/kex_to_kem_adapter/info.txt b/src/lib/pubkey/kex_to_kem_adapter/info.txt new file mode 100644 index 00000000000..ec9fee6c088 --- /dev/null +++ b/src/lib/pubkey/kex_to_kem_adapter/info.txt @@ -0,0 +1,18 @@ + +KEX_TO_KEM_ADAPTER -> 20240504 + + + +name -> "KEX to KEM adapter" +brief -> "Basic KEX to KEM key transformation" +type -> "Internal" + + + + +kex_to_kem_adapter.h + + + + + diff --git a/src/lib/tls/tls13_pqc/kex_to_kem_adapter.cpp b/src/lib/pubkey/kex_to_kem_adapter/kex_to_kem_adapter.cpp similarity index 93% rename from src/lib/tls/tls13_pqc/kex_to_kem_adapter.cpp rename to src/lib/pubkey/kex_to_kem_adapter/kex_to_kem_adapter.cpp index fd51dfcc9f9..f14c0a56676 100644 --- a/src/lib/tls/tls13_pqc/kex_to_kem_adapter.cpp +++ b/src/lib/pubkey/kex_to_kem_adapter/kex_to_kem_adapter.cpp @@ -3,7 +3,7 @@ * key in the KEM encapsulation. * * (C) 2023 Jack Lloyd - * 2023 Fabian Albert, René Meusel - Rohde & Schwarz Cybersecurity + * 2023,2024 Fabian Albert, René Meusel - Rohde & Schwarz Cybersecurity * * Botan is released under the Simplified BSD License (see license.txt) */ @@ -31,7 +31,7 @@ #include #endif -namespace Botan::TLS { +namespace Botan { namespace { @@ -103,7 +103,7 @@ std::unique_ptr generate_key_agreement_private_key(const P return new_kex_key; } -std::unique_ptr maybe_get_public_key(const std::unique_ptr& private_key) { +std::unique_ptr maybe_get_public_key(const std::unique_ptr& private_key) { BOTAN_ARG_CHECK(private_key != nullptr, "Private key is a nullptr"); return private_key->public_key(); } @@ -210,7 +210,7 @@ std::vector KEX_to_KEM_Adapter_PublicKey::raw_public_key_bits() const { } std::vector KEX_to_KEM_Adapter_PublicKey::public_key_bits() const { - throw Not_Implemented("The KEX-to-KEM adapter does not support ASN.1-based public key serialization"); + return m_public_key->public_key_bits(); } std::unique_ptr KEX_to_KEM_Adapter_PublicKey::generate_another(RandomNumberGenerator& rng) const { @@ -221,15 +221,21 @@ bool KEX_to_KEM_Adapter_PublicKey::supports_operation(PublicKeyOperation op) con return op == PublicKeyOperation::KeyEncapsulation; } -KEX_to_KEM_Adapter_PrivateKey::KEX_to_KEM_Adapter_PrivateKey(std::unique_ptr private_key) : - KEX_to_KEM_Adapter_PublicKey(maybe_get_public_key(private_key)), m_private_key(std::move(private_key)) { - BOTAN_ARG_CHECK(m_private_key->supports_operation(PublicKeyOperation::KeyAgreement), "Private key is no KEX key"); -} +KEX_to_KEM_Adapter_PrivateKey::KEX_to_KEM_Adapter_PrivateKey(std::unique_ptr private_key) : + KEX_to_KEM_Adapter_PublicKey(maybe_get_public_key(private_key)), m_private_key([&]() { + auto sk = dynamic_cast(private_key.release()); + BOTAN_ARG_CHECK(sk != nullptr, "Private Key must implement the PK_Key_Agreement_Key interface"); + return std::unique_ptr(sk); + }()) {} secure_vector KEX_to_KEM_Adapter_PrivateKey::private_key_bits() const { return m_private_key->private_key_bits(); } +secure_vector KEX_to_KEM_Adapter_PrivateKey::raw_private_key_bits() const { + return m_private_key->raw_private_key_bits(); +} + std::unique_ptr KEX_to_KEM_Adapter_PrivateKey::public_key() const { return std::make_unique(m_private_key->public_key()); } @@ -248,4 +254,4 @@ std::unique_ptr KEX_to_KEM_Adapter_PrivateKey::create_ke return std::make_unique(*m_private_key, rng, kdf, provider); } -} // namespace Botan::TLS +} // namespace Botan diff --git a/src/lib/tls/tls13_pqc/kex_to_kem_adapter.h b/src/lib/pubkey/kex_to_kem_adapter/kex_to_kem_adapter.h similarity index 88% rename from src/lib/tls/tls13_pqc/kex_to_kem_adapter.h rename to src/lib/pubkey/kex_to_kem_adapter/kex_to_kem_adapter.h index 9c57f24d343..cbccd51b046 100644 --- a/src/lib/tls/tls13_pqc/kex_to_kem_adapter.h +++ b/src/lib/pubkey/kex_to_kem_adapter/kex_to_kem_adapter.h @@ -3,7 +3,7 @@ * key in the KEM encapsulation. * * (C) 2023 Jack Lloyd - * 2023 Fabian Albert, René Meusel - Rohde & Schwarz Cybersecurity + * 2023,2024 Fabian Albert, René Meusel - Rohde & Schwarz Cybersecurity * * Botan is released under the Simplified BSD License (see license.txt) */ @@ -15,7 +15,7 @@ #include -namespace Botan::TLS { +namespace Botan { /** * Adapter to use a key agreement key pair (e.g. ECDH) as a key encapsulation @@ -49,7 +49,8 @@ BOTAN_DIAGNOSTIC_IGNORE_INHERITED_VIA_DOMINANCE /** * Adapter to use a key agreement key pair (e.g. ECDH) as a key encapsulation * mechanism. This works by generating an ephemeral key pair during the - * encapsulation. + * encapsulation. The following Botan key types are supported: + * ECDH, DH, X25519 and X448. * * The abstract interface of a key exchange mechanism (KEX) is mapped like so: * @@ -67,10 +68,12 @@ BOTAN_DIAGNOSTIC_IGNORE_INHERITED_VIA_DOMINANCE class BOTAN_TEST_API KEX_to_KEM_Adapter_PrivateKey final : public KEX_to_KEM_Adapter_PublicKey, public virtual Private_Key { public: - KEX_to_KEM_Adapter_PrivateKey(std::unique_ptr private_key); + KEX_to_KEM_Adapter_PrivateKey(std::unique_ptr private_key); secure_vector private_key_bits() const override; + secure_vector raw_private_key_bits() const override; + std::unique_ptr public_key() const override; bool check_key(RandomNumberGenerator& rng, bool strong) const override; @@ -84,6 +87,6 @@ class BOTAN_TEST_API KEX_to_KEM_Adapter_PrivateKey final : public KEX_to_KEM_Ada BOTAN_DIAGNOSTIC_POP -} // namespace Botan::TLS +} // namespace Botan #endif diff --git a/src/lib/tls/tls13_pqc/hybrid_public_key.cpp b/src/lib/tls/tls13_pqc/hybrid_public_key.cpp index a49dd9c66c9..c326456b0a1 100644 --- a/src/lib/tls/tls13_pqc/hybrid_public_key.cpp +++ b/src/lib/tls/tls13_pqc/hybrid_public_key.cpp @@ -13,6 +13,7 @@ #include #include +#include #include #include #include @@ -142,6 +143,98 @@ std::vector public_value_lengths_for_group(Group_Params group) { } } +std::vector> convert_kex_to_kem_pks(std::vector> pks) { + std::vector> result; + std::transform(pks.begin(), pks.end(), std::back_inserter(result), [](auto& key) -> std::unique_ptr { + BOTAN_ARG_CHECK(key != nullptr, "Public key list contains a nullptr"); + if(key->supports_operation(PublicKeyOperation::KeyAgreement) && + !key->supports_operation(PublicKeyOperation::KeyEncapsulation)) { + return std::make_unique(std::move(key)); + } else { + return std::move(key); + } + }); + return result; +} + +std::vector> convert_kex_to_kem_sks(std::vector> sks) { + std::vector> result; + std::transform(sks.begin(), sks.end(), std::back_inserter(result), [](auto& key) -> std::unique_ptr { + BOTAN_ARG_CHECK(key != nullptr, "Private key list contains a nullptr"); + if(key->supports_operation(PublicKeyOperation::KeyAgreement) && + !key->supports_operation(PublicKeyOperation::KeyEncapsulation)) { + auto ka_key = dynamic_cast(key.get()); + BOTAN_ASSERT_NONNULL(ka_key); + (void)key.release(); + return std::make_unique(std::unique_ptr(ka_key)); + } else { + return std::move(key); + } + }); + return result; +} + +template +void concat_secret_combiner(KEM_Operation& op, + std::span out_shared_secret, + const std::vector>& shared_secrets, + size_t desired_shared_key_len) { + BOTAN_ARG_CHECK(out_shared_secret.size() == op.shared_key_length(desired_shared_key_len), + "Invalid output buffer size"); + + BufferStuffer shared_secret_stuffer(out_shared_secret); + for(size_t idx = 0; idx < shared_secrets.size(); idx++) { + shared_secret_stuffer.append(shared_secrets.at(idx)); + } + BOTAN_ASSERT_NOMSG(shared_secret_stuffer.full()); +} + +template +size_t concat_shared_key_length(const std::vector& operation) { + return reduce( + operation, size_t(0), [](size_t acc, const auto& op) { return acc + op.shared_key_length(0 /*no KDF*/); }); +} + +/// Encryptor that simply concatenates the multiple shared secrets +class Hybrid_TLS_KEM_Encryptor final : public KEM_Encryption_with_Combiner { + public: + Hybrid_TLS_KEM_Encryptor(const std::vector>& public_keys, std::string_view provider) : + KEM_Encryption_with_Combiner(public_keys, provider) {} + + void combine_shared_secrets(std::span out_shared_secret, + const std::vector>& shared_secrets, + const std::vector>& /*ciphertexts*/, + size_t desired_shared_key_len, + std::span /*salt*/) override { + concat_secret_combiner(*this, out_shared_secret, shared_secrets, desired_shared_key_len); + } + + size_t shared_key_length(size_t /*desired_shared_key_len*/) const override { + return concat_shared_key_length(encryptors()); + } +}; + +/// Decryptor that simply concatenates the multiple shared secrets +class Hybrid_TLS_KEM_Decryptor final : public KEM_Decryption_with_Combiner { + public: + Hybrid_TLS_KEM_Decryptor(const std::vector>& private_keys, + RandomNumberGenerator& rng, + const std::string_view provider) : + KEM_Decryption_with_Combiner(private_keys, rng, provider) {} + + void combine_shared_secrets(std::span out_shared_secret, + const std::vector>& shared_secrets, + const std::vector>& /*ciphertexts*/, + size_t desired_shared_key_len, + std::span /*salt*/) override { + concat_secret_combiner(*this, out_shared_secret, shared_secrets, desired_shared_key_len); + } + + size_t shared_key_length(size_t /*desired_shared_key_len*/) const override { + return concat_shared_key_length(decryptors()); + } +}; + } // namespace std::unique_ptr Hybrid_KEM_PublicKey::load_for_group( @@ -164,58 +257,25 @@ std::unique_ptr Hybrid_KEM_PublicKey::load_for_group( return std::make_unique(std::move(pks)); } -Hybrid_KEM_PublicKey::Hybrid_KEM_PublicKey(std::vector> pks) { - BOTAN_ARG_CHECK(pks.size() >= 2, "List of public keys must include at least two keys"); - BOTAN_ARG_CHECK(std::all_of(pks.begin(), pks.end(), [](const auto& pk) { return pk != nullptr; }), - "List of public keys contains a nullptr"); - BOTAN_ARG_CHECK(std::all_of(pks.begin(), - pks.end(), - [](const auto& pk) { - return pk->supports_operation(PublicKeyOperation::KeyEncapsulation) || - pk->supports_operation(PublicKeyOperation::KeyAgreement); - }), - "Some provided public key is not compatible with this hybrid wrapper"); - - std::transform( - pks.begin(), pks.end(), std::back_inserter(m_public_keys), [](auto& key) -> std::unique_ptr { - if(key->supports_operation(PublicKeyOperation::KeyAgreement) && - !key->supports_operation(PublicKeyOperation::KeyEncapsulation)) { - return std::make_unique(std::move(key)); - } else { - return std::move(key); - } - }); - - m_key_length = - reduce(m_public_keys, size_t(0), [](size_t kl, const auto& key) { return std::max(kl, key->key_length()); }); - m_estimated_strength = reduce( - m_public_keys, size_t(0), [](size_t es, const auto& key) { return std::max(es, key->estimated_strength()); }); -} +Hybrid_KEM_PublicKey::Hybrid_KEM_PublicKey(std::vector> pks) : + Hybrid_PublicKey(convert_kex_to_kem_pks(std::move(pks))) {} + +Hybrid_KEM_PrivateKey::Hybrid_KEM_PrivateKey(std::vector> sks) : + Hybrid_PublicKey(convert_kex_to_kem_pks(extract_public_keys(sks))), + Hybrid_PrivateKey(convert_kex_to_kem_sks(std::move(sks))) {} std::string Hybrid_KEM_PublicKey::algo_name() const { std::ostringstream algo_name("Hybrid("); - for(size_t i = 0; i < m_public_keys.size(); ++i) { + for(size_t i = 0; i < public_keys().size(); ++i) { if(i > 0) { algo_name << ","; } - algo_name << m_public_keys[i]->algo_name(); + algo_name << public_keys().at(i)->algo_name(); } algo_name << ")"; return algo_name.str(); } -size_t Hybrid_KEM_PublicKey::estimated_strength() const { - return m_estimated_strength; -} - -size_t Hybrid_KEM_PublicKey::key_length() const { - return m_key_length; -} - -bool Hybrid_KEM_PublicKey::check_key(RandomNumberGenerator& rng, bool strong) const { - return reduce(m_public_keys, true, [&](bool ckr, const auto& key) { return ckr && key->check_key(rng, strong); }); -} - AlgorithmIdentifier Hybrid_KEM_PublicKey::algorithm_identifier() const { throw Botan::Not_Implemented("Hybrid keys don't have an algorithm identifier"); } @@ -232,87 +292,23 @@ std::vector Hybrid_KEM_PublicKey::raw_public_key_bits() const { // to be used with values that are not fixed-length, a length prefix or // other unambiguous encoding must be used to ensure that the composition // of the two values is injective. - return reduce(m_public_keys, std::vector(), [](auto pkb, const auto& key) { + return reduce(public_keys(), std::vector(), [](auto pkb, const auto& key) { return concat(pkb, key->raw_public_key_bits()); }); } std::unique_ptr Hybrid_KEM_PublicKey::generate_another(RandomNumberGenerator& rng) const { - std::vector> new_private_keys; - std::transform( - m_public_keys.begin(), m_public_keys.end(), std::back_inserter(new_private_keys), [&](const auto& public_key) { - return public_key->generate_another(rng); - }); - return std::make_unique(std::move(new_private_keys)); -} - -bool Hybrid_KEM_PublicKey::supports_operation(PublicKeyOperation op) const { - return PublicKeyOperation::KeyEncapsulation == op; + return std::make_unique(generate_other_sks_from_pks(rng)); } -namespace { - -class Hybrid_KEM_Encryption_Operation final : public PK_Ops::KEM_Encryption_with_KDF { - public: - Hybrid_KEM_Encryption_Operation(const Hybrid_KEM_PublicKey& key, - std::string_view kdf, - std::string_view provider) : - PK_Ops::KEM_Encryption_with_KDF(kdf), m_raw_kem_shared_key_length(0), m_encapsulated_key_length(0) { - m_kem_encryptors.reserve(key.public_keys().size()); - for(const auto& k : key.public_keys()) { - const auto& newenc = m_kem_encryptors.emplace_back(*k, "Raw", provider); - m_raw_kem_shared_key_length += newenc.shared_key_length(0 /* no KDF */); - m_encapsulated_key_length += newenc.encapsulated_key_length(); - } - } - - size_t raw_kem_shared_key_length() const override { return m_raw_kem_shared_key_length; } - - size_t encapsulated_key_length() const override { return m_encapsulated_key_length; } - - void raw_kem_encrypt(std::span out_encapsulated_key, - std::span raw_shared_key, - Botan::RandomNumberGenerator& rng) override { - BOTAN_ASSERT_NOMSG(out_encapsulated_key.size() == encapsulated_key_length()); - BOTAN_ASSERT_NOMSG(raw_shared_key.size() == raw_kem_shared_key_length()); - - BufferStuffer encaps_key_stuffer(out_encapsulated_key); - BufferStuffer shared_key_stuffer(raw_shared_key); - - for(auto& kem_enc : m_kem_encryptors) { - kem_enc.encrypt(encaps_key_stuffer.next(kem_enc.encapsulated_key_length()), - shared_key_stuffer.next(kem_enc.shared_key_length(0 /* no KDF */)), - rng); - } - } - - private: - std::vector m_kem_encryptors; - size_t m_raw_kem_shared_key_length; - size_t m_encapsulated_key_length; -}; - -} // namespace - std::unique_ptr Hybrid_KEM_PublicKey::create_kem_encryption_op( - std::string_view kdf, std::string_view provider) const { - return std::make_unique(*this, kdf, provider); -} - -namespace { - -auto extract_public_keys(const std::vector>& private_keys) { - std::vector> public_keys; - public_keys.reserve(private_keys.size()); - for(const auto& private_key : private_keys) { - BOTAN_ARG_CHECK(private_key != nullptr, "List of private keys contains a nullptr"); - public_keys.push_back(private_key->public_key()); + std::string_view params, std::string_view provider) const { + if(params != "Raw" && !params.empty()) { + throw Botan::Invalid_Argument("Hybrid KEM encryption does not support KDFs"); } - return public_keys; + return std::make_unique(public_keys(), provider); } -} // namespace - std::unique_ptr Hybrid_KEM_PrivateKey::generate_from_group(Group_Params group, RandomNumberGenerator& rng) { const auto algo_spec = algorithm_specs_for_group(group); @@ -324,88 +320,12 @@ std::unique_ptr Hybrid_KEM_PrivateKey::generate_from_grou return std::make_unique(std::move(private_keys)); } -Hybrid_KEM_PrivateKey::Hybrid_KEM_PrivateKey(std::vector> sks) : - Hybrid_KEM_PublicKey(extract_public_keys(sks)) { - BOTAN_ARG_CHECK(sks.size() >= 2, "List of private keys must include at least two keys"); - BOTAN_ARG_CHECK(std::all_of(sks.begin(), - sks.end(), - [](const auto& sk) { - return sk->supports_operation(PublicKeyOperation::KeyEncapsulation) || - sk->supports_operation(PublicKeyOperation::KeyAgreement); - }), - "Some provided private key is not compatible with this hybrid wrapper"); - - std::transform( - sks.begin(), sks.end(), std::back_inserter(m_private_keys), [](auto& key) -> std::unique_ptr { - if(key->supports_operation(PublicKeyOperation::KeyAgreement) && - !key->supports_operation(PublicKeyOperation::KeyEncapsulation)) { - auto ka_key = dynamic_cast(key.get()); - BOTAN_ASSERT_NONNULL(ka_key); - (void)key.release(); - return std::make_unique(std::unique_ptr(ka_key)); - } else { - return std::move(key); - } - }); -} - -secure_vector Hybrid_KEM_PrivateKey::private_key_bits() const { - throw Not_Implemented("Hybrid private keys cannot be serialized"); -} - -std::unique_ptr Hybrid_KEM_PrivateKey::public_key() const { - return std::make_unique(extract_public_keys(m_private_keys)); -} - -bool Hybrid_KEM_PrivateKey::check_key(RandomNumberGenerator& rng, bool strong) const { - return reduce(m_public_keys, true, [&](bool ckr, const auto& key) { return ckr && key->check_key(rng, strong); }); -} - -namespace { - -class Hybrid_KEM_Decryption final : public PK_Ops::KEM_Decryption_with_KDF { - public: - Hybrid_KEM_Decryption(const Hybrid_KEM_PrivateKey& key, - RandomNumberGenerator& rng, - const std::string_view kdf, - const std::string_view provider) : - PK_Ops::KEM_Decryption_with_KDF(kdf), m_encapsulated_key_length(0), m_raw_kem_shared_key_length(0) { - m_decryptors.reserve(key.private_keys().size()); - for(const auto& private_key : key.private_keys()) { - const auto& newdec = m_decryptors.emplace_back(*private_key, rng, "Raw", provider); - m_encapsulated_key_length += newdec.encapsulated_key_length(); - m_raw_kem_shared_key_length += newdec.shared_key_length(0 /* no KDF */); - } - } - - void raw_kem_decrypt(std::span out_shared_key, std::span encap_key) override { - BOTAN_ASSERT_NOMSG(out_shared_key.size() == raw_kem_shared_key_length()); - BOTAN_ASSERT_NOMSG(encap_key.size() == encapsulated_key_length()); - - BufferSlicer encap_key_slicer(encap_key); - BufferStuffer shared_secret_stuffer(out_shared_key); - - for(auto& decryptor : m_decryptors) { - decryptor.decrypt(shared_secret_stuffer.next(decryptor.shared_key_length(0 /* no KDF */)), - encap_key_slicer.take(decryptor.encapsulated_key_length())); - } - } - - size_t encapsulated_key_length() const override { return m_encapsulated_key_length; } - - size_t raw_kem_shared_key_length() const override { return m_raw_kem_shared_key_length; } - - private: - std::vector m_decryptors; - size_t m_encapsulated_key_length; - size_t m_raw_kem_shared_key_length; -}; - -} // namespace - std::unique_ptr Hybrid_KEM_PrivateKey::create_kem_decryption_op( - RandomNumberGenerator& rng, std::string_view kdf, std::string_view provider) const { - return std::make_unique(*this, rng, kdf, provider); + RandomNumberGenerator& rng, std::string_view params, std::string_view provider) const { + if(params != "Raw" && !params.empty()) { + throw Botan::Invalid_Argument("Hybrid KEM decryption does not support KDFs"); + } + return std::make_unique(private_keys(), rng, provider); } } // namespace Botan::TLS diff --git a/src/lib/tls/tls13_pqc/hybrid_public_key.h b/src/lib/tls/tls13_pqc/hybrid_public_key.h index 3d2def00520..7288ea71463 100644 --- a/src/lib/tls/tls13_pqc/hybrid_public_key.h +++ b/src/lib/tls/tls13_pqc/hybrid_public_key.h @@ -13,6 +13,7 @@ #include +#include #include #include @@ -37,7 +38,7 @@ namespace Botan::TLS { * serializes and parses keys and ciphertexts as described in the * above-mentioned IETF draft for a post-quantum TLS 1.3. */ -class BOTAN_TEST_API Hybrid_KEM_PublicKey : public virtual Public_Key { +class BOTAN_TEST_API Hybrid_KEM_PublicKey : public virtual Hybrid_PublicKey { public: static std::unique_ptr load_for_group(Group_Params group, std::span concatenated_public_values); @@ -45,34 +46,18 @@ class BOTAN_TEST_API Hybrid_KEM_PublicKey : public virtual Public_Key { public: explicit Hybrid_KEM_PublicKey(std::vector> pks); - Hybrid_KEM_PublicKey(Hybrid_KEM_PublicKey&&) = default; - Hybrid_KEM_PublicKey(const Hybrid_KEM_PublicKey&) = delete; - Hybrid_KEM_PublicKey& operator=(Hybrid_KEM_PublicKey&&) = default; - Hybrid_KEM_PublicKey& operator=(const Hybrid_KEM_PublicKey&) = delete; - ~Hybrid_KEM_PublicKey() = default; - std::string algo_name() const override; - size_t estimated_strength() const override; - size_t key_length() const override; - bool check_key(RandomNumberGenerator& rng, bool strong) const override; AlgorithmIdentifier algorithm_identifier() const override; std::vector raw_public_key_bits() const override; std::vector public_key_bits() const override; std::unique_ptr generate_another(RandomNumberGenerator& rng) const final; - bool supports_operation(PublicKeyOperation op) const override; - + // no KDF support std::unique_ptr create_kem_encryption_op( - std::string_view kdf, std::string_view provider = "base") const override; - - const auto& public_keys() const { return m_public_keys; } + std::string_view params, std::string_view provider = "base") const override; protected: - std::vector> m_public_keys; - - private: - size_t m_key_length; - size_t m_estimated_strength; + Hybrid_KEM_PublicKey() = default; }; BOTAN_DIAGNOSTIC_PUSH @@ -82,8 +67,8 @@ BOTAN_DIAGNOSTIC_IGNORE_INHERITED_VIA_DOMINANCE * Composes a number of private keys for hybrid key agreement as defined in this * IETF draft: https://datatracker.ietf.org/doc/html/draft-ietf-tls-hybrid-design-04 */ -class BOTAN_TEST_API Hybrid_KEM_PrivateKey final : public Private_Key, - public Hybrid_KEM_PublicKey { +class BOTAN_TEST_API Hybrid_KEM_PrivateKey final : public Hybrid_KEM_PublicKey, + public Hybrid_PrivateKey { public: /** * Generate a hybrid private key for the given TLS code point. @@ -93,23 +78,19 @@ class BOTAN_TEST_API Hybrid_KEM_PrivateKey final : public Private_Key, public: Hybrid_KEM_PrivateKey(std::vector> private_keys); - secure_vector private_key_bits() const override; + std::unique_ptr public_key() const override { + return std::make_unique(extract_public_keys(private_keys())); + } - std::unique_ptr public_key() const override; - - bool check_key(RandomNumberGenerator& rng, bool strong) const override; + bool check_key(RandomNumberGenerator& rng, bool strong) const override { + return Hybrid_PrivateKey::check_key(rng, strong); + } + // no KDF support std::unique_ptr create_kem_decryption_op( - RandomNumberGenerator& rng, std::string_view kdf, std::string_view provider = "base") const override; - - const auto& private_keys() const { return m_private_keys; } - - private: - std::vector> m_private_keys; + RandomNumberGenerator& rng, std::string_view params, std::string_view provider = "base") const override; }; -BOTAN_DIAGNOSTIC_POP - } // namespace Botan::TLS #endif diff --git a/src/lib/tls/tls13_pqc/info.txt b/src/lib/tls/tls13_pqc/info.txt index cd2a4ab76e3..1abc87e75df 100644 --- a/src/lib/tls/tls13_pqc/info.txt +++ b/src/lib/tls/tls13_pqc/info.txt @@ -12,9 +12,10 @@ brief -> "Hybrid Key Exchange for TLS 1.3 with Post-Quantum Algorithms" hybrid_public_key.h -kex_to_kem_adapter.h tls13 +hybrid_kem +kex_to_kem_adapter diff --git a/src/tests/test_tls_hybrid_kem_key.cpp b/src/tests/test_tls_hybrid_kem_key.cpp index 8170900cb56..57d17130d52 100644 --- a/src/tests/test_tls_hybrid_kem_key.cpp +++ b/src/tests/test_tls_hybrid_kem_key.cpp @@ -123,6 +123,19 @@ size_t length_of_hybrid_public_value(Ts... kex_kem_fn) { return (f(*kex_kem_fn()) + ...); } +/// Public_Key::key_length() +template +size_t key_length_of_hybrid_public_key(Ts... kex_kem_fn) { + std::vector key_lengths = {kex_kem_fn()->key_length()...}; + return *std::max_element(key_lengths.begin(), key_lengths.end()); +} + +template +size_t estimated_strength_of_hybrid_public_key(Ts... kex_kem_fn) { + std::vector strengths = {kex_kem_fn()->estimated_strength()...}; + return *std::max_element(strengths.begin(), strengths.end()); +} + template void roundtrip_test(Test::Result& result, Ts... kex_kem_fn) { Botan::TLS::Hybrid_KEM_PrivateKey hybrid_key(keys(kex_kem_fn()...)); @@ -136,6 +149,8 @@ void roundtrip_test(Test::Result& result, Ts... kex_kem_fn) { const auto expected_shared_secret_length = length_of_hybrid_shared_key(kex_kem_fn...); const auto expected_ciphertext_length = length_of_hybrid_ciphertext(kex_kem_fn...); const auto expected_public_key_length = length_of_hybrid_public_value(kex_kem_fn...); + const auto expected_key_length = key_length_of_hybrid_public_key(kex_kem_fn...); + const auto expected_strength = estimated_strength_of_hybrid_public_key(kex_kem_fn...); result.test_eq( "ciphertext has expected length", kem_result.encapsulated_shared_key().size(), expected_ciphertext_length); @@ -155,21 +170,29 @@ void roundtrip_test(Test::Result& result, Ts... kex_kem_fn) { result.test_eq("public key bits is the sum of its parts", hybrid_public_key.raw_public_key_bits().size(), expected_public_key_length); + + result.test_eq( + "Public_Key::key_length is the maximum of its parts", hybrid_public_key.key_length(), expected_key_length); + result.test_eq("Public_Key::estimated_strength is the maximum of its parts", + hybrid_public_key.estimated_strength(), + expected_strength); } std::vector hybrid_kem_keypair() { return { - CHECK("public handles empty list", - [](auto& result) { - result.test_throws("hybrid KEM key does not accept an empty list of keys", - [] { Botan::TLS::Hybrid_KEM_PublicKey({}); }); - }), - - CHECK("private handles empty list", - [](auto& result) { - result.test_throws("hybrid KEM key does not accept an empty list of keys", - [] { Botan::TLS::Hybrid_KEM_PrivateKey({}); }); - }), + Botan_Tests::CHECK("public handles empty list", + [](auto& result) { + result.test_throws("hybrid KEM key does not accept an empty list of keys", [] { + Botan::TLS::Hybrid_KEM_PublicKey(std::vector>(0)); + }); + }), + + Botan_Tests::CHECK("private handles empty list", + [](auto& result) { + result.test_throws("hybrid KEM key does not accept an empty list of keys", [] { + Botan::TLS::Hybrid_KEM_PrivateKey(std::vector>(0)); + }); + }), CHECK("public key handles nullptr", [&](auto& result) { @@ -215,8 +238,8 @@ std::vector hybrid_kem_keypair() { void kex_to_kem_roundtrip(Test::Result& result, const std::function()>& kex_fn) { - Botan::TLS::KEX_to_KEM_Adapter_PrivateKey kexkem_key(kex_fn()); - Botan::TLS::KEX_to_KEM_Adapter_PublicKey kexkem_public_key(kex_fn()); + Botan::KEX_to_KEM_Adapter_PrivateKey kexkem_key(kex_fn()); + Botan::KEX_to_KEM_Adapter_PublicKey kexkem_public_key(kex_fn()); auto& rng = global_test_rng(); @@ -244,19 +267,19 @@ void kex_to_kem_roundtrip(Test::Result& result, std::vector kex_to_kem_adapter() { return { - CHECK("handles nullptr", - [](auto& result) { - result.test_throws("private KEM adapter handles nullptr", - [] { Botan::TLS::KEX_to_KEM_Adapter_PrivateKey(nullptr); }); - result.test_throws("public KEM adapter handles nullptr", - [] { Botan::TLS::KEX_to_KEM_Adapter_PublicKey(nullptr); }); - }), - - CHECK("handles non-KEX keys", - [](auto& result) { - result.test_throws("public KEM adapter does not work with KEM keys", - [] { Botan::TLS::KEX_to_KEM_Adapter_PublicKey{kem()}; }); - }), + Botan_Tests::CHECK("handles nullptr", + [](auto& result) { + result.test_throws("private KEM adapter handles nullptr", + [] { Botan::KEX_to_KEM_Adapter_PrivateKey(nullptr); }); + result.test_throws("public KEM adapter handles nullptr", + [] { Botan::KEX_to_KEM_Adapter_PublicKey(nullptr); }); + }), + + Botan_Tests::CHECK("handles non-KEX keys", + [](auto& result) { + result.test_throws("public KEM adapter does not work with KEM keys", + [] { Botan::KEX_to_KEM_Adapter_PublicKey{kem()}; }); + }), CHECK("Diffie-Hellman roundtrip", [](auto& result) { kex_to_kem_roundtrip(result, kex_dh); }), CHECK("ECDH roundtrip", [](auto& result) { kex_to_kem_roundtrip(result, kex_ecdh); }), From 164e2b37d67273e75c8f7ac5adcb718e2bdce29b Mon Sep 17 00:00:00 2001 From: Fabian Albert Date: Thu, 13 Jun 2024 09:01:53 +0200 Subject: [PATCH 2/2] Ounsworth KEM Combiner --- doc/api_ref/pubkey.rst | 21 + doc/dev_ref/oids.rst | 13 + src/build-data/oids.txt | 13 + src/lib/asn1/oid_maps.cpp | 19 + .../pubkey/ounsworth_kem_combiner/info.txt | 26 ++ .../ounsworth_kem_combiner/ounsworth.cpp | 351 ++++++++++++++++ .../pubkey/ounsworth_kem_combiner/ounsworth.h | 226 ++++++++++ .../ounsworth_internal.cpp | 157 +++++++ .../ounsworth_internal.h | 39 ++ .../ounsworth_kem_combiner/ounsworth_mode.cpp | 287 +++++++++++++ .../ounsworth_kem_combiner/ounsworth_mode.h | 192 +++++++++ src/lib/pubkey/pk_algs.cpp | 22 + src/tests/data/pubkey/ounsworth.vec | 16 + .../data/pubkey/sp800_56c_one_step_kdm.vec | 390 ++++++++++++++++++ src/tests/test_ounsworth.cpp | 270 ++++++++++++ src/tests/test_pubkey.cpp | 3 +- 16 files changed, 2044 insertions(+), 1 deletion(-) create mode 100644 src/lib/pubkey/ounsworth_kem_combiner/info.txt create mode 100644 src/lib/pubkey/ounsworth_kem_combiner/ounsworth.cpp create mode 100644 src/lib/pubkey/ounsworth_kem_combiner/ounsworth.h create mode 100644 src/lib/pubkey/ounsworth_kem_combiner/ounsworth_internal.cpp create mode 100644 src/lib/pubkey/ounsworth_kem_combiner/ounsworth_internal.h create mode 100644 src/lib/pubkey/ounsworth_kem_combiner/ounsworth_mode.cpp create mode 100644 src/lib/pubkey/ounsworth_kem_combiner/ounsworth_mode.h create mode 100644 src/tests/data/pubkey/ounsworth.vec create mode 100644 src/tests/data/pubkey/sp800_56c_one_step_kdm.vec create mode 100644 src/tests/test_ounsworth.cpp diff --git a/doc/api_ref/pubkey.rst b/doc/api_ref/pubkey.rst index 93913c3a403..a259bc544b1 100644 --- a/doc/api_ref/pubkey.rst +++ b/doc/api_ref/pubkey.rst @@ -188,6 +188,27 @@ A set of signature schemes based on elliptic curves. All are national standards in their respective countries (Germany, South Korea, China, and Russia, resp), and are completely obscure and unused outside of that context. +KEM Combiner +------------ + +A KEM Combiner is a key encapsulation mechanism (KEM) that combines multiple +KEMs into a single KEM. The resulting KEM is secure if at least one combined +KEM is secure. Usually, the KEM Combiner combines a classical KEM with a +post-quantum secure KEM. Note that every key exchange algorithm can also be +described as a KEM. + +Ounsworth KEM Combiner +~~~~~~~~~~~~~~~~~~~~~~ + +This combiner is based on +`draft-ounsworth-cfrg-kem-combiners-05 `_ +(Feb 2024). It is a generic combiner that achieves IND-CCA security if at least +one combined KEM is. Every KEM that implements Botan's private and public key +interfaces can be an ingredient of this combiner. However, some KEMs are +predefined for easier usage. The predefined KEMs are Kyber (Round 3) and +FrodoKEM for post-quantum security and X25519, X448, and ECDH (with various +named curves) as classical key exchange algorithms formulated as KEMs. + .. _creating_new_private_keys: Creating New Private Keys diff --git a/doc/dev_ref/oids.rst b/doc/dev_ref/oids.rst index b6c31bda7d4..29cedd94452 100644 --- a/doc/dev_ref/oids.rst +++ b/doc/dev_ref/oids.rst @@ -43,6 +43,19 @@ Values currently assigned are:: kyber-768-90s OBJECT IDENTIFIER ::= { kyber-90s 2 } kyber-1024-90s OBJECT IDENTIFIER ::= { kyber-90s 3 } + ounsworth-kem-combiner OBJECT IDENTIFIER ::= { publicKey 20 } + + ounsworth-kem-combiner-kyber-768-r3-x25519-kmac-256 OBJECT IDENTIFIER ::= { ounsworth-kem-combiner 1 } + ounsworth-kem-combiner-kyber-1024-r3-x448-kmac-256 OBJECT IDENTIFIER ::= { ounsworth-kem-combiner 2 } + + ounsworth-kem-combiner-kyber-512-r3-ecdh-secp256r1-kmac-128 OBJECT IDENTIFIER ::= { ounsworth-kem-combiner 3 } + ounsworth-kem-combiner-kyber-768-r3-ecdh-secp384r1-kmac-256 OBJECT IDENTIFIER ::= { ounsworth-kem-combiner 4 } + ounsworth-kem-combiner-kyber-1024-r3-ecdh-secp512r1-kmac-256 OBJECT IDENTIFIER ::= { ounsworth-kem-combiner 5 } + + ounsworth-kem-combiner-frodokem-640-shake-ecdh-brainpool256r1-kmac-128 OBJECT IDENTIFIER ::= { ounsworth-kem-combiner 6 } + ounsworth-kem-combiner-frodokem-976-shake-ecdh-brainpool384r1-kmac-256 OBJECT IDENTIFIER ::= { ounsworth-kem-combiner 7 } + ounsworth-kem-combiner-frodokem-1344-shake-ecdh-brainpool512r1-kmac-256 OBJECT IDENTIFIER ::= { ounsworth-kem-combiner 8 } + xmss OBJECT IDENTIFIER ::= { publicKey 8 } -- The current dilithium implementation is compatible with the reference diff --git a/src/build-data/oids.txt b/src/build-data/oids.txt index 37513b91410..172f6e113dc 100644 --- a/src/build-data/oids.txt +++ b/src/build-data/oids.txt @@ -39,6 +39,19 @@ 1.3.6.1.4.1.25258.1.11.2 = Kyber-768-90s-r3 1.3.6.1.4.1.25258.1.11.3 = Kyber-1024-90s-r3 +# Ounsworth KEM Combiner Draft (Feb 2024) +# https://github.com/EntrustCorporation/draft-ounsworth-cfrg-kem-combiners/blob/475ff53eb8fb7213f6e5ab26dd23e5dc3203f7fa/draft-ounsworth-cfrg-kem-combiners.txt +1.3.6.1.4.1.25258.1.20.1 = OunsworthKEMCombiner/Kyber-768-r3/X25519/KMAC-256 +1.3.6.1.4.1.25258.1.20.2 = OunsworthKEMCombiner/Kyber-1024-r3/X448/KMAC-256 + +1.3.6.1.4.1.25258.1.20.3 = OunsworthKEMCombiner/Kyber-512-r3/ECDH-secp256r1/KMAC-128 +1.3.6.1.4.1.25258.1.20.4 = OunsworthKEMCombiner/Kyber-768-r3/ECDH-secp384r1/KMAC-256 +1.3.6.1.4.1.25258.1.20.5 = OunsworthKEMCombiner/Kyber-1024-r3/ECDH-secp521r1/KMAC-256 + +1.3.6.1.4.1.25258.1.20.6 = OunsworthKEMCombiner/FrodoKEM-640-SHAKE/ECDH-brainpool256r1/KMAC-128 +1.3.6.1.4.1.25258.1.20.7 = OunsworthKEMCombiner/FrodoKEM-976-SHAKE/ECDH-brainpool384r1/KMAC-256 +1.3.6.1.4.1.25258.1.20.8 = OunsworthKEMCombiner/FrodoKEM-1344-SHAKE/ECDH-brainpool512r1/KMAC-256 + # Dilithium OIDs are currently in Botan's private arc 1.3.6.1.4.1.25258.1.9.1 = Dilithium-4x4-r3 1.3.6.1.4.1.25258.1.9.2 = Dilithium-6x5-r3 diff --git a/src/lib/asn1/oid_maps.cpp b/src/lib/asn1/oid_maps.cpp index 95fa332ce9c..cc479737088 100644 --- a/src/lib/asn1/oid_maps.cpp +++ b/src/lib/asn1/oid_maps.cpp @@ -179,6 +179,14 @@ std::unordered_map OID_Map::load_oid2str_map() { {"1.3.6.1.4.1.25258.1.17.1", "eFrodoKEM-640-AES"}, {"1.3.6.1.4.1.25258.1.17.2", "eFrodoKEM-976-AES"}, {"1.3.6.1.4.1.25258.1.17.3", "eFrodoKEM-1344-AES"}, + {"1.3.6.1.4.1.25258.1.20.1", "OunsworthKEMCombiner/Kyber-768-r3/X25519/KMAC-256"}, + {"1.3.6.1.4.1.25258.1.20.2", "OunsworthKEMCombiner/Kyber-1024-r3/X448/KMAC-256"}, + {"1.3.6.1.4.1.25258.1.20.3", "OunsworthKEMCombiner/Kyber-512-r3/ECDH-secp256r1/KMAC-128"}, + {"1.3.6.1.4.1.25258.1.20.4", "OunsworthKEMCombiner/Kyber-768-r3/ECDH-secp384r1/KMAC-256"}, + {"1.3.6.1.4.1.25258.1.20.5", "OunsworthKEMCombiner/Kyber-1024-r3/ECDH-secp521r1/KMAC-256"}, + {"1.3.6.1.4.1.25258.1.20.6", "OunsworthKEMCombiner/FrodoKEM-640-SHAKE/ECDH-brainpool256r1/KMAC-128"}, + {"1.3.6.1.4.1.25258.1.20.7", "OunsworthKEMCombiner/FrodoKEM-976-SHAKE/ECDH-brainpool384r1/KMAC-256"}, + {"1.3.6.1.4.1.25258.1.20.8", "OunsworthKEMCombiner/FrodoKEM-1344-SHAKE/ECDH-brainpool512r1/KMAC-256"}, {"1.3.6.1.4.1.25258.1.3", "McEliece"}, {"1.3.6.1.4.1.25258.1.5", "XMSS-draft6"}, {"1.3.6.1.4.1.25258.1.6.1", "GOST-34.10-2012-256/SHA-256"}, @@ -432,6 +440,17 @@ std::unordered_map OID_Map::load_str2oid_map() { {"Microsoft UPN", OID({1, 3, 6, 1, 4, 1, 311, 20, 2, 3})}, {"OpenPGP.Curve25519", OID({1, 3, 6, 1, 4, 1, 3029, 1, 5, 1})}, {"OpenPGP.Ed25519", OID({1, 3, 6, 1, 4, 1, 11591, 15, 1})}, + {"OunsworthKEMCombiner/FrodoKEM-1344-SHAKE/ECDH-brainpool512r1/KMAC-256", + OID({1, 3, 6, 1, 4, 1, 25258, 1, 20, 8})}, + {"OunsworthKEMCombiner/FrodoKEM-640-SHAKE/ECDH-brainpool256r1/KMAC-128", + OID({1, 3, 6, 1, 4, 1, 25258, 1, 20, 6})}, + {"OunsworthKEMCombiner/FrodoKEM-976-SHAKE/ECDH-brainpool384r1/KMAC-256", + OID({1, 3, 6, 1, 4, 1, 25258, 1, 20, 7})}, + {"OunsworthKEMCombiner/Kyber-1024-r3/ECDH-secp521r1/KMAC-256", OID({1, 3, 6, 1, 4, 1, 25258, 1, 20, 5})}, + {"OunsworthKEMCombiner/Kyber-1024-r3/X448/KMAC-256", OID({1, 3, 6, 1, 4, 1, 25258, 1, 20, 2})}, + {"OunsworthKEMCombiner/Kyber-512-r3/ECDH-secp256r1/KMAC-128", OID({1, 3, 6, 1, 4, 1, 25258, 1, 20, 3})}, + {"OunsworthKEMCombiner/Kyber-768-r3/ECDH-secp384r1/KMAC-256", OID({1, 3, 6, 1, 4, 1, 25258, 1, 20, 4})}, + {"OunsworthKEMCombiner/Kyber-768-r3/X25519/KMAC-256", OID({1, 3, 6, 1, 4, 1, 25258, 1, 20, 1})}, {"PBE-PKCS5v20", OID({1, 2, 840, 113549, 1, 5, 13})}, {"PBES2", OID({1, 2, 840, 113549, 1, 5, 13})}, {"PKCS5.PBKDF2", OID({1, 2, 840, 113549, 1, 5, 12})}, diff --git a/src/lib/pubkey/ounsworth_kem_combiner/info.txt b/src/lib/pubkey/ounsworth_kem_combiner/info.txt new file mode 100644 index 00000000000..46850b0cbf3 --- /dev/null +++ b/src/lib/pubkey/ounsworth_kem_combiner/info.txt @@ -0,0 +1,26 @@ + +OUNSWORTH -> 20240528 + + + +name -> "Ounsworth" +lifecycle -> "Experimental" + + + +ounsworth_internal.h + + + +ounsworth.h +ounsworth_mode.h + + + +asn1 +hybrid_kem +kex_to_kem_adapter +kmac +sha3 +sp800_56a + diff --git a/src/lib/pubkey/ounsworth_kem_combiner/ounsworth.cpp b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth.cpp new file mode 100644 index 00000000000..d39d8b677e0 --- /dev/null +++ b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth.cpp @@ -0,0 +1,351 @@ +/** +* Implementation of the Ounsworth KEM combiner (draft-ounsworth-cfrg-kem-combiners-05) +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#include + +#include +#include +#include +#include +#include + +#include +#include + +namespace Botan { + +namespace { + +size_t pk_length(const std::vector& import_info) { + return std::accumulate( + import_info.begin(), import_info.end(), size_t(0), [](size_t acc, const Ounsworth::PublicKeyImportInfo& info) { + return acc + info.raw_pk_length(); + }); +} + +size_t sk_length(const std::vector& import_info) { + return std::accumulate( + import_info.begin(), import_info.end(), size_t(0), [](size_t acc, const Ounsworth::PrivateKeyImportInfo& info) { + return acc + info.raw_sk_length(); + }); +} + +/// @returns the summed up size of a two dimensional vector +template +size_t flattened_size(const std::vector>& a) { + return reduce(a, size_t(0), [](size_t acc, const std::span& v) { return acc + v.size(); }); +} + +// 4.1. Bit length encoding (or right_encode of SP800-185 Section 2.3.1). +std::vector rlen(std::span s) { + // 1. Let x = len(s) + const size_t x = s.size() * 8; + // 1. Let n be the smallest positive integer for which 2^{8n} > x + const size_t n = std::max(size_t(1), significant_bytes(x)); + // 2. Let x_1, x_2, ..., x_n be the base-256 encoding of x satisfying: + // x = sum 28(n-i)x i, for i = 1 to n + // 3. Let O_i = uint8(x_i), for i = 1 to n + const auto be_sz_encoding = store_be(x); + BOTAN_ASSERT_NOMSG(be_sz_encoding.size() >= n); + std::vector o_i(be_sz_encoding.end() - n, be_sz_encoding.end()); + // 4. Let O_{n+1} = uint8(n) + o_i.push_back(checked_cast_to_or_throw(n, "Too many input bytes")); + // 5. rlen(s) = O_1 || O_2 || ... || O_n || O_{n+1} + return o_i; +} + +/// @returns the length encoding for each vector element +template +std::vector> rlen_vec(const std::vector>& vec) { + std::vector> result; + std::transform( + vec.begin(), vec.end(), std::back_inserter(result), [](std::span v) { return rlen(v); }); + return result; +} + +/// Instantiates KDF of the specification +void ounsworth_secret_combiner(std::span out_shared_secret, + Ounsworth::Kdf kdf, + const std::vector>& shared_secrets, + const std::vector>& ciphertexts, + std::span fixed_info, + std::span big_k) { + BOTAN_ASSERT_NOMSG(shared_secrets.size() == ciphertexts.size()); + BOTAN_ASSERT_NOMSG(big_k.empty() || kdf.is_mac_based()); + + const auto ss_len_encodings = rlen_vec(shared_secrets); + const auto ct_len_encodings = rlen_vec(ciphertexts); + + const size_t kdf_input_buffer_size = flattened_size(ciphertexts) + flattened_size(ct_len_encodings) + + flattened_size(shared_secrets) + flattened_size(ss_len_encodings); + + secure_vector kdf_input_buffer(kdf_input_buffer_size); + BufferStuffer kdf_stuffer(kdf_input_buffer); + + // ct_1 || rlen(ct_1) || ss_1 || rlen(ss_1) || ct_2 || ... + for(size_t i = 0; i < shared_secrets.size(); ++i) { + kdf_stuffer.append(ciphertexts.at(i)); + kdf_stuffer.append(ct_len_encodings.at(i)); + kdf_stuffer.append(shared_secrets.at(i)); + kdf_stuffer.append(ss_len_encodings.at(i)); + } + BOTAN_ASSERT_NOMSG(kdf_stuffer.full()); + + kdf.create_kdf_instance()->derive_key(out_shared_secret, kdf_input_buffer, big_k, fixed_info); +} + +std::vector get_mac_big_k(Ounsworth::Kdf kdf, std::string_view params) { + BOTAN_ARG_CHECK(params.empty() || kdf.is_mac_based(), + "Parameters for Ounsworth KEM combiner with SHA3 must be empty."); + + if(params.empty()) { + // Use default_salt of SP800-56C2, Section 4.1, Implementation-Dependent Parameters 3. + switch(kdf.type()) { + // If H(x) = KMAC128 [...] the default_salt shall be an all-zero string of 164 bytes. + case Ounsworth::Kdf::Option::KMAC128: + return std::vector(164, 0); + // If H(x) = KMAC256 [...] the default_salt shall be an all-zero string of 132 bytes. + case Ounsworth::Kdf::Option::KMAC256: + return std::vector(132, 0); + // Hash based KDFs do not use a K. + case Ounsworth::Kdf::Option::SHA3_256: + case Ounsworth::Kdf::Option::SHA3_512: + return {}; + } + BOTAN_ASSERT_UNREACHABLE(); + } else { + // By default K is the bytes of the input string. + return {params.begin(), params.end()}; + } +} + +/** + * The Ounsworth combiner supports two domain separation mechanisms: + * + * 1. The required fixed_info parameter. In Botan it is represented as the salt + * parameter. This is NOT the salt of the underlying SP800-56C2 One-Step KDF. + * + * 2. Optional and only for KMAC based constructions: The context-specific + * string K, which is the key of the MAC. This string is passed via the + * params parameter in the create_kem_en/decryption_op. If it is empty, + * the default value is used as defined in SP800-56C2, Section 4.1, + * Implementation-Dependent Parameters 3. (named "default_salt"). + */ +class Ounsworth_Encryptor final : public KEM_Encryption_with_Combiner { + public: + Ounsworth_Encryptor(const Ounsworth_PublicKey& public_key, + std::string_view mac_big_k, + std::string_view provider) : + KEM_Encryption_with_Combiner(public_key.public_keys(), provider), + m_mac_big_k(get_mac_big_k(public_key.kdf(), mac_big_k)), + m_kdf(public_key.kdf()) {} + + void combine_shared_secrets(std::span out_shared_secret, + const std::vector>& shared_secrets, + const std::vector>& ciphertexts, + size_t /*desired_shared_key_len*/, + std::span fixed_info) override { + ounsworth_secret_combiner(out_shared_secret, m_kdf, shared_secrets, ciphertexts, fixed_info, m_mac_big_k); + } + + // The ciphertexts are concatenated without salt. + void combine_ciphertexts(std::span out_ciphertext, + const std::vector>& ciphertexts, + std::span /*salt*/) override { + KEM_Encryption_with_Combiner::combine_ciphertexts(out_ciphertext, ciphertexts, {}); + } + + size_t shared_key_length(size_t desired_shared_key_len) const override { return desired_shared_key_len; } + + private: + std::vector m_mac_big_k; + Ounsworth::Kdf m_kdf; +}; + +class Ounsworth_Decryptor final : public KEM_Decryption_with_Combiner { + public: + Ounsworth_Decryptor(const Ounsworth_PrivateKey& private_key, + RandomNumberGenerator& rng, + const std::string_view mac_big_k, + const std::string_view provider) : + KEM_Decryption_with_Combiner(private_key.private_keys(), rng, provider), + m_mac_big_k(get_mac_big_k(private_key.kdf(), mac_big_k)), + m_mode(private_key.kdf()) {} + + void combine_shared_secrets(std::span out_shared_secret, + const std::vector>& shared_secrets, + const std::vector>& ciphertexts, + size_t /*desired_shared_key_len*/, + std::span salt) override { + ounsworth_secret_combiner(out_shared_secret, m_mode, shared_secrets, ciphertexts, salt, m_mac_big_k); + } + + size_t shared_key_length(size_t desired_shared_key_len) const override { return desired_shared_key_len; } + + private: + std::vector m_mac_big_k; + Ounsworth::Kdf m_mode; +}; + +} // namespace + +Ounsworth_PublicKey::Ounsworth_PublicKey(std::vector> pks, Ounsworth::Kdf kdf) : + Hybrid_PublicKey(std::move(pks)), m_kdf(kdf) {} + +Ounsworth_PublicKey::Ounsworth_PublicKey(std::span pk_bytes, + std::vector import_info, + Ounsworth::Kdf kdf) : + Ounsworth_PublicKey( + [&]() { + BOTAN_ARG_CHECK(pk_bytes.size() == pk_length(import_info), + "Invalid Ounsworth KEM combiner public key size"); + BufferSlicer slicer(pk_bytes); + std::vector> pks; + std::transform(import_info.begin(), + import_info.end(), + std::back_inserter(pks), + [&](const Ounsworth::PublicKeyImportInfo& info) { + return info.load_public_key(slicer.take(info.raw_pk_length())); + }); + BOTAN_ASSERT_NOMSG(slicer.empty()); + return pks; + }(), + kdf) {} + +Ounsworth_PublicKey::Ounsworth_PublicKey(const AlgorithmIdentifier& alg_id, std::span pk_bytes) : + Ounsworth_PublicKey(pk_bytes, pk_import_info_and_kdf_from_alg_id(alg_id)) { + _set_alg_id_opt(alg_id); +} + +std::string Ounsworth_PublicKey::algo_name() const { + return ounsworth_algorithm_name(); +} + +AlgorithmIdentifier Ounsworth_PublicKey::algorithm_identifier() const { + if(auto alg_id = m_maybe_alg_id) { + return *alg_id; + } + throw Not_Implemented("Cannot get AlgorithmIdentifier from this Ounsworth KEM combiner public key."); +} + +std::unique_ptr Ounsworth_PublicKey::generate_another(RandomNumberGenerator& rng) const { + auto other_sks = Hybrid_PublicKey::generate_other_sks_from_pks(rng); + return std::make_unique(std::move(other_sks), kdf()); +} + +std::unique_ptr Ounsworth_PublicKey::create_kem_encryption_op(std::string_view mac_big_k, + std::string_view provider) const { + return std::make_unique(*this, mac_big_k, provider); +} + +// Create an Ounsworth KEM combiner private key from multiple KEM private keys +Ounsworth_PrivateKey::Ounsworth_PrivateKey(std::vector> sks, Ounsworth::Kdf kdf) : + Ounsworth_PrivateKey( + [&] { + std::vector> pks = extract_public_keys(sks); + return std::make_pair(std::move(pks), std::move(sks)); + }(), + kdf) {} + +Ounsworth_PrivateKey::Ounsworth_PrivateKey(RandomNumberGenerator& rng, + std::vector gen_info, + Ounsworth::Kdf kdf) : + Ounsworth_PrivateKey( + [&] { + std::vector> sks; + std::transform( + gen_info.begin(), + gen_info.end(), + std::back_inserter(sks), + [&](const Ounsworth::PrivateKeyGenerationInfo& info) { return info.create_private_key(rng); }); + + return sks; + }(), + kdf) {} + +Ounsworth_PrivateKey::Ounsworth_PrivateKey(RandomNumberGenerator& rng, std::string_view param_str) : + Ounsworth_PrivateKey(rng, [&] { + auto [sub_algos, kdf] = parse_ounsworth_mode_str(param_str); + std::vector gen_infos; + for(const auto& sub_algo : sub_algos) { + gen_infos.push_back(Ounsworth::PrivateKeyGenerationInfo(sub_algo)); + } + return std::make_pair(std::move(gen_infos), kdf); + }()) { + try { + auto oid = OID::from_string(param_str); // May throw Lookup_Error if no OID is found + _set_alg_id_opt(AlgorithmIdentifier(oid, AlgorithmIdentifier::USE_EMPTY_PARAM)); + } catch(Lookup_Error&) { + _set_alg_id_opt(std::nullopt); + } +} + +Ounsworth_PrivateKey::Ounsworth_PrivateKey(std::span key_bytes, + std::vector import_info, + Ounsworth::Kdf kdf) : + Ounsworth_PrivateKey( + [&] { + BOTAN_ARG_CHECK(key_bytes.size() == sk_length(import_info), + "Invalid Ounsworth KEM combiner private key size"); + std::vector> sks; + BufferSlicer slicer(key_bytes); + std::transform(import_info.begin(), + import_info.end(), + std::back_inserter(sks), + [&](const Ounsworth::PrivateKeyImportInfo& info) { + return info.load_private_key(slicer.take(info.raw_sk_length())); + }); + BOTAN_ASSERT_NOMSG(slicer.empty()); + + return sks; + }(), + kdf) {} + +Ounsworth_PrivateKey::Ounsworth_PrivateKey(const AlgorithmIdentifier& alg_id, std::span key_bytes) : + Ounsworth_PrivateKey(key_bytes, sk_import_info_and_kdf_from_alg_id(alg_id)) { + _set_alg_id_opt(alg_id); +} + +std::unique_ptr Ounsworth_PrivateKey::public_key() const { + std::vector> pks_copy; + std::transform(private_keys().begin(), private_keys().end(), std::back_inserter(pks_copy), [](const auto& sk) { + return sk->public_key(); + }); + auto pk = std::make_unique(std::move(pks_copy), kdf()); + pk->_set_alg_id_opt(get_alg_id_opt()); + + return pk; +} + +secure_vector Ounsworth_PrivateKey::raw_private_key_bits() const { + secure_vector sk_bytes; + for(const auto& sk : private_keys()) { + const auto sk_bytes_part = sk->raw_private_key_bits(); + sk_bytes.insert(sk_bytes.end(), sk_bytes_part.begin(), sk_bytes_part.end()); + } + return sk_bytes; +} + +bool Ounsworth_PrivateKey::check_key(RandomNumberGenerator& rng, bool strong) const { + return Hybrid_PrivateKey::check_key(rng, strong); +} + +std::unique_ptr Ounsworth_PrivateKey::create_kem_decryption_op( + RandomNumberGenerator& rng, std::string_view mac_big_k, std::string_view provider) const { + return std::make_unique(*this, rng, mac_big_k, provider); +} + +Ounsworth_PrivateKey::Ounsworth_PrivateKey( + std::pair>, std::vector>> key_pairs, + Ounsworth::Kdf kdf) : + Hybrid_PublicKey(std::move(key_pairs.first)), + Ounsworth_PublicKey(kdf), + Hybrid_PrivateKey(std::move(key_pairs.second)) {} + +} // namespace Botan diff --git a/src/lib/pubkey/ounsworth_kem_combiner/ounsworth.h b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth.h new file mode 100644 index 00000000000..ed2df18c0a5 --- /dev/null +++ b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth.h @@ -0,0 +1,226 @@ +/** +* Implementation of the Ounsworth KEM combiner (draft-ounsworth-cfrg-kem-combiners-05) +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#ifndef BOTAN_OUNSWORTH_H_ +#define BOTAN_OUNSWORTH_H_ + +#include +#include + +namespace Botan { + +/** + * @brief Ounsworth KEM Combiner Public Key + * + * See Ounsworth_PrivateKey for more information. + * + * @warning Experimental: The implementation is based on a very early + * draft version. Therefore, its behavior and API can change + * in future library versions. + */ +class BOTAN_UNSTABLE_API Ounsworth_PublicKey : public virtual Hybrid_PublicKey { + public: + Ounsworth_PublicKey(const AlgorithmIdentifier& alg_id, std::span pk_bytes); + + // Load a raw Ounsworth KEM combiner public key using import information for each sub algorithm + Ounsworth_PublicKey(std::span pk_bytes, + std::vector import_info, + Ounsworth::Kdf kdf); + + // Create an Ounsworth KEM combiner public key from multiple KEM public keys + Ounsworth_PublicKey(std::vector> pks, Ounsworth::Kdf kdf); + + std::string algo_name() const override; + AlgorithmIdentifier algorithm_identifier() const override; + std::unique_ptr generate_another(RandomNumberGenerator& rng) const final; + + /** + * @brief Create a kem decryption operation object + * + * @param mac_big_k the value K used for additional domain separation. Must be empty for SHA3 modes. + * @param provider the provider used for the underlying KEMs + * @return the encryption operation + */ + std::unique_ptr create_kem_encryption_op( + std::string_view mac_big_k = "", std::string_view provider = "base") const override; + + /// @returns the KDF used by the Ounsworth KEM combiner + Ounsworth::Kdf kdf() const { return m_kdf; } + + void _set_alg_id_opt(std::optional alg_id) { m_maybe_alg_id = std::move(alg_id); } + + protected: + // Used for inheritance + Ounsworth_PublicKey(Ounsworth::Kdf kdf) : m_kdf(kdf) {} + + std::optional get_alg_id_opt() const { return m_maybe_alg_id; } + + private: + /// Constructor helper + Ounsworth_PublicKey(std::span pk_bytes, + std::pair, Ounsworth::Kdf> pk_info_and_kdf) : + Ounsworth_PublicKey(pk_bytes, std::move(pk_info_and_kdf.first), pk_info_and_kdf.second) {} + + Ounsworth::Kdf m_kdf; + + /// Contains an alg id if the key was loaded from bytes using an alg id (Constructor(alg_id, pk_bytes)). + /// or created by the private key using a parameter string resembling the alg id. + std::optional m_maybe_alg_id; +}; + +BOTAN_DIAGNOSTIC_PUSH +BOTAN_DIAGNOSTIC_IGNORE_INHERITED_VIA_DOMINANCE + +/** + * @brief Ounsworth KEM Combiner Private Key + * + * Based on the specification draft (7 Feb 2024): + * https://github.com/EntrustCorporation/draft-ounsworth-cfrg-kem-combiners/blob/475ff53eb8fb7213f6e5ab26dd23e5dc3203f7fa/draft-ounsworth-cfrg-kem-combiners.txt. + * This combiner combines two or more key encapsulation mechanisms (KEMs) into + * a single KEM. It can combine a post-quantum secure KEM (e.g., Frodo or + * Kyber) with a classical KEM or KEX (e.g., ECDH). For that, the document + * defines a KDF combining its sub-algorithm's shared secrets and ciphertexts + * into a new shared secret. + * + * Here are some hints for using the KEM Combiner: + * + * - To create Ounsworth public and private keys, one can use a Key Derivation + * Function (KDF) with multiple private and public keys. The Ounsworth + * specification offers four different KDF options, which can be selected using + * the Ounsworth::Kdf::Option enum. + * + * Alternatively, for private key generation, one can use a list of + * Ounsworth::PrivateKeyGenerationInfo objects to specify how each sub private + * key is generated. To load a private key, one can use the + * Ounsworth::PrivateKeyImportInfo object, which specifies how each sub private + * key is loaded from raw bytes. Similarly, for public key generation and + * loading, one can use a list of Ounsworth::PublicKeyGenerationInfo. + * + * All three info classes can be easily instantiated with predefined + * sub-algorithms, which is the easiest way to use the KEM Combiner. However, + * if one need custom sub-algorithms, these classes also accept a callback + * function that allows defining how keys are generated and loaded. + * + * - The salt used by PK_KEM_Encryptor::encrypt and + * PK_KEM_Decryptor::decrypt acts as the fixedInfo. + * + * - Only if using the KMAC KDF mode may a parameter string be passed to the + * PK_KEM_Encryptor's or PK_KEM_Decryptor's constructor. This string's + * bytes act as the context-specific string K (see section 5.1). If an + * empty string or no parameter is passed, the default K value is applied, + * as defined in NIST.SP.800-56Cr2 Section 4.1 as default_salt. + * + * Here are some details about the application of the specification: + * + * - The KDF always contains the right-encoded length of the ciphertexts and + * shared secrets, even if the lengths are fixed. I.e.: + * ss = KDF(ct_1 || rlen(ct_1) || ss_1 || r_len(ss_1) || ct_2 || ..., fixedInfo) + * Encode are the lengths in bits rounded to the next byte. E.g. a X25519 sk + * has a length of 256 bits, even if it only contains 253 significant bits. + * Therefore, rlen(sk_x25519) = (0x01, 0x00, 0x02) + * + * - The Ounsworth public key concatenates its sub-algorithm's raw public + * keys. I.e.: + * pk = pk_1 || pk_2 || ... + * Therefore, the raw public key size must be fixed for each sub-algorithm. + * + * - The Ounsworth secret key concatenates its sub-algorithm's raw private + * keys. I.e.: + * sk = sk_1 || sk_2 || ... + * Therefore, the raw secret key size must be fixed for each sub-algorithm. + * + * @warning Experimental: The implementation is based on a very early + * draft version. Therefore, its behavior and API can change + * in future library versions. + */ +class BOTAN_UNSTABLE_API Ounsworth_PrivateKey final : public Ounsworth_PublicKey, + public Hybrid_PrivateKey { + public: + /** + * Create a new Ounsworth KEM combiner key using the given RNG and the + * provided key generation information (for each sub-algorithm) + */ + Ounsworth_PrivateKey(RandomNumberGenerator& rng, + std::vector gen_info, + Ounsworth::Kdf kdf); + + /** + * @brief Construct a new Ounsworth key using a formatted string for the parameters + * + * The string must be formatted as follows: + * OunsworthKEMCombiner/[sub_algo_1]/[sub_alg_2]/.../[kdf] + * + * Example: "OunsworthKEMCombiner/Kyber-512-r3/FrodoKEM-640-SHAKE/KMAC-128" + * + * [sub_algo_i] is one of: + * Kyber-512-r3, Kyber-768-r3, Kyber-1024-r3, FrodoKEM-640-SHAKE, + * FrodoKEM-976-SHAKE, FrodoKEM-1344-SHAKE, FrodoKEM-640-AES, + * FrodoKEM-976-AES, FrodoKEM-1344-AES, X25519, X448, ECDH-secp192R1, + * ECDH-secp224R1, ECDH-secp256r1, ECDH-secp384r1, ECDH-secp521r1, + * ECDH-brainpool256r1, ECDH-brainpool384r1, ECDH-brainpool512r1 + * + * [kdf] is one of: KMAC-128, KMAC-256, SHA3-256, SHA3-512 + * + * @param rng the rng used for key generation + * @param param_str the formatted string (see above) + */ + Ounsworth_PrivateKey(RandomNumberGenerator& rng, std::string_view param_str); + + // Load a raw Ounsworth KEM combiner private key + Ounsworth_PrivateKey(std::span key_bytes, + std::vector import_info, + Ounsworth::Kdf kdf); + + // Load a raw Ounsworth KEM combiner private key using import information for each sub algorithm + Ounsworth_PrivateKey(const AlgorithmIdentifier& alg_id, std::span key_bytes); + + // Create an Ounsworth KEM combiner private key from multiple KEM private keys + Ounsworth_PrivateKey(std::vector> sks, Ounsworth::Kdf kdf); + + std::unique_ptr public_key() const override; + + secure_vector raw_private_key_bits() const override; + + secure_vector private_key_bits() const override { return raw_private_key_bits(); } + + bool check_key(RandomNumberGenerator& rng, bool strong) const override; + + /** + * @brief Create a kem decryption operation object + * + * @param rng the rng used for the underlying KEM's decryption (e.g. EC masking) + * @param mac_big_k the value K used for additional domain separation. Must be empty for SHA3 modes. + * @param provider the provider used for the underlying KEMs + * @return the decryption operation + */ + std::unique_ptr create_kem_decryption_op( + RandomNumberGenerator& rng, + std::string_view mac_big_k = "", + std::string_view provider = "base") const override; + + private: + /// Constructor helpers. + Ounsworth_PrivateKey( + std::pair>, std::vector>> key_pairs, + Ounsworth::Kdf kdf); + + Ounsworth_PrivateKey( + std::span key_bytes, + std::pair, Ounsworth::Kdf> import_info_and_kdf) : + Ounsworth_PrivateKey(key_bytes, std::move(import_info_and_kdf.first), import_info_and_kdf.second) {} + + Ounsworth_PrivateKey( + RandomNumberGenerator& rng, + std::pair, Ounsworth::Kdf> gen_info_and_kdf) : + Ounsworth_PrivateKey(rng, std::move(gen_info_and_kdf.first), gen_info_and_kdf.second) {} +}; + +} // namespace Botan + +#endif // BOTAN_OUNSWORTH_H_ diff --git a/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_internal.cpp b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_internal.cpp new file mode 100644 index 00000000000..aae6012a5bd --- /dev/null +++ b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_internal.cpp @@ -0,0 +1,157 @@ +/** +* Ounsworth Internal Helpers +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#include + +namespace Botan { +namespace { +Ounsworth::Sub_Algo_Type sub_algo_type_from_string(std::string_view algo) { +#ifdef BOTAN_HAS_KYBER + if(algo == "Kyber-512-r3") { + return Ounsworth::Sub_Algo_Type::Kyber512_R3; + } + if(algo == "Kyber-768-r3") { + return Ounsworth::Sub_Algo_Type::Kyber768_R3; + } + if(algo == "Kyber-1024-r3") { + return Ounsworth::Sub_Algo_Type::Kyber1024_R3; + } +#endif +#ifdef BOTAN_HAS_FRODOKEM_SHAKE + if(algo == "FrodoKEM-640-SHAKE") { + return Ounsworth::Sub_Algo_Type::FrodoKEM640_SHAKE; + } + if(algo == "FrodoKEM-976-SHAKE") { + return Ounsworth::Sub_Algo_Type::FrodoKEM976_SHAKE; + } + if(algo == "FrodoKEM-1344-SHAKE") { + return Ounsworth::Sub_Algo_Type::FrodoKEM1344_SHAKE; + } +#endif +#ifdef BOTAN_HAS_FRODOKEM_AES + if(algo == "FrodoKEM-640-AES") { + return Ounsworth::Sub_Algo_Type::FrodoKEM640_AES; + } + if(algo == "FrodoKEM-976-AES") { + return Ounsworth::Sub_Algo_Type::FrodoKEM976_AES; + } + if(algo == "FrodoKEM-1344-AES") { + return Ounsworth::Sub_Algo_Type::FrodoKEM1344_AES; + } +#endif +#ifdef BOTAN_HAS_X25519 + if(algo == "X25519") { + return Ounsworth::Sub_Algo_Type::X25519; + } +#endif +#ifdef BOTAN_HAS_X448 + if(algo == "X448") { + return Ounsworth::Sub_Algo_Type::X448; + } +#endif +#ifdef BOTAN_HAS_ECDH + if(algo == "ECDH-secp192r1") { + return Ounsworth::Sub_Algo_Type::ECDH_Secp192R1; + } + if(algo == "ECDH-secp224r1") { + return Ounsworth::Sub_Algo_Type::ECDH_Secp224R1; + } + if(algo == "ECDH-secp256r1") { + return Ounsworth::Sub_Algo_Type::ECDH_Secp256R1; + } + if(algo == "ECDH-secp384r1") { + return Ounsworth::Sub_Algo_Type::ECDH_Secp384R1; + } + if(algo == "ECDH-secp521r1") { + return Ounsworth::Sub_Algo_Type::ECDH_Secp521R1; + } + if(algo == "ECDH-brainpool256r1") { + return Ounsworth::Sub_Algo_Type::ECDH_Brainpool256R1; + } + if(algo == "ECDH-brainpool384r1") { + return Ounsworth::Sub_Algo_Type::ECDH_Brainpool384R1; + } + if(algo == "ECDH-brainpool512r1") { + return Ounsworth::Sub_Algo_Type::ECDH_Brainpool512R1; + } +#endif + throw Invalid_Argument(fmt("Unknown Ounsworth sub-algorithm type '{}'", algo)); +} + +Ounsworth::Kdf::Option kdf_type_from_string(std::string_view type) { + if(type == "KMAC-128") { + return Ounsworth::Kdf::Option::KMAC128; + } + if(type == "KMAC-256") { + return Ounsworth::Kdf::Option::KMAC256; + } + if(type == "SHA3-256") { + return Ounsworth::Kdf::Option::SHA3_256; + } + if(type == "SHA3-512") { + return Ounsworth::Kdf::Option::SHA3_512; + } + throw Invalid_Argument(fmt("Unknown Ounsworth KDF type '{}'", type)); +} + +std::pair, Ounsworth::Kdf> sub_algos_and_kdf_from_alg_id( + const AlgorithmIdentifier& alg_id) { + return parse_ounsworth_mode_str(alg_id.oid().to_formatted_string()); +} + +template +std::pair, Ounsworth::Kdf> info_and_kdf_from_alg_id(const AlgorithmIdentifier& alg_id) + requires requires(Ounsworth::Sub_Algo_Type sub_algo) { InfoType{sub_algo}; } +{ + auto [sub_algo_types, kdf] = sub_algos_and_kdf_from_alg_id(alg_id); + std::vector info; + std::transform(sub_algo_types.begin(), sub_algo_types.end(), std::back_inserter(info), [](const auto& sub_algo) { + return InfoType{sub_algo}; + }); + return {std::move(info), kdf}; +} +} // namespace + +std::string ounsworth_algorithm_name() { + return "OunsworthKEMCombiner"; +} + +// Example: "OunsworthKEMCombiner/Kyber-512-r3/FrodoKEM-640-SHAKE/KMAC-128" +std::pair, Ounsworth::Kdf> parse_ounsworth_mode_str(std::string_view mode_str) { + const std::string prefix = ounsworth_algorithm_name(); + const std::vector parts = split_on(mode_str, '/'); + BOTAN_ARG_CHECK(parts.size() >= 4, "Ounsworth mode string must contain at least 4 parts"); + BOTAN_ARG_CHECK(parts[0] == prefix, "Invalid Ounsworth mode string"); + + // Parse sub-algorithms + std::vector sub_algo_types; + std::transform(parts.begin() + 1, parts.end() - 1, std::back_inserter(sub_algo_types), [](const std::string& part) { + return sub_algo_type_from_string(part); + }); + // Parse KDF + const Ounsworth::Kdf kdf(kdf_type_from_string(parts.back())); + + return {sub_algo_types, kdf}; +} + +std::pair, Ounsworth::Kdf> pk_import_info_and_kdf_from_alg_id( + const AlgorithmIdentifier& alg_id) { + return info_and_kdf_from_alg_id(alg_id); +} + +std::pair, Ounsworth::Kdf> sk_import_info_and_kdf_from_alg_id( + const AlgorithmIdentifier& alg_id) { + return info_and_kdf_from_alg_id(alg_id); +} + +std::pair, Ounsworth::Kdf> sk_gen_info_and_kdf_from_alg_id( + const AlgorithmIdentifier& alg_id) { + return info_and_kdf_from_alg_id(alg_id); +} +} // namespace Botan diff --git a/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_internal.h b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_internal.h new file mode 100644 index 00000000000..53b5d2280a9 --- /dev/null +++ b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_internal.h @@ -0,0 +1,39 @@ +/** +* Ounsworth Internal Helpers +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#ifndef BOTAN_OUNSWORTH_INTERNAL_H_ +#define BOTAN_OUNSWORTH_INTERNAL_H_ + +#include +#include +#include + +namespace Botan { + +/// @returns the name of the Ounsworth algorithm +std::string ounsworth_algorithm_name(); + +/// Example: "OunsworthKEMCombiner/Kyber-512-r3/FrodoKEM-640-SHAKE/KMAC-128" +std::pair, Ounsworth::Kdf> parse_ounsworth_mode_str(std::string_view mode_str); + +/// @returns (PkImportInfo, Kdf) pair from the given AlgorithmIdentifier +std::pair, Ounsworth::Kdf> pk_import_info_and_kdf_from_alg_id( + const AlgorithmIdentifier& alg_id); + +/// @returns (SkImportInfo, Kdf) pair from the given AlgorithmIdentifier +std::pair, Ounsworth::Kdf> sk_import_info_and_kdf_from_alg_id( + const AlgorithmIdentifier& alg_id); + +/// @returns (PkGenInfo, Kdf) pair from the given AlgorithmIdentifier +std::pair, Ounsworth::Kdf> sk_gen_info_and_kdf_from_alg_id( + const AlgorithmIdentifier& alg_id); + +} // namespace Botan + +#endif // BOTAN_OUNSWORTH_INTERNAL_H_ diff --git a/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_mode.cpp b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_mode.cpp new file mode 100644 index 00000000000..a709cfc84e3 --- /dev/null +++ b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_mode.cpp @@ -0,0 +1,287 @@ +/** +* Ounsworth KEM Combiner Mode +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#include + +#ifdef BOTAN_HAS_ECDH + #include +#endif +#ifdef BOTAN_HAS_FRODOKEM + #include + + #include + #include +#endif +#ifdef BOTAN_HAS_KYBER + #include + #include +#endif +#ifdef BOTAN_HAS_X25519 + #include +#endif +#ifdef BOTAN_HAS_X448 + #include +#endif + +#include +#include +#include +#include +#include +#include +#include + +namespace Botan::Ounsworth { +namespace { + +std::pair algo_name_and_params_for_sub_algo(Ounsworth::Sub_Algo_Type algo) { + switch(algo) { +#ifdef BOTAN_HAS_KYBER + case Ounsworth::Sub_Algo_Type::Kyber512_R3: + return {"Kyber", "Kyber-512-r3"}; + case Ounsworth::Sub_Algo_Type::Kyber768_R3: + return {"Kyber", "Kyber-768-r3"}; + case Ounsworth::Sub_Algo_Type::Kyber1024_R3: + return {"Kyber", "Kyber-1024-r3"}; +#endif +#ifdef BOTAN_HAS_FRODOKEM_SHAKE + case Ounsworth::Sub_Algo_Type::FrodoKEM640_SHAKE: + return {"FrodoKEM", "FrodoKEM-640-SHAKE"}; + case Ounsworth::Sub_Algo_Type::FrodoKEM976_SHAKE: + return {"FrodoKEM", "FrodoKEM-976-SHAKE"}; + case Ounsworth::Sub_Algo_Type::FrodoKEM1344_SHAKE: + return {"FrodoKEM", "FrodoKEM-1344-SHAKE"}; +#endif +#ifdef BOTAN_HAS_FRODOKEM_AES + case Ounsworth::Sub_Algo_Type::FrodoKEM640_AES: + return {"FrodoKEM", "FrodoKEM-640-AES"}; + case Ounsworth::Sub_Algo_Type::FrodoKEM976_AES: + return {"FrodoKEM", "FrodoKEM-976-AES"}; + case Ounsworth::Sub_Algo_Type::FrodoKEM1344_AES: + return {"FrodoKEM", "FrodoKEM-1344-AES"}; +#endif +#ifdef BOTAN_HAS_X25519 + case Ounsworth::Sub_Algo_Type::X25519: + return {"X25519", ""}; +#endif +#ifdef BOTAN_HAS_X448 + case Ounsworth::Sub_Algo_Type::X448: + return {"X448", ""}; +#endif +#ifdef BOTAN_HAS_ECDH + case Ounsworth::Sub_Algo_Type::ECDH_Secp192R1: + return {"ECDH", "secp192r1"}; + case Ounsworth::Sub_Algo_Type::ECDH_Secp224R1: + return {"ECDH", "secp224r1"}; + case Ounsworth::Sub_Algo_Type::ECDH_Secp256R1: + return {"ECDH", "secp256r1"}; + case Ounsworth::Sub_Algo_Type::ECDH_Secp384R1: + return {"ECDH", "secp384r1"}; + case Ounsworth::Sub_Algo_Type::ECDH_Secp521R1: + return {"ECDH", "secp521r1"}; + case Ounsworth::Sub_Algo_Type::ECDH_Brainpool256R1: + return {"ECDH", "brainpool256r1"}; + case Ounsworth::Sub_Algo_Type::ECDH_Brainpool384R1: + return {"ECDH", "brainpool384r1"}; + case Ounsworth::Sub_Algo_Type::ECDH_Brainpool512R1: + return {"ECDH", "brainpool512r1"}; +#endif + } + BOTAN_ASSERT_UNREACHABLE(); +} + +std::pair sk_pk_size_for_algo(Ounsworth::Sub_Algo_Type algo) { + [[maybe_unused]] const auto [algo_name, algo_params] = algo_name_and_params_for_sub_algo(algo); + +#ifdef BOTAN_HAS_KYBER + if(algo_name == "Kyber") { + const KyberConstants kyber_const((KyberMode(algo_params))); + return std::make_pair(kyber_const.private_key_bytes(), kyber_const.public_key_bytes()); + } +#endif +#ifdef BOTAN_HAS_FRODOKEM + if(algo_name == "FrodoKEM") { + const FrodoKEMConstants frodo_const((FrodoKEMMode(algo_params))); + return std::make_pair(frodo_const.len_private_key_bytes(), frodo_const.len_public_key_bytes()); + } +#endif +#ifdef BOTAN_HAS_X25519 + if(algo_name == "X25519") { + return std::make_pair(32, 32); + } +#endif +#ifdef BOTAN_HAS_X448 + if(algo_name == "X448") { + return std::make_pair(56, 56); + } +#endif +#ifdef BOTAN_HAS_ECDH + if(algo_name == "ECDH") { + const EC_Group ec_group(algo_params); + return std::make_pair(ec_group.get_order_bytes(), ec_group.point_size(EC_Point_Format::Uncompressed)); + } +#endif + + throw Not_Implemented(fmt("Algorithm {} not yet supported for Ounsworth KEM combiner", algo_name)); +} + +bool is_kem(Ounsworth::Sub_Algo_Type algo) { + const auto [alg_name, alg_params] = algo_name_and_params_for_sub_algo(algo); + return alg_name == "Kyber" || alg_name == "FrodoKEM"; +} + +std::function(RandomNumberGenerator&)> get_create_private_key_callback( + Ounsworth::Sub_Algo_Type algo) { + // Using std::tie instead of a direct assignment prevents a clang bug + [[maybe_unused]] std::string algo_name, algo_params; + std::tie(algo_name, algo_params) = algo_name_and_params_for_sub_algo(algo); + + if(is_kem(algo)) { + return [=](RandomNumberGenerator& rng) { return ::Botan::create_private_key(algo_name, rng, algo_params); }; + } + return [=](RandomNumberGenerator& rng) -> std::unique_ptr { + std::unique_ptr sk = ::Botan::create_private_key(algo_name, rng, algo_params); + if(auto kex_sk = std::unique_ptr(dynamic_cast(sk.release()))) { + return std::make_unique(std::move(kex_sk)); + } + throw Invalid_Argument(fmt("Algorithm {} is not listed as KEM and does not support key agreement", algo_name)); + }; +} + +std::function(std::span)> get_load_private_key_raw_callback( + Ounsworth::Sub_Algo_Type algo) { + // Using std::tie instead of a direct assignment prevents a clang bug + [[maybe_unused]] std::string algo_name, algo_params; + std::tie(algo_name, algo_params) = algo_name_and_params_for_sub_algo(algo); +#ifdef BOTAN_HAS_KYBER + if(algo_name == "Kyber") { + return [=](std::span key_data) -> std::unique_ptr { + return std::make_unique(key_data, KyberMode(algo_params)); + }; + } +#endif +#ifdef BOTAN_HAS_FRODOKEM + if(algo_name == "FrodoKEM") { + return [=](std::span key_data) -> std::unique_ptr { + return std::make_unique(key_data, FrodoKEMMode(algo_params)); + }; + } +#endif +#ifdef BOTAN_HAS_X25519 + if(algo_name == "X25519") { + return [=](std::span key_data) -> std::unique_ptr { + const secure_vector sk(key_data.begin(), key_data.end()); + return std::make_unique(std::make_unique(sk)); + }; + } +#endif +#ifdef BOTAN_HAS_X448 + if(algo_name == "X448") { + return [=](std::span key_data) -> std::unique_ptr { + return std::make_unique(std::make_unique(key_data)); + }; + } +#endif +#ifdef BOTAN_HAS_ECDH + if(algo_name == "ECDH") { + return [=](std::span key_data) -> std::unique_ptr { + const secure_vector sk(key_data.begin(), key_data.end()); + // Sadly the ECDH private key constructor only accepts a DER encoded key. Therefore we need to encode it first. + const auto encoded_sk = DER_Encoder() + .start_sequence() + .encode(static_cast(1) /* version ecPrivkeyVer1 */) + .encode(sk, ASN1_Type::OctetString) + .end_cons() + .get_contents(); + + const AlgorithmIdentifier alg_id(OID::from_string("ECDH"), + EC_Group(algo_params).DER_encode(EC_Group_Encoding::Explicit)); + + return std::make_unique(std::make_unique(alg_id, encoded_sk)); + }; + } +#endif + throw Invalid_Argument(fmt("Algorithm {} is not listed as KEM and does not support key agreement", algo_name)); +} + +std::function(std::span)> get_load_public_key_callback( + Ounsworth::Sub_Algo_Type algo) { + // Using std::tie instead of a direct assignment prevents a clang bug + [[maybe_unused]] std::string algo_name, algo_params; + std::tie(algo_name, algo_params) = algo_name_and_params_for_sub_algo(algo); +#ifdef BOTAN_HAS_KYBER + if(algo_name == "Kyber") { + return [=](std::span key_data) -> std::unique_ptr { + return std::make_unique(key_data, KyberMode(algo_params)); + }; + } +#endif +#ifdef BOTAN_HAS_FRODOKEM + if(algo_name == "FrodoKEM") { + return [=](std::span key_data) -> std::unique_ptr { + return std::make_unique(key_data, FrodoKEMMode(algo_params)); + }; + } +#endif +#ifdef BOTAN_HAS_X25519 + if(algo_name == "X25519") { + return [=](std::span key_data) -> std::unique_ptr { + const secure_vector pk(key_data.begin(), key_data.end()); + return std::make_unique(std::make_unique(pk)); + }; + } +#endif +#ifdef BOTAN_HAS_X448 + if(algo_name == "X448") { + return [=](std::span key_data) -> std::unique_ptr { + return std::make_unique(std::make_unique(key_data)); + }; + } +#endif +#ifdef BOTAN_HAS_ECDH + if(algo_name == "ECDH") { + return [=](std::span key_data) -> std::unique_ptr { + const AlgorithmIdentifier alg_id(OID::from_string("ECDH"), + EC_Group(algo_params).DER_encode(EC_Group_Encoding::Explicit)); + + return std::make_unique(std::make_unique(alg_id, key_data)); + }; + } +#endif + throw Invalid_Argument(fmt("Algorithm {} is not listed as KEM and does not support key agreement", algo_name)); +} + +} // namespace + +std::unique_ptr Ounsworth::Kdf::create_kdf_instance() const { + switch(type()) { + case Option::KMAC128: + return KDF::create_or_throw("SP800-56A(KMAC-128)"); + case Option::KMAC256: + return KDF::create_or_throw("SP800-56A(KMAC-256)"); + case Option::SHA3_256: + return KDF::create_or_throw("SP800-56A(SHA-3(256))"); + case Option::SHA3_512: + return KDF::create_or_throw("SP800-56A(SHA-3(512))"); + } + BOTAN_ASSERT_UNREACHABLE(); +} + +PrivateKeyGenerationInfo::PrivateKeyGenerationInfo(Sub_Algo_Type algo) : + m_create_private_key_callback(get_create_private_key_callback(algo)) {} + +PrivateKeyImportInfo::PrivateKeyImportInfo(Sub_Algo_Type algo) : + m_load_private_key_callback(get_load_private_key_raw_callback(algo)), + m_raw_sk_length(sk_pk_size_for_algo(algo).first) {} + +PublicKeyImportInfo::PublicKeyImportInfo(Sub_Algo_Type algo) : + m_load_public_key_callback(get_load_public_key_callback(algo)), + m_raw_pk_length(sk_pk_size_for_algo(algo).second) {} + +} // namespace Botan::Ounsworth diff --git a/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_mode.h b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_mode.h new file mode 100644 index 00000000000..5f297d5a2d2 --- /dev/null +++ b/src/lib/pubkey/ounsworth_kem_combiner/ounsworth_mode.h @@ -0,0 +1,192 @@ +/** +* Ounsworth KEM Combiner Mode +* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ + +#ifndef BOTAN_OUNSWORTH_MODE_H_ +#define BOTAN_OUNSWORTH_MODE_H_ + +#include +#include +#include +#include +#include + +#include + +namespace Botan::Ounsworth { + +/** + * @brief Defines one of the options for the KDF used in the Ounsworth KEM Combiner. + */ +class BOTAN_UNSTABLE_API Kdf { + public: + enum class Option { KMAC128, KMAC256, SHA3_256, SHA3_512 }; + + Kdf(Option type) : m_type(type) {} + + bool is_mac_based() const { return m_type == Option::KMAC128 || m_type == Option::KMAC256; } + + Option type() const { return m_type; } + + std::unique_ptr create_kdf_instance() const; + + private: + Option m_type; +}; + +/** + * @brief Predefined sub-algorithm types + * + * Note that additional custom algorithms can be used by calling the + * SubAlgo constructor with the appropriate callbacks. + */ +enum class BOTAN_UNSTABLE_API Sub_Algo_Type { +#ifdef BOTAN_HAS_KYBER + Kyber512_R3, + Kyber768_R3, + Kyber1024_R3, +#endif +#ifdef BOTAN_HAS_FRODOKEM_SHAKE + FrodoKEM640_SHAKE, + FrodoKEM976_SHAKE, + FrodoKEM1344_SHAKE, +#endif +#ifdef BOTAN_HAS_FRODOKEM_AES + FrodoKEM640_AES, + FrodoKEM976_AES, + FrodoKEM1344_AES, +#endif +#ifdef BOTAN_HAS_X25519 + X25519, +#endif +#ifdef BOTAN_HAS_X448 + X448, +#endif +#ifdef BOTAN_HAS_ECDH + ECDH_Secp192R1, + ECDH_Secp224R1, + ECDH_Secp256R1, + ECDH_Secp384R1, + ECDH_Secp521R1, + ECDH_Brainpool256R1, + ECDH_Brainpool384R1, + ECDH_Brainpool512R1, +#endif +}; + +/** + * @brief Specifies how to generate a new private key from raw key material. + */ +class BOTAN_UNSTABLE_API PrivateKeyGenerationInfo { + public: + /** + * @brief Define the private key generation information for a predefined type. + * + * This constructor creates the generation info automatically from intern Botan information. + * Using this constuctor is the easiest way to define a software key instance that is contained + * in the Sub_Algo_Type list. + * + * @param algo the predefined sub-algorithm type + */ + PrivateKeyGenerationInfo(Sub_Algo_Type algo); + + /** + * @brief Define the generation info for a custom key type. + * + * @param create_private_key_callback A callback for creating a secret key using the output of raw_private_key_bits() + */ + PrivateKeyGenerationInfo( + std::function(RandomNumberGenerator&)> create_private_key_callback) : + m_create_private_key_callback(std::move(create_private_key_callback)) {} + + std::unique_ptr create_private_key(RandomNumberGenerator& rng) const { + return m_create_private_key_callback(rng); + } + + private: + std::function(RandomNumberGenerator&)> m_create_private_key_callback; +}; + +/** + * @brief Specifies how to import a private key from raw key material. + */ +class BOTAN_UNSTABLE_API PrivateKeyImportInfo { + public: + /** + * @brief Define the private key import information for a predefined type. + * + * This constructor creates the import info automatically from intern Botan information. + * Using this constuctor is the easiest way to define a software key instance that is contained + * in the Sub_Algo_Type list. + * + * @param algo the predefined sub-algorithm type + */ + PrivateKeyImportInfo(Sub_Algo_Type algo); + + /** + * @brief Define the import info for a custom key type. + * + * @param load_private_key_callback A callback for loading a secret key using the output of raw_private_key_bits() + * @param raw_sk_length The length of raw_private_key_bits() in bytes + */ + PrivateKeyImportInfo( + std::function(std::span)> load_private_key_callback, + size_t raw_sk_length) : + m_load_private_key_callback(std::move(load_private_key_callback)), m_raw_sk_length(raw_sk_length) {} + + std::unique_ptr load_private_key(std::span key_data) const { + return m_load_private_key_callback(key_data); + } + + size_t raw_sk_length() const { return m_raw_sk_length; } + + private: + std::function(std::span)> m_load_private_key_callback; + size_t m_raw_sk_length; +}; + +/** + * @brief Specifies how to import a public key from raw key material. + */ +class BOTAN_UNSTABLE_API PublicKeyImportInfo { + public: + /** + * @brief Define the private key import information for a predefined type. + * + * This constructor creates the import info automatically from intern Botan information. + * Using this constuctor is the easiest way to define a software key instance that is contained + * in the Sub_Algo_Type list. + * + * @param algo the predefined sub-algorithm type + */ + PublicKeyImportInfo(Sub_Algo_Type algo); + + /** + * @brief Define the import info for a custom key type. + * + * @param load_public_key_callback A callback for loading a public key using the output of raw_public_key_bits() + * @param raw_pk_length The length of raw_public_key_bits() in bytes + */ + PublicKeyImportInfo(std::function(std::span)> load_public_key_callback, + size_t raw_pk_length) : + m_load_public_key_callback(std::move(load_public_key_callback)), m_raw_pk_length(raw_pk_length) {} + + std::unique_ptr load_public_key(std::span key_data) const { + return m_load_public_key_callback(key_data); + } + + size_t raw_pk_length() const { return m_raw_pk_length; } + + private: + std::function(std::span)> m_load_public_key_callback; + size_t m_raw_pk_length; +}; + +} // namespace Botan::Ounsworth + +#endif // BOTAN_OUNSWORTH_MODE_H_ diff --git a/src/lib/pubkey/pk_algs.cpp b/src/lib/pubkey/pk_algs.cpp index 40f43f56bd0..9f95bc5ddbf 100644 --- a/src/lib/pubkey/pk_algs.cpp +++ b/src/lib/pubkey/pk_algs.cpp @@ -82,6 +82,10 @@ #include #endif +#if defined(BOTAN_HAS_OUNSWORTH) + #include +#endif + #if defined(BOTAN_HAS_HSS_LMS) #include #endif @@ -146,6 +150,12 @@ std::unique_ptr load_public_key(const AlgorithmIdentifier& alg_id, } #endif +#if defined(BOTAN_HAS_OUNSWORTH) + if(alg_name == "OunsworthKEMCombiner") { + return std::make_unique(alg_id, key_bits); + } +#endif + #if defined(BOTAN_HAS_ECDSA) if(alg_name == "ECDSA") { return std::make_unique(alg_id, key_bits); @@ -299,6 +309,12 @@ std::unique_ptr load_private_key(const AlgorithmIdentifier& alg_id, } #endif +#if defined(BOTAN_HAS_OUNSWORTH) + if(alg_name.starts_with("OunsworthKEMCombiner")) { + return std::make_unique(alg_id, key_bits); + } +#endif + #if defined(BOTAN_HAS_MCELIECE) if(alg_name == "McEliece") { return std::make_unique(key_bits); @@ -488,6 +504,12 @@ std::unique_ptr create_private_key(std::string_view alg_name, } #endif +#if defined(BOTAN_HAS_OUNSWORTH) + if(alg_name == "OunsworthKEMCombiner") { + return std::make_unique(rng, params); + } +#endif + #if defined(BOTAN_HAS_DILITHIUM) || defined(BOTAN_HAS_DILITHIUM_AES) if(alg_name == "Dilithium" || alg_name == "Dilithium-") { const auto mode = [&]() -> DilithiumMode { diff --git a/src/tests/data/pubkey/ounsworth.vec b/src/tests/data/pubkey/ounsworth.vec new file mode 100644 index 00000000000..40725e18d28 --- /dev/null +++ b/src/tests/data/pubkey/ounsworth.vec @@ -0,0 +1,16 @@ +# Handcrafted test vector, to test the creation of the kdf_input. We expect here (because +# of the other tests) that the KDF works correctly. + +[X25519,X448] +# | X25519 sk Alice | X448 sk Alice +sk = 67C6697351FF4AEC29CDBAABF2FBE3467CC254F81BE8E78D765A2E63339FC99A466431296486ED9CD71FC207254820A2C4A85AEB0B2041494F8BF1F8CD30F11394223CF8A82995804957876E9FA71163506B4E5B8C8FA4DB +# | X25519 pk Alice | X448 pk Alice +pk = 63A8FD14A57B6ECCEA4ECD7AAFD31DE61D796A696E8F16278ABE1C9FEA237E05EFCF67E66CF5F068019CE6BE42C573D71FCE8DD5D3158B9096F031F0D3724FD83F783C6065CACEE411C2C8431675C3D8BA0CB08996D1B893 +# | X25519 sk Bob | X448 sk counterpart +rng_output = 66320DB73158A35A255D051758E95ED4ABB2CDC69BB454110E827441213DDC871B95D3E8C5C5FB5AE737529060E710A93E9718DD3E29418E948FE9201F8DFB3A22CF22E8941D427B54940BB47C1B5EBAB27698F19FD97F33 +# | X25519 pk Bob | X448 pk counterpart +ct = 04EF0E0255A826CDE15A283CD7A1DB51495C9E8D61C7EAC737AE8919A99DB86E587496F3BB21577136E796F4601FA668C7E6EED70C98F90566D2AD0F0754817766AEB7B67A32EC43F6AA8BFC706F8BB649BC7F0ADB90E9C3 +fixed_info = 112233445566778899 +K = TestK +# | ct_1 |len | ss_1 |len | ct_2 |len | ss_2 |len +kdf_input = 04EF0E0255A826CDE15A283CD7A1DB51495C9E8D61C7EAC737AE8919A99DB86E010002AB9434D5841151B8D6B86894F0998B73EF0A9F7A896A77586B01368ED90C4561010002587496F3BB21577136E796F4601FA668C7E6EED70C98F90566D2AD0F0754817766AEB7B67A32EC43F6AA8BFC706F8BB649BC7F0ADB90E9C301C002CFF9F5F31B332D9D7C50EB0FF033891B9179B12382FD0C25F3466C4271AE1B4CE51225FCB352ADC6618FB92C27AAA3A46790040A4277B70901C002 diff --git a/src/tests/data/pubkey/sp800_56c_one_step_kdm.vec b/src/tests/data/pubkey/sp800_56c_one_step_kdm.vec new file mode 100644 index 00000000000..6e85cff7fe7 --- /dev/null +++ b/src/tests/data/pubkey/sp800_56c_one_step_kdm.vec @@ -0,0 +1,390 @@ +# Test for the One-Step KDM defined in NIST SP 800-56C Revision 2, Section 4.1 + +# Test cases from https://github.com/usnistgov/ACVP-Server/blob/8b2204159c1b31a3202ff415cc7a9e1058c35fc5/gen-val/json-files/KDA-OneStep-Sp800-56Cr2/internalProjection.json +# The test cases from the VAL tests are used. From each group the first (passing) test case is taken. + +# Group 56 - Test 276 +[KMAC-128(1024)] +Z = EE238D725D6C7FE595FA09BD8EDE9F314366D85AF19F694E2829EE5FA04515164DB87D32414B38463B07F4AE565E1B9350CFA1D42A57CB6C55CFBD95B3BBEC89A9601CA972EF01E43A02B2BD0BBF1EE5BEA11A8CCEBE766A62F022432F7248EDC4FF6D7544DA356B5C6F92A1C12E5C7812ED08FCA8B18916D56083A75A5D54CDA374EB683731D2C79DC33D58D54CCAE6977DA08440EC62B068A5A617A1D22E9AC868ED8C14F4F5B37148E80B61F1BC7C78247A89F81C369101FF5C2DE5440F86CE9F4992C8420B120799A1767E63B0C5D38B5CB059FD3911FAB5CF1F06FC4C13BF676E11B69008D4D5D487312E3047D01F632A3258CFED3DB00022D017E0E68E +Salt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = CAD0A7C534CF28FDBDB47F473BE9121D6DE01554440736F1A5F12F5BBE140912BC419E12A96BA8AD3FFB2F566D8BA3CFF8B6981CC47709D193D641E1FD1091F6D74AB24836225B4AEB8C48A15EABC23FF45D1640BFC1E66F8AD53404B6933A879C8D022FCB972D0EF658DDABE694A6C7DBF87537982E84D97A7EE0643151A3C8382F3504739D376995AE6F449A61ED6A396556595C73B7D29275CD0301C2BD669C780DD4FEDF2D3251D1AA4F01164F4881E127EEB83F41460334E4A0CF893B40FD705AE9A96E4C60540F999DB9BA0777169D8C3D03BBD7F662B7434B408241EB6F630A088D65E50E1E2AAA8F36A3FD477F25231074ABA40879E84F8F7D6B8BFE9ECF40B601879C39AE01E8A7C350DFB146C0B6CC81E0BAB01A0C902A9F931007B2CFC8D0978D18ECFE126006AFC8E99B00000400 +Output = B8ED5E956C815E058285F356A377DF12C6F7BC1BDA74C9375DE20F1549754C2E3347691D8D5A45EFC024AEE93570C2CD4E5095262DB25D66566A7CA101ABAEA92DF5059FE87BA7DA7AED4C35B7A942E6378315921698041A0D23BD71D10AB04ED8EB760BD73B410C5019A48C6AE23808E4B4BD0D6E03574A9715CFC8C35EC7B2 + +# Group 57 - Test 281 +[KMAC-128(1024)] +Z = 8DED0C516EBF58E3BCF345D0B23BD81F7E42FF0C6228887143F8ECE3 +Salt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = DE5A05A71AA364646E0F9484114A99798404E770F1313CC58672E5881F331B581494EDB4653AF523CCF10A9A9A65F1892D8AFA9E126249F0298C4E91EBEA0DD0D2676461BDC01D3A54FC4B02A23639A8316CF236FE520F4DB4037526149B2EB812DDD656CC4A3B5900000400 +Output = 024637B3D8AF0793BC96C4D459F69DABC912EA9C089B3C202DAF9CA1F4A71075C3B26E7684590A38E97884D32840ACDDD3005684ABCEC6848969FFABEA6201005F17851BB7D9C7B0BCA4FB6BA5DEC93D71FEB30A43EA50A50C3A0E6E856E7F9775CEAEA7BBA533AB98E086A4163B4D3A69416BA957767711790D412931C291C8 + +# Group 58 - Test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alt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo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utput = 06407E76D37BA0168E27621BE9923F86A3E85564540B06BC04D63B3DA9D1DDC04719C372A1902BE005E77AFB670748F1C8814B3A7D4871CD0F230CE562F05D7830E8FAC4C797A8DA7DC2F198E77B2E052FD2A79CAD71B790722D7B303B897FF1EBB2C0BEE36CB35B56E7220C083D1290CD8FBE4FD1FD3AB1B511DB0892A898B4 + +# Group 59 - Test 291 +[KMAC-128(1024)] +Z = A21F3A38D7A80ED03020CF6C5C7C7B5A05A01A9ABDF7644105C797F61A1759D49B9561E94590ADA07923388C0EDF4211E1 +Salt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 3D90EB7CA2CE04097FC8854988F468AC85DF664128CDD97B79EB227892A70738C60B8C8A02D89059A2D8FFBDB24FADCA232E6AEEF70292E10390388D0E729284544406CDEFEFE84AE739052E39E56DEA8ADFF841039B58E1DCB2FDFF124DE1ECE403684F52014942935C55520EEA67BE49F897179E3DA6DBD59CAFCB10E18802133B8755798D60FCB5D0B9859791B72024CC00000400 +Output = 5BD976E64565B3E01594A1FB9C84D19E0567D4450AE53DEC5C2D20FC56888A84469B8B9FA7ACB057825E1199B726393F766FF74F6CBD93BCF810B5C6C74581E9F79416914D2BD568AD573AFA53FA97A7A701517921E88A979846ECCB357A98BA1F17A40D7E0F12B95EBF1B0D8908A330CE20FBB82B41E9282E9E07D69B58ECD9 + +# Group 60 - Test 296 +[KMAC-128(1024)] +Z = 6E95F88F6726840F58C1670D58F66CC56EA0AD1F9C2D4D606FD097FF8E020904C1144D99574B3F0A12247448234C0CFC4107E89E2A2001BC2F50DAA730 +Salt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 9734CD098B5965F3AECD563FD8409DEA5CF28846FAC2DC3C654279E695265FED839FC603465694D532D987435AFBD3F4C8FB3C4D8AAB31176866B1C7C9928712C6A4301C90294B870B87C0AEBEB768E068717A7EA9479CB4BB572D92DD4BBDFD147CA64E012FA0A7E8F79780F700000400 +Output = 0EA4FDC86D133D80009064FC8485FF2FBFEC4C107DE012EF930EBE52845FBD216D3C18A499657B3151206CA5B25D8F2A2CFDC68762DFB8B9A798CFD7BE10E331B3820CFEB093E8255A1BA49A95FBF251F502B86144D4C32F89800A626EE376A21788513045D1564E4314BC1E21A921A2D7CD085EC682A0D2069FF80A7B169B1B + +# Group 61 - Test 302 +[KMAC-128(1024)] +Z = BC8249C78E38A969C8B7B199B6E58F0F898A4FE5792C5EAA0A10AA94B86E75E397793DADAE37E222CB7244844B7A402C4428EACBAE9E93F930F7FF705B75DB0C3CFD13F612D438 +Salt = 7356FE840C258EA20981060A937BB1E0AB704F82E6AB3821507E6A12EE83C2324EBC657C8F490349B3DEAAA97DC55A764EEB97B94523F4D9D28DCE0F6E4180B42A83CFEDF200CC422994A6DB850BAF1E8ED8546F38ECB51EAA577C5C8C2CDE59B930B42CE4E84FA35BCFA6FB429F314FEA5A3C4C9B3AE4DFAFB4D641A32712CF8FE87AB75B9979CA25EFA91CCC65D2809920849EFC6D4134E70FC55DB2759204EC726014 +FixedInfo = 20CB706EF938BADC6FCCEF741188B735D3E5F91825A16F2F82B0707B55CB071977B72A4C0B26DFF62B21D33BF43E00A1224E079AA84A3F2CAC11C521D5989909566464A9183665C46FAF9110298763DF9E0D3584DE5F6FDB61438271EA4FA6BD31FDC2571E9FAEBCD50747D0FCDA511A7D389DEBD4080B794F28123437EF88275EB9CD01260E8EB489436A7548FA794B7B3B5A30739EED9B510EB338F36A0AEFE350D761A2248368856232919CD2880260069E41DE6C77351B7026A9771400000400 +Output = D38FB5C340557509190C4B6EDAE21243F15F7BFE9EFD55433363E1444D0721BF71C94C9189142306672EA3C334E9EE0685205547DBDD030E33EB67B91030EFE47737A318A88ABA37BD02B004FB8FF852DB58E33822F1280E1F0DC7812158CB436E8B00BDBCCDC083C9017FF229132452B0E21C455E54FD15FB960B030F05F13D + +# Group 62 - Test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alt = 7F719A07C9A9D6524E4A180D4013D9A416515EDE109D9273EF4FC82E9808F5D86282B6168EAB87589FED31D22243FB2B6DE3BE0946EE83368829B251017640801C3A503B3F4687D55BA5CC93D31B9CA2A0CAA5D9881212B3BEF65D1580E2FE6C8105EDBEE69CF612BC461B59A2412CE53F333400E3C2850AF937D83659441C76FF6FD40000DBD5D5CB889C0E1C0BEA962CB65A9C59FEDC5606ED9ABC71C19B595437648D +FixedInfo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utput = 187B3030C33DD67868D3935A1834B66DDA9B6A58165F0C33C8297A69CFDB8AEAA3A00B5BD165DF898F8C57A3FCA94AC52F56AA5B8799D64539B2EB4509CC2BBE27E7CBE174AA18E06352C559D6DF16BC4AA533492C59E7E7391CB33FED6770974E9C6232BE16DB99DC3D642541BE16B853B308C30322282348AC5C5AEF6595B2 + +# Group 63 - Test 311 +[KMAC-128(1024)] +Z = 0E0187FD20BF38B59708DC371C55B30635B4D82F05507441552849CF01AF912CCD1620832FA883D29AA845C899C6D2C9AF3B736B1321BC2F85B6A6A392D25EDCD075FEEF1E6341A81FEB51C27FF9F8FBCCDBA25F8C62A2CB053E +Salt = E77151A2BEEB6BC5C191C19EA4519AFFCDB5ECC26E6C27F84650BEC9A29207BF8DC2B4DCA8EDA13D84EE6620F3122B60292EF4A98B92019C4DFA905F28EFB328B1B4B1D0B1C32DC25F7755700975F2D7AFE7B955BAB8743E9266A0D6AF00B4D95E6F95E5E9DB47E283AF62FFD19403EED13F60DDC91297479A9BABF9A6B171C17726050C64C4160FC4826752000FDA3E60468820C22C00647CF9AA00EB0C64EB01620FAC +FixedInfo = D3633559602209C9761441449C96050AF96AA2F5535771AA80E039C4DAE654A6855BBE40D0EDD3E9ADD0DD89DEC3885A1DB2FD415BCEB6C2C73775D3CACE86F6FC5B03F5088E43B4E19C19A2F74AEEAD5197BEAC43315F8951C6CE13A2B485C672D4D3CC70D9F1DB5F4172BA580789964B17884F95F9CBD02873B6A0404AEB3482B6377DCDF0264C340300000400 +Output = 0470B2A0146B20B828816D0FAB2DFC8A7450FE02225D7DB513B6510B0D00DB4A37EC3D2A1D0841781AAF8B31B78787961991964E9A8A70A0B317A27F0821F5492CFF5767A31880BDC2061BDEF800B080846F9661ECD71B687603E7ED917A7A4E9F1685A02C8CAD5F076D2904EA9488B318920D62579CCB812DFB0A4BE0F15FAB + +# Group 64 - Test 317 +[KMAC-128(1024)] +Z = 2A99049A57E807BFA710A23BE5A8EE44925392E73322BFF71740667A +Salt = 18B20983B8129EAEF7F170DD21E48EA7202E2CC200A216D6C55683C848FC8CC7C529A436B7C26A116BEFE7A92A583DB6EB08F3A3082BA3BCE8C0462324099EDE9A9A355E9A7AAF14D234EEA45FFE970B79A7D2E6DB2662FA873EB066D63C46599447A7C164B65DBDEECECA6A262BFB98271C606A623226415C9A15F8379DE29C9F15CF5A97BF28D91134180168BE949C37E804B9D9E56E63A13E818D906EF207CF3228BB +FixedInfo = C732802CD5394FD196C780DD27A5672A4A3AB06CE72817EB5B868A63CD429D7026F27CE97E72580BF9E17D2DF5BFB25E00000400 +Output = A4A5076F8F957577D61E60548EF96C14B6CC6DBEF1DA0A78C5B4B55A55D0A55738B4187815C562C5664D45C049838F06F86084E40B067F593D9DB73E490D2D2DF80655AA340600726DCC3D0F5CF02905D65A10F338C700B90D4CC71F1F39C1825DD156259E34F1050BDB268D8BD068003E502458198B1E24F1BD7F4FF6BDD59F + +# Group 65 - Test 321 +[KMAC-128(1024)] +Z = 7008DEA773FE9C10F2FC4B2A1D9EE895FE69917C8136F8629F1E629A6232002B3435DBF04BB6D7186F140F78517FB5C02799BDC5C4B3384CF92A5E4B160C24 +Salt = 01759CAAD35E0F2FBB2F5630B982F28CFD6979A6873475C8DF093A007A71066E9FCD916BDD7C1E39CE21F13B8C924186FAA4CF5185ACF293E07A27F298DE50AD6AE2C2FA08EC30CDBBFE527AC8564206FBD2DECA1F705162C89A570E4AD938209BBA91CE993C58D96FEEC2D70EBB2D388871CBD0FFEC67FBB15B3661C5A0BC7DD56135F68ECB77C7A2DEB7866C03BEFFFB1DAE06570D82D1B01F991003FBB726752EDACD +FixedInfo = BA2956377723DE81BD171B4B6C3A5C7D86F292D87FEEE0975D8D368AC4987E028782BF90FBAE5744C88DF313138F6AE8ECF98FE44AC0B874EA34FF29EF0677A97D1A7C5D4A86415A5E74A5F8FE7EC5F083F7AA64FD523F04DF0A173C08B5B8CA7929E43F8A9491F05A08A3EC53D4259C4CEA854EE282513B8F6905AA09D53A589F895E65029E6A1E9A905DF6B3E3DD1AE44D697F829E10DF480C3B10243936B4593851D1AA3EEAB56A07EDF2629A00000400 +Output = 21162586192320810AD43D520FF361FE43494A321EB9CF27D5065B1F17BFEDBBC33A0683108AAA6457044BA7708E493F1065E87DF02CA82A7D709F2A3FE1FC6BC047B0A4F047BC043EC1FF337BE4CC3D136BE46114914A7C03A215F109809F629BFA8B5CA235A2686DEE37523B472476AC7CCB3BEA503AE504D26B785B6DACC7 + +# Group 66 - Test 326 +[SHA-224] +Z = 8EEA34F09903CB883C38EFDFC60C8C35A70AF4D780EF02889993DA7C +Salt = +FixedInfo = 835B3DB927E31A6F67254B3BFBE356C346236367C135AECABBD7CB186A376F23B931FB51B5698FA0BC685C601853A8F9D7B0FB1F05C9481D0DE2327DD0F9646E26068107017358BCA824D47600000400 +Output = 765A10D4EA33C22391CE5312120ACF0D4F97E4870ED8077B725ED11EBB6CED82B45040A3813FC7687626EBF46A12F25C784EB0D9E77F34E2C2733546BD5142096A11DC929DE60B846C73CCC76376DBD56CE754AFBBA5E9CD6D22DF5E9B8503E5B149BCA9EAEE9D8CC10B38EA2AD8F3D902A948B24163739B777D49711405CD12 + +# Group 67 - Test 331 +[SHA-224] +Z = 44C97E0F65AE26389678E5B62DBB0869BAC3EE41D33662035CF66F5FC23E81F4CAC8D3516D530E1A6F511BF0DB1631C98BB21F70A6A3C8171BEC6373C8958AB268C0CC5F84941CD93394E49B4E7DEFC06938F54CF1E9B5962858E5892C41AF54EC6A6ECBD69B0181FF10595B39F070007690B477EA761DD68CA2FB85151BE98DF01E8CBE7E66501EAFDFC30EC0423823DEFAA516CF9F727929EC3126B9B160C31F1A9D72144EFB1BA683165CF046C3BEC8B53676DF09A78E91A10D7A81F7A1C63CB455830001D91571841F762D031B3666B31D5B779D78759D9E74ED636CA0C6FA44600B7D2971E611AE13577E452C058F70E622BD9C0B9DC0D3AD71E8EAC384DC9EBC5A09AAA74DD5DBF8833A38484A0F5CD827F17C65B69E6AB5247747C209314D8FC6903C626797D79F2353AA0776F824B9AAF3F5D26B654C966C113F2574FE4B2D41AE406FC907CB1CC3E8CA0335D6C7649CBCC1555F8F3E07FF056A32B49B87ED56DFDD3D5CC0756B485461A96C4C9BD644F3C0FCECA20D1EEC9C303E73147124913750D0AC0B575CB8ADF76CAE2AA33044DD4725 +Salt = +FixedInfo = C01925A6B08949B31D2E1940C10FD3102C2D7DE58DD8B93B592BEFE0EEB1D8FF98844D91C13989A7090F149B1848049900000400 +Output = F8C172DBB82363FF3A0AFAD6A8D07AB73E1E7162ED02DFC875A3BFAB39CF07230D45D27DEC2F38753E6BD1E979010BBBD760DF7A2A821F5705C1005B73742135622B5262B57DB1659E563CD66FDFC4B4F383A4747568689DBE90BBF9AE822EA29F97C24CB80ABC56364E2220DBA836EED2599FA04D3B76CF8FF5AB297ADFB4F6 + +# Group 68 - Test 336 +[SHA-224] +Z = F63BB57F7B2F7BB5406D06093C8CCE09475BD03B61299DAEE5498015CC1CB91737F5F22F5123C8F11F777DED856F09EE +Salt = +FixedInfo = 8DB77B14181934E86A06A344209B2CBD20E415534FD789BF6E78EB5E5A00E23E62F965CE519916DC4B102EB8666147DC00000400 +Output = 58D5546BB875A4E669E1C244CD955A08101EA46B3E67E65E50A451D1060CC7C170A973CE0D744C25C887EBEA49100115C5D638D6B35AF12FB61AD27452DDEF69CA747B71F7F592D1FA4086DC61C3D2775F8FB0552C0EF9ABE05228E77DC02D0593F120985E53055E25AE48BD9D030B32619DECF846C8EB5BC2D2C4944867191E + +# Group 69 - Test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alt = +FixedInfo = D964FEEF632D1EF0A7FB013219F7E4F55A7EF44EA39AC418B43AB8A0841735584B87AB5B0CDAD96D493167D3FBE538EE00000400 +Output = 6782123B8380D3EC4A46E122639D946047DB233D14186EC7E841781B568F1CDFBEE2039DE0AA105CC82B684AC8DB1222EFA560C7884276668B179BE45F012A95B5BDFADED48918FFE1840D80B638E1B6F38B2EE0974E09468FF44A687A52F3A95BD6D458BC6FD6F615F25CFC5CDFA0F8BBA12EC4734D197AB5442E703109A57B + +# Group 70 - Test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alt = +FixedInfo = 116CB960F1CFC5794048D9D853FCBBD1FF59DD63BC682D21B39253D186E4DF57EAB6768C4E9F18B3ED470BC9A3BA3CA50BB2191F5D4B5623A954E98B2324E9139ADD9A3F8246AE0DC01ED269A462F90267300B21087C8184F5F9D3FDADD8D1C0B1B02B9DBCA3D516D4219CDED04B1D7C519663F5E49AC4C67A56E3585D822F5CFDA3B5C1DF4B99CB25F0BCCC42FBDBD852317FDC34CF6367720AE8556FFB0790EEDFDAAB246FAED17398C4480136D063AB525464131D3CD84FD9318D1D0C64EA38BE02135F862BA79592FA71A7B241A3980561D3E63F4FF0F339324F1643646E096BFA43D969690D263AA4620D2F12812948D1817B6D563301DB7DC89351E13AF508A1B9346AEB6986DD413C7350CB7002C6A0F87D5977AA252FADC4D2F0EA677717B3D9A01447CA404FDAF3187B62AFA050B87EB85851A8E241CE7B352BB861D059B7D5FF6CC0BA455951CF0159ECF3ABE2F08B51BBC12EEDB34561CF8C24911EDB4C056E0D9191DB093A7A873F5B28A39D0859BDD73D1D5F26E391FD9CC47FD3D80E5D828F90B43BAE638ED92055D14443FE930CF76A2D38CF95FFC1CD3F3F97139ADD10A06BA1301551280575ECF426A55F3CDC5C936EB51FFDED31C1C98DD66904C6147C76A47FDAEFA066204D36BDC6C18B5B15A89CD9AE598745EB7C20B5B74852ACA9BAE730BA5284F86D1D0FA642D9ADE17E441EBBB070CE63A75FD25FE70D832FF3789674A20A9F34644C497DBC2EA4BDDB08C23A774625402E8A3B5A86E944B79ACBD5E69789EA417F9602D5B0FDEEE2B958492CC41EFBC95F2DFD8C4C1ECA6721FA7BAA115D1624348758730F846E2C178778515066B11676E744ADAD1EC9D70A125A1F29056932AA9993763472B0A4DBABAB15F6D5797C19A5B07B90C0BEC7FE8DE5C0294AD7C39C6F26C9E3CBBB2762D56D6CE6C765EFD2836901C806A1D0637642F0991279491792DC5BC44B0083A679813190223E407D7FD3A393EF5579CAEB15E34F62A0E406FE8E2408E26FA527FDF01E806CBB795991523AF78048A6B7E53E34F027809698019D4C9B97D2CFB9CA23DC950D5E081F060ACFF839E6A44B29BCDAB2296F4AD9852BDE75DB7F64614B73DD2594D073BFF05D6071591CC3E013281AFB341A2DA7487065811EF97C667C2915FCC6B77344B80FCD56169349EBACFD6E57E5E08B6070A4DC07142CCFBDB37705A20870DE817F00DCBF7B9D4B25777AADEDB630DD81CC1D6DA439F34494CE49F462B8C0665AEB2588C362577EDD4915FB58C19D06A8D9BD636ECAC9A608C33E16FA7B943B72D36E8BBDD9B73F2F8C376EDFFB07D3E44370F7F43339C876E2617AA1860B15B7F5F76094814A18D0B197A7923F89693EE09D05914C306A33020C08F188F1C733CAAE686546B381490143249D6CCB83EA5303924E3FE0665D5DA64803931A14D635145EC373BD4172EB4472B28EC7DA4B109C0C9CC7FC482971DC2387266D8E74F5B364471694865F9F5A4A870AD73A802E6E71228E09899A5B7457FA1DE1CC36CC7C89C84708B981BE9BA55196A49EC8D74068F3A35BF07F7BAC4FD01645FA45ABE12BA8A011C09762147D7F880546AB456D4017267817F8242AD9079F1B963C1A2E56DC4FE33617588F6BBB5315A955B3EFECAC81157301BE7B8BD6281826CDCFD094325AFA9B311AC12D9A79D573B0010220C6E9660CAE60B0D7EA1450D9852AE590C6C5AA57D4B6D5138EC3D3B29565A026029D51B3609759DCB2CE51072D50F06E2C6BD9502704BD179CC7A4083C62A53C1B7D29759811FCA015D25C91CE72DB32CC10153AA2BCA42B13E9C45D376FAF0E5F207A0882BD7F41A67B0CCC30D1016124DB77EC70055C9586AC331752A21B219F8C62CFD4FF0E44FC8640FE522BD7460017FF53914E9AC2EF4E0890017CC7E67A5EF808170279242E083A0BC84CE48F3D34931A88958097947AD14E233D4C3791084A36BB147A943287E911E62F3DC19C2CCE4EB358EEC494B31D9296ABAC171A213A050D81BB0B824773765A154BB10C68FACF556759CC0D57B8771FFDDBA5FE432632E14A2997FC23B50C25FB1C4D2A3D8F7251AA5B40531B4F3618B82E37549872776276EE9CDA4B7AB0A8ACE85C8ED02F4E34303E71BA88A8CFE603E277D35DB90E58AB1D5A8BC4A28F1C15C9FCEB363AFB2F02950DA7CB2280D07A607CDB97C671A8D492C9CC5E50C93DE53CDC087949467FBE0E9ACF62E2EB74EAB9DB8EDF7559F2D275357CBAB93D9C647089B6966A8A55EE5C50F0B9441E090F83869CEC2EAE6FF37373039F35DB0EFE531380ECFBF77055C8BC8EE44C664579D4B296C83CF078F176B28EDBDF1DABEA343D208997DEC2194FD9DCA79FE5A5024EE3BCE0C6433C739D18CBBD10BF2FA4632DC9F268935C91935C0C78641509416F9F9A0FC20F18FE30881DF47055755B5240BDA92715A1E8F27FEFDE416CFCBA0C3B13861A81E520D7F0080A7C4E10823B4DE560D0167C8326B590A730EFEF3893994380D8B1A837A18DC0A498C79E82271FCE31A58F544FBCEB38C3B987AE9794A1D21BD137A2097F8BF02566396E5E79492FDE8784DA65B514B87ABB28C391B226DD072617CC56FE55B580F409647465F3EB7C1961BE72A8F8329E8EA05F340BE52ECBAED35165C5483F45F6835DE8B2461B1A5DCE77E1F28BDB787C929E3D9AAC0352F117BB800D494A9042B0FD8370AF302CDEFAE10E3720E369545FAE10D881F5F307CE97E373F9143EDDAE01D5F430D72BA376BF90A00A2089FA2E7A2287283F4386F2B348DBD3A39E8B811958A9DE98CF81353917C57BE6BA1673B616979FC0F607ABB38CFF5960DC8E850C86C537FCB14512C2471E46EE397FB3A23BAF32239707DE8FA68FDDE2447D575EB4B5656EB8AE6648BB37C7D49651436AE19DDD34ED39C2EB33EFAB188DCDF90FF3DD407DE9954019E41F5C5AF3127F51A86BB03E8C4A3BF4334E03F8C84A681891BBE615A3ECD592DB6A7F292DF53A37E87463F6E68BCBD9F3E369BF271C8463488A502E4967C60B6196C957242FD79C0D2B144DADB1A2E1E9307D69F73728A5C2A35804924862FDC111A7886DB40A714C61F64FC14606A18FE276AC65881C091E370C2FA024FE047AD694B45231C460DDE2F1144146DDCED2F829914DDDD356C5FABA3214E7543E7637969E15D999B873C38A38DEE204D8692116F462743C1175AA8EECEA3823681BD0F7451F47F0E9ED8B0589EF490054E7A46A384F6F0E6D7DB6E606C38744794D7A82DE37EB7DD459666471E2BAC75BB051732EB270E29DAE2E319C1B4A5051FDE843B7A4B0A65BD21DA9310DBD9CAF53025013D841629031268FDD4750F10398712E7F691B5D01654C6F140113C43E0C78EC0D4DE8C32B68ACD202B10BA74231AA45D2FCA927400F9EFB9B6DCA3D032941E9EE9223ADDD442B28915B6D9F61E7DDDF3E17EE80F6677F31FBC60757903D2D70516D8E2011E85CC07D9F8FC04199C2A2C45B7B319992577DB334963A05A8C7201BAE38238AA23BB94888134DE4326692000CFF585E481F899019C24CA2A44890EC73F2A72BC2AFC4B4D979B91CE896758139DE4D39B4940E5664E53966EF92C24130357AA8E7CBDF5A380DF25675ED7652283C35678AC021EE9A8FF6A109FDC1CCD02F0A5EE99DBE6E45D8FAD582A9E55A874363B15F93703A946345A53A253232E375FF5B48FE968BEE94FAFAFBB552E03430C63C2FA441D08A525D7F29AC0340D3F58BD5891A8B4D809356A064FA8DF1E36F523D6505286E4A8975D44B171F45355EF588A63650866E2B4258138C5AFF27A89748F1389EC87E310BDAA0FA79C3EB692CBEF9B4997AB8437504CEA7A0566315CEC5DA0AAE611DEF3D40B108CAE42F11FFB3E2BE15F56E7153A09ABCB8BC72BCE26BDEA9D4EA1D0F7D0FAA08EC0BE40FC0866312134681AC6FAEF5CC719BFEE8499D14AEF3F09862C6F60596A2DD1F486C0B57B6A4BB5AF619D1996C4DE30582A54DE60B54501B173D07CE6D3D9A7E081A43B0771EA4362FA968FF0F07D56A9464423021E63A8C1D82755ADAEB035F18E0A141B8786AC5D66FCC46E06E9E8C98E2B9719CB25FA95CFB28E1E37AA5FCEF496DAD946E4D4DD5DEE381909787456458D580E7F3A8858E35AF05C63FA4B9F05DDD68B302E56D62A0644438EDDF0C01EE2187349559CDB120AF79DBB0EE3A231C6F6FA3883485E0091541C059A63DAE8BB6B579C8D65FCC81F1E787C67678E2249EDF2B8D98B7A39B4F0AF4264EA208373F5228D05FC2FB9AFD3C40D72030130A680EFCAF74EEDEDE85D88AD2F9CABD31BFA8F68A824A339A8EA07C76962974DADCEEF10CD4C8DF36DDAB1B925C8A3A79B2D601940AF0F9591AD0775424BB8AA06BE75C34447007C13D017B7CA34E6B05F4A13120CADFC13923357CDB891C375827BEE0C8902F1AE4F6CC74CB291C8E97AC00715C13B25F4CAFEC635E54FE8DB1CDA49831E5170665FD45D2292C70268694D0DA16CE04FDC0EFC6E09694182AC9F5A03C4FA3226787163F6111724E128F83F8777EC8825109F43B544D9F1DA45E5644783FFFA97F0B4FA3991F0EF2FB43137FB33976800E6EDF3CF9222EB72AB05F6F036D92260E3632EEFFD7F13146EE5E8205C9CD03CE5AB20B650EDFB2F94F7A8A5154E05AC61848803D45DAC179444AD9D42707A43AB0C4E3C7593F57B76F33DA986B7690C733AA0D6D08B4923D7A64A46597222D2A12F6C8E5A78D7025B689F2D8183CDEE9B070F65532B73078A98B55C9650D40610CF3D4496041372AFF3F25392D3CC8CF2D0972D784391EE6402826DFB76F65DBC21F14E10B0CF323487A8F509E70A1D06A0C39CAE9028121D4E05653647FA58E90C3AACE0D32DC67D45CDA055AF3C7967B8B5E5CFEF69E6CED2214E873C77F2380E94465071D5BC86937C0886F6E43E9C8CA1BE4A22578D428B1EB69FB469F95E44A749DDC9060976F018277CAC71ED88B0F2E125D636DF48720F568B4CBCAEBAE8B4F8E47CEF8F7DC7947101900F51D199F34C6324D2133D8BB6CD5873D10B7129C77C0E53878BFD660607F9746B0F4F57CA5C582DD87264C34C6C08ECF583DF8DE56C9F4EA9ABF65B6A3B9746D689E7CFAA4DF7B089569656CAA7FF8DD757A1AD5ECFFE52CEE9A5C21CE1846ED92F6B4BE9E03497312E4DE3CF6E384F7E033CEEAA706641C5D1AFEEE528EED74A55B4F2F77D8114464C2DC501C4246ED88AFAFBB8CEC49E2262B97AF48AE35EE35FB7F3CD10DA690EF5BD6F1E98A48F4CA469C887C236F2498203C1E69009F3BB4C5DB6537103425382CDFFC11E203634A00AFE7E9E9B41160B64D0532DEBCCE57E7D3ECED92F5792E86723134CFDBE6266FFD25CEF62388B1C9F82D8A62ABAA5D14CCECC829D247257EDE0C7166DA58E3D868DE8919E223D49C16C0DA1BF80C92E3970F28BFBE8F4D863EB11AF724C88AD248826F3E8EF424F4AC86B820CD632FF804962E652B2C5AD81C170D06178023CFE1A87E2705977AC57553EB18676A9D4BB8327747976B7BC7AA75D508B99948979F208B6BAFE72A7BDEC5D0A6F3054DF21FC6A06018C2EF6C142E0F3013588B46F9DF1EB45DBD125892900A86D88FF5BAA5E86144DF4277BDD4E829C240BC0CE84CA935E9BFF3DB810B7FA28F7FC4553DF04FED1F40D7EF2FC8DDA7383E1ED8341F894B2DCCE6099207A11CCE713F9A7C2068E018F12B7197D601CFC986E322274E13CE1A4075A5D068DE4BB26FC63198A62D1B61452648EEA48BA372B7727152538C95A2D741AA3BC9263F391A16237A74873BF73676B3E3B6A65BEBB16FF7A71865C89340A51FE12551D7F90AFE94FF7655E2AE1989B81C1FD647F622CF8DA11F4937AE169ACF56355481EE93D3B9FE9D7EBA3F1116F15013DE2E10FB5536A73F6BCDC4FC317E3194F3C50BDACBFB4DE6434C5977CC0CED0D34E094CC6449FB5F5BB98E21A041E9D7310B1E04FF84F373FA7445509602F9F9EE643E1B5563A011C90A5EBF6E485B889CEF7AC506DC7272FBE930045AC56ABA79FD6AFBCA86C7ABD124E071F6EF5D2B79A01500BD72F7596009A11C0F7135AA7C54AECB74D429B2F03738FD35D37B9C0640769070E60F28C9DED0F338B7E30A221645728B636BEF3085E7CC9AC03731FCD9D4F27B58C1C1C73A2FDFC45A38D703D2BE6D047876DB33F2E931A7D662F9BD954D708FE6DCE18349EA013F9EE11AB78FA2FCBAF5C64A4A63D95839440BB13C6E7EA674EF67A5CF7862CBC3C03F0C4A2376B3879E683C3BC260F68BAC59E515ADC27EAB2C3D2D42299B2231020DAB5A6505932A205FFFED29D3B11DA9CF6B9A93CED06B9A7150B6A1D4E69E55650F737DA05B18F479E47E2E181C7CF3CE1610397797118029FBC01D88A405DD2D054650A5ECC0E0A5122BE0519495326D3E45D9C4CB5AAC5F196A613BBD07A4C4CFC3AE4FEA3214EFD405D243719A935DFCDB8F49C9ACF0B3953AD700B0B5ABE56E51EB28F32E49CE8EA270BB0E419AF16A11F069EC1316BAEBA17D3301A29245C1E0840B8BFE6EEC447C5CE066DB54126ED9A342FA6CC5F35D7626621A8D4AEA83D797625408CA0E54EBD5B2067330110398C14B8D151D5843D913550CC3D81A2E625497ED57AA3024305818C508CC70CB3325F3A8794DD76F84BAFE38EF3FAC039ABAD3E4FC44288B69C5DBED8CDDFDD74C444C6FDCB4E936389331803599E90B45A4A206A4BD0F7F94CF5C62831003B63A34D2D94BF1A83DC077A20CC3BD5AC6275EFD9093380C1F1D976184F2A9ADDAA0F53D9060116A4235353EB0DD2D16F6534F0C31EBA3AB78C433EAB534DD73FF287F39D9B4AE153390E8333EB0D152074D966265A8D65AD9CFF13E7644FB2A6874EF812F34638CB6B4B408457D7A6A03A92EB15F46E7EEAAAF6E3D4164CAE8982DB0B81BD4FC36FEF5A94D978109470C32A3412D9358192D0A562C6B62825F024C894EC4879DA6EB5C44B85F15F800DBD99FC3C4CD34227C7540B87AE79243AE08628F81E521ACF6670E61B6D58E6DC3D014FDA5316864DB0B34E633940DF9BDFA8EEE82BBD1F0D744F52C32102DB05B734C88E1503E3CF7E54B53D5F8F1EB944071E386EAE10F58F64DE36D5F4A265E09DE247FA23A2FDE14D863CB29E62528628C7C368CBA3A98CC2A1C7F1C50CF49167CBB1D194E20BDA86F412479DC8312CD00BE2F933DDBC5FC3ECEC2F7D74E55FDDDA7ACF8F22820BB1073677F36D79AED13566BA6CC27BE29B410426FDBCD1CD6C15B50777025236B65FBBBFB04790D813D9DC5F32516582E1F1C1E169486B6CB6F6CF94458D88AD94A90BD2555DE46D226D6F592998B43BA9FA94FFBFF6DFB222110D94B4B335832305F7F68D1F8D86F181D848FA8D8DC49B74477B10BBB38C9F88E1D2D4D5EF0AA669E6A76D5FAFF175A5BB63837F4B13E3E27AA3BDEBFD19AD55562D00F33CACE55BB835A171B7061805670DC550D1E5B5E2D61182C4666EAF88191465C7F6ECB370B46564F106C9F3FD78144AAC91B669BBE4F7DFE01DA9B11D36B83BBB038029B1AA67174BA1AAEAB5F1906E177BE63054CF6948209E6DD7DBA1069BFF3A0C1871381B9A418DB0CE638F4E2A3DABE1C1E574B6E66B6677A929D121080C9CAD3B9EA30CEC8590C6E84B029C41EF2A56AFD977A07DF2CF9D0893222173DF73D6A17D3576645BBB4985E2B9B6086F0ACB4B44F07BE34E1A7115075897DF26A9A2010B0B5CBA659BA0556AEE8863D4A4513AF1482D7174E1ACC9EFEC000C10A4747B2D9AACC045CC936271E0C4FAE450F11754B873AB14CF9BB7CB9277090E22462FD97CC4D5CBB5E374F332410099686C66F51E2E56D45DE7E2706876394186A4B2F16E6350C7F625830F57F90CB20C2031DBC89FB2E5378E3CCD8CCBE138F2CCFC3EF31CC9AA382F84D1139E629AA57F4C59AF2C1E82E3B61E280D88E77AF6969DBA83A2214889E0F7D712A69B55B64A467446E7DF80877FE11465438B2006A777BEE418D4EBE383418EBC95F2C4CA736B98B8FE227E5581C3689E14DBCB6FA47D157B65C911D30F72696625025AE87F29310EFAD483BCF314BD3AA7FB55FCA7B3BEE0DB43F3B47A938D81EF617A3F0E10897AD86323636DF0BF598D9C669CF458C79F4158F8F89419722E37E1BDA27E3AC71E885A457F530049D43C87CDFCB1C5639D13E869D52F11C52DE27663A7C4FBE14B89185267E5DB87AB2E180A593754949B9972AE5F865036EAB23B4ADABB77EC46E1054146610D1FB237F02565FC77592D511F2FB142C250DA6EC364F59DCFAB538E06D08081E5BAB933F111D72AA5AE1730E89A56CB6A5DB195D33C1BC643A359C7500BAA9E8A15FB75EB2BA083E6BDAADF2B49412962A389A16F1A97D120A45F91A5CDD8408D427A29B3C97EF40F20A07B1D4C6AA344FF85384C27D1044FAF3F5A1FAFA49728B82B85EC8618F7EBD5D9402EE7805FFE6F314A5500F8A8D866BFDCB15AC9D870CF529DAC69128649EA3944D0B96B0F8BF0A4E98825668B55D7EEFF1C62E2151AA9F999E71C50A358B97FBB8C4E80C765CC4FA37FD4826A5949B9FD0C6B4FB9A5C5835170D0DBDB9414CE0A9FCFC50FC4FB6A5C2C87EAAE0B6A6AB2E7E4C816C40F7B515E45B2C0287C2B5A728DD4C3FCA1E1D47203C91126D1A723A0F447BF7F30886483C1A1B6DFDC5FE5A9017FA29E0BA73FA437574C740F23000C82AC7861C45BF22072DFA3D1861BC9503D2049E1A3B64D7CA973CB32B8E75375833CEB95B022C94B5156444923E918028A055B629883497E3238848DA75376C728D7BAAE2E53558892D264ED248FA53E0172963FAE7C4D4DEB09E905AB5C2DC64378D8C91729852034F9EEE5D124782B3E2FE9C529BA3FF1A0D1C7A3738A7271C836119CBAD35DEB37CFE9DE7DEE1FA2AD6C801DDDE60C551583AC7504BCE02ED85CD3F0C72597BE4DB7BB261F45754D46DC6053A95ADE9C36E8C24291AB92F2E60923F33B667F0DC02978AC82333DD7C63E10A7BFD6280C400F57462357E7B6544D695D2D4B8B57741039C1572EAB8E2EE5AA8951F7305F56513EB6CDF32DF9FACFCB3DC16CCD70C762AEF0258E5D8EC615395151E2862F7B2AC9EABC42CA23106F5FB4BD61A36846FC6BD816BB8A104BFB0988163E594A74789F64D5046D334AC5ABBFAE9989CFAD5F8FAB3CFA981A9F9EFF297614E8BC1EFE5E373140B7C69798D2BEC619BF3B148FACFEFA6848C2BFD0A58CDAF4CC2D7471C95DD4AE4F4A4E8A1375CD47EB452BCA2E42425D3DD84C22E5808B0640AB1EA006B15EDB0532C1EF4C384084F5955130932BAFEADD7B332828D9E111299AB253FAC2ED4C85BEE5CE2D1FC8610074FCC6A1B491030F1962E40DD489EB00FF0F14995109F26BF2F5342EBEF4406F310CB2C4F21038BF5BA504B5494F7AE3147D216027A21D37C1B8B1ED505EA41E283D4D5F7D0F8E106F4C3B6E31B424B4E2847D6302689C7E5C3FC4703097FB970336697DF45D6791D023C8C41069679638E2855BE5B75481AB41ACE4916E4438005BC7A94A5DA767D0631A56FA37B0091465DE74C00BE2DAEFB3CB9BC537F4FA8AB2FBD0728BFC17675557D892344576ED722C8658CEEB0C2C4A2536650ECD383BBC8B3FAE9D7B30EC3743BB181F2514FA30AA827020A705F2AA7DFDCCD84EAB007FE7B7493FA787F49CA70FD4EDB69A47E21EB3B9CDA81363D47F56257FCD93371898DEB96D0718E4645018341AEA7200937D8A6B85C3A95EA11440489BFC54A4EB1ABF5FB73DB57C8A398D76F6B48824C7E211C4727E51D7F895E71283932DE1C71EF8930F39F2B5320CE9E79B91E49836C3EBB9EE1BC3E3BDCE99A9E2F78964111918EB5CBEE8A3ABFFE046521F96824FDA0A0CF73F0ADFFA4551F7ED9EB522534BF72224246230D0E2F8E8FBCE390FB68748A819ECA0184B3D0FBEEFC99694E8EC049B2F4D09888223E9A757561D0A0441B174339E0E67D7167F2DBCE454CA8A403F08C83D5167FB7C462844873EBA5ABCA3448410E527F4DCD870B50504C84C3E2E860067B6B786459518B5F334AF972422B1AC90F8B8C64F708EF4D7BD9084FC2B8926C5EE8D6E5FE58CD9AB67656BCD5862A589B467B7554BFEF525177BC27EB42D68A06CEF96D84B6108A01E124E75B40C43701F4929942993B58555A9C0FE3CF7BDA5EB1FD9ABE2B4D2EE0BD0E901745ADEE869FF6671C353B0468B798D1E5F04810713B2D082F4AD7F75CAFCE7E9DA40FEE2C81FF2CDFED168CBA2CE59622A9DDAE3CAC342733D97085CBD55433C1F6314E4DBB7AC29F85BDA66261E29FD0A3CDB1E29074CEF25DA9A6449FB19C9379ED9CCBB539F05ABF3FB07B2785DD80B4257D72E8ACAE93FC0487ABD582DE3638CDE83E6353F62040998E3F07CBF6E4557CC67EE7D560612BFF1FAC5A30F34E7EB8471D6932FC7BA36447480DDA921CB0E1DCC9D05CEE80EA52705FCE9A8588E19B199AE8A6C6314597DBD6564BB39C5FEE46DFB8D5E997522FC4306442127F3B9D93C076F20AF7C0959FBAF441B0AF82D4A1E019C025755C8F8DF29D87C7E451CF1706FA357001CE60A0DE4B4627E02262B72B26634E52A48DF6E7F4D9576074EA001B21D2113900C8446813CA03527781CBF5E83CCE52EB39D80B6F70CA13C8B3A84F989E61ED579F67F5B53A8C7C996558BEEC20141D3999BA82C069D967BEFAA39F469CB7CF3FB715FC5908EBA5BC987448D8880D6B53EFEB506DA0A56C9CC1FEA1E048150DAD3046F98B670D25EA272365D67528BC9B83E85CAA650086B1A164662DD5CDE0FE4ABD0144A9EF3C4C96B56D27570E00272B77AE2814586B328BA37BA359BC9F954ABDE47550E81331117003D13211551C07C0E975632ABB2E33522CBD214DBD9A86A038AC2A08E815ED1153D0879F84B7609CF117562635836A0E7D38FD014365408A70B7C9B5B9F9D7409C99AE253DB18A2ABE64B3FE24F7570162E301BF558AAA01F6C4510FE11E01A4157A1E8D84CCF27FF8538BEE67374FC1C7ABD4BA9DECBABB2732F23031837E49531A3574B91FAC369E9FAC1045D134E8F58293606754BE4AEFD7AD3103911EA464D0C09B1F44445A0B3C0F5C37AA93D464F5C15027E21A13B555B9FD79B772AEFBE3BBD8A599DEB6D2BB428268749FA8D526E9763F1A881FA96634FEFB16154DBE77D1D75368FA4E6B016AB002C379EA53B5138F053126CDBA0E40A0E74AB83D6B4545E15FF25EE9B6EFA765E7432EEA061B48B3538192045930CAB151B03D136752F330AE80069B68671098357FFD84C09251245D1F8F5F75F362658EC750C687DDE5E5C8EE7C5840A6D2E3E008F8BB965878A277C5F04C37BC1E2AD846423B4BF1A12D3A93DD3834C8E94E6BC71B941E3AACD0039CB7290B2079A626B12129F43EAAFC9C16F642297B3E2FEEFB6CB06245DCF970377AF6ED3D4430D607B473F7D74AD7787DD9FB341D087D92A5664F504FADDB2519013F16237976122A6031F9D0D4554BBD000F2101127276901967B4575B3738AD44CC2D9595788DFAFC47907E0DAB0C1AA6AC86E68969E52ED4AB9C07710F71F0B0077CE06FF26987F5AA6AF8A14B3BB56E2566CD27E9B4C0AD9C87FE0082A4673F31C949617A400C79AECF3D2992CB5CAA9C891676B1227950DD5BB0FFE236C4E7938B6DA7E552F83BDC7E4A62059D094D87E136478CFBCA9F712FB3737BE9F7F93243C69C19E38BD3D1A2717CC2EB8090CF2BE8DA30F62B5A27868B7125C9DE4EFA0C4D862DD8796FBC673EB755F226FCA1D93C5937F2067FC9F4749253483A0F5AC76EE8E721690B8520CD3676F44E9B18DEB960D9381569F435A897E3FE8F8A9DB5ACA48D3EDB5B3915924D5CFBB5718B5890E2D2D8C4066BFC27C37CA321176D29312C66DAF3A9C18C389D3E81651BF8253B0416FDB4CEE1127E81E89CE772B3D0CFC217AE96C65DA7E086A7A619EA7E0F606416D4E83DEC48DAFCA05050A212DF43586BE42B588951D9FE3BA017BC0F1FD2393FFA52F7293BA64207201836A51B26BE62280950489F5E69CB1178928AE11DB987F6BE399EA680753474F8E8BAA410B432A29D2CD8592FFD34F09DA9B0DBB6FF08D2DAB6D05960FF55E1AA789C925A68BB296D41E1258C61AD8E92FEA5D656DFEC947A140DCCDD9FE37E5164BBDC8BC6EF437F07BAA39482E7E782ADF8447EA6456655285949AB3B3028E475A873492F3B8B43247D9C4541BDD45EB8070EC7C8F4F9D7040CC7523367FCA400E4515745A08ABBC00D72A01D6A61F0AB7C1338D528C9C7FFB9E9B9F74B50971DBAB0A2AD80DBCC3FE3F091BBF991EEC6BF9E83FF1A5EB087FFD7216CCA9FB09E2D9AAF5927AF4A00125334D950C6D7DA568397FCEFC5B8690ACA5DCADBDE9217C9E281D06C454A569A73C4D3C8BB525CA1FD4B5CB77981AF6A1B9F7206E473D726FD94A22378D8A2E04E7670752285A93D63AF4FB6B9145E85A54944E72BA511E339F54D658FC0514D0216CCD80654B45F879DABF657111C4AF932E3C925A4F71B4E77C9D7E430DA0EA5A7C7D55F57B78813698C22C05F5B03CD32956ACFF6F4C9EB2C2FBEDDC7C913BF6B56B214E97D8F9CB2C0196DE2477E35A79EAD449A7AFB5ADCBEDDE7533BD383FA0407DE90AB6BE0D9044AF24EA6A9091712199B4C0DC4733443BF545D69A0FDB267138C519547C139F9515FEE2F9D9C133B50F43886EA0D905873D76CA5DA2B633821EB42BC4467065221361B55CCA81B2CFA37940435D453564895FD4E135B306CB4BBD8B8C80D73E5F96E5A3E64D9EE71267F000A9717F4FAA40AC9B74D00C17C757F2EBB1941ABFA422C1C2ACEF761124D4A4ED4D7A6ECE377F1F97408B51216992936C5EC3CBB7454D8B184FA6BEB9D7ED16D60165AA5AB451AF7D5B6FFD3F3B01795B995E0E4BAAA652E7D5131FD6FC6B073DBA9C32D2FE3CBA5D0F766DA835502B5F8DAB14EF2AD172344898877EBEBEE3B908229F66610706BE3D392D1CEA9B805C81CE85E0240F605A0293D9F4EAF7862C935833B5BCBD2E138B38FE9B2B74D8129D626644DB87113BE85C238F1A91E72BC44891B2AE1DCEF8036167354B48A62622F496D2235A75251AE1C38BB52184F27E39E3C1AAFB172444899F50AC2C1DABE7D8B0AF846565A81A3CBDC5321371A2C2036168F48E0EE3A41B3789029F61C8A6F59F26D446F5DFA2D85FA9DECB4F7C0291E00DF4C4A1770F84F68A35088079E69C90718F8444A211563D96050E689AA57C918309486547772EBB18E91735D06E54B84755E4F8A424E9566A0C18A5BAADEF917AD8EECEAEE3E6667828698B67B039AEAAC9067A36E76A61C7F7592DEDA6D372747EE61A1CFF815DD02BD00E96A14DB33A064C8E10541050E2FBCE2041C6925836F03CB56373A4E74726DE57485D6D96179AF47FFF0A72B134598DC1E6C884AE83186BF447654E2E763B98930544BA70CDB4F8C6651560A2F4741AB1A22B22EFC9D3ABF2DE2B4B105169856FBD77255F0B3FED19B84E822F1B4A2F8275AF880BAB460A3AA3B5A0AACEA114F7347BED23F690513A26CE25C41E4FB88ED609C17650C9EB9A9B2BFF5C6A13E7EE12906EC3D9059C4715E8C586E0956693121ABEB69F2797A34FB62992E76712FC55166974E2DA9994C050ADE87D2B50B4BED6C37D003CF47C15519E629A5C97B3C132B2414A1579E597CEF393A3ACF4EE28B3EF8F2AE42F0757A39A5CB02153B3E44195620989689E55FE613F445C2FAFAE5E93FE008BF566A4CBCAB2B3DFD3F8FE37EFC35CA33CCCA1E00B204AD3C322665E2C942A51EBD404E21546461A8E611EAC03077E85FDDAE2BE4FEC500A48CA0200CD4240E2A5014F6E594A8E1F7AE1DC6B3A939DD53333907D76CF532B326E3CA365B10C6ADC494FA0ECA1B99E48697D93178278756D77C1C9AD1D3BE4A22C0012D8D688F884F3FDA3190B4CF4FD3D8AB2A3F55742711579EEB9815EC9EC58AC29A6B6CBD31C21987ED4F99AE7567B5AFBE7283D4E55B6D9A4B9951A1D62C29CA3E29370583961DAE133ACF94ABA2373D3AEB19C88FC8ECD270F0544F702DC1BDE44451ADA4EF9BD83A139CD12EDD8B9FE8C2CE97EA0D0F8FD6DCF41E6E58C1B00BFD72364220FF088303D69E58C2AF650FC3A732DDCDBB567B93CDA4F81EDB10B1F594DD429A6290F5AC64A5648A23A481EC3C4A6973A69FDBB5D0A4B0F4B5E7A83A297B6730514C0E11A6846C960C4C387E99AD06844BDA71FB0D94E670A19B30D13B70D65B221B9943CFB54E179BE84AB6155290E6B9E4AB00D78A4BEB8FDDC6F49C087E56034ED02A93BF68F6DB4985597F754E6790CDD9BAC7DAAAF3452D0238AB29612041C92C63BA20B3929E73DA827D90189115721EFD28C0202FB28B4A4652076AB5CB03E9970663DAAECA027AE8095C7E8F74543F15DE2D242B6132C794CE7E95195BE3DEFC208CE55488FD2A4DEC81627A1F19C4E720C599AAFF0A23ECB862ABF54F67696BD69EA9383B5FDB78D72336851F80F77A73E480C44FB59AC9C521B463750270220681FA169338CCA089E85F99D3E90E6CC620F7C08970EDD0B43C710800656136BC096E2DEDBD9A6BA50A343D854E053629B4C8D6392D2C75AFE7D32DA371ABBE26E5E8D91F37218EF630EEB6E59CB8886A1579AB24871CA5E38E650F4B919B93C01AD93ED7704BA360EC5D55D20F0314F71FBF3F046BD9FF24BF4A6BDB827B5385C0C5E8B0AFA829547E17FD8640652DF94091C7E4215486028AEE7F9AA02178E9E495383DFD5588E7A46159F2DB8A123FE40BFDFA65371BF903E506388FCDB5D70AD91053A512053D8B2C1C3D4D89E890260F6755F982C3F4E8DD4F02921313C09EA67CC41A394F4C61F67C282C04D652E8994CA38E547E869D2B8CF45E66340855494223DCD02972B2F6AA7808602075D1AD69C71C690AE0CA589544AC01420C6F84894D79A7005160680C993548DE337038F5A073A38CDE96BCCADD228ADBBE8FE0C0E79491AEC74EDC6BA948A19C9436B7CF87C0D2EC2F6B1DDE286E4F2DCB11543AD2DD14EA40BFB6735FD3F8FC75E4392C4F56EC13CAB29EFC7ED16E7DC13B3EA2441681CE62072673D49C9ECE679CAF96EC10690AB3995153AB77F266338A0FFEA16098247A253DB9609FAC1C054A737037A108D13AE002DD3B00000400 +Output = F54711A8E8CF30CEF699307BE6A0E5768ED68BCB6F191B0D71A6A534CD4F87912520142D78F80C2DBDD3DA4A0783AC68CFD72DF27CBF33C1A47955BEAD9A7FFAD1E58934B6B8BF577A001C84724A97DE9429E4D41EB6CD3D333DB72B69E658AFC59A378483A5D4110DE2BEF4589C03D0DB728A8E46844D1D271B54BC2130DF63 + +# Group 71 - Test 351 +[HMAC(SHA-224)] +Z = AFCC8BF1BE48A39CD6E9581CD5DF3EB5C7F2274259589C4EE6BA493C9DF272BBF6B23E49 +Salt = 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = D6E4EEB1EF44B834778C4488C9A5E0E889ADEB609728A58A3E8C08ED75817F66D0C3F5FB0198001B8963D9DC5F0A211CEAF8B6C764B08E3DF408D2EC1EA68A4FC16AD4C2BEF6B176522F764AA0B2ADD97CA6C2F200000400 +Output = 2AA4A2BBBBB6467B66C3BFEF60AADFBBF74EEB5B1F626AEC92AD29F3253DFBED1624F828A74744A5C215B60CA21BCF99A08F425B7856439ADC222A92FBA8551A93B15F888E72E93E37156CA88FC2B9BAB0A1026E25BD892ACB85B5161440E23DD05E16DFE05DC6C536C93060AEBE99785AE85575C78DFE4B2A45C33EF9CF5149 + +# Group 72 - Test 356 +[HMAC(SHA-224)] +Z = 9BFA19A545562DA91C2E58F58B60B5583E1658D54C0C260E889C626BD6D4DE263BCAF058948D7C1A64A744AA8BA3800C708E563E8E046A8B53AE33C171925061D9E4990B6D25E69555E7D9B79879BCBB5ED3FD2736B70AD5D55D7E7B22D1023E5EDD24485FDEE06DB58CF699D940E9D129559373D1AF3EFE2CF8E94D939C214C80B3F8814BE610F147CED674B637CEBFAA1117441E83F2575E6F2F6FD0273C8B01ACD0A70094E2419AB1F6C3069D6E5C68B974CF2823F8515BF8162D28AAA33D91DC12249337791FE0406817D44D4F749D581A7365CD6814D163DF79B3C38102C8CB1056120BB4832DDA9D9137CAB53A72C9F1AAAD6C09A233243047BAA7F97ED1A0E18987C23E8E02C8E06E709B3801AB9920AD4153A2AA559818509AB74B0E480D2C70CB60D4937732FD50165E3A4B75CAFE06B5428CFE10ADEA5B55B6C10018F7CCAAE7ADCCAAA0D6F0CD51B3573FF36D075BB7640515B8141E970B746967004F036E9D2EB97C26B66BBA5844122E44F5D0BE1DC1501C656AD8A12AF2610B904811 +Salt = 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 64E19C35C42C241D08806A8090B54889C28F5A38847C1BE4A904B7816068C8A0AD58A69761D6CAB0E472719E0F13B9CD936DA889C330A21CA2E4ECF0A9E10955635C114DC2054B95F4551233C88DF0ABB0BCBF49A428EABFA5699CAC6BBF05F7A53A2C00BE6A8953B64CB1AEEF47863F9158AFAFD9AE90905CCFB74C5801E2A503027A4ECD8103606B98F734B8468E5DB5F5AE4D6409F92089F981C1CAF5EBAE816AF47EA43C353FA614B9D2CF1989DD91824144B0630FF8801F8B02C1A974256BC74E42241FDFF7395FB174027A4014FC426B3F1A5675CFAC189D84336F9E5789BC4C0F2E8620FCC15B9A2633BC111DA3BE726001FDE1B7D67CC8441CA053D485E4301397E4D36EA26D3DFB0E4C4C755DB9248644233CB9D0E4F301F5C36AFE57A9727F316FD7C844B6833EB7B19CCA7EBE07869FAA7EF76462836FAC172426ABF4ADAA17CA336540C331C21BA01C5354A0191AEA15F304548A4A65D4188C75789FDED404F06B97D8F29C92AFD282AEC75787398D9DC68AC9B19B82610B57DC56E0949E4EE4AADCDAA7B7B0A0BCB6EF0DAC702CF5E2560C3D2DB8AFCD453E8FA23C4FED6B92E291ABEA0CBEC012DD404FC48E00000400 +Output = FC50F70FF9AEFD4BBEBC09FE39E7D362C3CFD42A89F83111166A7288D66B5CB11E7486AB03248F86A02D802884BE27882A51F458D6946430C0AEBAFA539A33DBD5CEAB71B515E3C3927B83E000B820AD873C70A3778D064AC076C50CA37B5D9A1986036ED56B9A50C1C4EFEE8D1FCF1D5F4BFD8D7DEB85C6483297AE6E06E260 + +# Group 73 - Test 362 +[HMAC(SHA-224)] +Z = 35406CDA1260DA3902F458305B747189CA4E7E936A2066A917BAB618 +Salt = 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 93DD6EA6FE348CB6A94356EFC71A928C7133AF7225440D02BBE989497DF67AA8142358B988FF81D08719C1EB263C3CA7553D59DA7A4DCDD917442078306E03A8ADCF1DFB4B610AEFA68A90CEF2CE2AF0DA9D6697CE4AAC39A9805EBC21F736E91AED86FF07D05A6500000400 +Output = FCB8B19802B57A99A895B8BCEB756BE2D7D95F5AA009BB86D8FE565D5E6AC082F0741155C50C7F70E37705DFF807E5DF24BAF4D35BAE712FBDC17D79925BC37B442A4B18979298997204C2BD1A8E1C4E72C5E3A3CF5318554BDCE5D683401EF7D197BEEDA1C7F637205512CD43FC9870DAC2877DABE66A9ACF49FED0A9CDBBFD + +# Group 74 - Test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alt = 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 147AEE3952CBCD1B945338B865F29B53ABD1D263AD0A49617C8D868F8DCFB1DEB90284181CAF4A8C2535087C6E08E63B00000400 +Output = 0B3A1AC9CAEC050AED605867F14A925762319817B34024DEE303347ACFEC81C05B6DD1F806CDB55F5DB6C18C5BF5B24893D331A5719267214FA6F9B425F74F4CFC6F2A967DA3DC23085FCF07D824ED86DCFB3151BF9050EE7522F65C4DB2DC7CA085897423379FB47099E73D294B762688F2A7373B10A5AE1D1EE4F4956AFB05 + +# Group 75 - Test 371 +[HMAC(SHA-224)] +Z = 0D14C78177E0FAA52F4E8810D9C8D0AE5A90D582E40A07E15FBD5204D6B7C0300EA50D018EF1D4D2E75AEB7B5E0B4DF94CC281AC01B8271B1555724BB3E1001ACAE71B26C11C70DC3DD73B0C251D37D20905E6D6D28A172ACCCF1E +Salt = 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = FFCD11A92266119895DD56FE33995337FC6475E1747CAB8FA647ECCAECD0AA81F31ADE46720A308871A7FECC4530E09600000400 +Output = 0F8B4A8BAF445B1933819A126D39A02F1ED4BACDFDEF73817524A9863BC0F4094D2EFB44691B8F36D78E03701065DCD72A768F2058240D7A1520B29011260911506C65152A6DC8F4904C9EC5D4DD9D63C905E9CB54835BF39882B60197C7608F4C6BDA08A52710B1AC4CDB50065B05821BA6A30854AA8DC60D30BF28D90CFFED + +# Group 76 - Test 376 +[HMAC(SHA-224)] +Z = 80091A6C6053E437FD6CAE2503675A8799E9B7AC6DC66609E0C725E7CF496BB26FE4A1043241C3A78758E7D40E0F0E701E7EB3C7013AD8210D4DAD24FA6C90E440BC3511D878064DB1B8E645E773578DEB20535F2EAC6EA4F6797C398E75606E9ECF47659DFA9171DEE1736FDFCF9A8A873C995BDA2EB38721D20C69EAE52E2528C51582FEDEC9857B2D8EE2338F7702E3671EBD9B8834B3524643677F0D9F6CC3A7FF56D27EF1A5F934E40EE206CE643A8B778952F2CD281CE700F084C3B95F3C70E802F4B18E5AF070B068B1509B5336C72B386DDCDDACA9F40760D8E216A99D955F7D59042C65C4E4652F9F771D2347D9D29A6C56F59CEE41062116523E56A04FDFCE74E32C0961978F6278CBEEB0151EB21738B6F87C64D360860E8EFD5347DDFB8D283342FAF00B5165D3596F4EC715AF14A586349CDC0701B6DD1D14B3FD63BCE71AB6C6C532589D6C53D48466893DA32241FAB704C51643EEF875538E77A43A58BFF98C6B38F00F5D8AF9B21FF6FA2B30AC8C5737BB7CE1A721FEB641B5286605F47A60B56E50AF99327381A6BD64ECAFB709 +Salt = B7DEA92ED320AFFBBCE78A41D00B9F6F84E2A9E339646A01668F9D90A2DDE5408386340575785D0A99A8B41A9A98021E366042D2EF3A8FEBE41FA7302A48A370 +FixedInfo = 0124DAD22AD6D0C7B5991DC9504E200DF0DBEB206D042F474B37AF695B4FCBF35CEE7466D202974CFF0349E13AA9ABA700000400 +Output = FD5B8C05E2E54762B694B400CA4636E1BFC1A23D8C156F3E8CABAC1EF40E774985A5571B832D81F62BB3007F6E9B1E0122537E90A69CC16BCEA727560A2AFF90DAF80EFDE17139E723485F77AFF0BB98F2C86D89733090E0EB81A1E1C39D4DB1D4C92ED06CF6F42D2CED2C5E02B582B1A79EC2CDBACE2C8CFE6846CC9C5B2B3F + +# Group 77 - Test 381 +[HMAC(SHA-224)] +Z = F3CAABA5544AC48FE2C99D92E3101332C30EC1BED1190389A7FA3452 +Salt = B1DF56F5B2E9E4BC0BD9A05EFCF90BEA9A4ADB6C94CC52C9701BA4D886B77EF4A8C189EEB438DCBF7DA7FE16D832D976F18A4026EFDC133ACD0A2D8FA861640A +FixedInfo = EF7890D670FD75DB70CA49A7071FD49D9C3D27F2E711A2E138411A73737B68BB8CF001D8D117509B4656162639DE02A6E98D21FC8C571F05D3A9D916F976E62449B52021D18EC2AE8667F0E200000400 +Output = BAC72CD2E673EBC880828C03FFC2F9724CFBE3C6CD37DC1B5A5F11F94CF3DDD97A02FA9CC67FFAEA193F2D5836C206B86CFCDCAB1B4A5AD2C10EE1412BF53FC5BDCCCDD841D0E6023606B9FFF996741669AD9F26EC48D38BD4E1E73215B8BF2F852C4263DF4F4863D6137AACC9A32210474A11AB8DCFB757BB430725B2B1570B + +# Group 78 - Test 386 +[HMAC(SHA-224)] +Z = 915724050A7E3B859DB329149188ED46FDE1808C437C01F6CE1CB1F9A9C87EA2F270D6CE3C31E3167E8F7C12BB77F19DCA +Salt = 8044263F08E967266037ED95BA151AC5E48B8326B8C74207C0952CE42756060947B3BFE244877EF4FC860374EAD714BC603A117DFBE47D40276AC787DD63AD64 +FixedInfo = ABD86CCED27BFFF6097E0A36076A718795F24CFF10C4A8D5EBD1D77CA79D1678F3DFC3B912B252DC24379943772ED208E948399DA2646CBC9C1C6F8139E376CAEBA9D1C91132BE242ACB78DEDE4DE0F533EB8C28147222B0C386B2C8B27C81146728CDB9CA836BF23E506C354FE8B96F9CC7C5B30FC57792B4A7203F36CBB7893B718CF9E309BC2F5CBF3E31A831A3F6094900000400 +Output = 08D05BD3333B9EB46DDAB94C8DEECA4F63905F2FEC469AD06C14A5FB6CFEF2AFAC197DAAD7DCDDB4633EC4B81313A09F72DE739A40A67C32E5D860349225CDA07B17F091F062AF5334599AC28D32A727CCCE192D9D55326879C69F1F724B44B3E023AD2EA479D5C42B6C4D42B175A595D60A54C370640DC484B6A03934CE31FA + +# Group 79 - Test 391 +[HMAC(SHA-224)] +Z = 7CEBD9EC76774398569CFC15FE8622F334CD085ABB657147E03C5628A57D0F72BBD3B6BBEA8658847ED04DBC7483BAA8956B31A2FEF73233A6C373CEFBC268A3587099B82EB85E65700752EE99180A540B51EB0E2067E3548CE57448 +Salt = ECC88BD1BFE6D47ED8C5FA8179520AE14BBE191B0C6097879427892DEF717E293AD8B87AE89EADB23316B5A3D87F36AA94D2C50A0EAE21A443736F6C9808958D +FixedInfo = 69D300B0FC9FB311C928C92D05DAFB037B2415E74A2CA37D526DC5B4938B3C5F866DF3C6DEE40D277276A5D53098F652957EE5618F3355DC90C42DD4006D6234506E19C79BFD19CA708E10C3C9C02B75F3196887D39C348B59DAE3C48AB820A73355FCE3C9D250FE06B8FEC3BFAFB77389B78C201496894C52E29AEBFB1F836E52CF728034B52D803A7D1E5C00000400 +Output = 0E1F5DF93269E7C8875D830819BBF7096E5627264B76C7B221AB8BEC1B8E772841A75F0C65020365F922531488C20DEE838DBBE1D3984ABDFC9CFBEF23A277DDFA6198AF30CF03A058EA2A26154F09BEEFC4FFCA13363D6ACEA1B84D5EDBE4CCF917011B6514554DB60D9F3F5D427166E0FAE30A6462723B34775A2AD403A41D + +# Group 80 - Test 396 +[HMAC(SHA-224)] +Z = 9EDCF9A0D788D3B0DA01EFE19728B8E71DD51D0D17BF56F2CBE649B421A855B97968DD64CE5AAE12FF3C82A853A75E52CE108A3B2A4AB67C40C7FA859BD2EC5DAA4389F57A87F7A8104757CE3C97B9C66BE4870E06FFFC025E58EBC502BF5A560ABF3F0D6DCA36551E903B264C15D42C8DFC44F629F71CE950F6BFB1DC15384C6EA3E411C346C2B0DBB10523E94DF91E09C8DB3A0BC9FAEFD00354307A110624B325744534DEF4683750BF23E6EDEDA5263AC3E339EC71E3E918EFB7AFFA009AD4EC10D6F32059CDAC15267CACE307C0BB042A7BACDB10C3FB67658DABA07E5ECD6C07EEADA8A951B66FBF4AB06D4B4EA69B582E58CE07DBDBBE7E9D710F3C6B5FD6EAF831AE5C13328249B3B7EB827A05D69DE80CDE35B764389C09BBDCD40023773632E750254384650C8D856B1478C83A79450F60E39609D14857F1E0793F10CF1FCC644AB57E1CAC49F0743E89AD908EEA351BE4CF42449A7C9CCF42EFCD5681CB0E19A506B270952ADEA32730856E1899E1ADCFC0DCDD38716AFC2514478BEC17A5C3F7C6296F9705DCC1AD7BB50579C2E4897BB96E268F06DFCE754A7571EB8B1EDD35FE31FC235C673DE66BE41840E0469B8633170BF5DAC228C24CCBFF43C22C9193F6E5C05D6ABC92C56301522EA21B4149B934181DB2D31BBE8E67DFEE2CA1E7BD13BA5B229054BB4B34BEC9F681B72A2CB92CE4AAEAA44D520850B22508C6832CF7D3E6CC47FB769EDE03C10025230F418DE7B5AFCEDE91F986A31D06F2994EF5BEEF1A91F8B7146FDCB3897C9DD4F62557A5BF56BC411B1164DE835C6A5251677F5FD41C4967E64C3E71F1EAF0F6D8090088594401CD55930B63F8DE0352E0CD9D797276DDF6AEB0E9C02412D427755DBD87AF4B1FEEE1F1D5B212F718CF0D6283C61166549591AFD37932E2BF2A451D5B11AD11B56493AEE0C60B6FA5812A1BA3E33C1A44D16F6A9864AFB39DC1B8E021B87942EBB046C0E05637C3002914832DCFA3780B67D6D45498C1FC257404178A0B99B90457EB475C48811AA5C3035A61D528A1D943ECBA717E9AD6F7A2096271DD870383755855717DBBF8224752EE6FB89F2ED675F5120F1D2F5DAC5DC41741A362F8B273120103FE17CE55FCD7A1DB4634BBBA4A05D3D6397796765B54894B10F5FAE92E35A4745A78DC49CB4B86B3A5B801E70F28369D4B27E717875B7BDB6099A1838B4694481BCBE280A31FFD218E1ED1D72FEAE4B279852FC37DBF3F3CF87F69C96C15D2779031D1F4DAAF237BEA65D7C797745ACA620E995EBD2479ECBFBD2FC79BE88665E5694B8AB447C012E4EDE7F7ACFEFA284704B1F37BB8E0DBBB853B9BC10769D25C84C5929CA1CE140114169E003572FA58F1CF04BAE2EAABFBE82C835CC127FA8CE82C1FF9521916096CD56563DBC3E808985DE802F5BA88A3BFE4B6B8D880D77A7A7AC41D7B92B5DAD1FA746B8D6BDF9EE45BDC99A17506AC499B8C08F4E703E141F3CFBB62CC6474F68A77FB67D23E4CECAA9FDB61186D493627EADF07AB6449F6DB3DCCB7CC4984373EB20FBE3CD3337A94B35830F9BC7FC08688AC519BB3A89936383B05B9E0A003D0D51E972ED0BED33B7BBB54FE7F2E164386976D4C540C5D4A3D8FFAA76EF64F0856B027D3C2461EF6F9A5A811F2D7C533E274B030A85A80FDF25A75EEB4CDE023CC46D54561F9B836C816A7D50950A4B37EAF744F191C4F2CF589CD7A7DE60CA07AB161978A43E257C4C94DF8867686C0D5F2D5C16D5BD52EDD608944517C00150E2D4B901079A55370E2ABEF4B2D8D7ECD1EF77DFB1ACEC6427210309753396FB9982514F453DFCC70D1DB3B2117A0EE9120978AEBB9AD33413FE3F04516244C1DCC06EC1B1E9F64A9E237A94E100626625646BCA0573BC084403293B888AEA77A2A4B273D0345D7DC37E12779327474D39C79F4BE9F7769F444EF61F67B9C8B09B0DBC384D9C2DB4B055B17C0300473A1280F5514B85856EDD00100DE90DC374FA2577EA5169CE2F18DAC16F56439F645CDF1D3B3EB2D612F81D921BCB468F71B507CF9264A4193FBC240411987D7C7F1BDB54788F887CB9B7EC9E7A998A532CEC59ECC2C2BB3FB157ACB3BB6C9DFF86983BA61E637BDB91CA825DA45560DC7FDF70AF87F404AAC1F9C7F46B2A473C1580E3EB760A32AD9BE1D0D77D7D29794C07DE02A8A3707A73B1A0411117CD72A1FFCACDDEBCD45DD22953086E886C623AD90C289CE92BD05EC2985A5804C6EEFA4F5FD9EF644258207AEBD473DF3D1C0C0855D806B7C1F1C9AA32110504D8CDFDC6D7AB94687A90A112E06EEAF58A80E3AD5F20D2B4B5D1FAE43259F4F36B00D9D6CA0E5010B96B39388CCC89BCE60C0427146005A2A4C7D527BC5DC3A3C93DDF6A1BD0F19EA7F81D64D3777C9B09A742060DCE213A7AF5A7CB9D0808C6D00CB009578364280211E535AA80984C83722FC514A3B0793726FD7FF8F3B09D2DB7F57BC3F00D297C66A9CE4758616875A0CF4D95268EC588840954BCD08EBBE02C8E0BE90DFD42BFC4FBA36948FD308BBA5087BF90C9BBC3DE89C142CCFE680A03073498FD12C6387EEE5EE242A402454C21BB4898CEF76116F90BD425B1AE23DDE60D4B328CAD65A9207E883AD2CCEA5DE6F46B2245F010527715AA787F58ED7699B50F8E603C408CDD8E88DF49E82CA384438EAF14BD82F58BAB7ECD3A3327A94DD2130F606EA175A37FDFD8E5AC0DE5D2D4BB97023B48ACB46FFD11A1E40CBD576E7B57DE0F784FEA80DA6D6A476588CD10A146E08F17C939F10EE8AE9C067DDD4A104B24CB06842BAC2619F472ADB348ABADA861E9F767B9A012E48393EC10AADED007FABE246AC90320D7F6D1694CD5927C9AACB15CBD421B095935DF974C841CFB6DCF7345C5365A69BEA73982C2F958B41AE0603D964CAF8B40836AC522C1C8117994629589BD6CFAEA57996CCD6B8CB40AF2591495968FC0650D03323134B1480406EE4FBD53B673F4F5C4260D048853B59C09D419CC2857D41FF9402161F0BE7D966155BF325004D662E0BDFE63D05E5D349421F32EEE756C9D820D589CE6E5B3C299ED62D58859CDFD03083184F5662D41DD1847B4710783D43B379C1E01E97B2242F3D9FDA02A4CEBD66436724997D51E2B6A76520806B663EB130FC5359461497A8B1CCA8448BC537A5FBB376B6EE73AFCC1B26322E5AD6FBE5E465C7DB73B919BA1D130D2D1EFEDCDA947B56674B2316F8D8C71360CEB5BBBFF9C643679FCB20511AC2D9056B88942E8601E31695F5AC27CD66A6940A337CF71879B5B22D63DB7791EB5CF74AE35E7E5B1D934BACD438AE7970CB7A42B23D76B924E9CA06EF4C1A4C90EACDA3269798E1E94648AA361C0143BBA2797E27077CB9001DE27C4067A2663E81C8D57B6A1CE949A24A2FF677D707650B6E92B259CE59C0490E4281E28333753F210D23674E2A342CD7F6613C020E60645EC49B18A5608FEC3CCA9551162199AB6BF985376BC4CF0AAA58B95E45FC14A39497031CDFE138A7458E2B1E35DF849155A63917B2F4FC61E17BFADE08D57A68E9CA319BB2EE52A510382C6726B085A436C133BF64FD6DC532B50B318749DF71F551CEBA83BB5388669E141FBA2E17ECAD8128E74670B9B885B4560576B8442557E6963D9C33265EA97A301EB5F27A89BB82EACB6F37578C8F6BEEA91AFC0396BDCA1234B8D26E974D971F9EFC4924735E71027A4F01F06A1A4E100BCA73F6C9182C68D965D9FABDFC39CD5FA172DBA077B81D11C61BC326A4780DB3906AD11BF6C110D7E99B2C7C82C896122794E22802A0759C8EED8A2904527592557D86924CF5F4849ADD41EC55ABFE5045C778190A633016FC1E10EB46ABB52A8881288019DBDAA0AEED8B33B772BA9FD8D0D5B97DFD137DFE9F6E2796A2712610F85F0F4AD7211B81F5161DE02EB66B45A68DB8D2C623E79072573AF75C96C40A6C626DDEFF456588A87FA1E4A4F055D965832C667C9272663D0F903CA9C30197FBC1D0848FD0C8D3F43465398A25A00394E3BB5D2DC0CC3CE6FDAEC81859BD0DB82B0A44F3EABD20E0592749CF5964ECD7A99667D1BAC20506C46F4DF1A92C1B7E3492EE1277AD2B4B8C17EFC5D301554AA07145753C424B191CBCA11508ADF849ED1DD1AFAE8D49EF0BA31306DC22C26584559FA176089B06429D9FC19C36EE9F1DCCE89567DAA03F13BC7DD7488EB6BC7D3D4CF74D1616D5B2388A4FCD5CAB897B5C9493DE40A3D14DECB78CDD4E3FCCEC6C1D48C06AFCB25FC6D60AACEE2CCA495A26875AA3289A850C6149C8759B8943363DF927F5E4A2E4EE3607DA29DEAE35800279D783022A66443DA40CE0A096CEB0348A9C614B4CD4FE0B5DCD8FDFC3B16D29690C693978C0DA5B7241B8A0EF4B0496B9ED8F1C5FE90FE311FBC304C1B67F5CACCFEC9B646A2119B9C1345BB70F0620D25095430E1AF955A7CEA499DA931CA69D70B0F56CD6E74F309D36583EB6B1B6949D98DD5D1CCD5CC558714BBA51B7EF19721269C69BBD6A2DF25FDB76BEAE191A5EEA91833519AFD97691294014428F79AD17EDCFCB157F2F1B1376CBA7D35782B260FCE1309C3160E235DB1BEC8540692B824A1530CB7A5BCCC2206679910F51AC16C655ABBBFBF72D1E9B46704BF13B79F05DB624049878B6A89C2C945E7E7D7B4C67DEC1BA5989396E19C944300468EEB4C5F80F8A9D14F487100544346647E7DF7675B4E0F03FE86C41C2188C00C6AEE161FAA5655CF2C11BBEB1FA41F57A31325544F7B24950AE6B5D6B7D5F30B2390A473AAF97793C236E28FE309EAA46D8BE21483E3AD1F51B10911FA28060EA1AEF50A488CE38537A947EC8A86561408A00ECDD494AA18AAFCF08E8EAF4D0A237D06392DF3446C49C6B92E0C480C424F97C13732397BB7D812FD9CE92D5BE0D7442496C895ABC9E730F7505C723B9889D9BBDA90145E5803DECEC9BD3B9D3127059037E0861C0B62515B80818F8696ECBAC8866E72F6778C052CE4911E1B32B178EFD319185352502A5D968BEA5D20B36FE7D87E5EBA06E8B95033D87C25CFE7E76AEEB03A06C49336E52879EF20DC490550C6DE031A2C57900D1FDCF6994542C775BCB6A6260426B5EB988B1196E5C93D3A61B178875D942184D63E2D8A8EDF603A00C4FA197377124F6560BE5DEC764B4D677568A58CD83AA6D0299D26662B4C46D8FE0D311694AFDA67056F983AF1AE736493A5CB1649381DF600AE23417944C508E95F9AF9AFE10D407EFEB4F630A77E4CEEAFBAE055202888F6D0F7A1E04955CA55D8E27FFB62045E96204671B104D70850138ADF0F2AD1DBCF865BA43FA360B56075FB07BFCE50697ECA0B270BF81F4285374550FEC63050E0924E5BCB7318A1474279D0575C3F956489954F7BC26E1DD217275844B7F7DA465263EF63C4F3140986E97A15F169AC9F8A08F69086A34481A210BE97222830BC8FC1B108CF2F7D7035C62F06FFCFF2D5BE7A6CE8A45A18137CBE83326349DFA5F069D5E44F6B09F6F19AFAAEC6B130355321D0F1DE311655A60073D9166F1B3074E5C82FF546079F7C4B19CABFCE13E087A9918E7A448BC899DB3A470A76321B55BA6CDAA1C7EEF4A05B3659F9A020E0577E5F587A70EAD1B079F7D44AB7FAB295136AE0AE6B5ED7021BFF55164C3281AF750EF528D72EC09B1B4600AEE1009FB05CA63C31D0655673783FA93175ED067A96C54B57AB0F4B5FACB113C1C25F31B520DB0352BD2874C056A038128E6D5C2F17C2FE12B5C08B6FF8E95A4525BD13B04227AEC20C1E4D94D80128367F3448F706397EE60F83DCDF9D1F60FABD4CC17ED6A756D764526886B90D9692A0287F69D41791F72BFA67A8FF132464A4F6927E93C86EEEAE2D1EA830AAD0772CDBE2C18405E15FCB55474595F4F4730A99319974C36E92FA037FC5676D5C733FFD9DF3962EFDD6801731F26B58E21DF276058D2E1064CACF88F081EC71670D57A29E8802E6F900165FA9E98E2E1BEA855C36CE6AB425CE75A0DA8F3F142639F0C0207733776A3944703143EEEA6B9A083F9602AB67DD8829D1FF7D103D80479398C3E9C8241A1B5EE226383C5FA0751DFABCCF5BB9C2C4B9F8AB5D82B91B7AA86D938F6F7994C4FEF1CC7E2C8780D52F82363BA828B5371823636CE9191D1B6052CFBD24CFF7442654E810E0EAF82D5584669FD48BCD682AB85F56CDCB29E702AD5914A4D66996220AB76590EFFF778A212802F01FC8C97764938E66295EEDCA88F0E052825E7D9756BFAD4534DCCE46B5801CA8E47FF39DBB96F353F0FCD1A80CAA7DAE362D1A4DC0F7601356751E67F78F52FAF6FA75069F168F9C9C4E9EC6C2F3CA4344C5C6087B0393697692A43B339FA29FB3A4ABC6FDC263FC3585516450E6A5FAB04207AA2F069FA2B162D90302C521EDB2FFAD78FE8A855C6FE51F1AA654CC5F95B700557D659F611D9A51731EC3D154A007C92D364BB1B097850FBE67AD3D12E5F7D6E419C1E58C1CE3B4A04B2CD16F9386C7E367A2476CAB1A1762E1BC44C24A9CAFE03374EB77EB30CF8DB85CDABEE7E17ABC7F87AF85D80A690549D0BCEC616D0D25DBB9511E43477B17282F77042F61339E98B63F47B27BA994832EBF6647E7AD2F610A102B800362AEDF61F171AEFC24093704C41E9C6E2FFBD4E111B5E64A7929A12600436A7AA36CC4CBA5D2677E85A4D4A5B0C1014E55614D7A963360377A853468F024A108AEF7C5D56CE1DF6D767B2481ED60CFBD82915AA14C1962793231BD754FDDF9AA26C206807E93EFA012998408AC9269280A8446E9DEC7CAB57844695C81E2070A83C1145698DA31D98B297916CEEABD9B8E4F6756E87D6B4B28AF5AB07D7AC98BB052E35A3DF77761DB2F674A12E354C2F4D6C75B7DB75D771B524E003C1D08E2638C0A23ADA272459AD50E35E4869D66AF96CD766D3D17BA86910CB04D1246E9655BC0B05A0459C25D24888561D41828029B1282F67E3E343C54280774CF7A236A7019FCBEA001B219C3E49B61540EAEA8718FB745B1698F488F505BB6738631CFF9E97082B0A9824258446FFD86B39CBFEE7AFB014A2D53F09CAD5832441A5E23E22224E0CE8D137C810163055A2BF5E782AFD0D1BA13F22ECA3F1FC4261353CB49CA298C9B2F5FBF5CB5253C5C1E3FBC717E45A7D5A7FE0BBEC0001E4C6031B63DCF2399D87765D847B679B82FA0FEDA5D6C3457C9818A6D53F20400F7A775C66D44ED4AF89D18B5D61F29601551FDC2C107C5C236AEFB2B0A1C26E13D3BE771168F0A2D73BFE2132E7B06C4BC84898AE3413CEF189C457762510ADAA03730DCD3E5F49EDCE1040DF6DE5E8C166D8C04E6D7286E18CB571B1DD70E77CDD8F17CF71D32389960521BAF55BA7FA7634E70C8C8A3A1B427FA162E9DFF3EFCA353B15DF5EF64DE54DD9A88DC9602D175A91D15FB2B118A4F62E682108D66FADAE835589BF54080647BF3EA3DF1171E7C26ABF4FA19E4E8BC4D43367FC95A48B7C879F3A48F0821AE172FE003DDD792A9564B6AD62EC354DBE9E79426EE97845C07B81593C064B7817213CD6EC0C293E17A25075DA6406FEE0DB4194689A3C1D49EA0D661C91CCE6D9901168EB1629FF32E2DDAA06C22FCDE19EEA09ED2508298A27ED150C5B21F44C57370932E89CCBE42EB971C3C64436FF1AC23E86193D1199435087E10E2DEB54A1714BF92FE8A4DC70222A36A26CDAAFCE2439477596BDA230381A8C783C0758F01430A1F305245309B31CD7DF41D25DDD001D1586DC68D1123FFE533CAE8F8CFA0A7875CAB7AFEC3ABF23DE67D0E12E8C563A08C901636989FA59A3F15E132D9183A7C1705EB41709E617E945F2CC6BE2EFB150DB2110A1CBE9D37ECFB9D251A968D0333BC41E3DA6162AD9A32E525D78285CC4AFBD9661B7E3858F9C5A2E34C0BA18974F44943FB4610D7283C884517970D9FEED930BC1001F78CF03D39FB489ADA22780CBCE51264A58BB7F978130B289633C0EB7E163E198631D96BB8A0C1D8C0904F937DADCACE7B5CFF6ED5A643D0F8B8DE0BD4093B29C5F5BA87A39DC1A4EA9D9FBBE403E1743F94F4A94FF41F40C98D098A45BC76605C33A75F21FA6370063F62E4E70D5E023323B84A69875D6D44DC82171DD7D44D8286C942061497E7EF6E30AD51541D5BA417522A09F8E72575AD63B9E242DE46ECB4490468F219954DB23350BCD31AB8967469FC2EC101DB8B22442FA9D5AA12CEFD707C1CA3C00E0380EB1BC47257B9DD1D9F9C65AD446D3065B829002D1628DE07D3149CE7C62610CF99632E4231435B444CB00E882A92021D53E2D9D0DD9CE4195E05B5B30E19CD9E14803F467A84488209EDC9FA322C0D88C7AB0193C4255FC8B9A8C679C5552206BA40B4281AD9B855769E063D659DB2247F8B08302077DED8B85A2032E9CF10001B2F97F4508D13CFEB221BA2FE1812D9EBB048E5654D36424504B53EA9A387923104557877ADD4C8706D8D56CA23DD7D88C9D66151510460980FA22545843D6888E5C6DB85AB93C211AA4669BDCE51E729FAC2D70C0077F7DFDB141B6FF662B6D73B252C0B07684BA0E271D948E44BBC2B121BA84B14A3AE01D1D2FDE734A483739F5E098A7CF945A30DEBAFBE79C9B2D90B401489D6462534AF99045D0B498C92205312A724B77B36958E8149D85D9AE6200930C146B3C6A1F52E41E83FEB218F25880C14BFE2D23C116B3DACF82A52F18134383CD8B22A2C67D289F6F38C91D33B79643B4F2C2A6846098360E03E748F253574C1BE5D0899C35B30DA4B183594CC1DDB7CA97826F605F699D15BED8798ACD51F29215DE106F61DB37612205EDFDADF4E67C72154346E961FAF63FEA786D152FAA9F810741A75A29DFDBC959C15960DDFF36458EBA78F1749956866B9841B701BBE45F4EDBAC2B2C0B2C8D35BA83B88062D82B2F6ED0130AEE5CB36CD466566D1184DD79DAC2B52A66B45FCD82DFD04DC35AD1EFAEC985985D3A1090D792E06AFA10158BD17BDB33C7DAF9F4687144FFED8BFEB4D0507D270FAEF4B5F67D055FA8C83FC7DEBED9C10FA23F2CF0954752EF070EDCF1893239D7F44AAA3CEAD60706E989B0C33406FC68F03D0389551B595931A0CC840B49317803FCE5BA41B14DA6C9820BEEA08390D493E83ABAAA3CD3DA04ECEE377CD088F5785047C4DB8F502AF8AEC629F55E451FD74955943EA9C84AC0C04A92DC45548FAB014DE5A3681EE87D79647387949A4E7ECA7DD16034F6C535EA2CF977CEA35D214DBE90ADC3EA551AB5C9356FFE35EDBAC26080A276DD6A91FAA98DBD389D46AED372BD825410DF4B20473D9E88C0DF78EA3115145230940B41E5BDA2357562F267BD2FDDAED8EBD774D2D30AE8AB77B84CC3339A90AE6C03506B5B40E8541DF352264900782B3B1DCCA5C2BE33E4769C26A6F75369B419B1BEA709EAF6B87D379007EE5F479D5E43169C4FA95F2AAA595551F8658BAEFB4186919DD66E52BA1B4F22E8DE3DCCED1F0B820164F59F425B7E783CB1D3CC5979E52C2C35BC6AC518014448A28528D19203CC32E427E16DB2C65A40346BBC6098C46E070F5FF0EB3E662946635109B6BFACA86E33651EE7ED3C8B25A8A82C4248A79AAB3BE87E3A710097020ECEA93DEC02E960AD05083270AAEF8D9962ECD66938150D8FF5B8A90C55733B978E91DCC92587947F957A5DB529A1F4918A90E43C2F91A0AB7363739669F52762BD5C129E80182A462805FAD8C080F2694F12017DD6F9F3A0305DE14FCEBD848F521E351C0A43A38C0DBA352232D00955B24254EE847A81F3781CE224A537015E282CA9CAD5A5ABA30086F857EC6CBD13828687CF1BADBBFCE90BC1B6E7A4130511228FEFE38CDB39126F9B40766AFE3AD3CAC9B83D1380B71B8C57B1DFBE139CC66FC1EAA790DD4B3FC4E29C65D78940BDA174FA40DA74D20C367FC0D81BFDF50B0018FFAABBDC47C40992B1E58DEE9B4D2FCCDDB31E9CDE6E6BA683D8A155D176C8295373D66F8A7E2819DDB9E33EB3BA58622DEC73BE35548BD619455A70DEE74B952440A8F4B05CB9517253F16A4584ECDD487F3C1D0BED6AFC6787CB43CF9A6DCF2329C3A097A0E269097FAB9F51F35DE589290A4BB66FBEE7E1409492C6C3D01DF3435EA369750753CBF28CCAD44B3DFC1A9106A0B7601281CC2C169FF3AD5C95497FEA8EF0777690CAC2ABC8F18B14F7E0884022591A9CDDD24E1BE006D11676BB7D55E8421D855AB45FBA543EE4D0E80D1C71092417139F672DAC75D22BF08417E9ADC17421135192643A6CB9040A7EC4EE0CF6562D60683FC90A556E18BFEECC7459486395D61A12C7378480526971821A8D9119BCF9703210564A3B2519CAE9BABE23768D99527F26B24F9E92799614457B87E2A8A98B97CFD6FCE75640C517D517F9E87DB7FEA2703AC3479140090C3EA07BEB309F00B4A7A12D8B3BC2BAE9FAE0DE9C85D4B5C166B881A95D3239FD6237A91129BFF8B4B37FBC3279655AF1E4207ACA3D6B44E8B1A5AA2853B43464D4A7F096B49E0974AB1C07CABC666611E0D55D92960DA453CD5EAF3233A3D0BB497999E0763BC742B210D7E2BE114661D8DECC236F7EDD6D8767D17BE0BC8583FEC6DB02C83FEFADF9CD10747B2CBA9FD990EFB826CE81257C621F65E8C00FC385530E79B11FF2C796F2F2F1A45AD0A7CCBA3CF0800AD60D3F8D22BB06869FEBBFB4CF4BD3865A158170C3FCDBC1B39F1D26EB88ACCE78549EE2FF0B3574375AEFCDB257F9EECDB743E8BFF85F75EF3F99582F3EE08FB9710CC839A13E9DFE40682271CA004CF74D65CB186540841DD8833EA933B5A07D6198B3A4F13B32835B4DFF7D7C4D737D438CE4DF5DF05125B0B974D3C2F94B40E59FBF3E7E908431442908B66635D74D5700A37FF5861C20D63234756C77AD640466B2539ACA7EE60CDA667A102858E52FE14B6F5D50A798F35A09FD76900CAAA319DEBE1B062EA27000D09C1F107ADF2FAB057821517DE324CE5AC96DEFE7DC77858A8B078791345A6DC1DA34CB674D2476ED5D6D832F2EA4E646AC3B890F32DB0468865D9E561D0973FC517F22CA6A7B95537D21C2E1DF0CE82A5EA59AA756BE40FDFE36E2E377F40E204E623B16CF45EB47E3E0CE72D8039E6940164B2C29C15F8D95F10F56C378334C949AE47E752840A9D1C469B54CD6EE0E8CA55BAB41A3BB33E1B13F0FEEBC0C4C951B49C6112B0E9CC18CCFE5F5403ED500FE12CFC5C968DD61F6A983C50136A0A95FF68BABEF0C9F752074A9801D298B340410255CB6AC8BA7F4B61DCA83BD353650021FCB73D911246F8671550FD21813740782376DF0AC7EC1FF8500300EFB92CAB853353DFF3C8747924D622B4DA67AB64ED97F4FFFEFA3375CCBB06059B6BDE89CA3B54CCE624E86D2375C94E4DB8DB0E659E7CCE42F6D6E9F03A04DC3597EEFE24706DB56601036A5637F6D5D433BFD1974BAD7A6A02FA37E0CACDE99F3E951A4BAD81FD9A624A0318E6C13D3EB7A4CE23941ADAB22A9BA67DF817A0041C412775258D8901E375B2165FA4F5A96830087AD205E0661A3FC92683E100245062CDDC7AA56EB01FA0297470E4E1F3B23A5F084C0066EA2D922A944DA8A21CE +Salt = A330B41A8B7D3C738447B48E00DF834C416CF25FDEA576BA476845E7CA6F49AE919827919B61A81504CF2937C1B50A1E0973B42338B267CAC14F7B33934042AD +FixedInfo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utput = 05ABF54CCC412F341628402F55A5E07E897CEE3B99B959988B2A2E3BA66E47F98D7CFFC38203E2B66482A6091AC5524CB9FDADB182A7F1300E00003A32BDCD55E8959F94F3A999CAE63AC15CA6F8338361520F115F545FC554CC17BF27C6DD54B1D6117F2D800D3D27C4661B4D152E44DD7BDF116BFF2879C1BA7C35D863962B + +# Group 81 - Test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alt = +FixedInfo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utput = 0D0B1B42D7256ED6FF93BCC89F23F77856B8A9F352ADA31FE0F34A06AA81E1EF0CE5D210AF71F7796ADD8DB3AC114FA87CA444577837A0A8848111FB6FEA7CE1C693B7F2BE9CA599D312A15E6D0D13CAEAA5342532A554104AE96E420C0A91FB7DD4FA25892EA162F95F3FAB09BC078823DE44E9BD7B04D6E9772657F762D968 + +# Group 82 - Test 407 +[SHA-512] +Z = B101B69CB561D2E5D29E67674B8B1E8D58E5B1E143928DC11EED867001527B5780657509B72E1702D7E216F90227A03633FF0C69D9AAF5270A6ECACD64A9C7E8986A8EEBC2518C654F8B8B38BA972FE9BBEA1AC93B13C20F51385B4493678E621AD09132105B204DC9477D9BB9466065B25D34F20BE2B9299C9E47 +Salt = +FixedInfo = E39F56ACCD26447E1AFDE246F0DC26AB51F69F836C4108B2B0C2FEB9EE81298F8B0A8237259E1C7FDCF0191AE9EA2AD500000400 +Output = EAF5C5BC4A7771B0361F62D418A0F8D0415C66B60702C95C3A6B6F6C2302AFD3654CA7D7C2BC409E41296A9F4F235D2315C70DA131A0B7ADCD40B4FA20064D4FF2E8AB47DD8B0D9A4B7BCBFE0FC49E697F8262E4BECC4F71E1281E5F3863AD13F30FEDF006E30E37D45BFBCDB730A63883728EE15DF63884EB2B6B00081146DA + +# Group 83 - Test 412 +[SHA-512] +Z = 9AB3AE9941D27371DEFF2E2D063435D8FA8ED5C8DCDDEC9F656CAD08831102C7D0C74ECD924F177A61A7E342986950831E39F5CE1CCBE5E88141E9594CD419C242C69756B75411EF5CF294C2C56DE04FC5FADD9DD4448D671D0521A43F746CF569 +Salt = +FixedInfo = A9AF78B9157DFBD6C912AA3303EDA2E5A499CA0656F804E3D515B5E3CC55FB1E38F0CC2ADB9411330298A3C01997BA5555D819D8CD6158ABFF010CAF484CC639557159DEBFC5A45C05F3090E9B158B2CF169659F7E66F8C27360C31CFC8871ADBA6A5A5863799EBA77973EC624CC0BC21E0837B9F980A3B0C9BC585D801BF444B92DDAA7D8A93529225E202216C27FCCBE00000400 +Output = 219BCE917DD2CDD07EF9B28D5047441AC534E8219BA6FACDA17489951F0A4734040A99A7087AEFEA272FAFC4C5B34E58107DD08A95E477A640CB6F08D09912AC8E546A4E260568321A9C8ECECACC759A64CFF52519FB41A019F3A006C6320770E33E04D1AFCFD14B80805361A27C22B2BDF7CA3F747DFACAED81A7025DA3D56D + +# Group 84 - Test 416 +[SHA-512] +Z = 1F8775E1BEFA9ADD5095AB8DC3E17728666979FA0C0594A4043012856BFDD1C1BCF8BEC96676F04BD815F82A3F1A6909458CCD428BD393DD51DB58AE4572F248C0EAA72CEBBCB433AC05CDA0E3E5805CDF57F85E4591AB6424A9861AAA9C50A6B5DC10BF7748613DEB13D43738B887D7F6024B9619A824D1A91F744CFA9F47803C06586ABD765F2BED11076A62558499F580BAF11D8DAD0E46CE36D6734F4EF27D378DBC527D57B1F46923C6B76B9FE0F6E89B4892C4B7C9C3AAE81528539410D7BED502367A8191C84CB6D55670B92EE45E2A076025B15239C337D30E20FDAA3F7A36709A833F21F0FB6E4316F18DFA7EF63625FED38B0E2F6F86759B718D3790CDC7E46B37251A8429DBEB34E1C2BF +Salt = +FixedInfo = 38D2459C588E77065EA2A8BF9EC34ACBD1DE08F2969A1638F7BF20D071C9179B66C93B301C6612623F8D6AAE9CB4CFFD403A79362EB9B625F254FE0184B00074DD2A5759E895D2DAF6225238BD730D6FC56FDFA562D65FBE2223C5EE41098592C52822A924956C1FDFDC0C8D77D948B8433F0B0942C69D00D37CEE55B5B2B702AFC911062B50AFD178216BFFD6323A11787BA1F80C355BD72E4EF9D466E5414BDCE2BFB2EBC133E437173E9E9DCB4ECD50553AF6FE93E56F7CFDC85F34E7E8B6BF09CB25FF8B66B3729F8BF2A4D7D4F7AD2EBB4F9C0154A708BF3D5275A684C309E37671C3FCFB0BA4D6F8533BED2FB94F3D05B8AAF29A367B8F21FB960B896AF2C6E0D4912334B3E766423637D03629BBD45DFE10768AEAB70795F8AFE271E60C2F237217EB8EAD3C162F35DC513D1061C0F498819881B871C4EB2FA4EDF835139A250137F4F2BB5B2CCCA44D43F568824BA70977C05528653AA1B82AFC033BD93FA02F53B49F6090A803A0B6EAEABC9DBE04C340C8E9B3C978B6D65582635ECD838E38009227860EE7D161741EA11C11F63B8E5BD0BF6877A0C17B3BAE48610977BF5806FCB3D84D5F94FF3061548AF3F2859DE46DD68CDC9534B46A75E6A3E701C2C8A9950E969420FC315D9BFDAC552CF022523063CB4068ED159348F84990F29B2D0DA9B7E314D7CD483916F5C9AAC7FC62BF7795832FD0726079236E626835485265A874518FAF99E7B3929CB3C9663801AA607FD84401D582FB4693AEBF81DAD5C9BE30E3C9A7C33E50DA8405526EA60CD12DE3420A1211968B3DF952EDE9C23797EE2170730A2E8DA38AEB5500000400 +Output = 7980F8AE72E1F269EA918B383D60E90FFE1C19EEE98914748C47948346046C3432F217CCE2CF1B21CE541FFDAC486B03E1258BBFB261E8C351EA1D772FB8944405977C89723A6F69C11A704AE476CD32E2F9D1AD7A51C74757694E8CD958DC6F71681E2ADCEF0367764CC35125A2567F7378A5C4AB8A37156AE58341B335369A + +# Group 85 - Test 422 +[SHA-512] +Z = D355449432FD6676EC29719E7064C00C9CF1AE9C5714101839706225 +Salt = +FixedInfo = 7B63E969ECEF758B7AD04BCD3E6918011FA21103F006626B1A68B4387E676D8FBAD3A53E65BF0476BFF84E7F11CB6D3400000400 +Output = 5C3A5CC8D0B756F99259FC71D88C660465CDE5DBB729C8CA5BEC864993131D2D7E216D11B9D27D888D457B3BA4377C81FDA95F2380136C9F1091CC876FA113C53463E0AD02B86C505A318D6C38504E0A060AD70E9D9A883F5B2BCEDAC0AC48696696EA182C6F4E9E36326773E226C736D38DEC125B891A50D8AEDC008FA5C7B2 + +# Group 86 - Test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alt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo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utput = 461678646090A291A2A4DDE5D42B15E8DC1C1BD07B0B85D5DF3408418716BA0224BD20E4C8B7ED91F0E0EEC05DC4572EE792FB92A38306DB8781B640A1C9F79C1996E23D8040C1CA78B04601F6F390BBB1B497391DE0F5CC4206C0B1506ADBCCE2872A20596B190077251EB7C36CC226AB3469C79D0CDA7F3FBA5F72CAC5FEBE + +# Group 87 - Test 431 +[HMAC(SHA-512)] +Z = FFD84FF5AC5D2662B979D61D3BDB644C839FB329C1D2E306AF0B39C1FC084D33E17B7C299C0BB632EC3D +Salt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 8D4C8211D42BDBFE9AF3BA5EBB7C01EC7EC27CBA687B62C8F1190192A5877C3F0BB6B95EDC9B9A4FD45CC43FA1C44F8700000400 +Output = 2F5F9BC18CD76AB10DE6F625FF98F47928FFDE11CEF71910278426FCA26E7F42AD72644DFFE466CA4250C3F14DD92A32165F7331F71C052695821DC6A3896F51DCE83D207D2F4BAC2DECFF45233B5C5B7417B5B74736D461914A2A4E1E237AC8CE060E6AC402E99FC9556502091C1FFDB22D3D9F9E339C3511E01E009FD7A7B0 + +# Group 88 - Test 436 +[HMAC(SHA-512)] +Z = 1E61023E00A7E8F993CC2752533DD42C0F045DAF883AE14B737B8F9D6D5D2CBCF1C74854B83891AF75C4094AE3BFEFC7F7D38916C4C19A66B5BB7792575DBE9C170B124204CB00981B217023A19706EB0DE7FA2BFA44C803094D20B9D1ACD1E6E7AAE2EAABFDAEF2FF835A8CC4A4B3D575493F2843A647F9F6BD40B3BD001C76AE35C7556D7B354D0F3ED1413DBEC14900DDB9EE237F1BAF005066E04ABE30D1C5984B86EEB4B32F3762A85F5548495C9E8A71EED1E20EF9BBB60921AA6CAFB89D2789871B5FD472CC8BD03279D7660971114DF976CEF94F2067E5C3267FBA07942237BB51BB6EEB84E7 +Salt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = BCCA312F60A1792FA1657444DAD4E3DB52C53CCF68984B73375A662CEA07D0D3E7A964712BDEA2A15EA9DA6877E7EDD8FA447C70F85A02856937D6C1A13D6A6E3E65633E98E155B1AB64520C7805E1BCF2CD27673616634AE7FC5281904D05B1B5536D58A3E0A522ABB3875CA5EA81BCB8670EA7EE20C1ABBE061E3E03016532C0F8F6FAC2992301741687F8C22151063A5682F57FC6A9AC4D30F1C7E21A3833AB497EF7F0BC123A5C8E6D98CC0FDCB0CE01583B34107B3EEFE7B6D5D48090E2AE54079ED21F079392B706FB0598930405C64772FCE687B3E85016F84FA5F2628A73306014E17615735522BCC3648F06DF057AC6E21A55DFB41B8048347BE8B474CA5F949F730A7F8C29343A6BF70AF39CAAE5312CEAFCC8D8FD00000400 +Output = CA8C5568D866C5797CBADDBAC1995A5CC59EDA1F361372B527E761ECC85C043389014FF4DF2906343AB7D577B9AE72C06224B0556D157D7E4AB11D159111ED180597931D9D49607230D7EB345D597414C6A945E96A154E116CE8DDA7CA0DF7166CA34650EB14F464C845F7A2739CB8E32B899E070F7BE676CF8F980BE1D68123 + +# Group 89 - Test 441 +[HMAC(SHA-512)] +Z = 247689A2726AC1D49B994EC18976937E5F98E9F044D0A38296C39EA9 +Salt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 6F385CD8698E5C2E7BBF1559A20643746FB2C173D0B76077ABFA4F991F8EA5D9966011CA992EC5795B4A6BAC2DF8F35034E79A9DC389A804E69AFD60B5FC5B04FCD43DDB8C42F5FA0F1227C800000400 +Output = DCC508B8FEB684C48A4672D68E2F1FAA8C3647B36E45A23FBCC1902F90A8EB6D89DC40BE67BB24F45C7D155570CBE8FD201074FEB9F0F23BEF9976CF5DB533632F9F7B99A1C17674176F1F8E1C0CBE11374DFAD411E32A77E09A1EC60D6BDD5BAD950F89A601F049AE345B36DF254BFCF2E78CA31F28899BE4A9CBE35ED7851F + +# Group 90 - Test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alt = 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo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utput = ACEF20C5070595AE88EC57ACFACA5066988E149B46466C46E8CD26A693E3AB8CF6B0CEB73469D9B86DE7FF7FE71BA595D8E8521FEC16D83A9A0BD74536D9E65D13D49F68F690FDB40E646426E1921B9DD6C499EE2087A72B26157154320D7B9226D527E8F0F30D1B81654354696CBB713614C20D2575D692BA0B0A1E8FA80EAB + +# Group 91 - Test 451 +[HMAC(SHA-512)] +Z = BE96EA918CFBB670AA89B1FA7F9D6575B15A4FEAEB9B4C4CCA9CB05F758B5AEC7696747170DD14042EED8B7E1EED3C142D382E58CFD95632075A6FA0FFE55E3608D0E8BCB193AEE0B21EC341CD54A63A3CB044D3C262BC5E5325041EBEC623F12F59D2C42879C5720CF1BB8B37A9580C782E6723D78D8FDB9410367705BAD26DAAFAEB25611F68A3D31C61523E516E899D0AD99034CDEC1A7F34E3901D998E6D43F9DDA632F51752BF9BF0C3A80F0F78A153109428156787A11E1B7871273FC4E009614DC910DDAE9F01A69B558D389AAC55B85D5E6E76A446A7B6 +Salt = 10A3B65465374651E1A9BCCD5AB16E039FBAAE2E572EBE2FC58D760A32EA0A09976A8E1DA3A0604983E56758DC1B45D369A061AF503E219EC059F5C580CA37480298E89F84D8A40069FE6D79CD7E89BB52F6D469320CA1800A13F547A1C948F15E34D765D698CA3E0A94BCF2BF2BB2B5A1968FC8BB967DDAFDBE384F16AF9425 +FixedInfo = F02CA47F342B51E2BF9000B0E69F3F42B54401F031D222A063CEC3A3FDE263BFF8F4B7FC31BC7C08D28475230FE7AF997390CB5D906CD40618583D4A6F8212A0995E14CD897405761082F8EAB5F60B7ADEEEC481881CB50DC2407036338C8BCB6E2B191A618D883812537945799647898F71D7FA4D81CBB379765B11AC17CA8AC87281FC809AEBB6E9110354CF2F841E521D4EFE16533DEF289AB54D43714915A74974FDB499A6DD6FED4E8B71F34D2EC49F83F62C72D33D6F369627785AA3379D74481C5D48BDD5137A70E990AD25BEC12DA8E7A9E78AEF65D245726EBA58DFD7DF3997B20E5C6C862CDDB661390FB5A805E1D03A7B16D60BFA2BABB2F28C16AEDDB23C937F416EE7825700000400 +Output = 59724A00707A50665E36A675BC382A9E19ABFCDE2909E05C7290BB8D7B71C79607144B7E5F58FF03440B16373FC5CFBF3DD48B7CE8CADD131D9395FF62064F36C87FE307B18CEEE9D69C656E81DC4E3500949795DBC7C9256B80CD5EA448FA4C94786DB1ABF547C71317C2621301C4F9E7BA7636C9CB1498C86D44C831F7FD23 + +# Group 92 - Test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alt = 447C2CC9B92F542A6D996C165E381EAA71B9398660868B3B274B133550419E62F8CEF6898E4E45717A5E0EEFB9DB18394DC14C8AC770993A06BB18FEA1CE887B8825F276716C6CBD4300F7FAC191F73F49B404D9BD2787EB4467F5FB0C88717258CF80B01B62EE519B0AB14E5BDEA2FBB725871240E04B09D50DD860BE07C7F4 +FixedInfo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utput = FAE5DECA1D90850DAAD8641835AA98C9B63D82182D1B7EA02528392EC78EEC97CC445E0B01E343B64DFB09775C5214D100050D319547392363FB445194FA70F058E609CF792BE65E0768C7637B1A90A452ACC1A1E37127466247F4C788B59A71BD4C7595D02C03580DF2CBD8C3110E5B48D4049986F44098E1DE75092BE3B80F + +# Group 93 - Test 461 +[HMAC(SHA-512)] +Z = 74E96C89E130C8E76D2F514B85711AA969B91623749CE21E21E7BD05 +Salt = 289CEF2C9CFB0209F5D5799202F9C61A485FE672D51FD197B7701C76F3615E5AC2CBE0344999AB6CE4EFC83B51CD939113D580804180D008D038C54767E7F9BD11CA5F968ADAEFC8DF28F2A627A2D07CB7845DEC1F702522616A0E39628A95D796F0DE22494B1571C19FF067A23273DF7227D2FCBE8FAEEFEDA9E19F4BB168CF +FixedInfo = 9095D99A8242A489801C7BCE5F12CC427CDF842937293EFFB5CFF635A88AD321270D86BC4AB334108B4F5328F8B297068C3D412EBFDA507590EF4B6BB506E9B083ABE3FA211D21B3E96244F800000400 +Output = 0EA11B0D117FF0767C8FC7856A723E5244877DA82A996EA96AE46CFD7CA5E26451D09193A1CDD41BD2AA818032F275CA5D482F80EE988A53DF1CFCEC3B096EEC0E6B2A858160F7FB8ED55CE4E9B8F8F47441E27E6E9AD632806E1CB7963CD427A335D3311FD945F1FF0C2A25B94D4E6F3E1E40072A24CB0CAFC348CF0FBFBBB5 + +# Group 94 - Test 466 +[HMAC(SHA-512)] +Z = 423B5600844A7D0BFBA950045D454EE64BF5CA025C2D876614313C6D9A3016187FE1F11496FF5A2C08 +Salt = 1709FE54B1C2E80A2FA69D3159863350ED00DE77852304A7A4B51F2E5915F293FC5BE361D7541510B3F2BE34BEBD34001F6DABF2ED2964FA6AD5A8C6D29CFDEDDB5BEE8E8753BD99F2CCA0E91D6F7D4D7BF1CA5602CDEFEBEA6AB494EE08DC54DCDCA33B0AB0F2EAC3AEBFDC144E651F6A96CEAFF0D9C97F97F93F7A3D8047B2 +FixedInfo = A9B438838EE7E44AA1BB2FCB4C86E4296205BADB76ED9C90AC9D94768718D9A54B1013ADF1EF8E346CC87A83ACC5B0B4145EDEF6AFDC03EF2BDD88E3BAAD05411A4F5E219576A64C1FE8775120336367CC98B151D56EB228B700000400 +Output = 374A3D15161EF6E00AB062DA9ED12F736A7E80E179C3068EFAB55DC4433904C5C622878976D08C41E90CD966CD5B80BF7000C3FA9646B331EFF196168BD1A98FF60CB176B43049DC5201A3FD6F0980DAFDFE91037D4CF845B53D7C44E8FCD1786E50C35C73BCA49D4192AD30E1F72EF42EB1F1C0692FD9657FDE568900D7C7D5 + +# Group 95 - Test 471 +[HMAC(SHA-512)] +Z = 35C8E13B99BE70AA27ABD54E53A779D6B47A8718A22AAA20CC4559C83C70D8BB601B1475A6D98CD77D9B088B12F6EC0768B11AA460634B4A3E87142595EE462F37E7453FAEE288CF1EE87CED74E9A8E16BEFB782A00FA2A55BC3572FA8AABFF9897D74BAD757 +Salt = F61F34BBB30308A60E95B7BCD055E7CFACABA11D97A502BC8AD1EC8494827E5F9D3C449F514DBB44C2F36859EC327CAC7E1D00F31975943BBE85086F48CB9A76EFA3EF4D0266ECAD9FBB922BE0C142924034502EF96E028D8947053EFA5A00551F491B2EC5BDE1CE4CF9611C031D82C4C403C94820B9C00AD2B50BE33539A700 +FixedInfo = D79649638506960A7D70E8BA79D442954F65F9DEE0F12AA6AE9F75AACBA5032FE23E91AC9A5891492CE511C86DFBCF2500000400 +Output = CDCD87F5C0C366D79A52F8C0E7A4C63E567B564B14C4FD442C9F57D90A458AE03A8046BDB1CAA46076A1EAF689359C1E746F05F2D5F5C5EEEB426E72349167DC57B6E24BC0D6CFB9A6CD7361F5438FCE0A5DF844906548A31A6360E944373DBCF0B288922965F4CA9D3FA5B3A76F14E062D0CC35D4A80CF32428E422A3F8A265 + +# Group 96 - Test 476 +[SHA-3(512)] +Z = D35DA36C795A978547B2AF6042FEB0000FA58BA4EAE10B8A2A993C18FE2F9B0C070292D27D86734FBCB88393725BABE5DF3B374086898E653021F2ECA9543ECA4621BBEEE38F3B46E5122E78473CAB1D86E56C3CFAE22EC2F17562B9CC5862EA31CAD01E7832CB4B783122B54C7FDB92DABF450B3E7095163F3320AEDBB37807C87BF822CF86DCCBF1ABAC90F96DF611243E6C44602A6629ED9FA455FEBDF724C21B234391FFD14604A636A49982B6E4891E6BD3D83A23EBBE8922A0CDE17228504613AF517F309011447F831524B30F3F723670E5476BD5CA74C2C190E28B832A4BC94D92F556BF8F511A440FED60804AB28358649D731993A5A5A83FBFE12C888F7175A5FDC1C3CA9B0D5861FF7A6F1D0180710F14129CC16E4A54B9215B9DAA7C438A5D7D82CB23926C77393487DEF95EC99A5C8BA8CC19CFF227C9E5553713478DE9DE74CEE69BDDFDB8E02C6BB495133A0E586EE4376522FF2B631EA8214B4DA4A4E81DF2336D220840C30EEE19FB56467107A084B7EB7607D0A83B08A41DC0C6CE4666 +Salt = +FixedInfo = 0ADC8541AFDD25D0AE6CF2A7676CC2C6C317CEA288E73012A9C63D07A47A828BF2D1FB0C3DA37A83B13DD390DCA84703A2483AC24C1961618FF6C146189F9AED5A01EC30CFA5CE2B3A9A9E7A15DC441F1EC05E4FB9974CDF01CAB20BCFB51E50B8E86C20C865C30197F35998F9632C410290FB37F052D5C722B49693A6661F943398DE411E46B01AF74FA18E5E6F94975D5972EE4951E896298B677880BB503982B8078DFB899B747F4588D9E9FF538A2D164EF7A0A24C3B25D9CBB9BB2F5F80288A8DB2F9C1ADAC511291968C0E70F44523A8DF3C79C4106B014EA936EC8710DB15E759F398ADD5F58B7165B2B73C748301A643403A9510E4814BA696A337C277444EC882F3F6EB66E819D289A992B6A8E54C6EAEFF5529DE6A4DEA8413BD0F5DFA0E456EE459D06F55439563747A316CD0BA54B294BC8689BCADDCC46641A97E7D4603DBFE866239FF036B85DEE58B461151C5BD3C8DA3FEE944F44793CF73C0C87449FFC143BD9677913F38BA6FCDB1F47093D90172F2C746C41EBC1CDACA3E3B26F5AB9780B7A52AC72F2F54E9C2070011225E0EAEE6BE1FE18078E8E85DA7C094227D77F1774E8518B34D4E5DD7A7BEB4CB3C4AC8B303D47DC0C531330D5E8032B5965512E2AC54FC6AAFBAFA04D306127E16338E0B16555DDAD6FBA8D5CE3B6860D59B4BCC8747918629DE0860AF54BC6D070149C7E10850E22199293DDB2649B71BA9598F7419805FFB6F1467377E74003883FB17F384092E2BBFE607A78CF63E453FDF2354F4F103193D4BEA377BA107A1D0C9D1648FF7FACDAE84651C999C465A4CE3D88615D0025560A7EB7ED7DCAF2402A044D3508A2818663925F64663C028C9C1142BC60A42149C22EFB80F6007D37BAC805AC5101B600E9F9157E49E774F5FFBDFDEB02BD182FB09E36CEA37B7F7910A95BEB31F23A99FC457978D3D1D808EDAF0C75898DD106A337AE8B9BB2565361E95021F06294FC238768D3C3CB675F29D28109DEE16270CB4C4DD6FE5E1165293D344B30F1EB6EA8DB56FBFEAC52F11E9CE9BD277F90A6248123DBD14DD78A73678016BC85FC139FA8797F979701FF182F14C5E884DCB953F0C12D157B17124AEE82F09B7B203352C241F428E4A6F5BE3946E860226906682B91ECB94ED5D1ACA2543E8CB0200000400 +Output = 53C876F31059659198B53D5C7251531DBB7BA3E79E9BF9C887E0E2762EFA5838E8525AED45D7281E4E6613695C182DC0569010CCD644693DC304E49F9977ECBA2D8C163E7892215306B747ED8AB15DEB2253B74BD45CA0AA68B18B45A7C9BABF402DCDB4DF7DDFCFB121D2BB2871CA00AE7CCAC4268EB97EDB9CA4EBC1514707 + +# Group 97 - Test 481 +[SHA-3(512)] +Z = DA40F67550C21A259BF8407EDC7810D052B09590B416C79AD931F672 +Salt = +FixedInfo = DEA60A6F6F5F2B62FB7ED0621C8BFDAECD8BD6E6E747543DCBCD41901DC6C2EBF82A9FAD438FC292CECEC93C86A364E13458B80A112FF083B3512B2B88850C97D26827EFCB4A30F48F4EB51100000400 +Output = 0C782E1A4A7F6AC5E928FF44313745A3BEC77D07E41C3A44E283E46B64E617F4F1F12ECB0FD50D13037486E0DFF46870B3837201BCFD3F2691DEA7A23D0F4C63C2CAA5BC4CBF1913744E005FA57980273A1871305A89609092C895DA6BA6D06F07319686C42B12353EF9075BF6E7D7B7EFCAD4EA634644BDCBB83A3BBFF69722 + +# Group 98 - Test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alt = +FixedInfo = 00E29B69909193F9916628DF5322EF5479326D31CDF502239CB7634388F64B01D88EBF47B75D3B44313AF29DCC8303BF00000400 +Output = 4A73102C27CD2ACFF328F6807643C8ACDC461992A430757E4A37852910F5AF7E0911A7C2259DF6849B9C42E1D3252EFCB3ED6FFC28386C546824F1C8CD4A0C45CBA36AF20E22A757FC656830D08A1B235D75DFCF1C34FC80B182B30CC3CD90904B18D1D9C7C8EA7153E7AF21F73E1990D15AB548189F3734208C8FCC77A1C21D + +# Group 99 - Test 491 +[SHA-3(512)] +Z = 2EBF14B02DA941353CD7B17200C438119134466A69D534465161D3FB02743A99EE6123BDC4B8657941F2D35C55AB52FA1E703A13197C4D527DD969932383280F33071E53BE5782CB4760E7B727B11FBAF4F67E2A846EA10CB4E2154784ADD929A9FA0D756646F09D9ABF82BB8901349220ED40FCACD10A41 +Salt = +FixedInfo = 7D8499AFF51C8BC91B71B95B4340A73433D688FE280F5AF026236EC5D8808EEC7D11B78005FC20C30D1EF041311A7F7A0DA385491A8294C253AF3C0DCB522D26086FA1E7FBC45E53A0AB013DE52CC9F0D739D01637B34F1EF9B345634FC16F0F5CD56DFA0B57B3DDBABCFD69A18D7599128CCF3B6189FC766AAD3EAFA218109D15A3CB5BC5DC7DA67431A03329B9CC3762E77B605F84B327CE56917EA822D81AB4C96D7EE910AADF00000400 +Output = 9E471725BA6A1227FF680FC0AD0964DC05DBFE658F5EB9C1309C5C7475B4E79F468092EF968520234874D3AEE129181E3B388017B293EFA52EA65BCB2D90258853B909B23A997FD4DE3DD568407D44017A486B971DE83C1DD847EA972448BE495BB04F22F09ADB0F413CA6568B7A501EA5B4E5ED89803D7F9033B70D7416A9D1 + +# Group 100 - Test 496 +[SHA-3(512)] +Z = 78BC8FC4C7EFB606E9C45F42F55FA6925DC7A417883B19A5E96AD24FA223A3961BD21070A01C94A724E1840720499423AA10C6329DE8C2882C2FE15C97DAE86DCB7F8B8A8250A323FA41004BC446D5CBC669298A906F15A65D92C144408FE9242C484DF5145B8CD39B57A2B28F1F1BEE7421EB80FE15B519759FE50F243E7A9DF48F6BDF3549ECB2EA279F46888A4642A1E682BB2CDDB39827833E000E76FB3B9D2B3DD562BCD4F7DD185EB2ADDD9CB3A0F485207918C83165CE9C0A40C9CB48D94D23253EE7372706FCD4F40F1866C38D7FCAD9BED588C1507BBD9AE4DBF4B10D6DCB13A029336BCD44F502DA18AD226880E5347BD8B5A460C44E7152046BFCFFAE0DBC3BCE4472B345B1747AE9859FED109E50D7F35F1A2A06E1E49CE6B17FB96FEB5FB89B3206D0BD27DAF2DFAB42A9EB580484256CEA0EC5576DD51430DB20A454252B2F8A4514237544DD6EDF8274B6F9CCC2D1240D95168F42E1462945010548D2621FF9A2B71AD6A83201019D0739B4FE5A32E06977B64424D14260EACBA845DE0BE7BB28B553FEA23B9CC4D93B61844131F5ED47E354BA1D47AEF6B6BD1144F7DA3CFE8C7AE5F44879C4BE32D38CD3C8F81EFC109F201A0A74350DAA9B7767F9CE98650E297D5F2D058D67FE5E2F535559922E240B138F404A270ADA12FAD5E0C31D6126E12C5A264307232F6065327E1020A471582A1730BF473A83A4A23529BCC86391AD6376FD03864F22434E8785ABAE7D482491A826AE0E8A572A5DAD922A677DE8EADD2C8D68C9030051C53E499E64E1513560913AB04E6EDAF0DEC60686A0E8829726E98CFFB2A8B5CC59751CE97A36F064343313E9150FD4692C +Salt = +FixedInfo = 3F107ECF59C6E228C3D555458568737A030C5948ED7B5F2A515B6EA38F06CDF05D1625A2E2999C39DF36D8DCB0CA0EBF00000400 +Output = 47D85A97270846FEAFC43506709C175D230F286EA0C5F16143964773237DC2DD1DD86C4121CDA165EB2D6B1A8735D629C4892FAEBEB8AA929998992B1A973708E7EE5EC86AD05E71E346CF65FBD5CC42481BCD06FEE7071BC28E5EB4BC5CA63EAC132272C1094A994657DADBF928BA9B56F01094B03452EE7F14468F7C9FEDBE + +# Group 101 - Test 501 +[HMAC(SHA-3(512))] +Z = 5D1A8D1C9C0EFB15683DC9E4EA33A9B69BA81392E63423BA57604BAA +Salt = 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = C91DF1914CB8A8229A658A4D5E871C1239CCA1E7EF2D2EDD573A01430BAF0254082C3AC43CAEB3B5B3C868CD7478E4C900000400 +Output = 09FF0325F1D9DC711CA852A3930308010D81A58B09EFA5698DF4F4ED69F609554A07642B827A071769B26DA22F62759946F0901C0835DD0BF142562CF88D8DED60EBFE3D209B412BA1A2BF39174F213954FF0A38F440AFD23329CA7E33EF91EEDF1397DB21223BB23DADE9C9A4EB306F5832F8B2D03C3D8572CC36E3133BDFC5 + +# Group 102 - Test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alt = 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = AA0C424A3666C99ACEF87391B909850FC848BF51FDFF4EF3D741B22F0C053F50DCC7A69C79277A071B466B5D4216083E00000400 +Output = 334F143E78B7BA0A19885CD7046C956E6580050FF54281B2237B1D7849B6C603DBAEE62FD2ADA5A357AEBC443F3178D0623D11843AE720B61D474E76E477340664ACC11A6AFE7FD72D6CF66E10A3F7EBA79DD08DAF42329E24E17DC05A81AB4E40CBBFF4B539E8723F1DC268F6DB6C78F4FF99393F8EFAF22F5917EFAF415546 + +# Group 103 - Test 511 +[HMAC(SHA-3(512))] +Z = EC591DDFA75ED25F8021198114F59F353F56941745113D0E1CDAB569F3A1739F939CF60779F40262BE9B699EDF95F42D0EFEBC30D0357DE36197D3AAC090FBEABFF9160922AE34FB86654CC2F59EA5F08475FAEE8B3398AAA619B5AEEF89C70B5D5F3D858679A308ED476369DF23FD1645C334889B5949FD7E9C83C6B72243EACE2CE5F2B5EBB3B9FD9547D430174729E06DD0327496374351F2703A32A19E341C9481274CDD8315F6A81ED29C9AEFEFD7B56756575F7E505332CF3900AA611C68E46F20071EDF47C32792F3E68A +Salt = 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 76202B71E494BD07198BB488452C2447CEA6565761D1791A78A50B1ABD31A1E0E3F03C325697942052851287016743B400000400 +Output = B83ACBF00945C424D93C28A8E696714D1A1A8C4688C6C7ED85E8A7F747302F1460780E25E7726E264CE58E1AC77EF923D97B0EE53870B2A8DF19367894ED5915915B3D79A6B560AA326EF2DAA357C39B2604F4D7A71159E379D80EC6E8B05F9311795B61AE9414F5C7E1B10C01999D23F31AEDD16B4475DC9FAEB488F2FCBC1B + +# Group 104 - Test 517 +[HMAC(SHA-3(512))] +Z = B5BF1B7B67B74A819DD574B92393F0AA6814E8ECD3846E4BAFD4BBC4F61490E4F1A204FE35310C385F7FE1009B97827332E045138BCF64B9BE +Salt = 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 51AD74EFA9017FD60F50A506238BAE274F73AB5D924FE8AEB76DEA3183A7DDC1AE30336C047A7476BA6F387F710D8AC900000400 +Output = 301763BDB48360EFC6D8D21BDFBB6E9CA212027A829F2FA36B7DA0529E90963F2FE9D54E94017EA0C0ADEFD880DF7B948B7B36D9455D6A81743DB3300249D4011C4E676698C9C966616D0177E7E43677546EC696E6ECBF2E1E44D3ABB9AC728AEF561FDF6D0A6F942F266ABAD47356EDDE0039E6F5B7500433EDB044F01D7FA5 + +# Group 105 - Test 521 +[HMAC(SHA-3(512))] +Z = 82B273643BC3A9BEAB86C90DFBFA208053CDC9562FE452102D5EAB0B04CD0E2B645927B8A65E65287B2120B338FF80DD81E414BE205C87A96A19C2A0EC24E0CB39010D7CD7A165678BEAB3B68DBD29EFFE972FE599482C72D6FF5A0BC5F0132ED7AE7062EF7F75B0C9AD06 +Salt = 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 +FixedInfo = 4DCE5DA9C4248891FF52B87AA964FCFC5F24F23C6028D2223276DF47AFF5F82DA09DC823E86246228861565D2D98250A1457AB1E9E20FCABE9ABE6597C17824B08BECD393A9A7FC6361F71C3D2864AF02BC95A28D8BEDB93651631D97E9508E7F73FBD320C864F6F8083DD79B362C11B8464EE84FE798BC5F0DABF8A09FF4A1499242693A1CF54194D59A26484CC6E25A03BD9C8A9A10C1ED35E0100000400 +Output = 60F8919647A0B4856FBAC2F0B639FF5C66E999F93530EE897D87871CF0E100FD7D8FCBD3703EAD70213500C09E99B5D79F3E25506F16B32313EE446D6E38BF0CE7BC1E6CC78D3C82E24E63C5DBBEB2068199C647DD8482FF05C09F75B9FA461F96DC2516536E26F605CADE98070835AD8B1CB0528165B5ABB5AB35A18AAFF15A + +# Group 106 - Test 527 +[HMAC(SHA-3(512))] +Z = FB8E519EFF1A7BAEC27C530AC5435AE83BE46FF7C61A4A3D30E8D77FA4C4B0FD765760124725F1E45B7E1CB0E21F8D3AC4FD0A603742E65CA198C4F1FED72DDE2D3629527E1EE54645A73AAC77EBD6F5D9D656D1A3DD33A0A9DE312C6C378B952B939CB91466101ACEAE3E6BE2903BD2C53028896C5872CAEF3EB88F39B4F484121C3CB2BE9C250260C32A15A723DE626D6BE161BB9EB268465A553A6971DDF9C4E68FC1F3A83DA791E4281FC1B8244578220017ADB86AA2DE305BFC43B7E788E2ECCECC6857846E828E1926409098A15699F1 +Salt = 50F9C0E592B3F8187717C035AB0B68AF59597BDE6A72FAD7934B1E9AF6A872BC7963F2F19246274847C2F76859226545DA87401313125443EB522BBAFB3FDA6F7F1958105043369A +FixedInfo = 6D8EF1BFB5E529BF0519DAD117F2D5D17563B80166A5EEA462455846B03ACC8EEFAC7A7EA5B82C154F15A2E3273EC39537934EE4BED437F00AA5854130FA4D5AA5EAEA9A5E240AD25069524FDB97CD8AAE970512E65DE4D947D8A2AF8B7C7FA2647E7AF5C9722D3CA63541A2AE7FC8AC5510BDAF9DB2D820DFB30D8B61B108920B00CEA344239B6C47A2C5BF7DC38D54630360930E8BA23321BE1864DF74DF6BF4BF653BD42CB0B6A4CB3A3FE5FADEF718ECFF401CFC51713CA2D0F5D9403881E2AAB95CBBA54163447D905FFCDFD6F1B3F1A517F5C116AD1B20E0158FF533342B371EBBEC92E9BD03F50133AA6C921CB85FEA846BAB7D17EB8C27056D670AC48CB7FA00000400 +Output = 02845B9C7767ED4FC99EDB1863992F205C4E9D3B118A49CE883F0B12AAE66F962FDA7D4DEB66C0047C3B8F56D854611496E4DF130D0D126BE62AD7288E0B6FE75E1C5EF012ACDC116300ADAB727CC755F9D642F79C1A17BFEAD926845B1F5C04862847DE5F24A70B8B135DBA3178E532BA4148D32C995870E5A5C91F3454CA48 + +# Group 107 - Test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alt = D1527EEE821982B39DDB775FFCB1CD58465C9982E94ED3FB648ACD3368EE1B90993227F9E99B01B6AD21068DCC8999F34F9A6D7B2F3FAAF84C678983D030D5A46843E995A51CF2B4 +FixedInfo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utput = 9BB802BBA3DA01F75F41873CE32B0D2BA6FFCD894E1A2D805C2F30682E0E761C729151C86A40DBC16B6F1A86D20E1A8E5CD640A68AAB6A2958628BFA2F20781E5E4F8B910350EC14F1EC14E751891683FCBFD6C665C087FDE319FAEFF3D722B510E3CD3EE69D84D6247650EA6446550B8A1FEEDFBDCE84102097D62023052759 + +# Group 108 - Test 536 +[HMAC(SHA-3(512))] +Z = 4EA1D4CDED9BACDD87E60B1DA4454B35308E70EB887341D4A5F519B2BBBF985F6543CABC4E77941F8DB3925AEF7EFCC1EA27EA4E5DF95A195D224482BB39901940FB9CA106355D1BDDCDE5E28D9EF6EA77D4EB4CD8D95B02E4D0F1AB9271ED72951FF9E6697495D573C328B8FB3FEA4FCED7F4A8AC263939E205159B0BD1DE0586E12177EDC5C26B7C977212 +Salt = 133D07FA6CFD7C71777353B796E6AC2BDF116DE6D53CF50339564C4B496B1C00DDD0208E30F5AD78B7B4417CE55ACD39100BD7999850E233CB38EF19763425B9EF39116420BC36B7 +FixedInfo = AA0536B86FC13C2870C27F6F250C39EFAFA12B1E191BD907A8386B2BB6FE93169F00D7077D05DE37B253489F857018467CB1FC2EC589B7830D6C565C1761378339D148FD8FBBDBA9DBEDB881C586799CD70A65E53A335F938FC366757C102E58763DBF9E0AD6B1E1973761241C464674E1D36D46BAADC0F86F52D4419C72E03D12D5C70CFA5B6F44501F92FB2BCEE6630402E85D4E402D3D49B9F9791B02002A328DF303AA4B77C930BB86E7EB0AB268CCEF439C9D13CA05D872577100000400 +Output = FC49BA9E3AA963E0B10EE3DBE3141B6B235870EA706F7D24E37C25B2B3A2A2C943FE48552F1715C36FDC13D451BC4BF240C40FA352D62C6FCB28E208BBF270EA6DB2803A4C4A6860B58377878DF3347ECB8DC8CBADF23956BC1AD91D12354D52F0BD250241A803ACD4BEFAC684518C85EABC45C93E6318A89A01261A27825CDA + +# Group 109 - Test 541 +[HMAC(SHA-3(512))] +Z = CF4A17BBFF7764F6B2DCC60C845545D7F872418A3AD9F4CA50EF63A6 +Salt = DB5526039F980F30628B921991E457FCE0C279610A290A860D7B31DF7B7A469291F6DA0AD9A6CFFEB7500002F94E056BB96F449681F59CB560FFA96F96C781628E8B68964F116C24 +FixedInfo = 59FB56A6DE6A86B6EAC8A6FCDDD41DFAD806AA7E0815728AFD644EB46009DB99A9B295EFEB41E4A2493D9314BAEA8B9200000400 +Output = F1909AA97DBA9AA087B68A6050F26391106FF570B8A3585001AE9B4FFE8EB469094F0CEA8083D74F7F17C8EC48AF9331EB953807ABC5718E7D6ECC0701D714945CEF4B75EA4B84E15456F34665C0F107AEBCD8EAD72F85FC997503F2D91387534F5D7E9671DA54877BAA1053545B9DD690802617CA87D621AC518CAC61771FA9 + +# Group 110 - Test 546 +[HMAC(SHA-3(512))] +Z = 592ED9C1049601DCE56065784D77FCA1F258662B9E5BEB1F28025412435AA76DD65756FF9B300EEB6E342A4AB296BDA0045E2A59BB03D8B02D75F213816F110FAA180F0A1700FF1DB1222F760B19951A15D68255695185E5616EFF9B4DC00D9DAB356347B1D27687 +Salt = B394AA41E93A1F2D1040D38F0DBD450E60C0DC8E87B2B15C6318B02A46A55BE8659012AE5FE5A63EFD874EFF1C71B65C60AAED0CBBDB17C5430A278F781CB45E40F000C419A5B84D +FixedInfo = CC976A9F78F4678AA72847FB049BD965844296CF5E926DBB4BF11AD0B14E2C81BC4666FDBD11667547075E09DF03FA3DD85516E6AE4EA315CEA053D59A12D54510E5240DE28C92FB24127BFFC6336B693DA67ACB485F8604D49E2AD3C73BD130A4879167E2B0AB53215F45345277B3F8731A106B437ACDA14C06BD8DDFB35A6A46CE777A2BDF844D12BE451501D20B922B0A8622A618FF1C00000400 +Output = C81A26846312F43E003C04D8982659D3CED20D44588AA2EB5A2F69D15FE62EFE72CE606B31EB0883AF1D3A3B2153E784A770BCE9724CF7B246379C9CF9856926BDAC47976769E643DC2EE0A7D1364DBFDA6F2E78A9CCEE1DC14E701AA1A5ECD8EE443DA5A050BB100FFD1906D30F376B0398B982AC84714672EA822CDF69B779 + diff --git a/src/tests/test_ounsworth.cpp b/src/tests/test_ounsworth.cpp new file mode 100644 index 00000000000..96272733213 --- /dev/null +++ b/src/tests/test_ounsworth.cpp @@ -0,0 +1,270 @@ +/* +* (C) 2024 Jack Lloyd +* 2024 Fabian Albert - Rohde & Schwarz Cybersecurity +* +* Botan is released under the Simplified BSD License (see license.txt) +*/ +#include "tests.h" +#if defined(BOTAN_HAS_OUNSWORTH) + #include "test_pubkey.h" + #include "test_rng.h" + #include + #include + +namespace Botan_Tests { + +namespace { + +std::vector get_all_sub_algo_types() { + return { + #ifdef BOTAN_HAS_KYBER + Botan::Ounsworth::Sub_Algo_Type::Kyber512_R3, + Botan::Ounsworth::Sub_Algo_Type::Kyber768_R3, + Botan::Ounsworth::Sub_Algo_Type::Kyber1024_R3, + #endif + #ifdef BOTAN_HAS_FRODOKEM_SHAKE + Botan::Ounsworth::Sub_Algo_Type::FrodoKEM640_SHAKE, + Botan::Ounsworth::Sub_Algo_Type::FrodoKEM976_SHAKE, + Botan::Ounsworth::Sub_Algo_Type::FrodoKEM1344_SHAKE, + #endif + #ifdef BOTAN_HAS_FRODOKEM_AES + Botan::Ounsworth::Sub_Algo_Type::FrodoKEM640_AES, + Botan::Ounsworth::Sub_Algo_Type::FrodoKEM976_AES, + Botan::Ounsworth::Sub_Algo_Type::FrodoKEM1344_AES, + #endif + #ifdef BOTAN_HAS_X25519 + Botan::Ounsworth::Sub_Algo_Type::X25519, + #endif + #ifdef BOTAN_HAS_X448 + Botan::Ounsworth::Sub_Algo_Type::X448, + #endif + #ifdef BOTAN_HAS_ECDH + Botan::Ounsworth::Sub_Algo_Type::ECDH_Secp192R1, + Botan::Ounsworth::Sub_Algo_Type::ECDH_Secp224R1, + Botan::Ounsworth::Sub_Algo_Type::ECDH_Secp256R1, + Botan::Ounsworth::Sub_Algo_Type::ECDH_Secp384R1, + Botan::Ounsworth::Sub_Algo_Type::ECDH_Secp521R1, + Botan::Ounsworth::Sub_Algo_Type::ECDH_Brainpool256R1, + Botan::Ounsworth::Sub_Algo_Type::ECDH_Brainpool384R1, + Botan::Ounsworth::Sub_Algo_Type::ECDH_Brainpool512R1 + #endif + }; +} + +std::vector get_sub_algo_types_subset() { + return { + #ifdef BOTAN_HAS_KYBER + Botan::Ounsworth::Sub_Algo_Type::Kyber512_R3, + #endif + #ifdef BOTAN_HAS_FRODOKEM_SHAKE + Botan::Ounsworth::Sub_Algo_Type::FrodoKEM640_SHAKE, + #endif + #ifdef BOTAN_HAS_FRODOKEM_AES + Botan::Ounsworth::Sub_Algo_Type::FrodoKEM640_AES, + #endif + #ifdef BOTAN_HAS_X25519 + Botan::Ounsworth::Sub_Algo_Type::X25519, + #endif + #ifdef BOTAN_HAS_X448 + Botan::Ounsworth::Sub_Algo_Type::X448, + #endif + #ifdef BOTAN_HAS_ECDH + Botan::Ounsworth::Sub_Algo_Type::ECDH_Secp192R1, + Botan::Ounsworth::Sub_Algo_Type::ECDH_Brainpool256R1, + #endif + }; +} + +std::vector get_tested_sub_algos() { + if(Test::run_long_tests()) { + return get_all_sub_algo_types(); + } + return get_sub_algo_types_subset(); +} + +class Ounsworth_Keygen_Tests final : public PK_Key_Generation_Test { + public: + std::vector keygen_params() const override { + return { + #if defined(BOTAN_HAS_KYBER) && defined(BOTAN_HAS_X25519) + "OunsworthKEMCombiner/Kyber-768-r3/X25519/KMAC-256", + #endif + #if defined(BOTAN_HAS_KYBER) && defined(BOTAN_HAS_X448) + "OunsworthKEMCombiner/Kyber-1024-r3/X448/KMAC-256", + #endif + #if defined(BOTAN_HAS_KYBER) && defined(BOTAN_HAS_ECDH) + "OunsworthKEMCombiner/Kyber-512-r3/ECDH-secp256r1/KMAC-128", + "OunsworthKEMCombiner/Kyber-768-r3/ECDH-secp384r1/KMAC-256", + "OunsworthKEMCombiner/Kyber-1024-r3/ECDH-secp521r1/KMAC-256", + #endif + #if defined(BOTAN_HAS_FRODOKEM_SHAKE) && defined(BOTAN_HAS_ECDH) + "OunsworthKEMCombiner/FrodoKEM-640-SHAKE/ECDH-brainpool256r1/KMAC-128", + "OunsworthKEMCombiner/FrodoKEM-976-SHAKE/ECDH-brainpool384r1/KMAC-256", + "OunsworthKEMCombiner/FrodoKEM-1344-SHAKE/ECDH-brainpool512r1/KMAC-256" + #endif + }; + } + + std::string algo_name() const override { return "OunsworthKEMCombiner"; } + + std::unique_ptr public_key_from_raw(std::string_view keygen_params, + std::string_view /*provider*/, + std::span raw_key_bits) const override { + Botan::AlgorithmIdentifier alg_id(Botan::OID::from_string(keygen_params), + Botan::AlgorithmIdentifier::USE_EMPTY_PARAM); + return std::make_unique(alg_id, raw_key_bits); + } +}; + +BOTAN_REGISTER_TEST("ounsworth", "ounsworth_keygen", Ounsworth_Keygen_Tests); + +class Ounsworth_Roundtrip_Test final : public Test { + public: + std::vector run() override { + Test::Result result("Ounsworth"); + + // Test to combine all supported algorithms + auto sub_algos = get_tested_sub_algos(); + if(sub_algos.size() < 2) { + result.test_note("Skipping Ounsworth test as there are not enough sub algorithms"); + return {result}; + } + + for(Botan::Ounsworth::Kdf kdf : {Botan::Ounsworth::Kdf::Option::SHA3_256, + Botan::Ounsworth::Kdf::Option::SHA3_512, + Botan::Ounsworth::Kdf::Option::KMAC128, + Botan::Ounsworth::Kdf::Option::KMAC256}) { + std::vector gen_infos; + gen_infos.reserve(sub_algos.size()); + for(auto sub_algo : sub_algos) { + gen_infos.push_back(Botan::Ounsworth::PrivateKeyGenerationInfo(sub_algo)); + } + auto sk = std::make_unique(Test::rng(), gen_infos, kdf); + auto pk = sk->public_key(); + + // Test keys + result.test_eq("Public key bits", pk->public_key_bits(), sk->public_key_bits()); + + auto enc = Botan::PK_KEM_Encryptor(*pk); + auto dec = Botan::PK_KEM_Decryptor(*sk, rng()); + + // Encapsulate and decapsulate + auto [ct, ss] = Botan::KEM_Encapsulation::destructure(enc.encrypt(rng(), 32)); + auto ss_dec = dec.decrypt(ct, 32); + + result.test_eq("Encaps/Decaps roundtrip", ss, ss_dec); + + // Encapsulate with secret key + { + auto enc_sk = Botan::PK_KEM_Encryptor(*sk); + auto [ct2, ss2] = Botan::KEM_Encapsulation::destructure(enc_sk.encrypt(rng(), 32)); + auto ss2_dec = dec.decrypt(ct2, 32); + result.test_eq("Encaps with secret key (shared secret)", ss2_dec, ss2); + } + { + // Encapsulate with fixedInfo (salt) + auto salt = rng().random_vec(32); + auto [ct2, ss2] = Botan::KEM_Encapsulation::destructure(enc.encrypt(rng(), 32, salt)); + auto ss2_dec = dec.decrypt(ct2, 32, salt); + result.test_eq("Encaps with salt (shared secret)", ss2_dec, ss2); + } + // General tests + { + // Serialize and deserialize custom public key + std::vector import_info; + import_info.reserve(sub_algos.size()); + for(auto sub_algo : sub_algos) { + import_info.push_back(Botan::Ounsworth::PublicKeyImportInfo(sub_algo)); + } + auto pk2 = Botan::Ounsworth_PublicKey(pk->public_key_bits(), import_info, kdf); + result.test_eq("Public key bits (imported)", pk2.public_key_bits(), pk->public_key_bits()); + } + { + // Create a private and public key by passing the key objects + std::vector> sks; + std::vector> pks; + + for(const auto& gen_info : gen_infos) { + sks.push_back(gen_info.create_private_key(rng())); + pks.push_back(sks.back()->public_key()); + } + Botan::Ounsworth_PublicKey pk2(std::move(pks), kdf); + Botan::Ounsworth_PrivateKey sk2(std::move(sks), kdf); + + // Roundtrip + auto enc2 = Botan::PK_KEM_Encryptor(pk2); + auto dec2 = Botan::PK_KEM_Decryptor(sk2, rng()); + + auto [ct2, ss2] = Botan::KEM_Encapsulation::destructure(enc2.encrypt(rng(), 32)); + auto ss2_dec = dec2.decrypt(ct2, 32); + result.test_eq("Encaps/Decaps roundtrip (from key objects)", ss2, ss2_dec); + } + if(kdf.is_mac_based()) { + // Encapsulate with context specific MAC key K + std::string big_k = "My-Ounsworth-Domain-Separator"; + auto enc_with_k = Botan::PK_KEM_Encryptor(*pk, big_k); + auto dec_with_k = Botan::PK_KEM_Decryptor(*sk, rng(), big_k); + + auto [ct2, ss2] = Botan::KEM_Encapsulation::destructure(enc_with_k.encrypt(rng(), 32)); + auto ss2_dec = dec_with_k.decrypt(ct2, 32); + result.test_eq("Encaps with K (shared secret)", ss2_dec, ss2); + } + } + return {result}; + } +}; + +BOTAN_REGISTER_TEST("ounsworth", "ounsworth_roundtrip", Ounsworth_Roundtrip_Test); + + #if defined(BOTAN_HAS_X25519) && defined(BOTAN_HAS_X448) +class Ounsworth_Kat_Test final : public Text_Based_Test { + public: + Ounsworth_Kat_Test() : Text_Based_Test("pubkey/ounsworth.vec", "sk,pk,rng_output,ct,fixed_info,K,kdf_input") {} + + Test::Result run_one_test(const std::string& /*params*/, const VarMap& vars) override { + Test::Result result("Ounsworth KEM Combiner KAT"); + + auto sk = vars.get_req_bin("sk"); + auto pk = vars.get_req_bin("pk"); + auto rng_output = vars.get_req_bin("rng_output"); + auto ct = vars.get_req_bin("ct"); + auto fixed_info = vars.get_req_bin("fixed_info"); + auto big_k = vars.get_req_str("K"); + auto kdf_input = vars.get_req_bin("kdf_input"); + + Botan::Ounsworth::Kdf kdf(Botan::Ounsworth::Kdf::Option::KMAC128); + + const size_t desired_len = 32; + + Botan::Ounsworth_PrivateKey private_key( + sk, + {Botan::Ounsworth::Sub_Algo_Type::X25519, Botan::Ounsworth::Sub_Algo_Type::X448}, + Botan::Ounsworth::Kdf::Option::KMAC128); + Fixed_Output_RNG fixed_rng(rng_output); + + Botan::PK_KEM_Encryptor enc(private_key, big_k); + auto [enc_ct, enc_ss] = Botan::KEM_Encapsulation::destructure(enc.encrypt(fixed_rng, desired_len, fixed_info)); + + result.test_eq("Encapsulated ciphertext", enc_ct, ct); + + Botan::PK_KEM_Decryptor dec(private_key, rng(), big_k); + auto dec_ss = dec.decrypt(ct, desired_len, fixed_info); + + result.test_eq("Decapsulated shared secret", dec_ss, enc_ss); + + Botan::secure_vector kdm_output(desired_len); + auto mac = Botan::MessageAuthenticationCode::create(Botan::fmt("KMAC-128({})", desired_len * 8)); + std::vector big_k_bytes(big_k.begin(), big_k.end()); + + kdf.create_kdf_instance()->derive_key(kdm_output, kdf_input, big_k_bytes, fixed_info); + result.test_eq("Compare ss to KDM output for known input", kdm_output, enc_ss); + + return result; + } +}; + +BOTAN_REGISTER_TEST("ounsworth", "ounsworth_kat", Ounsworth_Kat_Test); + #endif +} // namespace +} // namespace Botan_Tests +#endif // BOTAN_HAS_OUNSWORTH diff --git a/src/tests/test_pubkey.cpp b/src/tests/test_pubkey.cpp index cbe93447793..6dbc2e12330 100644 --- a/src/tests/test_pubkey.cpp +++ b/src/tests/test_pubkey.cpp @@ -611,7 +611,8 @@ std::vector PK_Key_Generation_Test::run() { oid.value().to_string(), key.object_identifier().to_string()); } else { - const bool exception = name == "Kyber" || name == "FrodoKEM" || name == "SPHINCS+"; + const bool exception = + name == "Kyber" || name == "FrodoKEM" || name == "SPHINCS+" || name == "OunsworthKEMCombiner"; if(!exception) { result.test_failure("Keys name " + name + " does not map to an OID");