[IOT-977] Resolved |tinydtls-sha| symbol-conflict for deploying iotivity-stack

this change is for resolving |tinydtls-sha| symbol-conflict in using
|iotivity-tinydtls| with other crypto modules. this symbol-conflict
could occur on the |iotivity-tinydtls| deployed systems with using
|OpenSSL| or |OpenSSL|-like, which has another |SHA| symbols.
this issue has been tracked by eclipse-tinydtls maintainers and
could be changed as the maintainers' direction.

[patch #1] initial commit
[patch #2] updated commit message
[patch #3] fixed the API calling codes on |pkix_crypto|

Jira: https://jira.iotivity.org/browse/IOT-977
Eclipse-bugs: https://bugs.eclipse.org/bugs/show_bug.cgi?id=490467
Eclipse-git: https://git.eclipse.org/r/#/c/69697/

Change-Id: I5ec3b5d20c536ba4871272c6b0b1e3a2a2371ff6
Signed-off-by: Kyungsun Cho <goodsun.cho@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/7633
Reviewed-by: Dmitriy Zhuravlev <d.zhuravlev@samsung.com>
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Randeep Singh <randeep.s@samsung.com>

diff --git a/extlibs/tinydtls/hmac.h b/extlibs/tinydtls/hmac.h
index d9c5e53..afdfaea 100644 (file)
--- a/extlibs/tinydtls/hmac.h
+++ b/extlibs/tinydtls/hmac.h
@@ -35,24 +35,24 @@
  *  see http://www.aarongifford.com/ */
 #include "sha2/sha2.h"
 
-typedef SHA256_CTX dtls_hash_ctx;
+typedef DTLS_SHA256_CTX dtls_hash_ctx;
 typedef dtls_hash_ctx *dtls_hash_t;
-#define DTLS_HASH_CTX_SIZE sizeof(SHA256_CTX)
+#define DTLS_HASH_CTX_SIZE sizeof(DTLS_SHA256_CTX)
 
 static inline void
 dtls_hash_init(dtls_hash_t ctx) {
-  SHA256_Init((SHA256_CTX *)ctx);
+  DTLS_SHA256_Init((DTLS_SHA256_CTX *)ctx);
 }
 
 static inline void 
 dtls_hash_update(dtls_hash_t ctx, const unsigned char *input, size_t len) {
-  SHA256_Update((SHA256_CTX *)ctx, input, len);
+  DTLS_SHA256_Update((DTLS_SHA256_CTX *)ctx, input, len);
 }
 
 static inline size_t
 dtls_hash_finalize(unsigned char *buf, dtls_hash_t ctx) {
-  SHA256_Final(buf, (SHA256_CTX *)ctx);
-  return SHA256_DIGEST_LENGTH;
+  DTLS_SHA256_Final(buf, (DTLS_SHA256_CTX *)ctx);
+  return DTLS_SHA256_DIGEST_LENGTH;
 }
 #endif /* WITH_SHA256 */
 

diff --git a/extlibs/tinydtls/sha2/sha2.c b/extlibs/tinydtls/sha2/sha2.c
index 2578f17..4d729e7 100644 (file)
--- a/extlibs/tinydtls/sha2/sha2.c
+++ b/extlibs/tinydtls/sha2/sha2.c
@@ -146,9 +146,9 @@ typedef u_int64_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)
+#define DTLS_SHA256_SHORT_BLOCK_LENGTH (DTLS_SHA256_BLOCK_LENGTH - 8)
+#define DTLS_SHA384_SHORT_BLOCK_LENGTH (DTLS_SHA384_BLOCK_LENGTH - 16)
+#define DTLS_SHA512_SHORT_BLOCK_LENGTH (DTLS_SHA512_BLOCK_LENGTH - 16)
 
 
 /*** ENDIAN REVERSAL MACROS *******************************************/
@@ -245,9 +245,9 @@ typedef u_int64_t sha2_word64;      /* Exactly 8 bytes */
  * library -- they are intended for private internal visibility/use
  * only.
  */
-void SHA512_Last(SHA512_CTX*);
-void SHA256_Transform(SHA256_CTX*, const sha2_word32*);
-void SHA512_Transform(SHA512_CTX*, const sha2_word64*);
+void DTLS_SHA512_Last(DTLS_SHA512_CTX*);
+void DTLS_SHA256_Transform(DTLS_SHA256_CTX*, const sha2_word32*);
+void DTLS_SHA512_Transform(DTLS_SHA512_CTX*, const sha2_word64*);
 
 #ifdef WITH_SHA256
 /*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
@@ -367,12 +367,12 @@ static const char *sha2_hex_digits = "0123456789abcdef";
 
 /*** SHA-256: *********************************************************/
 #ifdef WITH_SHA256
-void SHA256_Init(SHA256_CTX* context) {
-       if (context == (SHA256_CTX*)0) {
+void DTLS_SHA256_Init(DTLS_SHA256_CTX* context) {
+       if (context == (DTLS_SHA256_CTX*)0) {
                return;
        }
-       MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
-       MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH);
+       MEMCPY_BCOPY(context->state, sha256_initial_hash_value, DTLS_SHA256_DIGEST_LENGTH);
+       MEMSET_BZERO(context->buffer, DTLS_SHA256_BLOCK_LENGTH);
        context->bitcount = 0;
 }
 
@@ -413,7 +413,7 @@ void SHA256_Init(SHA256_CTX* context) {
        (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
        j++
 
-void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
+void DTLS_SHA256_Transform(DTLS_SHA256_CTX* context, const sha2_word32* data) {
        sha2_word32     a, b, c, d, e, f, g, h, s0, s1;
        sha2_word32     T1, *W256;
        int             j;
@@ -471,7 +471,7 @@ void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
 
 #else /* SHA2_UNROLL_TRANSFORM */
 
-void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
+void DTLS_SHA256_Transform(DTLS_SHA256_CTX* context, const sha2_word32* data) {
        sha2_word32     a, b, c, d, e, f, g, h, s0, s1;
        sha2_word32     T1, T2, *W256;
        int             j;
@@ -551,7 +551,7 @@ void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
 
 #endif /* SHA2_UNROLL_TRANSFORM */
 
-void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
+void DTLS_SHA256_Update(DTLS_SHA256_CTX* context, const sha2_byte *data, size_t len) {
        unsigned int    freespace, usedspace;
 
        if (len == 0) {
@@ -560,12 +560,12 @@ void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
        }
 
        /* Sanity check: */
-       assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0);
+       assert(context != (DTLS_SHA256_CTX*)0 && data != (sha2_byte*)0);
 
-       usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
+       usedspace = (context->bitcount >> 3) % DTLS_SHA256_BLOCK_LENGTH;
        if (usedspace > 0) {
                /* Calculate how much free space is available in the buffer */
-               freespace = SHA256_BLOCK_LENGTH - usedspace;
+               freespace = DTLS_SHA256_BLOCK_LENGTH - usedspace;
 
                if (len >= freespace) {
                        /* Fill the buffer completely and process it */
@@ -573,7 +573,7 @@ void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
                        context->bitcount += freespace << 3;
                        len -= freespace;
                        data += freespace;
-                       SHA256_Transform(context, (sha2_word32*)context->buffer);
+                       DTLS_SHA256_Transform(context, (sha2_word32*)context->buffer);
                } else {
                        /* The buffer is not yet full */
                        MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
@@ -583,12 +583,12 @@ void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
                        return;
                }
        }
-       while (len >= SHA256_BLOCK_LENGTH) {
+       while (len >= DTLS_SHA256_BLOCK_LENGTH) {
                /* Process as many complete blocks as we can */
-               SHA256_Transform(context, (sha2_word32*)data);
-               context->bitcount += SHA256_BLOCK_LENGTH << 3;
-               len -= SHA256_BLOCK_LENGTH;
-               data += SHA256_BLOCK_LENGTH;
+               DTLS_SHA256_Transform(context, (sha2_word32*)data);
+               context->bitcount += DTLS_SHA256_BLOCK_LENGTH << 3;
+               len -= DTLS_SHA256_BLOCK_LENGTH;
+               data += DTLS_SHA256_BLOCK_LENGTH;
        }
        if (len > 0) {
                /* There's left-overs, so save 'em */
@@ -599,16 +599,16 @@ void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
        usedspace = freespace = 0;
 }
 
-void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
+void DTLS_SHA256_Final(sha2_byte digest[], DTLS_SHA256_CTX* context) {
        sha2_word32     *d = (sha2_word32*)digest;
        unsigned int    usedspace;
 
        /* Sanity check: */
-       assert(context != (SHA256_CTX*)0);
+       assert(context != (DTLS_SHA256_CTX*)0);
 
        /* If no digest buffer is passed, we don't bother doing this: */
        if (digest != (sha2_byte*)0) {
-               usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
+               usedspace = (context->bitcount >> 3) % DTLS_SHA256_BLOCK_LENGTH;
 #if BYTE_ORDER == LITTLE_ENDIAN
                /* Convert FROM host byte order */
                REVERSE64(context->bitcount,context->bitcount);
@@ -617,31 +617,31 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
                        /* Begin padding with a 1 bit: */
                        context->buffer[usedspace++] = 0x80;
 
-                       if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {
+                       if (usedspace <= DTLS_SHA256_SHORT_BLOCK_LENGTH) {
                                /* Set-up for the last transform: */
-                               MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace);
+                               MEMSET_BZERO(&context->buffer[usedspace], DTLS_SHA256_SHORT_BLOCK_LENGTH - usedspace);
                        } else {
-                               if (usedspace < SHA256_BLOCK_LENGTH) {
-                                       MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace);
+                               if (usedspace < DTLS_SHA256_BLOCK_LENGTH) {
+                                       MEMSET_BZERO(&context->buffer[usedspace], DTLS_SHA256_BLOCK_LENGTH - usedspace);
                                }
                                /* Do second-to-last transform: */
-                               SHA256_Transform(context, (sha2_word32*)context->buffer);
+                               DTLS_SHA256_Transform(context, (sha2_word32*)context->buffer);
 
                                /* And set-up for the last transform: */
-                               MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
+                               MEMSET_BZERO(context->buffer, DTLS_SHA256_SHORT_BLOCK_LENGTH);
                        }
                } else {
                        /* Set-up for the last transform: */
-                       MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
+                       MEMSET_BZERO(context->buffer, DTLS_SHA256_SHORT_BLOCK_LENGTH);
 
                        /* Begin padding with a 1 bit: */
                        *context->buffer = 0x80;
                }
                /* Set the bit count: */
-               *(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
+               *(sha2_word64*)&context->buffer[DTLS_SHA256_SHORT_BLOCK_LENGTH] = context->bitcount;
 
                /* Final transform: */
-               SHA256_Transform(context, (sha2_word32*)context->buffer);
+               DTLS_SHA256_Transform(context, (sha2_word32*)context->buffer);
 
 #if BYTE_ORDER == LITTLE_ENDIAN
                {
@@ -653,7 +653,7 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
                        }
                }
 #else
-               MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LENGTH);
+               MEMCPY_BCOPY(d, context->state, DTLS_SHA256_DIGEST_LENGTH);
 #endif
        }
 
@@ -662,17 +662,17 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
        usedspace = 0;
 }
 
-char *SHA256_End(SHA256_CTX* context, char buffer[]) {
-       sha2_byte       digest[SHA256_DIGEST_LENGTH], *d = digest;
+char *DTLS_SHA256_End(DTLS_SHA256_CTX* context, char buffer[]) {
+       sha2_byte       digest[DTLS_SHA256_DIGEST_LENGTH], *d = digest;
        int             i;
 
        /* Sanity check: */
-       assert(context != (SHA256_CTX*)0);
+       assert(context != (DTLS_SHA256_CTX*)0);
 
        if (buffer != (char*)0) {
-               SHA256_Final(digest, context);
+               DTLS_SHA256_Final(digest, context);
 
-               for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+               for (i = 0; i < DTLS_SHA256_DIGEST_LENGTH; i++) {
                        *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
                        *buffer++ = sha2_hex_digits[*d & 0x0f];
                        d++;
@@ -681,27 +681,27 @@ char *SHA256_End(SHA256_CTX* context, char buffer[]) {
        } else {
                MEMSET_BZERO(context, sizeof(*context));
        }
-       MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH);
+       MEMSET_BZERO(digest, DTLS_SHA256_DIGEST_LENGTH);
        return buffer;
 }
 
-char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
-       SHA256_CTX      context;
+char* DTLS_SHA256_Data(const sha2_byte* data, size_t len, char digest[DTLS_SHA256_DIGEST_STRING_LENGTH]) {
+       DTLS_SHA256_CTX context;
 
-       SHA256_Init(&context);
-       SHA256_Update(&context, data, len);
-       return SHA256_End(&context, digest);
+       DTLS_SHA256_Init(&context);
+       DTLS_SHA256_Update(&context, data, len);
+       return DTLS_SHA256_End(&context, digest);
 }
 #endif
 
 /*** SHA-512: *********************************************************/
 #ifdef WITH_SHA512
-void SHA512_Init(SHA512_CTX* context) {
-       if (context == (SHA512_CTX*)0) {
+void DTLS_SHA512_Init(DTLS_SHA512_CTX* context) {
+       if (context == (DTLS_SHA512_CTX*)0) {
                return;
        }
-       MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
-       MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH);
+       MEMCPY_BCOPY(context->state, sha512_initial_hash_value, DTLS_SHA512_DIGEST_LENGTH);
+       MEMSET_BZERO(context->buffer, DTLS_SHA512_BLOCK_LENGTH);
        context->bitcount[0] = context->bitcount[1] =  0;
 }
 
@@ -741,7 +741,7 @@ void SHA512_Init(SHA512_CTX* context) {
        (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
        j++
 
-void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
+void DTLS_SHA512_Transform(DTLS_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;
@@ -796,7 +796,7 @@ void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
 
 #else /* SHA2_UNROLL_TRANSFORM */
 
-void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
+void DTLS_SHA512_Transform(DTLS_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;
@@ -874,7 +874,7 @@ void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
 
 #endif /* SHA2_UNROLL_TRANSFORM */
 
-void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
+void DTLS_SHA512_Update(DTLS_SHA512_CTX* context, const sha2_byte *data, size_t len) {
        unsigned int    freespace, usedspace;
 
        if (len == 0) {
@@ -883,12 +883,12 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
        }
 
        /* Sanity check: */
-       assert(context != (SHA512_CTX*)0 && data != (sha2_byte*)0);
+       assert(context != (DTLS_SHA512_CTX*)0 && data != (sha2_byte*)0);
 
-       usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
+       usedspace = (context->bitcount[0] >> 3) % DTLS_SHA512_BLOCK_LENGTH;
        if (usedspace > 0) {
                /* Calculate how much free space is available in the buffer */
-               freespace = SHA512_BLOCK_LENGTH - usedspace;
+               freespace = DTLS_SHA512_BLOCK_LENGTH - usedspace;
 
                if (len >= freespace) {
                        /* Fill the buffer completely and process it */
@@ -896,7 +896,7 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
                        ADDINC128(context->bitcount, freespace << 3);
                        len -= freespace;
                        data += freespace;
-                       SHA512_Transform(context, (sha2_word64*)context->buffer);
+                       DTLS_SHA512_Transform(context, (sha2_word64*)context->buffer);
                } else {
                        /* The buffer is not yet full */
                        MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
@@ -906,12 +906,12 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
                        return;
                }
        }
-       while (len >= SHA512_BLOCK_LENGTH) {
+       while (len >= DTLS_SHA512_BLOCK_LENGTH) {
                /* Process as many complete blocks as we can */
-               SHA512_Transform(context, (sha2_word64*)data);
-               ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
-               len -= SHA512_BLOCK_LENGTH;
-               data += SHA512_BLOCK_LENGTH;
+               DTLS_SHA512_Transform(context, (sha2_word64*)data);
+               ADDINC128(context->bitcount, DTLS_SHA512_BLOCK_LENGTH << 3);
+               len -= DTLS_SHA512_BLOCK_LENGTH;
+               data += DTLS_SHA512_BLOCK_LENGTH;
        }
        if (len > 0) {
                /* There's left-overs, so save 'em */
@@ -922,10 +922,10 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
        usedspace = freespace = 0;
 }
 
-void SHA512_Last(SHA512_CTX* context) {
+void DTLS_SHA512_Last(DTLS_SHA512_CTX* context) {
        unsigned int    usedspace;
 
-       usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
+       usedspace = (context->bitcount[0] >> 3) % DTLS_SHA512_BLOCK_LENGTH;
 #if BYTE_ORDER == LITTLE_ENDIAN
        /* Convert FROM host byte order */
        REVERSE64(context->bitcount[0],context->bitcount[0]);
@@ -935,43 +935,43 @@ void SHA512_Last(SHA512_CTX* context) {
                /* Begin padding with a 1 bit: */
                context->buffer[usedspace++] = 0x80;
 
-               if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) {
+               if (usedspace <= DTLS_SHA512_SHORT_BLOCK_LENGTH) {
                        /* Set-up for the last transform: */
-                       MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace);
+                       MEMSET_BZERO(&context->buffer[usedspace], DTLS_SHA512_SHORT_BLOCK_LENGTH - usedspace);
                } else {
-                       if (usedspace < SHA512_BLOCK_LENGTH) {
-                               MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace);
+                       if (usedspace < DTLS_SHA512_BLOCK_LENGTH) {
+                               MEMSET_BZERO(&context->buffer[usedspace], DTLS_SHA512_BLOCK_LENGTH - usedspace);
                        }
                        /* Do second-to-last transform: */
-                       SHA512_Transform(context, (sha2_word64*)context->buffer);
+                       DTLS_SHA512_Transform(context, (sha2_word64*)context->buffer);
 
                        /* And set-up for the last transform: */
-                       MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH - 2);
+                       MEMSET_BZERO(context->buffer, DTLS_SHA512_BLOCK_LENGTH - 2);
                }
        } else {
                /* Prepare for final transform: */
-               MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LENGTH);
+               MEMSET_BZERO(context->buffer, DTLS_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];
+       *(sha2_word64*)&context->buffer[DTLS_SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1];
+       *(sha2_word64*)&context->buffer[DTLS_SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0];
 
        /* Final transform: */
-       SHA512_Transform(context, (sha2_word64*)context->buffer);
+       DTLS_SHA512_Transform(context, (sha2_word64*)context->buffer);
 }
 
-void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
+void DTLS_SHA512_Final(sha2_byte digest[], DTLS_SHA512_CTX* context) {
        sha2_word64     *d = (sha2_word64*)digest;
 
        /* Sanity check: */
-       assert(context != (SHA512_CTX*)0);
+       assert(context != (DTLS_SHA512_CTX*)0);
 
        /* If no digest buffer is passed, we don't bother doing this: */
        if (digest != (sha2_byte*)0) {
-               SHA512_Last(context);
+               DTLS_SHA512_Last(context);
 
                /* Save the hash data for output: */
 #if BYTE_ORDER == LITTLE_ENDIAN
@@ -984,7 +984,7 @@ void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
                        }
                }
 #else
-               MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LENGTH);
+               MEMCPY_BCOPY(d, context->state, DTLS_SHA512_DIGEST_LENGTH);
 #endif
        }
 
@@ -992,17 +992,17 @@ void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
        MEMSET_BZERO(context, sizeof(context));
 }
 
-char *SHA512_End(SHA512_CTX* context, char buffer[]) {
-       sha2_byte       digest[SHA512_DIGEST_LENGTH], *d = digest;
+char *DTLS_SHA512_End(DTLS_SHA512_CTX* context, char buffer[]) {
+       sha2_byte       digest[DTLS_SHA512_DIGEST_LENGTH], *d = digest;
        int             i;
 
        /* Sanity check: */
-       assert(context != (SHA512_CTX*)0);
+       assert(context != (DTLS_SHA512_CTX*)0);
 
        if (buffer != (char*)0) {
-               SHA512_Final(digest, context);
+               DTLS_SHA512_Final(digest, context);
 
-               for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
+               for (i = 0; i < DTLS_SHA512_DIGEST_LENGTH; i++) {
                        *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
                        *buffer++ = sha2_hex_digits[*d & 0x0f];
                        d++;
@@ -1011,43 +1011,43 @@ char *SHA512_End(SHA512_CTX* context, char buffer[]) {
        } else {
                MEMSET_BZERO(context, sizeof(context));
        }
-       MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH);
+       MEMSET_BZERO(digest, DTLS_SHA512_DIGEST_LENGTH);
        return buffer;
 }
 
-char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
-       SHA512_CTX      context;
+char* DTLS_SHA512_Data(const sha2_byte* data, size_t len, char digest[DTLS_SHA512_DIGEST_STRING_LENGTH]) {
+       DTLS_SHA512_CTX context;
 
-       SHA512_Init(&context);
-       SHA512_Update(&context, data, len);
-       return SHA512_End(&context, digest);
+       DTLS_SHA512_Init(&context);
+       DTLS_SHA512_Update(&context, data, len);
+       return DTLS_SHA512_End(&context, digest);
 }
 #endif
 
 /*** SHA-384: *********************************************************/
 #ifdef WITH_SHA384
-void SHA384_Init(SHA384_CTX* context) {
-       if (context == (SHA384_CTX*)0) {
+void DTLS_SHA384_Init(DTLS_SHA384_CTX* context) {
+       if (context == (DTLS_SHA384_CTX*)0) {
                return;
        }
-       MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
-       MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH);
+       MEMCPY_BCOPY(context->state, sha384_initial_hash_value, DTLS_SHA512_DIGEST_LENGTH);
+       MEMSET_BZERO(context->buffer, DTLS_SHA384_BLOCK_LENGTH);
        context->bitcount[0] = context->bitcount[1] = 0;
 }
 
-void SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) {
-       SHA512_Update((SHA512_CTX*)context, data, len);
+void DTLS_SHA384_Update(DTLS_SHA384_CTX* context, const sha2_byte* data, size_t len) {
+       DTLS_SHA512_Update((DTLS_SHA512_CTX*)context, data, len);
 }
 
-void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
+void DTLS_SHA384_Final(sha2_byte digest[], DTLS_SHA384_CTX* context) {
        sha2_word64     *d = (sha2_word64*)digest;
 
        /* Sanity check: */
-       assert(context != (SHA384_CTX*)0);
+       assert(context != (DTLS_SHA384_CTX*)0);
 
        /* If no digest buffer is passed, we don't bother doing this: */
        if (digest != (sha2_byte*)0) {
-               SHA512_Last((SHA512_CTX*)context);
+               DTLS_SHA512_Last((DTLS_SHA512_CTX*)context);
 
                /* Save the hash data for output: */
 #if BYTE_ORDER == LITTLE_ENDIAN
@@ -1060,7 +1060,7 @@ void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
                        }
                }
 #else
-               MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LENGTH);
+               MEMCPY_BCOPY(d, context->state, DTLS_SHA384_DIGEST_LENGTH);
 #endif
        }
 
@@ -1068,17 +1068,17 @@ void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
        MEMSET_BZERO(context, sizeof(context));
 }
 
-char *SHA384_End(SHA384_CTX* context, char buffer[]) {
-       sha2_byte       digest[SHA384_DIGEST_LENGTH], *d = digest;
+char *DTLS_SHA384_End(DTLS_SHA384_CTX* context, char buffer[]) {
+       sha2_byte       digest[DTLS_SHA384_DIGEST_LENGTH], *d = digest;
        int             i;
 
        /* Sanity check: */
-       assert(context != (SHA384_CTX*)0);
+       assert(context != (DTLS_SHA384_CTX*)0);
 
        if (buffer != (char*)0) {
-               SHA384_Final(digest, context);
+               DTLS_SHA384_Final(digest, context);
 
-               for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
+               for (i = 0; i < DTLS_SHA384_DIGEST_LENGTH; i++) {
                        *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
                        *buffer++ = sha2_hex_digits[*d & 0x0f];
                        d++;
@@ -1087,15 +1087,15 @@ char *SHA384_End(SHA384_CTX* context, char buffer[]) {
        } else {
                MEMSET_BZERO(context, sizeof(context));
        }
-       MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH);
+       MEMSET_BZERO(digest, DTLS_SHA384_DIGEST_LENGTH);
        return buffer;
 }
 
-char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) {
-       SHA384_CTX      context;
+char* DTLS_SHA384_Data(const sha2_byte* data, size_t len, char digest[DTLS_SHA384_DIGEST_STRING_LENGTH]) {
+       DTLS_SHA384_CTX context;
 
-       SHA384_Init(&context);
-       SHA384_Update(&context, data, len);
-       return SHA384_End(&context, digest);
+       DTLS_SHA384_Init(&context);
+       DTLS_SHA384_Update(&context, data, len);
+       return DTLS_SHA384_End(&context, digest);
 }
 #endif

diff --git a/extlibs/tinydtls/sha2/sha2.h b/extlibs/tinydtls/sha2/sha2.h
index 709fc80..e6eecc4 100644 (file)
--- a/extlibs/tinydtls/sha2/sha2.h
+++ b/extlibs/tinydtls/sha2/sha2.h
@@ -55,15 +55,15 @@ extern "C" {
 
 
 /*** SHA-256/384/512 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)
+#define DTLS_SHA256_BLOCK_LENGTH               64
+#define DTLS_SHA256_DIGEST_LENGTH              32
+#define DTLS_SHA256_DIGEST_STRING_LENGTH       (DTLS_SHA256_DIGEST_LENGTH * 2 + 1)
+#define DTLS_SHA384_BLOCK_LENGTH               128
+#define DTLS_SHA384_DIGEST_LENGTH              48
+#define DTLS_SHA384_DIGEST_STRING_LENGTH       (DTLS_SHA384_DIGEST_LENGTH * 2 + 1)
+#define DTLS_SHA512_BLOCK_LENGTH               128
+#define DTLS_SHA512_DIGEST_LENGTH              64
+#define DTLS_SHA512_DIGEST_STRING_LENGTH       (DTLS_SHA512_DIGEST_LENGTH * 2 + 1)
 
 
 /*** SHA-256/384/512 Context Structures *******************************/
@@ -94,33 +94,33 @@ typedef unsigned long long u_int64_t;       /* 8-bytes (64-bits) */
  */
 #ifdef SHA2_USE_INTTYPES_H
 
-typedef struct _SHA256_CTX {
+typedef struct _DTLS_SHA256_CTX {
        uint32_t        state[8];
        uint64_t        bitcount;
-       uint8_t buffer[SHA256_BLOCK_LENGTH];
-} SHA256_CTX;
-typedef struct _SHA512_CTX {
+       uint8_t buffer[DTLS_SHA256_BLOCK_LENGTH];
+} DTLS_SHA256_CTX;
+typedef struct _DTLS_SHA512_CTX {
        uint64_t        state[8];
        uint64_t        bitcount[2];
-       uint8_t buffer[SHA512_BLOCK_LENGTH];
-} SHA512_CTX;
+       uint8_t buffer[DTLS_SHA512_BLOCK_LENGTH];
+} DTLS_SHA512_CTX;
 
 #else /* SHA2_USE_INTTYPES_H */
 
-typedef struct _SHA256_CTX {
+typedef struct _DTLS_SHA256_CTX {
        u_int32_t       state[8];
        u_int64_t       bitcount;
-       u_int8_t        buffer[SHA256_BLOCK_LENGTH];
-} SHA256_CTX;
-typedef struct _SHA512_CTX {
+       u_int8_t        buffer[DTLS_SHA256_BLOCK_LENGTH];
+} DTLS_SHA256_CTX;
+typedef struct _DTLS_SHA512_CTX {
        u_int64_t       state[8];
        u_int64_t       bitcount[2];
-       u_int8_t        buffer[SHA512_BLOCK_LENGTH];
-} SHA512_CTX;
+       u_int8_t        buffer[DTLS_SHA512_BLOCK_LENGTH];
+} DTLS_SHA512_CTX;
 
 #endif /* SHA2_USE_INTTYPES_H */
 
-typedef SHA512_CTX SHA384_CTX;
+typedef DTLS_SHA512_CTX DTLS_SHA384_CTX;
 
 
 /*** SHA-256/384/512 Function Prototypes ******************************/
@@ -128,53 +128,53 @@ typedef SHA512_CTX SHA384_CTX;
 #ifdef SHA2_USE_INTTYPES_H
 
 #ifdef WITH_SHA256
-void SHA256_Init(SHA256_CTX *);
-void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t);
-void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
-char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
-char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
+void DTLS_SHA256_Init(DTLS_SHA256_CTX *);
+void DTLS_SHA256_Update(DTLS_SHA256_CTX*, const uint8_t*, size_t);
+void DTLS_SHA256_Final(uint8_t[DTLS_SHA256_DIGEST_LENGTH], DTLS_SHA256_CTX*);
+char* DTLS_SHA256_End(DTLS_SHA256_CTX*, char[DTLS_SHA256_DIGEST_STRING_LENGTH]);
+char* DTLS_SHA256_Data(const uint8_t*, size_t, char[DTLS_SHA256_DIGEST_STRING_LENGTH]);
 #endif
 
 #ifdef WITH_SHA384
-void SHA384_Init(SHA384_CTX*);
-void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t);
-void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
-char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
-char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
+void DTLS_SHA384_Init(DTLS_SHA384_CTX*);
+void DTLS_SHA384_Update(DTLS_SHA384_CTX*, const uint8_t*, size_t);
+void DTLS_SHA384_Final(uint8_t[DTLS_SHA384_DIGEST_LENGTH], SHA384_CTX*);
+char* DTLS_SHA384_End(DTLS_SHA384_CTX*, char[DTLS_SHA384_DIGEST_STRING_LENGTH]);
+char* DTLS_SHA384_Data(const uint8_t*, size_t, char[DTLS_SHA384_DIGEST_STRING_LENGTH]);
 #endif
 
 #ifdef WITH_SHA512
-void SHA512_Init(SHA512_CTX*);
-void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t);
-void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
-char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
-char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
+void DTLS_SHA512_Init(DTLS_SHA512_CTX*);
+void DTLS_SHA512_Update(DTLS_SHA512_CTX*, const uint8_t*, size_t);
+void DTLS_SHA512_Final(uint8_t[DTLS_SHA512_DIGEST_LENGTH], DTLS_SHA512_CTX*);
+char* DTLS_SHA512_End(DTLS_SHA512_CTX*, char[DTLS_SHA512_DIGEST_STRING_LENGTH]);
+char* DTLS_SHA512_Data(const uint8_t*, size_t, char[DTLS_SHA512_DIGEST_STRING_LENGTH]);
 #endif
 
 #else /* SHA2_USE_INTTYPES_H */
 
 #ifdef WITH_SHA256
-void SHA256_Init(SHA256_CTX *);
-void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t);
-void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
-char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
-char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
+void DTLS_SHA256_Init(DTLS_SHA256_CTX *);
+void DTLS_SHA256_Update(DTLS_SHA256_CTX*, const u_int8_t*, size_t);
+void DTLS_SHA256_Final(u_int8_t[DTLS_SHA256_DIGEST_LENGTH], DTLS_SHA256_CTX*);
+char* DTLS_SHA256_End(DTLS_SHA256_CTX*, char[DTLS_SHA256_DIGEST_STRING_LENGTH]);
+char* DTLS_SHA256_Data(const u_int8_t*, size_t, char[DTLS_SHA256_DIGEST_STRING_LENGTH]);
 #endif
 
 #ifdef WITH_SHA384
-void SHA384_Init(SHA384_CTX*);
-void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t);
-void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
-char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
-char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
+void DTLS_SHA384_Init(DTLS_SHA384_CTX*);
+void DTLS_SHA384_Update(DTLS_SHA384_CTX*, const u_int8_t*, size_t);
+void DTLS_SHA384_Final(u_int8_t[DTLS_SHA384_DIGEST_LENGTH], DTLS_SHA384_CTX*);
+char* DTLS_SHA384_End(DTLS_SHA384_CTX*, char[DTLS_SHA384_DIGEST_STRING_LENGTH]);
+char* DTLS_SHA384_Data(const u_int8_t*, size_t, char[DTLS_SHA384_DIGEST_STRING_LENGTH]);
 #endif
 
 #ifdef WITH_SHA512
-void SHA512_Init(SHA512_CTX*);
-void SHA512_Update(SHA512_CTX*, const u_int8_t*, size_t);
-void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
-char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
-char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
+void DTLS_SHA512_Init(DTLS_SHA512_CTX*);
+void DTLS_SHA512_Update(DTLS_SHA512_CTX*, const u_int8_t*, size_t);
+void DTLS_SHA512_Final(u_int8_t[DTLS_SHA512_DIGEST_LENGTH], DTLS_SHA512_CTX*);
+char* DTLS_SHA512_End(DTLS_SHA512_CTX*, char[DTLS_SHA512_DIGEST_STRING_LENGTH]);
+char* DTLS_SHA512_Data(const u_int8_t*, size_t, char[DTLS_SHA512_DIGEST_STRING_LENGTH]);
 #endif
 
 #endif /* SHA2_USE_INTTYPES_H */
@@ -182,27 +182,27 @@ char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
 #else /* NOPROTO */
 
 #ifdef WITH_SHA256
-void SHA256_Init();
-void SHA256_Update();
-void SHA256_Final();
-char* SHA256_End();
-char* SHA256_Data();
+void DTLS_SHA256_Init();
+void DTLS_SHA256_Update();
+void DTLS_SHA256_Final();
+char* DTLS_SHA256_End();
+char* DTLS_SHA256_Data();
 #endif
 
 #ifdef WITH_SHA384
-void SHA384_Init();
-void SHA384_Update();
-void SHA384_Final();
-char* SHA384_End();
-char* SHA384_Data();
+void DTLS_SHA384_Init();
+void DTLS_SHA384_Update();
+void DTLS_SHA384_Final();
+char* DTLS_SHA384_End();
+char* DTLS_SHA384_Data();
 #endif
 
 #ifdef WITH_SHA512
-void SHA512_Init();
-void SHA512_Update();
-void SHA512_Final();
-char* SHA512_End();
-char* SHA512_Data();
+void DTLS_SHA512_Init();
+void DTLS_SHA512_Update();
+void DTLS_SHA512_Final();
+char* DTLS_SHA512_End();
+char* DTLS_SHA512_Data();
 #endif
 
 #endif /* NOPROTO */

diff --git a/extlibs/tinydtls/sha2/sha2prog.c b/extlibs/tinydtls/sha2/sha2prog.c
index 8d9d6ae..b5c485e 100644 (file)
--- a/extlibs/tinydtls/sha2/sha2prog.c
+++ b/extlibs/tinydtls/sha2/sha2prog.c
@@ -52,14 +52,14 @@ int main(int argc, char **argv) {
        int             quiet = 0, hash = 0;
        char            *av, *file = (char*)0;
        FILE            *IN = (FILE*)0;
-       SHA256_CTX      ctx256;
-       SHA384_CTX      ctx384;
-       SHA512_CTX      ctx512;
+       DTLS_SHA256_CTX ctx256;
+       DTLS_SHA384_CTX ctx384;
+       DTLS_SHA512_CTX ctx512;
        unsigned char   buf[BUFLEN];
 
-       SHA256_Init(&ctx256);
-       SHA384_Init(&ctx384);
-       SHA512_Init(&ctx512);
+       DTLS_SHA256_Init(&ctx256);
+       DTLS_SHA384_Init(&ctx384);
+       DTLSSHA512_Init(&ctx512);
 
        /* Read data from STDIN by default */
        fd = fileno(stdin);
@@ -100,28 +100,28 @@ int main(int argc, char **argv) {
        kl = 0;
        while ((l = read(fd,buf,BUFLEN)) > 0) {
                kl += l;
-               SHA256_Update(&ctx256, (unsigned char*)buf, l);
-               SHA384_Update(&ctx384, (unsigned char*)buf, l);
-               SHA512_Update(&ctx512, (unsigned char*)buf, l);
+               DTLS_SHA256_Update(&ctx256, (unsigned char*)buf, l);
+               DTLS_SHA384_Update(&ctx384, (unsigned char*)buf, l);
+               DTLS_SHA512_Update(&ctx512, (unsigned char*)buf, l);
        }
        if (file) {
                fclose(IN);
        }
 
        if (hash & 1) {
-               SHA256_End(&ctx256, buf);
+               DTLS_SHA256_End(&ctx256, buf);
                if (!quiet)
                        printf("SHA-256 (%s) = ", file);
                printf("%s\n", buf);
        }
        if (hash & 2) {
-               SHA384_End(&ctx384, buf);
+               DTLS_SHA384_End(&ctx384, buf);
                if (!quiet)
                        printf("SHA-384 (%s) = ", file);
                printf("%s\n", buf);
        }
        if (hash & 4) {
-               SHA512_End(&ctx512, buf);
+               DTLS_SHA512_End(&ctx512, buf);
                if (!quiet)
                        printf("SHA-512 (%s) = ", file);
                printf("%s\n", buf);

diff --git a/extlibs/tinydtls/sha2/sha2speed.c b/extlibs/tinydtls/sha2/sha2speed.c
index 2e13575..f012f40 100644 (file)
--- a/extlibs/tinydtls/sha2/sha2speed.c
+++ b/extlibs/tinydtls/sha2/sha2speed.c
@@ -60,11 +60,11 @@ void printspeed(char *caption, unsigned long bytes, double time) {
 
 
 int main(int argc, char **argv) {
-       SHA256_CTX      c256;
-       SHA384_CTX      c384;
-       SHA512_CTX      c512;
+       DTLS_SHA256_CTX c256;
+       DTLS_SHA384_CTX c384;
+       DTLS_SHA512_CTX c512;
        char            buf[BUFSIZE];
-       char            md[SHA512_DIGEST_STRING_LENGTH];
+       char            md[DTLS_SHA512_DIGEST_STRING_LENGTH];
        int             bytes, blocks, rep, i, j;
        struct timeval  start, end;
        double          t, ave256, ave384, ave512;
@@ -97,18 +97,18 @@ int main(int argc, char **argv) {
        ave256 = ave384 = ave512 = 0;
        best256 = best384 = best512 = 100000;
        for (i = 0; i < rep; i++) {
-               SHA256_Init(&c256);
-               SHA384_Init(&c384);
-               SHA512_Init(&c512);
+               DTLS_SHA256_Init(&c256);
+               DTLS_SHA384_Init(&c384);
+               DTLS_SHA512_Init(&c512);
        
                gettimeofday(&start, (struct timezone*)0);
                for (j = 0; j < blocks; j++) {
-                       SHA256_Update(&c256, (unsigned char*)buf, BUFSIZE);
+                       DTLS_SHA256_Update(&c256, (unsigned char*)buf, BUFSIZE);
                }
                if (bytes % BUFSIZE) {
-                       SHA256_Update(&c256, (unsigned char*)buf, bytes % BUFSIZE);
+                       DTLS_SHA256_Update(&c256, (unsigned char*)buf, bytes % BUFSIZE);
                }
-               SHA256_End(&c256, md);
+               DTLS_SHA256_End(&c256, md);
                gettimeofday(&end, (struct timezone*)0);
                t = ((end.tv_sec - start.tv_sec) * 1000000.0 + (end.tv_usec - start.tv_usec)) / 1000000.0;
                ave256 += t;
@@ -119,12 +119,12 @@ int main(int argc, char **argv) {
 
                gettimeofday(&start, (struct timezone*)0);
                for (j = 0; j < blocks; j++) {
-                       SHA384_Update(&c384, (unsigned char*)buf, BUFSIZE);
+                       DTLS_SHA384_Update(&c384, (unsigned char*)buf, BUFSIZE);
                }
                if (bytes % BUFSIZE) {
-                       SHA384_Update(&c384, (unsigned char*)buf, bytes % BUFSIZE);
+                       DTLS_SHA384_Update(&c384, (unsigned char*)buf, bytes % BUFSIZE);
                }
-               SHA384_End(&c384, md);
+               DTLS_SHA384_End(&c384, md);
                gettimeofday(&end, (struct timezone*)0);
                t = ((end.tv_sec - start.tv_sec) * 1000000.0 + (end.tv_usec - start.tv_usec)) / 1000000.0;
                ave384 += t;
@@ -135,12 +135,12 @@ int main(int argc, char **argv) {
 
                gettimeofday(&start, (struct timezone*)0);
                for (j = 0; j < blocks; j++) {
-                       SHA512_Update(&c512, (unsigned char*)buf, BUFSIZE);
+                       DTLS_SHA512_Update(&c512, (unsigned char*)buf, BUFSIZE);
                }
                if (bytes % BUFSIZE) {
-                       SHA512_Update(&c512, (unsigned char*)buf, bytes % BUFSIZE);
+                       DTLS_SHA512_Update(&c512, (unsigned char*)buf, bytes % BUFSIZE);
                }
-               SHA512_End(&c512, md);
+               DTLS_SHA512_End(&c512, md);
                gettimeofday(&end, (struct timezone*)0);
                t = ((end.tv_sec - start.tv_sec) * 1000000.0 + (end.tv_usec - start.tv_usec)) / 1000000.0;
                ave512 += t;

diff --git a/extlibs/tinydtls/tests/pcap.c b/extlibs/tinydtls/tests/pcap.c
index 7534c5f..8f72f26 100644 (file)
--- a/extlibs/tinydtls/tests/pcap.c
+++ b/extlibs/tinydtls/tests/pcap.c
@@ -44,7 +44,7 @@ finalize_hash(uint8 *buf) {
 #if DTLS_VERSION == 0xfeff
   unsigned char statebuf[sizeof(md5_state_t) + sizeof(SHA_CTX)];
 #elif DTLS_VERSION == 0xfefd
-  unsigned char statebuf[sizeof(SHA256_CTX)];
+  unsigned char statebuf[sizeof(DTLS_SHA256_CTX)];
 #endif
 
   if (!hs_hash[0])
@@ -213,7 +213,7 @@ handle_packet(const u_char *packet, int length) {
 #endif
   uint8 hash_buf[16 + SHA1_DIGEST_LENGTH];
 #elif DTLS_VERSION == 0xfefd
-  uint8 hash_buf[SHA256_DIGEST_LENGTH];
+  uint8 hash_buf[DTLS_SHA256_DIGEST_LENGTH];
 #endif
 #define verify_data_length 12
   int is_client;

diff --git a/resource/csdk/connectivity/inc/pkix/crypto_adapter.h b/resource/csdk/connectivity/inc/pkix/crypto_adapter.h
index d824b5e..3f2b93c 100644 (file)
--- a/resource/csdk/connectivity/inc/pkix/crypto_adapter.h
+++ b/resource/csdk/connectivity/inc/pkix/crypto_adapter.h
@@ -52,10 +52,10 @@ extern "C" {
  */
 #undef GET_SHA_256
 #define GET_SHA_256(tbs, sha256) do{                     \
-        SHA256_CTX ctx256;                          \
-        SHA256_Init(&ctx256);                       \
-        SHA256_Update(&ctx256, tbs.data, tbs.len);  \
-        SHA256_Final(sha256, &ctx256);              \
+        DTLS_SHA256_CTX ctx256;                          \
+        DTLS_SHA256_Init(&ctx256);                       \
+        DTLS_SHA256_Update(&ctx256, tbs.data, tbs.len);  \
+        DTLS_SHA256_Final(sha256, &ctx256);              \
     }while(0)
 
 /**@def CHECK_SIGN(structure, caPubKey)