From 84645175c1c319b840a4b006a5ab55f07f6f404f Mon Sep 17 00:00:00 2001 From: Henrik Hautakoski Date: Wed, 31 May 2023 10:46:14 +0200 Subject: [PATCH] tests: Adding tests for sha256 and ripemd160 hashing functions. --- tests/CMakeLists.txt | 4 + tests/hash/ripemd160.cpp | 115 ++++++++++++++++++++++++++ tests/hash/sha256.cpp | 174 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 293 insertions(+) create mode 100644 tests/hash/ripemd160.cpp create mode 100644 tests/hash/sha256.cpp diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index c1a8429..5776caf 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -2,6 +2,10 @@ set(TEST_SRC main.cpp + # hash + hash/sha256.cpp + hash/ripemd160.cpp + # ec ec/generate.cpp ec/pubkey.cpp diff --git a/tests/hash/ripemd160.cpp b/tests/hash/ripemd160.cpp new file mode 100644 index 0000000..086605a --- /dev/null +++ b/tests/hash/ripemd160.cpp @@ -0,0 +1,115 @@ +#include +#include +#include +#include + +TEST_CASE("hash::ripemd160::ripemd160") { + + struct testcase { + const char *name; + std::string input; + libantelope::ripemd160_t expected; + bool valid; + }; + + std::vector tests = { + { + "valid #1", + "Morbi at egestas risus. Praesent blandit pharetra urna, nec porttitor risus sodales eu. Cras et volutpat elit, porta dapibus ipsum. Donec facilisis, eros nec imperdiet tristique, purus eros malesuada neque, quis interdum nisl risus nec leo.", + { + 0xd9, 0x6a, 0x48, 0xf8, 0x2b, 0x39, 0xa9, 0x9f, + 0x22, 0xba, 0x3e, 0x01, 0x58, 0x5b, 0x15, 0xc7, + 0x7b, 0x0e, 0x5f, 0x50, + }, + true + }, + { + "valid #2", + "Donec eget mattis velit, vel vulputate sem. Suspendisse vulputate dolor vel est facilisis congue. Nulla non leo nulla. Proin lorem elit, sagittis eget congue in, pellentesque sed nisi. In pulvinar tortor fermentum suscipit varius.", + { + 0x87, 0x1b, 0x87, 0xde, 0x2e, 0xb6, 0x8b, 0xb6, + 0xdc, 0x29, 0xe7, 0x40, 0xc3, 0xd1, 0x99, 0x42, + 0xad, 0x1a, 0xe3, 0x57 + }, + true + } + }; + + for(auto it = tests.begin(); it != tests.end(); it++) { + SUBCASE(it->name) { + libantelope::ripemd160_t dgst; + + CHECK( libantelope::ripemd160((const unsigned char*) it->input.c_str(), it->input.size(), &dgst) == &dgst ); + + CHECK_PRED(doctest::toString(dgst), doctest::toString(it->expected), it->valid); + } + } +} + +TEST_CASE("hash::ripemd160::init/update/final") { + + struct testcase { + const char *name; + std::vector inputs; + libantelope::ripemd160_t expected; + }; + + std::vector tests = { + { + "valid #1", + { + "tortor in congue luctus, tortor sapien condimentum quam, ac congue enim lacus vitae erat. Mauris dapibus eros bibendum", + "Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae", + }, + { + 0x30, 0x77, 0xaf, 0x6b, 0x43, 0x0b, 0x94, 0x8d, + 0x59, 0x4e, 0xc7, 0xbb, 0x1a, 0x2b, 0xc3, 0x08, + 0xaa, 0xf0, 0x75, 0x3a + } + }, + { + "valid #2", + { + "Cras suscipit, mi sit amet pretium blandit, massa felis aliquet eros", + "Aenean efficitur nibh quis enim mollis blandit", + "Vestibulum posuere tempus mi nec cursus" + }, + { + 0xf1, 0xcf, 0xea, 0xf7, 0xef, 0x3a, 0x0f, 0x80, + 0x26, 0x75, 0x40, 0x75, 0xe0, 0x9d, 0x89, 0x05, + 0xd1, 0x29, 0xe5, 0xf6 + } + }, + { + "valid #3", + { + "Donec nec blandit dui. Nulla et tempus odio, id fermentum neque. Nam vitae nunc leo. Aliquam dictum velit nec neque dignissim maximus nec at tellus", + "Proin elementum porttitor odio, ut ullamcorper justo rutrum in. Proin dignissim nec diam a eleifend. Duis consequat ultrices purus sed finibus", + "Donec eget ante dictum, scelerisque metus eget, mollis velit. Curabitur elementum fermentum lorem, a fringilla velit ultrices non" + }, + { + 0xbb, 0x25, 0x58, 0xa9, 0xd0, 0xc1, 0x23, 0xef, + 0x55, 0xac, 0x2d, 0x8c, 0xd5, 0xd6, 0xe1, 0x49, + 0x00, 0x5d, 0x86, 0xe8 + } + }, + }; + + for(auto it = tests.begin(); it != tests.end(); it++) { + SUBCASE(it->name) { + libantelope::ripemd160_ctx_t ctx; + libantelope::ripemd160_t dgst; + + CHECK_EQ(libantelope::ripemd160_init(&ctx), 1); + + for (auto in_it = it->inputs.begin(); in_it != it->inputs.end(); in_it++ ) { + CHECK_EQ(libantelope::ripemd160_update(&ctx, (const unsigned char*) in_it->c_str(), in_it->size()), 1); + } + + CHECK_EQ(libantelope::ripemd160_final(&ctx, &dgst), 1); + + CHECK( doctest::toString(dgst) == doctest::toString(it->expected) ); + } + } + +} \ No newline at end of file diff --git a/tests/hash/sha256.cpp b/tests/hash/sha256.cpp new file mode 100644 index 0000000..88b2744 --- /dev/null +++ b/tests/hash/sha256.cpp @@ -0,0 +1,174 @@ +#include +#include +#include +#include + +TEST_CASE("hash::sha256::sha256") { + + struct testcase { + const char *name; + std::string input; + libantelope::sha256_t expected; + bool valid; + }; + + std::vector tests = { + { + "valid #1", + "Suspendisse ut tincidunt quam. Praesent scelerisque risus vitae est consectetur, sed facilisis sem luctus. Praesent aliquet eros quis leo sodales, eget blandit diam scelerisque.", + { + 0x1e, 0x54, 0x96, 0x86, 0x2f, 0x39, 0x44, 0xea, + 0x42, 0xa9, 0x0f, 0xad, 0x56, 0x79, 0x4b, 0x77, + 0x8f, 0xcc, 0x54, 0xf7, 0x7a, 0x32, 0x60, 0x37, + 0x4b, 0xac, 0xd5, 0x65, 0x74, 0xf7, 0xcf, 0x6c + }, + true + }, + { + "valid #2", + "Phasellus consectetur augue vitae massa vulputate placerat. Pellentesque nec eros a velit bibendum venenatis sit amet et augue. Morbi malesuada facilisis consequat.", + { + 0x7c, 0x79, 0x4a, 0xf4, 0x9b, 0x5b, 0xb4, 0x0c, + 0xef, 0x4f, 0xaa, 0x65, 0xa4, 0x7c, 0x5f, 0xc5, + 0x95, 0x69, 0x49, 0x99, 0x6b, 0x08, 0x9b, 0xc0, + 0x40, 0x2d, 0x57, 0x8a, 0x90, 0x02, 0x42, 0x32, + }, + true + } + }; + + for(auto it = tests.begin(); it != tests.end(); it++) { + SUBCASE(it->name) { + libantelope::sha256_t dgst; + + CHECK( libantelope::sha256((const unsigned char*) it->input.c_str(), it->input.size(), &dgst) == &dgst ); + + CHECK_PRED(doctest::toString(dgst), doctest::toString(it->expected), it->valid); + } + } +} + +TEST_CASE("hash::sha256::sha256d") { + + struct testcase { + const char *name; + std::string input; + libantelope::sha256_t expected; + }; + + std::vector tests = { + { + "valid #1", + "Suspendisse ut tincidunt quam. Praesent scelerisque risus vitae est consectetur, sed facilisis sem luctus. Praesent aliquet eros quis leo sodales, eget blandit diam scelerisque.", + { + 0x4b, 0x6f, 0xa1, 0xf6, 0x30, 0x1e, 0xbe, 0x4a, + 0xc7, 0xef, 0x1e, 0x55, 0x3e, 0xdb, 0xc1, 0x31, + 0x1f, 0x6b, 0xf5, 0xc8, 0x04, 0xe9, 0x0e, 0xe3, + 0xbe, 0x66, 0x01, 0xbf, 0x70, 0x9f, 0x8e, 0x80, + } + }, + { + "valid #2", + "Vivamus ut elementum justo. Vestibulum lobortis rutrum libero sollicitudin aliquet. Nullam tempor urna non odio iaculis, sed pretium quam porttitor. Pellentesque pretium, justo vitae tristique porttitor, diam massa pulvinar neque, sed lacinia mi nulla sed nisi.", + { + 0x1f, 0x3f, 0x1c, 0x48, 0xf6, 0xee, 0x24, 0x1f, + 0x6c, 0x41, 0x86, 0x69, 0xe3, 0x2f, 0x5e, 0x4d, + 0xa5, 0x51, 0x04, 0x8b, 0x11, 0x35, 0x47, 0xad, + 0x7e, 0xd9, 0xfb, 0x2e, 0x59, 0xee, 0x66, 0x21, + } + }, + { + "valid #3", + "Praesent ultrices consequat risus luctus faucibus.", + { + 0xd5, 0x5f, 0x9c, 0xda, 0x2d, 0x93, 0x32, 0xc2, + 0x9b, 0xb1, 0xbb, 0x14, 0x55, 0x80, 0x72, 0xb7, + 0xba, 0x13, 0xa8, 0xc6, 0xa6, 0xbc, 0x65, 0xfc, + 0x49, 0xe0, 0x3b, 0x23, 0x04, 0x2a, 0x92, 0x8d, + } + } + }; + + for(auto it = tests.begin(); it != tests.end(); it++) { + SUBCASE(it->name) { + libantelope::sha256_t dgst; + + CHECK( libantelope::sha256d((const unsigned char*) it->input.c_str(), it->input.size(), &dgst) == &dgst ); + + CHECK( doctest::toString(dgst) == doctest::toString(it->expected) ); + } + } +} + +TEST_CASE("hash::sha256::init/update/final") { + + struct testcase { + const char *name; + std::vector inputs; + libantelope::sha256_t expected; + }; + + std::vector tests = { + { + "valid #1", + { + "Donec vestibulum enim commodo, faucibus nisi non, mattis quam.", + "Nam sed nunc dapibus, auctor risus placerat, aliquet dolor", + }, + { + 0x48, 0xc2, 0x34, 0x93, 0x3d, 0xae, 0x0d, 0xd0, + 0x28, 0xff, 0x5c, 0xa0, 0xca, 0xb1, 0x0a, 0xa3, + 0xe2, 0xa0, 0xa4, 0x7e, 0xb2, 0x71, 0xa5, 0x28, + 0x41, 0x03, 0x72, 0x20, 0xb5, 0x23, 0xc3, 0x67, + } + }, + { + "valid #2", + { + "In tempus, lectus ac molestie venenatis, enim purus suscipit tortor", + "sed sodales massa condimentum a", + "Integer sit amet pretium magna", + "Aenean non accumsan eros. Donec imperdiet justo tempor magna tincidunt malesuada", + "Duis eu tortor ac massa sagittis elementum" + }, + { + 0xfb, 0x12, 0x31, 0x9c, 0x2c, 0xe4, 0x94, 0x29, + 0xc9, 0xd3, 0xc7, 0x84, 0x0c, 0x58, 0x3d, 0x4c, + 0xde, 0xb5, 0x36, 0x59, 0x46, 0x69, 0xe1, 0x63, + 0xc5, 0x75, 0xb6, 0x94, 0x41, 0x5a, 0xd4, 0x62, + } + }, + { + "valid #3", + { + "Donec tempus pellentesque lobortis. Integer pellentesque feugiat enim ac suscipit. Curabitur urna quam, condimentum sed bibendum eu", + "Nullam lacinia ligula at ex gravida fermentum. Integer scelerisque accumsan iaculis. Suspendisse quis eros ut orci sollicitudin dignissim", + "Nulla ligula tortor, tristique eget feugiat non, vehicula sit amet velit. Proin fermentum sagittis tincidunt. Nullam condimentum dapibus magna", + }, + { + 0x19, 0xfb, 0x71, 0xb1, 0x47, 0x01, 0x7f, 0xf5, + 0xeb, 0xda, 0xc2, 0xd8, 0xe7, 0xab, 0xc9, 0xcb, + 0xea, 0x7d, 0x13, 0xa0, 0x2e, 0xe8, 0x48, 0x94, + 0x67, 0xc5, 0x14, 0xbf, 0x7d, 0x6f, 0x96, 0x83, + } + }, + }; + + for(auto it = tests.begin(); it != tests.end(); it++) { + SUBCASE(it->name) { + libantelope::sha256_ctx_t ctx; + libantelope::sha256_t dgst; + + CHECK_EQ(libantelope::sha256_init(&ctx), 1); + + for (auto in_it = it->inputs.begin(); in_it != it->inputs.end(); in_it++ ) { + CHECK_EQ(libantelope::sha256_update(&ctx, (const unsigned char*) in_it->c_str(), in_it->size()), 1); + } + + CHECK_EQ(libantelope::sha256_final(&ctx, &dgst), 1); + + CHECK( doctest::toString(dgst) == doctest::toString(it->expected) ); + } + } + +} \ No newline at end of file