| /* hash.c has unit tests |
| * |
| * Copyright (C) 2006-2012 Sawtooth Consulting Ltd. |
| * |
| * This file is part of CyaSSL. |
| * |
| * CyaSSL is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * CyaSSL is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <stdio.h> |
| |
| #include <cyassl/ctaocrypt/md4.h> |
| #include <cyassl/ctaocrypt/md5.h> |
| #include <cyassl/ctaocrypt/sha.h> |
| #include <cyassl/ctaocrypt/sha256.h> |
| #include <cyassl/ctaocrypt/sha512.h> |
| #include <cyassl/ctaocrypt/ripemd.h> |
| #include <cyassl/ctaocrypt/hmac.h> |
| |
| #include <tests/unit.h> |
| |
| typedef struct testVector { |
| char* input; |
| char* output; |
| size_t inLen; |
| size_t outLen; |
| } testVector; |
| |
| int md4_test(void); |
| int md5_test(void); |
| int sha_test(void); |
| int sha256_test(void); |
| int sha512_test(void); |
| int sha384_test(void); |
| int ripemd_test(void); |
| int hmac_test(void); |
| |
| int HashTest(void) |
| { |
| int ret = 0; |
| |
| printf(" Begin HASH Tests\n"); |
| |
| #ifndef NO_MD4 |
| if ( (ret = md4_test()) ) { |
| printf( " MD4 test failed!\n"); |
| return ret; |
| } else |
| printf( " MD4 test passed!\n"); |
| #endif |
| |
| if ( (ret = md5_test()) ) { |
| printf( " MD5 test failed!\n"); |
| return ret; |
| } else |
| printf( " MD5 test passed!\n"); |
| |
| if ( (ret = sha_test()) ) { |
| printf( " SHA test failed!\n"); |
| return ret; |
| } else |
| printf( " SHA test passed!\n"); |
| |
| #ifndef NO_SHA256 |
| if ( (ret = sha256_test()) ) { |
| printf( " SHA-256 test failed!\n"); |
| return ret; |
| } else |
| printf( " SHA-256 test passed!\n"); |
| #endif |
| |
| #ifdef CYASSL_SHA512 |
| if ( (ret = sha512_test()) ) { |
| printf( " SHA-512 test failed!\n"); |
| return ret; |
| } else |
| printf( " SHA-512 test passed!\n"); |
| #endif |
| |
| #ifdef CYASSL_SHA384 |
| if ( (ret = sha384_test()) ) { |
| printf( " SHA-384 test failed!\n"); |
| return ret; |
| } else |
| printf( " SHA-384 test passed!\n"); |
| #endif |
| |
| #ifdef CYASSL_RIPEMD |
| if ( (ret = ripemd_test()) ) { |
| printf( " RIPEMD test failed!\n"); |
| return ret; |
| } else |
| printf( " RIPEMD test passed!\n"); |
| #endif |
| |
| #ifndef NO_HMAC |
| if ( (ret = hmac_test()) ) { |
| printf( " HMAC test failed!\n"); |
| return ret; |
| } else |
| printf( " HMAC test passed!\n"); |
| #endif |
| |
| printf(" End HASH Tests\n"); |
| |
| return 0; |
| } |
| |
| #ifndef NO_MD4 |
| |
| int md4_test(void) |
| { |
| Md4 md4; |
| byte hash[MD4_DIGEST_SIZE]; |
| |
| testVector a, b, c, d, e, f, g; |
| testVector test_md4[7]; |
| int times = sizeof(test_md4) / sizeof(testVector), i; |
| |
| a.input = ""; |
| a.output = "\x31\xd6\xcf\xe0\xd1\x6a\xe9\x31\xb7\x3c\x59\xd7\xe0\xc0\x89" |
| "\xc0"; |
| a.inLen = strlen(a.input); |
| a.outLen = strlen(a.output); |
| |
| b.input = "a"; |
| b.output = "\xbd\xe5\x2c\xb3\x1d\xe3\x3e\x46\x24\x5e\x05\xfb\xdb\xd6\xfb" |
| "\x24"; |
| b.inLen = strlen(b.input); |
| b.outLen = strlen(b.output); |
| |
| c.input = "abc"; |
| c.output = "\xa4\x48\x01\x7a\xaf\x21\xd8\x52\x5f\xc1\x0a\xe8\x7a\xa6\x72" |
| "\x9d"; |
| c.inLen = strlen(c.input); |
| c.outLen = strlen(c.output); |
| |
| d.input = "message digest"; |
| d.output = "\xd9\x13\x0a\x81\x64\x54\x9f\xe8\x18\x87\x48\x06\xe1\xc7\x01" |
| "\x4b"; |
| d.inLen = strlen(d.input); |
| d.outLen = strlen(d.output); |
| |
| e.input = "abcdefghijklmnopqrstuvwxyz"; |
| e.output = "\xd7\x9e\x1c\x30\x8a\xa5\xbb\xcd\xee\xa8\xed\x63\xdf\x41\x2d" |
| "\xa9"; |
| e.inLen = strlen(e.input); |
| e.outLen = strlen(e.output); |
| |
| f.input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345" |
| "6789"; |
| f.output = "\x04\x3f\x85\x82\xf2\x41\xdb\x35\x1c\xe6\x27\xe1\x53\xe7\xf0" |
| "\xe4"; |
| f.inLen = strlen(f.input); |
| f.outLen = strlen(f.output); |
| |
| g.input = "1234567890123456789012345678901234567890123456789012345678" |
| "9012345678901234567890"; |
| g.output = "\xe3\x3b\x4d\xdc\x9c\x38\xf2\x19\x9c\x3e\x7b\x16\x4f\xcc\x05" |
| "\x36"; |
| g.inLen = strlen(g.input); |
| g.outLen = strlen(g.output); |
| |
| test_md4[0] = a; |
| test_md4[1] = b; |
| test_md4[2] = c; |
| test_md4[3] = d; |
| test_md4[4] = e; |
| test_md4[5] = f; |
| test_md4[6] = g; |
| |
| InitMd4(&md4); |
| |
| for (i = 0; i < times; ++i) { |
| Md4Update(&md4, (byte*)test_md4[i].input, (word32)test_md4[i].inLen); |
| Md4Final(&md4, hash); |
| |
| if (memcmp(hash, test_md4[i].output, MD4_DIGEST_SIZE) != 0) |
| return -205 - i; |
| } |
| |
| return 0; |
| } |
| |
| #endif /* NO_MD4 */ |
| |
| int md5_test(void) |
| { |
| Md5 md5; |
| byte hash[MD5_DIGEST_SIZE]; |
| |
| testVector a, b, c, d, e; |
| testVector test_md5[5]; |
| int times = sizeof(test_md5) / sizeof(testVector), i; |
| |
| a.input = "abc"; |
| a.output = "\x90\x01\x50\x98\x3c\xd2\x4f\xb0\xd6\x96\x3f\x7d\x28\xe1\x7f" |
| "\x72"; |
| a.inLen = strlen(a.input); |
| a.outLen = strlen(a.output); |
| |
| b.input = "message digest"; |
| b.output = "\xf9\x6b\x69\x7d\x7c\xb7\x93\x8d\x52\x5a\x2f\x31\xaa\xf1\x61" |
| "\xd0"; |
| b.inLen = strlen(b.input); |
| b.outLen = strlen(b.output); |
| |
| c.input = "abcdefghijklmnopqrstuvwxyz"; |
| c.output = "\xc3\xfc\xd3\xd7\x61\x92\xe4\x00\x7d\xfb\x49\x6c\xca\x67\xe1" |
| "\x3b"; |
| c.inLen = strlen(c.input); |
| c.outLen = strlen(c.output); |
| |
| d.input = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345" |
| "6789"; |
| d.output = "\xd1\x74\xab\x98\xd2\x77\xd9\xf5\xa5\x61\x1c\x2c\x9f\x41\x9d" |
| "\x9f"; |
| d.inLen = strlen(d.input); |
| d.outLen = strlen(d.output); |
| |
| e.input = "1234567890123456789012345678901234567890123456789012345678" |
| "9012345678901234567890"; |
| e.output = "\x57\xed\xf4\xa2\x2b\xe3\xc9\x55\xac\x49\xda\x2e\x21\x07\xb6" |
| "\x7a"; |
| e.inLen = strlen(e.input); |
| e.outLen = strlen(e.output); |
| |
| test_md5[0] = a; |
| test_md5[1] = b; |
| test_md5[2] = c; |
| test_md5[3] = d; |
| test_md5[4] = e; |
| |
| InitMd5(&md5); |
| |
| for (i = 0; i < times; ++i) { |
| Md5Update(&md5, (byte*)test_md5[i].input, (word32)test_md5[i].inLen); |
| Md5Final(&md5, hash); |
| |
| if (memcmp(hash, test_md5[i].output, MD5_DIGEST_SIZE) != 0) |
| return -5 - i; |
| } |
| |
| return 0; |
| } |
| |
| int sha_test(void) |
| { |
| Sha sha; |
| byte hash[SHA_DIGEST_SIZE]; |
| |
| testVector a, b, c, d; |
| testVector test_sha[4]; |
| int times = sizeof(test_sha) / sizeof(struct testVector), i; |
| |
| a.input = "abc"; |
| a.output = "\xA9\x99\x3E\x36\x47\x06\x81\x6A\xBA\x3E\x25\x71\x78\x50\xC2" |
| "\x6C\x9C\xD0\xD8\x9D"; |
| a.inLen = strlen(a.input); |
| a.outLen = strlen(a.output); |
| |
| b.input = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; |
| b.output = "\x84\x98\x3E\x44\x1C\x3B\xD2\x6E\xBA\xAE\x4A\xA1\xF9\x51\x29" |
| "\xE5\xE5\x46\x70\xF1"; |
| b.inLen = strlen(b.input); |
| b.outLen = strlen(b.output); |
| |
| c.input = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaa"; |
| c.output = "\x00\x98\xBA\x82\x4B\x5C\x16\x42\x7B\xD7\xA1\x12\x2A\x5A\x44" |
| "\x2A\x25\xEC\x64\x4D"; |
| c.inLen = strlen(c.input); |
| c.outLen = strlen(c.output); |
| |
| d.input = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" |
| "aaaaaaaaaa"; |
| d.output = "\xAD\x5B\x3F\xDB\xCB\x52\x67\x78\xC2\x83\x9D\x2F\x15\x1E\xA7" |
| "\x53\x99\x5E\x26\xA0"; |
| d.inLen = strlen(d.input); |
| d.outLen = strlen(d.output); |
| |
| test_sha[0] = a; |
| test_sha[1] = b; |
| test_sha[2] = c; |
| test_sha[3] = d; |
| |
| InitSha(&sha); |
| |
| for (i = 0; i < times; ++i) { |
| ShaUpdate(&sha, (byte*)test_sha[i].input, (word32)test_sha[i].inLen); |
| ShaFinal(&sha, hash); |
| |
| if (memcmp(hash, test_sha[i].output, SHA_DIGEST_SIZE) != 0) |
| return -10 - i; |
| } |
| |
| return 0; |
| } |
| |
| #ifndef NO_SHA256 |
| int sha256_test(void) |
| { |
| Sha256 sha; |
| byte hash[SHA256_DIGEST_SIZE]; |
| |
| testVector a, b; |
| testVector test_sha[2]; |
| int times = sizeof(test_sha) / sizeof(struct testVector), i; |
| |
| a.input = "abc"; |
| a.output = "\xBA\x78\x16\xBF\x8F\x01\xCF\xEA\x41\x41\x40\xDE\x5D\xAE\x22" |
| "\x23\xB0\x03\x61\xA3\x96\x17\x7A\x9C\xB4\x10\xFF\x61\xF2\x00" |
| "\x15\xAD"; |
| a.inLen = strlen(a.input); |
| a.outLen = strlen(a.output); |
| |
| b.input = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; |
| b.output = "\x24\x8D\x6A\x61\xD2\x06\x38\xB8\xE5\xC0\x26\x93\x0C\x3E\x60" |
| "\x39\xA3\x3C\xE4\x59\x64\xFF\x21\x67\xF6\xEC\xED\xD4\x19\xDB" |
| "\x06\xC1"; |
| b.inLen = strlen(b.input); |
| b.outLen = strlen(b.output); |
| |
| test_sha[0] = a; |
| test_sha[1] = b; |
| |
| InitSha256(&sha); |
| |
| for (i = 0; i < times; ++i) { |
| Sha256Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen); |
| Sha256Final(&sha, hash); |
| |
| if (memcmp(hash, test_sha[i].output, SHA256_DIGEST_SIZE) != 0) |
| return -10 - i; |
| } |
| |
| return 0; |
| } |
| #endif |
| |
| #ifdef CYASSL_SHA512 |
| int sha512_test(void) |
| { |
| Sha512 sha; |
| byte hash[SHA512_DIGEST_SIZE]; |
| |
| testVector a, b; |
| testVector test_sha[2]; |
| int times = sizeof(test_sha) / sizeof(struct testVector), i; |
| |
| a.input = "abc"; |
| a.output = "\xdd\xaf\x35\xa1\x93\x61\x7a\xba\xcc\x41\x73\x49\xae\x20\x41" |
| "\x31\x12\xe6\xfa\x4e\x89\xa9\x7e\xa2\x0a\x9e\xee\xe6\x4b\x55" |
| "\xd3\x9a\x21\x92\x99\x2a\x27\x4f\xc1\xa8\x36\xba\x3c\x23\xa3" |
| "\xfe\xeb\xbd\x45\x4d\x44\x23\x64\x3c\xe8\x0e\x2a\x9a\xc9\x4f" |
| "\xa5\x4c\xa4\x9f"; |
| a.inLen = strlen(a.input); |
| a.outLen = strlen(a.output); |
| |
| b.input = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhi" |
| "jklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"; |
| b.output = "\x8e\x95\x9b\x75\xda\xe3\x13\xda\x8c\xf4\xf7\x28\x14\xfc\x14" |
| "\x3f\x8f\x77\x79\xc6\xeb\x9f\x7f\xa1\x72\x99\xae\xad\xb6\x88" |
| "\x90\x18\x50\x1d\x28\x9e\x49\x00\xf7\xe4\x33\x1b\x99\xde\xc4" |
| "\xb5\x43\x3a\xc7\xd3\x29\xee\xb6\xdd\x26\x54\x5e\x96\xe5\x5b" |
| "\x87\x4b\xe9\x09"; |
| b.inLen = strlen(b.input); |
| b.outLen = strlen(b.output); |
| |
| test_sha[0] = a; |
| test_sha[1] = b; |
| |
| InitSha512(&sha); |
| |
| for (i = 0; i < times; ++i) { |
| Sha512Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen); |
| Sha512Final(&sha, hash); |
| |
| if (memcmp(hash, test_sha[i].output, SHA512_DIGEST_SIZE) != 0) |
| return -10 - i; |
| } |
| |
| return 0; |
| } |
| #endif |
| |
| #ifdef CYASSL_SHA384 |
| int sha384_test() |
| { |
| Sha384 sha; |
| byte hash[SHA384_DIGEST_SIZE]; |
| |
| testVector a, b; |
| testVector test_sha[2]; |
| int times = sizeof(test_sha) / sizeof(struct testVector), i; |
| |
| a.input = "abc"; |
| a.output = "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50" |
| "\x07\x27\x2c\x32\xab\x0e\xde\xd1\x63\x1a\x8b\x60\x5a\x43\xff" |
| "\x5b\xed\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34" |
| "\xc8\x25\xa7"; |
| a.inLen = strlen(a.input); |
| a.outLen = strlen(a.output); |
| |
| b.input = "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhi" |
| "jklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"; |
| b.output = "\x09\x33\x0c\x33\xf7\x11\x47\xe8\x3d\x19\x2f\xc7\x82\xcd\x1b" |
| "\x47\x53\x11\x1b\x17\x3b\x3b\x05\xd2\x2f\xa0\x80\x86\xe3\xb0" |
| "\xf7\x12\xfc\xc7\xc7\x1a\x55\x7e\x2d\xb9\x66\xc3\xe9\xfa\x91" |
| "\x74\x60\x39"; |
| b.inLen = strlen(b.input); |
| b.outLen = strlen(b.output); |
| |
| test_sha[0] = a; |
| test_sha[1] = b; |
| |
| InitSha384(&sha); |
| |
| for (i = 0; i < times; ++i) { |
| Sha384Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen); |
| Sha384Final(&sha, hash); |
| |
| if (memcmp(hash, test_sha[i].output, SHA384_DIGEST_SIZE) != 0) |
| return -10 - i; |
| } |
| |
| return 0; |
| } |
| #endif |
| |
| #ifdef CYASSL_RIPEMD |
| int ripemd_test(void) |
| { |
| RipeMd ripemd; |
| byte hash[RIPEMD_DIGEST_SIZE]; |
| |
| testVector a, b, c, d; |
| testVector test_ripemd[4]; |
| int times = sizeof(test_ripemd) / sizeof(struct testVector), i; |
| |
| a.input = "abc"; |
| a.output = "\x8e\xb2\x08\xf7\xe0\x5d\x98\x7a\x9b\x04\x4a\x8e\x98\xc6" |
| "\xb0\x87\xf1\x5a\x0b\xfc"; |
| a.inLen = strlen(a.input); |
| a.outLen = strlen(a.output); |
| |
| b.input = "message digest"; |
| b.output = "\x5d\x06\x89\xef\x49\xd2\xfa\xe5\x72\xb8\x81\xb1\x23\xa8" |
| "\x5f\xfa\x21\x59\x5f\x36"; |
| b.inLen = strlen(b.input); |
| b.outLen = strlen(b.output); |
| |
| c.input = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; |
| c.output = "\x12\xa0\x53\x38\x4a\x9c\x0c\x88\xe4\x05\xa0\x6c\x27\xdc" |
| "\xf4\x9a\xda\x62\xeb\x2b"; |
| c.inLen = strlen(c.input); |
| c.outLen = strlen(c.output); |
| |
| d.input = "12345678901234567890123456789012345678901234567890123456" |
| "789012345678901234567890"; |
| d.output = "\x9b\x75\x2e\x45\x57\x3d\x4b\x39\xf4\xdb\xd3\x32\x3c\xab" |
| "\x82\xbf\x63\x32\x6b\xfb"; |
| d.inLen = strlen(d.input); |
| d.outLen = strlen(d.output); |
| |
| test_ripemd[0] = a; |
| test_ripemd[1] = b; |
| test_ripemd[2] = c; |
| test_ripemd[3] = d; |
| |
| InitRipeMd(&ripemd); |
| |
| for (i = 0; i < times; ++i) { |
| RipeMdUpdate(&ripemd, (byte*)test_ripemd[i].input, |
| (word32)test_ripemd[i].inLen); |
| RipeMdFinal(&ripemd, hash); |
| |
| if (memcmp(hash, test_ripemd[i].output, RIPEMD_DIGEST_SIZE) != 0) |
| return -10 - i; |
| } |
| |
| return 0; |
| } |
| #endif /* CYASSL_RIPEMD */ |
| |
| #ifndef NO_HMAC |
| int hmac_test(void) |
| { |
| Hmac hmac; |
| byte hash[MD5_DIGEST_SIZE]; |
| |
| const char* keys[]= |
| { |
| "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b", |
| "Jefe", |
| "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA" |
| }; |
| |
| testVector a, b, c; |
| testVector test_hmac[3]; |
| |
| int times = sizeof(test_hmac) / sizeof(testVector), i; |
| |
| a.input = "Hi There"; |
| a.output = "\x92\x94\x72\x7a\x36\x38\xbb\x1c\x13\xf4\x8e\xf8\x15\x8b\xfc" |
| "\x9d"; |
| a.inLen = strlen(a.input); |
| a.outLen = strlen(a.output); |
| |
| b.input = "what do ya want for nothing?"; |
| b.output = "\x75\x0c\x78\x3e\x6a\xb0\xb5\x03\xea\xa8\x6e\x31\x0a\x5d\xb7" |
| "\x38"; |
| b.inLen = strlen(b.input); |
| b.outLen = strlen(b.output); |
| |
| c.input = "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" |
| "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" |
| "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD" |
| "\xDD\xDD\xDD\xDD\xDD\xDD"; |
| c.output = "\x56\xbe\x34\x52\x1d\x14\x4c\x88\xdb\xb8\xc7\x33\xf0\xe8\xb3" |
| "\xf6"; |
| c.inLen = strlen(c.input); |
| c.outLen = strlen(c.output); |
| |
| test_hmac[0] = a; |
| test_hmac[1] = b; |
| test_hmac[2] = c; |
| |
| for (i = 0; i < times; ++i) { |
| HmacSetKey(&hmac, MD5, (byte*)keys[i], (word32)strlen(keys[i])); |
| HmacUpdate(&hmac, (byte*)test_hmac[i].input, |
| (word32)test_hmac[i].inLen); |
| HmacFinal(&hmac, hash); |
| |
| if (memcmp(hash, test_hmac[i].output, MD5_DIGEST_SIZE) != 0) |
| return -20 - i; |
| } |
| |
| return 0; |
| } |
| #endif |
| |
