From c0ec88b6aa330d3a5a58396645678a31ed9f5d78 Mon Sep 17 00:00:00 2001 From: Jan Kaluza Date: Dec 12 2012 09:24:25 +0000 Subject: fix strict-aliasing gcc warning - remove unused SHA384 and SHA512 code --- diff --git a/apr-1.4.6-strict-aliasing.patch b/apr-1.4.6-strict-aliasing.patch new file mode 100644 index 0000000..59ef9f9 --- /dev/null +++ b/apr-1.4.6-strict-aliasing.patch @@ -0,0 +1,32 @@ +From 9ae65df5802f5f49751c851182ed2a90447c45f5 Mon Sep 17 00:00:00 2001 +From: Jan Kaluza +Date: Tue, 11 Dec 2012 11:07:28 +0100 +Subject: [PATCH 1/2] Fix strict-aliasing gcc warning + +--- + random/unix/sha2.c | 9 ++++++++- + 1 file changed, 8 insertions(+), 1 deletion(-) + +diff --git a/random/unix/sha2.c b/random/unix/sha2.c +index 212c1b7..887ac81 100644 +--- a/random/unix/sha2.c ++++ b/random/unix/sha2.c +@@ -537,7 +537,14 @@ void apr__SHA256_Final(sha2_byte digest[], SHA256_CTX* context) { + *context->buffer = 0x80; + } + /* Set the bit count: */ +- *(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount; ++ { ++ union { ++ apr_uint64_t bitcount; ++ apr_byte_t bytes[8]; ++ } bitcount; ++ bitcount.bitcount = context->bitcount; ++ MEMCPY_BCOPY(&context->buffer[SHA256_SHORT_BLOCK_LENGTH], bitcount.bytes, 8); ++ } + + /* Final transform: */ + apr__SHA256_Transform(context, (sha2_word32*)context->buffer); +-- +1.8.0 + diff --git a/apr-1.4.6-unused-code.patch b/apr-1.4.6-unused-code.patch new file mode 100644 index 0000000..8303835 --- /dev/null +++ b/apr-1.4.6-unused-code.patch @@ -0,0 +1,581 @@ +From acb4df5e6cfe894e5f9aff43f97db58af90723bb Mon Sep 17 00:00:00 2001 +From: Jan Kaluza +Date: Tue, 11 Dec 2012 11:07:56 +0100 +Subject: [PATCH 2/2] Remove unused sha2.c/sha2.h code + +--- + random/unix/sha2.c | 479 ----------------------------------------------------- + random/unix/sha2.h | 31 +--- + 2 files changed, 2 insertions(+), 508 deletions(-) + +diff --git a/random/unix/sha2.c b/random/unix/sha2.c +index 887ac81..66f4a4c 100644 +--- a/random/unix/sha2.c ++++ b/random/unix/sha2.c +@@ -52,8 +52,6 @@ typedef apr_uint64_t sha2_word64; /* Exactly 8 bytes */ + /*** SHA-256/384/512 Various Length Definitions ***********************/ + /* NOTE: Most of these are in sha2.h */ + #define SHA256_SHORT_BLOCK_LENGTH (SHA256_BLOCK_LENGTH - 8) +-#define SHA384_SHORT_BLOCK_LENGTH (SHA384_BLOCK_LENGTH - 16) +-#define SHA512_SHORT_BLOCK_LENGTH (SHA512_BLOCK_LENGTH - 16) + + + /*** ENDIAN REVERSAL MACROS *******************************************/ +@@ -150,9 +148,7 @@ typedef apr_uint64_t sha2_word64; /* Exactly 8 bytes */ + * library -- they are intended for private internal visibility/use + * only. + */ +-void apr__SHA512_Last(SHA512_CTX*); + void apr__SHA256_Transform(SHA256_CTX*, const sha2_word32*); +-void apr__SHA512_Transform(SHA512_CTX*, const sha2_word64*); + + + /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/ +@@ -188,74 +184,6 @@ static const sha2_word32 sha256_initial_hash_value[8] = { + 0x5be0cd19UL + }; + +-/* Hash constant words K for SHA-384 and SHA-512: */ +-static const sha2_word64 K512[80] = { +- APR_UINT64_C(0x428a2f98d728ae22), APR_UINT64_C(0x7137449123ef65cd), +- APR_UINT64_C(0xb5c0fbcfec4d3b2f), APR_UINT64_C(0xe9b5dba58189dbbc), +- APR_UINT64_C(0x3956c25bf348b538), APR_UINT64_C(0x59f111f1b605d019), +- APR_UINT64_C(0x923f82a4af194f9b), APR_UINT64_C(0xab1c5ed5da6d8118), +- APR_UINT64_C(0xd807aa98a3030242), APR_UINT64_C(0x12835b0145706fbe), +- APR_UINT64_C(0x243185be4ee4b28c), APR_UINT64_C(0x550c7dc3d5ffb4e2), +- APR_UINT64_C(0x72be5d74f27b896f), APR_UINT64_C(0x80deb1fe3b1696b1), +- APR_UINT64_C(0x9bdc06a725c71235), APR_UINT64_C(0xc19bf174cf692694), +- APR_UINT64_C(0xe49b69c19ef14ad2), APR_UINT64_C(0xefbe4786384f25e3), +- APR_UINT64_C(0x0fc19dc68b8cd5b5), APR_UINT64_C(0x240ca1cc77ac9c65), +- APR_UINT64_C(0x2de92c6f592b0275), APR_UINT64_C(0x4a7484aa6ea6e483), +- APR_UINT64_C(0x5cb0a9dcbd41fbd4), APR_UINT64_C(0x76f988da831153b5), +- APR_UINT64_C(0x983e5152ee66dfab), APR_UINT64_C(0xa831c66d2db43210), +- APR_UINT64_C(0xb00327c898fb213f), APR_UINT64_C(0xbf597fc7beef0ee4), +- APR_UINT64_C(0xc6e00bf33da88fc2), APR_UINT64_C(0xd5a79147930aa725), +- APR_UINT64_C(0x06ca6351e003826f), APR_UINT64_C(0x142929670a0e6e70), +- APR_UINT64_C(0x27b70a8546d22ffc), APR_UINT64_C(0x2e1b21385c26c926), +- APR_UINT64_C(0x4d2c6dfc5ac42aed), APR_UINT64_C(0x53380d139d95b3df), +- APR_UINT64_C(0x650a73548baf63de), APR_UINT64_C(0x766a0abb3c77b2a8), +- APR_UINT64_C(0x81c2c92e47edaee6), APR_UINT64_C(0x92722c851482353b), +- APR_UINT64_C(0xa2bfe8a14cf10364), APR_UINT64_C(0xa81a664bbc423001), +- APR_UINT64_C(0xc24b8b70d0f89791), APR_UINT64_C(0xc76c51a30654be30), +- APR_UINT64_C(0xd192e819d6ef5218), APR_UINT64_C(0xd69906245565a910), +- APR_UINT64_C(0xf40e35855771202a), APR_UINT64_C(0x106aa07032bbd1b8), +- APR_UINT64_C(0x19a4c116b8d2d0c8), APR_UINT64_C(0x1e376c085141ab53), +- APR_UINT64_C(0x2748774cdf8eeb99), APR_UINT64_C(0x34b0bcb5e19b48a8), +- APR_UINT64_C(0x391c0cb3c5c95a63), APR_UINT64_C(0x4ed8aa4ae3418acb), +- APR_UINT64_C(0x5b9cca4f7763e373), APR_UINT64_C(0x682e6ff3d6b2b8a3), +- APR_UINT64_C(0x748f82ee5defb2fc), APR_UINT64_C(0x78a5636f43172f60), +- APR_UINT64_C(0x84c87814a1f0ab72), APR_UINT64_C(0x8cc702081a6439ec), +- APR_UINT64_C(0x90befffa23631e28), APR_UINT64_C(0xa4506cebde82bde9), +- APR_UINT64_C(0xbef9a3f7b2c67915), APR_UINT64_C(0xc67178f2e372532b), +- APR_UINT64_C(0xca273eceea26619c), APR_UINT64_C(0xd186b8c721c0c207), +- APR_UINT64_C(0xeada7dd6cde0eb1e), APR_UINT64_C(0xf57d4f7fee6ed178), +- APR_UINT64_C(0x06f067aa72176fba), APR_UINT64_C(0x0a637dc5a2c898a6), +- APR_UINT64_C(0x113f9804bef90dae), APR_UINT64_C(0x1b710b35131c471b), +- APR_UINT64_C(0x28db77f523047d84), APR_UINT64_C(0x32caab7b40c72493), +- APR_UINT64_C(0x3c9ebe0a15c9bebc), APR_UINT64_C(0x431d67c49c100d4c), +- APR_UINT64_C(0x4cc5d4becb3e42b6), APR_UINT64_C(0x597f299cfc657e2a), +- APR_UINT64_C(0x5fcb6fab3ad6faec), APR_UINT64_C(0x6c44198c4a475817) +-}; +- +-/* Initial hash value H for SHA-384 */ +-static const sha2_word64 sha384_initial_hash_value[8] = { +- APR_UINT64_C(0xcbbb9d5dc1059ed8), +- APR_UINT64_C(0x629a292a367cd507), +- APR_UINT64_C(0x9159015a3070dd17), +- APR_UINT64_C(0x152fecd8f70e5939), +- APR_UINT64_C(0x67332667ffc00b31), +- APR_UINT64_C(0x8eb44a8768581511), +- APR_UINT64_C(0xdb0c2e0d64f98fa7), +- APR_UINT64_C(0x47b5481dbefa4fa4) +-}; +- +-/* Initial hash value H for SHA-512 */ +-static const sha2_word64 sha512_initial_hash_value[8] = { +- APR_UINT64_C(0x6a09e667f3bcc908), +- APR_UINT64_C(0xbb67ae8584caa73b), +- APR_UINT64_C(0x3c6ef372fe94f82b), +- APR_UINT64_C(0xa54ff53a5f1d36f1), +- APR_UINT64_C(0x510e527fade682d1), +- APR_UINT64_C(0x9b05688c2b3e6c1f), +- APR_UINT64_C(0x1f83d9abfb41bd6b), +- APR_UINT64_C(0x5be0cd19137e2179) +-}; +- + /* + * Constant used by SHA256/384/512_End() functions for converting the + * digest to a readable hexadecimal character string: +@@ -598,410 +526,3 @@ char* apr__SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIG + apr__SHA256_Update(&context, data, len); + return apr__SHA256_End(&context, digest); + } +- +- +-/*** SHA-512: *********************************************************/ +-void apr__SHA512_Init(SHA512_CTX* context) { +- if (context == (SHA512_CTX*)0) { +- return; +- } +- MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH); +- MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH); +- context->bitcount[0] = context->bitcount[1] = 0; +-} +- +-#ifdef SHA2_UNROLL_TRANSFORM +- +-/* Unrolled SHA-512 round macros: */ +-#if !APR_IS_BIGENDIAN +- +-#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \ +- REVERSE64(*data++, W512[j]); \ +- T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \ +- K512[j] + W512[j]; \ +- (d) += T1, \ +- (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \ +- j++ +- +- +-#else /* APR_IS_BIGENDIAN */ +- +-#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \ +- T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \ +- K512[j] + (W512[j] = *data++); \ +- (d) += T1; \ +- (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \ +- j++ +- +-#endif /* APR_IS_BIGENDIAN */ +- +-#define ROUND512(a,b,c,d,e,f,g,h) \ +- s0 = W512[(j+1)&0x0f]; \ +- s0 = sigma0_512(s0); \ +- s1 = W512[(j+14)&0x0f]; \ +- s1 = sigma1_512(s1); \ +- T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \ +- (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \ +- (d) += T1; \ +- (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \ +- j++ +- +-void apr__SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) { +- sha2_word64 a, b, c, d, e, f, g, h, s0, s1; +- sha2_word64 T1, *W512 = (sha2_word64*)context->buffer; +- int j; +- +- /* Initialize registers with the prev. intermediate value */ +- a = context->state[0]; +- b = context->state[1]; +- c = context->state[2]; +- d = context->state[3]; +- e = context->state[4]; +- f = context->state[5]; +- g = context->state[6]; +- h = context->state[7]; +- +- j = 0; +- do { +- ROUND512_0_TO_15(a,b,c,d,e,f,g,h); +- ROUND512_0_TO_15(h,a,b,c,d,e,f,g); +- ROUND512_0_TO_15(g,h,a,b,c,d,e,f); +- ROUND512_0_TO_15(f,g,h,a,b,c,d,e); +- ROUND512_0_TO_15(e,f,g,h,a,b,c,d); +- ROUND512_0_TO_15(d,e,f,g,h,a,b,c); +- ROUND512_0_TO_15(c,d,e,f,g,h,a,b); +- ROUND512_0_TO_15(b,c,d,e,f,g,h,a); +- } while (j < 16); +- +- /* Now for the remaining rounds up to 79: */ +- do { +- ROUND512(a,b,c,d,e,f,g,h); +- ROUND512(h,a,b,c,d,e,f,g); +- ROUND512(g,h,a,b,c,d,e,f); +- ROUND512(f,g,h,a,b,c,d,e); +- ROUND512(e,f,g,h,a,b,c,d); +- ROUND512(d,e,f,g,h,a,b,c); +- ROUND512(c,d,e,f,g,h,a,b); +- ROUND512(b,c,d,e,f,g,h,a); +- } while (j < 80); +- +- /* Compute the current intermediate hash value */ +- context->state[0] += a; +- context->state[1] += b; +- context->state[2] += c; +- context->state[3] += d; +- context->state[4] += e; +- context->state[5] += f; +- context->state[6] += g; +- context->state[7] += h; +- +- /* Clean up */ +- a = b = c = d = e = f = g = h = T1 = 0; +-} +- +-#else /* SHA2_UNROLL_TRANSFORM */ +- +-void apr__SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) { +- sha2_word64 a, b, c, d, e, f, g, h, s0, s1; +- sha2_word64 T1, T2, *W512 = (sha2_word64*)context->buffer; +- int j; +- +- /* Initialize registers with the prev. intermediate value */ +- a = context->state[0]; +- b = context->state[1]; +- c = context->state[2]; +- d = context->state[3]; +- e = context->state[4]; +- f = context->state[5]; +- g = context->state[6]; +- h = context->state[7]; +- +- j = 0; +- do { +-#if !APR_IS_BIGENDIAN +- /* Convert TO host byte order */ +- REVERSE64(*data++, W512[j]); +- /* Apply the SHA-512 compression function to update a..h */ +- T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j]; +-#else /* APR_IS_BIGENDIAN */ +- /* Apply the SHA-512 compression function to update a..h with copy */ +- T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++); +-#endif /* APR_IS_BIGENDIAN */ +- T2 = Sigma0_512(a) + Maj(a, b, c); +- h = g; +- g = f; +- f = e; +- e = d + T1; +- d = c; +- c = b; +- b = a; +- a = T1 + T2; +- +- j++; +- } while (j < 16); +- +- do { +- /* Part of the message block expansion: */ +- s0 = W512[(j+1)&0x0f]; +- s0 = sigma0_512(s0); +- s1 = W512[(j+14)&0x0f]; +- s1 = sigma1_512(s1); +- +- /* Apply the SHA-512 compression function to update a..h */ +- T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + +- (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); +- T2 = Sigma0_512(a) + Maj(a, b, c); +- h = g; +- g = f; +- f = e; +- e = d + T1; +- d = c; +- c = b; +- b = a; +- a = T1 + T2; +- +- j++; +- } while (j < 80); +- +- /* Compute the current intermediate hash value */ +- context->state[0] += a; +- context->state[1] += b; +- context->state[2] += c; +- context->state[3] += d; +- context->state[4] += e; +- context->state[5] += f; +- context->state[6] += g; +- context->state[7] += h; +- +- /* Clean up */ +- a = b = c = d = e = f = g = h = T1 = T2 = 0; +-} +- +-#endif /* SHA2_UNROLL_TRANSFORM */ +- +-void apr__SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) { +- unsigned int freespace, usedspace; +- +- if (len == 0) { +- /* Calling with no data is valid - we do nothing */ +- return; +- } +- +- /* Sanity check: */ +- assert(context != (SHA512_CTX*)0 && data != (sha2_byte*)0); +- +- usedspace = (unsigned int)((context->bitcount[0] >> 3) +- % SHA512_BLOCK_LENGTH); +- if (usedspace > 0) { +- /* Calculate how much free space is available in the buffer */ +- freespace = SHA512_BLOCK_LENGTH - usedspace; +- +- if (len >= freespace) { +- /* Fill the buffer completely and process it */ +- MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace); +- ADDINC128(context->bitcount, freespace << 3); +- len -= freespace; +- data += freespace; +- apr__SHA512_Transform(context, (sha2_word64*)context->buffer); +- } else { +- /* The buffer is not yet full */ +- MEMCPY_BCOPY(&context->buffer[usedspace], data, len); +- ADDINC128(context->bitcount, len << 3); +- /* Clean up: */ +- usedspace = freespace = 0; +- return; +- } +- } +- while (len >= SHA512_BLOCK_LENGTH) { +- /* Process as many complete blocks as we can */ +- apr__SHA512_Transform(context, (sha2_word64*)data); +- ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3); +- len -= SHA512_BLOCK_LENGTH; +- data += SHA512_BLOCK_LENGTH; +- } +- if (len > 0) { +- /* There's left-overs, so save 'em */ +- MEMCPY_BCOPY(context->buffer, data, len); +- ADDINC128(context->bitcount, len << 3); +- } +- /* Clean up: */ +- usedspace = freespace = 0; +-} +- +-void apr__SHA512_Last(SHA512_CTX* context) { +- unsigned int usedspace; +- +- usedspace = (unsigned int)((context->bitcount[0] >> 3) +- % SHA512_BLOCK_LENGTH); +-#if !APR_IS_BIGENDIAN +- /* Convert FROM host byte order */ +- REVERSE64(context->bitcount[0],context->bitcount[0]); +- REVERSE64(context->bitcount[1],context->bitcount[1]); +-#endif +- if (usedspace > 0) { +- /* Begin padding with a 1 bit: */ +- context->buffer[usedspace++] = 0x80; +- +- if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) { +- /* Set-up for the last transform: */ +- MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace); +- } else { +- if (usedspace < SHA512_BLOCK_LENGTH) { +- MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace); +- } +- /* Do second-to-last transform: */ +- apr__SHA512_Transform(context, (sha2_word64*)context->buffer); +- +- /* And set-up for the last transform: */ +- MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH - 2); +- } +- } else { +- /* Prepare for final transform: */ +- MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LENGTH); +- +- /* Begin padding with a 1 bit: */ +- *context->buffer = 0x80; +- } +- /* Store the length of input data (in bits): */ +- *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1]; +- *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0]; +- +- /* Final transform: */ +- apr__SHA512_Transform(context, (sha2_word64*)context->buffer); +-} +- +-void apr__SHA512_Final(sha2_byte digest[], SHA512_CTX* context) { +- sha2_word64 *d = (sha2_word64*)digest; +- +- /* Sanity check: */ +- assert(context != (SHA512_CTX*)0); +- +- /* If no digest buffer is passed, we don't bother doing this: */ +- if (digest != (sha2_byte*)0) { +- apr__SHA512_Last(context); +- +- /* Save the hash data for output: */ +-#if !APR_IS_BIGENDIAN +- { +- /* Convert TO host byte order */ +- int j; +- for (j = 0; j < 8; j++) { +- REVERSE64(context->state[j],context->state[j]); +- *d++ = context->state[j]; +- } +- } +-#else /* APR_IS_BIGENDIAN */ +- MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LENGTH); +-#endif /* APR_IS_BIGENDIAN */ +- } +- +- /* Zero out state data */ +- MEMSET_BZERO(context, sizeof(*context)); +-} +- +-char *apr__SHA512_End(SHA512_CTX* context, char buffer[]) { +- sha2_byte digest[SHA512_DIGEST_LENGTH], *d = digest; +- int i; +- +- /* Sanity check: */ +- assert(context != (SHA512_CTX*)0); +- +- if (buffer != (char*)0) { +- apr__SHA512_Final(digest, context); +- +- for (i = 0; i < SHA512_DIGEST_LENGTH; i++) { +- *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4]; +- *buffer++ = sha2_hex_digits[*d & 0x0f]; +- d++; +- } +- *buffer = (char)0; +- } else { +- MEMSET_BZERO(context, sizeof(*context)); +- } +- MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH); +- return buffer; +-} +- +-char* apr__SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) { +- SHA512_CTX context; +- +- apr__SHA512_Init(&context); +- apr__SHA512_Update(&context, data, len); +- return apr__SHA512_End(&context, digest); +-} +- +- +-/*** SHA-384: *********************************************************/ +-void apr__SHA384_Init(SHA384_CTX* context) { +- if (context == (SHA384_CTX*)0) { +- return; +- } +- MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH); +- MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH); +- context->bitcount[0] = context->bitcount[1] = 0; +-} +- +-void apr__SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) { +- apr__SHA512_Update((SHA512_CTX*)context, data, len); +-} +- +-void apr__SHA384_Final(sha2_byte digest[], SHA384_CTX* context) { +- sha2_word64 *d = (sha2_word64*)digest; +- +- /* Sanity check: */ +- assert(context != (SHA384_CTX*)0); +- +- /* If no digest buffer is passed, we don't bother doing this: */ +- if (digest != (sha2_byte*)0) { +- apr__SHA512_Last((SHA512_CTX*)context); +- +- /* Save the hash data for output: */ +-#if !APR_IS_BIGENDIAN +- { +- /* Convert TO host byte order */ +- int j; +- for (j = 0; j < 6; j++) { +- REVERSE64(context->state[j],context->state[j]); +- *d++ = context->state[j]; +- } +- } +-#else /* APR_IS_BIGENDIAN */ +- MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LENGTH); +-#endif /* APR_IS_BIGENDIAN */ +- } +- +- /* Zero out state data */ +- MEMSET_BZERO(context, sizeof(*context)); +-} +- +-char *apr__SHA384_End(SHA384_CTX* context, char buffer[]) { +- sha2_byte digest[SHA384_DIGEST_LENGTH], *d = digest; +- int i; +- +- /* Sanity check: */ +- assert(context != (SHA384_CTX*)0); +- +- if (buffer != (char*)0) { +- apr__SHA384_Final(digest, context); +- +- for (i = 0; i < SHA384_DIGEST_LENGTH; i++) { +- *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4]; +- *buffer++ = sha2_hex_digits[*d & 0x0f]; +- d++; +- } +- *buffer = (char)0; +- } else { +- MEMSET_BZERO(context, sizeof(*context)); +- } +- MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH); +- return buffer; +-} +- +-char* apr__SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) { +- SHA384_CTX context; +- +- apr__SHA384_Init(&context); +- apr__SHA384_Update(&context, data, len); +- return apr__SHA384_End(&context, digest); +-} +- +diff --git a/random/unix/sha2.h b/random/unix/sha2.h +index 9f0d93e..0a030d7 100644 +--- a/random/unix/sha2.h ++++ b/random/unix/sha2.h +@@ -29,16 +29,10 @@ extern "C" { + + #include "apr.h" + +-/*** SHA-256/384/512 Various Length Definitions ***********************/ ++/*** SHA-256 Various Length Definitions ***********************/ + #define SHA256_BLOCK_LENGTH 64 + #define SHA256_DIGEST_LENGTH 32 + #define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1) +-#define SHA384_BLOCK_LENGTH 128 +-#define SHA384_DIGEST_LENGTH 48 +-#define SHA384_DIGEST_STRING_LENGTH (SHA384_DIGEST_LENGTH * 2 + 1) +-#define SHA512_BLOCK_LENGTH 128 +-#define SHA512_DIGEST_LENGTH 64 +-#define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1) + + + /*** SHA-256/384/512 Context Structures *******************************/ +@@ -47,13 +41,6 @@ typedef struct _SHA256_CTX { + apr_uint64_t bitcount; + apr_byte_t buffer[SHA256_BLOCK_LENGTH]; + } SHA256_CTX; +-typedef struct _SHA512_CTX { +- apr_uint64_t state[8]; +- apr_uint64_t bitcount[2]; +- apr_byte_t buffer[SHA512_BLOCK_LENGTH]; +-} SHA512_CTX; +- +-typedef SHA512_CTX SHA384_CTX; + + + /*** SHA-256/384/512 Function Prototypes ******************************/ +@@ -63,21 +50,7 @@ void apr__SHA256_Final(apr_byte_t [SHA256_DIGEST_LENGTH], SHA256_CTX *); + char* apr__SHA256_End(SHA256_CTX *, char [SHA256_DIGEST_STRING_LENGTH]); + char* apr__SHA256_Data(const apr_byte_t *, size_t, + char [SHA256_DIGEST_STRING_LENGTH]); +- +-void apr__SHA384_Init(SHA384_CTX *); +-void apr__SHA384_Update(SHA384_CTX *, const apr_byte_t *, size_t); +-void apr__SHA384_Final(apr_byte_t [SHA384_DIGEST_LENGTH], SHA384_CTX *); +-char* apr__SHA384_End(SHA384_CTX *, char [SHA384_DIGEST_STRING_LENGTH]); +-char* apr__SHA384_Data(const apr_byte_t *, size_t, +- char [SHA384_DIGEST_STRING_LENGTH]); +- +-void apr__SHA512_Init(SHA512_CTX *); +-void apr__SHA512_Update(SHA512_CTX *, const apr_byte_t *, size_t); +-void apr__SHA512_Final(apr_byte_t [SHA512_DIGEST_LENGTH], SHA512_CTX *); +-char* apr__SHA512_End(SHA512_CTX *, char [SHA512_DIGEST_STRING_LENGTH]); +-char* apr__SHA512_Data(const apr_byte_t *, size_t, +- char [SHA512_DIGEST_STRING_LENGTH]); +- ++ + #ifdef __cplusplus + } + #endif /* __cplusplus */ +-- +1.8.0 + diff --git a/apr.spec b/apr.spec index 174c7cc..4881383 100644 --- a/apr.spec +++ b/apr.spec @@ -6,7 +6,7 @@ Summary: Apache Portable Runtime library Name: apr Version: 1.4.6 -Release: 4%{?dist} +Release: 5%{?dist} # ASL 2.0: everything # ISC: network_io/apr-1.4.6/network_io/unix/inet_?to?.c # BSD with advertising: strings/apr_snprintf.c, strings/apr_fnmatch.c, @@ -22,6 +22,8 @@ Patch2: apr-1.2.2-locktimeout.patch Patch3: apr-1.2.2-libdir.patch Patch4: apr-1.2.7-pkgconf.patch Patch5: apr-1.4.6-r1309386.patch +Patch6: apr-1.4.6-strict-aliasing.patch +Patch7: apr-1.4.6-unused-code.patch BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot BuildRequires: autoconf, libtool, libuuid-devel, python # To enable SCTP support @@ -51,6 +53,8 @@ C data structures and routines. %patch3 -p1 -b .libdir %patch4 -p1 -b .pkgconf %patch5 -p1 -b .r1309386 +%patch6 -p1 -b .strictaliasing +%patch7 -p1 -b .unusedcode %build # regenerate configure script etc. @@ -131,6 +135,10 @@ rm -rf $RPM_BUILD_ROOT %{_datadir}/aclocal/*.m4 %changelog +* Wed Dec 12 2012 Jan Kaluza - 1.4.6-5 +- fix strict-aliasing gcc warning +- remove unused SHA384 and SHA512 code + * Thu Nov 22 2012 Joe Orton - 1.4.6-4 - update license