Branch data Line data Source code
1 : : /*
2 : : Copyright (c) 2022 Eriptic Technologies. See the COPYRIGHT
3 : : file at the top-level directory of this distribution.
4 : :
5 : : Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 : : http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 : : <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 : : option. This file may not be copied, modified, or distributed
9 : : except according to those terms.
10 : : */
11 : : #include <zephyr/kernel.h>
12 : : #include <zephyr/ztest.h>
13 : :
14 : : #include "common/unit_test.h"
15 : : #include "common/oscore_edhoc_error.h"
16 : : #include "common/print_util.h"
17 : : #include "common/byte_array.h"
18 : :
19 : : #include "oscore/oscore_coap.h"
20 : : #include "oscore/option.h"
21 : :
22 : : /* Use this function for debugging to print an array of options*/
23 : 6 : static void print_options(struct o_coap_option *opt, uint8_t opt_cnt)
24 : : {
25 : 6 : uint8_t i;
26 [ + + ]: 22 : for (i = 0; i < opt_cnt; i++) {
27 : 16 : PRINTF("option_number: %d\n", opt[i].option_number);
28 : 16 : PRINT_ARRAY("value", opt[i].value, opt[i].len);
29 : 16 : PRINTF("delta: %d\n\n", opt[i].delta);
30 : : }
31 : 6 : }
32 : :
33 : 6 : static void assert_options(struct o_coap_option *opt,
34 : : struct o_coap_option *opt_expected, uint8_t opt_cnt,
35 : : uint8_t opt_cnt_expected)
36 : : {
37 : 6 : zassert_equal(opt_cnt, opt_cnt_expected, "wrong option count");
38 : :
39 [ + + ]: 22 : for (uint8_t i = 0; i < opt_cnt; i++) {
40 : 16 : zassert_equal(opt[i].delta, opt_expected[i].delta,
41 : : "wrong delta");
42 : 16 : zassert_equal(opt[i].len, opt_expected[i].len, "wrong length");
43 : 16 : zassert_equal(opt[i].option_number,
44 : : opt_expected[i].option_number, "option_number");
45 : :
46 : 16 : zassert_mem_equal__(opt[i].value, opt_expected[i].value,
47 : : opt[i].len, "wrong value");
48 : : }
49 : 6 : }
50 : :
51 : : /**
52 : : * @brief Tests the function inner_outer_option_split without options
53 : : * with that require special processing.
54 : : */
55 : 1 : void t100_inner_outer_option_split__no_special_options(void)
56 : : {
57 : 1 : enum err r;
58 : :
59 : 1 : struct o_coap_header header = {
60 : : .ver = 1,
61 : : .type = TYPE_CON,
62 : : .TKL = 0,
63 : : .code = CODE_REQ_POST,
64 : : .MID = 0x0,
65 : : };
66 : :
67 : 1 : struct o_coap_packet coap_pkt = {
68 : : .header = header,
69 : : .token = NULL,
70 : : .options_cnt = 4,
71 : : .options = {
72 : : /*If-Match (opt num 1, E)*/
73 : : { .delta = 1,
74 : : .len = 0,
75 : : .value = NULL,
76 : : .option_number = IF_MATCH },
77 : : /*Etag (opt num 4, E)*/
78 : : { .delta = 3,
79 : : .len = 0,
80 : : .value = NULL,
81 : : .option_number = ETAG },
82 : : /*Content-Format (opt num 12, E)*/
83 : : { .delta = 8,
84 : : .len = 0,
85 : : .value = NULL,
86 : : .option_number = 12 } ,
87 : : /*Proxy-Uri (opt num 35, U)*/
88 : : { .delta = 23,
89 : : .len = 0,
90 : : .value = NULL,
91 : : .option_number = PROXY_URI }
92 : : },
93 : : .payload.len = 0,
94 : : .payload.ptr = NULL,
95 : : };
96 : :
97 : 1 : struct o_coap_option inner_options[5];
98 : 1 : struct o_coap_option outer_options[5];
99 : 1 : memset(inner_options, 0, sizeof(inner_options));
100 : 1 : memset(outer_options, 0, sizeof(outer_options));
101 : 1 : uint16_t inner_options_len = 0;
102 : 1 : uint8_t inner_options_cnt = 0;
103 : 1 : uint8_t outer_options_cnt = 0;
104 : 1 : uint8_t expected_inner_options_cnt;
105 : 1 : uint8_t expected_outer_options_cnt;
106 : :
107 : 1 : struct o_coap_option expected_inner_options[] = {
108 : : /*If-Match (opt num 1, E)*/
109 : : { .delta = 1,
110 : : .len = 0,
111 : : .value = NULL,
112 : : .option_number = IF_MATCH },
113 : : /*Etag (opt num 4, E)*/
114 : : { .delta = 3, .len = 0, .value = NULL, .option_number = ETAG },
115 : : /*Content-Format (opt num 12, E)*/
116 : : { .delta = 8,
117 : : .len = 0,
118 : : .value = NULL,
119 : : .option_number = CONTENT_FORMAT }
120 : :
121 : : };
122 : 1 : expected_inner_options_cnt = sizeof(expected_inner_options) /
123 : : sizeof(expected_inner_options[0]);
124 : :
125 : 1 : struct o_coap_option expected_outer_options[] = {
126 : : /*Proxy-Uri (opt num 35, U)*/
127 : : { .delta = 35,
128 : : .len = 0,
129 : : .value = NULL,
130 : : .option_number = PROXY_URI }
131 : : };
132 : 1 : expected_outer_options_cnt = sizeof(expected_outer_options) /
133 : : sizeof(expected_outer_options[0]);
134 : :
135 : 1 : r = inner_outer_option_split(&coap_pkt, inner_options,
136 : : &inner_options_cnt, &inner_options_len,
137 : : outer_options, &outer_options_cnt);
138 : :
139 : 1 : PRINT_MSG("\ninner options\n");
140 : 1 : print_options(inner_options, inner_options_cnt);
141 : 1 : PRINT_MSG("\nouter options\n");
142 : 1 : print_options(outer_options, outer_options_cnt);
143 : :
144 : 1 : zassert_equal(r, ok, "Error in inner_outer_option_split. r: %d", r);
145 : :
146 : 1 : assert_options(inner_options, expected_inner_options, inner_options_cnt,
147 : : expected_inner_options_cnt);
148 : :
149 : 1 : assert_options(outer_options, expected_outer_options, outer_options_cnt,
150 : : expected_outer_options_cnt);
151 : 1 : }
152 : :
153 : : /**
154 : : * @brief Tests the function inner_outer_option_split with Observe option
155 : : * indicating a notification. This function tests the behavior of
156 : : * the server preparing a response
157 : : */
158 : 1 : void t101_inner_outer_option_split__with_observe_notification(void)
159 : : {
160 : 1 : enum err r;
161 : :
162 : 1 : struct o_coap_header header = {
163 : : .ver = 1,
164 : : .type = TYPE_ACK,
165 : : .TKL = 0,
166 : : .code = CODE_RESP_CONTENT,
167 : : .MID = 0x0,
168 : : };
169 : :
170 : : /*The Observe option value is a sequence number in notifications*/
171 : 1 : uint8_t observe_val[] = { 0x12 };
172 : :
173 : 1 : struct o_coap_packet coap_pkt = {
174 : : .header = header,
175 : : .token = NULL,
176 : : .options_cnt = 5,
177 : : .options = {
178 : : /*If-Match (opt num 1, E)*/
179 : : { .delta = 1,
180 : : .len = 0,
181 : : .value = NULL,
182 : : .option_number = IF_MATCH },
183 : : /*Etag (opt num 4, E)*/
184 : : { .delta = 3,
185 : : .len = 0,
186 : : .value = NULL,
187 : : .option_number = ETAG },
188 : : /*Observe (opt num 6, EU)*/
189 : : { .delta = 2,
190 : : .len = sizeof(observe_val),
191 : : .value = observe_val,
192 : : .option_number = OBSERVE },
193 : : /*Content-Format (opt num 12, E)*/
194 : : { .delta = 6,
195 : : .len = 0,
196 : : .value = NULL,
197 : : .option_number = CONTENT_FORMAT } ,
198 : : /*Proxy-Uri (opt num 35, U)*/
199 : : { .delta = 23,
200 : : .len = 0,
201 : : .value = NULL,
202 : : .option_number = PROXY_URI }
203 : : },
204 : : .payload.len = 0,
205 : : .payload.ptr = NULL,
206 : : };
207 : :
208 : 1 : struct o_coap_option inner_options[5];
209 : 1 : struct o_coap_option outer_options[5];
210 : 1 : memset(inner_options, 0, sizeof(inner_options));
211 : 1 : memset(outer_options, 0, sizeof(outer_options));
212 : 1 : uint16_t inner_options_len = 0;
213 : 1 : uint8_t inner_options_cnt = 0;
214 : 1 : uint8_t outer_options_cnt = 0;
215 : :
216 : 1 : struct o_coap_option expected_inner_options[] = {
217 : : /*If-Match (opt num 1, E)*/
218 : : { .delta = 1,
219 : : .len = 0,
220 : : .value = NULL,
221 : : .option_number = IF_MATCH },
222 : : /*Etag (opt num 4, E)*/
223 : : { .delta = 3, .len = 0, .value = NULL, .option_number = ETAG },
224 : : /*Observe(opt num 6): The inner observe option shall have
225 : : no value, see 4.1.3.5.2 in RFC8613*/
226 : : { .delta = 2,
227 : : .len = 0,
228 : : .value = NULL,
229 : : .option_number = OBSERVE },
230 : : /*Content-Format (opt num 12, E)*/
231 : : { .delta = 6,
232 : : .len = 0,
233 : : .value = NULL,
234 : : .option_number = CONTENT_FORMAT }
235 : :
236 : : };
237 : 1 : uint8_t expected_inner_options_cnt =
238 : : sizeof(expected_inner_options) / sizeof(struct o_coap_option);
239 : :
240 : 1 : struct o_coap_option expected_outer_options[2];
241 : 1 : memset(expected_outer_options, 0, sizeof(expected_outer_options));
242 : : /*Observe(opt num 6): The outer observe option may have
243 : : a value as in the original coap packet, see 4.1.3.5.2 in RFC8613*/
244 : 1 : expected_outer_options[0].delta = 6;
245 : 1 : expected_outer_options[0].len = sizeof(observe_val);
246 : 1 : expected_outer_options[0].value = observe_val;
247 : 1 : expected_outer_options[0].option_number = OBSERVE;
248 : :
249 : : /*Proxy-Uri (opt num 35, U)*/
250 : 1 : expected_outer_options[1].delta = 29;
251 : 1 : expected_outer_options[1].len = 0;
252 : 1 : expected_outer_options[1].value = NULL;
253 : 1 : expected_outer_options[1].option_number = PROXY_URI;
254 : :
255 : 1 : uint8_t expected_outer_options_cnt =
256 : : sizeof(expected_outer_options) / sizeof(struct o_coap_option);
257 : :
258 : 1 : r = inner_outer_option_split(&coap_pkt, inner_options,
259 : : &inner_options_cnt, &inner_options_len,
260 : : outer_options, &outer_options_cnt);
261 : :
262 : 1 : PRINT_MSG("\ninner options\n");
263 : 1 : print_options(inner_options, inner_options_cnt);
264 : 1 : PRINT_MSG("\nouter options\n");
265 : 1 : print_options(outer_options, outer_options_cnt);
266 : :
267 : 1 : zassert_equal(r, ok, "Error in inner_outer_option_split. r: %d", r);
268 : :
269 : 1 : assert_options(inner_options, expected_inner_options, inner_options_cnt,
270 : : expected_inner_options_cnt);
271 : :
272 : 1 : assert_options(outer_options, expected_outer_options, outer_options_cnt,
273 : : expected_outer_options_cnt);
274 : 1 : }
275 : :
276 : : /**
277 : : * @brief Tests the function inner_outer_option_split with Observe option
278 : : * indicating a registration. This function tests the behavior of
279 : : * the client preparing a request
280 : : */
281 : 1 : void t102_inner_outer_option_split__with_observe_registration(void)
282 : : {
283 : 1 : enum err r;
284 : :
285 : 1 : struct o_coap_header header = {
286 : : .ver = 1,
287 : : .type = TYPE_CON,
288 : : .TKL = 0,
289 : : .code = CODE_REQ_POST,
290 : : .MID = 0x0,
291 : : };
292 : :
293 : : /*The Observe option value is 0x00 when indicating a registration*/
294 : 1 : uint8_t observe_val[] = { 0x00 };
295 : :
296 : 1 : struct o_coap_packet coap_pkt = {
297 : : .header = header,
298 : : .token = NULL,
299 : : .options_cnt = 5,
300 : : .options = {
301 : : /*If-Match (opt num 1, E)*/
302 : : { .delta = 1,
303 : : .len = 0,
304 : : .value = NULL,
305 : : .option_number = IF_MATCH },
306 : : /*Etag (opt num 4, E)*/
307 : : { .delta = 3,
308 : : .len = 0,
309 : : .value = NULL,
310 : : .option_number = ETAG },
311 : : /*Observe (opt num 6, EU)*/
312 : : { .delta = 2,
313 : : .len = sizeof(observe_val),
314 : : .value = observe_val,
315 : : .option_number = OBSERVE},
316 : : /*Content-Format (opt num 12, E)*/
317 : : { .delta = 6,
318 : : .len = 0,
319 : : .value = NULL,
320 : : .option_number = CONTENT_FORMAT } ,
321 : : /*Proxy-Uri (opt num 35, U)*/
322 : : { .delta = 23,
323 : : .len = 0,
324 : : .value = NULL,
325 : : .option_number = PROXY_URI }
326 : : },
327 : : .payload.len = 0,
328 : : .payload.ptr = NULL,
329 : : };
330 : :
331 : 1 : struct o_coap_option inner_options[5];
332 : 1 : struct o_coap_option outer_options[5];
333 : 1 : memset(inner_options, 0, sizeof(inner_options));
334 : 1 : memset(outer_options, 0, sizeof(outer_options));
335 : 1 : uint16_t inner_options_len = 0;
336 : 1 : uint8_t inner_options_cnt = 0;
337 : 1 : uint8_t outer_options_cnt = 0;
338 : :
339 : 1 : struct o_coap_option expected_inner_options[4];
340 : 1 : memset(expected_inner_options, 0, sizeof(expected_inner_options));
341 : :
342 : : /*If-Match (opt num 1, E)*/
343 : 1 : expected_inner_options[0].delta = 1;
344 : 1 : expected_inner_options[0].len = 0;
345 : 1 : expected_inner_options[0].value = NULL;
346 : 1 : expected_inner_options[0].option_number = IF_MATCH;
347 : : /*Etag (opt num 4, E)*/
348 : 1 : expected_inner_options[1].delta = 3;
349 : 1 : expected_inner_options[1].len = 0;
350 : 1 : expected_inner_options[1].value = NULL;
351 : 1 : expected_inner_options[1].option_number = ETAG;
352 : : /*Observe(opt num 6): The inner observe option shall have
353 : : the value contained in the original coap packet, see 4.1.3.5.1 in RFC8613*/
354 : 1 : expected_inner_options[2].delta = 2;
355 : 1 : expected_inner_options[2].len = sizeof(observe_val);
356 : 1 : expected_inner_options[2].value = observe_val;
357 : 1 : expected_inner_options[2].option_number = OBSERVE;
358 : : /*Content-Format (opt num 12, E)*/
359 : 1 : expected_inner_options[3].delta = 6;
360 : 1 : expected_inner_options[3].len = 0;
361 : 1 : expected_inner_options[3].value = NULL;
362 : 1 : expected_inner_options[3].option_number = CONTENT_FORMAT;
363 : :
364 : 1 : struct o_coap_option expected_outer_options[2];
365 : 1 : memset(expected_outer_options, 0, sizeof(expected_outer_options));
366 : :
367 : : /*Observe(opt num 6): The outer observe option must have
368 : : a value as in the original coap packet, see 4.1.3.5.1 in RFC8613*/
369 : 1 : expected_outer_options[0].delta = 6;
370 : 1 : expected_outer_options[0].len = sizeof(observe_val);
371 : 1 : expected_outer_options[0].value = observe_val;
372 : 1 : expected_outer_options[0].option_number = OBSERVE;
373 : :
374 : : /*Proxy-Uri (opt num 35, U)*/
375 : 1 : expected_outer_options[1].delta = 29;
376 : 1 : expected_outer_options[1].len = 0;
377 : 1 : expected_outer_options[1].value = NULL;
378 : 1 : expected_outer_options[1].option_number = PROXY_URI;
379 : :
380 : 1 : r = inner_outer_option_split(&coap_pkt, inner_options,
381 : : &inner_options_cnt, &inner_options_len,
382 : : outer_options, &outer_options_cnt);
383 : 1 : zassert_equal(r, ok, "Error in inner_outer_option_split. r: %d", r);
384 : :
385 : 1 : PRINT_MSG("\ninner options\n");
386 : 1 : print_options(inner_options, inner_options_cnt);
387 : 1 : PRINT_MSG("\nouter options\n");
388 : 1 : print_options(outer_options, outer_options_cnt);
389 : :
390 : 1 : uint8_t expected_inner_options_cnt =
391 : : sizeof(expected_inner_options) / sizeof(struct o_coap_option);
392 : 1 : uint8_t expected_outer_options_cnt =
393 : : sizeof(expected_outer_options) / sizeof(struct o_coap_option);
394 : 1 : assert_options(inner_options, expected_inner_options, inner_options_cnt,
395 : : expected_inner_options_cnt);
396 : :
397 : 1 : assert_options(outer_options, expected_outer_options, outer_options_cnt,
398 : : expected_outer_options_cnt);
399 : 1 : }
400 : :
401 : : /**
402 : : * @brief Tests oscore_pkg_generate with an observe option.
403 : : * The observe option indicates registration, which is a
404 : : * request message.
405 : : *
406 : : */
407 : 1 : void t103_oscore_pkg_generate__request_with_observe_registration(void)
408 : : {
409 : 1 : enum err r;
410 : :
411 : 1 : struct o_coap_header header = {
412 : : .ver = 1,
413 : : .type = TYPE_CON,
414 : : .TKL = 0,
415 : : .code = CODE_REQ_POST,
416 : : .MID = 0x0,
417 : : };
418 : :
419 : : /*The Observe option value is 0x00 when indicating a registration*/
420 : 1 : uint8_t observe_val[] = { 0x00 };
421 : :
422 : 1 : struct o_coap_packet coap_pkt = {
423 : : .header = header,
424 : : .token = NULL,
425 : : .options_cnt = 5,
426 : : .options = {
427 : : /*If-Match (opt num 1, E)*/
428 : : { .delta = 1,
429 : : .len = 0,
430 : : .value = NULL,
431 : : .option_number = IF_MATCH },
432 : : /*Etag (opt num 4, E)*/
433 : : { .delta = 3,
434 : : .len = 0,
435 : : .value = NULL,
436 : : .option_number = ETAG },
437 : : /*Observe (opt num 6, EU)*/
438 : : { .delta = 2,
439 : : .len = sizeof(observe_val),
440 : : .value = observe_val,
441 : : .option_number = OBSERVE },
442 : : /*Content-Format (opt num 12, E)*/
443 : : { .delta = 6,
444 : : .len = 0,
445 : : .value = NULL,
446 : : .option_number = CONTENT_FORMAT } ,
447 : : /*Proxy-Uri (opt num 35, U)*/
448 : : { .delta = 23,
449 : : .len = 0,
450 : : .value = NULL,
451 : : .option_number = PROXY_URI }
452 : : },
453 : : .payload.len = 0,
454 : : .payload.ptr = NULL,
455 : : };
456 : :
457 : 1 : struct o_coap_option u_options[] = {
458 : : /*Observe(opt num 6): The outer observe option must have
459 : : a value as in the original coap packet, see 4.1.3.5.1 in RFC8613*/
460 : : { .delta = 6,
461 : : .len = sizeof(observe_val),
462 : : .value = observe_val,
463 : : .option_number = OBSERVE },
464 : : /*Proxy-Uri (opt num 35, U)*/
465 : : { .delta = 29,
466 : : .len = 0,
467 : : .value = NULL,
468 : : .option_number = PROXY_URI }
469 : : };
470 : :
471 : 1 : struct oscore_option oscore_option = {
472 : : .delta = 0, .len = 0, .value = NULL, .option_number = OSCORE
473 : : };
474 : :
475 : 1 : struct o_coap_packet oscore_pkt;
476 : 1 : memset(&oscore_pkt, 0, sizeof(oscore_pkt));
477 : :
478 : 1 : struct o_coap_header expected_oscore_header = {
479 : : .ver = 1,
480 : : .type = TYPE_CON,
481 : : .TKL = 0,
482 : : .code = CODE_REQ_FETCH,
483 : : .MID = 0x0,
484 : : };
485 : 1 : struct o_coap_packet expected_oscore_pkt = {
486 : : .header = expected_oscore_header,
487 : : .token = NULL,
488 : : .options_cnt = 3,
489 : : .options = { { .delta = 6,
490 : : .len = sizeof(observe_val),
491 : : .value = observe_val,
492 : : .option_number = OBSERVE },
493 : : { .delta = 3,
494 : : .len = 0,
495 : : .value = NULL,
496 : : .option_number = OSCORE },
497 : : { .delta = 26,
498 : : .len = 0,
499 : : .value = NULL,
500 : : .option_number = PROXY_URI } },
501 : : .payload.len = 0,
502 : : .payload.ptr = NULL,
503 : : };
504 : :
505 : 1 : struct byte_array no_ciphertext = { .ptr = NULL, .len = 0 };
506 : 1 : r = oscore_pkg_generate(&coap_pkt, &oscore_pkt, u_options, 2,
507 : : &no_ciphertext, &oscore_option);
508 : :
509 : 1 : zassert_equal(r, ok, "Error in oscore_pkg_generate. r: %d", r);
510 : :
511 : : // PRINTF("coap_pkt code: %02X\n", coap_pkt.header.code);
512 : : // PRINTF("oscore_pkt code: %02X\n", oscore_pkt.header.code);
513 : :
514 : : // PRINT_ARRAY("oscore_pkt", &oscore_pkt, sizeof(oscore_pkt));
515 : : // PRINT_ARRAY("oscore_pkt options", &oscore_pkt.options,
516 : : // sizeof(oscore_pkt.options));
517 : : // PRINT_ARRAY("expected_oscore_pkt", &expected_oscore_pkt,
518 : : // sizeof(expected_oscore_pkt));
519 : : // PRINT_ARRAY("expected_oscore_pkt options", &expected_oscore_pkt.options,
520 : : // sizeof(expected_oscore_pkt.options));
521 : :
522 : 1 : zassert_mem_equal__(&oscore_pkt, &expected_oscore_pkt,
523 : : sizeof(oscore_pkt), "oscore_pkt incorrect");
524 : 1 : }
525 : :
526 : : /**
527 : : * @brief Tests oscore_pkg_generate with an observe option.
528 : : * The observe option indicates notification.
529 : : * The message is a response.
530 : : *
531 : : */
532 : 1 : void t104_oscore_pkg_generate__request_with_observe_notification(void)
533 : : {
534 : 1 : enum err r;
535 : :
536 : 1 : struct o_coap_header header = {
537 : : .ver = 1,
538 : : .type = TYPE_ACK,
539 : : .TKL = 0,
540 : : .code = CODE_RESP_CONTENT,
541 : : .MID = 0x0,
542 : : };
543 : :
544 : : /*The Observe option value is 0x00 when indicating a registration*/
545 : 1 : uint8_t observe_val[] = { 0xde, 0xad, 0xbe, 0xaf };
546 : :
547 : 1 : struct o_coap_packet coap_pkt = {
548 : : .header = header,
549 : : .token = NULL,
550 : : .options_cnt = 1,
551 : : .options = {
552 : : /*Observe (opt num 6, EU)*/
553 : : { .delta = 6,
554 : : .len = sizeof(observe_val),
555 : : .value = observe_val,
556 : : .option_number = OBSERVE },
557 : : },
558 : : .payload.len = 0,
559 : : .payload.ptr = NULL,
560 : : };
561 : :
562 : 1 : struct o_coap_option u_options[] = {
563 : : /*Observe(opt num 6): The outer observe option may have
564 : : a value as in the original coap packet, see 4.1.3.5.1 in RFC8613*/
565 : : { .delta = 6,
566 : : .len = sizeof(observe_val),
567 : : .value = observe_val,
568 : : .option_number = OBSERVE }
569 : : };
570 : 1 : uint8_t u_options_len =
571 : : sizeof(u_options) / sizeof(struct o_coap_option);
572 : :
573 : 1 : struct oscore_option oscore_option = {
574 : : .delta = 0, .len = 0, .value = NULL, .option_number = OSCORE
575 : : };
576 : :
577 : 1 : struct o_coap_packet oscore_pkt;
578 : 1 : memset(&oscore_pkt, 0, sizeof(oscore_pkt));
579 : :
580 : 1 : struct o_coap_header expected_oscore_header = {
581 : : .ver = 1,
582 : : .type = TYPE_ACK,
583 : : .TKL = 0,
584 : : .code = CODE_RESP_CONTENT,
585 : : .MID = 0x0,
586 : : };
587 : 1 : struct o_coap_packet expected_oscore_pkt = {
588 : : .header = expected_oscore_header,
589 : : .token = NULL,
590 : : .options_cnt = 2,
591 : : .options = { { .delta = 6,
592 : : .len = sizeof(observe_val),
593 : : .value = observe_val,
594 : : .option_number = OBSERVE },
595 : : { .delta = 3,
596 : : .len = 0,
597 : : .value = NULL,
598 : : .option_number = OSCORE } },
599 : : .payload.len = 0,
600 : : .payload.ptr = NULL,
601 : : };
602 : 1 : struct byte_array no_ciphertext = { .ptr = NULL, .len = 0 };
603 : 1 : r = oscore_pkg_generate(&coap_pkt, &oscore_pkt, u_options,
604 : : u_options_len, &no_ciphertext, &oscore_option);
605 : :
606 : 1 : zassert_equal(r, ok, "Error in oscore_pkg_generate. r: %d", r);
607 : :
608 : : // PRINTF("coap_pkt code: %02X\n", coap_pkt.header.code);
609 : : // PRINTF("oscore_pkt code: %02X\n", oscore_pkt.header.code);
610 : :
611 : : // PRINT_ARRAY("oscore_pkt", &oscore_pkt, sizeof(oscore_pkt));
612 : : // PRINT_ARRAY("oscore_pkt options", &oscore_pkt.options,
613 : : // sizeof(oscore_pkt.options));
614 : : // PRINT_ARRAY("expected_oscore_pkt", &expected_oscore_pkt,
615 : : // sizeof(expected_oscore_pkt));
616 : : // PRINT_ARRAY("expected_oscore_pkt options", &expected_oscore_pkt.options,
617 : : // sizeof(expected_oscore_pkt.options));
618 : :
619 : 1 : zassert_mem_equal__(&oscore_pkt, &expected_oscore_pkt,
620 : : sizeof(oscore_pkt), "oscore_pkt incorrect");
621 : 1 : }
622 : :
623 : : /**
624 : : * @brief Tests the function inner_outer_option_split with too many options
625 : : */
626 : 1 : void t105_inner_outer_option_split__too_many_options(void)
627 : : {
628 : 1 : enum err r;
629 : :
630 : 1 : struct o_coap_header header = {
631 : : .ver = 1,
632 : : .type = TYPE_CON,
633 : : .TKL = 0,
634 : : .code = CODE_REQ_POST,
635 : : .MID = 0x0,
636 : : };
637 : :
638 : 1 : struct o_coap_packet coap_pkt = {
639 : : .header = header,
640 : : .token = NULL,
641 : : .options_cnt = 21,
642 : : .payload.len = 0,
643 : : .payload.ptr = NULL,
644 : : };
645 : :
646 : 1 : struct o_coap_option inner_options[5];
647 : 1 : struct o_coap_option outer_options[5];
648 : 1 : memset(inner_options, 0, sizeof(inner_options));
649 : 1 : memset(outer_options, 0, sizeof(outer_options));
650 : 1 : uint16_t inner_options_len = 0;
651 : 1 : uint8_t inner_options_cnt = 0;
652 : 1 : uint8_t outer_options_cnt = 0;
653 : :
654 : 1 : r = inner_outer_option_split(&coap_pkt, inner_options,
655 : : &inner_options_cnt, &inner_options_len,
656 : : outer_options, &outer_options_cnt);
657 : 1 : zassert_equal(r, too_many_options,
658 : : "Error in inner_outer_option_split. r: %d", r);
659 : 1 : }
660 : :
661 : : /**
662 : : * @brief create an OSCORE option without a PIV
663 : : */
664 : 1 : void t106_oscore_option_generate_no_piv(void)
665 : : {
666 : 1 : struct oscore_option oscore_option;
667 : :
668 : 1 : uint8_t val[] = { 0b11000, 1, 1, 1 };
669 : 1 : struct oscore_option expected = {
670 : : .delta = OSCORE,
671 : : .len = sizeof(val),
672 : : .value = val,
673 : : .option_number = OSCORE,
674 : : };
675 : :
676 : 1 : uint8_t kid_buf[] = { 1 };
677 : 1 : uint8_t kid_context_buf[] = { 1 };
678 : :
679 : 1 : struct byte_array piv = BYTE_ARRAY_INIT(NULL, 0);
680 : 1 : struct byte_array kid = BYTE_ARRAY_INIT(kid_buf, sizeof(kid_buf));
681 : 1 : struct byte_array kid_context =
682 : : BYTE_ARRAY_INIT(kid_context_buf, sizeof(kid_context_buf));
683 : :
684 : 1 : enum err r = oscore_option_generate(&piv, &kid, &kid_context,
685 : : &oscore_option);
686 : :
687 : 1 : zassert_equal(r, ok, "Error in oscore_option_generate. r: %d", r);
688 : 1 : zassert_equal(oscore_option.len, expected.len,
689 : : "wrong oscore option len");
690 : 1 : zassert_equal(oscore_option.option_number, expected.option_number,
691 : : "wrong oscore option_number");
692 : 1 : zassert_mem_equal__(oscore_option.value, expected.value,
693 : : oscore_option.len, "wrong oscore option value");
694 : 1 : ;
695 : 1 : }
|
