git.oblomov.eu Git - wine/blob - dlls/crypt32/tests/main.c

   1 /*
   2  * Miscellaneous crypt32 tests
   3  *
   4  * Copyright 2005 Juan Lang
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdarg.h>
  23 #include <windef.h>
  24 #include <winbase.h>
  25 #include <winerror.h>
  26 #include <wincrypt.h>
  27
  28 #include "wine/test.h"
  29
  30 struct OIDToAlgID
  31 {
  32     LPCSTR oid;
  33     DWORD algID;
  34 };
  35
  36 static const struct OIDToAlgID oidToAlgID[] = {
  37  { szOID_RSA_RSA, CALG_RSA_KEYX },
  38  { szOID_RSA_MD2RSA, CALG_MD2 },
  39  { szOID_RSA_MD4RSA, CALG_MD4 },
  40  { szOID_RSA_MD5RSA, CALG_MD5 },
  41  { szOID_RSA_SHA1RSA, CALG_SHA },
  42  { szOID_RSA_DH, CALG_DH_SF },
  43  { szOID_RSA_SMIMEalgESDH, CALG_DH_EPHEM },
  44  { szOID_RSA_SMIMEalgCMS3DESwrap, CALG_3DES },
  45  { szOID_RSA_SMIMEalgCMSRC2wrap, CALG_RC2 },
  46  { szOID_RSA_MD2, CALG_MD2 },
  47  { szOID_RSA_MD4, CALG_MD4 },
  48  { szOID_RSA_MD5, CALG_MD5 },
  49  { szOID_RSA_RC2CBC, CALG_RC2 },
  50  { szOID_RSA_RC4, CALG_RC4 },
  51  { szOID_RSA_DES_EDE3_CBC, CALG_3DES },
  52  { szOID_ANSI_X942_DH, CALG_DH_SF },
  53  { szOID_X957_DSA, CALG_DSS_SIGN },
  54  { szOID_X957_SHA1DSA, CALG_SHA },
  55  { szOID_OIWSEC_md4RSA, CALG_MD4 },
  56  { szOID_OIWSEC_md5RSA, CALG_MD5 },
  57  { szOID_OIWSEC_md4RSA2, CALG_MD4 },
  58  { szOID_OIWSEC_desCBC, CALG_DES },
  59  { szOID_OIWSEC_dsa, CALG_DSS_SIGN },
  60  { szOID_OIWSEC_shaDSA, CALG_SHA },
  61  { szOID_OIWSEC_shaRSA, CALG_SHA },
  62  { szOID_OIWSEC_sha, CALG_SHA },
  63  { szOID_OIWSEC_rsaXchg, CALG_RSA_KEYX },
  64  { szOID_OIWSEC_sha1, CALG_SHA },
  65  { szOID_OIWSEC_dsaSHA1, CALG_SHA },
  66  { szOID_OIWSEC_sha1RSASign, CALG_SHA },
  67  { szOID_OIWDIR_md2RSA, CALG_MD2 },
  68  { szOID_INFOSEC_mosaicUpdatedSig, CALG_SHA },
  69  { szOID_INFOSEC_mosaicKMandUpdSig, CALG_DSS_SIGN },
  70 };
  71
  72 static const struct OIDToAlgID algIDToOID[] = {
  73  { szOID_RSA_RSA, CALG_RSA_KEYX },
  74  { szOID_RSA_SMIMEalgESDH, CALG_DH_EPHEM },
  75  { szOID_RSA_MD2, CALG_MD2 },
  76  { szOID_RSA_MD4, CALG_MD4 },
  77  { szOID_RSA_MD5, CALG_MD5 },
  78  { szOID_RSA_RC2CBC, CALG_RC2 },
  79  { szOID_RSA_RC4, CALG_RC4 },
  80  { szOID_RSA_DES_EDE3_CBC, CALG_3DES },
  81  { szOID_ANSI_X942_DH, CALG_DH_SF },
  82  { szOID_X957_DSA, CALG_DSS_SIGN },
  83  { szOID_OIWSEC_desCBC, CALG_DES },
  84  { szOID_OIWSEC_sha1, CALG_SHA },
  85 };
  86
  87 static void testOIDToAlgID(void)
  88 {
  89     int i;
  90     DWORD alg;
  91
  92     /* Test with a bogus one */
  93     SetLastError(0xdeadbeef);
  94     alg = CertOIDToAlgId("1.2.3");
  95     ok(!alg && (GetLastError() == 0xdeadbeef ||
  96      GetLastError() == ERROR_RESOURCE_NAME_NOT_FOUND),
  97      "Expected ERROR_RESOURCE_NAME_NOT_FOUND or no error set, got %08lx\n",
  98      GetLastError());
  99
 100     for (i = 0; i < sizeof(oidToAlgID) / sizeof(oidToAlgID[0]); i++)
 101     {
 102         alg = CertOIDToAlgId(oidToAlgID[i].oid);
 103         /* Not all Windows installations support all these, so make sure it's
 104          * at least not the wrong one.
 105          */
 106         ok(alg == 0 || alg == oidToAlgID[i].algID,
 107          "Expected %ld, got %ld\n", oidToAlgID[i].algID, alg);
 108     }
 109 }
 110
 111 static void testAlgIDToOID(void)
 112 {
 113     int i;
 114     LPCSTR oid;
 115
 116     /* Test with a bogus one */
 117     SetLastError(0xdeadbeef);
 118     oid = CertAlgIdToOID(ALG_CLASS_SIGNATURE | ALG_TYPE_ANY | 80);
 119     ok(!oid && GetLastError() == 0xdeadbeef,
 120      "Didn't expect last error (%08lx) to be set\n", GetLastError());
 121     for (i = 0; i < sizeof(algIDToOID) / sizeof(algIDToOID[0]); i++)
 122     {
 123         oid = CertAlgIdToOID(algIDToOID[i].algID);
 124         /* Allow failure, not every version of Windows supports every algo */
 125         if (oid)
 126             ok(!strcmp(oid, algIDToOID[i].oid),
 127              "Expected %s, got %s\n", algIDToOID[i].oid, oid);
 128     }
 129 }
 130
 131 static void test_findAttribute(void)
 132 {
 133     PCRYPT_ATTRIBUTE ret;
 134     BYTE blobbin[] = {0x02,0x01,0x01};
 135     CRYPT_ATTR_BLOB blobs[] = { { sizeof blobbin, blobbin }, };
 136     CRYPT_ATTRIBUTE attr = { "1.2.3", sizeof(blobs) / sizeof(blobs[0]), blobs };
 137
 138     /* returns NULL, last error not set */
 139     SetLastError(0xdeadbeef);
 140     ret = CertFindAttribute(NULL, 0, NULL);
 141     ok(ret == NULL, "Expected failure\n");
 142     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08lx\n",
 143      GetLastError());
 144     /* crashes
 145     SetLastError(0xdeadbeef);
 146     ret = CertFindAttribute(NULL, 1, NULL);
 147      */
 148     /* returns NULL, last error is ERROR_INVALID_PARAMETER */
 149     SetLastError(0xdeadbeef);
 150     ret = CertFindAttribute(NULL, 1, &attr);
 151     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 152      "Expected ERROR_INVALID_PARAMETER, got %ld (%08lx)\n", GetLastError(),
 153      GetLastError());
 154     /* returns NULL, last error not set */
 155     SetLastError(0xdeadbeef);
 156     ret = CertFindAttribute("bogus", 1, &attr);
 157     ok(ret == NULL, "Expected failure\n");
 158     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08lx\n",
 159      GetLastError());
 160     /* returns NULL, last error not set */
 161     SetLastError(0xdeadbeef);
 162     ret = CertFindAttribute("1.2.4", 1, &attr);
 163     ok(ret == NULL, "Expected failure\n");
 164     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08lx\n",
 165      GetLastError());
 166     /* succeeds, last error not set */
 167     SetLastError(0xdeadbeef);
 168     ret = CertFindAttribute("1.2.3", 1, &attr);
 169     ok(ret != NULL, "CertFindAttribute failed: %08lx\n", GetLastError());
 170 }
 171
 172 static void test_findExtension(void)
 173 {
 174     PCERT_EXTENSION ret;
 175     BYTE blobbin[] = {0x02,0x01,0x01};
 176     CERT_EXTENSION ext = { "1.2.3", TRUE, { sizeof blobbin, blobbin } };
 177
 178     /* returns NULL, last error not set */
 179     SetLastError(0xdeadbeef);
 180     ret = CertFindExtension(NULL, 0, NULL);
 181     ok(ret == NULL, "Expected failure\n");
 182     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08lx\n",
 183      GetLastError());
 184     /* crashes
 185     SetLastError(0xdeadbeef);
 186     ret = CertFindExtension(NULL, 1, NULL);
 187      */
 188     /* returns NULL, last error is ERROR_INVALID_PARAMETER */
 189     SetLastError(0xdeadbeef);
 190     ret = CertFindExtension(NULL, 1, &ext);
 191     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 192      "Expected ERROR_INVALID_PARAMETER, got %ld (%08lx)\n", GetLastError(),
 193      GetLastError());
 194     /* returns NULL, last error not set */
 195     SetLastError(0xdeadbeef);
 196     ret = CertFindExtension("bogus", 1, &ext);
 197     ok(ret == NULL, "Expected failure\n");
 198     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08lx\n",
 199      GetLastError());
 200     /* returns NULL, last error not set */
 201     SetLastError(0xdeadbeef);
 202     ret = CertFindExtension("1.2.4", 1, &ext);
 203     ok(ret == NULL, "Expected failure\n");
 204     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08lx\n",
 205      GetLastError());
 206     /* succeeds, last error not set */
 207     SetLastError(0xdeadbeef);
 208     ret = CertFindExtension("1.2.3", 1, &ext);
 209     ok(ret != NULL, "CertFindExtension failed: %08lx\n", GetLastError());
 210 }
 211
 212 static void test_findRDNAttr(void)
 213 {
 214     PCERT_RDN_ATTR ret;
 215     BYTE bin[] = { 0x16,0x09,'J','u','a','n',' ','L','a','n','g' };
 216     CERT_RDN_ATTR attrs[] = {
 217      { "1.2.3", CERT_RDN_IA5_STRING, { sizeof bin, bin } },
 218     };
 219     CERT_RDN rdns[] = {
 220      { sizeof(attrs) / sizeof(attrs[0]), attrs },
 221     };
 222     CERT_NAME_INFO nameInfo = { sizeof(rdns) / sizeof(rdns[0]), rdns };
 223
 224     /* crashes
 225     SetLastError(0xdeadbeef);
 226     ret = CertFindRDNAttr(NULL, NULL);
 227      */
 228     /* returns NULL, last error is ERROR_INVALID_PARAMETER */
 229     SetLastError(0xdeadbeef);
 230     ret = CertFindRDNAttr(NULL, &nameInfo);
 231     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 232      "Expected ERROR_INVALID_PARAMETER, got %ld (%08lx)\n", GetLastError(),
 233      GetLastError());
 234     /* returns NULL, last error not set */
 235     SetLastError(0xdeadbeef);
 236     ret = CertFindRDNAttr("bogus", &nameInfo);
 237     ok(ret == NULL, "Expected failure\n");
 238     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08lx\n",
 239      GetLastError());
 240     /* returns NULL, last error not set */
 241     SetLastError(0xdeadbeef);
 242     ret = CertFindRDNAttr("1.2.4", &nameInfo);
 243     ok(ret == NULL, "Expected failure\n");
 244     ok(GetLastError() == 0xdeadbeef, "Last error was set to %08lx\n",
 245      GetLastError());
 246     /* succeeds, last error not set */
 247     SetLastError(0xdeadbeef);
 248     ret = CertFindRDNAttr("1.2.3", &nameInfo);
 249     ok(ret != NULL, "CertFindRDNAttr failed: %08lx\n", GetLastError());
 250 }
 251
 252 static void test_verifyTimeValidity(void)
 253 {
 254     SYSTEMTIME sysTime;
 255     FILETIME fileTime;
 256     CERT_INFO info = { 0 };
 257     LONG ret;
 258
 259     GetSystemTime(&sysTime);
 260     SystemTimeToFileTime(&sysTime, &fileTime);
 261     /* crashes
 262     ret = CertVerifyTimeValidity(NULL, NULL);
 263     ret = CertVerifyTimeValidity(&fileTime, NULL);
 264      */
 265     /* Check with 0 NotBefore and NotAfter */
 266     ret = CertVerifyTimeValidity(&fileTime, &info);
 267     ok(ret == 1, "Expected 1, got %ld\n", ret);
 268     memcpy(&info.NotAfter, &fileTime, sizeof(info.NotAfter));
 269     /* Check with NotAfter equal to comparison time */
 270     ret = CertVerifyTimeValidity(&fileTime, &info);
 271     ok(ret == 0, "Expected 0, got %ld\n", ret);
 272     /* Check with NotBefore after comparison time */
 273     memcpy(&info.NotBefore, &fileTime, sizeof(info.NotBefore));
 274     info.NotBefore.dwLowDateTime += 5000;
 275     ret = CertVerifyTimeValidity(&fileTime, &info);
 276     ok(ret == -1, "Expected -1, got %ld\n", ret);
 277 }
 278
 279 static void test_cryptAllocate(void)
 280 {
 281     LPVOID buf;
 282
 283     buf = CryptMemAlloc(0);
 284     ok(buf != NULL, "CryptMemAlloc failed: %08lx\n", GetLastError());
 285     CryptMemFree(buf);
 286     buf = CryptMemRealloc(NULL, 0);
 287     ok(!buf, "Expected NULL\n");
 288     buf = CryptMemAlloc(0);
 289     buf = CryptMemRealloc(buf, 1);
 290     ok(buf != NULL, "CryptMemRealloc failed: %08lx\n", GetLastError());
 291     CryptMemFree(buf);
 292 }
 293
 294 typedef DWORD  (WINAPI *I_CryptAllocTlsFunc)(void);
 295 typedef LPVOID (WINAPI *I_CryptDetachTlsFunc)(DWORD dwTlsIndex);
 296 typedef LPVOID (WINAPI *I_CryptGetTlsFunc)(DWORD dwTlsIndex);
 297 typedef BOOL   (WINAPI *I_CryptSetTlsFunc)(DWORD dwTlsIndex, LPVOID lpTlsValue);
 298 typedef BOOL   (WINAPI *I_CryptFreeTlsFunc)(DWORD dwTlsIndex, DWORD unknown);
 299
 300 static I_CryptAllocTlsFunc pI_CryptAllocTls;
 301 static I_CryptDetachTlsFunc pI_CryptDetachTls;
 302 static I_CryptGetTlsFunc pI_CryptGetTls;
 303 static I_CryptSetTlsFunc pI_CryptSetTls;
 304 static I_CryptFreeTlsFunc pI_CryptFreeTls;
 305
 306 static void test_cryptTls(void)
 307 {
 308     HMODULE lib = LoadLibraryA("crypt32.dll");
 309
 310     if (lib)
 311     {
 312         DWORD index;
 313         BOOL ret;
 314
 315         pI_CryptAllocTls = (I_CryptAllocTlsFunc)GetProcAddress(lib,
 316          "I_CryptAllocTls");
 317         pI_CryptDetachTls = (I_CryptDetachTlsFunc)GetProcAddress(lib,
 318          "I_CryptDetachTls");
 319         pI_CryptGetTls = (I_CryptGetTlsFunc)GetProcAddress(lib,
 320          "I_CryptGetTls");
 321         pI_CryptSetTls = (I_CryptSetTlsFunc)GetProcAddress(lib,
 322          "I_CryptSetTls");
 323         pI_CryptFreeTls = (I_CryptFreeTlsFunc)GetProcAddress(lib,
 324          "I_CryptFreeTls");
 325
 326         /* One normal pass */
 327         index = pI_CryptAllocTls();
 328         ok(index, "I_CryptAllocTls failed: %08lx\n", GetLastError());
 329         if (index)
 330         {
 331             LPVOID ptr;
 332
 333             ptr = pI_CryptGetTls(index);
 334             ok(!ptr, "Expected NULL\n");
 335             ret = pI_CryptSetTls(index, (LPVOID)0xdeadbeef);
 336             ok(ret, "I_CryptSetTls failed: %08lx\n", GetLastError());
 337             ptr = pI_CryptGetTls(index);
 338             ok(ptr == (LPVOID)0xdeadbeef, "Expected 0xdeadbeef, got %p\n", ptr);
 339             /* This crashes
 340             ret = pI_CryptFreeTls(index, 1);
 341              */
 342             ret = pI_CryptFreeTls(index, 0);
 343             ok(ret, "I_CryptFreeTls failed: %08lx\n", GetLastError());
 344             ret = pI_CryptFreeTls(index, 0);
 345             /* Not sure if this fails because TlsFree should fail, so leave as
 346              * todo for now.
 347              */
 348             todo_wine ok(!ret && GetLastError() ==
 349              HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER),
 350              "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n",
 351              GetLastError());
 352         }
 353         /* Similar pass, check I_CryptDetachTls */
 354         index = pI_CryptAllocTls();
 355         ok(index, "I_CryptAllocTls failed: %08lx\n", GetLastError());
 356         if (index)
 357         {
 358             LPVOID ptr;
 359
 360             ptr = pI_CryptGetTls(index);
 361             ok(!ptr, "Expected NULL\n");
 362             ret = pI_CryptSetTls(index, (LPVOID)0xdeadbeef);
 363             ok(ret, "I_CryptSetTls failed: %08lx\n", GetLastError());
 364             ptr = pI_CryptGetTls(index);
 365             ok(ptr == (LPVOID)0xdeadbeef, "Expected 0xdeadbeef, got %p\n", ptr);
 366             ptr = pI_CryptDetachTls(index);
 367             ok(ptr == (LPVOID)0xdeadbeef, "Expected 0xdeadbeef, got %p\n", ptr);
 368             ptr = pI_CryptGetTls(index);
 369             ok(!ptr, "Expected NULL\n");
 370         }
 371         FreeLibrary(lib);
 372     }
 373 }
 374
 375 START_TEST(main)
 376 {
 377     testOIDToAlgID();
 378     testAlgIDToOID();
 379     test_findAttribute();
 380     test_findExtension();
 381     test_findRDNAttr();
 382     test_verifyTimeValidity();
 383     test_cryptAllocate();
 384     test_cryptTls();
 385 }