engines/e_ossltest.c

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