X-Git-Url: https://git.openssl.org/gitweb/?p=openssl.git;a=blobdiff_plain;f=test%2Fenginetest.c;h=be57f1618305c4ec2b6ca9c2045aa348146c5340;hp=bbe40e64f5d5ff4717a83ae99c89740315827711;hb=97ea1e7f42eea97b117af08b3c1d29f6443850ab;hpb=7644a9aef8932ed4d1c3f25ed776c997702982be diff --git a/test/enginetest.c b/test/enginetest.c index bbe40e64f5..be57f16183 100644 --- a/test/enginetest.c +++ b/test/enginetest.c @@ -1,76 +1,24 @@ -/* crypto/engine/enginetest.c */ /* - * Written by Geoff Thorpe (geoff@geoffthorpe.net) for the OpenSSL project - * 2000. - */ -/* ==================================================================== - * Copyright (c) 1999-2001 The OpenSSL Project. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in - * the documentation and/or other materials provided with the - * distribution. - * - * 3. All advertising materials mentioning features or use of this - * software must display the following acknowledgment: - * "This product includes software developed by the OpenSSL Project - * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)" - * - * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For written permission, please contact - * licensing@OpenSSL.org. - * - * 5. Products derived from this software may not be called "OpenSSL" - * nor may "OpenSSL" appear in their names without prior written - * permission of the OpenSSL Project. - * - * 6. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by the OpenSSL Project - * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)" - * - * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY - * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR - * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. - * ==================================================================== - * - * This product includes cryptographic software written by Eric Young - * (eay@cryptsoft.com). This product includes software written by Tim - * Hudson (tjh@cryptsoft.com). + * Copyright 2000-2017 The OpenSSL Project Authors. All Rights Reserved. * + * Licensed under the OpenSSL license (the "License"). You may not use + * this file except in compliance with the License. You can obtain a copy + * in the file LICENSE in the source distribution or at + * https://www.openssl.org/source/license.html */ #include #include +#include #include -#ifdef OPENSSL_NO_ENGINE -int main(int argc, char *argv[]) -{ - printf("No ENGINE support\n"); - return (0); -} -#else +# include "testutil.h" + +#ifndef OPENSSL_NO_ENGINE # include # include # include +# include # include static void display_engine_list(void) @@ -78,15 +26,12 @@ static void display_engine_list(void) ENGINE *h; int loop; - h = ENGINE_get_first(); loop = 0; - printf("listing available engine types\n"); - while (h) { - printf("engine %i, id = \"%s\", name = \"%s\"\n", + for (h = ENGINE_get_first(); h != NULL; h = ENGINE_get_next(h)) { + TEST_info("#%d: id = \"%s\", name = \"%s\"", loop++, ENGINE_get_id(h), ENGINE_get_name(h)); - h = ENGINE_get_next(h); } - printf("end of list\n"); + /* * ENGINE_get_first() increases the struct_ref counter, so we must call * ENGINE_free() to decrease it again @@ -94,169 +39,320 @@ static void display_engine_list(void) ENGINE_free(h); } -int main(int argc, char *argv[]) +#define NUMTOADD 512 + +static int test_engines(void) { - ENGINE *block[512]; + ENGINE *block[NUMTOADD]; char buf[256]; const char *id, *name; ENGINE *ptr; int loop; - int to_return = 1; + int to_return = 0; ENGINE *new_h1 = NULL; ENGINE *new_h2 = NULL; ENGINE *new_h3 = NULL; ENGINE *new_h4 = NULL; - /* enable memory leak checking unless explicitly disabled */ - if (!((getenv("OPENSSL_DEBUG_MEMORY") != NULL) - && (0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off")))) { - CRYPTO_malloc_debug_init(); - CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL); - } else { - /* OPENSSL_DEBUG_MEMORY=off */ - CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0); - } - CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON); - ERR_load_crypto_strings(); - memset(block, 0, sizeof(block)); - if (((new_h1 = ENGINE_new()) == NULL) || - !ENGINE_set_id(new_h1, "test_id0") || - !ENGINE_set_name(new_h1, "First test item") || - ((new_h2 = ENGINE_new()) == NULL) || - !ENGINE_set_id(new_h2, "test_id1") || - !ENGINE_set_name(new_h2, "Second test item") || - ((new_h3 = ENGINE_new()) == NULL) || - !ENGINE_set_id(new_h3, "test_id2") || - !ENGINE_set_name(new_h3, "Third test item") || - ((new_h4 = ENGINE_new()) == NULL) || - !ENGINE_set_id(new_h4, "test_id3") || - !ENGINE_set_name(new_h4, "Fourth test item")) { - printf("Couldn't set up test ENGINE structures\n"); + if (!TEST_ptr(new_h1 = ENGINE_new()) + || !TEST_true(ENGINE_set_id(new_h1, "test_id0")) + || !TEST_true(ENGINE_set_name(new_h1, "First test item")) + || !TEST_ptr(new_h2 = ENGINE_new()) + || !TEST_true(ENGINE_set_id(new_h2, "test_id1")) + || !TEST_true(ENGINE_set_name(new_h2, "Second test item")) + || !TEST_ptr(new_h3 = ENGINE_new()) + || !TEST_true(ENGINE_set_id(new_h3, "test_id2")) + || !TEST_true(ENGINE_set_name(new_h3, "Third test item")) + || !TEST_ptr(new_h4 = ENGINE_new()) + || !TEST_true(ENGINE_set_id(new_h4, "test_id3")) + || !TEST_true(ENGINE_set_name(new_h4, "Fourth test item"))) goto end; - } - printf("\nenginetest beginning\n\n"); + TEST_info("Engines:"); display_engine_list(); - if (!ENGINE_add(new_h1)) { - printf("Add failed!\n"); + + if (!TEST_true(ENGINE_add(new_h1))) goto end; - } + TEST_info("Engines:"); display_engine_list(); + ptr = ENGINE_get_first(); - if (!ENGINE_remove(ptr)) { - printf("Remove failed!\n"); + if (!TEST_true(ENGINE_remove(ptr))) goto end; - } ENGINE_free(ptr); + TEST_info("Engines:"); display_engine_list(); - if (!ENGINE_add(new_h3) || !ENGINE_add(new_h2)) { - printf("Add failed!\n"); + + if (!TEST_true(ENGINE_add(new_h3)) + || !TEST_true(ENGINE_add(new_h2))) goto end; - } + TEST_info("Engines:"); display_engine_list(); - if (!ENGINE_remove(new_h2)) { - printf("Remove failed!\n"); + + if (!TEST_true(ENGINE_remove(new_h2))) goto end; - } + TEST_info("Engines:"); display_engine_list(); - if (!ENGINE_add(new_h4)) { - printf("Add failed!\n"); + + if (!TEST_true(ENGINE_add(new_h4))) goto end; - } + TEST_info("Engines:"); display_engine_list(); - if (ENGINE_add(new_h3)) { - printf("Add *should* have failed but didn't!\n"); + + /* Should fail. */ + if (!TEST_false(ENGINE_add(new_h3))) goto end; - } else - printf("Add that should fail did.\n"); ERR_clear_error(); - if (ENGINE_remove(new_h2)) { - printf("Remove *should* have failed but didn't!\n"); + + /* Should fail. */ + if (!TEST_false(ENGINE_remove(new_h2))) goto end; - } else - printf("Remove that should fail did.\n"); ERR_clear_error(); - if (!ENGINE_remove(new_h3)) { - printf("Remove failed!\n"); + + if (!TEST_true(ENGINE_remove(new_h3))) goto end; - } + TEST_info("Engines:"); display_engine_list(); - if (!ENGINE_remove(new_h4)) { - printf("Remove failed!\n"); + + if (!TEST_true(ENGINE_remove(new_h4))) goto end; - } + TEST_info("Engines:"); display_engine_list(); + /* * Depending on whether there's any hardware support compiled in, this * remove may be destined to fail. */ - ptr = ENGINE_get_first(); - if (ptr) + if ((ptr = ENGINE_get_first()) != NULL) { if (!ENGINE_remove(ptr)) - printf("Remove failed!i - probably no hardware " - "support present.\n"); + TEST_info("Remove failed - probably no hardware support present"); + } ENGINE_free(ptr); + TEST_info("Engines:"); display_engine_list(); - if (!ENGINE_add(new_h1) || !ENGINE_remove(new_h1)) { - printf("Couldn't add and remove to an empty list!\n"); + + if (!TEST_true(ENGINE_add(new_h1)) + || !TEST_true(ENGINE_remove(new_h1))) goto end; - } else - printf("Successfully added and removed to an empty list!\n"); - printf("About to beef up the engine-type list\n"); - for (loop = 0; loop < 512; loop++) { - sprintf(buf, "id%i", loop); + + TEST_info("About to beef up the engine-type list"); + for (loop = 0; loop < NUMTOADD; loop++) { + sprintf(buf, "id%d", loop); id = OPENSSL_strdup(buf); - sprintf(buf, "Fake engine type %i", loop); + sprintf(buf, "Fake engine type %d", loop); name = OPENSSL_strdup(buf); - if (((block[loop] = ENGINE_new()) == NULL) || - !ENGINE_set_id(block[loop], id) || - !ENGINE_set_name(block[loop], name)) { - printf("Couldn't create block of ENGINE structures.\n" - "I'll probably also core-dump now, damn.\n"); + if (!TEST_ptr(block[loop] = ENGINE_new()) + || !TEST_true(ENGINE_set_id(block[loop], id)) + || !TEST_true(ENGINE_set_name(block[loop], name))) goto end; - } } - for (loop = 0; loop < 512; loop++) { - if (!ENGINE_add(block[loop])) { - printf("\nAdding stopped at %i, (%s,%s)\n", - loop, ENGINE_get_id(block[loop]), - ENGINE_get_name(block[loop])); + for (loop = 0; loop < NUMTOADD; loop++) { + if (!TEST_true(ENGINE_add(block[loop]))) { + test_note("Adding stopped at %d, (%s,%s)", + loop, ENGINE_get_id(block[loop]), + ENGINE_get_name(block[loop])); goto cleanup_loop; - } else - printf("."); - fflush(stdout); + } } cleanup_loop: - printf("\nAbout to empty the engine-type list\n"); + TEST_info("About to empty the engine-type list"); while ((ptr = ENGINE_get_first()) != NULL) { - if (!ENGINE_remove(ptr)) { - printf("\nRemove failed!\n"); + if (!TEST_true(ENGINE_remove(ptr))) goto end; - } ENGINE_free(ptr); - printf("."); - fflush(stdout); } - for (loop = 0; loop < 512; loop++) { + for (loop = 0; loop < NUMTOADD; loop++) { OPENSSL_free((void *)ENGINE_get_id(block[loop])); OPENSSL_free((void *)ENGINE_get_name(block[loop])); } - printf("\nTests completed happily\n"); - to_return = 0; + to_return = 1; + end: - if (to_return) - ERR_print_errors_fp(stderr); ENGINE_free(new_h1); ENGINE_free(new_h2); ENGINE_free(new_h3); ENGINE_free(new_h4); - for (loop = 0; loop < 512; loop++) + for (loop = 0; loop < NUMTOADD; loop++) ENGINE_free(block[loop]); - ENGINE_cleanup(); - CRYPTO_cleanup_all_ex_data(); - ERR_free_strings(); - ERR_remove_thread_state(NULL); - CRYPTO_mem_leaks_fp(stderr); + return to_return; +} + +/* Test EVP_PKEY method */ +static EVP_PKEY_METHOD *test_rsa = NULL; + +static int called_encrypt = 0; + +/* Test function to check operation has been redirected */ +static int test_encrypt(EVP_PKEY_CTX *ctx, unsigned char *sig, + size_t *siglen, const unsigned char *tbs, size_t tbslen) +{ + called_encrypt = 1; + return 1; +} + +static int test_pkey_meths(ENGINE *e, EVP_PKEY_METHOD **pmeth, + const int **pnids, int nid) +{ + static const int rnid = EVP_PKEY_RSA; + if (pmeth == NULL) { + *pnids = &rnid; + return 1; + } + + if (nid == EVP_PKEY_RSA) { + *pmeth = test_rsa; + return 1; + } + + *pmeth = NULL; + return 0; +} + +/* Return a test EVP_PKEY value */ + +static EVP_PKEY *get_test_pkey(void) +{ + static unsigned char n[] = + "\x00\xAA\x36\xAB\xCE\x88\xAC\xFD\xFF\x55\x52\x3C\x7F\xC4\x52\x3F" + "\x90\xEF\xA0\x0D\xF3\x77\x4A\x25\x9F\x2E\x62\xB4\xC5\xD9\x9C\xB5" + "\xAD\xB3\x00\xA0\x28\x5E\x53\x01\x93\x0E\x0C\x70\xFB\x68\x76\x93" + "\x9C\xE6\x16\xCE\x62\x4A\x11\xE0\x08\x6D\x34\x1E\xBC\xAC\xA0\xA1" + "\xF5"; + static unsigned char e[] = "\x11"; + + RSA *rsa = RSA_new(); + EVP_PKEY *pk = EVP_PKEY_new(); + + if (rsa == NULL || pk == NULL || !EVP_PKEY_assign_RSA(pk, rsa)) { + RSA_free(rsa); + EVP_PKEY_free(pk); + return NULL; + } + + if (!RSA_set0_key(rsa, BN_bin2bn(n, sizeof(n)-1, NULL), + BN_bin2bn(e, sizeof(e)-1, NULL), NULL)) { + EVP_PKEY_free(pk); + return NULL; + } + + return pk; +} + +static int test_redirect(void) +{ + const unsigned char pt[] = "Hello World\n"; + unsigned char *tmp = NULL; + size_t len; + EVP_PKEY_CTX *ctx = NULL; + ENGINE *e = NULL; + EVP_PKEY *pkey = NULL; + + int to_return = 0; + + if (!TEST_ptr(pkey = get_test_pkey())) + goto err; + + len = EVP_PKEY_size(pkey); + if (!TEST_ptr(tmp = OPENSSL_malloc(len))) + goto err; + + if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL))) + goto err; + TEST_info("EVP_PKEY_encrypt test: no redirection"); + /* Encrypt some data: should succeed but not be redirected */ + if (!TEST_int_gt(EVP_PKEY_encrypt_init(ctx), 0) + || !TEST_int_gt(EVP_PKEY_encrypt(ctx, tmp, &len, pt, sizeof(pt)), 0) + || !TEST_false(called_encrypt)) + goto err; + EVP_PKEY_CTX_free(ctx); + ctx = NULL; + + /* Create a test ENGINE */ + if (!TEST_ptr(e = ENGINE_new()) + || !TEST_true(ENGINE_set_id(e, "Test redirect engine")) + || !TEST_true(ENGINE_set_name(e, "Test redirect engine"))) + goto err; + + /* + * Try to create a context for this engine and test key. + * Try setting test key engine. Both should fail because the + * engine has no public key methods. + */ + if (!TEST_ptr_null(EVP_PKEY_CTX_new(pkey, e)) + || !TEST_int_le(EVP_PKEY_set1_engine(pkey, e), 0)) + goto err; + + /* Setup an empty test EVP_PKEY_METHOD and set callback to return it */ + if (!TEST_ptr(test_rsa = EVP_PKEY_meth_new(EVP_PKEY_RSA, 0))) + goto err; + ENGINE_set_pkey_meths(e, test_pkey_meths); + + /* Getting a context for test ENGINE should now succeed */ + if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, e))) + goto err; + /* Encrypt should fail because operation is not supported */ + if (!TEST_int_le(EVP_PKEY_encrypt_init(ctx), 0)) + goto err; + EVP_PKEY_CTX_free(ctx); + ctx = NULL; + + /* Add test encrypt operation to method */ + EVP_PKEY_meth_set_encrypt(test_rsa, 0, test_encrypt); + + TEST_info("EVP_PKEY_encrypt test: redirection via EVP_PKEY_CTX_new()"); + if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, e))) + goto err; + /* Encrypt some data: should succeed and be redirected */ + if (!TEST_int_gt(EVP_PKEY_encrypt_init(ctx), 0) + || !TEST_int_gt(EVP_PKEY_encrypt(ctx, tmp, &len, pt, sizeof(pt)), 0) + || !TEST_true(called_encrypt)) + goto err; + + EVP_PKEY_CTX_free(ctx); + ctx = NULL; + called_encrypt = 0; + + /* Create context with default engine: should not be redirected */ + if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)) + || !TEST_int_gt(EVP_PKEY_encrypt_init(ctx), 0) + || !TEST_int_gt(EVP_PKEY_encrypt(ctx, tmp, &len, pt, sizeof(pt)), 0) + || !TEST_false(called_encrypt)) + goto err; + + EVP_PKEY_CTX_free(ctx); + ctx = NULL; + + /* Set engine explicitly for test key */ + if (!TEST_true(EVP_PKEY_set1_engine(pkey, e))) + goto err; + + TEST_info("EVP_PKEY_encrypt test: redirection via EVP_PKEY_set1_engine()"); + + /* Create context with default engine: should be redirected now */ + if (!TEST_ptr(ctx = EVP_PKEY_CTX_new(pkey, NULL)) + || !TEST_int_gt(EVP_PKEY_encrypt_init(ctx), 0) + || !TEST_int_gt(EVP_PKEY_encrypt(ctx, tmp, &len, pt, sizeof(pt)), 0) + || !TEST_true(called_encrypt)) + goto err; + + to_return = 1; + + err: + EVP_PKEY_CTX_free(ctx); + EVP_PKEY_free(pkey); + ENGINE_free(e); + OPENSSL_free(tmp); return to_return; } #endif + +int setup_tests(void) +{ +#ifdef OPENSSL_NO_ENGINE + TEST_note("No ENGINE support"); +#else + ADD_TEST(test_engines); + ADD_TEST(test_redirect); +#endif + return 1; +}