src/yaca/yaca-test-simple.cpp

   1 /*
   2  *  Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Contact: Dariusz Michaluk (d.michaluk@samsumg.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
  21  * @author Dariusz Michaluk (d.michaluk@samsumg.com)
  22  */
  23
  24 #include <yaca_simple.h>
  25
  26 #include "dpl/test/test_runner.h"
  27 #include "yaca-test-common.h"
  28 #include "yaca-test-vector.h"
  29
  30 namespace {
  31
  32 void digest_check_test_vector(yaca_digest_algorithm_e algo,
  33                               size_t repeats,
  34                               const Buffer &single_input,
  35                               const Buffer &expected)
  36 {
  37     /* concatenate input if needed */
  38     Buffer input(single_input);
  39     for (size_t i = 1; i < repeats; i++)
  40         input.insert(input.end(), single_input.begin(), single_input.end());
  41
  42     char *digest;
  43     size_t digest_len;
  44     YACA_SUCCESS(yaca_simple_calculate_digest(algo,
  45                                               input.data(),
  46                                               input.size(),
  47                                               &digest,
  48                                               &digest_len));
  49     RUNNER_ASSERT_MSG(digest != NULL, "NULL digest calculated");
  50
  51     auto digest_ptr = wrap_ptr(digest);
  52
  53     YACA_ASSERT_MSG(digest_len == expected.size(),
  54                     "Digest calculated for \""  <<
  55                     truncate_str(std::string(input.data(), input.size()), 16)
  56                     << "\" with " << digest2str(algo) << " is " <<
  57                     digest_len * 8 <<" bits long. Expected " <<
  58                     expected.size() * 8 << " bits");
  59
  60     int ret = yaca_memcmp(digest, expected.data(), digest_len);
  61     YACA_ASSERT_MSG(YACA_ERROR_NONE == ret,
  62                     "Digest calculated for \"" <<
  63                     truncate_str(std::string(input.data(), input.size()), 16)
  64                     << "\" with " << digest2str(algo) <<
  65                     " is different than expected");
  66 }
  67
  68 } // anonymous namespace
  69
  70
  71 RUNNER_TEST_GROUP_INIT(T7000_YACA_SIMPLE);
  72
  73 RUNNER_TEST(T7010_yaca_simple_calculate_digest_invalid_param, YacaTest)
  74 {
  75     char *digest;
  76     size_t digest_len;
  77     Buffer data = random_buffer(42);
  78
  79     YACA_INVALID_PARAM(yaca_simple_calculate_digest(static_cast<yaca_digest_algorithm_e>(-1),
  80                                                     data.data(),
  81                                                     data.size(),
  82                                                     &digest,
  83                                                     &digest_len));
  84     YACA_INVALID_PARAM(yaca_simple_calculate_digest(YACA_DIGEST_MD5,
  85                                                     nullptr,
  86                                                     data.size(),
  87                                                     &digest,
  88                                                     &digest_len));
  89     YACA_INVALID_PARAM(yaca_simple_calculate_digest(YACA_DIGEST_MD5,
  90                                                     data.data(),
  91                                                     0,
  92                                                     &digest,
  93                                                     &digest_len));
  94     YACA_INVALID_PARAM(yaca_simple_calculate_digest(YACA_DIGEST_MD5,
  95                                                     data.data(),
  96                                                     data.size(),
  97                                                     nullptr,
  98                                                     &digest_len));
  99     YACA_INVALID_PARAM(yaca_simple_calculate_digest(YACA_DIGEST_MD5,
 100                                                     data.data(),
 101                                                     data.size(),
 102                                                     &digest,
 103                                                     nullptr));
 104 }
 105
 106 RUNNER_TEST(T7020_yaca_simple_calculate_digest_ascii_vectors, YacaTest)
 107 {
 108     auto tvv = loadTestVector("digest_ascii.txt");
 109
 110     for (const auto &tv : tvv) {
 111         yaca_digest_algorithm_e algo;
 112         size_t repeats;
 113         std::string input;
 114         Buffer expected;
 115
 116         tv.get("algo", algo);
 117         tv.get("repeats", repeats);
 118         tv.get("input", input);
 119         tv.get("output", expected);
 120
 121         digest_check_test_vector(algo, repeats, Buffer(input.begin(), input.end()), expected);
 122     }
 123 }
 124
 125 RUNNER_TEST(T7030_yaca_simple_calculate_digest_binary_vectors, YacaTest)
 126 {
 127     auto tvv = loadTestVector("digest_binary.txt");
 128
 129     for (const auto &tv : tvv) {
 130         yaca_digest_algorithm_e algo;
 131         size_t repeats;
 132         Buffer input;
 133         Buffer expected;
 134
 135         tv.get("algo", algo);
 136         tv.get("repeats", repeats);
 137         tv.get("input", input);
 138         tv.get("output", expected);
 139
 140         digest_check_test_vector(algo, repeats, input, expected);
 141     }
 142 }
 143
 144 RUNNER_TEST(T7040_yaca_simple_calculate_signature_invalid_param, YacaTest)
 145 {
 146     char *signature;
 147     size_t signature_len;
 148     Buffer data = random_buffer(42);
 149     KeyPtr key_prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 150     KeyPtr key_pub = extract_public_key(key_prv);
 151     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 256);
 152
 153     YACA_INVALID_PARAM(yaca_simple_calculate_signature(static_cast<yaca_digest_algorithm_e>(-1),
 154                                                        key_prv.get(),
 155                                                        data.data(),
 156                                                        data.size(),
 157                                                        &signature,
 158                                                        &signature_len));
 159     YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
 160                                                        nullptr,
 161                                                        data.data(),
 162                                                        data.size(),
 163                                                        &signature,
 164                                                        &signature_len));
 165     YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
 166                                                        key_pub.get(),
 167                                                        data.data(),
 168                                                        data.size(),
 169                                                        &signature,
 170                                                        &signature_len));
 171     YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
 172                                                        key_sym.get(),
 173                                                        data.data(),
 174                                                        data.size(),
 175                                                        &signature,
 176                                                        &signature_len));
 177     YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
 178                                                        key_prv.get(),
 179                                                        nullptr,
 180                                                        data.size(),
 181                                                        &signature,
 182                                                        &signature_len));
 183     YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
 184                                                        key_prv.get(),
 185                                                        data.data(),
 186                                                        0,
 187                                                        &signature,
 188                                                        &signature_len));
 189     YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
 190                                                        key_prv.get(),
 191                                                        data.data(),
 192                                                        data.size(),
 193                                                        nullptr,
 194                                                        &signature_len));
 195     YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
 196                                                        key_prv.get(),
 197                                                        data.data(),
 198                                                        data.size(),
 199                                                        &signature,
 200                                                        nullptr));
 201 }
 202
 203 RUNNER_TEST(T7050_yaca_simple_verify_signature_invalid_param, YacaTest)
 204 {
 205     size_t signature_len;
 206     Buffer data = random_buffer(42);
 207     KeyPtr key_prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 208     KeyPtr key_pub = extract_public_key(key_prv);
 209     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 256);
 210     ChrPtr signature = simple_sign(YACA_DIGEST_MD5, key_prv, data.data(), data.size(), &signature_len);
 211
 212     YACA_INVALID_PARAM(yaca_simple_verify_signature(static_cast<yaca_digest_algorithm_e>(-1),
 213                                                     key_pub.get(),
 214                                                     data.data(),
 215                                                     data.size(),
 216                                                     signature.get(),
 217                                                     signature_len));
 218     YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
 219                                                     nullptr,
 220                                                     data.data(),
 221                                                     data.size(),
 222                                                     signature.get(),
 223                                                     signature_len));
 224     YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
 225                                                     key_prv.get(),
 226                                                     data.data(),
 227                                                     data.size(),
 228                                                     signature.get(),
 229                                                     signature_len));
 230     YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
 231                                                     key_sym.get(),
 232                                                     data.data(),
 233                                                     data.size(),
 234                                                     signature.get(),
 235                                                     signature_len));
 236     YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
 237                                                     key_pub.get(),
 238                                                     nullptr,
 239                                                     data.size(),
 240                                                     signature.get(),
 241                                                     signature_len));
 242     YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
 243                                                     key_pub.get(),
 244                                                     data.data(),
 245                                                     0,
 246                                                     signature.get(),
 247                                                     signature_len));
 248     YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
 249                                                     key_pub.get(),
 250                                                     data.data(),
 251                                                     data.size(),
 252                                                     nullptr,
 253                                                     signature_len));
 254     YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
 255                                                     key_pub.get(),
 256                                                     data.data(),
 257                                                     data.size(),
 258                                                     signature.get(),
 259                                                     0));
 260 }
 261
 262 RUNNER_TEST(T7060_yaca_simple_calculate_hmac_invalid_param, YacaTest)
 263 {
 264     char *mac;
 265     size_t mac_len;
 266     Buffer data = random_buffer(42);
 267     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 256);
 268     KeyPtr key_prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 269     KeyPtr key_pub = extract_public_key(key_prv);
 270
 271     YACA_INVALID_PARAM(yaca_simple_calculate_hmac(static_cast<yaca_digest_algorithm_e>(-1),
 272                                                   key_sym.get(),
 273                                                   data.data(),
 274                                                   data.size(),
 275                                                   &mac,
 276                                                   &mac_len));
 277     YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
 278                                                   nullptr,
 279                                                   data.data(),
 280                                                   data.size(),
 281                                                   &mac,
 282                                                   &mac_len));
 283     YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
 284                                                   key_prv.get(),
 285                                                   data.data(),
 286                                                   data.size(),
 287                                                   &mac,
 288                                                   &mac_len));
 289     YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
 290                                                   key_pub.get(),
 291                                                   data.data(),
 292                                                   data.size(),
 293                                                   &mac,
 294                                                   &mac_len));
 295     YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
 296                                                   key_sym.get(),
 297                                                   nullptr,
 298                                                   data.size(),
 299                                                   &mac,
 300                                                   &mac_len));
 301     YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
 302                                                   key_sym.get(),
 303                                                   data.data(),
 304                                                   0,
 305                                                   &mac,
 306                                                   &mac_len));
 307     YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
 308                                                   key_sym.get(),
 309                                                   data.data(),
 310                                                   data.size(),
 311                                                   nullptr,
 312                                                   &mac_len));
 313     YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
 314                                                   key_sym.get(),
 315                                                   data.data(),
 316                                                   data.size(),
 317                                                   &mac,
 318                                                   nullptr));
 319 }
 320
 321 RUNNER_TEST(T7070_yaca_simple_calculate_cmac_invalid_param, YacaTest)
 322 {
 323     char *mac;
 324     size_t mac_len;
 325     Buffer data = random_buffer(42);
 326     KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 256);
 327     KeyPtr key_prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
 328     KeyPtr key_pub = extract_public_key(key_prv);
 329
 330     YACA_INVALID_PARAM(yaca_simple_calculate_cmac(static_cast<yaca_encrypt_algorithm_e>(-1),
 331                                                   key_sym.get(),
 332                                                   data.data(),
 333                                                   data.size(),
 334                                                   &mac,
 335                                                   &mac_len));
 336     YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
 337                                                   nullptr,
 338                                                   data.data(),
 339                                                   data.size(),
 340                                                   &mac,
 341                                                   &mac_len));
 342     YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
 343                                                   key_prv.get(),
 344                                                   data.data(),
 345                                                   data.size(),
 346                                                   &mac,
 347                                                   &mac_len));
 348     YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
 349                                                   key_pub.get(),
 350                                                   data.data(),
 351                                                   data.size(),
 352                                                   &mac,
 353                                                   &mac_len));
 354     YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
 355                                                   key_sym.get(),
 356                                                   nullptr,
 357                                                   data.size(),
 358                                                   &mac,
 359                                                   &mac_len));
 360     YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
 361                                                   key_sym.get(),
 362                                                   data.data(),
 363                                                   0,
 364                                                   &mac,
 365                                                   &mac_len));
 366     YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
 367                                                   key_sym.get(),
 368                                                   data.data(),
 369                                                   data.size(),
 370                                                   nullptr,
 371                                                   &mac_len));
 372     YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
 373                                                   key_sym.get(),
 374                                                   data.data(),
 375                                                   data.size(),
 376                                                   &mac,
 377                                                   nullptr));
 378 }
 379
 380 RUNNER_TEST(T7080_yaca_simple_calculate_signature_vectors, YacaTest)
 381 {
 382     auto tvv = loadTestVector("sign_ascii.txt");
 383
 384     for (const auto &tv : tvv) {
 385         yaca_digest_algorithm_e algo;
 386         yaca_key_type_e key_type;
 387         Buffer key_data;
 388         size_t repeats;
 389         std::string single_input;
 390         Buffer expected;
 391
 392         tv.get("algo", algo);
 393         tv.get("key_type", key_type);
 394         tv.get("key", key_data);
 395         tv.get("repeats", repeats);
 396         tv.get("input", single_input);
 397         tv.get("output", expected);
 398
 399         KeyPtr key = import_key(key_type, nullptr, key_data.data(), key_data.size());
 400
 401         /* concatenate input if needed */
 402         Buffer input(single_input.begin(), single_input.end());
 403         for (size_t i = 1; i < repeats; i++)
 404             input.insert(input.end(), single_input.begin(), single_input.end());
 405
 406         char *signature;
 407         size_t signature_len;
 408         YACA_SUCCESS(yaca_simple_calculate_signature(algo,
 409                                                      key.get(),
 410                                                      input.data(),
 411                                                      input.size(),
 412                                                      &signature,
 413                                                      &signature_len));
 414         RUNNER_ASSERT_MSG(signature != NULL, "NULL signature calculated");
 415
 416         ChrPtr signature_ptr = wrap_ptr(signature);
 417
 418         YACA_ASSERT_MSG(signature_len == expected.size(),
 419                         "Signature calculated for \""  <<
 420                         truncate_str(std::string(input.data(), input.size()), 16)
 421                         << "\" with " << digest2str(algo) << " and " << keytype2str(key_type)
 422                         << " key is " << signature_len * 8
 423                         <<" bits long. Expected " << expected.size() * 8 << " bits");
 424
 425         int ret = yaca_memcmp(signature, expected.data(), signature_len);
 426         YACA_ASSERT_MSG(YACA_ERROR_NONE == ret,
 427                         "Signature calculated for \"" <<
 428                         truncate_str(std::string(input.data(), input.size()), 16) << "\" with "
 429                         << digest2str(algo) << " and " << keytype2str(key_type)
 430                         << "key is different than expected");
 431     }
 432 }
 433
 434 RUNNER_TEST(T7090_yaca_simple_calculate_signature_verify_vectors, YacaTest)
 435 {
 436     auto tvv = loadTestVector("sign_verify_ascii.txt");
 437
 438     for (const auto &tv : tvv) {
 439         yaca_digest_algorithm_e algo;
 440         yaca_key_type_e key_type;
 441         Buffer key_data;
 442         size_t repeats;
 443         std::string single_input;
 444
 445         tv.get("algo", algo);
 446         tv.get("key_type", key_type);
 447         tv.get("key", key_data);
 448         tv.get("repeats", repeats);
 449         tv.get("input", single_input);
 450
 451         KeyPtr key_prv = import_key(key_type, nullptr, key_data.data(), key_data.size());
 452         KeyPtr key_pub = extract_public_key(key_prv);
 453
 454         /* concatenate input if needed */
 455         Buffer input(single_input.begin(), single_input.end());
 456         for (size_t i = 1; i < repeats; i++)
 457             input.insert(input.end(), single_input.begin(), single_input.end());
 458
 459         char *signature;
 460         size_t signature_len;
 461         YACA_SUCCESS(yaca_simple_calculate_signature(algo,
 462                                                      key_prv.get(),
 463                                                      input.data(),
 464                                                      input.size(),
 465                                                      &signature,
 466                                                      &signature_len));
 467         RUNNER_ASSERT_MSG(signature != NULL, "NULL signature calculated");
 468
 469         ChrPtr signature_ptr = wrap_ptr(signature);
 470
 471         int ret = yaca_simple_verify_signature(algo,
 472                                                key_pub.get(),
 473                                                input.data(),
 474                                                input.size(),
 475                                                signature,
 476                                                signature_len);
 477
 478         YACA_ASSERT_MSG(YACA_ERROR_NONE == ret,
 479                         "Verification failed for \"" <<
 480                         truncate_str(std::string(input.data(), input.size()), 16) << "\" with "
 481                         << digest2str(algo) << " and " << keytype2str(key_type) << " key");
 482
 483         Buffer input_wrong = input;
 484         input_wrong.push_back('!');
 485
 486         ret = yaca_simple_verify_signature(algo,
 487                                            key_pub.get(),
 488                                            input_wrong.data(),
 489                                            input_wrong.size(),
 490                                            signature,
 491                                            signature_len);
 492
 493         YACA_ASSERT_MSG(YACA_ERROR_DATA_MISMATCH == ret,
 494                         "Verification succeeded for \"" <<
 495                         truncate_str(std::string(input.data(), input.size()), 16) << "\" with "
 496                         << digest2str(algo) << " and " << keytype2str(key_type)
 497                         << " key while the input has been tampered with");
 498     }
 499 }
 500
 501 RUNNER_TEST(T7100_yaca_simple_calculate_hmac_vectors, YacaTest)
 502 {
 503     auto tvv = loadTestVector("sign_hmac_ascii.txt");
 504
 505     for (const auto &tv : tvv) {
 506         yaca_digest_algorithm_e algo;
 507         Buffer key_data;
 508         size_t repeats;
 509         std::string single_input;
 510         Buffer expected;
 511
 512         tv.get("algo", algo);
 513         tv.get("key", key_data);
 514         tv.get("repeats", repeats);
 515         tv.get("input", single_input);
 516         tv.get("output", expected);
 517
 518         KeyPtr key = import_key(YACA_KEY_TYPE_SYMMETRIC, nullptr, key_data.data(), key_data.size());
 519
 520         /* concatenate input if needed */
 521         Buffer input(single_input.begin(), single_input.end());
 522         for (size_t i = 1; i < repeats; i++)
 523             input.insert(input.end(), single_input.begin(), single_input.end());
 524
 525         char *mac;
 526         size_t mac_len;
 527         YACA_SUCCESS(yaca_simple_calculate_hmac(algo,
 528                                                 key.get(),
 529                                                 input.data(),
 530                                                 input.size(),
 531                                                 &mac,
 532                                                 &mac_len));
 533         RUNNER_ASSERT_MSG(mac != NULL, "NULL signature calculated");
 534
 535         ChrPtr mac_ptr = wrap_ptr(mac);
 536
 537         YACA_ASSERT_MSG(mac_len == expected.size(),
 538                         "HMAC calculated for \""  <<
 539                         truncate_str(std::string(input.data(), input.size()), 16)
 540                         << "\" with " << digest2str(algo) << " is " << mac_len * 8
 541                         <<" bits long. Expected " << expected.size() * 8 << " bits");
 542
 543         int ret = yaca_memcmp(mac, expected.data(), mac_len);
 544         YACA_ASSERT_MSG(YACA_ERROR_NONE == ret,
 545                         "HMAC calculated for \"" <<
 546                         truncate_str(std::string(input.data(), input.size()), 16) << "\" with "
 547                         << digest2str(algo) << " is different than expected");
 548     }
 549 }
 550
 551 RUNNER_TEST(T7110_yaca_simple_calculate_cmac_vectors, YacaTest)
 552 {
 553     auto tvv = loadTestVector("sign_cmac_ascii.txt");
 554
 555     for (const auto &tv : tvv) {
 556         yaca_encrypt_algorithm_e algo;
 557         Buffer key_data;
 558         size_t repeats;
 559         std::string single_input;
 560         Buffer expected;
 561
 562         tv.get("algo", algo);
 563         tv.get("key", key_data);
 564         tv.get("repeats", repeats);
 565         tv.get("input", single_input);
 566         tv.get("output", expected);
 567
 568         KeyPtr key = import_key(YACA_KEY_TYPE_SYMMETRIC, nullptr, key_data.data(), key_data.size());
 569
 570         /* concatenate input if needed */
 571         Buffer input(single_input.begin(), single_input.end());
 572         for (size_t i = 1; i < repeats; i++)
 573             input.insert(input.end(), single_input.begin(), single_input.end());
 574
 575         char *mac;
 576         size_t mac_len;
 577         YACA_SUCCESS(yaca_simple_calculate_cmac(algo,
 578                                                 key.get(),
 579                                                 input.data(),
 580                                                 input.size(),
 581                                                 &mac,
 582                                                 &mac_len));
 583         RUNNER_ASSERT_MSG(mac != NULL, "NULL signature calculated");
 584
 585         ChrPtr mac_ptr = wrap_ptr(mac);
 586
 587         YACA_ASSERT_MSG(mac_len == expected.size(),
 588                         "CMAC calculated for \""  <<
 589                         truncate_str(std::string(input.data(), input.size()), 16)
 590                         << "\" with " << encrypt2str(algo) << " is " << mac_len * 8
 591                         <<" bits long. Expected " << expected.size() * 8 << " bits");
 592
 593         int ret = yaca_memcmp(mac, expected.data(), mac_len);
 594         YACA_ASSERT_MSG(YACA_ERROR_NONE == ret,
 595                         "CMAC calculated for \"" <<
 596                         truncate_str(std::string(input.data(), input.size()), 16) << "\" with "
 597                         << encrypt2str(algo) << " is different than expected");
 598     }
 599 }