Imported Upstream version 3.10.2+dfsg
This commit is contained in:
Mario Fetka
4
tests/CONF_FILES_README.md
Normal file
4
tests/CONF_FILES_README.md
Normal file
@@ -0,0 +1,4 @@
|
||||
suites.c is a dynamicically written program where new test cases can be written
|
||||
and added to as needed. When creating a new configure file for a test be sure
|
||||
to use the exact formatting as the existing configure files. Reference test.conf
|
||||
for an example.
|
||||
1
tests/README
Normal file
1
tests/README
Normal file
@@ -0,0 +1 @@
|
||||
Before creating any new configure files (.conf) read the CONF_FILES_README.md
|
||||
3091
tests/api.c
Normal file
3091
tests/api.c
Normal file
File diff suppressed because it is too large
Load Diff
993
tests/hash.c
Normal file
993
tests/hash.c
Normal file
@@ -0,0 +1,993 @@
|
||||
/* hash.c has unit tests
|
||||
*
|
||||
* Copyright (C) 2006-2016 wolfSSL Inc.
|
||||
*
|
||||
* This file is part of wolfSSL.
|
||||
*
|
||||
* wolfSSL 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.
|
||||
*
|
||||
* wolfSSL 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include <wolfssl/wolfcrypt/md4.h>
|
||||
#include <wolfssl/wolfcrypt/md5.h>
|
||||
#include <wolfssl/wolfcrypt/sha.h>
|
||||
#include <wolfssl/wolfcrypt/sha256.h>
|
||||
#include <wolfssl/wolfcrypt/sha512.h>
|
||||
#include <wolfssl/wolfcrypt/ripemd.h>
|
||||
#include <wolfssl/wolfcrypt/hmac.h>
|
||||
|
||||
#include <tests/unit.h>
|
||||
|
||||
typedef struct testVector {
|
||||
const char* input;
|
||||
const char* output;
|
||||
size_t inLen;
|
||||
size_t outLen;
|
||||
} testVector;
|
||||
|
||||
int md4_test(void);
|
||||
int md5_test(void);
|
||||
int sha_test(void);
|
||||
int sha224_test(void);
|
||||
int sha256_test(void);
|
||||
int sha512_test(void);
|
||||
int sha384_test(void);
|
||||
int ripemd_test(void);
|
||||
int hmac_md5_test(void);
|
||||
int hmac_sha_test(void);
|
||||
int hmac_sha224_test(void);
|
||||
int hmac_sha256_test(void);
|
||||
int hmac_sha384_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
|
||||
|
||||
#ifndef NO_MD5
|
||||
if ( (ret = md5_test()) ) {
|
||||
printf( " MD5 test failed!\n");
|
||||
return ret;
|
||||
} else
|
||||
printf( " MD5 test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifndef NO_SHA
|
||||
if ( (ret = sha_test()) ) {
|
||||
printf( " SHA test failed!\n");
|
||||
return ret;
|
||||
} else
|
||||
printf( " SHA test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifdef WOLFSSL_SHA224
|
||||
if ( (ret = sha224_test()) ) {
|
||||
printf( " SHA-224 test failed!\n");
|
||||
return ret;
|
||||
} else
|
||||
printf( " SHA-224 test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifndef NO_SHA256
|
||||
if ( (ret = sha256_test()) ) {
|
||||
printf( " SHA-256 test failed!\n");
|
||||
return ret;
|
||||
} else
|
||||
printf( " SHA-256 test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifdef WOLFSSL_SHA512
|
||||
if ( (ret = sha512_test()) ) {
|
||||
printf( " SHA-512 test failed!\n");
|
||||
return ret;
|
||||
} else
|
||||
printf( " SHA-512 test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifdef WOLFSSL_SHA384
|
||||
if ( (ret = sha384_test()) ) {
|
||||
printf( " SHA-384 test failed!\n");
|
||||
return ret;
|
||||
} else
|
||||
printf( " SHA-384 test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifdef WOLFSSL_RIPEMD
|
||||
if ( (ret = ripemd_test()) ) {
|
||||
printf( " RIPEMD test failed!\n");
|
||||
return ret;
|
||||
} else
|
||||
printf( " RIPEMD test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifndef NO_HMAC
|
||||
#ifndef NO_MD5
|
||||
if ( (ret = hmac_md5_test()) ) {
|
||||
printf( " HMAC-MD5 test failed!\n");
|
||||
return ret;
|
||||
} else
|
||||
printf( " HMAC-MD5 test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifndef NO_SHA
|
||||
if ( (ret = hmac_sha_test()) )
|
||||
printf( " HMAC-SHA test failed!\n");
|
||||
else
|
||||
printf( " HMAC-SHA test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifdef WOLFSSL_SHA224
|
||||
if ( (ret = hmac_sha224_test()) )
|
||||
printf( " HMAC-SHA224 test failed!\n");
|
||||
else
|
||||
printf( " HMAC-SHA224 test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifndef NO_SHA256
|
||||
if ( (ret = hmac_sha256_test()) )
|
||||
printf( " HMAC-SHA256 test failed!\n");
|
||||
else
|
||||
printf( " HMAC-SHA256 test passed!\n");
|
||||
#endif
|
||||
|
||||
#ifdef WOLFSSL_SHA384
|
||||
if ( (ret = hmac_sha384_test()) )
|
||||
printf( " HMAC-SHA384 test failed!\n");
|
||||
else
|
||||
printf( " HMAC-SHA384 test passed!\n");
|
||||
#endif
|
||||
#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 = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(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 = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(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 = XSTRLEN(c.input);
|
||||
c.outLen = XSTRLEN(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 = XSTRLEN(d.input);
|
||||
d.outLen = XSTRLEN(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 = XSTRLEN(e.input);
|
||||
e.outLen = XSTRLEN(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 = XSTRLEN(f.input);
|
||||
f.outLen = XSTRLEN(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 = XSTRLEN(g.input);
|
||||
g.outLen = XSTRLEN(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;
|
||||
|
||||
wc_InitMd4(&md4);
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
wc_Md4Update(&md4, (byte*)test_md4[i].input, (word32)test_md4[i].inLen);
|
||||
wc_Md4Final(&md4, hash);
|
||||
|
||||
if (XMEMCMP(hash, test_md4[i].output, MD4_DIGEST_SIZE) != 0)
|
||||
return -205 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* NO_MD4 */
|
||||
|
||||
#ifndef NO_MD5
|
||||
|
||||
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 = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(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 = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(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 = XSTRLEN(c.input);
|
||||
c.outLen = XSTRLEN(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 = XSTRLEN(d.input);
|
||||
d.outLen = XSTRLEN(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 = XSTRLEN(e.input);
|
||||
e.outLen = XSTRLEN(e.output);
|
||||
|
||||
test_md5[0] = a;
|
||||
test_md5[1] = b;
|
||||
test_md5[2] = c;
|
||||
test_md5[3] = d;
|
||||
test_md5[4] = e;
|
||||
|
||||
wc_InitMd5(&md5);
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
wc_Md5Update(&md5, (byte*)test_md5[i].input, (word32)test_md5[i].inLen);
|
||||
wc_Md5Final(&md5, hash);
|
||||
|
||||
if (XMEMCMP(hash, test_md5[i].output, MD5_DIGEST_SIZE) != 0)
|
||||
return -5 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* NO_MD5 */
|
||||
|
||||
#ifndef NO_SHA
|
||||
int sha_test(void)
|
||||
{
|
||||
Sha sha;
|
||||
byte hash[SHA_DIGEST_SIZE];
|
||||
|
||||
testVector a, b, c, d;
|
||||
testVector test_sha[4];
|
||||
int ret = 0;
|
||||
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 = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(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 = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(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 = XSTRLEN(c.input);
|
||||
c.outLen = XSTRLEN(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 = XSTRLEN(d.input);
|
||||
d.outLen = XSTRLEN(d.output);
|
||||
|
||||
test_sha[0] = a;
|
||||
test_sha[1] = b;
|
||||
test_sha[2] = c;
|
||||
test_sha[3] = d;
|
||||
|
||||
ret = wc_InitSha(&sha);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
wc_ShaUpdate(&sha, (byte*)test_sha[i].input, (word32)test_sha[i].inLen);
|
||||
wc_ShaFinal(&sha, hash);
|
||||
|
||||
if (XMEMCMP(hash, test_sha[i].output, SHA_DIGEST_SIZE) != 0)
|
||||
return -10 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif /* NO_SHA */
|
||||
|
||||
#ifdef WOLFSSL_SHA224
|
||||
int sha224_test(void)
|
||||
{
|
||||
Sha224 sha;
|
||||
byte hash[SHA224_DIGEST_SIZE];
|
||||
|
||||
testVector a, b;
|
||||
testVector test_sha[2];
|
||||
int ret;
|
||||
int times = sizeof(test_sha) / sizeof(struct testVector), i;
|
||||
|
||||
a.input = "abc";
|
||||
a.output = "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55"
|
||||
"\xb3\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
a.outLen = SHA224_DIGEST_SIZE;
|
||||
|
||||
b.input = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq";
|
||||
b.output = "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01"
|
||||
"\x50\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
b.outLen = SHA224_DIGEST_SIZE;
|
||||
|
||||
test_sha[0] = a;
|
||||
test_sha[1] = b;
|
||||
|
||||
ret = wc_InitSha224(&sha);
|
||||
if (ret != 0)
|
||||
return -4005;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
ret = wc_Sha224Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
ret = wc_Sha224Final(&sha, hash);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
if (XMEMCMP(hash, test_sha[i].output, SHA224_DIGEST_SIZE) != 0)
|
||||
return -10 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef NO_SHA256
|
||||
int sha256_test(void)
|
||||
{
|
||||
Sha256 sha;
|
||||
byte hash[SHA256_DIGEST_SIZE];
|
||||
|
||||
testVector a, b;
|
||||
testVector test_sha[2];
|
||||
int ret;
|
||||
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 = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(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 = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(b.output);
|
||||
|
||||
test_sha[0] = a;
|
||||
test_sha[1] = b;
|
||||
|
||||
ret = wc_InitSha256(&sha);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
ret = wc_Sha256Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
ret = wc_Sha256Final(&sha, hash);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
if (XMEMCMP(hash, test_sha[i].output, SHA256_DIGEST_SIZE) != 0)
|
||||
return -10 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef WOLFSSL_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;
|
||||
int ret;
|
||||
|
||||
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 = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(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 = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(b.output);
|
||||
|
||||
test_sha[0] = a;
|
||||
test_sha[1] = b;
|
||||
|
||||
ret = wc_InitSha512(&sha);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
ret = wc_Sha512Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
ret = wc_Sha512Final(&sha, hash);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
if (XMEMCMP(hash, test_sha[i].output, SHA512_DIGEST_SIZE) != 0)
|
||||
return -10 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef WOLFSSL_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;
|
||||
int ret;
|
||||
|
||||
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 = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(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 = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(b.output);
|
||||
|
||||
test_sha[0] = a;
|
||||
test_sha[1] = b;
|
||||
|
||||
ret = wc_InitSha384(&sha);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
ret = wc_Sha384Update(&sha, (byte*)test_sha[i].input,(word32)test_sha[i].inLen);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
ret = wc_Sha384Final(&sha, hash);
|
||||
if (ret != 0)
|
||||
return ret;
|
||||
|
||||
if (XMEMCMP(hash, test_sha[i].output, SHA384_DIGEST_SIZE) != 0)
|
||||
return -10 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef WOLFSSL_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 = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(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 = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(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 = XSTRLEN(c.input);
|
||||
c.outLen = XSTRLEN(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 = XSTRLEN(d.input);
|
||||
d.outLen = XSTRLEN(d.output);
|
||||
|
||||
test_ripemd[0] = a;
|
||||
test_ripemd[1] = b;
|
||||
test_ripemd[2] = c;
|
||||
test_ripemd[3] = d;
|
||||
|
||||
wc_InitRipeMd(&ripemd);
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
wc_RipeMdUpdate(&ripemd, (byte*)test_ripemd[i].input,
|
||||
(word32)test_ripemd[i].inLen);
|
||||
wc_RipeMdFinal(&ripemd, hash);
|
||||
|
||||
if (XMEMCMP(hash, test_ripemd[i].output, RIPEMD_DIGEST_SIZE) != 0)
|
||||
return -10 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif /* WOLFSSL_RIPEMD */
|
||||
|
||||
#if !defined(NO_HMAC) && !defined(NO_MD5)
|
||||
int hmac_md5_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 ret;
|
||||
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 = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(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 = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(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 = XSTRLEN(c.input);
|
||||
c.outLen = XSTRLEN(c.output);
|
||||
|
||||
test_hmac[0] = a;
|
||||
test_hmac[1] = b;
|
||||
test_hmac[2] = c;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
#if defined(HAVE_FIPS)
|
||||
if (i == 1)
|
||||
continue; /* fips not allowed */
|
||||
#endif
|
||||
ret = wc_HmacSetKey(&hmac, MD5, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
|
||||
if (ret != 0)
|
||||
return -4014;
|
||||
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
|
||||
(word32)test_hmac[i].inLen);
|
||||
if (ret != 0)
|
||||
return -4015;
|
||||
ret = wc_HmacFinal(&hmac, hash);
|
||||
if (ret != 0)
|
||||
return -4016;
|
||||
|
||||
if (XMEMCMP(hash, test_hmac[i].output, MD5_DIGEST_SIZE) != 0)
|
||||
return -20 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(NO_HMAC) && !defined(NO_SHA)
|
||||
int hmac_sha_test(void)
|
||||
{
|
||||
Hmac hmac;
|
||||
byte hash[SHA_DIGEST_SIZE];
|
||||
|
||||
const char* keys[]=
|
||||
{
|
||||
"\x0b\x0b\x0b\x0b\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\xAA"
|
||||
"\xAA\xAA\xAA"
|
||||
};
|
||||
|
||||
testVector a, b, c;
|
||||
testVector test_hmac[3];
|
||||
|
||||
int ret;
|
||||
int times = sizeof(test_hmac) / sizeof(testVector), i;
|
||||
|
||||
a.input = "Hi There";
|
||||
a.output = "\xb6\x17\x31\x86\x55\x05\x72\x64\xe2\x8b\xc0\xb6\xfb\x37\x8c"
|
||||
"\x8e\xf1\x46\xbe\x00";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(a.output);
|
||||
|
||||
b.input = "what do ya want for nothing?";
|
||||
b.output = "\xef\xfc\xdf\x6a\xe5\xeb\x2f\xa2\xd2\x74\x16\xd5\xf1\x84\xdf"
|
||||
"\x9c\x25\x9a\x7c\x79";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(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 = "\x12\x5d\x73\x42\xb9\xac\x11\xcd\x91\xa3\x9a\xf4\x8a\xa1\x7b"
|
||||
"\x4f\x63\xf1\x75\xd3";
|
||||
c.inLen = XSTRLEN(c.input);
|
||||
c.outLen = XSTRLEN(c.output);
|
||||
|
||||
test_hmac[0] = a;
|
||||
test_hmac[1] = b;
|
||||
test_hmac[2] = c;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
#if defined(HAVE_FIPS)
|
||||
if (i == 1)
|
||||
continue; /* fips not allowed */
|
||||
#endif
|
||||
ret = wc_HmacSetKey(&hmac, SHA, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
|
||||
if (ret != 0)
|
||||
return -4017;
|
||||
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
|
||||
(word32)test_hmac[i].inLen);
|
||||
if (ret != 0)
|
||||
return -4018;
|
||||
ret = wc_HmacFinal(&hmac, hash);
|
||||
if (ret != 0)
|
||||
return -4019;
|
||||
|
||||
if (XMEMCMP(hash, test_hmac[i].output, SHA_DIGEST_SIZE) != 0)
|
||||
return -20 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(NO_HMAC) && defined(WOLFSSL_SHA224)
|
||||
int hmac_sha224_test(void)
|
||||
{
|
||||
Hmac hmac;
|
||||
byte hash[SHA224_DIGEST_SIZE];
|
||||
|
||||
const char* keys[]=
|
||||
{
|
||||
"\x0b\x0b\x0b\x0b\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\xAA"
|
||||
"\xAA\xAA\xAA"
|
||||
};
|
||||
|
||||
testVector a, b, c;
|
||||
testVector test_hmac[3];
|
||||
|
||||
int ret;
|
||||
int times = sizeof(test_hmac) / sizeof(testVector), i;
|
||||
|
||||
a.input = "Hi There";
|
||||
a.output = "\x89\x6f\xb1\x12\x8a\xbb\xdf\x19\x68\x32\x10\x7c\xd4\x9d\xf3"
|
||||
"\x3f\x47\xb4\xb1\x16\x99\x12\xba\x4f\x53\x68\x4b\x22";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
a.outLen = SHA224_DIGEST_SIZE;
|
||||
|
||||
b.input = "what do ya want for nothing?";
|
||||
b.output = "\xa3\x0e\x01\x09\x8b\xc6\xdb\xbf\x45\x69\x0f\x3a\x7e\x9e\x6d"
|
||||
"\x0f\x8b\xbe\xa2\xa3\x9e\x61\x48\x00\x8f\xd0\x5e\x44";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
b.outLen = SHA224_DIGEST_SIZE;
|
||||
|
||||
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 = "\x7f\xb3\xcb\x35\x88\xc6\xc1\xf6\xff\xa9\x69\x4d\x7d\x6a\xd2"
|
||||
"\x64\x93\x65\xb0\xc1\xf6\x5d\x69\xd1\xec\x83\x33\xea";
|
||||
c.inLen = XSTRLEN(c.input);
|
||||
c.outLen = SHA224_DIGEST_SIZE;
|
||||
|
||||
test_hmac[0] = a;
|
||||
test_hmac[1] = b;
|
||||
test_hmac[2] = c;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
#if defined(HAVE_FIPS) || defined(HAVE_CAVIUM)
|
||||
if (i == 1)
|
||||
continue; /* cavium can't handle short keys, fips not allowed */
|
||||
#endif
|
||||
ret = wc_HmacSetKey(&hmac, SHA224, (byte*)keys[i],(word32)XSTRLEN(keys[i]));
|
||||
if (ret != 0)
|
||||
return -4021;
|
||||
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
|
||||
(word32)test_hmac[i].inLen);
|
||||
if (ret != 0)
|
||||
return -4022;
|
||||
ret = wc_HmacFinal(&hmac, hash);
|
||||
if (ret != 0)
|
||||
return -4023;
|
||||
|
||||
if (XMEMCMP(hash, test_hmac[i].output, SHA224_DIGEST_SIZE) != 0)
|
||||
return -20 - i;
|
||||
#ifdef WOLFSSL_ASYNC_CRYPT
|
||||
wc_HmacAsyncFree(&hmac);
|
||||
#endif
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if !defined(NO_HMAC) && !defined(NO_SHA256)
|
||||
int hmac_sha256_test(void)
|
||||
{
|
||||
Hmac hmac;
|
||||
byte hash[SHA256_DIGEST_SIZE];
|
||||
|
||||
const char* keys[]=
|
||||
{
|
||||
"\x0b\x0b\x0b\x0b\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\xAA"
|
||||
"\xAA\xAA\xAA"
|
||||
};
|
||||
|
||||
testVector a, b, c;
|
||||
testVector test_hmac[3];
|
||||
|
||||
int ret;
|
||||
int times = sizeof(test_hmac) / sizeof(testVector), i;
|
||||
|
||||
a.input = "Hi There";
|
||||
a.output = "\xb0\x34\x4c\x61\xd8\xdb\x38\x53\x5c\xa8\xaf\xce\xaf\x0b\xf1"
|
||||
"\x2b\x88\x1d\xc2\x00\xc9\x83\x3d\xa7\x26\xe9\x37\x6c\x2e\x32"
|
||||
"\xcf\xf7";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(a.output);
|
||||
|
||||
b.input = "what do ya want for nothing?";
|
||||
b.output = "\x5b\xdc\xc1\x46\xbf\x60\x75\x4e\x6a\x04\x24\x26\x08\x95\x75"
|
||||
"\xc7\x5a\x00\x3f\x08\x9d\x27\x39\x83\x9d\xec\x58\xb9\x64\xec"
|
||||
"\x38\x43";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(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 = "\x77\x3e\xa9\x1e\x36\x80\x0e\x46\x85\x4d\xb8\xeb\xd0\x91\x81"
|
||||
"\xa7\x29\x59\x09\x8b\x3e\xf8\xc1\x22\xd9\x63\x55\x14\xce\xd5"
|
||||
"\x65\xfe";
|
||||
c.inLen = XSTRLEN(c.input);
|
||||
c.outLen = XSTRLEN(c.output);
|
||||
|
||||
test_hmac[0] = a;
|
||||
test_hmac[1] = b;
|
||||
test_hmac[2] = c;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
#if defined(HAVE_FIPS)
|
||||
if (i == 1)
|
||||
continue; /* fips not allowed */
|
||||
#endif
|
||||
ret = wc_HmacSetKey(&hmac,SHA256, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
|
||||
if (ret != 0)
|
||||
return -4020;
|
||||
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
|
||||
(word32)test_hmac[i].inLen);
|
||||
if (ret != 0)
|
||||
return -4021;
|
||||
ret = wc_HmacFinal(&hmac, hash);
|
||||
if (ret != 0)
|
||||
return -4022;
|
||||
|
||||
if (XMEMCMP(hash, test_hmac[i].output, SHA256_DIGEST_SIZE) != 0)
|
||||
return -20 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if !defined(NO_HMAC) && defined(WOLFSSL_SHA384)
|
||||
int hmac_sha384_test(void)
|
||||
{
|
||||
Hmac hmac;
|
||||
byte hash[SHA384_DIGEST_SIZE];
|
||||
|
||||
const char* keys[]=
|
||||
{
|
||||
"\x0b\x0b\x0b\x0b\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\xAA"
|
||||
"\xAA\xAA\xAA"
|
||||
};
|
||||
|
||||
testVector a, b, c;
|
||||
testVector test_hmac[3];
|
||||
|
||||
int ret;
|
||||
int times = sizeof(test_hmac) / sizeof(testVector), i;
|
||||
|
||||
a.input = "Hi There";
|
||||
a.output = "\xaf\xd0\x39\x44\xd8\x48\x95\x62\x6b\x08\x25\xf4\xab\x46\x90"
|
||||
"\x7f\x15\xf9\xda\xdb\xe4\x10\x1e\xc6\x82\xaa\x03\x4c\x7c\xeb"
|
||||
"\xc5\x9c\xfa\xea\x9e\xa9\x07\x6e\xde\x7f\x4a\xf1\x52\xe8\xb2"
|
||||
"\xfa\x9c\xb6";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
a.outLen = XSTRLEN(a.output);
|
||||
|
||||
b.input = "what do ya want for nothing?";
|
||||
b.output = "\xaf\x45\xd2\xe3\x76\x48\x40\x31\x61\x7f\x78\xd2\xb5\x8a\x6b"
|
||||
"\x1b\x9c\x7e\xf4\x64\xf5\xa0\x1b\x47\xe4\x2e\xc3\x73\x63\x22"
|
||||
"\x44\x5e\x8e\x22\x40\xca\x5e\x69\xe2\xc7\x8b\x32\x39\xec\xfa"
|
||||
"\xb2\x16\x49";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
b.outLen = XSTRLEN(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 = "\x88\x06\x26\x08\xd3\xe6\xad\x8a\x0a\xa2\xac\xe0\x14\xc8\xa8"
|
||||
"\x6f\x0a\xa6\x35\xd9\x47\xac\x9f\xeb\xe8\x3e\xf4\xe5\x59\x66"
|
||||
"\x14\x4b\x2a\x5a\xb3\x9d\xc1\x38\x14\xb9\x4e\x3a\xb6\xe1\x01"
|
||||
"\xa3\x4f\x27";
|
||||
c.inLen = XSTRLEN(c.input);
|
||||
c.outLen = XSTRLEN(c.output);
|
||||
|
||||
test_hmac[0] = a;
|
||||
test_hmac[1] = b;
|
||||
test_hmac[2] = c;
|
||||
|
||||
for (i = 0; i < times; ++i) {
|
||||
#if defined(HAVE_FIPS)
|
||||
if (i == 1)
|
||||
continue; /* fips not allowed */
|
||||
#endif
|
||||
ret = wc_HmacSetKey(&hmac,SHA384, (byte*)keys[i], (word32)XSTRLEN(keys[i]));
|
||||
if (ret != 0)
|
||||
return -4023;
|
||||
ret = wc_HmacUpdate(&hmac, (byte*)test_hmac[i].input,
|
||||
(word32)test_hmac[i].inLen);
|
||||
if (ret != 0)
|
||||
return -4024;
|
||||
ret = wc_HmacFinal(&hmac, hash);
|
||||
if (ret != 0)
|
||||
return -4025;
|
||||
|
||||
if (XMEMCMP(hash, test_hmac[i].output, SHA384_DIGEST_SIZE) != 0)
|
||||
return -20 - i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
28
tests/include.am
Normal file
28
tests/include.am
Normal file
@@ -0,0 +1,28 @@
|
||||
# vim:ft=automake
|
||||
# included from Top Level Makefile.am
|
||||
# All paths should be given relative to the root
|
||||
|
||||
|
||||
if BUILD_TESTS
|
||||
check_PROGRAMS += tests/unit.test
|
||||
noinst_PROGRAMS += tests/unit.test
|
||||
tests_unit_test_SOURCES = \
|
||||
tests/unit.c \
|
||||
tests/api.c \
|
||||
tests/suites.c \
|
||||
tests/hash.c \
|
||||
tests/srp.c \
|
||||
examples/client/client.c \
|
||||
examples/server/server.c
|
||||
tests_unit_test_CFLAGS = -DNO_MAIN_DRIVER $(AM_CFLAGS)
|
||||
tests_unit_test_LDADD = src/libwolfssl.la $(LIB_STATIC_ADD)
|
||||
tests_unit_test_DEPENDENCIES = src/libwolfssl.la
|
||||
endif
|
||||
EXTRA_DIST += tests/unit.h
|
||||
EXTRA_DIST += tests/test.conf \
|
||||
tests/test-qsh.conf \
|
||||
tests/test-psk-no-id.conf \
|
||||
tests/test-dtls.conf \
|
||||
tests/test-sctp.conf \
|
||||
tests/test-sig.conf
|
||||
DISTCLEANFILES+= tests/.libs/unit.test
|
||||
697
tests/srp.c
Normal file
697
tests/srp.c
Normal file
@@ -0,0 +1,697 @@
|
||||
/* srp.c SRP unit tests
|
||||
*
|
||||
* Copyright (C) 2006-2016 wolfSSL Inc.
|
||||
*
|
||||
* This file is part of wolfSSL.
|
||||
*
|
||||
* wolfSSL 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.
|
||||
*
|
||||
* wolfSSL 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#include <tests/unit.h>
|
||||
#include <wolfssl/wolfcrypt/sha512.h>
|
||||
#include <wolfssl/wolfcrypt/srp.h>
|
||||
|
||||
#if defined(WOLFCRYPT_HAVE_SRP) && defined(WOLFSSL_SHA512)
|
||||
|
||||
static byte username[] = "user";
|
||||
static word32 usernameSz = 4;
|
||||
|
||||
static byte password[] = "password";
|
||||
static word32 passwordSz = 8;
|
||||
|
||||
static byte N[] = {
|
||||
0xD4, 0xC7, 0xF8, 0xA2, 0xB3, 0x2C, 0x11, 0xB8, 0xFB, 0xA9, 0x58, 0x1E,
|
||||
0xC4, 0xBA, 0x4F, 0x1B, 0x04, 0x21, 0x56, 0x42, 0xEF, 0x73, 0x55, 0xE3,
|
||||
0x7C, 0x0F, 0xC0, 0x44, 0x3E, 0xF7, 0x56, 0xEA, 0x2C, 0x6B, 0x8E, 0xEB,
|
||||
0x75, 0x5A, 0x1C, 0x72, 0x30, 0x27, 0x66, 0x3C, 0xAA, 0x26, 0x5E, 0xF7,
|
||||
0x85, 0xB8, 0xFF, 0x6A, 0x9B, 0x35, 0x22, 0x7A, 0x52, 0xD8, 0x66, 0x33,
|
||||
0xDB, 0xDF, 0xCA, 0x43
|
||||
};
|
||||
|
||||
static byte g[] = {
|
||||
0x02
|
||||
};
|
||||
|
||||
static byte salt[] = {
|
||||
0x80, 0x66, 0x61, 0x5B, 0x7D, 0x33, 0xA2, 0x2E, 0x79, 0x18
|
||||
};
|
||||
|
||||
static byte verifier[] = {
|
||||
0x24, 0x5F, 0xA5, 0x1B, 0x2A, 0x28, 0xF8, 0xFF, 0xE2, 0xA0, 0xF8, 0x61,
|
||||
0x7B, 0x0F, 0x3C, 0x05, 0xD6, 0x4A, 0x55, 0xDF, 0x74, 0x31, 0x54, 0x47,
|
||||
0xA1, 0xFA, 0x9D, 0x25, 0x7B, 0x02, 0x88, 0x0A, 0xE8, 0x5A, 0xBA, 0x8B,
|
||||
0xA2, 0xD3, 0x8A, 0x62, 0x46, 0x8C, 0xEC, 0x52, 0xBE, 0xDE, 0xFC, 0x75,
|
||||
0xF5, 0xDB, 0x9C, 0x8C, 0x9B, 0x34, 0x7A, 0xE7, 0x4A, 0x5F, 0xBB, 0x96,
|
||||
0x38, 0x19, 0xAB, 0x24
|
||||
};
|
||||
|
||||
static byte a[] = {
|
||||
0x37, 0x95, 0xF2, 0xA6, 0xF1, 0x6F, 0x0D, 0x58, 0xBF, 0xED, 0x44, 0x87,
|
||||
0xE0, 0xB6, 0xCC, 0x1C, 0xA0, 0x50, 0xC6, 0x61, 0xBB, 0x36, 0xE0, 0x9A,
|
||||
0xF3, 0xF7, 0x1E, 0x7A, 0x61, 0x86, 0x5A, 0xF5
|
||||
};
|
||||
|
||||
static byte A[] = {
|
||||
0x8D, 0x28, 0xC5, 0x6A, 0x46, 0x5C, 0x82, 0xDB, 0xC7, 0xF6, 0x8B, 0x62,
|
||||
0x1A, 0xAD, 0xA1, 0x76, 0x1B, 0x55, 0xFF, 0xAB, 0x10, 0x2F, 0xFF, 0x4A,
|
||||
0xAA, 0x46, 0xAD, 0x33, 0x64, 0xDE, 0x28, 0x2E, 0x82, 0x7A, 0xBE, 0xEA,
|
||||
0x32, 0xFC, 0xD6, 0x14, 0x01, 0x71, 0xE6, 0xC8, 0xC9, 0x53, 0x69, 0x55,
|
||||
0xE1, 0xF8, 0x3D, 0xDD, 0xC7, 0xD5, 0x21, 0xCE, 0xFF, 0x17, 0xFC, 0x23,
|
||||
0xBF, 0xCF, 0x2D, 0xB0
|
||||
};
|
||||
|
||||
static byte b[] = {
|
||||
0x2B, 0xDD, 0x30, 0x30, 0x53, 0xAF, 0xD8, 0x3A, 0xE7, 0xE0, 0x17, 0x82,
|
||||
0x39, 0x44, 0x2C, 0xDB, 0x30, 0x88, 0x0F, 0xC8, 0x88, 0xC2, 0xB2, 0xC1,
|
||||
0x78, 0x43, 0x2F, 0xD5, 0x60, 0xD4, 0xDA, 0x43
|
||||
};
|
||||
|
||||
static byte B[] = {
|
||||
0xB5, 0x80, 0x36, 0x7F, 0x50, 0x89, 0xC1, 0x04, 0x42, 0x98, 0xD7, 0x6A,
|
||||
0x37, 0x8E, 0xF1, 0x81, 0x52, 0xC5, 0x7A, 0xA1, 0xD5, 0xB7, 0x66, 0x84,
|
||||
0xA1, 0x3E, 0x32, 0x82, 0x2B, 0x3A, 0xB5, 0xD7, 0x3D, 0x50, 0xF1, 0x58,
|
||||
0xBD, 0x89, 0x75, 0xC7, 0x51, 0xCF, 0x6C, 0x03, 0xD4, 0xCA, 0xD5, 0x6E,
|
||||
0x97, 0x4D, 0xA3, 0x1E, 0x19, 0x0B, 0xF0, 0xAA, 0x7D, 0x14, 0x90, 0x80,
|
||||
0x0E, 0xC7, 0x92, 0xAD
|
||||
};
|
||||
|
||||
static byte key[] = {
|
||||
0x66, 0x00, 0x9D, 0x58, 0xB3, 0xD2, 0x0D, 0x4B, 0x69, 0x7F, 0xCF, 0x48,
|
||||
0xFF, 0x8F, 0x15, 0x81, 0x4C, 0x4B, 0xFE, 0x9D, 0x85, 0x77, 0x88, 0x60,
|
||||
0x1D, 0x1E, 0x51, 0xCF, 0x75, 0xCC, 0x58, 0x00, 0xE7, 0x8D, 0x22, 0x87,
|
||||
0x13, 0x6C, 0x88, 0x55
|
||||
};
|
||||
|
||||
static byte client_proof[] = {
|
||||
0x0D, 0x49, 0xE1, 0x9C, 0x3A, 0x88, 0x43, 0x15, 0x45, 0xA8, 0xAC, 0xAB,
|
||||
0xEA, 0x15, 0x1A, 0xEE, 0xF9, 0x38, 0x4D, 0x21
|
||||
};
|
||||
|
||||
static byte server_proof[] = {
|
||||
0xBD, 0xB1, 0x20, 0x70, 0x46, 0xC9, 0xD6, 0xCC, 0xE2, 0x1D, 0x75, 0xA2,
|
||||
0xD0, 0xAF, 0xC5, 0xBC, 0xAE, 0x12, 0xFC, 0x75
|
||||
};
|
||||
|
||||
static void test_SrpInit(void)
|
||||
{
|
||||
Srp srp;
|
||||
|
||||
/* invalid params */
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpInit(NULL, SRP_TYPE_SHA, SRP_CLIENT_SIDE));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpInit(&srp, (SrpType)255, SRP_CLIENT_SIDE));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpInit(&srp, SRP_TYPE_SHA, (SrpSide)255));
|
||||
|
||||
/* success */
|
||||
AssertIntEQ(0, wc_SrpInit(&srp, SRP_TYPE_SHA, SRP_CLIENT_SIDE));
|
||||
|
||||
wc_SrpTerm(&srp);
|
||||
}
|
||||
|
||||
static void test_SrpSetUsername(void)
|
||||
{
|
||||
Srp srp;
|
||||
|
||||
AssertIntEQ(0, wc_SrpInit(&srp, SRP_TYPE_SHA, SRP_CLIENT_SIDE));
|
||||
|
||||
/* invalid params */
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetUsername(NULL, username, usernameSz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetUsername(&srp, NULL, usernameSz));
|
||||
|
||||
/* success */
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&srp, username, usernameSz));
|
||||
AssertIntEQ((int) usernameSz, srp.userSz);
|
||||
AssertIntEQ(0, XMEMCMP(srp.user, username, usernameSz));
|
||||
|
||||
wc_SrpTerm(&srp);
|
||||
}
|
||||
|
||||
static void test_SrpSetParams(void)
|
||||
{
|
||||
Srp srp;
|
||||
|
||||
AssertIntEQ(0, wc_SrpInit(&srp, SRP_TYPE_SHA, SRP_CLIENT_SIDE));
|
||||
|
||||
/* invalid call order */
|
||||
AssertIntEQ(SRP_CALL_ORDER_E, wc_SrpSetParams(&srp, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
|
||||
/* fix call order */
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&srp, username, usernameSz));
|
||||
|
||||
/* invalid params */
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetParams(NULL, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetParams(&srp, NULL, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetParams(&srp, N, sizeof(N),
|
||||
NULL, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetParams(&srp, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
NULL, sizeof(salt)));
|
||||
|
||||
/* success */
|
||||
AssertIntEQ(0, wc_SrpSetParams(&srp, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
|
||||
AssertIntEQ(sizeof(salt), srp.saltSz);
|
||||
AssertIntEQ(0, XMEMCMP(srp.salt, salt, srp.saltSz));
|
||||
|
||||
wc_SrpTerm(&srp);
|
||||
}
|
||||
|
||||
static void test_SrpSetPassword(void)
|
||||
{
|
||||
Srp srp;
|
||||
byte v[64];
|
||||
word32 vSz = 0;
|
||||
|
||||
AssertIntEQ(0, wc_SrpInit(&srp, SRP_TYPE_SHA, SRP_CLIENT_SIDE));
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&srp, username, usernameSz));
|
||||
|
||||
/* invalid call order */
|
||||
AssertIntEQ(SRP_CALL_ORDER_E,
|
||||
wc_SrpSetPassword(&srp, password, passwordSz));
|
||||
AssertIntEQ(SRP_CALL_ORDER_E,
|
||||
wc_SrpGetVerifier(&srp, v, &vSz));
|
||||
|
||||
/* fix call order */
|
||||
AssertIntEQ(0, wc_SrpSetParams(&srp, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
|
||||
/* invalid params */
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetPassword(NULL, password, passwordSz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetPassword(&srp, NULL, passwordSz));
|
||||
|
||||
/* success */
|
||||
AssertIntEQ(0, wc_SrpSetPassword(&srp, password, passwordSz));
|
||||
|
||||
/* invalid params */
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpGetVerifier(NULL, v, &vSz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpGetVerifier(&srp, NULL, &vSz));
|
||||
AssertIntEQ(BUFFER_E, wc_SrpGetVerifier(&srp, v, &vSz));
|
||||
|
||||
/* success */
|
||||
vSz = sizeof(v);
|
||||
AssertIntEQ(0, wc_SrpGetVerifier(&srp, v, &vSz));
|
||||
AssertIntEQ(vSz, sizeof(verifier));
|
||||
AssertIntEQ(0, XMEMCMP(verifier, v, vSz));
|
||||
|
||||
/* invalid params - client side srp */
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetVerifier(&srp, v, vSz));
|
||||
|
||||
wc_SrpTerm(&srp);
|
||||
AssertIntEQ(0, wc_SrpInit(&srp, SRP_TYPE_SHA, SRP_SERVER_SIDE));
|
||||
|
||||
/* invalid params */
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetVerifier(NULL, v, vSz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpSetVerifier(&srp, NULL, vSz));
|
||||
|
||||
/* success */
|
||||
AssertIntEQ(0, wc_SrpSetVerifier(&srp, v, vSz));
|
||||
|
||||
wc_SrpTerm(&srp);
|
||||
}
|
||||
|
||||
static void test_SrpGetPublic(void)
|
||||
{
|
||||
Srp srp;
|
||||
byte pub[64];
|
||||
word32 pubSz = 0;
|
||||
|
||||
AssertIntEQ(0, wc_SrpInit(&srp, SRP_TYPE_SHA, SRP_CLIENT_SIDE));
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&srp, username, usernameSz));
|
||||
AssertIntEQ(0, wc_SrpSetParams(&srp, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
|
||||
/* invalid call order */
|
||||
AssertIntEQ(SRP_CALL_ORDER_E, wc_SrpGetPublic(&srp, pub, &pubSz));
|
||||
|
||||
/* fix call order */
|
||||
AssertIntEQ(0, wc_SrpSetPassword(&srp, password, passwordSz));
|
||||
|
||||
/* invalid params */
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpGetPublic(NULL, pub, &pubSz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpGetPublic(&srp, NULL, &pubSz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpGetPublic(&srp, pub, NULL));
|
||||
AssertIntEQ(BUFFER_E, wc_SrpGetPublic(&srp, pub, &pubSz));
|
||||
|
||||
/* success */
|
||||
pubSz = sizeof(pub);
|
||||
AssertIntEQ(0, wc_SrpSetPrivate(&srp, a, sizeof(a)));
|
||||
AssertIntEQ(0, wc_SrpGetPublic(&srp, pub, &pubSz));
|
||||
AssertIntEQ(pubSz, sizeof(A));
|
||||
AssertIntEQ(0, XMEMCMP(pub, A, pubSz));
|
||||
|
||||
wc_SrpTerm(&srp);
|
||||
|
||||
AssertIntEQ(0, wc_SrpInit(&srp, SRP_TYPE_SHA, SRP_SERVER_SIDE));
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&srp, username, usernameSz));
|
||||
AssertIntEQ(0, wc_SrpSetParams(&srp, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
|
||||
/* invalid call order */
|
||||
AssertIntEQ(SRP_CALL_ORDER_E, wc_SrpGetPublic(&srp, pub, &pubSz));
|
||||
|
||||
/* fix call order */
|
||||
AssertIntEQ(0, wc_SrpSetVerifier(&srp, verifier, sizeof(verifier)));
|
||||
|
||||
/* success */
|
||||
AssertIntEQ(0, wc_SrpSetPrivate(&srp, b, sizeof(b)));
|
||||
AssertIntEQ(0, wc_SrpGetPublic(&srp, pub, &pubSz));
|
||||
AssertIntEQ(pubSz, sizeof(B));
|
||||
AssertIntEQ(0, XMEMCMP(pub, B, pubSz));
|
||||
|
||||
wc_SrpTerm(&srp);
|
||||
}
|
||||
|
||||
static void test_SrpComputeKey(void)
|
||||
{
|
||||
Srp cli, srv;
|
||||
byte clientPubKey[64];
|
||||
byte serverPubKey[64];
|
||||
word32 clientPubKeySz = 64;
|
||||
word32 serverPubKeySz = 64;
|
||||
|
||||
AssertIntEQ(0, wc_SrpInit(&cli, SRP_TYPE_SHA, SRP_CLIENT_SIDE));
|
||||
AssertIntEQ(0, wc_SrpInit(&srv, SRP_TYPE_SHA, SRP_SERVER_SIDE));
|
||||
|
||||
/* invalid call order */
|
||||
AssertIntEQ(SRP_CALL_ORDER_E, wc_SrpComputeKey(&cli,
|
||||
clientPubKey, clientPubKeySz,
|
||||
serverPubKey, serverPubKeySz));
|
||||
|
||||
/* fix call order */
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&cli, username, usernameSz));
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&srv, username, usernameSz));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetParams(&cli, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
AssertIntEQ(0, wc_SrpSetParams(&srv, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetPassword(&cli, password, passwordSz));
|
||||
AssertIntEQ(0, wc_SrpSetVerifier(&srv, verifier, sizeof(verifier)));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetPrivate(&cli, a, sizeof(a)));
|
||||
AssertIntEQ(0, wc_SrpGetPublic(&cli, clientPubKey, &clientPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(clientPubKey, A, clientPubKeySz));
|
||||
AssertIntEQ(0, wc_SrpSetPrivate(&srv, b, sizeof(b)));
|
||||
AssertIntEQ(0, wc_SrpGetPublic(&srv, serverPubKey, &serverPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(serverPubKey, B, serverPubKeySz));
|
||||
|
||||
/* invalid params */
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpComputeKey(NULL,
|
||||
clientPubKey, clientPubKeySz,
|
||||
serverPubKey, serverPubKeySz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpComputeKey(&cli,
|
||||
NULL, clientPubKeySz,
|
||||
serverPubKey, serverPubKeySz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpComputeKey(&cli,
|
||||
clientPubKey, 0,
|
||||
serverPubKey, serverPubKeySz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpComputeKey(&cli,
|
||||
clientPubKey, clientPubKeySz,
|
||||
NULL, serverPubKeySz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpComputeKey(&cli,
|
||||
clientPubKey, clientPubKeySz,
|
||||
serverPubKey, 0));
|
||||
|
||||
/* success */
|
||||
AssertIntEQ(0, wc_SrpComputeKey(&cli, clientPubKey, clientPubKeySz,
|
||||
serverPubKey, serverPubKeySz));
|
||||
AssertIntEQ(0, wc_SrpComputeKey(&srv, clientPubKey, clientPubKeySz,
|
||||
serverPubKey, serverPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(cli.key, key, sizeof(key)));
|
||||
AssertIntEQ(0, XMEMCMP(srv.key, key, sizeof(key)));
|
||||
|
||||
wc_SrpTerm(&cli);
|
||||
wc_SrpTerm(&srv);
|
||||
}
|
||||
|
||||
static void test_SrpGetProofAndVerify(void)
|
||||
{
|
||||
Srp cli, srv;
|
||||
byte clientPubKey[64];
|
||||
byte serverPubKey[64];
|
||||
word32 clientPubKeySz = 64;
|
||||
word32 serverPubKeySz = 64;
|
||||
byte clientProof[SRP_MAX_DIGEST_SIZE];
|
||||
byte serverProof[SRP_MAX_DIGEST_SIZE];
|
||||
word32 clientProofSz = SRP_MAX_DIGEST_SIZE;
|
||||
word32 serverProofSz = SRP_MAX_DIGEST_SIZE;
|
||||
|
||||
AssertIntEQ(0, wc_SrpInit(&cli, SRP_TYPE_SHA, SRP_CLIENT_SIDE));
|
||||
AssertIntEQ(0, wc_SrpInit(&srv, SRP_TYPE_SHA, SRP_SERVER_SIDE));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&cli, username, usernameSz));
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&srv, username, usernameSz));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetParams(&cli, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
AssertIntEQ(0, wc_SrpSetParams(&srv, N, sizeof(N),
|
||||
g, sizeof(g),
|
||||
salt, sizeof(salt)));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetPassword(&cli, password, passwordSz));
|
||||
AssertIntEQ(0, wc_SrpSetVerifier(&srv, verifier, sizeof(verifier)));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetPrivate(&cli, a, sizeof(a)));
|
||||
AssertIntEQ(0, wc_SrpGetPublic(&cli, clientPubKey, &clientPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(clientPubKey, A, clientPubKeySz));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetPrivate(&srv, b, sizeof(b)));
|
||||
AssertIntEQ(0, wc_SrpGetPublic(&srv, serverPubKey, &serverPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(serverPubKey, B, serverPubKeySz));
|
||||
|
||||
AssertIntEQ(0, wc_SrpComputeKey(&cli, clientPubKey, clientPubKeySz,
|
||||
serverPubKey, serverPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(cli.key, key, sizeof(key)));
|
||||
|
||||
AssertIntEQ(0, wc_SrpComputeKey(&srv, clientPubKey, clientPubKeySz,
|
||||
serverPubKey, serverPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(srv.key, key, sizeof(key)));
|
||||
|
||||
/* invalid params */
|
||||
serverProofSz = 0;
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpGetProof(NULL, clientProof,&clientProofSz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpGetProof(&cli, NULL, &clientProofSz));
|
||||
AssertIntEQ(BAD_FUNC_ARG, wc_SrpGetProof(&cli, clientProof,NULL));
|
||||
AssertIntEQ(BUFFER_E, wc_SrpGetProof(&srv, serverProof,&serverProofSz));
|
||||
|
||||
AssertIntEQ(BAD_FUNC_ARG,
|
||||
wc_SrpVerifyPeersProof(NULL, clientProof, clientProofSz));
|
||||
AssertIntEQ(BAD_FUNC_ARG,
|
||||
wc_SrpVerifyPeersProof(&cli, NULL, clientProofSz));
|
||||
AssertIntEQ(BUFFER_E,
|
||||
wc_SrpVerifyPeersProof(&srv, serverProof, serverProofSz));
|
||||
serverProofSz = SRP_MAX_DIGEST_SIZE;
|
||||
|
||||
/* success */
|
||||
AssertIntEQ(0, wc_SrpGetProof(&cli, clientProof, &clientProofSz));
|
||||
AssertIntEQ(0, XMEMCMP(clientProof, client_proof, sizeof(client_proof)));
|
||||
AssertIntEQ(0, wc_SrpVerifyPeersProof(&srv, clientProof, clientProofSz));
|
||||
AssertIntEQ(0, wc_SrpGetProof(&srv, serverProof, &serverProofSz));
|
||||
AssertIntEQ(0, XMEMCMP(serverProof, server_proof, sizeof(server_proof)));
|
||||
AssertIntEQ(0, wc_SrpVerifyPeersProof(&cli, serverProof, serverProofSz));
|
||||
|
||||
wc_SrpTerm(&cli);
|
||||
wc_SrpTerm(&srv);
|
||||
}
|
||||
|
||||
static int sha512_key_gen(Srp* srp, byte* secret, word32 size)
|
||||
{
|
||||
Sha512 hash;
|
||||
int r;
|
||||
|
||||
srp->key = (byte*)XMALLOC(SHA512_DIGEST_SIZE, NULL, DYNAMIC_TYPE_SRP);
|
||||
if (srp->key == NULL)
|
||||
return MEMORY_E;
|
||||
|
||||
srp->keySz = SHA512_DIGEST_SIZE;
|
||||
|
||||
r = wc_InitSha512(&hash);
|
||||
if (!r) r = wc_Sha512Update(&hash, secret, size);
|
||||
if (!r) r = wc_Sha512Final(&hash, srp->key);
|
||||
|
||||
XMEMSET(&hash, 0, sizeof(Sha512));
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static void test_SrpKeyGenFunc_cb(void)
|
||||
{
|
||||
Srp cli, srv;
|
||||
byte clientPubKey[1024];
|
||||
byte serverPubKey[1024];
|
||||
word32 clientPubKeySz = 1024;
|
||||
word32 serverPubKeySz = 1024;
|
||||
byte clientProof[SRP_MAX_DIGEST_SIZE];
|
||||
byte serverProof[SRP_MAX_DIGEST_SIZE];
|
||||
word32 clientProofSz = SRP_MAX_DIGEST_SIZE;
|
||||
word32 serverProofSz = SRP_MAX_DIGEST_SIZE;
|
||||
|
||||
byte username_[] = "alice";
|
||||
word32 usernameSz_ = 5;
|
||||
|
||||
byte password_[] = "password123";
|
||||
word32 passwordSz_ = 11;
|
||||
|
||||
byte N_[] = {
|
||||
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC9, 0x0F, 0xDA, 0xA2,
|
||||
0x21, 0x68, 0xC2, 0x34, 0xC4, 0xC6, 0x62, 0x8B, 0x80, 0xDC, 0x1C, 0xD1,
|
||||
0x29, 0x02, 0x4E, 0x08, 0x8A, 0x67, 0xCC, 0x74, 0x02, 0x0B, 0xBE, 0xA6,
|
||||
0x3B, 0x13, 0x9B, 0x22, 0x51, 0x4A, 0x08, 0x79, 0x8E, 0x34, 0x04, 0xDD,
|
||||
0xEF, 0x95, 0x19, 0xB3, 0xCD, 0x3A, 0x43, 0x1B, 0x30, 0x2B, 0x0A, 0x6D,
|
||||
0xF2, 0x5F, 0x14, 0x37, 0x4F, 0xE1, 0x35, 0x6D, 0x6D, 0x51, 0xC2, 0x45,
|
||||
0xE4, 0x85, 0xB5, 0x76, 0x62, 0x5E, 0x7E, 0xC6, 0xF4, 0x4C, 0x42, 0xE9,
|
||||
0xA6, 0x37, 0xED, 0x6B, 0x0B, 0xFF, 0x5C, 0xB6, 0xF4, 0x06, 0xB7, 0xED,
|
||||
0xEE, 0x38, 0x6B, 0xFB, 0x5A, 0x89, 0x9F, 0xA5, 0xAE, 0x9F, 0x24, 0x11,
|
||||
0x7C, 0x4B, 0x1F, 0xE6, 0x49, 0x28, 0x66, 0x51, 0xEC, 0xE4, 0x5B, 0x3D,
|
||||
0xC2, 0x00, 0x7C, 0xB8, 0xA1, 0x63, 0xBF, 0x05, 0x98, 0xDA, 0x48, 0x36,
|
||||
0x1C, 0x55, 0xD3, 0x9A, 0x69, 0x16, 0x3F, 0xA8, 0xFD, 0x24, 0xCF, 0x5F,
|
||||
0x83, 0x65, 0x5D, 0x23, 0xDC, 0xA3, 0xAD, 0x96, 0x1C, 0x62, 0xF3, 0x56,
|
||||
0x20, 0x85, 0x52, 0xBB, 0x9E, 0xD5, 0x29, 0x07, 0x70, 0x96, 0x96, 0x6D,
|
||||
0x67, 0x0C, 0x35, 0x4E, 0x4A, 0xBC, 0x98, 0x04, 0xF1, 0x74, 0x6C, 0x08,
|
||||
0xCA, 0x18, 0x21, 0x7C, 0x32, 0x90, 0x5E, 0x46, 0x2E, 0x36, 0xCE, 0x3B,
|
||||
0xE3, 0x9E, 0x77, 0x2C, 0x18, 0x0E, 0x86, 0x03, 0x9B, 0x27, 0x83, 0xA2,
|
||||
0xEC, 0x07, 0xA2, 0x8F, 0xB5, 0xC5, 0x5D, 0xF0, 0x6F, 0x4C, 0x52, 0xC9,
|
||||
0xDE, 0x2B, 0xCB, 0xF6, 0x95, 0x58, 0x17, 0x18, 0x39, 0x95, 0x49, 0x7C,
|
||||
0xEA, 0x95, 0x6A, 0xE5, 0x15, 0xD2, 0x26, 0x18, 0x98, 0xFA, 0x05, 0x10,
|
||||
0x15, 0x72, 0x8E, 0x5A, 0x8A, 0xAA, 0xC4, 0x2D, 0xAD, 0x33, 0x17, 0x0D,
|
||||
0x04, 0x50, 0x7A, 0x33, 0xA8, 0x55, 0x21, 0xAB, 0xDF, 0x1C, 0xBA, 0x64,
|
||||
0xEC, 0xFB, 0x85, 0x04, 0x58, 0xDB, 0xEF, 0x0A, 0x8A, 0xEA, 0x71, 0x57,
|
||||
0x5D, 0x06, 0x0C, 0x7D, 0xB3, 0x97, 0x0F, 0x85, 0xA6, 0xE1, 0xE4, 0xC7,
|
||||
0xAB, 0xF5, 0xAE, 0x8C, 0xDB, 0x09, 0x33, 0xD7, 0x1E, 0x8C, 0x94, 0xE0,
|
||||
0x4A, 0x25, 0x61, 0x9D, 0xCE, 0xE3, 0xD2, 0x26, 0x1A, 0xD2, 0xEE, 0x6B,
|
||||
0xF1, 0x2F, 0xFA, 0x06, 0xD9, 0x8A, 0x08, 0x64, 0xD8, 0x76, 0x02, 0x73,
|
||||
0x3E, 0xC8, 0x6A, 0x64, 0x52, 0x1F, 0x2B, 0x18, 0x17, 0x7B, 0x20, 0x0C,
|
||||
0xBB, 0xE1, 0x17, 0x57, 0x7A, 0x61, 0x5D, 0x6C, 0x77, 0x09, 0x88, 0xC0,
|
||||
0xBA, 0xD9, 0x46, 0xE2, 0x08, 0xE2, 0x4F, 0xA0, 0x74, 0xE5, 0xAB, 0x31,
|
||||
0x43, 0xDB, 0x5B, 0xFC, 0xE0, 0xFD, 0x10, 0x8E, 0x4B, 0x82, 0xD1, 0x20,
|
||||
0xA9, 0x3A, 0xD2, 0xCA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
|
||||
};
|
||||
|
||||
byte g_[] = {
|
||||
0x05
|
||||
};
|
||||
|
||||
byte salt_[] = {
|
||||
0xBE, 0xB2, 0x53, 0x79, 0xD1, 0xA8, 0x58, 0x1E, 0xB5, 0xA7, 0x27, 0x67,
|
||||
0x3A, 0x24, 0x41, 0xEE
|
||||
};
|
||||
|
||||
byte verifier_[] = {
|
||||
0x9B, 0x5E, 0x06, 0x17, 0x01, 0xEA, 0x7A, 0xEB, 0x39, 0xCF, 0x6E, 0x35,
|
||||
0x19, 0x65, 0x5A, 0x85, 0x3C, 0xF9, 0x4C, 0x75, 0xCA, 0xF2, 0x55, 0x5E,
|
||||
0xF1, 0xFA, 0xF7, 0x59, 0xBB, 0x79, 0xCB, 0x47, 0x70, 0x14, 0xE0, 0x4A,
|
||||
0x88, 0xD6, 0x8F, 0xFC, 0x05, 0x32, 0x38, 0x91, 0xD4, 0xC2, 0x05, 0xB8,
|
||||
0xDE, 0x81, 0xC2, 0xF2, 0x03, 0xD8, 0xFA, 0xD1, 0xB2, 0x4D, 0x2C, 0x10,
|
||||
0x97, 0x37, 0xF1, 0xBE, 0xBB, 0xD7, 0x1F, 0x91, 0x24, 0x47, 0xC4, 0xA0,
|
||||
0x3C, 0x26, 0xB9, 0xFA, 0xD8, 0xED, 0xB3, 0xE7, 0x80, 0x77, 0x8E, 0x30,
|
||||
0x25, 0x29, 0xED, 0x1E, 0xE1, 0x38, 0xCC, 0xFC, 0x36, 0xD4, 0xBA, 0x31,
|
||||
0x3C, 0xC4, 0x8B, 0x14, 0xEA, 0x8C, 0x22, 0xA0, 0x18, 0x6B, 0x22, 0x2E,
|
||||
0x65, 0x5F, 0x2D, 0xF5, 0x60, 0x3F, 0xD7, 0x5D, 0xF7, 0x6B, 0x3B, 0x08,
|
||||
0xFF, 0x89, 0x50, 0x06, 0x9A, 0xDD, 0x03, 0xA7, 0x54, 0xEE, 0x4A, 0xE8,
|
||||
0x85, 0x87, 0xCC, 0xE1, 0xBF, 0xDE, 0x36, 0x79, 0x4D, 0xBA, 0xE4, 0x59,
|
||||
0x2B, 0x7B, 0x90, 0x4F, 0x44, 0x2B, 0x04, 0x1C, 0xB1, 0x7A, 0xEB, 0xAD,
|
||||
0x1E, 0x3A, 0xEB, 0xE3, 0xCB, 0xE9, 0x9D, 0xE6, 0x5F, 0x4B, 0xB1, 0xFA,
|
||||
0x00, 0xB0, 0xE7, 0xAF, 0x06, 0x86, 0x3D, 0xB5, 0x3B, 0x02, 0x25, 0x4E,
|
||||
0xC6, 0x6E, 0x78, 0x1E, 0x3B, 0x62, 0xA8, 0x21, 0x2C, 0x86, 0xBE, 0xB0,
|
||||
0xD5, 0x0B, 0x5B, 0xA6, 0xD0, 0xB4, 0x78, 0xD8, 0xC4, 0xE9, 0xBB, 0xCE,
|
||||
0xC2, 0x17, 0x65, 0x32, 0x6F, 0xBD, 0x14, 0x05, 0x8D, 0x2B, 0xBD, 0xE2,
|
||||
0xC3, 0x30, 0x45, 0xF0, 0x38, 0x73, 0xE5, 0x39, 0x48, 0xD7, 0x8B, 0x79,
|
||||
0x4F, 0x07, 0x90, 0xE4, 0x8C, 0x36, 0xAE, 0xD6, 0xE8, 0x80, 0xF5, 0x57,
|
||||
0x42, 0x7B, 0x2F, 0xC0, 0x6D, 0xB5, 0xE1, 0xE2, 0xE1, 0xD7, 0xE6, 0x61,
|
||||
0xAC, 0x48, 0x2D, 0x18, 0xE5, 0x28, 0xD7, 0x29, 0x5E, 0xF7, 0x43, 0x72,
|
||||
0x95, 0xFF, 0x1A, 0x72, 0xD4, 0x02, 0x77, 0x17, 0x13, 0xF1, 0x68, 0x76,
|
||||
0xDD, 0x05, 0x0A, 0xE5, 0xB7, 0xAD, 0x53, 0xCC, 0xB9, 0x08, 0x55, 0xC9,
|
||||
0x39, 0x56, 0x64, 0x83, 0x58, 0xAD, 0xFD, 0x96, 0x64, 0x22, 0xF5, 0x24,
|
||||
0x98, 0x73, 0x2D, 0x68, 0xD1, 0xD7, 0xFB, 0xEF, 0x10, 0xD7, 0x80, 0x34,
|
||||
0xAB, 0x8D, 0xCB, 0x6F, 0x0F, 0xCF, 0x88, 0x5C, 0xC2, 0xB2, 0xEA, 0x2C,
|
||||
0x3E, 0x6A, 0xC8, 0x66, 0x09, 0xEA, 0x05, 0x8A, 0x9D, 0xA8, 0xCC, 0x63,
|
||||
0x53, 0x1D, 0xC9, 0x15, 0x41, 0x4D, 0xF5, 0x68, 0xB0, 0x94, 0x82, 0xDD,
|
||||
0xAC, 0x19, 0x54, 0xDE, 0xC7, 0xEB, 0x71, 0x4F, 0x6F, 0xF7, 0xD4, 0x4C,
|
||||
0xD5, 0xB8, 0x6F, 0x6B, 0xD1, 0x15, 0x81, 0x09, 0x30, 0x63, 0x7C, 0x01,
|
||||
0xD0, 0xF6, 0x01, 0x3B, 0xC9, 0x74, 0x0F, 0xA2, 0xC6, 0x33, 0xBA, 0x89
|
||||
};
|
||||
|
||||
byte a_[] = {
|
||||
0x60, 0x97, 0x55, 0x27, 0x03, 0x5C, 0xF2, 0xAD, 0x19, 0x89, 0x80, 0x6F,
|
||||
0x04, 0x07, 0x21, 0x0B, 0xC8, 0x1E, 0xDC, 0x04, 0xE2, 0x76, 0x2A, 0x56,
|
||||
0xAF, 0xD5, 0x29, 0xDD, 0xDA, 0x2D, 0x43, 0x93
|
||||
};
|
||||
|
||||
byte A_[] = {
|
||||
0xFA, 0xB6, 0xF5, 0xD2, 0x61, 0x5D, 0x1E, 0x32, 0x35, 0x12, 0xE7, 0x99,
|
||||
0x1C, 0xC3, 0x74, 0x43, 0xF4, 0x87, 0xDA, 0x60, 0x4C, 0xA8, 0xC9, 0x23,
|
||||
0x0F, 0xCB, 0x04, 0xE5, 0x41, 0xDC, 0xE6, 0x28, 0x0B, 0x27, 0xCA, 0x46,
|
||||
0x80, 0xB0, 0x37, 0x4F, 0x17, 0x9D, 0xC3, 0xBD, 0xC7, 0x55, 0x3F, 0xE6,
|
||||
0x24, 0x59, 0x79, 0x8C, 0x70, 0x1A, 0xD8, 0x64, 0xA9, 0x13, 0x90, 0xA2,
|
||||
0x8C, 0x93, 0xB6, 0x44, 0xAD, 0xBF, 0x9C, 0x00, 0x74, 0x5B, 0x94, 0x2B,
|
||||
0x79, 0xF9, 0x01, 0x2A, 0x21, 0xB9, 0xB7, 0x87, 0x82, 0x31, 0x9D, 0x83,
|
||||
0xA1, 0xF8, 0x36, 0x28, 0x66, 0xFB, 0xD6, 0xF4, 0x6B, 0xFC, 0x0D, 0xDB,
|
||||
0x2E, 0x1A, 0xB6, 0xE4, 0xB4, 0x5A, 0x99, 0x06, 0xB8, 0x2E, 0x37, 0xF0,
|
||||
0x5D, 0x6F, 0x97, 0xF6, 0xA3, 0xEB, 0x6E, 0x18, 0x20, 0x79, 0x75, 0x9C,
|
||||
0x4F, 0x68, 0x47, 0x83, 0x7B, 0x62, 0x32, 0x1A, 0xC1, 0xB4, 0xFA, 0x68,
|
||||
0x64, 0x1F, 0xCB, 0x4B, 0xB9, 0x8D, 0xD6, 0x97, 0xA0, 0xC7, 0x36, 0x41,
|
||||
0x38, 0x5F, 0x4B, 0xAB, 0x25, 0xB7, 0x93, 0x58, 0x4C, 0xC3, 0x9F, 0xC8,
|
||||
0xD4, 0x8D, 0x4B, 0xD8, 0x67, 0xA9, 0xA3, 0xC1, 0x0F, 0x8E, 0xA1, 0x21,
|
||||
0x70, 0x26, 0x8E, 0x34, 0xFE, 0x3B, 0xBE, 0x6F, 0xF8, 0x99, 0x98, 0xD6,
|
||||
0x0D, 0xA2, 0xF3, 0xE4, 0x28, 0x3C, 0xBE, 0xC1, 0x39, 0x3D, 0x52, 0xAF,
|
||||
0x72, 0x4A, 0x57, 0x23, 0x0C, 0x60, 0x4E, 0x9F, 0xBC, 0xE5, 0x83, 0xD7,
|
||||
0x61, 0x3E, 0x6B, 0xFF, 0xD6, 0x75, 0x96, 0xAD, 0x12, 0x1A, 0x87, 0x07,
|
||||
0xEE, 0xC4, 0x69, 0x44, 0x95, 0x70, 0x33, 0x68, 0x6A, 0x15, 0x5F, 0x64,
|
||||
0x4D, 0x5C, 0x58, 0x63, 0xB4, 0x8F, 0x61, 0xBD, 0xBF, 0x19, 0xA5, 0x3E,
|
||||
0xAB, 0x6D, 0xAD, 0x0A, 0x18, 0x6B, 0x8C, 0x15, 0x2E, 0x5F, 0x5D, 0x8C,
|
||||
0xAD, 0x4B, 0x0E, 0xF8, 0xAA, 0x4E, 0xA5, 0x00, 0x88, 0x34, 0xC3, 0xCD,
|
||||
0x34, 0x2E, 0x5E, 0x0F, 0x16, 0x7A, 0xD0, 0x45, 0x92, 0xCD, 0x8B, 0xD2,
|
||||
0x79, 0x63, 0x93, 0x98, 0xEF, 0x9E, 0x11, 0x4D, 0xFA, 0xAA, 0xB9, 0x19,
|
||||
0xE1, 0x4E, 0x85, 0x09, 0x89, 0x22, 0x4D, 0xDD, 0x98, 0x57, 0x6D, 0x79,
|
||||
0x38, 0x5D, 0x22, 0x10, 0x90, 0x2E, 0x9F, 0x9B, 0x1F, 0x2D, 0x86, 0xCF,
|
||||
0xA4, 0x7E, 0xE2, 0x44, 0x63, 0x54, 0x65, 0xF7, 0x10, 0x58, 0x42, 0x1A,
|
||||
0x01, 0x84, 0xBE, 0x51, 0xDD, 0x10, 0xCC, 0x9D, 0x07, 0x9E, 0x6F, 0x16,
|
||||
0x04, 0xE7, 0xAA, 0x9B, 0x7C, 0xF7, 0x88, 0x3C, 0x7D, 0x4C, 0xE1, 0x2B,
|
||||
0x06, 0xEB, 0xE1, 0x60, 0x81, 0xE2, 0x3F, 0x27, 0xA2, 0x31, 0xD1, 0x84,
|
||||
0x32, 0xD7, 0xD1, 0xBB, 0x55, 0xC2, 0x8A, 0xE2, 0x1F, 0xFC, 0xF0, 0x05,
|
||||
0xF5, 0x75, 0x28, 0xD1, 0x5A, 0x88, 0x88, 0x1B, 0xB3, 0xBB, 0xB7, 0xFE
|
||||
};
|
||||
|
||||
byte b_[] = {
|
||||
0xE4, 0x87, 0xCB, 0x59, 0xD3, 0x1A, 0xC5, 0x50, 0x47, 0x1E, 0x81, 0xF0,
|
||||
0x0F, 0x69, 0x28, 0xE0, 0x1D, 0xDA, 0x08, 0xE9, 0x74, 0xA0, 0x04, 0xF4,
|
||||
0x9E, 0x61, 0xF5, 0xD1, 0x05, 0x28, 0x4D, 0x20
|
||||
};
|
||||
|
||||
byte B_[] = {
|
||||
0x40, 0xF5, 0x70, 0x88, 0xA4, 0x82, 0xD4, 0xC7, 0x73, 0x33, 0x84, 0xFE,
|
||||
0x0D, 0x30, 0x1F, 0xDD, 0xCA, 0x90, 0x80, 0xAD, 0x7D, 0x4F, 0x6F, 0xDF,
|
||||
0x09, 0xA0, 0x10, 0x06, 0xC3, 0xCB, 0x6D, 0x56, 0x2E, 0x41, 0x63, 0x9A,
|
||||
0xE8, 0xFA, 0x21, 0xDE, 0x3B, 0x5D, 0xBA, 0x75, 0x85, 0xB2, 0x75, 0x58,
|
||||
0x9B, 0xDB, 0x27, 0x98, 0x63, 0xC5, 0x62, 0x80, 0x7B, 0x2B, 0x99, 0x08,
|
||||
0x3C, 0xD1, 0x42, 0x9C, 0xDB, 0xE8, 0x9E, 0x25, 0xBF, 0xBD, 0x7E, 0x3C,
|
||||
0xAD, 0x31, 0x73, 0xB2, 0xE3, 0xC5, 0xA0, 0xB1, 0x74, 0xDA, 0x6D, 0x53,
|
||||
0x91, 0xE6, 0xA0, 0x6E, 0x46, 0x5F, 0x03, 0x7A, 0x40, 0x06, 0x25, 0x48,
|
||||
0x39, 0xA5, 0x6B, 0xF7, 0x6D, 0xA8, 0x4B, 0x1C, 0x94, 0xE0, 0xAE, 0x20,
|
||||
0x85, 0x76, 0x15, 0x6F, 0xE5, 0xC1, 0x40, 0xA4, 0xBA, 0x4F, 0xFC, 0x9E,
|
||||
0x38, 0xC3, 0xB0, 0x7B, 0x88, 0x84, 0x5F, 0xC6, 0xF7, 0xDD, 0xDA, 0x93,
|
||||
0x38, 0x1F, 0xE0, 0xCA, 0x60, 0x84, 0xC4, 0xCD, 0x2D, 0x33, 0x6E, 0x54,
|
||||
0x51, 0xC4, 0x64, 0xCC, 0xB6, 0xEC, 0x65, 0xE7, 0xD1, 0x6E, 0x54, 0x8A,
|
||||
0x27, 0x3E, 0x82, 0x62, 0x84, 0xAF, 0x25, 0x59, 0xB6, 0x26, 0x42, 0x74,
|
||||
0x21, 0x59, 0x60, 0xFF, 0xF4, 0x7B, 0xDD, 0x63, 0xD3, 0xAF, 0xF0, 0x64,
|
||||
0xD6, 0x13, 0x7A, 0xF7, 0x69, 0x66, 0x1C, 0x9D, 0x4F, 0xEE, 0x47, 0x38,
|
||||
0x26, 0x03, 0xC8, 0x8E, 0xAA, 0x09, 0x80, 0x58, 0x1D, 0x07, 0x75, 0x84,
|
||||
0x61, 0xB7, 0x77, 0xE4, 0x35, 0x6D, 0xDA, 0x58, 0x35, 0x19, 0x8B, 0x51,
|
||||
0xFE, 0xEA, 0x30, 0x8D, 0x70, 0xF7, 0x54, 0x50, 0xB7, 0x16, 0x75, 0xC0,
|
||||
0x8C, 0x7D, 0x83, 0x02, 0xFD, 0x75, 0x39, 0xDD, 0x1F, 0xF2, 0xA1, 0x1C,
|
||||
0xB4, 0x25, 0x8A, 0xA7, 0x0D, 0x23, 0x44, 0x36, 0xAA, 0x42, 0xB6, 0xA0,
|
||||
0x61, 0x5F, 0x3F, 0x91, 0x5D, 0x55, 0xCC, 0x3B, 0x96, 0x6B, 0x27, 0x16,
|
||||
0xB3, 0x6E, 0x4D, 0x1A, 0x06, 0xCE, 0x5E, 0x5D, 0x2E, 0xA3, 0xBE, 0xE5,
|
||||
0xA1, 0x27, 0x0E, 0x87, 0x51, 0xDA, 0x45, 0xB6, 0x0B, 0x99, 0x7B, 0x0F,
|
||||
0xFD, 0xB0, 0xF9, 0x96, 0x2F, 0xEE, 0x4F, 0x03, 0xBE, 0xE7, 0x80, 0xBA,
|
||||
0x0A, 0x84, 0x5B, 0x1D, 0x92, 0x71, 0x42, 0x17, 0x83, 0xAE, 0x66, 0x01,
|
||||
0xA6, 0x1E, 0xA2, 0xE3, 0x42, 0xE4, 0xF2, 0xE8, 0xBC, 0x93, 0x5A, 0x40,
|
||||
0x9E, 0xAD, 0x19, 0xF2, 0x21, 0xBD, 0x1B, 0x74, 0xE2, 0x96, 0x4D, 0xD1,
|
||||
0x9F, 0xC8, 0x45, 0xF6, 0x0E, 0xFC, 0x09, 0x33, 0x8B, 0x60, 0xB6, 0xB2,
|
||||
0x56, 0xD8, 0xCA, 0xC8, 0x89, 0xCC, 0xA3, 0x06, 0xCC, 0x37, 0x0A, 0x0B,
|
||||
0x18, 0xC8, 0xB8, 0x86, 0xE9, 0x5D, 0xA0, 0xAF, 0x52, 0x35, 0xFE, 0xF4,
|
||||
0x39, 0x30, 0x20, 0xD2, 0xB7, 0xF3, 0x05, 0x69, 0x04, 0x75, 0x90, 0x42
|
||||
};
|
||||
|
||||
byte key_[] = {
|
||||
0x5C, 0xBC, 0x21, 0x9D, 0xB0, 0x52, 0x13, 0x8E, 0xE1, 0x14, 0x8C, 0x71,
|
||||
0xCD, 0x44, 0x98, 0x96, 0x3D, 0x68, 0x25, 0x49, 0xCE, 0x91, 0xCA, 0x24,
|
||||
0xF0, 0x98, 0x46, 0x8F, 0x06, 0x01, 0x5B, 0xEB, 0x6A, 0xF2, 0x45, 0xC2,
|
||||
0x09, 0x3F, 0x98, 0xC3, 0x65, 0x1B, 0xCA, 0x83, 0xAB, 0x8C, 0xAB, 0x2B,
|
||||
0x58, 0x0B, 0xBF, 0x02, 0x18, 0x4F, 0xEF, 0xDF, 0x26, 0x14, 0x2F, 0x73,
|
||||
0xDF, 0x95, 0xAC, 0x50
|
||||
};
|
||||
|
||||
AssertIntEQ(0, wc_SrpInit(&cli, SRP_TYPE_SHA512, SRP_CLIENT_SIDE));
|
||||
AssertIntEQ(0, wc_SrpInit(&srv, SRP_TYPE_SHA512, SRP_SERVER_SIDE));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&cli, username_, usernameSz_));
|
||||
AssertIntEQ(0, wc_SrpSetUsername(&srv, username_, usernameSz_));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetParams(&cli, N_, sizeof(N_),
|
||||
g_, sizeof(g_),
|
||||
salt_, sizeof(salt_)));
|
||||
AssertIntEQ(0, wc_SrpSetParams(&srv, N_, sizeof(N_),
|
||||
g_, sizeof(g_),
|
||||
salt_, sizeof(salt_)));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetPassword(&cli, password_, passwordSz_));
|
||||
AssertIntEQ(0, wc_SrpSetVerifier(&srv, verifier_, sizeof(verifier_)));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetPrivate(&cli, a_, sizeof(a_)));
|
||||
AssertIntEQ(0, wc_SrpGetPublic(&cli, clientPubKey, &clientPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(clientPubKey, A_, clientPubKeySz));
|
||||
|
||||
AssertIntEQ(0, wc_SrpSetPrivate(&srv, b_, sizeof(b_)));
|
||||
AssertIntEQ(0, wc_SrpGetPublic(&srv, serverPubKey, &serverPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(serverPubKey, B_, serverPubKeySz));
|
||||
|
||||
cli.keyGenFunc_cb = sha512_key_gen;
|
||||
AssertIntEQ(0, wc_SrpComputeKey(&cli, clientPubKey, clientPubKeySz,
|
||||
serverPubKey, serverPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(cli.key, key_, sizeof(key_)));
|
||||
|
||||
srv.keyGenFunc_cb = sha512_key_gen;
|
||||
AssertIntEQ(0, wc_SrpComputeKey(&srv, clientPubKey, clientPubKeySz,
|
||||
serverPubKey, serverPubKeySz));
|
||||
AssertIntEQ(0, XMEMCMP(srv.key, key_, sizeof(key_)));
|
||||
|
||||
AssertIntEQ(0, wc_SrpGetProof(&cli, clientProof, &clientProofSz));
|
||||
AssertIntEQ(0, wc_SrpVerifyPeersProof(&srv, clientProof, clientProofSz));
|
||||
|
||||
AssertIntEQ(0, wc_SrpGetProof(&srv, serverProof, &serverProofSz));
|
||||
AssertIntEQ(0, wc_SrpVerifyPeersProof(&cli, serverProof, serverProofSz));
|
||||
|
||||
wc_SrpTerm(&cli);
|
||||
wc_SrpTerm(&srv);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
void SrpTest(void)
|
||||
{
|
||||
#if defined(WOLFCRYPT_HAVE_SRP) && defined(WOLFSSL_SHA512)
|
||||
test_SrpInit();
|
||||
test_SrpSetUsername();
|
||||
test_SrpSetParams();
|
||||
test_SrpSetPassword();
|
||||
test_SrpGetPublic();
|
||||
test_SrpComputeKey();
|
||||
test_SrpGetProofAndVerify();
|
||||
test_SrpKeyGenFunc_cb();
|
||||
#endif
|
||||
}
|
||||
596
tests/suites.c
Normal file
596
tests/suites.c
Normal file
@@ -0,0 +1,596 @@
|
||||
/* suites.c
|
||||
*
|
||||
* Copyright (C) 2006-2016 wolfSSL Inc.
|
||||
*
|
||||
* This file is part of wolfSSL.
|
||||
*
|
||||
* wolfSSL 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.
|
||||
*
|
||||
* wolfSSL 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <wolfssl/ssl.h>
|
||||
#include <tests/unit.h>
|
||||
|
||||
|
||||
#define MAX_ARGS 40
|
||||
#define MAX_COMMAND_SZ 240
|
||||
#define MAX_SUITE_SZ 80
|
||||
#define NOT_BUILT_IN -123
|
||||
#if defined(NO_OLD_TLS) || !defined(WOLFSSL_ALLOW_SSLV3)
|
||||
#define VERSION_TOO_OLD -124
|
||||
#endif
|
||||
|
||||
#include "examples/client/client.h"
|
||||
#include "examples/server/server.h"
|
||||
|
||||
|
||||
static WOLFSSL_CTX* cipherSuiteCtx = NULL;
|
||||
static char nonblockFlag[] = "-N";
|
||||
static char noVerifyFlag[] = "-d";
|
||||
static char disableEMSFlag[] = "-n";
|
||||
static char flagSep[] = " ";
|
||||
#if !defined(USE_WINDOWS_API) && !defined(WOLFSSL_TIRTOS)
|
||||
static char portFlag[] = "-p";
|
||||
static char svrPort[] = "0";
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef WOLFSSL_ALLOW_SSLV3
|
||||
/* if the protocol version is sslv3 return 1, else 0 */
|
||||
static int IsSslVersion(const char* line)
|
||||
{
|
||||
const char* find = "-v ";
|
||||
const char* begin = strstr(line, find);
|
||||
|
||||
if (begin) {
|
||||
int version = -1;
|
||||
|
||||
begin += 3;
|
||||
|
||||
version = atoi(begin);
|
||||
|
||||
if (version == 0)
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif /* !WOLFSSL_ALLOW_SSLV3 */
|
||||
|
||||
#ifdef NO_OLD_TLS
|
||||
/* if the protocol version is less than tls 1.2 return 1, else 0 */
|
||||
static int IsOldTlsVersion(const char* line)
|
||||
{
|
||||
const char* find = "-v ";
|
||||
const char* begin = strstr(line, find);
|
||||
|
||||
if (begin) {
|
||||
int version = -1;
|
||||
|
||||
begin += 3;
|
||||
|
||||
version = atoi(begin);
|
||||
|
||||
if (version < 3)
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif /* NO_OLD_TLS */
|
||||
|
||||
|
||||
/* if the cipher suite on line is valid store in suite and return 1, else 0 */
|
||||
static int IsValidCipherSuite(const char* line, char* suite)
|
||||
{
|
||||
int found = 0;
|
||||
int valid = 0;
|
||||
|
||||
const char* find = "-l ";
|
||||
const char* begin = strstr(line, find);
|
||||
const char* end;
|
||||
|
||||
suite[0] = '\0';
|
||||
|
||||
if (begin) {
|
||||
begin += 3;
|
||||
|
||||
end = XSTRSTR(begin, " ");
|
||||
|
||||
if (end) {
|
||||
long len = end - begin;
|
||||
if (len > MAX_SUITE_SZ) {
|
||||
printf("suite too long!\n");
|
||||
return 0;
|
||||
}
|
||||
XMEMCPY(suite, begin, len);
|
||||
suite[len] = '\0';
|
||||
}
|
||||
else
|
||||
XSTRNCPY(suite, begin, MAX_SUITE_SZ);
|
||||
|
||||
suite[MAX_SUITE_SZ] = '\0';
|
||||
found = 1;
|
||||
}
|
||||
|
||||
/* if QSH not enabled then do not use QSH suite */
|
||||
#ifdef HAVE_QSH
|
||||
if (XSTRNCMP(suite, "QSH", 3) == 0) {
|
||||
if (wolfSSL_CTX_set_cipher_list(cipherSuiteCtx, suite + 4)
|
||||
!= SSL_SUCCESS)
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (found) {
|
||||
if (wolfSSL_CTX_set_cipher_list(cipherSuiteCtx, suite) == SSL_SUCCESS)
|
||||
valid = 1;
|
||||
}
|
||||
|
||||
return valid;
|
||||
}
|
||||
|
||||
|
||||
static int execute_test_case(int svr_argc, char** svr_argv,
|
||||
int cli_argc, char** cli_argv,
|
||||
int addNoVerify, int addNonBlocking,
|
||||
int addDisableEMS)
|
||||
{
|
||||
#ifdef WOLFSSL_TIRTOS
|
||||
func_args cliArgs = {0};
|
||||
func_args svrArgs = {0};
|
||||
cliArgs.argc = cli_argc;
|
||||
cliArgs.argv = cli_argv;
|
||||
svrArgs.argc = svr_argc;
|
||||
svrArgs.argv = svr_argv;
|
||||
#else
|
||||
func_args cliArgs = {cli_argc, cli_argv, 0, NULL, NULL};
|
||||
func_args svrArgs = {svr_argc, svr_argv, 0, NULL, NULL};
|
||||
#endif
|
||||
|
||||
tcp_ready ready;
|
||||
THREAD_TYPE serverThread;
|
||||
char commandLine[MAX_COMMAND_SZ];
|
||||
char cipherSuite[MAX_SUITE_SZ+1];
|
||||
int i;
|
||||
size_t added = 0;
|
||||
static int tests = 1;
|
||||
|
||||
commandLine[0] = '\0';
|
||||
for (i = 0; i < svr_argc; i++) {
|
||||
added += XSTRLEN(svr_argv[i]) + 2;
|
||||
if (added >= MAX_COMMAND_SZ) {
|
||||
printf("server command line too long\n");
|
||||
break;
|
||||
}
|
||||
strcat(commandLine, svr_argv[i]);
|
||||
strcat(commandLine, flagSep);
|
||||
}
|
||||
|
||||
if (IsValidCipherSuite(commandLine, cipherSuite) == 0) {
|
||||
#ifdef DEBUG_SUITE_TESTS
|
||||
printf("cipher suite %s not supported in build\n", cipherSuite);
|
||||
#endif
|
||||
return NOT_BUILT_IN;
|
||||
}
|
||||
|
||||
#ifndef WOLFSSL_ALLOW_SSLV3
|
||||
if (IsSslVersion(commandLine) == 1) {
|
||||
#ifdef DEBUG_SUITE_TESTS
|
||||
printf("protocol version on line %s is too old\n", commandLine);
|
||||
#endif
|
||||
return VERSION_TOO_OLD;
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef NO_OLD_TLS
|
||||
if (IsOldTlsVersion(commandLine) == 1) {
|
||||
#ifdef DEBUG_SUITE_TESTS
|
||||
printf("protocol version on line %s is too old\n", commandLine);
|
||||
#endif
|
||||
return VERSION_TOO_OLD;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (addNoVerify) {
|
||||
printf("repeating test with client cert request off\n");
|
||||
added += 4; /* -d plus space plus terminator */
|
||||
if (added >= MAX_COMMAND_SZ || svr_argc >= MAX_ARGS)
|
||||
printf("server command line too long\n");
|
||||
else {
|
||||
svr_argv[svr_argc++] = noVerifyFlag;
|
||||
svrArgs.argc = svr_argc;
|
||||
strcat(commandLine, noVerifyFlag);
|
||||
strcat(commandLine, flagSep);
|
||||
}
|
||||
}
|
||||
if (addNonBlocking) {
|
||||
printf("repeating test with non blocking on\n");
|
||||
added += 4; /* -N plus terminator */
|
||||
if (added >= MAX_COMMAND_SZ || svr_argc >= MAX_ARGS)
|
||||
printf("server command line too long\n");
|
||||
else {
|
||||
svr_argv[svr_argc++] = nonblockFlag;
|
||||
svrArgs.argc = svr_argc;
|
||||
strcat(commandLine, nonblockFlag);
|
||||
strcat(commandLine, flagSep);
|
||||
}
|
||||
}
|
||||
#if !defined(USE_WINDOWS_API) && !defined(WOLFSSL_TIRTOS)
|
||||
/* add port 0 */
|
||||
if (svr_argc + 2 > MAX_ARGS)
|
||||
printf("cannot add the magic port number flag to server\n");
|
||||
else
|
||||
{
|
||||
svr_argv[svr_argc++] = portFlag;
|
||||
svr_argv[svr_argc++] = svrPort;
|
||||
svrArgs.argc = svr_argc;
|
||||
}
|
||||
#endif
|
||||
printf("trying server command line[%d]: %s\n", tests, commandLine);
|
||||
|
||||
commandLine[0] = '\0';
|
||||
added = 0;
|
||||
for (i = 0; i < cli_argc; i++) {
|
||||
added += XSTRLEN(cli_argv[i]) + 2;
|
||||
if (added >= MAX_COMMAND_SZ) {
|
||||
printf("client command line too long\n");
|
||||
break;
|
||||
}
|
||||
strcat(commandLine, cli_argv[i]);
|
||||
strcat(commandLine, flagSep);
|
||||
}
|
||||
if (addNonBlocking) {
|
||||
added += 4; /* -N plus space plus terminator */
|
||||
if (added >= MAX_COMMAND_SZ)
|
||||
printf("client command line too long\n");
|
||||
else {
|
||||
cli_argv[cli_argc++] = nonblockFlag;
|
||||
strcat(commandLine, nonblockFlag);
|
||||
strcat(commandLine, flagSep);
|
||||
cliArgs.argc = cli_argc;
|
||||
}
|
||||
}
|
||||
if (addDisableEMS) {
|
||||
printf("repeating test without extended master secret\n");
|
||||
added += 4; /* -n plus terminator */
|
||||
if (added >= MAX_COMMAND_SZ)
|
||||
printf("client command line too long\n");
|
||||
else {
|
||||
cli_argv[cli_argc++] = disableEMSFlag;
|
||||
strcat(commandLine, disableEMSFlag);
|
||||
strcat(commandLine, flagSep);
|
||||
cliArgs.argc = cli_argc;
|
||||
}
|
||||
}
|
||||
printf("trying client command line[%d]: %s\n", tests++, commandLine);
|
||||
|
||||
InitTcpReady(&ready);
|
||||
|
||||
#ifdef WOLFSSL_TIRTOS
|
||||
fdOpenSession(Task_self());
|
||||
#endif
|
||||
|
||||
/* start server */
|
||||
svrArgs.signal = &ready;
|
||||
start_thread(server_test, &svrArgs, &serverThread);
|
||||
wait_tcp_ready(&svrArgs);
|
||||
#if !defined(USE_WINDOWS_API) && !defined(WOLFSSL_TIRTOS)
|
||||
if (ready.port != 0)
|
||||
{
|
||||
if (cli_argc + 2 > MAX_ARGS)
|
||||
printf("cannot add the magic port number flag to client\n");
|
||||
else {
|
||||
char portNumber[8];
|
||||
snprintf(portNumber, sizeof(portNumber), "%d", ready.port);
|
||||
cli_argv[cli_argc++] = portFlag;
|
||||
cli_argv[cli_argc++] = portNumber;
|
||||
cliArgs.argc = cli_argc;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
/* start client */
|
||||
client_test(&cliArgs);
|
||||
|
||||
/* verify results */
|
||||
if (cliArgs.return_code != 0) {
|
||||
printf("client_test failed\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
join_thread(serverThread);
|
||||
if (svrArgs.return_code != 0) {
|
||||
printf("server_test failed\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
#ifdef WOLFSSL_TIRTOS
|
||||
fdCloseSession(Task_self());
|
||||
#endif
|
||||
FreeTcpReady(&ready);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void test_harness(void* vargs)
|
||||
{
|
||||
func_args* args = (func_args*)vargs;
|
||||
char* script;
|
||||
long sz, len;
|
||||
int cliMode = 0; /* server or client command flag, server first */
|
||||
int ret;
|
||||
FILE* file;
|
||||
char* svrArgs[MAX_ARGS];
|
||||
int svrArgsSz;
|
||||
char* cliArgs[MAX_ARGS];
|
||||
int cliArgsSz;
|
||||
char* cursor;
|
||||
char* comment;
|
||||
const char* fname = "tests/test.conf";
|
||||
|
||||
if (args->argc == 1) {
|
||||
printf("notice: using default file %s\n", fname);
|
||||
}
|
||||
else if(args->argc != 2) {
|
||||
printf("usage: harness [FILE]\n");
|
||||
args->return_code = 1;
|
||||
return;
|
||||
}
|
||||
else {
|
||||
fname = args->argv[1];
|
||||
}
|
||||
|
||||
file = fopen(fname, "rb");
|
||||
if (file == NULL) {
|
||||
fprintf(stderr, "unable to open %s\n", fname);
|
||||
args->return_code = 1;
|
||||
return;
|
||||
}
|
||||
fseek(file, 0, SEEK_END);
|
||||
sz = ftell(file);
|
||||
rewind(file);
|
||||
if (sz <= 0) {
|
||||
fprintf(stderr, "%s is empty\n", fname);
|
||||
fclose(file);
|
||||
args->return_code = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
script = (char*)malloc(sz+1);
|
||||
if (script == 0) {
|
||||
fprintf(stderr, "unable to allocte script buffer\n");
|
||||
fclose(file);
|
||||
args->return_code = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
len = fread(script, 1, sz, file);
|
||||
if (len != sz) {
|
||||
fprintf(stderr, "read error\n");
|
||||
fclose(file);
|
||||
free(script);
|
||||
args->return_code = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
fclose(file);
|
||||
script[sz] = 0;
|
||||
|
||||
cursor = script;
|
||||
svrArgsSz = 1;
|
||||
svrArgs[0] = args->argv[0];
|
||||
cliArgsSz = 1;
|
||||
cliArgs[0] = args->argv[0];
|
||||
|
||||
while (*cursor != 0) {
|
||||
int do_it = 0;
|
||||
|
||||
switch (*cursor) {
|
||||
case '\n':
|
||||
/* A blank line triggers test case execution or switches
|
||||
to client mode if we don't have the client command yet */
|
||||
if (cliMode == 0)
|
||||
cliMode = 1; /* switch to client mode processing */
|
||||
else
|
||||
do_it = 1; /* Do It, we have server and client */
|
||||
cursor++;
|
||||
break;
|
||||
case '#':
|
||||
/* Ignore lines that start with a #. */
|
||||
comment = strsep(&cursor, "\n");
|
||||
#ifdef DEBUG_SUITE_TESTS
|
||||
printf("%s\n", comment);
|
||||
#else
|
||||
(void)comment;
|
||||
#endif
|
||||
break;
|
||||
case '-':
|
||||
/* Parameters start with a -. They end in either a newline
|
||||
* or a space. Capture until either, save in Args list. */
|
||||
if (cliMode)
|
||||
cliArgs[cliArgsSz++] = strsep(&cursor, " \n");
|
||||
else
|
||||
svrArgs[svrArgsSz++] = strsep(&cursor, " \n");
|
||||
break;
|
||||
default:
|
||||
/* Anything from cursor until end of line that isn't the above
|
||||
* is data for a paramter. Just up until the next newline in
|
||||
* the Args list. */
|
||||
if (cliMode)
|
||||
cliArgs[cliArgsSz++] = strsep(&cursor, "\n");
|
||||
else
|
||||
svrArgs[svrArgsSz++] = strsep(&cursor, "\n");
|
||||
if (*cursor == 0) /* eof */
|
||||
do_it = 1;
|
||||
}
|
||||
|
||||
if (svrArgsSz == MAX_ARGS || cliArgsSz == MAX_ARGS) {
|
||||
fprintf(stderr, "too many arguments, forcing test run\n");
|
||||
do_it = 1;
|
||||
}
|
||||
|
||||
if (do_it) {
|
||||
ret = execute_test_case(svrArgsSz, svrArgs,
|
||||
cliArgsSz, cliArgs, 0, 0, 0);
|
||||
/* don't repeat if not supported in build */
|
||||
if (ret == 0) {
|
||||
execute_test_case(svrArgsSz, svrArgs,
|
||||
cliArgsSz, cliArgs, 0, 1, 0);
|
||||
execute_test_case(svrArgsSz, svrArgs,
|
||||
cliArgsSz, cliArgs, 1, 0, 0);
|
||||
execute_test_case(svrArgsSz, svrArgs,
|
||||
cliArgsSz, cliArgs, 1, 1, 0);
|
||||
#ifdef HAVE_EXTENDED_MASTER
|
||||
execute_test_case(svrArgsSz, svrArgs,
|
||||
cliArgsSz, cliArgs, 0, 0, 1);
|
||||
execute_test_case(svrArgsSz, svrArgs,
|
||||
cliArgsSz, cliArgs, 0, 1, 1);
|
||||
execute_test_case(svrArgsSz, svrArgs,
|
||||
cliArgsSz, cliArgs, 1, 0, 1);
|
||||
execute_test_case(svrArgsSz, svrArgs,
|
||||
cliArgsSz, cliArgs, 1, 1, 1);
|
||||
#endif
|
||||
}
|
||||
svrArgsSz = 1;
|
||||
cliArgsSz = 1;
|
||||
cliMode = 0;
|
||||
}
|
||||
}
|
||||
|
||||
free(script);
|
||||
args->return_code = 0;
|
||||
}
|
||||
|
||||
|
||||
int SuiteTest(void)
|
||||
{
|
||||
func_args args;
|
||||
char argv0[2][80];
|
||||
char* myArgv[2];
|
||||
|
||||
printf(" Begin Cipher Suite Tests\n");
|
||||
|
||||
/* setup */
|
||||
myArgv[0] = argv0[0];
|
||||
myArgv[1] = argv0[1];
|
||||
args.argv = myArgv;
|
||||
strcpy(argv0[0], "SuiteTest");
|
||||
|
||||
#ifdef WOLFSSL_STATIC_MEMORY
|
||||
byte memory[200000];
|
||||
#endif
|
||||
|
||||
(void)test_harness;
|
||||
|
||||
cipherSuiteCtx = wolfSSL_CTX_new(wolfTLSv1_2_client_method());
|
||||
if (cipherSuiteCtx == NULL) {
|
||||
printf("can't get cipher suite ctx\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* load in static memory buffer if enabled */
|
||||
#ifdef WOLFSSL_STATIC_MEMORY
|
||||
if (wolfSSL_CTX_load_static_memory(&cipherSuiteCtx, NULL,
|
||||
memory, sizeof(memory), 0, 1)
|
||||
!= SSL_SUCCESS) {
|
||||
printf("unable to load static memory and create ctx");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* default case */
|
||||
args.argc = 1;
|
||||
printf("starting default cipher suite tests\n");
|
||||
test_harness(&args);
|
||||
if (args.return_code != 0) {
|
||||
printf("error from script %d\n", args.return_code);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/* any extra cases will need another argument */
|
||||
args.argc = 2;
|
||||
|
||||
#ifdef WOLFSSL_DTLS
|
||||
/* add dtls extra suites */
|
||||
strcpy(argv0[1], "tests/test-dtls.conf");
|
||||
printf("starting dtls extra cipher suite tests\n");
|
||||
test_harness(&args);
|
||||
if (args.return_code != 0) {
|
||||
printf("error from script %d\n", args.return_code);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
#endif
|
||||
#ifdef WOLFSSL_SCTP
|
||||
/* add dtls-sctp extra suites */
|
||||
strcpy(argv0[1], "tests/test-sctp.conf");
|
||||
printf("starting dtls-sctp extra cipher suite tests\n");
|
||||
test_harness(&args);
|
||||
if (args.return_code != 0) {
|
||||
printf("error from script %d\n", args.return_code);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
#endif
|
||||
#ifndef WC_STRICT_SIG
|
||||
#if !defined(NO_RSA) && defined(HAVE_ECC) /* testing mixed ECC/RSA cert */
|
||||
/* add extra signature test suites */
|
||||
strcpy(argv0[1], "tests/test-sig.conf");
|
||||
printf("starting sig extra cipher suite tests\n");
|
||||
test_harness(&args);
|
||||
if (args.return_code != 0) {
|
||||
printf("error from script %d\n", args.return_code);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
#endif /* HAVE_RSA and HAVE_ECC */
|
||||
#endif /* !WC_STRICT_SIG */
|
||||
#ifdef HAVE_QSH
|
||||
/* add QSH extra suites */
|
||||
strcpy(argv0[1], "tests/test-qsh.conf");
|
||||
printf("starting qsh extra cipher suite tests\n");
|
||||
test_harness(&args);
|
||||
if (args.return_code != 0) {
|
||||
printf("error from script %d\n", args.return_code);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef NO_PSK
|
||||
/* add psk extra suites */
|
||||
strcpy(argv0[1], "tests/test-psk-no-id.conf");
|
||||
printf("starting psk no identity extra cipher suite tests\n");
|
||||
test_harness(&args);
|
||||
if (args.return_code != 0) {
|
||||
printf("error from script %d\n", args.return_code);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
#endif
|
||||
|
||||
printf(" End Cipher Suite Tests\n");
|
||||
|
||||
wolfSSL_CTX_free(cipherSuiteCtx);
|
||||
wolfSSL_Cleanup();
|
||||
|
||||
return args.return_code;
|
||||
}
|
||||
|
||||
|
||||
1111
tests/test-dtls.conf
Normal file
1111
tests/test-dtls.conf
Normal file
File diff suppressed because it is too large
Load Diff
253
tests/test-psk-no-id.conf
Normal file
253
tests/test-psk-no-id.conf
Normal file
@@ -0,0 +1,253 @@
|
||||
# No Hint server TLSv1.2 PSK-CHACHA20-POLY1305
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l PSK-CHACHA20-POLY1305
|
||||
|
||||
# No Hint client TLSv1.2 PSK-CHACHA20-POLY1305
|
||||
-s
|
||||
-v 3
|
||||
-l PSK-CHACHA20-POLY1305
|
||||
|
||||
# No Hint server TLSv1.2 DHE-PSK-CHACHA20-POLY1305
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l DHE-PSK-CHACHA20-POLY1305
|
||||
|
||||
# No Hint client TLSv1.2 DHE-PSK-CHACHA20-POLY1305
|
||||
-s
|
||||
-v 3
|
||||
-l DHE-PSK-CHACHA20-POLY1305
|
||||
|
||||
# No Hint server TLSv1.2 ECDHE-PSK-CHACHA20-POLY1305
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l ECDHE-PSK-CHACHA20-POLY1305
|
||||
|
||||
# No Hint client TLSv1.2 ECDHE-PSK-CHACHA20-POLY1305
|
||||
-s
|
||||
-v 3
|
||||
-l ECDHE-PSK-CHACHA20-POLY1305
|
||||
|
||||
# No Hint server TLSv1 ECDHE-PSK-AES128-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 1
|
||||
-l ECDHE-PSK-AES128-SHA256
|
||||
|
||||
# No Hint client TLSv1 ECDHE-PSK-AES128-SHA256
|
||||
-s
|
||||
-v 1
|
||||
-l ECDHE-PSK-AES128-SHA256
|
||||
|
||||
# No Hint server TLSv1.1 ECDHE-PSK-AES128-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 2
|
||||
-l ECDHE-PSK-AES128-SHA256
|
||||
|
||||
# No Hint client TLSv1.1 ECDHE-PSK-AES128-SHA256
|
||||
-s
|
||||
-v 2
|
||||
-l ECDHE-PSK-AES128-SHA256
|
||||
|
||||
# No Hint server TLSv1.2 ECDHE-PSK-AES128-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l ECDHE-PSK-AES128-SHA256
|
||||
|
||||
# No Hint client TLSv1.2 ECDHE-PSK-AES128-SHA256
|
||||
-s
|
||||
-v 3
|
||||
-l ECDHE-PSK-AES128-SHA256
|
||||
|
||||
# No Hint server TLSv1 ECDHE-PSK-NULL-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 1
|
||||
-l ECDHE-PSK-NULL-SHA256
|
||||
|
||||
# No Hint client TLSv1 ECDHE-PSK-NULL-SHA256
|
||||
-s
|
||||
-v 1
|
||||
-l ECDHE-PSK-NULL-SHA256
|
||||
|
||||
# No Hint server TLSv1.1 ECDHE-PSK-NULL-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 2
|
||||
-l ECDHE-PSK-NULL-SHA256
|
||||
|
||||
# No Hint client TLSv1.1 ECDHE-PSK-NULL-SHA256
|
||||
-s
|
||||
-v 2
|
||||
-l ECDHE-PSK-NULL-SHA256
|
||||
|
||||
# No Hint server TLSv1.2 ECDHE-PSK-NULL-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l ECDHE-PSK-NULL-SHA256
|
||||
|
||||
# No Hint client TLSv1.2 ECDHE-PSK-NULL-SHA256
|
||||
-s
|
||||
-v 3
|
||||
-l ECDHE-PSK-NULL-SHA256
|
||||
|
||||
# No Hint server TLSv1 PSK-AES128
|
||||
-s
|
||||
-I
|
||||
-v 1
|
||||
-l PSK-AES128-CBC-SHA
|
||||
|
||||
# No Hint client TLSv1 PSK-AES128
|
||||
-s
|
||||
-v 1
|
||||
-l PSK-AES128-CBC-SHA
|
||||
|
||||
# No Hint server TLSv1 PSK-AES256
|
||||
-s
|
||||
-I
|
||||
-v 1
|
||||
-l PSK-AES256-CBC-SHA
|
||||
|
||||
# No Hint client TLSv1 PSK-AES256
|
||||
-s
|
||||
-v 1
|
||||
-l PSK-AES256-CBC-SHA
|
||||
|
||||
# No Hint server TLSv1.1 PSK-AES128
|
||||
-s
|
||||
-I
|
||||
-v 2
|
||||
-l PSK-AES128-CBC-SHA
|
||||
|
||||
# No Hint client TLSv1.1 PSK-AES128
|
||||
-s
|
||||
-v 2
|
||||
-l PSK-AES128-CBC-SHA
|
||||
|
||||
# No Hint server TLSv1.1 PSK-AES256
|
||||
-s
|
||||
-I
|
||||
-v 2
|
||||
-l PSK-AES256-CBC-SHA
|
||||
|
||||
# No Hint client TLSv1.1 PSK-AES256
|
||||
-s
|
||||
-v 2
|
||||
-l PSK-AES256-CBC-SHA
|
||||
|
||||
# No Hint server TLSv1.2 PSK-AES128
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l PSK-AES128-CBC-SHA
|
||||
|
||||
# No Hint client TLSv1.2 PSK-AES128
|
||||
-s
|
||||
-v 3
|
||||
-l PSK-AES128-CBC-SHA
|
||||
|
||||
# No Hint server TLSv1.2 PSK-AES256
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l PSK-AES256-CBC-SHA
|
||||
|
||||
# No Hint client TLSv1.2 PSK-AES256
|
||||
-s
|
||||
-v 3
|
||||
-l PSK-AES256-CBC-SHA
|
||||
|
||||
# No Hint server TLSv1.0 PSK-AES128-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 1
|
||||
-l PSK-AES128-CBC-SHA256
|
||||
|
||||
# No Hint client TLSv1.0 PSK-AES128-SHA256
|
||||
-s
|
||||
-v 1
|
||||
-l PSK-AES128-CBC-SHA256
|
||||
|
||||
# No Hint server TLSv1.1 PSK-AES128-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 2
|
||||
-l PSK-AES128-CBC-SHA256
|
||||
|
||||
# No Hint client TLSv1.1 PSK-AES128-SHA256
|
||||
-s
|
||||
-v 2
|
||||
-l PSK-AES128-CBC-SHA256
|
||||
|
||||
# No Hint server TLSv1.2 PSK-AES128-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l PSK-AES128-CBC-SHA256
|
||||
|
||||
# No Hint client TLSv1.2 PSK-AES128-SHA256
|
||||
-s
|
||||
-v 3
|
||||
-l PSK-AES128-CBC-SHA256
|
||||
|
||||
# No Hint server TLSv1.0 PSK-AES256-SHA384
|
||||
-s
|
||||
-I
|
||||
-v 1
|
||||
-l PSK-AES256-CBC-SHA384
|
||||
|
||||
# No Hint client TLSv1.0 PSK-AES256-SHA384
|
||||
-s
|
||||
-v 1
|
||||
-l PSK-AES256-CBC-SHA384
|
||||
|
||||
# No Hint server TLSv1.1 PSK-AES256-SHA384
|
||||
-s
|
||||
-I
|
||||
-v 2
|
||||
-l PSK-AES256-CBC-SHA384
|
||||
|
||||
# No Hint client TLSv1.1 PSK-AES256-SHA384
|
||||
-s
|
||||
-v 2
|
||||
-l PSK-AES256-CBC-SHA384
|
||||
|
||||
# No Hint server TLSv1.2 PSK-AES256-SHA384
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l PSK-AES256-CBC-SHA384
|
||||
|
||||
# No Hint client TLSv1.2 PSK-AES256-SHA384
|
||||
-s
|
||||
-v 3
|
||||
-l PSK-AES256-CBC-SHA384
|
||||
|
||||
# server TLSv1.2 PSK-AES128-GCM-SHA256
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l PSK-AES128-GCM-SHA256
|
||||
|
||||
# client TLSv1.2 PSK-AES128-GCM-SHA256
|
||||
-s
|
||||
-v 3
|
||||
-l PSK-AES128-GCM-SHA256
|
||||
|
||||
# server TLSv1.2 PSK-AES256-GCM-SHA384
|
||||
-s
|
||||
-I
|
||||
-v 3
|
||||
-l PSK-AES256-GCM-SHA384
|
||||
|
||||
# client TLSv1.2 PSK-AES256-GCM-SHA384
|
||||
-s
|
||||
-v 3
|
||||
-l PSK-AES256-GCM-SHA384
|
||||
|
||||
2209
tests/test-qsh.conf
Normal file
2209
tests/test-qsh.conf
Normal file
File diff suppressed because it is too large
Load Diff
1111
tests/test-sctp.conf
Normal file
1111
tests/test-sctp.conf
Normal file
File diff suppressed because it is too large
Load Diff
209
tests/test-sig.conf
Normal file
209
tests/test-sig.conf
Normal file
@@ -0,0 +1,209 @@
|
||||
# server TLSv1 ECDHE-ECDSA-DES3
|
||||
-v 1
|
||||
-l ECDHE-ECDSA-DES-CBC3-SHA
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1 ECDHE-ECDSA-DES3
|
||||
-v 1
|
||||
-l ECDHE-ECDSA-DES-CBC3-SHA
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1 ECDHE-ECDSA-AES128
|
||||
-v 1
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-c ./certs/server-ecc.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1 ECDHE-ECDSA-AES128
|
||||
-v 1
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-A ./certs/server-ecc.pem
|
||||
|
||||
# server TLSv1 ECDHE-ECDSA-AES128
|
||||
-v 1
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1 ECDHE-ECDSA-AES128
|
||||
-v 1
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1 ECDHE-ECDSA-AES256
|
||||
-v 1
|
||||
-l ECDHE-ECDSA-AES256-SHA
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1 ECDHE-ECDSA-AES256
|
||||
-v 1
|
||||
-l ECDHE-ECDSA-AES256-SHA
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.1 ECDHE-ECDSA-DES3
|
||||
-v 2
|
||||
-l ECDHE-ECDSA-DES-CBC3-SHA
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.1 ECDHE-ECDSA-DES3
|
||||
-v 2
|
||||
-l ECDHE-ECDSA-DES-CBC3-SHA
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.1 ECDHE-ECDSA-AES128
|
||||
-v 2
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-c ./certs/server-ecc.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.1 ECDHE-ECDSA-AES128
|
||||
-v 2
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-A ./certs/server-ecc.pem
|
||||
|
||||
# server TLSv1.1 ECDHE-ECDSA-AES128
|
||||
-v 2
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.1 ECDHE-ECDSA-AES128
|
||||
-v 2
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.1 ECDHE-ECDSA-AES256
|
||||
-v 2
|
||||
-l ECDHE-ECDSA-AES256-SHA
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.1 ECDHE-ECDSA-AES256
|
||||
-v 2
|
||||
-l ECDHE-ECDSA-AES256-SHA
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDHE-ECDSA-DES3
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-DES-CBC3-SHA
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDHE-ECDSA-DES3
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-DES-CBC3-SHA
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDHE-ECDSA-AES128
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-c ./certs/server-ecc.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDHE-ECDSA-AES128
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-SHA
|
||||
-A ./certs/server-ecc.pem
|
||||
|
||||
# server TLSv1.2 ECDHE-ECDSA-AES128-SHA256
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-SHA256
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDHE-ECDSA-AES128-SHA256
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-SHA256
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDHE-ECDSA-AES256
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES256-SHA
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDHE-ECDSA-AES256
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES256-SHA
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDHE-EDCSA-CHACHA20-POLY1305
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-CHACHA20-POLY1305
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDHE-ECDSA-CHACHA20-POLY1305
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-CHACHA20-POLY1305
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDH-ECDSA-AES128-SHA256
|
||||
-v 3
|
||||
-l ECDH-ECDSA-AES128-SHA256
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDH-ECDSA-AES128-SHA256
|
||||
-v 3
|
||||
-l ECDH-ECDSA-AES128-SHA256
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDH-ECDSA-AES256
|
||||
-v 3
|
||||
-l ECDH-ECDSA-AES256-SHA
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDH-ECDSA-AES256
|
||||
-v 3
|
||||
-l ECDH-ECDSA-AES256-SHA
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDHE-ECDSA-AES128-GCM-SHA256
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-GCM-SHA256
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDHE-ECDSA-AES128-GCM-SHA256
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-GCM-SHA256
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDHE-ECDSA-AES256-GCM-SHA384
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES256-GCM-SHA384
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDHE-ECDSA-AES256-GCM-SHA384
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES256-GCM-SHA384
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDHE-ECDSA-AES128-CCM
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-CCM
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDHE-ECDSA-AES128-CCM
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-CCM
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
# server TLSv1.2 ECDHE-ECDSA-AES128-CCM-8
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-CCM-8
|
||||
-c ./certs/server-ecc-rsa.pem
|
||||
-k ./certs/ecc-key.pem
|
||||
|
||||
# client TLSv1.2 ECDHE-ECDSA-AES128-CCM-8
|
||||
-v 3
|
||||
-l ECDHE-ECDSA-AES128-CCM-8
|
||||
-A ./certs/ca-cert.pem
|
||||
|
||||
2198
tests/test.conf
Normal file
2198
tests/test.conf
Normal file
File diff suppressed because it is too large
Load Diff
160
tests/unit.c
Normal file
160
tests/unit.c
Normal file
@@ -0,0 +1,160 @@
|
||||
/* unit.c API unit tests driver
|
||||
*
|
||||
* Copyright (C) 2006-2016 wolfSSL Inc.
|
||||
*
|
||||
* This file is part of wolfSSL.
|
||||
*
|
||||
* wolfSSL 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.
|
||||
*
|
||||
* wolfSSL 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
|
||||
*/
|
||||
|
||||
|
||||
/* Name change compatibility layer no longer need to be included here */
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#include <stdio.h>
|
||||
#include <tests/unit.h>
|
||||
|
||||
|
||||
int myoptind = 0;
|
||||
char* myoptarg = NULL;
|
||||
int unit_test(int argc, char** argv);
|
||||
|
||||
#ifndef NO_TESTSUITE_MAIN_DRIVER
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
return unit_test(argc, argv);
|
||||
}
|
||||
#endif
|
||||
|
||||
int unit_test(int argc, char** argv)
|
||||
{
|
||||
int ret;
|
||||
|
||||
(void)argc;
|
||||
(void)argv;
|
||||
printf("starting unit tests...\n");
|
||||
|
||||
#if defined(DEBUG_WOLFSSL) && !defined(HAVE_VALGRIND)
|
||||
wolfSSL_Debugging_ON();
|
||||
#endif
|
||||
|
||||
#ifdef HAVE_WNR
|
||||
if (wc_InitNetRandom(wnrConfig, NULL, 5000) != 0)
|
||||
err_sys("Whitewood netRandom global config failed");
|
||||
#endif /* HAVE_WNR */
|
||||
|
||||
#ifndef WOLFSSL_TIRTOS
|
||||
ChangeToWolfRoot();
|
||||
#endif
|
||||
|
||||
ApiTest();
|
||||
|
||||
if ( (ret = HashTest()) != 0){
|
||||
printf("hash test failed with %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#ifndef SINGLE_THREADED
|
||||
if ( (ret = SuiteTest()) != 0){
|
||||
printf("suite test failed with %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
SrpTest();
|
||||
|
||||
#ifdef HAVE_WNR
|
||||
if (wc_FreeNetRandom() < 0)
|
||||
err_sys("Failed to free netRandom context");
|
||||
#endif /* HAVE_WNR */
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void wait_tcp_ready(func_args* args)
|
||||
{
|
||||
#ifdef SINGLE_THREADED
|
||||
(void)args;
|
||||
#elif defined(_POSIX_THREADS) && !defined(__MINGW32__)
|
||||
pthread_mutex_lock(&args->signal->mutex);
|
||||
|
||||
if (!args->signal->ready)
|
||||
pthread_cond_wait(&args->signal->cond, &args->signal->mutex);
|
||||
args->signal->ready = 0; /* reset */
|
||||
|
||||
pthread_mutex_unlock(&args->signal->mutex);
|
||||
#else
|
||||
(void)args;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void start_thread(THREAD_FUNC fun, func_args* args, THREAD_TYPE* thread)
|
||||
{
|
||||
#ifdef SINGLE_THREADED
|
||||
(void)fun;
|
||||
(void)args;
|
||||
(void)thread;
|
||||
#elif defined(_POSIX_THREADS) && !defined(__MINGW32__)
|
||||
pthread_create(thread, 0, fun, args);
|
||||
return;
|
||||
#elif defined (WOLFSSL_TIRTOS)
|
||||
/* Initialize the defaults and set the parameters. */
|
||||
Task_Params taskParams;
|
||||
Task_Params_init(&taskParams);
|
||||
taskParams.arg0 = (UArg)args;
|
||||
taskParams.stackSize = 65535;
|
||||
*thread = Task_create((Task_FuncPtr)fun, &taskParams, NULL);
|
||||
if (*thread == NULL) {
|
||||
printf("Failed to create new Task\n");
|
||||
}
|
||||
Task_yield();
|
||||
#else
|
||||
*thread = (THREAD_TYPE)_beginthreadex(0, 0, fun, args, 0, 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
void join_thread(THREAD_TYPE thread)
|
||||
{
|
||||
#ifdef SINGLE_THREADED
|
||||
(void)thread;
|
||||
#elif defined(_POSIX_THREADS) && !defined(__MINGW32__)
|
||||
pthread_join(thread, 0);
|
||||
#elif defined (WOLFSSL_TIRTOS)
|
||||
while(1) {
|
||||
if (Task_getMode(thread) == Task_Mode_TERMINATED) {
|
||||
Task_sleep(5);
|
||||
break;
|
||||
}
|
||||
Task_yield();
|
||||
}
|
||||
#else
|
||||
int res = WaitForSingleObject((HANDLE)thread, INFINITE);
|
||||
assert(res == WAIT_OBJECT_0);
|
||||
res = CloseHandle((HANDLE)thread);
|
||||
assert(res);
|
||||
(void)res; /* Suppress un-used variable warning */
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
85
tests/unit.h
Normal file
85
tests/unit.h
Normal file
@@ -0,0 +1,85 @@
|
||||
/* unit.c API unit tests driver
|
||||
*
|
||||
* Copyright (C) 2006-2016 wolfSSL Inc.
|
||||
*
|
||||
* This file is part of wolfSSL.
|
||||
*
|
||||
* wolfSSL 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.
|
||||
*
|
||||
* wolfSSL 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
|
||||
*/
|
||||
|
||||
|
||||
#ifndef CyaSSL_UNIT_H
|
||||
#define CyaSSL_UNIT_H
|
||||
|
||||
#include <wolfssl/ssl.h>
|
||||
#include <wolfssl/test.h> /* thread and tcp stuff */
|
||||
|
||||
#define Fail(description, result) do { \
|
||||
printf("\nERROR - %s line %d failed with:", __FILE__, __LINE__); \
|
||||
printf("\n expected: "); printf description; \
|
||||
printf("\n result: "); printf result; printf("\n\n"); \
|
||||
abort(); \
|
||||
} while(0)
|
||||
|
||||
#define Assert(test, description, result) if (!(test)) Fail(description, result)
|
||||
|
||||
#define AssertTrue(x) Assert( (x), ("%s is true", #x), (#x " => FALSE"))
|
||||
#define AssertFalse(x) Assert(!(x), ("%s is false", #x), (#x " => TRUE"))
|
||||
#define AssertNotNull(x) Assert( (x), ("%s is not null", #x), (#x " => NULL"))
|
||||
|
||||
#define AssertNull(x) do { \
|
||||
void* _x = (void *) (x); \
|
||||
\
|
||||
Assert(!_x, ("%s is null", #x), (#x " => %p", _x)); \
|
||||
} while(0)
|
||||
|
||||
#define AssertInt(x, y, op, er) do { \
|
||||
int _x = x; \
|
||||
int _y = y; \
|
||||
\
|
||||
Assert(_x op _y, ("%s " #op " %s", #x, #y), ("%d " #er " %d", _x, _y)); \
|
||||
} while(0)
|
||||
|
||||
#define AssertIntEQ(x, y) AssertInt(x, y, ==, !=)
|
||||
#define AssertIntNE(x, y) AssertInt(x, y, !=, ==)
|
||||
#define AssertIntGT(x, y) AssertInt(x, y, >, <=)
|
||||
#define AssertIntLT(x, y) AssertInt(x, y, <, >=)
|
||||
#define AssertIntGE(x, y) AssertInt(x, y, >=, <)
|
||||
#define AssertIntLE(x, y) AssertInt(x, y, <=, >)
|
||||
|
||||
#define AssertStr(x, y, op, er) do { \
|
||||
const char* _x = x; \
|
||||
const char* _y = y; \
|
||||
int _z = strcmp(_x, _y); \
|
||||
\
|
||||
Assert(_z op 0, ("%s " #op " %s", #x, #y), \
|
||||
("\"%s\" " #er " \"%s\"", _x, _y));\
|
||||
} while(0)
|
||||
|
||||
#define AssertStrEQ(x, y) AssertStr(x, y, ==, !=)
|
||||
#define AssertStrNE(x, y) AssertStr(x, y, !=, ==)
|
||||
#define AssertStrGT(x, y) AssertStr(x, y, >, <=)
|
||||
#define AssertStrLT(x, y) AssertStr(x, y, <, >=)
|
||||
#define AssertStrGE(x, y) AssertStr(x, y, >=, <)
|
||||
#define AssertStrLE(x, y) AssertStr(x, y, <=, >)
|
||||
|
||||
|
||||
void ApiTest(void);
|
||||
int SuiteTest(void);
|
||||
int HashTest(void);
|
||||
void SrpTest(void);
|
||||
|
||||
|
||||
#endif /* CyaSSL_UNIT_H */
|
||||
Reference in New Issue
Block a user