7#include <botan/spake2p.h>
9#include <botan/exceptn.h>
10#include <botan/hash.h>
14#include <botan/mem_ops.h>
15#include <botan/pwdhash.h>
16#include <botan/internal/buffer_stuffer.h>
17#include <botan/internal/concat_util.h>
18#include <botan/internal/ct_utils.h>
19#include <botan/internal/fmt.h>
20#include <botan/internal/loadstor.h>
21#include <botan/internal/mem_utils.h>
27std::array<uint8_t, 8> le64_length(std::span<const uint8_t> data) {
28 return store_le(
static_cast<uint64_t
>(data.size()));
32 std::string_view password,
33 std::span<const uint8_t> prover_id,
34 std::span<const uint8_t> verifier_id,
35 std::span<const uint8_t> salt) {
48 const auto append_with_le64_length = [&](std::span<const uint8_t> data) {
49 stuffer.
append(le64_length(data));
54 append_with_le64_length(prover_id);
55 append_with_le64_length(verifier_id);
76 pwhash->hash(w0s_w1s, pbkdf_input_sv, salt);
81 return {std::move(w0), std::move(w1)};
86 std::vector<uint8_t> confirm_p;
87 std::vector<uint8_t> confirm_v;
91 std::span<const uint8_t> context,
92 std::span<const uint8_t> prover_id,
93 std::span<const uint8_t> verifier_id,
94 std::span<const uint8_t> share_p,
95 std::span<const uint8_t> share_v,
101 const auto hash_with_le64_length = [&](std::span<const uint8_t> data) {
102 hash->update(le64_length(data));
120 hash_with_le64_length(context);
121 hash_with_le64_length(prover_id);
122 hash_with_le64_length(verifier_id);
125 hash_with_le64_length(share_p);
126 hash_with_le64_length(share_v);
131 const auto k_main = hash->final();
146 const size_t mac_key_len = hash->output_length();
147 const auto confirm_keys = kdf->derive_key<
secure_vector<uint8_t>>(2 * mac_key_len, k_main,
"",
"ConfirmationKeys");
150 keys.shared_key = kdf->derive_key<
secure_vector<uint8_t>>(hash->output_length(), k_main,
"",
"SharedKey");
152 mac->set_key(std::span{confirm_keys}.first(mac_key_len));
153 mac->update(share_v);
154 keys.confirm_p = mac->final_stdvec();
156 mac->set_key(std::span{confirm_keys}.last(mac_key_len));
157 mac->update(share_p);
158 keys.confirm_v = mac->final_stdvec();
163std::tuple<EC_Group, EC_AffinePoint, EC_AffinePoint> spake2p_group_params(std::string_view group_name,
164 std::string_view m_hex,
165 std::string_view n_hex) {
169 return {std::move(group), std::move(m), std::move(n)};
174constexpr std::string_view SPAKE2P_P256_M =
"02886e2f97ace46e55ba9dd7242579f2993b64e16ef3dcab95afd497333d8fa12f";
176constexpr std::string_view SPAKE2P_P256_N =
"03d8bbd6c639c62937b04d997f38c3770719c629d7014d49a24b4f98baa1292b49";
178constexpr std::string_view SPAKE2P_P384_M =
179 "030ff0895ae5ebf6187080a82d82b42e2765e3b2f8749c7e05eba366434b363d3dc36f15314739074d2eb8613fceec2853";
181constexpr std::string_view SPAKE2P_P384_N =
182 "02c72cf2e390853a1c1c4ad816a62fd15824f56078918f43f922ca21518f9c543bb252c5490214cf9aa3f0baab4b665c10";
184constexpr std::string_view SPAKE2P_P521_M =
185 "02003f06f38131b2ba2600791e82488e8d20ab889af753a41806c5db18d37d85608cfae06b82e4a72cd744c719193562a653ea1f119ee"
186 "f9356907edc9b56979962d7aa";
188constexpr std::string_view SPAKE2P_P521_N =
189 "0200c7924b9ec017f3094562894336a53c50167ba8c5963876880542bc669e494b2532d76c5b53dfb349fdf69154b9e0048c58a42e8ed"
190 "04cef052a3bc349d95575cd25";
195 m_group(std::move(group)), m_spake2p_m(std::move(m)), m_spake2p_n(std::move(n)), m_hash_fn(hash_fn) {}
198 auto [
group, m, n] = spake2p_group_params(
"secp256r1", SPAKE2P_P256_M, SPAKE2P_P256_N);
199 return SystemParameters(std::move(
group), std::move(m), std::move(n),
"SHA-256");
203 auto [
group, m, n] = spake2p_group_params(
"secp256r1", SPAKE2P_P256_M, SPAKE2P_P256_N);
204 return SystemParameters(std::move(
group), std::move(m), std::move(n),
"SHA-512");
208 auto [
group, m, n] = spake2p_group_params(
"secp384r1", SPAKE2P_P384_M, SPAKE2P_P384_N);
209 return SystemParameters(std::move(
group), std::move(m), std::move(n),
"SHA-256");
213 auto [
group, m, n] = spake2p_group_params(
"secp384r1", SPAKE2P_P384_M, SPAKE2P_P384_N);
214 return SystemParameters(std::move(
group), std::move(m), std::move(n),
"SHA-512");
218 auto [
group, m, n] = spake2p_group_params(
"secp521r1", SPAKE2P_P521_M, SPAKE2P_P521_N);
219 return SystemParameters(std::move(
group), std::move(m), std::move(n),
"SHA-512");
223 std::span<const uint8_t> seed,
224 std::string_view hash_fn) {
225 BOTAN_ARG_CHECK(
group.has_cofactor() ==
false,
"SPAKE2+ is not supported for groups with a cofactor");
227 if(!
group.hash_to_curve_supported(hash_fn)) {
228 throw Not_Implemented(
"SPAKE2+ custom params require hash2curve support which is not available for this curve");
234 return SystemParameters(
group, std::move(m), std::move(n), hash_fn);
238 return 1 + 2 * m_group.get_p_bytes();
242 if(m_hash_fn ==
"SHA-256") {
244 }
else if(m_hash_fn ==
"SHA-384") {
246 }
else if(m_hash_fn ==
"SHA-512") {
254 std::string_view password,
255 std::span<const uint8_t> prover_id,
256 std::span<const uint8_t> verifier_id,
257 std::span<const uint8_t> salt,
266 if(record.size() != scalar_len + point_len) {
267 throw Decoding_Error(
"Invalid length for SPAKE2+ registration record");
277 return RegistrationRecord(std::move(*w0), std::move(*l));
284ProverSecret::ProverSecret(
EC_Scalar w0,
EC_Scalar w1) : m_w0(std::move(w0)), m_w1(std::move(w1)) {
289 std::string_view password,
290 std::span<const uint8_t> prover_id,
291 std::span<const uint8_t> verifier_id,
292 std::span<const uint8_t> salt) {
293 auto [w0, w1] = derive_w0_w1(params, password, prover_id, verifier_id, salt);
294 return ProverSecret(std::move(w0), std::move(w1));
298 return ProverSecret(std::move(w0), std::move(w1));
303 return ProverSecret(std::move(w0_w1->first), std::move(w0_w1->second));
321 std::span<const uint8_t> prover_id,
322 std::span<const uint8_t> verifier_id,
323 std::span<const uint8_t> context) :
326 m_prover_id(prover_id.begin(), prover_id.end()),
327 m_verifier_id(verifier_id.begin(), verifier_id.end()),
328 m_context(context.begin(), context.end()) {}
341 m_our_message = std::make_pair(share_p->serialize_uncompressed(), x);
342 m_state = State::ShareGenerated;
343 return m_our_message->first;
345 throw Internal_Error(
"Computed the identity element during SPAKE2+ key exchange");
350 BOTAN_STATE_CHECK(m_state == State::ShareGenerated && m_our_message.has_value());
353 m_state = State::Failed;
354 const auto our_message = std::exchange(m_our_message, std::nullopt);
355 const auto& share_p = our_message->first;
356 const auto& x = our_message->second;
358 const size_t share_size = m_params.share_size();
359 const size_t confirm_size = m_params.confirmation_size();
361 if(peer_message.size() != share_size + confirm_size) {
362 throw Decoding_Error(
"Invalid length for SPAKE2+ verifier message");
365 const auto share_v = peer_message.first(share_size);
366 const auto confirm_v = peer_message.last(confirm_size);
373 const auto& w0 = m_secret.m_w0;
374 const auto& w1 = m_secret.m_w1;
375 const auto& n = m_params.spake2p_n();
387 auto keys = spake2p_key_schedule(m_params, m_context, m_prover_id, m_verifier_id, share_p, share_v, *z, *v, w0);
395 m_shared_secret = std::move(keys.shared_key);
396 m_state = State::Complete;
398 return keys.confirm_p;
403 return m_shared_secret;
408 std::span<const uint8_t> prover_id,
409 std::span<const uint8_t> verifier_id,
410 std::span<const uint8_t> context) :
413 m_prover_id(prover_id.begin(), prover_id.end()),
414 m_verifier_id(verifier_id.begin(), verifier_id.end()),
415 m_context(context.begin(), context.end()) {}
422 m_state = State::Failed;
429 const auto& w0 = m_record.m_w0;
440 throw Internal_Error(
"Computed the identity element during SPAKE2+ key exchange");
442 const auto share_v = share_v_pt->serialize_uncompressed();
449 const auto v = m_record.m_l.mul(y, rng);
451 auto keys = spake2p_key_schedule(m_params, m_context, m_prover_id, m_verifier_id, peer_message, share_v, *z, v, w0);
455 m_shared_secret = std::move(keys.shared_key);
456 m_expected_confirmation = std::move(keys.confirm_p);
457 m_state = State::Responded;
466 m_expected_confirmation.clear();
467 m_shared_secret.clear();
468 m_state = State::Failed;
472 m_expected_confirmation.clear();
473 m_state = State::Complete;
479 m_expected_confirmation.clear();
480 m_state = State::Complete;
485 return m_shared_secret;
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_STATE_CHECK(expr)
#define BOTAN_ARG_CHECK(expr, msg)
Helper class to ease in-place marshalling of concatenated fixed-length values.
constexpr void append(std::span< const uint8_t > buffer)
constexpr bool full() const
static EC_AffinePoint hash_to_curve_ro(const EC_Group &group, std::string_view hash_fn, std::span< const uint8_t > input, std::span< const uint8_t > domain_sep)
static std::optional< EC_AffinePoint > deserialize_uncompressed(const EC_Group &group, std::span< const uint8_t > bytes)
static std::optional< EC_AffinePoint > mul_px_qy(const EC_AffinePoint &p, const EC_Scalar &x, const EC_AffinePoint &q, const EC_Scalar &y, RandomNumberGenerator &rng)
static EC_AffinePoint g_mul(const EC_Scalar &scalar, RandomNumberGenerator &rng)
Multiply by the group generator returning a complete point.
T serialize_uncompressed() const
static EC_AffinePoint generator(const EC_Group &group)
Return the standard group generator.
static EC_Group from_name(std::string_view name)
size_t get_order_bytes() const
static std::optional< EC_Scalar > deserialize(const EC_Group &group, std::span< const uint8_t > bytes)
static T serialize_pair(const EC_Scalar &r, const EC_Scalar &s)
static EC_Scalar from_bytes_mod_order(const EC_Group &group, std::span< const uint8_t > bytes)
static EC_Scalar random(const EC_Group &group, RandomNumberGenerator &rng)
static std::optional< std::pair< EC_Scalar, EC_Scalar > > deserialize_pair(const EC_Group &group, std::span< const uint8_t > bytes)
static std::unique_ptr< HashFunction > create_or_throw(std::string_view algo_spec, std::string_view provider="")
static std::unique_ptr< KDF > create_or_throw(std::string_view algo_spec, std::string_view provider="")
static std::unique_ptr< MessageAuthenticationCode > create_or_throw(std::string_view algo_spec, std::string_view provider="")
static std::unique_ptr< PasswordHashFamily > create_or_throw(std::string_view algo_spec, std::string_view provider="")
std::vector< uint8_t > process_message(std::span< const uint8_t > peer_message, RandomNumberGenerator &rng)
std::vector< uint8_t > generate_message(RandomNumberGenerator &rng)
secure_vector< uint8_t > shared_secret() const
ProverContext(const SystemParameters ¶ms, const ProverSecret &secret, std::span< const uint8_t > prover_id, std::span< const uint8_t > verifier_id, std::span< const uint8_t > context={})
static ProverSecret from_prehashed(EC_Scalar w0, EC_Scalar w1)
static ProverSecret from_password(const SystemParameters ¶ms, std::string_view password, std::span< const uint8_t > prover_id, std::span< const uint8_t > verifier_id, std::span< const uint8_t > salt)
static ProverSecret deserialize(const SystemParameters ¶ms, std::span< const uint8_t > secret)
RegistrationRecord registration_record(RandomNumberGenerator &rng) const
secure_vector< uint8_t > serialize() const
secure_vector< uint8_t > serialize() const
static RegistrationRecord deserialize(const SystemParameters ¶ms, std::span< const uint8_t > record)
static RegistrationRecord from_password(const SystemParameters ¶ms, std::string_view password, std::span< const uint8_t > prover_id, std::span< const uint8_t > verifier_id, std::span< const uint8_t > salt, RandomNumberGenerator &rng)
const EC_Group & group() const
const EC_AffinePoint & spake2p_n() const
static SystemParameters rfc9383_p256_sha512()
static SystemParameters rfc9383_p521_sha512()
static SystemParameters rfc9383_p384_sha256()
const std::string & hash_function() const
static SystemParameters rfc9383_p256_sha256()
static SystemParameters rfc9383_p384_sha512()
size_t confirmation_size() const
const EC_AffinePoint & spake2p_m() const
static SystemParameters custom(const EC_Group &group, std::span< const uint8_t > seed, std::string_view hash_fn)
size_t share_size() const
std::vector< uint8_t > process_message(std::span< const uint8_t > peer_message, RandomNumberGenerator &rng)
VerifierContext(const SystemParameters ¶ms, const RegistrationRecord &record, std::span< const uint8_t > prover_id, std::span< const uint8_t > verifier_id, std::span< const uint8_t > context={})
secure_vector< uint8_t > shared_secret() const
void verify_confirmation(std::span< const uint8_t > confirmation)
constexpr decltype(auto) driveby_unpoison(T &&v)
constexpr auto scoped_poison(const Ts &... xs)
constexpr void unpoison_all(const Ts &... ts)
constexpr void unpoison(const T *p, size_t n)
std::span< const uint8_t > as_span_of_bytes(const char *s, size_t len)
std::string fmt(std::string_view format, const T &... args)
constexpr auto store_le(ParamTs &&... params)
constexpr auto concat(Rs &&... ranges)
size_t hex_decode(uint8_t output[], const char input[], size_t input_length, size_t &input_consumed, bool ignore_ws)
const char * cast_uint8_ptr_to_char(const uint8_t *b)
std::vector< T, secure_allocator< T > > secure_vector
bool constant_time_compare(std::span< const uint8_t > x, std::span< const uint8_t > y)