5123321399

Committed 30 May 2023 04:06PM UTC coverage: 92.213% (+0.004%) from 92.209%

Build # 5123321399

Build Type

Pull #3558

github

Committed by

web-flow

Commit Message

Merge dd72f7389 into 057bcbc35

Pull Request Pull Request #3558: Add braces around all if/else statements

Run Details

75602 of 81986 relevant lines covered (92.21%)

11859779.3 hits per line

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

98.92

/src/lib/passhash/bcrypt/bcrypt.cpp

/*
* Bcrypt Password Hashing
* (C) 2010,2018,2020 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/bcrypt.h>

#include <botan/base64.h>
#include <botan/rng.h>
#include <botan/internal/blowfish.h>
#include <botan/internal/ct_utils.h>
#include <botan/internal/fmt.h>
#include <botan/internal/parsing.h>

namespace Botan {

namespace {

// Bcrypt uses a non-standard base64 alphabet
uint8_t base64_to_bcrypt_encoding(uint8_t c) {
   const auto is_ab = CT::Mask<uint8_t>::is_within_range(c, 'a', 'b');
   const auto is_cz = CT::Mask<uint8_t>::is_within_range(c, 'c', 'z');
   const auto is_CZ = CT::Mask<uint8_t>::is_within_range(c, 'C', 'Z');

   const auto is_01 = CT::Mask<uint8_t>::is_within_range(c, '0', '1');
   const auto is_29 = CT::Mask<uint8_t>::is_within_range(c, '2', '9');

   const auto is_A = CT::Mask<uint8_t>::is_equal(c, 'A');
   const auto is_B = CT::Mask<uint8_t>::is_equal(c, 'B');
   const auto is_plus = CT::Mask<uint8_t>::is_equal(c, '+');
   const auto is_slash = CT::Mask<uint8_t>::is_equal(c, '/');

   uint8_t ret = 0x80;
   ret = is_ab.select(c - 'a' + 'Y', ret);
   ret = is_cz.select(c - 2, ret);
   ret = is_CZ.select(c - 2, ret);
   ret = is_01.select(c - '0' + 'y', ret);
   ret = is_29.select(c - '2' + '0', ret);
   ret = is_A.select('.', ret);
   ret = is_B.select('/', ret);
   ret = is_plus.select('8', ret);
   ret = is_slash.select('9', ret);

   return ret;
}

uint8_t bcrypt_encoding_to_base64(uint8_t c) {
   const auto is_ax = CT::Mask<uint8_t>::is_within_range(c, 'a', 'x');
   const auto is_yz = CT::Mask<uint8_t>::is_within_range(c, 'y', 'z');

   const auto is_AX = CT::Mask<uint8_t>::is_within_range(c, 'A', 'X');
   const auto is_YZ = CT::Mask<uint8_t>::is_within_range(c, 'Y', 'Z');
   const auto is_07 = CT::Mask<uint8_t>::is_within_range(c, '0', '7');

   const auto is_8 = CT::Mask<uint8_t>::is_equal(c, '8');
   const auto is_9 = CT::Mask<uint8_t>::is_equal(c, '9');
   const auto is_dot = CT::Mask<uint8_t>::is_equal(c, '.');
   const auto is_slash = CT::Mask<uint8_t>::is_equal(c, '/');

   uint8_t ret = 0x80;
   ret = is_ax.select(c - 'a' + 'c', ret);
   ret = is_yz.select(c - 'y' + '0', ret);
   ret = is_AX.select(c - 'A' + 'C', ret);
   ret = is_YZ.select(c - 'Y' + 'a', ret);
   ret = is_07.select(c - '0' + '2', ret);
   ret = is_8.select('+', ret);
   ret = is_9.select('/', ret);
   ret = is_dot.select('A', ret);
   ret = is_slash.select('B', ret);

   return ret;
}

std::string bcrypt_base64_encode(const uint8_t input[], size_t length) {
   std::string b64 = base64_encode(input, length);

   while(!b64.empty() && b64[b64.size() - 1] == '=') {
      b64 = b64.substr(0, b64.size() - 1);
   }

   for(size_t i = 0; i != b64.size(); ++i) {
      b64[i] = static_cast<char>(base64_to_bcrypt_encoding(static_cast<uint8_t>(b64[i])));
   }

   return b64;
}

std::vector<uint8_t> bcrypt_base64_decode(std::string_view input) {
   std::string translated;
   for(size_t i = 0; i != input.size(); ++i) {
      char c = bcrypt_encoding_to_base64(static_cast<uint8_t>(input[i]));
      translated.push_back(c);
   }

   return unlock(base64_decode(translated));
}

std::string make_bcrypt(std::string_view pass, const std::vector<uint8_t>& salt, uint16_t work_factor, char version) {
   /*
   * On a 4 GHz Skylake, workfactor == 18 takes about 15 seconds to
   * hash a password. This seems like a reasonable upper bound for the
   * time being.
   * Bcrypt allows up to work factor 31 (2^31 iterations)
   */
   BOTAN_ARG_CHECK(work_factor >= 4 && work_factor <= 18, "Invalid bcrypt work factor");

   alignas(64) static const uint8_t BCRYPT_MAGIC[8 * 3] = {0x4F, 0x72, 0x70, 0x68, 0x65, 0x61, 0x6E, 0x42,
                                                           0x65, 0x68, 0x6F, 0x6C, 0x64, 0x65, 0x72, 0x53,
                                                           0x63, 0x72, 0x79, 0x44, 0x6F, 0x75, 0x62, 0x74};

   Blowfish blowfish;

   secure_vector<uint8_t> pass_with_trailing_null(pass.size() + 1);
   copy_mem(pass_with_trailing_null.data(), cast_char_ptr_to_uint8(pass.data()), pass.length());

   // Include the trailing NULL byte, so we need c_str() not data()
   blowfish.salted_set_key(
      pass_with_trailing_null.data(), pass_with_trailing_null.size(), salt.data(), salt.size(), work_factor);

   std::vector<uint8_t> ctext(BCRYPT_MAGIC, BCRYPT_MAGIC + 8 * 3);

   for(size_t i = 0; i != 64; ++i) {
      blowfish.encrypt_n(ctext.data(), ctext.data(), 3);
   }

   std::string salt_b64 = bcrypt_base64_encode(salt.data(), salt.size());

   std::string work_factor_str = std::to_string(work_factor);
   if(work_factor_str.length() == 1) {
      work_factor_str = "0" + work_factor_str;
   }

   return fmt("$2{}${}${}{}",
              version,
              work_factor_str,
              salt_b64.substr(0, 22),
              bcrypt_base64_encode(ctext.data(), ctext.size() - 1));
}

}  // namespace

std::string generate_bcrypt(std::string_view pass, RandomNumberGenerator& rng, uint16_t work_factor, char version) {
   /*
   2a, 2b and 2y are identical for our purposes because our implementation of 2a
   never had the truncation or signed char bugs in the first place.
   */

   if(version != 'a' && version != 'b' && version != 'y') {
      throw Invalid_Argument("Unknown bcrypt version '" + std::string(1, version) + "'");
   }

   std::vector<uint8_t> salt;
   rng.random_vec(salt, 16);
   return make_bcrypt(pass, salt, work_factor, version);
}

bool check_bcrypt(std::string_view pass, std::string_view hash) {
   if(hash.size() != 60 || hash[0] != '$' || hash[1] != '2' || hash[3] != '$' || hash[6] != '$') {
      return false;
   }

   const char bcrypt_version = hash[2];

   if(bcrypt_version != 'a' && bcrypt_version != 'b' && bcrypt_version != 'y') {
      return false;
   }

   const uint16_t workfactor = to_uint16(hash.substr(4, 2));

   const std::vector<uint8_t> salt = bcrypt_base64_decode(hash.substr(7, 22));
   if(salt.size() != 16) {
      return false;
   }

   const std::string compare = make_bcrypt(pass, salt, workfactor, bcrypt_version);

   return same_mem(hash.data(), compare.data(), compare.size());
}

}  // namespace Botan

1	/*
2	* Bcrypt Password Hashing
3	* (C) 2010,2018,2020 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/bcrypt.h>
9
10	#include <botan/base64.h>
11	#include <botan/rng.h>
12	#include <botan/internal/blowfish.h>
13	#include <botan/internal/ct_utils.h>
14	#include <botan/internal/fmt.h>
15	#include <botan/internal/parsing.h>
16
17	namespace Botan {
18
19	namespace {
20
21	// Bcrypt uses a non-standard base64 alphabet
22	uint8_t base64_to_bcrypt_encoding(uint8_t c) {	36,888✔
23	const auto is_ab = CT::Mask<uint8_t>::is_within_range(c, 'a', 'b');	36,888✔
24	const auto is_cz = CT::Mask<uint8_t>::is_within_range(c, 'c', 'z');	36,888✔
25	const auto is_CZ = CT::Mask<uint8_t>::is_within_range(c, 'C', 'Z');	36,888✔
26
27	const auto is_01 = CT::Mask<uint8_t>::is_within_range(c, '0', '1');	36,888✔
28	const auto is_29 = CT::Mask<uint8_t>::is_within_range(c, '2', '9');	36,888✔
29
30	const auto is_A = CT::Mask<uint8_t>::is_equal(c, 'A');	36,888✔
31	const auto is_B = CT::Mask<uint8_t>::is_equal(c, 'B');	36,888✔
32	const auto is_plus = CT::Mask<uint8_t>::is_equal(c, '+');	36,888✔
33	const auto is_slash = CT::Mask<uint8_t>::is_equal(c, '/');	36,888✔
34
35	uint8_t ret = 0x80;	36,888✔
36	ret = is_ab.select(c - 'a' + 'Y', ret);	36,888✔
37	ret = is_cz.select(c - 2, ret);	36,888✔
38	ret = is_CZ.select(c - 2, ret);	36,888✔
39	ret = is_01.select(c - '0' + 'y', ret);	36,888✔
40	ret = is_29.select(c - '2' + '0', ret);	36,888✔
41	ret = is_A.select('.', ret);	36,888✔
42	ret = is_B.select('/', ret);	36,888✔
43	ret = is_plus.select('8', ret);	36,888✔
44	ret = is_slash.select('9', ret);	36,888✔
45
46	return ret;	36,888✔
47	}
48
49	uint8_t bcrypt_encoding_to_base64(uint8_t c) {	8,602✔
50	const auto is_ax = CT::Mask<uint8_t>::is_within_range(c, 'a', 'x');	8,602✔
51	const auto is_yz = CT::Mask<uint8_t>::is_within_range(c, 'y', 'z');	8,602✔
52
53	const auto is_AX = CT::Mask<uint8_t>::is_within_range(c, 'A', 'X');	8,602✔
54	const auto is_YZ = CT::Mask<uint8_t>::is_within_range(c, 'Y', 'Z');	8,602✔
55	const auto is_07 = CT::Mask<uint8_t>::is_within_range(c, '0', '7');	8,602✔
56
57	const auto is_8 = CT::Mask<uint8_t>::is_equal(c, '8');	8,602✔
58	const auto is_9 = CT::Mask<uint8_t>::is_equal(c, '9');	8,602✔
59	const auto is_dot = CT::Mask<uint8_t>::is_equal(c, '.');	8,602✔
60	const auto is_slash = CT::Mask<uint8_t>::is_equal(c, '/');	8,602✔
61
62	uint8_t ret = 0x80;	8,602✔
63	ret = is_ax.select(c - 'a' + 'c', ret);	8,602✔
64	ret = is_yz.select(c - 'y' + '0', ret);	8,602✔
65	ret = is_AX.select(c - 'A' + 'C', ret);	8,602✔
66	ret = is_YZ.select(c - 'Y' + 'a', ret);	8,602✔
67	ret = is_07.select(c - '0' + '2', ret);	8,602✔
68	ret = is_8.select('+', ret);	8,602✔
69	ret = is_9.select('/', ret);	8,602✔
70	ret = is_dot.select('A', ret);	8,602✔
71	ret = is_slash.select('B', ret);	8,602✔
72
73	return ret;	8,602✔
74	}
75
76	std::string bcrypt_base64_encode(const uint8_t input[], size_t length) {	1,392✔
77	std::string b64 = base64_encode(input, length);	1,392✔
78
79	while(!b64.empty() && b64[b64.size() - 1] == '=') {	4,872✔
80	b64 = b64.substr(0, b64.size() - 1);	4,176✔
81	}
82
83	for(size_t i = 0; i != b64.size(); ++i) {	38,280✔
84	b64[i] = static_cast<char>(base64_to_bcrypt_encoding(static_cast<uint8_t>(b64[i])));	36,888✔
85	}
86
87	return b64;	1,392✔
88	}	×
89
90	std::vector<uint8_t> bcrypt_base64_decode(std::string_view input) {	391✔
91	std::string translated;	391✔
92	for(size_t i = 0; i != input.size(); ++i) {	8,993✔
93	char c = bcrypt_encoding_to_base64(static_cast<uint8_t>(input[i]));	8,602✔
94	translated.push_back(c);	8,602✔
95	}
96
97	return unlock(base64_decode(translated));	1,173✔
98	}	391✔
99
100	std::string make_bcrypt(std::string_view pass, const std::vector<uint8_t>& salt, uint16_t work_factor, char version) {	696✔
101	/*
102	* On a 4 GHz Skylake, workfactor == 18 takes about 15 seconds to
103	* hash a password. This seems like a reasonable upper bound for the
104	* time being.
105	* Bcrypt allows up to work factor 31 (2^31 iterations)
106	*/
107	BOTAN_ARG_CHECK(work_factor >= 4 && work_factor <= 18, "Invalid bcrypt work factor");	696✔
108
109	alignas(64) static const uint8_t BCRYPT_MAGIC[8 * 3] = {0x4F, 0x72, 0x70, 0x68, 0x65, 0x61, 0x6E, 0x42,	696✔
110	0x65, 0x68, 0x6F, 0x6C, 0x64, 0x65, 0x72, 0x53,
111	0x63, 0x72, 0x79, 0x44, 0x6F, 0x75, 0x62, 0x74};
112
113	Blowfish blowfish;	696✔
114
115	secure_vector<uint8_t> pass_with_trailing_null(pass.size() + 1);	696✔
116	copy_mem(pass_with_trailing_null.data(), cast_char_ptr_to_uint8(pass.data()), pass.length());	696✔
117
118	// Include the trailing NULL byte, so we need c_str() not data()
119	blowfish.salted_set_key(	696✔
120	pass_with_trailing_null.data(), pass_with_trailing_null.size(), salt.data(), salt.size(), work_factor);	696✔
121
122	std::vector<uint8_t> ctext(BCRYPT_MAGIC, BCRYPT_MAGIC + 8 * 3);	696✔
123
124	for(size_t i = 0; i != 64; ++i) {	45,240✔
125	blowfish.encrypt_n(ctext.data(), ctext.data(), 3);	44,544✔
126	}
127
128	std::string salt_b64 = bcrypt_base64_encode(salt.data(), salt.size());	696✔
129
130	std::string work_factor_str = std::to_string(work_factor);	696✔
131	if(work_factor_str.length() == 1) {	696✔
132	work_factor_str = "0" + work_factor_str;	674✔
133	}
134
135	return fmt("$2{}${}${}{}",	696✔
136	version,
137	work_factor_str,
138	salt_b64.substr(0, 22),	1,392✔
139	bcrypt_base64_encode(ctext.data(), ctext.size() - 1));	2,784✔
140	}	2,784✔
141
142	} // namespace
143
144	std::string generate_bcrypt(std::string_view pass, RandomNumberGenerator& rng, uint16_t work_factor, char version) {	306✔
145	/*
146	2a, 2b and 2y are identical for our purposes because our implementation of 2a
147	never had the truncation or signed char bugs in the first place.
148	*/
149
150	if(version != 'a' && version != 'b' && version != 'y') {	306✔
151	throw Invalid_Argument("Unknown bcrypt version '" + std::string(1, version) + "'");	2✔
152	}
153
154	std::vector<uint8_t> salt;	305✔
155	rng.random_vec(salt, 16);	305✔
156	return make_bcrypt(pass, salt, work_factor, version);	305✔
157	}	305✔
158
159	bool check_bcrypt(std::string_view pass, std::string_view hash) {	391✔
160	if(hash.size() != 60 \|\| hash[0] != '$' \|\| hash[1] != '2' \|\| hash[3] != '$' \|\| hash[6] != '$') {	391✔
161	return false;
162	}
163
164	const char bcrypt_version = hash[2];	391✔
165
166	if(bcrypt_version != 'a' && bcrypt_version != 'b' && bcrypt_version != 'y') {	391✔
167	return false;
168	}
169
170	const uint16_t workfactor = to_uint16(hash.substr(4, 2));	391✔
171
172	const std::vector<uint8_t> salt = bcrypt_base64_decode(hash.substr(7, 22));	391✔
173	if(salt.size() != 16) {	391✔
174	return false;
175	}
176
177	const std::string compare = make_bcrypt(pass, salt, workfactor, bcrypt_version);	391✔
178
179	return same_mem(hash.data(), compare.data(), compare.size());	782✔
180	}	782✔
181
182	} // namespace Botan

randombit / botan / 5123321399

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