/*
- * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2016-2018 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
#include <string.h>
#include <stdlib.h>
#include <openssl/opensslv.h>
+#include <openssl/ssl.h>
+#include <openssl/ossl_typ.h>
+#include "internal/dso_conf.h"
+#include "testutil.h"
-#define SSL_CTX_NEW "SSL_CTX_new"
-#define SSL_CTX_FREE "SSL_CTX_free"
-#define TLS_METHOD "TLS_method"
+typedef void DSO;
-#define ERR_GET_ERROR "ERR_get_error"
-#define OPENSSL_VERSION_NUM_FUNC "OpenSSL_version_num"
-
-typedef struct ssl_ctx_st SSL_CTX;
-typedef struct ssl_method_st SSL_METHOD;
typedef const SSL_METHOD * (*TLS_method_t)(void);
typedef SSL_CTX * (*SSL_CTX_new_t)(const SSL_METHOD *meth);
typedef void (*SSL_CTX_free_t)(SSL_CTX *);
-
typedef unsigned long (*ERR_get_error_t)(void);
typedef unsigned long (*OpenSSL_version_num_t)(void);
+typedef DSO * (*DSO_dsobyaddr_t)(void (*addr)(), int flags);
+typedef int (*DSO_free_t)(DSO *dso);
-TLS_method_t TLS_method;
-SSL_CTX_new_t SSL_CTX_new;
-SSL_CTX_free_t SSL_CTX_free;
-
-ERR_get_error_t ERR_get_error;
-OpenSSL_version_num_t OpenSSL_version_num;
+typedef enum test_types_en {
+ CRYPTO_FIRST,
+ SSL_FIRST,
+ JUST_CRYPTO,
+ DSO_REFTEST
+} TEST_TYPE;
+static TEST_TYPE test_type;
+static const char *path_crypto;
+static const char *path_ssl;
#ifdef DSO_DLFCN
# include <dlfcn.h>
-typedef void * SHLIB;
-typedef void * SHLIB_SYM;
+# define SHLIB_INIT NULL
-# define SHARED_LIBRARY_SUFFIX ".so"
+typedef void *SHLIB;
+typedef void *SHLIB_SYM;
-static int shlib_load(char *filename, SHLIB *lib)
+static int shlib_load(const char *filename, SHLIB *lib)
{
- char *tmpfile;
- size_t filenamelen = strlen(filename);
-
- /* Total length = base filename len + suffix len + 1 for NULL terminator */
- tmpfile = malloc(filenamelen + sizeof(SHARED_LIBRARY_SUFFIX) + 1);
- if (tmpfile == NULL)
- return 0;
- strcpy(tmpfile, filename);
- strcpy(tmpfile + filenamelen, SHARED_LIBRARY_SUFFIX);
-
- *lib = dlopen(tmpfile, RTLD_GLOBAL | RTLD_LAZY);
- free(tmpfile);
-
- if (*lib == NULL)
- return 0;
-
- return 1;
+ *lib = dlopen(filename, RTLD_GLOBAL | RTLD_LAZY);
+ return *lib == NULL ? 0 : 1;
}
static int shlib_sym(SHLIB lib, const char *symname, SHLIB_SYM *sym)
{
*sym = dlsym(lib, symname);
-
return *sym != NULL;
}
static int shlib_close(SHLIB lib)
{
- if (dlclose(lib) != 0)
- return 0;
-
- return 1;
+ return dlclose(lib) != 0 ? 0 : 1;
}
+#endif
-#elif defined(DSO_WIN32)
+#ifdef DSO_WIN32
# include <windows.h>
+# define SHLIB_INIT 0
+
typedef HINSTANCE SHLIB;
-typedef void * SHLIB_SYM;
+typedef void *SHLIB_SYM;
-static int shlib_load(char *filename, SHLIB *lib)
+static int shlib_load(const char *filename, SHLIB *lib)
{
*lib = LoadLibraryA(filename);
- if (*lib == NULL)
- return 0;
-
- return 1;
+ return *lib == NULL ? 0 : 1;
}
static int shlib_sym(SHLIB lib, const char *symname, SHLIB_SYM *sym)
{
*sym = (SHLIB_SYM)GetProcAddress(lib, symname);
-
return *sym != NULL;
}
static int shlib_close(SHLIB lib)
{
- if (FreeLibrary(lib) == 0)
- return 0;
-
- return 1;
+ return FreeLibrary(lib) == 0 ? 0 : 1;
}
-
#endif
-/* The test is only currently implemented for DSO_DLFCN and DSO_WIN32 */
-#if defined(DSO_DLFCN) || defined(DSO_WIN32)
-
-# define CRYPTO_FIRST_OPT "-crypto_first"
-# define SSL_FIRST_OPT "-ssl_first"
-# define JUST_CRYPTO_OPT "-just_crypto"
-enum test_types_en {
- CRYPTO_FIRST,
- SSL_FIRST,
- JUST_CRYPTO
-};
+#if defined(DSO_DLFCN) || defined(DSO_WIN32)
-int main(int argc, char **argv)
+static int test_lib(void)
{
- SHLIB ssllib, cryptolib;
+ SHLIB ssllib = SHLIB_INIT;
+ SHLIB cryptolib = SHLIB_INIT;
SSL_CTX *ctx;
union {
- void (*func) (void);
+ void (*func)(void);
SHLIB_SYM sym;
- } tls_method_sym, ssl_ctx_new_sym, ssl_ctx_free_sym, err_get_error_sym,
- openssl_version_num_sym;
- enum test_types_en test_type;
- int i;
-
- if (argc != 4) {
- printf("Unexpected number of arguments\n");
- return 1;
+ } symbols[3];
+ TLS_method_t myTLS_method;
+ SSL_CTX_new_t mySSL_CTX_new;
+ SSL_CTX_free_t mySSL_CTX_free;
+ ERR_get_error_t myERR_get_error;
+ OpenSSL_version_num_t myOpenSSL_version_num;
+ int result = 0;
+
+ switch (test_type) {
+ case JUST_CRYPTO:
+ if (!TEST_true(shlib_load(path_crypto, &cryptolib)))
+ goto end;
+ break;
+ case CRYPTO_FIRST:
+ if (!TEST_true(shlib_load(path_crypto, &cryptolib))
+ || !TEST_true(shlib_load(path_ssl, &ssllib)))
+ goto end;
+ break;
+ case SSL_FIRST:
+ if (!TEST_true(shlib_load(path_ssl, &ssllib))
+ || !TEST_true(shlib_load(path_crypto, &cryptolib)))
+ goto end;
+ break;
+ case DSO_REFTEST:
+ if (!TEST_true(shlib_load(path_crypto, &cryptolib)))
+ goto end;
+ break;
}
- if (strcmp(argv[1], CRYPTO_FIRST_OPT) == 0) {
- test_type = CRYPTO_FIRST;
- } else if (strcmp(argv[1], SSL_FIRST_OPT) == 0) {
- test_type = SSL_FIRST;
- } else if (strcmp(argv[1], JUST_CRYPTO_OPT) == 0) {
- test_type = JUST_CRYPTO;
- } else {
- printf("Unrecognised argument\n");
- return 1;
- }
-
- for (i = 0; i < 2; i++) {
- if ((i == 0 && (test_type == CRYPTO_FIRST
- || test_type == JUST_CRYPTO))
- || (i == 1 && test_type == SSL_FIRST)) {
- if (!shlib_load(argv[2], &cryptolib)) {
- printf("Unable to load libcrypto\n");
- return 1;
- }
- }
- if ((i == 0 && test_type == SSL_FIRST)
- || (i == 1 && test_type == CRYPTO_FIRST)) {
- if (!shlib_load(argv[3], &ssllib)) {
- printf("Unable to load libssl\n");
- return 1;
- }
- }
+ if (test_type != JUST_CRYPTO && test_type != DSO_REFTEST) {
+ if (!TEST_true(shlib_sym(ssllib, "TLS_method", &symbols[0].sym))
+ || !TEST_true(shlib_sym(ssllib, "SSL_CTX_new", &symbols[1].sym))
+ || !TEST_true(shlib_sym(ssllib, "SSL_CTX_free", &symbols[2].sym)))
+ goto end;
+ myTLS_method = (TLS_method_t)symbols[0].func;
+ mySSL_CTX_new = (SSL_CTX_new_t)symbols[1].func;
+ mySSL_CTX_free = (SSL_CTX_free_t)symbols[2].func;
+ if (!TEST_ptr(ctx = mySSL_CTX_new(myTLS_method())))
+ goto end;
+ mySSL_CTX_free(ctx);
}
- if (test_type != JUST_CRYPTO) {
- if (!shlib_sym(ssllib, TLS_METHOD, &tls_method_sym.sym)
- || !shlib_sym(ssllib, SSL_CTX_NEW, &ssl_ctx_new_sym.sym)
- || !shlib_sym(ssllib, SSL_CTX_FREE, &ssl_ctx_free_sym.sym)) {
- printf("Unable to load ssl symbols\n");
- return 1;
- }
-
- TLS_method = (TLS_method_t)tls_method_sym.func;
- SSL_CTX_new = (SSL_CTX_new_t)ssl_ctx_new_sym.func;
- SSL_CTX_free = (SSL_CTX_free_t)ssl_ctx_free_sym.func;
-
- ctx = SSL_CTX_new(TLS_method());
- if (ctx == NULL) {
- printf("Unable to create SSL_CTX\n");
- return 1;
+ if (!TEST_true(shlib_sym(cryptolib, "ERR_get_error", &symbols[0].sym))
+ || !TEST_true(shlib_sym(cryptolib, "OpenSSL_version_num",
+ &symbols[1].sym)))
+ goto end;
+ myERR_get_error = (ERR_get_error_t)symbols[0].func;
+ if (!TEST_int_eq(myERR_get_error(), 0))
+ goto end;
+
+ /*
+ * The bits that COMPATIBILITY_MASK lets through MUST be the same in
+ * the library and in the application.
+ * The bits that are masked away MUST be a larger or equal number in
+ * the library compared to the application.
+ */
+# define COMPATIBILITY_MASK 0xfff00000L
+ myOpenSSL_version_num = (OpenSSL_version_num_t)symbols[1].func;
+ if (!TEST_int_eq(myOpenSSL_version_num() & COMPATIBILITY_MASK,
+ OPENSSL_VERSION_NUMBER & COMPATIBILITY_MASK))
+ goto end;
+ if (!TEST_int_ge(myOpenSSL_version_num() & ~COMPATIBILITY_MASK,
+ OPENSSL_VERSION_NUMBER & ~COMPATIBILITY_MASK))
+ goto end;
+
+ if (test_type == DSO_REFTEST) {
+# ifdef DSO_DLFCN
+ DSO_dsobyaddr_t myDSO_dsobyaddr;
+ DSO_free_t myDSO_free;
+
+ /*
+ * This is resembling the code used in ossl_init_base() and
+ * OPENSSL_atexit() to block unloading the library after dlclose().
+ * We are not testing this on Windows, because it is done there in a
+ * completely different way. Especially as a call to DSO_dsobyaddr()
+ * will always return an error, because DSO_pathbyaddr() is not
+ * implemented there.
+ */
+ if (!TEST_true(shlib_sym(cryptolib, "DSO_dsobyaddr", &symbols[0].sym))
+ || !TEST_true(shlib_sym(cryptolib, "DSO_free",
+ &symbols[1].sym)))
+ goto end;
+
+ myDSO_dsobyaddr = (DSO_dsobyaddr_t)symbols[0].func;
+ myDSO_free = (DSO_free_t)symbols[1].func;
+
+ {
+ DSO *hndl;
+ /* use known symbol from crypto module */
+ if (!TEST_ptr(hndl = myDSO_dsobyaddr((void (*)())ERR_get_error, 0)))
+ goto end;
+ myDSO_free(hndl);
}
- SSL_CTX_free(ctx);
+# endif /* DSO_DLFCN */
}
- if (!shlib_sym(cryptolib, ERR_GET_ERROR, &err_get_error_sym.sym)
- || !shlib_sym(cryptolib, OPENSSL_VERSION_NUM_FUNC,
- &openssl_version_num_sym.sym)) {
- printf("Unable to load crypto symbols\n");
- return 1;
+ switch (test_type) {
+ case JUST_CRYPTO:
+ if (!TEST_true(shlib_close(cryptolib)))
+ goto end;
+ break;
+ case CRYPTO_FIRST:
+ if (!TEST_true(shlib_close(cryptolib))
+ || !TEST_true(shlib_close(ssllib)))
+ goto end;
+ break;
+ case SSL_FIRST:
+ if (!TEST_true(shlib_close(ssllib))
+ || !TEST_true(shlib_close(cryptolib)))
+ goto end;
+ break;
+ case DSO_REFTEST:
+ if (!TEST_true(shlib_close(cryptolib)))
+ goto end;
+ break;
}
- ERR_get_error = (ERR_get_error_t)err_get_error_sym.func;
- OpenSSL_version_num = (OpenSSL_version_num_t)openssl_version_num_sym.func;
+ result = 1;
+end:
+ return result;
+}
+#endif
- if (ERR_get_error() != 0) {
- printf("Unexpected error in error queue\n");
- return 1;
- }
- if (OpenSSL_version_num() != OPENSSL_VERSION_NUMBER) {
- printf("Unexpected library version loaded\n");
- return 1;
- }
+int setup_tests(void)
+{
+ const char *p = test_get_argument(0);
- for (i = 0; i < 2; i++) {
- if ((i == 0 && test_type == CRYPTO_FIRST)
- || (i == 1 && test_type == SSL_FIRST)) {
- if (!shlib_close(ssllib)) {
- printf("Unable to close libssl\n");
- return 1;
- }
- }
- if ((i == 0 && (test_type == SSL_FIRST
- || test_type == JUST_CRYPTO))
- || (i == 1 && test_type == CRYPTO_FIRST)) {
- if (!shlib_close(cryptolib)) {
- printf("Unable to close libcrypto\n");
- return 1;
- }
- }
+ if (strcmp(p, "-crypto_first") == 0) {
+ test_type = CRYPTO_FIRST;
+ } else if (strcmp(p, "-ssl_first") == 0) {
+ test_type = SSL_FIRST;
+ } else if (strcmp(p, "-just_crypto") == 0) {
+ test_type = JUST_CRYPTO;
+ } else if (strcmp(p, "-dso_ref") == 0) {
+ test_type = JUST_CRYPTO;
+ } else {
+ TEST_error("Unrecognised argument");
+ return 0;
}
+ if (!TEST_ptr(path_crypto = test_get_argument(1))
+ || !TEST_ptr(path_ssl = test_get_argument(2)))
+ return 0;
- printf("Success\n");
- return 0;
-}
-#else
-int main(void)
-{
- printf("Test not implemented on this platform\n");
- return 0;
-}
+#if defined(DSO_DLFCN) || defined(DSO_WIN32)
+ ADD_TEST(test_lib);
#endif
+ return 1;
+}
projects / openssl.git / blobdiff