| /* |
| * crypt32 cert functions tests |
| * |
| * Copyright 2005 Juan Lang |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| #include <stdio.h> |
| #include <stdarg.h> |
| #include <windef.h> |
| #include <winbase.h> |
| #include <winreg.h> |
| #include <winerror.h> |
| #include <wincrypt.h> |
| |
| #include "wine/test.h" |
| |
| /* The following aren't defined in wincrypt.h, as they're "reserved" */ |
| #define CERT_CERT_PROP_ID 32 |
| #define CERT_CRL_PROP_ID 33 |
| #define CERT_CTL_PROP_ID 34 |
| |
| struct CertPropIDHeader |
| { |
| DWORD propID; |
| DWORD unknown1; |
| DWORD cb; |
| }; |
| |
| static void testCryptHashCert(void) |
| { |
| static const BYTE emptyHash[] = { 0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, |
| 0x0d, 0x32, 0x55, 0xbf, 0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, |
| 0x09 }; |
| static const BYTE knownHash[] = { 0xae, 0x9d, 0xbf, 0x6d, 0xf5, 0x46, 0xee, |
| 0x8b, 0xc5, 0x7a, 0x13, 0xba, 0xc2, 0xb1, 0x04, 0xf2, 0xbf, 0x52, 0xa8, |
| 0xa2 }; |
| static const BYTE toHash[] = "abcdefghijklmnopqrstuvwxyz0123456789.,;!?:"; |
| BOOL ret; |
| BYTE hash[20]; |
| DWORD hashLen = sizeof(hash); |
| |
| /* NULL buffer and nonzero length crashes |
| ret = CryptHashCertificate(0, 0, 0, NULL, size, hash, &hashLen); |
| empty hash length also crashes |
| ret = CryptHashCertificate(0, 0, 0, buf, size, hash, NULL); |
| */ |
| /* Test empty hash */ |
| ret = CryptHashCertificate(0, 0, 0, toHash, sizeof(toHash), NULL, |
| &hashLen); |
| ok(ret, "CryptHashCertificate failed: %08lx\n", GetLastError()); |
| ok(hashLen == sizeof(hash), |
| "Got unexpected size of hash %ld, expected %d\n", hashLen, sizeof(hash)); |
| /* Test with empty buffer */ |
| ret = CryptHashCertificate(0, 0, 0, NULL, 0, hash, &hashLen); |
| ok(ret, "CryptHashCertificate failed: %08lx\n", GetLastError()); |
| ok(!memcmp(hash, emptyHash, sizeof(emptyHash)), |
| "Unexpected hash of nothing\n"); |
| /* Test a known value */ |
| ret = CryptHashCertificate(0, 0, 0, toHash, sizeof(toHash), hash, |
| &hashLen); |
| ok(ret, "CryptHashCertificate failed: %08lx\n", GetLastError()); |
| ok(!memcmp(hash, knownHash, sizeof(knownHash)), "Unexpected hash\n"); |
| } |
| |
| static const BYTE emptyCert[] = { 0x30, 0x00 }; |
| static const BYTE bigCert[] = "\x30\x7a\x02\x01\x01\x30\x02\x06\x00" |
| "\x30\x15\x31\x13\x30\x11\x06\x03\x55\x04\x03\x13\x0a\x4a\x75\x61\x6e\x20\x4c" |
| "\x61\x6e\x67\x00\x30\x22\x18\x0f\x31\x36\x30\x31\x30\x31\x30\x31\x30\x30\x30" |
| "\x30\x30\x30\x5a\x18\x0f\x31\x36\x30\x31\x30\x31\x30\x31\x30\x30\x30\x30\x30" |
| "\x30\x5a\x30\x15\x31\x13\x30\x11\x06\x03\x55\x04\x03\x13\x0a\x4a\x75\x61\x6e" |
| "\x20\x4c\x61\x6e\x67\x00\x30\x07\x30\x02\x06\x00\x03\x01\x00\xa3\x16\x30\x14" |
| "\x30\x12\x06\x03\x55\x1d\x13\x01\x01\xff\x04\x08\x30\x06\x01\x01\xff\x02\x01" |
| "\x01"; |
| static const BYTE signedBigCert[] = { |
| 0x30, 0x81, 0x93, 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06, 0x00, 0x30, |
| 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, |
| 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x22, 0x18, 0x0f, |
| 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, |
| 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, |
| 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, |
| 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, |
| 0x6e, 0x67, 0x00, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00, 0xa3, |
| 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, |
| 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06, |
| 0x00, 0x03, 0x11, 0x00, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, |
| 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 }; |
| static const BYTE serializedCert[] = { 0x20, 0x00, 0x00, 0x00, |
| 0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x30, 0x7a, 0x02, 0x01, 0x01, |
| 0x30, 0x02, 0x06, 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, |
| 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, |
| 0x00, 0x30, 0x22, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, |
| 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, |
| 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x15, |
| 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, |
| 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x07, 0x30, 0x02, 0x06, |
| 0x00, 0x03, 0x01, 0x00, 0xa3, 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, |
| 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, |
| 0x01, 0x01 }; |
| |
| static void testMemStore(void) |
| { |
| HCERTSTORE store1, store2; |
| PCCERT_CONTEXT context; |
| BOOL ret; |
| |
| /* NULL provider */ |
| store1 = CertOpenStore(0, 0, 0, 0, NULL); |
| ok(!store1 && GetLastError() == ERROR_FILE_NOT_FOUND, |
| "Expected ERROR_FILE_NOT_FOUND, got %ld\n", GetLastError()); |
| /* weird flags */ |
| store1 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_DELETE_FLAG, NULL); |
| ok(!store1 && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED, |
| "Expected ERROR_CALL_NOT_IMPLEMENTED, got %ld\n", GetLastError()); |
| |
| /* normal */ |
| store1 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| ok(store1 != NULL, "CertOpenStore failed: %ld\n", GetLastError()); |
| /* open existing doesn't */ |
| store2 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_OPEN_EXISTING_FLAG, NULL); |
| ok(store2 != NULL, "CertOpenStore failed: %ld\n", GetLastError()); |
| ok(store1 != store2, "Expected different stores\n"); |
| |
| /* add a bogus (empty) cert */ |
| context = NULL; |
| ret = CertAddEncodedCertificateToStore(store1, X509_ASN_ENCODING, emptyCert, |
| sizeof(emptyCert), CERT_STORE_ADD_ALWAYS, &context); |
| /* Windows returns CRYPT_E_ASN1_EOD, but accept CRYPT_E_ASN1_CORRUPT as |
| * well (because matching errors is tough in this case) |
| */ |
| ok(!ret && (GetLastError() == CRYPT_E_ASN1_EOD || GetLastError() == |
| CRYPT_E_ASN1_CORRUPT), |
| "Expected CRYPT_E_ASN1_EOD or CRYPT_E_ASN1_CORRUPT, got %08lx\n", |
| GetLastError()); |
| /* add a signed cert (this also fails) */ |
| ok(!ret && (GetLastError() == CRYPT_E_ASN1_EOD || GetLastError() == |
| CRYPT_E_ASN1_CORRUPT), |
| "Expected CRYPT_E_ASN1_EOD or CRYPT_E_ASN1_CORRUPT, got %08lx\n", |
| GetLastError()); |
| ret = CertAddEncodedCertificateToStore(store1, X509_ASN_ENCODING, |
| signedBigCert, sizeof(signedBigCert) - 1, CERT_STORE_ADD_ALWAYS, &context); |
| /* add a cert to store1 */ |
| ret = CertAddEncodedCertificateToStore(store1, X509_ASN_ENCODING, bigCert, |
| sizeof(bigCert) - 1, CERT_STORE_ADD_ALWAYS, &context); |
| ok(ret, "CertAddEncodedCertificateToStore failed: %08lx\n", GetLastError()); |
| ok(context != NULL, "Expected a valid cert context\n"); |
| if (context) |
| { |
| DWORD size; |
| BYTE *buf; |
| |
| ok(context->cbCertEncoded == sizeof(bigCert) - 1, |
| "Expected cert of %d bytes, got %ld\n", sizeof(bigCert) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert, sizeof(bigCert) - 1), |
| "Unexpected encoded cert in context\n"); |
| ok(context->hCertStore == store1, "Unexpected store\n"); |
| |
| /* check serializing this element */ |
| /* These crash |
| ret = CertSerializeCertificateStoreElement(NULL, 0, NULL, NULL); |
| ret = CertSerializeCertificateStoreElement(context, 0, NULL, NULL); |
| ret = CertSerializeCertificateStoreElement(NULL, 0, NULL, &size); |
| */ |
| /* apparently flags are ignored */ |
| ret = CertSerializeCertificateStoreElement(context, 1, NULL, &size); |
| ok(ret, "CertSerializeCertificateStoreElement failed: %08lx\n", |
| GetLastError()); |
| buf = HeapAlloc(GetProcessHeap(), 0, size); |
| if (buf) |
| { |
| ret = CertSerializeCertificateStoreElement(context, 0, buf, &size); |
| ok(size == sizeof(serializedCert), "Expected size %d, got %ld\n", |
| sizeof(serializedCert), size); |
| ok(!memcmp(serializedCert, buf, size), |
| "Unexpected serialized cert\n"); |
| HeapFree(GetProcessHeap(), 0, buf); |
| } |
| |
| ret = CertFreeCertificateContext(context); |
| ok(ret, "CertFreeCertificateContext failed: %08lx\n", GetLastError()); |
| } |
| /* verify the cert's in store1 */ |
| context = CertEnumCertificatesInStore(store1, NULL); |
| ok(context != NULL, "Expected a valid context\n"); |
| context = CertEnumCertificatesInStore(store1, context); |
| ok(!context && GetLastError() == CRYPT_E_NOT_FOUND, |
| "Expected CRYPT_E_NOT_FOUND, got %08lx\n", GetLastError()); |
| /* verify store2 (the "open existing" mem store) is still empty */ |
| context = CertEnumCertificatesInStore(store2, NULL); |
| ok(!context, "Expected an empty store\n"); |
| /* delete the cert from store1, and check it's empty */ |
| context = CertEnumCertificatesInStore(store1, NULL); |
| if (context) |
| { |
| /* Deleting a bitwise copy crashes with an access to an uninitialized |
| * pointer, so a cert context has some special data out there in memory |
| * someplace |
| CERT_CONTEXT copy; |
| memcpy(©, context, sizeof(copy)); |
| ret = CertDeleteCertificateFromStore(©); |
| */ |
| PCCERT_CONTEXT copy = CertDuplicateCertificateContext(context); |
| |
| ok(copy != NULL, "CertDuplicateCertificateContext failed: %08lx\n", |
| GetLastError()); |
| ret = CertDeleteCertificateFromStore(context); |
| ok(ret, "CertDeleteCertificateFromStore failed: %08lx\n", |
| GetLastError()); |
| /* try deleting a copy */ |
| ret = CertDeleteCertificateFromStore(copy); |
| ok(ret, "CertDeleteCertificateFromStore failed: %08lx\n", |
| GetLastError()); |
| /* check that the store is empty */ |
| context = CertEnumCertificatesInStore(store1, NULL); |
| ok(!context, "Expected an empty store\n"); |
| } |
| |
| /* close an empty store */ |
| ret = CertCloseStore(NULL, 0); |
| ok(ret, "CertCloseStore failed: %ld\n", GetLastError()); |
| ret = CertCloseStore(store1, 0); |
| ok(ret, "CertCloseStore failed: %ld\n", GetLastError()); |
| ret = CertCloseStore(store2, 0); |
| ok(ret, "CertCloseStore failed: %ld\n", GetLastError()); |
| |
| /* This seems nonsensical, but you can open a read-only mem store, only |
| * it isn't read-only |
| */ |
| store1 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_READONLY_FLAG, NULL); |
| ok(store1 != NULL, "CertOpenStore failed: %ld\n", GetLastError()); |
| /* yep, this succeeds */ |
| ret = CertAddEncodedCertificateToStore(store1, X509_ASN_ENCODING, bigCert, |
| sizeof(bigCert) - 1, CERT_STORE_ADD_ALWAYS, &context); |
| ok(ret, "CertAddEncodedCertificateToStore failed: %08lx\n", GetLastError()); |
| ok(context != NULL, "Expected a valid cert context\n"); |
| if (context) |
| { |
| ok(context->cbCertEncoded == sizeof(bigCert) - 1, |
| "Expected cert of %d bytes, got %ld\n", sizeof(bigCert) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert, sizeof(bigCert) - 1), |
| "Unexpected encoded cert in context\n"); |
| ok(context->hCertStore == store1, "Unexpected store\n"); |
| ret = CertDeleteCertificateFromStore(context); |
| ok(ret, "CertDeleteCertificateFromStore failed: %08lx\n", |
| GetLastError()); |
| } |
| CertCloseStore(store1, 0); |
| } |
| |
| static const BYTE bigCert2[] = "\x30\x7a\x02\x01\x01\x30\x02\x06\x00" |
| "\x30\x15\x31\x13\x30\x11\x06\x03\x55\x04\x03\x13\x0a\x41\x6c\x65\x78\x20\x4c" |
| "\x61\x6e\x67\x00\x30\x22\x18\x0f\x31\x36\x30\x31\x30\x31\x30\x31\x30\x30\x30" |
| "\x30\x30\x30\x5a\x18\x0f\x31\x36\x30\x31\x30\x31\x30\x31\x30\x30\x30\x30\x30" |
| "\x30\x5a\x30\x15\x31\x13\x30\x11\x06\x03\x55\x04\x03\x13\x0a\x41\x6c\x65\x78" |
| "\x20\x4c\x61\x6e\x67\x00\x30\x07\x30\x02\x06\x00\x03\x01\x00\xa3\x16\x30\x14" |
| "\x30\x12\x06\x03\x55\x1d\x13\x01\x01\xff\x04\x08\x30\x06\x01\x01\xff\x02\x01" |
| "\x01"; |
| |
| static void testCollectionStore(void) |
| { |
| HCERTSTORE store1, store2, collection, collection2; |
| PCCERT_CONTEXT context; |
| BOOL ret; |
| |
| collection = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| |
| /* Try adding a cert to any empty collection */ |
| ret = CertAddEncodedCertificateToStore(collection, X509_ASN_ENCODING, |
| bigCert, sizeof(bigCert) - 1, CERT_STORE_ADD_ALWAYS, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED), |
| "Expected HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED), got %08lx\n", |
| GetLastError()); |
| |
| /* Create and add a cert to a memory store */ |
| store1 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| ret = CertAddEncodedCertificateToStore(store1, X509_ASN_ENCODING, |
| bigCert, sizeof(bigCert) - 1, CERT_STORE_ADD_ALWAYS, NULL); |
| ok(ret, "CertAddEncodedCertificateToStore failed: %08lx\n", GetLastError()); |
| /* Add the memory store to the collection, without allowing adding */ |
| ret = CertAddStoreToCollection(collection, store1, 0, 0); |
| ok(ret, "CertAddStoreToCollection failed: %08lx\n", GetLastError()); |
| /* Verify the cert is in the collection */ |
| context = CertEnumCertificatesInStore(collection, NULL); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection, "Unexpected store\n"); |
| CertFreeCertificateContext(context); |
| } |
| /* Check that adding to the collection isn't allowed */ |
| ret = CertAddEncodedCertificateToStore(collection, X509_ASN_ENCODING, |
| bigCert2, sizeof(bigCert2) - 1, CERT_STORE_ADD_ALWAYS, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED), |
| "Expected HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED), got %08lx\n", |
| GetLastError()); |
| |
| /* Create a new memory store */ |
| store2 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| /* Try adding a store to a non-collection store */ |
| ret = CertAddStoreToCollection(store1, store2, |
| CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| /* Try adding some bogus stores */ |
| /* This crashes in Windows |
| ret = CertAddStoreToCollection(0, store2, |
| CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0); |
| */ |
| /* This "succeeds"... */ |
| ret = CertAddStoreToCollection(collection, 0, |
| CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0); |
| ok(ret, "CertAddStoreToCollection failed: %08lx\n", GetLastError()); |
| /* while this crashes. |
| ret = CertAddStoreToCollection(collection, 1, |
| CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0); |
| */ |
| |
| /* Add it to the collection, this time allowing adding */ |
| ret = CertAddStoreToCollection(collection, store2, |
| CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0); |
| ok(ret, "CertAddStoreToCollection failed: %08lx\n", GetLastError()); |
| /* Check that adding to the collection is allowed */ |
| ret = CertAddEncodedCertificateToStore(collection, X509_ASN_ENCODING, |
| bigCert2, sizeof(bigCert2) - 1, CERT_STORE_ADD_ALWAYS, NULL); |
| ok(ret, "CertAddEncodedCertificateToStore failed: %08lx\n", GetLastError()); |
| /* Now check that it was actually added to store2 */ |
| context = CertEnumCertificatesInStore(store2, NULL); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == store2, "Unexpected store\n"); |
| CertFreeCertificateContext(context); |
| } |
| /* Check that the collection has both bigCert and bigCert2. bigCert comes |
| * first because store1 was added first. |
| */ |
| context = CertEnumCertificatesInStore(collection, NULL); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection, "Unexpected store\n"); |
| ok(context->cbCertEncoded == sizeof(bigCert) - 1, |
| "Expected size %d, got %ld\n", sizeof(bigCert) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert, context->cbCertEncoded), |
| "Unexpected cert\n"); |
| context = CertEnumCertificatesInStore(collection, context); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection, "Unexpected store\n"); |
| ok(context->cbCertEncoded == sizeof(bigCert2) - 1, |
| "Expected size %d, got %ld\n", sizeof(bigCert2) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert2, |
| context->cbCertEncoded), "Unexpected cert\n"); |
| context = CertEnumCertificatesInStore(collection, context); |
| ok(!context, "Unexpected cert\n"); |
| } |
| } |
| /* close store2, and check that the collection is unmodified */ |
| CertCloseStore(store2, 0); |
| context = CertEnumCertificatesInStore(collection, NULL); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection, "Unexpected store\n"); |
| ok(context->cbCertEncoded == sizeof(bigCert) - 1, |
| "Expected size %d, got %ld\n", sizeof(bigCert) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert, context->cbCertEncoded), |
| "Unexpected cert\n"); |
| context = CertEnumCertificatesInStore(collection, context); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection, "Unexpected store\n"); |
| ok(context->cbCertEncoded == sizeof(bigCert2) - 1, |
| "Expected size %d, got %ld\n", sizeof(bigCert2) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert2, |
| context->cbCertEncoded), "Unexpected cert\n"); |
| context = CertEnumCertificatesInStore(collection, context); |
| ok(!context, "Unexpected cert\n"); |
| } |
| } |
| |
| /* Adding a collection to a collection is legal */ |
| collection2 = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| ret = CertAddStoreToCollection(collection2, collection, |
| CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0); |
| ok(ret, "CertAddStoreToCollection failed: %08lx\n", GetLastError()); |
| /* check the contents of collection2 */ |
| context = CertEnumCertificatesInStore(collection2, NULL); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection2, "Unexpected store\n"); |
| ok(context->cbCertEncoded == sizeof(bigCert) - 1, |
| "Expected size %d, got %ld\n", sizeof(bigCert) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert, context->cbCertEncoded), |
| "Unexpected cert\n"); |
| context = CertEnumCertificatesInStore(collection2, context); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection2, "Unexpected store\n"); |
| ok(context->cbCertEncoded == sizeof(bigCert2) - 1, |
| "Expected size %d, got %ld\n", sizeof(bigCert2) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert2, |
| context->cbCertEncoded), "Unexpected cert\n"); |
| context = CertEnumCertificatesInStore(collection2, context); |
| ok(!context, "Unexpected cert\n"); |
| } |
| } |
| |
| /* I'd like to test closing the collection in the middle of enumeration, |
| * but my tests have been inconsistent. The first time calling |
| * CertEnumCertificatesInStore on a closed collection succeeded, while the |
| * second crashed. So anything appears to be fair game. |
| * I'd also like to test removing a store from a collection in the middle |
| * of an enumeration, but my tests in Windows have been inconclusive. |
| * In one scenario it worked. In another scenario, about a third of the |
| * time this leads to "random" crashes elsewhere in the code. This |
| * probably means this is not allowed. |
| */ |
| |
| CertCloseStore(store1, 0); |
| CertCloseStore(collection, 0); |
| CertCloseStore(collection2, 0); |
| |
| /* Add the same cert to two memory stores, then put them in a collection */ |
| store1 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| ok(store1 != 0, "CertOpenStore failed: %08lx\n", GetLastError()); |
| store2 = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| ok(store2 != 0, "CertOpenStore failed: %08lx\n", GetLastError()); |
| |
| ret = CertAddEncodedCertificateToStore(store1, X509_ASN_ENCODING, |
| bigCert, sizeof(bigCert) - 1, CERT_STORE_ADD_ALWAYS, NULL); |
| ok(ret, "CertAddEncodedCertificateToStore failed: %08lx\n", GetLastError()); |
| ret = CertAddEncodedCertificateToStore(store2, X509_ASN_ENCODING, |
| bigCert, sizeof(bigCert) - 1, CERT_STORE_ADD_ALWAYS, NULL); |
| ok(ret, "CertAddEncodedCertificateToStore failed: %08lx\n", GetLastError()); |
| collection = CertOpenStore(CERT_STORE_PROV_COLLECTION, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| ok(collection != 0, "CertOpenStore failed: %08lx\n", GetLastError()); |
| |
| ret = CertAddStoreToCollection(collection, store1, |
| CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0); |
| ok(ret, "CertAddStoreToCollection failed: %08lx\n", GetLastError()); |
| ret = CertAddStoreToCollection(collection, store2, |
| CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0); |
| ok(ret, "CertAddStoreToCollection failed: %08lx\n", GetLastError()); |
| |
| /* Check that the collection has two copies of the same cert */ |
| context = CertEnumCertificatesInStore(collection, NULL); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection, "Unexpected store\n"); |
| ok(context->cbCertEncoded == sizeof(bigCert) - 1, |
| "Expected size %d, got %ld\n", sizeof(bigCert) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert, context->cbCertEncoded), |
| "Unexpected cert\n"); |
| context = CertEnumCertificatesInStore(collection, context); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection, "Unexpected store\n"); |
| ok(context->cbCertEncoded == sizeof(bigCert) - 1, |
| "Expected size %d, got %ld\n", sizeof(bigCert) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert, context->cbCertEncoded), |
| "Unexpected cert\n"); |
| context = CertEnumCertificatesInStore(collection, context); |
| ok(context == NULL, "Unexpected cert\n"); |
| } |
| } |
| |
| /* The following would check whether I can delete an identical cert, rather |
| * than one enumerated from the store. It crashes, so that means I must |
| * only call CertDeleteCertificateFromStore with contexts enumerated from |
| * the store. |
| context = CertCreateCertificateContext(X509_ASN_ENCODING, bigCert, |
| sizeof(bigCert) - 1); |
| ok(context != NULL, "CertCreateCertificateContext failed: %08lx\n", |
| GetLastError()); |
| if (context) |
| { |
| ret = CertDeleteCertificateFromStore(collection, context); |
| printf("ret is %d, GetLastError is %08lx\n", ret, GetLastError()); |
| CertFreeCertificateContext(context); |
| } |
| */ |
| |
| /* Now check deleting from the collection. */ |
| context = CertEnumCertificatesInStore(collection, NULL); |
| ok(context != NULL, "Expected a valid context\n"); |
| if (context) |
| { |
| CertDeleteCertificateFromStore(context); |
| /* store1 should now be empty */ |
| context = CertEnumCertificatesInStore(store1, NULL); |
| ok(!context, "Unexpected cert\n"); |
| /* and there should be one certificate in the collection */ |
| context = CertEnumCertificatesInStore(collection, NULL); |
| ok(context != NULL, "Expected a valid cert\n"); |
| if (context) |
| { |
| ok(context->hCertStore == collection, "Unexpected store\n"); |
| ok(context->cbCertEncoded == sizeof(bigCert) - 1, |
| "Expected size %d, got %ld\n", sizeof(bigCert) - 1, |
| context->cbCertEncoded); |
| ok(!memcmp(context->pbCertEncoded, bigCert, context->cbCertEncoded), |
| "Unexpected cert\n"); |
| } |
| context = CertEnumCertificatesInStore(collection, context); |
| ok(context == NULL, "Unexpected cert\n"); |
| } |
| |
| /* Finally, test removing stores from the collection. No return value, so |
| * it's a bit funny to test. |
| */ |
| /* This crashes |
| CertRemoveStoreFromCollection(NULL, NULL); |
| */ |
| /* This "succeeds," no crash, no last error set */ |
| SetLastError(0xdeadbeef); |
| CertRemoveStoreFromCollection(store2, collection); |
| ok(GetLastError() == 0xdeadbeef, |
| "Didn't expect an error to be set: %08lx\n", GetLastError()); |
| |
| /* After removing store2, the collection should be empty */ |
| SetLastError(0xdeadbeef); |
| CertRemoveStoreFromCollection(collection, store2); |
| ok(GetLastError() == 0xdeadbeef, |
| "Didn't expect an error to be set: %08lx\n", GetLastError()); |
| context = CertEnumCertificatesInStore(collection, NULL); |
| ok(!context, "Unexpected cert\n"); |
| |
| CertCloseStore(collection, 0); |
| CertCloseStore(store2, 0); |
| CertCloseStore(store1, 0); |
| } |
| |
| static void testCertProperties(void) |
| { |
| PCCERT_CONTEXT context = CertCreateCertificateContext(X509_ASN_ENCODING, |
| bigCert, sizeof(bigCert) - 1); |
| |
| ok(context != NULL, "CertCreateCertificateContext failed: %08lx\n", |
| GetLastError()); |
| if (context) |
| { |
| DWORD propID, numProps, access, size; |
| BOOL ret; |
| BYTE hash[20] = { 0 }, hashProperty[20]; |
| CRYPT_DATA_BLOB blob; |
| |
| /* This crashes |
| propID = CertEnumCertificateContextProperties(NULL, 0); |
| */ |
| |
| propID = 0; |
| numProps = 0; |
| do { |
| propID = CertEnumCertificateContextProperties(context, propID); |
| if (propID) |
| numProps++; |
| } while (propID != 0); |
| ok(numProps == 0, "Expected 0 properties, got %ld\n", numProps); |
| |
| /* Tests with a NULL cert context. Prop ID 0 fails.. */ |
| ret = CertSetCertificateContextProperty(NULL, 0, 0, NULL); |
| ok(!ret && GetLastError() == |
| HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| /* while this just crashes. |
| ret = CertSetCertificateContextProperty(NULL, |
| CERT_KEY_PROV_HANDLE_PROP_ID, 0, NULL); |
| */ |
| |
| ret = CertSetCertificateContextProperty(context, 0, 0, NULL); |
| ok(!ret && GetLastError() == |
| HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| /* Can't set the cert property directly, this crashes. |
| ret = CertSetCertificateContextProperty(context, |
| CERT_CERT_PROP_ID, 0, bigCert2); |
| */ |
| |
| /* This crashes. |
| ret = CertGetCertificateContextProperty(context, |
| CERT_ACCESS_STATE_PROP_ID, 0, NULL); |
| */ |
| size = sizeof(access); |
| ret = CertGetCertificateContextProperty(context, |
| CERT_ACCESS_STATE_PROP_ID, &access, &size); |
| ok(ret, "CertGetCertificateContextProperty failed: %08lx\n", |
| GetLastError()); |
| ok(!(access & CERT_ACCESS_STATE_WRITE_PERSIST_FLAG), |
| "Didn't expect a persisted cert\n"); |
| /* Trying to set this "read only" property crashes. |
| access |= CERT_ACCESS_STATE_WRITE_PERSIST_FLAG; |
| ret = CertSetCertificateContextProperty(context, |
| CERT_ACCESS_STATE_PROP_ID, 0, &access); |
| */ |
| |
| /* Can I set the hash to an invalid hash? */ |
| blob.pbData = hash; |
| blob.cbData = sizeof(hash); |
| ret = CertSetCertificateContextProperty(context, CERT_HASH_PROP_ID, 0, |
| &blob); |
| ok(ret, "CertSetCertificateContextProperty failed: %08lx\n", |
| GetLastError()); |
| size = sizeof(hashProperty); |
| ret = CertGetCertificateContextProperty(context, CERT_HASH_PROP_ID, |
| hashProperty, &size); |
| ok(!memcmp(hashProperty, hash, sizeof(hash)), "Unexpected hash\n"); |
| /* Delete the (bogus) hash, and get the real one */ |
| ret = CertSetCertificateContextProperty(context, CERT_HASH_PROP_ID, 0, |
| NULL); |
| ok(ret, "CertSetCertificateContextProperty failed: %08lx\n", |
| GetLastError()); |
| size = sizeof(hash); |
| ret = CryptHashCertificate(0, 0, 0, bigCert, sizeof(bigCert) - 1, |
| hash, &size); |
| ok(ret, "CryptHashCertificate failed: %08lx\n", GetLastError()); |
| ret = CertGetCertificateContextProperty(context, CERT_HASH_PROP_ID, |
| hashProperty, &size); |
| ok(ret, "CertGetCertificateContextProperty failed: %08lx\n", |
| GetLastError()); |
| ok(!memcmp(hash, hashProperty, sizeof(hash)), "Unexpected hash\n"); |
| |
| /* Now that the hash property is set, we should get one property when |
| * enumerating. |
| */ |
| propID = 0; |
| numProps = 0; |
| do { |
| propID = CertEnumCertificateContextProperties(context, propID); |
| if (propID) |
| numProps++; |
| } while (propID != 0); |
| ok(numProps == 1, "Expected 1 properties, got %ld\n", numProps); |
| |
| CertFreeCertificateContext(context); |
| } |
| } |
| |
| static void testAddSerialized(void) |
| { |
| BOOL ret; |
| HCERTSTORE store; |
| BYTE buf[sizeof(struct CertPropIDHeader) * 2 + 20 + sizeof(bigCert) - 1] = |
| { 0 }; |
| BYTE hash[20]; |
| struct CertPropIDHeader *hdr; |
| PCCERT_CONTEXT context; |
| |
| ret = CertAddSerializedElementToStore(0, NULL, 0, 0, 0, 0, NULL, NULL); |
| ok(!ret && GetLastError() == ERROR_END_OF_MEDIA, |
| "Expected ERROR_END_OF_MEDIA, got %08lx\n", GetLastError()); |
| |
| store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| ok(store != 0, "CertOpenStore failed: %08lx\n", GetLastError()); |
| |
| ret = CertAddSerializedElementToStore(store, NULL, 0, 0, 0, 0, NULL, NULL); |
| ok(!ret && GetLastError() == ERROR_END_OF_MEDIA, |
| "Expected ERROR_END_OF_MEDIA, got %08lx\n", GetLastError()); |
| |
| /* Test with an empty property */ |
| hdr = (struct CertPropIDHeader *)buf; |
| hdr->propID = CERT_CERT_PROP_ID; |
| hdr->unknown1 = 1; |
| hdr->cb = 0; |
| ret = CertAddSerializedElementToStore(store, buf, sizeof(buf), 0, 0, 0, |
| NULL, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| /* Test with a bad size in property header */ |
| hdr->cb = sizeof(bigCert) - 2; |
| memcpy(buf + sizeof(struct CertPropIDHeader), bigCert, sizeof(bigCert) - 1); |
| ret = CertAddSerializedElementToStore(store, buf, sizeof(buf), 0, 0, 0, |
| NULL, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, 0, 0, 0, NULL, |
| NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, CERT_STORE_ADD_NEW, |
| 0, 0, NULL, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| /* Kosher size in property header, but no context type */ |
| hdr->cb = sizeof(bigCert) - 1; |
| ret = CertAddSerializedElementToStore(store, buf, sizeof(buf), 0, 0, 0, |
| NULL, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, 0, 0, 0, NULL, |
| NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, CERT_STORE_ADD_NEW, |
| 0, 0, NULL, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| /* With a bad context type */ |
| ret = CertAddSerializedElementToStore(store, buf, sizeof(buf), 0, 0, |
| CERT_STORE_CRL_CONTEXT_FLAG, NULL, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, 0, 0, |
| CERT_STORE_CRL_CONTEXT_FLAG, NULL, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, CERT_STORE_ADD_NEW, |
| 0, CERT_STORE_CRL_CONTEXT_FLAG, NULL, NULL); |
| ok(!ret && GetLastError() == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), |
| "Expected HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got %08lx\n", |
| GetLastError()); |
| /* Bad unknown field, good type */ |
| hdr->unknown1 = 2; |
| ret = CertAddSerializedElementToStore(store, buf, sizeof(buf), 0, 0, |
| CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, NULL); |
| ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, |
| "Expected ERROR_FILE_NOT_FOUND got %08lx\n", GetLastError()); |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, 0, 0, |
| CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, NULL); |
| ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, |
| "Expected ERROR_FILE_NOT_FOUND got %08lx\n", GetLastError()); |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, CERT_STORE_ADD_NEW, |
| 0, CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, NULL); |
| ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, |
| "Expected ERROR_FILE_NOT_FOUND got %08lx\n", GetLastError()); |
| /* Most everything okay, but bad add disposition */ |
| hdr->unknown1 = 1; |
| /* This crashes |
| ret = CertAddSerializedElementToStore(store, buf, sizeof(buf), 0, 0, |
| CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, NULL); |
| * as does this |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, 0, 0, |
| CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, NULL); |
| */ |
| /* Everything okay, but buffer's too big */ |
| ret = CertAddSerializedElementToStore(store, buf, sizeof(buf), |
| CERT_STORE_ADD_NEW, 0, CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, NULL); |
| ok(ret, "CertAddSerializedElementToStore failed: %08lx\n", GetLastError()); |
| /* Everything okay, check it's not re-added */ |
| ret = CertAddSerializedElementToStore(store, buf, |
| sizeof(struct CertPropIDHeader) + sizeof(bigCert) - 1, CERT_STORE_ADD_NEW, |
| 0, CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, NULL); |
| ok(!ret && GetLastError() == CRYPT_E_EXISTS, |
| "Expected CRYPT_E_EXISTS, got %08lx\n", GetLastError()); |
| |
| context = CertEnumCertificatesInStore(store, NULL); |
| ok(context != NULL, "Expected a cert\n"); |
| if (context) |
| CertDeleteCertificateFromStore(context); |
| |
| /* Try adding with a bogus hash. Oddly enough, it succeeds, and the hash, |
| * when queried, is the real hash rather than the bogus hash. |
| */ |
| hdr = (struct CertPropIDHeader *)(buf + sizeof(struct CertPropIDHeader) + |
| sizeof(bigCert) - 1); |
| hdr->propID = CERT_HASH_PROP_ID; |
| hdr->unknown1 = 1; |
| hdr->cb = sizeof(hash); |
| memset(hash, 0xc, sizeof(hash)); |
| memcpy((LPBYTE)hdr + sizeof(struct CertPropIDHeader), hash, sizeof(hash)); |
| ret = CertAddSerializedElementToStore(store, buf, sizeof(buf), |
| CERT_STORE_ADD_NEW, 0, CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, |
| (const void **)&context); |
| ok(ret, "CertAddSerializedElementToStore failed: %08lx\n", GetLastError()); |
| if (context) |
| { |
| BYTE hashVal[20], realHash[20]; |
| DWORD size = sizeof(hashVal); |
| |
| ret = CryptHashCertificate(0, 0, 0, bigCert, sizeof(bigCert) - 1, |
| realHash, &size); |
| ok(ret, "CryptHashCertificate failed: %08lx\n", GetLastError()); |
| ret = CertGetCertificateContextProperty(context, CERT_HASH_PROP_ID, |
| hashVal, &size); |
| ok(ret, "CertGetCertificateContextProperty failed: %08lx\n", |
| GetLastError()); |
| ok(!memcmp(hashVal, realHash, size), "Unexpected hash\n"); |
| } |
| |
| CertCloseStore(store, 0); |
| } |
| |
| START_TEST(cert) |
| { |
| testCryptHashCert(); |
| |
| /* various combinations of CertOpenStore */ |
| testMemStore(); |
| testCollectionStore(); |
| |
| testCertProperties(); |
| testAddSerialized(); |
| } |
