dlls/crypt32/main.c

   1 /*
   2  * Copyright 2002 Mike McCormack for CodeWeavers
   3  * Copyright 2005 Juan Lang
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winternl.h"
  27 #include "wincrypt.h"
  28 #include "winreg.h"
  29 #include "winuser.h"
  30 #include "i_cryptasn1tls.h"
  31 #include "crypt32_private.h"
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  35
  36 static HCRYPTPROV hDefProv;
  37 HINSTANCE hInstance;
  38 unixlib_handle_t crypt32_handle = 0;
  39
  40 static CRITICAL_SECTION prov_param_cs;
  41 static CRITICAL_SECTION_DEBUG prov_param_cs_debug =
  42 {
  43     0, 0, &prov_param_cs,
  44     { &prov_param_cs_debug.ProcessLocksList,
  45     &prov_param_cs_debug.ProcessLocksList },
  46     0, 0, { (DWORD_PTR)(__FILE__ ": prov_param_cs") }
  47 };
  48 static CRITICAL_SECTION prov_param_cs = { &prov_param_cs_debug, -1, 0, 0, 0, 0 };
  49
  50 BOOL WINAPI DllMain(HINSTANCE hInst, DWORD reason, PVOID pvReserved)
  51 {
  52     switch (reason)
  53     {
  54         case DLL_PROCESS_ATTACH:
  55             hInstance = hInst;
  56             DisableThreadLibraryCalls(hInst);
  57             init_empty_store();
  58             crypt_oid_init();
  59             if (NtQueryVirtualMemory( GetCurrentProcess(), hInst, MemoryWineUnixFuncs,
  60                                       &crypt32_handle, sizeof(crypt32_handle), NULL ))
  61                 return FALSE;
  62             CRYPT32_CALL( process_attach, NULL );
  63             break;
  64         case DLL_PROCESS_DETACH:
  65             if (pvReserved) break;
  66             crypt_oid_free();
  67             crypt_sip_free();
  68             default_chain_engine_free();
  69             if (hDefProv) CryptReleaseContext(hDefProv, 0);
  70             CRYPT32_CALL( process_detach, NULL );
  71             break;
  72     }
  73     return TRUE;
  74 }
  75
  76 static HCRYPTPROV CRYPT_GetDefaultProvider(void)
  77 {
  78     if (!hDefProv)
  79     {
  80         HCRYPTPROV prov;
  81
  82         if (!CryptAcquireContextW(&prov, NULL, MS_ENH_RSA_AES_PROV_W,
  83          PROV_RSA_AES, CRYPT_VERIFYCONTEXT))
  84             return hDefProv;
  85         InterlockedCompareExchangePointer((PVOID *)&hDefProv, (PVOID)prov,
  86          NULL);
  87         if (hDefProv != prov)
  88             CryptReleaseContext(prov, 0);
  89     }
  90     return hDefProv;
  91 }
  92
  93 typedef void * HLRUCACHE;
  94
  95 /* this function is called by Internet Explorer when it is about to verify a
  96  * downloaded component.  The first parameter appears to be a pointer to an
  97  * unknown type, native fails unless it points to a buffer of at least 20 bytes.
  98  * The second parameter appears to be an out parameter, whatever it's set to is
  99  * passed (by cryptnet.dll) to I_CryptFlushLruCache.
 100  */
 101 BOOL WINAPI I_CryptCreateLruCache(void *unknown, HLRUCACHE *out)
 102 {
 103     FIXME("(%p, %p): stub!\n", unknown, out);
 104     *out = (void *)0xbaadf00d;
 105     return TRUE;
 106 }
 107
 108 BOOL WINAPI I_CryptFindLruEntry(DWORD unk0, DWORD unk1)
 109 {
 110     FIXME("(%08lx, %08lx): stub!\n", unk0, unk1);
 111     return FALSE;
 112 }
 113
 114 BOOL WINAPI I_CryptFindLruEntryData(DWORD unk0, DWORD unk1, DWORD unk2)
 115 {
 116     FIXME("(%08lx, %08lx, %08lx): stub!\n", unk0, unk1, unk2);
 117     return FALSE;
 118 }
 119
 120 BOOL WINAPI I_CryptCreateLruEntry(HLRUCACHE h, DWORD unk0, DWORD unk1)
 121 {
 122     FIXME("(%p, %08lx, %08lx): stub!\n", h, unk0, unk1);
 123     return FALSE;
 124 }
 125
 126 DWORD WINAPI I_CryptFlushLruCache(HLRUCACHE h, DWORD unk0, DWORD unk1)
 127 {
 128     FIXME("(%p, %08lx, %08lx): stub!\n", h, unk0, unk1);
 129     return 0;
 130 }
 131
 132 HLRUCACHE WINAPI I_CryptFreeLruCache(HLRUCACHE h, DWORD unk0, DWORD unk1)
 133 {
 134     FIXME("(%p, %08lx, %08lx): stub!\n", h, unk0, unk1);
 135     return h;
 136 }
 137
 138 LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
 139 {
 140     return malloc(cbSize);
 141 }
 142
 143 LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize)
 144 {
 145     return realloc(pv, cbSize);
 146 }
 147
 148 VOID WINAPI CryptMemFree(LPVOID pv)
 149 {
 150     free(pv);
 151 }
 152
 153 DWORD WINAPI I_CryptAllocTls(void)
 154 {
 155     return TlsAlloc();
 156 }
 157
 158 LPVOID WINAPI I_CryptDetachTls(DWORD dwTlsIndex)
 159 {
 160     LPVOID ret;
 161
 162     ret = TlsGetValue(dwTlsIndex);
 163     TlsSetValue(dwTlsIndex, NULL);
 164     return ret;
 165 }
 166
 167 LPVOID WINAPI I_CryptGetTls(DWORD dwTlsIndex)
 168 {
 169     return TlsGetValue(dwTlsIndex);
 170 }
 171
 172 BOOL WINAPI I_CryptSetTls(DWORD dwTlsIndex, LPVOID lpTlsValue)
 173 {
 174     return TlsSetValue(dwTlsIndex, lpTlsValue);
 175 }
 176
 177 BOOL WINAPI I_CryptFreeTls(DWORD dwTlsIndex, DWORD unknown)
 178 {
 179     BOOL ret;
 180
 181     TRACE("(%ld, %ld)\n", dwTlsIndex, unknown);
 182
 183     ret = TlsFree(dwTlsIndex);
 184     if (!ret) SetLastError( E_INVALIDARG );
 185     return ret;
 186 }
 187
 188 BOOL WINAPI I_CryptGetOssGlobal(DWORD x)
 189 {
 190     FIXME("%08lx\n", x);
 191     return FALSE;
 192 }
 193
 194 static BOOL is_supported_algid(HCRYPTPROV prov, ALG_ID algid)
 195 {
 196     PROV_ENUMALGS prov_algs;
 197     DWORD size = sizeof(prov_algs);
 198     BOOL ret = FALSE;
 199
 200     /* This enumeration is not thread safe */
 201     EnterCriticalSection(&prov_param_cs);
 202     if (CryptGetProvParam(prov, PP_ENUMALGS, (BYTE *)&prov_algs, &size, CRYPT_FIRST))
 203     {
 204         do
 205         {
 206             if (prov_algs.aiAlgid == algid)
 207             {
 208                 ret = TRUE;
 209                 break;
 210             }
 211         } while (CryptGetProvParam(prov, PP_ENUMALGS, (BYTE *)&prov_algs, &size, CRYPT_NEXT));
 212     }
 213     LeaveCriticalSection(&prov_param_cs);
 214     return ret;
 215 }
 216
 217 HCRYPTPROV WINAPI DECLSPEC_HOTPATCH I_CryptGetDefaultCryptProv(ALG_ID algid)
 218 {
 219     HCRYPTPROV prov, defprov;
 220
 221     TRACE("(%08x)\n", algid);
 222
 223     defprov = CRYPT_GetDefaultProvider();
 224
 225     if (algid && !is_supported_algid(defprov, algid))
 226     {
 227         DWORD i = 0, type, size;
 228
 229         while (CryptEnumProvidersW(i, NULL, 0, &type, NULL, &size))
 230         {
 231             WCHAR *name = CryptMemAlloc(size);
 232             if (name)
 233             {
 234                 if (CryptEnumProvidersW(i, NULL, 0, &type, name, &size))
 235                 {
 236                     if (CryptAcquireContextW(&prov, NULL, name, type, CRYPT_VERIFYCONTEXT))
 237                     {
 238                         if (is_supported_algid(prov, algid))
 239                         {
 240                             CryptMemFree(name);
 241                             return prov;
 242                         }
 243                         CryptReleaseContext(prov, 0);
 244                     }
 245                 }
 246                 CryptMemFree(name);
 247             }
 248             i++;
 249         }
 250
 251         SetLastError(E_INVALIDARG);
 252         return 0;
 253     }
 254
 255     CryptContextAddRef(defprov, NULL, 0);
 256     return defprov;
 257 }
 258
 259 BOOL WINAPI I_CryptReadTrustedPublisherDWORDValueFromRegistry(LPCWSTR name,
 260  DWORD *value)
 261 {
 262     HKEY key;
 263     LONG rc;
 264     BOOL ret = FALSE;
 265
 266     TRACE("(%s, %p)\n", debugstr_w(name), value);
 267
 268     *value = 0;
 269     rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, L"Software\\Policies\\Microsoft\\SystemCertificates\\TrustedPublisher\\Safer", &key);
 270     if (rc == ERROR_SUCCESS)
 271     {
 272         DWORD size = sizeof(DWORD);
 273
 274         if (!RegQueryValueExW(key, name, NULL, NULL, (LPBYTE)value, &size))
 275             ret = TRUE;
 276         RegCloseKey(key);
 277     }
 278     return ret;
 279 }
 280
 281 DWORD WINAPI I_CryptInstallOssGlobal(DWORD x, DWORD y, DWORD z)
 282 {
 283     static int ret = 8;
 284     ret++;
 285     FIXME("%08lx %08lx %08lx, return value %d\n", x, y, z,ret);
 286     return ret;
 287 }
 288
 289 BOOL WINAPI I_CryptInstallAsn1Module(ASN1module_t x, DWORD y, void* z)
 290 {
 291     FIXME("(%p %08lx %p): stub\n", x, y, z);
 292     return TRUE;
 293 }
 294
 295 BOOL WINAPI I_CryptUninstallAsn1Module(HCRYPTASN1MODULE x)
 296 {
 297     FIXME("(%08lx): stub\n", x);
 298     return TRUE;
 299 }
 300
 301 ASN1decoding_t WINAPI I_CryptGetAsn1Decoder(HCRYPTASN1MODULE x)
 302 {
 303     FIXME("(%08lx): stub\n", x);
 304     return NULL;
 305 }
 306
 307 ASN1encoding_t WINAPI I_CryptGetAsn1Encoder(HCRYPTASN1MODULE x)
 308 {
 309     FIXME("(%08lx): stub\n", x);
 310     return NULL;
 311 }
 312
 313 BOOL WINAPI CryptProtectMemory(void *data, DWORD len, DWORD flags)
 314 {
 315     static int fixme_once;
 316     if (!fixme_once++) FIXME("(%p %lu %08lx): stub\n", data, len, flags);
 317     return TRUE;
 318 }
 319
 320 BOOL WINAPI CryptUnprotectMemory(void *data, DWORD len, DWORD flags)
 321 {
 322     static int fixme_once;
 323     if (!fixme_once++) FIXME("(%p %lu %08lx): stub\n", data, len, flags);
 324     return TRUE;
 325 }