From 367dae44b29e11c33e2e22aa19cbb5a3ff13e107 Mon Sep 17 00:00:00 2001 From: Paul Bakker Date: Sun, 28 Jun 2009 21:50:27 +0000 Subject: - Added CMake makefiles as alternative to regular Makefiles. - Added preliminary Code Coverage tests for AES, ARC4, Base64, MPI, SHA-family, MD-family and HMAC-SHA-family. --- CMakeLists.txt | 15 + ChangeLog | 5 + library/CMakeLists.txt | 15 + programs/CMakeLists.txt | 5 + programs/aes/CMakeLists.txt | 2 + programs/hash/CMakeLists.txt | 11 + programs/pkey/CMakeLists.txt | 20 + programs/ssl/CMakeLists.txt | 8 + programs/test/CMakeLists.txt | 12 + tests/CMakeLists.txt | 21 + tests/fct.h | 1688 ++++++++++++++++++++++++++++ tests/scripts/generate_code.pl | 91 ++ tests/suites/helpers.function | 57 + tests/suites/test_suite_aes.data | 662 +++++++++++ tests/suites/test_suite_aes.function | 168 +++ tests/suites/test_suite_arc4.data | 8 + tests/suites/test_suite_arc4.function | 26 + tests/suites/test_suite_base64.data | 41 + tests/suites/test_suite_base64.function | 36 + tests/suites/test_suite_hmac_shax.data | 107 ++ tests/suites/test_suite_hmac_shax.function | 120 ++ tests/suites/test_suite_mdx.data | 62 + tests/suites/test_suite_mdx.function | 65 ++ tests/suites/test_suite_mpi.data | 341 ++++++ tests/suites/test_suite_mpi.function | 391 +++++++ tests/suites/test_suite_shax.data | 119 ++ tests/suites/test_suite_shax.function | 105 ++ 27 files changed, 4201 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 library/CMakeLists.txt create mode 100644 programs/CMakeLists.txt create mode 100644 programs/aes/CMakeLists.txt create mode 100644 programs/hash/CMakeLists.txt create mode 100644 programs/pkey/CMakeLists.txt create mode 100644 programs/ssl/CMakeLists.txt create mode 100644 programs/test/CMakeLists.txt create mode 100644 tests/CMakeLists.txt create mode 100644 tests/fct.h create mode 100755 tests/scripts/generate_code.pl create mode 100644 tests/suites/helpers.function create mode 100644 tests/suites/test_suite_aes.data create mode 100644 tests/suites/test_suite_aes.function create mode 100644 tests/suites/test_suite_arc4.data create mode 100644 tests/suites/test_suite_arc4.function create mode 100644 tests/suites/test_suite_base64.data create mode 100644 tests/suites/test_suite_base64.function create mode 100644 tests/suites/test_suite_hmac_shax.data create mode 100644 tests/suites/test_suite_hmac_shax.function create mode 100644 tests/suites/test_suite_mdx.data create mode 100644 tests/suites/test_suite_mdx.function create mode 100644 tests/suites/test_suite_mpi.data create mode 100644 tests/suites/test_suite_mpi.function create mode 100644 tests/suites/test_suite_shax.data create mode 100644 tests/suites/test_suite_shax.function diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..3c58803 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,15 @@ +cmake_minimum_required(VERSION 2.6) +project(POLARSSL C) + +enable_testing() + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -Wall -W -fprofile-arcs -ftest-coverage -lgcov") +set(CMAKE_SHARED_LINKER_FLAGS "-fprofile-arcs -ftest-coverage") +#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -Wall -W") +#set(CMAKE_SHARED_LINKER_FLAGS "") + +include_directories(include/) + +add_subdirectory(library) +add_subdirectory(programs) +add_subdirectory(tests) diff --git a/ChangeLog b/ChangeLog index b72b055..67f6926 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,6 +1,11 @@ PolarSSL ChangeLog = Version X released on X +Features + * Added CMake makefiles as alternative to regular Makefiles. + * Added preliminary Code Coverage tests for AES, ARC4, + Base64, MPI, SHA-family, MD-family and HMAC-SHA-family. + Bug fixes * Fixed incorrect handling of negative strings in mpi_read_string() (found by code coverage tests). diff --git a/library/CMakeLists.txt b/library/CMakeLists.txt new file mode 100644 index 0000000..51c45fc --- /dev/null +++ b/library/CMakeLists.txt @@ -0,0 +1,15 @@ +add_library(polarssl STATIC + base64.c rsa.c timing.c havege.c + md5.c + ssl_cli.c + bignum.c debug.c sha1.c x509parse.c + aes.c net.c ssl_srv.c + camellia.c des.c md2.c sha2.c xtea.c + arc4.c + padlock.c + ssl_tls.c + certs.c + dhm.c + md4.c + sha4.c +) diff --git a/programs/CMakeLists.txt b/programs/CMakeLists.txt new file mode 100644 index 0000000..a11929a --- /dev/null +++ b/programs/CMakeLists.txt @@ -0,0 +1,5 @@ +add_subdirectory(aes) +add_subdirectory(hash) +add_subdirectory(pkey) +add_subdirectory(ssl) +add_subdirectory(test) diff --git a/programs/aes/CMakeLists.txt b/programs/aes/CMakeLists.txt new file mode 100644 index 0000000..1daad58 --- /dev/null +++ b/programs/aes/CMakeLists.txt @@ -0,0 +1,2 @@ +add_executable(aescrypt2 aescrypt2.c) +target_link_libraries(aescrypt2 polarssl) diff --git a/programs/hash/CMakeLists.txt b/programs/hash/CMakeLists.txt new file mode 100644 index 0000000..e9af522 --- /dev/null +++ b/programs/hash/CMakeLists.txt @@ -0,0 +1,11 @@ +add_executable(hello hello.c) +target_link_libraries(hello polarssl) + +add_executable(md5sum md5sum.c) +target_link_libraries(md5sum polarssl) + +add_executable(sha1sum sha1sum.c) +target_link_libraries(sha1sum polarssl) + +add_executable(sha2sum sha2sum.c) +target_link_libraries(sha2sum polarssl) diff --git a/programs/pkey/CMakeLists.txt b/programs/pkey/CMakeLists.txt new file mode 100644 index 0000000..7190ee4 --- /dev/null +++ b/programs/pkey/CMakeLists.txt @@ -0,0 +1,20 @@ +add_executable(dh_client dh_client.c) +target_link_libraries(dh_client polarssl) + +add_executable(dh_genprime dh_genprime.c) +target_link_libraries(dh_genprime polarssl) + +add_executable(dh_server dh_server.c) +target_link_libraries(dh_server polarssl) + +add_executable(mpi_demo mpi_demo.c) +target_link_libraries(mpi_demo polarssl) + +add_executable(rsa_genkey rsa_genkey.c) +target_link_libraries(rsa_genkey polarssl) + +add_executable(rsa_sign rsa_sign.c) +target_link_libraries(rsa_sign polarssl) + +add_executable(rsa_verify rsa_verify.c) +target_link_libraries(rsa_verify polarssl) diff --git a/programs/ssl/CMakeLists.txt b/programs/ssl/CMakeLists.txt new file mode 100644 index 0000000..8eb6d3c --- /dev/null +++ b/programs/ssl/CMakeLists.txt @@ -0,0 +1,8 @@ +add_executable(ssl_client1 ssl_client1.c) +target_link_libraries(ssl_client1 polarssl) + +add_executable(ssl_client2 ssl_client2.c) +target_link_libraries(ssl_client2 polarssl) + +add_executable(ssl_server ssl_server.c) +target_link_libraries(ssl_server polarssl) diff --git a/programs/test/CMakeLists.txt b/programs/test/CMakeLists.txt new file mode 100644 index 0000000..95c01b4 --- /dev/null +++ b/programs/test/CMakeLists.txt @@ -0,0 +1,12 @@ +add_executable(selftest selftest.c) +target_link_libraries(selftest polarssl) + +add_executable(benchmark benchmark.c) +target_link_libraries(benchmark polarssl) + +add_executable(ssl_test ssl_test.c) +target_link_libraries(ssl_test polarssl) + +add_executable(ssl_cert_test ssl_cert_test.c) +target_link_libraries(ssl_cert_test polarssl) + diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 0000000..8c83288 --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,21 @@ +function(add_test_suite suite_name) + add_custom_command( + OUTPUT test_suite_${suite_name}.c + COMMAND scripts/generate_code.pl suites test_suite_${suite_name} + DEPENDS scripts/generate_code.pl polarssl fct.h suites/helpers.function suites/test_suite_${suite_name}.function suites/test_suite_${suite_name}.data +) + + add_executable(test_suite_${suite_name} test_suite_${suite_name}.c) + target_link_libraries(test_suite_${suite_name} polarssl) + add_test(${suite_name}-suite test_suite_${suite_name}) +endfunction(add_test_suite) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function -Wno-unused-value") + +add_test_suite(mpi) +add_test_suite(base64) +add_test_suite(arc4) +add_test_suite(mdx) +add_test_suite(shax) +add_test_suite(hmac_shax) +add_test_suite(aes) diff --git a/tests/fct.h b/tests/fct.h new file mode 100644 index 0000000..f6c1251 --- /dev/null +++ b/tests/fct.h @@ -0,0 +1,1688 @@ +/* +==================================================================== +Copyright (c) 2008 Ian Blumel. All rights reserved. + +FCT (Fast C Test) Unit Testing Framework + +Copyright (c) 2008, Ian Blumel (ian.blumel@gmail.com) +All rights reserved. + +This license is based on the BSD License. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + * Neither the name of, Ian Blumel, nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +==================================================================== + +File: fct.h +*/ + +#if !defined(FCT_INCLUDED__IMB) +#define FCT_INCLUDED__IMB + +#define FCT_VERSION_STR "1.0.2" +#define FCT_VERSION_MAJOR 1 +#define FCT_VERSION_MINOR 0 +#define FCT_VERSION_MICRO 2 + +/* Define this to remove unneeded WIN32 warnings. We will undefine this at +the end of the file so as not to interfere with your build. */ +#if defined(WIN32) && !defined(_CRT_SECURE_NO_WARNINGS) +# define _CRT_SECURE_NO_WARNINGS +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +#define FCT_MAX_NAME 256 +#define FCT_MAX_LOG_LINE 256 + +#define nbool_t int +#define FCT_TRUE 1 +#define FCT_FALSE 0 + +/* Forward declarations. The following forward declarations are required +because there is a inter-relationship between certain objects that +just can not be untwined. */ +typedef struct _fct_logger_i fct_logger_i; +typedef struct _fct_standard_logger_t fct_standard_logger_t; +typedef struct _fct_minimal_logger_t fct_minimal_logger_t; +typedef struct _fctchk_t fctchk_t; +typedef struct _fct_test_t fct_test_t; +typedef struct _fct_ts_t fct_ts_t; +typedef struct _fctkern_t fctkern_t; + +/* Forward declare some functions used throughout. */ +static fct_standard_logger_t * +fct_standard_logger__new(void); + +static void +fct_logger__del(fct_logger_i *logger); + +static void +fct_logger__on_cndtn(fct_logger_i *self, fctchk_t const *chk); + +static void +fct_logger__on_test_start(fct_logger_i *logger, fct_test_t const *test); + +static void +fct_logger__on_test_end(fct_logger_i *logger, fct_test_t const *test); + +static void +fct_logger__on_test_suite_start(fct_logger_i *logger, fct_ts_t const *ts); + +static void +fct_logger__on_test_suite_end(fct_logger_i *logger, fct_ts_t const *ts); + +static void +fct_logger__on_fct_start(fct_logger_i *logger, fctkern_t const *kern); + +static void +fct_logger__on_fct_end(fct_logger_i *logger, fctkern_t const *kern); + + + +/* Explicitly indicate a no-op */ +#define fct_pass() + +#define fct_unused(x) ((void) (x)); + +/* This is just a little trick to let me put comments inside of macros. I +really only want to bother with this when we are "unwinding" the macros +for debugging purposes. */ +#if defined(FCT_CONF_UNWIND) +# define _fct_cmt(string) {char*_=string;} +#else +# define _fct_cmt(string) +#endif + +/* +-------------------------------------------------------- +UTILITIES +-------------------------------------------------------- +*/ + +/* Utility for truncated, safe string copies. */ +static void +fct_safe_str_cpy(char *dst, char const *src, size_t num) +{ + assert( dst != NULL ); + assert( src != NULL ); + assert( num > 0 ); + strncpy(dst, src, num); + dst[num-1] = '\0'; +} + +/* Isolate the snprintf implemenation. */ +int +fct_snprintf(char *buffer, size_t buffer_len, char *format, ...) +{ + int count =0; + va_list args; + va_start(args, format); + count =vsnprintf(buffer, buffer_len, format, args); + va_end(args); + return count; +} + +/* A very, very simple "filter". This just compares the supplied prefix +against the test_str, to see if they both have the same starting +characters. If they do we return true, otherwise we return false. If the +prefix is a blank string or NULL, then it will return FCT_TRUE.*/ +static nbool_t +fct_filter_pass(char const *prefix, char const *test_str) +{ + nbool_t is_match = FCT_FALSE; + char const *prefix_p; + char const *test_str_p; + + /* If you got nothing to test against, why test? */ + assert( test_str != NULL ); + + /* When the prefix is NULL or blank, we always return FCT_TRUE. */ + if ( prefix == NULL || prefix[0] == '\0' ) + { + return FCT_TRUE; + } + + /* Iterate through both character arrays at the same time. We are + going to play a game and see if we can beat the house. */ + for ( prefix_p = prefix, test_str_p = test_str; + *prefix_p != '\0' && *test_str_p != '\0'; + ++prefix_p, ++test_str_p ) + { + is_match = *prefix_p == *test_str_p; + if ( !is_match ) + { + break; /* Quit the first time we don't match. */ + } + } + + /* If the iterator for the test_str is pointing at the null char, and + the iterator for the prefix string is not, then the prefix string is + larger than the actual test string, and therefore we failed to pass the + filter. */ + if ( *test_str_p == '\0' && *prefix_p != '\0' ) + { + return FCT_FALSE; + } + + /* is_match will be set to the either FCT_TRUE if we kicked of the loop + early because our filter ran out of characters or FCT_FALSE if we + encountered a mismatch before our filter ran out of characters. */ + return is_match; +} + +/* Returns true if two reals are equal. */ +nbool_t +fct_real_eq(double v1, double v2) +{ + return (nbool_t)(fabs(v1 - v2) < DBL_EPSILON); +} + +/* +-------------------------------------------------------- +TIMER +-------------------------------------------------------- +*/ + +typedef struct _fct_timer_t fct_timer_t; +struct _fct_timer_t { + clock_t start; + clock_t stop; + double duration; +}; + + +static void +fct_timer__init(fct_timer_t *timer) { + assert(timer != NULL); + memset(timer, 0, sizeof(fct_timer_t)); +} + + +static void +fct_timer__start(fct_timer_t *timer) { + assert(timer != NULL); + timer->start = clock(); +} + + +static void +fct_timer__stop(fct_timer_t *timer) { + assert(timer != NULL); + timer->stop = clock(); + timer->duration = (double) (timer->stop - timer->start) / CLOCKS_PER_SEC; +} + + +/* Returns the time in seconds. */ +static double +fct_timer__duration(fct_timer_t *timer) { + assert( timer != NULL ); + return timer->duration; +} + + +/* +-------------------------------------------------------- +GENERIC LIST +-------------------------------------------------------- +*/ + +/* For now we will just keep it at a linear growth rate. */ +#define FCT_LIST_GROWTH_FACTOR 2 + +/* Starting size for the list, to keep it simple we will start +at a reasonable size. */ +#define FCT_LIST_START_SIZE 2 + +/* Helper macros for quickly iterating through a list. You should be able +to do something like, + + NLIST_FOREACH_BGN(fct_logger_i*, logger, my_list) + { + fct_logger__on_blah(logger); + } + NLIST_FOREACH_END(); + +*/ +#define NLIST_FOREACH_BGN(Type, Var, List)\ +{\ + if ( List != NULL ) {\ + size_t item_i##Var;\ + size_t num_items##Var = nlist__size(List);\ + for( item_i##Var =0; item_i##Var != num_items##Var; ++item_i##Var )\ + {\ + Type Var = (Type) nlist__at((List), item_i##Var); + +#define NLIST_FOREACH_END() }}} + +/* Used to manage a list of loggers. This works mostly like +the STL vector, where the array grows as more items are +appended. */ +typedef struct _nlist_t nlist_t; +struct _nlist_t +{ + /* Item's are stored as pointers to void. */ + void **itm_list; + + /* Indicates the number of element's in the array. */ + size_t avail_itm_num; + + /* Indicates the number of actually elements in the array. */ + size_t used_itm_num; +}; + +static nlist_t * +nlist_new(void) +{ + nlist_t *list = (nlist_t*)calloc(1, sizeof(nlist_t)); + assert( list != NULL && "memory check"); + + list->itm_list = (void**)malloc(sizeof(void*)*FCT_LIST_START_SIZE); + assert( list->itm_list != NULL && "memory check"); + + list->avail_itm_num =FCT_LIST_START_SIZE; + list->used_itm_num =0; + return list; +} + +typedef void (*on_del_t)(void*); + +/* Cleans up list, and applies `on_del` to each item in the list. +If on_del is NULL, it will not be applied. If `list` is NULL this +function does nothing. */ +static void +nlist__del(nlist_t *list, on_del_t on_del) +{ + size_t itm_i =0; + + if ( list == NULL ) { return; } + + /* Walk through the list applying the destroy function, if it was + defined. */ + if ( on_del != NULL ) + { + for ( itm_i =0; itm_i != list->used_itm_num; ++itm_i ) + { + on_del(list->itm_list[itm_i]); + } + } + + free(list->itm_list); + free(list); +} + + +/* Returns the number of elements within the list. */ +static size_t +nlist__size(nlist_t const *list) +{ + assert( list != NULL ); + return list->used_itm_num; +} + + +/* Returns the item at idx, asserts otherwise. */ +static void* +nlist__at(nlist_t const *list, size_t idx) +{ + assert( list != NULL ); + assert( idx < list->used_itm_num ); + return list->itm_list[idx]; +} + + +static void +nlist__append(nlist_t *list, void *itm) +{ + assert( list != NULL ); + assert( list->itm_list != NULL ); + assert( list->avail_itm_num != 0 ); + + /* If we ran out of room, then the last increment should be equal to the + available space, in this case we need to grow a little more. */ + if ( list->used_itm_num == list->avail_itm_num ) + { + list->avail_itm_num = list->avail_itm_num*FCT_LIST_GROWTH_FACTOR; + list->itm_list = (void**)realloc( + list->itm_list, sizeof(void*)*list->avail_itm_num + ); + assert( list->itm_list != NULL && "memory check"); + } + + list->itm_list[list->used_itm_num] = itm; + ++(list->used_itm_num); +} + + + +/* +----------------------------------------------------------- +A SINGLE CHECK +----------------------------------------------------------- +This defines a single check. It indicates what the check was, +and where it occurred. A "Test" object will have-a bunch +of "checks". +*/ + +struct _fctchk_t { + /* This string that represents the condition. */ + char cndtn[FCT_MAX_LOG_LINE]; + + /* These indicate where the condition occurred. */ + char file[FCT_MAX_LOG_LINE]; + + int lineno; + + nbool_t is_pass; +}; + +#define fctchk__is_pass(_CHK_) ((_CHK_)->is_pass) +#define fctchk__file(_CHK_) ((_CHK_)->file) +#define fctchk__lineno(_CHK_) ((_CHK_)->lineno) +#define fctchk__cndtn(_CHK_) ((_CHK_)->cndtn) + + +static fctchk_t* +fctchk_new(char const *cndtn, char const *file, int lineno, nbool_t is_pass) +{ + fctchk_t *chk = NULL; + + assert( cndtn != NULL ); + assert( file != NULL ); + assert( lineno > 0 ); + + chk = (fctchk_t*)calloc(1, sizeof(fctchk_t)); + assert( chk != NULL && "out of memory"); + if ( chk == NULL ) { return NULL; } + + fct_safe_str_cpy(chk->cndtn, cndtn, FCT_MAX_LOG_LINE); + fct_safe_str_cpy(chk->file, file, FCT_MAX_LOG_LINE); + chk->lineno = lineno; + + chk->is_pass =is_pass; + + return chk; +} + + +/* Cleans up a "check" object. If the `chk` is NULL, this function does +nothing. */ +static void +fctchk__del(fctchk_t *chk) +{ + if ( chk == NULL ) { return; } + free( chk ); +} + + +/* +----------------------------------------------------------- +A TEST +----------------------------------------------------------- +A suite will have-a list of tests. Where each test will have-a +list of failed and passed checks. +*/ + +struct _fct_test_t { + /* List of failed and passed "checks" (fctchk_t). Two seperate + lists make it faster to determine how many checks passed and how + many checks failed. */ + nlist_t *failed_chks; + nlist_t *passed_chks; + + /* The name of the test case. */ + char name[FCT_MAX_NAME]; +}; + +#define fct_test__name(_TEST_) ((_TEST_)->name) + +static fct_test_t* +fct_test_new(char const *name) { + fct_test_t *test =NULL; + + test = (fct_test_t*)malloc(sizeof(fct_test_t)); + assert( test != NULL && "out of memory"); + + fct_safe_str_cpy(test->name, name, FCT_MAX_NAME); + + test->failed_chks = nlist_new(); + test->passed_chks = nlist_new(); + assert( test->failed_chks != NULL && "out of memory"); + assert( test->passed_chks != NULL && "out of memory"); + + return test; +} + + +static nbool_t +fct_test__is_pass(fct_test_t const *test) +{ + assert( test != NULL ); + return nlist__size(test->failed_chks) == 0; +} + + +static void +fct_test__add(fct_test_t *test, fctchk_t *chk) +{ + + assert( test != NULL ); + assert( chk != NULL ); + + if ( fctchk__is_pass(chk) ) + { + nlist__append(test->passed_chks, (void*)chk); + } + else + { + nlist__append(test->failed_chks, (void*)chk); + } +} + +/* Returns the number of checks made throughout the test. */ +static int +fct_test__chk_cnt(fct_test_t const *test) +{ + assert( test != NULL ); + return nlist__size(test->failed_chks) + nlist__size(test->passed_chks); +} + + +static void +fct_test__del(fct_test_t *test) +{ + if (test == NULL ) { return; } + nlist__del(test->passed_chks, (on_del_t)fctchk__del); + nlist__del(test->failed_chks, (on_del_t)fctchk__del); + free(test); +} + + +/* +----------------------------------------------------------- +TEST SUITE (TS) +----------------------------------------------------------- +*/ + + +/* The different types of 'modes' that a test suite can be in. + +While the test suite is iterating through all the tests, its "State" +can change from "setup mode", to "test mode" to "tear down" mode. +These help to indicate what mode are currently in. Think of it as a +basic FSM. + + if the count was 0 end + +--------->---------------------> ending_mode-----+ + | ^ + ^ | +start | [if no more tests] + | | | + +-count_mode -> setup_mode -> test_mode -> teardown_mode + ^ | + +-----------<---------------+ +*/ +enum ts_mode { + ts_mode_cnt, /* To setup when done counting. */ + ts_mode_setup, /* To test when done setup. */ + ts_mode_teardown, /* To ending mode, when no more tests. */ + ts_mode_test, /* To tear down mode. */ + ts_mode_ending, /* To ... */ + ts_mode_end /* .. The End. */ +}; + +/* Types of modes the test could be in. */ +typedef enum { + fct_test_status_SUCCESS, + fct_test_status_FAILURE +} fct_test_status; + + +struct _fct_ts_t { + /* For counting our 'current' test number, and the total number of + tests. */ + int curr_test_num; + int total_test_num; + + /* Keeps track of the current state of the object while it is walking + through its "FSM" */ + enum ts_mode mode; + + /* The name of the test suite. */ + char name[FCT_MAX_NAME]; + + /* List of tests that where executed within the test suite. */ + nlist_t *test_list; +}; + + +#define fct_ts__is_setup_mode(ts) ((ts)->mode == ts_mode_setup) +#define fct_ts__is_teardown_mode(ts) ((ts)->mode == ts_mode_teardown) +#define fct_ts__is_test_mode(ts) ((ts)->mode == ts_mode_test) +#define fct_ts__is_ending_mode(ts) ((ts)->mode == ts_mode_ending) +#define fct_ts__is_end(ts) ((ts)->mode == ts_mode_end) +#define fct_ts__is_cnt_mode(ts) ((ts)->mode == ts_mode_cnt) +#define fct_ts__name(ts) ((ts)->name) + + +static fct_ts_t * +fct_ts_new(char const *name) { + fct_ts_t *ts =NULL; + ts = (fct_ts_t*)calloc(1, sizeof(fct_ts_t)); + assert( ts != NULL ); + + fct_safe_str_cpy(ts->name, name, FCT_MAX_NAME); + ts->mode = ts_mode_cnt; + + ts->test_list = nlist_new(); + assert( ts->test_list != NULL && "no memory"); + + return ts; +} + +static void +fct_ts__del(fct_ts_t *ts) { + if ( ts == NULL ) { return; } + free(ts); +} + +/* Flag a test suite as complete. It will no longer accept any more tests. */ +#define fct_ts__end(_TS_) ((_TS_)->mode == ts_mode_end) + + +static nbool_t +fct_ts__is_more_tests(fct_ts_t const *ts) { + assert( ts != NULL ); + assert( !fct_ts__is_end(ts) ); + return ts->curr_test_num < ts->total_test_num; +} + + +/* Indicates that we have started a test case. */ +static void +fct_ts__test_begin(fct_ts_t *ts) { + assert( !fct_ts__is_end(ts) ); + ++(ts->curr_test_num); +} + + +/* Takes OWNERSHIP of a test object, and warehouses it for later stat +generation. */ +static void +fct_ts__add_test(fct_ts_t *ts, fct_test_t *test) { + assert( ts != NULL && "invalid arg"); + assert( test != NULL && "invalid arg"); + assert( !fct_ts__is_end(ts) ); + nlist__append(ts->test_list, test); +} + + +static void +fct_ts__test_end(fct_ts_t *ts) { + assert( ts != NULL ); + assert( fct_ts__is_test_mode(ts) && "not in test mode, can't end!" ); + + /* After a test has completed, move to teardown mode. */ + ts->mode = ts_mode_teardown; +} + + +/* Increments the internal count by 1. */ +static void +fct_ts__inc_total_test_num(fct_ts_t *ts) +{ + assert( ts != NULL ); + assert( fct_ts__is_cnt_mode(ts) ); + assert( !fct_ts__is_end(ts) ); + ++(ts->total_test_num); +} + + +/* Flags the end of the setup, which implies we are going to move into +setup mode. You must be already in setup mode for this to work! */ +static void +fct_ts__setup_end(fct_ts_t *ts) +{ + assert( fct_ts__is_setup_mode(ts) ); + assert( !fct_ts__is_end(ts) ); + ts->mode = ts_mode_test; +} + + +/* This cndtn is set when we have iterated through all the tests, and +there was nothing more to do. */ +static void +fct_ts__ending(fct_ts_t *ts) +{ + // We can only go from 'test-mode' to 'end-down' mode. + assert( fct_ts__is_test_mode(ts) ); + assert( !fct_ts__is_end(ts) ); + ts->mode = ts_mode_ending; +} + + +/* Flags the end of the teardown, which implies we are going to move +into setup mode (for the next 'iteration'). */ +static void +fct_ts__teardown_end(fct_ts_t *ts) +{ + assert( fct_ts__is_teardown_mode(ts) ); + assert( !fct_ts__is_end(ts) ); + /* We have to decide if we should keep on testing by moving into tear down + mode or if we have reached the real end and should be moving into the + ending mode. */ + if ( fct_ts__is_more_tests(ts) ) { + ts->mode = ts_mode_setup; + } + else { + ts->mode = ts_mode_ending; + } +} + + +/* Flags the end of the counting, and proceeding to the first setup. +Consider the special case when a test suite has NO tests in it, in +that case we will have a current count that is zero, in which case +we can skip right to 'ending'. */ +static void +fct_ts__cnt_end(fct_ts_t *ts) +{ + assert( ts != NULL ); + assert( fct_ts__is_cnt_mode(ts) ); + assert( !fct_ts__is_end(ts) ); + if (ts->total_test_num == 0 ) { + ts->mode = ts_mode_ending; + } + else { + ts->mode = ts_mode_setup; + } +} + + +static nbool_t +fct_ts__is_test_cnt(fct_ts_t const *ts, int test_num) +{ + assert( ts != NULL ); + assert( 0 <= test_num ); + assert( test_num < ts->total_test_num ); + assert( !fct_ts__is_end(ts) ); + + /* As we roll through the tests we increment the count. With this + count we can decide if we need to execute a test or not. */ + return test_num == ts->curr_test_num; +} + + +/* Returns the # of tests on the FCT TS object. This is the actual +# of tests executed. */ +static int +fct_ts__tst_cnt(fct_ts_t const *ts) +{ + assert( ts != NULL ); + assert( !fct_ts__is_end(ts) ); + return nlist__size(ts->test_list); +} + + +/* Returns the # of tests in the TS object that passed. */ +static int +fct_ts__tst_cnt_passed(fct_ts_t const *ts) +{ + int tally =0; + + assert( ts != NULL ); + assert( !fct_ts__is_end(ts) ); + + NLIST_FOREACH_BGN(fct_test_t*, test, ts->test_list) + { + if ( fct_test__is_pass(test) ) + { + tally += 1; + } + } + NLIST_FOREACH_END(); + return tally; +} + + +/* Returns the # of checks made throughout a test suite. */ +static int +fct_ts__chk_cnt(fct_ts_t const *ts) +{ + int tally =0; + + assert( ts != NULL ); + + NLIST_FOREACH_BGN(fct_test_t *, test, ts->test_list) + { + tally += fct_test__chk_cnt(test); + } + NLIST_FOREACH_END(); + return tally; +} + + +/* +-------------------------------------------------------- +FCT KERNAL +-------------------------------------------------------- + +The "fctkern" is a singleton that is defined throughout the +system. +*/ + +struct _fctkern_t { + /* This is an list of loggers that can be used in the fct system. + You/ can attach _MAX_LOGGERS to any framework. */ + nlist_t *logger_list; + + /* This is a list of prefix's that can be used to determine if a + test is should be run or not. */ + nlist_t *prefix_list; + + /* This is a list of test suites that where generated throughout the + testing process. */ + nlist_t *ts_list; +}; + + +/* Returns the number of filters defined for the fct kernal. */ +#define fctkern__filter_cnt(_NK_) (nlist__size((_NK_)->prefix_list)) + + +static void +fctkern__add_logger(fctkern_t *fct, fct_logger_i *logger_owns) +{ + assert(fct != NULL && "invalid arg"); + assert(logger_owns != NULL && "invalid arg"); + nlist__append(fct->logger_list, logger_owns); + assert( fct->logger_list != NULL && "memory check"); +} + +/* Appends a prefix filter that is used to determine if a test can +be executed or not. If the test starts with the same characters as +the prefix, then it should be "runnable". The prefix filter must be +a non-NULL, non-Blank string. */ +static void +fctkern__add_prefix_filter(fctkern_t const *fct, char const *prefix_filter) +{ + char *filter =NULL; + int filter_len =0; + + assert( fct != NULL && "invalid arg" ); + assert( prefix_filter != NULL && "invalid arg" ); + assert( strlen(prefix_filter) > 0 && "invalid arg" ); + + /* First we make a copy of the prefix, then we store it away + in our little list. */ + filter_len = strlen(prefix_filter); + filter = (char*)malloc(sizeof(char)*(filter_len+1)); + strncpy(filter, prefix_filter, filter_len); + filter[filter_len] = '\0'; + + nlist__append(fct->prefix_list, (void*)filter); +} + + +/* Parses the command line and sets up the framework. The argc and argv +should be directly from the program's main. */ +static void +fctkern_init(fctkern_t *nk, int argc, char *argv[]) +{ + fct_logger_i *standard_logger = NULL; + int arg_i =0; + + assert( nk != NULL ); + + memset(nk, 0, sizeof(fctkern_t)); + + nk->logger_list = nlist_new(); + nk->prefix_list = nlist_new(); + nk->ts_list = nlist_new(); + + /* Low-budget memory check for now. */ + assert( nk->logger_list != NULL ); + assert( nk->prefix_list != NULL ); + assert( nk->ts_list != NULL ); + + standard_logger = (fct_logger_i*) fct_standard_logger__new(); + assert( standard_logger != NULL && "no memory!"); + + fctkern__add_logger(nk, standard_logger); + standard_logger = NULL; /* Owned by the nk list. */ + + /* Our basic parser. For now we just take each 'argv' and assume + that it is a prefix filter. Notice we start at argument 1, since + we don't care about the *name* of the program. */ + for ( arg_i =1; arg_i < argc; ++arg_i ) + { + fctkern__add_prefix_filter(nk, argv[arg_i]); + } +} + + +/* Takes OWNERSHIP of the test suite after we have finished executing +its contents. This way we can build up all kinds of summaries at the end +of a run. */ +static void +fctkern__add_ts(fctkern_t *nk, fct_ts_t *ts) { + assert( nk != NULL ); + assert( ts != NULL ); + nlist__append(nk->ts_list, ts); +} + + + +/* Returns FCT_TRUE if the supplied test_name passes the filters set on +this test suite. If there are no filters, we return FCT_TRUE always. */ +static nbool_t +fctkern__pass_filter(fctkern_t *nk, char const *test_name) { + int prefix_i =0; + int prefix_list_size =0; + + assert( nk != NULL && "invalid arg"); + assert( test_name != NULL ); + assert( strlen(test_name) > 0 ); + + prefix_list_size = fctkern__filter_cnt(nk); + + /* If there is no filter list, then we return FCT_TRUE always. */ + if ( prefix_list_size == 0 ) { + return FCT_TRUE; + } + + /* Iterate through the prefix filter list, and see if we have + anything that does not pass. All we require is ONE item that + passes the test in order for us to succeed here. */ + for ( prefix_i = 0; prefix_i != prefix_list_size; ++prefix_i ) { + char const *prefix = (char const*)nlist__at(nk->prefix_list, prefix_i); + nbool_t pass = fct_filter_pass(prefix, test_name); + if ( pass ) { + return FCT_TRUE; + } + } + + /* Otherwise, we never managed to find a prefix that satisfied the + supplied test name. Therefore we have failed to pass to the filter + list test. */ + return FCT_FALSE; +} + + +/* Returns the number of tests that were performed. */ +static int +fctkern__tst_cnt(fctkern_t const *nk) +{ + int tally =0; + assert( nk != NULL ); + + NLIST_FOREACH_BGN(fct_ts_t *, ts, nk->ts_list) + { + tally += fct_ts__tst_cnt(ts); + } + NLIST_FOREACH_END(); + return tally; +} + +/* Returns the number of tests that passed. */ +static int +fctkern__tst_cnt_passed(fctkern_t const *nk) +{ + int tally =0; + assert( nk != NULL ); + + NLIST_FOREACH_BGN(fct_ts_t*, ts, nk->ts_list) + { + tally += fct_ts__tst_cnt_passed(ts); + } + NLIST_FOREACH_END(); + + return tally; +} + + +/* Returns the number of tests that failed. */ +static int +fctkern__tst_cnt_failed(fctkern_t const *nk) +{ + /* Keep it simple for now and just do a little math. */ + int total =0; + int passed =0; + int failed =0; + + assert( nk != NULL ); + + total = fctkern__tst_cnt(nk); + passed = fctkern__tst_cnt_passed(nk); + + failed = total - passed; + + return failed; +} + + +/* Returns the number of checks made throughout the entire test. */ +static int +fctkern__chk_cnt(fctkern_t const *nk) +{ + int tally =0; + assert( nk != NULL ); + + NLIST_FOREACH_BGN(fct_ts_t *, ts, nk->ts_list) + { + tally += fct_ts__chk_cnt(ts); + } + NLIST_FOREACH_END(); + return tally; +} + + +/* Indicates the very end of all the tests. */ +static void +fctkern__end(fctkern_t *fct) +{ + fct_unused(fct); +} + + +/* Cleans up the contents of a fctkern. NULL does nothing. */ +static void +fctkern__final(fctkern_t *fct) +{ + if ( fct == NULL ) { return; } + + nlist__del(fct->logger_list, (on_del_t)fct_logger__del); + + /* The prefix list is a list of malloc'd strings. */ + nlist__del(fct->prefix_list, (on_del_t)free); + + nlist__del(fct->ts_list, (on_del_t)fct_ts__del); +} + + +static void +fctkern__log_suite_start(fctkern_t *kern, fct_ts_t const *ts) +{ + assert( kern != NULL ); + assert( ts != NULL ); + NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list) + { + fct_logger__on_test_suite_start(logger, ts); + } + NLIST_FOREACH_END(); +} + + +static void +fctkern__log_suite_end(fctkern_t *kern, fct_ts_t const *ts) +{ + assert( kern != NULL ); + assert( ts != NULL ); + NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list) + { + fct_logger__on_test_suite_end(logger, ts); + } + NLIST_FOREACH_END(); +} + + +static void +fctkern__log_chk(fctkern_t *kern, fctchk_t const *chk) +{ + assert( kern != NULL ); + assert( chk != NULL ); + + NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list) + { + fct_logger__on_cndtn(logger, chk); + } + NLIST_FOREACH_END(); +} + + +/* Called whenever a test is started. */ +static void +fctkern__log_test_start(fctkern_t *kern, fct_test_t const *test) +{ + assert( kern != NULL ); + assert( test != NULL ); + NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list) + { + fct_logger__on_test_start(logger, test); + } + NLIST_FOREACH_END(); +} + + +static void +fctkern__log_test_end(fctkern_t *kern, fct_test_t const *test) +{ + assert( kern != NULL ); + assert( test != NULL ); + NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list) + { + fct_logger__on_test_end(logger, test); + } + NLIST_FOREACH_END(); +} + + +static void +fctkern__log_start(fctkern_t *kern) +{ + assert( kern != NULL ); + NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list) + { + fct_logger__on_fct_start(logger, kern); + } + NLIST_FOREACH_END(); +} + + +static void +fctkern__log_end(fctkern_t *kern) +{ + assert( kern != NULL ); + NLIST_FOREACH_BGN(fct_logger_i*, logger, kern->logger_list) + { + fct_logger__on_fct_end(logger, kern); + } + NLIST_FOREACH_END(); +} + + +/* +----------------------------------------------------------- +LOGGER INTERFACE + +Defines an interface to a logging system. A logger +must define the following functions in order to hook +into the logging system. + +See the "Standard Logger" and "Minimal Logger" as examples +of the implementation. +----------------------------------------------------------- +*/ + +typedef void (*fct_logger_on_cndtn_fn)(fct_logger_i *self, + fctchk_t const *chk); +#define _fct_logger_head \ + fct_logger_on_cndtn_fn on_cndtn;\ + void (*on_test_start)(fct_logger_i *logger, fct_test_t const *test);\ + void (*on_test_end)(fct_logger_i *logger, fct_test_t const *test);\ + void (*on_test_suite_start)(fct_logger_i *logger, fct_ts_t const *ts);\ + void (*on_test_suite_end)(fct_logger_i *logger, fct_ts_t const *ts);\ + void (*on_fct_start)(fct_logger_i *logger, fctkern_t const *kern);\ + void (*on_fct_end)(fct_logger_i *logger, fctkern_t const *kern);\ + void (*on_delete)(fct_logger_i *logger)\ + +struct _fct_logger_i { + _fct_logger_head; +}; + + +/* Initializes the elements of a logger interface so they are at their +standard values. */ +static void +fct_logger__init(fct_logger_i *logger) +{ + assert( logger != NULL ); + logger->on_cndtn =NULL; + logger->on_test_start =NULL; + logger->on_test_end =NULL; + logger->on_test_suite_start =NULL; + logger->on_test_suite_end =NULL; + logger->on_fct_start =NULL; + logger->on_fct_end =NULL; + logger->on_delete =NULL; +} + + +static void +fct_logger__del(fct_logger_i *logger) +{ + if ( logger == NULL ) { return; } + if ( logger->on_delete) { logger->on_delete(logger); } +} + + +static void +fct_logger__on_test_start(fct_logger_i *logger, fct_test_t const *test) +{ + assert( logger != NULL && "invalid arg"); + assert( test != NULL && "invalid arg"); + + if ( logger->on_test_start != NULL ) + { + logger->on_test_start(logger, test); + } +} + + +static void +fct_logger__on_test_end(fct_logger_i *logger, fct_test_t const *test) +{ + assert( logger != NULL && "invalid arg"); + assert( test != NULL && "invalid arg"); + + if ( logger->on_test_end != NULL ) + { + logger->on_test_end(logger, test); + } +} + + +static void +fct_logger__on_test_suite_start(fct_logger_i *logger, fct_ts_t const *ts) +{ + assert( logger != NULL && "invalid arg"); + assert( ts != NULL && "invalid arg"); + + if ( logger->on_test_suite_start != NULL ) + { + logger->on_test_suite_start(logger, ts); + } +} + + +static void +fct_logger__on_test_suite_end(fct_logger_i *logger, fct_ts_t const *ts) +{ + assert( logger != NULL && "invalid arg"); + assert( ts != NULL && "invalid arg"); + + if ( logger->on_test_suite_end != NULL ) + { + logger->on_test_suite_end(logger, ts); + } +} + + +static void +fct_logger__on_cndtn(fct_logger_i *logger, fctchk_t const *chk) +{ + assert( logger != NULL && "invalid arg"); + assert( chk != NULL && "invalid arg"); + + if ( logger->on_cndtn ) + { + logger->on_cndtn(logger, chk); + } +} + + +/* When we start all our tests. */ +static void +fct_logger__on_fct_start(fct_logger_i *logger, fctkern_t const *kern) +{ + assert( logger != NULL ); + assert( kern != NULL ); + + if ( logger->on_fct_start != NULL ) + { + logger->on_fct_start(logger, kern); + } +} + + +/* When we have reached the end of ALL of our testing. */ +static void +fct_logger__on_fct_end(fct_logger_i *logger, fctkern_t const *kern) +{ + assert( logger != NULL ); + assert( kern != NULL ); + + if ( logger->on_fct_end ) + { + logger->on_fct_end(logger, kern); + } +} + + + +/* +----------------------------------------------------------- +MINIMAL LOGGER +----------------------------------------------------------- +*/ + +/* Minimal logger, reports the minimum amount of information needed +to determine "something is happening". */ +struct _fct_minimal_logger_t { + _fct_logger_head; +}; + + +static void +fct_minimal_logger__on_cndtn(fct_logger_i *self, fctchk_t const *chk) +{ + fct_unused(self); + printf(fctchk__is_pass(chk) ? "." : "!"); +} + + +static void +fct_minimal_logger__del(fct_logger_i *self) +{ + free(self); +} + + +static fct_minimal_logger_t * +fct_minimal_logger__new(void) +{ + fct_minimal_logger_t *self = (fct_minimal_logger_t*)\ + calloc(1,sizeof(fct_minimal_logger_t)); + if ( self == NULL ) { return NULL; } + + fct_logger__init((fct_logger_i*)self); + + self->on_cndtn = fct_minimal_logger__on_cndtn; + self->on_delete = fct_minimal_logger__del; + return self; +} + + +/* +----------------------------------------------------------- +STANDARD LOGGER +----------------------------------------------------------- +*/ + +struct _fct_standard_logger_t { + _fct_logger_head; + + /* Start time. For now we use the low-accuracy time_t version. */ + fct_timer_t timer; + + /* A list of char*'s that needs to be cleaned up. */ + nlist_t *failed_cndtns_list; +}; + + +/* When a failure occurrs, we will record the details so we can display +them when the log "finishes" up. */ +static void +fct_standard_logger__on_cndtn(fct_logger_i *logger_, fctchk_t const *chk) +{ + fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_; + + assert( logger != NULL ); + assert( chk != NULL ); + + /* Only record failures. */ + if ( !fctchk__is_pass(chk) ) + { + /* For now we will truncate the string to some set amount, later + we can work out a dynamic string object. */ + char *str = (char*)malloc(sizeof(char)*FCT_MAX_LOG_LINE); + assert( str != NULL ); + + fct_snprintf( + str, + FCT_MAX_LOG_LINE, + "%s(%d): %s", + fctchk__file(chk), + fctchk__lineno(chk), + fctchk__cndtn(chk) + ); + + /* Append it to the listing ... */ + nlist__append(logger->failed_cndtns_list, (void*)str); + } +} + + +static void +fct_standard_logger__on_test_start(fct_logger_i *logger_, + fct_test_t const *test) +{ + fct_unused(logger_); + printf("%s ... ", fct_test__name(test)); +} + + +static void +fct_standard_logger__on_test_end(fct_logger_i *logger_, + fct_test_t const *test) +{ + nbool_t is_pass; + fct_unused(logger_); + + is_pass = fct_test__is_pass(test); + printf("%s\n", (is_pass) ? "PASS" : "FAIL" ); +} + + +static void +fct_standard_logger__on_test_suite_start(fct_logger_i *logger_, + fct_ts_t const *ts) +{ + fct_unused(logger_); + fct_unused(ts); +} + + +static void +fct_standard_logger__on_test_suite_end(fct_logger_i *logger_, + fct_ts_t const *ts) +{ + fct_unused(logger_); + fct_unused(ts); +} + + +static void +fct_standard_logger__on_fct_start(fct_logger_i *logger_, + fctkern_t const *nk) +{ + fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_; + fct_unused(nk); + fct_timer__start(&(logger->timer)); +} + + +static void +fct_standard_logger__on_fct_end(fct_logger_i *logger_, fctkern_t const *nk) +{ + fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_; + nbool_t is_success =1; + double elasped_time =0; + int num_tests =0; + int num_passed =0; + + fct_timer__stop(&(logger->timer)); + + is_success = nlist__size(logger->failed_cndtns_list) ==0; + + if ( !is_success ) + { + printf("\n--------------------------------------------------------\n"); + printf("FAILED TESTS\n\n"); + + NLIST_FOREACH_BGN(char *, cndtn_str, logger->failed_cndtns_list) + { + printf("%s\n", cndtn_str); + } + NLIST_FOREACH_END(); + + printf("\n"); + } + + printf("\n--------------------------------------------------------\n"); + + num_tests = fctkern__tst_cnt(nk); + num_passed = fctkern__tst_cnt_passed(nk); + + printf( + "%s (%d/%d tests", + (is_success) ? "PASSED" : "FAILED", + num_passed, + num_tests + ); + + elasped_time = fct_timer__duration(&(logger->timer)); + if ( elasped_time > 0.0000001 ) + { + printf(" in %.6fs)\n", elasped_time); + } + else + { + /* Don't bother displaying the time to execute. */ + printf(")\n"); + } +} + + +static void +fct_standard_logger__del(fct_logger_i *logger_) +{ + fct_standard_logger_t *logger = (fct_standard_logger_t*)logger_; + + NLIST_FOREACH_BGN(char *, cndtn_str, logger->failed_cndtns_list) + { + free(cndtn_str); + } + NLIST_FOREACH_END(); + + free(logger); + logger_ =NULL; +} + + +fct_standard_logger_t * +fct_standard_logger__new(void) +{ + fct_standard_logger_t *logger = (fct_standard_logger_t *)calloc( + 1, sizeof(fct_standard_logger_t) + ); + if ( logger == NULL ) + { + return NULL; + } + fct_logger__init((fct_logger_i*)logger); + logger->on_cndtn = fct_standard_logger__on_cndtn; + logger->on_test_start = fct_standard_logger__on_test_start; + logger->on_test_end = fct_standard_logger__on_test_end; + logger->on_test_suite_start = fct_standard_logger__on_test_suite_start; + logger->on_test_suite_end = fct_standard_logger__on_test_suite_end; + logger->on_fct_start = fct_standard_logger__on_fct_start; + logger->on_fct_end = fct_standard_logger__on_fct_end; + logger->on_delete = fct_standard_logger__del; + + logger->failed_cndtns_list = nlist_new(); + assert( logger->failed_cndtns_list != NULL ); + + fct_timer__init(&(logger->timer)); + + return logger; +} + + + +/* +------------------------------------------------------------ +MAGIC MACROS +------------------------------------------------------------ +*/ + +#define FCT_BGN() \ +int \ +main(int argc, char *argv[])\ +{\ + fctkern_t fctkern__;\ + fctkern_init(&fctkern__, argc, argv);\ + fctkern__log_start(&fctkern__); + + +#define FCT_END()\ + {\ + int num_failed__ =0;\ + num_failed__ = fctkern__tst_cnt_failed((&fctkern__));\ + fctkern__log_end(&fctkern__);\ + fctkern__end(&fctkern__);\ + fctkern__final(&fctkern__);\ + return num_failed__;\ + }\ +} + +#define FCT_FIXTURE_SUITE_BGN(_NAME_) \ + {\ + fct_ts_t *ts__ = fct_ts_new( #_NAME_ );\ + fctkern__log_suite_start((&fctkern__), ts__);\ + for (;;)\ + {\ + int fct_test_num__ = -1;\ + _fct_cmt("Strict compiler warnings will complain in 'blank' suites.")\ + _fct_cmt("so we are going to do a 'noop' to trick them.")\ + fct_test_num__ = fct_test_num__;\ + if ( fct_ts__is_ending_mode(ts__) )\ + {\ + _fct_cmt("flag the test suite as complete.");\ + fct_ts__end(ts__);\ + break;\ + } + + +/* Closes off a "Fixture" test suite. */ +#define FCT_FIXTURE_SUITE_END() \ + if ( fct_ts__is_cnt_mode(ts__) )\ + {\ + fct_ts__cnt_end(ts__);\ + }\ + }\ + fctkern__add_ts((&fctkern__), ts__);\ + fctkern__log_suite_end((&fctkern__), ts__);\ + ts__ = NULL;\ + } + + + +#define FCT_SETUP_BGN()\ + if ( fct_ts__is_setup_mode(ts__) ) { + +#define FCT_SETUP_END() \ + fct_ts__setup_end(ts__); } + +#define FCT_TEARDOWN_BGN() \ + if ( fct_ts__is_teardown_mode(ts__) ) {\ + +#define FCT_TEARDOWN_END() \ + fct_ts__teardown_end(ts__); \ + continue; \ + } + +/* Lets you create a test suite, where maybe you don't want a fixture. We +do it by 'stubbing' out the setup/teardown logic. */ +#define FCT_SUITE_BGN(Name) \ + FCT_FIXTURE_SUITE_BGN(Name) {\ + FCT_SETUP_BGN() {_fct_cmt("stubbed"); } FCT_SETUP_END()\ + FCT_TEARDOWN_BGN() {_fct_cmt("stubbed");} FCT_TEARDOWN_END()\ + +#define FCT_SUITE_END() } FCT_FIXTURE_SUITE_END() + +/* Depending on whether or not we are counting the tests, we will have to +first determine if the test is the "current" count. Then we have to determine +if we can pass the filter. Finally we will execute everything so that when a +check fails, we can "break" out to the end of the test. */ +#define FCT_TEST_BGN(_NAME_) \ + {\ + char const *test_name__ = #_NAME_;\ + ++fct_test_num__;\ + if ( fct_ts__is_cnt_mode(ts__) )\ + {\ + fct_ts__inc_total_test_num(ts__);\ + }\ + else if ( fct_ts__is_test_mode(ts__) \ + && fct_ts__is_test_cnt(ts__, fct_test_num__) )\ + {\ + int is_pass__;\ + is_pass__ = FCT_FALSE;\ + fct_ts__test_begin(ts__);\ + if ( fctkern__pass_filter(&fctkern__, test_name__ ) )\ + {\ + fct_test_t *test__ = fct_test_new( test_name__ );\ + fctkern__log_test_start(&fctkern__, test__);\ + for (;;) \ + { + +#define FCT_TEST_END() \ + break;\ + }\ + fct_ts__add_test(ts__, test__);\ + fctkern__log_test_end(&fctkern__, test__);\ + }\ + fct_ts__test_end(ts__);\ + continue;\ + }\ + } + + + +/* +--------------------------------------------------------- +CHECKING MACROS +---------------------------------------------------------- + +For now we only have the one "positive" check macro. In the future I plan +to add more macros that check for different types of common conditions. +*/ + +#define fct_chk(_CNDTN_) \ + {\ + fctchk_t *chk =NULL;\ + is_pass__ = (_CNDTN_);\ + chk = fctchk_new(#_CNDTN_, __FILE__, __LINE__, is_pass__);\ + fct_test__add(test__, chk);\ + fctkern__log_chk(&fctkern__, chk);\ + if ( !is_pass__ ) { break; }\ + } + + +/* +--------------------------------------------------------- +GUT CHECK MACROS +---------------------------------------------------------- + +The following macros are used to help check the "guts" of +the FCT, and to confirm that it all works according to spec. +*/ + +/* Generates a message to STDERR and exits the application with a +non-zero number. */ +#define _FCT_GUTCHK(_CNDTN_) \ + if ( !(_CNDTN_) ) {\ + fprintf(stderr, "gutchk fail: '" #_CNDTN_ "' was not true.\n");\ + exit(1);\ + }\ + else {\ + fprintf(stdout, "gutchk pass: '" #_CNDTN_ "'\n");\ + } + + +/* +--------------------------------------------------------- +CLOSING STATEMENTS +---------------------------------------------------------- +*/ + +/* This is defined at the start of the file. We are undefining it +here so it doesn't conflict with existing. */ +#if defined(WIN32) +# undef _CRT_SECURE_NO_WARNINGS +#endif + +#endif /* !FCT_INCLUDED__IMB */ diff --git a/tests/scripts/generate_code.pl b/tests/scripts/generate_code.pl new file mode 100755 index 0000000..6aa9c05 --- /dev/null +++ b/tests/scripts/generate_code.pl @@ -0,0 +1,91 @@ +#!/usr/bin/perl +# + +use strict; + +my $suite_dir = shift or die "Missing suite directory"; +my $suite_name = shift or die "Missing suite name"; +my $test_file = $suite_name.".c"; +my $test_helper_file = $suite_dir."/helpers.function"; +my $test_case_file = $suite_dir."/".$suite_name.".function"; +my $test_data_file = $suite_dir."/".$suite_name.".data"; + +open(TEST_DATA, "$test_data_file") or die "Opening test cases '$test_data_file': $!"; + +my $line_separator = $/; +undef $/; + +open(TEST_HELPERS, "$test_helper_file") or die "Opening test helpers '$test_helper_file': $!"; +my $test_helpers = ; +close(TEST_HELPERS); + +open(TEST_CASES, "$test_case_file") or die "Opening test cases '$test_case_file': $!"; +my $test_cases = ; +close(TEST_CASES); +my ( $suite_header ) = $test_cases =~ /BEGIN_HEADER\n(.*?)\nEND_HEADER/s; + +$/ = $line_separator; + +open(TEST_FILE, ">$test_file") or die "Opening destination file '$test_file': $!"; +print TEST_FILE << "END"; +#include "fct.h" +$suite_header + +$test_helpers + +FCT_BGN() +{ + FCT_SUITE_BGN($suite_name) + { +END + +while (my $line = ) +{ + my $description = $line; + $line = ; + my $command_line = $line; + $line = ; + + my $test_name = $description; + $test_name =~ tr/A-Z \-/a-z__/; + $test_name =~ tr/a-z0-9_//cd; + + my ( $case, $var_value ) = $command_line =~ /^([\w_]+):(.*)$/; + + my ( $var_def, $case_code ) = $test_cases =~ /BEGIN_CASE\n$case:([^\n]*)\n(.*?)\nEND_CASE/s; + + my @var_def_arr = split(/:/, $var_def); + my @var_value_arr = split(/:/, $var_value); + + while (@var_def_arr) + { + my $def = shift @var_def_arr; + my $val = shift @var_value_arr; + + $case_code =~ s/\{$def\}/$val/g; + } + $case_code = "int ${test_name}_code_present = 0;\nTEST_ASSERT( ${test_name}_code_present == 1 );" if ($case_code =~ /^\s*$/); + + $case_code =~ s/TEST_ASSERT/fct_chk/g; + $case_code =~ s/TEST_EQUALS/fct_chk/g; + + $case_code =~ s/^/ /gm; + + + print TEST_FILE << "END"; + FCT_TEST_BGN($test_name) +$case_code + FCT_TEST_END(); + +END +} + +print TEST_FILE << "END"; + } + FCT_SUITE_END(); +} +FCT_END(); +END + +close(TEST_DATA); +close(TEST_FILE); diff --git a/tests/suites/helpers.function b/tests/suites/helpers.function new file mode 100644 index 0000000..6717292 --- /dev/null +++ b/tests/suites/helpers.function @@ -0,0 +1,57 @@ +int unhexify(unsigned char *obuf, const char *ibuf) +{ + unsigned char c, c2; + int len = strlen(ibuf) / 2; + assert(!(strlen(ibuf) %1)); // must be even number of bytes + + while (*ibuf != 0) + { + c = *ibuf++; + if( c >= '0' && c <= '9' ) + c -= '0'; + else if( c >= 'a' && c <= 'f' ) + c -= 'a' - 10; + else if( c >= 'A' && c <= 'F' ) + c -= 'A' - 10; + else + assert( 0 ); + + c2 = *ibuf++; + if( c2 >= '0' && c2 <= '9' ) + c2 -= '0'; + else if( c2 >= 'a' && c2 <= 'f' ) + c2 -= 'a' - 10; + else if( c2 >= 'A' && c2 <= 'F' ) + c2 -= 'A' - 10; + else + assert( 0 ); + + *obuf++ = ( c << 4 ) | c2; + } + + return len; +} + +void hexify(unsigned char *obuf, const unsigned char *ibuf, int len) +{ + unsigned char l, h; + + while (len != 0) + { + h = (*ibuf) / 16; + l = (*ibuf) % 16; + + if( h < 10 ) + *obuf++ = '0' + h; + else + *obuf++ = 'a' + h - 10; + + if( l < 10 ) + *obuf++ = '0' + l; + else + *obuf++ = 'a' + l - 10; + + ++ibuf; + len--; + } +} diff --git a/tests/suites/test_suite_aes.data b/tests/suites/test_suite_aes.data new file mode 100644 index 0000000..ddfddcf --- /dev/null +++ b/tests/suites/test_suite_aes.data @@ -0,0 +1,662 @@ +AES-128-ECB Encrypt NIST KAT #1 +aes_encrypt_ecb:"00000000000000000000000000000000":"f34481ec3cc627bacd5dc3fb08f273e6":"0336763e966d92595a567cc9ce537f5e" + +AES-128-ECB Encrypt NIST KAT #2 +aes_encrypt_ecb:"00000000000000000000000000000000":"9798c4640bad75c7c3227db910174e72":"a9a1631bf4996954ebc093957b234589" + +AES-128-ECB Encrypt NIST KAT #3 +aes_encrypt_ecb:"00000000000000000000000000000000":"96ab5c2ff612d9dfaae8c31f30c42168":"ff4f8391a6a40ca5b25d23bedd44a597" + +AES-128-ECB Encrypt NIST KAT #4 +aes_encrypt_ecb:"e0000000000000000000000000000000":"00000000000000000000000000000000":"72a1da770f5d7ac4c9ef94d822affd97" + +AES-128-ECB Encrypt NIST KAT #5 +aes_encrypt_ecb:"f0000000000000000000000000000000":"00000000000000000000000000000000":"970014d634e2b7650777e8e84d03ccd8" + +AES-128-ECB Encrypt NIST KAT #6 +aes_encrypt_ecb:"f8000000000000000000000000000000":"00000000000000000000000000000000":"f17e79aed0db7e279e955b5f493875a7" + +AES-128-ECB Encrypt NIST KAT #7 +aes_encrypt_ecb:"fffffffffffff0000000000000000000":"00000000000000000000000000000000":"7b90785125505fad59b13c186dd66ce3" + +AES-128-ECB Encrypt NIST KAT #8 +aes_encrypt_ecb:"fffffffffffff8000000000000000000":"00000000000000000000000000000000":"8b527a6aebdaec9eaef8eda2cb7783e5" + +AES-128-ECB Encrypt NIST KAT #9 +aes_encrypt_ecb:"fffffffffffffc000000000000000000":"00000000000000000000000000000000":"43fdaf53ebbc9880c228617d6a9b548b" + +AES-128-ECB Encrypt NIST KAT #10 +aes_encrypt_ecb:"ffffffffffffffffffffffffffffc000":"00000000000000000000000000000000":"70c46bb30692be657f7eaa93ebad9897" + +AES-128-ECB Encrypt NIST KAT #11 +aes_encrypt_ecb:"ffffffffffffffffffffffffffffe000":"00000000000000000000000000000000":"323994cfb9da285a5d9642e1759b224a" + +AES-128-ECB Encrypt NIST KAT #12 +aes_encrypt_ecb:"fffffffffffffffffffffffffffff000":"00000000000000000000000000000000":"1dbf57877b7b17385c85d0b54851e371" + +AES-128-ECB Encrypt NIST KAT #13 +aes_encrypt_ecb:"00000000000000000000000000000000":"ffffffffffffffc00000000000000000":"3a4d354f02bb5a5e47d39666867f246a" + +AES-128-ECB Encrypt NIST KAT #14 +aes_encrypt_ecb:"00000000000000000000000000000000":"ffffffffffffffe00000000000000000":"d451b8d6e1e1a0ebb155fbbf6e7b7dc3" + +AES-128-ECB Encrypt NIST KAT #15 +aes_encrypt_ecb:"00000000000000000000000000000000":"fffffffffffffff00000000000000000":"6898d4f42fa7ba6a10ac05e87b9f2080" + +AES-128-ECB Encrypt NIST KAT #16 +aes_encrypt_ecb:"00000000000000000000000000000000":"ffffffffffffffffffffffffe0000000":"082eb8be35f442fb52668e16a591d1d6" + +AES-128-ECB Encrypt NIST KAT #17 +aes_encrypt_ecb:"00000000000000000000000000000000":"fffffffffffffffffffffffff0000000":"e656f9ecf5fe27ec3e4a73d00c282fb3" + +AES-128-ECB Encrypt NIST KAT #18 +aes_encrypt_ecb:"00000000000000000000000000000000":"fffffffffffffffffffffffff8000000":"2ca8209d63274cd9a29bb74bcd77683a" + +AES-128-ECB Decrypt NIST KAT #1 +aes_decrypt_ecb:"00000000000000000000000000000000":"db4f1aa530967d6732ce4715eb0ee24b":"ff000000000000000000000000000000" + +AES-128-ECB Decrypt NIST KAT #2 +aes_decrypt_ecb:"00000000000000000000000000000000":"a81738252621dd180a34f3455b4baa2f":"ff800000000000000000000000000000" + +AES-128-ECB Decrypt NIST KAT #3 +aes_decrypt_ecb:"00000000000000000000000000000000":"77e2b508db7fd89234caf7939ee5621a":"ffc00000000000000000000000000000" + +AES-128-ECB Decrypt NIST KAT #4 +aes_decrypt_ecb:"00000000000000000000000000000000":"dc43be40be0e53712f7e2bf5ca707209":"6a118a874519e64e9963798a503f1d35" + +AES-128-ECB Decrypt NIST KAT #5 +aes_decrypt_ecb:"00000000000000000000000000000000":"92beedab1895a94faa69b632e5cc47ce":"cb9fceec81286ca3e989bd979b0cb284" + +AES-128-ECB Decrypt NIST KAT #6 +aes_decrypt_ecb:"00000000000000000000000000000000":"459264f4798f6a78bacb89c15ed3d601":"b26aeb1874e47ca8358ff22378f09144" + +AES-128-ECB Decrypt NIST KAT #7 +aes_decrypt_ecb:"b69418a85332240dc82492353956ae0c":"a303d940ded8f0baff6f75414cac5243":"00000000000000000000000000000000" + +AES-128-ECB Decrypt NIST KAT #8 +aes_decrypt_ecb:"71b5c08a1993e1362e4d0ce9b22b78d5":"c2dabd117f8a3ecabfbb11d12194d9d0":"00000000000000000000000000000000" + +AES-128-ECB Decrypt NIST KAT #9 +aes_decrypt_ecb:"e234cdca2606b81f29408d5f6da21206":"fff60a4740086b3b9c56195b98d91a7b":"00000000000000000000000000000000" + +AES-128-ECB Decrypt NIST KAT #10 +aes_decrypt_ecb:"ffffffffffffffff0000000000000000":"84be19e053635f09f2665e7bae85b42d":"00000000000000000000000000000000" + +AES-128-ECB Decrypt NIST KAT #11 +aes_decrypt_ecb:"ffffffffffffffff8000000000000000":"32cd652842926aea4aa6137bb2be2b5e":"00000000000000000000000000000000" + +AES-192-ECB Encrypt NIST KAT #1 +aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"fffffffffffffffffffff80000000000":"156f07767a85a4312321f63968338a01" + +AES-192-ECB Encrypt NIST KAT #2 +aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"fffffffffffffffffffffc0000000000":"15eec9ebf42b9ca76897d2cd6c5a12e2" + +AES-192-ECB Encrypt NIST KAT #3 +aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"fffffffffffffffffffffe0000000000":"db0d3a6fdcc13f915e2b302ceeb70fd8" + +AES-192-ECB Encrypt NIST KAT #4 +aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"51719783d3185a535bd75adc65071ce1":"4f354592ff7c8847d2d0870ca9481b7c" + +AES-192-ECB Encrypt NIST KAT #5 +aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"26aa49dcfe7629a8901a69a9914e6dfd":"d5e08bf9a182e857cf40b3a36ee248cc" + +AES-192-ECB Encrypt NIST KAT #6 +aes_encrypt_ecb:"000000000000000000000000000000000000000000000000":"941a4773058224e1ef66d10e0a6ee782":"067cd9d3749207791841562507fa9626" + +AES-192-ECB Encrypt NIST KAT #7 +aes_encrypt_ecb:"d2926527e0aa9f37b45e2ec2ade5853ef807576104c7ace3":"00000000000000000000000000000000":"dd619e1cf204446112e0af2b9afa8f8c" + +AES-192-ECB Encrypt NIST KAT #8 +aes_encrypt_ecb:"982215f4e173dfa0fcffe5d3da41c4812c7bcc8ed3540f93":"00000000000000000000000000000000":"d4f0aae13c8fe9339fbf9e69ed0ad74d" + +AES-192-ECB Encrypt NIST KAT #9 +aes_encrypt_ecb:"98c6b8e01e379fbd14e61af6af891596583565f2a27d59e9":"00000000000000000000000000000000":"19c80ec4a6deb7e5ed1033dda933498f" + +AES-192-ECB Encrypt NIST KAT #10 +aes_encrypt_ecb:"fffffffffffffffffffffffffff800000000000000000000":"00000000000000000000000000000000":"8dd274bd0f1b58ae345d9e7233f9b8f3" + +AES-192-ECB Encrypt NIST KAT #11 +aes_encrypt_ecb:"fffffffffffffffffffffffffffc00000000000000000000":"00000000000000000000000000000000":"9d6bdc8f4ce5feb0f3bed2e4b9a9bb0b" + +AES-192-ECB Encrypt NIST KAT #12 +aes_encrypt_ecb:"fffffffffffffffffffffffffffe00000000000000000000":"00000000000000000000000000000000":"fd5548bcf3f42565f7efa94562528d46" + +AES-192-ECB Decrypt NIST KAT #1 +aes_decrypt_ecb:"fffffffffffffffffffffffffffffffff000000000000000":"bb2852c891c5947d2ed44032c421b85f":"00000000000000000000000000000000" + +AES-192-ECB Decrypt NIST KAT #2 +aes_decrypt_ecb:"fffffffffffffffffffffffffffffffff800000000000000":"1b9f5fbd5e8a4264c0a85b80409afa5e":"00000000000000000000000000000000" + +AES-192-ECB Decrypt NIST KAT #3 +aes_decrypt_ecb:"fffffffffffffffffffffffffffffffffc00000000000000":"30dab809f85a917fe924733f424ac589":"00000000000000000000000000000000" + +AES-192-ECB Decrypt NIST KAT #4 +aes_decrypt_ecb:"61257134a518a0d57d9d244d45f6498cbc32f2bafc522d79":"cfe4d74002696ccf7d87b14a2f9cafc9":"00000000000000000000000000000000" + +AES-192-ECB Decrypt NIST KAT #5 +aes_decrypt_ecb:"b0ab0a6a818baef2d11fa33eac947284fb7d748cfb75e570":"d2eafd86f63b109b91f5dbb3a3fb7e13":"00000000000000000000000000000000" + +AES-192-ECB Decrypt NIST KAT #6 +aes_decrypt_ecb:"ee053aa011c8b428cdcc3636313c54d6a03cac01c71579d6":"9b9fdd1c5975655f539998b306a324af":"00000000000000000000000000000000" + +AES-192-ECB Decrypt NIST KAT #7 +aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"275cfc0413d8ccb70513c3859b1d0f72":"1b077a6af4b7f98229de786d7516b639" + +AES-192-ECB Decrypt NIST KAT #8 +aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"c9b8135ff1b5adc413dfd053b21bd96d":"9c2d8842e5f48f57648205d39a239af1" + +AES-192-ECB Decrypt NIST KAT #9 +aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"4a3650c3371ce2eb35e389a171427440":"bff52510095f518ecca60af4205444bb" + +AES-192-ECB Decrypt NIST KAT #10 +aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"b2099795e88cc158fd75ea133d7e7fbe":"ffffffffffffffffffffc00000000000" + +AES-192-ECB Decrypt NIST KAT #11 +aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"a6cae46fb6fadfe7a2c302a34242817b":"ffffffffffffffffffffe00000000000" + +AES-192-ECB Decrypt NIST KAT #12 +aes_decrypt_ecb:"000000000000000000000000000000000000000000000000":"026a7024d6a902e0b3ffccbaa910cc3f":"fffffffffffffffffffff00000000000" + +AES-256-ECB Encrypt NIST KAT #1 +aes_encrypt_ecb:"c1cc358b449909a19436cfbb3f852ef8bcb5ed12ac7058325f56e6099aab1a1c":"00000000000000000000000000000000":"352065272169abf9856843927d0674fd" + +AES-256-ECB Encrypt NIST KAT #2 +aes_encrypt_ecb:"984ca75f4ee8d706f46c2d98c0bf4a45f5b00d791c2dfeb191b5ed8e420fd627":"00000000000000000000000000000000":"4307456a9e67813b452e15fa8fffe398" + +AES-256-ECB Encrypt NIST KAT #3 +aes_encrypt_ecb:"b43d08a447ac8609baadae4ff12918b9f68fc1653f1269222f123981ded7a92f":"00000000000000000000000000000000":"4663446607354989477a5c6f0f007ef4" + +AES-256-ECB Encrypt NIST KAT #4 +aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"0b24af36193ce4665f2825d7b4749c98":"a9ff75bd7cf6613d3731c77c3b6d0c04" + +AES-256-ECB Encrypt NIST KAT #5 +aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"761c1fe41a18acf20d241650611d90f1":"623a52fcea5d443e48d9181ab32c7421" + +AES-256-ECB Encrypt NIST KAT #6 +aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"8a560769d605868ad80d819bdba03771":"38f2c7ae10612415d27ca190d27da8b4" + +AES-256-ECB Encrypt NIST KAT #7 +aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"ffffff80000000000000000000000000":"36aff0ef7bf3280772cf4cac80a0d2b2" + +AES-256-ECB Encrypt NIST KAT #8 +aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"ffffffc0000000000000000000000000":"1f8eedea0f62a1406d58cfc3ecea72cf" + +AES-256-ECB Encrypt NIST KAT #9 +aes_encrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"ffffffe0000000000000000000000000":"abf4154a3375a1d3e6b1d454438f95a6" + +AES-256-ECB Encrypt NIST KAT #10 +aes_encrypt_ecb:"ffffffffffffffffffffffffffffffffffff8000000000000000000000000000":"00000000000000000000000000000000":"45d089c36d5c5a4efc689e3b0de10dd5" + +AES-256-ECB Encrypt NIST KAT #11 +aes_encrypt_ecb:"ffffffffffffffffffffffffffffffffffffc000000000000000000000000000":"00000000000000000000000000000000":"b4da5df4becb5462e03a0ed00d295629" + +AES-256-ECB Encrypt NIST KAT #12 +aes_encrypt_ecb:"ffffffffffffffffffffffffffffffffffffe000000000000000000000000000":"00000000000000000000000000000000":"dcf4e129136c1a4b7a0f38935cc34b2b" + +AES-256-ECB Decrypt NIST KAT #1 +aes_decrypt_ecb:"fffffffffffffffffffffffffffffffffffffffffffffff00000000000000000":"edf61ae362e882ddc0167474a7a77f3a":"00000000000000000000000000000000" + +AES-256-ECB Decrypt NIST KAT #2 +aes_decrypt_ecb:"fffffffffffffffffffffffffffffffffffffffffffffff80000000000000000":"6168b00ba7859e0970ecfd757efecf7c":"00000000000000000000000000000000" + +AES-256-ECB Decrypt NIST KAT #3 +aes_decrypt_ecb:"fffffffffffffffffffffffffffffffffffffffffffffffc0000000000000000":"d1415447866230d28bb1ea18a4cdfd02":"00000000000000000000000000000000" + +AES-256-ECB Decrypt NIST KAT #4 +aes_decrypt_ecb:"f8be9ba615c5a952cabbca24f68f8593039624d524c816acda2c9183bd917cb9":"a3944b95ca0b52043584ef02151926a8":"00000000000000000000000000000000" + +AES-256-ECB Decrypt NIST KAT #5 +aes_decrypt_ecb:"797f8b3d176dac5b7e34a2d539c4ef367a16f8635f6264737591c5c07bf57a3e":"a74289fe73a4c123ca189ea1e1b49ad5":"00000000000000000000000000000000" + +AES-256-ECB Decrypt NIST KAT #6 +aes_decrypt_ecb:"6838d40caf927749c13f0329d331f448e202c73ef52c5f73a37ca635d4c47707":"b91d4ea4488644b56cf0812fa7fcf5fc":"00000000000000000000000000000000" + +AES-256-ECB Decrypt NIST KAT #7 +aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"623a52fcea5d443e48d9181ab32c7421":"761c1fe41a18acf20d241650611d90f1" + +AES-256-ECB Decrypt NIST KAT #8 +aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"38f2c7ae10612415d27ca190d27da8b4":"8a560769d605868ad80d819bdba03771" + +AES-256-ECB Decrypt NIST KAT #9 +aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"1bc704f1bce135ceb810341b216d7abe":"91fbef2d15a97816060bee1feaa49afe" + +AES-256-ECB Decrypt NIST KAT #10 +aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"ddc6bf790c15760d8d9aeb6f9a75fd4e":"80000000000000000000000000000000" + +AES-256-ECB Decrypt NIST KAT #11 +aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"0a6bdc6d4c1e6280301fd8e97ddbe601":"c0000000000000000000000000000000" + +AES-256-ECB Decrypt NIST KAT #12 +aes_decrypt_ecb:"0000000000000000000000000000000000000000000000000000000000000000":"9b80eefb7ebe2d2b16247aa0efc72f5d":"e0000000000000000000000000000000" + +AES-128-CBC Encrypt NIST KAT #1 +aes_encrypt_cbc:"fffffffffffff8000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"8b527a6aebdaec9eaef8eda2cb7783e5" + +AES-128-CBC Encrypt NIST KAT #2 +aes_encrypt_cbc:"fffffffffffffc000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"43fdaf53ebbc9880c228617d6a9b548b" + +AES-128-CBC Encrypt NIST KAT #3 +aes_encrypt_cbc:"fffffffffffffe000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"53786104b9744b98f052c46f1c850d0b" + +AES-128-CBC Encrypt NIST KAT #4 +aes_encrypt_cbc:"e37b1c6aa2846f6fdb413f238b089f23":"00000000000000000000000000000000":"00000000000000000000000000000000":"43c9f7e62f5d288bb27aa40ef8fe1ea8" + +AES-128-CBC Encrypt NIST KAT #5 +aes_encrypt_cbc:"6c002b682483e0cabcc731c253be5674":"00000000000000000000000000000000":"00000000000000000000000000000000":"3580d19cff44f1014a7c966a69059de5" + +AES-128-CBC Encrypt NIST KAT #6 +aes_encrypt_cbc:"143ae8ed6555aba96110ab58893a8ae1":"00000000000000000000000000000000":"00000000000000000000000000000000":"806da864dd29d48deafbe764f8202aef" + +AES-128-CBC Encrypt NIST KAT #7 +aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"6a118a874519e64e9963798a503f1d35":"dc43be40be0e53712f7e2bf5ca707209" + +AES-128-CBC Encrypt NIST KAT #8 +aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"cb9fceec81286ca3e989bd979b0cb284":"92beedab1895a94faa69b632e5cc47ce" + +AES-128-CBC Encrypt NIST KAT #9 +aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"b26aeb1874e47ca8358ff22378f09144":"459264f4798f6a78bacb89c15ed3d601" + +AES-128-CBC Encrypt NIST KAT #10 +aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffffffffffffc000000000":"90684a2ac55fe1ec2b8ebd5622520b73" + +AES-128-CBC Encrypt NIST KAT #11 +aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffffffffffffe000000000":"7472f9a7988607ca79707795991035e6" + +AES-128-CBC Encrypt NIST KAT #12 +aes_encrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"fffffffffffffffffffffff000000000":"56aff089878bf3352f8df172a3ae47d8" + +AES-128-CBC Decrypt NIST KAT #1 +aes_decrypt_cbc:"ffffffffe00000000000000000000000":"00000000000000000000000000000000":"23f710842b9bb9c32f26648c786807ca":"00000000000000000000000000000000" + +AES-128-CBC Decrypt NIST KAT #2 +aes_decrypt_cbc:"fffffffff00000000000000000000000":"00000000000000000000000000000000":"44a98bf11e163f632c47ec6a49683a89":"00000000000000000000000000000000" + +AES-128-CBC Decrypt NIST KAT #3 +aes_decrypt_cbc:"fffffffff80000000000000000000000":"00000000000000000000000000000000":"0f18aff94274696d9b61848bd50ac5e5":"00000000000000000000000000000000" + +AES-128-CBC Decrypt NIST KAT #4 +aes_decrypt_cbc:"e234cdca2606b81f29408d5f6da21206":"00000000000000000000000000000000":"fff60a4740086b3b9c56195b98d91a7b":"00000000000000000000000000000000" + +AES-128-CBC Decrypt NIST KAT #5 +aes_decrypt_cbc:"13237c49074a3da078dc1d828bb78c6f":"00000000000000000000000000000000":"8146a08e2357f0caa30ca8c94d1a0544":"00000000000000000000000000000000" + +AES-128-CBC Decrypt NIST KAT #6 +aes_decrypt_cbc:"3071a2a48fe6cbd04f1a129098e308f8":"00000000000000000000000000000000":"4b98e06d356deb07ebb824e5713f7be3":"00000000000000000000000000000000" + +AES-128-CBC Decrypt NIST KAT #7 +aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"0336763e966d92595a567cc9ce537f5e":"f34481ec3cc627bacd5dc3fb08f273e6" + +AES-128-CBC Decrypt NIST KAT #8 +aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"a9a1631bf4996954ebc093957b234589":"9798c4640bad75c7c3227db910174e72" + +AES-128-CBC Decrypt NIST KAT #9 +aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"ff4f8391a6a40ca5b25d23bedd44a597":"96ab5c2ff612d9dfaae8c31f30c42168" + +AES-128-CBC Decrypt NIST KAT #10 +aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"f9b0fda0c4a898f5b9e6f661c4ce4d07":"fffffffffffffffffffffffffffffff0" + +AES-128-CBC Decrypt NIST KAT #11 +aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"8ade895913685c67c5269f8aae42983e":"fffffffffffffffffffffffffffffff8" + +AES-128-CBC Decrypt NIST KAT #12 +aes_decrypt_cbc:"00000000000000000000000000000000":"00000000000000000000000000000000":"39bde67d5c8ed8a8b1c37eb8fa9f5ac0":"fffffffffffffffffffffffffffffffc" + +AES-192-CBC Encrypt NIST KAT #1 +aes_encrypt_cbc:"fffffffffffffffffffffffffffffffffffffffffffffe00":"00000000000000000000000000000000":"00000000000000000000000000000000":"ddb505e6cc1384cbaec1df90b80beb20" + +AES-192-CBC Encrypt NIST KAT #2 +aes_encrypt_cbc:"ffffffffffffffffffffffffffffffffffffffffffffff00":"00000000000000000000000000000000":"00000000000000000000000000000000":"5674a3bed27bf4bd3622f9f5fe208306" + +AES-192-CBC Encrypt NIST KAT #3 +aes_encrypt_cbc:"ffffffffffffffffffffffffffffffffffffffffffffff80":"00000000000000000000000000000000":"00000000000000000000000000000000":"b687f26a89cfbfbb8e5eeac54055315e" + +AES-192-CBC Encrypt NIST KAT #4 +aes_encrypt_cbc:"25a39dbfd8034f71a81f9ceb55026e4037f8f6aa30ab44ce":"00000000000000000000000000000000":"00000000000000000000000000000000":"3608c344868e94555d23a120f8a5502d" + +AES-192-CBC Encrypt NIST KAT #5 +aes_encrypt_cbc:"e08c15411774ec4a908b64eadc6ac4199c7cd453f3aaef53":"00000000000000000000000000000000":"00000000000000000000000000000000":"77da2021935b840b7f5dcc39132da9e5" + +AES-192-CBC Encrypt NIST KAT #6 +aes_encrypt_cbc:"3b375a1ff7e8d44409696e6326ec9dec86138e2ae010b980":"00000000000000000000000000000000":"00000000000000000000000000000000":"3b7c24f825e3bf9873c9f14d39a0e6f4" + +AES-192-CBC Encrypt NIST KAT #7 +aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"51719783d3185a535bd75adc65071ce1":"4f354592ff7c8847d2d0870ca9481b7c" + +AES-192-CBC Encrypt NIST KAT #8 +aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"26aa49dcfe7629a8901a69a9914e6dfd":"d5e08bf9a182e857cf40b3a36ee248cc" + +AES-192-CBC Encrypt NIST KAT #9 +aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"941a4773058224e1ef66d10e0a6ee782":"067cd9d3749207791841562507fa9626" + +AES-192-CBC Encrypt NIST KAT #10 +aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffc00000000000000000000000000000":"030d7e5b64f380a7e4ea5387b5cd7f49" + +AES-192-CBC Encrypt NIST KAT #11 +aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffe00000000000000000000000000000":"0dc9a2610037009b698f11bb7e86c83e" + +AES-192-CBC Encrypt NIST KAT #12 +aes_encrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"fff00000000000000000000000000000":"0046612c766d1840c226364f1fa7ed72" + +AES-192-CBC Decrypt NIST KAT #1 +aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"902d88d13eae52089abd6143cfe394e9":"ffffffffe00000000000000000000000" + +AES-192-CBC Decrypt NIST KAT #2 +aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"d49bceb3b823fedd602c305345734bd2":"fffffffff00000000000000000000000" + +AES-192-CBC Decrypt NIST KAT #3 +aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"707b1dbb0ffa40ef7d95def421233fae":"fffffffff80000000000000000000000" + +AES-192-CBC Decrypt NIST KAT #4 +aes_decrypt_cbc:"fffffffffffffffffffc0000000000000000000000000000":"00000000000000000000000000000000":"8dfd999be5d0cfa35732c0ddc88ff5a5":"00000000000000000000000000000000" + +AES-192-CBC Decrypt NIST KAT #5 +aes_decrypt_cbc:"fffffffffffffffffffe0000000000000000000000000000":"00000000000000000000000000000000":"02647c76a300c3173b841487eb2bae9f":"00000000000000000000000000000000" + +AES-192-CBC Decrypt NIST KAT #6 +aes_decrypt_cbc:"ffffffffffffffffffff0000000000000000000000000000":"00000000000000000000000000000000":"172df8b02f04b53adab028b4e01acd87":"00000000000000000000000000000000" + +AES-192-CBC Decrypt NIST KAT #7 +aes_decrypt_cbc:"b3ad5cea1dddc214ca969ac35f37dae1a9a9d1528f89bb35":"00000000000000000000000000000000":"3cf5e1d21a17956d1dffad6a7c41c659":"00000000000000000000000000000000" + +AES-192-CBC Decrypt NIST KAT #8 +aes_decrypt_cbc:"45899367c3132849763073c435a9288a766c8b9ec2308516":"00000000000000000000000000000000":"69fd12e8505f8ded2fdcb197a121b362":"00000000000000000000000000000000" + +AES-192-CBC Decrypt NIST KAT #9 +aes_decrypt_cbc:"ec250e04c3903f602647b85a401a1ae7ca2f02f67fa4253e":"00000000000000000000000000000000":"8aa584e2cc4d17417a97cb9a28ba29c8":"00000000000000000000000000000000" + +AES-192-CBC Decrypt NIST KAT #10 +aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"c9b8135ff1b5adc413dfd053b21bd96d":"9c2d8842e5f48f57648205d39a239af1" + +AES-192-CBC Decrypt NIST KAT #11 +aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"4a3650c3371ce2eb35e389a171427440":"bff52510095f518ecca60af4205444bb" + +AES-192-CBC Decrypt NIST KAT #12 +aes_decrypt_cbc:"000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"4f354592ff7c8847d2d0870ca9481b7c":"51719783d3185a535bd75adc65071ce1" + +AES-256-CBC Encrypt NIST KAT #1 +aes_encrypt_cbc:"8000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"e35a6dcb19b201a01ebcfa8aa22b5759" + +AES-256-CBC Encrypt NIST KAT #2 +aes_encrypt_cbc:"c000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"b29169cdcf2d83e838125a12ee6aa400" + +AES-256-CBC Encrypt NIST KAT #3 +aes_encrypt_cbc:"e000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"d8f3a72fc3cdf74dfaf6c3e6b97b2fa6" + +AES-256-CBC Encrypt NIST KAT #4 +aes_encrypt_cbc:"dc0eba1f2232a7879ded34ed8428eeb8769b056bbaf8ad77cb65c3541430b4cf":"00000000000000000000000000000000":"00000000000000000000000000000000":"fc6aec906323480005c58e7e1ab004ad" + +AES-256-CBC Encrypt NIST KAT #5 +aes_encrypt_cbc:"f8be9ba615c5a952cabbca24f68f8593039624d524c816acda2c9183bd917cb9":"00000000000000000000000000000000":"00000000000000000000000000000000":"a3944b95ca0b52043584ef02151926a8" + +AES-256-CBC Encrypt NIST KAT #6 +aes_encrypt_cbc:"797f8b3d176dac5b7e34a2d539c4ef367a16f8635f6264737591c5c07bf57a3e":"00000000000000000000000000000000":"00000000000000000000000000000000":"a74289fe73a4c123ca189ea1e1b49ad5" + +AES-256-CBC Encrypt NIST KAT #7 +aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"761c1fe41a18acf20d241650611d90f1":"623a52fcea5d443e48d9181ab32c7421" + +AES-256-CBC Encrypt NIST KAT #8 +aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"8a560769d605868ad80d819bdba03771":"38f2c7ae10612415d27ca190d27da8b4" + +AES-256-CBC Encrypt NIST KAT #9 +aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"91fbef2d15a97816060bee1feaa49afe":"1bc704f1bce135ceb810341b216d7abe" + +AES-256-CBC Encrypt NIST KAT #10 +aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffff800000000000000000":"0d9ac756eb297695eed4d382eb126d26" + +AES-256-CBC Encrypt NIST KAT #11 +aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffffc00000000000000000":"56ede9dda3f6f141bff1757fa689c3e1" + +AES-256-CBC Encrypt NIST KAT #12 +aes_encrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"ffffffffffffffe00000000000000000":"768f520efe0f23e61d3ec8ad9ce91774" + +AES-256-CBC Decrypt NIST KAT #1 +aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"49af6b372135acef10132e548f217b17":"ff000000000000000000000000000000" + +AES-256-CBC Decrypt NIST KAT #2 +aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"8bcd40f94ebb63b9f7909676e667f1e7":"ff800000000000000000000000000000" + +AES-256-CBC Decrypt NIST KAT #3 +aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"fe1cffb83f45dcfb38b29be438dbd3ab":"ffc00000000000000000000000000000" + +AES-256-CBC Decrypt NIST KAT #4 +aes_decrypt_cbc:"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc00":"00000000000000000000000000000000":"cca7c3086f5f9511b31233da7cab9160":"00000000000000000000000000000000" + +AES-256-CBC Decrypt NIST KAT #5 +aes_decrypt_cbc:"fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe00":"00000000000000000000000000000000":"5b40ff4ec9be536ba23035fa4f06064c":"00000000000000000000000000000000" + +AES-256-CBC Decrypt NIST KAT #6 +aes_decrypt_cbc:"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00":"00000000000000000000000000000000":"60eb5af8416b257149372194e8b88749":"00000000000000000000000000000000" + +AES-256-CBC Decrypt NIST KAT #7 +aes_decrypt_cbc:"90143ae20cd78c5d8ebdd6cb9dc1762427a96c78c639bccc41a61424564eafe1":"00000000000000000000000000000000":"798c7c005dee432b2c8ea5dfa381ecc3":"00000000000000000000000000000000" + +AES-256-CBC Decrypt NIST KAT #8 +aes_decrypt_cbc:"b7a5794d52737475d53d5a377200849be0260a67a2b22ced8bbef12882270d07":"00000000000000000000000000000000":"637c31dc2591a07636f646b72daabbe7":"00000000000000000000000000000000" + +AES-256-CBC Decrypt NIST KAT #9 +aes_decrypt_cbc:"fca02f3d5011cfc5c1e23165d413a049d4526a991827424d896fe3435e0bf68e":"00000000000000000000000000000000":"179a49c712154bbffbe6e7a84a18e220":"00000000000000000000000000000000" + +AES-256-CBC Decrypt NIST KAT #10 +aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"5c9d844ed46f9885085e5d6a4f94c7d7":"014730f80ac625fe84f026c60bfd547d" + +AES-256-CBC Decrypt NIST KAT #11 +aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"a9ff75bd7cf6613d3731c77c3b6d0c04":"0b24af36193ce4665f2825d7b4749c98" + +AES-256-CBC Decrypt NIST KAT #12 +aes_decrypt_cbc:"0000000000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"623a52fcea5d443e48d9181ab32c7421":"761c1fe41a18acf20d241650611d90f1" + +AES-128-CFB128 Encrypt NIST KAT #1 +aes_encrypt_cfb128:"f0000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"970014d634e2b7650777e8e84d03ccd8" + +AES-128-CFB128 Encrypt NIST KAT #2 +aes_encrypt_cfb128:"f8000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"f17e79aed0db7e279e955b5f493875a7" + +AES-128-CFB128 Encrypt NIST KAT #3 +aes_encrypt_cfb128:"fc000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"9ed5a75136a940d0963da379db4af26a" + +AES-128-CFB128 Encrypt NIST KAT #4 +aes_encrypt_cfb128:"64cf9c7abc50b888af65f49d521944b2":"00000000000000000000000000000000":"00000000000000000000000000000000":"f7efc89d5dba578104016ce5ad659c05" + +AES-128-CFB128 Encrypt NIST KAT #5 +aes_encrypt_cfb128:"47d6742eefcc0465dc96355e851b64d9":"00000000000000000000000000000000":"00000000000000000000000000000000":"0306194f666d183624aa230a8b264ae7" + +AES-128-CFB128 Encrypt NIST KAT #6 +aes_encrypt_cfb128:"3eb39790678c56bee34bbcdeccf6cdb5":"00000000000000000000000000000000":"00000000000000000000000000000000":"858075d536d79ccee571f7d7204b1f67" + +AES-128-CFB128 Encrypt NIST KAT #7 +aes_encrypt_cfb128:"00000000000000000000000000000000":"6a118a874519e64e9963798a503f1d35":"00000000000000000000000000000000":"dc43be40be0e53712f7e2bf5ca707209" + +AES-128-CFB128 Encrypt NIST KAT #8 +aes_encrypt_cfb128:"00000000000000000000000000000000":"cb9fceec81286ca3e989bd979b0cb284":"00000000000000000000000000000000":"92beedab1895a94faa69b632e5cc47ce" + +AES-128-CFB128 Encrypt NIST KAT #9 +aes_encrypt_cfb128:"00000000000000000000000000000000":"b26aeb1874e47ca8358ff22378f09144":"00000000000000000000000000000000":"459264f4798f6a78bacb89c15ed3d601" + +AES-128-CFB128 Encrypt NIST KAT #10 +aes_encrypt_cfb128:"00000000000000000000000000000000":"fffffffffffffffffffffffffffffff0":"00000000000000000000000000000000":"f9b0fda0c4a898f5b9e6f661c4ce4d07" + +AES-128-CFB128 Encrypt NIST KAT #11 +aes_encrypt_cfb128:"00000000000000000000000000000000":"fffffffffffffffffffffffffffffff8":"00000000000000000000000000000000":"8ade895913685c67c5269f8aae42983e" + +AES-128-CFB128 Encrypt NIST KAT #12 +aes_encrypt_cfb128:"00000000000000000000000000000000":"fffffffffffffffffffffffffffffffc":"00000000000000000000000000000000":"39bde67d5c8ed8a8b1c37eb8fa9f5ac0" + +AES-128-CFB128 Decrypt NIST KAT #1 +aes_decrypt_cfb128:"fffffffe000000000000000000000000":"00000000000000000000000000000000":"1114bc2028009b923f0b01915ce5e7c4":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #2 +aes_decrypt_cfb128:"ffffffff000000000000000000000000":"00000000000000000000000000000000":"9c28524a16a1e1c1452971caa8d13476":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #3 +aes_decrypt_cfb128:"ffffffff800000000000000000000000":"00000000000000000000000000000000":"ed62e16363638360fdd6ad62112794f0":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #4 +aes_decrypt_cfb128:"3071a2a48fe6cbd04f1a129098e308f8":"00000000000000000000000000000000":"4b98e06d356deb07ebb824e5713f7be3":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #5 +aes_decrypt_cfb128:"90f42ec0f68385f2ffc5dfc03a654dce":"00000000000000000000000000000000":"7a20a53d460fc9ce0423a7a0764c6cf2":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #6 +aes_decrypt_cfb128:"febd9a24d8b65c1c787d50a4ed3619a9":"00000000000000000000000000000000":"f4a70d8af877f9b02b4c40df57d45b17":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #7 +aes_decrypt_cfb128:"00000000000000000000000000000000":"f34481ec3cc627bacd5dc3fb08f273e6":"0336763e966d92595a567cc9ce537f5e":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #8 +aes_decrypt_cfb128:"00000000000000000000000000000000":"9798c4640bad75c7c3227db910174e72":"a9a1631bf4996954ebc093957b234589":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #9 +aes_decrypt_cfb128:"00000000000000000000000000000000":"96ab5c2ff612d9dfaae8c31f30c42168":"ff4f8391a6a40ca5b25d23bedd44a597":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #10 +aes_decrypt_cfb128:"00000000000000000000000000000000":"ffffffffffffffff0000000000000000":"f807c3e7985fe0f5a50e2cdb25c5109e":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #11 +aes_decrypt_cfb128:"00000000000000000000000000000000":"ffffffffffffffff8000000000000000":"41f992a856fb278b389a62f5d274d7e9":"00000000000000000000000000000000" + +AES-128-CFB128 Decrypt NIST KAT #12 +aes_decrypt_cfb128:"00000000000000000000000000000000":"ffffffffffffffffc000000000000000":"10d3ed7a6fe15ab4d91acbc7d0767ab1":"00000000000000000000000000000000" + +AES-192-CFB128 Encrypt NIST KAT #1 +aes_encrypt_cfb128:"fffffffffffffffffffc0000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"8dfd999be5d0cfa35732c0ddc88ff5a5" + +AES-192-CFB128 Encrypt NIST KAT #2 +aes_encrypt_cfb128:"fffffffffffffffffffe0000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"02647c76a300c3173b841487eb2bae9f" + +AES-192-CFB128 Encrypt NIST KAT #3 +aes_encrypt_cfb128:"ffffffffffffffffffff0000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"172df8b02f04b53adab028b4e01acd87" + +AES-192-CFB128 Encrypt NIST KAT #4 +aes_encrypt_cfb128:"d184c36cf0dddfec39e654195006022237871a47c33d3198":"00000000000000000000000000000000":"00000000000000000000000000000000":"2e19fb60a3e1de0166f483c97824a978" + +AES-192-CFB128 Encrypt NIST KAT #5 +aes_encrypt_cfb128:"4c6994ffa9dcdc805b60c2c0095334c42d95a8fc0ca5b080":"00000000000000000000000000000000":"00000000000000000000000000000000":"7656709538dd5fec41e0ce6a0f8e207d" + +AES-192-CFB128 Encrypt NIST KAT #6 +aes_encrypt_cfb128:"c88f5b00a4ef9a6840e2acaf33f00a3bdc4e25895303fa72":"00000000000000000000000000000000":"00000000000000000000000000000000":"a67cf333b314d411d3c0ae6e1cfcd8f5" + +AES-192-CFB128 Encrypt NIST KAT #7 +aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"9c2d8842e5f48f57648205d39a239af1":"00000000000000000000000000000000":"c9b8135ff1b5adc413dfd053b21bd96d" + +AES-192-CFB128 Encrypt NIST KAT #8 +aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"bff52510095f518ecca60af4205444bb":"00000000000000000000000000000000":"4a3650c3371ce2eb35e389a171427440" + +AES-192-CFB128 Encrypt NIST KAT #9 +aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"51719783d3185a535bd75adc65071ce1":"00000000000000000000000000000000":"4f354592ff7c8847d2d0870ca9481b7c" + +AES-192-CFB128 Encrypt NIST KAT #10 +aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"ffffffffffffffe00000000000000000":"00000000000000000000000000000000":"f34e4a6324ea4a5c39a661c8fe5ada8f" + +AES-192-CFB128 Encrypt NIST KAT #11 +aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"fffffffffffffff00000000000000000":"00000000000000000000000000000000":"0882a16f44088d42447a29ac090ec17e" + +AES-192-CFB128 Encrypt NIST KAT #12 +aes_encrypt_cfb128:"000000000000000000000000000000000000000000000000":"fffffffffffffff80000000000000000":"00000000000000000000000000000000":"3a3c15bfc11a9537c130687004e136ee" + +AES-192-CFB128 Decrypt NIST KAT #1 +aes_decrypt_cfb128:"ffffffffffffffffffffffffffffffffffffffffffe00000":"00000000000000000000000000000000":"60136703374f64e860b48ce31f930716":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #2 +aes_decrypt_cfb128:"fffffffffffffffffffffffffffffffffffffffffff00000":"00000000000000000000000000000000":"8d63a269b14d506ccc401ab8a9f1b591":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #3 +aes_decrypt_cfb128:"fffffffffffffffffffffffffffffffffffffffffff80000":"00000000000000000000000000000000":"d317f81dc6aa454aee4bd4a5a5cff4bd":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #4 +aes_decrypt_cfb128:"98c6b8e01e379fbd14e61af6af891596583565f2a27d59e9":"00000000000000000000000000000000":"19c80ec4a6deb7e5ed1033dda933498f":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #5 +aes_decrypt_cfb128:"b3ad5cea1dddc214ca969ac35f37dae1a9a9d1528f89bb35":"00000000000000000000000000000000":"3cf5e1d21a17956d1dffad6a7c41c659":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #6 +aes_decrypt_cfb128:"45899367c3132849763073c435a9288a766c8b9ec2308516":"00000000000000000000000000000000":"69fd12e8505f8ded2fdcb197a121b362":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #7 +aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"1b077a6af4b7f98229de786d7516b639":"275cfc0413d8ccb70513c3859b1d0f72":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #8 +aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"9c2d8842e5f48f57648205d39a239af1":"c9b8135ff1b5adc413dfd053b21bd96d":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #9 +aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"bff52510095f518ecca60af4205444bb":"4a3650c3371ce2eb35e389a171427440":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #10 +aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"ffffffffffffffffffff000000000000":"54d632d03aba0bd0f91877ebdd4d09cb":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #11 +aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"ffffffffffffffffffff800000000000":"d3427be7e4d27cd54f5fe37b03cf0897":"00000000000000000000000000000000" + +AES-192-CFB128 Decrypt NIST KAT #12 +aes_decrypt_cfb128:"000000000000000000000000000000000000000000000000":"ffffffffffffffffffffc00000000000":"b2099795e88cc158fd75ea133d7e7fbe":"00000000000000000000000000000000" + +AES-256-CFB128 Encrypt NIST KAT #1 +aes_encrypt_cfb128:"ffffffe000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"bbd1097a62433f79449fa97d4ee80dbf" + +AES-256-CFB128 Encrypt NIST KAT #2 +aes_encrypt_cfb128:"fffffff000000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"07058e408f5b99b0e0f061a1761b5b3b" + +AES-256-CFB128 Encrypt NIST KAT #3 +aes_encrypt_cfb128:"fffffff800000000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"00000000000000000000000000000000":"5fd1f13fa0f31e37fabde328f894eac2" + +AES-256-CFB128 Encrypt NIST KAT #4 +aes_encrypt_cfb128:"13428b5e4c005e0636dd338405d173ab135dec2a25c22c5df0722d69dcc43887":"00000000000000000000000000000000":"00000000000000000000000000000000":"649a71545378c783e368c9ade7114f6c" + +AES-256-CFB128 Encrypt NIST KAT #5 +aes_encrypt_cfb128:"07eb03a08d291d1b07408bf3512ab40c91097ac77461aad4bb859647f74f00ee":"00000000000000000000000000000000":"00000000000000000000000000000000":"47cb030da2ab051dfc6c4bf6910d12bb" + +AES-256-CFB128 Encrypt NIST KAT #6 +aes_encrypt_cfb128:"90143ae20cd78c5d8ebdd6cb9dc1762427a96c78c639bccc41a61424564eafe1":"00000000000000000000000000000000":"00000000000000000000000000000000":"798c7c005dee432b2c8ea5dfa381ecc3" + +AES-256-CFB128 Encrypt NIST KAT #7 +aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"0b24af36193ce4665f2825d7b4749c98":"00000000000000000000000000000000":"a9ff75bd7cf6613d3731c77c3b6d0c04" + +AES-256-CFB128 Encrypt NIST KAT #8 +aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"761c1fe41a18acf20d241650611d90f1":"00000000000000000000000000000000":"623a52fcea5d443e48d9181ab32c7421" + +AES-256-CFB128 Encrypt NIST KAT #9 +aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"8a560769d605868ad80d819bdba03771":"00000000000000000000000000000000":"38f2c7ae10612415d27ca190d27da8b4" + +AES-256-CFB128 Encrypt NIST KAT #10 +aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"ffffffffffffffffffffffffe0000000":"00000000000000000000000000000000":"2be1fae5048a25582a679ca10905eb80" + +AES-256-CFB128 Encrypt NIST KAT #11 +aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"fffffffffffffffffffffffff0000000":"00000000000000000000000000000000":"da86f292c6f41ea34fb2068df75ecc29" + +AES-256-CFB128 Encrypt NIST KAT #12 +aes_encrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"fffffffffffffffffffffffff8000000":"00000000000000000000000000000000":"220df19f85d69b1b562fa69a3c5beca5" + +AES-256-CFB128 Decrypt NIST KAT #1 +aes_decrypt_cfb128:"ffffffffff800000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"be66cfea2fecd6bf0ec7b4352c99bcaa":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #2 +aes_decrypt_cfb128:"ffffffffffc00000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"df31144f87a2ef523facdcf21a427804":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #3 +aes_decrypt_cfb128:"ffffffffffe00000000000000000000000000000000000000000000000000000":"00000000000000000000000000000000":"b5bb0f5629fb6aae5e1839a3c3625d63":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #4 +aes_decrypt_cfb128:"1d85a181b54cde51f0e098095b2962fdc93b51fe9b88602b3f54130bf76a5bd9":"00000000000000000000000000000000":"531c2c38344578b84d50b3c917bbb6e1":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #5 +aes_decrypt_cfb128:"dc0eba1f2232a7879ded34ed8428eeb8769b056bbaf8ad77cb65c3541430b4cf":"00000000000000000000000000000000":"fc6aec906323480005c58e7e1ab004ad":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #6 +aes_decrypt_cfb128:"f8be9ba615c5a952cabbca24f68f8593039624d524c816acda2c9183bd917cb9":"00000000000000000000000000000000":"a3944b95ca0b52043584ef02151926a8":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #7 +aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"761c1fe41a18acf20d241650611d90f1":"623a52fcea5d443e48d9181ab32c7421":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #8 +aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"8a560769d605868ad80d819bdba03771":"38f2c7ae10612415d27ca190d27da8b4":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #9 +aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"91fbef2d15a97816060bee1feaa49afe":"1bc704f1bce135ceb810341b216d7abe":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #10 +aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"e0000000000000000000000000000000":"9b80eefb7ebe2d2b16247aa0efc72f5d":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #11 +aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"f0000000000000000000000000000000":"7f2c5ece07a98d8bee13c51177395ff7":"00000000000000000000000000000000" + +AES-256-CFB128 Decrypt NIST KAT #12 +aes_decrypt_cfb128:"0000000000000000000000000000000000000000000000000000000000000000":"f8000000000000000000000000000000":"7818d800dcf6f4be1e0e94f403d1e4c2":"00000000000000000000000000000000" diff --git a/tests/suites/test_suite_aes.function b/tests/suites/test_suite_aes.function new file mode 100644 index 0000000..861ad2a --- /dev/null +++ b/tests/suites/test_suite_aes.function @@ -0,0 +1,168 @@ +BEGIN_HEADER +#include +END_HEADER + +BEGIN_CASE +aes_encrypt_ecb:hex_key_string:hex_src_string:hex_dst_string +{ + unsigned char key_str[100]; + unsigned char src_str[100]; + unsigned char dst_str[100]; + unsigned char output[100]; + aes_context ctx; + + memset(key_str, 0x00, 100); + memset(src_str, 0x00, 100); + memset(dst_str, 0x00, 100); + memset(output, 0x00, 100); + + int key_len = unhexify( key_str, {hex_key_string} ); + unhexify( src_str, {hex_src_string} ); + + aes_setkey_enc( &ctx, key_str, key_len * 8 ); + aes_crypt_ecb( &ctx, AES_ENCRYPT, src_str, output ); + hexify( dst_str, output, 16 ); + + TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +aes_decrypt_ecb:hex_key_string:hex_src_string:hex_dst_string +{ + unsigned char key_str[100]; + unsigned char src_str[100]; + unsigned char dst_str[100]; + unsigned char output[100]; + aes_context ctx; + + memset(key_str, 0x00, 100); + memset(src_str, 0x00, 100); + memset(dst_str, 0x00, 100); + memset(output, 0x00, 100); + + int key_len = unhexify( key_str, {hex_key_string} ); + unhexify( src_str, {hex_src_string} ); + + aes_setkey_dec( &ctx, key_str, key_len * 8 ); + aes_crypt_ecb( &ctx, AES_DECRYPT, src_str, output ); + hexify( dst_str, output, 16 ); + + TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +aes_encrypt_cbc:hex_key_string:hex_iv_string:hex_src_string:hex_dst_string +{ + unsigned char key_str[100]; + unsigned char iv_str[100]; + unsigned char src_str[100]; + unsigned char dst_str[100]; + unsigned char output[100]; + aes_context ctx; + + memset(key_str, 0x00, 100); + memset(iv_str, 0x00, 100); + memset(src_str, 0x00, 100); + memset(dst_str, 0x00, 100); + memset(output, 0x00, 100); + + int key_len = unhexify( key_str, {hex_key_string} ); + unhexify( iv_str, {hex_iv_string} ); + unhexify( src_str, {hex_src_string} ); + + aes_setkey_enc( &ctx, key_str, key_len * 8 ); + aes_crypt_cbc( &ctx, AES_ENCRYPT, 16, iv_str, src_str, output ); + hexify( dst_str, output, 16 ); + + TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +aes_decrypt_cbc:hex_key_string:hex_iv_string:hex_src_string:hex_dst_string +{ + unsigned char key_str[100]; + unsigned char iv_str[100]; + unsigned char src_str[100]; + unsigned char dst_str[100]; + unsigned char output[100]; + aes_context ctx; + + memset(key_str, 0x00, 100); + memset(iv_str, 0x00, 100); + memset(src_str, 0x00, 100); + memset(dst_str, 0x00, 100); + memset(output, 0x00, 100); + + int key_len = unhexify( key_str, {hex_key_string} ); + unhexify( iv_str, {hex_iv_string} ); + unhexify( src_str, {hex_src_string} ); + + aes_setkey_dec( &ctx, key_str, key_len * 8 ); + aes_crypt_cbc( &ctx, AES_DECRYPT, 16, iv_str, src_str, output ); + hexify( dst_str, output, 16 ); + + TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +aes_encrypt_cfb128:hex_key_string:hex_iv_string:hex_src_string:hex_dst_string +{ + unsigned char key_str[100]; + unsigned char iv_str[100]; + unsigned char src_str[100]; + unsigned char dst_str[100]; + unsigned char output[100]; + aes_context ctx; + int iv_offset = 0; + + memset(key_str, 0x00, 100); + memset(iv_str, 0x00, 100); + memset(src_str, 0x00, 100); + memset(dst_str, 0x00, 100); + memset(output, 0x00, 100); + + int key_len = unhexify( key_str, {hex_key_string} ); + unhexify( iv_str, {hex_iv_string} ); + unhexify( src_str, {hex_src_string} ); + + aes_setkey_enc( &ctx, key_str, key_len * 8 ); + aes_crypt_cfb128( &ctx, AES_ENCRYPT, 16, &iv_offset, iv_str, src_str, output ); + hexify( dst_str, output, 16 ); + + TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +aes_decrypt_cfb128:hex_key_string:hex_iv_string:hex_src_string:hex_dst_string +{ + unsigned char key_str[100]; + unsigned char iv_str[100]; + unsigned char src_str[100]; + unsigned char dst_str[100]; + unsigned char output[100]; + aes_context ctx; + int iv_offset = 0; + + memset(key_str, 0x00, 100); + memset(iv_str, 0x00, 100); + memset(src_str, 0x00, 100); + memset(dst_str, 0x00, 100); + memset(output, 0x00, 100); + + int key_len = unhexify( key_str, {hex_key_string} ); + unhexify( iv_str, {hex_iv_string} ); + unhexify( src_str, {hex_src_string} ); + + aes_setkey_enc( &ctx, key_str, key_len * 8 ); + aes_crypt_cfb128( &ctx, AES_DECRYPT, 16, &iv_offset, iv_str, src_str, output ); + hexify( dst_str, output, 16 ); + + TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 ); +} +END_CASE + diff --git a/tests/suites/test_suite_arc4.data b/tests/suites/test_suite_arc4.data new file mode 100644 index 0000000..535bdd9 --- /dev/null +++ b/tests/suites/test_suite_arc4.data @@ -0,0 +1,8 @@ +Test vector ARC4 [Cryptlib] +arc4_crypt:"0000000000000000":"0123456789abcdef":"7494c2e7104b0879" + +Test vector ARC4 [COMMERCE] +arc4_crypt:"dcee4cf92c":"618a63d2fb":"f13829c9de" + +Test vector ARC4 [SSH ARCFOUR] +arc4_crypt:"527569736c696e6e756e206c61756c75206b6f727669737373616e692c2074e4686be470e46964656e2070e4e46c6ce42074e47973696b75752e204b6573e479f66e206f6e206f6e6e69206f6d616e616e692c206b61736b6973617675756e206c61616b736f7420766572686f75752e20456e206d6120696c6f697473652c20737572652068756f6b61612c206d75747461206d657473e46e2074756d6d757573206d756c6c652074756f6b61612e205075756e746f2070696c76656e2c206d692068756b6b75752c207369696e746f20766172616e207475756c6973656e2c206d69206e756b6b75752e2054756f6b7375742076616e616d6f6e206a61207661726a6f74207665656e2c206e69697374e420737964e46d656e69206c61756c756e207465656e2e202d2045696e6f204c65696e6f":"29041972fb42ba5fc7127712f13829c9":"358186999001e6b5daf05eceeb7eee21e0689c1f00eea81f7dd2caaee1d2763e68af0ead33d66c268bc946c484fbe94c5f5e0b86a59279e4f824e7a640bd223210b0a61160b7bce986ea65688003596b630a6b90f8e0caf6912a98eb872176e83c202caa64166d2cce57ff1bca57b213f0ed1aa72fb8ea52b0be01cd1e412867720b326eb389d011bd70d8af035fb0d8589dbce3c666f5ea8d4c7954c50c3f340b0467f81b425961c11843074df620f208404b394cf9d37ff54b5f1ad8f6ea7da3c561dfa7281f964463d2cc35a4d1b03490dec51b0711fbd6f55f79234d5b7c766622a66de92be996461d5e4dc878ef9bca030521e8351e4baed2fd04f9467368c4ad6ac186d08245b263a2666d1f6c5420f1599dfd9f438921c2f5a463938ce0982265eef70179bc553f339eb1a4c1af5f6a547f" diff --git a/tests/suites/test_suite_arc4.function b/tests/suites/test_suite_arc4.function new file mode 100644 index 0000000..343c0f6 --- /dev/null +++ b/tests/suites/test_suite_arc4.function @@ -0,0 +1,26 @@ +BEGIN_HEADER +#include +END_HEADER + +BEGIN_CASE +arc4_crypt:hex_src_string:hex_key_string:hex_dst_string +{ + unsigned char src_str[1000]; + unsigned char key_str[1000]; + unsigned char dst_str[2000]; + + memset(src_str, 0x00, 1000); + memset(key_str, 0x00, 1000); + memset(dst_str, 0x00, 2000); + + int src_len = unhexify( src_str, {hex_src_string} ); + int key_len = unhexify( key_str, {hex_key_string} ); + + arc4_context ctx; + arc4_setup(&ctx, key_str, key_len); + arc4_crypt(&ctx, src_str, src_len); + hexify( dst_str, src_str, src_len ); + + TEST_ASSERT( strcmp( (char *) dst_str, {hex_dst_string} ) == 0 ); +} +END_CASE diff --git a/tests/suites/test_suite_base64.data b/tests/suites/test_suite_base64.data new file mode 100644 index 0000000..4c31fa5 --- /dev/null +++ b/tests/suites/test_suite_base64.data @@ -0,0 +1,41 @@ +Test case base64_encode #1 +base64_encode:"":"" + +Test case base64_encode #2 +base64_encode:"f":"Zg==" + +Test case base64_encode #3 +base64_encode:"fo":"Zm8=" + +Test case base64_encode #4 +base64_encode:"foo":"Zm9v" + +Test case base64_encode #5 +base64_encode:"foob":"Zm9vYg==" + +Test case base64_encode #6 +base64_encode:"fooba":"Zm9vYmE=" + +Test case base64_encode #7 +base64_encode:"foobar":"Zm9vYmFy" + +Test case base64_decode #1 +base64_decode:"":"" + +Test case base64_decode #2 +base64_decode:"Zg==":"f" + +Test case base64_decode #3 +base64_decode:"Zm8=":"fo" + +Test case base64_decode #4 +base64_decode:"Zm9v":"foo" + +Test case base64_decode #5 +base64_decode:"Zm9vYg==":"foob" + +Test case base64_decode #6 +base64_decode:"Zm9vYmE=":"fooba" + +Test case base64_decode #7 +base64_decode:"Zm9vYmFy":"foobar" diff --git a/tests/suites/test_suite_base64.function b/tests/suites/test_suite_base64.function new file mode 100644 index 0000000..7482db4 --- /dev/null +++ b/tests/suites/test_suite_base64.function @@ -0,0 +1,36 @@ +BEGIN_HEADER +#include +END_HEADER + +BEGIN_CASE +base64_encode:src_string:dst_string +{ + unsigned char src_str[1000]; + unsigned char dst_str[1000]; + int len = 1000; + + memset(src_str, 0x00, 1000); + memset(dst_str, 0x00, 1000); + + strcpy( (char *) src_str, {src_string} ); + TEST_ASSERT( base64_encode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 ); + TEST_ASSERT( strcmp( (char *) dst_str, {dst_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +base64_decode:src_string:dst_string +{ + unsigned char src_str[1000]; + unsigned char dst_str[1000]; + int len = 1000; + int res; + + memset(src_str, 0x00, 1000); + memset(dst_str, 0x00, 1000); + + strcpy( (char *) src_str, {src_string} ); + TEST_ASSERT( res = base64_decode( dst_str, &len, src_str, strlen( (char *) src_str ) ) == 0 ); + TEST_ASSERT( strcmp( (char *) dst_str, {dst_string} ) == 0 ); +} +END_CASE diff --git a/tests/suites/test_suite_hmac_shax.data b/tests/suites/test_suite_hmac_shax.data new file mode 100644 index 0000000..670c3d4 --- /dev/null +++ b/tests/suites/test_suite_hmac_shax.data @@ -0,0 +1,107 @@ +HMAC-SHA-1 Test Vector FIPS-198a #1 +sha1_hmac:20:"000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f":"53616d706c65202331":"4f4ca3d5d68ba7cc0a1208c9c61e9c5da0403c0a" + +HMAC-SHA-1 Test Vector FIPS-198a #2 +sha1_hmac:20:"303132333435363738393a3b3c3d3e3f40414243":"53616d706c65202332":"0922d3405faa3d194f82a45830737d5cc6c75d24" + +HMAC-SHA-1 Test Vector FIPS-198a #3 +sha1_hmac:20:"505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3":"53616d706c65202333":"bcf41eab8bb2d802f3d05caf7cb092ecf8d1a3aa" + +HMAC-SHA-1 Test Vector FIPS-198a #4 +sha1_hmac:12:"707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0":"53616d706c65202334":"9ea886efe268dbecce420c75" + +HMAC-SHA-1 Test Vector NIST CAVS #1 +sha1_hmac:10:"7b10f4124b15c82e":"27dcb5b1daf60cfd3e2f73d4d64ca9c684f8bf71fc682a46793b1790afa4feb100ca7aaff26f58f0e1d0ed42f1cdad1f474afa2e79d53a0c42892c4d7b327cbe46b295ed8da3b6ecab3d4851687a6f812b79df2f6b20f11f6706f5301790ca99625aad7391d84f78043d2a0a239b1477984c157bbc9276064e7a1a406b0612ca":"4ead12c2fe3d6ea43acb" + +HMAC-SHA-1 Test Vector NIST CAVS #2 +sha1_hmac:10:"4fe9fb902172a21b":"4ceb3a7c13659c22fe51134f03dce4c239d181b63c6b0b59d367157fd05cab98384f92dfa482d2d5e78e72eef1b1838af4696026c54233d484ecbbe87f904df5546419f8567eafd232e6c2fcd3ee2b7682c63000524b078dbb2096f585007deae752562df1fe3b01278089e16f3be46e2d0f7cabac2d8e6cc02a2d0ca953425f":"564428a67be1924b5793" + +HMAC-SHA-1 Test Vector NIST CAVS #3 +sha1_hmac:10:"d1f01455f78c4fb4":"00d40f67b57914bec456a3e3201ef1464be319a8d188c02e157af4b54f9b5a66d67f898a9bdbb19ff63a80aba6f246d013575721d52eb1b47a65def884011c49b257bcc2817fc853f106e8138ce386d7a5ac3103de0a3fa0ed6bb7af9ff66ebd1cc46fb86e4da0013d20a3c2dcd8fb828a4b70f7f104b41bf3f44682a66497ea":"56a665a7cdfe610f9fc5" + +HMAC-SHA-1 Test Vector NIST CAVS #4 +sha1_hmac:10:"4e5ef77fdf033a5b":"e59326464e3201d195e29f2a3446ec1b1c9ff31154e2a4d0e40ed466f1bc855d29f76835624fa0127d29c9b1915939a046f385af7e5d47a23ba91f28bd22f811ea258dbbf3332bcd3543b8285d5df41bd064ffd64a341c22c4edb44f9c8d9e6df0c59dbf4a052a6c83da7478e179a6f3839c6870ff8ca8b9497f9ac1d725fdda":"981c0a7a8423b63a8fa6" + +HMAC-SHA-1 Test Vector NIST CAVS #5 +sha1_hmac:10:"bcd9ff8aa60be2be":"51be4d0eb37bab714f92e19e9d70390655b363e8cd346a748245e731f437759cb8206412c8dab2ef1d4f36f880f41ff69d949da4594fdecb65e23cac1329b59e69e29bf875b38c31df6fa546c595f35cc2192aa750679a8a51a65e00e839d73a8d8c598a610d237fbe78955213589d80efcb73b95b8586f96d17b6f51a71c3b8":"84633f9f5040c8971478" + +HMAC-SHA-1 Test Vector NIST CAVS #6 +sha1_hmac:10:"4a661bce6ed86d21":"5ff6c744f1aab1bc29697d71f67541b8b3cec3c7079183b10a83fb98a9ee251d4bac3e1cb581ca972aaed8efd7c2875a6fb4c991132f67c9742d45e53bc7e8eaa94b35b37a907be61086b426cd11088ac118934e85d968c9667fd69fc6f6ea38c0fe34710b7ece91211b9b7ea00acd31f022aa6726368f9928a1352f122233f1":"739df59353ac6694e55e" + +HMAC-SHA-1 Test Vector NIST CAVS #7 +sha1_hmac:10:"1287e1565a57b547":"390ffdccc6171c11568d85b8f913e019bf4cd982ca9cd21ea730d41bdf3fcc0bc88ff48ba13a8f23deb2d96ec1033e7b2a58ca72b0c1e17bf03330db25d1e360fa6918009c4294bd1215b5ccd159a8f58bc3dc3d490eb7c3b9f887e8c98dbbb274a75373dcb695a59abd0219529d88518a96f92abc0bbcbda985c388f1fbbcc9":"d78ddf08077c7d9e2ba6" + +HMAC-SHA-224 Test Vector NIST CAVS #1 +sha224_hmac:14:"e055eb756697ee573fd3214811a9f7fa":"3875847012ee42fe54a0027bdf38cca7021b83a2ed0503af69ef6c37c637bc1114fba40096c5947d736e19b7af3c68d95a4e3b8b073adbbb80f47e9db8f2d4f0018ddd847fabfdf9dd9b52c93e40458977725f6b7ba15f0816bb895cdf50401268f5d702b7e6a5f9faef57b8768c8a3fc14f9a4b3182b41d940e337d219b29ff":"40a453133361cc48da11baf616ee" + +HMAC-SHA-224 Test Vector NIST CAVS #2 +sha224_hmac:14:"88e5258b55b1623385eb9632fa7c57d6":"ada76bb604be14326551701cf30e48a65eee80b44f0b9d4a07b1844543b7844a621097fdc99de57387458ae9354899b620d0617eabcaefa9eef3d413a33628054335ce656c26fa2986e0f111a6351096b283101ec7868871d770b370973c7405983f9756b3005a3eab492cfd0e7eb42e5c2e15fa6be8718c0a50acc4e5717230":"81c783af538015cef3c60095df53" + +HMAC-SHA-224 Test Vector NIST CAVS #3 +sha224_hmac:14:"85d402d822114d31abf75526e2538705":"8020d8d98cc2e2298b32879c51c751e1dd5558fe2eabb8f158604297d6d072ce2261a1d6830b7cfe2617b57c7126f99c9476211d6161acd75d266da217ec8174b80484c9dc6f0448a0a036a3fc82e8bf54bdb71549368258d5d41f57978a4c266b92e8783ef66350215573d99be4089144b383ad8f3222bae8f3bf80ffb1bb2b":"2aa0340ac9deafe3be38129daca0" + +HMAC-SHA-224 Test Vector NIST CAVS #4 +sha224_hmac:14:"545c6eecc5ee46fa17c59f91a94f81ae":"8fb7f3565593170152ddb2021874784e951977cfdd22f8b72a72a61320a8f2a35697b5e913f717805559b1af1861ee3ed42fb788481e4fd276b17bdbefcae7b4501dc5d20de5b7626dd5efdcd65294db4bdf682c33d9a9255c6435383fa5f1c886326a3acbc6bd50a33ab5b2dbb034ce0112d4e226bbcd57e3731a519aa1d784":"3eb566eac54c4a3a9ef092469f24" + +HMAC-SHA-224 Test Vector NIST CAVS #5 +sha224_hmac:14:"4466ab4dc438841a9750c7f173dff02e":"2534c11c78c99cffaec8f722f04adc7045c7324d58ce98e37cfa94b6ed21ed7f58ce55379ef24b72d6d640ee9154f96c614734be9c408e225d7ba4cecc1179cc9f6e1808e1067aa8f244a99bd0c3267594c1887a40d167f8b7cf78db0d19f97b01fc50b8c86def490dfa7a5135002c33e71d77a8cce8ea0f93e0580439a33733":"59f44a9bbed4875b892d22d6b5ab" + +HMAC-SHA-224 Test Vector NIST CAVS #6 +sha224_hmac:28:"0e3dd9bb5e4cf0f09a4c11600af56d8d":"f4589fa76c328ea25cf8bae582026ba40a59d45a546ff31cf80eb826088f69bb954c452c74586836416dee90a5255bc5d56d3b405b3705a5197045688b32fa984c3a3dfbdc9c2460a0b5e6312a624048bb6f170306535e9b371a3ab134a2642a230ad03d2c688cca80baeaee9a20e1d4c548b1cede29c6a45bf4df2c8c476f1a":"12175b93e3da4c58217145e4dc0a1cf142fab9319bb501e037b350ba" + +HMAC-SHA-224 Test Vector NIST CAVS #7 +sha224_hmac:28:"cda5187b0c5dcb0f8e5a8beed2306584":"9011ae29b44c49b347487ce972965f16ade3c15be0856ce9c853a9739dba07e4f20d594ddc1dfe21560a65a4e458cfa17745575b915a30c7a9412ff8d1d689db9680dd2428c27588bb0dc92d2cd9445fe8f44b840a197c52c3c4333fff45533945134398df6436513cfab06c924046b8c795a5bd92e8d5f2de85bf306f2eed67":"4aaba92b40e2a600feab176eb9b292d814864195c03342aad6f67f08" + +HMAC-SHA-256 Test Vector NIST CAVS #1 +sha256_hmac:16:"cdffd34e6b16fdc0":"d83e78b99ab61709608972b36e76a575603db742269cc5dd4e7d5ca7816e26b65151c92632550cb4c5253c885d5fce53bc47459a1dbd5652786c4aac0145a532f12c05138af04cbb558101a7af5df478834c2146594dd73690d01a4fe72545894335f427ac70204798068cb86c5a600b40b414ede23590b41e1192373df84fe3":"c6f0dde266cb4a26d41e8259d33499cc" + +HMAC-SHA-256 Test Vector NIST CAVS #2 +sha256_hmac:16:"6d97bb5892245be2":"13c2b391d59c0252ca5d2302beaaf88c4bcd779bb505ad9a122003dfae4cc123ad2bd036f225c4f040021a6b9fb8bd6f0281cf2e2631a732bdc71693cc42ef6d52b6c6912a9ef77b3274eb85ad7f965ae6ed44ac1721962a884ec7acfb4534b1488b1c0c45afa4dae8da1eb7b0a88a3240365d7e4e7d826abbde9f9203fd99d7":"31588e241b015319a5ab8c4527296498" + +HMAC-SHA-256 Test Vector NIST CAVS #3 +sha256_hmac:16:"3c7fc8a70b49007a":"60024e428a39c8b8bb2e9591bad9dc2115dfbfd716b6eb7af30a6eb34560caccbbfa47b710fa8d523aca71e9e5ba10fc1feb1a43556d71f07ea4f33496f093044e8caf1d02b79e46eb1288d5964a7a7494f6b92574c35784eece054c6151281d80822f7d47b8231c35d07f5cb5cf4310ddc844845a01c6bfab514c048eccaf9f":"1c98c94a32bec9f253c21070f82f8438" + +HMAC-SHA-256 Test Vector NIST CAVS #4 +sha256_hmac:24:"369f33f85b927a07":"ae8e2a94ca386d448cbacdb0e9040ae3cb297c296363052cc157455da29a0c95897315fc11e3f12b81e2418da1ec280bccbc00e847584ce9d14deeba7b3c9b8dba958b04bba37551f6c9ba9c060be1a4b8cf43aa62e5078b76c6512c5619b71a6a7cf5727180e1ff14f5a1a3c1691bf8b6ebad365c151e58d749d57adb3a4986":"60b90383286533d309de46593e6ce39fc51fb00a8d88278c" + +HMAC-SHA-256 Test Vector NIST CAVS #5 +sha256_hmac:24:"e5179687582b4dc4":"ce103bdacdf32f614f6727bcb31ca1c2824a850d00f5585b016fb234fe1ef2cd687f302d3c6b738ed89a24060d65c36675d0d96307c72ef3e8a83bfa8402e226de9d5d1724ba75c4879bf41a4a465ce61887d9f49a34757849b48bae81c27ebed76faae2ad669bca04747d409148d40812776e0ae2c395b3cb9c89981ce72d5c":"509581f6816df4b8cc9f2cf42b7cc6e6a5a1e375a16f2412" + +HMAC-SHA-256 Test Vector NIST CAVS #6 +sha256_hmac:24:"63cec6246aeb1b61":"c178db908a405fa88aa255b8cad22b4057016585f139ee930388b083d86062fa0b3ea1f23f8a43bd11bee8464bcbd19b5ab9f6a8038d5245516f8274d20c8ee3033a07b908da528fa00343bb595deed500cab9745c4cb6391c23300f0d3584b090b3326c4cfa342620b78f9f5b4f27f7307ed770643ec1764aeae3dcf1a3ec69":"64f3dd861b7c7d29fce9ae0ce9ed954b5d7141806ee9eec7" + +HMAC-SHA-384 Test Vector NIST CAVS #1 +sha384_hmac:32:"91a7401817386948ca952f9a20ee55dc":"2fea5b91035d6d501f3a834fa178bff4e64b99a8450432dafd32e4466b0e1e7781166f8a73f7e036b3b0870920f559f47bd1400a1a906e85e0dcf00a6c26862e9148b23806680f285f1fe4f93cdaf924c181a965465739c14f2268c8be8b471847c74b222577a1310bcdc1a85ef1468aa1a3fd4031213c97324b7509c9050a3d":"6d7be9490058cf413cc09fd043c224c2ec4fa7859b13783000a9a593c9f75838" + +HMAC-SHA-384 Test Vector NIST CAVS #2 +sha384_hmac:32:"d6cac19657061aa90a6da11cd2e9ea47":"9f482e4655173135dfaa22a11bbbe6af263db48716406c5aec162ba3c4b41cad4f5a91558377521191c7343118beee65982929802913d67b6de5c4bdc3d27299bd722219d5ad2efa5bdb9ff7b229fc4bbc3f60719320cf2e7a51cad1133d21bad2d80919b1836ef825308b7c51c6b7677ac782e2bc30007afba065681cbdd215":"f3d5f3c008175321aa7b2ea379eaa4f8b9dcc60f895ec8940b8162f80a7dfe9f" + +HMAC-SHA-384 Test Vector NIST CAVS #3 +sha384_hmac:32:"e06366ad149b8442cd4c1abdddd0afde":"2d140a194c02a5598f69174834679b8371234a0d505491f1bd03e128dd91a8bca2fb812e9d5da71613b5b00952ea78bf450d5b7547dea79135925085c7d3e6f52009c51ca3d88c6c09e9d074b0ee110736e0ec9b478b93efb34d7bf1c41b54decec43eab077a3aa4998ede53f67b4ea36c266745f9643d5360bdc8337c70dabf":"c19c67eda6fe29f3667bee1c897c333ce7683094ae77e84b4c16378d290895a1" + +HMAC-SHA-384 Test Vector NIST CAVS #4 +sha384_hmac:48:"01ac59f42f8bb91d1bd10fe6990d7a87":"3caf18c476edd5615f343ac7b7d3a9da9efade755672d5ba4b8ae8a7505539ea2c124ff755ec0457fbe49e43480b3c71e7f4742ec3693aad115d039f90222b030fdc9440313691716d5302005808c07627483b916fdf61983063c2eb1268f2deeef42fc790334456bc6bad256e31fc9066de7cc7e43d1321b1866db45e905622":"1985fa2163a5943fc5d92f1fe8831215e7e91f0bff5332bc713a072bdb3a8f9e5c5157463a3bfeb36231416e65973e64" + +HMAC-SHA-384 Test Vector NIST CAVS #5 +sha384_hmac:48:"fd74b9d9e102a3a80df1baf0cb35bace":"1a068917584813d1689ccbd0370c2114d537cdc8cc52bf6db16d5535f8f7d1ad0c850a9fa0cf62373ffbf7642b1f1e8164010d350721d798d9f99e9724830399c2fce26377e83d38845675457865c03d4a07d741a505ef028343eb29fd46d0f761f3792886998c1e5c32ac3bc7e6f08faed194b34f06eff4d5d4a5b42c481e0e":"a981eaf5de3d78b20ebd4414a4edd0657e3667cd808a0dbc430cf7252f73a5b24efa136039207bd59806897457d74e0c" + +HMAC-SHA-384 Test Vector NIST CAVS #5 +sha384_hmac:48:"9fe794f0e26b669fa5f6883149377c6c":"6010c9745e8f1d44cfdc99e7e0fd79bc4271944c2d1d84dba589073dfc4ca5eb98c59356f60cd87bef28aeb83a832bde339b2087daf942aa1f67876c5d5ed33924bed4143bc12a2be532ccaf64daa7e2bc3c8872b9823b0533b6f5159135effe8c61545536975d7c3a61ba7365ec35f165bc92b4d19eb9156ade17dfa1bb4161":"915ae61f8754698c2b6ef9629e93441f8541bd4258a5e05372d19136cfaefc0473b48d96119291b38eb1a3cb1982a986" + +HMAC-SHA-512 Test Vector NIST CAVS #1 +sha512_hmac:32:"c95a17c09940a691ed2d621571b0eb844ede55a9":"99cd28262e81f34878cdcebf4128e05e2098a7009278a66f4c785784d0e5678f3f2b22f86e982d273b6273a222ec61750b4556d766f1550a7aedfe83faedbc4bdae83fa560d62df17eb914d05fdaa48940551bac81d700f5fca7147295e386e8120d66742ec65c6ee8d89a92217a0f6266d0ddc60bb20ef679ae8299c8502c2f":"6bc1379d156559ddee2ed420ea5d5c5ff3e454a1059b7ba72c350e77b6e9333c" + +HMAC-SHA-512 Test Vector NIST CAVS #2 +sha512_hmac:32:"3b10b8fa718840d1dea8e9fc317476bcf55875fd":"f04f5b7073d7d0274e8354433b390306c5607632f5f589c12edb62d55673aff2366d2e6b24de731adf92e654baa30b1cfd4a069788f65ec1b99b015d904d8832110dbd74eae35a81562d14ce4136d820ad0a55ff5489ba678fbbc1c27663ec1349d70e740f0e0ec27cfbe8971819f4789e486b50a2d7271d77e2aaea50de62fd":"fc3c38c7a17e3ce06db033f1c172866f01a00045db55f2e234f71c82264f2ba2" + +HMAC-SHA-512 Test Vector NIST CAVS #3 +sha512_hmac:32:"4803d311394600dc1e0d8fc8cedeb8bde3fe7c42":"a10c125dd702a97153ad923ba5e9889cfac1ba169de370debe51f233735aa6effcc9785c4b5c7e48c477dc5c411ae6a959118584e26adc94b42c2b29b046f3cf01c65b24a24bd2e620bdf650a23bb4a72655b1100d7ce9a4dab697c6379754b4396c825de4b9eb73f2e6a6c0d0353bbdeaf706612800e137b858fdb30f3311c6":"7cd8236c55102e6385f52279506df6fcc388ab75092da21395ce14a82b202ffa" + +HMAC-SHA-512 Test Vector NIST CAVS #4 +sha512_hmac:48:"aeb2f3b977fa6c8e71e07c5a5c74ff58166de092":"22457355dc76095abd46846b41cfe49a06ce42ac8857b4702fc771508dfb3626e0bfe851df897a07b36811ec433766e4b4166c26301b3493e7440d4554b0ef6ac20f1a530e58fac8aeba4e9ff2d4898d8a28783b49cd269c2965fd7f8e4f2d60cf1e5284f2495145b72382aad90e153a90ecae125ad75336fb128825c23fb8b0":"fa39bd8fcc3bfa218f9dea5d3b2ce10a7619e31678a56d8a9d927b1fe703b125af445debe9a89a07db6194d27b44d85a" + +HMAC-SHA-512 Test Vector NIST CAVS #5 +sha512_hmac:48:"4285d3d7744da52775bb44ca436a3154f7980309":"208f0b6f2de2e5aa5df11927ddc6df485edc1193181c484d0f0a434a95418803101d4de9fdb798f93516a6916fa38a8207de1666fe50fe3441c03b112eaaae6954ed063f7ac4e3c1e3f73b20d153fe9e4857f5e91430f0a70ee820529adac2467469fd18adf10e2af0fea27c0abc83c5a9af77c364a466cffce8bab4e2b70bc1":"fe7603f205b2774fe0f14ecfa3e338e90608a806d11ca459dff5ce36b1b264ecd3af5f0492a7521d8da3102ba20927a5" + +HMAC-SHA-512 Test Vector NIST CAVS #6 +sha512_hmac:48:"8ab783d5acf32efa0d9c0a21abce955e96630d89":"17371e013dce839963d54418e97be4bd9fa3cb2a368a5220f5aa1b8aaddfa3bdefc91afe7c717244fd2fb640f5cb9d9bf3e25f7f0c8bc758883b89dcdce6d749d9672fed222277ece3e84b3ec01b96f70c125fcb3cbee6d19b8ef0873f915f173bdb05d81629ba187cc8ac1934b2f75952fb7616ae6bd812946df694bd2763af":"9ac7ca8d1aefc166b046e4cf7602ebe181a0e5055474bff5b342106731da0d7e48e4d87bc0a6f05871574289a1b099f8" diff --git a/tests/suites/test_suite_hmac_shax.function b/tests/suites/test_suite_hmac_shax.function new file mode 100644 index 0000000..7b4a0dc --- /dev/null +++ b/tests/suites/test_suite_hmac_shax.function @@ -0,0 +1,120 @@ +BEGIN_HEADER +#include +#include +#include +END_HEADER + +BEGIN_CASE +sha1_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char key_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[41]; + + memset(src_str, 0x00, 10000); + memset(key_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 41); + + int key_len = unhexify( key_str, {hex_key_string} ); + int src_len = unhexify( src_str, {hex_src_string} ); + + sha1_hmac( key_str, key_len, src_str, src_len, output ); + hexify( hash_str, output, 20 ); + + TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 ); +} +END_CASE + +BEGIN_CASE +sha224_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char key_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[57]; + + memset(src_str, 0x00, 10000); + memset(key_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 57); + + int key_len = unhexify( key_str, {hex_key_string} ); + int src_len = unhexify( src_str, {hex_src_string} ); + + sha2_hmac( key_str, key_len, src_str, src_len, output, 1 ); + hexify( hash_str, output, 28 ); + + TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 ); +} +END_CASE + +BEGIN_CASE +sha256_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char key_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[65]; + + memset(src_str, 0x00, 10000); + memset(key_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 65); + + int key_len = unhexify( key_str, {hex_key_string} ); + int src_len = unhexify( src_str, {hex_src_string} ); + + sha2_hmac( key_str, key_len, src_str, src_len, output, 0 ); + hexify( hash_str, output, 32 ); + + TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 ); +} +END_CASE + +BEGIN_CASE +sha384_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char key_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[97]; + + memset(src_str, 0x00, 10000); + memset(key_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 97); + + int key_len = unhexify( key_str, {hex_key_string} ); + int src_len = unhexify( src_str, {hex_src_string} ); + + sha4_hmac( key_str, key_len, src_str, src_len, output, 1 ); + hexify( hash_str, output, 48 ); + + TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 ); +} +END_CASE + +BEGIN_CASE +sha512_hmac:trunc_size:hex_key_string:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char key_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[129]; + + memset(src_str, 0x00, 10000); + memset(key_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 129); + + int key_len = unhexify( key_str, {hex_key_string} ); + int src_len = unhexify( src_str, {hex_src_string} ); + + sha4_hmac( key_str, key_len, src_str, src_len, output, 0 ); + hexify( hash_str, output, 64 ); + + TEST_ASSERT( strncmp( (char *) hash_str, {hex_hash_string}, {trunc_size} * 2 ) == 0 ); +} +END_CASE diff --git a/tests/suites/test_suite_mdx.data b/tests/suites/test_suite_mdx.data new file mode 100644 index 0000000..e930c04 --- /dev/null +++ b/tests/suites/test_suite_mdx.data @@ -0,0 +1,62 @@ +md2 Test vector RFC1319 #1 +md2_text:"":"8350e5a3e24c153df2275c9f80692773" + +md2 Test vector RFC1319 #2 +md2_text:"a":"32ec01ec4a6dac72c0ab96fb34c0b5d1" + +md2 Test vector RFC1319 #3 +md2_text:"abc":"da853b0d3f88d99b30283a69e6ded6bb" + +md2 Test vector RFC1319 #4 +md2_text:"message digest":"ab4f496bfb2a530b219ff33031fe06b0" + +md2 Test vector RFC1319 #5 +md2_text:"abcdefghijklmnopqrstuvwxyz":"4e8ddff3650292ab5a4108c3aa47940b" + +md2 Test vector RFC1319 #6 +md2_text:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789":"da33def2a42df13975352846c30338cd" + +md2 Test vector RFC1319 #7 +md2_text:"12345678901234567890123456789012345678901234567890123456789012345678901234567890":"d5976f79d83d3a0dc9806c3c66f3efd8" + +md4 Test vector RFC1320 #1 +md4_text:"":"31d6cfe0d16ae931b73c59d7e0c089c0" + +md4 Test vector RFC1320 #2 +md4_text:"a":"bde52cb31de33e46245e05fbdbd6fb24" + +md4 Test vector RFC1320 #3 +md4_text:"abc":"a448017aaf21d8525fc10ae87aa6729d" + +md4 Test vector RFC1320 #4 +md4_text:"message digest":"d9130a8164549fe818874806e1c7014b" + +md4 Test vector RFC1320 #5 +md4_text:"abcdefghijklmnopqrstuvwxyz":"d79e1c308aa5bbcdeea8ed63df412da9" + +md4 Test vector RFC1320 #6 +md4_text:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789":"043f8582f241db351ce627e153e7f0e4" + +md4 Test vector RFC1320 #7 +md4_text:"12345678901234567890123456789012345678901234567890123456789012345678901234567890":"e33b4ddc9c38f2199c3e7b164fcc0536" + +md5 Test vector RFC1321 #1 +md5_text:"":"d41d8cd98f00b204e9800998ecf8427e" + +md5 Test vector RFC1321 #2 +md5_text:"a":"0cc175b9c0f1b6a831c399e269772661" + +md5 Test vector RFC1321 #3 +md5_text:"abc":"900150983cd24fb0d6963f7d28e17f72" + +md5 Test vector RFC1321 #4 +md5_text:"message digest":"f96b697d7cb7938d525a2f31aaf161d0" + +md5 Test vector RFC1321 #5 +md5_text:"abcdefghijklmnopqrstuvwxyz":"c3fcd3d76192e4007dfb496cca67e13b" + +md5 Test vector RFC1321 #6 +md5_text:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789":"d174ab98d277d9f5a5611c2c9f419d9f" + +md5 Test vector RFC1321 #7 +md5_text:"12345678901234567890123456789012345678901234567890123456789012345678901234567890":"57edf4a22be3c955ac49da2e2107b67a" diff --git a/tests/suites/test_suite_mdx.function b/tests/suites/test_suite_mdx.function new file mode 100644 index 0000000..62046d7 --- /dev/null +++ b/tests/suites/test_suite_mdx.function @@ -0,0 +1,65 @@ +BEGIN_HEADER +#include +#include +#include +END_HEADER + +BEGIN_CASE +md2_text:text_src_string:hex_hash_string +{ + unsigned char src_str[1000]; + unsigned char hash_str[1000]; + unsigned char output[33]; + + memset(src_str, 0x00, 1000); + memset(hash_str, 0x00, 1000); + memset(output, 0x00, 33); + + strcpy( (char *) src_str, {text_src_string} ); + + md2( src_str, strlen( (char *) src_str ), output ); + hexify( hash_str, output, 16 ); + + TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +md4_text:text_src_string:hex_hash_string +{ + unsigned char src_str[1000]; + unsigned char hash_str[1000]; + unsigned char output[33]; + + memset(src_str, 0x00, 1000); + memset(hash_str, 0x00, 1000); + memset(output, 0x00, 33); + + strcpy( (char *) src_str, {text_src_string} ); + + md4( src_str, strlen( (char *) src_str ), output ); + hexify( hash_str, output, 16 ); + + TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +md5_text:text_src_string:hex_hash_string +{ + unsigned char src_str[1000]; + unsigned char hash_str[1000]; + unsigned char output[33]; + + memset(src_str, 0x00, 1000); + memset(hash_str, 0x00, 1000); + memset(output, 0x00, 33); + + strcpy( (char *) src_str, {text_src_string} ); + + md5( src_str, strlen( (char *) src_str ), output ); + hexify( hash_str, output, 16 ); + + TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 ); +} +END_CASE diff --git a/tests/suites/test_suite_mpi.data b/tests/suites/test_suite_mpi.data new file mode 100644 index 0000000..ac25ceb --- /dev/null +++ b/tests/suites/test_suite_mpi.data @@ -0,0 +1,341 @@ +Base test mpi_read_write_string #1 +mpi_read_write_string:10:"128":10:"128" + +Base test mpi_read_write_string #2 +mpi_read_write_string:10:"128":16:"80" + +Base test mpi_read_write_string #3 (Read zero) +mpi_read_write_string:10:"0":10:"0" + +Base test mpi_read_write_string #3 (Negative decimal) +mpi_read_write_string:10:"-23":10:"-23" + +Base test mpi_read_write_string #3 (Negative hex) +mpi_read_write_string:16:"-20":10:"-32" + +Base test mpi_read_write_string #3 (Negative decimal) +mpi_read_write_string:16:"-23":16:"-23" + +Base test mpi_cmp_int #1 +mpi_cmp_int:693:693:0 + +Base test mpi_cmp_int #2 +mpi_cmp_int:693:692:1 + +Base test mpi_cmp_int #3 +mpi_cmp_int:693:694:-1 + +Base test mpi_cmp_int (Negative values) #1 +mpi_cmp_int:-2:-2:0 + +Base test mpi_cmp_int (Negative values) #2 +mpi_cmp_int:-2:-3:1 + +Base test mpi_cmp_int (Negative values) #3 +mpi_cmp_int:-2:-1:-1 + +Base test mpi_cmp_mpi #1 +mpi_cmp_mpi:10:"693":10:"693":0 + +Base test mpi_cmp_mpi #2 +mpi_cmp_mpi:10:"693":10:"692":1 + +Base test mpi_cmp_mpi #3 +mpi_cmp_mpi:10:"693":10:"694":-1 + +Base test mpi_cmp_mpi (Negative values) #1 +mpi_cmp_mpi:10:"-2":10:"-2":0 + +Base test mpi_cmp_mpi (Negative values) #2 +mpi_cmp_mpi:10:"-2":10:"-3":1 + +Base test mpi_cmp_mpi (Negative values) #3 +mpi_cmp_mpi:10:"-2":10:"-1":-1 + +Base test mpi_cmp_abs #1 +mpi_cmp_abs:10:"693":10:"693":0 + +Base test mpi_cmp_abs #2 +mpi_cmp_abs:10:"693":10:"692":1 + +Base test mpi_cmp_abs #3 +mpi_cmp_abs:10:"693":10:"694":-1 + +Base test mpi_cmp_abs (Negative values) #1 +mpi_cmp_abs:10:"-2":10:"-2":0 + +Base test mpi_cmp_abs (Negative values) #2 +mpi_cmp_abs:10:"-2":10:"-3":-1 + +Base test mpi_cmp_abs (Negative values) #3 +mpi_cmp_abs:10:"-2":10:"-1":1 + +Base test mpi_cmp_abs (Mix values) #1 +mpi_cmp_abs:10:"-2":10:"2":0 + +Base test mpi_cmp_abs (Mix values) #2 +mpi_cmp_abs:10:"2":10:"-3":-1 + +Base test mpi_cmp_abs (Mix values) #3 +mpi_cmp_abs:10:"-2":10:"1":1 + +Base test mpi_copy #1 +mpi_copy:0:1500 + +Base test mpi_swap #1 +mpi_swap:0:1500 + +Base test mpi_add_abs #1 +mpi_add_abs:10:"12345678":10:"642531":10:"12988209" + +Base test mpi_add_abs #2 +mpi_add_abs:10:"-12345678":10:"642531":10:"12988209" + +Base test mpi_add_abs #3 +mpi_add_abs:10:"12345678":10:"-642531":10:"12988209" + +Base test mpi_add_abs #4 +mpi_add_abs:10:"-12345678":10:"-642531":10:"12988209" + +Test mpi_add_abs #1 +mpi_add_abs:10:"-643808006803554439230129854961492699151386107534013432918073439524138264842370630061369715394739134090922937332590384720397133335969549256322620979036686633213903952966175107096769180017646161851573147596390153":10:"56125680981752282333498088313568935051383833838594899821664631784577337171193624243181360054669678410455329112434552942717084003541384594864129940145043086760031292483340068923506115878221189886491132772739661669044958531131327771":10:"56125680981752282334141896320372489490613963693556392520816017892111350604111697682705498319512049040516698827829292076808006940873974979584527073481012636016353913462376755556720019831187364993587901952757307830896531678727717924" + +Base test mpi_add_mpi #1 +mpi_add_mpi:10:"12345678":10:"642531":10:"12988209" + +Base test mpi_add_mpi #2 +mpi_add_mpi:10:"-12345678":10:"642531":10:"-11703147" + +Base test mpi_add_mpi #3 +mpi_add_mpi:10:"12345678":10:"-642531":10:"11703147" + +Base test mpi_add_mpi #4 +mpi_add_mpi:10:"-12345678":10:"-642531":10:"-12988209" + +Test mpi_add_mpi #1 +mpi_add_mpi:10:"203956878356401977405765866929034577280193993314348263094772646453283062722701277632936616063144088173312372882677123879538709400158306567338328279154499698366071906766440037074217117805690872792848149112022286332144876183376326512083574821647933992961249917319836219304274280243803104015000563790123":10:"531872289054204184185084734375133399408303613982130856645299464930952178606045848877129147820387996428175564228204785846141207532462936339834139412401975338705794646595487324365194792822189473092273993580587964571659678084484152603881094176995594813302284232006001752128168901293560051833646881436219":10:"735829167410606161590850601304167976688497607296479119740072111384235241328747126510065763883532084601487937110881909725679916932621242907172467691556475037071866553361927361439411910627880345885122142692610250903804554267860479115964668998643528806263534149325837971432443181537363155848647445226342" + +Test mpi_add_mpi #2 +mpi_add_mpi:10:"643808006803554439230129854961492699151386107534013432918073439524138264842370630061369715394739134090922937332590384720397133335969549256322620979036686633213903952966175107096769180017646161851573147596390153":10:"56125680981752282333498088313568935051383833838594899821664631784577337171193624243181360054669678410455329112434552942717084003541384594864129940145043086760031292483340068923506115878221189886491132772739661669044958531131327771":10:"56125680981752282334141896320372489490613963693556392520816017892111350604111697682705498319512049040516698827829292076808006940873974979584527073481012636016353913462376755556720019831187364993587901952757307830896531678727717924" + +Test mpi_add_int #1 +mpi_add_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":9871232:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227022647561" + +Test mpi_add_int #2 +mpi_add_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":-9871232:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227002905097" + +Base test mpi_sub_abs #1 (Test with larger second input) +mpi_sub_abs:10:"5":10:"7":10:"0":POLARSSL_ERR_MPI_NEGATIVE_VALUE + +Base test mpi_sub_abs #2 (Test with larger second input) +mpi_sub_abs:10:"-5":10:"-7":10:"0":POLARSSL_ERR_MPI_NEGATIVE_VALUE + +Base test mpi_sub_abs #3 (Test with larger second input) +mpi_sub_abs:10:"-5":10:"7":10:"0":POLARSSL_ERR_MPI_NEGATIVE_VALUE + +Base test mpi_sub_abs #4 (Test with larger second input) +mpi_sub_abs:10:"5":10:"-7":10:"0":POLARSSL_ERR_MPI_NEGATIVE_VALUE + +Base test mpi_sub_abs #1 +mpi_sub_abs:10:"7":10:"5":10:"2":0 + +Base test mpi_sub_abs #2 +mpi_sub_abs:10:"-7":10:"-5":10:"2":0 + +Base test mpi_sub_abs #3 +mpi_sub_abs:10:"-7":10:"5":10:"2":0 + +Base test mpi_sub_abs #4 +mpi_sub_abs:10:"7":10:"-5":10:"2":0 + +Base test mpi_sub_mpi #1 (Test with negative result) +mpi_sub_mpi:10:"5":10:"7":10:"-2" + +Base test mpi_sub_mpi #2 (Test with negative inputs) +mpi_sub_mpi:10:"-5":10:"-7":10:"2" + +Base test mpi_sub_mpi #3 (Test with negative base) +mpi_sub_mpi:10:"-5":10:"7":10:"-12" + +Base test mpi_sub_mpi #4 (Test with negative substraction) +mpi_sub_mpi:10:"5":10:"-7":10:"12" + +Test mpi_sub_mpi #1 +mpi_sub_mpi:10:"531872289054204184185084734375133399408303613982130856645299464930952178606045848877129147820387996428175564228204785846141207532462936339834139412401975338705794646595487324365194792822189473092273993580587964571659678084484152603881094176995594813302284232006001752128168901293560051833646881436219":10:"203956878356401977405765866929034577280193993314348263094772646453283062722701277632936616063144088173312372882677123879538709400158306567338328279154499698366071906766440037074217117805690872792848149112022286332144876183376326512083574821647933992961249917319836219304274280243803104015000563790123":10:"327915410697802206779318867446098822128109620667782593550526818477669115883344571244192531757243908254863191345527661966602498132304629772495811133247475640339722739829047287290977675016498600299425844468565678239514801901107826091797519355347660820341034314686165532823894621049756947818646317646096" + +Test mpi_sub_mpi #2 (Test for negative result) +mpi_sub_mpi:10:"643808006803554439230129854961492699151386107534013432918073439524138264842370630061369715394739134090922937332590384720397133335969549256322620979036686633213903952966175107096769180017646161851573147596390153":10:"56125680981752282333498088313568935051383833838594899821664631784577337171193624243181360054669678410455329112434552942717084003541384594864129940145043086760031292483340068923506115878221189886491132772739661669044958531131327771":10:"-56125680981752282332854280306765380612153703983633407122513245677043323738275550803657221789827307780393959397039813808626161066208794210143732806809073537503708671504303382290292211925255014779394363592722015507193385383534937618" + +Test mpi_sub_int #1 +mpi_sub_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":-9871232:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227022647561" + +Test mpi_sub_int #2 +mpi_sub_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":9871232:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227002905097" + +Test mpi_shift_l #1 +mpi_shift_l:10:"64":1:10:"128" + +Test mpi_shift_l #2 +mpi_shift_l:10:"658385546911733550164516088405238961461880256029834598831972039469421755117818013653494814438931957316403111689187691446941406788869098983929874080332195117465344344350008880118042764943201875870917468833709791733282363323948005998269792207":37:10:"90487820548639020691922304619723076305400961610119884872723190678642804168382367856686134531865643066983017249846286450251272364365605022750900439437595355052945035915579216557330505438734955340526145476988250171181404966718289259743378883640981192704" + +Test mpi_shift_r #1 +mpi_shift_r:10:"128":1:10:"64" + +Test mpi_shift_r #2 +mpi_shift_r:10:"120815570979701484704906977000760567182871429114712069861589084706550626575967516787438008593490722779337547394120718248995900363209947025063336882559539208430319216688889117222633155838468458047056355241515415159736436403445579777425189969":45:10:"3433785053053426415343295076376096153094051405637175942660777670498379921354157795219578264137985649407981651226029903483433269093721578004287291678324982297860947730012217028349628999378309630601971640587504883789518896817457" + +Base test mpi_mul_mpi #1 +mpi_mul_mpi:10:"5":10:"7":10:"35" + +Base test mpi_mul_mpi #2 +mpi_mul_mpi:10:"-5":10:"7":10:"-35" + +Base test mpi_mul_mpi #3 +mpi_mul_mpi:10:"5":10:"-7":10:"-35" + +Base test mpi_mul_mpi #4 +mpi_mul_mpi:10:"-5":10:"-7":10:"35" + +Test mpi_mul_mpi #1 +mpi_mul_mpi:10:"28911710017320205966167820725313234361535259163045867986277478145081076845846493521348693253530011243988160148063424837895971948244167867236923919506962312185829914482993478947657472351461336729641485069323635424692930278888923450060546465883490944265147851036817433970984747733020522259537":10:"16471581891701794764704009719057349996270239948993452268812975037240586099924712715366967486587417803753916334331355573776945238871512026832810626226164346328807407669366029926221415383560814338828449642265377822759768011406757061063524768140567867350208554439342320410551341675119078050953":10:"476221599179424887669515829231223263939342135681791605842540429321038144633323941248706405375723482912535192363845116154236465184147599697841273424891410002781967962186252583311115708128167171262206919514587899883547279647025952837516324649656913580411611297312678955801899536937577476819667861053063432906071315727948826276092545739432005962781562403795455162483159362585281248265005441715080197800335757871588045959754547836825977169125866324128449699877076762316768127816074587766799018626179199776188490087103869164122906791440101822594139648973454716256383294690817576188761" + +Test mpi_mul_int #1 +mpi_mul_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":9871232:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":== + +Test mpi_mul_int #2 (Unsigned, thus failure) +mpi_mul_int:10:"2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":-9871232:10:"-20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":!= + +Test mpi_mul_int #3 +mpi_mul_int:10:"-2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":9871232:10:"-20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":== + +Test mpi_mul_int #4 (Unsigned, thus failure) +mpi_mul_int:10:"-2039568783564019774057658669290345772801939933143482630947726464532830627227012776329":-9871232:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":!= + +Base test mpi_div_mpi #1 +mpi_div_mpi:10:"1000":10:"13":10:"76":10:"12":0 + +Base test mpi_div_mpi #2 (Divide by zero) +mpi_div_mpi:10:"1000":10:"0":10:"1":10:"1":POLARSSL_ERR_MPI_DIVISION_BY_ZERO + +Base test mpi_div_mpi #3 +mpi_div_mpi:10:"1000":10:"-13":10:"-76":10:"12":0 + +Test mpi_div_mpi #1 +mpi_div_mpi:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":10:"34":10:"592148724779947824773845002981655249516095268533053127589864347174804198178334111238460803":10:"26":0 + +Test mpi_div_mpi #2 +mpi_div_mpi:10:"476221599179424887669515829231223263939342135681791605842540429321038144633323941248706405375723482912535192363845116154236465184147599697841273424891410002781967962186252583311115708128167171262206919514587899883547279647025952837516324649656913580411611297312678955801899536937577476819667861053063432906071315727948826276092545739432005962781562403795455162483159362585281248265005441715080197800335757871588045959754547836825977169125866324128449699877076762316768127816074587766799018626179199776188490087103869164122906791440101822594139648973454716256383294690817576188762":10:"28911710017320205966167820725313234361535259163045867986277478145081076845846493521348693253530011243988160148063424837895971948244167867236923919506962312185829914482993478947657472351461336729641485069323635424692930278888923450060546465883490944265147851036817433970984747733020522259537":10:"16471581891701794764704009719057349996270239948993452268812975037240586099924712715366967486587417803753916334331355573776945238871512026832810626226164346328807407669366029926221415383560814338828449642265377822759768011406757061063524768140567867350208554439342320410551341675119078050953":10:"1":0 + +Base test mpi_div_int #1 +mpi_div_int:10:"1000":13:10:"76":10:"12":0 + +Base test mpi_div_mpi #2 (Divide by zero) +mpi_div_int:10:"1000":0:10:"1":10:"1":POLARSSL_ERR_MPI_DIVISION_BY_ZERO + +Base test mpi_div_int #3 +mpi_div_int:10:"1000":-13:10:"-76":10:"12":0 + +Test mpi_div_int #1 +mpi_div_int:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":34:10:"592148724779947824773845002981655249516095268533053127589864347174804198178334111238460803":10:"26":0 + +Test mpi_div_int #2 +mpi_div_int:10:"20133056642518226042310730101376278483547239130123806338055387803943342738063359782107667328":-34:10:"-592148724779947824773845002981655249516095268533053127589864347174804198178334111238460803":10:"26":0 + +Base test mpi_mod_mpi #1 +mpi_mod_mpi:10:"1000":10:"13":10:"12":0 + +Base test mpi_mod_mpi #2 (Divide by zero) +mpi_mod_mpi:10:"1000":10:"0":10:"0":POLARSSL_ERR_MPI_DIVISION_BY_ZERO + +Base test mpi_mod_mpi #3 +mpi_mod_mpi:10:"-1000":10:"13":10:"1":0 + +Base test mpi_mod_mpi #4 (Negative modulo) +mpi_mod_mpi:10:"1000":10:"-13":10:"-1":POLARSSL_ERR_MPI_NEGATIVE_VALUE + +Base test mpi_mod_mpi #5 (Negative modulo) +mpi_mod_mpi:10:"-1000":10:"-13":10:"-12":POLARSSL_ERR_MPI_NEGATIVE_VALUE + +Base test mpi_mod_int #1 +mpi_mod_int:10:"1000":13:12:0 + +Base test mpi_mod_int #2 (Divide by zero) +mpi_mod_int:10:"1000":0:0:POLARSSL_ERR_MPI_DIVISION_BY_ZERO + +Base test mpi_mod_int #3 +mpi_mod_int:10:"-1000":13:1:0 + +Base test mpi_mod_int #4 (Negative modulo) +mpi_mod_int:10:"1000":-13:0:POLARSSL_ERR_MPI_NEGATIVE_VALUE + +Base test mpi_mod_int #5 (Negative modulo) +mpi_mod_int:10:"-1000":-13:0:POLARSSL_ERR_MPI_NEGATIVE_VALUE + +Base test mpi_exp_mod #1 +mpi_exp_mod:10:"23":10:"13":10:"29":10:"":10:"24":0 + +Base test mpi_exp_mod #2 +mpi_exp_mod:10:"23":10:"13":10:"30":10:"":10:"0":POLARSSL_ERR_MPI_BAD_INPUT_DATA + +Base test mpi_exp_mod #3 +mpi_exp_mod:10:"23":10:"13":10:"-29":10:"":10:"24":POLARSSL_ERR_MPI_BAD_INPUT_DATA + +Test mpi_exp_mod #1 +mpi_exp_mod:10:"433019240910377478217373572959560109819648647016096560523769010881172869083338285573756574557395862965095016483867813043663981946477698466501451832407592327356331263124555137732393938242285782144928753919588632679050799198937132922145084847":10:"5781538327977828897150909166778407659250458379645823062042492461576758526757490910073628008613977550546382774775570888130029763571528699574717583228939535960234464230882573615930384979100379102915657483866755371559811718767760594919456971354184113721":10:"583137007797276923956891216216022144052044091311388601652961409557516421612874571554415606746479105795833145583959622117418531166391184939066520869800857530421873250114773204354963864729386957427276448683092491947566992077136553066273207777134303397724679138833126700957":10:"":10:"114597449276684355144920670007147953232659436380163461553186940113929777196018164149703566472936578890991049344459204199888254907113495794730452699842273939581048142004834330369483813876618772578869083248061616444392091693787039636316845512292127097865026290173004860736":0 + +Base test GCD #1 +mpi_gcd:10:"693":10:"609":10:"21" + +Base test GCD #2 +mpi_gcd:10:"1764":10:"868":10:"28" + +Base test GCD #3 +mpi_gcd:10:"768454923":10:"542167814":10:"1" + +Test GCD #1 +mpi_gcd:10:"433019240910377478217373572959560109819648647016096560523769010881172869083338285573756574557395862965095016483867813043663981946477698466501451832407592327356331263124555137732393938242285782144928753919588632679050799198937132922145084847":10:"5781538327977828897150909166778407659250458379645823062042492461576758526757490910073628008613977550546382774775570888130029763571528699574717583228939535960234464230882573615930384979100379102915657483866755371559811718767760594919456971354184113721":10:"1" + +Base test mpi_inv_mod #1 +mpi_inv_mod:10:"3":10:"11":10:"4":0 + +Base test mpi_inv_mod #2 +mpi_inv_mod:10:"3":10:"0":10:"0":POLARSSL_ERR_MPI_BAD_INPUT_DATA + +Base test mpi_inv_mod #3 +mpi_inv_mod:10:"3":10:"-11":10:"4":POLARSSL_ERR_MPI_BAD_INPUT_DATA + +Base test mpi_inv_mod #4 +mpi_inv_mod:10:"2":10:"4":10:"0":POLARSSL_ERR_MPI_NOT_ACCEPTABLE + +Test mpi_inv_mod #1 +mpi_inv_mod:16:"aa4df5cb14b4c31237f98bd1faf527c283c2d0f3eec89718664ba33f9762907c":16:"fffbbd660b94412ae61ead9c2906a344116e316a256fd387874c6c675b1d587d":16:"8d6a5c1d7adeae3e94b9bcd2c47e0d46e778bc8804a2cc25c02d775dc3d05b0c":0 + +Base test mpi_is_prime #1 +mpi_is_prime:10:"0":POLARSSL_ERR_MPI_NOT_ACCEPTABLE + +Base test mpi_is_prime #2 +mpi_is_prime:10:"1":POLARSSL_ERR_MPI_NOT_ACCEPTABLE + +Base test mpi_is_prime #3 +mpi_is_prime:10:"2":0 + +Base test mpi_is_prime #4 +mpi_is_prime:10:"3":0 + +Base test mpi_is_prime #5 +mpi_is_prime:10:"4":POLARSSL_ERR_MPI_NOT_ACCEPTABLE + +Base test mpi_is_prime #6 +mpi_is_prime:10:"5":0 + +Base test mpi_is_prime #7 +mpi_is_prime:10:"27":POLARSSL_ERR_MPI_NOT_ACCEPTABLE + +Base test mpi_is_prime #8 +mpi_is_prime:10:"47":0 + +Test mpi_is_prime #1 +mpi_is_prime:10:"827131507221654563937832686696200995595835694437983658840870036586124168186967796809117749047430768825822857042432722828096779098498192459819306321073968735177531164565305635281198148032612029767584644305912099":0 + +Test mpi_is_prime #2 +mpi_is_prime:10:"827131507221654563937832686696200995595835694437983658840870036586124168186967796809117749047430768825822857042432722828096779098498192459819306321073968735177531164565305635281198148032612029767584644305912001":POLARSSL_ERR_MPI_NOT_ACCEPTABLE diff --git a/tests/suites/test_suite_mpi.function b/tests/suites/test_suite_mpi.function new file mode 100644 index 0000000..cea5edd --- /dev/null +++ b/tests/suites/test_suite_mpi.function @@ -0,0 +1,391 @@ +BEGIN_HEADER +#include + +static int myrand( void *rng_state ) +{ + if( rng_state != NULL ) + rng_state = NULL; + + return( rand() ); +} + +END_HEADER + +BEGIN_CASE +mpi_read_write_string:radix_X:input_X:radix_A:input_A +{ + mpi X; + char str[1000]; + int len = 1000; + + mpi_init(&X, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_write_string( &X, {radix_A}, str, &len ) == 0 ); + TEST_ASSERT( strcmp( str, {input_A} ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_gcd:radix_X:input_X:radix_Y:input_Y:radix_A:input_A +{ + mpi A, X, Y, Z; + mpi_init(&A, &X, &Y, &Z, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_gcd( &Z, &X, &Y ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_cmp_int:input_X:input_A:result_CMP +{ + mpi X; + mpi_init(&X, NULL); + + TEST_ASSERT( mpi_lset( &X, {input_X} ) == 0); + TEST_ASSERT( mpi_cmp_int( &X, {input_A} ) == {result_CMP}); +} +END_CASE + +BEGIN_CASE +mpi_cmp_mpi:radix_X:input_X:radix_Y:input_Y:input_A +{ + mpi X, Y; + mpi_init(&X, &Y, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == {input_A} ); +} +END_CASE + +BEGIN_CASE +mpi_cmp_abs:radix_X:input_X:radix_Y:input_Y:input_A +{ + mpi X, Y; + mpi_init(&X, &Y, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_cmp_abs( &X, &Y ) == {input_A} ); +} +END_CASE + +BEGIN_CASE +mpi_copy:input_X:input_A +{ + mpi X, Y, A; + mpi_init(&X, &Y, &A, NULL); + + TEST_ASSERT( mpi_lset( &X, {input_X} ) == 0 ); + TEST_ASSERT( mpi_lset( &Y, {input_A} ) == 0 ); + TEST_ASSERT( mpi_lset( &A, {input_A} ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 ); + TEST_ASSERT( mpi_copy( &Y, &X ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) != 0 ); +} +END_CASE + +BEGIN_CASE +mpi_swap:input_X:input_Y +{ + mpi X, Y, A; + mpi_init(&X, &Y, &A, NULL); + + TEST_ASSERT( mpi_lset( &X, {input_X} ) == 0 ); + TEST_ASSERT( mpi_lset( &Y, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_lset( &A, {input_X} ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 ); + TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 ); + mpi_swap( &X, &Y ); + TEST_ASSERT( mpi_cmp_mpi( &X, &Y ) != 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Y, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_add_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A +{ + mpi X, Y, Z, A; + mpi_init(&X, &Y, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_add_mpi( &Z, &X, &Y ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_add_abs:radix_X:input_X:radix_Y:input_Y:radix_A:input_A +{ + mpi X, Y, Z, A; + mpi_init(&X, &Y, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_add_abs( &Z, &X, &Y ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_add_int:radix_X:input_X:input_Y:radix_A:input_A +{ + mpi X, Z, A; + mpi_init(&X, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_add_int( &Z, &X, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_sub_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A +{ + mpi X, Y, Z, A; + mpi_init(&X, &Y, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_sub_mpi( &Z, &X, &Y ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_sub_abs:radix_X:input_X:radix_Y:input_Y:radix_A:input_A:sub_result +{ + mpi X, Y, Z, A; + int res; + mpi_init(&X, &Y, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + + res = mpi_sub_abs( &Z, &X, &Y ); + TEST_ASSERT( res == {sub_result} ); + if( res == 0 ) + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_sub_int:radix_X:input_X:input_Y:radix_A:input_A +{ + mpi X, Z, A; + mpi_init(&X, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_sub_int( &Z, &X, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_mul_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A +{ + mpi X, Y, Z, A; + mpi_init(&X, &Y, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_mul_mpi( &Z, &X, &Y ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_mul_int:radix_X:input_X:input_Y:radix_A:input_A:result_comparison +{ + mpi X, Z, A; + mpi_init(&X, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_mul_int( &Z, &X, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) {result_comparison} 0 ); +} +END_CASE + +BEGIN_CASE +mpi_div_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A:radix_B:input_B:div_result +{ + mpi X, Y, Q, R, A, B; + int res; + mpi_init(&X, &Y, &Q, &R, &A, &B, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_read_string( &B, {radix_B}, {input_B} ) == 0 ); + res = mpi_div_mpi( &Q, &R, &X, &Y ); + TEST_ASSERT( res == {div_result} ); + if( res == 0 ) + { + TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 ); + } +} +END_CASE + +BEGIN_CASE +mpi_div_int:radix_X:input_X:input_Y:radix_A:input_A:radix_B:input_B:div_result +{ + mpi X, Q, R, A, B; + int res; + mpi_init(&X, &Q, &R, &A, &B, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_read_string( &B, {radix_B}, {input_B} ) == 0 ); + res = mpi_div_int( &Q, &R, &X, {input_Y} ); + TEST_ASSERT( res == {div_result} ); + if( res == 0 ) + { + TEST_ASSERT( mpi_cmp_mpi( &Q, &A ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &R, &B ) == 0 ); + } +} +END_CASE + +BEGIN_CASE +mpi_mod_mpi:radix_X:input_X:radix_Y:input_Y:radix_A:input_A:div_result +{ + mpi X, Y, Z, A; + int res; + mpi_init(&X, &Y, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + res = mpi_mod_mpi( &Z, &X, &Y ); + TEST_ASSERT( res == {div_result} ); + if( res == 0 ) + { + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); + } +} +END_CASE + +BEGIN_CASE +mpi_mod_int:radix_X:input_X:input_Y:input_A:div_result +{ + mpi X; + int res; + t_int r; + mpi_init(&X, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + res = mpi_mod_int( &r, &X, {input_Y} ); + TEST_ASSERT( res == {div_result} ); + if( res == 0 ) + { + TEST_ASSERT( r == {input_A} ); + } +} +END_CASE + +BEGIN_CASE +mpi_exp_mod:radix_A:input_A:radix_E:input_E:radix_N:input_N:radix_RR:input_RR:radix_X:input_X:div_result +{ + mpi A, E, N, RR, Z, X; + int res; + mpi_init(&A, &E, &N, &RR, &Z, &X, NULL); + + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_read_string( &E, {radix_E}, {input_E} ) == 0 ); + TEST_ASSERT( mpi_read_string( &N, {radix_N}, {input_N} ) == 0 ); + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + + if( strlen( {input_RR} ) ) + TEST_ASSERT( mpi_read_string( &RR, {radix_RR}, {input_RR} ) == 0 ); + + res = mpi_exp_mod( &Z, &A, &E, &N, &RR ); + TEST_ASSERT( res == {div_result} ); + if( res == 0 ) + { + TEST_ASSERT( mpi_cmp_mpi( &Z, &X ) == 0 ); + } +} +END_CASE + +BEGIN_CASE +mpi_inv_mod:radix_X:input_X:radix_Y:input_Y:radix_A:input_A:div_result +{ + mpi X, Y, Z, A; + int res; + mpi_init(&X, &Y, &Z, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &Y, {radix_Y}, {input_Y} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + res = mpi_inv_mod( &Z, &X, &Y ); + TEST_ASSERT( res == {div_result} ); + if( res == 0 ) + { + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); + } +} +END_CASE + +BEGIN_CASE +mpi_is_prime:radix_X:input_X:div_result +{ + mpi X; + int res; + mpi_init(&X, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + res = mpi_is_prime( &X, myrand, NULL ); + TEST_ASSERT( res == {div_result} ); +} +END_CASE + +BEGIN_CASE +mpi_shift_l:radix_X:input_X:shift_X:radix_A:input_A +{ + mpi X, A; + mpi_init(&X, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_shift_l( &X, {shift_X} ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 ); +} +END_CASE + +BEGIN_CASE +mpi_shift_r:radix_X:input_X:shift_X:radix_A:input_A +{ + mpi X, A; + mpi_init(&X, &A, NULL); + + TEST_ASSERT( mpi_read_string( &X, {radix_X}, {input_X} ) == 0 ); + TEST_ASSERT( mpi_read_string( &A, {radix_A}, {input_A} ) == 0 ); + TEST_ASSERT( mpi_shift_r( &X, {shift_X} ) == 0 ); + TEST_ASSERT( mpi_cmp_mpi( &X, &A ) == 0 ); +} +END_CASE + +/* Helper Code + char str[1000]; + int len = 1000; + mpi_write_string(&Z, 10, str, &len); + printf("Z: %d %s\n", Z.s, str); + TEST_ASSERT( mpi_cmp_mpi( &Z, &A ) == 0 ); +*/ diff --git a/tests/suites/test_suite_shax.data b/tests/suites/test_suite_shax.data new file mode 100644 index 0000000..15b402d --- /dev/null +++ b/tests/suites/test_suite_shax.data @@ -0,0 +1,119 @@ +SHA-1 Test Vector NIST CAVS #1 +sha1:"":"da39a3ee5e6b4b0d3255bfef95601890afd80709" + +SHA-1 Test Vector NIST CAVS #2 +sha1:"a8":"99f2aa95e36f95c2acb0eaf23998f030638f3f15" + +SHA-1 Test Vector NIST CAVS #3 +sha1:"3000":"f944dcd635f9801f7ac90a407fbc479964dec024" + +SHA-1 Test Vector NIST CAVS #4 +sha1:"42749e":"a444319e9b6cc1e8464c511ec0969c37d6bb2619" + +SHA-1 Test Vector NIST CAVS #5 +sha1:"9fc3fe08":"16a0ff84fcc156fd5d3ca3a744f20a232d172253" + +SHA-1 Test Vector NIST CAVS #6 +sha1:"b5c1c6f1af":"fec9deebfcdedaf66dda525e1be43597a73a1f93" + +SHA-1 Test Vector NIST CAVS #7 +sha1:"ec29561244ede706b6eb30a1c371d74450a105c3f9735f7fa9fe38cf67f304a5736a106e92e17139a6813b1c81a4f3d3fb9546ab4296fa9f722826c066869edacd73b2548035185813e22634a9da44000d95a281ff9f264ecce0a931222162d021cca28db5f3c2aa24945ab1e31cb413ae29810fd794cad5dfaf29ec43cb38d198fe4ae1da2359780221405bd6712a5305da4b1b737fce7cd21c0eb7728d08235a9011":"970111c4e77bcc88cc20459c02b69b4aa8f58217" + +SHA-1 Test Vector NIST CAVS #8 +sha1:"5fc2c3f6a7e79dc94be526e5166a238899d54927ce470018fbfd668fd9dd97cbf64e2c91584d01da63be3cc9fdff8adfefc3ac728e1e335b9cdc87f069172e323d094b47fa1e652afe4d6aa147a9f46fda33cacb65f3aa12234746b9007a8c85fe982afed7815221e43dba553d8fe8a022cdac1b99eeeea359e5a9d2e72e382dffa6d19f359f4f27dc3434cd27daeeda8e38594873398678065fbb23665aba9309d946135da0e4a4afdadff14db18e85e71dd93c3bf9faf7f25c8194c4269b1ee3d9934097ab990025d9c3aaf63d5109f52335dd3959d38ae485050e4bbb6235574fc0102be8f7a306d6e8de6ba6becf80f37415b57f9898a5824e77414197422be3d36a6080":"0423dc76a8791107d14e13f5265b343f24cc0f19" + +SHA-1 Test Vector NIST CAVS #9 +sha1:"0f865f46a8f3aed2da18482aa09a8f390dc9da07d51d1bd10fe0bf5f3928d5927d08733d32075535a6d1c8ac1b2dc6ba0f2f633dc1af68e3f0fa3d85e6c60cb7b56c239dc1519a007ea536a07b518ecca02a6c31b46b76f021620ef3fc6976804018380e5ab9c558ebfc5cb1c9ed2d974722bf8ab6398f1f2b82fa5083f85c16a5767a3a07271d67743f00850ce8ec428c7f22f1cf01f99895c0c844845b06a06cecb0c6cf83eb55a1d4ebc44c2c13f6f7aa5e0e08abfd84e7864279057abc471ee4a45dbbb5774afa24e51791a0eada11093b88681fe30baa3b2e94113dc63342c51ca5d1a6096d0897b626e42cb91761058008f746f35465465540ad8c6b8b60f7e1461b3ce9e6529625984cb8c7d46f07f735be067588a0117f23e34ff57800e2bbe9a1605fde6087fb15d22c5d3ac47566b8c448b0cee40373e5ba6eaa21abee71366afbb27dbbd300477d70c371e7b8963812f5ed4fb784fb2f3bd1d3afe883cdd47ef32beaea":"6692a71d73e00f27df976bc56df4970650d90e45" + +SHA-1 Test Vector NIST CAVS #10 +sha1:"8236153781bd2f1b81ffe0def1beb46f5a70191142926651503f1b3bb1016acdb9e7f7acced8dd168226f118ff664a01a8800116fd023587bfba52a2558393476f5fc69ce9c65001f23e70476d2cc81c97ea19caeb194e224339bcb23f77a83feac5096f9b3090c51a6ee6d204b735aa71d7e996d380b80822e4dfd43683af9c7442498cacbea64842dfda238cb099927c6efae07fdf7b23a4e4456e0152b24853fe0d5de4179974b2b9d4a1cdbefcbc01d8d311b5dda059136176ea698ab82acf20dd490be47130b1235cb48f8a6710473cfc923e222d94b582f9ae36d4ca2a32d141b8e8cc36638845fbc499bce17698c3fecae2572dbbd470552430d7ef30c238c2124478f1f780483839b4fb73d63a9460206824a5b6b65315b21e3c2f24c97ee7c0e78faad3df549c7ca8ef241876d9aafe9a309f6da352bec2caaa92ee8dca392899ba67dfed90aef33d41fc2494b765cb3e2422c8e595dabbfaca217757453fb322a13203f425f6073a9903e2dc5818ee1da737afc345f0057744e3a56e1681c949eb12273a3bfc20699e423b96e44bd1ff62e50a848a890809bfe1611c6787d3d741103308f849a790f9c015098286dbacfc34c1718b2c2b77e32194a75dda37954a320fa68764027852855a7e5b5274eb1e2cbcd27161d98b59ad245822015f48af82a45c0ed59be94f9af03d9736048570d6e3ef63b1770bc98dfb77de84b1bb1708d872b625d9ab9b06c18e5dbbf34399391f0f8aa26ec0dac7ff4cb8ec97b52bcb942fa6db2385dcd1b3b9d567aaeb425d567b0ebe267235651a1ed9bf78fd93d3c1dd077fe340bb04b00529c58f45124b717c168d07e9826e33376988bc5cf62845c2009980a4dfa69fbc7e5a0b1bb20a5958ca967aec68eb31dd8fccca9afcd30a26bab26279f1bf6724ff":"11863b483809ef88413ca9b0084ac4a5390640af" + +SHA-224 Test Vector NIST CAVS #1 +sha224:"":"d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f" + +SHA-224 Test Vector NIST CAVS #2 +sha224:"ff":"e33f9d75e6ae1369dbabf81b96b4591ae46bba30b591a6b6c62542b5" + +SHA-224 Test Vector NIST CAVS #3 +sha224:"984c":"2fa9df9157d9e027cfbc4c6a9df32e1adc0cbe2328ec2a63c5ae934e" + +SHA-224 Test Vector NIST CAVS #4 +sha224:"50efd0":"b5a9820413c2bf8211fbbf5df1337043b32fa4eafaf61a0c8e9ccede" + +SHA-224 Test Vector NIST CAVS #5 +sha224:"e5e09924":"fd19e74690d291467ce59f077df311638f1c3a46e510d0e49a67062d" + +SHA-224 Test Vector NIST CAVS #6 +sha224:"21ebecb914":"78f4a71c21c694499ce1c7866611b14ace70d905012c356323c7c713" + +SHA-224 Test Vector NIST CAVS #7 +sha224:"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":"1302149d1e197c41813b054c942329d420e366530f5517b470e964fe" + +SHA-256 Test Vector NIST CAVS #1 +sha256:"":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + +SHA-256 Test Vector NIST CAVS #2 +sha256:"bd":"68325720aabd7c82f30f554b313d0570c95accbb7dc4b5aae11204c08ffe732b" + +SHA-256 Test Vector NIST CAVS #3 +sha256:"5fd4":"7c4fbf484498d21b487b9d61de8914b2eadaf2698712936d47c3ada2558f6788" + +SHA-256 Test Vector NIST CAVS #4 +sha256:"b0bd69":"4096804221093ddccfbf46831490ea63e9e99414858f8d75ff7f642c7ca61803" + +SHA-256 Test Vector NIST CAVS #5 +sha256:"c98c8e55":"7abc22c0ae5af26ce93dbb94433a0e0b2e119d014f8e7f65bd56c61ccccd9504" + +SHA-256 Test Vector NIST CAVS #6 +sha256:"81a723d966":"7516fb8bb11350df2bf386bc3c33bd0f52cb4c67c6e4745e0488e62c2aea2605" + +SHA-256 Test Vector NIST CAVS #7 +sha256:"8390cf0be07661cc7669aac54ce09a37733a629d45f5d983ef201f9b2d13800e555d9b1097fec3b783d7a50dcb5e2b644b96a1e9463f177cf34906bf388f366db5c2deee04a30e283f764a97c3b377a034fefc22c259214faa99babaff160ab0aaa7e2ccb0ce09c6b32fe08cbc474694375aba703fadbfa31cf685b30a11c57f3cf4edd321e57d3ae6ebb1133c8260e75b9224fa47a2bb205249add2e2e62f817491482ae152322be0900355cdcc8d42a98f82e961a0dc6f537b7b410eff105f59673bfb787bf042aa071f7af68d944d27371c64160fe9382772372516c230c1f45c0d6b6cca7f274b394da9402d3eafdf733994ec58ab22d71829a98399574d4b5908a447a5a681cb0dd50a31145311d92c22a16de1ead66a5499f2dceb4cae694772ce90762ef8336afec653aa9b1a1c4820b221136dfce80dce2ba920d88a530c9410d0a4e0358a3a11052e58dd73b0b179ef8f56fe3b5a2d117a73a0c38a1392b6938e9782e0d86456ee4884e3c39d4d75813f13633bc79baa07c0d2d555afbf207f52b7dca126d015aa2b9873b3eb065e90b9b065a5373fe1fb1b20d594327d19fba56cb81e7b6696605ffa56eba3c27a438697cc21b201fd7e09f18deea1b3ea2f0d1edc02df0e20396a145412cd6b13c32d2e605641c948b714aec30c0649dc44143511f35ab0fd5dd64c34d06fe86f3836dfe9edeb7f08cfc3bd40956826356242191f99f53473f32b0cc0cf9321d6c92a112e8db90b86ee9e87cc32d0343db01e32ce9eb782cb24efbbbeb440fe929e8f2bf8dfb1550a3a2e742e8b455a3e5730e9e6a7a9824d17acc0f72a7f67eae0f0970f8bde46dcdefaed3047cf807e7f00a42e5fd11d40f5e98533d7574425b7d2bc3b3845c443008b58980e768e464e17cc6f6b3939eee52f713963d07d8c4abf02448ef0b889c9671e2f8a436ddeeffcca7176e9bf9d1005ecd377f2fa67c23ed1f137e60bf46018a8bd613d038e883704fc26e798969df35ec7bbc6a4fe46d8910bd82fa3cded265d0a3b6d399e4251e4d8233daa21b5812fded6536198ff13aa5a1cd46a5b9a17a4ddc1d9f85544d1d1cc16f3df858038c8e071a11a7e157a85a6a8dc47e88d75e7009a8b26fdb73f33a2a70f1e0c259f8f9533b9b8f9af9288b7274f21baeec78d396f8bacdcc22471207d9b4efccd3fedc5c5a2214ff5e51c553f35e21ae696fe51e8df733a8e06f50f419e599e9f9e4b37ce643fc810faaa47989771509d69a110ac916261427026369a21263ac4460fb4f708f8ae28599856db7cb6a43ac8e03d64a9609807e76c5f312b9d1863bfa304e8953647648b4f4ab0ed995e":"4109cdbec3240ad74cc6c37f39300f70fede16e21efc77f7865998714aad0b5e" + +SHA-384 Test Vector NIST CAVS #1 +sha384:"":"38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b" + +SHA-384 Test Vector NIST CAVS #2 +sha384:"ab":"fb94d5be118865f6fcbc978b825da82cff188faec2f66cb84b2537d74b4938469854b0ca89e66fa2e182834736629f3d" + +SHA-384 Test Vector NIST CAVS #3 +sha384:"7c27":"3d80be467df86d63abb9ea1d3f9cb39cd19890e7f2c53a6200bedc5006842b35e820dc4e0ca90ca9b97ab23ef07080fc" + +SHA-384 Test Vector NIST CAVS #4 +sha384:"31f5ca":"78d54b943421fdf7ba90a7fb9637c2073aa480454bd841d39ff72f4511fc21fb67797b652c0c823229342873d3bef955" + +SHA-384 Test Vector NIST CAVS #5 +sha384:"7bdee3f8":"8bdafba0777ee446c3431c2d7b1fbb631089f71d2ca417abc1d230e1aba64ec2f1c187474a6f4077d372c14ad407f99a" + +SHA-384 Test Vector NIST CAVS #6 +sha384:"8f05604915":"504e414bf1db1060f14c8c799e25b1e0c4dcf1504ebbd129998f0ae283e6de86e0d3c7e879c73ec3b1836c3ee89c2649" + +SHA-384 Test Vector NIST CAVS #7 +sha384:"665da6eda214":"4c022f112010908848312f8b8f1072625fd5c105399d562ea1d56130619a7eac8dfc3748fd05ee37e4b690be9daa9980" + +SHA-384 Test Vector NIST CAVS #8 +sha384:"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":"cba9e3eb12a6f83db11e8a6ff40d1049854ee094416bc527fea931d8585428a8ed6242ce81f6769b36e2123a5c23483e" + +SHA-512 Test Vector NIST CAVS #1 +sha512:"":"cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e" + +SHA-512 Test Vector NIST CAVS #2 +sha512:"8f":"e4cd2d19931b5aad9c920f45f56f6ce34e3d38c6d319a6e11d0588ab8b838576d6ce6d68eea7c830de66e2bd96458bfa7aafbcbec981d4ed040498c3dd95f22a" + +SHA-512 Test Vector NIST CAVS #3 +sha512:"e724":"7dbb520221a70287b23dbcf62bfc1b73136d858e86266732a7fffa875ecaa2c1b8f673b5c065d360c563a7b9539349f5f59bef8c0c593f9587e3cd50bb26a231" + +SHA-512 Test Vector NIST CAVS #4 +sha512:"de4c90":"33ce98281045a5c4c9df0363d8196f1d7dfcd5ee46ac89776fd8a4344c12f123a66788af5bd41ceff1941aa5637654b4064c88c14e00465ab79a2fc6c97e1014" + +SHA-512 Test Vector NIST CAVS #5 +sha512:"a801e94b":"dadb1b5a27f9fece8d86adb2a51879beb1787ff28f4e8ce162cad7fee0f942efcabbf738bc6f797fc7cc79a3a75048cd4c82ca0757a324695bfb19a557e56e2f" + +SHA-512 Test Vector NIST CAVS #6 +sha512:"94390d3502":"b6175c4c4cccf69e0ce5f0312010886ea6b34d43673f942ae42483f9cbb7da817de4e11b5d58e25a3d9bd721a22cdffe1c40411cc45df1911fa5506129b69297" + +SHA-512 Test Vector NIST CAVS #7 +sha512:"49297dd63e5f":"1fcc1e6f6870859d11649f5e5336a9cd16329c029baf04d5a6edf257889a2e9522b497dd656bb402da461307c4ee382e2e89380c8e6e6e7697f1e439f650fa94" + +SHA-512 Test Vector NIST CAVS #8 +sha512:"990d1ae71a62d7bda9bfdaa1762a68d296eee72a4cd946f287a898fbabc002ea941fd8d4d991030b4d27a637cce501a834bb95eab1b7889a3e784c7968e67cbf552006b206b68f76d9191327524fcc251aeb56af483d10b4e0c6c5e599ee8c0fe4faeca8293844a8547c6a9a90d093f2526873a19ad4a5e776794c68c742fb834793d2dfcb7fea46c63af4b70fd11cb6e41834e72ee40edb067b292a794990c288d5007e73f349fb383af6a756b8301ad6e5e0aa8cd614399bb3a452376b1575afa6bdaeaafc286cb064bb91edef97c632b6c1113d107fa93a0905098a105043c2f05397f702514439a08a9e5ddc196100721d45c8fc17d2ed659376f8a00bd5cb9a0860e26d8a29d8d6aaf52de97e9346033d6db501a35dbbaf97c20b830cd2d18c2532f3a59cc497ee64c0e57d8d060e5069b28d86edf1adcf59144b221ce3ddaef134b3124fbc7dd000240eff0f5f5f41e83cd7f5bb37c9ae21953fe302b0f6e8b68fa91c6ab99265c64b2fd9cd4942be04321bb5d6d71932376c6f2f88e02422ba6a5e2cb765df93fd5dd0728c6abdaf03bce22e0678a544e2c3636f741b6f4447ee58a8fc656b43ef817932176adbfc2e04b2c812c273cd6cbfa4098f0be036a34221fa02643f5ee2e0b38135f2a18ecd2f16ebc45f8eb31b8ab967a1567ee016904188910861ca1fa205c7adaa194b286893ffe2f4fbe0384c2aef72a4522aeafd3ebc71f9db71eeeef86c48394a1c86d5b36c352cc33a0a2c800bc99e62fd65b3a2fd69e0b53996ec13d8ce483ce9319efd9a85acefabdb5342226febb83fd1daf4b24265f50c61c6de74077ef89b6fecf9f29a1f871af1e9f89b2d345cda7499bd45c42fa5d195a1e1a6ba84851889e730da3b2b916e96152ae0c92154b49719841db7e7cc707ba8a5d7b101eb4ac7b629bb327817910fff61580b59aab78182d1a2e33473d05b00b170b29e331870826cfe45af206aa7d0246bbd8566ca7cfb2d3c10bfa1db7dd48dd786036469ce7282093d78b5e1a5b0fc81a54c8ed4ceac1e5305305e78284ac276f5d7862727aff246e17addde50c670028d572cbfc0be2e4f8b2eb28fa68ad7b4c6c2a239c460441bfb5ea049f23b08563b4e47729a59e5986a61a6093dbd54f8c36ebe87edae01f251cb060ad1364ce677d7e8d5a4a4ca966a7241cc360bc2acb280e5f9e9c1b032ad6a180a35e0c5180b9d16d026c865b252098cc1d99ba7375ca31c7702c0d943d5e3dd2f6861fa55bd46d94b67ed3e52eccd8dd06d968e01897d6de97ed3058d91dd":"8e4bc6f8b8c60fe4d68c61d9b159c8693c3151c46749af58da228442d927f23359bd6ccd6c2ec8fa3f00a86cecbfa728e1ad60b821ed22fcd309ba91a4138bc9" diff --git a/tests/suites/test_suite_shax.function b/tests/suites/test_suite_shax.function new file mode 100644 index 0000000..f90d161 --- /dev/null +++ b/tests/suites/test_suite_shax.function @@ -0,0 +1,105 @@ +BEGIN_HEADER +#include +#include +#include +END_HEADER + +BEGIN_CASE +sha1:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[41]; + + memset(src_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 41); + + int src_len = unhexify( src_str, {hex_src_string} ); + + sha1( src_str, src_len, output ); + hexify( hash_str, output, 20 ); + + TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +sha224:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[57]; + + memset(src_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 57); + + int src_len = unhexify( src_str, {hex_src_string} ); + + sha2( src_str, src_len, output, 1 ); + hexify( hash_str, output, 28 ); + + TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +sha256:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[65]; + + memset(src_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 65); + + int src_len = unhexify( src_str, {hex_src_string} ); + + sha2( src_str, src_len, output, 0 ); + hexify( hash_str, output, 32 ); + + TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +sha384:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[97]; + + memset(src_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 97); + + int src_len = unhexify( src_str, {hex_src_string} ); + + sha4( src_str, src_len, output, 1 ); + hexify( hash_str, output, 48 ); + + TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 ); +} +END_CASE + +BEGIN_CASE +sha512:hex_src_string:hex_hash_string +{ + unsigned char src_str[10000]; + unsigned char hash_str[10000]; + unsigned char output[129]; + + memset(src_str, 0x00, 10000); + memset(hash_str, 0x00, 10000); + memset(output, 0x00, 129); + + int src_len = unhexify( src_str, {hex_src_string} ); + + sha4( src_str, src_len, output, 0); + hexify( hash_str, output, 64 ); + + TEST_ASSERT( strcmp( (char *) hash_str, {hex_hash_string} ) == 0 ); +} +END_CASE -- cgit v1.1