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