tests/test_seal.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_seal.cpp
  21  * @author  Lukasz Pawelczyk <l.pawelczyk@samsung.com>
  22  * @brief   Seal API unit tests.
  23  */
  24
  25 #include <boost/test/unit_test.hpp>
  26 #include <vector>
  27
  28 #include <yaca_crypto.h>
  29 #include <yaca_seal.h>
  30 #include <yaca_key.h>
  31 #include <yaca_encrypt.h>
  32 #include <yaca_error.h>
  33
  34 #include "common.h"
  35
  36
  37 BOOST_AUTO_TEST_SUITE(TESTS_SEAL)
  38
  39 BOOST_FIXTURE_TEST_CASE(T701__positive__seal_open, InitDebugFixture)
  40 {
  41         struct seal_args {
  42                 yaca_encrypt_algorithm_e algo;
  43                 yaca_block_cipher_mode_e bcm;
  44                 size_t key_bit_len;
  45                 yaca_padding_e padding;
  46                 size_t split;
  47         };
  48
  49         const std::vector<seal_args> sargs = {
  50                 {YACA_ENCRYPT_AES, YACA_BCM_CBC,  128, YACA_INVALID_PADDING, 16},
  51                 {YACA_ENCRYPT_AES, YACA_BCM_CBC,  128, YACA_PADDING_NONE,     8},
  52                 {YACA_ENCRYPT_AES, YACA_BCM_CBC,  128, YACA_PADDING_PKCS7,   11},
  53                 {YACA_ENCRYPT_AES, YACA_BCM_CFB,  128, YACA_INVALID_PADDING, 24},
  54                 {YACA_ENCRYPT_AES, YACA_BCM_CFB1, 128, YACA_INVALID_PADDING, 13},
  55                 {YACA_ENCRYPT_AES, YACA_BCM_CFB8, 128, YACA_INVALID_PADDING,  4},
  56                 {YACA_ENCRYPT_AES, YACA_BCM_CTR,  128, YACA_INVALID_PADDING, 66},
  57                 {YACA_ENCRYPT_AES, YACA_BCM_ECB,  128, YACA_INVALID_PADDING,  3},
  58                 {YACA_ENCRYPT_AES, YACA_BCM_ECB,  128, YACA_PADDING_NONE,    11},
  59                 {YACA_ENCRYPT_AES, YACA_BCM_ECB,  128, YACA_PADDING_PKCS7,   34},
  60                 {YACA_ENCRYPT_AES, YACA_BCM_OFB,  128, YACA_INVALID_PADDING, 27},
  61
  62                 {YACA_ENCRYPT_AES, YACA_BCM_CBC,  192, YACA_INVALID_PADDING,  9},
  63                 {YACA_ENCRYPT_AES, YACA_BCM_CBC,  192, YACA_PADDING_NONE,    12},
  64                 {YACA_ENCRYPT_AES, YACA_BCM_CBC,  192, YACA_PADDING_PKCS7,   11},
  65                 {YACA_ENCRYPT_AES, YACA_BCM_CFB,  192, YACA_INVALID_PADDING, 31},
  66                 {YACA_ENCRYPT_AES, YACA_BCM_CFB1, 192, YACA_INVALID_PADDING, 17},
  67                 {YACA_ENCRYPT_AES, YACA_BCM_CFB8, 192, YACA_INVALID_PADDING,  2},
  68                 {YACA_ENCRYPT_AES, YACA_BCM_CTR,  192, YACA_INVALID_PADDING,  1},
  69                 {YACA_ENCRYPT_AES, YACA_BCM_ECB,  192, YACA_INVALID_PADDING, 24},
  70                 {YACA_ENCRYPT_AES, YACA_BCM_ECB,  192, YACA_PADDING_NONE,    15},
  71                 {YACA_ENCRYPT_AES, YACA_BCM_ECB,  192, YACA_PADDING_PKCS7,   33},
  72                 {YACA_ENCRYPT_AES, YACA_BCM_OFB,  192, YACA_INVALID_PADDING, 44},
  73
  74                 {YACA_ENCRYPT_AES, YACA_BCM_CBC,  256, YACA_INVALID_PADDING, 10},
  75                 {YACA_ENCRYPT_AES, YACA_BCM_CBC,  256, YACA_PADDING_NONE,    11},
  76                 {YACA_ENCRYPT_AES, YACA_BCM_CBC,  256, YACA_PADDING_PKCS7,   23},
  77                 {YACA_ENCRYPT_AES, YACA_BCM_CFB,  256, YACA_INVALID_PADDING, 17},
  78                 {YACA_ENCRYPT_AES, YACA_BCM_CFB1, 256, YACA_INVALID_PADDING, 23},
  79                 {YACA_ENCRYPT_AES, YACA_BCM_CFB8, 256, YACA_INVALID_PADDING, 29},
  80                 {YACA_ENCRYPT_AES, YACA_BCM_CTR,  256, YACA_INVALID_PADDING, 21},
  81                 {YACA_ENCRYPT_AES, YACA_BCM_ECB,  256, YACA_INVALID_PADDING,  9},
  82                 {YACA_ENCRYPT_AES, YACA_BCM_ECB,  256, YACA_PADDING_NONE,     3},
  83                 {YACA_ENCRYPT_AES, YACA_BCM_ECB,  256, YACA_PADDING_PKCS7,   15},
  84                 {YACA_ENCRYPT_AES, YACA_BCM_OFB,  256, YACA_INVALID_PADDING, 13},
  85
  86                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_CBC,  64, YACA_INVALID_PADDING, 31},
  87                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_CBC,  64, YACA_PADDING_NONE,    22},
  88                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_CBC,  64, YACA_PADDING_PKCS7,   39},
  89                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_CFB,  64, YACA_INVALID_PADDING, 24},
  90                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_CFB1, 64, YACA_INVALID_PADDING, 11},
  91                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_CFB8, 64, YACA_INVALID_PADDING, 22},
  92                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_ECB,  64, YACA_INVALID_PADDING,  7},
  93                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_ECB,  64, YACA_PADDING_NONE,    19},
  94                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_ECB,  64, YACA_PADDING_PKCS7,    9},
  95                 {YACA_ENCRYPT_UNSAFE_DES, YACA_BCM_OFB,  64, YACA_INVALID_PADDING,  2},
  96
  97                 {YACA_ENCRYPT_UNSAFE_3DES_2TDEA, YACA_BCM_CBC, 128, YACA_INVALID_PADDING, 16},
  98                 {YACA_ENCRYPT_UNSAFE_3DES_2TDEA, YACA_BCM_CBC, 128, YACA_PADDING_NONE,    25},
  99                 {YACA_ENCRYPT_UNSAFE_3DES_2TDEA, YACA_BCM_CBC, 128, YACA_PADDING_PKCS7,   26},
 100                 {YACA_ENCRYPT_UNSAFE_3DES_2TDEA, YACA_BCM_CFB, 128, YACA_INVALID_PADDING, 23},
 101                 {YACA_ENCRYPT_UNSAFE_3DES_2TDEA, YACA_BCM_ECB, 128, YACA_INVALID_PADDING, 13},
 102                 {YACA_ENCRYPT_UNSAFE_3DES_2TDEA, YACA_BCM_ECB, 128, YACA_PADDING_NONE,    10},
 103                 {YACA_ENCRYPT_UNSAFE_3DES_2TDEA, YACA_BCM_ECB, 128, YACA_PADDING_PKCS7,   29},
 104                 {YACA_ENCRYPT_UNSAFE_3DES_2TDEA, YACA_BCM_OFB, 128, YACA_INVALID_PADDING, 32},
 105
 106                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CBC,  192, YACA_INVALID_PADDING, 39},
 107                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CBC,  192, YACA_PADDING_NONE,    29},
 108                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CBC,  192, YACA_PADDING_PKCS7,   19},
 109                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CFB,  192, YACA_INVALID_PADDING,  9},
 110                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CFB1, 192, YACA_INVALID_PADDING, 44},
 111                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CFB8, 192, YACA_INVALID_PADDING, 33},
 112                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_ECB,  192, YACA_INVALID_PADDING, 22},
 113                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_ECB,  192, YACA_PADDING_NONE,    11},
 114                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_ECB,  192, YACA_PADDING_PKCS7,   13},
 115                 {YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_OFB,  192, YACA_INVALID_PADDING,  1},
 116
 117                 {YACA_ENCRYPT_UNSAFE_RC4, YACA_BCM_NONE, 256, YACA_INVALID_PADDING, 17},
 118
 119                 {YACA_ENCRYPT_CAST5, YACA_BCM_CBC, 128, YACA_INVALID_PADDING,  3},
 120                 {YACA_ENCRYPT_CAST5, YACA_BCM_CBC, 128, YACA_PADDING_NONE,    24},
 121                 {YACA_ENCRYPT_CAST5, YACA_BCM_CBC, 128, YACA_PADDING_PKCS7,   21},
 122                 {YACA_ENCRYPT_CAST5, YACA_BCM_CFB, 128, YACA_INVALID_PADDING, 19},
 123                 {YACA_ENCRYPT_CAST5, YACA_BCM_ECB, 128, YACA_INVALID_PADDING,  7},
 124                 {YACA_ENCRYPT_CAST5, YACA_BCM_ECB, 128, YACA_PADDING_NONE,     6},
 125                 {YACA_ENCRYPT_CAST5, YACA_BCM_ECB, 128, YACA_PADDING_PKCS7,   18},
 126                 {YACA_ENCRYPT_CAST5, YACA_BCM_OFB, 128, YACA_INVALID_PADDING,  2},
 127         };
 128
 129         for (const auto &sa: sargs) {
 130                 int ret;
 131                 yaca_context_h ctx = YACA_CONTEXT_NULL;
 132                 yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
 133                 yaca_key_h key_sym = YACA_KEY_NULL, iv = YACA_KEY_NULL;
 134
 135                 char *encrypted = NULL, *decrypted = NULL;
 136                 size_t encrypted_len = 0, decrypted_len = 0;
 137
 138                 generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_prv, &key_pub);
 139
 140                 /* SEAL */
 141                 {
 142                         ret = yaca_seal_initialize(&ctx, key_pub, sa.algo, sa.bcm,
 143                                                                            sa.key_bit_len, &key_sym, &iv);
 144                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 145
 146                         size_t total = allocate_output(ctx, INPUT_DATA_SIZE, sa.split, encrypted);
 147                         size_t written;
 148
 149                         call_update_loop(ctx, INPUT_DATA, INPUT_DATA_SIZE,
 150                                                          encrypted, encrypted_len, sa.split,
 151                                                          yaca_seal_update);
 152
 153                         if (sa.padding != YACA_INVALID_PADDING) {
 154                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING, &sa.padding,
 155                                                                                                 sizeof(yaca_padding_e));
 156                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 157                         }
 158
 159                         ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
 160                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 161                         encrypted_len += written;
 162
 163                         BOOST_REQUIRE(encrypted_len <= total);
 164                         ret = yaca_realloc(encrypted_len, (void **)&encrypted);
 165                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 166
 167                         yaca_context_destroy(ctx);
 168                         ctx = YACA_CONTEXT_NULL;
 169                 }
 170
 171                 /* OPEN */
 172                 {
 173                         ret = yaca_open_initialize(&ctx, key_prv, sa.algo, sa.bcm,
 174                                                                            sa.key_bit_len, key_sym, iv);
 175                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 176
 177                         if (sa.padding != YACA_INVALID_PADDING) {
 178                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING, &sa.padding,
 179                                                                                                 sizeof(yaca_padding_e));
 180                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 181                         }
 182
 183                         size_t total = allocate_output(ctx, encrypted_len, sa.split, decrypted);
 184                         size_t written;
 185
 186                         call_update_loop(ctx, encrypted, encrypted_len,
 187                                                          decrypted, decrypted_len, sa.split,
 188                                                          yaca_open_update);
 189
 190                         ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
 191                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 192                         decrypted_len += written;
 193
 194                         BOOST_REQUIRE(decrypted_len <= total);
 195                         ret = yaca_realloc(decrypted_len, (void **)&decrypted);
 196                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 197
 198                         yaca_context_destroy(ctx);
 199                         ctx = YACA_CONTEXT_NULL;
 200                 }
 201
 202                 BOOST_REQUIRE(decrypted_len == INPUT_DATA_SIZE);
 203                 ret = yaca_memcmp(INPUT_DATA, decrypted, INPUT_DATA_SIZE);
 204                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 205
 206                 yaca_key_destroy(key_prv);
 207                 yaca_key_destroy(key_pub);
 208                 yaca_key_destroy(key_sym);
 209                 yaca_key_destroy(iv);
 210                 yaca_free(encrypted);
 211                 yaca_free(decrypted);
 212         }
 213 }
 214
 215 BOOST_FIXTURE_TEST_CASE(T702__negative__seal_open, InitDebugFixture)
 216 {
 217         int ret;
 218         yaca_context_h ctx = YACA_CONTEXT_NULL, ctx_encrypt = YACA_CONTEXT_NULL;
 219         yaca_key_h key_rsa_prv = YACA_KEY_NULL, key_rsa_pub = YACA_KEY_NULL;
 220         yaca_key_h key_rsa_prv2 = YACA_KEY_NULL, key_rsa_pub2 = YACA_KEY_NULL;
 221         yaca_key_h key_dsa_prv = YACA_KEY_NULL, key_dsa_pub = YACA_KEY_NULL;
 222         yaca_key_h key_sym = YACA_KEY_NULL, key_sym2 = YACA_KEY_NULL;
 223         yaca_key_h iv = YACA_KEY_NULL, iv2 = YACA_KEY_NULL;
 224         yaca_padding_e pad_pkcs7 = YACA_PADDING_PKCS7;
 225         yaca_padding_e pad_invalid = YACA_PADDING_X931;
 226         size_t len = 128;
 227
 228         char *encrypted = NULL, *decrypted = NULL;
 229         size_t encrypted_len = 0, decrypted_len = 0;
 230
 231         ret = yaca_key_generate(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT, &key_sym2);
 232         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 233         ret = yaca_key_generate(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_128BIT, &iv2);
 234         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 235         ret = yaca_encrypt_initialize(&ctx_encrypt, YACA_ENCRYPT_AES, YACA_BCM_CBC, key_sym2, iv2);
 236         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 237
 238         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_rsa_prv,  &key_rsa_pub);
 239         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_rsa_prv2, &key_rsa_pub2);
 240         generate_asymmetric_keys(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_dsa_prv,  &key_dsa_pub);
 241
 242         /* get an encrypted key_sym2 */
 243         yaca_key_destroy(key_sym2);
 244         key_sym2 = YACA_KEY_NULL;
 245         ret = yaca_seal_initialize(&ctx, key_rsa_pub2, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 246                                                            YACA_KEY_LENGTH_256BIT, &key_sym2, &iv);
 247         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 248         yaca_context_destroy(ctx);
 249         ctx = YACA_CONTEXT_NULL;
 250         yaca_key_destroy(iv);
 251         iv = YACA_KEY_NULL;
 252
 253         /* SEAL */
 254         {
 255                 ret = yaca_seal_initialize(NULL, key_rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 256                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 257                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 258
 259                 ret = yaca_seal_initialize(&ctx, YACA_KEY_NULL, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 260                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 261                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 262
 263                 ret = yaca_seal_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 264                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 265                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 266
 267                 ret = yaca_seal_initialize(&ctx, key_dsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 268                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 269                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 270
 271                 ret = yaca_seal_initialize(&ctx, key_dsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 272                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 273                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 274
 275                 ret = yaca_seal_initialize(&ctx, key_sym2, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 276                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 277                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 278
 279                 ret = yaca_seal_initialize(&ctx, key_rsa_pub, YACA_INVALID_ENCRYPT_ALGORITHM, YACA_BCM_CBC,
 280                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 281                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 282
 283                 ret = yaca_seal_initialize(&ctx, key_rsa_pub, YACA_ENCRYPT_AES, YACA_INVALID_BLOCK_CIPHER_MODE,
 284                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 285                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 286
 287                 ret = yaca_seal_initialize(&ctx, key_rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 288                                                                    257, &key_sym, &iv);
 289                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 290
 291                 ret = yaca_seal_initialize(&ctx, key_rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 292                                                                    YACA_KEY_LENGTH_256BIT, NULL, &iv);
 293                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 294
 295                 ret = yaca_seal_initialize(&ctx, key_rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 296                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, NULL);
 297                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 298
 299                 ret = yaca_seal_initialize(&ctx, key_rsa_pub, YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CTR,
 300                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 301                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 302
 303                 ret = yaca_seal_initialize(&ctx, key_rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 304                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 305                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 306
 307                 ret = yaca_context_get_output_length(ctx, INPUT_DATA_SIZE, NULL);
 308                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 309
 310                 size_t total = allocate_output(ctx, INPUT_DATA_SIZE, 1, encrypted);
 311                 size_t written;
 312
 313                 ret = yaca_seal_update(YACA_CONTEXT_NULL, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
 314                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 315
 316                 ret = yaca_seal_update(ctx_encrypt, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
 317                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 318
 319                 ret = yaca_seal_update(ctx, NULL, INPUT_DATA_SIZE, encrypted, &written);
 320                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 321
 322                 ret = yaca_seal_update(ctx, INPUT_DATA, 0, encrypted, &written);
 323                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 324
 325                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, NULL, &written);
 326                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 327
 328                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, NULL);
 329                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 330
 331                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
 332                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 333                 encrypted_len = written;
 334
 335                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
 336                                                                                 &len, sizeof(size_t));
 337                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 338
 339                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 340                                                                                 &pad_invalid, sizeof(yaca_padding_e));
 341                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 342
 343                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 344                                                                                 &pad_pkcs7, 1);
 345                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 346
 347                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING, &pad_pkcs7,
 348                                                                                 sizeof(yaca_padding_e));
 349                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 350
 351                 ret = yaca_seal_finalize(YACA_CONTEXT_NULL, encrypted + encrypted_len, &written);
 352                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 353
 354                 ret = yaca_seal_finalize(ctx_encrypt, encrypted + encrypted_len, &written);
 355                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 356
 357                 ret = yaca_seal_finalize(ctx, NULL, &written);
 358                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 359
 360                 ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, NULL);
 361                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 362
 363                 ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
 364                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 365                 encrypted_len += written;
 366                 BOOST_REQUIRE(encrypted_len <= total);
 367                 ret = yaca_realloc(encrypted_len, (void **)&encrypted);
 368                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 369
 370                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING, &pad_pkcs7,
 371                                                                                 sizeof(yaca_padding_e));
 372                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 373
 374                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
 375                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 376
 377                 ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
 378                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 379
 380                 yaca_context_destroy(ctx);
 381                 ctx = YACA_CONTEXT_NULL;
 382         }
 383
 384         /* OPEN */
 385         {
 386                 ret = yaca_open_initialize(NULL, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 387                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 388                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 389
 390                 ret = yaca_open_initialize(&ctx, key_rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 391                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 392                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 393
 394                 ret = yaca_open_initialize(&ctx, key_dsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 395                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 396                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 397
 398                 ret = yaca_open_initialize(&ctx, key_dsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 399                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 400                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 401
 402                 ret = yaca_open_initialize(&ctx, key_sym2, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 403                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 404                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 405
 406                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_INVALID_ENCRYPT_ALGORITHM, YACA_BCM_CBC,
 407                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 408                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 409
 410                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_INVALID_BLOCK_CIPHER_MODE,
 411                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 412                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 413
 414                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 415                                                                    YACA_KEY_LENGTH_192BIT, key_sym, iv);
 416                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 417
 418                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 419                                                                    YACA_KEY_LENGTH_256BIT, YACA_KEY_NULL, iv);
 420                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 421
 422                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 423                                                                    YACA_KEY_LENGTH_256BIT, key_sym2, iv);
 424                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 425
 426                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 427                                                                    YACA_KEY_LENGTH_256BIT, key_rsa_prv, iv);
 428                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 429
 430                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 431                                                                    YACA_KEY_LENGTH_256BIT, iv, iv);
 432                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 433
 434                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 435                                                                    YACA_KEY_LENGTH_256BIT, key_sym, YACA_KEY_NULL);
 436                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 437
 438                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 439                                                                    YACA_KEY_LENGTH_256BIT, key_sym, key_sym2);
 440                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 441
 442                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 443                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 444                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 445
 446                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
 447                                                                                 &len, sizeof(size_t));
 448                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 449
 450                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 451                                                                                 &pad_invalid, 1);
 452                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 453
 454                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 455                                                                                 &pad_pkcs7, sizeof(yaca_padding_e));
 456                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 457
 458                 ret = yaca_context_get_output_length(ctx, encrypted_len, NULL);
 459                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 460
 461                 allocate_output(ctx, encrypted_len, 1, decrypted);
 462                 size_t written;
 463
 464                 ret = yaca_open_update(YACA_CONTEXT_NULL, encrypted, encrypted_len, decrypted, &written);
 465                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 466
 467                 ret = yaca_open_update(ctx_encrypt, encrypted, encrypted_len, decrypted, &written);
 468                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 469
 470                 ret = yaca_open_update(ctx, NULL, encrypted_len, decrypted, &written);
 471                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 472
 473                 ret = yaca_open_update(ctx, encrypted, 0, decrypted, &written);
 474                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 475
 476                 ret = yaca_open_update(ctx, encrypted, encrypted_len, NULL, &written);
 477                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 478
 479                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, NULL);
 480                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 481
 482                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
 483                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 484                 decrypted_len = written;
 485
 486                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 487                                                                                 &pad_pkcs7, sizeof(yaca_padding_e));
 488                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 489
 490                 ret = yaca_open_finalize(YACA_CONTEXT_NULL, decrypted + decrypted_len, &written);
 491                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 492
 493                 ret = yaca_open_finalize(ctx_encrypt, decrypted + decrypted_len, &written);
 494                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 495
 496                 ret = yaca_open_finalize(ctx, NULL, &written);
 497                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 498
 499                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, NULL);
 500                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 501
 502                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
 503                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 504
 505                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
 506                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 507
 508                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
 509                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 510
 511                 yaca_context_destroy(ctx);
 512                 ctx = YACA_CONTEXT_NULL;
 513                 yaca_free(decrypted);
 514                 decrypted = NULL;
 515         }
 516
 517         /* OPEN, wrong asym key */
 518         {
 519                 ret = yaca_open_initialize(&ctx, key_rsa_prv2, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 520                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 521                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 522         }
 523
 524         /* OPEN, wrong BCM */
 525         {
 526                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_ECB,
 527                                                                    YACA_KEY_LENGTH_256BIT, key_sym, YACA_KEY_NULL);
 528                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 529
 530                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 531                                                                                 &pad_pkcs7, sizeof(yaca_padding_e));
 532                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 533
 534                 allocate_output(ctx, encrypted_len, 1, decrypted);
 535                 size_t written;
 536
 537                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
 538                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 539                 decrypted_len = written;
 540
 541                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
 542                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 543
 544                 yaca_context_destroy(ctx);
 545                 ctx = YACA_CONTEXT_NULL;
 546                 yaca_free(decrypted);
 547                 decrypted = NULL;
 548         }
 549
 550         /* OPEN, wrong symmetric key */
 551         {
 552                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 553                                                                    YACA_KEY_LENGTH_256BIT, key_sym2, iv);
 554                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 555         }
 556
 557         /* OPEN, broken the end of ciphertext */
 558         {
 559                 encrypted[encrypted_len - 1] = ~encrypted[encrypted_len - 1];
 560                 encrypted[encrypted_len - 2] = ~encrypted[encrypted_len - 2];
 561
 562                 ret = yaca_open_initialize(&ctx, key_rsa_prv, YACA_ENCRYPT_AES, YACA_BCM_CBC,
 563                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
 564                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 565
 566                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_PADDING,
 567                                                                                 &pad_pkcs7, sizeof(yaca_padding_e));
 568                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 569
 570                 allocate_output(ctx, encrypted_len, 1, decrypted);
 571                 size_t written;
 572
 573                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
 574                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 575                 decrypted_len = written;
 576
 577                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
 578                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 579
 580                 yaca_context_destroy(ctx);
 581                 ctx = YACA_CONTEXT_NULL;
 582                 yaca_free(decrypted);
 583                 decrypted = NULL;
 584         }
 585
 586         yaca_key_destroy(key_rsa_prv);
 587         yaca_key_destroy(key_rsa_pub);
 588         yaca_key_destroy(key_rsa_prv2);
 589         yaca_key_destroy(key_rsa_pub2);
 590         yaca_key_destroy(key_dsa_prv);
 591         yaca_key_destroy(key_dsa_pub);
 592         yaca_key_destroy(key_sym);
 593         yaca_key_destroy(key_sym2);
 594         yaca_key_destroy(iv);
 595         yaca_free(encrypted);
 596 }
 597
 598 BOOST_FIXTURE_TEST_CASE(T703__positive__seal_open_rc2, InitDebugFixture)
 599 {
 600         struct seal_args {
 601                 yaca_block_cipher_mode_e bcm;
 602                 size_t key_bit_len;
 603                 size_t effective_key_bits;
 604                 size_t split;
 605         };
 606
 607         const std::vector<seal_args> sargs = {
 608                 {YACA_BCM_CBC, 128, IGNORE, 11},
 609                 {YACA_BCM_CBC, 192,     64, 22},
 610                 {YACA_BCM_CBC, 200,    128,  3},
 611                 {YACA_BCM_CBC, 192,    255,  7},
 612                 {YACA_BCM_CBC, 192,    713,  2},
 613                 {YACA_BCM_CBC, 224,      1, 19},
 614                 {YACA_BCM_CBC, 256,   1024, 19},
 615                 {YACA_BCM_CFB, 192, IGNORE, 13},
 616                 {YACA_BCM_CFB, 192,    333, 33},
 617                 {YACA_BCM_ECB, 272, IGNORE,  8},
 618                 {YACA_BCM_ECB, 192,    666, 15},
 619                 {YACA_BCM_OFB, 520, IGNORE, 25},
 620                 {YACA_BCM_OFB, 224,    999, 35},
 621         };
 622
 623         for (const auto &sa: sargs) {
 624                 int ret;
 625                 yaca_context_h ctx = YACA_CONTEXT_NULL;
 626                 yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
 627                 yaca_key_h key_sym = YACA_KEY_NULL, iv = YACA_KEY_NULL;
 628
 629                 char *encrypted = NULL, *decrypted = NULL;
 630                 size_t encrypted_len = 0, decrypted_len = 0;
 631
 632                 generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_prv, &key_pub);
 633
 634                 /* SEAL */
 635                 {
 636                         ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_UNSAFE_RC2, sa.bcm,
 637                                                                            sa.key_bit_len, &key_sym, &iv);
 638                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 639
 640                         if (sa.effective_key_bits != IGNORE) {
 641                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
 642                                                                                                 &sa.effective_key_bits, sizeof(size_t));
 643                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 644                         }
 645
 646                         size_t total = allocate_output(ctx, INPUT_DATA_SIZE, sa.split, encrypted);
 647                         size_t written;
 648
 649                         call_update_loop(ctx, INPUT_DATA, INPUT_DATA_SIZE,
 650                                                          encrypted, encrypted_len, sa.split,
 651                                                          yaca_seal_update);
 652
 653                         ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
 654                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 655                         encrypted_len += written;
 656
 657                         BOOST_REQUIRE(encrypted_len <= total);
 658                         ret = yaca_realloc(encrypted_len, (void **)&encrypted);
 659                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 660
 661                         yaca_context_destroy(ctx);
 662                         ctx = YACA_CONTEXT_NULL;
 663                 }
 664
 665                 /* OPEN */
 666                 {
 667                         ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_UNSAFE_RC2, sa.bcm,
 668                                                                            sa.key_bit_len, key_sym, iv);
 669                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 670
 671                         if (sa.effective_key_bits != IGNORE) {
 672                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
 673                                                                                                 &sa.effective_key_bits, sizeof(size_t));
 674                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 675                         }
 676
 677                         size_t total = allocate_output(ctx, encrypted_len, sa.split, decrypted);
 678                         size_t written;
 679
 680                         call_update_loop(ctx, encrypted, encrypted_len,
 681                                                          decrypted, decrypted_len, sa.split,
 682                                                          yaca_open_update);
 683
 684                         ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
 685                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 686                         decrypted_len += written;
 687
 688                         BOOST_REQUIRE(decrypted_len <= total);
 689                         ret = yaca_realloc(decrypted_len, (void **)&decrypted);
 690                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 691
 692                         yaca_context_destroy(ctx);
 693                         ctx = YACA_CONTEXT_NULL;
 694                 }
 695
 696                 BOOST_REQUIRE(decrypted_len == INPUT_DATA_SIZE);
 697                 ret = yaca_memcmp(INPUT_DATA, decrypted, INPUT_DATA_SIZE);
 698                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 699
 700                 yaca_key_destroy(key_prv);
 701                 yaca_key_destroy(key_pub);
 702                 yaca_key_destroy(key_sym);
 703                 yaca_key_destroy(iv);
 704                 yaca_free(encrypted);
 705                 yaca_free(decrypted);
 706         }
 707 }
 708
 709 BOOST_FIXTURE_TEST_CASE(T704__negative__encrypt_decrypt_rc2, InitDebugFixture)
 710 {
 711         int ret;
 712         yaca_context_h ctx = YACA_CONTEXT_NULL;
 713         yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
 714         yaca_key_h key_sym = YACA_KEY_NULL, iv = YACA_KEY_NULL;
 715
 716         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_prv, &key_pub);
 717
 718         /* SEAL */
 719         {
 720                 ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_UNSAFE_RC2, YACA_BCM_CFB1,
 721                                                                    YACA_KEY_LENGTH_192BIT, &key_sym, &iv);
 722                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 723
 724                 ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_UNSAFE_RC2, YACA_BCM_CTR,
 725                                                                    YACA_KEY_LENGTH_192BIT, &key_sym, &iv);
 726                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 727
 728                 ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_UNSAFE_RC2, YACA_BCM_CBC,
 729                                                                    YACA_KEY_LENGTH_192BIT, &key_sym, &iv);
 730                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 731
 732                 yaca_context_destroy(ctx);
 733                 ctx = YACA_CONTEXT_NULL;
 734         }
 735
 736         /* OPEN */
 737         {
 738                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_UNSAFE_RC2, YACA_BCM_CFB1,
 739                                                                    YACA_KEY_LENGTH_192BIT, key_sym, iv);
 740                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 741
 742                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_UNSAFE_RC2, YACA_BCM_CTR,
 743                                                                    YACA_KEY_LENGTH_192BIT, key_sym, iv);
 744                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 745         }
 746
 747         yaca_key_destroy(key_prv);
 748         yaca_key_destroy(key_pub);
 749         yaca_key_destroy(key_sym);
 750         yaca_key_destroy(iv);
 751 }
 752
 753 BOOST_FIXTURE_TEST_CASE(T705__positive__open_seal_ccm, InitDebugFixture)
 754 {
 755         struct seal_args {
 756                 size_t key_bit_len;
 757                 size_t ccm_tag_len;
 758                 size_t aad_len;
 759         };
 760
 761         const std::vector<seal_args> sargs = {
 762                 {128, IGNORE, IGNORE},
 763                 {128,      4, IGNORE},
 764                 {128, IGNORE,     13},
 765                 {128,      6,     23},
 766
 767                 {192, IGNORE, IGNORE},
 768                 {192,     10, IGNORE},
 769                 {192, IGNORE,     21},
 770                 {192,      8,     17},
 771
 772                 {256, IGNORE, IGNORE},
 773                 {256,     16, IGNORE},
 774                 {256, IGNORE,     55},
 775                 {256,     12,     33},
 776         };
 777
 778         for (const auto &sa: sargs) {
 779                 int ret;
 780                 yaca_context_h ctx = YACA_CONTEXT_NULL;
 781                 yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
 782                 yaca_key_h key_sym = YACA_KEY_NULL, iv = YACA_KEY_NULL;
 783
 784                 char *tag = NULL, *aad = NULL;
 785                 size_t tag_len;
 786
 787                 char *encrypted = NULL, *decrypted = NULL;
 788                 size_t encrypted_len, decrypted_len;
 789
 790                 generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_prv, &key_pub);
 791
 792                 /* SEAL */
 793                 {
 794                         ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_AES, YACA_BCM_CCM,
 795                                                                            sa.key_bit_len, &key_sym, &iv);
 796                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 797
 798                         size_t total = allocate_output(ctx, INPUT_DATA_SIZE, 1, encrypted);
 799                         size_t written;
 800
 801                         if (sa.ccm_tag_len != IGNORE) {
 802                                 tag_len = sa.ccm_tag_len;
 803
 804                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG_LEN,
 805                                                                                                 &tag_len, sizeof(tag_len));
 806                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 807                         }
 808
 809                         if (sa.aad_len != IGNORE) {
 810                                 ret = yaca_malloc(sa.aad_len, (void**)&aad);
 811                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 812
 813                                 ret = yaca_randomize_bytes(aad, sa.aad_len);
 814                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 815
 816                                 ret = yaca_seal_update(ctx, NULL, INPUT_DATA_SIZE,
 817                                                                            NULL, &written);
 818                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 819
 820                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD,
 821                                                                                                 aad, sa.aad_len);
 822                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 823                         }
 824
 825                         ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
 826                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 827                         encrypted_len = written;
 828
 829                         ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
 830                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 831                         encrypted_len += written;
 832
 833                         BOOST_REQUIRE(encrypted_len <= total);
 834                         ret = yaca_realloc(encrypted_len, (void **)&encrypted);
 835                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 836
 837                         ret = yaca_context_get_property(ctx, YACA_PROPERTY_CCM_TAG, (void**)&tag, &tag_len);
 838                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 839
 840                         yaca_context_destroy(ctx);
 841                         ctx = YACA_CONTEXT_NULL;
 842                 }
 843
 844                 /* OPEN */
 845                 {
 846                         ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_CCM,
 847                                                                            sa.key_bit_len, key_sym, iv);
 848                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 849
 850                         size_t total = allocate_output(ctx, encrypted_len, 1, decrypted);
 851
 852                         ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG, tag, tag_len);
 853                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 854
 855                         size_t written;
 856
 857                         if (sa.aad_len != IGNORE) {
 858                                 ret = yaca_open_update(ctx, NULL, encrypted_len,
 859                                                                            NULL, &written);
 860                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 861
 862                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD,
 863                                                                                                 aad, sa.aad_len);
 864                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 865                         }
 866
 867                         ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
 868                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 869                         decrypted_len = written;
 870
 871                         ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
 872                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 873                         decrypted_len += written;
 874
 875                         BOOST_REQUIRE(decrypted_len <= total);
 876                         ret = yaca_realloc(decrypted_len, (void **)&decrypted);
 877                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 878
 879                         yaca_context_destroy(ctx);
 880                         ctx = YACA_CONTEXT_NULL;
 881                 }
 882
 883                 BOOST_REQUIRE(decrypted_len == INPUT_DATA_SIZE);
 884                 ret = yaca_memcmp(INPUT_DATA, decrypted, INPUT_DATA_SIZE);
 885                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 886
 887                 yaca_key_destroy(key_prv);
 888                 yaca_key_destroy(key_pub);
 889                 yaca_key_destroy(key_sym);
 890                 yaca_key_destroy(iv);
 891                 yaca_free(encrypted);
 892                 yaca_free(decrypted);
 893                 yaca_free(tag);
 894                 yaca_free(aad);
 895         }
 896 }
 897
 898 BOOST_FIXTURE_TEST_CASE(T706__negative__open_seal_ccm, InitDebugFixture)
 899 {
 900         int ret;
 901         yaca_context_h ctx = YACA_CONTEXT_NULL;
 902         yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
 903         yaca_key_h key_sym = YACA_KEY_NULL, iv = YACA_KEY_NULL;
 904
 905         char *tag = NULL, *aad = NULL;
 906         size_t tag_len = 0, tag_len_invalid = 17, aad_len = 55;
 907
 908         char *encrypted = NULL, *decrypted = NULL;
 909         size_t encrypted_len, decrypted_len;
 910
 911         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_prv, &key_pub);
 912
 913         ret = yaca_malloc(aad_len, (void**)&aad);
 914         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 915         ret = yaca_randomize_bytes(aad, aad_len);
 916         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 917
 918         /* SEAL, AAD without pre-update */
 919         {
 920                 ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_AES, YACA_BCM_CCM,
 921                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 922                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 923
 924                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad, aad_len);
 925                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 926
 927                 yaca_context_destroy(ctx);
 928                 ctx = YACA_CONTEXT_NULL;
 929                 yaca_key_destroy(key_sym);
 930                 key_sym = YACA_KEY_NULL;
 931                 yaca_key_destroy(iv);
 932                 iv = YACA_KEY_NULL;
 933         }
 934
 935         /* SEAL, pre-update without AAD */
 936         {
 937                 ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_AES, YACA_BCM_CCM,
 938                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 939                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 940
 941                 allocate_output(ctx, INPUT_DATA_SIZE, 1, encrypted);
 942                 size_t written;
 943
 944                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG_LEN,
 945                                                                                 &tag_len_invalid, sizeof(tag_len_invalid));
 946                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 947
 948                 ret = yaca_seal_update(ctx, NULL, INPUT_DATA_SIZE, NULL, &written);
 949                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 950
 951                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
 952                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 953
 954                 yaca_context_destroy(ctx);
 955                 ctx = YACA_CONTEXT_NULL;
 956                 yaca_key_destroy(key_sym);
 957                 key_sym = YACA_KEY_NULL;
 958                 yaca_key_destroy(iv);
 959                 iv = YACA_KEY_NULL;
 960         }
 961
 962         /* SEAL */
 963         {
 964                 ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_AES, YACA_BCM_CCM,
 965                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
 966                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 967
 968                 size_t total = allocate_output(ctx, INPUT_DATA_SIZE, 1, encrypted);
 969                 size_t written;
 970
 971                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG_LEN,
 972                                                                                 &tag_len_invalid, sizeof(tag_len_invalid));
 973                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 974
 975                 ret = yaca_seal_update(ctx, NULL, INPUT_DATA_SIZE, encrypted, &written);
 976                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 977
 978                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, NULL, &written);
 979                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 980
 981                 ret = yaca_context_get_property(ctx, YACA_PROPERTY_CCM_TAG, (void**)&tag, &tag_len);
 982                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 983
 984                 ret = yaca_seal_update(ctx, NULL, INPUT_DATA_SIZE, NULL, &written);
 985                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 986
 987                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
 988                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 989
 990                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad, aad_len);
 991                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 992
 993                 ret = yaca_seal_update(ctx, NULL, INPUT_DATA_SIZE, NULL, &written);
 994                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 995
 996                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
 997                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 998                 encrypted_len = written;
 999
1000                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
1001                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1002
1003                 ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
1004                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1005                 encrypted_len += written;
1006                 BOOST_REQUIRE(encrypted_len <= total);
1007                 ret = yaca_realloc(encrypted_len, (void **)&encrypted);
1008                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1009
1010                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad, aad_len);
1011                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1012
1013                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
1014                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1015
1016                 ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
1017                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1018
1019                 ret = yaca_context_get_property(ctx, YACA_PROPERTY_CCM_TAG, (void**)&tag, &tag_len);
1020                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1021
1022                 yaca_context_destroy(ctx);
1023                 ctx = YACA_CONTEXT_NULL;
1024         }
1025
1026         /* OPEN, no TAG */
1027         {
1028                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_CCM,
1029                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1030                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1031
1032                 allocate_output(ctx, encrypted_len, 1, decrypted);
1033                 size_t written;
1034
1035                 ret = yaca_open_update(ctx, NULL, encrypted_len, NULL, &written);
1036                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1037                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad, aad_len);
1038                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1039
1040                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1041                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1042
1043                 yaca_context_destroy(ctx);
1044                 ctx = YACA_CONTEXT_NULL;
1045                 yaca_free(decrypted);
1046                 decrypted = NULL;
1047         }
1048
1049         /* OPEN, AAD without pre-update */
1050         {
1051                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_CCM,
1052                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1053                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1054
1055                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG, tag, tag_len);
1056                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1057
1058                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad, aad_len);
1059                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1060
1061                 yaca_context_destroy(ctx);
1062                 ctx = YACA_CONTEXT_NULL;
1063         }
1064
1065         /* OPEN, pre-update without AAD */
1066         {
1067                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_CCM,
1068                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1069                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1070
1071                 allocate_output(ctx, encrypted_len, 1, decrypted);
1072                 size_t written;
1073
1074                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG, tag, tag_len);
1075                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1076
1077                 ret = yaca_open_update(ctx, NULL, encrypted_len, NULL, &written);
1078                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1079
1080                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1081                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1082
1083                 yaca_context_destroy(ctx);
1084                 ctx = YACA_CONTEXT_NULL;
1085                 yaca_free(decrypted);
1086                 decrypted = NULL;
1087         }
1088
1089         /* OPEN, no AAD */
1090         {
1091                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_CCM,
1092                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1093                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1094
1095                 allocate_output(ctx, encrypted_len, 1, decrypted);
1096                 size_t written;
1097
1098                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG, tag, tag_len);
1099                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1100
1101                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1102                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1103
1104                 yaca_context_destroy(ctx);
1105                 ctx = YACA_CONTEXT_NULL;
1106                 yaca_free(decrypted);
1107                 decrypted = NULL;
1108         }
1109
1110         /* OPEN */
1111         {
1112                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_CCM,
1113                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1114                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1115
1116                 allocate_output(ctx, encrypted_len, 1, decrypted);
1117                 size_t written;
1118
1119                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG, tag, tag_len);
1120                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1121
1122                 ret = yaca_open_update(ctx, NULL, encrypted_len, decrypted, &written);
1123                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1124
1125                 ret = yaca_open_update(ctx, encrypted, encrypted_len, NULL, &written);
1126                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1127
1128                 ret = yaca_open_update(ctx, NULL, encrypted_len, NULL, &written);
1129                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1130
1131                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1132                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1133
1134                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad, aad_len);
1135                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1136
1137                 ret = yaca_open_update(ctx, NULL, encrypted_len, NULL, &written);
1138                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1139
1140                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1141                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1142                 decrypted_len = written;
1143
1144                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1145                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1146
1147                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1148                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1149
1150                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad, aad_len);
1151                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1152
1153                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG, tag, tag_len);
1154                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1155
1156                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1157                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1158
1159                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1160                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1161
1162                 yaca_context_destroy(ctx);
1163                 ctx = YACA_CONTEXT_NULL;
1164                 yaca_free(decrypted);
1165                 decrypted = NULL;
1166         }
1167
1168         /* OPEN, broken TAG */
1169         {
1170                 char *tag2 = NULL;
1171                 ret = yaca_malloc(tag_len, (void**)&tag2);
1172                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1173                 memcpy((void*)tag2, (void*)tag, tag_len);
1174                 tag2[0] = ~tag2[0];
1175                 tag2[1] = ~tag2[1];
1176
1177                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_CCM,
1178                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1179                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1180
1181                 allocate_output(ctx, encrypted_len, 1, decrypted);
1182                 size_t written;
1183
1184                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG, tag2, tag_len);
1185                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1186
1187                 ret = yaca_open_update(ctx, NULL, encrypted_len, NULL, &written);
1188                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1189                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad, aad_len);
1190                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1191
1192                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1193                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1194
1195                 yaca_context_destroy(ctx);
1196                 ctx = YACA_CONTEXT_NULL;
1197                 yaca_free(decrypted);
1198                 decrypted = NULL;
1199                 yaca_free(tag2);
1200         }
1201
1202         /* OPEN, broken AAD */
1203         {
1204                 char *aad2 = NULL;
1205                 ret = yaca_malloc(aad_len, (void**)&aad2);
1206                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1207                 memcpy((void*)aad2, (void*)aad, aad_len);
1208                 aad2[0] = ~aad2[0];
1209                 aad2[1] = ~aad2[1];
1210
1211                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_CCM,
1212                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1213                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1214
1215                 allocate_output(ctx, encrypted_len, 1, decrypted);
1216                 size_t written;
1217
1218                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG, tag, tag_len);
1219                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1220
1221                 ret = yaca_open_update(ctx, NULL, encrypted_len, NULL, &written);
1222                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1223                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad2, aad_len);
1224                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1225
1226                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1227                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1228
1229                 yaca_context_destroy(ctx);
1230                 ctx = YACA_CONTEXT_NULL;
1231                 yaca_free(decrypted);
1232                 decrypted = NULL;
1233                 yaca_free(aad2);
1234         }
1235
1236         /* OPEN, broken ciphertext */
1237         {
1238                 encrypted[0] = ~encrypted[0];
1239                 encrypted[1] = ~encrypted[1];
1240
1241                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_CCM,
1242                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1243                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1244
1245                 allocate_output(ctx, encrypted_len, 1, decrypted);
1246                 size_t written;
1247
1248                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_TAG, tag, tag_len);
1249                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1250
1251                 ret = yaca_open_update(ctx, NULL, encrypted_len, NULL, &written);
1252                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1253                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_CCM_AAD, aad, aad_len);
1254                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1255
1256                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1257                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1258
1259                 yaca_context_destroy(ctx);
1260                 ctx = YACA_CONTEXT_NULL;
1261                 yaca_free(decrypted);
1262                 decrypted = NULL;
1263         }
1264
1265         yaca_key_destroy(key_prv);
1266         yaca_key_destroy(key_pub);
1267         yaca_key_destroy(key_sym);
1268         yaca_key_destroy(iv);
1269         yaca_free(encrypted);
1270         yaca_free(tag);
1271         yaca_free(aad);
1272 }
1273
1274 BOOST_FIXTURE_TEST_CASE(T707__positive__seal_open_gcm, InitDebugFixture)
1275 {
1276         struct seal_args {
1277                 size_t key_bit_len;
1278                 size_t gcm_tag_len;
1279                 size_t aad_len;
1280                 size_t split;
1281         };
1282
1283         const std::vector<seal_args> sargs = {
1284                 {128, IGNORE, IGNORE, 11},
1285                 {128,      4, IGNORE, 12},
1286                 {128, IGNORE,     21, 13},
1287                 {128,     13,     22, 14},
1288
1289                 {192, IGNORE, IGNORE, 22},
1290                 {192,      8, IGNORE, 23},
1291                 {192, IGNORE,     32, 24},
1292                 {192,     15,     33, 25},
1293
1294                 {256, IGNORE, IGNORE, 33},
1295                 {256,     14, IGNORE, 34},
1296                 {256, IGNORE,     17, 35},
1297                 {256,     16,     44, 36},
1298         };
1299
1300         for (const auto &sa: sargs) {
1301                 int ret;
1302                 yaca_context_h ctx = YACA_CONTEXT_NULL;
1303                 yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
1304                 yaca_key_h key_sym = YACA_KEY_NULL, iv = YACA_KEY_NULL;
1305
1306                 char *encrypted = NULL, *decrypted = NULL;
1307                 size_t encrypted_len = 0, decrypted_len = 0;
1308
1309                 char *tag = NULL, *aad = NULL;
1310                 size_t tag_len;
1311
1312                 generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_prv, &key_pub);
1313
1314                 /* SEAL */
1315                 {
1316                         ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_AES, YACA_BCM_GCM,
1317                                                                            sa.key_bit_len, &key_sym, &iv);
1318                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1319
1320                         size_t total = allocate_output(ctx, INPUT_DATA_SIZE, sa.split, encrypted);
1321                         size_t written;
1322
1323                         if (sa.aad_len != IGNORE) {
1324                                 ret = yaca_malloc(sa.aad_len, (void**)&aad);
1325                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1326
1327                                 ret = yaca_randomize_bytes(aad, sa.aad_len);
1328                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1329
1330                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_AAD,
1331                                                                                                 aad, sa.aad_len);
1332                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1333                         }
1334
1335                         call_update_loop(ctx, INPUT_DATA, INPUT_DATA_SIZE,
1336                                                          encrypted, encrypted_len, sa.split,
1337                                                          yaca_seal_update);
1338
1339                         ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
1340                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1341                         encrypted_len += written;
1342
1343                         BOOST_REQUIRE(encrypted_len <= total);
1344                         ret = yaca_realloc(encrypted_len, (void **)&encrypted);
1345                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1346
1347                         if (sa.gcm_tag_len != IGNORE) {
1348                                 tag_len = sa.gcm_tag_len;
1349
1350                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_TAG_LEN,
1351                                                                                                 &tag_len, sizeof(tag_len));
1352                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1353
1354                         }
1355
1356                         ret = yaca_context_get_property(ctx, YACA_PROPERTY_GCM_TAG,
1357                                                                                         (void**)&tag, &tag_len);
1358                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1359
1360                         yaca_context_destroy(ctx);
1361                         ctx = YACA_CONTEXT_NULL;
1362                 }
1363
1364                 /* OPEN */
1365                 {
1366                         ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_GCM,
1367                                                                            sa.key_bit_len, key_sym, iv);
1368                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1369
1370                         size_t total = allocate_output(ctx, encrypted_len, sa.split, decrypted);
1371                         size_t written;
1372
1373                         if (sa.aad_len != IGNORE) {
1374                                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_AAD,
1375                                                                                                 aad, sa.aad_len);
1376                                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1377                         }
1378
1379                         call_update_loop(ctx, encrypted, encrypted_len,
1380                                                          decrypted, decrypted_len, sa.split,
1381                                                          yaca_open_update);
1382
1383                         ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_TAG,
1384                                                                                         tag, tag_len);
1385                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1386
1387                         ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1388                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1389                         decrypted_len += written;
1390
1391                         BOOST_REQUIRE(decrypted_len <= total);
1392                         ret = yaca_realloc(decrypted_len, (void **)&decrypted);
1393                         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1394
1395                         yaca_context_destroy(ctx);
1396                         ctx = YACA_CONTEXT_NULL;
1397                 }
1398
1399                 BOOST_REQUIRE(decrypted_len == INPUT_DATA_SIZE);
1400                 ret = yaca_memcmp(INPUT_DATA, decrypted, INPUT_DATA_SIZE);
1401                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1402
1403                 yaca_key_destroy(key_prv);
1404                 yaca_key_destroy(key_pub);
1405                 yaca_key_destroy(key_sym);
1406                 yaca_key_destroy(iv);
1407                 yaca_free(encrypted);
1408                 yaca_free(decrypted);
1409                 yaca_free(tag);
1410                 yaca_free(aad);
1411         }
1412 }
1413
1414 BOOST_FIXTURE_TEST_CASE(T708__negative__seal_open_gcm, InitDebugFixture)
1415 {
1416         int ret;
1417         yaca_context_h ctx = YACA_CONTEXT_NULL;
1418         yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
1419         yaca_key_h key_sym = YACA_KEY_NULL, iv = YACA_KEY_NULL;
1420
1421         char *encrypted = NULL, *decrypted = NULL;
1422         size_t encrypted_len = 0, decrypted_len = 0;
1423
1424         char *tag = NULL, *aad = NULL;
1425         size_t tag_len = 0, tag_len_invalid = 17, aad_len = 55;
1426
1427         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, &key_prv, &key_pub);
1428
1429         ret = yaca_malloc(aad_len, (void**)&aad);
1430         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1431         ret = yaca_randomize_bytes(aad, aad_len);
1432         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1433
1434         /* SEAL */
1435         {
1436                 ret = yaca_seal_initialize(&ctx, key_pub, YACA_ENCRYPT_AES, YACA_BCM_GCM,
1437                                                                    YACA_KEY_LENGTH_256BIT, &key_sym, &iv);
1438                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1439
1440                 size_t total = allocate_output(ctx, INPUT_DATA_SIZE, 1, encrypted);
1441                 size_t written;
1442
1443                 ret = yaca_seal_update(ctx, NULL, INPUT_DATA_SIZE, NULL, &written);
1444                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1445
1446                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_AAD, aad, aad_len);
1447                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1448
1449                 ret = yaca_seal_update(ctx, NULL, INPUT_DATA_SIZE, NULL, &written);
1450                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1451
1452                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
1453                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1454                 encrypted_len = written;
1455
1456                 ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
1457                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1458                 encrypted_len += written;
1459                 BOOST_REQUIRE(encrypted_len <= total);
1460                 ret = yaca_realloc(encrypted_len, (void **)&encrypted);
1461                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1462
1463                 ret = yaca_seal_update(ctx, INPUT_DATA, INPUT_DATA_SIZE, encrypted, &written);
1464                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1465
1466                 ret = yaca_seal_finalize(ctx, encrypted + encrypted_len, &written);
1467                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1468
1469                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_TAG_LEN,
1470                                                                                 &tag_len_invalid, sizeof(tag_len_invalid));
1471                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1472
1473                 ret = yaca_context_get_property(ctx, YACA_PROPERTY_GCM_TAG,
1474                                                                                 (void**)&tag, &tag_len);
1475                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1476
1477                 yaca_context_destroy(ctx);
1478                 ctx = YACA_CONTEXT_NULL;
1479         }
1480
1481         /* OPEN, no TAG */
1482         {
1483                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_GCM,
1484                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1485                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1486
1487                 allocate_output(ctx, encrypted_len, 1, decrypted);
1488                 size_t written;
1489
1490                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_AAD, aad, aad_len);
1491                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1492
1493                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1494                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1495                 decrypted_len = written;
1496
1497                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1498                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1499
1500                 yaca_context_destroy(ctx);
1501                 ctx = YACA_CONTEXT_NULL;
1502                 yaca_free(decrypted);
1503                 decrypted = NULL;
1504         }
1505
1506         /* OPEN, no AAD */
1507         {
1508                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_GCM,
1509                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1510                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1511
1512                 allocate_output(ctx, encrypted_len, 1, decrypted);
1513                 size_t written;
1514
1515                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1516                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1517                 decrypted_len = written;
1518
1519                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_TAG, tag, tag_len);
1520                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1521
1522                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1523                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1524
1525                 yaca_context_destroy(ctx);
1526                 ctx = YACA_CONTEXT_NULL;
1527                 yaca_free(decrypted);
1528                 decrypted = NULL;
1529         }
1530
1531         /* OPEN */
1532         {
1533                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_GCM,
1534                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1535                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1536
1537                 allocate_output(ctx, encrypted_len, 1, decrypted);
1538                 size_t written;
1539
1540                 ret = yaca_open_update(ctx, NULL, encrypted_len, NULL, &written);
1541                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1542
1543                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_AAD, aad, aad_len);
1544                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1545
1546                 ret = yaca_open_update(ctx, NULL, encrypted_len, NULL, &written);
1547                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1548
1549                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1550                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1551                 decrypted_len = written;
1552
1553                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_TAG, tag, tag_len);
1554                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1555
1556                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1557                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1558
1559                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1560                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1561
1562                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1563                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1564
1565                 yaca_context_destroy(ctx);
1566                 ctx = YACA_CONTEXT_NULL;
1567                 yaca_free(decrypted);
1568                 decrypted = NULL;
1569         }
1570
1571         /* OPEN, broken TAG */
1572         {
1573                 char *tag2 = NULL;
1574                 ret = yaca_malloc(tag_len, (void**)&tag2);
1575                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1576                 memcpy((void*)tag2, (void*)tag, tag_len);
1577                 tag2[0] = ~tag2[0];
1578                 tag2[1] = ~tag2[1];
1579
1580                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_GCM,
1581                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1582                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1583
1584                 allocate_output(ctx, encrypted_len, 1, decrypted);
1585                 size_t written;
1586
1587                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_AAD, aad, aad_len);
1588                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1589
1590                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1591                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1592                 decrypted_len = written;
1593
1594                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_TAG, tag2, tag_len);
1595                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1596
1597                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1598                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1599
1600                 yaca_context_destroy(ctx);
1601                 ctx = YACA_CONTEXT_NULL;
1602                 yaca_free(decrypted);
1603                 decrypted = NULL;
1604                 yaca_free(tag2);
1605         }
1606
1607         /* OPEN, broken AAD */
1608         {
1609                 char *aad2 = NULL;
1610                 ret = yaca_malloc(aad_len, (void**)&aad2);
1611                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1612                 memcpy((void*)aad2, (void*)aad, aad_len);
1613                 aad2[0] = ~aad2[0];
1614                 aad2[1] = ~aad2[1];
1615
1616                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_GCM,
1617                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1618                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1619
1620                 allocate_output(ctx, encrypted_len, 1, decrypted);
1621                 size_t written;
1622
1623                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_AAD, aad2, aad_len);
1624                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1625
1626                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1627                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1628                 decrypted_len = written;
1629
1630                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_TAG, tag, tag_len);
1631                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1632
1633                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1634                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1635
1636                 yaca_context_destroy(ctx);
1637                 ctx = YACA_CONTEXT_NULL;
1638                 yaca_free(decrypted);
1639                 decrypted = NULL;
1640                 yaca_free(aad2);
1641         }
1642
1643         /* OPEN, broken ciphertext */
1644         {
1645                 encrypted[0] = ~encrypted[0];
1646                 encrypted[1] = ~encrypted[1];
1647
1648                 ret = yaca_open_initialize(&ctx, key_prv, YACA_ENCRYPT_AES, YACA_BCM_GCM,
1649                                                                    YACA_KEY_LENGTH_256BIT, key_sym, iv);
1650                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1651
1652                 allocate_output(ctx, encrypted_len, 1, decrypted);
1653                 size_t written;
1654
1655                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_AAD, aad, aad_len);
1656                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1657
1658                 ret = yaca_open_update(ctx, encrypted, encrypted_len, decrypted, &written);
1659                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1660                 decrypted_len = written;
1661
1662                 ret = yaca_context_set_property(ctx, YACA_PROPERTY_GCM_TAG, tag, tag_len);
1663                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
1664
1665                 ret = yaca_open_finalize(ctx, decrypted + decrypted_len, &written);
1666                 BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
1667
1668                 yaca_context_destroy(ctx);
1669                 ctx = YACA_CONTEXT_NULL;
1670                 yaca_free(decrypted);
1671                 decrypted = NULL;
1672         }
1673
1674         yaca_key_destroy(key_prv);
1675         yaca_key_destroy(key_pub);
1676         yaca_key_destroy(key_sym);
1677         yaca_key_destroy(iv);
1678         yaca_free(encrypted);
1679         yaca_free(tag);
1680         yaca_free(aad);
1681 }
1682
1683 BOOST_AUTO_TEST_SUITE_END()