engines/e_ossltest.c

   1 /*
   2  * Written by Matt Caswell (matt@openssl.org) for the OpenSSL project.
   3  */
   4 /* ====================================================================
   5  * Copyright (c) 2015 The OpenSSL Project.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  *
  19  * 3. All advertising materials mentioning features or use of this
  20  *    software must display the following acknowledgment:
  21  *    "This product includes software developed by the OpenSSL Project
  22  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  23  *
  24  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  25  *    endorse or promote products derived from this software without
  26  *    prior written permission. For written permission, please contact
  27  *    licensing@OpenSSL.org.
  28  *
  29  * 5. Products derived from this software may not be called "OpenSSL"
  30  *    nor may "OpenSSL" appear in their names without prior written
  31  *    permission of the OpenSSL Project.
  32  *
  33  * 6. Redistributions of any form whatsoever must retain the following
  34  *    acknowledgment:
  35  *    "This product includes software developed by the OpenSSL Project
  36  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  37  *
  38  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  39  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  41  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  42  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  43  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  44  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  45  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  47  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  48  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  49  * OF THE POSSIBILITY OF SUCH DAMAGE.
  50  * ====================================================================
  51  */
  52
  53 /*
  54  * This is the OSSLTEST engine. It provides deliberately crippled digest
  55  * implementations for test purposes. It is highly insecure and must NOT be
  56  * used for any purpose except testing
  57  */
  58
  59 #include <stdio.h>
  60 #include <string.h>
  61
  62 #include <openssl/engine.h>
  63 #include <openssl/sha.h>
  64 #include <openssl/md5.h>
  65 #include <openssl/rsa.h>
  66 #include <openssl/evp.h>
  67 #include <openssl/modes.h>
  68 #include <openssl/aes.h>
  69 #include <openssl/crypto.h>
  70
  71 #define OSSLTEST_LIB_NAME "OSSLTEST"
  72 #include "e_ossltest_err.c"
  73
  74 /* Engine Id and Name */
  75 static const char *engine_ossltest_id = "ossltest";
  76 static const char *engine_ossltest_name = "OpenSSL Test engine support";
  77
  78
  79 /* Engine Lifetime functions */
  80 static int ossltest_destroy(ENGINE *e);
  81 static int ossltest_init(ENGINE *e);
  82 static int ossltest_finish(ENGINE *e);
  83 void ENGINE_load_ossltest(void);
  84
  85
  86 /* Set up digests */
  87 static int ossltest_digests(ENGINE *e, const EVP_MD **digest,
  88                           const int **nids, int nid);
  89
  90 /* MD5 */
  91 static int digest_md5_init(EVP_MD_CTX *ctx);
  92 static int digest_md5_update(EVP_MD_CTX *ctx, const void *data,
  93                              size_t count);
  94 static int digest_md5_final(EVP_MD_CTX *ctx, unsigned char *md);
  95
  96 static EVP_MD *_hidden_md5_md = NULL;
  97 static const EVP_MD *digest_md5(void)
  98 {
  99     if (_hidden_md5_md == NULL) {
 100         EVP_MD *md;
 101
 102         if ((md = EVP_MD_meth_new(NID_md5, NID_md5WithRSAEncryption)) == NULL
 103             || !EVP_MD_meth_set_result_size(md, MD5_DIGEST_LENGTH)
 104             || !EVP_MD_meth_set_input_blocksize(md, MD5_CBLOCK)
 105             || !EVP_MD_meth_set_app_datasize(md,
 106                                              sizeof(EVP_MD *) + sizeof(MD5_CTX))
 107             || !EVP_MD_meth_set_flags(md, 0)
 108             || !EVP_MD_meth_set_init(md, digest_md5_init)
 109             || !EVP_MD_meth_set_update(md, digest_md5_update)
 110             || !EVP_MD_meth_set_final(md, digest_md5_final)) {
 111             EVP_MD_meth_free(md);
 112             md = NULL;
 113         }
 114         _hidden_md5_md = md;
 115     }
 116     return _hidden_md5_md;
 117 }
 118
 119 /* SHA1 */
 120 static int digest_sha1_init(EVP_MD_CTX *ctx);
 121 static int digest_sha1_update(EVP_MD_CTX *ctx, const void *data,
 122                               size_t count);
 123 static int digest_sha1_final(EVP_MD_CTX *ctx, unsigned char *md);
 124
 125 static EVP_MD *_hidden_sha1_md = NULL;
 126 static const EVP_MD *digest_sha1(void)
 127 {
 128     if (_hidden_sha1_md == NULL) {
 129         EVP_MD *md;
 130
 131         if ((md = EVP_MD_meth_new(NID_sha1, NID_sha1WithRSAEncryption)) == NULL
 132             || !EVP_MD_meth_set_result_size(md, SHA_DIGEST_LENGTH)
 133             || !EVP_MD_meth_set_input_blocksize(md, SHA_CBLOCK)
 134             || !EVP_MD_meth_set_app_datasize(md,
 135                                              sizeof(EVP_MD *) + sizeof(SHA_CTX))
 136             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_DIGALGID_ABSENT)
 137             || !EVP_MD_meth_set_init(md, digest_sha1_init)
 138             || !EVP_MD_meth_set_update(md, digest_sha1_update)
 139             || !EVP_MD_meth_set_final(md, digest_sha1_final)) {
 140             EVP_MD_meth_free(md);
 141             md = NULL;
 142         }
 143         _hidden_sha1_md = md;
 144     }
 145     return _hidden_sha1_md;
 146 }
 147
 148 /* SHA256 */
 149 static int digest_sha256_init(EVP_MD_CTX *ctx);
 150 static int digest_sha256_update(EVP_MD_CTX *ctx, const void *data,
 151                                 size_t count);
 152 static int digest_sha256_final(EVP_MD_CTX *ctx, unsigned char *md);
 153
 154 static EVP_MD *_hidden_sha256_md = NULL;
 155 static const EVP_MD *digest_sha256(void)
 156 {
 157     if (_hidden_sha256_md == NULL) {
 158         EVP_MD *md;
 159
 160         if ((md = EVP_MD_meth_new(NID_sha256, NID_sha256WithRSAEncryption)) == NULL
 161             || !EVP_MD_meth_set_result_size(md, SHA256_DIGEST_LENGTH)
 162             || !EVP_MD_meth_set_input_blocksize(md, SHA256_CBLOCK)
 163             || !EVP_MD_meth_set_app_datasize(md,
 164                                              sizeof(EVP_MD *) + sizeof(SHA256_CTX))
 165             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_DIGALGID_ABSENT)
 166             || !EVP_MD_meth_set_init(md, digest_sha256_init)
 167             || !EVP_MD_meth_set_update(md, digest_sha256_update)
 168             || !EVP_MD_meth_set_final(md, digest_sha256_final)) {
 169             EVP_MD_meth_free(md);
 170             md = NULL;
 171         }
 172         _hidden_sha256_md = md;
 173     }
 174     return _hidden_sha256_md;
 175 }
 176
 177 /* SHA384/SHA512 */
 178 static int digest_sha384_init(EVP_MD_CTX *ctx);
 179 static int digest_sha512_init(EVP_MD_CTX *ctx);
 180 static int digest_sha512_update(EVP_MD_CTX *ctx, const void *data,
 181                                 size_t count);
 182 static int digest_sha384_final(EVP_MD_CTX *ctx, unsigned char *md);
 183 static int digest_sha512_final(EVP_MD_CTX *ctx, unsigned char *md);
 184
 185 static EVP_MD *_hidden_sha384_md = NULL;
 186 static const EVP_MD *digest_sha384(void)
 187 {
 188     if (_hidden_sha384_md == NULL) {
 189         EVP_MD *md;
 190
 191         if ((md = EVP_MD_meth_new(NID_sha384, NID_sha384WithRSAEncryption)) == NULL
 192             || !EVP_MD_meth_set_result_size(md, SHA384_DIGEST_LENGTH)
 193             || !EVP_MD_meth_set_input_blocksize(md, SHA512_CBLOCK)
 194             || !EVP_MD_meth_set_app_datasize(md,
 195                                              sizeof(EVP_MD *) + sizeof(SHA512_CTX))
 196             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_DIGALGID_ABSENT)
 197             || !EVP_MD_meth_set_init(md, digest_sha384_init)
 198             || !EVP_MD_meth_set_update(md, digest_sha512_update)
 199             || !EVP_MD_meth_set_final(md, digest_sha384_final)) {
 200             EVP_MD_meth_free(md);
 201             md = NULL;
 202         }
 203         _hidden_sha384_md = md;
 204     }
 205     return _hidden_sha384_md;
 206 }
 207 static EVP_MD *_hidden_sha512_md = NULL;
 208 static const EVP_MD *digest_sha512(void)
 209 {
 210     if (_hidden_sha512_md == NULL) {
 211         EVP_MD *md;
 212
 213         if ((md = EVP_MD_meth_new(NID_sha512, NID_sha512WithRSAEncryption)) == NULL
 214             || !EVP_MD_meth_set_result_size(md, SHA512_DIGEST_LENGTH)
 215             || !EVP_MD_meth_set_input_blocksize(md, SHA512_CBLOCK)
 216             || !EVP_MD_meth_set_app_datasize(md,
 217                                              sizeof(EVP_MD *) + sizeof(SHA512_CTX))
 218             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_DIGALGID_ABSENT)
 219             || !EVP_MD_meth_set_init(md, digest_sha512_init)
 220             || !EVP_MD_meth_set_update(md, digest_sha512_update)
 221             || !EVP_MD_meth_set_final(md, digest_sha512_final)) {
 222             EVP_MD_meth_free(md);
 223             md = NULL;
 224         }
 225         _hidden_sha512_md = md;
 226     }
 227     return _hidden_sha512_md;
 228 }
 229 static void destroy_digests(void)
 230 {
 231     EVP_MD_meth_free(_hidden_md5_md);
 232     _hidden_md5_md = NULL;
 233     EVP_MD_meth_free(_hidden_sha1_md);
 234     _hidden_sha1_md = NULL;
 235     EVP_MD_meth_free(_hidden_sha256_md);
 236     _hidden_sha256_md = NULL;
 237     EVP_MD_meth_free(_hidden_sha384_md);
 238     _hidden_sha384_md = NULL;
 239     EVP_MD_meth_free(_hidden_sha512_md);
 240     _hidden_sha512_md = NULL;
 241 }
 242 static int ossltest_digest_nids(const int **nids)
 243 {
 244     static int digest_nids[6] = { 0, 0, 0, 0, 0, 0 };
 245     static int pos = 0;
 246     static int init = 0;
 247
 248     if (!init) {
 249         const EVP_MD *md;
 250         if ((md = digest_md5()) != NULL)
 251             digest_nids[pos++] = EVP_MD_type(md);
 252         if ((md = digest_sha1()) != NULL)
 253             digest_nids[pos++] = EVP_MD_type(md);
 254         if ((md = digest_sha256()) != NULL)
 255             digest_nids[pos++] = EVP_MD_type(md);
 256         if ((md = digest_sha384()) != NULL)
 257             digest_nids[pos++] = EVP_MD_type(md);
 258         if ((md = digest_sha512()) != NULL)
 259             digest_nids[pos++] = EVP_MD_type(md);
 260         digest_nids[pos] = 0;
 261         init = 1;
 262     }
 263     *nids = digest_nids;
 264     return pos;
 265 }
 266
 267 /* Setup ciphers */
 268 static int ossltest_ciphers(ENGINE *, const EVP_CIPHER **,
 269                             const int **, int);
 270
 271 static int ossltest_cipher_nids[] = {
 272     NID_aes_128_cbc, 0
 273 };
 274
 275 /* AES128 */
 276
 277 int ossltest_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 278                              const unsigned char *iv, int enc);
 279 int ossltest_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 280                                const unsigned char *in, size_t inl);
 281
 282 static EVP_CIPHER *_hidden_aes_128_cbc = NULL;
 283 static const EVP_CIPHER *ossltest_aes_128_cbc(void)
 284 {
 285     if (_hidden_aes_128_cbc == NULL
 286         && ((_hidden_aes_128_cbc = EVP_CIPHER_meth_new(NID_aes_128_cbc,
 287                                                        16 /* block size */,
 288                                                        16 /* key len */)) == NULL
 289             || !EVP_CIPHER_meth_set_iv_length(_hidden_aes_128_cbc,16)
 290             || !EVP_CIPHER_meth_set_flags(_hidden_aes_128_cbc,
 291                                           EVP_CIPH_FLAG_DEFAULT_ASN1
 292                                           | EVP_CIPH_CBC_MODE)
 293             || !EVP_CIPHER_meth_set_init(_hidden_aes_128_cbc,
 294                                          ossltest_aes128_init_key)
 295             || !EVP_CIPHER_meth_set_do_cipher(_hidden_aes_128_cbc,
 296                                               ossltest_aes128_cbc_cipher)
 297             || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_aes_128_cbc,
 298                                                   EVP_CIPHER_impl_ctx_size(EVP_aes_128_cbc())))) {
 299         EVP_CIPHER_meth_free(_hidden_aes_128_cbc);
 300         _hidden_aes_128_cbc = NULL;
 301     }
 302     return _hidden_aes_128_cbc;
 303 }
 304 static void destroy_ciphers(void)
 305 {
 306     EVP_CIPHER_meth_free(_hidden_aes_128_cbc);
 307     _hidden_aes_128_cbc = NULL;
 308 }
 309
 310 static int bind_ossltest(ENGINE *e)
 311 {
 312     /* Ensure the ossltest error handling is set up */
 313     ERR_load_OSSLTEST_strings();
 314
 315     if (!ENGINE_set_id(e, engine_ossltest_id)
 316         || !ENGINE_set_name(e, engine_ossltest_name)
 317         || !ENGINE_set_digests(e, ossltest_digests)
 318         || !ENGINE_set_ciphers(e, ossltest_ciphers)
 319         || !ENGINE_set_destroy_function(e, ossltest_destroy)
 320         || !ENGINE_set_init_function(e, ossltest_init)
 321         || !ENGINE_set_finish_function(e, ossltest_finish)) {
 322         OSSLTESTerr(OSSLTEST_F_BIND_OSSLTEST, OSSLTEST_R_INIT_FAILED);
 323         return 0;
 324     }
 325
 326     return 1;
 327 }
 328
 329 #ifndef OPENSSL_NO_DYNAMIC_ENGINE
 330 static int bind_helper(ENGINE *e, const char *id)
 331 {
 332     if (id && (strcmp(id, engine_ossltest_id) != 0))
 333         return 0;
 334     if (!bind_ossltest(e))
 335         return 0;
 336     return 1;
 337 }
 338
 339 IMPLEMENT_DYNAMIC_CHECK_FN()
 340     IMPLEMENT_DYNAMIC_BIND_FN(bind_helper)
 341 #endif
 342
 343 static ENGINE *engine_ossltest(void)
 344 {
 345     ENGINE *ret = ENGINE_new();
 346     if (ret == NULL)
 347         return NULL;
 348     if (!bind_ossltest(ret)) {
 349         ENGINE_free(ret);
 350         return NULL;
 351     }
 352     return ret;
 353 }
 354
 355 void ENGINE_load_ossltest(void)
 356 {
 357     /* Copied from eng_[openssl|dyn].c */
 358     ENGINE *toadd = engine_ossltest();
 359     if (!toadd)
 360         return;
 361     ENGINE_add(toadd);
 362     ENGINE_free(toadd);
 363     ERR_clear_error();
 364 }
 365
 366
 367 static int ossltest_init(ENGINE *e)
 368 {
 369     return 1;
 370 }
 371
 372
 373 static int ossltest_finish(ENGINE *e)
 374 {
 375     return 1;
 376 }
 377
 378
 379 static int ossltest_destroy(ENGINE *e)
 380 {
 381     destroy_digests();
 382     destroy_ciphers();
 383     ERR_unload_OSSLTEST_strings();
 384     return 1;
 385 }
 386
 387 static int ossltest_digests(ENGINE *e, const EVP_MD **digest,
 388                           const int **nids, int nid)
 389 {
 390     int ok = 1;
 391     if (!digest) {
 392         /* We are returning a list of supported nids */
 393         return ossltest_digest_nids(nids);
 394     }
 395     /* We are being asked for a specific digest */
 396     switch (nid) {
 397     case NID_md5:
 398         *digest = digest_md5();
 399         break;
 400     case NID_sha1:
 401         *digest = digest_sha1();
 402         break;
 403     case NID_sha256:
 404         *digest = digest_sha256();
 405         break;
 406     case NID_sha384:
 407         *digest = digest_sha384();
 408         break;
 409     case NID_sha512:
 410         *digest = digest_sha512();
 411         break;
 412     default:
 413         ok = 0;
 414         *digest = NULL;
 415         break;
 416     }
 417     return ok;
 418 }
 419
 420 static int ossltest_ciphers(ENGINE *e, const EVP_CIPHER **cipher,
 421                           const int **nids, int nid)
 422 {
 423     int ok = 1;
 424     if (!cipher) {
 425         /* We are returning a list of supported nids */
 426         *nids = ossltest_cipher_nids;
 427         return (sizeof(ossltest_cipher_nids) - 1)
 428                / sizeof(ossltest_cipher_nids[0]);
 429     }
 430     /* We are being asked for a specific cipher */
 431     switch (nid) {
 432     case NID_aes_128_cbc:
 433         *cipher = ossltest_aes_128_cbc();
 434         break;
 435     default:
 436         ok = 0;
 437         *cipher = NULL;
 438         break;
 439     }
 440     return ok;
 441 }
 442
 443 static void fill_known_data(unsigned char *md, unsigned int len)
 444 {
 445     unsigned int i;
 446
 447     for (i=0; i<len; i++) {
 448         md[i] = (unsigned char)(i & 0xff);
 449     }
 450 }
 451
 452 /*
 453  * MD5 implementation. We go through the motions of doing MD5 by deferring to
 454  * the standard implementation. Then we overwrite the result with a will defined
 455  * value, so that all "MD5" digests using the test engine always end up with
 456  * the same value.
 457  */
 458 #undef data
 459 #define data(ctx) ((MD5_CTX *)EVP_MD_CTX_md_data(ctx))
 460 static int digest_md5_init(EVP_MD_CTX *ctx)
 461 {
 462     return MD5_Init(data(ctx));
 463 }
 464
 465 static int digest_md5_update(EVP_MD_CTX *ctx, const void *data,
 466                              size_t count)
 467 {
 468     return MD5_Update(data(ctx), data, (size_t)count);
 469 }
 470
 471 static int digest_md5_final(EVP_MD_CTX *ctx, unsigned char *md)
 472 {
 473     int ret;
 474     ret = MD5_Final(md, data(ctx));
 475
 476     if (ret > 0) {
 477         fill_known_data(md, MD5_DIGEST_LENGTH);
 478     }
 479     return ret;
 480 }
 481
 482 /*
 483  * SHA1 implementation.
 484  */
 485 #undef data
 486 #define data(ctx) ((SHA_CTX *)EVP_MD_CTX_md_data(ctx))
 487 static int digest_sha1_init(EVP_MD_CTX *ctx)
 488 {
 489     return SHA1_Init(data(ctx));
 490 }
 491
 492 static int digest_sha1_update(EVP_MD_CTX *ctx, const void *data,
 493                               size_t count)
 494 {
 495     return SHA1_Update(data(ctx), data, (size_t)count);
 496 }
 497
 498 static int digest_sha1_final(EVP_MD_CTX *ctx, unsigned char *md)
 499 {
 500     int ret;
 501     ret = SHA1_Final(md, data(ctx));
 502
 503     if (ret > 0) {
 504         fill_known_data(md, SHA_DIGEST_LENGTH);
 505     }
 506     return ret;
 507 }
 508
 509 /*
 510  * SHA256 implementation.
 511  */
 512 #undef data
 513 #define data(ctx) ((SHA256_CTX *)EVP_MD_CTX_md_data(ctx))
 514 static int digest_sha256_init(EVP_MD_CTX *ctx)
 515 {
 516     return SHA256_Init(data(ctx));
 517 }
 518
 519 static int digest_sha256_update(EVP_MD_CTX *ctx, const void *data,
 520                                 size_t count)
 521 {
 522     return SHA256_Update(data(ctx), data, (size_t)count);
 523 }
 524
 525 static int digest_sha256_final(EVP_MD_CTX *ctx, unsigned char *md)
 526 {
 527     int ret;
 528     ret = SHA256_Final(md, data(ctx));
 529
 530     if (ret > 0) {
 531         fill_known_data(md, SHA256_DIGEST_LENGTH);
 532     }
 533     return ret;
 534 }
 535
 536 /*
 537  * SHA384/512 implementation.
 538  */
 539 #undef data
 540 #define data(ctx) ((SHA512_CTX *)EVP_MD_CTX_md_data(ctx))
 541 static int digest_sha384_init(EVP_MD_CTX *ctx)
 542 {
 543     return SHA384_Init(data(ctx));
 544 }
 545
 546 static int digest_sha512_init(EVP_MD_CTX *ctx)
 547 {
 548     return SHA512_Init(data(ctx));
 549 }
 550
 551 static int digest_sha512_update(EVP_MD_CTX *ctx, const void *data,
 552                                 size_t count)
 553 {
 554     return SHA512_Update(data(ctx), data, (size_t)count);
 555 }
 556
 557 static int digest_sha384_final(EVP_MD_CTX *ctx, unsigned char *md)
 558 {
 559     int ret;
 560     /* Actually uses SHA512_Final! */
 561     ret = SHA512_Final(md, data(ctx));
 562
 563     if (ret > 0) {
 564         fill_known_data(md, SHA384_DIGEST_LENGTH);
 565     }
 566     return ret;
 567 }
 568
 569 static int digest_sha512_final(EVP_MD_CTX *ctx, unsigned char *md)
 570 {
 571     int ret;
 572     ret = SHA512_Final(md, data(ctx));
 573
 574     if (ret > 0) {
 575         fill_known_data(md, SHA512_DIGEST_LENGTH);
 576     }
 577     return ret;
 578 }
 579
 580 /*
 581  * AES128 Implementation
 582  */
 583
 584 int ossltest_aes128_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 585                              const unsigned char *iv, int enc)
 586 {
 587     return EVP_CIPHER_meth_get_init(EVP_aes_128_cbc()) (ctx, key, iv, enc);
 588 }
 589
 590 int ossltest_aes128_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 591                                const unsigned char *in, size_t inl)
 592 {
 593     unsigned char *tmpbuf;
 594     int ret;
 595
 596     tmpbuf = OPENSSL_malloc(inl);
 597     if (tmpbuf == NULL)
 598         return -1;
 599
 600     /* Remember what we were asked to encrypt */
 601     memcpy(tmpbuf, in, inl);
 602
 603     /* Go through the motions of encrypting it */
 604     ret = EVP_CIPHER_meth_get_do_cipher(EVP_aes_128_cbc())(ctx, out, in, inl);
 605
 606     /* Throw it all away and just use the plaintext as the output */
 607     memcpy(out, tmpbuf, inl);
 608     OPENSSL_free(tmpbuf);
 609
 610     return ret;
 611 }