2 test_cases_verify.c -- Execution of specific meshlink black box test cases
3 Copyright (C) 2018 Guus Sliepen <guus@meshlink.io>
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.
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.
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.
24 #include "execute_tests.h"
25 #include "test_cases_verify.h"
26 #include "../common/containers.h"
27 #include "../common/test_step.h"
28 #include "../common/common_handlers.h"
36 /* Modify this to change the logging level of Meshlink */
37 #define TEST_MESHLINK_LOG_LEVEL MESHLINK_DEBUG
39 static void test_case_verify_01(void **state);
40 static bool test_verify_01(void);
41 static void test_case_verify_02(void **state);
42 static bool test_verify_02(void);
43 static void test_case_verify_03(void **state);
44 static bool test_verify_03(void);
45 static void test_case_verify_04(void **state);
46 static bool test_verify_04(void);
47 static void test_case_verify_05(void **state);
48 static bool test_verify_05(void);
49 static void test_case_verify_06(void **state);
50 static bool test_verify_06(void);
52 /* State structure for verify API Test Case #1 */
53 static black_box_state_t test_case_verify_01_state = {
54 .test_case_name = "test_case_verify_01",
57 /* State structure for verify API Test Case #2 */
58 static black_box_state_t test_case_verify_02_state = {
59 .test_case_name = "test_case_verify_02",
62 /* State structure for verify API Test Case #3 */
63 static black_box_state_t test_case_verify_03_state = {
64 .test_case_name = "test_case_verify_03",
67 /* State structure for verify API Test Case #4 */
68 static black_box_state_t test_case_verify_04_state = {
69 .test_case_name = "test_case_verify_04",
72 /* State structure for verify API Test Case #5 */
73 static black_box_state_t test_case_verify_05_state = {
74 .test_case_name = "test_case_verify_05",
77 /* State structure for verify API Test Case #6 */
78 static black_box_state_t test_case_verify_06_state = {
79 .test_case_name = "test_case_verify_06",
84 /* Execute meshlink_verify Test Case # 1 - Valid case - verify a data successfully*/
85 void test_case_verify_01(void **state) {
86 execute_test(test_verify_01, state);
89 /* Test Steps for meshlink_sign Test Case # 1 - Valid case
92 1. Run NUT(Node Under Test)
93 2. Sign data with meshlink_sign
94 3. Verify data with the sign buffer used while signing
97 Verifies data successfully with the apt signature
99 bool test_verify_01(void) {
100 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
101 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
103 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
104 assert(meshlink_start(mesh_handle));
107 char sig[MESHLINK_SIGLEN];
108 size_t ssize = MESHLINK_SIGLEN;
109 bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
112 meshlink_node_t *source = meshlink_get_node(mesh_handle, "nut");
114 ret = meshlink_verify(mesh_handle, source, data, strlen(data) + 1, sig, ssize);
115 meshlink_close(mesh_handle);
116 assert(meshlink_destroy("verifyconf"));
119 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to verify data\n");
123 PRINT_TEST_CASE_MSG("meshlink_verify Successfully verified data\n");
128 /* Execute verify_data Test Case # 2 - Invalid case - meshlink_verify passing NULL args*/
129 void test_case_verify_02(void **state) {
130 execute_test(test_verify_02, state);
133 /* Test Steps for meshlink_sign Test Case # 2 - Invalid case
136 1. Run NUT(Node Under Test)
137 2. Sign data with meshlink_sign
138 3. Trying to pass NULL as mesh handle argument
139 and other arguments being valid
142 Reports error accordingly by returning false
144 bool test_verify_02(void) {
145 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
146 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
148 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
149 assert(meshlink_start(mesh_handle));
152 char sig[MESHLINK_SIGLEN];
153 size_t ssize = MESHLINK_SIGLEN;
154 bool sret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
157 meshlink_node_t *source = meshlink_get_node(mesh_handle, "nut");
158 assert(source != NULL);
159 bool ret = meshlink_verify(NULL, source, data, strlen(data) + 1, sig, ssize);
160 meshlink_close(mesh_handle);
161 assert(meshlink_destroy("verifyconf"));
164 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as mesh_handle arg\n");
168 PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as mesh_handle arg\n");
173 /* Execute verify_data Test Case # 3 - Invalid case - meshlink_verify passing NULL args*/
174 void test_case_verify_03(void **state) {
175 execute_test(test_verify_03, state);
178 /* Test Steps for meshlink_sign Test Case # 3 - Invalid case
181 1. Run NUT(Node Under Test)
182 2. Sign data with meshlink_sign
183 3. Trying to pass NULL as source node handle argument
184 and other arguments being valid
187 Reports error accordingly by returning false
189 bool test_verify_03(void) {
190 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
191 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
193 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
194 assert(meshlink_start(mesh_handle));
197 char sig[MESHLINK_SIGLEN];
198 size_t ssize = MESHLINK_SIGLEN;
199 bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
201 ret = meshlink_verify(mesh_handle, NULL, data, strlen(data) + 1, sig, ssize);
202 meshlink_close(mesh_handle);
203 assert(meshlink_destroy("verifyconf"));
206 PRINT_TEST_CASE_MSG("meshlink_verify successfully reported NULL as node_handle arg\n");
210 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to report NULL as node_handle arg\n");
214 /* Execute verify_data Test Case # 4 - Invalid case - meshlink_verify passing NULL args*/
215 void test_case_verify_04(void **state) {
216 execute_test(test_verify_04, state);
219 /* Test Steps for meshlink_sign Test Case # 4 - Invalid case
222 1. Run NUT(Node Under Test)
223 2. Sign data with meshlink_sign
224 3. Trying to pass NULL as signed data argument
225 and other arguments being valid
228 Reports error accordingly by returning false
230 bool test_verify_04(void) {
231 assert(meshlink_destroy("verifyconf"));
232 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
233 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
235 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
236 assert(meshlink_start(mesh_handle));
239 char sig[MESHLINK_SIGLEN];
240 size_t ssize = MESHLINK_SIGLEN;
241 bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
243 meshlink_node_t *source = meshlink_get_node(mesh_handle, "nut");
244 assert(source != NULL);
245 ret = meshlink_verify(mesh_handle, source, NULL, strlen(data) + 1, sig, ssize);
246 meshlink_stop(mesh_handle);
247 meshlink_close(mesh_handle);
248 assert(meshlink_destroy("verifyconf"));
251 PRINT_TEST_CASE_MSG("meshlink_verify successfully reported NULL as data arg\n");
255 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to report NULL as data arg\n");
260 /* Execute verify_data Test Case # 5 - Invalid case - meshlink_verify passing NULL args*/
261 void test_case_verify_05(void **state) {
262 execute_test(test_verify_05, state);
265 /* Test Steps for meshlink_sign Test Case # 5 - Invalid case
268 1. Run NUT(Node Under Test)
269 2. Sign data with meshlink_sign
270 3. Trying to pass NULL as signature buffer argument
271 and other arguments being valid
274 Reports error accordingly by returning false
276 bool test_verify_05(void) {
277 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
278 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", 1);
280 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
281 assert(meshlink_start(mesh_handle));
284 char sig[MESHLINK_SIGLEN];
285 size_t ssize = MESHLINK_SIGLEN;
286 bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
288 meshlink_node_t *source = meshlink_get_node(mesh_handle, "nut");
289 assert(source != NULL);
291 ret = meshlink_verify(mesh_handle, source, data, strlen(data) + 1, NULL, ssize);
292 meshlink_stop(mesh_handle);
293 meshlink_close(mesh_handle);
294 assert(meshlink_destroy("verifyconf"));
297 PRINT_TEST_CASE_MSG("meshlink_verify successfully NULL as sign arg\n");
301 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to report NULL as sign arg\n");
305 /* Execute verify_data Test Case # 6 - Functionality test, when a wrong source node is mentioned to verify
307 void test_case_verify_06(void **state) {
308 execute_test(test_verify_06, state);
311 /* Test Steps for meshlink_verify Test Case # 6 - Functionality Test
314 1. Run NUT(Node Under Test) and peer
315 2. Sign using peer as source node.
316 3. Verify with NUT but passing NUT as source node rather than
317 'peer' as source node
320 API returns false when it detects the wrong source node
322 bool test_verify_06(void) {
323 /* deleting the confbase if already exists */
324 assert(meshlink_destroy("verifyconf1"));
325 assert(meshlink_destroy("verifyconf2"));
326 /* Set up logging for Meshlink */
327 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
328 meshlink_handle_t *mesh1 = meshlink_open("verifyconf1", "nut", "chat", DEV_CLASS_STATIONARY);
330 meshlink_handle_t *mesh2 = meshlink_open("verifyconf2", "bar", "chat", DEV_CLASS_STATIONARY);
333 char *exp1 = meshlink_export(mesh1);
334 assert(exp1 != NULL);
335 char *exp2 = meshlink_export(mesh2);
336 assert(exp2 != NULL);
337 assert(meshlink_import(mesh1, exp2));
338 assert(meshlink_import(mesh2, exp1));
340 /* signing done by peer node */
342 char sig[MESHLINK_SIGLEN];
343 size_t ssize = MESHLINK_SIGLEN;
344 bool ret = meshlink_sign(mesh2, data, strlen(data) + 1, sig, &ssize);
347 meshlink_node_t *source_nut = meshlink_get_self(mesh1);
349 ret = meshlink_verify(mesh_handle, source_nut, data, strlen(data) + 1, sig, ssize);
350 meshlink_close(mesh1);
351 meshlink_close(mesh2);
352 assert(meshlink_destroy("verifyconf1"));
353 assert(meshlink_destroy("verifyconf2"));
356 PRINT_TEST_CASE_MSG("meshlink_verify successfully returned 'false' when a wrong source node used to verify the data\n");
360 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to report error when a wrong source is mentioned\n");
365 int test_meshlink_verify(void) {
366 const struct CMUnitTest blackbox_verify_tests[] = {
367 cmocka_unit_test_prestate_setup_teardown(test_case_verify_01, NULL, NULL,
368 (void *)&test_case_verify_01_state),
369 cmocka_unit_test_prestate_setup_teardown(test_case_verify_02, NULL, NULL,
370 (void *)&test_case_verify_02_state),
371 cmocka_unit_test_prestate_setup_teardown(test_case_verify_03, NULL, NULL,
372 (void *)&test_case_verify_03_state),
373 cmocka_unit_test_prestate_setup_teardown(test_case_verify_04, NULL, NULL,
374 (void *)&test_case_verify_04_state),
375 cmocka_unit_test_prestate_setup_teardown(test_case_verify_05, NULL, NULL,
376 (void *)&test_case_verify_05_state),
377 cmocka_unit_test_prestate_setup_teardown(test_case_verify_06, NULL, NULL,
378 (void *)&test_case_verify_06_state)
381 total_tests += sizeof(blackbox_verify_tests) / sizeof(blackbox_verify_tests[0]);
383 return cmocka_run_group_tests(blackbox_verify_tests, NULL, NULL);