4 * @brief Tests to test the Generator class generator_t
9 * Copyright (C) 2005 Jan Hutter, Martin Willi
10 * Hochschule fuer Technik Rapperswil
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
19 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
25 #include "generator_test.h"
28 #include <encoding/generator.h>
29 #include <utils/allocator.h>
30 #include <utils/logger_manager.h>
31 #include <utils/logger.h>
32 #include <encoding/payloads/encodings.h>
33 #include <encoding/payloads/ike_header.h>
34 #include <encoding/payloads/transform_attribute.h>
35 #include <encoding/payloads/transform_substructure.h>
36 #include <encoding/payloads/proposal_substructure.h>
37 #include <encoding/payloads/sa_payload.h>
38 #include <encoding/payloads/ke_payload.h>
39 #include <encoding/payloads/notify_payload.h>
40 #include <encoding/payloads/nonce_payload.h>
45 void test_generator_with_header_payload(tester_t
*tester
)
47 generator_t
*generator
;
48 ike_header_t
*header_data
;
49 chunk_t generated_data
;
52 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"header payload");
54 header_data
= ike_header_create();
55 header_data
->set_initiator_spi(header_data
,1);
56 header_data
->set_responder_spi(header_data
,2);
57 ((payload_t
*) header_data
)->set_next_type((payload_t
*) header_data
, 3);
58 header_data
->set_exchange_type(header_data
, 6);
59 header_data
->set_initiator_flag(header_data
, TRUE
);
60 header_data
->set_response_flag(header_data
, TRUE
);
61 header_data
->set_message_id(header_data
,7);
63 generator
= generator_create();
64 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
66 generator
->generate_payload(generator
,(payload_t
*) header_data
);
68 generator
->write_to_chunk(generator
,&generated_data
);
70 u_int8_t expected_generation
[] = {
80 logger
->log_bytes(logger
,RAW
,"expected header",expected_generation
,sizeof(expected_generation
));
81 tester
->assert_true(tester
,(generated_data
.len
== sizeof(expected_generation
)), "compare generated data length");
82 logger
->log_chunk(logger
,RAW
,"generated header",&generated_data
);
83 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data 1");
84 allocator_free_chunk(&generated_data
);
86 generator
->destroy(generator
);
88 header_data
->set_initiator_spi(header_data
,0x22000054231234LL
);
89 header_data
->set_responder_spi(header_data
,0x122398);
90 ((payload_t
*) header_data
)->set_next_type((payload_t
*) header_data
,0xF3);
91 header_data
->set_exchange_type(header_data
, 0x12);
92 header_data
->set_initiator_flag(header_data
, TRUE
);
93 header_data
->set_response_flag(header_data
, TRUE
);
94 header_data
->set_message_id(header_data
,0x33AFF3);
96 generator
= generator_create();
97 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
99 generator
->generate_payload(generator
,(payload_t
*)header_data
);
101 generator
->write_to_chunk(generator
,&generated_data
);
103 u_int8_t expected_generation2
[] = {
114 logger
->log_bytes(logger
,RAW
,"expected header",expected_generation2
,sizeof(expected_generation2
));
116 logger
->log_chunk(logger
,RAW
,"generated header",&generated_data
);
118 tester
->assert_true(tester
,(memcmp(expected_generation2
,generated_data
.ptr
,sizeof(expected_generation2
)) == 0), "compare generated data 2");
119 allocator_free_chunk(&generated_data
);
121 header_data
->destroy(header_data
);
123 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
124 generator
->destroy(generator
);
128 * Described in header
130 void test_generator_with_transform_attribute(tester_t
*tester
)
132 generator_t
*generator
;
133 transform_attribute_t
*attribute
;
134 chunk_t generated_data
;
137 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"transform_attribute payload");
140 /* test empty attribute */
141 generator
= generator_create();
142 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
143 attribute
= transform_attribute_create();
144 generator
->generate_payload(generator
,(payload_t
*)attribute
);
145 generator
->write_to_chunk(generator
,&generated_data
);
146 logger
->log_chunk(logger
,RAW
,"generated attribute",&generated_data
);
148 u_int8_t expected_generation
[] = {
151 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
152 allocator_free_chunk(&generated_data
);
153 attribute
->destroy(attribute
);
154 generator
->destroy(generator
);
156 /* test attribute with 2 byte data */
157 generator
= generator_create();
158 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
160 attribute
= transform_attribute_create();
161 u_int16_t dataval
= 5768;
163 data
.ptr
= (void *) &dataval
;
166 attribute
->set_value_chunk(attribute
,data
);
168 generator
->generate_payload(generator
,(payload_t
*)attribute
);
169 generator
->write_to_chunk(generator
,&generated_data
);
170 logger
->log_chunk(logger
,RAW
,"generated attribute",&generated_data
);
172 u_int8_t expected_generation2
[] = {
175 tester
->assert_true(tester
,(memcmp(expected_generation2
,generated_data
.ptr
,sizeof(expected_generation2
)) == 0), "compare generated data");
177 allocator_free_chunk(&generated_data
);
178 attribute
->destroy(attribute
);
179 generator
->destroy(generator
);
183 /* test attribute with 25 byte data */
184 generator
= generator_create();
185 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
187 attribute
= transform_attribute_create();
188 char *stringval
= "ddddddddddeeeeeeeeeefffff";
189 data
.ptr
= (void *) stringval
;
192 attribute
->set_value_chunk(attribute
,data
);
194 attribute
->set_attribute_type(attribute
,456);
197 generator
->generate_payload(generator
,(payload_t
*)attribute
);
198 generator
->write_to_chunk(generator
,&generated_data
);
199 logger
->log_chunk(logger
,RAW
,"generated attribute",&generated_data
);
201 u_int8_t expected_generation3
[] = {
211 tester
->assert_true(tester
,(memcmp(expected_generation3
,generated_data
.ptr
,sizeof(expected_generation3
)) == 0), "compare generated data");
213 allocator_free_chunk(&generated_data
);
214 attribute
->destroy(attribute
);
215 generator
->destroy(generator
);
218 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
224 * Described in header
226 void test_generator_with_transform_substructure(tester_t
*tester
)
228 generator_t
*generator
;
229 transform_attribute_t
*attribute1
, *attribute2
;
230 transform_substructure_t
*transform
;
232 chunk_t generated_data
;
235 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"transform substr.");
237 /* create generator */
238 generator
= generator_create();
239 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
241 /* create attribute 1 */
242 attribute1
= transform_attribute_create();
243 char *stringval
= "abcd";
244 data
.ptr
= (void *) stringval
;
246 attribute1
->set_value_chunk(attribute1
,data
);
247 attribute1
->set_attribute_type(attribute1
,0);
248 logger
->log(logger
,CONTROL
,"attribute1 created");
250 /* create attribute 2 */
251 attribute2
= transform_attribute_create();
253 data
.ptr
= (void *) stringval
;
255 attribute2
->set_value_chunk(attribute2
,data
);
256 attribute2
->set_attribute_type(attribute2
,0);
257 logger
->log(logger
,CONTROL
,"attribute2 created");
259 /* create transform */
260 transform
= transform_substructure_create();
261 tester
->assert_true(tester
,(transform
!= NULL
), "transform create check");
262 transform
->add_transform_attribute(transform
,attribute1
);
263 transform
->add_transform_attribute(transform
,attribute2
);
264 transform
->set_transform_type(transform
,5); /* hex 5 */
265 transform
->set_transform_id(transform
,65000); /* hex FDE8 */
268 logger
->log(logger
,CONTROL
,"transform created");
270 generator
->generate_payload(generator
,(payload_t
*)transform
);
271 generator
->write_to_chunk(generator
,&generated_data
);
272 logger
->log_chunk(logger
,RAW
,"generated transform",&generated_data
);
274 u_int8_t expected_generation3
[] = {
282 tester
->assert_true(tester
,(memcmp(expected_generation3
,generated_data
.ptr
,sizeof(expected_generation3
)) == 0), "compare generated data");
284 allocator_free_chunk(&generated_data
);
285 transform
->destroy(transform
);
286 generator
->destroy(generator
);
289 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
294 * Described in header
296 void test_generator_with_proposal_substructure(tester_t
*tester
)
298 generator_t
*generator
;
299 transform_attribute_t
*attribute1
, *attribute2
, *attribute3
;
300 transform_substructure_t
*transform1
, *transform2
;
301 proposal_substructure_t
*proposal
;
303 chunk_t generated_data
;
306 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"transform substr.");
308 /* create generator */
309 generator
= generator_create();
310 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
312 /* create attribute 1 */
313 attribute1
= transform_attribute_create();
314 char *stringval
= "abcd";
315 data
.ptr
= (void *) stringval
;
317 attribute1
->set_value_chunk(attribute1
,data
);
318 attribute1
->set_attribute_type(attribute1
,0);
320 logger
->log(logger
,CONTROL
,"attribute1 created");
322 /* create attribute 2 */
323 attribute2
= transform_attribute_create();
325 data
.ptr
= (void *) stringval
;
327 attribute2
->set_value_chunk(attribute2
,data
);
328 attribute2
->set_attribute_type(attribute2
,0);
329 logger
->log(logger
,CONTROL
,"attribute2 created");
331 /* create attribute 3 */
332 attribute3
= transform_attribute_create();
334 data
.ptr
= (void *) stringval
;
336 attribute3
->set_value_chunk(attribute3
,data
);
337 attribute3
->set_attribute_type(attribute3
,0);
338 logger
->log(logger
,CONTROL
,"attribute3 created");
340 /* create transform 1*/
341 transform1
= transform_substructure_create();
342 tester
->assert_true(tester
,(transform1
!= NULL
), "transform create check");
343 transform1
->add_transform_attribute(transform1
,attribute1
);
344 transform1
->add_transform_attribute(transform1
,attribute2
);
345 transform1
->set_transform_type(transform1
,5); /* hex 5 */
346 transform1
->set_transform_id(transform1
,65000); /* hex FDE8 */
348 /* create transform 2*/
349 transform2
= transform_substructure_create();
350 tester
->assert_true(tester
,(transform2
!= NULL
), "transform create check");
351 transform2
->add_transform_attribute(transform2
,attribute3
);
352 transform2
->set_transform_type(transform2
,3); /* hex 3 */
353 transform2
->set_transform_id(transform2
,4); /* hex 4 */
355 logger
->log(logger
,CONTROL
,"transforms created");
357 proposal
= proposal_substructure_create();
358 tester
->assert_true(tester
,(proposal
!= NULL
), "proposal create check");
360 stringval
= "ABCDEFGH";
361 data
.ptr
= (void *) stringval
;
364 proposal
->add_transform_substructure(proposal
,transform1
);
365 proposal
->add_transform_substructure(proposal
,transform2
);
366 proposal
->set_spi(proposal
,data
);
367 proposal
->set_proposal_number(proposal
,7);
368 proposal
->set_protocol_id(proposal
,4);
370 generator
->generate_payload(generator
,(payload_t
*)proposal
);
371 generator
->write_to_chunk(generator
,&generated_data
);
372 logger
->log_chunk(logger
,RAW
,"generated transform",&generated_data
);
374 u_int8_t expected_generation
[] = {
375 /* proposal header */
381 /* first transform */
384 /* first transform attributes */
389 /* second transform */
392 /* second transform attributes */
396 logger
->log_bytes(logger
,RAW
,"expected transform",expected_generation
,sizeof(expected_generation
));
398 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
400 allocator_free_chunk(&generated_data
);
401 proposal
->destroy(proposal
);
402 generator
->destroy(generator
);
405 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
409 * Described in header
411 void test_generator_with_sa_payload(tester_t
*tester
)
413 generator_t
*generator
;
414 transform_attribute_t
*attribute1
, *attribute2
, *attribute3
;
415 transform_substructure_t
*transform1
, *transform2
;
416 proposal_substructure_t
*proposal1
, *proposal2
;
417 sa_payload_t
*sa_payload
;
418 ike_header_t
*ike_header
;
421 chunk_t generated_data
;
424 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"Message with SA Payload");
426 /* create generator */
427 generator
= generator_create();
428 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
430 /* create attribute 1 */
431 attribute1
= transform_attribute_create();
432 char *stringval
= "abcd";
433 data
.ptr
= (void *) stringval
;
435 attribute1
->set_value_chunk(attribute1
,data
);
436 attribute1
->set_attribute_type(attribute1
,0);
437 logger
->log(logger
,CONTROL
,"attribute1 created");
439 /* create attribute 2 */
440 attribute2
= transform_attribute_create();
442 data
.ptr
= (void *) stringval
;
444 attribute2
->set_value_chunk(attribute2
,data
);
445 attribute2
->set_attribute_type(attribute2
,0);
446 logger
->log(logger
,CONTROL
,"attribute2 created");
448 /* create attribute 3 */
449 attribute3
= transform_attribute_create();
451 data
.ptr
= (void *) stringval
;
453 attribute3
->set_value_chunk(attribute3
,data
);
454 attribute3
->set_attribute_type(attribute3
,0);
455 logger
->log(logger
,CONTROL
,"attribute3 created");
457 /* create transform 1*/
458 transform1
= transform_substructure_create();
459 tester
->assert_true(tester
,(transform1
!= NULL
), "transform create check");
460 transform1
->add_transform_attribute(transform1
,attribute1
);
461 transform1
->add_transform_attribute(transform1
,attribute2
);
462 transform1
->set_transform_type(transform1
,5); /* hex 5 */
463 transform1
->set_transform_id(transform1
,65000); /* hex FDE8 */
465 /* create transform 2*/
466 transform2
= transform_substructure_create();
467 tester
->assert_true(tester
,(transform2
!= NULL
), "transform create check");
468 transform2
->add_transform_attribute(transform2
,attribute3
);
469 transform2
->set_transform_type(transform2
,3); /* hex 3 */
470 transform2
->set_transform_id(transform2
,4); /* hex 4 */
472 logger
->log(logger
,CONTROL
,"transforms created");
474 /* create proposal 1 */
475 proposal1
= proposal_substructure_create();
476 tester
->assert_true(tester
,(proposal1
!= NULL
), "proposal create check");
478 stringval
= "ABCDEFGH";
479 data
.ptr
= (void *) stringval
;
482 proposal1
->add_transform_substructure(proposal1
,transform1
);
483 proposal1
->add_transform_substructure(proposal1
,transform2
);
484 proposal1
->set_spi(proposal1
,data
);
485 proposal1
->set_proposal_number(proposal1
,7);
486 proposal1
->set_protocol_id(proposal1
,4);
488 /* create proposal 2 */
489 proposal2
= proposal_substructure_create();
490 tester
->assert_true(tester
,(proposal2
!= NULL
), "proposal create check");
491 proposal2
->set_proposal_number(proposal2
,7);
492 proposal2
->set_protocol_id(proposal2
,5);
494 /* create sa_payload */
495 sa_payload
= sa_payload_create();
497 sa_payload
->add_proposal_substructure(sa_payload
,proposal1
);
498 sa_payload
->add_proposal_substructure(sa_payload
,proposal2
);
500 ike_header
= ike_header_create();
501 ike_header
->set_initiator_spi(ike_header
,0x22000054231234LL
);
502 ike_header
->set_responder_spi(ike_header
,0x122398);
503 ((payload_t
*) ike_header
)->set_next_type((payload_t
*) ike_header
,SECURITY_ASSOCIATION
);
504 ike_header
->set_exchange_type(ike_header
, 0x12);
505 ike_header
->set_initiator_flag(ike_header
, TRUE
);
506 ike_header
->set_response_flag(ike_header
, TRUE
);
507 ike_header
->set_message_id(ike_header
,0x33AFF3);
509 generator
->generate_payload(generator
,(payload_t
*)ike_header
);
510 generator
->generate_payload(generator
,(payload_t
*)sa_payload
);
511 generator
->write_to_chunk(generator
,&generated_data
);
512 logger
->log_chunk(logger
,RAW
,"generated transform",&generated_data
);
514 u_int8_t expected_generation
[] = {
515 /* sa payload header */
524 /* sa payload header */
526 /* proposal header */
532 /* first transform */
535 /* first transform attributes */
540 /* second transform */
543 /* second transform attributes */
546 /* proposal header 2*/
552 logger
->log_bytes(logger
,RAW
,"expected transform",expected_generation
,sizeof(expected_generation
));
554 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
556 allocator_free_chunk(&generated_data
);
557 ike_header
->destroy(ike_header
);
558 sa_payload
->destroy(sa_payload
);
559 generator
->destroy(generator
);
561 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
566 * Described in header
568 void test_generator_with_ke_payload(tester_t
*tester
)
570 generator_t
*generator
;
571 ke_payload_t
*ke_payload
;
573 chunk_t generated_data
;
574 chunk_t key_exchange_data
;
576 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"Message with KE Payload");
578 /* create generator */
579 generator
= generator_create();
580 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
582 ke_payload
= ke_payload_create();
585 key_exchange_data
.ptr
= "test-text";
586 key_exchange_data
.len
= strlen(key_exchange_data
.ptr
);
588 ke_payload
->set_key_exchange_data(ke_payload
,key_exchange_data
);
590 ke_payload
->set_dh_group_number(ke_payload
,7777);
592 generator
->generate_payload(generator
,(payload_t
*)ke_payload
);
593 generator
->write_to_chunk(generator
,&generated_data
);
594 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
596 u_int8_t expected_generation
[] = {
600 /* key exchange data */
607 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
609 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
611 allocator_free_chunk(&generated_data
);
613 ke_payload
->destroy(ke_payload
);
614 generator
->destroy(generator
);
616 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
621 * Described in header
623 void test_generator_with_notify_payload(tester_t
*tester
)
625 generator_t
*generator
;
626 notify_payload_t
*notify_payload
;
628 chunk_t generated_data
;
629 chunk_t spi
,notification_data
;
631 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"Message with Notify Payload");
633 /* create generator */
634 generator
= generator_create();
635 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
637 notify_payload
= notify_payload_create();
641 spi
.len
= strlen(spi
.ptr
);
643 notification_data
.ptr
= "67890";
644 notification_data
.len
= strlen(notification_data
.ptr
);
646 notify_payload
->set_protocol_id(notify_payload
,255);
647 notify_payload
->set_notify_message_type(notify_payload
,63333); /* Hex F765 */
648 notify_payload
->set_spi(notify_payload
,spi
);
649 notify_payload
->set_notification_data(notify_payload
,notification_data
);
651 generator
->generate_payload(generator
,(payload_t
*)notify_payload
);
652 generator
->write_to_chunk(generator
,&generated_data
);
653 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
655 u_int8_t expected_generation
[] = {
662 /* notification data */
667 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
669 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
671 allocator_free_chunk(&generated_data
);
673 notify_payload
->destroy(notify_payload
);
674 generator
->destroy(generator
);
676 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);
681 * Described in header
683 void test_generator_with_nonce_payload(tester_t
*tester
)
685 generator_t
*generator
;
686 nonce_payload_t
*nonce_payload
;
688 chunk_t generated_data
;
691 logger
= global_logger_manager
->create_logger(global_logger_manager
,TESTER
,"Message with Nonce Payload");
693 /* create generator */
694 generator
= generator_create();
695 tester
->assert_true(tester
,(generator
!= NULL
), "generator create check");
697 nonce_payload
= nonce_payload_create();
700 nonce
.ptr
= "1234567890123456";
701 nonce
.len
= strlen("1234567890123456");
703 nonce_payload
->set_nonce(nonce_payload
,nonce
);
705 generator
->generate_payload(generator
,(payload_t
*)nonce_payload
);
706 generator
->write_to_chunk(generator
,&generated_data
);
707 logger
->log_chunk(logger
,RAW
,"generated payload",&generated_data
);
710 u_int8_t expected_generation
[] = {
720 logger
->log_bytes(logger
,RAW
,"expected payload",expected_generation
,sizeof(expected_generation
));
722 tester
->assert_true(tester
,(memcmp(expected_generation
,generated_data
.ptr
,sizeof(expected_generation
)) == 0), "compare generated data");
724 allocator_free_chunk(&generated_data
);
727 nonce_payload
->destroy(nonce_payload
);
728 generator
->destroy(generator
);
730 global_logger_manager
->destroy_logger(global_logger_manager
,logger
);