programs/charon/testing/encryption_payload_test.c

   1 /**
   2  * @file encryption_payload_test.c
   3  *
   4  * @brief Tests for the encryption_payload_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 "encryption_payload_test.h"
  26
  27 #include <daemon.h>
  28 #include <utils/logger_manager.h>
  29 #include <encoding/generator.h>
  30 #include <encoding/parser.h>
  31 #include <encoding/payloads/encryption_payload.h>
  32 #include <encoding/payloads/nonce_payload.h>
  33 #include <crypto/crypters/crypter.h>
  34 #include <crypto/signers/signer.h>
  35
  36 /*
  37  * described in Header-File
  38  */
  39 void test_encryption_payload(protected_tester_t *tester)
  40 {
  41         encryption_payload_t *encryption_payload;
  42         nonce_payload_t *nonce_payload;
  43         crypter_t *crypter;
  44         signer_t *signer;
  45         chunk_t nonce, got_nonce;
  46         chunk_t data;
  47         chunk_t key;
  48         generator_t *generator;
  49         parser_t *parser;
  50         status_t status;
  51         logger_t *logger;
  52         iterator_t *iterator;
  53
  54
  55         u_int8_t key_bytes[]  = {
  56                 0x01,0x01,0x01,0x01,
  57                 0x01,0x01,0x01,0x01,
  58                 0x01,0x01,0x01,0x01,
  59                 0x01,0x01,0x01,0x01
  60         };
  61         key.ptr = key_bytes;
  62         key.len = sizeof(key_bytes);
  63
  64         logger = logger_manager->get_logger(logger_manager, TESTER);
  65
  66         nonce.ptr = "test text und so...";
  67         nonce.len = strlen(nonce.ptr) + 1;
  68
  69         logger->log_chunk(logger, RAW, "nonce", nonce);
  70
  71         encryption_payload = encryption_payload_create();
  72         nonce_payload = nonce_payload_create();
  73         nonce_payload->set_nonce(nonce_payload, nonce);
  74
  75         encryption_payload->add_payload(encryption_payload, (payload_t*)nonce_payload);
  76         signer = signer_create(AUTH_HMAC_SHA1_96);
  77         crypter = crypter_create(ENCR_AES_CBC, 16);
  78
  79         signer->set_key(signer, key);
  80         crypter->set_key(crypter, key);
  81
  82
  83
  84         /* generating */
  85
  86         encryption_payload->set_transforms(encryption_payload, crypter, signer);
  87
  88         logger->log(logger, RAW, "encrypt");
  89         status = encryption_payload->encrypt(encryption_payload);
  90         tester->assert_true(tester, (status == SUCCESS), "encryption");
  91
  92         generator = generator_create();
  93         generator->generate_payload(generator, (payload_t*)encryption_payload);
  94
  95         generator->write_to_chunk(generator, &data);
  96         logger->log_chunk(logger, RAW, "generated data", data);
  97
  98         encryption_payload->build_signature(encryption_payload, data);
  99         logger->log_chunk(logger, RAW, "generated data", data);
 100
 101         encryption_payload->destroy(encryption_payload);
 102
 103
 104         /* parsing */
 105
 106         parser = parser_create(data);
 107         status = parser->parse_payload(parser, ENCRYPTED, (payload_t**)&encryption_payload);
 108         tester->assert_true(tester, (status == SUCCESS), "parsing");
 109
 110         encryption_payload->set_transforms(encryption_payload, crypter, signer);
 111         status = encryption_payload->verify_signature(encryption_payload, data);
 112         tester->assert_true(tester, (status == SUCCESS), "signature verification");
 113
 114         status = encryption_payload->decrypt(encryption_payload);
 115         tester->assert_true(tester, (status == SUCCESS), "decryption");
 116
 117
 118         iterator = encryption_payload->create_payload_iterator(encryption_payload, TRUE);
 119         while (iterator->has_next(iterator))
 120         {
 121                 iterator->current(iterator, (void**)&nonce_payload);
 122                 got_nonce = nonce_payload->get_nonce(nonce_payload);
 123         }
 124         iterator->destroy(iterator);
 125
 126
 127         tester->assert_true(tester, (got_nonce.len == nonce.len), "decrypted nonce");
 128         tester->assert_false(tester, memcmp(nonce.ptr, got_nonce.ptr, nonce.len), "decrypted nonce");
 129
 130         logger->log_chunk(logger, RAW, "nonce", got_nonce);
 131
 132         free(data.ptr);
 133         free(got_nonce.ptr);
 134         encryption_payload->destroy(encryption_payload);
 135         crypter->destroy(crypter);
 136         signer->destroy(signer);
 137         generator->destroy(generator);
 138         parser->destroy(parser);
 139 }