git.meshlink.io Git - meshlink/blob - test/blackbox/run_blackbox_tests/test_cases_sign.c

   1 /*
   2     test_cases_sign.c -- Execution of specific meshlink black box test cases
   3     Copyright (C) 2018  Guus Sliepen <guus@meshlink.io>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #ifdef NDEBUG
  21 #undef NDEBUG
  22 #endif
  23
  24 #include "execute_tests.h"
  25 #include "test_cases_sign.h"
  26 #include "../common/containers.h"
  27 #include "../common/test_step.h"
  28 #include "../common/common_handlers.h"
  29 #include <assert.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <stdarg.h>
  33 #include <setjmp.h>
  34 #include <cmocka.h>
  35
  36 /* Modify this to change the logging level of Meshlink */
  37 #define TEST_MESHLINK_LOG_LEVEL MESHLINK_DEBUG
  38
  39 static void test_case_sign_01(void **state);
  40 static bool test_sign_01(void);
  41 static void test_case_sign_02(void **state);
  42 static bool test_sign_02(void);
  43 static void test_case_sign_03(void **state);
  44 static bool test_sign_03(void);
  45 static void test_case_sign_04(void **state);
  46 static bool test_sign_04(void);
  47 static void test_case_sign_05(void **state);
  48 static bool test_sign_05(void);
  49 static void test_case_sign_06(void **state);
  50 static bool test_sign_06(void);
  51 static void test_case_sign_07(void **state);
  52 static bool test_sign_07(void);
  53
  54 /* State structure for sign API Test Case #1 */
  55 static black_box_state_t test_case_sign_01_state = {
  56         .test_case_name = "test_case_sign_01",
  57 };
  58
  59 /* State structure for sign API Test Case #2 */
  60 static black_box_state_t test_case_sign_02_state = {
  61         .test_case_name = "test_case_sign_02",
  62 };
  63
  64 /* State structure for sign API Test Case #3 */
  65 static black_box_state_t test_case_sign_03_state = {
  66         .test_case_name = "test_case_sign_03",
  67 };
  68
  69 /* State structure for sign API Test Case #4 */
  70 static black_box_state_t test_case_sign_04_state = {
  71         .test_case_name = "test_case_sign_04",
  72 };
  73
  74 /* State structure for sign API Test Case #5 */
  75 static black_box_state_t test_case_sign_05_state = {
  76         .test_case_name = "test_case_sign_05",
  77 };
  78
  79 /* State structure for sign API Test Case #6 */
  80 static black_box_state_t test_case_sign_06_state = {
  81         .test_case_name = "test_case_sign_06",
  82 };
  83
  84 /* State structure for sign API Test Case #7 */
  85 static black_box_state_t test_case_sign_07_state = {
  86         .test_case_name = "test_case_sign_07",
  87 };
  88
  89
  90 /* Execute sign_data Test Case # 1 - Valid case - sign a data successfully*/
  91 static void test_case_sign_01(void **state) {
  92         execute_test(test_sign_01, state);
  93 }
  94
  95 /* Test Steps for meshlink_sign Test Case # 1 - Valid case
  96
  97     Test Steps:
  98     1. Run NUT(Node Under Test)
  99     2. Sign data
 100
 101     Expected Result:
 102     Signs data successfully
 103 */
 104 static bool test_sign_01(void) {
 105         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 106
 107         // Create meshlink instance
 108         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
 109         assert(mesh_handle);
 110         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 111         assert(meshlink_start(mesh_handle));
 112
 113         // Signing data
 114
 115         char *data = "Test";
 116         char sig[MESHLINK_SIGLEN];
 117         size_t ssize = MESHLINK_SIGLEN;
 118         bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
 119
 120         // Clean up
 121         meshlink_close(mesh_handle);
 122         assert(meshlink_destroy("signconf"));
 123
 124         return ret;
 125 }
 126
 127 /* Execute sign_data Test Case # 2 - Invalid case - meshlink_sign passing NULL as mesh handle argument*/
 128 static void test_case_sign_02(void **state) {
 129         execute_test(test_sign_02, state);
 130         return;
 131 }
 132
 133 /* Test Steps for meshlink_sign Test Case # 2 - invalid case
 134
 135     Test Steps:
 136     1. meshlink_sign API called by passing NULL as mesh handle argument
 137
 138     Expected Result:
 139     API returns false hinting the error.
 140 */
 141 static bool test_sign_02(void) {
 142         char *data = "Test";
 143         char sig[MESHLINK_SIGLEN];
 144         size_t ssize = MESHLINK_SIGLEN;
 145
 146         // Calling meshlink_sign API
 147         bool ret = meshlink_sign(NULL, data, strlen(data) + 1, sig, &ssize);
 148
 149         if(!ret) {
 150                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as mesh_handle arg\n");
 151                 return true;
 152         }
 153
 154         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as mesh_handle arg\n");
 155         return false;
 156 }
 157
 158 /* Execute sign_data Test Case # 3 - Invalid case - meshlink_sign passing data to be signed as NULL */
 159 static void test_case_sign_03(void **state) {
 160         execute_test(test_sign_03, state);
 161 }
 162
 163 /* Test Steps for meshlink_sign Test Case # 3 - invalid case
 164
 165     Test Steps:
 166     1. Run NUT(Node Under Test)
 167     2. meshlink_sign API called by passing NULL as data argument
 168         that has to be signed.
 169
 170     Expected Result:
 171     API returns false hinting the error.
 172 */
 173 static bool test_sign_03(void) {
 174         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 175
 176         // Create meshlink instance
 177         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
 178         assert(mesh_handle);
 179         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 180         assert(meshlink_start(mesh_handle));
 181
 182         // Signing Data
 183         char *data = "Test";
 184         char sig[MESHLINK_SIGLEN];
 185         size_t ssize = MESHLINK_SIGLEN;
 186         bool ret = meshlink_sign(mesh_handle, NULL, strlen(data) + 1, sig, &ssize);
 187
 188         // Clean up
 189
 190         meshlink_close(mesh_handle);
 191         assert(meshlink_destroy("signconf"));
 192
 193         if(!ret) {
 194                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as data arg\n");
 195                 return true;
 196         } else {
 197                 PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as data arg\n");
 198                 return false;
 199         }
 200 }
 201
 202 /* Execute sign_data Test Case # 4 - Invalid case - meshlink_sign passing 0 as size of data
 203       to be signed */
 204 static void test_case_sign_04(void **state) {
 205         execute_test(test_sign_04, state);
 206 }
 207
 208 /* Test Steps for meshlink_sign Test Case # 3 - invalid case
 209
 210     Test Steps:
 211     1. Run NUT(Node Under Test)
 212     2. meshlink_sign API called by passing 0 as size of data to be signed
 213
 214     Expected Result:
 215     API returns false hinting the error.
 216 */
 217 static bool test_sign_04(void) {
 218         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 219
 220         // Create meshlink instance
 221
 222         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
 223         assert(mesh_handle);
 224         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 225         assert(meshlink_start(mesh_handle));
 226
 227         // Signing data
 228
 229         char *data = "Test";
 230         char sig[MESHLINK_SIGLEN];
 231         size_t ssize = MESHLINK_SIGLEN;
 232         bool ret = meshlink_sign(mesh_handle, data, 0, sig, &ssize);
 233
 234         // Clean up
 235
 236         meshlink_close(mesh_handle);
 237         assert(meshlink_destroy("signconf"));
 238
 239         if(!ret) {
 240                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing 0 as size of data arg\n");
 241                 return true;
 242         }
 243
 244         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing 0 as size of data arg\n");
 245         return false;
 246 }
 247
 248 /* Execute sign_data Test Case # 5 - Invalid case - meshlink_sign passing NULL as
 249       signature buffer argument*/
 250 static void test_case_sign_05(void **state) {
 251         execute_test(test_sign_05, state);
 252 }
 253
 254 /* Test Steps for meshlink_sign Test Case # 5 - invalid case
 255
 256     Test Steps:
 257     1. Run NUT(Node Under Test)
 258     2. meshlink_sign API called by passing NULL for signature buffer argument
 259
 260     Expected Result:
 261     API returns false hinting the error.
 262 */
 263 static bool test_sign_05(void) {
 264         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 265
 266         // Create meshlink instance
 267
 268         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
 269         assert(mesh_handle);
 270         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 271         assert(meshlink_start(mesh_handle));
 272
 273         // Signing data
 274
 275         char *data = "Test";
 276         size_t ssize = MESHLINK_SIGLEN;
 277         bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, NULL, &ssize);
 278
 279         // Clean up
 280
 281         meshlink_close(mesh_handle);
 282         assert(meshlink_destroy("signconf"));
 283
 284         if(!ret) {
 285                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as sign arg\n");
 286                 return true;
 287         }
 288
 289         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as sign arg\n");
 290         return false;
 291 }
 292
 293 /* Execute sign_data Test Case # 6 - Invalid case - meshlink_sign passing NULL for size of
 294       signature argument */
 295 static void test_case_sign_06(void **state) {
 296         execute_test(test_sign_06, state);
 297 }
 298
 299 /* Test Steps for meshlink_sign Test Case # 6 - invalid case
 300
 301     Test Steps:
 302     1. Run NUT(Node Under Test)
 303     2. meshlink_sign API called by passing NULL for size of signature buffer argument
 304
 305     Expected Result:
 306     API returns false hinting the error.
 307 */
 308 static bool test_sign_06(void) {
 309         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 310
 311         // Create meshlink instance
 312         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
 313         assert(mesh_handle);
 314         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 315         assert(meshlink_start(mesh_handle));
 316
 317         // Signing data
 318
 319         char *data = "Test";
 320         char sig[MESHLINK_SIGLEN];
 321         bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, NULL);
 322
 323         // Clean up
 324
 325         meshlink_close(mesh_handle);
 326         assert(meshlink_destroy("signconf"));
 327
 328         if(!ret) {
 329                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as signsize arg\n");
 330                 return true;
 331         }
 332
 333         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as signsize arg\n");
 334         return false;
 335 }
 336
 337 /* Execute sign_data Test Case # 7 - Invalid case - meshlink_sign passing size of signature < MESHLINK_SIGLEN*/
 338 static void test_case_sign_07(void **state) {
 339         execute_test(test_sign_07, state);
 340 }
 341
 342 /* Test Steps for meshlink_sign Test Case # 6 - invalid case
 343
 344     Test Steps:
 345     1. Run NUT(Node Under Test)
 346     2. meshlink_sign API called by passing size of signature < MESHLINK_SIGLEN
 347
 348     Expected Result:
 349     API returns false hinting the error.
 350 */
 351 static bool test_sign_07(void) {
 352         meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 353
 354         // Create meshlink instance
 355
 356         meshlink_handle_t *mesh_handle = meshlink_open("signconf", "nut", "node_sim", 1);
 357         assert(mesh_handle);
 358         meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
 359         assert(meshlink_start(mesh_handle));
 360
 361         // Signing data
 362
 363         char *data = "Test";
 364         char sig[MESHLINK_SIGLEN];
 365         size_t ssize = 5;  //5 < MESHLINK_SIGLEN
 366         bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
 367
 368         // Cleanup
 369
 370         meshlink_stop(mesh_handle);
 371         meshlink_close(mesh_handle);
 372         assert(meshlink_destroy("signconf"));
 373
 374         if(!ret) {
 375                 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing signsize < MESHLINK_SIGLEN arg\n");
 376                 return true;
 377         }
 378
 379         PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing signsize < MESHLINK_SIGLEN arg\n");
 380         return false;
 381 }
 382
 383
 384 int test_meshlink_sign(void) {
 385         const struct CMUnitTest blackbox_sign_tests[] = {
 386                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_01, NULL, NULL,
 387                                 (void *)&test_case_sign_01_state),
 388                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_02, NULL, NULL,
 389                                 (void *)&test_case_sign_02_state),
 390                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_03, NULL, NULL,
 391                                 (void *)&test_case_sign_03_state),
 392                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_04, NULL, NULL,
 393                                 (void *)&test_case_sign_04_state),
 394                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_05, NULL, NULL,
 395                                 (void *)&test_case_sign_05_state),
 396                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_06, NULL, NULL,
 397                                 (void *)&test_case_sign_06_state),
 398                 cmocka_unit_test_prestate_setup_teardown(test_case_sign_07, NULL, NULL,
 399                                 (void *)&test_case_sign_07_state)
 400         };
 401         total_tests += sizeof(blackbox_sign_tests) / sizeof(blackbox_sign_tests[0]);
 402
 403         return cmocka_run_group_tests(blackbox_sign_tests, NULL, NULL);
 404 }