diff --git a/ctaocrypt/benchmark/benchmark.c b/ctaocrypt/benchmark/benchmark.c
index 443bffe39..5dc28e004 100644
--- a/ctaocrypt/benchmark/benchmark.c
+++ b/ctaocrypt/benchmark/benchmark.c
@@ -633,10 +633,19 @@ void bench_sha256(void)
     }
     start = current_time(1);
     
-    for(i = 0; i < numBlocks; i++)
-        Sha256Update(&hash, plain, sizeof(plain));
+    for(i = 0; i < numBlocks; i++) {
+        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++)
-        Sha512Update(&hash, plain, sizeof(plain));
-   
-    Sha512Final(&hash, digest);
+    for(i = 0; i < numBlocks; i++) {
+        ret = Sha512Update(&hash, plain, sizeof(plain));
+        if (ret != 0) {
+            printf("Sha512Update failed, ret = %d\n", ret);
+            return;
+        }
+    }
+
+    ret = Sha512Final(&hash, digest);
+    if (ret != 0) {
+        printf("Sha512Final failed, ret = %d\n", ret);
+        return;
+    }
 
     total = current_time(0) - start;
     persec = 1 / total * numBlocks;
diff --git a/ctaocrypt/src/port/pic32/pic32mz-hash.c b/ctaocrypt/src/port/pic32/pic32mz-hash.c
index cdc97eaca..7511725c7 100644
--- a/ctaocrypt/src/port/pic32/pic32mz-hash.c
+++ b/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 */
 
diff --git a/ctaocrypt/test/test.c b/ctaocrypt/test/test.c
index 568c7a837..add0ab93b 100644
--- a/ctaocrypt/test/test.c
+++ b/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);
-        Sha256Final(&sha, hash);
+        ret = Sha256Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        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);
-        Sha512Final(&sha, hash);
+        ret = Sha512Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        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);
-        Sha384Final(&sha, hash);
+        ret = Sha384Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        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;
diff --git a/mcapi/mcapi_test.c b/mcapi/mcapi_test.c
index f92062c4d..6be78909c 100644
--- a/mcapi/mcapi_test.c
+++ b/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");
diff --git a/tests/hash.c b/tests/hash.c
index 225856d92..629c93e25 100644
--- a/tests/hash.c
+++ b/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);
-        Sha256Final(&sha, hash);
+        ret = Sha256Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        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);
-        Sha512Final(&sha, hash);
+        ret = Sha512Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        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);
-        Sha384Final(&sha, hash);
+        ret = Sha384Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
+        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;
diff --git a/testsuite/testsuite.c b/testsuite/testsuite.c
index be8109669..419704f0c 100644
--- a/testsuite/testsuite.c
+++ b/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 )
-        Sha256Update(&sha256, buf, i);
+    while( ( i = (int)fread(buf, 1, sizeof(buf), f )) > 0 ) {
+        ret = Sha256Update(&sha256, buf, i);
+        if (ret != 0) {
+            printf("Can't Sha256Update %d\n", ret);
+            return;
+        }
+    }
     
-    Sha256Final(&sha256, shasum);
+    ret = Sha256Final(&sha256, shasum);
+    if (ret != 0) {
+        printf("Can't Sha256Final %d\n", ret);
+        return;
+    }
+
     memcpy(check, shasum, sizeof(shasum));
 
     for(j = 0; j < SHA256_DIGEST_SIZE; ++j )