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.
20 #include "execute_tests.h"
21 #include "test_cases_verify.h"
22 #include "../common/containers.h"
23 #include "../common/test_step.h"
24 #include "../common/common_handlers.h"
32 /* Modify this to change the logging level of Meshlink */
33 #define TEST_MESHLINK_LOG_LEVEL MESHLINK_DEBUG
35 static void test_case_verify_01(void **state);
36 static bool test_verify_01(void);
37 static void test_case_verify_02(void **state);
38 static bool test_verify_02(void);
39 static void test_case_verify_03(void **state);
40 static bool test_verify_03(void);
41 static void test_case_verify_04(void **state);
42 static bool test_verify_04(void);
43 static void test_case_verify_05(void **state);
44 static bool test_verify_05(void);
45 static void test_case_verify_06(void **state);
46 static bool test_verify_06(void);
48 /* State structure for verify API Test Case #1 */
49 static black_box_state_t test_case_verify_01_state = {
50 .test_case_name = "test_case_verify_01",
53 /* State structure for verify API Test Case #2 */
54 static black_box_state_t test_case_verify_02_state = {
55 .test_case_name = "test_case_verify_02",
58 /* State structure for verify API Test Case #3 */
59 static black_box_state_t test_case_verify_03_state = {
60 .test_case_name = "test_case_verify_03",
63 /* State structure for verify API Test Case #4 */
64 static black_box_state_t test_case_verify_04_state = {
65 .test_case_name = "test_case_verify_04",
68 /* State structure for verify API Test Case #5 */
69 static black_box_state_t test_case_verify_05_state = {
70 .test_case_name = "test_case_verify_05",
73 /* State structure for verify API Test Case #6 */
74 static black_box_state_t test_case_verify_06_state = {
75 .test_case_name = "test_case_verify_06",
80 /* Execute meshlink_verify Test Case # 1 - Valid case - verify a data successfully*/
81 void test_case_verify_01(void **state) {
82 execute_test(test_verify_01, state);
85 /* Test Steps for meshlink_sign Test Case # 1 - Valid case
88 1. Run NUT(Node Under Test)
89 2. Sign data with meshlink_sign
90 3. Verify data with the sign buffer used while signing
93 Verifies data successfully with the apt signature
95 bool test_verify_01(void) {
96 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
97 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
99 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
100 assert(meshlink_start(mesh_handle));
103 char sig[MESHLINK_SIGLEN];
104 size_t ssize = MESHLINK_SIGLEN;
105 bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
108 meshlink_node_t *source = meshlink_get_node(mesh_handle, "nut");
110 ret = meshlink_verify(mesh_handle, source, data, strlen(data) + 1, sig, ssize);
111 meshlink_close(mesh_handle);
112 meshlink_destroy("verifyconf");
115 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to verify data\n");
119 PRINT_TEST_CASE_MSG("meshlink_verify Successfully verified data\n");
124 /* Execute verify_data Test Case # 2 - Invalid case - meshlink_verify passing NULL args*/
125 void test_case_verify_02(void **state) {
126 execute_test(test_verify_02, state);
129 /* Test Steps for meshlink_sign Test Case # 2 - Invalid case
132 1. Run NUT(Node Under Test)
133 2. Sign data with meshlink_sign
134 3. Trying to pass NULL as mesh handle argument
135 and other arguments being valid
138 Reports error accordingly by returning false
140 bool test_verify_02(void) {
141 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
142 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
144 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
145 assert(meshlink_start(mesh_handle));
148 char sig[MESHLINK_SIGLEN];
149 size_t ssize = MESHLINK_SIGLEN;
150 bool sret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
153 meshlink_node_t *source = meshlink_get_node(mesh_handle, "nut");
154 assert(source != NULL);
155 bool ret = meshlink_verify(NULL, source, data, strlen(data) + 1, sig, ssize);
156 meshlink_close(mesh_handle);
157 meshlink_destroy("verifyconf");
160 PRINT_TEST_CASE_MSG("meshlink_sign Successfully reported error on passing NULL as mesh_handle arg\n");
164 PRINT_TEST_CASE_MSG("meshlink_sign FAILED to report error on passing NULL as mesh_handle arg\n");
169 /* Execute verify_data Test Case # 3 - Invalid case - meshlink_verify passing NULL args*/
170 void test_case_verify_03(void **state) {
171 execute_test(test_verify_03, state);
174 /* Test Steps for meshlink_sign Test Case # 3 - Invalid case
177 1. Run NUT(Node Under Test)
178 2. Sign data with meshlink_sign
179 3. Trying to pass NULL as source node handle argument
180 and other arguments being valid
183 Reports error accordingly by returning false
185 bool test_verify_03(void) {
186 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
187 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
189 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
190 assert(meshlink_start(mesh_handle));
193 char sig[MESHLINK_SIGLEN];
194 size_t ssize = MESHLINK_SIGLEN;
195 bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
197 ret = meshlink_verify(mesh_handle, NULL, data, strlen(data) + 1, sig, ssize);
198 meshlink_close(mesh_handle);
199 meshlink_destroy("verifyconf");
202 PRINT_TEST_CASE_MSG("meshlink_verify successfully reported NULL as node_handle arg\n");
206 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to report NULL as node_handle arg\n");
210 /* Execute verify_data Test Case # 4 - Invalid case - meshlink_verify passing NULL args*/
211 void test_case_verify_04(void **state) {
212 execute_test(test_verify_04, state);
215 /* Test Steps for meshlink_sign Test Case # 4 - Invalid case
218 1. Run NUT(Node Under Test)
219 2. Sign data with meshlink_sign
220 3. Trying to pass NULL as signed data argument
221 and other arguments being valid
224 Reports error accordingly by returning false
226 bool test_verify_04(void) {
227 meshlink_destroy("verifyconf");
228 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
229 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", DEV_CLASS_BACKBONE);
231 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
232 assert(meshlink_start(mesh_handle));
235 char sig[MESHLINK_SIGLEN];
236 size_t ssize = MESHLINK_SIGLEN;
237 bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
239 meshlink_node_t *source = meshlink_get_node(mesh_handle, "nut");
240 assert(source != NULL);
241 ret = meshlink_verify(mesh_handle, source, NULL, strlen(data) + 1, sig, ssize);
242 meshlink_stop(mesh_handle);
243 meshlink_close(mesh_handle);
244 meshlink_destroy("verifyconf");
247 PRINT_TEST_CASE_MSG("meshlink_verify successfully reported NULL as data arg\n");
251 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to report NULL as data arg\n");
256 /* Execute verify_data Test Case # 5 - Invalid case - meshlink_verify passing NULL args*/
257 void test_case_verify_05(void **state) {
258 execute_test(test_verify_05, state);
261 /* Test Steps for meshlink_sign Test Case # 5 - Invalid case
264 1. Run NUT(Node Under Test)
265 2. Sign data with meshlink_sign
266 3. Trying to pass NULL as signature buffer argument
267 and other arguments being valid
270 Reports error accordingly by returning false
272 bool test_verify_05(void) {
273 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
274 meshlink_handle_t *mesh_handle = meshlink_open("verifyconf", "nut", "node_sim", 1);
276 meshlink_set_log_cb(mesh_handle, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
277 assert(meshlink_start(mesh_handle));
280 char sig[MESHLINK_SIGLEN];
281 size_t ssize = MESHLINK_SIGLEN;
282 bool ret = meshlink_sign(mesh_handle, data, strlen(data) + 1, sig, &ssize);
284 meshlink_node_t *source = meshlink_get_node(mesh_handle, "nut");
285 assert(source != NULL);
287 ret = meshlink_verify(mesh_handle, source, data, strlen(data) + 1, NULL, ssize);
288 meshlink_stop(mesh_handle);
289 meshlink_close(mesh_handle);
290 meshlink_destroy("verifyconf");
293 PRINT_TEST_CASE_MSG("meshlink_verify successfully NULL as sign arg\n");
297 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to report NULL as sign arg\n");
301 /* Execute verify_data Test Case # 6 - Functionality test, when a wrong source node is mentioned to verify
303 void test_case_verify_06(void **state) {
304 execute_test(test_verify_06, state);
307 /* Test Steps for meshlink_verify Test Case # 6 - Functionality Test
310 1. Run NUT(Node Under Test) and peer
311 2. Sign using peer as source node.
312 3. Verify with NUT but passing NUT as source node rather than
313 'peer' as source node
316 API returns false when it detects the wrong source node
318 bool test_verify_06(void) {
319 /* deleting the confbase if already exists */
320 meshlink_destroy("verifyconf1");
321 meshlink_destroy("verifyconf2");
322 /* Set up logging for Meshlink */
323 meshlink_set_log_cb(NULL, TEST_MESHLINK_LOG_LEVEL, meshlink_callback_logger);
324 meshlink_handle_t *mesh1 = meshlink_open("verifyconf1", "nut", "chat", DEV_CLASS_STATIONARY);
326 meshlink_handle_t *mesh2 = meshlink_open("verifyconf2", "bar", "chat", DEV_CLASS_STATIONARY);
329 char *exp1 = meshlink_export(mesh1);
330 assert(exp1 != NULL);
331 char *exp2 = meshlink_export(mesh2);
332 assert(exp2 != NULL);
333 assert(meshlink_import(mesh1, exp2));
334 assert(meshlink_import(mesh2, exp1));
336 /* signing done by peer node */
338 char sig[MESHLINK_SIGLEN];
339 size_t ssize = MESHLINK_SIGLEN;
340 bool ret = meshlink_sign(mesh2, data, strlen(data) + 1, sig, &ssize);
343 meshlink_node_t *source_nut = meshlink_get_self(mesh1);
345 ret = meshlink_verify(mesh_handle, source_nut, data, strlen(data) + 1, sig, ssize);
346 meshlink_close(mesh1);
347 meshlink_close(mesh2);
348 meshlink_destroy("verifyconf1");
349 meshlink_destroy("verifyconf2");
352 PRINT_TEST_CASE_MSG("meshlink_verify successfully returned 'false' when a wrong source node used to verify the data\n");
356 PRINT_TEST_CASE_MSG("meshlink_verify FAILED to report error when a wrong source is mentioned\n");
361 int test_meshlink_verify(void) {
362 const struct CMUnitTest blackbox_verify_tests[] = {
363 cmocka_unit_test_prestate_setup_teardown(test_case_verify_01, NULL, NULL,
364 (void *)&test_case_verify_01_state),
365 cmocka_unit_test_prestate_setup_teardown(test_case_verify_02, NULL, NULL,
366 (void *)&test_case_verify_02_state),
367 cmocka_unit_test_prestate_setup_teardown(test_case_verify_03, NULL, NULL,
368 (void *)&test_case_verify_03_state),
369 cmocka_unit_test_prestate_setup_teardown(test_case_verify_04, NULL, NULL,
370 (void *)&test_case_verify_04_state),
371 cmocka_unit_test_prestate_setup_teardown(test_case_verify_05, NULL, NULL,
372 (void *)&test_case_verify_05_state),
373 cmocka_unit_test_prestate_setup_teardown(test_case_verify_06, NULL, NULL,
374 (void *)&test_case_verify_06_state)
377 total_tests += sizeof(blackbox_verify_tests) / sizeof(blackbox_verify_tests[0]);
379 return cmocka_run_group_tests(blackbox_verify_tests, NULL, NULL);