crypto/dso/dso_win32.c

   1 /*
   2  * Copyright 2000-2017 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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 "e_os.h"
  11 #include "dso_locl.h"
  12
  13 #if defined(DSO_WIN32)
  14
  15 # ifdef _WIN32_WCE
  16 #  if _WIN32_WCE < 300
  17 static FARPROC GetProcAddressA(HMODULE hModule, LPCSTR lpProcName)
  18 {
  19     WCHAR lpProcNameW[64];
  20     int i;
  21
  22     for (i = 0; lpProcName[i] && i < 64; i++)
  23         lpProcNameW[i] = (WCHAR)lpProcName[i];
  24     if (i == 64)
  25         return NULL;
  26     lpProcNameW[i] = 0;
  27
  28     return GetProcAddressW(hModule, lpProcNameW);
  29 }
  30 #  endif
  31 #  undef GetProcAddress
  32 #  define GetProcAddress GetProcAddressA
  33
  34 static HINSTANCE LoadLibraryA(LPCSTR lpLibFileName)
  35 {
  36     WCHAR *fnamw;
  37     size_t len_0 = strlen(lpLibFileName) + 1, i;
  38
  39 #  ifdef _MSC_VER
  40     fnamw = (WCHAR *)_alloca(len_0 * sizeof(WCHAR));
  41 #  else
  42     fnamw = (WCHAR *)alloca(len_0 * sizeof(WCHAR));
  43 #  endif
  44     if (fnamw == NULL) {
  45         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
  46         return NULL;
  47     }
  48 #  if defined(_WIN32_WCE) && _WIN32_WCE>=101
  49     if (!MultiByteToWideChar(CP_ACP, 0, lpLibFileName, len_0, fnamw, len_0))
  50 #  endif
  51         for (i = 0; i < len_0; i++)
  52             fnamw[i] = (WCHAR)lpLibFileName[i];
  53
  54     return LoadLibraryW(fnamw);
  55 }
  56 # endif
  57
  58 /* Part of the hack in "win32_load" ... */
  59 # define DSO_MAX_TRANSLATED_SIZE 256
  60
  61 static int win32_load(DSO *dso);
  62 static int win32_unload(DSO *dso);
  63 static DSO_FUNC_TYPE win32_bind_func(DSO *dso, const char *symname);
  64 static char *win32_name_converter(DSO *dso, const char *filename);
  65 static char *win32_merger(DSO *dso, const char *filespec1,
  66                           const char *filespec2);
  67 static void *win32_globallookup(const char *name);
  68
  69 static const char *openssl_strnchr(const char *string, int c, size_t len);
  70
  71 static DSO_METHOD dso_meth_win32 = {
  72     "OpenSSL 'win32' shared library method",
  73     win32_load,
  74     win32_unload,
  75     win32_bind_func,
  76     NULL,                       /* ctrl */
  77     win32_name_converter,
  78     win32_merger,
  79     NULL,                       /* init */
  80     NULL,                       /* finish */
  81     NULL,                       /* pathbyaddr */
  82     win32_globallookup
  83 };
  84
  85 DSO_METHOD *DSO_METHOD_openssl(void)
  86 {
  87     return &dso_meth_win32;
  88 }
  89
  90 /*
  91  * For this DSO_METHOD, our meth_data STACK will contain; (i) a pointer to
  92  * the handle (HINSTANCE) returned from LoadLibrary(), and copied.
  93  */
  94
  95 static int win32_load(DSO *dso)
  96 {
  97     HINSTANCE h = NULL, *p = NULL;
  98     /* See applicable comments from dso_dl.c */
  99     char *filename = DSO_convert_filename(dso, NULL);
 100
 101     if (filename == NULL) {
 102         DSOerr(DSO_F_WIN32_LOAD, DSO_R_NO_FILENAME);
 103         goto err;
 104     }
 105     h = LoadLibraryA(filename);
 106     if (h == NULL) {
 107         DSOerr(DSO_F_WIN32_LOAD, DSO_R_LOAD_FAILED);
 108         ERR_add_error_data(3, "filename(", filename, ")");
 109         goto err;
 110     }
 111     p = OPENSSL_malloc(sizeof(*p));
 112     if (p == NULL) {
 113         DSOerr(DSO_F_WIN32_LOAD, ERR_R_MALLOC_FAILURE);
 114         goto err;
 115     }
 116     *p = h;
 117     if (!sk_void_push(dso->meth_data, p)) {
 118         DSOerr(DSO_F_WIN32_LOAD, DSO_R_STACK_ERROR);
 119         goto err;
 120     }
 121     /* Success */
 122     dso->loaded_filename = filename;
 123     return 1;
 124  err:
 125     /* Cleanup ! */
 126     OPENSSL_free(filename);
 127     OPENSSL_free(p);
 128     if (h != NULL)
 129         FreeLibrary(h);
 130     return 0;
 131 }
 132
 133 static int win32_unload(DSO *dso)
 134 {
 135     HINSTANCE *p;
 136     if (dso == NULL) {
 137         DSOerr(DSO_F_WIN32_UNLOAD, ERR_R_PASSED_NULL_PARAMETER);
 138         return 0;
 139     }
 140     if (sk_void_num(dso->meth_data) < 1)
 141         return 1;
 142     p = sk_void_pop(dso->meth_data);
 143     if (p == NULL) {
 144         DSOerr(DSO_F_WIN32_UNLOAD, DSO_R_NULL_HANDLE);
 145         return 0;
 146     }
 147     if (!FreeLibrary(*p)) {
 148         DSOerr(DSO_F_WIN32_UNLOAD, DSO_R_UNLOAD_FAILED);
 149         /*
 150          * We should push the value back onto the stack in case of a retry.
 151          */
 152         sk_void_push(dso->meth_data, p);
 153         return 0;
 154     }
 155     /* Cleanup */
 156     OPENSSL_free(p);
 157     return 1;
 158 }
 159
 160 static DSO_FUNC_TYPE win32_bind_func(DSO *dso, const char *symname)
 161 {
 162     HINSTANCE *ptr;
 163     union {
 164         void *p;
 165         FARPROC f;
 166     } sym;
 167
 168     if ((dso == NULL) || (symname == NULL)) {
 169         DSOerr(DSO_F_WIN32_BIND_FUNC, ERR_R_PASSED_NULL_PARAMETER);
 170         return NULL;
 171     }
 172     if (sk_void_num(dso->meth_data) < 1) {
 173         DSOerr(DSO_F_WIN32_BIND_FUNC, DSO_R_STACK_ERROR);
 174         return NULL;
 175     }
 176     ptr = sk_void_value(dso->meth_data, sk_void_num(dso->meth_data) - 1);
 177     if (ptr == NULL) {
 178         DSOerr(DSO_F_WIN32_BIND_FUNC, DSO_R_NULL_HANDLE);
 179         return NULL;
 180     }
 181     sym.f = GetProcAddress(*ptr, symname);
 182     if (sym.p == NULL) {
 183         DSOerr(DSO_F_WIN32_BIND_FUNC, DSO_R_SYM_FAILURE);
 184         ERR_add_error_data(3, "symname(", symname, ")");
 185         return NULL;
 186     }
 187     return (DSO_FUNC_TYPE)sym.f;
 188 }
 189
 190 struct file_st {
 191     const char *node;
 192     int nodelen;
 193     const char *device;
 194     int devicelen;
 195     const char *predir;
 196     int predirlen;
 197     const char *dir;
 198     int dirlen;
 199     const char *file;
 200     int filelen;
 201 };
 202
 203 static struct file_st *win32_splitter(DSO *dso, const char *filename,
 204                                       int assume_last_is_dir)
 205 {
 206     struct file_st *result = NULL;
 207     enum { IN_NODE, IN_DEVICE, IN_FILE } position;
 208     const char *start = filename;
 209     char last;
 210
 211     if (!filename) {
 212         DSOerr(DSO_F_WIN32_SPLITTER, DSO_R_NO_FILENAME);
 213         return NULL;
 214     }
 215
 216     result = OPENSSL_zalloc(sizeof(*result));
 217     if (result == NULL) {
 218         DSOerr(DSO_F_WIN32_SPLITTER, ERR_R_MALLOC_FAILURE);
 219         return NULL;
 220     }
 221
 222     position = IN_DEVICE;
 223
 224     if ((filename[0] == '\\' && filename[1] == '\\')
 225         || (filename[0] == '/' && filename[1] == '/')) {
 226         position = IN_NODE;
 227         filename += 2;
 228         start = filename;
 229         result->node = start;
 230     }
 231
 232     do {
 233         last = filename[0];
 234         switch (last) {
 235         case ':':
 236             if (position != IN_DEVICE) {
 237                 DSOerr(DSO_F_WIN32_SPLITTER, DSO_R_INCORRECT_FILE_SYNTAX);
 238                 OPENSSL_free(result);
 239                 return NULL;
 240             }
 241             result->device = start;
 242             result->devicelen = (int)(filename - start);
 243             position = IN_FILE;
 244             start = ++filename;
 245             result->dir = start;
 246             break;
 247         case '\\':
 248         case '/':
 249             if (position == IN_NODE) {
 250                 result->nodelen = (int)(filename - start);
 251                 position = IN_FILE;
 252                 start = ++filename;
 253                 result->dir = start;
 254             } else if (position == IN_DEVICE) {
 255                 position = IN_FILE;
 256                 filename++;
 257                 result->dir = start;
 258                 result->dirlen = (int)(filename - start);
 259                 start = filename;
 260             } else {
 261                 filename++;
 262                 result->dirlen += (int)(filename - start);
 263                 start = filename;
 264             }
 265             break;
 266         case '\0':
 267             if (position == IN_NODE) {
 268                 result->nodelen = (int)(filename - start);
 269             } else {
 270                 if (filename - start > 0) {
 271                     if (assume_last_is_dir) {
 272                         if (position == IN_DEVICE) {
 273                             result->dir = start;
 274                             result->dirlen = 0;
 275                         }
 276                         result->dirlen += (int)(filename - start);
 277                     } else {
 278                         result->file = start;
 279                         result->filelen = (int)(filename - start);
 280                     }
 281                 }
 282             }
 283             break;
 284         default:
 285             filename++;
 286             break;
 287         }
 288     }
 289     while (last);
 290
 291     if (!result->nodelen)
 292         result->node = NULL;
 293     if (!result->devicelen)
 294         result->device = NULL;
 295     if (!result->dirlen)
 296         result->dir = NULL;
 297     if (!result->filelen)
 298         result->file = NULL;
 299
 300     return result;
 301 }
 302
 303 static char *win32_joiner(DSO *dso, const struct file_st *file_split)
 304 {
 305     int len = 0, offset = 0;
 306     char *result = NULL;
 307     const char *start;
 308
 309     if (!file_split) {
 310         DSOerr(DSO_F_WIN32_JOINER, ERR_R_PASSED_NULL_PARAMETER);
 311         return NULL;
 312     }
 313     if (file_split->node) {
 314         len += 2 + file_split->nodelen; /* 2 for starting \\ */
 315         if (file_split->predir || file_split->dir || file_split->file)
 316             len++;              /* 1 for ending \ */
 317     } else if (file_split->device) {
 318         len += file_split->devicelen + 1; /* 1 for ending : */
 319     }
 320     len += file_split->predirlen;
 321     if (file_split->predir && (file_split->dir || file_split->file)) {
 322         len++;                  /* 1 for ending \ */
 323     }
 324     len += file_split->dirlen;
 325     if (file_split->dir && file_split->file) {
 326         len++;                  /* 1 for ending \ */
 327     }
 328     len += file_split->filelen;
 329
 330     if (!len) {
 331         DSOerr(DSO_F_WIN32_JOINER, DSO_R_EMPTY_FILE_STRUCTURE);
 332         return NULL;
 333     }
 334
 335     result = OPENSSL_malloc(len + 1);
 336     if (result == NULL) {
 337         DSOerr(DSO_F_WIN32_JOINER, ERR_R_MALLOC_FAILURE);
 338         return NULL;
 339     }
 340
 341     if (file_split->node) {
 342         strcpy(&result[offset], "\\\\");
 343         offset += 2;
 344         strncpy(&result[offset], file_split->node, file_split->nodelen);
 345         offset += file_split->nodelen;
 346         if (file_split->predir || file_split->dir || file_split->file) {
 347             result[offset] = '\\';
 348             offset++;
 349         }
 350     } else if (file_split->device) {
 351         strncpy(&result[offset], file_split->device, file_split->devicelen);
 352         offset += file_split->devicelen;
 353         result[offset] = ':';
 354         offset++;
 355     }
 356     start = file_split->predir;
 357     while (file_split->predirlen > (start - file_split->predir)) {
 358         const char *end = openssl_strnchr(start, '/',
 359                                           file_split->predirlen - (start -
 360                                                                    file_split->predir));
 361         if (!end)
 362             end = start
 363                 + file_split->predirlen - (start - file_split->predir);
 364         strncpy(&result[offset], start, end - start);
 365         offset += (int)(end - start);
 366         result[offset] = '\\';
 367         offset++;
 368         start = end + 1;
 369     }
 370     start = file_split->dir;
 371     while (file_split->dirlen > (start - file_split->dir)) {
 372         const char *end = openssl_strnchr(start, '/',
 373                                           file_split->dirlen - (start -
 374                                                                 file_split->dir));
 375         if (!end)
 376             end = start + file_split->dirlen - (start - file_split->dir);
 377         strncpy(&result[offset], start, end - start);
 378         offset += (int)(end - start);
 379         result[offset] = '\\';
 380         offset++;
 381         start = end + 1;
 382     }
 383     strncpy(&result[offset], file_split->file, file_split->filelen);
 384     offset += file_split->filelen;
 385     result[offset] = '\0';
 386     return result;
 387 }
 388
 389 static char *win32_merger(DSO *dso, const char *filespec1,
 390                           const char *filespec2)
 391 {
 392     char *merged = NULL;
 393     struct file_st *filespec1_split = NULL;
 394     struct file_st *filespec2_split = NULL;
 395
 396     if (!filespec1 && !filespec2) {
 397         DSOerr(DSO_F_WIN32_MERGER, ERR_R_PASSED_NULL_PARAMETER);
 398         return NULL;
 399     }
 400     if (!filespec2) {
 401         merged = OPENSSL_strdup(filespec1);
 402         if (merged == NULL) {
 403             DSOerr(DSO_F_WIN32_MERGER, ERR_R_MALLOC_FAILURE);
 404             return NULL;
 405         }
 406     } else if (!filespec1) {
 407         merged = OPENSSL_strdup(filespec2);
 408         if (merged == NULL) {
 409             DSOerr(DSO_F_WIN32_MERGER, ERR_R_MALLOC_FAILURE);
 410             return NULL;
 411         }
 412     } else {
 413         filespec1_split = win32_splitter(dso, filespec1, 0);
 414         if (!filespec1_split) {
 415             DSOerr(DSO_F_WIN32_MERGER, ERR_R_MALLOC_FAILURE);
 416             return NULL;
 417         }
 418         filespec2_split = win32_splitter(dso, filespec2, 1);
 419         if (!filespec2_split) {
 420             DSOerr(DSO_F_WIN32_MERGER, ERR_R_MALLOC_FAILURE);
 421             OPENSSL_free(filespec1_split);
 422             return NULL;
 423         }
 424
 425         /* Fill in into filespec1_split */
 426         if (!filespec1_split->node && !filespec1_split->device) {
 427             filespec1_split->node = filespec2_split->node;
 428             filespec1_split->nodelen = filespec2_split->nodelen;
 429             filespec1_split->device = filespec2_split->device;
 430             filespec1_split->devicelen = filespec2_split->devicelen;
 431         }
 432         if (!filespec1_split->dir) {
 433             filespec1_split->dir = filespec2_split->dir;
 434             filespec1_split->dirlen = filespec2_split->dirlen;
 435         } else if (filespec1_split->dir[0] != '\\'
 436                    && filespec1_split->dir[0] != '/') {
 437             filespec1_split->predir = filespec2_split->dir;
 438             filespec1_split->predirlen = filespec2_split->dirlen;
 439         }
 440         if (!filespec1_split->file) {
 441             filespec1_split->file = filespec2_split->file;
 442             filespec1_split->filelen = filespec2_split->filelen;
 443         }
 444
 445         merged = win32_joiner(dso, filespec1_split);
 446     }
 447     OPENSSL_free(filespec1_split);
 448     OPENSSL_free(filespec2_split);
 449     return merged;
 450 }
 451
 452 static char *win32_name_converter(DSO *dso, const char *filename)
 453 {
 454     char *translated;
 455     int len, transform;
 456
 457     len = strlen(filename);
 458     transform = ((strstr(filename, "/") == NULL) &&
 459                  (strstr(filename, "\\") == NULL) &&
 460                  (strstr(filename, ":") == NULL));
 461     if (transform)
 462         /* We will convert this to "%s.dll" */
 463         translated = OPENSSL_malloc(len + 5);
 464     else
 465         /* We will simply duplicate filename */
 466         translated = OPENSSL_malloc(len + 1);
 467     if (translated == NULL) {
 468         DSOerr(DSO_F_WIN32_NAME_CONVERTER, DSO_R_NAME_TRANSLATION_FAILED);
 469         return NULL;
 470     }
 471     if (transform)
 472         sprintf(translated, "%s.dll", filename);
 473     else
 474         sprintf(translated, "%s", filename);
 475     return translated;
 476 }
 477
 478 static const char *openssl_strnchr(const char *string, int c, size_t len)
 479 {
 480     size_t i;
 481     const char *p;
 482     for (i = 0, p = string; i < len && *p; i++, p++) {
 483         if (*p == c)
 484             return p;
 485     }
 486     return NULL;
 487 }
 488
 489 # include <tlhelp32.h>
 490 # ifdef _WIN32_WCE
 491 #  define DLLNAME "TOOLHELP.DLL"
 492 # else
 493 #  ifdef MODULEENTRY32
 494 #   undef MODULEENTRY32         /* unmask the ASCII version! */
 495 #  endif
 496 #  define DLLNAME "KERNEL32.DLL"
 497 # endif
 498
 499 typedef HANDLE(WINAPI *CREATETOOLHELP32SNAPSHOT) (DWORD, DWORD);
 500 typedef BOOL(WINAPI *CLOSETOOLHELP32SNAPSHOT) (HANDLE);
 501 typedef BOOL(WINAPI *MODULE32) (HANDLE, MODULEENTRY32 *);
 502
 503 static void *win32_globallookup(const char *name)
 504 {
 505     HMODULE dll;
 506     HANDLE hModuleSnap = INVALID_HANDLE_VALUE;
 507     MODULEENTRY32 me32;
 508     CREATETOOLHELP32SNAPSHOT create_snap;
 509     CLOSETOOLHELP32SNAPSHOT close_snap;
 510     MODULE32 module_first, module_next;
 511     union {
 512         void *p;
 513         FARPROC f;
 514     } ret = { NULL };
 515
 516     dll = LoadLibrary(TEXT(DLLNAME));
 517     if (dll == NULL) {
 518         DSOerr(DSO_F_WIN32_GLOBALLOOKUP, DSO_R_UNSUPPORTED);
 519         return NULL;
 520     }
 521
 522     create_snap = (CREATETOOLHELP32SNAPSHOT)
 523         GetProcAddress(dll, "CreateToolhelp32Snapshot");
 524     if (create_snap == NULL) {
 525         FreeLibrary(dll);
 526         DSOerr(DSO_F_WIN32_GLOBALLOOKUP, DSO_R_UNSUPPORTED);
 527         return NULL;
 528     }
 529     /* We take the rest for granted... */
 530 # ifdef _WIN32_WCE
 531     close_snap = (CLOSETOOLHELP32SNAPSHOT)
 532         GetProcAddress(dll, "CloseToolhelp32Snapshot");
 533 # else
 534     close_snap = (CLOSETOOLHELP32SNAPSHOT) CloseHandle;
 535 # endif
 536     module_first = (MODULE32) GetProcAddress(dll, "Module32First");
 537     module_next = (MODULE32) GetProcAddress(dll, "Module32Next");
 538
 539     hModuleSnap = (*create_snap) (TH32CS_SNAPMODULE, 0);
 540     if (hModuleSnap == INVALID_HANDLE_VALUE) {
 541         FreeLibrary(dll);
 542         DSOerr(DSO_F_WIN32_GLOBALLOOKUP, DSO_R_UNSUPPORTED);
 543         return NULL;
 544     }
 545
 546     me32.dwSize = sizeof(me32);
 547
 548     if (!(*module_first) (hModuleSnap, &me32)) {
 549         (*close_snap) (hModuleSnap);
 550         FreeLibrary(dll);
 551         return NULL;
 552     }
 553
 554     do {
 555         if ((ret.f = GetProcAddress(me32.hModule, name))) {
 556             (*close_snap) (hModuleSnap);
 557             FreeLibrary(dll);
 558             return ret.p;
 559         }
 560     } while ((*module_next) (hModuleSnap, &me32));
 561
 562     (*close_snap) (hModuleSnap);
 563     FreeLibrary(dll);
 564     return NULL;
 565 }
 566 #endif                          /* DSO_WIN32 */