test/shlibloadtest.c

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <openssl/opensslv.h>
  14
  15 /* The test is only currently implemented for DSO_DLFCN and DSO_WIN32 */
  16 #if defined(DSO_DLFCN) || defined(DSO_WIN32)
  17
  18 #define SSL_CTX_NEW "SSL_CTX_new"
  19 #define SSL_CTX_FREE "SSL_CTX_free"
  20 #define TLS_METHOD "TLS_method"
  21
  22 #define ERR_GET_ERROR "ERR_get_error"
  23 #define OPENSSL_VERSION_NUM_FUNC "OpenSSL_version_num"
  24
  25 typedef struct ssl_ctx_st SSL_CTX;
  26 typedef struct ssl_method_st SSL_METHOD;
  27 typedef const SSL_METHOD * (*TLS_method_t)(void);
  28 typedef SSL_CTX * (*SSL_CTX_new_t)(const SSL_METHOD *meth);
  29 typedef void (*SSL_CTX_free_t)(SSL_CTX *);
  30
  31 typedef unsigned long (*ERR_get_error_t)(void);
  32 typedef unsigned long (*OpenSSL_version_num_t)(void);
  33
  34 static TLS_method_t TLS_method;
  35 static SSL_CTX_new_t SSL_CTX_new;
  36 static SSL_CTX_free_t SSL_CTX_free;
  37
  38 static ERR_get_error_t ERR_get_error;
  39 static OpenSSL_version_num_t OpenSSL_version_num;
  40
  41 #ifdef DSO_DLFCN
  42
  43 # include <dlfcn.h>
  44
  45 typedef void * SHLIB;
  46 typedef void * SHLIB_SYM;
  47 # define SHLIB_INIT NULL
  48
  49 static int shlib_load(const char *filename, SHLIB *lib)
  50 {
  51     *lib = dlopen(filename, RTLD_GLOBAL | RTLD_LAZY);
  52
  53     if (*lib == NULL)
  54         return 0;
  55
  56     return 1;
  57 }
  58
  59 static int shlib_sym(SHLIB lib, const char *symname, SHLIB_SYM *sym)
  60 {
  61     *sym = dlsym(lib, symname);
  62
  63     return *sym != NULL;
  64 }
  65
  66 static int shlib_close(SHLIB lib)
  67 {
  68     if (dlclose(lib) != 0)
  69         return 0;
  70
  71     return 1;
  72 }
  73
  74 #elif defined(DSO_WIN32)
  75
  76 # include <windows.h>
  77
  78 typedef HINSTANCE SHLIB;
  79 typedef void * SHLIB_SYM;
  80 # define SHLIB_INIT 0
  81
  82 static int shlib_load(const char *filename, SHLIB *lib)
  83 {
  84     *lib = LoadLibraryA(filename);
  85     if (*lib == NULL)
  86         return 0;
  87
  88     return 1;
  89 }
  90
  91 static int shlib_sym(SHLIB lib, const char *symname, SHLIB_SYM *sym)
  92 {
  93     *sym = (SHLIB_SYM)GetProcAddress(lib, symname);
  94
  95     return *sym != NULL;
  96 }
  97
  98 static int shlib_close(SHLIB lib)
  99 {
 100     if (FreeLibrary(lib) == 0)
 101         return 0;
 102
 103     return 1;
 104 }
 105
 106 #endif
 107
 108 # define CRYPTO_FIRST_OPT    "-crypto_first"
 109 # define SSL_FIRST_OPT       "-ssl_first"
 110 # define JUST_CRYPTO_OPT     "-just_crypto"
 111
 112 enum test_types_en {
 113     CRYPTO_FIRST,
 114     SSL_FIRST,
 115     JUST_CRYPTO
 116 };
 117
 118 int main(int argc, char **argv)
 119 {
 120     SHLIB ssllib = SHLIB_INIT, cryptolib = SHLIB_INIT;
 121     SSL_CTX *ctx;
 122     union {
 123         void (*func) (void);
 124         SHLIB_SYM sym;
 125     } tls_method_sym, ssl_ctx_new_sym, ssl_ctx_free_sym, err_get_error_sym,
 126     openssl_version_num_sym;
 127     enum test_types_en test_type;
 128     int i;
 129
 130     if (argc != 4) {
 131         printf("Unexpected number of arguments\n");
 132         return 1;
 133     }
 134
 135     if (strcmp(argv[1], CRYPTO_FIRST_OPT) == 0) {
 136         test_type = CRYPTO_FIRST;
 137     } else if (strcmp(argv[1], SSL_FIRST_OPT) == 0) {
 138             test_type = SSL_FIRST;
 139     } else if (strcmp(argv[1], JUST_CRYPTO_OPT) == 0) {
 140             test_type = JUST_CRYPTO;
 141     } else {
 142         printf("Unrecognised argument\n");
 143         return 1;
 144     }
 145
 146     for (i = 0; i < 2; i++) {
 147         if ((i == 0 && (test_type == CRYPTO_FIRST
 148                        || test_type == JUST_CRYPTO))
 149                || (i == 1 && test_type == SSL_FIRST)) {
 150             if (!shlib_load(argv[2], &cryptolib)) {
 151                 printf("Unable to load libcrypto\n");
 152                 return 1;
 153             }
 154         }
 155         if ((i == 0 && test_type == SSL_FIRST)
 156                 || (i == 1 && test_type == CRYPTO_FIRST)) {
 157             if (!shlib_load(argv[3], &ssllib)) {
 158                 printf("Unable to load libssl\n");
 159                 return 1;
 160             }
 161         }
 162     }
 163
 164     if (test_type != JUST_CRYPTO) {
 165         if (!shlib_sym(ssllib, TLS_METHOD, &tls_method_sym.sym)
 166                 || !shlib_sym(ssllib, SSL_CTX_NEW, &ssl_ctx_new_sym.sym)
 167                 || !shlib_sym(ssllib, SSL_CTX_FREE, &ssl_ctx_free_sym.sym)) {
 168             printf("Unable to load ssl symbols\n");
 169             return 1;
 170         }
 171
 172         TLS_method = (TLS_method_t)tls_method_sym.func;
 173         SSL_CTX_new = (SSL_CTX_new_t)ssl_ctx_new_sym.func;
 174         SSL_CTX_free = (SSL_CTX_free_t)ssl_ctx_free_sym.func;
 175
 176         ctx = SSL_CTX_new(TLS_method());
 177         if (ctx == NULL) {
 178             printf("Unable to create SSL_CTX\n");
 179             return 1;
 180         }
 181         SSL_CTX_free(ctx);
 182     }
 183
 184     if (!shlib_sym(cryptolib, ERR_GET_ERROR, &err_get_error_sym.sym)
 185             || !shlib_sym(cryptolib, OPENSSL_VERSION_NUM_FUNC,
 186                           &openssl_version_num_sym.sym)) {
 187         printf("Unable to load crypto symbols\n");
 188         return 1;
 189     }
 190
 191     ERR_get_error = (ERR_get_error_t)err_get_error_sym.func;
 192     OpenSSL_version_num = (OpenSSL_version_num_t)openssl_version_num_sym.func;
 193
 194     if (ERR_get_error() != 0) {
 195         printf("Unexpected error in error queue\n");
 196         return 1;
 197     }
 198
 199     if (OpenSSL_version_num() != OPENSSL_VERSION_NUMBER) {
 200         printf("Unexpected library version loaded\n");
 201         return 1;
 202     }
 203
 204     for (i = 0; i < 2; i++) {
 205         if ((i == 0 && test_type == CRYPTO_FIRST)
 206                 || (i == 1 && test_type == SSL_FIRST)) {
 207             if (!shlib_close(ssllib)) {
 208                 printf("Unable to close libssl\n");
 209                 return 1;
 210             }
 211         }
 212         if ((i == 0 && (test_type == SSL_FIRST
 213                        || test_type == JUST_CRYPTO))
 214                 || (i == 1 && test_type == CRYPTO_FIRST)) {
 215             if (!shlib_close(cryptolib)) {
 216                 printf("Unable to close libcrypto\n");
 217                 return 1;
 218             }
 219         }
 220     }
 221
 222     printf("Success\n");
 223     return 0;
 224 }
 225 #else
 226 int main(void)
 227 {
 228     printf("Test not implemented on this platform\n");
 229     return 0;
 230 }
 231 #endif