Directory: | cvmfs/ |
---|---|
File: | cvmfs/crypto/hash.cc |
Date: | 2025-07-13 02:35:07 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 275 | 306 | 89.9% |
Branches: | 169 | 268 | 63.1% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /** | ||
2 | * This file is part of the CernVM File System. | ||
3 | */ | ||
4 | |||
5 | |||
6 | #include "crypto/hash.h" | ||
7 | |||
8 | #include <alloca.h> | ||
9 | #include <errno.h> | ||
10 | #include <fcntl.h> | ||
11 | #include <openssl/hmac.h> | ||
12 | #include <openssl/md5.h> | ||
13 | #include <openssl/ripemd.h> | ||
14 | #include <openssl/sha.h> | ||
15 | #include <unistd.h> | ||
16 | |||
17 | #include <cstdio> | ||
18 | #include <cstring> | ||
19 | |||
20 | #include "KeccakHash.h" | ||
21 | #include "crypto/openssl_version.h" | ||
22 | #include "util/exception.h" | ||
23 | |||
24 | |||
25 | using namespace std; // NOLINT | ||
26 | |||
27 | #ifdef CVMFS_NAMESPACE_GUARD | ||
28 | namespace CVMFS_NAMESPACE_GUARD { | ||
29 | #endif | ||
30 | |||
31 | namespace shash { | ||
32 | |||
33 | const char *kAlgorithmIds[] = {"", "", "-rmd160", "-shake128", ""}; | ||
34 | |||
35 | |||
36 | 132 | bool HexPtr::IsValid() const { | |
37 | 132 | const unsigned l = str->length(); | |
38 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 126 times.
|
132 | if (l == 0) |
39 | 6 | return false; | |
40 | 126 | const char *c = str->data(); // Walks through the string | |
41 | 126 | unsigned i = 0; // String position of *c | |
42 | |||
43 |
2/2✓ Branch 0 taken 4920 times.
✓ Branch 1 taken 30 times.
|
4950 | for (; i < l; ++i, ++c) { |
44 |
2/2✓ Branch 0 taken 84 times.
✓ Branch 1 taken 4836 times.
|
4920 | if (*c == '-') |
45 | 84 | break; | |
46 |
6/8✓ Branch 0 taken 4836 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4836 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1962 times.
✓ Branch 5 taken 2874 times.
✓ Branch 6 taken 12 times.
✓ Branch 7 taken 1950 times.
|
4836 | if ((*c < '0') || (*c > 'f') || ((*c > '9') && (*c < 'a'))) |
47 | 12 | return false; | |
48 | } | ||
49 | |||
50 | // Walk through all algorithms | ||
51 |
2/2✓ Branch 0 taken 420 times.
✓ Branch 1 taken 90 times.
|
510 | for (unsigned j = 0; j < kAny; ++j) { |
52 | 420 | const unsigned hex_length = 2 * kDigestSizes[j]; | |
53 | 420 | const unsigned algo_id_length = kAlgorithmIdSizes[j]; | |
54 |
2/2✓ Branch 0 taken 132 times.
✓ Branch 1 taken 288 times.
|
420 | if (i == hex_length) { |
55 | // Right suffix? | ||
56 |
4/4✓ Branch 0 taken 366 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 318 times.
✓ Branch 3 taken 48 times.
|
390 | for (; (i < l) && (i - hex_length < algo_id_length); ++i, ++c) { |
57 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 258 times.
|
318 | if (*c != kAlgorithmIds[j][i - hex_length]) |
58 | 60 | break; | |
59 | } | ||
60 |
3/4✓ Branch 0 taken 24 times.
✓ Branch 1 taken 108 times.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
|
132 | if ((i == l) && (l == hex_length + algo_id_length)) |
61 | 24 | return true; | |
62 | 108 | i = hex_length; | |
63 | 108 | c = str->data() + i; | |
64 | } | ||
65 | } | ||
66 | |||
67 | 90 | return false; | |
68 | } | ||
69 | |||
70 | |||
71 | ✗ | Algorithms ParseHashAlgorithm(const string &algorithm_option) { | |
72 | ✗ | if (algorithm_option == "sha1") | |
73 | ✗ | return kSha1; | |
74 | ✗ | if (algorithm_option == "rmd160") | |
75 | ✗ | return kRmd160; | |
76 | ✗ | if (algorithm_option == "shake128") | |
77 | ✗ | return kShake128; | |
78 | ✗ | return kAny; | |
79 | } | ||
80 | |||
81 | |||
82 | 167999 | Any MkFromHexPtr(const HexPtr hex, const char suffix) { | |
83 | 167999 | Any result; | |
84 | |||
85 | 167999 | const unsigned length = hex.str->length(); | |
86 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 167993 times.
|
167999 | if (length == 2 * kDigestSizes[kMd5]) |
87 | 6 | result = Any(kMd5, hex); | |
88 |
2/2✓ Branch 0 taken 167899 times.
✓ Branch 1 taken 100 times.
|
167999 | if (length == 2 * kDigestSizes[kSha1]) |
89 | 167899 | result = Any(kSha1, hex); | |
90 | // TODO(jblomer) compare -rmd160, -shake128 | ||
91 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 167990 times.
|
167999 | if ((length == 2 * kDigestSizes[kRmd160] + kAlgorithmIdSizes[kRmd160])) |
92 | 9 | result = Any(kRmd160, hex); | |
93 |
2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 167981 times.
|
167999 | if ((length == 2 * kDigestSizes[kShake128] + kAlgorithmIdSizes[kShake128])) |
94 | 18 | result = Any(kShake128, hex); | |
95 | |||
96 | 167999 | result.suffix = suffix; | |
97 | 167999 | return result; | |
98 | } | ||
99 | |||
100 | |||
101 | /** | ||
102 | * Similar to MkFromHexPtr but the suffix is deducted from the HexPtr string. | ||
103 | */ | ||
104 | 20010 | Any MkFromSuffixedHexPtr(const HexPtr hex) { | |
105 | 20010 | Any result; | |
106 | |||
107 | 20010 | const unsigned length = hex.str->length(); | |
108 |
2/2✓ Branch 0 taken 1713 times.
✓ Branch 1 taken 18297 times.
|
20010 | if ((length == 2 * kDigestSizes[kMd5]) |
109 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1707 times.
|
1713 | || (length == 2 * kDigestSizes[kMd5] + 1)) { |
110 | 18303 | const Suffix suffix = (length == 2 * kDigestSizes[kMd5] + 1) | |
111 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 18297 times.
|
18303 | ? *(hex.str->rbegin()) |
112 | 18303 | : kSuffixNone; | |
113 | 18303 | result = Any(kMd5, hex, suffix); | |
114 | } | ||
115 |
2/2✓ Branch 0 taken 19101 times.
✓ Branch 1 taken 909 times.
|
20010 | if ((length == 2 * kDigestSizes[kSha1]) |
116 |
2/2✓ Branch 0 taken 762 times.
✓ Branch 1 taken 18339 times.
|
19101 | || (length == 2 * kDigestSizes[kSha1] + 1)) { |
117 | 1671 | const Suffix suffix = (length == 2 * kDigestSizes[kSha1] + 1) | |
118 |
2/2✓ Branch 0 taken 762 times.
✓ Branch 1 taken 909 times.
|
1671 | ? *(hex.str->rbegin()) |
119 | 1671 | : kSuffixNone; | |
120 | 1671 | result = Any(kSha1, hex, suffix); | |
121 | } | ||
122 |
2/2✓ Branch 0 taken 20004 times.
✓ Branch 1 taken 6 times.
|
20010 | if ((length == 2 * kDigestSizes[kRmd160] + kAlgorithmIdSizes[kRmd160]) |
123 | 20004 | || (length | |
124 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 19992 times.
|
20004 | == 2 * kDigestSizes[kRmd160] + kAlgorithmIdSizes[kRmd160] + 1)) { |
125 | const Suffix suffix = (length | ||
126 | 18 | == 2 * kDigestSizes[kRmd160] | |
127 | 18 | + kAlgorithmIdSizes[kRmd160] + 1) | |
128 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 6 times.
|
18 | ? *(hex.str->rbegin()) |
129 | 18 | : kSuffixNone; | |
130 | 18 | result = Any(kRmd160, hex, suffix); | |
131 | } | ||
132 |
2/2✓ Branch 0 taken 20004 times.
✓ Branch 1 taken 6 times.
|
20010 | if ((length == 2 * kDigestSizes[kShake128] + kAlgorithmIdSizes[kShake128]) |
133 | 20004 | || (length | |
134 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 19998 times.
|
20004 | == 2 * kDigestSizes[kShake128] + kAlgorithmIdSizes[kShake128] + 1)) { |
135 | const Suffix suffix = (length | ||
136 | 12 | == 2 * kDigestSizes[kShake128] | |
137 | 12 | + kAlgorithmIdSizes[kShake128] + 1) | |
138 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.
|
12 | ? *(hex.str->rbegin()) |
139 | 12 | : kSuffixNone; | |
140 | 12 | result = Any(kShake128, hex, suffix); | |
141 | } | ||
142 | |||
143 | 20010 | return result; | |
144 | } | ||
145 | |||
146 | |||
147 | /** | ||
148 | * Allows the caller to create the context on the stack. | ||
149 | */ | ||
150 | 1392079 | unsigned GetContextSize(const Algorithms algorithm) { | |
151 |
4/5✓ Branch 0 taken 610095 times.
✓ Branch 1 taken 781367 times.
✓ Branch 2 taken 74 times.
✓ Branch 3 taken 561 times.
✗ Branch 4 not taken.
|
1392079 | switch (algorithm) { |
152 | 610095 | case kMd5: | |
153 | 610095 | return sizeof(MD5_CTX); | |
154 | 781367 | case kSha1: | |
155 | 781367 | return sizeof(SHA_CTX); | |
156 | 74 | case kRmd160: | |
157 | 74 | return sizeof(RIPEMD160_CTX); | |
158 | 561 | case kShake128: | |
159 | 561 | return sizeof(Keccak_HashInstance); | |
160 | ✗ | default: | |
161 | ✗ | PANIC(kLogDebug | kLogSyslogErr, | |
162 | "tried to generate hash context for unspecified hash. Aborting..."); | ||
163 | } | ||
164 | } | ||
165 | |||
166 | 1392121 | void Init(ContextPtr context) { | |
167 | HashReturn keccak_result; | ||
168 |
4/5✓ Branch 0 taken 610113 times.
✓ Branch 1 taken 781373 times.
✓ Branch 2 taken 74 times.
✓ Branch 3 taken 561 times.
✗ Branch 4 not taken.
|
1392121 | switch (context.algorithm) { |
169 | 610113 | case kMd5: | |
170 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 610113 times.
|
610113 | assert(context.size == sizeof(MD5_CTX)); |
171 | 610113 | MD5_Init(reinterpret_cast<MD5_CTX *>(context.buffer)); | |
172 | 610113 | break; | |
173 | 781373 | case kSha1: | |
174 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 781373 times.
|
781373 | assert(context.size == sizeof(SHA_CTX)); |
175 | 781373 | SHA1_Init(reinterpret_cast<SHA_CTX *>(context.buffer)); | |
176 | 781187 | break; | |
177 | 74 | case kRmd160: | |
178 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
|
74 | assert(context.size == sizeof(RIPEMD160_CTX)); |
179 | 74 | RIPEMD160_Init(reinterpret_cast<RIPEMD160_CTX *>(context.buffer)); | |
180 | 74 | break; | |
181 | 561 | case kShake128: | |
182 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 561 times.
|
561 | assert(context.size == sizeof(Keccak_HashInstance)); |
183 | 561 | keccak_result = Keccak_HashInitialize_SHAKE128( | |
184 | reinterpret_cast<Keccak_HashInstance *>(context.buffer)); | ||
185 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 561 times.
|
561 | assert(keccak_result == SUCCESS); |
186 | 561 | break; | |
187 | ✗ | default: | |
188 | ✗ | PANIC(NULL); // Undefined hash | |
189 | } | ||
190 | 1391935 | } | |
191 | |||
192 | 559058580 | void Update(const unsigned char *buffer, const unsigned buffer_length, | |
193 | ContextPtr context) { | ||
194 | HashReturn keccak_result; | ||
195 |
4/5✓ Branch 0 taken 142321446 times.
✓ Branch 1 taken 139912507 times.
✓ Branch 2 taken 138412118 times.
✓ Branch 3 taken 138412578 times.
✗ Branch 4 not taken.
|
559058580 | switch (context.algorithm) { |
196 | 142321446 | case kMd5: | |
197 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 142321446 times.
|
142321446 | assert(context.size == sizeof(MD5_CTX)); |
198 | 142321446 | MD5_Update(reinterpret_cast<MD5_CTX *>(context.buffer), buffer, | |
199 | buffer_length); | ||
200 | 142321446 | break; | |
201 | 139912507 | case kSha1: | |
202 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 139912507 times.
|
139912507 | assert(context.size == sizeof(SHA_CTX)); |
203 | 139912507 | SHA1_Update(reinterpret_cast<SHA_CTX *>(context.buffer), buffer, | |
204 | buffer_length); | ||
205 | 139916005 | break; | |
206 | 138412118 | case kRmd160: | |
207 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 138412118 times.
|
138412118 | assert(context.size == sizeof(RIPEMD160_CTX)); |
208 | 138412118 | RIPEMD160_Update(reinterpret_cast<RIPEMD160_CTX *>(context.buffer), | |
209 | buffer, buffer_length); | ||
210 | 138412118 | break; | |
211 | 138412578 | case kShake128: | |
212 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 138412578 times.
|
138412578 | assert(context.size == sizeof(Keccak_HashInstance)); |
213 | 276825156 | keccak_result = Keccak_HashUpdate( | |
214 | 138412578 | reinterpret_cast<Keccak_HashInstance *>(context.buffer), buffer, | |
215 | 138412578 | buffer_length * 8); | |
216 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 138412578 times.
|
138412578 | assert(keccak_result == SUCCESS); |
217 | 138412578 | break; | |
218 | ✗ | default: | |
219 | ✗ | PANIC(NULL); // Undefined hash | |
220 | } | ||
221 | 559062147 | } | |
222 | |||
223 | 1373110 | void Final(ContextPtr context, Any *any_digest) { | |
224 | HashReturn keccak_result; | ||
225 |
4/5✓ Branch 0 taken 610089 times.
✓ Branch 1 taken 762452 times.
✓ Branch 2 taken 74 times.
✓ Branch 3 taken 561 times.
✗ Branch 4 not taken.
|
1373110 | switch (context.algorithm) { |
226 | 610089 | case kMd5: | |
227 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 610089 times.
|
610089 | assert(context.size == sizeof(MD5_CTX)); |
228 | 610089 | MD5_Final(any_digest->digest, | |
229 | 610089 | reinterpret_cast<MD5_CTX *>(context.buffer)); | |
230 | 610089 | break; | |
231 | 762452 | case kSha1: | |
232 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 762452 times.
|
762452 | assert(context.size == sizeof(SHA_CTX)); |
233 | 762452 | SHA1_Final(any_digest->digest, | |
234 | 762452 | reinterpret_cast<SHA_CTX *>(context.buffer)); | |
235 | 767552 | break; | |
236 | 74 | case kRmd160: | |
237 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 74 times.
|
74 | assert(context.size == sizeof(RIPEMD160_CTX)); |
238 | 74 | RIPEMD160_Final(any_digest->digest, | |
239 | 74 | reinterpret_cast<RIPEMD160_CTX *>(context.buffer)); | |
240 | 74 | break; | |
241 | 561 | case kShake128: | |
242 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 561 times.
|
561 | assert(context.size == sizeof(Keccak_HashInstance)); |
243 | 1122 | keccak_result = Keccak_HashFinal( | |
244 | 561 | reinterpret_cast<Keccak_HashInstance *>(context.buffer), NULL); | |
245 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 561 times.
|
561 | assert(keccak_result == SUCCESS); |
246 | 1122 | keccak_result = Keccak_HashSqueeze( | |
247 | 561 | reinterpret_cast<Keccak_HashInstance *>(context.buffer), | |
248 | 561 | any_digest->digest, kDigestSizes[kShake128] * 8); | |
249 | 561 | break; | |
250 | ✗ | default: | |
251 | ✗ | PANIC(NULL); // Undefined hash | |
252 | } | ||
253 | 1378276 | any_digest->algorithm = context.algorithm; | |
254 | 1378276 | } | |
255 | |||
256 | |||
257 | 11082 | void HashMem(const unsigned char *buffer, const unsigned buffer_size, | |
258 | Any *any_digest) { | ||
259 | 11082 | const Algorithms algorithm = any_digest->algorithm; | |
260 |
1/2✓ Branch 1 taken 11082 times.
✗ Branch 2 not taken.
|
11082 | ContextPtr context(algorithm); |
261 | 11082 | context.buffer = alloca(context.size); | |
262 | |||
263 |
1/2✓ Branch 1 taken 11082 times.
✗ Branch 2 not taken.
|
11082 | Init(context); |
264 |
1/2✓ Branch 1 taken 11082 times.
✗ Branch 2 not taken.
|
11082 | Update(buffer, buffer_size, context); |
265 |
1/2✓ Branch 1 taken 11082 times.
✗ Branch 2 not taken.
|
11082 | Final(context, any_digest); |
266 | 11082 | } | |
267 | |||
268 | |||
269 | 735 | void HashString(const std::string &content, Any *any_digest) { | |
270 | 735 | HashMem(reinterpret_cast<const unsigned char *>(content.data()), | |
271 | 735 | content.length(), any_digest); | |
272 | 735 | } | |
273 | |||
274 | |||
275 | 303750 | void Hmac(const string &key, | |
276 | const unsigned char *buffer, | ||
277 | const unsigned buffer_size, | ||
278 | Any *any_digest) { | ||
279 | 303750 | const Algorithms algorithm = any_digest->algorithm; | |
280 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 303750 times.
|
303750 | assert(algorithm != kAny); |
281 | |||
282 | 303750 | const unsigned block_size = kBlockSizes[algorithm]; | |
283 | 303750 | unsigned char key_block[block_size]; | |
284 | 303750 | memset(key_block, 0, block_size); | |
285 |
2/2✓ Branch 1 taken 3666 times.
✓ Branch 2 taken 300084 times.
|
303750 | if (key.length() > block_size) { |
286 |
1/2✓ Branch 1 taken 3666 times.
✗ Branch 2 not taken.
|
3666 | Any hash_key(algorithm); |
287 |
1/2✓ Branch 3 taken 3666 times.
✗ Branch 4 not taken.
|
3666 | HashMem(reinterpret_cast<const unsigned char *>(key.data()), key.length(), |
288 | &hash_key); | ||
289 | 3666 | memcpy(key_block, hash_key.digest, kDigestSizes[algorithm]); | |
290 | } else { | ||
291 |
2/2✓ Branch 1 taken 300066 times.
✓ Branch 2 taken 18 times.
|
300084 | if (key.length() > 0) |
292 | 300066 | memcpy(key_block, key.data(), key.length()); | |
293 | } | ||
294 | |||
295 | 303750 | unsigned char pad_block[block_size]; | |
296 | // Inner hash | ||
297 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | Any hash_inner(algorithm); |
298 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | ContextPtr context_inner(algorithm); |
299 | 303750 | context_inner.buffer = alloca(context_inner.size); | |
300 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | Init(context_inner); |
301 |
2/2✓ Branch 0 taken 19440000 times.
✓ Branch 1 taken 303750 times.
|
19743750 | for (unsigned i = 0; i < block_size; ++i) |
302 | 19440000 | pad_block[i] = key_block[i] ^ 0x36; | |
303 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | Update(pad_block, block_size, context_inner); |
304 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | Update(buffer, buffer_size, context_inner); |
305 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | Final(context_inner, &hash_inner); |
306 | |||
307 | // Outer hash | ||
308 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | ContextPtr context_outer(algorithm); |
309 | 303750 | context_outer.buffer = alloca(context_outer.size); | |
310 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | Init(context_outer); |
311 |
2/2✓ Branch 0 taken 19440000 times.
✓ Branch 1 taken 303750 times.
|
19743750 | for (unsigned i = 0; i < block_size; ++i) |
312 | 19440000 | pad_block[i] = key_block[i] ^ 0x5c; | |
313 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | Update(pad_block, block_size, context_outer); |
314 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | Update(hash_inner.digest, kDigestSizes[algorithm], context_outer); |
315 | |||
316 |
1/2✓ Branch 1 taken 303750 times.
✗ Branch 2 not taken.
|
303750 | Final(context_outer, any_digest); |
317 | 303750 | } | |
318 | |||
319 | |||
320 | 6823 | bool HashFd(int fd, Any *any_digest) { | |
321 | 6823 | const Algorithms algorithm = any_digest->algorithm; | |
322 |
1/2✓ Branch 1 taken 6823 times.
✗ Branch 2 not taken.
|
6823 | ContextPtr context(algorithm); |
323 | 6823 | context.buffer = alloca(context.size); | |
324 | |||
325 |
1/2✓ Branch 1 taken 6823 times.
✗ Branch 2 not taken.
|
6823 | Init(context); |
326 | unsigned char io_buffer[4096]; | ||
327 | int actual_bytes; | ||
328 |
3/4✓ Branch 1 taken 3031415 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3024592 times.
✓ Branch 4 taken 6823 times.
|
3031415 | while ((actual_bytes = read(fd, io_buffer, 4096)) != 0) { |
329 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3024592 times.
|
3024592 | if (actual_bytes == -1) { |
330 | ✗ | if (errno == EINTR) | |
331 | ✗ | continue; | |
332 | ✗ | return false; | |
333 | } | ||
334 |
1/2✓ Branch 1 taken 3024592 times.
✗ Branch 2 not taken.
|
3024592 | Update(io_buffer, actual_bytes, context); |
335 | } | ||
336 |
1/2✓ Branch 1 taken 6823 times.
✗ Branch 2 not taken.
|
6823 | Final(context, any_digest); |
337 | 6823 | return true; | |
338 | } | ||
339 | |||
340 | |||
341 | 6823 | bool HashFile(const std::string &filename, Any *any_digest) { | |
342 | 6823 | const int fd = open(filename.c_str(), O_RDONLY); | |
343 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6823 times.
|
6823 | if (fd == -1) |
344 | ✗ | return false; | |
345 | |||
346 | 6823 | const bool result = HashFd(fd, any_digest); | |
347 | 6823 | close(fd); | |
348 | 6823 | return result; | |
349 | } | ||
350 | |||
351 | |||
352 | /** | ||
353 | * Fast constructor for hashing path names. | ||
354 | */ | ||
355 | 8592 | Md5::Md5(const AsciiPtr ascii) { | |
356 | 8592 | algorithm = kMd5; | |
357 | 8592 | const string *str = ascii.str; | |
358 | |||
359 | MD5_CTX md5_state; | ||
360 |
1/2✓ Branch 1 taken 8592 times.
✗ Branch 2 not taken.
|
8592 | MD5_Init(&md5_state); |
361 |
1/2✓ Branch 3 taken 8592 times.
✗ Branch 4 not taken.
|
8592 | MD5_Update(&md5_state, reinterpret_cast<const unsigned char *>(&(*str)[0]), |
362 | str->length()); | ||
363 |
1/2✓ Branch 1 taken 8592 times.
✗ Branch 2 not taken.
|
8592 | MD5_Final(digest, &md5_state); |
364 | 8592 | } | |
365 | |||
366 | |||
367 | 8903354 | Md5::Md5(const char *chars, const unsigned length) { | |
368 | 8903354 | algorithm = kMd5; | |
369 | |||
370 | MD5_CTX md5_state; | ||
371 |
1/2✓ Branch 1 taken 8903354 times.
✗ Branch 2 not taken.
|
8903354 | MD5_Init(&md5_state); |
372 |
1/2✓ Branch 1 taken 8903354 times.
✗ Branch 2 not taken.
|
8903354 | MD5_Update(&md5_state, reinterpret_cast<const unsigned char *>(chars), |
373 | length); | ||
374 |
1/2✓ Branch 1 taken 8903354 times.
✗ Branch 2 not taken.
|
8903354 | MD5_Final(digest, &md5_state); |
375 | 8903354 | } | |
376 | |||
377 | |||
378 | ✗ | Md5::Md5(const uint64_t lo, const uint64_t hi) { | |
379 | ✗ | algorithm = kMd5; | |
380 | ✗ | memcpy(digest, &lo, 8); | |
381 | ✗ | memcpy(digest + 8, &hi, 8); | |
382 | } | ||
383 | |||
384 | 11375 | void Md5::ToIntPair(uint64_t *lo, uint64_t *hi) const { | |
385 | 11375 | memcpy(lo, digest, 8); | |
386 | 11375 | memcpy(hi, digest + 8, 8); | |
387 | 11375 | } | |
388 | |||
389 | |||
390 | 300070 | Md5 Any::CastToMd5() { | |
391 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 300070 times.
|
300070 | assert(algorithm == kMd5); |
392 | 300070 | Md5 result; | |
393 | 300070 | memcpy(result.digest, digest, kDigestSizes[kMd5]); | |
394 | 300070 | return result; | |
395 | } | ||
396 | |||
397 | #ifndef OPENSSL_API_INTERFACE_V09 | ||
398 | 36 | static string HexFromSha256(unsigned char digest[SHA256_DIGEST_LENGTH]) { | |
399 | 36 | string result; | |
400 |
1/2✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
|
36 | result.reserve(2 * SHA256_DIGEST_LENGTH); |
401 |
2/2✓ Branch 0 taken 1152 times.
✓ Branch 1 taken 36 times.
|
1188 | for (unsigned i = 0; i < SHA256_DIGEST_LENGTH; ++i) { |
402 | 1152 | const char d1 = digest[i] / 16; | |
403 | 1152 | const char d2 = digest[i] % 16; | |
404 |
3/4✓ Branch 0 taken 666 times.
✓ Branch 1 taken 486 times.
✓ Branch 3 taken 1152 times.
✗ Branch 4 not taken.
|
1152 | result.push_back(d1 + ((d1 <= 9) ? '0' : 'a' - 10)); |
405 |
3/4✓ Branch 0 taken 798 times.
✓ Branch 1 taken 354 times.
✓ Branch 3 taken 1152 times.
✗ Branch 4 not taken.
|
1152 | result.push_back(d2 + ((d2 <= 9) ? '0' : 'a' - 10)); |
406 | } | ||
407 | 36 | return result; | |
408 | } | ||
409 | #endif | ||
410 | |||
411 | 6 | string Sha256File(const string &filename) { | |
412 | #ifdef OPENSSL_API_INTERFACE_V09 | ||
413 | PANIC(NULL); | ||
414 | #else | ||
415 |
1/2✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
|
6 | const int fd = open(filename.c_str(), O_RDONLY); |
416 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (fd < 0) |
417 | ✗ | return ""; | |
418 | |||
419 | SHA256_CTX ctx; | ||
420 |
1/2✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
|
6 | SHA256_Init(&ctx); |
421 | |||
422 | unsigned char io_buffer[4096]; | ||
423 | int actual_bytes; | ||
424 |
2/4✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
|
6 | while ((actual_bytes = read(fd, io_buffer, 4096)) != 0) { |
425 | ✗ | if (actual_bytes == -1) { | |
426 | ✗ | if (errno == EINTR) | |
427 | ✗ | continue; | |
428 | ✗ | close(fd); | |
429 | ✗ | return ""; | |
430 | } | ||
431 | ✗ | SHA256_Update(&ctx, io_buffer, actual_bytes); | |
432 | } | ||
433 |
1/2✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
|
6 | close(fd); |
434 | |||
435 | unsigned char digest[SHA256_DIGEST_LENGTH]; | ||
436 |
1/2✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
|
6 | SHA256_Final(digest, &ctx); |
437 |
1/2✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
|
6 | return HexFromSha256(digest); |
438 | #endif | ||
439 | } | ||
440 | |||
441 | 12 | string Sha256Mem(const unsigned char *buffer, const unsigned buffer_size) { | |
442 | #ifdef OPENSSL_API_INTERFACE_V09 | ||
443 | PANIC(NULL); | ||
444 | #else | ||
445 | unsigned char digest[SHA256_DIGEST_LENGTH]; | ||
446 |
1/2✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
|
12 | SHA256(buffer, buffer_size, digest); |
447 |
1/2✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
|
24 | return HexFromSha256(digest); |
448 | #endif | ||
449 | } | ||
450 | |||
451 | 6 | string Sha256String(const string &content) { | |
452 | 6 | return Sha256Mem(reinterpret_cast<const unsigned char *>(content.data()), | |
453 | 6 | content.length()); | |
454 | } | ||
455 | |||
456 | |||
457 | 42 | std::string Hmac256(const std::string &key, | |
458 | const std::string &content, | ||
459 | bool raw_output) { | ||
460 | #ifdef OPENSSL_API_INTERFACE_V09 | ||
461 | PANIC(NULL); | ||
462 | #else | ||
463 | unsigned char digest[SHA256_DIGEST_LENGTH]; | ||
464 | 42 | const unsigned block_size = 64; | |
465 | 42 | const unsigned key_length = key.length(); | |
466 | unsigned char key_block[block_size]; | ||
467 | 42 | memset(key_block, 0, block_size); | |
468 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 36 times.
|
42 | if (key_length > block_size) { |
469 |
1/2✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
|
6 | SHA256(reinterpret_cast<const unsigned char *>(key.data()), key_length, |
470 | key_block); | ||
471 | } else { | ||
472 |
1/2✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
|
36 | if (key.length() > 0) |
473 | 36 | memcpy(key_block, key.data(), key_length); | |
474 | } | ||
475 | |||
476 | unsigned char pad_block[block_size]; | ||
477 | // Inner hash | ||
478 | SHA256_CTX ctx_inner; | ||
479 | unsigned char digest_inner[SHA256_DIGEST_LENGTH]; | ||
480 |
1/2✓ Branch 1 taken 42 times.
✗ Branch 2 not taken.
|
42 | SHA256_Init(&ctx_inner); |
481 |
2/2✓ Branch 0 taken 2688 times.
✓ Branch 1 taken 42 times.
|
2730 | for (unsigned i = 0; i < block_size; ++i) |
482 | 2688 | pad_block[i] = key_block[i] ^ 0x36; | |
483 |
1/2✓ Branch 1 taken 42 times.
✗ Branch 2 not taken.
|
42 | SHA256_Update(&ctx_inner, pad_block, block_size); |
484 |
1/2✓ Branch 3 taken 42 times.
✗ Branch 4 not taken.
|
42 | SHA256_Update(&ctx_inner, content.data(), content.length()); |
485 |
1/2✓ Branch 1 taken 42 times.
✗ Branch 2 not taken.
|
42 | SHA256_Final(digest_inner, &ctx_inner); |
486 | |||
487 | // Outer hash | ||
488 | SHA256_CTX ctx_outer; | ||
489 |
1/2✓ Branch 1 taken 42 times.
✗ Branch 2 not taken.
|
42 | SHA256_Init(&ctx_outer); |
490 |
2/2✓ Branch 0 taken 2688 times.
✓ Branch 1 taken 42 times.
|
2730 | for (unsigned i = 0; i < block_size; ++i) |
491 | 2688 | pad_block[i] = key_block[i] ^ 0x5c; | |
492 |
1/2✓ Branch 1 taken 42 times.
✗ Branch 2 not taken.
|
42 | SHA256_Update(&ctx_outer, pad_block, block_size); |
493 |
1/2✓ Branch 1 taken 42 times.
✗ Branch 2 not taken.
|
42 | SHA256_Update(&ctx_outer, digest_inner, SHA256_DIGEST_LENGTH); |
494 | |||
495 |
1/2✓ Branch 1 taken 42 times.
✗ Branch 2 not taken.
|
42 | SHA256_Final(digest, &ctx_outer); |
496 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 18 times.
|
42 | if (raw_output) |
497 |
1/2✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
|
24 | return string(reinterpret_cast<const char *>(digest), SHA256_DIGEST_LENGTH); |
498 |
1/2✓ Branch 1 taken 18 times.
✗ Branch 2 not taken.
|
18 | return HexFromSha256(digest); |
499 | #endif | ||
500 | } | ||
501 | |||
502 | } // namespace shash | ||
503 | |||
504 | #ifdef CVMFS_NAMESPACE_GUARD | ||
505 | } // namespace CVMFS_NAMESPACE_GUARD | ||
506 | #endif | ||
507 |