tests/test_sign.cpp

   1 /*
   2  *  Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Lukasz Pawelczyk <l.pawelczyk@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18
  19 /**
  20  * @file    test_sign.cpp
  21  * @author  Lukasz Pawelczyk <l.pawelczyk@samsung.com>
  22  * @brief   Signature API unit tests.
  23  */
  24
  25 #include <boost/test/unit_test.hpp>
  26 #include <vector>
  27
  28 #include <yaca_crypto.h>
  29 #include <yaca_sign.h>
  30 #include <yaca_key.h>
  31 #include <yaca_digest.h>
  32 #include <yaca_error.h>
  33
  34 #include "common.h"
  35
  36
  37 namespace {
  38
  39 using update_fun_3_t = int(yaca_context_h ctx, const char *input, size_t input_len);
  40
  41 void call_update_loop(yaca_context_h &ctx, const char *input, size_t input_len,
  42                                           size_t split, update_fun_3_t *fun)
  43 {
  44         BOOST_REQUIRE_MESSAGE(split >= 1, "Fix your test");
  45
  46         int ret;
  47         size_t left = input_len;
  48         size_t part = input_len / split;
  49
  50         BOOST_REQUIRE_MESSAGE(part >= 1, "Fix your test");
  51
  52         for (;;) {
  53                 ret = fun(ctx, input, part);
  54                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
  55
  56                 input += part;
  57                 left -= part;
  58
  59                 if (left == 0)
  60                         break;
  61
  62                 if (left < part)
  63                         part = left;
  64         }
  65 }
  66
  67 } //namespace
  68
  69
  70 BOOST_AUTO_TEST_SUITE(TESTS_SIGN)
  71
  72 BOOST_FIXTURE_TEST_CASE(T801__positive__sign_verify, InitDebugFixture)
  73 {
  74         struct sign_args {
  75                 yaca_key_type_e type_prv;
  76                 yaca_key_bit_length_e key_bit_len;
  77                 yaca_digest_algorithm_e digest;
  78                 yaca_padding_e pad;
  79                 size_t split;
  80         };
  81
  82         const std::vector<sign_args> sargs = {
  83                 {YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT,
  84                  YACA_DIGEST_MD5, YACA_INVALID_PADDING, 27},
  85                 {YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT,
  86                  YACA_DIGEST_MD5, YACA_PADDING_PKCS1_PSS, 14},
  87                 {YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_2048BIT,
  88                  YACA_DIGEST_SHA1, YACA_PADDING_X931, 34},
  89                 {YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT,
  90                  YACA_DIGEST_SHA384, YACA_PADDING_PKCS1, 9},
  91                 {YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_2048BIT,
  92                  YACA_DIGEST_SHA512, YACA_PADDING_PKCS1_PSS, 12},
  93
  94                 {YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT,
  95                  YACA_DIGEST_SHA256, YACA_INVALID_PADDING, 5},
  96                 {YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT,
  97                  YACA_DIGEST_SHA224, YACA_INVALID_PADDING, 31},
  98                 {YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_2048BIT,
  99                  YACA_DIGEST_SHA1, YACA_INVALID_PADDING, 29},
 100                 {YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT,
 101                  YACA_DIGEST_SHA384, YACA_INVALID_PADDING, 19},
 102                 {YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_2048BIT,
 103                  YACA_DIGEST_SHA512, YACA_INVALID_PADDING, 11},
 104
 105                 {YACA_KEY_TYPE_EC_PRIV,
 106                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_EC_SECP256K1,
 107                  YACA_DIGEST_SHA256, YACA_INVALID_PADDING, 13},
 108                 {YACA_KEY_TYPE_EC_PRIV,
 109                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_EC_SECP384R1,
 110                  YACA_DIGEST_SHA224, YACA_INVALID_PADDING, 23},
 111                 {YACA_KEY_TYPE_EC_PRIV,
 112                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_EC_SECP521R1,
 113                  YACA_DIGEST_SHA1, YACA_INVALID_PADDING, 33},
 114                 {YACA_KEY_TYPE_EC_PRIV,
 115                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_EC_PRIME192V1,
 116                  YACA_DIGEST_SHA384, YACA_INVALID_PADDING, 22},
 117                 {YACA_KEY_TYPE_EC_PRIV,
 118                  (yaca_key_bit_length_e)YACA_KEY_LENGTH_EC_PRIME256V1,
 119                  YACA_DIGEST_SHA512, YACA_INVALID_PADDING, 20},
 120         };
 121
 122         for (const auto &sa: sargs) {
 123                 int ret;
 124                 yaca_context_h ctx = YACA_CONTEXT_NULL;
 125                 yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
 126
 127                 char *signature = NULL;
 128                 size_t signature_len;
 129
 130                 generate_asymmetric_keys(sa.type_prv, sa.key_bit_len, &key_prv, &key_pub);
 131
 132                 /* SIGN */
 133                 {
 134                         ret = yaca_sign_initialize(&ctx, sa.digest, key_prv);
 135                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 136
 137                         if (sa.pad != YACA_INVALID_PADDING) {
 138                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 139                                                                                                 &sa.pad, sizeof(sa.pad));
 140                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 141                         }
 142
 143                         call_update_loop(ctx, INPUT_DATA, INPUT_DATA_SIZE,
 144                                                          sa.split, &yaca_sign_update);
 145
 146                         ret = yaca_context_get_output_length(ctx, 0, &signature_len);
 147                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 148
 149                         ret = yaca_malloc(signature_len, (void **)&signature);
 150                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 151
 152                         ret = yaca_sign_finalize(ctx, signature, &signature_len);
 153                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 154
 155                         yaca_context_destroy(ctx);
 156                         ctx = YACA_CONTEXT_NULL;
 157                 }
 158
 159                 /* VERIFY */
 160                 {
 161                         ret = yaca_verify_initialize(&ctx, sa.digest, key_pub);
 162                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 163
 164                         if (sa.pad != YACA_INVALID_PADDING) {
 165                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 166                                                                                                 &sa.pad, sizeof(sa.pad));
 167                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 168                         }
 169
 170                         call_update_loop(ctx, INPUT_DATA, INPUT_DATA_SIZE,
 171                                                          sa.split + 3, &yaca_verify_update);
 172
 173                         ret = yaca_verify_finalize(ctx, signature, signature_len);
 174                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 175
 176                         yaca_context_destroy(ctx);
 177                         ctx = YACA_CONTEXT_NULL;
 178                 }
 179
 180                 yaca_key_destroy(key_prv);
 181                 yaca_key_destroy(key_pub);
 182                 yaca_free(signature);
 183         }
 184 }
 185
 186 BOOST_FIXTURE_TEST_CASE(T802__negative__sign_verify, InitDebugFixture)
 187 {
 188         int ret;
 189         yaca_context_h ctx = YACA_CONTEXT_NULL, ctx_digest = YACA_CONTEXT_NULL;
 190         yaca_key_h key_rsa_prv = YACA_KEY_NULL, key_rsa_pub = YACA_KEY_NULL;
 191         yaca_key_h key_rsa_prv2 = YACA_KEY_NULL, key_rsa_pub2 = YACA_KEY_NULL;
 192         yaca_key_h key_dsa_prv = YACA_KEY_NULL, key_dsa_pub = YACA_KEY_NULL;
 193         yaca_key_h key_sym = YACA_KEY_NULL, key_rsa_prv_short = YACA_KEY_NULL;
 194         yaca_padding_e pad_invalid = YACA_PADDING_X931, pad_none = YACA_PADDING_NONE;
 195         yaca_padding_e pad = YACA_PADDING_PKCS1, pad2 = YACA_PADDING_PKCS1_PSS;
 196
 197         size_t len = 128;
 198
 199         char *signature = NULL;
 200         size_t signature_len;
 201
 202         ret = yaca_digest_initialize(&ctx_digest, YACA_DIGEST_MD5);
 203         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 204         ret = yaca_key_generate(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT, &key_sym);
 205         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 206
 207         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT, &key_rsa_prv_short);
 208         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_rsa_prv, &key_rsa_pub);
 209         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_rsa_prv2, &key_rsa_pub2);
 210         generate_asymmetric_keys(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_dsa_prv, &key_dsa_pub);
 211
 212         /* SIGN */
 213         {
 214                 ret = yaca_sign_initialize(NULL, YACA_DIGEST_MD5, key_rsa_prv);
 215                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 216
 217                 ret = yaca_sign_initialize(&ctx, YACA_INVALID_DIGEST_ALGORITHM, key_rsa_prv);
 218                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 219
 220                 ret = yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, YACA_KEY_NULL);
 221                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 222
 223                 ret = yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, key_rsa_pub);
 224                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 225
 226                 ret = yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, key_sym);
 227                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 228
 229                 ret = yaca_sign_initialize(&ctx, YACA_DIGEST_SHA384, key_rsa_prv_short);
 230                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 231
 232                 ret = yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, key_rsa_prv);
 233                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 234
 235                 ret = yaca_context_set_property(ctx, YACA_INVALID_PROPERTY,
 236                                                                                 &pad, sizeof(pad));
 237                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 238
 239                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 240                                                                                 NULL, sizeof(pad));
 241                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 242
 243                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 244                                                                                 &pad, 1);
 245                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 246
 247                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
 248                                                                                 &len, sizeof(size_t));
 249                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 250
 251                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 252                                                                                 &pad_none, sizeof(pad_none));
 253                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 254
 255                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 256                                                                                 &pad_invalid, sizeof(pad_invalid));
 257                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 258
 259                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 260                                                                                 &pad, sizeof(pad));
 261                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 262
 263                 ret = yaca_sign_update(YACA_CONTEXT_NULL, INPUT_DATA, INPUT_DATA_SIZE);
 264                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 265
 266                 ret = yaca_sign_update(ctx, NULL, INPUT_DATA_SIZE);
 267                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 268
 269                 ret = yaca_sign_update(ctx, INPUT_DATA, 0);
 270                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 271
 272                 ret = yaca_sign_update(ctx_digest, INPUT_DATA, INPUT_DATA_SIZE);
 273                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 274
 275                 ret = yaca_sign_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 276                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 277
 278                 ret = yaca_context_get_output_length(ctx, 0, NULL);
 279                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 280
 281                 ret = yaca_context_get_output_length(ctx, 1, &signature_len);
 282                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 283
 284                 ret = yaca_context_get_output_length(ctx, 0, &signature_len);
 285                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 286
 287                 ret = yaca_malloc(signature_len, (void **)&signature);
 288                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 289
 290                 ret = yaca_sign_finalize(YACA_CONTEXT_NULL, signature, &signature_len);
 291                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 292
 293                 ret = yaca_sign_finalize(ctx, NULL, &signature_len);
 294                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 295
 296                 ret = yaca_sign_finalize(ctx, signature, NULL);
 297                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 298
 299                 ret = yaca_sign_finalize(ctx, signature, &signature_len);
 300                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 301
 302                 ret = yaca_sign_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 303                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 304
 305                 ret = yaca_sign_finalize(ctx, signature, &signature_len);
 306                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 307
 308                 yaca_context_destroy(ctx);
 309                 ctx = YACA_CONTEXT_NULL;
 310         }
 311
 312         /* VERIFY */
 313         {
 314                 ret = yaca_verify_initialize(NULL, YACA_DIGEST_MD5, key_rsa_pub);
 315                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 316
 317                 ret = yaca_verify_initialize(&ctx, YACA_INVALID_DIGEST_ALGORITHM, key_rsa_pub);
 318                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 319
 320                 ret = yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, YACA_KEY_NULL);
 321                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 322
 323                 ret = yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, key_rsa_prv);
 324                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 325
 326                 ret = yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, key_sym);
 327                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 328
 329                 ret = yaca_verify_initialize(&ctx, YACA_DIGEST_SHA384, key_rsa_prv_short);
 330                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 331
 332                 ret = yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, key_rsa_pub);
 333                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 334
 335                 ret = yaca_context_set_property(ctx, YACA_INVALID_PROPERTY,
 336                                                                                 &pad, sizeof(pad));
 337                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 338
 339                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 340                                                                                 NULL, sizeof(pad));
 341                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 342
 343                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 344                                                                                 &pad, 1);
 345                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 346
 347                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
 348                                                                                 &len, sizeof(size_t));
 349                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 350
 351                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 352                                                                                 &pad_none, sizeof(pad_none));
 353                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 354
 355                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 356                                                                                 &pad_invalid, sizeof(pad_invalid));
 357                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 358
 359                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 360                                                                                 &pad, sizeof(pad));
 361                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 362
 363                 ret = yaca_verify_update(YACA_CONTEXT_NULL, INPUT_DATA, INPUT_DATA_SIZE);
 364                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 365
 366                 ret = yaca_verify_update(ctx, NULL, INPUT_DATA_SIZE);
 367                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 368
 369                 ret = yaca_verify_update(ctx, INPUT_DATA, 0);
 370                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 371
 372                 ret = yaca_verify_update(ctx_digest, INPUT_DATA, INPUT_DATA_SIZE);
 373                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 374
 375                 ret = yaca_verify_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 376                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 377
 378                 ret = yaca_verify_finalize(YACA_CONTEXT_NULL, signature, signature_len);
 379                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 380
 381                 ret = yaca_verify_finalize(ctx, NULL, signature_len);
 382                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 383
 384                 ret = yaca_verify_finalize(ctx, signature, 0);
 385                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 386
 387                 ret = yaca_verify_finalize(ctx_digest, signature, signature_len);
 388                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 389
 390                 ret = yaca_verify_finalize(ctx, signature, signature_len - 1);
 391                 BOOST_REQUIRE(ret == YACA_ERROR_DATA_MISMATCH);
 392
 393                 ret = yaca_verify_finalize(ctx, signature + 1, signature_len - 1);
 394                 BOOST_REQUIRE(ret == YACA_ERROR_DATA_MISMATCH);
 395
 396                 ret = yaca_verify_finalize(ctx, signature, signature_len);
 397                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 398
 399                 ret = yaca_verify_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 400                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 401
 402                 ret = yaca_verify_finalize(ctx, signature, signature_len);
 403                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 404
 405                 yaca_context_destroy(ctx);
 406                 ctx = YACA_CONTEXT_NULL;
 407         }
 408
 409         /* VERIFY, wrong algo */
 410         {
 411                 ret = yaca_verify_initialize(&ctx, YACA_DIGEST_SHA1, key_rsa_pub);
 412                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 413
 414                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 415                                                                                 &pad, sizeof(pad));
 416                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 417
 418                 ret = yaca_verify_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 419                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 420
 421                 ret = yaca_verify_finalize(ctx, signature, signature_len);
 422                 BOOST_REQUIRE(ret == YACA_ERROR_DATA_MISMATCH);
 423
 424                 yaca_context_destroy(ctx);
 425                 ctx = YACA_CONTEXT_NULL;
 426         }
 427
 428         /* VERIFY, wrong key */
 429         {
 430                 ret = yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, key_rsa_pub2);
 431                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 432
 433                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 434                                                                                 &pad, sizeof(pad));
 435                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 436
 437                 ret = yaca_verify_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 438                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 439
 440                 ret = yaca_verify_finalize(ctx, signature, signature_len);
 441                 BOOST_REQUIRE(ret == YACA_ERROR_DATA_MISMATCH);
 442
 443                 yaca_context_destroy(ctx);
 444                 ctx = YACA_CONTEXT_NULL;
 445         }
 446
 447         /* VERIFY, wrong padding */
 448         {
 449                 ret = yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, key_rsa_pub);
 450                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 451
 452                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 453                                                                                 &pad2, sizeof(pad2));
 454                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 455
 456                 ret = yaca_verify_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 457                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 458
 459                 ret = yaca_verify_finalize(ctx, signature, signature_len);
 460                 BOOST_REQUIRE(ret == YACA_ERROR_DATA_MISMATCH);
 461
 462                 yaca_context_destroy(ctx);
 463                 ctx = YACA_CONTEXT_NULL;
 464         }
 465
 466         /* SIGN DSA */
 467         {
 468                 ret = yaca_sign_initialize(&ctx, YACA_DIGEST_SHA1, key_dsa_prv);
 469                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 470
 471                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 472                                                                                 &pad, sizeof(pad));
 473                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 474
 475                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 476                                                                                 &pad2, sizeof(pad2));
 477                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 478
 479                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 480                                                                                 &pad_invalid, sizeof(pad_invalid));
 481                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 482
 483                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 484                                                                                 &pad_none, sizeof(pad_none));
 485                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 486
 487                 yaca_context_destroy(ctx);
 488                 ctx = YACA_CONTEXT_NULL;
 489         }
 490
 491         /* VERIFY DSA */
 492         {
 493                 ret = yaca_verify_initialize(&ctx, YACA_DIGEST_SHA1, key_dsa_pub);
 494                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 495
 496                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 497                                                                                 &pad, sizeof(pad));
 498                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 499
 500                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 501                                                                                 &pad2, sizeof(pad2));
 502                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 503
 504                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 505                                                                                 &pad_invalid, sizeof(pad_invalid));
 506                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 507
 508                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 509                                                                                 &pad_none, sizeof(pad_none));
 510                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 511
 512                 yaca_context_destroy(ctx);
 513                 ctx = YACA_CONTEXT_NULL;
 514         }
 515
 516         yaca_key_destroy(key_rsa_prv);
 517         yaca_key_destroy(key_rsa_pub);
 518         yaca_key_destroy(key_rsa_prv2);
 519         yaca_key_destroy(key_rsa_pub2);
 520         yaca_key_destroy(key_rsa_prv_short);
 521         yaca_key_destroy(key_dsa_prv);
 522         yaca_key_destroy(key_dsa_pub);
 523         yaca_key_destroy(key_sym);
 524         yaca_context_destroy(ctx_digest);
 525         yaca_free(signature);
 526 }
 527
 528 BOOST_FIXTURE_TEST_CASE(T803__positive__sign_cmac, InitDebugFixture)
 529 {
 530         struct cmac_args {
 531                 yaca_key_type_e type;
 532                 yaca_key_bit_length_e len;
 533                 yaca_encrypt_algorithm_e algo;
 534                 size_t split;
 535         };
 536
 537         const std::vector<cmac_args> cargs = {
 538                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT,
 539                  YACA_ENCRYPT_AES, 11},
 540                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_UNSAFE_128BIT,
 541                  YACA_ENCRYPT_CAST5, 22},
 542                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT,
 543                  YACA_ENCRYPT_3DES_3TDEA, 33},
 544                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT,
 545                  YACA_ENCRYPT_UNSAFE_RC2, 44},
 546                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_UNSAFE_64BIT,
 547                  YACA_ENCRYPT_UNSAFE_DES, 13},
 548
 549                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT,
 550                  YACA_ENCRYPT_AES, 15},
 551                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT,
 552                  YACA_ENCRYPT_CAST5, 41},
 553                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT,
 554                  YACA_ENCRYPT_3DES_3TDEA, 17},
 555                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT,
 556                  YACA_ENCRYPT_UNSAFE_RC2, 9},
 557                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_64BIT,
 558                  YACA_ENCRYPT_UNSAFE_DES, 12},
 559         };
 560
 561         for (const auto &ca: cargs) {
 562                 int ret;
 563                 yaca_context_h ctx = YACA_CONTEXT_NULL;
 564                 yaca_key_h key = YACA_KEY_NULL;
 565
 566                 char *signature = NULL, *signature2 = NULL;
 567                 size_t signature_len, signature2_len;
 568
 569                 ret = yaca_key_generate(ca.type, ca.len, &key);
 570                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 571
 572                 /* SIGN */
 573                 {
 574                         ret = yaca_sign_initialize_cmac(&ctx, ca.algo, key);
 575                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 576
 577                         call_update_loop(ctx, INPUT_DATA, INPUT_DATA_SIZE,
 578                                                          ca.split, yaca_sign_update);
 579
 580                         ret = yaca_context_get_output_length(ctx, 0, &signature_len);
 581                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 582
 583                         ret = yaca_malloc(signature_len, (void **)&signature);
 584                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 585
 586                         ret = yaca_sign_finalize(ctx, signature, &signature_len);
 587                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 588
 589                         yaca_context_destroy(ctx);
 590                         ctx = YACA_CONTEXT_NULL;
 591                 }
 592
 593                 /* VERIFY */
 594                 {
 595                         ret = yaca_sign_initialize_cmac(&ctx, ca.algo, key);
 596                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 597
 598                         call_update_loop(ctx, INPUT_DATA, INPUT_DATA_SIZE,
 599                                                          ca.split + 3, yaca_sign_update);
 600
 601                         ret = yaca_context_get_output_length(ctx, 0, &signature2_len);
 602                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 603
 604                         ret = yaca_malloc(signature2_len, (void **)&signature2);
 605                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 606
 607                         ret = yaca_sign_finalize(ctx, signature2, &signature2_len);
 608                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 609
 610                         yaca_context_destroy(ctx);
 611                         ctx = YACA_CONTEXT_NULL;
 612
 613                         BOOST_REQUIRE(signature_len == signature2_len);
 614                         ret = yaca_memcmp(signature, signature2, signature_len);
 615                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 616                 }
 617
 618                 yaca_key_destroy(key);
 619                 yaca_free(signature);
 620                 yaca_free(signature2);
 621         }
 622 }
 623
 624 BOOST_FIXTURE_TEST_CASE(T804__negative__sign_cmac, InitDebugFixture)
 625 {
 626         int ret;
 627         yaca_context_h ctx = YACA_CONTEXT_NULL;
 628         yaca_key_h key = YACA_KEY_NULL, key2 = YACA_KEY_NULL;
 629         yaca_key_h key_rsa = YACA_KEY_NULL, key_dsa = YACA_KEY_NULL;
 630
 631         char *signature = NULL, *signature2 = NULL;
 632         size_t signature_len, signature2_len;
 633
 634         ret = yaca_key_generate(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT, &key);
 635         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 636         ret = yaca_key_generate(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT, &key2);
 637         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 638
 639         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT, &key_rsa);
 640         generate_asymmetric_keys(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_dsa);
 641
 642         /* SIGN */
 643         {
 644                 ret = yaca_sign_initialize_cmac(NULL, YACA_ENCRYPT_AES, key);
 645                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 646
 647                 ret = yaca_sign_initialize_cmac(&ctx, YACA_INVALID_ENCRYPT_ALGORITHM, key);
 648                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 649
 650                 ret = yaca_sign_initialize_cmac(&ctx, YACA_ENCRYPT_AES, YACA_KEY_NULL);
 651                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 652
 653                 ret = yaca_sign_initialize_cmac(&ctx, YACA_ENCRYPT_AES, key_rsa);
 654                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 655
 656                 ret = yaca_sign_initialize_cmac(&ctx, YACA_ENCRYPT_AES, key_dsa);
 657                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 658
 659                 ret = yaca_sign_initialize_cmac(&ctx, YACA_ENCRYPT_AES, key);
 660                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 661
 662                 ret = yaca_sign_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 663                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 664
 665                 ret = yaca_context_get_output_length(ctx, 0, &signature_len);
 666                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 667
 668                 ret = yaca_malloc(signature_len, (void **)&signature);
 669                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 670
 671                 ret = yaca_sign_finalize(ctx, signature, &signature_len);
 672                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 673
 674                 yaca_context_destroy(ctx);
 675                 ctx = YACA_CONTEXT_NULL;
 676         }
 677
 678         /* VERIFY, wrong algo */
 679         {
 680                 ret = yaca_sign_initialize_cmac(&ctx, YACA_ENCRYPT_3DES_3TDEA, key);
 681                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 682
 683                 ret = yaca_sign_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 684                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 685
 686                 ret = yaca_context_get_output_length(ctx, 0, &signature2_len);
 687                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 688
 689                 ret = yaca_malloc(signature2_len, (void **)&signature2);
 690                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 691
 692                 ret = yaca_sign_finalize(ctx, signature2, &signature2_len);
 693                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 694
 695                 signature2_len = std::min(signature_len, signature2_len);
 696                 ret = yaca_memcmp(signature, signature2, signature2_len);
 697                 BOOST_REQUIRE(ret == YACA_ERROR_DATA_MISMATCH);
 698
 699                 yaca_context_destroy(ctx);
 700                 ctx = YACA_CONTEXT_NULL;
 701                 yaca_free(signature2);
 702                 signature2 = NULL;
 703         }
 704
 705         /* VERIFY, wrong key */
 706         {
 707                 ret = yaca_sign_initialize_cmac(&ctx, YACA_ENCRYPT_AES, key2);
 708                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 709
 710                 ret = yaca_sign_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 711                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 712
 713                 ret = yaca_context_get_output_length(ctx, 0, &signature2_len);
 714                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 715
 716                 ret = yaca_malloc(signature2_len, (void **)&signature2);
 717                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 718
 719                 ret = yaca_sign_finalize(ctx, signature2, &signature2_len);
 720                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 721
 722                 BOOST_REQUIRE(signature_len == signature2_len);
 723                 ret = yaca_memcmp(signature, signature2, signature_len);
 724                 BOOST_REQUIRE(ret == YACA_ERROR_DATA_MISMATCH);
 725
 726                 yaca_context_destroy(ctx);
 727                 ctx = YACA_CONTEXT_NULL;
 728                 yaca_free(signature2);
 729                 signature2 = NULL;
 730         }
 731
 732         yaca_key_destroy(key);
 733         yaca_key_destroy(key2);
 734         yaca_key_destroy(key_rsa);
 735         yaca_key_destroy(key_dsa);
 736         yaca_free(signature);
 737 }
 738
 739 BOOST_FIXTURE_TEST_CASE(T805__positive__sign_hmac, InitDebugFixture)
 740 {
 741         struct hmac_args {
 742                 yaca_key_type_e type;
 743                 yaca_key_bit_length_e len;
 744                 yaca_digest_algorithm_e digest;
 745                 size_t split;
 746         };
 747
 748         const std::vector<hmac_args> hargs = {
 749                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT,
 750                  YACA_DIGEST_MD5, 13},
 751                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_UNSAFE_128BIT,
 752                  YACA_DIGEST_SHA1, 32},
 753                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT,
 754                  YACA_DIGEST_SHA224, 23},
 755                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT,
 756                  YACA_DIGEST_SHA256, 20},
 757                 {YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_UNSAFE_64BIT,
 758                  YACA_DIGEST_SHA384, 13},
 759
 760                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT,
 761                  YACA_DIGEST_MD5, 9},
 762                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT,
 763                  YACA_DIGEST_SHA1, 7},
 764                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT,
 765                  YACA_DIGEST_SHA224, 14},
 766                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT,
 767                  YACA_DIGEST_SHA384, 20},
 768                 {YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_64BIT,
 769                  YACA_DIGEST_SHA512, 10},
 770         };
 771
 772         for (const auto &ha: hargs) {
 773                 int ret;
 774                 yaca_context_h ctx = YACA_CONTEXT_NULL;
 775                 yaca_key_h key = YACA_KEY_NULL;
 776
 777                 char *signature = NULL, *signature2 = NULL;
 778                 size_t signature_len, signature2_len;
 779
 780                 ret = yaca_key_generate(ha.type, ha.len, &key);
 781                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 782
 783                 /* SIGN */
 784                 {
 785                         ret = yaca_sign_initialize_hmac(&ctx, ha.digest, key);
 786                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 787
 788                         call_update_loop(ctx, INPUT_DATA, INPUT_DATA_SIZE,
 789                                                          ha.split, yaca_sign_update);
 790
 791                         ret = yaca_context_get_output_length(ctx, 0, &signature_len);
 792                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 793
 794                         ret = yaca_malloc(signature_len, (void **)&signature);
 795                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 796
 797                         ret = yaca_sign_finalize(ctx, signature, &signature_len);
 798                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 799
 800                         yaca_context_destroy(ctx);
 801                         ctx = YACA_CONTEXT_NULL;
 802                 }
 803
 804                 /* VERIFY */
 805                 {
 806                         ret = yaca_sign_initialize_hmac(&ctx, ha.digest, key);
 807                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 808
 809                         call_update_loop(ctx, INPUT_DATA, INPUT_DATA_SIZE,
 810                                                          ha.split + 3, yaca_sign_update);
 811
 812                         ret = yaca_context_get_output_length(ctx, 0, &signature2_len);
 813                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 814
 815                         ret = yaca_malloc(signature2_len, (void **)&signature2);
 816                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 817
 818                         ret = yaca_sign_finalize(ctx, signature2, &signature2_len);
 819                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 820
 821                         yaca_context_destroy(ctx);
 822                         ctx = YACA_CONTEXT_NULL;
 823
 824                         BOOST_REQUIRE(signature_len == signature2_len);
 825                         ret = yaca_memcmp(signature, signature2, signature_len);
 826                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 827                 }
 828
 829                 yaca_key_destroy(key);
 830                 yaca_free(signature);
 831                 yaca_free(signature2);
 832         }
 833 }
 834
 835 BOOST_FIXTURE_TEST_CASE(T806__negative__sign_hmac, InitDebugFixture)
 836 {
 837         int ret;
 838         yaca_context_h ctx = YACA_CONTEXT_NULL;
 839         yaca_key_h key = YACA_KEY_NULL, key2 = YACA_KEY_NULL;
 840         yaca_key_h key_rsa = YACA_KEY_NULL, key_dsa = YACA_KEY_NULL;
 841
 842         char *signature = NULL, *signature2 = NULL;
 843         size_t signature_len, signature2_len;
 844
 845         ret = yaca_key_generate(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT, &key);
 846         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 847         ret = yaca_key_generate(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT, &key2);
 848         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 849
 850         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT, &key_rsa);
 851         generate_asymmetric_keys(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_dsa);
 852
 853         /* SIGN */
 854         {
 855                 ret = yaca_sign_initialize_hmac(NULL, YACA_DIGEST_MD5, key);
 856                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 857
 858                 ret = yaca_sign_initialize_hmac(&ctx, YACA_INVALID_DIGEST_ALGORITHM, key);
 859                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 860
 861                 ret = yaca_sign_initialize_hmac(&ctx, YACA_DIGEST_MD5, YACA_KEY_NULL);
 862                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 863
 864                 ret = yaca_sign_initialize_hmac(&ctx, YACA_DIGEST_MD5, key_rsa);
 865                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 866
 867                 ret = yaca_sign_initialize_hmac(&ctx, YACA_DIGEST_MD5, key_dsa);
 868                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 869
 870                 ret = yaca_sign_initialize_hmac(&ctx, YACA_DIGEST_MD5, key);
 871                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 872
 873                 ret = yaca_sign_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 874                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 875
 876                 ret = yaca_context_get_output_length(ctx, 0, &signature_len);
 877                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 878
 879                 ret = yaca_malloc(signature_len, (void **)&signature);
 880                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 881
 882                 ret = yaca_sign_finalize(ctx, signature, &signature_len);
 883                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 884
 885                 yaca_context_destroy(ctx);
 886                 ctx = YACA_CONTEXT_NULL;
 887         }
 888
 889         /* VERIFY, wrong algo */
 890         {
 891                 ret = yaca_sign_initialize_hmac(&ctx, YACA_DIGEST_SHA1, key);
 892                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 893
 894                 ret = yaca_sign_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 895                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 896
 897                 ret = yaca_context_get_output_length(ctx, 0, &signature2_len);
 898                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 899
 900                 ret = yaca_malloc(signature2_len, (void **)&signature2);
 901                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 902
 903                 ret = yaca_sign_finalize(ctx, signature2, &signature2_len);
 904                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 905
 906                 signature2_len = std::min(signature_len, signature2_len);
 907                 ret = yaca_memcmp(signature, signature2, signature2_len);
 908                 BOOST_REQUIRE(ret == YACA_ERROR_DATA_MISMATCH);
 909
 910                 yaca_context_destroy(ctx);
 911                 ctx = YACA_CONTEXT_NULL;
 912                 yaca_free(signature2);
 913                 signature2 = NULL;
 914         }
 915
 916         /* VERIFY, wrong key */
 917         {
 918                 ret = yaca_sign_initialize_hmac(&ctx, YACA_DIGEST_MD5, key2);
 919                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 920
 921                 ret = yaca_sign_update(ctx, INPUT_DATA, INPUT_DATA_SIZE);
 922                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 923
 924                 ret = yaca_context_get_output_length(ctx, 0, &signature2_len);
 925                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 926
 927                 ret = yaca_malloc(signature2_len, (void **)&signature2);
 928                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 929
 930                 ret = yaca_sign_finalize(ctx, signature2, &signature2_len);
 931                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 932
 933                 BOOST_REQUIRE(signature_len == signature2_len);
 934                 ret = yaca_memcmp(signature, signature2, signature_len);
 935                 BOOST_REQUIRE(ret == YACA_ERROR_DATA_MISMATCH);
 936
 937                 yaca_context_destroy(ctx);
 938                 ctx = YACA_CONTEXT_NULL;
 939                 yaca_free(signature2);
 940                 signature2 = NULL;
 941         }
 942
 943         yaca_key_destroy(key);
 944         yaca_key_destroy(key2);
 945         yaca_key_destroy(key_rsa);
 946         yaca_key_destroy(key_dsa);
 947         yaca_free(signature);
 948 }
 949
 950 BOOST_AUTO_TEST_SUITE_END()