/src/httpd/srclib/apr/random/unix/sha2.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* Licensed to the Apache Software Foundation (ASF) under one or more |
2 | | * contributor license agreements. See the NOTICE file distributed with |
3 | | * this work for additional information regarding copyright ownership. |
4 | | * The ASF licenses this file to You under the Apache License, Version 2.0 |
5 | | * (the "License"); you may not use this file except in compliance with |
6 | | * the License. You may obtain a copy of the License at |
7 | | * |
8 | | * http://www.apache.org/licenses/LICENSE-2.0 |
9 | | * |
10 | | * Unless required by applicable law or agreed to in writing, software |
11 | | * distributed under the License is distributed on an "AS IS" BASIS, |
12 | | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
13 | | * See the License for the specific language governing permissions and |
14 | | * limitations under the License. |
15 | | */ |
16 | | /* |
17 | | * FILE: sha2.c |
18 | | * AUTHOR: Aaron D. Gifford <me@aarongifford.com> |
19 | | * |
20 | | * A licence was granted to the ASF by Aaron on 4 November 2003. |
21 | | */ |
22 | | |
23 | | #include <string.h> /* memcpy()/memset() or bcopy()/bzero() */ |
24 | | #include <assert.h> /* assert() */ |
25 | | #include "sha2.h" |
26 | | |
27 | | /* |
28 | | * ASSERT NOTE: |
29 | | * Some sanity checking code is included using assert(). On my FreeBSD |
30 | | * system, this additional code can be removed by compiling with NDEBUG |
31 | | * defined. Check your own systems manpage on assert() to see how to |
32 | | * compile WITHOUT the sanity checking code on your system. |
33 | | * |
34 | | * UNROLLED TRANSFORM LOOP NOTE: |
35 | | * You can define SHA2_UNROLL_TRANSFORM to use the unrolled transform |
36 | | * loop version for the hash transform rounds (defined using macros |
37 | | * later in this file). Either define on the command line, for example: |
38 | | * |
39 | | * cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c |
40 | | * |
41 | | * or define below: |
42 | | * |
43 | | * #define SHA2_UNROLL_TRANSFORM |
44 | | * |
45 | | */ |
46 | | |
47 | | /*** SHA-256/384/512 Machine Architecture Definitions *****************/ |
48 | | typedef apr_byte_t sha2_byte; /* Exactly 1 byte */ |
49 | | typedef apr_uint32_t sha2_word32; /* Exactly 4 bytes */ |
50 | | typedef apr_uint64_t sha2_word64; /* Exactly 8 bytes */ |
51 | | |
52 | | /*** SHA-256/384/512 Various Length Definitions ***********************/ |
53 | | /* NOTE: Most of these are in sha2.h */ |
54 | 0 | #define SHA256_SHORT_BLOCK_LENGTH (SHA256_BLOCK_LENGTH - 8) |
55 | | |
56 | | |
57 | | /*** ENDIAN REVERSAL MACROS *******************************************/ |
58 | | #if !APR_IS_BIGENDIAN |
59 | 0 | #define REVERSE32(w,x) { \ |
60 | 0 | sha2_word32 tmp = (w); \ |
61 | 0 | tmp = (tmp >> 16) | (tmp << 16); \ |
62 | 0 | (x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \ |
63 | 0 | } |
64 | 0 | #define REVERSE64(w,x) { \ |
65 | 0 | sha2_word64 tmp = (w); \ |
66 | 0 | tmp = (tmp >> 32) | (tmp << 32); \ |
67 | 0 | tmp = ((tmp & APR_UINT64_C(0xff00ff00ff00ff00)) >> 8) | \ |
68 | 0 | ((tmp & APR_UINT64_C(0x00ff00ff00ff00ff)) << 8); \ |
69 | 0 | (x) = ((tmp & APR_UINT64_C(0xffff0000ffff0000)) >> 16) | \ |
70 | 0 | ((tmp & APR_UINT64_C(0x0000ffff0000ffff)) << 16); \ |
71 | 0 | } |
72 | | #endif /* !APR_IS_BIGENDIAN */ |
73 | | |
74 | | /* |
75 | | * Macro for incrementally adding the unsigned 64-bit integer n to the |
76 | | * unsigned 128-bit integer (represented using a two-element array of |
77 | | * 64-bit words): |
78 | | */ |
79 | | #define ADDINC128(w,n) { \ |
80 | | (w)[0] += (sha2_word64)(n); \ |
81 | | if ((w)[0] < (n)) { \ |
82 | | (w)[1]++; \ |
83 | | } \ |
84 | | } |
85 | | |
86 | | /* |
87 | | * Macros for copying blocks of memory and for zeroing out ranges |
88 | | * of memory. Using these macros makes it easy to switch from |
89 | | * using memset()/memcpy() and using bzero()/bcopy(). |
90 | | * |
91 | | * Please define either SHA2_USE_MEMSET_MEMCPY or define |
92 | | * SHA2_USE_BZERO_BCOPY depending on which function set you |
93 | | * choose to use: |
94 | | */ |
95 | | #if !defined(SHA2_USE_MEMSET_MEMCPY) && !defined(SHA2_USE_BZERO_BCOPY) |
96 | | /* Default to memset()/memcpy() if no option is specified */ |
97 | | #define SHA2_USE_MEMSET_MEMCPY 1 |
98 | | #endif |
99 | | #if defined(SHA2_USE_MEMSET_MEMCPY) && defined(SHA2_USE_BZERO_BCOPY) |
100 | | /* Abort with an error if BOTH options are defined */ |
101 | | #error Define either SHA2_USE_MEMSET_MEMCPY or SHA2_USE_BZERO_BCOPY, not both! |
102 | | #endif |
103 | | |
104 | | #ifdef SHA2_USE_MEMSET_MEMCPY |
105 | 0 | #define MEMSET_BZERO(p,l) memset((p), 0, (l)) |
106 | 0 | #define MEMCPY_BCOPY(d,s,l) memcpy((d), (s), (l)) |
107 | | #endif |
108 | | #ifdef SHA2_USE_BZERO_BCOPY |
109 | | #define MEMSET_BZERO(p,l) bzero((p), (l)) |
110 | | #define MEMCPY_BCOPY(d,s,l) bcopy((s), (d), (l)) |
111 | | #endif |
112 | | |
113 | | |
114 | | /*** THE SIX LOGICAL FUNCTIONS ****************************************/ |
115 | | /* |
116 | | * Bit shifting and rotation (used by the six SHA-XYZ logical functions: |
117 | | * |
118 | | * NOTE: The naming of R and S appears backwards here (R is a SHIFT and |
119 | | * S is a ROTATION) because the SHA-256/384/512 description document |
120 | | * (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this |
121 | | * same "backwards" definition. |
122 | | */ |
123 | | /* Shift-right (used in SHA-256, SHA-384, and SHA-512): */ |
124 | 0 | #define R(b,x) ((x) >> (b)) |
125 | | /* 32-bit Rotate-right (used in SHA-256): */ |
126 | 0 | #define S32(b,x) (((x) >> (b)) | ((x) << (32 - (b)))) |
127 | | /* 64-bit Rotate-right (used in SHA-384 and SHA-512): */ |
128 | | #define S64(b,x) (((x) >> (b)) | ((x) << (64 - (b)))) |
129 | | |
130 | | /* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */ |
131 | 0 | #define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z))) |
132 | 0 | #define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) |
133 | | |
134 | | /* Four of six logical functions used in SHA-256: */ |
135 | 0 | #define Sigma0_256(x) (S32(2, (x)) ^ S32(13, (x)) ^ S32(22, (x))) |
136 | 0 | #define Sigma1_256(x) (S32(6, (x)) ^ S32(11, (x)) ^ S32(25, (x))) |
137 | 0 | #define sigma0_256(x) (S32(7, (x)) ^ S32(18, (x)) ^ R(3 , (x))) |
138 | 0 | #define sigma1_256(x) (S32(17, (x)) ^ S32(19, (x)) ^ R(10, (x))) |
139 | | |
140 | | /* Four of six logical functions used in SHA-384 and SHA-512: */ |
141 | | #define Sigma0_512(x) (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x))) |
142 | | #define Sigma1_512(x) (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x))) |
143 | | #define sigma0_512(x) (S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7, (x))) |
144 | | #define sigma1_512(x) (S64(19, (x)) ^ S64(61, (x)) ^ R( 6, (x))) |
145 | | |
146 | | /*** INTERNAL FUNCTION PROTOTYPES *************************************/ |
147 | | /* NOTE: These should not be accessed directly from outside this |
148 | | * library -- they are intended for private internal visibility/use |
149 | | * only. |
150 | | */ |
151 | | void apr__SHA256_Transform(SHA256_CTX*, const sha2_word32*); |
152 | | |
153 | | |
154 | | /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/ |
155 | | /* Hash constant words K for SHA-256: */ |
156 | | static const sha2_word32 K256[64] = { |
157 | | 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, |
158 | | 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, |
159 | | 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL, |
160 | | 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL, |
161 | | 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL, |
162 | | 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, |
163 | | 0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, |
164 | | 0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL, |
165 | | 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL, |
166 | | 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL, |
167 | | 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, |
168 | | 0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, |
169 | | 0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL, |
170 | | 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL, |
171 | | 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL, |
172 | | 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL |
173 | | }; |
174 | | |
175 | | /* Initial hash value H for SHA-256: */ |
176 | | static const sha2_word32 sha256_initial_hash_value[8] = { |
177 | | 0x6a09e667UL, |
178 | | 0xbb67ae85UL, |
179 | | 0x3c6ef372UL, |
180 | | 0xa54ff53aUL, |
181 | | 0x510e527fUL, |
182 | | 0x9b05688cUL, |
183 | | 0x1f83d9abUL, |
184 | | 0x5be0cd19UL |
185 | | }; |
186 | | |
187 | | /* |
188 | | * Constant used by SHA256/384/512_End() functions for converting the |
189 | | * digest to a readable hexadecimal character string: |
190 | | */ |
191 | | static const char *sha2_hex_digits = "0123456789abcdef"; |
192 | | |
193 | | |
194 | | /*** SHA-256: *********************************************************/ |
195 | 0 | void apr__SHA256_Init(SHA256_CTX* context) { |
196 | 0 | if (context == (SHA256_CTX*)0) { |
197 | 0 | return; |
198 | 0 | } |
199 | 0 | MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH); |
200 | 0 | MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH); |
201 | 0 | context->bitcount = 0; |
202 | 0 | } |
203 | | |
204 | | #ifdef SHA2_UNROLL_TRANSFORM |
205 | | |
206 | | /* Unrolled SHA-256 round macros: */ |
207 | | |
208 | | #if !APR_IS_BIGENDIAN |
209 | | |
210 | | #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \ |
211 | | REVERSE32(*data++, W256[j]); \ |
212 | | T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \ |
213 | | K256[j] + W256[j]; \ |
214 | | (d) += T1; \ |
215 | | (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ |
216 | | j++ |
217 | | |
218 | | |
219 | | #else /* APR_IS_BIGENDIAN */ |
220 | | |
221 | | #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \ |
222 | | T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \ |
223 | | K256[j] + (W256[j] = *data++); \ |
224 | | (d) += T1; \ |
225 | | (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ |
226 | | j++ |
227 | | |
228 | | #endif /* APR_IS_BIGENDIAN */ |
229 | | |
230 | | #define ROUND256(a,b,c,d,e,f,g,h) \ |
231 | | s0 = W256[(j+1)&0x0f]; \ |
232 | | s0 = sigma0_256(s0); \ |
233 | | s1 = W256[(j+14)&0x0f]; \ |
234 | | s1 = sigma1_256(s1); \ |
235 | | T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \ |
236 | | (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \ |
237 | | (d) += T1; \ |
238 | | (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ |
239 | | j++ |
240 | | |
241 | | void apr__SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) { |
242 | | sha2_word32 a, b, c, d, e, f, g, h, s0, s1; |
243 | | sha2_word32 T1, *W256; |
244 | | int j; |
245 | | |
246 | | W256 = (sha2_word32*)context->buffer; |
247 | | |
248 | | /* Initialize registers with the prev. intermediate value */ |
249 | | a = context->state[0]; |
250 | | b = context->state[1]; |
251 | | c = context->state[2]; |
252 | | d = context->state[3]; |
253 | | e = context->state[4]; |
254 | | f = context->state[5]; |
255 | | g = context->state[6]; |
256 | | h = context->state[7]; |
257 | | |
258 | | j = 0; |
259 | | do { |
260 | | /* Rounds 0 to 15 (unrolled): */ |
261 | | ROUND256_0_TO_15(a,b,c,d,e,f,g,h); |
262 | | ROUND256_0_TO_15(h,a,b,c,d,e,f,g); |
263 | | ROUND256_0_TO_15(g,h,a,b,c,d,e,f); |
264 | | ROUND256_0_TO_15(f,g,h,a,b,c,d,e); |
265 | | ROUND256_0_TO_15(e,f,g,h,a,b,c,d); |
266 | | ROUND256_0_TO_15(d,e,f,g,h,a,b,c); |
267 | | ROUND256_0_TO_15(c,d,e,f,g,h,a,b); |
268 | | ROUND256_0_TO_15(b,c,d,e,f,g,h,a); |
269 | | } while (j < 16); |
270 | | |
271 | | /* Now for the remaining rounds to 64: */ |
272 | | do { |
273 | | ROUND256(a,b,c,d,e,f,g,h); |
274 | | ROUND256(h,a,b,c,d,e,f,g); |
275 | | ROUND256(g,h,a,b,c,d,e,f); |
276 | | ROUND256(f,g,h,a,b,c,d,e); |
277 | | ROUND256(e,f,g,h,a,b,c,d); |
278 | | ROUND256(d,e,f,g,h,a,b,c); |
279 | | ROUND256(c,d,e,f,g,h,a,b); |
280 | | ROUND256(b,c,d,e,f,g,h,a); |
281 | | } while (j < 64); |
282 | | |
283 | | /* Compute the current intermediate hash value */ |
284 | | context->state[0] += a; |
285 | | context->state[1] += b; |
286 | | context->state[2] += c; |
287 | | context->state[3] += d; |
288 | | context->state[4] += e; |
289 | | context->state[5] += f; |
290 | | context->state[6] += g; |
291 | | context->state[7] += h; |
292 | | |
293 | | /* Clean up */ |
294 | | a = b = c = d = e = f = g = h = T1 = 0; |
295 | | } |
296 | | |
297 | | #else /* SHA2_UNROLL_TRANSFORM */ |
298 | | |
299 | 0 | void apr__SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) { |
300 | 0 | sha2_word32 a, b, c, d, e, f, g, h, s0, s1; |
301 | 0 | sha2_word32 T1, T2, *W256; |
302 | 0 | int j; |
303 | |
|
304 | 0 | W256 = (sha2_word32*)context->buffer; |
305 | | |
306 | | /* Initialize registers with the prev. intermediate value */ |
307 | 0 | a = context->state[0]; |
308 | 0 | b = context->state[1]; |
309 | 0 | c = context->state[2]; |
310 | 0 | d = context->state[3]; |
311 | 0 | e = context->state[4]; |
312 | 0 | f = context->state[5]; |
313 | 0 | g = context->state[6]; |
314 | 0 | h = context->state[7]; |
315 | |
|
316 | 0 | j = 0; |
317 | 0 | do { |
318 | 0 | #if !APR_IS_BIGENDIAN |
319 | | /* Copy data while converting to host byte order */ |
320 | 0 | REVERSE32(*data++,W256[j]); |
321 | | /* Apply the SHA-256 compression function to update a..h */ |
322 | 0 | T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j]; |
323 | | #else /* APR_IS_BIGENDIAN */ |
324 | | /* Apply the SHA-256 compression function to update a..h with copy */ |
325 | | T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++); |
326 | | #endif /* APR_IS_BIGENDIAN */ |
327 | 0 | T2 = Sigma0_256(a) + Maj(a, b, c); |
328 | 0 | h = g; |
329 | 0 | g = f; |
330 | 0 | f = e; |
331 | 0 | e = d + T1; |
332 | 0 | d = c; |
333 | 0 | c = b; |
334 | 0 | b = a; |
335 | 0 | a = T1 + T2; |
336 | |
|
337 | 0 | j++; |
338 | 0 | } while (j < 16); |
339 | |
|
340 | 0 | do { |
341 | | /* Part of the message block expansion: */ |
342 | 0 | s0 = W256[(j+1)&0x0f]; |
343 | 0 | s0 = sigma0_256(s0); |
344 | 0 | s1 = W256[(j+14)&0x0f]; |
345 | 0 | s1 = sigma1_256(s1); |
346 | | |
347 | | /* Apply the SHA-256 compression function to update a..h */ |
348 | 0 | T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + |
349 | 0 | (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); |
350 | 0 | T2 = Sigma0_256(a) + Maj(a, b, c); |
351 | 0 | h = g; |
352 | 0 | g = f; |
353 | 0 | f = e; |
354 | 0 | e = d + T1; |
355 | 0 | d = c; |
356 | 0 | c = b; |
357 | 0 | b = a; |
358 | 0 | a = T1 + T2; |
359 | |
|
360 | 0 | j++; |
361 | 0 | } while (j < 64); |
362 | | |
363 | | /* Compute the current intermediate hash value */ |
364 | 0 | context->state[0] += a; |
365 | 0 | context->state[1] += b; |
366 | 0 | context->state[2] += c; |
367 | 0 | context->state[3] += d; |
368 | 0 | context->state[4] += e; |
369 | 0 | context->state[5] += f; |
370 | 0 | context->state[6] += g; |
371 | 0 | context->state[7] += h; |
372 | | |
373 | | /* Clean up */ |
374 | 0 | a = b = c = d = e = f = g = h = T1 = T2 = 0; |
375 | 0 | } |
376 | | |
377 | | #endif /* SHA2_UNROLL_TRANSFORM */ |
378 | | |
379 | 0 | void apr__SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) { |
380 | 0 | unsigned int freespace, usedspace; |
381 | |
|
382 | 0 | if (len == 0) { |
383 | | /* Calling with no data is valid - we do nothing */ |
384 | 0 | return; |
385 | 0 | } |
386 | | |
387 | | /* Sanity check: */ |
388 | 0 | assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0); |
389 | | |
390 | 0 | usedspace = (unsigned int)((context->bitcount >> 3) |
391 | 0 | % SHA256_BLOCK_LENGTH); |
392 | 0 | if (usedspace > 0) { |
393 | | /* Calculate how much free space is available in the buffer */ |
394 | 0 | freespace = SHA256_BLOCK_LENGTH - usedspace; |
395 | |
|
396 | 0 | if (len >= freespace) { |
397 | | /* Fill the buffer completely and process it */ |
398 | 0 | MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace); |
399 | 0 | context->bitcount += freespace << 3; |
400 | 0 | len -= freespace; |
401 | 0 | data += freespace; |
402 | 0 | apr__SHA256_Transform(context, (sha2_word32*)context->buffer); |
403 | 0 | } else { |
404 | | /* The buffer is not yet full */ |
405 | 0 | MEMCPY_BCOPY(&context->buffer[usedspace], data, len); |
406 | 0 | context->bitcount += len << 3; |
407 | | /* Clean up: */ |
408 | 0 | usedspace = freespace = 0; |
409 | 0 | return; |
410 | 0 | } |
411 | 0 | } |
412 | 0 | while (len >= SHA256_BLOCK_LENGTH) { |
413 | | /* Process as many complete blocks as we can */ |
414 | 0 | apr__SHA256_Transform(context, (sha2_word32*)data); |
415 | 0 | context->bitcount += SHA256_BLOCK_LENGTH << 3; |
416 | 0 | len -= SHA256_BLOCK_LENGTH; |
417 | 0 | data += SHA256_BLOCK_LENGTH; |
418 | 0 | } |
419 | 0 | if (len > 0) { |
420 | | /* There's left-overs, so save 'em */ |
421 | 0 | MEMCPY_BCOPY(context->buffer, data, len); |
422 | 0 | context->bitcount += len << 3; |
423 | 0 | } |
424 | | /* Clean up: */ |
425 | 0 | usedspace = freespace = 0; |
426 | 0 | } |
427 | | |
428 | 0 | void apr__SHA256_Final(sha2_byte digest[SHA256_DIGEST_LENGTH], SHA256_CTX* context) { |
429 | 0 | sha2_word32 *d = (sha2_word32*)digest; |
430 | 0 | unsigned int usedspace; |
431 | | |
432 | | /* Sanity check: */ |
433 | 0 | assert(context != (SHA256_CTX*)0); |
434 | | |
435 | | /* If no digest buffer is passed, we don't bother doing this: */ |
436 | 0 | if (digest != (sha2_byte*)0) { |
437 | 0 | usedspace = (unsigned int)((context->bitcount >> 3) |
438 | 0 | % SHA256_BLOCK_LENGTH); |
439 | 0 | #if !APR_IS_BIGENDIAN |
440 | | /* Convert FROM host byte order */ |
441 | 0 | REVERSE64(context->bitcount,context->bitcount); |
442 | 0 | #endif |
443 | 0 | if (usedspace > 0) { |
444 | | /* Begin padding with a 1 bit: */ |
445 | 0 | context->buffer[usedspace++] = 0x80; |
446 | |
|
447 | 0 | if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) { |
448 | | /* Set-up for the last transform: */ |
449 | 0 | MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace); |
450 | 0 | } else { |
451 | 0 | if (usedspace < SHA256_BLOCK_LENGTH) { |
452 | 0 | MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace); |
453 | 0 | } |
454 | | /* Do second-to-last transform: */ |
455 | 0 | apr__SHA256_Transform(context, (sha2_word32*)context->buffer); |
456 | | |
457 | | /* And set-up for the last transform: */ |
458 | 0 | MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH); |
459 | 0 | } |
460 | 0 | } else { |
461 | | /* Set-up for the last transform: */ |
462 | 0 | MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH); |
463 | | |
464 | | /* Begin padding with a 1 bit: */ |
465 | 0 | *context->buffer = 0x80; |
466 | 0 | } |
467 | | /* Set the bit count: */ |
468 | 0 | { |
469 | 0 | union dummy { |
470 | 0 | apr_uint64_t bitcount; |
471 | 0 | apr_byte_t bytes[8]; |
472 | 0 | } bitcount; |
473 | 0 | bitcount.bitcount = context->bitcount; |
474 | 0 | MEMCPY_BCOPY(&context->buffer[SHA256_SHORT_BLOCK_LENGTH], bitcount.bytes, 8); |
475 | 0 | } |
476 | | |
477 | | /* Final transform: */ |
478 | 0 | apr__SHA256_Transform(context, (sha2_word32*)context->buffer); |
479 | |
|
480 | 0 | #if !APR_IS_BIGENDIAN |
481 | 0 | { |
482 | | /* Convert TO host byte order */ |
483 | 0 | int j; |
484 | 0 | for (j = 0; j < 8; j++) { |
485 | 0 | REVERSE32(context->state[j],context->state[j]); |
486 | 0 | *d++ = context->state[j]; |
487 | 0 | } |
488 | 0 | } |
489 | | #else |
490 | | MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LENGTH); |
491 | | #endif |
492 | 0 | } |
493 | | |
494 | | /* Clean up state data: */ |
495 | 0 | MEMSET_BZERO(context, sizeof(*context)); |
496 | 0 | usedspace = 0; |
497 | 0 | } |
498 | | |
499 | 0 | char *apr__SHA256_End(SHA256_CTX* context, char buffer[SHA256_DIGEST_STRING_LENGTH]) { |
500 | 0 | sha2_byte digest[SHA256_DIGEST_LENGTH], *d = digest; |
501 | 0 | int i; |
502 | | |
503 | | /* Sanity check: */ |
504 | 0 | assert(context != (SHA256_CTX*)0); |
505 | | |
506 | 0 | if (buffer != (char*)0) { |
507 | 0 | apr__SHA256_Final(digest, context); |
508 | |
|
509 | 0 | for (i = 0; i < SHA256_DIGEST_LENGTH; i++) { |
510 | 0 | *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4]; |
511 | 0 | *buffer++ = sha2_hex_digits[*d & 0x0f]; |
512 | 0 | d++; |
513 | 0 | } |
514 | 0 | *buffer = (char)0; |
515 | 0 | } else { |
516 | 0 | MEMSET_BZERO(context, sizeof(*context)); |
517 | 0 | } |
518 | 0 | MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH); |
519 | 0 | return buffer; |
520 | 0 | } |
521 | | |
522 | 0 | char* apr__SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) { |
523 | 0 | SHA256_CTX context; |
524 | |
|
525 | 0 | apr__SHA256_Init(&context); |
526 | 0 | apr__SHA256_Update(&context, data, len); |
527 | 0 | return apr__SHA256_End(&context, digest); |
528 | 0 | } |