src/libstrongswan/tests/suites/test_hasher.c

   1 /*
   2  * Copyright (C) 2013-2015 Andreas Steffen
   3  * HSR Hochschule fuer Technik Rapperswil
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  */
  15
  16 #include "test_suite.h"
  17
  18 #include <crypto/hashers/hasher.h>
  19 #include <crypto/prfs/prf.h>
  20 #include <crypto/signers/signer.h>
  21 #include <asn1/oid.h>
  22 #include <utils/test.h>
  23
  24 typedef struct {
  25         int oid;
  26         hash_algorithm_t alg;
  27         key_type_t key;
  28 }hasher_oid_t;
  29
  30 static hasher_oid_t oids[] = {
  31         { OID_MD2, HASH_MD2, KEY_ANY },                         /*  0 */
  32         { OID_MD5, HASH_MD5, KEY_ANY },                         /*  1 */
  33         { OID_SHA1, HASH_SHA1, KEY_ANY },                       /*  2 */
  34         { OID_SHA224, HASH_SHA224, KEY_ANY },                   /*  3 */
  35         { OID_SHA256, HASH_SHA256, KEY_ANY },                   /*  4 */
  36         { OID_SHA384, HASH_SHA384, KEY_ANY },                   /*  5 */
  37         { OID_SHA512, HASH_SHA512, KEY_ANY },                   /*  6 */
  38         { OID_SHA3_224, HASH_SHA3_224, KEY_ANY },               /*  7 */
  39         { OID_SHA3_256, HASH_SHA3_256, KEY_ANY },               /*  8 */
  40         { OID_SHA3_384, HASH_SHA3_384, KEY_ANY },               /*  9 */
  41         { OID_SHA3_512, HASH_SHA3_512, KEY_ANY },               /* 10 */
  42         { OID_UNKNOWN, HASH_UNKNOWN, KEY_ANY },                 /* 11 */
  43         { OID_MD2_WITH_RSA, HASH_MD2, KEY_RSA },                /* 12 */
  44         { OID_MD5_WITH_RSA, HASH_MD5, KEY_RSA },                /* 13 */
  45         { OID_SHA1_WITH_RSA, HASH_SHA1, KEY_RSA },              /* 14 */
  46         { OID_SHA224_WITH_RSA, HASH_SHA224, KEY_RSA },          /* 15 */
  47         { OID_SHA256_WITH_RSA, HASH_SHA256, KEY_RSA },          /* 16 */
  48         { OID_SHA384_WITH_RSA, HASH_SHA384, KEY_RSA },          /* 17 */
  49         { OID_SHA512_WITH_RSA, HASH_SHA512, KEY_RSA },          /* 18 */
  50         { OID_UNKNOWN, HASH_UNKNOWN, KEY_RSA },                 /* 19 */
  51         { OID_ECDSA_WITH_SHA1, HASH_SHA1, KEY_ECDSA },          /* 20 */
  52         { OID_ECDSA_WITH_SHA256, HASH_SHA256, KEY_ECDSA },      /* 21 */
  53         { OID_ECDSA_WITH_SHA384, HASH_SHA384, KEY_ECDSA },      /* 22 */
  54         { OID_ECDSA_WITH_SHA512, HASH_SHA512, KEY_ECDSA },      /* 23 */
  55         { OID_UNKNOWN, HASH_UNKNOWN, KEY_ECDSA },               /* 24 */
  56         { OID_BLISS_WITH_SHA2_256, HASH_SHA256, KEY_BLISS },    /* 25 */
  57         { OID_BLISS_WITH_SHA2_384, HASH_SHA384, KEY_BLISS },    /* 26 */
  58         { OID_BLISS_WITH_SHA2_512, HASH_SHA512, KEY_BLISS },    /* 27 */
  59         { OID_BLISS_WITH_SHA3_256, HASH_SHA3_256, KEY_BLISS },  /* 28 */
  60         { OID_BLISS_WITH_SHA3_384, HASH_SHA3_384, KEY_BLISS },  /* 29 */
  61         { OID_BLISS_WITH_SHA3_512, HASH_SHA3_512, KEY_BLISS },  /* 30 */
  62         { OID_UNKNOWN, HASH_UNKNOWN, KEY_BLISS }                /* 31 */
  63 };
  64
  65 START_TEST(test_hasher_from_oid)
  66 {
  67         ck_assert(hasher_algorithm_from_oid(oids[_i].oid) == oids[_i].alg);
  68 }
  69 END_TEST
  70
  71 START_TEST(test_hasher_to_oid)
  72 {
  73         ck_assert(hasher_algorithm_to_oid(oids[_i].alg) == oids[_i].oid);
  74 }
  75 END_TEST
  76
  77 START_TEST(test_hasher_sig_to_oid)
  78 {
  79         ck_assert(hasher_signature_algorithm_to_oid(oids[_i].alg,
  80                                                                                                 oids[_i].key) == oids[_i].oid);
  81 }
  82 END_TEST
  83
  84 typedef struct {
  85         signature_scheme_t scheme;
  86         hash_algorithm_t alg;
  87 }hasher_sig_scheme_t;
  88
  89 static hasher_sig_scheme_t sig_schemes[] = {
  90         { SIGN_UNKNOWN,               HASH_UNKNOWN  },
  91         { SIGN_RSA_EMSA_PKCS1_NULL,   HASH_UNKNOWN  },
  92         { SIGN_RSA_EMSA_PKCS1_MD5,    HASH_MD5      },
  93         { SIGN_RSA_EMSA_PKCS1_SHA1,   HASH_SHA1     },
  94         { SIGN_RSA_EMSA_PKCS1_SHA224, HASH_SHA224   },
  95         { SIGN_RSA_EMSA_PKCS1_SHA256, HASH_SHA256   },
  96         { SIGN_RSA_EMSA_PKCS1_SHA384, HASH_SHA384   },
  97         { SIGN_RSA_EMSA_PKCS1_SHA512, HASH_SHA512   },
  98         { SIGN_ECDSA_WITH_SHA1_DER,   HASH_SHA1     },
  99         { SIGN_ECDSA_WITH_SHA256_DER, HASH_SHA256   },
 100         { SIGN_ECDSA_WITH_SHA384_DER, HASH_SHA384   },
 101         { SIGN_ECDSA_WITH_SHA512_DER, HASH_SHA512   },
 102         { SIGN_ECDSA_WITH_NULL,       HASH_UNKNOWN  },
 103         { SIGN_ECDSA_256,             HASH_SHA256   },
 104         { SIGN_ECDSA_384,             HASH_SHA384   },
 105         { SIGN_ECDSA_521,             HASH_SHA512   },
 106         { SIGN_BLISS_WITH_SHA2_256,   HASH_SHA256   },
 107         { SIGN_BLISS_WITH_SHA2_384,   HASH_SHA384   },
 108         { SIGN_BLISS_WITH_SHA2_512,   HASH_SHA512   },
 109         { SIGN_BLISS_WITH_SHA3_256,   HASH_SHA3_256 },
 110         { SIGN_BLISS_WITH_SHA3_384,   HASH_SHA3_384 },
 111         { SIGN_BLISS_WITH_SHA3_512,   HASH_SHA3_512 },
 112         { 30,                                             HASH_UNKNOWN  }
 113 };
 114
 115 START_TEST(test_hasher_from_sig_scheme)
 116 {
 117         ck_assert(hasher_from_signature_scheme(sig_schemes[_i].scheme) ==
 118                                                                                    sig_schemes[_i].alg);
 119 }
 120 END_TEST
 121
 122 typedef struct {
 123         pseudo_random_function_t prf;
 124         hash_algorithm_t alg;
 125 }hasher_prf_t;
 126
 127 static hasher_prf_t prfs[] = {
 128         { PRF_HMAC_MD5, HASH_MD5 },
 129         { PRF_HMAC_SHA1, HASH_SHA1 },
 130         { PRF_FIPS_SHA1_160, HASH_SHA1 },
 131         { PRF_KEYED_SHA1, HASH_SHA1 },
 132         { PRF_HMAC_SHA2_256, HASH_SHA256 },
 133         { PRF_HMAC_SHA2_384, HASH_SHA384 },
 134         { PRF_HMAC_SHA2_512, HASH_SHA512 },
 135         { PRF_HMAC_TIGER, HASH_UNKNOWN },
 136         { PRF_AES128_XCBC, HASH_UNKNOWN },
 137         { PRF_AES128_CMAC, HASH_UNKNOWN },
 138         { PRF_FIPS_DES, HASH_UNKNOWN },
 139         { PRF_CAMELLIA128_XCBC, HASH_UNKNOWN },
 140         { PRF_UNDEFINED, HASH_UNKNOWN },
 141         { 0, HASH_UNKNOWN }
 142 };
 143
 144 START_TEST(test_hasher_from_prf)
 145 {
 146         ck_assert(hasher_algorithm_from_prf(prfs[_i].prf) == prfs[_i].alg);
 147 }
 148 END_TEST
 149
 150 typedef struct {
 151         integrity_algorithm_t auth;
 152         hash_algorithm_t alg;
 153         size_t length;
 154 }hasher_auth_t;
 155
 156 static hasher_auth_t auths[] = {
 157         { AUTH_UNDEFINED, HASH_MD2, 0 },
 158         { AUTH_UNDEFINED, HASH_MD4, 0 },
 159         { AUTH_UNDEFINED, HASH_SHA224, 0 },
 160         { AUTH_UNDEFINED, 9, 0 },
 161         { AUTH_UNDEFINED, HASH_UNKNOWN, 0 },
 162         { AUTH_HMAC_MD5_96, HASH_MD5, 12 },
 163         { AUTH_HMAC_SHA1_96, HASH_SHA1, 12 },
 164         { AUTH_HMAC_SHA2_256_96, HASH_SHA256, 12 },
 165         { AUTH_HMAC_MD5_128, HASH_MD5, 16 },
 166         { AUTH_HMAC_SHA1_128, HASH_SHA1, 16 },
 167         { AUTH_HMAC_SHA2_256_128, HASH_SHA256, 16 },
 168         { AUTH_HMAC_SHA1_160, HASH_SHA1, 20 },
 169         { AUTH_HMAC_SHA2_384_192, HASH_SHA384, 24 },
 170         { AUTH_HMAC_SHA2_256_256, HASH_SHA256, 32 },
 171         { AUTH_HMAC_SHA2_512_256, HASH_SHA512, 32 },
 172         { AUTH_HMAC_SHA2_384_384, HASH_SHA384, 48 },
 173         { AUTH_HMAC_SHA2_512_512, HASH_SHA512, 64 },
 174         { AUTH_AES_CMAC_96, HASH_UNKNOWN, 0 },
 175         { AUTH_AES_128_GMAC, HASH_UNKNOWN, 0 },
 176         { AUTH_AES_192_GMAC, HASH_UNKNOWN, 0 },
 177         { AUTH_AES_256_GMAC, HASH_UNKNOWN, 0 },
 178         { AUTH_AES_XCBC_96, HASH_UNKNOWN, 0 },
 179         { AUTH_DES_MAC, HASH_UNKNOWN, 0 },
 180         { AUTH_CAMELLIA_XCBC_96, HASH_UNKNOWN, 0 },
 181         { 0, HASH_UNKNOWN, 0 }
 182 };
 183
 184 START_TEST(test_hasher_from_integrity)
 185 {
 186         size_t length;
 187
 188         length = 0;
 189         ck_assert(hasher_algorithm_from_integrity(auths[_i].auth, NULL) ==
 190                                                                                           auths[_i].alg);
 191         ck_assert(hasher_algorithm_from_integrity(auths[_i].auth, &length) ==
 192                                                                                           auths[_i].alg);
 193         ck_assert(length == auths[_i].length);
 194 }
 195 END_TEST
 196
 197 START_TEST(test_hasher_to_integrity)
 198 {
 199         ck_assert(hasher_algorithm_to_integrity(
 200                                                 auths[_i].alg, auths[_i].length) == auths[_i].auth);
 201         ck_assert(hasher_algorithm_to_integrity(
 202                                                 auths[_i].alg, 0) == AUTH_UNDEFINED);
 203 }
 204 END_TEST
 205
 206
 207 typedef struct {
 208         hash_algorithm_t alg;
 209         bool ikev2;
 210 }hasher_ikev2_t;
 211
 212 static hasher_ikev2_t ikev2[] = {
 213         { HASH_SHA1,     TRUE  },
 214         { HASH_SHA256,   TRUE  },
 215         { HASH_SHA384,   TRUE  },
 216         { HASH_SHA512,   TRUE  },
 217         { HASH_UNKNOWN,  FALSE },
 218         { HASH_MD2,      FALSE },
 219         { HASH_MD4,      FALSE },
 220         { HASH_MD5,      FALSE },
 221         { HASH_SHA224,   FALSE },
 222         { HASH_SHA3_224, FALSE },
 223         { HASH_SHA3_256, FALSE },
 224         { HASH_SHA3_384, FALSE },
 225         { HASH_SHA3_512, FALSE },
 226         { 30,            FALSE }
 227 };
 228
 229 START_TEST(test_hasher_for_ikev2)
 230 {
 231         ck_assert(hasher_algorithm_for_ikev2(ikev2[_i].alg) == ikev2[_i].ikev2);
 232 }
 233 END_TEST
 234
 235 Suite *hasher_suite_create()
 236 {
 237         Suite *s;
 238         TCase *tc;
 239
 240         s = suite_create("hasher");
 241
 242         tc = tcase_create("from_oid");
 243         tcase_add_loop_test(tc, test_hasher_from_oid, 0, 15);
 244         suite_add_tcase(s, tc);
 245
 246         tc = tcase_create("to_oid");
 247         tcase_add_loop_test(tc, test_hasher_to_oid, 0, 12);
 248         suite_add_tcase(s, tc);
 249
 250         tc = tcase_create("sig_to_oid");
 251         tcase_add_loop_test(tc, test_hasher_sig_to_oid, 11, countof(oids));
 252         suite_add_tcase(s, tc);
 253
 254         tc = tcase_create("from_sig_scheme");
 255         tcase_add_loop_test(tc, test_hasher_from_sig_scheme, 0, countof(sig_schemes));
 256         suite_add_tcase(s, tc);
 257
 258         tc = tcase_create("from_prf");
 259         tcase_add_loop_test(tc, test_hasher_from_prf, 0, countof(prfs));
 260         suite_add_tcase(s, tc);
 261
 262         tc = tcase_create("from_integrity");
 263         tcase_add_loop_test(tc, test_hasher_from_integrity, 4, countof(auths));
 264         suite_add_tcase(s, tc);
 265
 266         tc = tcase_create("to_integrity");
 267         tcase_add_loop_test(tc, test_hasher_to_integrity, 0, 17);
 268         suite_add_tcase(s, tc);
 269
 270         tc = tcase_create("for_ikev2");
 271         tcase_add_loop_test(tc, test_hasher_for_ikev2, 0, countof(ikev2));
 272         suite_add_tcase(s, tc);
 273
 274         return s;
 275 }