programs/charon/testing/hmac_signer_test.c

   1 /**
   2  * @file hmac_signer_test.c
   3  *
   4  * @brief Tests for the hmac_signer_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
  24 #include <string.h>
  25
  26 #include "hmac_signer_test.h"
  27
  28 #include <crypto/signers/signer.h>
  29 #include <daemon.h>
  30
  31
  32 /*
  33  * Described in header.
  34  */
  35 void test_hmac_md5_signer(protected_tester_t *tester)
  36 {
  37         /* Test cases from RFC2202
  38          *
  39          * test_case =     5
  40          * key =           0x0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c
  41          * key_len =       16
  42          * data =          "Test With Truncation"
  43          * data_len =      20
  44          * digest =        0x56461ef2342edc00f9bab995690efd4c
  45          * digest-96       0x56461ef2342edc00f9bab995
  46          *
  47          * currently only this test 5 gets performed!
  48          */
  49         chunk_t keys[4];
  50         chunk_t data[4];
  51         chunk_t signature[4];
  52         chunk_t reference[4];
  53         chunk_t wrong_reference[4];
  54         int i;
  55         logger_t *logger;
  56         bool valid;
  57
  58         logger = logger_manager->get_logger(logger_manager, TESTER);
  59
  60         signer_t *signer = (signer_t *) signer_create(AUTH_HMAC_MD5_96);
  61         tester->assert_true(tester, (signer != NULL), "signer create call check");
  62
  63
  64                 /*
  65          * values for test 5
  66          */
  67         u_int8_t key1[] = {
  68                 0x0c,0x0c,0x0c,0x0c,
  69                 0x0c,0x0c,0x0c,0x0c,
  70                 0x0c,0x0c,0x0c,0x0c,
  71                 0x0c,0x0c,0x0c,0x0c,
  72         };
  73         keys[0].ptr = key1;
  74         keys[0].len = sizeof(key1);
  75         data[0].ptr = "Test With Truncation";
  76         data[0].len = 20;
  77         u_int8_t reference1[] = {
  78                 0x56,0x46,0x1e,0xf2,0x34,0x2e,
  79                 0xdc,0x00,0xf9,0xba,0xb9,0x95
  80         };
  81         reference[0].ptr = reference1;
  82         reference[0].len = sizeof(reference1);
  83
  84         u_int8_t wrong_reference1[] = {
  85                 0x56,0x46,0x1e,0xa2,0x34,0x2e,
  86                 0xdc,0x00,0xf9,0xba,0xb9,0x95
  87         };
  88
  89         wrong_reference[0].ptr = wrong_reference1;
  90         wrong_reference[0].len = sizeof(wrong_reference1);
  91
  92         for (i=0; i<1; i++)
  93         {
  94                 signer->set_key(signer, keys[i]);
  95                 signer->allocate_signature(signer, data[i], &signature[i]);
  96                 tester->assert_true(tester, signature[i].len == 12, "chunk len");
  97                 tester->assert_true(tester, (memcmp(signature[i].ptr, reference[i].ptr, 12) == 0), "hmac value");
  98                 logger->log_chunk(logger,RAW,"expected signature:",reference[i]);
  99                 logger->log_chunk(logger,RAW,"signature:",signature[i]);
 100                 free(signature[i].ptr);
 101                 valid = signer->verify_signature(signer, data[i],reference[i]);
 102                 tester->assert_true(tester, (valid == TRUE), "Signature valid check");
 103
 104                 valid = signer->verify_signature(signer, data[i],wrong_reference[i]);
 105                 tester->assert_true(tester, (valid == FALSE), "Signature not valid check");
 106         }
 107         signer->destroy(signer);
 108 }
 109
 110
 111 /*
 112  * Described in header.
 113  */
 114 void test_hmac_sha1_signer(protected_tester_t *tester)
 115 {
 116         /*
 117          * test_case =     7
 118          * key =           0xaa repeated 80 times
 119          * key_len =       80
 120          * data =          "Test Using Larger Than Block-Size Key and Larger
 121          *                 Than One Block-Size Data"
 122          * data_len =      73
 123          * digest =        0x4c1a03424b55e07fe7f27be1d58bb9324a9a5a04
 124          * digest-96 =     0x4c1a03424b55e07fe7f27be1
 125          */
 126
 127         chunk_t keys[4];
 128         chunk_t data[4];
 129         chunk_t signature[4];
 130         chunk_t reference[4];
 131         chunk_t wrong_reference[4];
 132         int i;
 133         logger_t *logger;
 134         bool valid;
 135
 136         logger = logger_manager->get_logger(logger_manager, TESTER);
 137
 138         signer_t *signer = (signer_t *) signer_create(AUTH_HMAC_SHA1_96);
 139         tester->assert_true(tester, (signer != NULL), "signer create call check");
 140
 141
 142                 /*
 143          * values for test 5
 144          */
 145         u_int8_t key1[] = {
 146                 0xaa,0xaa,0xaa,0xaa,
 147                 0xaa,0xaa,0xaa,0xaa,
 148                 0xaa,0xaa,0xaa,0xaa,
 149                 0xaa,0xaa,0xaa,0xaa,
 150                 0xaa,0xaa,0xaa,0xaa,
 151                 0xaa,0xaa,0xaa,0xaa,
 152                 0xaa,0xaa,0xaa,0xaa,
 153                 0xaa,0xaa,0xaa,0xaa,
 154                 0xaa,0xaa,0xaa,0xaa,
 155                 0xaa,0xaa,0xaa,0xaa,
 156                 0xaa,0xaa,0xaa,0xaa,
 157                 0xaa,0xaa,0xaa,0xaa,
 158                 0xaa,0xaa,0xaa,0xaa,
 159                 0xaa,0xaa,0xaa,0xaa,
 160                 0xaa,0xaa,0xaa,0xaa,
 161                 0xaa,0xaa,0xaa,0xaa,
 162                 0xaa,0xaa,0xaa,0xaa,
 163                 0xaa,0xaa,0xaa,0xaa,
 164                 0xaa,0xaa,0xaa,0xaa,
 165                 0xaa,0xaa,0xaa,0xaa,
 166         };
 167         keys[0].ptr = key1;
 168         keys[0].len = sizeof(key1);
 169         data[0].ptr = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data";
 170         data[0].len = 73;
 171         u_int8_t reference1[] = {
 172                 0xe8,0xe9,0x9d,0x0f,0x45,0x23,
 173                 0x7d,0x78,0x6d,0x6b,0xba,0xa7
 174         };
 175         reference[0].ptr = reference1;
 176         reference[0].len = sizeof(reference1);
 177
 178         u_int8_t wrong_reference1[] = {
 179                 0xe8,0xe9,0x9d,0x0f,0x46,0x23,
 180                 0x7d,0x71,0x6d,0x6b,0xba,0xa7
 181         };
 182
 183         wrong_reference[0].ptr = wrong_reference1;
 184         wrong_reference[0].len = sizeof(wrong_reference1);
 185
 186         for (i=0; i<1; i++)
 187         {
 188                 signer->set_key(signer, keys[i]);
 189                 signer->allocate_signature(signer, data[i], &signature[i]);
 190                 tester->assert_true(tester, signature[i].len == 12, "chunk len");
 191                 tester->assert_true(tester, (memcmp(signature[i].ptr, reference[i].ptr, 12) == 0), "hmac value");
 192                 logger->log_chunk(logger,RAW,"expected signature:",reference[i]);
 193                 logger->log_chunk(logger,RAW,"signature:",signature[i]);
 194                 free(signature[i].ptr);
 195                 valid = signer->verify_signature(signer, data[i],reference[i]);
 196                 tester->assert_true(tester, (valid == TRUE), "Signature valid check");
 197
 198                 valid = signer->verify_signature(signer, data[i],wrong_reference[i]);
 199                 tester->assert_true(tester, (valid == FALSE), "Signature not valid check");
 200         }
 201
 202         signer->destroy(signer);
 203 }