forked from wolfSSL/wolfssl
Merge pull request #8513 from SparkiDev/api_c_split_ciphers
Test api.c: split out MACs and ciphers
This commit is contained in:
Daniel Pouzzner
GitHub
@ -2512,7 +2512,6 @@ if(WOLFSSL_EXAMPLES)
|
||||
# Build unit tests
|
||||
add_executable(unit_test
|
||||
tests/api.c
|
||||
tests/api/test_dtls.c
|
||||
tests/api/test_md5.c
|
||||
tests/api/test_sha.c
|
||||
tests/api/test_sha256.c
|
||||
@ -2522,8 +2521,21 @@ if(WOLFSSL_EXAMPLES)
|
||||
tests/api/test_sm3.c
|
||||
tests/api/test_ripemd.c
|
||||
tests/api/test_hash.c
|
||||
tests/api/test_hmac.c
|
||||
tests/api/test_cmac.c
|
||||
tests/api/test_des3.c
|
||||
tests/api/test_chacha.c
|
||||
tests/api/test_poly1305.c
|
||||
tests/api/test_chacha20_poly1305.c
|
||||
tests/api/test_camellia.c
|
||||
tests/api/test_arc4.c
|
||||
tests/api/test_rc2.c
|
||||
tests/api/test_aes.c
|
||||
tests/api/test_ascon.c
|
||||
tests/api/test_sm4.c
|
||||
tests/api/test_wc_encrypt.c
|
||||
tests/api/test_mlkem.c
|
||||
tests/api/test_dtls.c
|
||||
tests/api/test_ocsp.c
|
||||
tests/hash.c
|
||||
tests/srp.c
|
||||
|
||||
5138
tests/api.c
5138
tests/api.c
File diff suppressed because it is too large
Load Diff
@ -32,6 +32,28 @@
|
||||
#define TEST_STRING_SZ 25
|
||||
|
||||
|
||||
/* Returns the result based on whether check is true.
|
||||
*
|
||||
* @param [in] check Condition for success.
|
||||
* @return When condition is true: TEST_SUCCESS.
|
||||
* @return When condition is false: TEST_FAIL.
|
||||
*/
|
||||
#ifdef DEBUG_WOLFSSL_VERBOSE
|
||||
#define XSTRINGIFY(s) STRINGIFY(s)
|
||||
#define STRINGIFY(s) #s
|
||||
#define TEST_RES_CHECK(check) ({ \
|
||||
int _ret = (check) ? TEST_SUCCESS : TEST_FAIL; \
|
||||
if (_ret == TEST_FAIL) { \
|
||||
fprintf(stderr, " check \"%s\" at %d ", \
|
||||
XSTRINGIFY(check), __LINE__); \
|
||||
} \
|
||||
_ret; })
|
||||
#else
|
||||
#define TEST_RES_CHECK(check) \
|
||||
((check) ? TEST_SUCCESS : TEST_FAIL)
|
||||
#endif /* DEBUG_WOLFSSL_VERBOSE */
|
||||
|
||||
|
||||
typedef struct testVector {
|
||||
const char* input;
|
||||
const char* output;
|
||||
|
||||
@ -3,6 +3,7 @@
|
||||
# All paths should be given relative to the
|
||||
|
||||
if BUILD_TESTS
|
||||
# Digests
|
||||
tests_unit_test_SOURCES += tests/api/test_md5.c
|
||||
tests_unit_test_SOURCES += tests/api/test_sha.c
|
||||
tests_unit_test_SOURCES += tests/api/test_sha256.c
|
||||
@ -12,11 +13,29 @@ tests_unit_test_SOURCES += tests/api/test_blake2.c
|
||||
tests_unit_test_SOURCES += tests/api/test_sm3.c
|
||||
tests_unit_test_SOURCES += tests/api/test_ripemd.c
|
||||
tests_unit_test_SOURCES += tests/api/test_hash.c
|
||||
# MAC
|
||||
tests_unit_test_SOURCES += tests/api/test_hmac.c
|
||||
tests_unit_test_SOURCES += tests/api/test_cmac.c
|
||||
# Cipher
|
||||
tests_unit_test_SOURCES += tests/api/test_des3.c
|
||||
tests_unit_test_SOURCES += tests/api/test_chacha.c
|
||||
tests_unit_test_SOURCES += tests/api/test_poly1305.c
|
||||
tests_unit_test_SOURCES += tests/api/test_chacha20_poly1305.c
|
||||
tests_unit_test_SOURCES += tests/api/test_camellia.c
|
||||
tests_unit_test_SOURCES += tests/api/test_arc4.c
|
||||
tests_unit_test_SOURCES += tests/api/test_rc2.c
|
||||
tests_unit_test_SOURCES += tests/api/test_aes.c
|
||||
tests_unit_test_SOURCES += tests/api/test_ascon.c
|
||||
tests_unit_test_SOURCES += tests/api/test_sm4.c
|
||||
tests_unit_test_SOURCES += tests/api/test_wc_encrypt.c
|
||||
# Signature Algorithm
|
||||
tests_unit_test_SOURCES += tests/api/test_mlkem.c
|
||||
# TLS Protocol
|
||||
tests_unit_test_SOURCES += tests/api/test_dtls.c
|
||||
# TLS Feature
|
||||
tests_unit_test_SOURCES += tests/api/test_ocsp.c
|
||||
endif
|
||||
|
||||
EXTRA_DIST += tests/api/api.h
|
||||
EXTRA_DIST += tests/api/test_md5.h
|
||||
EXTRA_DIST += tests/api/test_sha.h
|
||||
@ -28,9 +47,20 @@ EXTRA_DIST += tests/api/test_sm3.h
|
||||
EXTRA_DIST += tests/api/test_ripemd.h
|
||||
EXTRA_DIST += tests/api/test_digest.h
|
||||
EXTRA_DIST += tests/api/test_hash.h
|
||||
EXTRA_DIST += tests/api/test_hmac.h
|
||||
EXTRA_DIST += tests/api/test_cmac.h
|
||||
EXTRA_DIST += tests/api/test_des3.h
|
||||
EXTRA_DIST += tests/api/test_chacha.h
|
||||
EXTRA_DIST += tests/api/test_poly1305.h
|
||||
EXTRA_DIST += tests/api/test_chacha20_poly1305.h
|
||||
EXTRA_DIST += tests/api/test_camellia.h
|
||||
EXTRA_DIST += tests/api/test_arc4.h
|
||||
EXTRA_DIST += tests/api/test_rc2.h
|
||||
EXTRA_DIST += tests/api/test_aes.h
|
||||
EXTRA_DIST += tests/api/test_ascon.h
|
||||
EXTRA_DIST += tests/api/test_ascon.h
|
||||
EXTRA_DIST += tests/api/test_sm4.h
|
||||
EXTRA_DIST += tests/api/test_ascon_kats.h
|
||||
EXTRA_DIST += tests/api/test_wc_encrypt.h
|
||||
EXTRA_DIST += tests/api/test_mlkem.h
|
||||
EXTRA_DIST += tests/api/test_dtls.h
|
||||
EXTRA_DIST += tests/api/test_ocsp.h
|
||||
|
||||
2685
tests/api/test_aes.c
Normal file
2685
tests/api/test_aes.c
Normal file
File diff suppressed because it is too large
Load Diff
44
tests/api/test_aes.h
Normal file
44
tests/api/test_aes.h
Normal file
@ -0,0 +1,44 @@
|
||||
/* test_aes.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_AES_H
|
||||
#define WOLFCRYPT_TEST_AES_H
|
||||
|
||||
int test_wc_AesSetKey(void);
|
||||
int test_wc_AesSetIV(void);
|
||||
int test_wc_AesCbcEncryptDecrypt(void);
|
||||
int test_wc_AesCtrEncryptDecrypt(void);
|
||||
int test_wc_AesGcmSetKey(void);
|
||||
int test_wc_AesGcmEncryptDecrypt(void);
|
||||
int test_wc_AesGcmMixedEncDecLongIV(void);
|
||||
int test_wc_AesGcmStream(void);
|
||||
int test_wc_GmacSetKey(void);
|
||||
int test_wc_GmacUpdate(void);
|
||||
int test_wc_AesCcmSetKey(void);
|
||||
int test_wc_AesCcmEncryptDecrypt(void);
|
||||
#if defined(WOLFSSL_AES_EAX) && \
|
||||
(!defined(HAVE_FIPS) || FIPS_VERSION_GE(5, 3)) && !defined(HAVE_SELFTEST)
|
||||
int test_wc_AesEaxVectors(void);
|
||||
int test_wc_AesEaxEncryptAuth(void);
|
||||
int test_wc_AesEaxDecryptAuth(void);
|
||||
#endif /* WOLFSSL_AES_EAX */
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_AES_H */
|
||||
114
tests/api/test_arc4.c
Normal file
114
tests/api/test_arc4.c
Normal file
@ -0,0 +1,114 @@
|
||||
/* test_arc4.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/arc4.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_arc4.h>
|
||||
|
||||
/*
|
||||
* Testing wc_Arc4SetKey()
|
||||
*/
|
||||
int test_wc_Arc4SetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifndef NO_RC4
|
||||
Arc4 arc;
|
||||
const char* key = "\x01\x23\x45\x67\x89\xab\xcd\xef";
|
||||
int keyLen = 8;
|
||||
|
||||
ExpectIntEQ(wc_Arc4SetKey(&arc, (byte*)key, (word32)keyLen), 0);
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_Arc4SetKey(NULL, (byte*)key, (word32)keyLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Arc4SetKey(&arc, NULL , (word32)keyLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Arc4SetKey(&arc, (byte*)key, 0 ),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
|
||||
} /* END test_wc_Arc4SetKey */
|
||||
|
||||
/*
|
||||
* Testing wc_Arc4Process for ENC/DEC.
|
||||
*/
|
||||
int test_wc_Arc4Process(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifndef NO_RC4
|
||||
Arc4 enc;
|
||||
Arc4 dec;
|
||||
const char* key = "\x01\x23\x45\x67\x89\xab\xcd\xef";
|
||||
int keyLen = 8;
|
||||
const char* input = "\x01\x23\x45\x67\x89\xab\xcd\xef";
|
||||
byte cipher[8];
|
||||
byte plain[8];
|
||||
|
||||
/* Init stack variables */
|
||||
XMEMSET(&enc, 0, sizeof(Arc4));
|
||||
XMEMSET(&dec, 0, sizeof(Arc4));
|
||||
XMEMSET(cipher, 0, sizeof(cipher));
|
||||
XMEMSET(plain, 0, sizeof(plain));
|
||||
|
||||
/* Use for async. */
|
||||
ExpectIntEQ(wc_Arc4Init(&enc, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_Arc4Init(&dec, NULL, INVALID_DEVID), 0);
|
||||
|
||||
ExpectIntEQ(wc_Arc4SetKey(&enc, (byte*)key, (word32)keyLen), 0);
|
||||
ExpectIntEQ(wc_Arc4SetKey(&dec, (byte*)key, (word32)keyLen), 0);
|
||||
|
||||
ExpectIntEQ(wc_Arc4Process(&enc, cipher, (byte*)input, (word32)keyLen), 0);
|
||||
ExpectIntEQ(wc_Arc4Process(&dec, plain, cipher, (word32)keyLen), 0);
|
||||
ExpectIntEQ(XMEMCMP(plain, input, keyLen), 0);
|
||||
|
||||
/* Bad args. */
|
||||
ExpectIntEQ(wc_Arc4Process(NULL, plain, cipher, (word32)keyLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Arc4Process(&dec, NULL, cipher, (word32)keyLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Arc4Process(&dec, plain, NULL, (word32)keyLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
wc_Arc4Free(&enc);
|
||||
wc_Arc4Free(&dec);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
|
||||
} /* END test_wc_Arc4Process */
|
||||
|
||||
28
tests/api/test_arc4.h
Normal file
28
tests/api/test_arc4.h
Normal file
@ -0,0 +1,28 @@
|
||||
/* test_arc4.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_ARC4_H
|
||||
#define WOLFCRYPT_TEST_ARC4_H
|
||||
|
||||
int test_wc_Arc4SetKey(void);
|
||||
int test_wc_Arc4Process(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_ARC4_H */
|
||||
224
tests/api/test_camellia.c
Normal file
224
tests/api/test_camellia.c
Normal file
@ -0,0 +1,224 @@
|
||||
/* test_camellia.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/camellia.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_camellia.h>
|
||||
|
||||
/*
|
||||
* testing wc_CamelliaSetKey
|
||||
*/
|
||||
int test_wc_CamelliaSetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef HAVE_CAMELLIA
|
||||
wc_Camellia camellia;
|
||||
/*128-bit key*/
|
||||
static const byte key16[] = {
|
||||
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
|
||||
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
|
||||
};
|
||||
/* 192-bit key */
|
||||
static const byte key24[] = {
|
||||
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
|
||||
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
|
||||
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
|
||||
};
|
||||
/* 256-bit key */
|
||||
static const byte key32[] = {
|
||||
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
|
||||
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
|
||||
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
|
||||
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff
|
||||
};
|
||||
static const byte iv[] = {
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
||||
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
|
||||
};
|
||||
|
||||
ExpectIntEQ(wc_CamelliaSetKey(&camellia, key16, (word32)sizeof(key16), iv),
|
||||
0);
|
||||
ExpectIntEQ(wc_CamelliaSetKey(&camellia, key16, (word32)sizeof(key16),
|
||||
NULL), 0);
|
||||
ExpectIntEQ(wc_CamelliaSetKey(&camellia, key24, (word32)sizeof(key24), iv),
|
||||
0);
|
||||
ExpectIntEQ(wc_CamelliaSetKey(&camellia, key24, (word32)sizeof(key24),
|
||||
NULL), 0);
|
||||
ExpectIntEQ(wc_CamelliaSetKey(&camellia, key32, (word32)sizeof(key32), iv),
|
||||
0);
|
||||
ExpectIntEQ(wc_CamelliaSetKey(&camellia, key32, (word32)sizeof(key32),
|
||||
NULL), 0);
|
||||
|
||||
/* Bad args. */
|
||||
ExpectIntEQ(wc_CamelliaSetKey(NULL, key32, (word32)sizeof(key32), iv),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_CameliaSetKey */
|
||||
|
||||
/*
|
||||
* Testing wc_CamelliaSetIV()
|
||||
*/
|
||||
int test_wc_CamelliaSetIV(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef HAVE_CAMELLIA
|
||||
wc_Camellia camellia;
|
||||
static const byte iv[] = {
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
||||
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
|
||||
};
|
||||
|
||||
ExpectIntEQ(wc_CamelliaSetIV(&camellia, iv), 0);
|
||||
ExpectIntEQ(wc_CamelliaSetIV(&camellia, NULL), 0);
|
||||
|
||||
/* Bad args. */
|
||||
ExpectIntEQ(wc_CamelliaSetIV(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CamelliaSetIV(NULL, iv), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_CamelliaSetIV*/
|
||||
|
||||
/*
|
||||
* Test wc_CamelliaEncryptDirect and wc_CamelliaDecryptDirect
|
||||
*/
|
||||
int test_wc_CamelliaEncryptDecryptDirect(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef HAVE_CAMELLIA
|
||||
wc_Camellia camellia;
|
||||
static const byte key24[] = {
|
||||
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
|
||||
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
|
||||
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
|
||||
};
|
||||
static const byte iv[] = {
|
||||
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
||||
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
|
||||
};
|
||||
static const byte plainT[] = {
|
||||
0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
|
||||
0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A
|
||||
};
|
||||
byte enc[sizeof(plainT)];
|
||||
byte dec[sizeof(enc)];
|
||||
|
||||
/* Init stack variables.*/
|
||||
XMEMSET(enc, 0, 16);
|
||||
XMEMSET(enc, 0, 16);
|
||||
|
||||
ExpectIntEQ(wc_CamelliaSetKey(&camellia, key24, (word32)sizeof(key24), iv),
|
||||
0);
|
||||
ExpectIntEQ(wc_CamelliaEncryptDirect(&camellia, enc, plainT), 0);
|
||||
ExpectIntEQ(wc_CamelliaDecryptDirect(&camellia, dec, enc), 0);
|
||||
ExpectIntEQ(XMEMCMP(plainT, dec, WC_CAMELLIA_BLOCK_SIZE), 0);
|
||||
|
||||
/* Pass bad args. */
|
||||
ExpectIntEQ(wc_CamelliaEncryptDirect(NULL, enc, plainT),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CamelliaEncryptDirect(&camellia, NULL, plainT),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CamelliaEncryptDirect(&camellia, enc, NULL),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_CamelliaDecryptDirect(NULL, dec, enc),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CamelliaDecryptDirect(&camellia, NULL, enc),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CamelliaDecryptDirect(&camellia, dec, NULL),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test-wc_CamelliaEncryptDecryptDirect */
|
||||
|
||||
/*
|
||||
* Testing wc_CamelliaCbcEncrypt and wc_CamelliaCbcDecrypt
|
||||
*/
|
||||
int test_wc_CamelliaCbcEncryptDecrypt(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef HAVE_CAMELLIA
|
||||
wc_Camellia camellia;
|
||||
static const byte key24[] = {
|
||||
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
|
||||
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
|
||||
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77
|
||||
};
|
||||
static const byte plainT[] = {
|
||||
0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
|
||||
0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A
|
||||
};
|
||||
byte enc[WC_CAMELLIA_BLOCK_SIZE];
|
||||
byte dec[WC_CAMELLIA_BLOCK_SIZE];
|
||||
|
||||
/* Init stack variables. */
|
||||
XMEMSET(enc, 0, WC_CAMELLIA_BLOCK_SIZE);
|
||||
XMEMSET(enc, 0, WC_CAMELLIA_BLOCK_SIZE);
|
||||
|
||||
ExpectIntEQ(wc_CamelliaSetKey(&camellia, key24, (word32)sizeof(key24),
|
||||
NULL), 0);
|
||||
ExpectIntEQ(wc_CamelliaCbcEncrypt(&camellia, enc, plainT,
|
||||
WC_CAMELLIA_BLOCK_SIZE), 0);
|
||||
|
||||
ExpectIntEQ(wc_CamelliaSetKey(&camellia, key24, (word32)sizeof(key24),
|
||||
NULL), 0);
|
||||
ExpectIntEQ(wc_CamelliaCbcDecrypt(&camellia, dec, enc,
|
||||
WC_CAMELLIA_BLOCK_SIZE),
|
||||
0);
|
||||
ExpectIntEQ(XMEMCMP(plainT, dec, WC_CAMELLIA_BLOCK_SIZE), 0);
|
||||
|
||||
/* Pass in bad args. */
|
||||
ExpectIntEQ(wc_CamelliaCbcEncrypt(NULL, enc, plainT,
|
||||
WC_CAMELLIA_BLOCK_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CamelliaCbcEncrypt(&camellia, NULL, plainT,
|
||||
WC_CAMELLIA_BLOCK_SIZE), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CamelliaCbcEncrypt(&camellia, enc, NULL,
|
||||
WC_CAMELLIA_BLOCK_SIZE), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_CamelliaCbcDecrypt(NULL, dec, enc, WC_CAMELLIA_BLOCK_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CamelliaCbcDecrypt(&camellia, NULL, enc,
|
||||
WC_CAMELLIA_BLOCK_SIZE), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CamelliaCbcDecrypt(&camellia, dec, NULL,
|
||||
WC_CAMELLIA_BLOCK_SIZE), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_CamelliaCbcEncryptDecrypt */
|
||||
|
||||
30
tests/api/test_camellia.h
Normal file
30
tests/api/test_camellia.h
Normal file
@ -0,0 +1,30 @@
|
||||
/* test_camellia.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_CAMELLIA_H
|
||||
#define WOLFCRYPT_TEST_CAMELLIA_H
|
||||
|
||||
int test_wc_CamelliaSetKey(void);
|
||||
int test_wc_CamelliaSetIV(void);
|
||||
int test_wc_CamelliaEncryptDecryptDirect(void);
|
||||
int test_wc_CamelliaCbcEncryptDecrypt(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_CAMELLIA_H */
|
||||
196
tests/api/test_chacha.c
Normal file
196
tests/api/test_chacha.c
Normal file
@ -0,0 +1,196 @@
|
||||
/* test_chacha.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/chacha.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_chacha.h>
|
||||
|
||||
/*
|
||||
* Testing wc_Chacha_SetKey() and wc_Chacha_SetIV()
|
||||
*/
|
||||
int test_wc_Chacha_SetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef HAVE_CHACHA
|
||||
ChaCha ctx;
|
||||
const byte key[] = {
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01
|
||||
};
|
||||
word32 keySz = (word32)(sizeof(key)/sizeof(byte));
|
||||
byte cipher[128];
|
||||
|
||||
XMEMSET(cipher, 0, sizeof(cipher));
|
||||
ExpectIntEQ(wc_Chacha_SetKey(&ctx, key, keySz), 0);
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_Chacha_SetKey(NULL, key, keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Chacha_SetKey(&ctx, key, 18), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_Chacha_SetIV(&ctx, cipher, 0), 0);
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_Chacha_SetIV(NULL, cipher, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Chacha_SetKey */
|
||||
|
||||
/*
|
||||
* Testing wc_Chacha_Process()
|
||||
*/
|
||||
int test_wc_Chacha_Process(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef HAVE_CHACHA
|
||||
ChaCha enc, dec;
|
||||
byte cipher[128];
|
||||
byte plain[128];
|
||||
const byte key[] =
|
||||
{
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01
|
||||
};
|
||||
const char* input = "Everybody gets Friday off.";
|
||||
word32 keySz = sizeof(key)/sizeof(byte);
|
||||
unsigned long int inlen = XSTRLEN(input);
|
||||
|
||||
/* Initialize stack variables. */
|
||||
XMEMSET(cipher, 0, 128);
|
||||
XMEMSET(plain, 0, 128);
|
||||
|
||||
ExpectIntEQ(wc_Chacha_SetKey(&enc, key, keySz), 0);
|
||||
ExpectIntEQ(wc_Chacha_SetKey(&dec, key, keySz), 0);
|
||||
ExpectIntEQ(wc_Chacha_SetIV(&enc, cipher, 0), 0);
|
||||
ExpectIntEQ(wc_Chacha_SetIV(&dec, cipher, 0), 0);
|
||||
|
||||
ExpectIntEQ(wc_Chacha_Process(&enc, cipher, (byte*)input, (word32)inlen),
|
||||
0);
|
||||
ExpectIntEQ(wc_Chacha_Process(&dec, plain, cipher, (word32)inlen), 0);
|
||||
ExpectIntEQ(XMEMCMP(input, plain, inlen), 0);
|
||||
|
||||
#if !defined(USE_INTEL_CHACHA_SPEEDUP) && !defined(WOLFSSL_ARMASM)
|
||||
/* test checking and using leftovers, currently just in C code */
|
||||
ExpectIntEQ(wc_Chacha_SetIV(&enc, cipher, 0), 0);
|
||||
ExpectIntEQ(wc_Chacha_SetIV(&dec, cipher, 0), 0);
|
||||
|
||||
ExpectIntEQ(wc_Chacha_Process(&enc, cipher, (byte*)input,
|
||||
(word32)inlen - 2), 0);
|
||||
ExpectIntEQ(wc_Chacha_Process(&enc, cipher + (inlen - 2),
|
||||
(byte*)input + (inlen - 2), 2), 0);
|
||||
ExpectIntEQ(wc_Chacha_Process(&dec, plain, (byte*)cipher,
|
||||
(word32)inlen - 2), 0);
|
||||
ExpectIntEQ(wc_Chacha_Process(&dec, cipher + (inlen - 2),
|
||||
(byte*)input + (inlen - 2), 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(input, plain, inlen), 0);
|
||||
|
||||
/* check edge cases with counter increment */
|
||||
{
|
||||
/* expected results collected from wolfSSL 4.3.0 encrypted in one call*/
|
||||
const byte expected[] = {
|
||||
0x54,0xB1,0xE2,0xD4,0xA2,0x4D,0x52,0x5F,
|
||||
0x42,0x04,0x89,0x7C,0x6E,0x2D,0xFC,0x2D,
|
||||
0x10,0x25,0xB6,0x92,0x71,0xD5,0xC3,0x20,
|
||||
0xE3,0x0E,0xEC,0xF4,0xD8,0x10,0x70,0x29,
|
||||
0x2D,0x4C,0x2A,0x56,0x21,0xE1,0xC7,0x37,
|
||||
0x0B,0x86,0xF5,0x02,0x8C,0xB8,0xB8,0x38,
|
||||
0x41,0xFD,0xDF,0xD9,0xC3,0xE6,0xC8,0x88,
|
||||
0x06,0x82,0xD4,0x80,0x6A,0x50,0x69,0xD5,
|
||||
0xB9,0xB0,0x2F,0x44,0x36,0x5D,0xDA,0x5E,
|
||||
0xDE,0xF6,0xF5,0xFC,0x44,0xDC,0x07,0x51,
|
||||
0xA7,0x32,0x42,0xDB,0xCC,0xBD,0xE2,0xE5,
|
||||
0x0B,0xB1,0x14,0xFF,0x12,0x80,0x16,0x43,
|
||||
0xE7,0x40,0xD5,0xEA,0xC7,0x3F,0x69,0x07,
|
||||
0x64,0xD4,0x86,0x6C,0xE2,0x1F,0x8F,0x6E,
|
||||
0x35,0x41,0xE7,0xD3,0xB5,0x5D,0xD6,0xD4,
|
||||
0x9F,0x00,0xA9,0xAE,0x3D,0x28,0xA5,0x37,
|
||||
0x80,0x3D,0x11,0x25,0xE2,0xB6,0x99,0xD9,
|
||||
0x9B,0x98,0xE9,0x37,0xB9,0xF8,0xA0,0x04,
|
||||
0xDF,0x13,0x49,0x3F,0x19,0x6A,0x45,0x06,
|
||||
0x21,0xB4,0xC7,0x3B,0x49,0x45,0xB4,0xC8,
|
||||
0x03,0x5B,0x43,0x89,0xBD,0xB3,0x96,0x4B,
|
||||
0x17,0x6F,0x85,0xC6,0xCF,0xA6,0x05,0x35,
|
||||
0x1E,0x25,0x03,0xBB,0x55,0x0A,0xD5,0x54,
|
||||
0x41,0xEA,0xEB,0x50,0x40,0x1B,0x43,0x19,
|
||||
0x59,0x1B,0x0E,0x12,0x3E,0xA2,0x71,0xC3,
|
||||
0x1A,0xA7,0x11,0x50,0x43,0x9D,0x56,0x3B,
|
||||
0x63,0x2F,0x63,0xF1,0x8D,0xAE,0xF3,0x23,
|
||||
0xFA,0x1E,0xD8,0x6A,0xE1,0xB2,0x4B,0xF3,
|
||||
0xB9,0x13,0x7A,0x72,0x2B,0x6D,0xCC,0x41,
|
||||
0x1C,0x69,0x7C,0xCD,0x43,0x6F,0xE4,0xE2,
|
||||
0x38,0x99,0xFB,0xC3,0x38,0x92,0x62,0x35,
|
||||
0xC0,0x1D,0x60,0xE4,0x4B,0xDD,0x0C,0x14
|
||||
};
|
||||
const byte iv2[] = {
|
||||
0x9D,0xED,0xE7,0x0F,0xEC,0x81,0x51,0xD9,
|
||||
0x77,0x39,0x71,0xA6,0x21,0xDF,0xB8,0x93
|
||||
};
|
||||
byte input2[256];
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 256; i++)
|
||||
input2[i] = (byte)i;
|
||||
|
||||
ExpectIntEQ(wc_Chacha_SetIV(&enc, iv2, 0), 0);
|
||||
|
||||
ExpectIntEQ(wc_Chacha_Process(&enc, cipher, input2, 64), 0);
|
||||
ExpectIntEQ(XMEMCMP(expected, cipher, 64), 0);
|
||||
|
||||
ExpectIntEQ(wc_Chacha_Process(&enc, cipher, input2 + 64, 128), 0);
|
||||
ExpectIntEQ(XMEMCMP(expected + 64, cipher, 128), 0);
|
||||
|
||||
/* partial */
|
||||
ExpectIntEQ(wc_Chacha_Process(&enc, cipher, input2 + 192, 32), 0);
|
||||
ExpectIntEQ(XMEMCMP(expected + 192, cipher, 32), 0);
|
||||
|
||||
ExpectIntEQ(wc_Chacha_Process(&enc, cipher, input2 + 224, 32), 0);
|
||||
ExpectIntEQ(XMEMCMP(expected + 224, cipher, 32), 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_Chacha_Process(NULL, cipher, (byte*)input, (word32)inlen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Chacha_Process */
|
||||
|
||||
28
tests/api/test_chacha.h
Normal file
28
tests/api/test_chacha.h
Normal file
@ -0,0 +1,28 @@
|
||||
/* test_chacha.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_CHACHA_H
|
||||
#define WOLFCRYPT_TEST_CHACHA_H
|
||||
|
||||
int test_wc_Chacha_SetKey(void);
|
||||
int test_wc_Chacha_Process(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_CHACHA_H */
|
||||
164
tests/api/test_chacha20_poly1305.c
Normal file
164
tests/api/test_chacha20_poly1305.c
Normal file
@ -0,0 +1,164 @@
|
||||
/* test_chacha20_poly1305.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/chacha20_poly1305.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_chacha20_poly1305.h>
|
||||
|
||||
/*
|
||||
* Testing wc_ChaCha20Poly1305_Encrypt() and wc_ChaCha20Poly1305_Decrypt()
|
||||
*/
|
||||
int test_wc_ChaCha20Poly1305_aead(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if defined(HAVE_CHACHA) && defined(HAVE_POLY1305)
|
||||
const byte key[] = {
|
||||
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
|
||||
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
|
||||
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
|
||||
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f
|
||||
};
|
||||
const byte plaintext[] = {
|
||||
0x4c, 0x61, 0x64, 0x69, 0x65, 0x73, 0x20, 0x61,
|
||||
0x6e, 0x64, 0x20, 0x47, 0x65, 0x6e, 0x74, 0x6c,
|
||||
0x65, 0x6d, 0x65, 0x6e, 0x20, 0x6f, 0x66, 0x20,
|
||||
0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x61, 0x73,
|
||||
0x73, 0x20, 0x6f, 0x66, 0x20, 0x27, 0x39, 0x39,
|
||||
0x3a, 0x20, 0x49, 0x66, 0x20, 0x49, 0x20, 0x63,
|
||||
0x6f, 0x75, 0x6c, 0x64, 0x20, 0x6f, 0x66, 0x66,
|
||||
0x65, 0x72, 0x20, 0x79, 0x6f, 0x75, 0x20, 0x6f,
|
||||
0x6e, 0x6c, 0x79, 0x20, 0x6f, 0x6e, 0x65, 0x20,
|
||||
0x74, 0x69, 0x70, 0x20, 0x66, 0x6f, 0x72, 0x20,
|
||||
0x74, 0x68, 0x65, 0x20, 0x66, 0x75, 0x74, 0x75,
|
||||
0x72, 0x65, 0x2c, 0x20, 0x73, 0x75, 0x6e, 0x73,
|
||||
0x63, 0x72, 0x65, 0x65, 0x6e, 0x20, 0x77, 0x6f,
|
||||
0x75, 0x6c, 0x64, 0x20, 0x62, 0x65, 0x20, 0x69,
|
||||
0x74, 0x2e
|
||||
};
|
||||
const byte iv[] = {
|
||||
0x07, 0x00, 0x00, 0x00, 0x40, 0x41, 0x42, 0x43,
|
||||
0x44, 0x45, 0x46, 0x47
|
||||
};
|
||||
const byte aad[] = { /* additional data */
|
||||
0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3,
|
||||
0xc4, 0xc5, 0xc6, 0xc7
|
||||
};
|
||||
const byte cipher[] = { /* expected output from operation */
|
||||
0xd3, 0x1a, 0x8d, 0x34, 0x64, 0x8e, 0x60, 0xdb,
|
||||
0x7b, 0x86, 0xaf, 0xbc, 0x53, 0xef, 0x7e, 0xc2,
|
||||
0xa4, 0xad, 0xed, 0x51, 0x29, 0x6e, 0x08, 0xfe,
|
||||
0xa9, 0xe2, 0xb5, 0xa7, 0x36, 0xee, 0x62, 0xd6,
|
||||
0x3d, 0xbe, 0xa4, 0x5e, 0x8c, 0xa9, 0x67, 0x12,
|
||||
0x82, 0xfa, 0xfb, 0x69, 0xda, 0x92, 0x72, 0x8b,
|
||||
0x1a, 0x71, 0xde, 0x0a, 0x9e, 0x06, 0x0b, 0x29,
|
||||
0x05, 0xd6, 0xa5, 0xb6, 0x7e, 0xcd, 0x3b, 0x36,
|
||||
0x92, 0xdd, 0xbd, 0x7f, 0x2d, 0x77, 0x8b, 0x8c,
|
||||
0x98, 0x03, 0xae, 0xe3, 0x28, 0x09, 0x1b, 0x58,
|
||||
0xfa, 0xb3, 0x24, 0xe4, 0xfa, 0xd6, 0x75, 0x94,
|
||||
0x55, 0x85, 0x80, 0x8b, 0x48, 0x31, 0xd7, 0xbc,
|
||||
0x3f, 0xf4, 0xde, 0xf0, 0x8e, 0x4b, 0x7a, 0x9d,
|
||||
0xe5, 0x76, 0xd2, 0x65, 0x86, 0xce, 0xc6, 0x4b,
|
||||
0x61, 0x16
|
||||
};
|
||||
const byte authTag[] = { /* expected output from operation */
|
||||
0x1a, 0xe1, 0x0b, 0x59, 0x4f, 0x09, 0xe2, 0x6a,
|
||||
0x7e, 0x90, 0x2e, 0xcb, 0xd0, 0x60, 0x06, 0x91
|
||||
};
|
||||
byte generatedCiphertext[272];
|
||||
byte generatedPlaintext[272];
|
||||
byte generatedAuthTag[CHACHA20_POLY1305_AEAD_AUTHTAG_SIZE];
|
||||
|
||||
/* Initialize stack variables. */
|
||||
XMEMSET(generatedCiphertext, 0, 272);
|
||||
XMEMSET(generatedPlaintext, 0, 272);
|
||||
|
||||
/* Test Encrypt */
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Encrypt(key, iv, aad, sizeof(aad),
|
||||
plaintext, sizeof(plaintext), generatedCiphertext, generatedAuthTag),
|
||||
0);
|
||||
ExpectIntEQ(XMEMCMP(generatedCiphertext, cipher,
|
||||
sizeof(cipher)/sizeof(byte)), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Encrypt(NULL, iv, aad, sizeof(aad),
|
||||
plaintext, sizeof(plaintext), generatedCiphertext, generatedAuthTag),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Encrypt(key, NULL, aad, sizeof(aad),
|
||||
plaintext, sizeof(plaintext), generatedCiphertext, generatedAuthTag),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Encrypt(key, iv, aad, sizeof(aad), NULL,
|
||||
sizeof(plaintext), generatedCiphertext, generatedAuthTag),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Encrypt(key, iv, aad, sizeof(aad),
|
||||
NULL, sizeof(plaintext), generatedCiphertext, generatedAuthTag),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Encrypt(key, iv, aad, sizeof(aad),
|
||||
plaintext, sizeof(plaintext), NULL, generatedAuthTag),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Encrypt(key, iv, aad, sizeof(aad),
|
||||
plaintext, sizeof(plaintext), generatedCiphertext, NULL),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Decrypt(key, iv, aad, sizeof(aad), cipher,
|
||||
sizeof(cipher), authTag, generatedPlaintext), 0);
|
||||
ExpectIntEQ(XMEMCMP(generatedPlaintext, plaintext,
|
||||
sizeof(plaintext)/sizeof(byte)), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Decrypt(NULL, iv, aad, sizeof(aad), cipher,
|
||||
sizeof(cipher), authTag, generatedPlaintext),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Decrypt(key, NULL, aad, sizeof(aad),
|
||||
cipher, sizeof(cipher), authTag, generatedPlaintext),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Decrypt(key, iv, aad, sizeof(aad), NULL,
|
||||
sizeof(cipher), authTag, generatedPlaintext),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Decrypt(key, iv, aad, sizeof(aad), cipher,
|
||||
sizeof(cipher), NULL, generatedPlaintext),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Decrypt(key, iv, aad, sizeof(aad), cipher,
|
||||
sizeof(cipher), authTag, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_ChaCha20Poly1305_Decrypt(key, iv, aad, sizeof(aad), NULL,
|
||||
sizeof(cipher), authTag, generatedPlaintext),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_ChaCha20Poly1305_aead */
|
||||
|
||||
27
tests/api/test_chacha20_poly1305.h
Normal file
27
tests/api/test_chacha20_poly1305.h
Normal file
@ -0,0 +1,27 @@
|
||||
/* test_chacha20_poly1305.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_CHACHA20_POLY1305_H
|
||||
#define WOLFCRYPT_TEST_CHACHA20_POLY1305_H
|
||||
|
||||
int test_wc_ChaCha20Poly1305_aead(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_CHACHA20_POLY1305_H */
|
||||
259
tests/api/test_cmac.c
Normal file
259
tests/api/test_cmac.c
Normal file
@ -0,0 +1,259 @@
|
||||
/* test_cmac.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/cmac.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_cmac.h>
|
||||
|
||||
/*
|
||||
* Testing wc_InitCmac()
|
||||
*/
|
||||
int test_wc_InitCmac(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if defined(WOLFSSL_CMAC) && !defined(NO_AES)
|
||||
Cmac cmac1;
|
||||
Cmac cmac2;
|
||||
Cmac cmac3;
|
||||
/* AES 128 key. */
|
||||
byte key1[] = "\x01\x02\x03\x04\x05\x06\x07\x08"
|
||||
"\x09\x10\x11\x12\x13\x14\x15\x16";
|
||||
/* AES 192 key. */
|
||||
byte key2[] = "\x01\x02\x03\x04\x05\x06\x07\x08"
|
||||
"\x09\x01\x11\x12\x13\x14\x15\x16"
|
||||
"\x01\x02\x03\x04\x05\x06\x07\x08";
|
||||
/* AES 256 key. */
|
||||
byte key3[] = "\x01\x02\x03\x04\x05\x06\x07\x08"
|
||||
"\x09\x01\x11\x12\x13\x14\x15\x16"
|
||||
"\x01\x02\x03\x04\x05\x06\x07\x08"
|
||||
"\x09\x01\x11\x12\x13\x14\x15\x16";
|
||||
word32 key1Sz = (word32)sizeof(key1) - 1;
|
||||
word32 key2Sz = (word32)sizeof(key2) - 1;
|
||||
word32 key3Sz = (word32)sizeof(key3) - 1;
|
||||
int type = WC_CMAC_AES;
|
||||
|
||||
(void)key1;
|
||||
(void)key1Sz;
|
||||
(void)key2;
|
||||
(void)key2Sz;
|
||||
|
||||
XMEMSET(&cmac1, 0, sizeof(Cmac));
|
||||
XMEMSET(&cmac2, 0, sizeof(Cmac));
|
||||
XMEMSET(&cmac3, 0, sizeof(Cmac));
|
||||
|
||||
#ifdef WOLFSSL_AES_128
|
||||
ExpectIntEQ(wc_InitCmac(&cmac1, key1, key1Sz, type, NULL), 0);
|
||||
#endif
|
||||
#ifdef WOLFSSL_AES_192
|
||||
wc_AesFree(&cmac1.aes);
|
||||
ExpectIntEQ(wc_InitCmac(&cmac2, key2, key2Sz, type, NULL), 0);
|
||||
#endif
|
||||
#ifdef WOLFSSL_AES_256
|
||||
wc_AesFree(&cmac2.aes);
|
||||
ExpectIntEQ(wc_InitCmac(&cmac3, key3, key3Sz, type, NULL), 0);
|
||||
#endif
|
||||
|
||||
wc_AesFree(&cmac3.aes);
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_InitCmac(NULL, key3, key3Sz, type, NULL),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_InitCmac(&cmac3, NULL, key3Sz, type, NULL),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_InitCmac(&cmac3, key3, 0, type, NULL),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_InitCmac(&cmac3, key3, key3Sz, 0, NULL),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_InitCmac */
|
||||
|
||||
/*
|
||||
* Testing wc_CmacUpdate()
|
||||
*/
|
||||
int test_wc_CmacUpdate(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if defined(WOLFSSL_CMAC) && !defined(NO_AES) && defined(WOLFSSL_AES_128)
|
||||
Cmac cmac;
|
||||
byte key[] = {
|
||||
0x64, 0x4c, 0xbf, 0x12, 0x85, 0x9d, 0xf0, 0x55,
|
||||
0x7e, 0xa9, 0x1f, 0x08, 0xe0, 0x51, 0xff, 0x27
|
||||
};
|
||||
byte in[] = "\xe2\xb4\xb6\xf9\x48\x44\x02\x64"
|
||||
"\x5c\x47\x80\x9e\xd5\xa8\x3a\x17"
|
||||
"\xb3\x78\xcf\x85\x22\x41\x74\xd9"
|
||||
"\xa0\x97\x39\x71\x62\xf1\x8e\x8f"
|
||||
"\xf4";
|
||||
word32 inSz = (word32)sizeof(in) - 1;
|
||||
word32 keySz = (word32)sizeof(key);
|
||||
int type = WC_CMAC_AES;
|
||||
|
||||
XMEMSET(&cmac, 0, sizeof(Cmac));
|
||||
|
||||
ExpectIntEQ(wc_InitCmac(&cmac, key, keySz, type, NULL), 0);
|
||||
ExpectIntEQ(wc_CmacUpdate(&cmac, in, inSz), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_CmacUpdate(NULL, in, inSz), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CmacUpdate(&cmac, NULL, 30), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
wc_AesFree(&cmac.aes);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_CmacUpdate */
|
||||
|
||||
/*
|
||||
* Testing wc_CmacFinal()
|
||||
*/
|
||||
int test_wc_CmacFinal(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if defined(WOLFSSL_CMAC) && !defined(NO_AES) && defined(WOLFSSL_AES_128)
|
||||
Cmac cmac;
|
||||
byte key[] = {
|
||||
0x64, 0x4c, 0xbf, 0x12, 0x85, 0x9d, 0xf0, 0x55,
|
||||
0x7e, 0xa9, 0x1f, 0x08, 0xe0, 0x51, 0xff, 0x27
|
||||
};
|
||||
byte msg[] = {
|
||||
0xe2, 0xb4, 0xb6, 0xf9, 0x48, 0x44, 0x02, 0x64,
|
||||
0x5c, 0x47, 0x80, 0x9e, 0xd5, 0xa8, 0x3a, 0x17,
|
||||
0xb3, 0x78, 0xcf, 0x85, 0x22, 0x41, 0x74, 0xd9,
|
||||
0xa0, 0x97, 0x39, 0x71, 0x62, 0xf1, 0x8e, 0x8f,
|
||||
0xf4
|
||||
};
|
||||
/* Test vectors from CMACGenAES128.rsp from
|
||||
* http://csrc.nist.gov/groups/STM/cavp/block-cipher-modes.html#cmac
|
||||
* Per RFC4493 truncation of lsb is possible.
|
||||
*/
|
||||
byte expMac[] = {
|
||||
0x4e, 0x6e, 0xc5, 0x6f, 0xf9, 0x5d, 0x0e, 0xae,
|
||||
0x1c, 0xf8, 0x3e, 0xfc, 0xf4, 0x4b, 0xeb
|
||||
};
|
||||
byte mac[WC_AES_BLOCK_SIZE];
|
||||
word32 msgSz = (word32)sizeof(msg);
|
||||
word32 keySz = (word32)sizeof(key);
|
||||
word32 macSz = sizeof(mac);
|
||||
word32 badMacSz = 17;
|
||||
int expMacSz = sizeof(expMac);
|
||||
int type = WC_CMAC_AES;
|
||||
|
||||
XMEMSET(&cmac, 0, sizeof(Cmac));
|
||||
XMEMSET(mac, 0, macSz);
|
||||
|
||||
ExpectIntEQ(wc_InitCmac(&cmac, key, keySz, type, NULL), 0);
|
||||
ExpectIntEQ(wc_CmacUpdate(&cmac, msg, msgSz), 0);
|
||||
|
||||
#if (!defined(HAVE_FIPS) || FIPS_VERSION_GE(5, 3)) && !defined(HAVE_SELFTEST)
|
||||
/* Pass in bad args. */
|
||||
ExpectIntEQ(wc_CmacFinalNoFree(NULL, mac, &macSz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CmacFinalNoFree(&cmac, NULL, &macSz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CmacFinalNoFree(&cmac, mac, &badMacSz),
|
||||
WC_NO_ERR_TRACE(BUFFER_E));
|
||||
|
||||
/* For the last call, use the API with implicit wc_CmacFree(). */
|
||||
ExpectIntEQ(wc_CmacFinal(&cmac, mac, &macSz), 0);
|
||||
ExpectIntEQ(XMEMCMP(mac, expMac, expMacSz), 0);
|
||||
#else /* !HAVE_FIPS || FIPS>=5.3 */
|
||||
ExpectIntEQ(wc_CmacFinal(&cmac, mac, &macSz), 0);
|
||||
ExpectIntEQ(XMEMCMP(mac, expMac, expMacSz), 0);
|
||||
|
||||
/* Pass in bad args. */
|
||||
ExpectIntEQ(wc_CmacFinal(NULL, mac, &macSz), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CmacFinal(&cmac, NULL, &macSz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_CmacFinal(&cmac, mac, &badMacSz), WC_NO_ERR_TRACE(BUFFER_E));
|
||||
#endif /* !HAVE_FIPS || FIPS>=5.3 */
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_CmacFinal */
|
||||
|
||||
/*
|
||||
* Testing wc_AesCmacGenerate() && wc_AesCmacVerify()
|
||||
*/
|
||||
int test_wc_AesCmacGenerate(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if defined(WOLFSSL_CMAC) && !defined(NO_AES) && defined(WOLFSSL_AES_128)
|
||||
byte key[] = {
|
||||
0x26, 0xef, 0x8b, 0x40, 0x34, 0x11, 0x7d, 0x9e,
|
||||
0xbe, 0xc0, 0xc7, 0xfc, 0x31, 0x08, 0x54, 0x69
|
||||
};
|
||||
byte msg[] = "\x18\x90\x49\xef\xfd\x7c\xf9\xc8"
|
||||
"\xf3\x59\x65\xbc\xb0\x97\x8f\xd4";
|
||||
byte expMac[] = "\x29\x5f\x2f\x71\xfc\x58\xe6\xf6"
|
||||
"\x3d\x32\x65\x4c\x66\x23\xc5";
|
||||
byte mac[WC_AES_BLOCK_SIZE];
|
||||
word32 keySz = sizeof(key);
|
||||
word32 macSz = sizeof(mac);
|
||||
word32 msgSz = sizeof(msg) - 1;
|
||||
word32 expMacSz = sizeof(expMac) - 1;
|
||||
|
||||
XMEMSET(mac, 0, macSz);
|
||||
|
||||
ExpectIntEQ(wc_AesCmacGenerate(mac, &macSz, msg, msgSz, key, keySz), 0);
|
||||
ExpectIntEQ(XMEMCMP(mac, expMac, expMacSz), 0);
|
||||
|
||||
/* Pass in bad args. */
|
||||
ExpectIntEQ(wc_AesCmacGenerate(NULL, &macSz, msg, msgSz, key, keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_AesCmacGenerate(mac, &macSz, msg, msgSz, NULL, keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_AesCmacGenerate(mac, &macSz, msg, msgSz, key, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_AesCmacGenerate(mac, &macSz, NULL, msgSz, key, keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_AesCmacVerify(mac, macSz, msg, msgSz, key, keySz), 0);
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_AesCmacVerify(NULL, macSz, msg, msgSz, key, keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_AesCmacVerify(mac, 0, msg, msgSz, key, keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_AesCmacVerify(mac, macSz, msg, msgSz, NULL, keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_AesCmacVerify(mac, macSz, msg, msgSz, key, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_AesCmacVerify(mac, macSz, NULL, msgSz, key, keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
|
||||
} /* END test_wc_AesCmacGenerate */
|
||||
|
||||
30
tests/api/test_cmac.h
Normal file
30
tests/api/test_cmac.h
Normal file
@ -0,0 +1,30 @@
|
||||
/* test_cmac.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_CMAC_H
|
||||
#define WOLFCRYPT_TEST_CMAC_H
|
||||
|
||||
int test_wc_InitCmac(void);
|
||||
int test_wc_CmacUpdate(void);
|
||||
int test_wc_CmacFinal(void);
|
||||
int test_wc_AesCmacGenerate(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_CMAC_H */
|
||||
231
tests/api/test_des3.c
Normal file
231
tests/api/test_des3.c
Normal file
@ -0,0 +1,231 @@
|
||||
/* test_des3.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/des3.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_des3.h>
|
||||
|
||||
/*
|
||||
* unit test for wc_Des3_SetIV()
|
||||
*/
|
||||
int test_wc_Des3_SetIV(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifndef NO_DES3
|
||||
Des3 des;
|
||||
const byte key[] = {
|
||||
0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
|
||||
0xfe,0xde,0xba,0x98,0x76,0x54,0x32,0x10,
|
||||
0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67
|
||||
};
|
||||
const byte iv[] = {
|
||||
0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef,
|
||||
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
|
||||
0x11,0x21,0x31,0x41,0x51,0x61,0x71,0x81
|
||||
};
|
||||
|
||||
XMEMSET(&des, 0, sizeof(Des3));
|
||||
|
||||
ExpectIntEQ(wc_Des3Init(&des, NULL, INVALID_DEVID), 0);
|
||||
|
||||
/* DES_ENCRYPTION or DES_DECRYPTION */
|
||||
ExpectIntEQ(wc_Des3_SetKey(&des, key, iv, DES_ENCRYPTION), 0);
|
||||
ExpectIntEQ(XMEMCMP(iv, des.reg, DES_BLOCK_SIZE), 0);
|
||||
|
||||
#ifndef HAVE_FIPS /* no sanity checks with FIPS wrapper */
|
||||
/* Test explicitly wc_Des3_SetIV() */
|
||||
ExpectIntEQ(wc_Des3_SetIV(NULL, iv), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_SetIV(&des, NULL), 0);
|
||||
#endif
|
||||
wc_Des3Free(&des);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
|
||||
} /* END test_wc_Des3_SetIV */
|
||||
|
||||
/*
|
||||
* unit test for wc_Des3_SetKey()
|
||||
*/
|
||||
int test_wc_Des3_SetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifndef NO_DES3
|
||||
Des3 des;
|
||||
const byte key[] = {
|
||||
0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
|
||||
0xfe,0xde,0xba,0x98,0x76,0x54,0x32,0x10,
|
||||
0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67
|
||||
};
|
||||
const byte iv[] = {
|
||||
0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef,
|
||||
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
|
||||
0x11,0x21,0x31,0x41,0x51,0x61,0x71,0x81
|
||||
};
|
||||
|
||||
XMEMSET(&des, 0, sizeof(Des3));
|
||||
|
||||
ExpectIntEQ(wc_Des3Init(&des, NULL, INVALID_DEVID), 0);
|
||||
|
||||
/* DES_ENCRYPTION or DES_DECRYPTION */
|
||||
ExpectIntEQ(wc_Des3_SetKey(&des, key, iv, DES_ENCRYPTION), 0);
|
||||
ExpectIntEQ(XMEMCMP(iv, des.reg, DES_BLOCK_SIZE), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_Des3_SetKey(NULL, key, iv, DES_ENCRYPTION),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_SetKey(&des, NULL, iv, DES_ENCRYPTION),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_SetKey(&des, key, iv, -1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* Default case. Should return 0. */
|
||||
ExpectIntEQ(wc_Des3_SetKey(&des, key, NULL, DES_ENCRYPTION), 0);
|
||||
|
||||
wc_Des3Free(&des);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
|
||||
} /* END test_wc_Des3_SetKey */
|
||||
|
||||
/*
|
||||
* Test function for wc_Des3_CbcEncrypt and wc_Des3_CbcDecrypt
|
||||
*/
|
||||
int test_wc_Des3_CbcEncryptDecrypt(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifndef NO_DES3
|
||||
Des3 des;
|
||||
byte cipher[24];
|
||||
byte plain[24];
|
||||
const byte key[] = {
|
||||
0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
|
||||
0xfe,0xde,0xba,0x98,0x76,0x54,0x32,0x10,
|
||||
0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67
|
||||
};
|
||||
const byte iv[] = {
|
||||
0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef,
|
||||
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
|
||||
0x11,0x21,0x31,0x41,0x51,0x61,0x71,0x81
|
||||
};
|
||||
const byte vector[] = { /* "Now is the time for all " w/o trailing 0 */
|
||||
0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
|
||||
0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
|
||||
0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20
|
||||
};
|
||||
|
||||
XMEMSET(&des, 0, sizeof(Des3));
|
||||
|
||||
ExpectIntEQ(wc_Des3Init(&des, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_Des3_SetKey(&des, key, iv, DES_ENCRYPTION), 0);
|
||||
|
||||
ExpectIntEQ(wc_Des3_CbcEncrypt(&des, cipher, vector, 24), 0);
|
||||
ExpectIntEQ(wc_Des3_SetKey(&des, key, iv, DES_DECRYPTION), 0);
|
||||
ExpectIntEQ(wc_Des3_CbcDecrypt(&des, plain, cipher, 24), 0);
|
||||
ExpectIntEQ(XMEMCMP(plain, vector, 24), 0);
|
||||
|
||||
/* Pass in bad args. */
|
||||
ExpectIntEQ(wc_Des3_CbcEncrypt(NULL, cipher, vector, 24),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcEncrypt(&des, NULL, vector, 24),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcEncrypt(&des, cipher, NULL, sizeof(vector)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_Des3_CbcDecrypt(NULL, plain, cipher, 24),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcDecrypt(&des, NULL, cipher, 24),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcDecrypt(&des, plain, NULL, 24),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
wc_Des3Free(&des);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
|
||||
} /* END wc_Des3_CbcEncrypt */
|
||||
|
||||
/*
|
||||
* Unit test for wc_Des3_EcbEncrypt
|
||||
*/
|
||||
int test_wc_Des3_EcbEncrypt(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_DES3) && defined(WOLFSSL_DES_ECB)
|
||||
Des3 des;
|
||||
byte cipher[24];
|
||||
word32 cipherSz = sizeof(cipher);
|
||||
const byte key[] = {
|
||||
0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
|
||||
0xfe,0xde,0xba,0x98,0x76,0x54,0x32,0x10,
|
||||
0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67
|
||||
};
|
||||
const byte iv[] = {
|
||||
0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef,
|
||||
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
|
||||
0x11,0x21,0x31,0x41,0x51,0x61,0x71,0x81
|
||||
};
|
||||
const byte vector[] = { /* "Now is the time for all " w/o trailing 0 */
|
||||
0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
|
||||
0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
|
||||
0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20
|
||||
};
|
||||
|
||||
XMEMSET(&des, 0, sizeof(Des3));
|
||||
|
||||
ExpectIntEQ(wc_Des3Init(&des, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_Des3_SetKey(&des, key, iv, DES_ENCRYPTION), 0);
|
||||
|
||||
/* Bad Cases */
|
||||
ExpectIntEQ(wc_Des3_EcbEncrypt(NULL, 0, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_EcbEncrypt(NULL, cipher, vector, cipherSz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_EcbEncrypt(&des, 0, vector, cipherSz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_EcbEncrypt(&des, cipher, NULL, cipherSz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_EcbEncrypt(&des, cipher, vector, 0), 0);
|
||||
|
||||
/* Good Cases */
|
||||
ExpectIntEQ(wc_Des3_EcbEncrypt(&des, cipher, vector, cipherSz), 0);
|
||||
|
||||
wc_Des3Free(&des);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Des3_EcbEncrypt */
|
||||
|
||||
30
tests/api/test_des3.h
Normal file
30
tests/api/test_des3.h
Normal file
@ -0,0 +1,30 @@
|
||||
/* test_des3.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_DES3_H
|
||||
#define WOLFCRYPT_TEST_DES3_H
|
||||
|
||||
int test_wc_Des3_SetIV(void);
|
||||
int test_wc_Des3_SetKey(void);
|
||||
int test_wc_Des3_CbcEncryptDecrypt(void);
|
||||
int test_wc_Des3_EcbEncrypt(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_DES3_H */
|
||||
691
tests/api/test_hmac.c
Normal file
691
tests/api/test_hmac.c
Normal file
@ -0,0 +1,691 @@
|
||||
/* test_cmac.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/hmac.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_hmac.h>
|
||||
|
||||
/*
|
||||
* Test function for wc_HmacSetKey
|
||||
*/
|
||||
int test_wc_Md5HmacSetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && !defined(NO_MD5)
|
||||
Hmac hmac;
|
||||
int ret, times, itr;
|
||||
|
||||
const char* keys[]=
|
||||
{
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b",
|
||||
#ifndef HAVE_FIPS
|
||||
"Jefe", /* smaller than minimum FIPS key size */
|
||||
#endif
|
||||
"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
|
||||
};
|
||||
times = sizeof(keys) / sizeof(char*);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
|
||||
for (itr = 0; itr < times; itr++) {
|
||||
ret = wc_HmacSetKey(&hmac, WC_MD5, (byte*)keys[itr],
|
||||
(word32)XSTRLEN(keys[itr]));
|
||||
#if defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 5)
|
||||
wc_HmacFree(&hmac);
|
||||
ExpectIntEQ(ret, WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#else
|
||||
ExpectIntEQ(ret, 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Bad args. */
|
||||
ExpectIntEQ(wc_HmacSetKey(NULL, WC_MD5, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_MD5, NULL, (word32)XSTRLEN(keys[0])),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, 21, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ret = wc_HmacSetKey(&hmac, WC_MD5, (byte*)keys[0], 0);
|
||||
#if defined(HAVE_FIPS_VERSION) && (HAVE_FIPS_VERSION >= 5)
|
||||
ExpectIntEQ(ret, WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#elif defined(HAVE_FIPS)
|
||||
ExpectIntEQ(ret, WC_NO_ERR_TRACE(HMAC_MIN_KEYLEN_E));
|
||||
#else
|
||||
ExpectIntEQ(ret, 0);
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Md5HmacSetKey */
|
||||
|
||||
/*
|
||||
* testing wc_HmacSetKey() on wc_Sha hash.
|
||||
*/
|
||||
int test_wc_ShaHmacSetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && !defined(NO_SHA)
|
||||
Hmac hmac;
|
||||
int ret, times, itr;
|
||||
|
||||
const char* keys[]=
|
||||
{
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
|
||||
"\x0b\x0b\x0b",
|
||||
#ifndef HAVE_FIPS
|
||||
"Jefe", /* smaller than minimum FIPS key size */
|
||||
#endif
|
||||
"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
|
||||
"\xAA\xAA\xAA"
|
||||
};
|
||||
|
||||
times = sizeof(keys) / sizeof(char*);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
|
||||
for (itr = 0; itr < times; itr++) {
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA, (byte*)keys[itr],
|
||||
(word32)XSTRLEN(keys[itr])), 0);
|
||||
}
|
||||
|
||||
/* Bad args. */
|
||||
ExpectIntEQ(wc_HmacSetKey(NULL, WC_SHA, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA, NULL, (word32)XSTRLEN(keys[0])),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, 21, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ret = wc_HmacSetKey(&hmac, WC_SHA, (byte*)keys[0], 0);
|
||||
#ifdef HAVE_FIPS
|
||||
ExpectIntEQ(ret, WC_NO_ERR_TRACE(HMAC_MIN_KEYLEN_E));
|
||||
#else
|
||||
ExpectIntEQ(ret, 0);
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_ShaHmacSetKey() */
|
||||
|
||||
/*
|
||||
* testing wc_HmacSetKey() on Sha224 hash.
|
||||
*/
|
||||
int test_wc_Sha224HmacSetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && defined(WOLFSSL_SHA224)
|
||||
Hmac hmac;
|
||||
int ret, times, itr;
|
||||
|
||||
const char* keys[]=
|
||||
{
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
|
||||
"\x0b\x0b\x0b",
|
||||
#ifndef HAVE_FIPS
|
||||
"Jefe", /* smaller than minimum FIPS key size */
|
||||
#endif
|
||||
"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
|
||||
"\xAA\xAA\xAA"
|
||||
};
|
||||
times = sizeof(keys) / sizeof(char*);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
|
||||
for (itr = 0; itr < times; itr++) {
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA224, (byte*)keys[itr],
|
||||
(word32)XSTRLEN(keys[itr])), 0);
|
||||
}
|
||||
|
||||
/* Bad args. */
|
||||
ExpectIntEQ(wc_HmacSetKey(NULL, WC_SHA224, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA224, NULL, (word32)XSTRLEN(keys[0])),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, 21, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ret = wc_HmacSetKey(&hmac, WC_SHA224, (byte*)keys[0], 0);
|
||||
#ifdef HAVE_FIPS
|
||||
ExpectIntEQ(ret, WC_NO_ERR_TRACE(HMAC_MIN_KEYLEN_E));
|
||||
#else
|
||||
ExpectIntEQ(ret, 0);
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Sha224HmacSetKey() */
|
||||
|
||||
/*
|
||||
* testing wc_HmacSetKey() on Sha256 hash
|
||||
*/
|
||||
int test_wc_Sha256HmacSetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && !defined(NO_SHA256)
|
||||
Hmac hmac;
|
||||
int ret, times, itr;
|
||||
|
||||
const char* keys[]=
|
||||
{
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
|
||||
"\x0b\x0b\x0b",
|
||||
#ifndef HAVE_FIPS
|
||||
"Jefe", /* smaller than minimum FIPS key size */
|
||||
#endif
|
||||
"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
|
||||
"\xAA\xAA\xAA"
|
||||
};
|
||||
times = sizeof(keys) / sizeof(char*);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
|
||||
for (itr = 0; itr < times; itr++) {
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA256, (byte*)keys[itr],
|
||||
(word32)XSTRLEN(keys[itr])), 0);
|
||||
}
|
||||
|
||||
/* Bad args. */
|
||||
ExpectIntEQ(wc_HmacSetKey(NULL, WC_SHA256, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA256, NULL, (word32)XSTRLEN(keys[0])),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, 21, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ret = wc_HmacSetKey(&hmac, WC_SHA256, (byte*)keys[0], 0);
|
||||
#ifdef HAVE_FIPS
|
||||
ExpectIntEQ(ret, WC_NO_ERR_TRACE(HMAC_MIN_KEYLEN_E));
|
||||
#else
|
||||
ExpectIntEQ(ret, 0);
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Sha256HmacSetKey() */
|
||||
|
||||
/*
|
||||
* testing wc_HmacSetKey on Sha384 hash.
|
||||
*/
|
||||
int test_wc_Sha384HmacSetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && defined(WOLFSSL_SHA384)
|
||||
Hmac hmac;
|
||||
int ret, times, itr;
|
||||
|
||||
const char* keys[]=
|
||||
{
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
|
||||
"\x0b\x0b\x0b",
|
||||
#ifndef HAVE_FIPS
|
||||
"Jefe", /* smaller than minimum FIPS key size */
|
||||
#endif
|
||||
"\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
|
||||
"\xAA\xAA\xAA"
|
||||
};
|
||||
times = sizeof(keys) / sizeof(char*);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
|
||||
for (itr = 0; itr < times; itr++) {
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA384, (byte*)keys[itr],
|
||||
(word32)XSTRLEN(keys[itr])), 0);
|
||||
}
|
||||
|
||||
/* Bad args. */
|
||||
ExpectIntEQ(wc_HmacSetKey(NULL, WC_SHA384, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA384, NULL, (word32)XSTRLEN(keys[0])),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, 21, (byte*)keys[0],
|
||||
(word32)XSTRLEN(keys[0])), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ret = wc_HmacSetKey(&hmac, WC_SHA384, (byte*)keys[0], 0);
|
||||
#ifdef HAVE_FIPS
|
||||
ExpectIntEQ(ret, WC_NO_ERR_TRACE(HMAC_MIN_KEYLEN_E));
|
||||
#else
|
||||
ExpectIntEQ(ret, 0);
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Sha384HmacSetKey() */
|
||||
|
||||
/*
|
||||
* testing wc_HmacUpdate on wc_Md5 hash.
|
||||
*/
|
||||
int test_wc_Md5HmacUpdate(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && !defined(NO_MD5) && !(defined(HAVE_FIPS_VERSION) && \
|
||||
(HAVE_FIPS_VERSION >= 5))
|
||||
Hmac hmac;
|
||||
testVector a, b;
|
||||
#ifdef HAVE_FIPS
|
||||
const char* keys =
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
|
||||
#else
|
||||
const char* keys = "Jefe";
|
||||
#endif
|
||||
|
||||
a.input = "what do ya want for nothing?";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
b.input = "Hi There";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_MD5, (byte*)keys,
|
||||
(word32)XSTRLEN(keys)), 0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)b.input, (word32)b.inLen), 0);
|
||||
/* Update Hmac. */
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_HmacUpdate(NULL, (byte*)a.input, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, NULL, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, 0), 0);
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Md5HmacUpdate */
|
||||
|
||||
/*
|
||||
* testing wc_HmacUpdate on SHA hash.
|
||||
*/
|
||||
int test_wc_ShaHmacUpdate(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && !defined(NO_SHA)
|
||||
Hmac hmac;
|
||||
testVector a, b;
|
||||
#ifdef HAVE_FIPS
|
||||
const char* keys =
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
|
||||
#else
|
||||
const char* keys = "Jefe";
|
||||
#endif
|
||||
|
||||
a.input = "what do ya want for nothing?";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
b.input = "Hi There";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA, (byte*)keys,
|
||||
(word32)XSTRLEN(keys)), 0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)b.input, (word32)b.inLen), 0);
|
||||
/* Update Hmac. */
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_HmacUpdate(NULL, (byte*)a.input, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, NULL, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, 0), 0);
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_ShaHmacUpdate */
|
||||
|
||||
/*
|
||||
* testing wc_HmacUpdate on SHA224 hash.
|
||||
*/
|
||||
int test_wc_Sha224HmacUpdate(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && defined(WOLFSSL_SHA224)
|
||||
Hmac hmac;
|
||||
testVector a, b;
|
||||
#ifdef HAVE_FIPS
|
||||
const char* keys =
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
|
||||
#else
|
||||
const char* keys = "Jefe";
|
||||
#endif
|
||||
|
||||
a.input = "what do ya want for nothing?";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
b.input = "Hi There";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA224, (byte*)keys,
|
||||
(word32)XSTRLEN(keys)), 0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)b.input, (word32)b.inLen), 0);
|
||||
/* Update Hmac. */
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_HmacUpdate(NULL, (byte*)a.input, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, NULL, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, 0), 0);
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Sha224HmacUpdate */
|
||||
|
||||
/*
|
||||
* testing wc_HmacUpdate on SHA256 hash.
|
||||
*/
|
||||
int test_wc_Sha256HmacUpdate(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && !defined(NO_SHA256)
|
||||
Hmac hmac;
|
||||
testVector a, b;
|
||||
#ifdef HAVE_FIPS
|
||||
const char* keys =
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
|
||||
#else
|
||||
const char* keys = "Jefe";
|
||||
#endif
|
||||
|
||||
a.input = "what do ya want for nothing?";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
b.input = "Hi There";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA256, (byte*)keys,
|
||||
(word32)XSTRLEN(keys)), 0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)b.input, (word32)b.inLen), 0);
|
||||
/* Update Hmac. */
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_HmacUpdate(NULL, (byte*)a.input, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, NULL, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, 0), 0);
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Sha256HmacUpdate */
|
||||
|
||||
/*
|
||||
* testing wc_HmacUpdate on SHA384 hash.
|
||||
*/
|
||||
int test_wc_Sha384HmacUpdate(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && defined(WOLFSSL_SHA384)
|
||||
Hmac hmac;
|
||||
testVector a, b;
|
||||
#ifdef HAVE_FIPS
|
||||
const char* keys =
|
||||
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
|
||||
#else
|
||||
const char* keys = "Jefe";
|
||||
#endif
|
||||
|
||||
a.input = "what do ya want for nothing?";
|
||||
a.inLen = XSTRLEN(a.input);
|
||||
b.input = "Hi There";
|
||||
b.inLen = XSTRLEN(b.input);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA384, (byte*)keys,
|
||||
(word32)XSTRLEN(keys)), 0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)b.input, (word32)b.inLen), 0);
|
||||
/* Update Hmac. */
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_HmacUpdate(NULL, (byte*)a.input, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, NULL, (word32)a.inLen),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, 0), 0);
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Sha384HmacUpdate */
|
||||
|
||||
/*
|
||||
* Testing wc_HmacFinal() with MD5
|
||||
*/
|
||||
|
||||
int test_wc_Md5HmacFinal(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && !defined(NO_MD5) && !(defined(HAVE_FIPS_VERSION) && \
|
||||
(HAVE_FIPS_VERSION >= 5))
|
||||
Hmac hmac;
|
||||
byte hash[WC_MD5_DIGEST_SIZE];
|
||||
testVector a;
|
||||
const char* key;
|
||||
|
||||
key = "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b";
|
||||
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);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_MD5, (byte*)key, (word32)XSTRLEN(key)),
|
||||
0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, hash), 0);
|
||||
ExpectIntEQ(XMEMCMP(hash, a.output, WC_MD5_DIGEST_SIZE), 0);
|
||||
|
||||
/* Try bad parameters. */
|
||||
ExpectIntEQ(wc_HmacFinal(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#ifndef HAVE_FIPS
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Md5HmacFinal */
|
||||
|
||||
/*
|
||||
* Testing wc_HmacFinal() with SHA
|
||||
*/
|
||||
int test_wc_ShaHmacFinal(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && !defined(NO_SHA)
|
||||
Hmac hmac;
|
||||
byte hash[WC_SHA_DIGEST_SIZE];
|
||||
testVector a;
|
||||
const char* key;
|
||||
|
||||
key = "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
|
||||
"\x0b\x0b\x0b";
|
||||
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);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA, (byte*)key, (word32)XSTRLEN(key)),
|
||||
0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, hash), 0);
|
||||
ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA_DIGEST_SIZE), 0);
|
||||
|
||||
/* Try bad parameters. */
|
||||
ExpectIntEQ(wc_HmacFinal(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#ifndef HAVE_FIPS
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_ShaHmacFinal */
|
||||
|
||||
/*
|
||||
* Testing wc_HmacFinal() with SHA224
|
||||
*/
|
||||
int test_wc_Sha224HmacFinal(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && defined(WOLFSSL_SHA224)
|
||||
Hmac hmac;
|
||||
byte hash[WC_SHA224_DIGEST_SIZE];
|
||||
testVector a;
|
||||
const char* key;
|
||||
|
||||
key = "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
|
||||
"\x0b\x0b\x0b";
|
||||
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 = XSTRLEN(a.output);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA224, (byte*)key,
|
||||
(word32)XSTRLEN(key)), 0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, hash), 0);
|
||||
ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA224_DIGEST_SIZE), 0);
|
||||
|
||||
/* Try bad parameters. */
|
||||
ExpectIntEQ(wc_HmacFinal(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#ifndef HAVE_FIPS
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Sha224HmacFinal */
|
||||
|
||||
/*
|
||||
* Testing wc_HmacFinal() with SHA256
|
||||
*/
|
||||
int test_wc_Sha256HmacFinal(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && !defined(NO_SHA256)
|
||||
Hmac hmac;
|
||||
byte hash[WC_SHA256_DIGEST_SIZE];
|
||||
testVector a;
|
||||
const char* key;
|
||||
|
||||
key = "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
|
||||
"\x0b\x0b\x0b";
|
||||
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);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA256, (byte*)key,
|
||||
(word32)XSTRLEN(key)), 0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, hash), 0);
|
||||
ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA256_DIGEST_SIZE), 0);
|
||||
|
||||
/* Try bad parameters. */
|
||||
ExpectIntEQ(wc_HmacFinal(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#ifndef HAVE_FIPS
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Sha256HmacFinal */
|
||||
|
||||
/*
|
||||
* Testing wc_HmacFinal() with SHA384
|
||||
*/
|
||||
int test_wc_Sha384HmacFinal(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#if !defined(NO_HMAC) && defined(WOLFSSL_SHA384)
|
||||
Hmac hmac;
|
||||
byte hash[WC_SHA384_DIGEST_SIZE];
|
||||
testVector a;
|
||||
const char* key;
|
||||
|
||||
key = "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
|
||||
"\x0b\x0b\x0b";
|
||||
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);
|
||||
|
||||
ExpectIntEQ(wc_HmacInit(&hmac, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_HmacSetKey(&hmac, WC_SHA384, (byte*)key,
|
||||
(word32)XSTRLEN(key)), 0);
|
||||
ExpectIntEQ(wc_HmacUpdate(&hmac, (byte*)a.input, (word32)a.inLen), 0);
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, hash), 0);
|
||||
ExpectIntEQ(XMEMCMP(hash, a.output, WC_SHA384_DIGEST_SIZE), 0);
|
||||
|
||||
/* Try bad parameters. */
|
||||
ExpectIntEQ(wc_HmacFinal(NULL, hash), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#ifndef HAVE_FIPS
|
||||
ExpectIntEQ(wc_HmacFinal(&hmac, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
|
||||
wc_HmacFree(&hmac);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Sha384HmacFinal */
|
||||
|
||||
41
tests/api/test_hmac.h
Normal file
41
tests/api/test_hmac.h
Normal file
@ -0,0 +1,41 @@
|
||||
/* test_hmac.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_HMAC_H
|
||||
#define WOLFCRYPT_TEST_HMAC_H
|
||||
|
||||
int test_wc_Md5HmacSetKey(void);
|
||||
int test_wc_Md5HmacUpdate(void);
|
||||
int test_wc_Md5HmacFinal(void);
|
||||
int test_wc_ShaHmacSetKey(void);
|
||||
int test_wc_ShaHmacUpdate(void);
|
||||
int test_wc_ShaHmacFinal(void);
|
||||
int test_wc_Sha224HmacSetKey(void);
|
||||
int test_wc_Sha224HmacUpdate(void);
|
||||
int test_wc_Sha224HmacFinal(void);
|
||||
int test_wc_Sha256HmacSetKey(void);
|
||||
int test_wc_Sha256HmacUpdate(void);
|
||||
int test_wc_Sha256HmacFinal(void);
|
||||
int test_wc_Sha384HmacSetKey(void);
|
||||
int test_wc_Sha384HmacUpdate(void);
|
||||
int test_wc_Sha384HmacFinal(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_HMAC_H */
|
||||
73
tests/api/test_poly1305.c
Normal file
73
tests/api/test_poly1305.c
Normal file
@ -0,0 +1,73 @@
|
||||
/* test_poly1305.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/poly1305.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_poly1305.h>
|
||||
|
||||
/*
|
||||
* unit test for wc_Poly1305SetKey()
|
||||
*/
|
||||
int test_wc_Poly1305SetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef HAVE_POLY1305
|
||||
Poly1305 ctx;
|
||||
const byte key[] =
|
||||
{
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01
|
||||
};
|
||||
word32 keySz = (word32)(sizeof(key)/sizeof(byte));
|
||||
|
||||
ExpectIntEQ(wc_Poly1305SetKey(&ctx, key, keySz), 0);
|
||||
|
||||
/* Test bad args. */
|
||||
ExpectIntEQ(wc_Poly1305SetKey(NULL, key,keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Poly1305SetKey(&ctx, NULL, keySz),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Poly1305SetKey(&ctx, key, 18),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Poly1305_SetKey() */
|
||||
|
||||
27
tests/api/test_poly1305.h
Normal file
27
tests/api/test_poly1305.h
Normal file
@ -0,0 +1,27 @@
|
||||
/* test_poly1305.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_POLY1305_H
|
||||
#define WOLFCRYPT_TEST_POLY1305_H
|
||||
|
||||
int test_wc_Poly1305SetKey(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_POLY1305_H */
|
||||
230
tests/api/test_rc2.c
Normal file
230
tests/api/test_rc2.c
Normal file
@ -0,0 +1,230 @@
|
||||
/* test_rc2.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/rc2.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_rc2.h>
|
||||
|
||||
/*
|
||||
* Testing function for wc_Rc2SetKey().
|
||||
*/
|
||||
int test_wc_Rc2SetKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef WC_RC2
|
||||
Rc2 rc2;
|
||||
byte key40[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
|
||||
byte iv[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
|
||||
|
||||
/* valid key and IV */
|
||||
ExpectIntEQ(wc_Rc2SetKey(&rc2, key40, (word32) sizeof(key40) / sizeof(byte),
|
||||
iv, 40), 0);
|
||||
/* valid key, no IV */
|
||||
ExpectIntEQ(wc_Rc2SetKey(&rc2, key40, (word32) sizeof(key40) / sizeof(byte),
|
||||
NULL, 40), 0);
|
||||
|
||||
/* bad arguments */
|
||||
/* null Rc2 struct */
|
||||
ExpectIntEQ(wc_Rc2SetKey(NULL, key40, (word32) sizeof(key40) / sizeof(byte),
|
||||
iv, 40), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* null key */
|
||||
ExpectIntEQ(wc_Rc2SetKey(&rc2, NULL, (word32) sizeof(key40) / sizeof(byte),
|
||||
iv, 40), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* key size == 0 */
|
||||
ExpectIntEQ(wc_Rc2SetKey(&rc2, key40, 0, iv, 40),
|
||||
WC_NO_ERR_TRACE(WC_KEY_SIZE_E));
|
||||
/* key size > 128 */
|
||||
ExpectIntEQ(wc_Rc2SetKey(&rc2, key40, 129, iv, 40),
|
||||
WC_NO_ERR_TRACE(WC_KEY_SIZE_E));
|
||||
/* effective bits == 0 */
|
||||
ExpectIntEQ(wc_Rc2SetKey(&rc2, key40, (word32)sizeof(key40) / sizeof(byte),
|
||||
iv, 0), WC_NO_ERR_TRACE(WC_KEY_SIZE_E));
|
||||
/* effective bits > 1024 */
|
||||
ExpectIntEQ(wc_Rc2SetKey(&rc2, key40, (word32)sizeof(key40) / sizeof(byte),
|
||||
iv, 1025), WC_NO_ERR_TRACE(WC_KEY_SIZE_E));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Rc2SetKey */
|
||||
|
||||
/*
|
||||
* Testing function for wc_Rc2SetIV().
|
||||
*/
|
||||
int test_wc_Rc2SetIV(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef WC_RC2
|
||||
Rc2 rc2;
|
||||
byte iv[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
|
||||
|
||||
/* valid IV */
|
||||
ExpectIntEQ(wc_Rc2SetIV(&rc2, iv), 0);
|
||||
/* valid NULL IV */
|
||||
ExpectIntEQ(wc_Rc2SetIV(&rc2, NULL), 0);
|
||||
|
||||
/* bad arguments */
|
||||
ExpectIntEQ(wc_Rc2SetIV(NULL, iv), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Rc2SetIV(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Rc2SetIV */
|
||||
|
||||
/*
|
||||
* Testing function for wc_Rc2EcbEncrypt() and wc_Rc2EcbDecrypt().
|
||||
*/
|
||||
int test_wc_Rc2EcbEncryptDecrypt(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef WC_RC2
|
||||
Rc2 rc2;
|
||||
int effectiveKeyBits = 63;
|
||||
byte cipher[RC2_BLOCK_SIZE];
|
||||
byte plain[RC2_BLOCK_SIZE];
|
||||
byte key[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||||
byte input[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
||||
byte output[] = { 0xeb, 0xb7, 0x73, 0xf9, 0x93, 0x27, 0x8e, 0xff };
|
||||
|
||||
XMEMSET(cipher, 0, sizeof(cipher));
|
||||
XMEMSET(plain, 0, sizeof(plain));
|
||||
|
||||
ExpectIntEQ(wc_Rc2SetKey(&rc2, key, (word32) sizeof(key) / sizeof(byte),
|
||||
NULL, effectiveKeyBits), 0);
|
||||
ExpectIntEQ(wc_Rc2EcbEncrypt(&rc2, cipher, input, RC2_BLOCK_SIZE), 0);
|
||||
ExpectIntEQ(XMEMCMP(cipher, output, RC2_BLOCK_SIZE), 0);
|
||||
|
||||
ExpectIntEQ(wc_Rc2EcbDecrypt(&rc2, plain, cipher, RC2_BLOCK_SIZE), 0);
|
||||
ExpectIntEQ(XMEMCMP(plain, input, RC2_BLOCK_SIZE), 0);
|
||||
|
||||
/* Rc2EcbEncrypt bad arguments */
|
||||
/* null Rc2 struct */
|
||||
ExpectIntEQ(wc_Rc2EcbEncrypt(NULL, cipher, input, RC2_BLOCK_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* null out buffer */
|
||||
ExpectIntEQ(wc_Rc2EcbEncrypt(&rc2, NULL, input, RC2_BLOCK_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* null input buffer */
|
||||
ExpectIntEQ(wc_Rc2EcbEncrypt(&rc2, cipher, NULL, RC2_BLOCK_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* output buffer sz != RC2_BLOCK_SIZE (8) */
|
||||
ExpectIntEQ(wc_Rc2EcbEncrypt(&rc2, cipher, input, 7),
|
||||
WC_NO_ERR_TRACE(BUFFER_E));
|
||||
|
||||
/* Rc2EcbDecrypt bad arguments */
|
||||
/* null Rc2 struct */
|
||||
ExpectIntEQ(wc_Rc2EcbDecrypt(NULL, plain, output, RC2_BLOCK_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* null out buffer */
|
||||
ExpectIntEQ(wc_Rc2EcbDecrypt(&rc2, NULL, output, RC2_BLOCK_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* null input buffer */
|
||||
ExpectIntEQ(wc_Rc2EcbDecrypt(&rc2, plain, NULL, RC2_BLOCK_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* output buffer sz != RC2_BLOCK_SIZE (8) */
|
||||
ExpectIntEQ(wc_Rc2EcbDecrypt(&rc2, plain, output, 7),
|
||||
WC_NO_ERR_TRACE(BUFFER_E));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Rc2EcbEncryptDecrypt */
|
||||
|
||||
/*
|
||||
* Testing function for wc_Rc2CbcEncrypt() and wc_Rc2CbcDecrypt().
|
||||
*/
|
||||
int test_wc_Rc2CbcEncryptDecrypt(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifdef WC_RC2
|
||||
Rc2 rc2;
|
||||
int effectiveKeyBits = 63;
|
||||
byte cipher[RC2_BLOCK_SIZE*2];
|
||||
byte plain[RC2_BLOCK_SIZE*2];
|
||||
/* vector taken from test.c */
|
||||
byte key[] = {
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
byte iv[] = {
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
byte input[] = {
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
byte output[] = {
|
||||
0xeb, 0xb7, 0x73, 0xf9, 0x93, 0x27, 0x8e, 0xff,
|
||||
0xf0, 0x51, 0x77, 0x8b, 0x65, 0xdb, 0x13, 0x57
|
||||
};
|
||||
|
||||
XMEMSET(cipher, 0, sizeof(cipher));
|
||||
XMEMSET(plain, 0, sizeof(plain));
|
||||
|
||||
ExpectIntEQ(wc_Rc2SetKey(&rc2, key, (word32) sizeof(key) / sizeof(byte),
|
||||
iv, effectiveKeyBits), 0);
|
||||
ExpectIntEQ(wc_Rc2CbcEncrypt(&rc2, cipher, input, sizeof(input)), 0);
|
||||
ExpectIntEQ(XMEMCMP(cipher, output, sizeof(output)), 0);
|
||||
|
||||
/* reset IV for decrypt */
|
||||
ExpectIntEQ(wc_Rc2SetIV(&rc2, iv), 0);
|
||||
ExpectIntEQ(wc_Rc2CbcDecrypt(&rc2, plain, cipher, sizeof(cipher)), 0);
|
||||
ExpectIntEQ(XMEMCMP(plain, input, sizeof(input)), 0);
|
||||
|
||||
/* Rc2CbcEncrypt bad arguments */
|
||||
/* null Rc2 struct */
|
||||
ExpectIntEQ(wc_Rc2CbcEncrypt(NULL, cipher, input, sizeof(input)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* null out buffer */
|
||||
ExpectIntEQ(wc_Rc2CbcEncrypt(&rc2, NULL, input, sizeof(input)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* null input buffer */
|
||||
ExpectIntEQ(wc_Rc2CbcEncrypt(&rc2, cipher, NULL, sizeof(input)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Rc2CbcDecrypt bad arguments */
|
||||
/* in size is 0 */
|
||||
ExpectIntEQ(wc_Rc2CbcDecrypt(&rc2, plain, output, 0), 0);
|
||||
/* null Rc2 struct */
|
||||
ExpectIntEQ(wc_Rc2CbcDecrypt(NULL, plain, output, sizeof(output)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* null out buffer */
|
||||
ExpectIntEQ(wc_Rc2CbcDecrypt(&rc2, NULL, output, sizeof(output)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
/* null input buffer */
|
||||
ExpectIntEQ(wc_Rc2CbcDecrypt(&rc2, plain, NULL, sizeof(output)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Rc2CbcEncryptDecrypt */
|
||||
|
||||
30
tests/api/test_rc2.h
Normal file
30
tests/api/test_rc2.h
Normal file
@ -0,0 +1,30 @@
|
||||
/* test_rc2.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_RC2_H
|
||||
#define WOLFCRYPT_TEST_RC2_H
|
||||
|
||||
int test_wc_Rc2SetKey(void);
|
||||
int test_wc_Rc2SetIV(void);
|
||||
int test_wc_Rc2EcbEncryptDecrypt(void);
|
||||
int test_wc_Rc2CbcEncryptDecrypt(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_RC2_H */
|
||||
795
tests/api/test_sm4.c
Normal file
795
tests/api/test_sm4.c
Normal file
@ -0,0 +1,795 @@
|
||||
/* test_sm4.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/sm4.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_sm4.h>
|
||||
|
||||
/*
|
||||
* Testing streaming SM4 API.
|
||||
*/
|
||||
int test_wc_Sm4(void)
|
||||
{
|
||||
int res = TEST_SKIPPED;
|
||||
#ifdef WOLFSSL_SM4
|
||||
EXPECT_DECLS;
|
||||
wc_Sm4 sm4;
|
||||
#if defined(WOLFSSL_SM4_ECB) || defined(WOLFSSL_SM4_CBC) || \
|
||||
defined(WOLFSSL_SM4_CTR) || defined(WOLFSSL_SM4_CCM)
|
||||
unsigned char key[SM4_KEY_SIZE];
|
||||
#endif
|
||||
#if defined(WOLFSSL_SM4_CBC) || defined(WOLFSSL_SM4_CTR)
|
||||
unsigned char iv[SM4_IV_SIZE];
|
||||
#endif
|
||||
|
||||
/* Invalid parameters - wc_Sm4Init */
|
||||
ExpectIntEQ(wc_Sm4Init(NULL, NULL, INVALID_DEVID),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid cases - wc_Sm4Init */
|
||||
ExpectIntEQ(wc_Sm4Init(&sm4, NULL, INVALID_DEVID), 0);
|
||||
|
||||
#if defined(WOLFSSL_SM4_ECB) || defined(WOLFSSL_SM4_CBC) || \
|
||||
defined(WOLFSSL_SM4_CTR) || defined(WOLFSSL_SM4_CCM)
|
||||
XMEMSET(key, 0, sizeof(key));
|
||||
|
||||
/* Invalid parameters - wc_Sm4SetKey. */
|
||||
ExpectIntEQ(wc_Sm4SetKey(NULL, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetKey(NULL, key, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetKey(NULL, NULL, SM4_KEY_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, key, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, NULL, SM4_KEY_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetKey(NULL, key, SM4_KEY_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, key, SM4_KEY_SIZE-1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, key, SM4_KEY_SIZE+1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid cases - wc_Sm4SetKey. */
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, key, SM4_KEY_SIZE), 0);
|
||||
#endif
|
||||
|
||||
#if defined(WOLFSSL_SM4_CBC) || defined(WOLFSSL_SM4_CTR)
|
||||
XMEMSET(iv, 0, sizeof(iv));
|
||||
|
||||
/* Invalid parameters - wc_Sm4SetIV. */
|
||||
ExpectIntEQ(wc_Sm4SetIV(NULL, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, NULL), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4SetIV(NULL, iv), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid cases - wc_Sm4SetIV. */
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
#endif
|
||||
|
||||
/* Valid cases - wc_Sm4Free */
|
||||
wc_Sm4Free(NULL);
|
||||
wc_Sm4Free(&sm4);
|
||||
|
||||
res = EXPECT_RESULT();
|
||||
#endif
|
||||
return res;
|
||||
} /* END test_wc_Sm4 */
|
||||
|
||||
/*
|
||||
* Testing block based SM4-ECB API.
|
||||
*/
|
||||
int test_wc_Sm4Ecb(void)
|
||||
{
|
||||
int res = TEST_SKIPPED;
|
||||
#ifdef WOLFSSL_SM4_ECB
|
||||
EXPECT_DECLS;
|
||||
wc_Sm4 sm4;
|
||||
unsigned char key[SM4_KEY_SIZE];
|
||||
unsigned char in[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char out[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char out2[SM4_BLOCK_SIZE];
|
||||
|
||||
XMEMSET(key, 0, sizeof(key));
|
||||
XMEMSET(in, 0, sizeof(in));
|
||||
|
||||
ExpectIntEQ(wc_Sm4Init(&sm4, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(&sm4, out, in, 0),
|
||||
WC_NO_ERR_TRACE(MISSING_KEY));
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(&sm4, out, in, 0),
|
||||
WC_NO_ERR_TRACE(MISSING_KEY));
|
||||
|
||||
/* Tested in test_wc_Sm4. */
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, key, SM4_KEY_SIZE), 0);
|
||||
|
||||
/* Invalid parameters - wc_Sm4EcbEncrypt. */
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(NULL, NULL, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(&sm4, NULL, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(NULL, out, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(NULL, NULL, in, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(NULL, NULL, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(NULL, out, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(&sm4, NULL, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(&sm4, out, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(&sm4, out, in, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid cases - wc_Sm4EcbEncrypt. */
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(&sm4, out, in, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(&sm4, out2, in, SM4_BLOCK_SIZE), 0);
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(&sm4, out, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(out, out2, SM4_BLOCK_SIZE), 0);
|
||||
/* In and out are same pointer. */
|
||||
ExpectIntEQ(wc_Sm4EcbEncrypt(&sm4, in, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(in, out, SM4_BLOCK_SIZE * 2), 0);
|
||||
|
||||
/* Invalid parameters - wc_Sm4EcbDecrypt. */
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(NULL, NULL, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(&sm4, NULL, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(NULL, out, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(NULL, NULL, in, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(NULL, NULL, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(NULL, out, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(&sm4, NULL, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(&sm4, out, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(&sm4, out, in, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid cases - wc_Sm4EcbDecrypt. */
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(&sm4, out, in, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(&sm4, out2, in, SM4_BLOCK_SIZE), 0);
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(&sm4, out, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(out, out2, SM4_BLOCK_SIZE), 0);
|
||||
/* In and out are same pointer. */
|
||||
ExpectIntEQ(wc_Sm4EcbDecrypt(&sm4, in, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(in, out, SM4_BLOCK_SIZE * 2), 0);
|
||||
|
||||
wc_Sm4Free(&sm4);
|
||||
|
||||
res = EXPECT_RESULT();
|
||||
#endif
|
||||
return res;
|
||||
} /* END test_wc_Sm4Ecb */
|
||||
|
||||
/*
|
||||
* Testing block based SM4-CBC API.
|
||||
*/
|
||||
int test_wc_Sm4Cbc(void)
|
||||
{
|
||||
int res = TEST_SKIPPED;
|
||||
#ifdef WOLFSSL_SM4_CBC
|
||||
EXPECT_DECLS;
|
||||
wc_Sm4 sm4;
|
||||
unsigned char key[SM4_KEY_SIZE];
|
||||
unsigned char iv[SM4_IV_SIZE];
|
||||
unsigned char in[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char out[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char out2[SM4_BLOCK_SIZE];
|
||||
|
||||
XMEMSET(key, 0, sizeof(key));
|
||||
XMEMSET(iv, 0, sizeof(iv));
|
||||
XMEMSET(in, 0, sizeof(in));
|
||||
|
||||
ExpectIntEQ(wc_Sm4Init(&sm4, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, out, in, 0),
|
||||
WC_NO_ERR_TRACE(MISSING_KEY));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, out, in, 0),
|
||||
WC_NO_ERR_TRACE(MISSING_KEY));
|
||||
/* Tested in test_wc_Sm4. */
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, key, SM4_KEY_SIZE), 0);
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, out, in, 0),
|
||||
WC_NO_ERR_TRACE(MISSING_IV));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, out, in, 0),
|
||||
WC_NO_ERR_TRACE(MISSING_IV));
|
||||
/* Tested in test_wc_Sm4. */
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
|
||||
/* Invalid parameters - wc_Sm4CbcEncrypt. */
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(NULL, NULL, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, NULL, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(NULL, out, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(NULL, NULL, in, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(NULL, NULL, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(NULL, out, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, NULL, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, out, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, out, in, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid cases - wc_Sm4CbcEncrypt. */
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, out, in, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, out2, in, SM4_BLOCK_SIZE), 0);
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, out, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(out, out2, SM4_BLOCK_SIZE), 0);
|
||||
/* In and out are same pointer. */
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CbcEncrypt(&sm4, in, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(in, out, SM4_BLOCK_SIZE * 2), 0);
|
||||
|
||||
/* Invalid parameters - wc_Sm4CbcDecrypt. */
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(NULL, NULL, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, NULL, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(NULL, out, NULL, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(NULL, NULL, in, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(NULL, NULL, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(NULL, out, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, NULL, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, out, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, out, in, 1),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
/* Valid cases - wc_Sm4CbcDecrypt. */
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, out, in, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, out2, in, SM4_BLOCK_SIZE), 0);
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, out, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(out, out2, SM4_BLOCK_SIZE), 0);
|
||||
/* In and out are same pointer. */
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CbcDecrypt(&sm4, in, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(in, out, SM4_BLOCK_SIZE * 2), 0);
|
||||
|
||||
wc_Sm4Free(&sm4);
|
||||
|
||||
res = EXPECT_RESULT();
|
||||
#endif
|
||||
return res;
|
||||
} /* END test_wc_Sm4Cbc */
|
||||
|
||||
/*
|
||||
* Testing streaming SM4-CTR API.
|
||||
*/
|
||||
int test_wc_Sm4Ctr(void)
|
||||
{
|
||||
int res = TEST_SKIPPED;
|
||||
#ifdef WOLFSSL_SM4_CTR
|
||||
EXPECT_DECLS;
|
||||
wc_Sm4 sm4;
|
||||
unsigned char key[SM4_KEY_SIZE];
|
||||
unsigned char iv[SM4_IV_SIZE];
|
||||
unsigned char in[SM4_BLOCK_SIZE * 4];
|
||||
unsigned char out[SM4_BLOCK_SIZE * 4];
|
||||
unsigned char out2[SM4_BLOCK_SIZE * 4];
|
||||
word32 chunk;
|
||||
word32 i;
|
||||
|
||||
XMEMSET(key, 0, sizeof(key));
|
||||
XMEMSET(iv, 0, sizeof(iv));
|
||||
XMEMSET(in, 0, sizeof(in));
|
||||
|
||||
ExpectIntEQ(wc_Sm4Init(&sm4, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out, in, 0),
|
||||
WC_NO_ERR_TRACE(MISSING_KEY));
|
||||
/* Tested in test_wc_Sm4. */
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, key, SM4_KEY_SIZE), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out, in, 0),
|
||||
WC_NO_ERR_TRACE(MISSING_IV));
|
||||
/* Tested in test_wc_Sm4. */
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
|
||||
/* Invalid parameters - wc_Sm4CtrEncrypt. */
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(NULL, NULL, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, NULL, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(NULL, out, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(NULL, NULL, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out, NULL, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, NULL, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(NULL, out, in, 0),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid cases - wc_Sm4CtrEncrypt. */
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out, in, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out2, in, 1), 0);
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out, in, 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(out, out2, 1), 0);
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out2, in, SM4_BLOCK_SIZE), 0);
|
||||
ExpectIntEQ(XMEMCMP(out2, out, 2), 0);
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(out, out2, SM4_BLOCK_SIZE), 0);
|
||||
/* In and out are same pointer. Also check encrypt of cipher text produces
|
||||
* plaintext.
|
||||
*/
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out, out, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(in, out, SM4_BLOCK_SIZE * 2), 0);
|
||||
|
||||
/* Chunking tests. */
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out2, in, (word32)sizeof(in)), 0);
|
||||
for (chunk = 1; chunk <= SM4_BLOCK_SIZE + 1; chunk++) {
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
for (i = 0; i + chunk <= (word32)sizeof(in); i += chunk) {
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out + i, in + i, chunk), 0);
|
||||
}
|
||||
if (i < (word32)sizeof(in)) {
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out + i, in + i,
|
||||
(word32)sizeof(in) - i), 0);
|
||||
}
|
||||
ExpectIntEQ(XMEMCMP(out, out2, (word32)sizeof(out)), 0);
|
||||
}
|
||||
|
||||
for (i = 0; i < (word32)sizeof(iv); i++) {
|
||||
iv[i] = 0xff;
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(wc_Sm4SetIV(&sm4, iv), 0);
|
||||
ExpectIntEQ(wc_Sm4CtrEncrypt(&sm4, out2, out, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(XMEMCMP(out2, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
}
|
||||
|
||||
wc_Sm4Free(&sm4);
|
||||
|
||||
res = EXPECT_RESULT();
|
||||
#endif
|
||||
return res;
|
||||
} /* END test_wc_Sm4Ctr */
|
||||
|
||||
/*
|
||||
* Testing stream SM4-GCM API.
|
||||
*/
|
||||
int test_wc_Sm4Gcm(void)
|
||||
{
|
||||
int res = TEST_SKIPPED;
|
||||
#ifdef WOLFSSL_SM4_GCM
|
||||
EXPECT_DECLS;
|
||||
wc_Sm4 sm4;
|
||||
unsigned char key[SM4_KEY_SIZE];
|
||||
unsigned char nonce[GCM_NONCE_MAX_SZ];
|
||||
unsigned char in[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char in2[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char out[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char out2[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char dec[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char tag[SM4_BLOCK_SIZE];
|
||||
unsigned char aad[SM4_BLOCK_SIZE * 2];
|
||||
word32 i;
|
||||
|
||||
XMEMSET(key, 0, sizeof(key));
|
||||
XMEMSET(nonce, 0, sizeof(nonce));
|
||||
XMEMSET(in, 0, sizeof(in));
|
||||
XMEMSET(in2, 0, sizeof(in2));
|
||||
XMEMSET(aad, 0, sizeof(aad));
|
||||
|
||||
ExpectIntEQ(wc_Sm4Init(&sm4, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, 0, nonce, GCM_NONCE_MID_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(MISSING_KEY));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, out, in, 0, nonce, GCM_NONCE_MID_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(MISSING_KEY));
|
||||
|
||||
/* Invalid parameters - wc_Sm4GcmSetKey. */
|
||||
ExpectIntEQ(wc_Sm4GcmSetKey(NULL, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmSetKey(&sm4, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmSetKey(NULL, key, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmSetKey(NULL, NULL, SM4_KEY_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmSetKey(&sm4, key, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmSetKey(&sm4, NULL, SM4_KEY_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmSetKey(NULL, key, SM4_KEY_SIZE),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid parameters - wc_Sm4GcmSetKey. */
|
||||
ExpectIntEQ(wc_Sm4GcmSetKey(&sm4, key, SM4_KEY_SIZE), 0);
|
||||
|
||||
/* Invalid parameters - wc_Sm4GcmEncrypt. */
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(NULL, NULL, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, NULL, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(NULL, out, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(NULL, NULL, in, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(NULL, NULL, NULL, 1, nonce, GCM_NONCE_MID_SZ,
|
||||
NULL, 0, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(NULL, NULL, NULL, 1, NULL, 0, tag,
|
||||
SM4_BLOCK_SIZE, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(NULL, out, in, 1, nonce, GCM_NONCE_MID_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, NULL, in, 1, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, NULL, 1, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, 1, NULL, GCM_NONCE_MID_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, 1, nonce, 0, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, 1, nonce, GCM_NONCE_MID_SZ,
|
||||
NULL, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, 1, nonce, GCM_NONCE_MID_SZ, tag,
|
||||
WOLFSSL_MIN_AUTH_TAG_SZ-1, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, 1, nonce, GCM_NONCE_MID_SZ, tag,
|
||||
SM4_BLOCK_SIZE+1, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Invalid parameters - wc_Sm4GcmDecrypt. */
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(NULL, NULL, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, NULL, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(NULL, out, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(NULL, NULL, in, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(NULL, NULL, NULL, 1, nonce, GCM_NONCE_MID_SZ,
|
||||
NULL, 0, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(NULL, NULL, NULL, 1, NULL, 0, tag,
|
||||
SM4_BLOCK_SIZE, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(NULL, out, in, 1, nonce, GCM_NONCE_MID_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, NULL, in, 1, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, out, NULL, 1, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, out, in, 1, NULL, GCM_NONCE_MID_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, out, in, 1, nonce, 0, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, out, in, 1, nonce, GCM_NONCE_MID_SZ,
|
||||
NULL, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, out, in, 1, nonce, GCM_NONCE_MID_SZ, tag,
|
||||
WOLFSSL_MIN_AUTH_TAG_SZ-1, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, out, in, 1, nonce, GCM_NONCE_MID_SZ, tag,
|
||||
SM4_BLOCK_SIZE+1, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid cases - wc_Sm4GcmEncrypt/wc_Sm4GcmDecrypt. */
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, NULL, NULL, 0, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, NULL, NULL, 0, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, NULL, NULL, 0, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, NULL, NULL, 0, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, NULL, 1), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, NULL, 1), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE * 2, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE * 2, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, in2, in2, SM4_BLOCK_SIZE * 2, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(in2, out, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, in2, in2, SM4_BLOCK_SIZE * 2, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(in2, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
|
||||
/* Check vald values of nonce - wc_Sm4GcmEncrypt/wc_Sm4GcmDecrypt. */
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
GCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
GCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE * 2, nonce,
|
||||
GCM_NONCE_MIN_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE * 2, nonce,
|
||||
GCM_NONCE_MIN_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE * 2, nonce,
|
||||
GCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(SM4_GCM_AUTH_E));
|
||||
|
||||
/* Check valid values of tag size - wc_Sm4GcmEncrypt/wc_Sm4GcmDecrypt. */
|
||||
for (i = WOLFSSL_MIN_AUTH_TAG_SZ; i < SM4_BLOCK_SIZE; i++) {
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, i, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, i, aad, sizeof(aad)), 0);
|
||||
}
|
||||
|
||||
/* Check different in/out sizes. */
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, 0, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, out, in, 0, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, 1, nonce,
|
||||
GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
for (i = 2; i <= SM4_BLOCK_SIZE * 2; i++) {
|
||||
XMEMCPY(out2, out, i - 1);
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, out, in, i, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(out, out2, i - 1), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, dec, out, i, nonce, GCM_NONCE_MID_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(in, dec, i), 0);
|
||||
}
|
||||
|
||||
/* Force the counter to roll over in first byte. */
|
||||
{
|
||||
static unsigned char largeIn[256 * SM4_BLOCK_SIZE];
|
||||
static unsigned char largeOut[256 * SM4_BLOCK_SIZE];
|
||||
|
||||
ExpectIntEQ(wc_Sm4GcmEncrypt(&sm4, largeOut, largeIn, sizeof(largeIn),
|
||||
nonce, GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4GcmDecrypt(&sm4, largeOut, largeOut, sizeof(largeIn),
|
||||
nonce, GCM_NONCE_MID_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(largeOut, largeIn, sizeof(largeIn)), 0);
|
||||
}
|
||||
|
||||
wc_Sm4Free(&sm4);
|
||||
|
||||
res = EXPECT_RESULT();
|
||||
#endif
|
||||
return res;
|
||||
} /* END test_wc_Sm4Gcm */
|
||||
|
||||
/*
|
||||
* Testing stream SM4-CCM API.
|
||||
*/
|
||||
int test_wc_Sm4Ccm(void)
|
||||
{
|
||||
int res = TEST_SKIPPED;
|
||||
#ifdef WOLFSSL_SM4_CCM
|
||||
EXPECT_DECLS;
|
||||
wc_Sm4 sm4;
|
||||
unsigned char key[SM4_KEY_SIZE];
|
||||
unsigned char nonce[CCM_NONCE_MAX_SZ];
|
||||
unsigned char in[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char in2[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char out[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char out2[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char dec[SM4_BLOCK_SIZE * 2];
|
||||
unsigned char tag[SM4_BLOCK_SIZE];
|
||||
unsigned char aad[SM4_BLOCK_SIZE * 2];
|
||||
word32 i;
|
||||
|
||||
XMEMSET(key, 0, sizeof(key));
|
||||
XMEMSET(nonce, 0, sizeof(nonce));
|
||||
XMEMSET(in, 0, sizeof(in));
|
||||
XMEMSET(in2, 0, sizeof(in2));
|
||||
XMEMSET(aad, 0, sizeof(aad));
|
||||
|
||||
ExpectIntEQ(wc_Sm4Init(&sm4, NULL, INVALID_DEVID), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, 0, nonce, CCM_NONCE_MAX_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(MISSING_KEY));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, out, in, 0, nonce, CCM_NONCE_MAX_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(MISSING_KEY));
|
||||
ExpectIntEQ(wc_Sm4SetKey(&sm4, key, SM4_KEY_SIZE), 0);
|
||||
|
||||
/* Invalid parameters - wc_Sm4CcmEncrypt. */
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(NULL, NULL, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, NULL, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(NULL, out, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(NULL, NULL, in, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(NULL, NULL, NULL, 1, nonce, CCM_NONCE_MAX_SZ,
|
||||
NULL, 0, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(NULL, NULL, NULL, 1, NULL, 0, tag,
|
||||
SM4_BLOCK_SIZE, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(NULL, out, in, 1, nonce, CCM_NONCE_MAX_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, NULL, in, 1, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, NULL, 1, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, 1, NULL, CCM_NONCE_MAX_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, 1, nonce, 0, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, 1, nonce, CCM_NONCE_MAX_SZ,
|
||||
NULL, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, 1, nonce, CCM_NONCE_MAX_SZ, tag,
|
||||
WOLFSSL_MIN_AUTH_TAG_SZ-1, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, 1, nonce, CCM_NONCE_MAX_SZ, tag,
|
||||
SM4_BLOCK_SIZE+1, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Invalid parameters - wc_Sm4CcmDecrypt. */
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(NULL, NULL, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, NULL, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(NULL, out, NULL, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(NULL, NULL, in, 1, NULL, 0, NULL, 0, NULL,
|
||||
0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(NULL, NULL, NULL, 1, nonce, CCM_NONCE_MAX_SZ,
|
||||
NULL, 0, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(NULL, NULL, NULL, 1, NULL, 0, tag,
|
||||
SM4_BLOCK_SIZE, NULL, 0), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(NULL, out, in, 1, nonce, CCM_NONCE_MAX_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, NULL, in, 1, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, out, NULL, 1, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, out, in, 1, NULL, CCM_NONCE_MAX_SZ, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, out, in, 1, nonce, 0, tag,
|
||||
SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, out, in, 1, nonce, CCM_NONCE_MAX_SZ,
|
||||
NULL, SM4_BLOCK_SIZE, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, out, in, 1, nonce, CCM_NONCE_MAX_SZ, tag,
|
||||
WOLFSSL_MIN_AUTH_TAG_SZ - 1, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, out, in, 1, nonce, CCM_NONCE_MAX_SZ, tag,
|
||||
SM4_BLOCK_SIZE + 1, aad, sizeof(aad)), WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
|
||||
/* Valid cases - wc_Sm4CcmEncrypt/wc_Sm4CcmDecrypt. */
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, NULL, NULL, 0, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, NULL, NULL, 0, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, NULL, NULL, 0, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, NULL, NULL, 0, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, NULL, 1), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, NULL, 1), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE * 2, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE * 2, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, in2, in2, SM4_BLOCK_SIZE * 2, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(in2, out, SM4_BLOCK_SIZE * 2), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, in2, in2, SM4_BLOCK_SIZE * 2, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(in2, in, SM4_BLOCK_SIZE * 2), 0);
|
||||
|
||||
/* Check vald values of nonce - wc_Sm4CcmEncrypt/wc_Sm4CcmDecrypt. */
|
||||
for (i = CCM_NONCE_MIN_SZ; i <= CCM_NONCE_MAX_SZ; i++) {
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
i, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
i, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
}
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MIN_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(SM4_CCM_AUTH_E));
|
||||
|
||||
/* Check invalid values of tag size - wc_Sm4CcmEncrypt/wc_Sm4CcmDecrypt. */
|
||||
for (i = 0; i < 4; i++) {
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, i * 2 + 1, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, i * 2 + 1, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
}
|
||||
/* Odd values in range 4..SM4_BLOCK_SIZE. */
|
||||
for (i = 2; i < SM4_BLOCK_SIZE / 2; i++) {
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, i * 2 + 1, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, i * 2 + 1, aad, sizeof(aad)),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
}
|
||||
/* Check valid values of tag size - wc_Sm4CcmEncrypt/wc_Sm4CcmDecrypt.
|
||||
* Even values in range 4..SM4_BLOCK_SIZE.
|
||||
*/
|
||||
for (i = 2; i < SM4_BLOCK_SIZE / 2; i++) {
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, i * 2, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, in, out, SM4_BLOCK_SIZE, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, i * 2, aad, sizeof(aad)), 0);
|
||||
}
|
||||
|
||||
/* Check different in/out sizes. */
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, 0, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, out, in, 0, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, 1, nonce,
|
||||
CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, NULL, 0), 0);
|
||||
for (i = 2; i <= SM4_BLOCK_SIZE * 2; i++) {
|
||||
XMEMCPY(out2, out, i - 1);
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, out, in, i, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(out, out2, i - 1), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, dec, out, i, nonce, CCM_NONCE_MAX_SZ,
|
||||
tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(in, dec, i), 0);
|
||||
}
|
||||
|
||||
/* Force the counter to roll over in first byte. */
|
||||
{
|
||||
static unsigned char largeIn[256 * SM4_BLOCK_SIZE];
|
||||
static unsigned char largeOut[256 * SM4_BLOCK_SIZE];
|
||||
|
||||
ExpectIntEQ(wc_Sm4CcmEncrypt(&sm4, largeOut, largeIn, sizeof(largeIn),
|
||||
nonce, CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(wc_Sm4CcmDecrypt(&sm4, largeOut, largeOut, sizeof(largeIn),
|
||||
nonce, CCM_NONCE_MAX_SZ, tag, SM4_BLOCK_SIZE, aad, sizeof(aad)), 0);
|
||||
ExpectIntEQ(XMEMCMP(largeOut, largeIn, sizeof(largeIn)), 0);
|
||||
}
|
||||
|
||||
wc_Sm4Free(&sm4);
|
||||
|
||||
res = EXPECT_RESULT();
|
||||
#endif
|
||||
return res;
|
||||
} /* END test_wc_Sm4Ccm */
|
||||
|
||||
32
tests/api/test_sm4.h
Normal file
32
tests/api/test_sm4.h
Normal file
@ -0,0 +1,32 @@
|
||||
/* test_sm4.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_SM4_H
|
||||
#define WOLFCRYPT_TEST_SM4_H
|
||||
|
||||
int test_wc_Sm4(void);
|
||||
int test_wc_Sm4Ecb(void);
|
||||
int test_wc_Sm4Cbc(void);
|
||||
int test_wc_Sm4Ctr(void);
|
||||
int test_wc_Sm4Gcm(void);
|
||||
int test_wc_Sm4Ccm(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_SM4_H */
|
||||
99
tests/api/test_wc_encrypt.c
Normal file
99
tests/api/test_wc_encrypt.c
Normal file
@ -0,0 +1,99 @@
|
||||
/* test_wc_encrypt.c
|
||||
*
|
||||
* Copyright (C) 2006-2025 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
|
||||
|
||||
#if !defined(WOLFSSL_USER_SETTINGS) && !defined(WOLFSSL_NO_OPTIONS_H)
|
||||
#include <wolfssl/options.h>
|
||||
#endif
|
||||
#include <wolfssl/wolfcrypt/settings.h>
|
||||
|
||||
#ifdef NO_INLINE
|
||||
#include <wolfssl/wolfcrypt/misc.h>
|
||||
#else
|
||||
#define WOLFSSL_MISC_INCLUDED
|
||||
#include <wolfcrypt/src/misc.c>
|
||||
#endif
|
||||
|
||||
#include <wolfssl/wolfcrypt/wc_encrypt.h>
|
||||
#include <wolfssl/wolfcrypt/types.h>
|
||||
#include <tests/unit.h>
|
||||
#include <tests/api/api.h>
|
||||
#include <tests/api/test_wc_encrypt.h>
|
||||
|
||||
/*
|
||||
* Unit test for wc_Des3_CbcEncryptWithKey and wc_Des3_CbcDecryptWithKey
|
||||
*/
|
||||
int test_wc_Des3_CbcEncryptDecryptWithKey(void)
|
||||
{
|
||||
EXPECT_DECLS;
|
||||
#ifndef NO_DES3
|
||||
word32 vectorSz, cipherSz;
|
||||
byte cipher[24];
|
||||
byte plain[24];
|
||||
byte vector[] = { /* Now is the time for all w/o trailing 0 */
|
||||
0x4e,0x6f,0x77,0x20,0x69,0x73,0x20,0x74,
|
||||
0x68,0x65,0x20,0x74,0x69,0x6d,0x65,0x20,
|
||||
0x66,0x6f,0x72,0x20,0x61,0x6c,0x6c,0x20
|
||||
};
|
||||
byte key[] = {
|
||||
0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef,
|
||||
0xfe,0xde,0xba,0x98,0x76,0x54,0x32,0x10,
|
||||
0x89,0xab,0xcd,0xef,0x01,0x23,0x45,0x67
|
||||
};
|
||||
byte iv[] = {
|
||||
0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef,
|
||||
0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
|
||||
0x11,0x21,0x31,0x41,0x51,0x61,0x71,0x81
|
||||
};
|
||||
|
||||
vectorSz = sizeof(byte) * 24;
|
||||
cipherSz = sizeof(byte) * 24;
|
||||
|
||||
ExpectIntEQ(wc_Des3_CbcEncryptWithKey(cipher, vector, vectorSz, key, iv),
|
||||
0);
|
||||
ExpectIntEQ(wc_Des3_CbcDecryptWithKey(plain, cipher, cipherSz, key, iv), 0);
|
||||
ExpectIntEQ(XMEMCMP(plain, vector, 24), 0);
|
||||
|
||||
/* pass in bad args. */
|
||||
ExpectIntEQ(wc_Des3_CbcEncryptWithKey(NULL, vector, vectorSz, key, iv),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcEncryptWithKey(cipher, NULL, vectorSz, key, iv),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcEncryptWithKey(cipher, vector, vectorSz, NULL, iv),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcEncryptWithKey(cipher, vector, vectorSz, key, NULL),
|
||||
0);
|
||||
|
||||
ExpectIntEQ(wc_Des3_CbcDecryptWithKey(NULL, cipher, cipherSz, key, iv),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcDecryptWithKey(plain, NULL, cipherSz, key, iv),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcDecryptWithKey(plain, cipher, cipherSz, NULL, iv),
|
||||
WC_NO_ERR_TRACE(BAD_FUNC_ARG));
|
||||
ExpectIntEQ(wc_Des3_CbcDecryptWithKey(plain, cipher, cipherSz, key, NULL),
|
||||
0);
|
||||
#endif
|
||||
return EXPECT_RESULT();
|
||||
} /* END test_wc_Des3_CbcEncryptDecryptWithKey */
|
||||
|
||||
27
tests/api/test_wc_encrypt.h
Normal file
27
tests/api/test_wc_encrypt.h
Normal file
@ -0,0 +1,27 @@
|
||||
/* test_wc_encrypt.h
|
||||
*
|
||||
* Copyright (C) 2006-2025 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 WOLFCRYPT_TEST_WC_ENCRYPT_H
|
||||
#define WOLFCRYPT_TEST_WC_ENCRYPT_H
|
||||
|
||||
int test_wc_Des3_CbcEncryptDecryptWithKey(void);
|
||||
|
||||
#endif /* WOLFCRYPT_TEST_WC_ENCRYPT_H */
|
||||
Reference in New Issue
Block a user