Source/charon/testcases/parser_test.c

   1 /**
   2  * @file parser_test.c
   3  *
   4  * @brief Tests for the parser_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 "parser_test.h"
  26
  27 #include <utils/allocator.h>
  28 #include <utils/logger_manager.h>
  29 #include <encoding/generator.h>
  30 #include <encoding/parser.h>
  31 #include <encoding/payloads/encodings.h>
  32 #include <encoding/payloads/ike_header.h>
  33 #include <encoding/payloads/sa_payload.h>
  34 #include <encoding/payloads/nonce_payload.h>
  35 #include <encoding/payloads/id_payload.h>
  36 #include <encoding/payloads/ke_payload.h>
  37 #include <encoding/payloads/notify_payload.h>
  38 #include <encoding/payloads/auth_payload.h>
  39 #include <encoding/payloads/cert_payload.h>
  40 #include <encoding/payloads/certreq_payload.h>
  41 #include <encoding/payloads/ts_payload.h>
  42 #include <encoding/payloads/delete_payload.h>
  43 #include <encoding/payloads/vendor_id_payload.h>
  44 #include <encoding/payloads/cp_payload.h>
  45 #include <encoding/payloads/eap_payload.h>
  46
  47
  48 /*
  49  * Described in Header
  50  */
  51 void test_parser_with_header_payload(protected_tester_t *tester)
  52 {
  53         parser_t *parser;
  54         ike_header_t *ike_header;
  55         status_t status;
  56         chunk_t header_chunk;
  57
  58         u_int8_t header_bytes[] = {
  59                 0x01,0x00,0x00,0x00,
  60                 0x00,0x00,0x00,0x00,
  61                 0x02,0x00,0x00,0x00,
  62                 0x00,0x00,0x00,0x00,
  63                 0x03,0x45,0x06,0x28,
  64                 0x00,0x00,0x00,0x07,
  65                 0x00,0x00,0x00,0x1C,
  66         };
  67         header_chunk.ptr = header_bytes;
  68         header_chunk.len = sizeof(header_bytes);
  69
  70
  71         parser = parser_create(header_chunk);
  72         tester->assert_true(tester,(parser != NULL), "parser create check");
  73         status = parser->parse_payload(parser, HEADER, (payload_t**)&ike_header);
  74         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
  75         parser->destroy(parser);
  76
  77         if (status != SUCCESS)
  78         {
  79                 return;
  80         }
  81
  82         tester->assert_true(tester,(ike_header->get_initiator_spi(ike_header) == 1),"parsed initiator_spi value");
  83         tester->assert_true(tester,(ike_header->get_responder_spi(ike_header) == 2),"parsed responder_spi value");
  84         tester->assert_true(tester,(ike_header->payload_interface.get_next_type((payload_t*)ike_header) == 3),"parsed next_payload value");
  85         tester->assert_true(tester,(ike_header->get_maj_version(ike_header) == 4),"parsed maj_version value");
  86         tester->assert_true(tester,(ike_header->get_min_version(ike_header) == 5),"parsed min_version value");
  87         tester->assert_true(tester,(ike_header->get_exchange_type(ike_header) == 6),"parsed exchange_type value");
  88         tester->assert_true(tester,(ike_header->get_initiator_flag(ike_header) == TRUE),"parsed flags.initiator value");
  89         tester->assert_true(tester,(ike_header->get_version_flag(ike_header) == FALSE),"parsed flags.version value");
  90         tester->assert_true(tester,(ike_header->get_response_flag(ike_header) == TRUE),"parsed flags.response value");
  91         tester->assert_true(tester,(ike_header->get_message_id(ike_header) == 7),"parsed message_id value");
  92         tester->assert_true(tester,(ike_header->payload_interface.get_length((payload_t*)ike_header) == 0x1C),"parsed length value");
  93
  94         ike_header->destroy(ike_header);
  95 }
  96
  97 /*
  98  * Described in Header
  99  */
 100 void test_parser_with_sa_payload(protected_tester_t *tester)
 101 {
 102         parser_t *parser;
 103         sa_payload_t *sa_payload;
 104         status_t status;
 105         chunk_t sa_chunk, sa_chunk2, sa_chunk3;
 106         iterator_t *proposals, *transforms, *attributes;
 107
 108         /* first test generic parsing functionality */
 109
 110         u_int8_t sa_bytes[] = {
 111                 0x00,0x80,0x00,0x24, /* payload header*/
 112                         0x00,0x00,0x00,0x20,  /* a proposal */
 113                         0x01,0x02,0x04,0x05,
 114                         0x01,0x02,0x03,0x04, /* spi */
 115                                 0x00,0x00,0x00,0x14, /* transform */
 116                                 0x07,0x00,0x00,0x03,
 117                                         0x80,0x01,0x00,0x05, /* attribute without length */
 118                                         0x00,0x03,0x00,0x04, /* attribute with length */
 119                                                 0x01,0x02,0x03,0x04
 120
 121
 122         };
 123
 124         sa_chunk.ptr = sa_bytes;
 125         sa_chunk.len = sizeof(sa_bytes);
 126
 127
 128         parser = parser_create(sa_chunk);
 129         tester->assert_true(tester,(parser != NULL), "parser create check");
 130         status = parser->parse_payload(parser, SECURITY_ASSOCIATION, (payload_t**)&sa_payload);
 131         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 132         parser->destroy(parser);
 133
 134         if (status != SUCCESS)
 135         {
 136                 return;
 137         }
 138
 139
 140         proposals = sa_payload->create_proposal_substructure_iterator(sa_payload, TRUE);
 141         while (proposals->has_next(proposals))
 142         {
 143                 proposal_substructure_t *proposal;
 144                 proposals->current(proposals, (void**)&proposal);
 145                 chunk_t spi;
 146                 u_int8_t spi_should[] = {0x01, 0x02, 0x03, 0x04};
 147
 148                 tester->assert_true(tester,(proposal->get_proposal_number(proposal) == 1),"proposal number");
 149                 tester->assert_true(tester,(proposal->get_protocol_id(proposal) == 2),"proposal id");
 150                 spi = proposal->get_spi(proposal);
 151                 tester->assert_false(tester,(memcmp(&spi_should, spi.ptr, spi.len)),"proposal spi");
 152
 153                 transforms = proposal->create_transform_substructure_iterator(proposal, TRUE);
 154                 while(transforms->has_next(transforms))
 155                 {
 156                         transform_substructure_t *transform;
 157                         int loopi;
 158                         transforms->current(transforms, (void**)&transform);
 159                         tester->assert_true(tester,(transform->get_transform_type(transform) == 7),"transform type");
 160                         tester->assert_true(tester,(transform->get_transform_id(transform) == 3),"transform id");
 161                         attributes = transform->create_transform_attribute_iterator(transform, TRUE);
 162                         loopi = 0;
 163                         while (attributes->has_next(attributes))
 164                         {
 165                                 transform_attribute_t *attribute;
 166                                 attributes->current(attributes, (void**)&attribute);
 167                                 if (loopi == 0)
 168                                 {
 169                                         u_int8_t value[] = {0x05, 0x00};
 170                                         chunk_t attribute_value;
 171                                         tester->assert_true(tester,(attribute->get_attribute_type(attribute) == 1),"attribute 1 type");
 172                                         attribute_value = attribute->get_value_chunk(attribute);
 173                                         tester->assert_false(tester,(memcmp(&value, attribute_value.ptr, attribute_value.len)),"attribute 1 value");
 174                                 }
 175                                 if (loopi == 1)
 176                                 {
 177                                         u_int8_t value[] = {0x01, 0x02, 0x03, 0x04};
 178                                         chunk_t attribute_value;
 179                                         tester->assert_true(tester,(attribute->get_attribute_type(attribute) == 3),"attribute 2 type");
 180                                         attribute_value = attribute->get_value_chunk(attribute);
 181                                         tester->assert_false(tester,(memcmp(&value, attribute_value.ptr, attribute_value.len)),"attribute 2 value");
 182                                 }
 183                                 loopi++;
 184                         }
 185                         attributes->destroy(attributes);
 186                 }
 187                 transforms->destroy(transforms);
 188         }
 189         proposals->destroy(proposals);
 190
 191         sa_payload->destroy(sa_payload);
 192
 193
 194
 195         /* now test SA functionality after parsing an SA payload*/
 196
 197         u_int8_t sa_bytes2[] = {
 198                 0x00,0x00,0x00,0x6C, /* payload header*/
 199                         0x02,0x00,0x00,0x34,  /* a proposal */
 200                         0x01,0x01,0x00,0x04,
 201                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 202                                 0x01,0x00,0x00,0x01,
 203                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 204                                 0x03,0x00,0x00,0x0C, /* transform 2 */
 205                                 0x02,0x00,0x00,0x01,
 206                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 207                                 0x03,0x00,0x00,0x0C, /* transform 3 */
 208                                 0x03,0x00,0x00,0x01,
 209                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 210                                 0x00,0x00,0x00,0x08, /* transform 4 */
 211                                 0x04,0x00,0x00,0x01,
 212                         0x00,0x00,0x00,0x34,  /* a proposal */
 213                         0x01,0x01,0x00,0x04,
 214                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 215                                 0x01,0x00,0x00,0x02,
 216                                         0x80,0x0E,0x00,0x10, /* keylength attribute with 16 bytes length */
 217                                 0x03,0x00,0x00,0x0C, /* transform 2 */
 218                                 0x02,0x00,0x00,0x02,
 219                                         0x80,0x0E,0x00,0x10, /* keylength attribute with 16 bytes length */
 220                                 0x03,0x00,0x00,0x0C, /* transform 3 */
 221                                 0x03,0x00,0x00,0x02,
 222                                         0x80,0x0E,0x00,0x10, /* keylength attribute with 16 bytes length */
 223                                 0x00,0x00,0x00,0x08, /* transform 4 */
 224                                 0x04,0x00,0x00,0x02,
 225         };
 226
 227         sa_chunk2.ptr = sa_bytes2;
 228         sa_chunk2.len = sizeof(sa_bytes2);
 229
 230         parser = parser_create(sa_chunk2);
 231         tester->assert_true(tester,(parser != NULL), "parser create check");
 232         status = parser->parse_payload(parser, SECURITY_ASSOCIATION, (payload_t**)&sa_payload);
 233         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 234         parser->destroy(parser);
 235
 236         if (status != SUCCESS)
 237         {
 238                 return;
 239         }
 240
 241         status = sa_payload->payload_interface.verify(&(sa_payload->payload_interface));
 242         tester->assert_true(tester,(status == SUCCESS),"verify call check");
 243         /*
 244         status = sa_payload->get_ike_proposals (sa_payload, &ike_proposals, &ike_proposal_count);
 245         tester->assert_true(tester,(status == SUCCESS),"get ike proposals call check");
 246
 247         tester->assert_true(tester,(ike_proposal_count == 2),"ike proposal count check");
 248         tester->assert_true(tester,(ike_proposals[0].encryption_algorithm == 1),"ike proposal content check");
 249         tester->assert_true(tester,(ike_proposals[0].encryption_algorithm_key_length == 20),"ike proposal content check");
 250         tester->assert_true(tester,(ike_proposals[0].integrity_algorithm == 1),"ike proposal content check");
 251         tester->assert_true(tester,(ike_proposals[0].integrity_algorithm_key_length == 20),"ike proposal content check");
 252         tester->assert_true(tester,(ike_proposals[0].pseudo_random_function == 1),"ike proposal content check");
 253         tester->assert_true(tester,(ike_proposals[0].pseudo_random_function_key_length == 20),"ike proposal content check");
 254         tester->assert_true(tester,(ike_proposals[0].diffie_hellman_group == 1),"ike proposal content check");
 255
 256         tester->assert_true(tester,(ike_proposals[1].encryption_algorithm == 2),"ike proposal content check");
 257         tester->assert_true(tester,(ike_proposals[1].encryption_algorithm_key_length == 16),"ike proposal content check");
 258         tester->assert_true(tester,(ike_proposals[1].integrity_algorithm == 2),"ike proposal content check");
 259         tester->assert_true(tester,(ike_proposals[1].integrity_algorithm_key_length == 16),"ike proposal content check");
 260         tester->assert_true(tester,(ike_proposals[1].pseudo_random_function == 2),"ike proposal content check");
 261         tester->assert_true(tester,(ike_proposals[1].pseudo_random_function_key_length == 16),"ike proposal content check");
 262         tester->assert_true(tester,(ike_proposals[1].diffie_hellman_group == 2),"ike proposal content check");
 263
 264
 265         if (status == SUCCESS)
 266         {
 267                 allocator_free(ike_proposals);
 268         }
 269         */
 270         sa_payload->destroy(sa_payload);
 271
 272         /* now test SA functionality after parsing an SA payload with child sa proposals*/
 273         u_int8_t sa_bytes3[] = {
 274                 0x00,0x00,0x00,0xA0, /* payload header*/
 275
 276                         /* suite 1 */
 277                         0x02,0x00,0x00,0x28,  /* a proposal */
 278                         0x01,0x02,0x04,0x03,
 279                         0x01,0x01,0x01,0x01,
 280                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 281                                 0x03,0x00,0x00,0x01,
 282                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 283
 284                                 0x03,0x00,0x00,0x08, /* transform 2 */
 285                                 0x04,0x00,0x00,0x0E,
 286
 287                                 0x00,0x00,0x00,0x08, /* transform 3 */
 288                                 0x05,0x00,0x00,0x01,
 289
 290
 291                         0x02,0x00,0x00,0x20,  /* a proposal */
 292                         0x01,0x03,0x04,0x02,
 293                         0x02,0x02,0x02,0x02,
 294
 295                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 296                                 0x01,0x00,0x00,0x0C,
 297                                         0x80,0x0E,0x00,0x20, /* keylength attribute with 32 bytes length */
 298
 299                                 0x00,0x00,0x00,0x08, /* transform 2 */
 300                                 0x04,0x00,0x00,0x02,
 301
 302                         /* suite 2 */
 303                         0x02,0x00,0x00,0x28,  /* a proposal */
 304                         0x02,0x02,0x04,0x03,
 305                         0x01,0x01,0x01,0x01,
 306                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 307                                 0x03,0x00,0x00,0x01,
 308                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 309
 310                                 0x03,0x00,0x00,0x08, /* transform 2 */
 311                                 0x04,0x00,0x00,0x0E,
 312
 313                                 0x00,0x00,0x00,0x08, /* transform 3 */
 314                                 0x05,0x00,0x00,0x01,
 315
 316
 317                         0x00,0x00,0x00,0x2C,  /* a proposal */
 318                         0x02,0x03,0x04,0x03,
 319                         0x02,0x02,0x02,0x02,
 320
 321                                 0x03,0x00,0x00,0x0C, /* transform 1 */
 322                                 0x01,0x00,0x00,0x0C,
 323                                         0x80,0x0E,0x00,0x20, /* keylength attribute with 32 bytes length */
 324
 325                                 0x03,0x00,0x00,0x0C, /* transform 2 */
 326                                 0x03,0x00,0x00,0x01,
 327                                         0x80,0x0E,0x00,0x14, /* keylength attribute with 20 bytes length */
 328
 329                                 0x00,0x00,0x00,0x08, /* transform 3 */
 330                                 0x04,0x00,0x00,0x02,
 331         };
 332
 333         sa_chunk3.ptr = sa_bytes3;
 334         sa_chunk3.len = sizeof(sa_bytes3);
 335
 336         parser = parser_create(sa_chunk3);
 337         tester->assert_true(tester,(parser != NULL), "parser create check");
 338         status = parser->parse_payload(parser, SECURITY_ASSOCIATION, (payload_t**)&sa_payload);
 339         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 340         parser->destroy(parser);
 341
 342         if (status != SUCCESS)
 343         {
 344                 return;
 345         }
 346
 347         status = sa_payload->payload_interface.verify(&(sa_payload->payload_interface));
 348         tester->assert_true(tester,(status == SUCCESS),"verify call check");
 349 /*
 350         status = sa_payload->get_ike_proposals (sa_payload, &ike_proposals, &ike_proposal_count);
 351         tester->assert_false(tester,(status == SUCCESS),"get ike proposals call check");
 352
 353         status = sa_payload->get_proposals (sa_payload, &proposals, &proposal_count);
 354         tester->assert_true(tester,(status == SUCCESS),"get child proposals call check");
 355
 356
 357         tester->assert_true(tester,(proposal_count == 2),"child proposal count check");
 358         tester->assert_true(tester,(proposals[0].ah.is_set == TRUE),"is ah set check");
 359         tester->assert_true(tester,(proposals[0].ah.integrity_algorithm == AUTH_HMAC_MD5_96),"integrity_algorithm check");
 360         tester->assert_true(tester,(proposals[0].ah.integrity_algorithm_key_size == 20),"integrity_algorithm_key_size check");
 361         tester->assert_true(tester,(proposals[0].ah.diffie_hellman_group == MODP_2048_BIT),"diffie_hellman_group check");
 362         tester->assert_true(tester,(proposals[0].ah.extended_sequence_numbers == EXT_SEQ_NUMBERS),"extended_sequence_numbers check");
 363         tester->assert_true(tester,(proposals[0].ah.spi[0] == 1),"spi check");
 364         tester->assert_true(tester,(proposals[0].ah.spi[1] == 1),"spi check");
 365         tester->assert_true(tester,(proposals[0].ah.spi[2] == 1),"spi check");
 366         tester->assert_true(tester,(proposals[0].ah.spi[3] == 1),"spi check");
 367
 368         tester->assert_true(tester,(proposals[0].esp.is_set == TRUE),"is ah set check");
 369         tester->assert_true(tester,(proposals[0].esp.encryption_algorithm == ENCR_AES_CBC),"integrity_algorithm check");
 370         tester->assert_true(tester,(proposals[0].esp.encryption_algorithm_key_size == 32),"integrity_algorithm_key_size check");
 371         tester->assert_true(tester,(proposals[0].esp.diffie_hellman_group == MODP_1024_BIT),"diffie_hellman_group check");
 372         tester->assert_true(tester,(proposals[0].esp.integrity_algorithm == AUTH_UNDEFINED),"integrity_algorithm check");
 373         tester->assert_true(tester,(proposals[0].esp.spi[0] == 2),"spi check");
 374         tester->assert_true(tester,(proposals[0].esp.spi[1] == 2),"spi check");
 375         tester->assert_true(tester,(proposals[0].esp.spi[2] == 2),"spi check");
 376         tester->assert_true(tester,(proposals[0].esp.spi[3] == 2),"spi check");
 377
 378         tester->assert_true(tester,(proposals[1].ah.is_set == TRUE),"is ah set check");
 379         tester->assert_true(tester,(proposals[1].ah.integrity_algorithm == AUTH_HMAC_MD5_96),"integrity_algorithm check");
 380         tester->assert_true(tester,(proposals[1].ah.integrity_algorithm_key_size == 20),"integrity_algorithm_key_size check");
 381         tester->assert_true(tester,(proposals[1].ah.diffie_hellman_group == MODP_2048_BIT),"diffie_hellman_group check");
 382         tester->assert_true(tester,(proposals[1].ah.extended_sequence_numbers == EXT_SEQ_NUMBERS),"extended_sequence_numbers check");
 383         tester->assert_true(tester,(proposals[1].ah.spi[0] == 1),"spi check");
 384         tester->assert_true(tester,(proposals[1].ah.spi[1] == 1),"spi check");
 385         tester->assert_true(tester,(proposals[1].ah.spi[2] == 1),"spi check");
 386         tester->assert_true(tester,(proposals[1].ah.spi[3] == 1),"spi check");
 387
 388         tester->assert_true(tester,(proposals[1].esp.is_set == TRUE),"is ah set check");
 389         tester->assert_true(tester,(proposals[1].esp.encryption_algorithm == ENCR_AES_CBC),"integrity_algorithm check");
 390         tester->assert_true(tester,(proposals[1].esp.encryption_algorithm_key_size == 32),"integrity_algorithm_key_size check");
 391         tester->assert_true(tester,(proposals[1].esp.diffie_hellman_group == MODP_1024_BIT),"diffie_hellman_group check");
 392         tester->assert_true(tester,(proposals[1].esp.integrity_algorithm == AUTH_HMAC_MD5_96),"integrity_algorithm check");
 393         tester->assert_true(tester,(proposals[1].esp.integrity_algorithm_key_size == 20),"integrity_algorithm check");
 394         tester->assert_true(tester,(proposals[1].esp.spi[0] == 2),"spi check");
 395         tester->assert_true(tester,(proposals[1].esp.spi[1] == 2),"spi check");
 396         tester->assert_true(tester,(proposals[1].esp.spi[2] == 2),"spi check");
 397         tester->assert_true(tester,(proposals[1].esp.spi[3] == 2),"spi check");
 398
 399         if (status == SUCCESS)
 400         {
 401                 allocator_free(proposals);
 402         }
 403         */
 404
 405         sa_payload->destroy(sa_payload);
 406 }
 407
 408 /*
 409  * Described in Header
 410  */
 411 void test_parser_with_nonce_payload(protected_tester_t *tester)
 412 {
 413         parser_t *parser;
 414         nonce_payload_t *nonce_payload;
 415         status_t status;
 416         chunk_t nonce_chunk, result;
 417
 418         u_int8_t nonce_bytes[] = {
 419                 0x00,0x00,0x00,0x14, /* payload header */
 420                         0x00,0x01,0x02,0x03,  /* 16 Byte nonce */
 421                         0x04,0x05,0x06,0x07,
 422                         0x08,0x09,0x0A,0x2B,
 423                         0x0C,0x0D,0x0E,0x0F
 424         };
 425
 426         nonce_chunk.ptr = nonce_bytes;
 427         nonce_chunk.len = sizeof(nonce_bytes);
 428
 429         parser = parser_create(nonce_chunk);
 430         tester->assert_true(tester,(parser != NULL), "parser create check");
 431         status = parser->parse_payload(parser, NONCE, (payload_t**)&nonce_payload);
 432         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 433         parser->destroy(parser);
 434
 435         if (status != SUCCESS)
 436         {
 437                 return;
 438         }
 439         result = nonce_payload->get_nonce(nonce_payload);
 440         tester->assert_true(tester,(result.len == 16), "parsed nonce lenght");
 441         tester->assert_false(tester,(memcmp(nonce_bytes + 4, result.ptr, result.len)), "parsed nonce data");
 442         nonce_payload->destroy(nonce_payload);
 443         allocator_free_chunk(&result);
 444 }
 445
 446 /*
 447  * Described in Header
 448  */
 449 void test_parser_with_id_payload(protected_tester_t *tester)
 450 {
 451         parser_t *parser;
 452         id_payload_t *id_payload;
 453         status_t status;
 454         chunk_t id_chunk, result;
 455
 456         u_int8_t id_bytes[] = {
 457                 0x00,0x00,0x00,0x14, /* payload header */
 458                 0x05,0x01,0x02,0x03,
 459                         0x04,0x05,0x06,0x07,/* 12 Byte nonce */
 460                         0x08,0x09,0x0A,0x2B,
 461                         0x0C,0x0D,0x0E,0x0F
 462         };
 463
 464         id_chunk.ptr = id_bytes;
 465         id_chunk.len = sizeof(id_bytes);
 466
 467         parser = parser_create(id_chunk);
 468         tester->assert_true(tester,(parser != NULL), "parser create check");
 469         status = parser->parse_payload(parser, ID_INITIATOR, (payload_t**)&id_payload);
 470         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 471         parser->destroy(parser);
 472
 473         if (status != SUCCESS)
 474         {
 475                 return;
 476         }
 477         result = id_payload->get_data_clone(id_payload);
 478         tester->assert_true(tester,(id_payload->get_initiator(id_payload) == TRUE), "is IDi payload");
 479         tester->assert_true(tester,(id_payload->get_id_type(id_payload) == ID_IPV6_ADDR), "is ID_IPV6_ADDR ID type");
 480         tester->assert_true(tester,(result.len == 12), "parsed data lenght");
 481         tester->assert_false(tester,(memcmp(id_bytes + 8, result.ptr, result.len)), "parsed nonce data");
 482         id_payload->destroy(id_payload);
 483         allocator_free_chunk(&result);
 484 }
 485
 486
 487 /*
 488  * Described in Header
 489  */
 490 void test_parser_with_ke_payload(protected_tester_t *tester)
 491 {
 492         parser_t *parser;
 493         ke_payload_t *ke_payload;
 494         status_t status;
 495         chunk_t ke_chunk, result;
 496
 497         u_int8_t ke_bytes[] = {
 498                 0x00,0x00,0x00,0x18, /* payload header */
 499                 0x00,0x03,0x00,0x00, /* dh group 3 */
 500                         0x01,0x02,0x03,0x03, /* 16 Byte dh data */
 501                         0x04,0x05,0x06,0x07,
 502                         0x08,0x09,0x0A,0x2B,
 503                         0x0C,0x0D,0x0E,0x0F
 504         };
 505
 506         ke_chunk.ptr = ke_bytes;
 507         ke_chunk.len = sizeof(ke_bytes);
 508
 509         parser = parser_create(ke_chunk);
 510         tester->assert_true(tester,(parser != NULL), "parser create check");
 511         status = parser->parse_payload(parser, KEY_EXCHANGE, (payload_t**)&ke_payload);
 512         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 513         parser->destroy(parser);
 514
 515         if (status != SUCCESS)
 516         {
 517                 return;
 518         }
 519         tester->assert_true(tester,(ke_payload->get_dh_group_number(ke_payload) == 3), "DH group");
 520         result = ke_payload->get_key_exchange_data(ke_payload);
 521         tester->assert_true(tester,(result.len == 16), "parsed key lenght");
 522         tester->assert_false(tester,(memcmp(ke_bytes + 8, result.ptr, result.len)), "parsed key data");
 523         ke_payload->destroy(ke_payload);
 524 }
 525
 526
 527 /*
 528  * Described in Header
 529  */
 530 void test_parser_with_notify_payload(protected_tester_t *tester)
 531 {
 532         parser_t *parser;
 533         notify_payload_t *notify_payload;
 534         status_t status;
 535         chunk_t notify_chunk, result;
 536
 537         u_int8_t notify_bytes[] = {
 538                 0x00,0x00,0x00,0x1C, /* payload header */
 539                 0x03,0x04,0x00,0x01,
 540                         0x01,0x02,0x03,0x03, /* spi */
 541                         0x04,0x05,0x06,0x07, /* noti dati */
 542                         0x08,0x09,0x0A,0x2B,
 543                         0x0C,0x0D,0x0E,0x0F,
 544                         0x0C,0x0D,0x0E,0x0F
 545         };
 546
 547         notify_chunk.ptr = notify_bytes;
 548         notify_chunk.len = sizeof(notify_bytes);
 549
 550         parser = parser_create(notify_chunk);
 551         tester->assert_true(tester,(parser != NULL), "parser create check");
 552         status = parser->parse_payload(parser, NOTIFY, (payload_t**)&notify_payload);
 553         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 554         parser->destroy(parser);
 555
 556         if (status != SUCCESS)
 557         {
 558                 return;
 559         }
 560         tester->assert_true(tester,(notify_payload->get_protocol_id(notify_payload) == 3), "Protocol id");
 561         tester->assert_true(tester,(notify_payload->get_notify_message_type(notify_payload) == 1), "notify message type");
 562
 563         result = notify_payload->get_spi(notify_payload);
 564         tester->assert_false(tester,(memcmp(notify_bytes + 8, result.ptr, result.len)), "parsed spi");
 565
 566         result = notify_payload->get_notification_data(notify_payload);
 567         tester->assert_false(tester,(memcmp(notify_bytes + 12, result.ptr, result.len)), "parsed notification data");
 568
 569         notify_payload->destroy(notify_payload);
 570 }
 571
 572 /*
 573  * Described in Header
 574  */
 575 void test_parser_with_auth_payload(protected_tester_t *tester)
 576 {
 577         parser_t *parser;
 578         auth_payload_t *auth_payload;
 579         status_t status;
 580         chunk_t auth_chunk, result;
 581
 582         u_int8_t auth_bytes[] = {
 583                 0x00,0x00,0x00,0x14, /* payload header */
 584                 0x03,0x01,0x02,0x03,
 585                         0x04,0x05,0x06,0x07,/* 12 Byte nonce */
 586                         0x08,0x09,0x0A,0x2B,
 587                         0x0C,0x0D,0x0E,0x0F
 588         };
 589
 590         auth_chunk.ptr = auth_bytes;
 591         auth_chunk.len = sizeof(auth_bytes);
 592
 593         parser = parser_create(auth_chunk);
 594         tester->assert_true(tester,(parser != NULL), "parser create check");
 595         status = parser->parse_payload(parser, AUTHENTICATION, (payload_t**)&auth_payload);
 596         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 597         parser->destroy(parser);
 598
 599         if (status != SUCCESS)
 600         {
 601                 return;
 602         }
 603         result = auth_payload->get_data_clone(auth_payload);
 604         tester->assert_true(tester,(auth_payload->get_auth_method(auth_payload) == DSS_DIGITAL_SIGNATURE), "is DSS_DIGITAL_SIGNATURE method");
 605         tester->assert_true(tester,(result.len == 12), "parsed data lenght");
 606         tester->assert_false(tester,(memcmp(auth_bytes + 8, result.ptr, result.len)), "parsed nonce data");
 607         auth_payload->destroy(auth_payload);
 608         allocator_free_chunk(&result);
 609 }
 610
 611 /*
 612  * Described in Header
 613  */
 614 void test_parser_with_ts_payload(protected_tester_t *tester)
 615 {
 616         parser_t *parser;
 617         ts_payload_t *ts_payload;
 618         status_t status;
 619         chunk_t ts_chunk;
 620         traffic_selector_substructure_t *ts1, *ts2;
 621         host_t *start_host1, *start_host2, *end_host1, *end_host2;
 622         iterator_t *iterator;
 623
 624         u_int8_t ts_bytes[] = {
 625                 /* payload header */
 626                 0x00,0x00,0x00,0x28,
 627                 0x02,0x00,0x00,0x00,
 628
 629                         /* traffic selector 1 */
 630                         0x07,0x00,0x00,0x10,
 631                         0x01,0xF4,0x01,0xF4,
 632                         0xC0,0xA8,0x01,0x00,
 633                         0xC0,0xA8,0x01,0xFF,
 634
 635                         /* traffic selector 2 */
 636                         0x07,0x03,0x00,0x10,
 637                         0x00,0x00,0xFF,0xFF,
 638                         0x00,0x00,0x00,0x00,
 639                         0xFF,0xFF,0xFF,0xFF,
 640         };
 641
 642         ts_chunk.ptr = ts_bytes;
 643         ts_chunk.len = sizeof(ts_bytes);
 644
 645         parser = parser_create(ts_chunk);
 646         tester->assert_true(tester,(parser != NULL), "parser create check");
 647         status = parser->parse_payload(parser, TRAFFIC_SELECTOR_RESPONDER, (payload_t**)&ts_payload);
 648         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 649         parser->destroy(parser);
 650
 651         if (status != SUCCESS)
 652         {
 653                 return;
 654         }
 655
 656         iterator = ts_payload->create_traffic_selector_substructure_iterator(ts_payload,TRUE);
 657
 658         tester->assert_true(tester,(iterator->has_next(iterator)), "has next check");
 659
 660         /* check first ts */
 661         iterator->current(iterator,(void **)&ts1);
 662         tester->assert_true(tester,(ts1->get_protocol_id(ts1) == 0), "ip protocol id check");
 663         start_host1 = ts1->get_start_host(ts1);
 664         end_host1 = ts1->get_end_host(ts1);
 665         tester->assert_true(tester,(start_host1->get_port(start_host1) == 500), "start port check");
 666         tester->assert_true(tester,(end_host1->get_port(end_host1) == 500), "start port check");
 667         tester->assert_true(tester,(memcmp(start_host1->get_address(start_host1),"192.168.1.0",strlen("192.168.1.0")) == 0), "start address check");
 668         tester->assert_true(tester,(memcmp(end_host1->get_address(end_host1),"192.168.1.255",strlen("192.168.1.255")) == 0), "end address check");
 669
 670         start_host1->destroy(start_host1);
 671         end_host1->destroy(end_host1);
 672
 673         tester->assert_true(tester,(iterator->has_next(iterator)), "has next check");
 674
 675         /* check second ts */
 676
 677         iterator->current(iterator,(void **)&ts2);
 678
 679         tester->assert_true(tester,(ts2->get_protocol_id(ts2) == 3), "ip protocol id check");
 680         start_host2 = ts2->get_start_host(ts2);
 681         end_host2 = ts2->get_end_host(ts2);
 682         tester->assert_true(tester,(start_host2->get_port(start_host2) == 0), "start port check");
 683         tester->assert_true(tester,(end_host2->get_port(end_host2) == 65535), "start port check");
 684         tester->assert_true(tester,(memcmp(start_host2->get_address(start_host2),"0.0.0.0",strlen("0.0.0.0")) == 0), "start address check");
 685         tester->assert_true(tester,(memcmp(end_host2->get_address(end_host2),"255.255.255.255",strlen("255.255.255.255")) == 0), "end address check");
 686         start_host2->destroy(start_host2);
 687         end_host2->destroy(end_host2);
 688
 689
 690
 691         tester->assert_false(tester,(iterator->has_next(iterator)), "has next check");
 692
 693         iterator->destroy(iterator);
 694
 695         ts_payload->destroy(ts_payload);
 696 }
 697
 698 /*
 699  * Described in Header
 700  */
 701 void test_parser_with_cert_payload(protected_tester_t *tester)
 702 {
 703         parser_t *parser;
 704         cert_payload_t *cert_payload;
 705         status_t status;
 706         chunk_t cert_chunk, result;
 707
 708         u_int8_t cert_bytes[] = {
 709                 0x00,0x00,0x00,0x11, /* payload header */
 710                 0x03,
 711                         0x04,0x05,0x06,0x07,/* 12 Byte nonce */
 712                         0x08,0x09,0x0A,0x2B,
 713                         0x0C,0x0D,0x0E,0x0F
 714         };
 715
 716         cert_chunk.ptr = cert_bytes;
 717         cert_chunk.len = sizeof(cert_bytes);
 718
 719         parser = parser_create(cert_chunk);
 720         tester->assert_true(tester,(parser != NULL), "parser create check");
 721         status = parser->parse_payload(parser, CERTIFICATE, (payload_t**)&cert_payload);
 722         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 723         parser->destroy(parser);
 724
 725         if (status != SUCCESS)
 726         {
 727                 return;
 728         }
 729         result = cert_payload->get_data_clone(cert_payload);
 730         tester->assert_true(tester,(cert_payload->get_cert_encoding(cert_payload) == DNS_SIGNED_KEY), "is DNS_SIGNED_KEY encoding");
 731         tester->assert_true(tester,(result.len == 12), "parsed data lenght");
 732         tester->assert_false(tester,(memcmp(cert_bytes + 5, result.ptr, result.len)), "parsed data");
 733         cert_payload->destroy(cert_payload);
 734         allocator_free_chunk(&result);
 735 }
 736
 737 /*
 738  * Described in Header
 739  */
 740 void test_parser_with_certreq_payload(protected_tester_t *tester)
 741 {
 742         parser_t *parser;
 743         certreq_payload_t *certreq_payload;
 744         status_t status;
 745         chunk_t certreq_chunk, result;
 746
 747         u_int8_t certreq_bytes[] = {
 748                 0x00,0x00,0x00,0x11, /* payload header */
 749                 0x03,
 750                         0x04,0x05,0x06,0x07,/* 12 Byte data */
 751                         0x08,0x09,0x0A,0x2B,
 752                         0x0C,0x0D,0x0E,0x0F
 753         };
 754
 755         certreq_chunk.ptr = certreq_bytes;
 756         certreq_chunk.len = sizeof(certreq_bytes);
 757
 758         parser = parser_create(certreq_chunk);
 759         tester->assert_true(tester,(parser != NULL), "parser create check");
 760         status = parser->parse_payload(parser, CERTIFICATE_REQUEST, (payload_t**)&certreq_payload);
 761         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 762         parser->destroy(parser);
 763
 764         if (status != SUCCESS)
 765         {
 766                 return;
 767         }
 768         result = certreq_payload->get_data_clone(certreq_payload);
 769         tester->assert_true(tester,(certreq_payload->get_cert_encoding(certreq_payload) == DNS_SIGNED_KEY), "is DNS_SIGNED_KEY encoding");
 770         tester->assert_true(tester,(result.len == 12), "parsed data lenght");
 771         tester->assert_false(tester,(memcmp(certreq_bytes + 5, result.ptr, result.len)), "parsed data");
 772         certreq_payload->destroy(certreq_payload);
 773         allocator_free_chunk(&result);
 774 }
 775
 776 /*
 777  * Described in Header
 778  */
 779 void test_parser_with_delete_payload(protected_tester_t *tester)
 780 {
 781         parser_t *parser;
 782         delete_payload_t *delete_payload;
 783         status_t status;
 784         chunk_t delete_chunk, result;
 785
 786         u_int8_t delete_bytes[] = {
 787                 0x00,0x00,0x00,0x14, /* payload header */
 788                 0x03,0x03,0x00,0x04,
 789                         0x04,0x05,0x06,0x07,/* 12 Byte data */
 790                         0x08,0x09,0x0A,0x2B,
 791                         0x0C,0x0D,0x0E,0x0F
 792         };
 793
 794         delete_chunk.ptr = delete_bytes;
 795         delete_chunk.len = sizeof(delete_bytes);
 796
 797         parser = parser_create(delete_chunk);
 798         tester->assert_true(tester,(parser != NULL), "parser create check");
 799         status = parser->parse_payload(parser, DELETE, (payload_t**)&delete_payload);
 800         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 801         parser->destroy(parser);
 802
 803         if (status != SUCCESS)
 804         {
 805                 return;
 806         }
 807         result = delete_payload->get_spis(delete_payload);
 808         tester->assert_true(tester,(delete_payload->get_protocol_id(delete_payload) == ESP), "is ESP protocol");
 809         tester->assert_true(tester,(delete_payload->get_spi_size(delete_payload) == 3), "SPI size check");
 810         tester->assert_true(tester,(delete_payload->get_spi_count(delete_payload) == 4), "SPI count check");
 811         tester->assert_true(tester,(result.len == 12), "parsed data lenght");
 812         tester->assert_false(tester,(memcmp(delete_bytes + 8, result.ptr, result.len)), "parsed data");
 813         tester->assert_true(tester,(((payload_t *)delete_payload)->verify((payload_t *)delete_payload) == SUCCESS), "verify check");
 814
 815         delete_payload->destroy(delete_payload);
 816 }
 817
 818
 819 /*
 820  * Described in Header
 821  */
 822 void test_parser_with_vendor_id_payload(protected_tester_t *tester)
 823 {
 824         parser_t *parser;
 825         vendor_id_payload_t *vendor_id_payload;
 826         status_t status;
 827         chunk_t vendor_id_chunk, result;
 828
 829         u_int8_t vendor_id_bytes[] = {
 830                 0x00,0x00,0x00,0x10, /* payload header */
 831                         0x04,0x05,0x06,0x07,/* 12 Byte data */
 832                         0x08,0x09,0x0A,0x2B,
 833                         0x0C,0x0D,0x0E,0x0F
 834         };
 835
 836         vendor_id_chunk.ptr = vendor_id_bytes;
 837         vendor_id_chunk.len = sizeof(vendor_id_bytes);
 838
 839         parser = parser_create(vendor_id_chunk);
 840         tester->assert_true(tester,(parser != NULL), "parser create check");
 841         status = parser->parse_payload(parser, VENDOR_ID, (payload_t**)&vendor_id_payload);
 842         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 843         parser->destroy(parser);
 844
 845         if (status != SUCCESS)
 846         {
 847                 return;
 848         }
 849         result = vendor_id_payload->get_data(vendor_id_payload);
 850         tester->assert_true(tester,(result.len == 12), "parsed data lenght");
 851         tester->assert_false(tester,(memcmp(vendor_id_bytes + 4, result.ptr, result.len)), "parsed data");
 852         tester->assert_true(tester,(((payload_t *)vendor_id_payload)->verify((payload_t *)vendor_id_payload) == SUCCESS), "verify check");
 853
 854         vendor_id_payload->destroy(vendor_id_payload);
 855 }
 856
 857 /*
 858  * Described in Header
 859  */
 860 void test_parser_with_cp_payload(protected_tester_t *tester)
 861 {
 862         parser_t *parser;
 863         cp_payload_t *cp_payload;
 864         configuration_attribute_t *attribute;
 865         status_t status;
 866         chunk_t cp_chunk;
 867         iterator_t *iterator;
 868
 869         /* first test generic parsing functionality */
 870
 871         u_int8_t cp_bytes[] = {
 872                 /* cp payload header */
 873                 0x00,0x00,0x00,0x18,
 874                 0x05,0x00,0x00,0x00,
 875                 /* configuration attribute 1*/
 876                 0x00,0x03,0x00,0x04,
 877                 0x61,0x62,0x63,0x64,
 878                 /* configuration attribute 2*/
 879                 0x00,0x04,0x00,0x04,
 880                 0x65,0x66,0x67,0x68,
 881         };
 882
 883         cp_chunk.ptr = cp_bytes;
 884         cp_chunk.len = sizeof(cp_bytes);
 885
 886
 887         parser = parser_create(cp_chunk);
 888         tester->assert_true(tester,(parser != NULL), "parser create check");
 889         status = parser->parse_payload(parser, CONFIGURATION, (payload_t**)&cp_payload);
 890         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 891
 892         iterator = cp_payload->create_configuration_attribute_iterator(cp_payload,TRUE);
 893
 894         tester->assert_true(tester,(iterator->has_next(iterator)),"has_next call check");
 895
 896         iterator->current(iterator,(void **)&attribute);
 897
 898
 899         tester->assert_true(tester,(attribute->get_attribute_type(attribute) == 3),"get type check");
 900         tester->assert_true(tester,(attribute->get_attribute_length(attribute) == 4),"get type check");
 901
 902         tester->assert_true(tester,(iterator->has_next(iterator)),"has_next call check");
 903
 904         iterator->current(iterator,(void **)&attribute);
 905
 906
 907         tester->assert_true(tester,(attribute->get_attribute_type(attribute) == 4),"get type check");
 908         tester->assert_true(tester,(attribute->get_attribute_length(attribute) == 4),"get type check");
 909
 910         iterator->current(iterator,(void **)&attribute);
 911
 912         tester->assert_false(tester,(iterator->has_next(iterator)),"has_next call check");
 913
 914
 915         iterator->destroy(iterator);
 916
 917         if (status != SUCCESS)
 918         {
 919                 return;
 920         }
 921
 922         cp_payload->destroy(cp_payload);
 923         parser->destroy(parser);
 924
 925 }
 926
 927 /*
 928  * Described in Header
 929  */
 930 void test_parser_with_eap_payload(protected_tester_t *tester)
 931 {
 932         parser_t *parser;
 933         eap_payload_t *eap_payload;
 934         status_t status;
 935         chunk_t eap_chunk, result;
 936
 937         u_int8_t eap_bytes[] = {
 938                 0x00,0x00,0x00,0x10, /* payload header */
 939                         0x04,0x05,0x06,0x07,/* 12 Byte data */
 940                         0x08,0x09,0x0A,0x2B,
 941                         0x0C,0x0D,0x0E,0x0F
 942         };
 943
 944         eap_chunk.ptr = eap_bytes;
 945         eap_chunk.len = sizeof(eap_bytes);
 946
 947         parser = parser_create(eap_chunk);
 948         tester->assert_true(tester,(parser != NULL), "parser create check");
 949         status = parser->parse_payload(parser, VENDOR_ID, (payload_t**)&eap_payload);
 950         tester->assert_true(tester,(status == SUCCESS),"parse_payload call check");
 951         parser->destroy(parser);
 952
 953         if (status != SUCCESS)
 954         {
 955                 return;
 956         }
 957         result = eap_payload->get_message(eap_payload);
 958         tester->assert_true(tester,(result.len == 12), "parsed data lenght");
 959         tester->assert_false(tester,(memcmp(eap_bytes + 4, result.ptr, result.len)), "parsed data");
 960         tester->assert_true(tester,(((payload_t *)eap_payload)->verify((payload_t *)eap_payload) == SUCCESS), "verify check");
 961
 962         eap_payload->destroy(eap_payload);
 963 }
 964