programs/charon/testing/generator_test.c

   1 /**
   2  * @file generator_test.c
   3  *
   4  * @brief Tests for the generator_t class.
   5  *
   6  */
   7
   8 /*
   9  * Copyright (C) 2005 Jan Hutter, Martin Willi
  10  * Hochschule fuer Technik Rapperswil
  11  *
  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>.
  16  *
  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
  20  * for more details.
  21  */
  22
  23 #include <string.h>
  24
  25 #include "generator_test.h"
  26
  27 #include <daemon.h>
  28 #include <encoding/generator.h>
  29 #include <utils/logger_manager.h>
  30 #include <utils/logger.h>
  31 #include <encoding/payloads/encodings.h>
  32 #include <encoding/payloads/ike_header.h>
  33 #include <encoding/payloads/transform_attribute.h>
  34 #include <encoding/payloads/transform_substructure.h>
  35 #include <encoding/payloads/proposal_substructure.h>
  36 #include <encoding/payloads/sa_payload.h>
  37 #include <encoding/payloads/ke_payload.h>
  38 #include <encoding/payloads/notify_payload.h>
  39 #include <encoding/payloads/nonce_payload.h>
  40 #include <encoding/payloads/id_payload.h>
  41 #include <encoding/payloads/auth_payload.h>
  42 #include <encoding/payloads/cert_payload.h>
  43 #include <encoding/payloads/certreq_payload.h>
  44 #include <encoding/payloads/ts_payload.h>
  45 #include <encoding/payloads/delete_payload.h>
  46 #include <encoding/payloads/vendor_id_payload.h>
  47 #include <encoding/payloads/cp_payload.h>
  48 #include <encoding/payloads/eap_payload.h>
  49
  50 /*
  51  * Described in Header
  52  */
  53 void test_generator_with_header_payload(protected_tester_t *tester)
  54 {
  55         generator_t *generator;
  56         ike_header_t *header_data;
  57         chunk_t generated_data;
  58         logger_t *logger;
  59
  60         logger = logger_manager->get_logger(logger_manager, TESTER);
  61
  62         header_data = ike_header_create();
  63         header_data->set_initiator_spi(header_data,1);
  64         header_data->set_responder_spi(header_data,2);
  65         ((payload_t *) header_data)->set_next_type((payload_t *) header_data, 3);
  66         header_data->set_exchange_type(header_data, 6);
  67         header_data->set_initiator_flag(header_data, TRUE);
  68         header_data->set_response_flag(header_data, TRUE);
  69         header_data->set_message_id(header_data,7);
  70
  71         generator = generator_create();
  72         tester->assert_true(tester,(generator != NULL), "generator create check");
  73
  74         generator->generate_payload(generator,(payload_t *) header_data);
  75
  76         generator->write_to_chunk(generator,&generated_data);
  77
  78         u_int8_t expected_generation[] = {
  79                 0x01,0x00,0x00,0x00,
  80                 0x00,0x00,0x00,0x00,
  81                 0x02,0x00,0x00,0x00,
  82                 0x00,0x00,0x00,0x00,
  83                 0x03,0x20,0x06,0x28,
  84                 0x00,0x00,0x00,0x07,
  85                 0x00,0x00,0x00,0x1C,
  86         };
  87
  88         logger->log_bytes(logger,RAW,"expected header",expected_generation,sizeof(expected_generation));
  89         tester->assert_true(tester,(generated_data.len == sizeof(expected_generation)), "compare generated data length");
  90         logger->log_chunk(logger,RAW,"generated header",generated_data);
  91         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data 1");
  92         chunk_free(&generated_data);
  93
  94         generator->destroy(generator);
  95
  96         header_data->set_initiator_spi(header_data,0x22000054231234LL);
  97         header_data->set_responder_spi(header_data,0x122398);
  98         ((payload_t *) header_data)->set_next_type((payload_t *) header_data,0xF3);
  99         header_data->set_exchange_type(header_data, 0x12);
 100         header_data->set_initiator_flag(header_data, TRUE);
 101         header_data->set_response_flag(header_data, TRUE);
 102         header_data->set_message_id(header_data,0x33AFF3);
 103
 104         generator = generator_create();
 105         tester->assert_true(tester,(generator != NULL), "generator create check");
 106
 107         generator->generate_payload(generator,(payload_t *)header_data);
 108
 109         generator->write_to_chunk(generator,&generated_data);
 110
 111         u_int8_t expected_generation2[] = {
 112                 0x34,0x12,0x23,0x54,
 113                 0x00,0x00,0x22,0x00,
 114                 0x98,0x23,0x12,0x00,
 115                 0x00,0x00,0x00,0x00,
 116                 0xF3,0x20,0x12,0x28,
 117                 0x00,0x33,0xAF,0xF3,
 118                 0x00,0x00,0x00,0x1C,
 119         };
 120
 121
 122         logger->log_bytes(logger,RAW,"expected header",expected_generation2,sizeof(expected_generation2));
 123
 124         logger->log_chunk(logger,RAW,"generated header",generated_data);
 125
 126         tester->assert_true(tester,(memcmp(expected_generation2,generated_data.ptr,sizeof(expected_generation2)) == 0), "compare generated data 2");
 127         chunk_free(&generated_data);
 128
 129         header_data->destroy(header_data);
 130
 131         generator->destroy(generator);
 132 }
 133
 134 /*
 135  * Described in header
 136  */
 137 void test_generator_with_transform_attribute(protected_tester_t *tester)
 138 {
 139         generator_t *generator;
 140         transform_attribute_t *attribute;
 141         chunk_t generated_data;
 142         logger_t *logger;
 143
 144         logger = logger_manager->get_logger(logger_manager, TESTER);
 145
 146
 147         /* test empty attribute */
 148         generator = generator_create();
 149         tester->assert_true(tester,(generator != NULL), "generator create check");
 150         attribute = transform_attribute_create();
 151         generator->generate_payload(generator,(payload_t *)attribute);
 152         generator->write_to_chunk(generator,&generated_data);
 153         logger->log_chunk(logger,RAW,"generated attribute",generated_data);
 154
 155         u_int8_t expected_generation[] = {
 156                 0x80,0x00,0x00,0x00,
 157         };
 158         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
 159         chunk_free(&generated_data);
 160         attribute->destroy(attribute);
 161         generator->destroy(generator);
 162
 163         /* test attribute with 2 byte data */
 164         generator = generator_create();
 165         tester->assert_true(tester,(generator != NULL), "generator create check");
 166
 167         attribute = transform_attribute_create();
 168         u_int16_t dataval = 5768;
 169         chunk_t data;
 170         data.ptr = (void *) &dataval;
 171         data.len = 2;
 172
 173         attribute->set_value_chunk(attribute,data);
 174
 175         generator->generate_payload(generator,(payload_t *)attribute);
 176         generator->write_to_chunk(generator,&generated_data);
 177         logger->log_chunk(logger,RAW,"generated attribute",generated_data);
 178
 179         u_int8_t expected_generation2[] = {
 180                 0x80,0x00,0x16,0x88,
 181         };
 182         tester->assert_true(tester,(memcmp(expected_generation2,generated_data.ptr,sizeof(expected_generation2)) == 0), "compare generated data");
 183
 184         chunk_free(&generated_data);
 185         attribute->destroy(attribute);
 186         generator->destroy(generator);
 187
 188
 189
 190         /* test attribute with 25 byte data */
 191                 generator = generator_create();
 192         tester->assert_true(tester,(generator != NULL), "generator create check");
 193
 194         attribute = transform_attribute_create();
 195         char *stringval = "ddddddddddeeeeeeeeeefffff";
 196         data.ptr = (void *) stringval;
 197         data.len = 25;
 198
 199         attribute->set_value_chunk(attribute,data);
 200
 201         attribute->set_attribute_type(attribute,456);
 202
 203
 204         generator->generate_payload(generator,(payload_t *)attribute);
 205         generator->write_to_chunk(generator,&generated_data);
 206         logger->log_chunk(logger,RAW,"generated attribute",generated_data);
 207
 208         u_int8_t expected_generation3[] = {
 209                 0x01,0xC8,0x00,0x19,
 210                 0x64,0x64,0x64,0x64,
 211                 0x64,0x64,0x64,0x64,
 212                 0x64,0x64,0x65,0x65,
 213                 0x65,0x65,0x65,0x65,
 214                 0x65,0x65,0x65,0x65,
 215                 0x66,0x66,0x66,0x66,
 216                 0x66
 217         };
 218         tester->assert_true(tester,(memcmp(expected_generation3,generated_data.ptr,sizeof(expected_generation3)) == 0), "compare generated data");
 219
 220         chunk_free(&generated_data);
 221         attribute->destroy(attribute);
 222         generator->destroy(generator);
 223 }
 224
 225
 226
 227 /*
 228  * Described in header
 229  */
 230 void test_generator_with_transform_substructure(protected_tester_t *tester)
 231 {
 232         generator_t *generator;
 233         transform_attribute_t *attribute1, *attribute2;
 234         transform_substructure_t *transform;
 235         chunk_t data;
 236         chunk_t generated_data;
 237         logger_t *logger;
 238
 239         logger = logger_manager->get_logger(logger_manager,TESTER);
 240
 241         /* create generator */
 242         generator = generator_create();
 243         tester->assert_true(tester,(generator != NULL), "generator create check");
 244
 245         /* create attribute 1 */
 246         attribute1 = transform_attribute_create();
 247         char *stringval = "abcd";
 248         data.ptr = (void *) stringval;
 249         data.len = 4;
 250         attribute1->set_value_chunk(attribute1,data);
 251         attribute1->set_attribute_type(attribute1,0);
 252         logger->log(logger,CONTROL,"attribute1 created");
 253
 254         /* create attribute 2 */
 255         attribute2 = transform_attribute_create();
 256         stringval = "efgh";
 257         data.ptr = (void *) stringval;
 258         data.len = 4;
 259         attribute2->set_value_chunk(attribute2,data);
 260         attribute2->set_attribute_type(attribute2,0);
 261         logger->log(logger,CONTROL,"attribute2 created");
 262
 263         /* create transform */
 264         transform = transform_substructure_create();
 265         tester->assert_true(tester,(transform != NULL), "transform create check");
 266         transform->add_transform_attribute(transform,attribute1);
 267         transform->add_transform_attribute(transform,attribute2);
 268         transform->set_transform_type(transform,5); /* hex 5 */
 269         transform->set_transform_id(transform,65000); /* hex FDE8 */
 270
 271
 272         logger->log(logger,CONTROL,"transform created");
 273
 274         generator->generate_payload(generator,(payload_t *)transform);
 275         generator->write_to_chunk(generator,&generated_data);
 276         logger->log_chunk(logger,RAW,"generated transform",generated_data);
 277
 278         u_int8_t expected_generation3[] = {
 279                 0x00,0x00,0x00,0x18,
 280                 0x05,0x00,0xFD,0xE8,
 281                 0x00,0x00,0x00,0x04,
 282                 0x61,0x62,0x63,0x64,
 283                 0x00,0x00,0x00,0x04,
 284                 0x65,0x66,0x67,0x68,
 285         };
 286         tester->assert_true(tester,(memcmp(expected_generation3,generated_data.ptr,sizeof(expected_generation3)) == 0), "compare generated data");
 287
 288         chunk_free(&generated_data);
 289         transform->destroy(transform);
 290         generator->destroy(generator);
 291 }
 292
 293
 294 /*
 295  * Described in header
 296  */
 297 void test_generator_with_proposal_substructure(protected_tester_t *tester)
 298 {
 299         generator_t *generator;
 300         transform_attribute_t *attribute1, *attribute2, *attribute3;
 301         transform_substructure_t *transform1, *transform2;
 302         proposal_substructure_t *proposal;
 303         chunk_t data;
 304         chunk_t generated_data;
 305         logger_t *logger;
 306
 307         logger = logger_manager->get_logger(logger_manager,TESTER);
 308
 309         /* create generator */
 310         generator = generator_create();
 311         tester->assert_true(tester,(generator != NULL), "generator create check");
 312
 313         /* create attribute 1 */
 314         attribute1 = transform_attribute_create();
 315         char *stringval = "abcd";
 316         data.ptr = (void *) stringval;
 317         data.len = 4;
 318         attribute1->set_value_chunk(attribute1,data);
 319         attribute1->set_attribute_type(attribute1,0);
 320
 321         logger->log(logger,CONTROL,"attribute1 created");
 322
 323         /* create attribute 2 */
 324         attribute2 = transform_attribute_create();
 325         stringval = "efgh";
 326         data.ptr = (void *) stringval;
 327         data.len = 4;
 328         attribute2->set_value_chunk(attribute2,data);
 329         attribute2->set_attribute_type(attribute2,0);
 330         logger->log(logger,CONTROL,"attribute2 created");
 331
 332         /* create attribute 3 */
 333         attribute3 = transform_attribute_create();
 334         stringval = "ijkl";
 335         data.ptr = (void *) stringval;
 336         data.len = 4;
 337         attribute3->set_value_chunk(attribute3,data);
 338         attribute3->set_attribute_type(attribute3,0);
 339         logger->log(logger,CONTROL,"attribute3 created");
 340
 341         /* create transform 1*/
 342         transform1 = transform_substructure_create();
 343         tester->assert_true(tester,(transform1 != NULL), "transform create check");
 344         transform1->add_transform_attribute(transform1,attribute1);
 345         transform1->add_transform_attribute(transform1,attribute2);
 346         transform1->set_transform_type(transform1,5); /* hex 5 */
 347         transform1->set_transform_id(transform1,65000); /* hex FDE8 */
 348
 349         /* create transform 2*/
 350         transform2 = transform_substructure_create();
 351         tester->assert_true(tester,(transform2 != NULL), "transform create check");
 352         transform2->add_transform_attribute(transform2,attribute3);
 353         transform2->set_transform_type(transform2,3); /* hex 3 */
 354         transform2->set_transform_id(transform2,4); /* hex 4 */
 355
 356         logger->log(logger,CONTROL,"transforms created");
 357
 358         proposal = proposal_substructure_create();
 359         tester->assert_true(tester,(proposal != NULL), "proposal create check");
 360
 361         stringval = "ABCDEFGH";
 362         data.ptr = (void *) stringval;
 363         data.len = 8;
 364
 365         proposal->add_transform_substructure(proposal,transform1);
 366         proposal->add_transform_substructure(proposal,transform2);
 367         proposal->set_spi(proposal,data);
 368         proposal->set_proposal_number(proposal,7);
 369         proposal->set_protocol_id(proposal,4);
 370
 371         generator->generate_payload(generator,(payload_t *)proposal);
 372         generator->write_to_chunk(generator,&generated_data);
 373         logger->log_chunk(logger,RAW,"generated transform",generated_data);
 374
 375         u_int8_t expected_generation[] = {
 376                 /* proposal header */
 377                 0x00,0x00,0x00,0x38,
 378                 0x07,0x04,0x08,0x02,
 379                 /* SPI */
 380                 0x41,0x42,0x43,0x44,
 381                 0x45,0x46,0x47,0x48,
 382                 /* first transform */
 383                 0x03,0x00,0x00,0x18,
 384                 0x05,0x00,0xFD,0xE8,
 385                 /* first transform attributes */
 386                 0x00,0x00,0x00,0x04,
 387                 0x61,0x62,0x63,0x64,
 388                 0x00,0x00,0x00,0x04,
 389                 0x65,0x66,0x67,0x68,
 390                 /* second transform */
 391                 0x00,0x00,0x00,0x10,
 392                 0x03,0x00,0x00,0x04,
 393                 /* second transform attributes */
 394                 0x00,0x00,0x00,0x04,
 395                 0x69,0x6A,0x6B,0x6C
 396         };
 397         logger->log_bytes(logger,RAW,"expected transform",expected_generation,sizeof(expected_generation));
 398
 399         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
 400
 401         chunk_free(&generated_data);
 402         proposal->destroy(proposal);
 403         generator->destroy(generator);
 404 }
 405
 406 /*
 407  * Described in header
 408  */
 409 void test_generator_with_sa_payload(protected_tester_t *tester)
 410 {
 411         generator_t *generator;
 412         transform_attribute_t *attribute1, *attribute2, *attribute3;
 413         transform_substructure_t *transform1, *transform2;
 414         proposal_substructure_t *proposal_str1, *proposal_str2;
 415         linked_list_t *list;
 416         proposal_t *proposal1, *proposal2;
 417         sa_payload_t *sa_payload;
 418         ike_header_t *ike_header;
 419
 420         chunk_t data;
 421         chunk_t generated_data;
 422         logger_t *logger;
 423
 424         logger = logger_manager->get_logger(logger_manager,TESTER);
 425
 426         /* create generator */
 427         generator = generator_create();
 428         tester->assert_true(tester,(generator != NULL), "generator create check");
 429
 430         /* --------------------------- */
 431         /* test first with self created proposals */
 432
 433         /* create attribute 1 */
 434         attribute1 = transform_attribute_create();
 435         char *stringval = "abcd";
 436         data.ptr = (void *) stringval;
 437         data.len = 4;
 438         attribute1->set_value_chunk(attribute1,data);
 439         attribute1->set_attribute_type(attribute1,0);
 440         logger->log(logger,CONTROL,"attribute1 created");
 441
 442         /* create attribute 2 */
 443         attribute2 = transform_attribute_create();
 444         stringval = "efgh";
 445         data.ptr = (void *) stringval;
 446         data.len = 4;
 447         attribute2->set_value_chunk(attribute2,data);
 448         attribute2->set_attribute_type(attribute2,0);
 449         logger->log(logger,CONTROL,"attribute2 created");
 450
 451         /* create attribute 3 */
 452         attribute3 = transform_attribute_create();
 453         stringval = "ijkl";
 454         data.ptr = (void *) stringval;
 455         data.len = 4;
 456         attribute3->set_value_chunk(attribute3,data);
 457         attribute3->set_attribute_type(attribute3,0);
 458         logger->log(logger,CONTROL,"attribute3 created");
 459
 460         /* create transform 1*/
 461         transform1 = transform_substructure_create();
 462         tester->assert_true(tester,(transform1 != NULL), "transform create check");
 463         transform1->add_transform_attribute(transform1,attribute1);
 464         transform1->add_transform_attribute(transform1,attribute2);
 465         transform1->set_transform_type(transform1,5); /* hex 5 */
 466         transform1->set_transform_id(transform1,65000); /* hex FDE8 */
 467
 468         /* create transform 2*/
 469         transform2 = transform_substructure_create();
 470         tester->assert_true(tester,(transform2 != NULL), "transform create check");
 471         transform2->add_transform_attribute(transform2,attribute3);
 472         transform2->set_transform_type(transform2,3); /* hex 3 */
 473         transform2->set_transform_id(transform2,4); /* hex 4 */
 474
 475         logger->log(logger,CONTROL,"transforms created");
 476
 477         /* create proposal 1 */
 478         proposal_str1 = proposal_substructure_create();
 479         tester->assert_true(tester,(proposal1 != NULL), "proposal create check");
 480
 481         stringval = "ABCDEFGH";
 482         data.ptr = (void *) stringval;
 483         data.len = 8;
 484
 485         proposal_str1->add_transform_substructure(proposal_str1,transform1);
 486         proposal_str1->add_transform_substructure(proposal_str1,transform2);
 487         proposal_str1->set_spi(proposal_str1,data);
 488         proposal_str1->set_proposal_number(proposal_str1,7);
 489         proposal_str1->set_protocol_id(proposal_str1,4);
 490
 491         /* create proposal 2 */
 492         proposal_str2 = proposal_substructure_create();
 493         tester->assert_true(tester,(proposal_str2 != NULL), "proposal create check");
 494         proposal_str2->set_proposal_number(proposal_str2,7);
 495         proposal_str2->set_protocol_id(proposal_str2,5);
 496
 497         /* create sa_payload */
 498         sa_payload = sa_payload_create();
 499
 500         sa_payload->add_proposal_substructure(sa_payload,proposal_str1);
 501         sa_payload->add_proposal_substructure(sa_payload,proposal_str2);
 502
 503         ike_header = ike_header_create();
 504         ike_header->set_initiator_spi(ike_header,0x22000054231234LL);
 505         ike_header->set_responder_spi(ike_header,0x122398);
 506         ((payload_t *) ike_header)->set_next_type((payload_t *) ike_header,SECURITY_ASSOCIATION);
 507         ike_header->set_exchange_type(ike_header, 0x12);
 508         ike_header->set_initiator_flag(ike_header, TRUE);
 509         ike_header->set_response_flag(ike_header, TRUE);
 510         ike_header->set_message_id(ike_header,0x33AFF3);
 511
 512         generator->generate_payload(generator,(payload_t *)ike_header);
 513         generator->generate_payload(generator,(payload_t *)sa_payload);
 514         generator->write_to_chunk(generator,&generated_data);
 515         logger->log_chunk(logger,RAW,"generated transform",generated_data);
 516
 517         u_int8_t expected_generation[] = {
 518                 /* sa payload header */
 519                 0x34,0x12,0x23,0x54,
 520                 0x00,0x00,0x22,0x00,
 521                 0x98,0x23,0x12,0x00,
 522                 0x00,0x00,0x00,0x00,
 523                 0x21,0x20,0x12,0x28,
 524                 0x00,0x33,0xAF,0xF3,
 525                 0x00,0x00,0x00,0x60,
 526
 527                 /* sa payload header */
 528                 0x00,0x00,0x00,0x44,
 529                 /* proposal header */
 530                 0x02,0x00,0x00,0x38,
 531                 0x07,0x04,0x08,0x02,
 532                 /* SPI */
 533                 0x41,0x42,0x43,0x44,
 534                 0x45,0x46,0x47,0x48,
 535                 /* first transform */
 536                 0x03,0x00,0x00,0x18,
 537                 0x05,0x00,0xFD,0xE8,
 538                 /* first transform attributes */
 539                 0x00,0x00,0x00,0x04,
 540                 0x61,0x62,0x63,0x64,
 541                 0x00,0x00,0x00,0x04,
 542                 0x65,0x66,0x67,0x68,
 543                 /* second transform */
 544                 0x00,0x00,0x00,0x10,
 545                 0x03,0x00,0x00,0x04,
 546                 /* second transform attributes */
 547                 0x00,0x00,0x00,0x04,
 548                 0x69,0x6A,0x6B,0x6C,
 549                 /* proposal header 2*/
 550                 0x00,0x00,0x00,0x08,
 551                 0x07,0x05,0x00,0x00,
 552
 553         };
 554
 555         logger->log_bytes(logger,RAW,"expected transform",expected_generation,sizeof(expected_generation));
 556
 557         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
 558
 559         chunk_free(&generated_data);
 560         ike_header->destroy(ike_header);
 561         sa_payload->destroy(sa_payload);
 562         generator->destroy(generator);
 563
 564         /* --------------------------- */
 565         /* test with automatic created proposals */
 566
 567         generator = generator_create();
 568         tester->assert_true(tester,(generator != NULL), "generator create check");
 569
 570
 571         proposal1 = proposal_create(1);
 572         proposal1->add_algorithm(proposal1, PROTO_IKE, ENCRYPTION_ALGORITHM, 1, 20);
 573         proposal1->add_algorithm(proposal1, PROTO_IKE, PSEUDO_RANDOM_FUNCTION, 2, 22);
 574         proposal1->add_algorithm(proposal1, PROTO_IKE, INTEGRITY_ALGORITHM, 3, 24);
 575         proposal1->add_algorithm(proposal1, PROTO_IKE, DIFFIE_HELLMAN_GROUP, 4, 0);
 576
 577         proposal2 = proposal_create(2);
 578         proposal2->add_algorithm(proposal2, PROTO_IKE, ENCRYPTION_ALGORITHM, 5, 26);
 579         proposal2->add_algorithm(proposal2, PROTO_IKE, PSEUDO_RANDOM_FUNCTION, 6, 28);
 580         proposal2->add_algorithm(proposal2, PROTO_IKE, INTEGRITY_ALGORITHM, 7, 30);
 581         proposal2->add_algorithm(proposal2, PROTO_IKE, DIFFIE_HELLMAN_GROUP, 8, 0);
 582
 583         list = linked_list_create();
 584         list->insert_last(list, (void*)proposal1);
 585         list->insert_last(list, (void*)proposal2);
 586         sa_payload = sa_payload_create_from_proposal_list(list);
 587         tester->assert_true(tester,(sa_payload != NULL), "sa_payload create check");
 588
 589         generator->generate_payload(generator,(payload_t *)sa_payload);
 590         generator->write_to_chunk(generator,&generated_data);
 591         logger->log_chunk(logger,RAW,"generated",generated_data);
 592
 593         u_int8_t expected_generation2[] = {
 594                 0x00,0x00,0x00,0x6C, /* payload header*/
 595                         0x02,0x00,0x00,0x34,  /* a proposal */
 596                         0x01,0x01,0x00,0x04,
 597                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 598                                 0x01,0x00,0x00,0x01,
 599                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 600                                 0x03,0x00,0x00,0x0C, /* transform 2 */
 601                                 0x02,0x00,0x00,0x02,
 602                                         0x80,0x0E,0x00,0x16, /* keylength attribute with 20 bytes length */
 603                                 0x03,0x00,0x00,0x0C, /* transform 3 */
 604                                 0x03,0x00,0x00,0x03,
 605                                         0x80,0x0E,0x00,0x18, /* keylength attribute with 20 bytes length */
 606                                 0x00,0x00,0x00,0x08, /* transform 4 */
 607                                 0x04,0x00,0x00,0x04,
 608                         0x00,0x00,0x00,0x34,  /* a proposal */
 609                         0x02,0x01,0x00,0x04,
 610                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 611                                 0x01,0x00,0x00,0x05,
 612                                         0x80,0x0E,0x00,0x1A, /* keylength attribute with 16 bytes length */
 613                                 0x03,0x00,0x00,0x0C, /* transform 2 */
 614                                 0x02,0x00,0x00,0x06,
 615                                         0x80,0x0E,0x00,0x1C, /* keylength attribute with 16 bytes length */
 616                                 0x03,0x00,0x00,0x0C, /* transform 3 */
 617                                 0x03,0x00,0x00,0x07,
 618                                         0x80,0x0E,0x00,0x1E, /* keylength attribute with 16 bytes length */
 619                                 0x00,0x00,0x00,0x08, /* transform 4 */
 620                                 0x04,0x00,0x00,0x08,
 621
 622         };
 623
 624         logger->log_bytes(logger,RAW,"expected",expected_generation2,sizeof(expected_generation2));
 625
 626         tester->assert_true(tester,(memcmp(expected_generation2,generated_data.ptr,sizeof(expected_generation2)) == 0), "compare generated data");
 627
 628         sa_payload->destroy(sa_payload);
 629         list->destroy(list);
 630         proposal1->destroy(proposal1);
 631         proposal2->destroy(proposal2);
 632         chunk_free(&generated_data);
 633         generator->destroy(generator);
 634
 635
 636         /* --------------------------- */
 637         /* test with automatic created child proposals */
 638
 639         generator = generator_create();
 640         tester->assert_true(tester,(generator != NULL), "generator create check");
 641
 642
 643         proposal1 = proposal_create(1);
 644
 645         proposal1->add_algorithm(proposal1, PROTO_AH, INTEGRITY_ALGORITHM, AUTH_HMAC_MD5_96, 20);
 646         proposal1->add_algorithm(proposal1, PROTO_AH, DIFFIE_HELLMAN_GROUP, MODP_2048_BIT, 0);
 647         proposal1->add_algorithm(proposal1, PROTO_AH, EXTENDED_SEQUENCE_NUMBERS, EXT_SEQ_NUMBERS, 0);
 648         proposal1->set_spi(proposal1, PROTO_AH, 0x01010101l);
 649
 650         proposal1->add_algorithm(proposal1, PROTO_ESP, ENCRYPTION_ALGORITHM, ENCR_AES_CBC, 20);
 651         proposal1->add_algorithm(proposal1, PROTO_ESP, DIFFIE_HELLMAN_GROUP, MODP_1024_BIT, 0);
 652         proposal1->set_spi(proposal1, PROTO_ESP, 0x02020202);
 653
 654
 655         proposal2->add_algorithm(proposal2, PROTO_AH, INTEGRITY_ALGORITHM, AUTH_HMAC_MD5_96, 20);
 656         proposal2->add_algorithm(proposal2, PROTO_AH, DIFFIE_HELLMAN_GROUP, MODP_2048_BIT, 0);
 657         proposal2->add_algorithm(proposal2, PROTO_AH, EXTENDED_SEQUENCE_NUMBERS, EXT_SEQ_NUMBERS, 0);
 658         proposal2->set_spi(proposal2, PROTO_AH, 0x01010101);
 659
 660         proposal2->add_algorithm(proposal2, PROTO_ESP, ENCRYPTION_ALGORITHM, ENCR_AES_CBC, 32);
 661         proposal2->add_algorithm(proposal2, PROTO_ESP, INTEGRITY_ALGORITHM, AUTH_HMAC_MD5_96, 20);
 662         proposal2->add_algorithm(proposal2, PROTO_ESP, DIFFIE_HELLMAN_GROUP, MODP_1024_BIT, 0);
 663         proposal2->set_spi(proposal2, PROTO_ESP, 0x02020202);
 664
 665         list->insert_last(list, (void*)proposal1);
 666         list->insert_last(list, (void*)proposal2);
 667
 668         sa_payload = sa_payload_create_from_proposal_list(list);
 669         tester->assert_true(tester,(sa_payload != NULL), "sa_payload create check");
 670
 671         generator->generate_payload(generator,(payload_t *)sa_payload);
 672         generator->write_to_chunk(generator,&generated_data);
 673         logger->log_chunk(logger,RAW,"generated",generated_data);
 674
 675         u_int8_t expected_generation3[] = {
 676                 0x00,0x00,0x00,0xA0, /* payload header*/
 677
 678                         /* suite 1 */
 679                         0x02,0x00,0x00,0x28,  /* a proposal */
 680                         0x01,0x02,0x04,0x03,
 681                         0x01,0x01,0x01,0x01,
 682                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 683                                 0x03,0x00,0x00,0x01,
 684                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 685
 686                                 0x03,0x00,0x00,0x08, /* transform 2 */
 687                                 0x04,0x00,0x00,0x0E,
 688
 689                                 0x00,0x00,0x00,0x08, /* transform 3 */
 690                                 0x05,0x00,0x00,0x01,
 691
 692
 693                         0x02,0x00,0x00,0x20,  /* a proposal */
 694                         0x01,0x03,0x04,0x02,
 695                         0x02,0x02,0x02,0x02,
 696
 697                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 698                                 0x01,0x00,0x00,0x0C,
 699                                         0x80,0x0E,0x00,0x20, /* keylength attribute with 32 bytes length */
 700
 701                                 0x00,0x00,0x00,0x08, /* transform 2 */
 702                                 0x04,0x00,0x00,0x02,
 703
 704                         /* suite 2 */
 705                         0x02,0x00,0x00,0x28,  /* a proposal */
 706                         0x02,0x02,0x04,0x03,
 707                         0x01,0x01,0x01,0x01,
 708                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 709                                 0x03,0x00,0x00,0x01,
 710                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 711
 712                                 0x03,0x00,0x00,0x08, /* transform 2 */
 713                                 0x04,0x00,0x00,0x0E,
 714
 715                                 0x00,0x00,0x00,0x08, /* transform 3 */
 716                                 0x05,0x00,0x00,0x01,
 717
 718
 719                         0x00,0x00,0x00,0x2C,  /* a proposal */
 720                         0x02,0x03,0x04,0x03,
 721                         0x02,0x02,0x02,0x02,
 722
 723                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 724                                 0x01,0x00,0x00,0x0C,
 725                                         0x80,0x0E,0x00,0x20, /* keylength attribute with 32 bytes length */
 726
 727                                 0x03,0x00,0x00,0x0C, /* transform 2 */
 728                                 0x03,0x00,0x00,0x01,
 729                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 730
 731                                 0x00,0x00,0x00,0x08, /* transform 3 */
 732                                 0x04,0x00,0x00,0x02,
 733
 734         };
 735
 736
 737         logger->log_bytes(logger,RAW,"expected",expected_generation3,sizeof(expected_generation3));
 738
 739         tester->assert_true(tester,(memcmp(expected_generation3,generated_data.ptr,sizeof(expected_generation3)) == 0), "compare generated data");
 740
 741         sa_payload->destroy(sa_payload);
 742         proposal1->destroy(proposal1);
 743         proposal2->destroy(proposal2);
 744         list->destroy(list);
 745         chunk_free(&generated_data);
 746         generator->destroy(generator);
 747
 748 }
 749
 750 /*
 751  * Described in header
 752  */
 753 void test_generator_with_ke_payload(protected_tester_t *tester)
 754 {
 755         generator_t *generator;
 756         ke_payload_t *ke_payload;
 757         logger_t *logger;
 758         chunk_t generated_data;
 759         chunk_t key_exchange_data;
 760
 761         logger = logger_manager->get_logger(logger_manager,TESTER);
 762
 763         /* create generator */
 764         generator = generator_create();
 765         tester->assert_true(tester,(generator != NULL), "generator create check");
 766
 767         ke_payload = ke_payload_create();
 768
 769
 770         key_exchange_data.ptr = "test-text";
 771         key_exchange_data.len = strlen(key_exchange_data.ptr);
 772
 773         ke_payload->set_key_exchange_data(ke_payload,key_exchange_data);
 774
 775         ke_payload->set_dh_group_number(ke_payload,7777);
 776
 777         generator->generate_payload(generator,(payload_t *)ke_payload);
 778         generator->write_to_chunk(generator,&generated_data);
 779         logger->log_chunk(logger,RAW,"generated payload",generated_data);
 780
 781         u_int8_t expected_generation[] = {
 782                 /* payload header */
 783                 0x00,0x00,0x00,0x11,
 784                 0x1E,0x61,0x00,0x00,
 785                 /* key exchange data */
 786                 0x74,0x65,0x73,0x74,
 787                 0x2D,0x74,0x65,0x78,
 788                 0x74
 789         };
 790
 791
 792         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
 793
 794         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
 795
 796         chunk_free(&generated_data);
 797
 798         ke_payload->destroy(ke_payload);
 799         generator->destroy(generator);
 800
 801 }
 802
 803 /*
 804  * Described in header
 805  */
 806 void test_generator_with_notify_payload(protected_tester_t *tester)
 807 {
 808         generator_t *generator;
 809         notify_payload_t *notify_payload;
 810         logger_t *logger;
 811         chunk_t generated_data;
 812         chunk_t spi,notification_data;
 813
 814         logger = logger_manager->get_logger(logger_manager,TESTER);
 815
 816         /* create generator */
 817         generator = generator_create();
 818         tester->assert_true(tester,(generator != NULL), "generator create check");
 819
 820         notify_payload = notify_payload_create();
 821
 822
 823         spi.ptr = "12345";
 824         spi.len = strlen(spi.ptr);
 825
 826         notification_data.ptr = "67890";
 827         notification_data.len = strlen(notification_data.ptr);
 828
 829         notify_payload->set_protocol_id(notify_payload,255);
 830         notify_payload->set_notify_message_type(notify_payload,63333); /* Hex F765 */
 831         notify_payload->set_spi(notify_payload,spi);
 832         notify_payload->set_notification_data(notify_payload,notification_data);
 833
 834         generator->generate_payload(generator,(payload_t *)notify_payload);
 835         generator->write_to_chunk(generator,&generated_data);
 836         logger->log_chunk(logger,RAW,"generated payload",generated_data);
 837
 838         u_int8_t expected_generation[] = {
 839                 /* payload header */
 840                 0x00,0x00,0x00,0x12,
 841                 0xFF,0x05,0xF7,0x65,
 842                 /* spi */
 843                 0x31,0x32,0x33,0x34,
 844                 0x35,
 845                 /* notification data */
 846                 0x36,0x37,0x38,0x39,
 847                 0x30,
 848         };
 849
 850         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
 851
 852         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
 853
 854         chunk_free(&generated_data);
 855
 856         notify_payload->destroy(notify_payload);
 857         generator->destroy(generator);
 858 }
 859
 860 /*
 861  * Described in header
 862  */
 863 void test_generator_with_nonce_payload(protected_tester_t *tester)
 864 {
 865         generator_t *generator;
 866         nonce_payload_t *nonce_payload;
 867         logger_t *logger;
 868         chunk_t generated_data;
 869         chunk_t nonce;
 870
 871         logger = logger_manager->get_logger(logger_manager,TESTER);
 872
 873         /* create generator */
 874         generator = generator_create();
 875         tester->assert_true(tester,(generator != NULL), "generator create check");
 876
 877         nonce_payload = nonce_payload_create();
 878
 879
 880         nonce.ptr = "1234567890123456";
 881         nonce.len = strlen("1234567890123456");
 882
 883         nonce_payload->set_nonce(nonce_payload,nonce);
 884
 885         generator->generate_payload(generator,(payload_t *)nonce_payload);
 886         generator->write_to_chunk(generator,&generated_data);
 887         logger->log_chunk(logger,RAW,"generated payload",generated_data);
 888
 889
 890         u_int8_t expected_generation[] = {
 891                 /* payload header */
 892                 0x00,0x00,0x00,0x14,
 893                 /* nonce data */
 894                 0x31,0x32,0x33,0x34,
 895                 0x35,0x36,0x37,0x38,
 896                 0x39,0x30,0x31,0x32,
 897                 0x33,0x34,0x35,0x36
 898         };
 899
 900         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
 901
 902         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
 903
 904         chunk_free(&generated_data);
 905
 906
 907         nonce_payload->destroy(nonce_payload);
 908         generator->destroy(generator);
 909 }
 910
 911 /*
 912  * Described in header.
 913  */
 914 void test_generator_with_id_payload(protected_tester_t *tester)
 915 {
 916         generator_t *generator;
 917         id_payload_t *id_payload;
 918         logger_t *logger;
 919         chunk_t generated_data;
 920         chunk_t id;
 921
 922         logger = logger_manager->get_logger(logger_manager,TESTER);
 923
 924         /* create generator */
 925         generator = generator_create();
 926         tester->assert_true(tester,(generator != NULL), "generator create check");
 927
 928         id_payload = id_payload_create(FALSE);
 929
 930
 931         id.ptr = "123456789012";
 932         id.len = strlen(id.ptr);
 933
 934         id_payload->set_id_type(id_payload,ID_IPV4_ADDR);
 935         id_payload->set_data(id_payload,id);
 936
 937         generator->generate_payload(generator,(payload_t *)id_payload);
 938         generator->write_to_chunk(generator,&generated_data);
 939         logger->log_chunk(logger,RAW,"generated payload",generated_data);
 940
 941
 942         u_int8_t expected_generation[] = {
 943                 /* payload header */
 944                 0x00,0x00,0x00,0x14,
 945                 0x01,0x00,0x00,0x00,
 946                 /* id data */
 947                 0x31,0x32,0x33,0x34,
 948                 0x35,0x36,0x37,0x38,
 949                 0x39,0x30,0x31,0x32,
 950         };
 951
 952         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
 953
 954         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
 955
 956         chunk_free(&generated_data);
 957
 958         id_payload->destroy(id_payload);
 959         generator->destroy(generator);
 960 }
 961
 962 /*
 963  * Described in header.
 964  */
 965 void test_generator_with_auth_payload(protected_tester_t *tester)
 966 {
 967         generator_t *generator;
 968         auth_payload_t *auth_payload;
 969         logger_t *logger;
 970         chunk_t generated_data;
 971         chunk_t auth;
 972
 973         logger = logger_manager->get_logger(logger_manager,TESTER);
 974
 975         /* create generator */
 976         generator = generator_create();
 977         tester->assert_true(tester,(generator != NULL), "generator create check");
 978
 979         auth_payload = auth_payload_create(FALSE);
 980
 981
 982         auth.ptr = "123456789012";
 983         auth.len = strlen(auth.ptr);
 984
 985         auth_payload->set_auth_method(auth_payload,SHARED_KEY_MESSAGE_INTEGRITY_CODE);
 986         auth_payload->set_data(auth_payload,auth);
 987
 988         generator->generate_payload(generator,(payload_t *)auth_payload);
 989         generator->write_to_chunk(generator,&generated_data);
 990         logger->log_chunk(logger,RAW,"generated payload",generated_data);
 991
 992
 993         u_int8_t expected_generation[] = {
 994                 /* payload header */
 995                 0x00,0x00,0x00,0x14,
 996                 0x02,0x00,0x00,0x00,
 997                 /* auth data */
 998                 0x31,0x32,0x33,0x34,
 999                 0x35,0x36,0x37,0x38,
1000                 0x39,0x30,0x31,0x32,
1001         };
1002
1003         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
1004
1005         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
1006
1007         chunk_free(&generated_data);
1008
1009         auth_payload->destroy(auth_payload);
1010         generator->destroy(generator);
1011 }
1012
1013 /*
1014  * Described in header.
1015  */
1016 void test_generator_with_ts_payload(protected_tester_t *tester)
1017 {
1018         generator_t *generator;
1019         ts_payload_t *ts_payload;
1020         traffic_selector_substructure_t *ts1, *ts2;
1021         host_t *start_host1, *start_host2, *end_host1, *end_host2;
1022         logger_t *logger;
1023         chunk_t generated_data;
1024
1025         logger = logger_manager->get_logger(logger_manager,TESTER);
1026
1027         /* create generator */
1028         generator = generator_create();
1029         tester->assert_true(tester,(generator != NULL), "generator create check");
1030
1031         ts_payload = ts_payload_create(TRUE);
1032
1033         /* first traffic selector */
1034         ts1 = traffic_selector_substructure_create();
1035
1036         start_host1 = host_create(AF_INET,"192.168.1.0",500);
1037         ts1->set_start_host(ts1,start_host1);
1038         start_host1->destroy(start_host1);
1039
1040         end_host1 = host_create(AF_INET,"192.168.1.255",500);
1041         ts1->set_end_host(ts1,end_host1);
1042         end_host1->destroy(end_host1);
1043
1044         ts_payload->add_traffic_selector_substructure(ts_payload,ts1);
1045
1046         /* second traffic selector */
1047
1048         ts2 = traffic_selector_substructure_create();
1049
1050         start_host2 = host_create(AF_INET,"0.0.0.0",0);
1051         ts2->set_start_host(ts2,start_host2);
1052         ts2->set_protocol_id(ts2,3);
1053         start_host2->destroy(start_host2);
1054
1055         end_host2 = host_create(AF_INET,"255.255.255.255",65535);
1056         ts2->set_end_host(ts2,end_host2);
1057         end_host2->destroy(end_host2);
1058
1059         ts_payload->add_traffic_selector_substructure(ts_payload,ts2);
1060
1061
1062         generator->generate_payload(generator,(payload_t *)ts_payload);
1063         generator->write_to_chunk(generator,&generated_data);
1064         logger->log_chunk(logger,RAW,"generated payload",generated_data);
1065
1066
1067         u_int8_t expected_generation[] = {
1068                 /* payload header */
1069                 0x00,0x00,0x00,0x28,
1070                 0x02,0x00,0x00,0x00,
1071
1072                 /* traffic selector 1 */
1073                 0x07,0x00,0x00,0x10,
1074                 0x01,0xF4,0x01,0xF4,
1075                 0xC0,0xA8,0x01,0x00,
1076                 0xC0,0xA8,0x01,0xFF,
1077
1078                 /* traffic selector 2 */
1079                 0x07,0x03,0x00,0x10,
1080                 0x00,0x00,0xFF,0xFF,
1081                 0x00,0x00,0x00,0x00,
1082                 0xFF,0xFF,0xFF,0xFF,
1083         };
1084
1085         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
1086
1087         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
1088
1089         chunk_free(&generated_data);
1090
1091         ts_payload->destroy(ts_payload);
1092         generator->destroy(generator);
1093 }
1094
1095 /*
1096  * Described in header.
1097  */
1098 void test_generator_with_cert_payload(protected_tester_t *tester)
1099 {
1100         generator_t *generator;
1101         cert_payload_t *cert_payload;
1102         logger_t *logger;
1103         chunk_t generated_data;
1104         chunk_t cert;
1105
1106         logger = logger_manager->get_logger(logger_manager,TESTER);
1107
1108         /* create generator */
1109         generator = generator_create();
1110         tester->assert_true(tester,(generator != NULL), "generator create check");
1111
1112         cert_payload = cert_payload_create();
1113
1114
1115         cert.ptr = "123456789012";
1116         cert.len = strlen(cert.ptr);
1117
1118         cert_payload->set_cert_encoding(cert_payload,PGP_CERTIFICATE);
1119         cert_payload->set_data(cert_payload,cert);
1120
1121         generator->generate_payload(generator,(payload_t *)cert_payload);
1122         generator->write_to_chunk(generator,&generated_data);
1123         logger->log_chunk(logger,RAW,"generated payload",generated_data);
1124
1125         u_int8_t expected_generation[] = {
1126                 /* payload header */
1127                 0x00,0x00,0x00,0x11,
1128                 0x02,
1129                 /* cert data */
1130                 0x31,0x32,0x33,0x34,
1131                 0x35,0x36,0x37,0x38,
1132                 0x39,0x30,0x31,0x32,
1133         };
1134
1135         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
1136
1137         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
1138
1139         chunk_free(&generated_data);
1140
1141         cert_payload->destroy(cert_payload);
1142         generator->destroy(generator);
1143 }
1144
1145 /*
1146  * Described in header.
1147  */
1148 void test_generator_with_certreq_payload(protected_tester_t *tester)
1149 {
1150         generator_t *generator;
1151         certreq_payload_t *certreq_payload;
1152         logger_t *logger;
1153         chunk_t generated_data;
1154         chunk_t certreq;
1155
1156         logger = logger_manager->get_logger(logger_manager,TESTER);
1157
1158         /* create generator */
1159         generator = generator_create();
1160         tester->assert_true(tester,(generator != NULL), "generator create check");
1161
1162         certreq_payload = certreq_payload_create();
1163
1164
1165         certreq.ptr = "123456789012";
1166         certreq.len = strlen(certreq.ptr);
1167
1168         certreq_payload->set_cert_encoding(certreq_payload,PGP_CERTIFICATE);
1169         certreq_payload->set_data(certreq_payload,certreq);
1170
1171         generator->generate_payload(generator,(payload_t *)certreq_payload);
1172         generator->write_to_chunk(generator,&generated_data);
1173         logger->log_chunk(logger,RAW,"generated payload",generated_data);
1174
1175         u_int8_t expected_generation[] = {
1176                 /* payload header */
1177                 0x00,0x00,0x00,0x11,
1178                 0x02,
1179                 /* certreq data */
1180                 0x31,0x32,0x33,0x34,
1181                 0x35,0x36,0x37,0x38,
1182                 0x39,0x30,0x31,0x32,
1183         };
1184
1185         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
1186
1187         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
1188
1189         chunk_free(&generated_data);
1190
1191         certreq_payload->destroy(certreq_payload);
1192         generator->destroy(generator);
1193 }
1194
1195 /*
1196  * Described in header.
1197  */
1198 void test_generator_with_delete_payload(protected_tester_t *tester)
1199 {
1200         generator_t *generator;
1201         delete_payload_t *delete_payload;
1202         logger_t *logger;
1203         chunk_t generated_data;
1204         chunk_t spis;
1205
1206         logger = logger_manager->get_logger(logger_manager,TESTER);
1207
1208         /* create generator */
1209         generator = generator_create();
1210         tester->assert_true(tester,(generator != NULL), "generator create check");
1211
1212         delete_payload = delete_payload_create();
1213
1214
1215         spis.ptr = "123456789012";
1216         spis.len = strlen(spis.ptr);
1217
1218         delete_payload->set_protocol_id(delete_payload, PROTO_AH);
1219         delete_payload->set_spi_count(delete_payload,3);
1220         delete_payload->set_spi_size(delete_payload,4);
1221         delete_payload->set_spis(delete_payload,spis);
1222
1223         generator->generate_payload(generator,(payload_t *)delete_payload);
1224         generator->write_to_chunk(generator,&generated_data);
1225         logger->log_chunk(logger,RAW,"generated payload",generated_data);
1226
1227         u_int8_t expected_generation[] = {
1228                 /* payload header */
1229                 0x00,0x00,0x00,0x14,
1230                 0x02,0x04,0x00,0x03,
1231                 /* delete data */
1232                 0x31,0x32,0x33,0x34,
1233                 0x35,0x36,0x37,0x38,
1234                 0x39,0x30,0x31,0x32,
1235         };
1236
1237         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
1238
1239         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
1240
1241         chunk_free(&generated_data);
1242
1243         delete_payload->destroy(delete_payload);
1244         generator->destroy(generator);
1245 }
1246
1247 /*
1248  * Described in header.
1249  */
1250 void test_generator_with_vendor_id_payload(protected_tester_t *tester)
1251 {
1252         generator_t *generator;
1253         vendor_id_payload_t *vendor_id_payload;
1254         logger_t *logger;
1255         chunk_t generated_data;
1256         chunk_t data;
1257
1258         logger = logger_manager->get_logger(logger_manager,TESTER);
1259
1260         /* create generator */
1261         generator = generator_create();
1262         tester->assert_true(tester,(generator != NULL), "generator create check");
1263
1264         vendor_id_payload = vendor_id_payload_create();
1265
1266
1267         data.ptr = "123456789012";
1268         data.len = strlen(data.ptr);
1269 ;
1270         vendor_id_payload->set_data(vendor_id_payload,data);
1271         generator->generate_payload(generator,(payload_t *)vendor_id_payload);
1272         generator->write_to_chunk(generator,&generated_data);
1273         logger->log_chunk(logger,RAW,"generated payload",generated_data);
1274
1275         u_int8_t expected_generation[] = {
1276                 /* payload header */
1277                 0x00,0x00,0x00,0x10,
1278                 /* vendor_id data */
1279                 0x31,0x32,0x33,0x34,
1280                 0x35,0x36,0x37,0x38,
1281                 0x39,0x30,0x31,0x32,
1282         };
1283
1284         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
1285
1286         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
1287
1288         chunk_free(&generated_data);
1289
1290         vendor_id_payload->destroy(vendor_id_payload);
1291         generator->destroy(generator);
1292 }
1293
1294 /*
1295  * Described in header
1296  */
1297 void test_generator_with_cp_payload(protected_tester_t *tester)
1298 {
1299         generator_t *generator;
1300         configuration_attribute_t *attribute1, *attribute2;
1301         cp_payload_t *configuration;
1302         chunk_t data;
1303         chunk_t generated_data;
1304         logger_t *logger;
1305
1306         logger = logger_manager->get_logger(logger_manager,TESTER);
1307
1308         /* create generator */
1309         generator = generator_create();
1310         tester->assert_true(tester,(generator != NULL), "generator create check");
1311
1312         /* create attribute 1 */
1313         attribute1 = configuration_attribute_create();
1314         char *stringval = "abcd";
1315         data.ptr = (void *) stringval;
1316         data.len = 4;
1317         attribute1->set_value(attribute1,data);
1318         attribute1->set_attribute_type(attribute1,3);
1319         logger->log(logger,CONTROL,"attribute1 created");
1320
1321         /* create attribute 2 */
1322         attribute2 = configuration_attribute_create();
1323         stringval = "efgh";
1324         data.ptr = (void *) stringval;
1325         data.len = 4;
1326         attribute2->set_value(attribute2,data);
1327         attribute2->set_attribute_type(attribute2,4);
1328         logger->log(logger,CONTROL,"attribute2 created");
1329
1330         /* create configuration */
1331         configuration = cp_payload_create();
1332         tester->assert_true(tester,(configuration != NULL), "configuration create check");
1333         configuration->add_configuration_attribute(configuration,attribute1);
1334         configuration->add_configuration_attribute(configuration,attribute2);
1335         configuration->set_config_type(configuration,5); /* hex 5 */
1336
1337
1338         logger->log(logger,CONTROL,"cp payload created");
1339
1340         generator->generate_payload(generator,(payload_t *)configuration);
1341         generator->write_to_chunk(generator,&generated_data);
1342         logger->log_chunk(logger,RAW,"generated configuration",generated_data);
1343
1344         u_int8_t expected_generation3[] = {
1345                 /* cp payload header */
1346                 0x00,0x00,0x00,0x18,
1347                 0x05,0x00,0x00,0x00,
1348                 /* configuration attribute 1*/
1349                 0x00,0x03,0x00,0x04,
1350                 0x61,0x62,0x63,0x64,
1351                 /* configuration attribute 2*/
1352                 0x00,0x04,0x00,0x04,
1353                 0x65,0x66,0x67,0x68,
1354         };
1355
1356         logger->log_bytes(logger,RAW,"expected configuration",expected_generation3,sizeof(expected_generation3));
1357
1358         tester->assert_true(tester,(memcmp(expected_generation3,generated_data.ptr,sizeof(expected_generation3)) == 0), "compare generated data");
1359
1360         chunk_free(&generated_data);
1361         configuration->destroy(configuration);
1362         generator->destroy(generator);
1363 }
1364
1365 /*
1366  * Described in header.
1367  */
1368 void test_generator_with_eap_payload(protected_tester_t *tester)
1369 {
1370         generator_t *generator;
1371         eap_payload_t *eap_payload;
1372         logger_t *logger;
1373         chunk_t generated_data;
1374         chunk_t message;
1375
1376         logger = logger_manager->get_logger(logger_manager,TESTER);
1377
1378         /* create generator */
1379         generator = generator_create();
1380         tester->assert_true(tester,(generator != NULL), "generator create check");
1381
1382         eap_payload = eap_payload_create();
1383
1384
1385         message.ptr = "123456789012";
1386         message.len = strlen(message.ptr);
1387 ;
1388         eap_payload->set_message(eap_payload,message);
1389         generator->generate_payload(generator,(payload_t *)eap_payload);
1390         generator->write_to_chunk(generator,&generated_data);
1391         logger->log_chunk(logger,RAW,"generated payload",generated_data);
1392
1393         u_int8_t expected_generation[] = {
1394                 /* payload header */
1395                 0x00,0x00,0x00,0x10,
1396                 /* eap data */
1397                 0x31,0x32,0x33,0x34,
1398                 0x35,0x36,0x37,0x38,
1399                 0x39,0x30,0x31,0x32,
1400         };
1401
1402         logger->log_bytes(logger,RAW,"expected payload",expected_generation,sizeof(expected_generation));
1403
1404         tester->assert_true(tester,(memcmp(expected_generation,generated_data.ptr,sizeof(expected_generation)) == 0), "compare generated data");
1405
1406         chunk_free(&generated_data);
1407
1408         eap_payload->destroy(eap_payload);
1409         generator->destroy(generator);
1410 }