Botan 3.14.1
Crypto and TLS for C&
pgp_s2k.cpp
Go to the documentation of this file.
1/*
2* OpenPGP S2K
3* (C) 1999-2007,2017 Jack Lloyd
4* (C) 2018 Ribose Inc
5*
6* Botan is released under the Simplified BSD License (see license.txt)
7*/
8
9#include <botan/pgp_s2k.h>
10
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>
17#include <algorithm>
18#include <array>
19
20namespace Botan {
21
22namespace {
23
24void pgp_s2k(HashFunction& hash,
25 uint8_t output_buf[],
26 size_t output_len,
27 const char* password,
28 const size_t password_size,
29 const uint8_t salt[],
30 size_t salt_len,
31 size_t iterations) {
32 if(iterations > 1 && salt_len == 0) {
33 throw Invalid_Argument("OpenPGP S2K requires a salt in iterated mode");
34 }
35
36 const size_t input_len = add_or_throw(salt_len, password_size, "OpenPGP S2K salt and password are too large");
37 secure_vector<uint8_t> input_buf(input_len);
38 if(salt_len > 0) {
39 copy_mem(input_buf.data(), salt, salt_len);
40 }
41 if(password_size > 0) {
42 copy_mem(std::span(input_buf).subspan(salt_len), as_span_of_bytes(password, password_size));
43 }
44
45 secure_vector<uint8_t> hash_buf(hash.output_length());
46
47 size_t pass = 0;
48 size_t generated = 0;
49
50 while(generated != output_len) {
51 const size_t output_this_pass = std::min(hash_buf.size(), output_len - generated);
52
53 // Preload some number of zero bytes (empty first iteration)
54 std::vector<uint8_t> zero_padding(pass);
55 hash.update(zero_padding);
56
57 // The input is always fully processed even if iterations is very small
58 if(!input_buf.empty()) {
59 size_t left = std::max(iterations, input_buf.size());
60 while(left > 0) {
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;
64 }
65 }
66
67 hash.final(hash_buf.data());
68 copy_mem(output_buf + generated, hash_buf.data(), output_this_pass);
69 generated += output_this_pass;
70 ++pass;
71 }
72}
73
74} // namespace
75
76size_t OpenPGP_S2K::pbkdf(uint8_t output_buf[],
77 size_t output_len,
78 std::string_view password,
79 const uint8_t salt[],
80 size_t salt_len,
81 size_t iterations,
82 std::chrono::milliseconds desired_msec) const {
83 if(iterations == 0) {
84 const RFC4880_S2K_Family s2k_params(m_hash->new_object());
85 iterations = s2k_params.tune_params(output_len, desired_msec.count(), {}, 10)->iterations();
86 }
87
88 pgp_s2k(*m_hash, output_buf, output_len, password.data(), password.size(), salt, salt_len, iterations);
89
90 return iterations;
91}
92
93std::string RFC4880_S2K_Family::name() const {
94 return fmt("OpenPGP-S2K({})", m_hash->name());
95}
96
97std::unique_ptr<PasswordHash> RFC4880_S2K_Family::tune_params(size_t output_len,
98 uint64_t desired_msec,
99 std::optional<size_t> /*max_memory*/,
100 uint64_t tuning_msec) const {
101 // Benchmark the real S2K, since hashing the salt and password in small
102 // pieces has a large per-call cost that bulk hashing would not reflect
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{};
106
107 auto tuning_hash = m_hash->new_object();
108 std::vector<uint8_t> tuning_out(tuning_hash->output_length());
109
110 const uint64_t measured_nsec = measure_cost(tuning_msec, [&]() {
111 pgp_s2k(*tuning_hash,
112 tuning_out.data(),
113 tuning_out.size(),
114 tuning_password.data(),
115 tuning_password.size(),
116 tuning_salt.data(),
117 tuning_salt.size(),
118 tuning_iterations);
119 });
120
121 const double hash_bytes_per_second = (tuning_iterations * 1000000000.0) / measured_nsec;
122 const uint64_t desired_nsec = desired_msec * 1000000;
123
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));
126
127 const double bytes_to_be_hashed = (hash_bytes_per_second * (desired_nsec / 1000000000.0)) / blocks_required;
128 const size_t iterations = RFC4880_round_iterations(static_cast<size_t>(bytes_to_be_hashed));
129
130 return std::make_unique<RFC4880_S2K>(m_hash->new_object(), iterations);
131}
132
133std::unique_ptr<PasswordHash> RFC4880_S2K_Family::from_params(size_t iterations,
134 size_t /*unused*/,
135 size_t /*unused*/) const {
136 return std::make_unique<RFC4880_S2K>(m_hash->new_object(), iterations);
137}
138
139std::unique_ptr<PasswordHash> RFC4880_S2K_Family::default_params() const {
140 return std::make_unique<RFC4880_S2K>(m_hash->new_object(), 50331648);
141}
142
143std::unique_ptr<PasswordHash> RFC4880_S2K_Family::from_iterations(size_t iterations) const {
144 return std::make_unique<RFC4880_S2K>(m_hash->new_object(), iterations);
145}
146
147RFC4880_S2K::RFC4880_S2K(std::unique_ptr<HashFunction> hash, size_t iterations) :
148 m_hash(std::move(hash)), m_iterations(iterations) {}
149
150std::string RFC4880_S2K::to_string() const {
151 return fmt("OpenPGP-S2K({},{})", m_hash->name(), m_iterations);
152}
153
154void RFC4880_S2K::derive_key(uint8_t out[],
155 size_t out_len,
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);
161}
162
163} // namespace Botan
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
Definition pgp_s2k.cpp:76
void hash(std::span< uint8_t > out, std::string_view password, std::span< const uint8_t > salt) const
Definition pwdhash.h:95
std::unique_ptr< PasswordHash > from_iterations(size_t iterations) const override
Definition pgp_s2k.cpp:143
std::unique_ptr< PasswordHash > default_params() const override
Definition pgp_s2k.cpp:139
std::unique_ptr< PasswordHash > from_params(size_t iterations, size_t, size_t) const override
Definition pgp_s2k.cpp:133
std::string name() const override
Definition pgp_s2k.cpp:93
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
Definition pgp_s2k.cpp:97
std::string to_string() const override
Definition pgp_s2k.cpp:150
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
Definition pgp_s2k.cpp:154
size_t iterations() const override
Definition pgp_s2k.h:90
RFC4880_S2K(std::unique_ptr< HashFunction > hash, size_t iterations)
Definition pgp_s2k.cpp:147
constexpr T add_or_throw(T a, T b, std::string_view msg)
Definition int_utils.h:66
std::span< const uint8_t > as_span_of_bytes(const char *s, size_t len)
Definition mem_utils.h:59
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53
constexpr void copy_mem(T *out, const T *in, size_t n)
Definition mem_ops.h:144
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:128
uint64_t measure_cost(uint64_t trial_msec, F func)
Definition time_utils.h:34
size_t RFC4880_round_iterations(size_t iterations)
Definition rfc4880.h:32