5955746790

Committed 23 Aug 2023 04:26PM UTC coverage: 91.708% (-0.003%) from 91.711%

Build # 5955746790

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #3677 from randombit/jack/ninja-build

Run Details

78577 of 85682 relevant lines covered (91.71%)

8475420.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

75.76

/src/lib/pbkdf/argon2/argon2pwhash.cpp

/**
* (C) 2019 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/argon2.h>

#include <botan/exceptn.h>
#include <botan/internal/fmt.h>
#include <botan/internal/timer.h>
#include <algorithm>
#include <limits>

namespace Botan {

Argon2::Argon2(uint8_t family, size_t M, size_t t, size_t p) : m_family(family), m_M(M), m_t(t), m_p(p) {
   BOTAN_ARG_CHECK(m_p >= 1 && m_p <= 128, "Invalid Argon2 threads parameter");
   BOTAN_ARG_CHECK(m_M >= 8 * m_p && m_M <= 8192 * 1024, "Invalid Argon2 M parameter");
   BOTAN_ARG_CHECK(m_t >= 1 && m_t <= std::numeric_limits<uint32_t>::max(), "Invalid Argon2 t parameter");
}

void Argon2::derive_key(uint8_t output[],
                        size_t output_len,
                        const char* password,
                        size_t password_len,
                        const uint8_t salt[],
                        size_t salt_len) const {
   argon2(output, output_len, password, password_len, salt, salt_len, nullptr, 0, nullptr, 0);
}

void Argon2::derive_key(uint8_t output[],
                        size_t output_len,
                        const char* password,
                        size_t password_len,
                        const uint8_t salt[],
                        size_t salt_len,
                        const uint8_t ad[],
                        size_t ad_len,
                        const uint8_t key[],
                        size_t key_len) const {
   argon2(output, output_len, password, password_len, salt, salt_len, key, key_len, ad, ad_len);
}

namespace {

std::string argon2_family_name(uint8_t f) {
   switch(f) {
      case 0:
         return "Argon2d";
      case 1:
         return "Argon2i";
      case 2:
         return "Argon2id";
      default:
         throw Invalid_Argument("Unknown Argon2 parameter");
   }
}

}  // namespace

std::string Argon2::to_string() const {
   return fmt("{}({},{},{})", argon2_family_name(m_family), m_M, m_t, m_p);
}

Argon2_Family::Argon2_Family(uint8_t family) : m_family(family) {
   if(m_family != 0 && m_family != 1 && m_family != 2) {
      throw Invalid_Argument("Unknown Argon2 family identifier");
   }
}

std::string Argon2_Family::name() const {
   return argon2_family_name(m_family);
}

std::unique_ptr<PasswordHash> Argon2_Family::tune(size_t /*output_length*/,
                                                  std::chrono::milliseconds msec,
                                                  size_t max_memory,
                                                  std::chrono::milliseconds tune_time) const {
   const size_t max_kib = (max_memory == 0) ? 256 * 1024 : max_memory * 1024;

   // Tune with a large memory otherwise we measure cache vs RAM speeds and underestimate
   // costs for larger params. Default is 36 MiB, or use 128 for long times.
   const size_t tune_M = (msec >= std::chrono::milliseconds(200) ? 128 : 36) * 1024;
   const size_t p = 1;
   size_t t = 1;

   Timer timer("Argon2");

   auto pwhash = this->from_params(tune_M, t, p);

   timer.run_until_elapsed(tune_time, [&]() {
      uint8_t output[64] = {0};
      pwhash->derive_key(output, sizeof(output), "test", 4, nullptr, 0);
   });

   if(timer.events() == 0 || timer.value() == 0) {
      return default_params();
   }

   size_t M = 4 * 1024;

   const uint64_t measured_time = timer.value() / (timer.events() * (tune_M / M));

   const uint64_t target_nsec = msec.count() * static_cast<uint64_t>(1000000);

   /*
   * Argon2 scaling rules:
   * k*M, k*t, k*p all increase cost by about k
   *
   * Since we don't even take advantage of p > 1, we prefer increasing
   * t or M instead.
   *
   * If possible to increase M, prefer that.
   */

   uint64_t est_nsec = measured_time;

   if(est_nsec < target_nsec && M < max_kib) {
      const uint64_t desired_cost_increase = (target_nsec + est_nsec - 1) / est_nsec;
      const uint64_t mem_headroom = max_kib / M;

      const uint64_t M_mult = std::min(desired_cost_increase, mem_headroom);
      M *= static_cast<size_t>(M_mult);
      est_nsec *= M_mult;
   }

   if(est_nsec < target_nsec / 2) {
      const uint64_t desired_cost_increase = (target_nsec + est_nsec - 1) / est_nsec;
      t *= static_cast<size_t>(desired_cost_increase);
   }

   return this->from_params(M, t, p);
}

std::unique_ptr<PasswordHash> Argon2_Family::default_params() const {
   return this->from_params(128 * 1024, 1, 1);
}

std::unique_ptr<PasswordHash> Argon2_Family::from_iterations(size_t iter) const {
   /*
   These choices are arbitrary, but should not change in future
   releases since they will break applications expecting deterministic
   mapping from iteration count to params
   */
   const size_t M = iter;
   const size_t t = 1;
   const size_t p = 1;
   return this->from_params(M, t, p);
}

std::unique_ptr<PasswordHash> Argon2_Family::from_params(size_t M, size_t t, size_t p) const {
   return std::make_unique<Argon2>(m_family, M, t, p);
}

}  // namespace Botan

1	/**
2	* (C) 2019 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include <botan/argon2.h>
8
9	#include <botan/exceptn.h>
10	#include <botan/internal/fmt.h>
11	#include <botan/internal/timer.h>
12	#include <algorithm>
13	#include <limits>
14
15	namespace Botan {
16
17	Argon2::Argon2(uint8_t family, size_t M, size_t t, size_t p) : m_family(family), m_M(M), m_t(t), m_p(p) {	1,118✔
18	BOTAN_ARG_CHECK(m_p >= 1 && m_p <= 128, "Invalid Argon2 threads parameter");	1,118✔
19	BOTAN_ARG_CHECK(m_M >= 8 * m_p && m_M <= 8192 * 1024, "Invalid Argon2 M parameter");	1,118✔
20	BOTAN_ARG_CHECK(m_t >= 1 && m_t <= std::numeric_limits<uint32_t>::max(), "Invalid Argon2 t parameter");	1,118✔
21	}	1,118✔
22
23	void Argon2::derive_key(uint8_t output[],	47✔
24	size_t output_len,
25	const char* password,
26	size_t password_len,
27	const uint8_t salt[],
28	size_t salt_len) const {
29	argon2(output, output_len, password, password_len, salt, salt_len, nullptr, 0, nullptr, 0);	47✔
30	}	47✔
31
32	void Argon2::derive_key(uint8_t output[],	1,071✔
33	size_t output_len,
34	const char* password,
35	size_t password_len,
36	const uint8_t salt[],
37	size_t salt_len,
38	const uint8_t ad[],
39	size_t ad_len,
40	const uint8_t key[],
41	size_t key_len) const {
42	argon2(output, output_len, password, password_len, salt, salt_len, key, key_len, ad, ad_len);	1,071✔
43	}	1,071✔
44
45	namespace {
46
47	std::string argon2_family_name(uint8_t f) {	22✔
48	switch(f) {	22✔
49	case 0:	2✔
50	return "Argon2d";	2✔
51	case 1:	2✔
52	return "Argon2i";	2✔
53	case 2:	18✔
54	return "Argon2id";	18✔
55	default:	×
56	throw Invalid_Argument("Unknown Argon2 parameter");	×
57	}
58	}
59
60	} // namespace
61
62	std::string Argon2::to_string() const {	16✔
63	return fmt("{}({},{},{})", argon2_family_name(m_family), m_M, m_t, m_p);	16✔
64	}
65
66	Argon2_Family::Argon2_Family(uint8_t family) : m_family(family) {	1,092✔
67	if(m_family != 0 && m_family != 1 && m_family != 2) {	1,092✔
68	throw Invalid_Argument("Unknown Argon2 family identifier");	×
69	}
70	}	1,092✔
71
72	std::string Argon2_Family::name() const {	6✔
73	return argon2_family_name(m_family);	6✔
74	}
75
76	std::unique_ptr<PasswordHash> Argon2_Family::tune(size_t /output_length/,	6✔
77	std::chrono::milliseconds msec,
78	size_t max_memory,
79	std::chrono::milliseconds tune_time) const {
80	const size_t max_kib = (max_memory == 0) ? 256 * 1024 : max_memory * 1024;	6✔
81
82	// Tune with a large memory otherwise we measure cache vs RAM speeds and underestimate
83	// costs for larger params. Default is 36 MiB, or use 128 for long times.
84	const size_t tune_M = (msec >= std::chrono::milliseconds(200) ? 128 : 36) * 1024;	12✔
85	const size_t p = 1;	6✔
86	size_t t = 1;	6✔
87
88	Timer timer("Argon2");	6✔
89
90	auto pwhash = this->from_params(tune_M, t, p);	6✔
91
92	timer.run_until_elapsed(tune_time, [&]() {	6✔
93	uint8_t output[64] = {0};	6✔
94	pwhash->derive_key(output, sizeof(output), "test", 4, nullptr, 0);	6✔
95	});	6✔
96
97	if(timer.events() == 0 \|\| timer.value() == 0) {	6✔
98	return default_params();	×
99	}
100
101	size_t M = 4 * 1024;	6✔
102
103	const uint64_t measured_time = timer.value() / (timer.events() * (tune_M / M));	6✔
104
105	const uint64_t target_nsec = msec.count() * static_cast<uint64_t>(1000000);	6✔
106
107	/*
108	* Argon2 scaling rules:
109	* kM, kt, k*p all increase cost by about k
110	*
111	* Since we don't even take advantage of p > 1, we prefer increasing
112	* t or M instead.
113	*
114	* If possible to increase M, prefer that.
115	*/
116
117	uint64_t est_nsec = measured_time;	6✔
118
119	if(est_nsec < target_nsec && M < max_kib) {	6✔
120	const uint64_t desired_cost_increase = (target_nsec + est_nsec - 1) / est_nsec;	×
121	const uint64_t mem_headroom = max_kib / M;	×
122
123	const uint64_t M_mult = std::min(desired_cost_increase, mem_headroom);	×
124	M *= static_cast<size_t>(M_mult);	×
125	est_nsec *= M_mult;	×
126	}
127
128	if(est_nsec < target_nsec / 2) {	6✔
129	const uint64_t desired_cost_increase = (target_nsec + est_nsec - 1) / est_nsec;	×
130	t *= static_cast<size_t>(desired_cost_increase);	×
131	}
132
133	return this->from_params(M, t, p);	6✔
134	}	6✔
135
136	std::unique_ptr<PasswordHash> Argon2_Family::default_params() const {	4✔
137	return this->from_params(128 * 1024, 1, 1);	4✔
138	}
139
140	std::unique_ptr<PasswordHash> Argon2_Family::from_iterations(size_t iter) const {	×
141	/*
142	These choices are arbitrary, but should not change in future
143	releases since they will break applications expecting deterministic
144	mapping from iteration count to params
145	*/
146	const size_t M = iter;	×
147	const size_t t = 1;	×
148	const size_t p = 1;	×
149	return this->from_params(M, t, p);	×
150	}
151
152	std::unique_ptr<PasswordHash> Argon2_Family::from_params(size_t M, size_t t, size_t p) const {	1,118✔
153	return std::make_unique<Argon2>(m_family, M, t, p);	1,118✔
154	}
155
156	} // namespace Botan

randombit / botan / 5955746790

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous