Debian Codegraph @

deps/curl/lib/sha256.c

raw
1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 2017, Florin Petriuc, <[email protected]>
9 * Copyright (C) 2018 - 2020, Daniel Stenberg, <[email protected]>, et al.
10 *
11 * This software is licensed as described in the file COPYING, which
12 * you should have received as part of this distribution. The terms
13 * are also available at https://curl.haxx.se/docs/copyright.html.
14 *
15 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
16 * copies of the Software, and permit persons to whom the Software is
17 * furnished to do so, under the terms of the COPYING file.
18 *
19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20 * KIND, either express or implied.
21 *
22 ***************************************************************************/
23
24 #include "curl_setup.h"
25
26 #ifndef CURL_DISABLE_CRYPTO_AUTH
27
28 #include "warnless.h"
29 #include "curl_sha256.h"
30
31 #if defined(USE_OPENSSL)
32
33 #include <openssl/opensslv.h>
34
35 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL)
36 #define USE_OPENSSL_SHA256
37 #endif
38
39 #endif /* USE_OPENSSL */
40
41 #ifdef USE_MBEDTLS
42 #include <mbedtls/version.h>
43
44 #if(MBEDTLS_VERSION_NUMBER >= 0x02070000)
45 #define HAS_RESULT_CODE_BASED_FUNCTIONS
46 #endif
47 #endif /* USE_MBEDTLS */
48
49 /* Please keep the SSL backend-specific #if branches in this order:
50 *
51 * 1. USE_OPENSSL
52 * 2. USE_GNUTLS_NETTLE
53 * 3. USE_GNUTLS
54 * 4. USE_MBEDTLS
55 * 5. USE_COMMON_CRYPTO
56 * 6. USE_WIN32_CRYPTO
57 *
58 * This ensures that the same SSL branch gets activated throughout this source
59 * file even if multiple backends are enabled at the same time.
60 */
61
62 #if defined(USE_OPENSSL_SHA256)
63
64 /* When OpenSSL is available we use the SHA256-function from OpenSSL */
65 #include <openssl/sha.h>
66
67 #elif defined(USE_GNUTLS_NETTLE)
68
69 #include <nettle/sha.h>
70
71 #include "curl_memory.h"
72
73 /* The last #include file should be: */
74 #include "memdebug.h"
75
76 typedef struct sha256_ctx SHA256_CTX;
77
78 static void SHA256_Init(SHA256_CTX *ctx)
79 {
80 sha256_init(ctx);
81 }
82
83 static void SHA256_Update(SHA256_CTX *ctx,
84 const unsigned char *data,
85 unsigned int length)
86 {
87 sha256_update(ctx, length, data);
88 }
89
90 static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx)
91 {
92 sha256_digest(ctx, SHA256_DIGEST_SIZE, digest);
93 }
94
95 #elif defined(USE_GNUTLS)
96
97 #include <gcrypt.h>
98
99 #include "curl_memory.h"
100
101 /* The last #include file should be: */
102 #include "memdebug.h"
103
104 typedef gcry_md_hd_t SHA256_CTX;
105
106 static void SHA256_Init(SHA256_CTX *ctx)
107 {
108 gcry_md_open(ctx, GCRY_MD_SHA256, 0);
109 }
110
111 static void SHA256_Update(SHA256_CTX *ctx,
112 const unsigned char *data,
113 unsigned int length)
114 {
115 gcry_md_write(*ctx, data, length);
116 }
117
118 static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx)
119 {
120 memcpy(digest, gcry_md_read(*ctx, 0), SHA256_DIGEST_LENGTH);
121 gcry_md_close(*ctx);
122 }
123
124 #elif defined(USE_MBEDTLS)
125
126 #include <mbedtls/sha256.h>
127
128 #include "curl_memory.h"
129
130 /* The last #include file should be: */
131 #include "memdebug.h"
132
133 typedef mbedtls_sha256_context SHA256_CTX;
134
135 static void SHA256_Init(SHA256_CTX *ctx)
136 {
137 #if !defined(HAS_RESULT_CODE_BASED_FUNCTIONS)
138 mbedtls_sha256_starts(ctx, 0);
139 #else
140 (void) mbedtls_sha256_starts_ret(ctx, 0);
141 #endif
142 }
143
144 static void SHA256_Update(SHA256_CTX *ctx,
145 const unsigned char *data,
146 unsigned int length)
147 {
148 #if !defined(HAS_RESULT_CODE_BASED_FUNCTIONS)
149 mbedtls_sha256_update(ctx, data, length);
150 #else
151 (void) mbedtls_sha256_update_ret(ctx, data, length);
152 #endif
153 }
154
155 static void SHA256_Final(unsigned char *digest, SHA256_CTX *ctx)
156 {
157 #if !defined(HAS_RESULT_CODE_BASED_FUNCTIONS)
158 mbedtls_sha256_finish(ctx, digest);
159 #else
160 (void) mbedtls_sha256_finish_ret(ctx, digest);
161 #endif
162 }
163
164 #else
165
166 /* When no other crypto library is available we use this code segment */
167
168 /* This is based on SHA256 implementation in LibTomCrypt that was released into
169 * public domain by Tom St Denis. */
170
171 #define WPA_GET_BE32(a) ((((unsigned long)(a)[0]) << 24) | \
172 (((unsigned long)(a)[1]) << 16) | \
173 (((unsigned long)(a)[2]) << 8) | \
174 ((unsigned long)(a)[3]))
175 #define WPA_PUT_BE32(a, val) \
176 do { \
177 (a)[0] = (unsigned char)((((unsigned long) (val)) >> 24) & 0xff); \
178 (a)[1] = (unsigned char)((((unsigned long) (val)) >> 16) & 0xff); \
179 (a)[2] = (unsigned char)((((unsigned long) (val)) >> 8) & 0xff); \
180 (a)[3] = (unsigned char)(((unsigned long) (val)) & 0xff); \
181 } while(0)
182
183 #ifdef HAVE_LONGLONG
184 #define WPA_PUT_BE64(a, val) \
185 do { \
186 (a)[0] = (unsigned char)(((unsigned long long)(val)) >> 56); \
187 (a)[1] = (unsigned char)(((unsigned long long)(val)) >> 48); \
188 (a)[2] = (unsigned char)(((unsigned long long)(val)) >> 40); \
189 (a)[3] = (unsigned char)(((unsigned long long)(val)) >> 32); \
190 (a)[4] = (unsigned char)(((unsigned long long)(val)) >> 24); \
191 (a)[5] = (unsigned char)(((unsigned long long)(val)) >> 16); \
192 (a)[6] = (unsigned char)(((unsigned long long)(val)) >> 8); \
193 (a)[7] = (unsigned char)(((unsigned long long)(val)) & 0xff); \
194 } while(0)
195 #else
196 #define WPA_PUT_BE64(a, val) \
197 do { \
198 (a)[0] = (unsigned char)(((unsigned __int64)(val)) >> 56); \
199 (a)[1] = (unsigned char)(((unsigned __int64)(val)) >> 48); \
200 (a)[2] = (unsigned char)(((unsigned __int64)(val)) >> 40); \
201 (a)[3] = (unsigned char)(((unsigned __int64)(val)) >> 32); \
202 (a)[4] = (unsigned char)(((unsigned __int64)(val)) >> 24); \
203 (a)[5] = (unsigned char)(((unsigned __int64)(val)) >> 16); \
204 (a)[6] = (unsigned char)(((unsigned __int64)(val)) >> 8); \
205 (a)[7] = (unsigned char)(((unsigned __int64)(val)) & 0xff); \
206 } while(0)
207 #endif
208
209 typedef struct sha256_state {
210 #ifdef HAVE_LONGLONG
211 unsigned long long length;
212 #else
213 unsigned __int64 length;
214 #endif
215 unsigned long state[8], curlen;
216 unsigned char buf[64];
217 } SHA256_CTX;
218
219 /* The K array */
220 static const unsigned long K[64] = {
221 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, 0x3956c25bUL,
222 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, 0xd807aa98UL, 0x12835b01UL,
223 0x243185beUL, 0x550c7dc3UL, 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL,
224 0xc19bf174UL, 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
225 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, 0x983e5152UL,
226 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, 0xc6e00bf3UL, 0xd5a79147UL,
227 0x06ca6351UL, 0x14292967UL, 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL,
228 0x53380d13UL, 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
229 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, 0xd192e819UL,
230 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,
231 0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,
232 0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
233 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
234 };
235
236 /* Various logical functions */
237 #define RORc(x, y) \
238 (((((unsigned long)(x) & 0xFFFFFFFFUL) >> (unsigned long)((y) & 31)) | \
239 ((unsigned long)(x) << (unsigned long)(32 - ((y) & 31)))) & 0xFFFFFFFFUL)
240 #define Ch(x,y,z) (z ^ (x & (y ^ z)))
241 #define Maj(x,y,z) (((x | y) & z) | (x & y))
242 #define S(x, n) RORc((x), (n))
243 #define R(x, n) (((x)&0xFFFFFFFFUL)>>(n))
244 #define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22))
245 #define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25))
246 #define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
247 #define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
248
249 /* Compress 512-bits */
250 static int sha256_compress(struct sha256_state *md,
251 unsigned char *buf)
252 {
253 unsigned long S[8], W[64];
254 int i;
255
256 /* Copy state into S */
257 for(i = 0; i < 8; i++) {
258 S[i] = md->state[i];
259 }
260 /* copy the state into 512-bits into W[0..15] */
261 for(i = 0; i < 16; i++)
262 W[i] = WPA_GET_BE32(buf + (4 * i));
263 /* fill W[16..63] */
264 for(i = 16; i < 64; i++) {
265 W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) +
266 W[i - 16];
267 }
268
269 /* Compress */
270 #define RND(a,b,c,d,e,f,g,h,i) \
271 unsigned long t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
272 unsigned long t1 = Sigma0(a) + Maj(a, b, c); \
273 d += t0; \
274 h = t0 + t1;
275 for(i = 0; i < 64; ++i) {
276 unsigned long t;
277 RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i);
278 t = S[7]; S[7] = S[6]; S[6] = S[5]; S[5] = S[4];
279 S[4] = S[3]; S[3] = S[2]; S[2] = S[1]; S[1] = S[0]; S[0] = t;
280 }
281
282 /* Feedback */
283 for(i = 0; i < 8; i++) {
284 md->state[i] = md->state[i] + S[i];
285 }
286
287 return 0;
288 }
289
290 /* Initialize the hash state */
291 static void SHA256_Init(struct sha256_state *md)
292 {
293 md->curlen = 0;
294 md->length = 0;
295 md->state[0] = 0x6A09E667UL;
296 md->state[1] = 0xBB67AE85UL;
297 md->state[2] = 0x3C6EF372UL;
298 md->state[3] = 0xA54FF53AUL;
299 md->state[4] = 0x510E527FUL;
300 md->state[5] = 0x9B05688CUL;
301 md->state[6] = 0x1F83D9ABUL;
302 md->state[7] = 0x5BE0CD19UL;
303 }
304
305 /*
306 Process a block of memory though the hash
307 @param md The hash state
308 @param in The data to hash
309 @param inlen The length of the data (octets)
310 @return CRYPT_OK if successful
311 */
312 static int SHA256_Update(struct sha256_state *md,
313 const unsigned char *in,
314 unsigned long inlen)
315 {
316 unsigned long n;
317
318 #define block_size 64
319 if(md->curlen > sizeof(md->buf))
320 return -1;
321 while(inlen > 0) {
322 if(md->curlen == 0 && inlen >= block_size) {
323 if(sha256_compress(md, (unsigned char *)in) < 0)
324 return -1;
325 md->length += block_size * 8;
326 in += block_size;
327 inlen -= block_size;
328 }
329 else {
330 n = CURLMIN(inlen, (block_size - md->curlen));
331 memcpy(md->buf + md->curlen, in, n);
332 md->curlen += n;
333 in += n;
334 inlen -= n;
335 if(md->curlen == block_size) {
336 if(sha256_compress(md, md->buf) < 0)
337 return -1;
338 md->length += 8 * block_size;
339 md->curlen = 0;
340 }
341 }
342 }
343
344 return 0;
345 }
346
347 /*
348 Terminate the hash to get the digest
349 @param md The hash state
350 @param out [out] The destination of the hash (32 bytes)
351 @return CRYPT_OK if successful
352 */
353 static int SHA256_Final(unsigned char *out,
354 struct sha256_state *md)
355 {
356 int i;
357
358 if(md->curlen >= sizeof(md->buf))
359 return -1;
360
361 /* Increase the length of the message */
362 md->length += md->curlen * 8;
363
364 /* Append the '1' bit */
365 md->buf[md->curlen++] = (unsigned char)0x80;
366
367 /* If the length is currently above 56 bytes we append zeros
368 * then compress. Then we can fall back to padding zeros and length
369 * encoding like normal.
370 */
371 if(md->curlen > 56) {
372 while(md->curlen < 64) {
373 md->buf[md->curlen++] = (unsigned char)0;
374 }
375 sha256_compress(md, md->buf);
376 md->curlen = 0;
377 }
378
379 /* Pad up to 56 bytes of zeroes */
380 while(md->curlen < 56) {
381 md->buf[md->curlen++] = (unsigned char)0;
382 }
383
384 /* Store length */
385 WPA_PUT_BE64(md->buf + 56, md->length);
386 sha256_compress(md, md->buf);
387
388 /* Copy output */
389 for(i = 0; i < 8; i++)
390 WPA_PUT_BE32(out + (4 * i), md->state[i]);
391
392 return 0;
393 }
394
395 #endif /* CRYPTO LIBS */
396
397 /*
398 * Curl_sha256it()
399 *
400 * Generates a SHA256 hash for the given input data.
401 *
402 * Parameters:
403 *
404 * output [in/out] - The output buffer.
405 * input [in] - The input data.
406 * length [in] - The input length.
407 */
408 void Curl_sha256it(unsigned char *output, const unsigned char *input,
409 const size_t length)
410 {
411 SHA256_CTX ctx;
412
413 SHA256_Init(&ctx);
414 SHA256_Update(&ctx, input, curlx_uztoui(length));
415 SHA256_Final(output, &ctx);
416 }
417
418 #endif /* CURL_DISABLE_CRYPTO_AUTH */