Deleted Added
sdiff udiff text old ( 251886 ) new ( 253734 )
full compact
sha2.c (251886) sha2.c (253734)
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

--- 38 unchanged lines hidden (view full) ---

47/*** SHA-256/384/512 Machine Architecture Definitions *****************/
48typedef apr_byte_t sha2_byte; /* Exactly 1 byte */
49typedef apr_uint32_t sha2_word32; /* Exactly 4 bytes */
50typedef 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#define SHA256_SHORT_BLOCK_LENGTH (SHA256_BLOCK_LENGTH - 8)
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

--- 38 unchanged lines hidden (view full) ---

47/*** SHA-256/384/512 Machine Architecture Definitions *****************/
48typedef apr_byte_t sha2_byte; /* Exactly 1 byte */
49typedef apr_uint32_t sha2_word32; /* Exactly 4 bytes */
50typedef 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#define SHA256_SHORT_BLOCK_LENGTH (SHA256_BLOCK_LENGTH - 8)
55#define SHA384_SHORT_BLOCK_LENGTH (SHA384_BLOCK_LENGTH - 16)
56#define SHA512_SHORT_BLOCK_LENGTH (SHA512_BLOCK_LENGTH - 16)
57
58
59/*** ENDIAN REVERSAL MACROS *******************************************/
60#if !APR_IS_BIGENDIAN
61#define REVERSE32(w,x) { \
62 sha2_word32 tmp = (w); \
63 tmp = (tmp >> 16) | (tmp << 16); \
64 (x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \

--- 80 unchanged lines hidden (view full) ---

145#define sigma0_512(x) (S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7, (x)))
146#define sigma1_512(x) (S64(19, (x)) ^ S64(61, (x)) ^ R( 6, (x)))
147
148/*** INTERNAL FUNCTION PROTOTYPES *************************************/
149/* NOTE: These should not be accessed directly from outside this
150 * library -- they are intended for private internal visibility/use
151 * only.
152 */
55
56
57/*** ENDIAN REVERSAL MACROS *******************************************/
58#if !APR_IS_BIGENDIAN
59#define REVERSE32(w,x) { \
60 sha2_word32 tmp = (w); \
61 tmp = (tmp >> 16) | (tmp << 16); \
62 (x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \

--- 80 unchanged lines hidden (view full) ---

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 */
153void apr__SHA512_Last(SHA512_CTX*);
154void apr__SHA256_Transform(SHA256_CTX*, const sha2_word32*);
151void apr__SHA256_Transform(SHA256_CTX*, const sha2_word32*);
155void apr__SHA512_Transform(SHA512_CTX*, const sha2_word64*);
156
157
158/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
159/* Hash constant words K for SHA-256: */
160static const sha2_word32 K256[64] = {
161 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
162 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
163 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,

--- 19 unchanged lines hidden (view full) ---

183 0x3c6ef372UL,
184 0xa54ff53aUL,
185 0x510e527fUL,
186 0x9b05688cUL,
187 0x1f83d9abUL,
188 0x5be0cd19UL
189};
190
152
153
154/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
155/* Hash constant words K for SHA-256: */
156static const sha2_word32 K256[64] = {
157 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
158 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
159 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,

--- 19 unchanged lines hidden (view full) ---

179 0x3c6ef372UL,
180 0xa54ff53aUL,
181 0x510e527fUL,
182 0x9b05688cUL,
183 0x1f83d9abUL,
184 0x5be0cd19UL
185};
186
191/* Hash constant words K for SHA-384 and SHA-512: */
192static const sha2_word64 K512[80] = {
193 APR_UINT64_C(0x428a2f98d728ae22), APR_UINT64_C(0x7137449123ef65cd),
194 APR_UINT64_C(0xb5c0fbcfec4d3b2f), APR_UINT64_C(0xe9b5dba58189dbbc),
195 APR_UINT64_C(0x3956c25bf348b538), APR_UINT64_C(0x59f111f1b605d019),
196 APR_UINT64_C(0x923f82a4af194f9b), APR_UINT64_C(0xab1c5ed5da6d8118),
197 APR_UINT64_C(0xd807aa98a3030242), APR_UINT64_C(0x12835b0145706fbe),
198 APR_UINT64_C(0x243185be4ee4b28c), APR_UINT64_C(0x550c7dc3d5ffb4e2),
199 APR_UINT64_C(0x72be5d74f27b896f), APR_UINT64_C(0x80deb1fe3b1696b1),
200 APR_UINT64_C(0x9bdc06a725c71235), APR_UINT64_C(0xc19bf174cf692694),
201 APR_UINT64_C(0xe49b69c19ef14ad2), APR_UINT64_C(0xefbe4786384f25e3),
202 APR_UINT64_C(0x0fc19dc68b8cd5b5), APR_UINT64_C(0x240ca1cc77ac9c65),
203 APR_UINT64_C(0x2de92c6f592b0275), APR_UINT64_C(0x4a7484aa6ea6e483),
204 APR_UINT64_C(0x5cb0a9dcbd41fbd4), APR_UINT64_C(0x76f988da831153b5),
205 APR_UINT64_C(0x983e5152ee66dfab), APR_UINT64_C(0xa831c66d2db43210),
206 APR_UINT64_C(0xb00327c898fb213f), APR_UINT64_C(0xbf597fc7beef0ee4),
207 APR_UINT64_C(0xc6e00bf33da88fc2), APR_UINT64_C(0xd5a79147930aa725),
208 APR_UINT64_C(0x06ca6351e003826f), APR_UINT64_C(0x142929670a0e6e70),
209 APR_UINT64_C(0x27b70a8546d22ffc), APR_UINT64_C(0x2e1b21385c26c926),
210 APR_UINT64_C(0x4d2c6dfc5ac42aed), APR_UINT64_C(0x53380d139d95b3df),
211 APR_UINT64_C(0x650a73548baf63de), APR_UINT64_C(0x766a0abb3c77b2a8),
212 APR_UINT64_C(0x81c2c92e47edaee6), APR_UINT64_C(0x92722c851482353b),
213 APR_UINT64_C(0xa2bfe8a14cf10364), APR_UINT64_C(0xa81a664bbc423001),
214 APR_UINT64_C(0xc24b8b70d0f89791), APR_UINT64_C(0xc76c51a30654be30),
215 APR_UINT64_C(0xd192e819d6ef5218), APR_UINT64_C(0xd69906245565a910),
216 APR_UINT64_C(0xf40e35855771202a), APR_UINT64_C(0x106aa07032bbd1b8),
217 APR_UINT64_C(0x19a4c116b8d2d0c8), APR_UINT64_C(0x1e376c085141ab53),
218 APR_UINT64_C(0x2748774cdf8eeb99), APR_UINT64_C(0x34b0bcb5e19b48a8),
219 APR_UINT64_C(0x391c0cb3c5c95a63), APR_UINT64_C(0x4ed8aa4ae3418acb),
220 APR_UINT64_C(0x5b9cca4f7763e373), APR_UINT64_C(0x682e6ff3d6b2b8a3),
221 APR_UINT64_C(0x748f82ee5defb2fc), APR_UINT64_C(0x78a5636f43172f60),
222 APR_UINT64_C(0x84c87814a1f0ab72), APR_UINT64_C(0x8cc702081a6439ec),
223 APR_UINT64_C(0x90befffa23631e28), APR_UINT64_C(0xa4506cebde82bde9),
224 APR_UINT64_C(0xbef9a3f7b2c67915), APR_UINT64_C(0xc67178f2e372532b),
225 APR_UINT64_C(0xca273eceea26619c), APR_UINT64_C(0xd186b8c721c0c207),
226 APR_UINT64_C(0xeada7dd6cde0eb1e), APR_UINT64_C(0xf57d4f7fee6ed178),
227 APR_UINT64_C(0x06f067aa72176fba), APR_UINT64_C(0x0a637dc5a2c898a6),
228 APR_UINT64_C(0x113f9804bef90dae), APR_UINT64_C(0x1b710b35131c471b),
229 APR_UINT64_C(0x28db77f523047d84), APR_UINT64_C(0x32caab7b40c72493),
230 APR_UINT64_C(0x3c9ebe0a15c9bebc), APR_UINT64_C(0x431d67c49c100d4c),
231 APR_UINT64_C(0x4cc5d4becb3e42b6), APR_UINT64_C(0x597f299cfc657e2a),
232 APR_UINT64_C(0x5fcb6fab3ad6faec), APR_UINT64_C(0x6c44198c4a475817)
233};
234
235/* Initial hash value H for SHA-384 */
236static const sha2_word64 sha384_initial_hash_value[8] = {
237 APR_UINT64_C(0xcbbb9d5dc1059ed8),
238 APR_UINT64_C(0x629a292a367cd507),
239 APR_UINT64_C(0x9159015a3070dd17),
240 APR_UINT64_C(0x152fecd8f70e5939),
241 APR_UINT64_C(0x67332667ffc00b31),
242 APR_UINT64_C(0x8eb44a8768581511),
243 APR_UINT64_C(0xdb0c2e0d64f98fa7),
244 APR_UINT64_C(0x47b5481dbefa4fa4)
245};
246
247/* Initial hash value H for SHA-512 */
248static const sha2_word64 sha512_initial_hash_value[8] = {
249 APR_UINT64_C(0x6a09e667f3bcc908),
250 APR_UINT64_C(0xbb67ae8584caa73b),
251 APR_UINT64_C(0x3c6ef372fe94f82b),
252 APR_UINT64_C(0xa54ff53a5f1d36f1),
253 APR_UINT64_C(0x510e527fade682d1),
254 APR_UINT64_C(0x9b05688c2b3e6c1f),
255 APR_UINT64_C(0x1f83d9abfb41bd6b),
256 APR_UINT64_C(0x5be0cd19137e2179)
257};
258
259/*
260 * Constant used by SHA256/384/512_End() functions for converting the
261 * digest to a readable hexadecimal character string:
262 */
263static const char *sha2_hex_digits = "0123456789abcdef";
264
265
266/*** SHA-256: *********************************************************/

--- 265 unchanged lines hidden (view full) ---

532 } else {
533 /* Set-up for the last transform: */
534 MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
535
536 /* Begin padding with a 1 bit: */
537 *context->buffer = 0x80;
538 }
539 /* Set the bit count: */
187/*
188 * Constant used by SHA256/384/512_End() functions for converting the
189 * digest to a readable hexadecimal character string:
190 */
191static const char *sha2_hex_digits = "0123456789abcdef";
192
193
194/*** SHA-256: *********************************************************/

--- 265 unchanged lines hidden (view full) ---

460 } else {
461 /* Set-up for the last transform: */
462 MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
463
464 /* Begin padding with a 1 bit: */
465 *context->buffer = 0x80;
466 }
467 /* Set the bit count: */
540 *(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
468 {
469 union dummy {
470 apr_uint64_t bitcount;
471 apr_byte_t bytes[8];
472 } bitcount;
473 bitcount.bitcount = context->bitcount;
474 MEMCPY_BCOPY(&context->buffer[SHA256_SHORT_BLOCK_LENGTH], bitcount.bytes, 8);
475 }
541
542 /* Final transform: */
543 apr__SHA256_Transform(context, (sha2_word32*)context->buffer);
544
545#if !APR_IS_BIGENDIAN
546 {
547 /* Convert TO host byte order */
548 int j;

--- 37 unchanged lines hidden (view full) ---

586
587char* apr__SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
588 SHA256_CTX context;
589
590 apr__SHA256_Init(&context);
591 apr__SHA256_Update(&context, data, len);
592 return apr__SHA256_End(&context, digest);
593}
476
477 /* Final transform: */
478 apr__SHA256_Transform(context, (sha2_word32*)context->buffer);
479
480#if !APR_IS_BIGENDIAN
481 {
482 /* Convert TO host byte order */
483 int j;

--- 37 unchanged lines hidden (view full) ---

521
522char* apr__SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
523 SHA256_CTX context;
524
525 apr__SHA256_Init(&context);
526 apr__SHA256_Update(&context, data, len);
527 return apr__SHA256_End(&context, digest);
528}
594
595
596/*** SHA-512: *********************************************************/
597void apr__SHA512_Init(SHA512_CTX* context) {
598 if (context == (SHA512_CTX*)0) {
599 return;
600 }
601 MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
602 MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH);
603 context->bitcount[0] = context->bitcount[1] = 0;
604}
605
606#ifdef SHA2_UNROLL_TRANSFORM
607
608/* Unrolled SHA-512 round macros: */
609#if !APR_IS_BIGENDIAN
610
611#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
612 REVERSE64(*data++, W512[j]); \
613 T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
614 K512[j] + W512[j]; \
615 (d) += T1, \
616 (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \
617 j++
618
619
620#else /* APR_IS_BIGENDIAN */
621
622#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
623 T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
624 K512[j] + (W512[j] = *data++); \
625 (d) += T1; \
626 (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
627 j++
628
629#endif /* APR_IS_BIGENDIAN */
630
631#define ROUND512(a,b,c,d,e,f,g,h) \
632 s0 = W512[(j+1)&0x0f]; \
633 s0 = sigma0_512(s0); \
634 s1 = W512[(j+14)&0x0f]; \
635 s1 = sigma1_512(s1); \
636 T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \
637 (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \
638 (d) += T1; \
639 (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
640 j++
641
642void apr__SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
643 sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
644 sha2_word64 T1, *W512 = (sha2_word64*)context->buffer;
645 int j;
646
647 /* Initialize registers with the prev. intermediate value */
648 a = context->state[0];
649 b = context->state[1];
650 c = context->state[2];
651 d = context->state[3];
652 e = context->state[4];
653 f = context->state[5];
654 g = context->state[6];
655 h = context->state[7];
656
657 j = 0;
658 do {
659 ROUND512_0_TO_15(a,b,c,d,e,f,g,h);
660 ROUND512_0_TO_15(h,a,b,c,d,e,f,g);
661 ROUND512_0_TO_15(g,h,a,b,c,d,e,f);
662 ROUND512_0_TO_15(f,g,h,a,b,c,d,e);
663 ROUND512_0_TO_15(e,f,g,h,a,b,c,d);
664 ROUND512_0_TO_15(d,e,f,g,h,a,b,c);
665 ROUND512_0_TO_15(c,d,e,f,g,h,a,b);
666 ROUND512_0_TO_15(b,c,d,e,f,g,h,a);
667 } while (j < 16);
668
669 /* Now for the remaining rounds up to 79: */
670 do {
671 ROUND512(a,b,c,d,e,f,g,h);
672 ROUND512(h,a,b,c,d,e,f,g);
673 ROUND512(g,h,a,b,c,d,e,f);
674 ROUND512(f,g,h,a,b,c,d,e);
675 ROUND512(e,f,g,h,a,b,c,d);
676 ROUND512(d,e,f,g,h,a,b,c);
677 ROUND512(c,d,e,f,g,h,a,b);
678 ROUND512(b,c,d,e,f,g,h,a);
679 } while (j < 80);
680
681 /* Compute the current intermediate hash value */
682 context->state[0] += a;
683 context->state[1] += b;
684 context->state[2] += c;
685 context->state[3] += d;
686 context->state[4] += e;
687 context->state[5] += f;
688 context->state[6] += g;
689 context->state[7] += h;
690
691 /* Clean up */
692 a = b = c = d = e = f = g = h = T1 = 0;
693}
694
695#else /* SHA2_UNROLL_TRANSFORM */
696
697void apr__SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
698 sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
699 sha2_word64 T1, T2, *W512 = (sha2_word64*)context->buffer;
700 int j;
701
702 /* Initialize registers with the prev. intermediate value */
703 a = context->state[0];
704 b = context->state[1];
705 c = context->state[2];
706 d = context->state[3];
707 e = context->state[4];
708 f = context->state[5];
709 g = context->state[6];
710 h = context->state[7];
711
712 j = 0;
713 do {
714#if !APR_IS_BIGENDIAN
715 /* Convert TO host byte order */
716 REVERSE64(*data++, W512[j]);
717 /* Apply the SHA-512 compression function to update a..h */
718 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j];
719#else /* APR_IS_BIGENDIAN */
720 /* Apply the SHA-512 compression function to update a..h with copy */
721 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++);
722#endif /* APR_IS_BIGENDIAN */
723 T2 = Sigma0_512(a) + Maj(a, b, c);
724 h = g;
725 g = f;
726 f = e;
727 e = d + T1;
728 d = c;
729 c = b;
730 b = a;
731 a = T1 + T2;
732
733 j++;
734 } while (j < 16);
735
736 do {
737 /* Part of the message block expansion: */
738 s0 = W512[(j+1)&0x0f];
739 s0 = sigma0_512(s0);
740 s1 = W512[(j+14)&0x0f];
741 s1 = sigma1_512(s1);
742
743 /* Apply the SHA-512 compression function to update a..h */
744 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] +
745 (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);
746 T2 = Sigma0_512(a) + Maj(a, b, c);
747 h = g;
748 g = f;
749 f = e;
750 e = d + T1;
751 d = c;
752 c = b;
753 b = a;
754 a = T1 + T2;
755
756 j++;
757 } while (j < 80);
758
759 /* Compute the current intermediate hash value */
760 context->state[0] += a;
761 context->state[1] += b;
762 context->state[2] += c;
763 context->state[3] += d;
764 context->state[4] += e;
765 context->state[5] += f;
766 context->state[6] += g;
767 context->state[7] += h;
768
769 /* Clean up */
770 a = b = c = d = e = f = g = h = T1 = T2 = 0;
771}
772
773#endif /* SHA2_UNROLL_TRANSFORM */
774
775void apr__SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
776 unsigned int freespace, usedspace;
777
778 if (len == 0) {
779 /* Calling with no data is valid - we do nothing */
780 return;
781 }
782
783 /* Sanity check: */
784 assert(context != (SHA512_CTX*)0 && data != (sha2_byte*)0);
785
786 usedspace = (unsigned int)((context->bitcount[0] >> 3)
787 % SHA512_BLOCK_LENGTH);
788 if (usedspace > 0) {
789 /* Calculate how much free space is available in the buffer */
790 freespace = SHA512_BLOCK_LENGTH - usedspace;
791
792 if (len >= freespace) {
793 /* Fill the buffer completely and process it */
794 MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
795 ADDINC128(context->bitcount, freespace << 3);
796 len -= freespace;
797 data += freespace;
798 apr__SHA512_Transform(context, (sha2_word64*)context->buffer);
799 } else {
800 /* The buffer is not yet full */
801 MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
802 ADDINC128(context->bitcount, len << 3);
803 /* Clean up: */
804 usedspace = freespace = 0;
805 return;
806 }
807 }
808 while (len >= SHA512_BLOCK_LENGTH) {
809 /* Process as many complete blocks as we can */
810 apr__SHA512_Transform(context, (sha2_word64*)data);
811 ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
812 len -= SHA512_BLOCK_LENGTH;
813 data += SHA512_BLOCK_LENGTH;
814 }
815 if (len > 0) {
816 /* There's left-overs, so save 'em */
817 MEMCPY_BCOPY(context->buffer, data, len);
818 ADDINC128(context->bitcount, len << 3);
819 }
820 /* Clean up: */
821 usedspace = freespace = 0;
822}
823
824void apr__SHA512_Last(SHA512_CTX* context) {
825 unsigned int usedspace;
826
827 usedspace = (unsigned int)((context->bitcount[0] >> 3)
828 % SHA512_BLOCK_LENGTH);
829#if !APR_IS_BIGENDIAN
830 /* Convert FROM host byte order */
831 REVERSE64(context->bitcount[0],context->bitcount[0]);
832 REVERSE64(context->bitcount[1],context->bitcount[1]);
833#endif
834 if (usedspace > 0) {
835 /* Begin padding with a 1 bit: */
836 context->buffer[usedspace++] = 0x80;
837
838 if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) {
839 /* Set-up for the last transform: */
840 MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace);
841 } else {
842 if (usedspace < SHA512_BLOCK_LENGTH) {
843 MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace);
844 }
845 /* Do second-to-last transform: */
846 apr__SHA512_Transform(context, (sha2_word64*)context->buffer);
847
848 /* And set-up for the last transform: */
849 MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH - 2);
850 }
851 } else {
852 /* Prepare for final transform: */
853 MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LENGTH);
854
855 /* Begin padding with a 1 bit: */
856 *context->buffer = 0x80;
857 }
858 /* Store the length of input data (in bits): */
859 *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1];
860 *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0];
861
862 /* Final transform: */
863 apr__SHA512_Transform(context, (sha2_word64*)context->buffer);
864}
865
866void apr__SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
867 sha2_word64 *d = (sha2_word64*)digest;
868
869 /* Sanity check: */
870 assert(context != (SHA512_CTX*)0);
871
872 /* If no digest buffer is passed, we don't bother doing this: */
873 if (digest != (sha2_byte*)0) {
874 apr__SHA512_Last(context);
875
876 /* Save the hash data for output: */
877#if !APR_IS_BIGENDIAN
878 {
879 /* Convert TO host byte order */
880 int j;
881 for (j = 0; j < 8; j++) {
882 REVERSE64(context->state[j],context->state[j]);
883 *d++ = context->state[j];
884 }
885 }
886#else /* APR_IS_BIGENDIAN */
887 MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LENGTH);
888#endif /* APR_IS_BIGENDIAN */
889 }
890
891 /* Zero out state data */
892 MEMSET_BZERO(context, sizeof(*context));
893}
894
895char *apr__SHA512_End(SHA512_CTX* context, char buffer[]) {
896 sha2_byte digest[SHA512_DIGEST_LENGTH], *d = digest;
897 int i;
898
899 /* Sanity check: */
900 assert(context != (SHA512_CTX*)0);
901
902 if (buffer != (char*)0) {
903 apr__SHA512_Final(digest, context);
904
905 for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
906 *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
907 *buffer++ = sha2_hex_digits[*d & 0x0f];
908 d++;
909 }
910 *buffer = (char)0;
911 } else {
912 MEMSET_BZERO(context, sizeof(*context));
913 }
914 MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH);
915 return buffer;
916}
917
918char* apr__SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
919 SHA512_CTX context;
920
921 apr__SHA512_Init(&context);
922 apr__SHA512_Update(&context, data, len);
923 return apr__SHA512_End(&context, digest);
924}
925
926
927/*** SHA-384: *********************************************************/
928void apr__SHA384_Init(SHA384_CTX* context) {
929 if (context == (SHA384_CTX*)0) {
930 return;
931 }
932 MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
933 MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH);
934 context->bitcount[0] = context->bitcount[1] = 0;
935}
936
937void apr__SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) {
938 apr__SHA512_Update((SHA512_CTX*)context, data, len);
939}
940
941void apr__SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
942 sha2_word64 *d = (sha2_word64*)digest;
943
944 /* Sanity check: */
945 assert(context != (SHA384_CTX*)0);
946
947 /* If no digest buffer is passed, we don't bother doing this: */
948 if (digest != (sha2_byte*)0) {
949 apr__SHA512_Last((SHA512_CTX*)context);
950
951 /* Save the hash data for output: */
952#if !APR_IS_BIGENDIAN
953 {
954 /* Convert TO host byte order */
955 int j;
956 for (j = 0; j < 6; j++) {
957 REVERSE64(context->state[j],context->state[j]);
958 *d++ = context->state[j];
959 }
960 }
961#else /* APR_IS_BIGENDIAN */
962 MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LENGTH);
963#endif /* APR_IS_BIGENDIAN */
964 }
965
966 /* Zero out state data */
967 MEMSET_BZERO(context, sizeof(*context));
968}
969
970char *apr__SHA384_End(SHA384_CTX* context, char buffer[]) {
971 sha2_byte digest[SHA384_DIGEST_LENGTH], *d = digest;
972 int i;
973
974 /* Sanity check: */
975 assert(context != (SHA384_CTX*)0);
976
977 if (buffer != (char*)0) {
978 apr__SHA384_Final(digest, context);
979
980 for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
981 *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
982 *buffer++ = sha2_hex_digits[*d & 0x0f];
983 d++;
984 }
985 *buffer = (char)0;
986 } else {
987 MEMSET_BZERO(context, sizeof(*context));
988 }
989 MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH);
990 return buffer;
991}
992
993char* apr__SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) {
994 SHA384_CTX context;
995
996 apr__SHA384_Init(&context);
997 apr__SHA384_Update(&context, data, len);
998 return apr__SHA384_End(&context, digest);
999}
1000