tests/test_rsa.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_rsa.c
  21  * @author  Lukasz Pawelczyk <l.pawelczyk@samsung.com>
  22  * @brief   RSA API unit tests.
  23  */
  24
  25 #include <boost/test/unit_test.hpp>
  26 #include <vector>
  27
  28 #include <yaca_crypto.h>
  29 #include <yaca_rsa.h>
  30 #include <yaca_key.h>
  31 #include <yaca_error.h>
  32
  33 #include "common.h"
  34
  35
  36 BOOST_AUTO_TEST_SUITE(TESTS_RSA)
  37
  38 BOOST_FIXTURE_TEST_CASE(T401__positive__private_encrypt, InitDebugFixture)
  39 {
  40         struct rsa_args {
  41                 yaca_padding_e pad;
  42                 yaca_key_bit_length_e bit_len;
  43                 size_t shorter;
  44         };
  45
  46         const std::vector<struct rsa_args> rargs = {
  47                 {YACA_PADDING_NONE,         YACA_KEY_LENGTH_512BIT,   0},
  48                 {YACA_PADDING_NONE,         YACA_KEY_LENGTH_2048BIT,  0},
  49                 {YACA_PADDING_PKCS1,        YACA_KEY_LENGTH_512BIT,  11},
  50                 {YACA_PADDING_PKCS1,        YACA_KEY_LENGTH_4096BIT, 11},
  51         };
  52
  53         for (const auto &ra: rargs) {
  54                 int ret;
  55                 yaca_key_h rsa_prv = YACA_KEY_NULL, rsa_pub = YACA_KEY_NULL;
  56                 size_t input_len = ra.bit_len / 8 - ra.shorter;
  57                 char *encrypted = NULL, *decrypted = NULL;
  58                 size_t encrypted_len, decrypted_len;
  59
  60                 generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, ra.bit_len, &rsa_prv, &rsa_pub);
  61
  62                 ret = yaca_rsa_private_encrypt(ra.pad, rsa_prv, INPUT_DATA, input_len,
  63                                                                            &encrypted, &encrypted_len);
  64                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
  65
  66                 ret = yaca_rsa_public_decrypt(ra.pad, rsa_pub, encrypted, encrypted_len,
  67                                                                           &decrypted, &decrypted_len);
  68                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
  69
  70                 BOOST_REQUIRE(decrypted_len == input_len);
  71                 ret = yaca_memcmp(decrypted, INPUT_DATA, input_len);
  72                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
  73
  74                 yaca_key_destroy(rsa_prv);
  75                 yaca_key_destroy(rsa_pub);
  76                 yaca_free(encrypted);
  77                 yaca_free(decrypted);
  78         }
  79
  80         /* Empty input, must use padding */
  81         for (const auto &ra: rargs) {
  82                 if (ra.pad == YACA_PADDING_NONE)
  83                         continue;
  84
  85                 int ret;
  86                 yaca_key_h rsa_prv = YACA_KEY_NULL, rsa_pub = YACA_KEY_NULL;
  87                 char *encrypted = NULL, *decrypted = NULL;
  88                 size_t encrypted_len, decrypted_len;
  89
  90                 generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, ra.bit_len, &rsa_prv, &rsa_pub);
  91
  92                 ret = yaca_rsa_private_encrypt(ra.pad, rsa_prv, NULL, 0,
  93                                                                            &encrypted, &encrypted_len);
  94                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
  95
  96                 ret = yaca_rsa_public_decrypt(ra.pad, rsa_pub, encrypted, encrypted_len,
  97                                                                           &decrypted, &decrypted_len);
  98                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
  99
 100                 BOOST_REQUIRE(decrypted == NULL);
 101                 BOOST_REQUIRE(decrypted_len == 0);
 102
 103                 yaca_key_destroy(rsa_prv);
 104                 yaca_key_destroy(rsa_pub);
 105                 yaca_free(encrypted);
 106                 yaca_free(decrypted);
 107         }
 108 }
 109
 110 BOOST_FIXTURE_TEST_CASE(T402__negative__private_encrypt, InitDebugFixture)
 111 {
 112         int ret;
 113         size_t bit_len = YACA_KEY_LENGTH_1024BIT;
 114         yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
 115         yaca_key_h key_prv2 = YACA_KEY_NULL, key_pub2 = YACA_KEY_NULL;
 116         yaca_key_h key_dsa = YACA_KEY_NULL, key_ec = YACA_KEY_NULL;
 117         size_t input_len = bit_len / 8;
 118         size_t input_len_pkcs1 = bit_len / 8 - 11;
 119         char *encrypted = NULL, *encrypted_pkcs1 = NULL, *decrypted = NULL;
 120         size_t encrypted_len, encrypted_pkcs1_len, decrypted_len;
 121
 122         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, bit_len, &key_prv, &key_pub);
 123         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, bit_len, &key_prv2, &key_pub2);
 124         generate_asymmetric_keys(YACA_KEY_TYPE_DSA_PRIV, bit_len, &key_dsa);
 125         generate_asymmetric_keys(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &key_ec);
 126
 127         ret = yaca_rsa_private_encrypt(YACA_INVALID_PADDING, key_prv,
 128                                                                    INPUT_DATA, input_len,
 129                                                                    &encrypted, &encrypted_len);
 130         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 131
 132         ret = yaca_rsa_private_encrypt(YACA_PADDING_X931, key_prv,
 133                                                                    INPUT_DATA, input_len,
 134                                                                    &encrypted, &encrypted_len);
 135         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 136
 137         ret = yaca_rsa_private_encrypt(YACA_PADDING_PKCS1_OAEP, key_prv,
 138                                                                    INPUT_DATA, input_len,
 139                                                                    &encrypted, &encrypted_len);
 140         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 141
 142         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, YACA_KEY_NULL,
 143                                                                    INPUT_DATA, input_len,
 144                                                                    &encrypted, &encrypted_len);
 145         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 146
 147         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_pub,
 148                                                                    INPUT_DATA, input_len,
 149                                                                    &encrypted, &encrypted_len);
 150         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 151
 152         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_ec,
 153                                                                    INPUT_DATA, input_len,
 154                                                                    &encrypted, &encrypted_len);
 155         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 156
 157         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_dsa,
 158                                                                    INPUT_DATA, input_len,
 159                                                                    &encrypted, &encrypted_len);
 160         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 161
 162         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_prv,
 163                                                                    NULL, input_len,
 164                                                                    &encrypted, &encrypted_len);
 165         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 166
 167         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_prv,
 168                                                                    INPUT_DATA, 0,
 169                                                                    &encrypted, &encrypted_len);
 170         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 171
 172         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_prv,
 173                                                                    INPUT_DATA, input_len + 1,
 174                                                                    &encrypted, &encrypted_len);
 175         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 176
 177         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_prv,
 178                                                                    INPUT_DATA, input_len - 1,
 179                                                                    &encrypted, &encrypted_len);
 180         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 181
 182         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_prv,
 183                                                                    INPUT_DATA, input_len - 8,
 184                                                                    &encrypted, &encrypted_len);
 185         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 186
 187         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_prv,
 188                                                                    INPUT_DATA, input_len,
 189                                                                    NULL, &encrypted_len);
 190         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 191
 192         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_prv,
 193                                                                    INPUT_DATA, input_len,
 194                                                                    &encrypted, NULL);
 195         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 196
 197         ret = yaca_rsa_private_encrypt(YACA_PADDING_PKCS1, key_prv,
 198                                                                    INPUT_DATA, input_len_pkcs1 + 1,
 199                                                                    &encrypted_pkcs1, &encrypted_pkcs1_len);
 200         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 201
 202         ret = yaca_rsa_private_encrypt(YACA_PADDING_NONE, key_prv,
 203                                                                    INPUT_DATA, input_len,
 204                                                                    &encrypted, &encrypted_len);
 205         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 206         ret = yaca_rsa_private_encrypt(YACA_PADDING_PKCS1, key_prv,
 207                                                                    INPUT_DATA, input_len_pkcs1,
 208                                                                    &encrypted_pkcs1, &encrypted_pkcs1_len);
 209         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 210
 211         ret = yaca_rsa_public_decrypt(YACA_INVALID_PADDING, key_pub,
 212                                                                   encrypted, encrypted_len,
 213                                                                   &decrypted, &decrypted_len);
 214         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 215
 216         ret = yaca_rsa_public_decrypt(YACA_PADDING_PKCS1_SSLV23, key_pub,
 217                                                                   encrypted, encrypted_len,
 218                                                                   &decrypted, &decrypted_len);
 219         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 220
 221         ret = yaca_rsa_public_decrypt(YACA_PADDING_PKCS1, key_pub,
 222                                                                   encrypted, encrypted_len,
 223                                                                   &decrypted, &decrypted_len);
 224         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 225
 226         ret = yaca_rsa_public_decrypt(YACA_PADDING_NONE, YACA_KEY_NULL,
 227                                                                   encrypted, encrypted_len,
 228                                                                   &decrypted, &decrypted_len);
 229         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 230
 231         ret = yaca_rsa_public_decrypt(YACA_PADDING_NONE, key_prv,
 232                                                                   encrypted, encrypted_len,
 233                                                                   &decrypted, &decrypted_len);
 234         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 235
 236         ret = yaca_rsa_public_decrypt(YACA_PADDING_NONE, key_ec,
 237                                                                   encrypted, encrypted_len,
 238                                                                   &decrypted, &decrypted_len);
 239         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 240
 241         ret = yaca_rsa_public_decrypt(YACA_PADDING_NONE, key_dsa,
 242                                                                   encrypted, encrypted_len,
 243                                                                   &decrypted, &decrypted_len);
 244         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 245
 246         ret = yaca_rsa_public_decrypt(YACA_PADDING_NONE, key_pub,
 247                                                                   NULL, encrypted_len,
 248                                                                   &decrypted, &decrypted_len);
 249         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 250
 251         ret = yaca_rsa_public_decrypt(YACA_PADDING_NONE, key_pub,
 252                                                                   encrypted, 0,
 253                                                                   &decrypted, &decrypted_len);
 254         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 255
 256         ret = yaca_rsa_public_decrypt(YACA_PADDING_NONE, key_pub,
 257                                                                   encrypted, encrypted_len,
 258                                                                   NULL, &decrypted_len);
 259         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 260
 261         ret = yaca_rsa_public_decrypt(YACA_PADDING_NONE, key_pub,
 262                                                                   encrypted, encrypted_len,
 263                                                                   &decrypted, NULL);
 264         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 265
 266         ret = yaca_rsa_public_decrypt(YACA_PADDING_PKCS1_PSS, key_pub,
 267                                                                   encrypted_pkcs1, encrypted_pkcs1_len,
 268                                                                   &decrypted, &decrypted_len);
 269         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 270
 271         ret = yaca_rsa_public_decrypt(YACA_PADDING_X931, key_pub,
 272                                                                   encrypted_pkcs1, encrypted_pkcs1_len,
 273                                                                   &decrypted, &decrypted_len);
 274         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 275
 276         ret = yaca_rsa_public_decrypt(YACA_PADDING_PKCS1, key_pub2,
 277                                                                   encrypted_pkcs1, encrypted_pkcs1_len,
 278                                                                   &decrypted, &decrypted_len);
 279         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 280
 281         ret = yaca_rsa_public_decrypt(YACA_PADDING_PKCS1, key_pub,
 282                                                                   encrypted_pkcs1, encrypted_pkcs1_len - 1,
 283                                                                   &decrypted, &decrypted_len);
 284         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 285
 286         ret = yaca_rsa_public_decrypt(YACA_PADDING_PKCS1, key_pub,
 287                                                                   encrypted_pkcs1 + 1, encrypted_pkcs1_len - 1,
 288                                                                   &decrypted, &decrypted_len);
 289         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 290
 291         yaca_key_destroy(key_prv);
 292         yaca_key_destroy(key_pub);
 293         yaca_key_destroy(key_prv2);
 294         yaca_key_destroy(key_pub2);
 295         yaca_key_destroy(key_dsa);
 296         yaca_key_destroy(key_ec);
 297         yaca_free(encrypted);
 298         yaca_free(encrypted_pkcs1);
 299 }
 300
 301 BOOST_FIXTURE_TEST_CASE(T403__positive__public_encrypt, InitDebugFixture)
 302 {
 303         struct rsa_args {
 304                 yaca_padding_e pad;
 305                 yaca_key_bit_length_e bit_len;
 306                 size_t shorter;
 307         };
 308
 309         const std::vector<struct rsa_args> rargs = {
 310                 {YACA_PADDING_NONE,         YACA_KEY_LENGTH_512BIT,   0},
 311                 {YACA_PADDING_PKCS1,        YACA_KEY_LENGTH_1024BIT, 11},
 312                 {YACA_PADDING_PKCS1_OAEP,   YACA_KEY_LENGTH_2048BIT, 42},
 313         };
 314
 315         for (const auto &ra: rargs) {
 316                 int ret;
 317                 yaca_key_h rsa_prv = YACA_KEY_NULL, rsa_pub = YACA_KEY_NULL;
 318                 size_t input_len = ra.bit_len / 8 - ra.shorter;
 319                 char *encrypted = NULL, *decrypted = NULL;
 320                 size_t encrypted_len, decrypted_len;
 321
 322                 generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, ra.bit_len, &rsa_prv, &rsa_pub);
 323
 324                 ret = yaca_rsa_public_encrypt(ra.pad, rsa_pub, INPUT_DATA, input_len,
 325                                                                           &encrypted, &encrypted_len);
 326                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 327
 328                 ret = yaca_rsa_private_decrypt(ra.pad, rsa_prv, encrypted, encrypted_len,
 329                                                                            &decrypted, &decrypted_len);
 330                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 331
 332                 BOOST_REQUIRE(decrypted_len == input_len);
 333                 ret = yaca_memcmp(decrypted, INPUT_DATA, input_len);
 334                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 335
 336                 yaca_key_destroy(rsa_prv);
 337                 yaca_key_destroy(rsa_pub);
 338                 yaca_free(encrypted);
 339                 yaca_free(decrypted);
 340         }
 341
 342         /* Empty input, must use padding */
 343         for (const auto &ra: rargs) {
 344                 if (ra.pad == YACA_PADDING_NONE)
 345                         continue;
 346
 347                 int ret;
 348                 yaca_key_h rsa_prv = YACA_KEY_NULL, rsa_pub = YACA_KEY_NULL;
 349                 char *encrypted = NULL, *decrypted = NULL;
 350                 size_t encrypted_len, decrypted_len;
 351
 352                 generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, ra.bit_len, &rsa_prv, &rsa_pub);
 353
 354                 ret = yaca_rsa_public_encrypt(ra.pad, rsa_pub, NULL, 0,
 355                                                                           &encrypted, &encrypted_len);
 356                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 357
 358                 ret = yaca_rsa_private_decrypt(ra.pad, rsa_prv, encrypted, encrypted_len,
 359                                                                            &decrypted, &decrypted_len);
 360                 BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 361
 362                 BOOST_REQUIRE(decrypted_len == 0);
 363                 BOOST_REQUIRE(decrypted == NULL);
 364
 365                 yaca_key_destroy(rsa_prv);
 366                 yaca_key_destroy(rsa_pub);
 367                 yaca_free(encrypted);
 368                 yaca_free(decrypted);
 369         }
 370 }
 371
 372 BOOST_FIXTURE_TEST_CASE(T404__negative__public_encrypt, InitDebugFixture)
 373 {
 374         int ret;
 375         size_t bit_len = YACA_KEY_LENGTH_1024BIT;
 376         yaca_key_h key_prv = YACA_KEY_NULL, key_pub = YACA_KEY_NULL;
 377         yaca_key_h key_prv2 = YACA_KEY_NULL, key_pub2 = YACA_KEY_NULL;
 378         yaca_key_h key_dsa = YACA_KEY_NULL, key_ec = YACA_KEY_NULL;
 379         size_t input_len = bit_len / 8;
 380         size_t input_len_pkcs1 = bit_len / 8 - 11;
 381         size_t input_len_pkcs1_oaep = bit_len / 8 - 42;
 382         size_t input_len_pkcs1_sslv23 = bit_len / 8 - 11;
 383         char *encrypted = NULL, *encrypted_pkcs1 = NULL;
 384         char *encrypted_pkcs1_oaep = NULL, *encrypted_pkcs1_sslv23 = NULL;
 385         char *decrypted = NULL;
 386         size_t encrypted_len, encrypted_pkcs1_len, encrypted_pkcs1_oaep_len;
 387         size_t encrypted_pkcs1_sslv23_len, decrypted_len;
 388
 389         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, bit_len, &key_prv, &key_pub);
 390         generate_asymmetric_keys(YACA_KEY_TYPE_RSA_PRIV, bit_len, &key_prv2, &key_pub2);
 391         generate_asymmetric_keys(YACA_KEY_TYPE_DSA_PRIV, bit_len, &key_dsa);
 392         generate_asymmetric_keys(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &key_ec);
 393
 394         ret = yaca_rsa_public_encrypt(YACA_INVALID_PADDING, key_pub,
 395                                                                   INPUT_DATA, input_len,
 396                                                                   &encrypted, &encrypted_len);
 397         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 398
 399         ret = yaca_rsa_public_encrypt(YACA_PADDING_X931, key_pub,
 400                                                                   INPUT_DATA, input_len,
 401                                                                   &encrypted, &encrypted_len);
 402         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 403
 404         ret = yaca_rsa_public_encrypt(YACA_PADDING_PKCS1_PSS, key_pub,
 405                                                                   INPUT_DATA, input_len,
 406                                                                   &encrypted, &encrypted_len);
 407         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 408
 409         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, YACA_KEY_NULL,
 410                                                                   INPUT_DATA, input_len,
 411                                                                   &encrypted, &encrypted_len);
 412         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 413
 414         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_prv,
 415                                                                   INPUT_DATA, input_len,
 416                                                                   &encrypted, &encrypted_len);
 417         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 418
 419         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_ec,
 420                                                                   INPUT_DATA, input_len,
 421                                                                   &encrypted, &encrypted_len);
 422         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 423
 424         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_dsa,
 425                                                                   INPUT_DATA, input_len,
 426                                                                   &encrypted, &encrypted_len);
 427         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 428
 429         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_pub,
 430                                                                   NULL, input_len,
 431                                                                   &encrypted, &encrypted_len);
 432         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 433
 434         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_pub,
 435                                                                   INPUT_DATA, 0,
 436                                                                   &encrypted, &encrypted_len);
 437         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 438
 439         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_pub,
 440                                                                   INPUT_DATA, input_len + 1,
 441                                                                   &encrypted, &encrypted_len);
 442         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 443
 444         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_pub,
 445                                                                   INPUT_DATA, input_len - 1,
 446                                                                   &encrypted, &encrypted_len);
 447         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 448
 449         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_pub,
 450                                                                   INPUT_DATA, input_len - 8,
 451                                                                   &encrypted, &encrypted_len);
 452         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 453
 454         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_pub,
 455                                                                   INPUT_DATA, input_len,
 456                                                                   NULL, &encrypted_len);
 457         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 458
 459         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_pub,
 460                                                                   INPUT_DATA, input_len,
 461                                                                   &encrypted, NULL);
 462         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 463
 464         ret = yaca_rsa_public_encrypt(YACA_PADDING_PKCS1, key_pub,
 465                                                                   INPUT_DATA, input_len_pkcs1 + 1,
 466                                                                   &encrypted_pkcs1, &encrypted_pkcs1_len);
 467         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 468
 469         ret = yaca_rsa_public_encrypt(YACA_PADDING_PKCS1_OAEP, key_pub,
 470                                                                   INPUT_DATA, input_len_pkcs1_oaep + 1,
 471                                                                   &encrypted_pkcs1_oaep, &encrypted_pkcs1_oaep_len);
 472         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 473
 474         ret = yaca_rsa_public_encrypt(YACA_PADDING_PKCS1_SSLV23, key_pub,
 475                                                                   INPUT_DATA, input_len_pkcs1_sslv23 + 1,
 476                                                                   &encrypted_pkcs1_sslv23, &encrypted_pkcs1_sslv23_len);
 477         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 478
 479         ret = yaca_rsa_public_encrypt(YACA_PADDING_NONE, key_pub,
 480                                                                   INPUT_DATA, input_len,
 481                                                                   &encrypted, &encrypted_len);
 482         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 483         ret = yaca_rsa_public_encrypt(YACA_PADDING_PKCS1, key_pub,
 484                                                                   INPUT_DATA, input_len_pkcs1,
 485                                                                   &encrypted_pkcs1, &encrypted_pkcs1_len);
 486         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 487         ret = yaca_rsa_public_encrypt(YACA_PADDING_PKCS1_OAEP, key_pub,
 488                                                                   INPUT_DATA, input_len_pkcs1_oaep,
 489                                                                   &encrypted_pkcs1_oaep, &encrypted_pkcs1_oaep_len);
 490         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 491         ret = yaca_rsa_public_encrypt(YACA_PADDING_PKCS1_SSLV23, key_pub,
 492                                                                   INPUT_DATA, input_len_pkcs1_sslv23,
 493                                                                   &encrypted_pkcs1_sslv23, &encrypted_pkcs1_sslv23_len);
 494         BOOST_REQUIRE(ret == YACA_ERROR_NONE);
 495
 496         ret = yaca_rsa_private_decrypt(YACA_INVALID_PADDING, key_prv,
 497                                                                    encrypted, encrypted_len,
 498                                                                    &decrypted, &decrypted_len);
 499         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 500
 501         ret = yaca_rsa_private_decrypt(YACA_PADDING_X931, key_prv,
 502                                                                    encrypted, encrypted_len,
 503                                                                    &decrypted, &decrypted_len);
 504         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 505
 506         ret = yaca_rsa_private_decrypt(YACA_PADDING_PKCS1, key_prv,
 507                                                                    encrypted, encrypted_len,
 508                                                                    &decrypted, &decrypted_len);
 509         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 510
 511         ret = yaca_rsa_private_decrypt(YACA_PADDING_NONE, YACA_KEY_NULL,
 512                                                                    encrypted, encrypted_len,
 513                                                                    &decrypted, &decrypted_len);
 514         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 515
 516         ret = yaca_rsa_private_decrypt(YACA_PADDING_NONE, key_pub,
 517                                                                    encrypted, encrypted_len,
 518                                                                    &decrypted, &decrypted_len);
 519         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 520
 521         ret = yaca_rsa_private_decrypt(YACA_PADDING_NONE, key_ec,
 522                                                                    encrypted, encrypted_len,
 523                                                                    &decrypted, &decrypted_len);
 524         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 525
 526         ret = yaca_rsa_private_decrypt(YACA_PADDING_NONE, key_dsa,
 527                                                                    encrypted, encrypted_len,
 528                                                                    &decrypted, &decrypted_len);
 529         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 530
 531         ret = yaca_rsa_private_decrypt(YACA_PADDING_NONE, key_prv,
 532                                                                    NULL, encrypted_len,
 533                                                                    &decrypted, &decrypted_len);
 534         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 535
 536         ret = yaca_rsa_private_decrypt(YACA_PADDING_NONE, key_prv,
 537                                                                    encrypted, 0,
 538                                                                    &decrypted, &decrypted_len);
 539         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 540
 541         ret = yaca_rsa_private_decrypt(YACA_PADDING_NONE, key_prv,
 542                                                                    encrypted, encrypted_len,
 543                                                                    NULL, &decrypted_len);
 544         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 545
 546         ret = yaca_rsa_private_decrypt(YACA_PADDING_NONE, key_prv,
 547                                                                    encrypted, encrypted_len,
 548                                                                    &decrypted, NULL);
 549         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 550
 551         ret = yaca_rsa_private_decrypt(YACA_PADDING_PKCS1_PSS, key_prv,
 552                                                                    encrypted_pkcs1, encrypted_pkcs1_len,
 553                                                                    &decrypted, &decrypted_len);
 554         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 555
 556         ret = yaca_rsa_private_decrypt(YACA_PADDING_PKCS1, key_prv,
 557                                                                    encrypted_pkcs1, encrypted_pkcs1_len - 1,
 558                                                                    &decrypted, &decrypted_len);
 559         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 560
 561         ret = yaca_rsa_private_decrypt(YACA_PADDING_PKCS1, key_prv,
 562                                                                    encrypted_pkcs1_oaep, encrypted_pkcs1_oaep_len,
 563                                                                    &decrypted, &decrypted_len);
 564         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 565
 566         ret = yaca_rsa_private_decrypt(YACA_PADDING_PKCS1_SSLV23, key_prv,
 567                                                                    encrypted_pkcs1_oaep, encrypted_pkcs1_oaep_len,
 568                                                                    &decrypted, &decrypted_len);
 569         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 570
 571         ret = yaca_rsa_private_decrypt(YACA_PADDING_PKCS1_OAEP, key_prv,
 572                                                                    encrypted_pkcs1_oaep, encrypted_pkcs1_oaep_len - 1,
 573                                                                    &decrypted, &decrypted_len);
 574         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 575
 576         ret = yaca_rsa_private_decrypt(YACA_PADDING_PKCS1_OAEP, key_prv,
 577                                                                    encrypted_pkcs1_sslv23, encrypted_pkcs1_sslv23_len,
 578                                                                    &decrypted, &decrypted_len);
 579         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 580
 581         ret = yaca_rsa_private_decrypt(YACA_PADDING_PKCS1_SSLV23, key_prv,
 582                                                                    encrypted_pkcs1_sslv23, encrypted_pkcs1_sslv23_len - 1,
 583                                                                    &decrypted, &decrypted_len);
 584         BOOST_REQUIRE(ret == YACA_ERROR_INVALID_PARAMETER);
 585
 586         yaca_key_destroy(key_prv);
 587         yaca_key_destroy(key_pub);
 588         yaca_key_destroy(key_prv2);
 589         yaca_key_destroy(key_pub2);
 590         yaca_key_destroy(key_dsa);
 591         yaca_key_destroy(key_ec);
 592         yaca_free(encrypted);
 593         yaca_free(encrypted_pkcs1);
 594         yaca_free(encrypted_pkcs1_oaep);
 595         yaca_free(encrypted_pkcs1_sslv23);
 596 }
 597
 598 BOOST_AUTO_TEST_SUITE_END()