SHA256, SHA384 and SHA512 error verification on test files.

ctaocrypt/benchmark/benchmark.c

@@ -633,10 +633,19 @@ void bench_sha256(void)
     }
     start = current_time(1);
     
-    for(i = 0; i < numBlocks; i++)
+    for(i = 0; i < numBlocks; i++) {
-        Sha256Update(&hash, plain, sizeof(plain));
+        ret = Sha256Update(&hash, plain, sizeof(plain));
+        if (ret != 0) {
+            printf("Sha256Update failed, ret = %d\n", ret);
+            return;
+        }
+    }
    
-    Sha256Final(&hash, digest);
+    ret = Sha256Final(&hash, digest);
+    if (ret != 0) {
+        printf("Sha256Final failed, ret = %d\n", ret);
+        return;
+    }
 
     total = current_time(0) - start;
     persec = 1 / total * numBlocks;
@@ -665,10 +674,19 @@ void bench_sha512(void)
     }
     start = current_time(1);
     
-    for(i = 0; i < numBlocks; i++)
+    for(i = 0; i < numBlocks; i++) {
-        Sha512Update(&hash, plain, sizeof(plain));
+        ret = Sha512Update(&hash, plain, sizeof(plain));
+        if (ret != 0) {
+            printf("Sha512Update failed, ret = %d\n", ret);
+            return;
+        }
+    }
 
-    Sha512Final(&hash, digest);
+    ret = Sha512Final(&hash, digest);
+    if (ret != 0) {
+        printf("Sha512Final failed, ret = %d\n", ret);
+        return;
+    }
 
     total = current_time(0) - start;
     persec = 1 / total * numBlocks;

ctaocrypt/src/port/pic32/pic32mz-hash.c

@@ -221,19 +221,23 @@ void InitSha256(Sha256* sha256)
     reset_engine(&(sha256->desc), PIC32_ALGO_SHA256) ;
 }
 
-void Sha256Update(Sha256* sha256, const byte* data, word32 len)
+int Sha256Update(Sha256* sha256, const byte* data, word32 len)
 {
     CYASSL_ENTER("Sha256Update\n") ;
     update_engine(&(sha256->desc), data, len, sha256->digest) ;
+
+    return 0;
 }
 
-void Sha256Final(Sha256* sha256, byte* hash)
+int Sha256Final(Sha256* sha256, byte* hash)
 {
     CYASSL_ENTER("Sha256Final\n") ;
     start_engine(&(sha256->desc)) ;
     wait_engine(&(sha256->desc), (char *)sha256->digest, SHA256_HASH_SIZE) ;
     XMEMCPY(hash, sha256->digest, SHA256_HASH_SIZE) ;
     InitSha256(sha256);  /* reset state */
+
+    return 0;
 }
 #endif /* NO_SHA256 */
 

ctaocrypt/test/test.c

@@ -972,8 +972,12 @@ int sha256_test(void)
         return -4003;
 
     for (i = 0; i < times; ++i) {
-        Sha256Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        ret = Sha256Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
-        Sha256Final(&sha, hash);
+        if (ret != 0)
+            return -4004;
+        ret = Sha256Final(&sha, hash);
+        if (ret != 0)
+            return -4005;
 
         if (memcmp(hash, test_sha[i].output, SHA256_DIGEST_SIZE) != 0)
             return -10 - i;
@@ -1022,8 +1026,13 @@ int sha512_test(void)
         return -4009;
 
     for (i = 0; i < times; ++i) {
-        Sha512Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        ret = Sha512Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
-        Sha512Final(&sha, hash);
+        if (ret != 0)
+            return -4010;
+
+        ret = Sha512Final(&sha, hash);
+        if (ret != 0)
+            return -4011;
 
         if (memcmp(hash, test_sha[i].output, SHA512_DIGEST_SIZE) != 0)
             return -10 - i;
@@ -1067,11 +1076,16 @@ int sha384_test(void)
 
     ret = InitSha384(&sha);
     if (ret != 0)
-        return -4010;
+        return -4012;
 
     for (i = 0; i < times; ++i) {
-        Sha384Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        ret = Sha384Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
-        Sha384Final(&sha, hash);
+        if (ret != 0)
+            return -4013;
+
+        ret = Sha384Final(&sha, hash);
+        if (ret != 0)
+            return -4014;
 
         if (memcmp(hash, test_sha[i].output, SHA384_DIGEST_SIZE) != 0)
             return -10 - i;

mcapi/mcapi_test.c

@@ -284,10 +284,18 @@ static int check_sha256(void)
     }
 
     CRYPT_SHA256_DataAdd(&mcSha256, ourData, OUR_DATA_SIZE);
-    Sha256Update(&defSha256, ourData, OUR_DATA_SIZE);
+    ret = Sha256Update(&defSha256, ourData, OUR_DATA_SIZE);
+    if (ret != 0) {
+        printf("sha256 update default failed\n");
+        return -1;
+    }
 
     CRYPT_SHA256_Finalize(&mcSha256, mcDigest);
-    Sha256Final(&defSha256, defDigest);
+    ret = Sha256Final(&defSha256, defDigest);
+    if (ret != 0) {
+        printf("sha256 final default failed\n");
+        return -1;
+    }
 
     if (memcmp(mcDigest, defDigest, CRYPT_SHA256_DIGEST_SIZE) != 0) {
         printf("sha256 final memcmp fialed\n");
@@ -316,10 +324,18 @@ static int check_sha384(void)
     }
 
     CRYPT_SHA384_DataAdd(&mcSha384, ourData, OUR_DATA_SIZE);
-    Sha384Update(&defSha384, ourData, OUR_DATA_SIZE);
+    ret = Sha384Update(&defSha384, ourData, OUR_DATA_SIZE);
+    if (ret != 0) {
+        printf("sha384 update default failed\n");
+        return -1;
+    }
 
     CRYPT_SHA384_Finalize(&mcSha384, mcDigest);
-    Sha384Final(&defSha384, defDigest);
+    ret = Sha384Final(&defSha384, defDigest);
+    if (ret != 0) {
+        printf("sha384 final default failed\n");
+        return -1;
+    }
 
     if (memcmp(mcDigest, defDigest, CRYPT_SHA384_DIGEST_SIZE) != 0) {
         printf("sha384 final memcmp fialed\n");
@@ -348,10 +364,18 @@ static int check_sha512(void)
     }
 
     CRYPT_SHA512_DataAdd(&mcSha512, ourData, OUR_DATA_SIZE);
-    Sha512Update(&defSha512, ourData, OUR_DATA_SIZE);
+    ret = Sha512Update(&defSha512, ourData, OUR_DATA_SIZE);
+    if (ret != 0) {
+        printf("sha512 update default failed\n");
+        return -1;
+    }
 
     CRYPT_SHA512_Finalize(&mcSha512, mcDigest);
-    Sha512Final(&defSha512, defDigest);
+    ret = Sha512Final(&defSha512, defDigest);
+    if (ret != 0) {
+        printf("sha512 final default failed\n");
+        return -1;
+    }
 
     if (memcmp(mcDigest, defDigest, CRYPT_SHA512_DIGEST_SIZE) != 0) {
         printf("sha512 final memcmp fialed\n");

tests/hash.c

@@ -386,8 +386,13 @@ int sha256_test(void)
         return ret;
 
     for (i = 0; i < times; ++i) {
-        Sha256Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        ret = Sha256Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
-        Sha256Final(&sha, hash);
+        if (ret != 0)
+            return ret;
+
+        ret = Sha256Final(&sha, hash);
+        if (ret != 0)
+            return ret;
 
         if (memcmp(hash, test_sha[i].output, SHA256_DIGEST_SIZE) != 0)
             return -10 - i;
@@ -432,11 +437,16 @@ int sha512_test(void)
 
     ret = InitSha512(&sha);
     if (ret != 0)
-        return -4009;
+        return ret;
 
     for (i = 0; i < times; ++i) {
-        Sha512Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        ret = Sha512Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
-        Sha512Final(&sha, hash);
+        if (ret != 0)
+            return ret;
+
+        ret = Sha512Final(&sha, hash);
+        if (ret != 0)
+            return ret;
 
         if (memcmp(hash, test_sha[i].output, SHA512_DIGEST_SIZE) != 0)
             return -10 - i;
@@ -482,8 +492,13 @@ int sha384_test()
         return ret;
 
     for (i = 0; i < times; ++i) {
-        Sha384Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        ret = Sha384Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
-        Sha384Final(&sha, hash);
+        if (ret != 0)
+            return ret;
+
+        ret = Sha384Final(&sha, hash);
+        if (ret != 0)
+            return ret;
 
         if (memcmp(hash, test_sha[i].output, SHA384_DIGEST_SIZE) != 0)
             return -10 - i;

testsuite/testsuite.c

@@ -321,10 +321,20 @@ void file_test(const char* file, byte* check)
         printf("Can't open %s\n", file);
         return;
     }
-    while( ( i = (int)fread(buf, 1, sizeof(buf), f )) > 0 )
+    while( ( i = (int)fread(buf, 1, sizeof(buf), f )) > 0 ) {
-        Sha256Update(&sha256, buf, i);
+        ret = Sha256Update(&sha256, buf, i);
+        if (ret != 0) {
+            printf("Can't Sha256Update %d\n", ret);
+            return;
+        }
+    }
+    
+    ret = Sha256Final(&sha256, shasum);
+    if (ret != 0) {
+        printf("Can't Sha256Final %d\n", ret);
+        return;
+    }
 
-    Sha256Final(&sha256, shasum);
     memcpy(check, shasum, sizeof(shasum));
 
     for(j = 0; j < SHA256_DIGEST_SIZE; ++j )