Fork of François Berder Crypto, fixed AES CBC and small rework
Dependents: AES_example shaun_larada Smartage
Fork of Crypto by
Revision 6:19aa835f2bbb, committed 2013-09-12
- Comitter:
- feb11
- Date:
- Thu Sep 12 16:03:43 2013 +0000
- Parent:
- 5:06cd9c8afa0b
- Child:
- 7:2dbbdfb08123
- Commit message:
- change public API for hash + small improvements for hash + rearrange code
Changed in this revision
--- a/HashAlgorithm.h Thu Sep 12 15:08:51 2013 +0000 +++ b/HashAlgorithm.h Thu Sep 12 16:03:43 2013 +0000 @@ -8,9 +8,10 @@ public : virtual ~HashAlgorithm(); - virtual void update(uint8_t *in, uint32_t length) = 0; - virtual void finalize(uint8_t *out) = 0; + virtual uint8_t outputSize() const = 0; + virtual void update(uint8_t *data, uint32_t length) = 0; + virtual void finalize(uint8_t *hash) = 0; }; #endif
--- a/MD2.cpp Thu Sep 12 15:08:51 2013 +0000 +++ b/MD2.cpp Thu Sep 12 16:03:43 2013 +0000 @@ -36,6 +36,92 @@ memset(x, 0, 16); } +uint8_t MD2::outputSize() const +{ + return 16; +} + +void MD2::update(uint8_t *data, uint32_t length) +{ + if(bufferLength == 0) + { + while(length >= 16) + { + computeBlock(checksum, x, &l, data); + length -= 16; + data += 16; + } + bufferLength = length; + memcpy(buffer, data, length); + } + else if(length < 16-bufferLength) + { + memcpy(&buffer[bufferLength], data, length); + bufferLength += length; + } + else + { + int offset = 16-bufferLength; + memcpy(&buffer[bufferLength], data, offset); + computeBlock(checksum, x, &l, buffer); + data += offset; + length -= offset; + while(length >= 16) + { + computeBlock(checksum, x, &l, data); + data += 16; + length -= 16; + } + bufferLength = length; + memcpy(buffer, &data, length); + } + +} + +void MD2::finalize(uint8_t *hash) +{ + // compute what's left data the buffer + int padding = 16 - bufferLength; + memset(&buffer[bufferLength], padding, padding); + computeBlock(checksum, x, &l, buffer); + computeBlock(checksum, x, &l, checksum); + memcpy(hash, x, 16); + + uint32_t *x2 = (uint32_t*)x; + uint32_t *checksum2 = (uint32_t*)checksum; + + // reset state + bufferLength = 0; + l = 0; + checksum2[0] = x2[0] = 0; + checksum2[1] = x2[1] = 0; + checksum2[2] = x2[2] = 0; + checksum2[3] = x2[3] = 0; +} + +void MD2::computeHash(uint8_t *hash, uint8_t *data, uint32_t length) +{ + uint8_t x[48]; + uint8_t checksum[16]; + uint8_t buffer[16]; + memset(x, 0, 16); + memset(checksum, 0, 16); + uint8_t l = 0; + while(length >= 16) + { + computeBlock(checksum, x, &l, data); + length -= 16; + data += 16; + } + + memcpy(buffer, data, length); + uint8_t padding = 16-length; + memset(&buffer[length], padding, padding); + computeBlock(checksum, x, &l, buffer); + computeBlock(checksum,x, &l, checksum); + memcpy(hash, x, 16); +} + void MD2::computeBlock(uint8_t *checksum2, uint8_t *x2, uint8_t *l2, uint8_t *buffer2) { if(checksum2 != buffer2) @@ -112,90 +198,4 @@ t += j; } -} - -void MD2::update(uint8_t *in, uint32_t length) -{ - if(bufferLength == 0) - { - while(length >= 16) - { - computeBlock(checksum, x, &l, in); - length -= 16; - in += 16; - } - bufferLength = length; - memcpy(buffer, in, length); - } - else if(length < 16-bufferLength) - { - memcpy(&buffer[bufferLength], in, length); - bufferLength += length; - } - else - { - int offset = 16-bufferLength; - memcpy(&buffer[bufferLength], in, offset); - computeBlock(checksum, x, &l, buffer); - in += offset; - length -= offset; - while(length >= 16) - { - computeBlock(checksum, x, &l, in); - in += 16; - length -= 16; - } - bufferLength = length; - memcpy(buffer, &in, length); - } - -} - -void MD2::finalize(uint8_t *digest) -{ - // compute what's left in the buffer - int padding = 16 - bufferLength; - memset(&buffer[bufferLength], padding, padding); - computeBlock(checksum, x, &l, buffer); - computeBlock(checksum, x, &l, checksum); - memcpy(digest, x, 16); - - uint32_t *x2 = (uint32_t*)x; - uint32_t *checksum2 = (uint32_t*)checksum; - - // reset state - bufferLength = 0; - l = 0; - checksum2[0] = x2[0] = 0; - checksum2[1] = x2[1] = 0; - checksum2[2] = x2[2] = 0; - checksum2[3] = x2[3] = 0; -} - -uint8_t MD2::outputSize() const -{ - return 16; -} - -void MD2::computeDigest(uint8_t *digest, uint8_t *in, uint32_t length) -{ - uint8_t x[48]; - uint8_t checksum[16]; - uint8_t buffer[16]; - memset(x, 0, 16); - memset(checksum, 0, 16); - uint8_t l = 0; - while(length >= 16) - { - computeBlock(checksum, x, &l, in); - length -= 16; - in += 16; - } - - memcpy(buffer, in, length); - uint8_t padding = 16-length; - memset(&buffer[length], padding, padding); - computeBlock(checksum, x, &l, buffer); - computeBlock(checksum,x, &l, checksum); - memcpy(digest, x, 16); -} +} \ No newline at end of file
--- a/MD2.h Thu Sep 12 15:08:51 2013 +0000 +++ b/MD2.h Thu Sep 12 16:03:43 2013 +0000 @@ -9,11 +9,11 @@ MD2(); - virtual void update(uint8_t *in, uint32_t length); - virtual void finalize(uint8_t *out); virtual uint8_t outputSize() const; + virtual void update(uint8_t *data, uint32_t length); + virtual void finalize(uint8_t *hash); - static void computeDigest(uint8_t *digest, uint8_t *in, uint32_t length); + static void computeHash(uint8_t *hash, uint8_t *data, uint32_t length); private :
--- a/MD5.cpp Thu Sep 12 15:08:51 2013 +0000 +++ b/MD5.cpp Thu Sep 12 16:03:43 2013 +0000 @@ -50,33 +50,34 @@ return 16; } -void MD5::update(uint8_t *in, uint32_t length) +void MD5::update(uint8_t *data, uint32_t length) { if(length < 64-bufferLength) { - memcpy(&buffer[bufferLength], in, length); + memcpy(&buffer[bufferLength], data, length); bufferLength += length; totalBufferLength += length; return; } int offset = 64-bufferLength; - memcpy(&buffer[bufferLength], in, offset); + memcpy(&buffer[bufferLength], data, offset); computeRounds(&a, &b, &c, &d, buffer); while(length-offset > 64) { - memcpy(buffer, &in[offset], 64); + memcpy(buffer, &data[offset], 64); computeRounds(&a, &b, &c, &d, buffer); offset += 64; } if(offset > length) offset -= 64; bufferLength = length - offset; - memcpy(buffer, &in[offset], bufferLength); + memcpy(buffer, &data[offset], bufferLength); totalBufferLength += length; } -void MD5::finalize(uint8_t *digest) +void MD5::finalize(uint8_t *hash) { + uint32_t *hash2 = (uint32_t*)hash; uint16_t padding; if(totalBufferLength % 64 < 56) padding = 56 - (totalBufferLength % 64); @@ -99,10 +100,10 @@ memcpy(&buffer[60], &lengthBitHigh, 4); computeRounds(&a, &b, &c, &d, buffer); - memcpy(digest, &a, 4); - memcpy(&digest[4], &b, 4); - memcpy(&digest[8], &c, 4); - memcpy(&digest[12], &d, 4); + hash2[0] = a; + hash2[1] = b; + hash2[2] = c; + hash2[3] = d; // reset state a = A; b = B; @@ -112,9 +113,52 @@ bufferLength = 0; } + +void MD5::computeHash(uint8_t *hash, uint8_t *data, uint32_t length) +{ + uint32_t *hash2 = (uint32_t*)hash; + uint64_t lengthBit = length << 3; + uint16_t padding; + if(length % 64 < 56) + padding = 56 - (length % 64); + else + padding = 56 + (64 - (length % 64)); + + uint32_t a = A, b = B, c = C, d = D; + while(length >= 64) + { + computeRounds(&a, &b, &c, &d, data); + data += 64; + length -= 64; + } + uint8_t buffer[64]; + memcpy(buffer, data, length); + buffer[length++] = 0x80; + padding--; + if(padding+length == 56) + memset(&buffer[length], 0, padding); + else + { + memset(&buffer[length], 0, 64-length); + computeRounds(&a, &b, &c, &d, data); + memset(buffer, 0, 56); + } + + uint32_t lengthBitLow = lengthBit; + uint32_t lengthBitHigh = lengthBit >> 32; + memcpy(&buffer[56], &lengthBitLow, 4); + memcpy(&buffer[60], &lengthBitHigh, 4); + + computeRounds(&a, &b, &c, &d, buffer); + + hash2[0] = a; + hash2[1] = b; + hash2[2] = c; + hash2[3] = d; +} + void MD5::computeRounds(uint32_t *a2, uint32_t *b2, uint32_t *c2, uint32_t *d2, uint8_t *buffer) { - uint32_t a = *a2, b = *b2, c = *c2, d = *d2; uint32_t tmpA = a, tmpB = b, tmpC = c, tmpD = d; @@ -152,45 +196,3 @@ *c2 = c + tmpC; *d2 = d + tmpD; } - -void MD5::computeDigest(uint8_t *digest, uint8_t *msg, uint32_t length) -{ - uint64_t lengthBit = length << 3; - uint16_t padding; - if(length % 64 < 56) - padding = 56 - (length % 64); - else - padding = 56 + (64 - (length % 64)); - - uint32_t a = A, b = B, c = C, d = D; - while(length >= 64) - { - computeRounds(&a, &b, &c, &d, msg); - msg += 64; - length -= 64; - } - uint8_t buffer[64]; - memcpy(buffer, msg, length); - buffer[length++] = 0x80; - padding--; - if(padding+length == 56) - memset(&buffer[length], 0, padding); - else - { - memset(&buffer[length], 0, 64-length); - computeRounds(&a, &b, &c, &d, msg); - memset(buffer, 0, 56); - } - - uint32_t lengthBitLow = lengthBit; - uint32_t lengthBitHigh = lengthBit >> 32; - memcpy(&buffer[56], &lengthBitLow, 4); - memcpy(&buffer[60], &lengthBitHigh, 4); - - computeRounds(&a, &b, &c, &d, buffer); - - memcpy(digest, &a, 4); - memcpy(&digest[4], &b, 4); - memcpy(&digest[8], &c, 4); - memcpy(&digest[12], &d, 4); -} \ No newline at end of file
--- a/MD5.h Thu Sep 12 15:08:51 2013 +0000 +++ b/MD5.h Thu Sep 12 16:03:43 2013 +0000 @@ -10,11 +10,11 @@ MD5(); - virtual void update(uint8_t *in, uint32_t length); - virtual void finalize(uint8_t *out); virtual uint8_t outputSize() const; + virtual void update(uint8_t *data, uint32_t length); + virtual void finalize(uint8_t *hash); - static void computeDigest(uint8_t *digest, uint8_t *in, uint32_t length); + static void computeHash(uint8_t *hash, uint8_t *data, uint32_t length); private :
--- a/SHA1.cpp Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA1.cpp Thu Sep 12 16:03:43 2013 +0000 @@ -59,34 +59,34 @@ return 20; } -void SHA1::update(uint8_t *in, uint32_t length) +void SHA1::update(uint8_t *data, uint32_t length) { if(length < 64-bufferLength) { - memcpy(&buffer[bufferLength], in, length); + memcpy(&buffer[bufferLength], data, length); bufferLength += length; totalBufferLength += length; return; } int offset = 64-bufferLength; - memcpy(&buffer[bufferLength], in, offset); + memcpy(&buffer[bufferLength], data, offset); computeBlock(&h0,&h1,&h2,&h3,&h4, buffer); while(length-offset > 64) { - memcpy(buffer, &in[offset], 64); + memcpy(buffer, &data[offset], 64); computeBlock(&h0,&h1,&h2,&h3,&h4, buffer); offset += 64; } if(offset > length) offset -= 64; bufferLength = length - offset; - memcpy(buffer, &in[offset], bufferLength); + memcpy(buffer, &data[offset], bufferLength); totalBufferLength += length; } -void SHA1::finalize(uint8_t *digest) +void SHA1::finalize(uint8_t *hash) { - uint32_t *digest2 = (uint32_t*)digest; + uint32_t *hash2 = (uint32_t*)hash; uint16_t padding; if(totalBufferLength % 64 < 56) padding = 56 - (totalBufferLength % 64); @@ -113,11 +113,11 @@ memcpy(&buffer[60], &lengthBitLow, 4); computeBlock(&h0,&h1,&h2,&h3,&h4, buffer); - digest2[0] = __rev(h0); - digest2[1] = __rev(h1); - digest2[2] = __rev(h2); - digest2[3] = __rev(h3); - digest2[4] = __rev(h4); + hash2[0] = __rev(h0); + hash2[1] = __rev(h1); + hash2[2] = __rev(h2); + hash2[3] = __rev(h3); + hash2[4] = __rev(h4); // reset state h0 = H0; @@ -129,6 +129,54 @@ bufferLength = 0; } + +void SHA1::computeHash(uint8_t *hash, uint8_t *data, uint32_t length) +{ + uint32_t *hash2 = (uint32_t*)hash; + uint64_t lengthBit = length << 3; + uint32_t padding; + if(length % 64 < 56) + padding = 56 - (length % 64); + else + padding = 56 + (64 - (length % 64)); + + uint32_t h0 = H0, h1 = H1, h2 = H2, h3 = H3, h4 = H4; + while(length >= 64) + { + computeBlock(&h0,&h1,&h2,&h3,&h4, data); + length -= 64; + data += 64; + } + + uint8_t buffer[64]; + memcpy(buffer, data, length); + buffer[length++] = 0x80; + padding--; + if(padding+length+8 == 64) + memset(&buffer[length], 0, padding); + else + { + memset(&buffer[length], 0, 64-length); + computeBlock(&h0,&h1,&h2,&h3,&h4, buffer); + memset(buffer, 0, 56); + } + + uint32_t lengthBitLow = lengthBit; + uint32_t lengthBitHigh = lengthBit >> 32; + lengthBitLow = __rev(lengthBitLow); + lengthBitHigh = __rev(lengthBitHigh); + memcpy(&buffer[60], &lengthBitLow, 4); + memcpy(&buffer[56], &lengthBitHigh, 4); + + computeBlock(&h0,&h1,&h2,&h3,&h4, buffer); + + hash2[0] = __rev(h0); + hash2[1] = __rev(h1); + hash2[2] = __rev(h2); + hash2[3] = __rev(h3); + hash2[4] = __rev(h4); +} + void SHA1::computeBlock(uint32_t *h02, uint32_t *h12, uint32_t *h22, uint32_t *h32, uint32_t *h42, uint8_t *buffer) { uint32_t *buffer2 = (uint32_t*)buffer; @@ -171,58 +219,3 @@ *h42 += e; } - - -/* method 1 */ -void SHA1::computeDigest(uint8_t *digest, uint8_t *in, uint32_t length) -{ - uint64_t lengthBit = length << 3; - uint32_t padding; - if(length % 64 < 56) - padding = 56 - (length % 64); - else - padding = 56 + (64 - (length % 64)); - - uint32_t h0 = H0, h1 = H1, h2 = H2, h3 = H3, h4 = H4; - while(length >= 64) - { - computeBlock(&h0,&h1,&h2,&h3,&h4, in); - length -= 64; - in += 64; - } - - uint8_t buffer[64]; - memcpy(buffer, in, length); - buffer[length++] = 0x80; - padding--; - if(padding+length+8 == 64) - memset(&buffer[length], 0, padding); - else - { - memset(&buffer[length], 0, 64-length); - computeBlock(&h0,&h1,&h2,&h3,&h4, buffer); - memset(buffer, 0, 56); - } - - uint32_t lengthBitLow = lengthBit; - uint32_t lengthBitHigh = lengthBit >> 32; - lengthBitLow = __rev(lengthBitLow); - lengthBitHigh = __rev(lengthBitHigh); - memcpy(&buffer[60], &lengthBitLow, 4); - memcpy(&buffer[56], &lengthBitHigh, 4); - - computeBlock(&h0,&h1,&h2,&h3,&h4, buffer); - - h0 = __rev(h0); - h1 = __rev(h1); - h2 = __rev(h2); - h3 = __rev(h3); - h4 = __rev(h4); - - memcpy(digest, &h0, 4); - memcpy(&digest[4], &h1, 4); - memcpy(&digest[8], &h2, 4); - memcpy(&digest[12], &h3, 4); - memcpy(&digest[16], &h4, 4); -} -
--- a/SHA1.h Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA1.h Thu Sep 12 16:03:43 2013 +0000 @@ -9,12 +9,12 @@ public : SHA1(); + + virtual uint8_t outputSize() const; + virtual void update(uint8_t *data, uint32_t length); + virtual void finalize(uint8_t *hash); - virtual void update(uint8_t *in, uint32_t length); - virtual void finalize(uint8_t *out); - virtual uint8_t outputSize() const; - - static void computeDigest(uint8_t *digest, uint8_t *in, uint32_t length); + static void computeHash(uint8_t *hash, uint8_t *data, uint32_t length); private : static void computeBlock(uint32_t *h02, uint32_t *h12, uint32_t *h22, uint32_t *h32, uint32_t *h42, uint8_t *buffer);
--- a/SHA224.cpp Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA224.cpp Thu Sep 12 16:03:43 2013 +0000 @@ -7,22 +7,22 @@ { } -void SHA224::update(uint8_t *in, uint32_t length) -{ - algo.update(in, length); -} - -void SHA224::finalize(uint8_t *out) -{ - algo.finalize(out); -} - uint8_t SHA224::outputSize() const { return 28; } -void SHA224::computeDigest(uint8_t *digest, uint8_t *in, uint32_t length) +void SHA224::update(uint8_t *data, uint32_t length) +{ + algo.update(data, length); +} + +void SHA224::finalize(uint8_t *hash) { - SHA2_32::computeDigest(SHA_224, digest, in, length); + algo.finalize(hash); } + +void SHA224::computeHash(uint8_t *hash, uint8_t *data, uint32_t length) +{ + SHA2_32::computeHash(SHA_224, hash, data, length); +}
--- a/SHA224.h Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA224.h Thu Sep 12 16:03:43 2013 +0000 @@ -9,11 +9,12 @@ public : SHA224(); - virtual void update(uint8_t *in, uint32_t length); - virtual void finalize(uint8_t *out); + virtual uint8_t outputSize() const; + virtual void update(uint8_t *data, uint32_t length); + virtual void finalize(uint8_t *hash); - static void computeDigest(uint8_t *digest, uint8_t *in, uint32_t length); + static void computeHash(uint8_t *hash, uint8_t *data, uint32_t length); private :
--- a/SHA256.cpp Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA256.cpp Thu Sep 12 16:03:43 2013 +0000 @@ -7,22 +7,22 @@ { } -void SHA256::update(uint8_t *in, uint32_t length) -{ - algo.update(in, length); -} - -void SHA256::finalize(uint8_t *out) -{ - algo.finalize(out); -} - uint8_t SHA256::outputSize() const { return 32; } -void SHA256::computeDigest(uint8_t *digest, uint8_t *in, uint32_t length) +void SHA256::update(uint8_t *data, uint32_t length) +{ + algo.update(data, length); +} + +void SHA256::finalize(uint8_t *hash) { - SHA2_32::computeDigest(SHA_256, digest, in, length); + algo.finalize(hash); } + +void SHA256::computeHash(uint8_t *hash, uint8_t *data, uint32_t length) +{ + SHA2_32::computeHash(SHA_256, hash, data, length); +}
--- a/SHA256.h Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA256.h Thu Sep 12 16:03:43 2013 +0000 @@ -10,11 +10,12 @@ public : SHA256(); - virtual void update(uint8_t *in, uint32_t length); - virtual void finalize(uint8_t *out); + virtual uint8_t outputSize() const; + virtual void update(uint8_t *data, uint32_t length); + virtual void finalize(uint8_t *hash); - static void computeDigest(uint8_t *digest, uint8_t *in, uint32_t length); + static void computeHash(uint8_t *hash, uint8_t *data, uint32_t length); private :
--- a/SHA2_32.cpp Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA2_32.cpp Thu Sep 12 16:03:43 2013 +0000 @@ -66,33 +66,34 @@ } } -void SHA2_32::update(uint8_t *in, uint32_t length) +void SHA2_32::update(uint8_t *data, uint32_t length) { if(length < 64-bufferLength) { - memcpy(&buffer[bufferLength], in, length); + memcpy(&buffer[bufferLength], data, length); bufferLength += length; totalBufferLength += length; return; } int offset = 64-bufferLength; - memcpy(&buffer[bufferLength], in, offset); + memcpy(&buffer[bufferLength], data, offset); computeBlock(&h0,&h1,&h2,&h3,&h4,&h5,&h6,&h7,buffer); while(length-offset > 64) { - memcpy(buffer, &in[offset], 64); + memcpy(buffer, &data[offset], 64); computeBlock(&h0,&h1,&h2,&h3,&h4,&h5,&h6,&h7,buffer); offset += 64; } if(offset > length) offset -= 64; bufferLength = length - offset; - memcpy(buffer, &in[offset], bufferLength); + memcpy(buffer, &data[offset], bufferLength); totalBufferLength += length; } -void SHA2_32::finalize(uint8_t *digest) +void SHA2_32::finalize(uint8_t *hash) { + uint32_t *hash2 = (uint32_t*)hash; uint16_t padding; if(totalBufferLength % 64 < 56) padding = 56 - (totalBufferLength % 64); @@ -119,26 +120,17 @@ memcpy(&buffer[56], &lengthBitHigh, 4); computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); - h0 = __rev(h0); - h1 = __rev(h1); - h2 = __rev(h2); - h3 = __rev(h3); - h4 = __rev(h4); - h5 = __rev(h5); - h6 = __rev(h6); - memcpy(digest, &h0, 4); - memcpy(&digest[4], &h1, 4); - memcpy(&digest[8], &h2, 4); - memcpy(&digest[12], &h3, 4); - memcpy(&digest[16], &h4, 4); - memcpy(&digest[20], &h5, 4); - memcpy(&digest[24], &h6, 4); + hash2[0] = __rev(h0); + hash2[1] = __rev(h1); + hash2[2] = __rev(h2); + hash2[3] = __rev(h3); + hash2[4] = __rev(h4); + hash2[5] = __rev(h5); + hash2[6] = __rev(h6); + if(type == SHA_256) - { - h7 = __rev(h7); - memcpy(&digest[28], &h7, 4); - } + hash2[7] = __rev(h7); // reset state switch(type) @@ -169,6 +161,58 @@ bufferLength = 0; } +void SHA2_32::computeHash(SHA_32_TYPE type, uint8_t *hash, uint8_t *data, uint32_t length) +{ + uint32_t *hash2 = (uint32_t*)hash; + uint32_t h0 = H[type*8], h1 = H[type*8+1], h2 = H[type*8+2], h3 = H[type*8+3]; + uint32_t h4 = H[type*8+4], h5 = H[type*8+5], h6 = H[type*8+6], h7 = H[type*8+7]; + uint64_t lengthBit = length << 3; + uint16_t padding; + if(length % 64 < 56) + padding = 56 - (length % 64); + else + padding = 56 + (64 - (length % 64)); + + while(length >= 64) + { + computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, data); + length -= 64; + data += 64; + } + uint8_t buffer[64]; + memcpy(buffer, data,length); + buffer[length++] = 0x80; + padding--; + if(padding+length == 56) + memset(&buffer[length], 0, padding); + else + { + memset(&buffer[length], 0, 64-length); + computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); + memset(buffer, 0, 56); + } + + uint32_t lengthBitLow = lengthBit; + uint32_t lengthBitHigh = lengthBit >> 32; + lengthBitLow = __rev(lengthBitLow); + memcpy(&buffer[60], &lengthBitLow, 4); + lengthBitHigh = __rev(lengthBitHigh); + memcpy(&buffer[56], &lengthBitHigh, 4); + computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); + + hash2[0] = __rev(h0); + hash2[1] = __rev(h1); + hash2[2] = __rev(h2); + hash2[3] = __rev(h3); + hash2[4] = __rev(h4); + hash2[5] = __rev(h5); + hash2[6] = __rev(h6); + + + if(type == SHA_256) + hash2[7] = __rev(h7); +} + void SHA2_32::computeBlock(uint32_t *h02, uint32_t *h12, uint32_t *h22, @@ -268,64 +312,3 @@ *h72 += h; } -void SHA2_32::computeDigest(SHA_32_TYPE type, uint8_t *digest, uint8_t *in, uint32_t length) -{ - uint32_t h0 = H[type*8], h1 = H[type*8+1], h2 = H[type*8+2], h3 = H[type*8+3]; - uint32_t h4 = H[type*8+4], h5 = H[type*8+5], h6 = H[type*8+6], h7 = H[type*8+7]; - uint64_t lengthBit = length << 3; - uint16_t padding; - if(length % 64 < 56) - padding = 56 - (length % 64); - else - padding = 56 + (64 - (length % 64)); - - while(length >= 64) - { - computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, in); - length -= 64; - in += 64; - } - uint8_t buffer[64]; - memcpy(buffer, in,length); - buffer[length++] = 0x80; - padding--; - if(padding+length == 56) - memset(&buffer[length], 0, padding); - else - { - memset(&buffer[length], 0, 64-length); - computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); - memset(buffer, 0, 56); - } - - uint32_t lengthBitLow = lengthBit; - uint32_t lengthBitHigh = lengthBit >> 32; - lengthBitLow = __rev(lengthBitLow); - memcpy(&buffer[60], &lengthBitLow, 4); - lengthBitHigh = __rev(lengthBitHigh); - memcpy(&buffer[56], &lengthBitHigh, 4); - computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); - - h0 = __rev(h0); - h1 = __rev(h1); - h2 = __rev(h2); - h3 = __rev(h3); - h4 = __rev(h4); - h5 = __rev(h5); - h6 = __rev(h6); - - memcpy(digest, &h0, 4); - memcpy(&digest[4], &h1, 4); - memcpy(&digest[8], &h2, 4); - memcpy(&digest[12], &h3, 4); - memcpy(&digest[16], &h4, 4); - memcpy(&digest[20], &h5, 4); - memcpy(&digest[24], &h6, 4); - - - if(type == SHA_256) - { - h7 = __rev(h7); - memcpy(&digest[28], &h7, 4); - } -}
--- a/SHA2_32.h Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA2_32.h Thu Sep 12 16:03:43 2013 +0000 @@ -14,9 +14,10 @@ public : SHA2_32(SHA_32_TYPE type); - void update(uint8_t *in, uint32_t length); + void update(uint8_t *data, uint32_t length); void finalize(uint8_t *digest); - static void computeDigest(SHA_32_TYPE type, uint8_t *digest, uint8_t *in, uint32_t length); + + static void computeHash(SHA_32_TYPE type, uint8_t *digest, uint8_t *data, uint32_t length); private :
--- a/SHA2_64.cpp Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA2_64.cpp Thu Sep 12 16:03:43 2013 +0000 @@ -65,33 +65,34 @@ } } -void SHA2_64::update(uint8_t *in, uint32_t length) +void SHA2_64::update(uint8_t *data, uint32_t length) { if(length < 128-bufferLength) { - memcpy(&buffer[bufferLength], in, length); + memcpy(&buffer[bufferLength], data, length); bufferLength += length; totalBufferLength += length; return; } int offset = 128-bufferLength; - memcpy(&buffer[bufferLength], in, offset); + memcpy(&buffer[bufferLength], data, offset); computeBlock(&h0,&h1,&h2,&h3,&h4,&h5,&h6,&h7,buffer); while(length-offset > 128) { - memcpy(buffer, &in[offset], 128); + memcpy(buffer, &data[offset], 128); computeBlock(&h0,&h1,&h2,&h3,&h4,&h5,&h6,&h7,buffer); offset += 128; } if(offset > length) offset -= 128; bufferLength = length - offset; - memcpy(buffer, &in[offset], bufferLength); + memcpy(buffer, &data[offset], bufferLength); totalBufferLength += length; } -void SHA2_64::finalize(uint8_t *digest) +void SHA2_64::finalize(uint8_t *hash) { + uint64_t *hash2 = (uint64_t*)hash; uint64_t lengthBit = totalBufferLength << 3; uint32_t padding; if(totalBufferLength % 128 < 112) @@ -116,27 +117,18 @@ computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); - h0 = revWord(h0); - h1 = revWord(h1); - h2 = revWord(h2); - h3 = revWord(h3); - h4 = revWord(h4); - h5 = revWord(h5); + hash2[0] = revWord(h0); + hash2[1] = revWord(h1); + hash2[2] = revWord(h2); + hash2[3] = revWord(h3); + hash2[4] = revWord(h4); + hash2[5] = revWord(h5); - - memcpy(digest, &h0, 8); - memcpy(&digest[8], &h1, 8); - memcpy(&digest[16], &h2, 8); - memcpy(&digest[24], &h3, 8); - memcpy(&digest[32], &h4, 8); - memcpy(&digest[40], &h5, 8); if(type == SHA_512) { - h6 = revWord(h6); - h7 = revWord(h7); - memcpy(&digest[48], &h6, 8); - memcpy(&digest[56], &h7, 8); + hash2[6] = revWord(h6); + hash2[7] = revWord(h7); } // reset state @@ -168,6 +160,60 @@ bufferLength = 0; } +void SHA2_64::computeHash(SHA2_64_TYPE type, uint8_t *hash, uint8_t *data, uint32_t length) +{ + uint64_t *hash2 = (uint64_t*)hash; + uint64_t lengthBit = length * 8; + uint64_t h0 = H[type*8], h1 = H[type*8+1], h2 = H[type*8+2], h3 = H[type*8+3]; + uint64_t h4 = H[type*8+4], h5 = H[type*8+5], h6 = H[type*8+6], h7 = H[type*8+7]; + + int padding; + if(length % 128 < 112) + padding = 112 - (length % 128); + else + padding = 112 + (128 - (length % 128)); + + while(length >= 128) + { + computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, data); + data += 128; + length -= 128; + } + uint8_t buffer[128]; + memcpy(buffer, data,length); + buffer[length] = 0x80; + length++; + padding--; + + if(padding+length == 112) + memset(&buffer[length], 0, padding); + else + { + memset(&buffer[length], 0, 128-length); + computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); + memset(buffer, 0, 112); + } + + lengthBit = revWord(lengthBit); + memset(&buffer[112], 0, 8); + memcpy(&buffer[120], &lengthBit, 8); + computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); + + hash2[0] = revWord(h0); + hash2[1] = revWord(h1); + hash2[2] = revWord(h2); + hash2[3] = revWord(h3); + hash2[4] = revWord(h4); + hash2[5] = revWord(h5); + + + if(type == SHA_512) + { + hash2[6] = revWord(h6); + hash2[7] = revWord(h7); + } +} + void SHA2_64::computeBlock(uint64_t *h02, uint64_t *h12, uint64_t *h22, @@ -306,66 +352,3 @@ *h62 += g; *h72 += h; } - -void SHA2_64::computeDigest(SHA2_64_TYPE type, uint8_t *digest, uint8_t *in, uint32_t length) -{ - uint64_t lengthBit = length * 8; - uint64_t h0 = H[type*8], h1 = H[type*8+1], h2 = H[type*8+2], h3 = H[type*8+3]; - uint64_t h4 = H[type*8+4], h5 = H[type*8+5], h6 = H[type*8+6], h7 = H[type*8+7]; - - int padding; - if(length % 128 < 112) - padding = 112 - (length % 128); - else - padding = 112 + (128 - (length % 128)); - - while(length >= 128) - { - computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, in); - in += 128; - length -= 128; - } - uint8_t buffer[128]; - memcpy(buffer, in,length); - buffer[length] = 0x80; - length++; - padding--; - - if(padding+length == 112) - memset(&buffer[length], 0, padding); - else - { - memset(&buffer[length], 0, 128-length); - computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); - memset(buffer, 0, 112); - } - - lengthBit = revWord(lengthBit); - memset(&buffer[112], 0, 8); - memcpy(&buffer[120], &lengthBit, 8); - computeBlock(&h0, &h1, &h2, &h3, &h4, &h5, &h6, &h7, buffer); - - h0 = revWord(h0); - h1 = revWord(h1); - h2 = revWord(h2); - h3 = revWord(h3); - h4 = revWord(h4); - h5 = revWord(h5); - - - memcpy(digest, &h0, 8); - memcpy(&digest[8], &h1, 8); - memcpy(&digest[16], &h2, 8); - memcpy(&digest[24], &h3, 8); - memcpy(&digest[32], &h4, 8); - memcpy(&digest[40], &h5, 8); - - if(type == SHA_512) - { - h6 = revWord(h6); - h7 = revWord(h7); - memcpy(&digest[48], &h6, 8); - memcpy(&digest[56], &h7, 8); - } -} -
--- a/SHA2_64.h Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA2_64.h Thu Sep 12 16:03:43 2013 +0000 @@ -14,9 +14,11 @@ public : SHA2_64(SHA2_64_TYPE type); - void update(uint8_t *in, uint32_t length); - void finalize(uint8_t *digest); - static void computeDigest(SHA2_64_TYPE type, uint8_t *digest, uint8_t *in, uint32_t length); + + void update(uint8_t *data, uint32_t length); + void finalize(uint8_t *hash); + + static void computeHash(SHA2_64_TYPE type, uint8_t *hash, uint8_t *data, uint32_t length); private :
--- a/SHA384.cpp Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA384.cpp Thu Sep 12 16:03:43 2013 +0000 @@ -7,22 +7,22 @@ { } -void SHA384::update(uint8_t *in, uint32_t length) -{ - algo.update(in, length); -} - -void SHA384::finalize(uint8_t *out) -{ - algo.finalize(out); -} - uint8_t SHA384::outputSize() const { return 48; } -void SHA384::computeDigest(uint8_t *digest, uint8_t *in, uint32_t length) +void SHA384::update(uint8_t *data, uint32_t length) +{ + algo.update(data, length); +} + +void SHA384::finalize(uint8_t *hash) { - SHA2_64::computeDigest(SHA_384, digest, in, length); + algo.finalize(hash); } + +void SHA384::computeHash(uint8_t *hash, uint8_t *data, uint32_t length) +{ + SHA2_64::computeHash(SHA_384, hash, data, length); +}
--- a/SHA384.h Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA384.h Thu Sep 12 16:03:43 2013 +0000 @@ -10,11 +10,12 @@ public : SHA384(); - virtual void update(uint8_t *in, uint32_t length); - virtual void finalize(uint8_t *out); + virtual uint8_t outputSize() const; + virtual void update(uint8_t *data, uint32_t length); + virtual void finalize(uint8_t *hash); - static void computeDigest(uint8_t *digest, uint8_t *in, uint32_t length); + static void computeHash(uint8_t *hash, uint8_t *data, uint32_t length); private :
--- a/SHA512.cpp Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA512.cpp Thu Sep 12 16:03:43 2013 +0000 @@ -7,22 +7,22 @@ { } -void SHA512::update(uint8_t *in, uint32_t length) -{ - algo.update(in, length); -} - -void SHA512::finalize(uint8_t *out) -{ - algo.finalize(out); -} - uint8_t SHA512::outputSize() const { return 64; } -void SHA512::computeDigest(uint8_t *digest, uint8_t *in, uint32_t length) +void SHA512::update(uint8_t *data, uint32_t length) +{ + algo.update(data, length); +} + +void SHA512::finalize(uint8_t *hash) { - SHA2_64::computeDigest(SHA_512, digest, in, length); + algo.finalize(hash); } + +void SHA512::computeHash(uint8_t *hash, uint8_t *data, uint32_t length) +{ + SHA2_64::computeHash(SHA_512, hash, data, length); +}
--- a/SHA512.h Thu Sep 12 15:08:51 2013 +0000 +++ b/SHA512.h Thu Sep 12 16:03:43 2013 +0000 @@ -10,11 +10,12 @@ public : SHA512(); - virtual void update(uint8_t *in, uint32_t length); - virtual void finalize(uint8_t *out); + virtual uint8_t outputSize() const; + virtual void update(uint8_t *data, uint32_t length); + virtual void finalize(uint8_t *hash); - static void computeDigest(uint8_t *digest, uint8_t *in, uint32_t length); + static void computeHash(uint8_t *hash, uint8_t *data, uint32_t length); private :