9#include <botan/pgp_s2k.h>
11#include <botan/exceptn.h>
12#include <botan/mem_ops.h>
13#include <botan/internal/fmt.h>
14#include <botan/internal/int_utils.h>
15#include <botan/internal/mem_utils.h>
16#include <botan/internal/time_utils.h>
28 const size_t password_size,
32 if(iterations > 1 && salt_len == 0) {
36 const size_t input_len =
add_or_throw(salt_len, password_size,
"OpenPGP S2K salt and password are too large");
39 copy_mem(input_buf.data(), salt, salt_len);
41 if(password_size > 0) {
50 while(generated != output_len) {
51 const size_t output_this_pass = std::min(hash_buf.size(), output_len - generated);
54 std::vector<uint8_t> zero_padding(pass);
55 hash.update(zero_padding);
58 if(!input_buf.empty()) {
59 size_t left = std::max(iterations, input_buf.size());
61 const size_t input_to_take = std::min(left, input_buf.size());
62 hash.update(input_buf.data(), input_to_take);
63 left -= input_to_take;
67 hash.final(hash_buf.data());
68 copy_mem(output_buf + generated, hash_buf.data(), output_this_pass);
69 generated += output_this_pass;
78 std::string_view password,
82 std::chrono::milliseconds desired_msec)
const {
85 iterations = s2k_params.
tune_params(output_len, desired_msec.count(), {}, 10)->iterations();
88 pgp_s2k(*m_hash, output_buf, output_len, password.data(), password.size(), salt, salt_len, iterations);
94 return fmt(
"OpenPGP-S2K({})", m_hash->name());
98 uint64_t desired_msec,
99 std::optional<size_t> ,
100 uint64_t tuning_msec)
const {
103 constexpr size_t tuning_iterations = 1024 * 1024;
104 constexpr std::string_view tuning_password =
"password";
105 const std::array<uint8_t, 8> tuning_salt{};
107 auto tuning_hash = m_hash->new_object();
108 std::vector<uint8_t> tuning_out(tuning_hash->output_length());
110 const uint64_t measured_nsec =
measure_cost(tuning_msec, [&]() {
111 pgp_s2k(*tuning_hash,
114 tuning_password.data(),
115 tuning_password.size(),
121 const double hash_bytes_per_second = (tuning_iterations * 1000000000.0) / measured_nsec;
122 const uint64_t desired_nsec = desired_msec * 1000000;
124 const size_t hash_size = m_hash->output_length();
125 const size_t blocks_required = std::max<size_t>(1, (output_len / hash_size) + (output_len % hash_size != 0 ? 1 : 0));
127 const double bytes_to_be_hashed = (hash_bytes_per_second * (desired_nsec / 1000000000.0)) / blocks_required;
130 return std::make_unique<RFC4880_S2K>(m_hash->new_object(), iterations);
136 return std::make_unique<RFC4880_S2K>(m_hash->new_object(), iterations);
140 return std::make_unique<RFC4880_S2K>(m_hash->new_object(), 50331648);
144 return std::make_unique<RFC4880_S2K>(m_hash->new_object(), iterations);
151 return fmt(
"OpenPGP-S2K({},{})", m_hash->name(), m_iterations);
156 const char* password,
157 const size_t password_len,
158 const uint8_t salt[],
159 size_t salt_len)
const {
160 pgp_s2k(*m_hash, out, out_len, password, password_len, salt, salt_len, m_iterations);
size_t pbkdf(uint8_t output_buf[], size_t output_len, std::string_view passphrase, const uint8_t salt[], size_t salt_len, size_t iterations, std::chrono::milliseconds msec) const override
void hash(std::span< uint8_t > out, std::string_view password, std::span< const uint8_t > salt) const
std::unique_ptr< PasswordHash > from_iterations(size_t iterations) const override
std::unique_ptr< PasswordHash > default_params() const override
std::unique_ptr< PasswordHash > from_params(size_t iterations, size_t, size_t) const override
std::string name() const override
std::unique_ptr< PasswordHash > tune_params(size_t output_len, uint64_t desired_runtime_msec, std::optional< size_t > max_memory, uint64_t tune_msec) const override
std::string to_string() const override
void derive_key(uint8_t out[], size_t out_len, const char *password, size_t password_len, const uint8_t salt[], size_t salt_len) const override
size_t iterations() const override
RFC4880_S2K(std::unique_ptr< HashFunction > hash, size_t iterations)
constexpr T add_or_throw(T a, T b, std::string_view msg)
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 void copy_mem(T *out, const T *in, size_t n)
std::vector< T, secure_allocator< T > > secure_vector
uint64_t measure_cost(uint64_t trial_msec, F func)
size_t RFC4880_round_iterations(size_t iterations)