2 * crypt32 cert store function tests
4 * Copyright 2005-2006 Juan Lang
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.
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.
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
30 #include "wine/test.h"
32 /* The following aren't defined in wincrypt.h, as they're "reserved" */
33 #define CERT_CERT_PROP_ID 32
34 #define CERT_CRL_PROP_ID 33
35 #define CERT_CTL_PROP_ID 34
37 struct CertPropIDHeader
44 static const BYTE emptyCert
[] = { 0x30, 0x00 };
45 static const BYTE bigCert
[] = { 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
46 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
47 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x22,
48 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30,
49 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30,
50 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x15, 0x31, 0x13, 0x30,
51 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20,
52 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01,
53 0x00, 0xa3, 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01,
54 0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
55 static const BYTE signedBigCert
[] = {
56 0x30, 0x81, 0x93, 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06, 0x00, 0x30,
57 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a,
58 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x22, 0x18, 0x0f,
59 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30,
60 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30,
61 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06,
62 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61,
63 0x6e, 0x67, 0x00, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00, 0xa3,
64 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff,
65 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
66 0x00, 0x03, 0x11, 0x00, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07,
67 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 };
68 static const BYTE serializedCert
[] = { 0x20, 0x00, 0x00, 0x00,
69 0x01, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x30, 0x7a, 0x02, 0x01, 0x01,
70 0x30, 0x02, 0x06, 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55,
71 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67,
72 0x00, 0x30, 0x22, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31,
73 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31,
74 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x15,
75 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75,
76 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x07, 0x30, 0x02, 0x06,
77 0x00, 0x03, 0x01, 0x00, 0xa3, 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55,
78 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02,
80 static const BYTE signedCRL
[] = { 0x30, 0x45, 0x30, 0x2c, 0x30, 0x02, 0x06,
81 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
82 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x18, 0x0f,
83 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30,
84 0x30, 0x5a, 0x30, 0x02, 0x06, 0x00, 0x03, 0x11, 0x00, 0x0f, 0x0e, 0x0d, 0x0c,
85 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 };
86 static const BYTE bigCert2
[] = { 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
87 0x00, 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13,
88 0x0a, 0x41, 0x6c, 0x65, 0x78, 0x20, 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x22,
89 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30,
90 0x30, 0x30, 0x30, 0x5a, 0x18, 0x0f, 0x31, 0x36, 0x30, 0x31, 0x30, 0x31, 0x30,
91 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a, 0x30, 0x15, 0x31, 0x13, 0x30,
92 0x11, 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x41, 0x6c, 0x65, 0x78, 0x20,
93 0x4c, 0x61, 0x6e, 0x67, 0x00, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01,
94 0x00, 0xa3, 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01,
95 0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
98 static BOOL (WINAPI
*pCertAddStoreToCollection
)(HCERTSTORE
,HCERTSTORE
,DWORD
,DWORD
);
99 static BOOL (WINAPI
*pCertControlStore
)(HCERTSTORE
,DWORD
,DWORD
,void const*);
100 static PCCRL_CONTEXT (WINAPI
*pCertEnumCRLsInStore
)(HCERTSTORE
,PCCRL_CONTEXT
);
101 static BOOL (WINAPI
*pCertEnumSystemStore
)(DWORD
,void*,void*,PFN_CERT_ENUM_SYSTEM_STORE
);
102 static BOOL (WINAPI
*pCertGetStoreProperty
)(HCERTSTORE
,DWORD
,void*,DWORD
*);
103 static void (WINAPI
*pCertRemoveStoreFromCollection
)(HCERTSTORE
,HCERTSTORE
);
104 static BOOL (WINAPI
*pCertSetStoreProperty
)(HCERTSTORE
,DWORD
,DWORD
,const void*);
105 static BOOL (WINAPI
*pCertAddCertificateLinkToStore
)(HCERTSTORE
,PCCERT_CONTEXT
,DWORD
,PCCERT_CONTEXT
*);
107 static void testMemStore(void)
109 HCERTSTORE store1
, store2
;
110 PCCERT_CONTEXT context
;
115 store1
= CertOpenStore(0, 0, 0, 0, NULL
);
116 ok(!store1
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
117 "Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
119 store1
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
120 CERT_STORE_DELETE_FLAG
, NULL
);
121 ok(!store1
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
,
122 "Expected ERROR_CALL_NOT_IMPLEMENTED, got %d\n", GetLastError());
125 store1
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
126 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
127 ok(store1
!= NULL
, "CertOpenStore failed: %d\n", GetLastError());
128 /* open existing doesn't */
129 store2
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
130 CERT_STORE_OPEN_EXISTING_FLAG
, NULL
);
131 ok(store2
!= NULL
, "CertOpenStore failed: %d\n", GetLastError());
132 ok(store1
!= store2
, "Expected different stores\n");
134 /* add a bogus (empty) cert */
136 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
, emptyCert
,
137 sizeof(emptyCert
), CERT_STORE_ADD_ALWAYS
, &context
);
138 /* Windows returns CRYPT_E_ASN1_EOD or OSS_DATA_ERROR, but accept
139 * CRYPT_E_ASN1_CORRUPT as well (because matching errors is tough in this
142 GLE
= GetLastError();
143 ok(!ret
&& (GLE
== CRYPT_E_ASN1_EOD
|| GLE
== CRYPT_E_ASN1_CORRUPT
||
144 GLE
== OSS_DATA_ERROR
),
145 "Expected CRYPT_E_ASN1_EOD or CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %08x\n",
147 /* add a "signed" cert--the signature isn't a real signature, so this adds
148 * without any check of the signature's validity
150 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
,
151 signedBigCert
, sizeof(signedBigCert
), CERT_STORE_ADD_ALWAYS
, &context
);
152 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError());
153 ok(context
!= NULL
, "Expected a valid cert context\n");
156 ok(context
->cbCertEncoded
== sizeof(signedBigCert
),
157 "Wrong cert size %d\n", context
->cbCertEncoded
);
158 ok(!memcmp(context
->pbCertEncoded
, signedBigCert
,
159 sizeof(signedBigCert
)), "Unexpected encoded cert in context\n");
160 /* remove it, the rest of the tests will work on an unsigned cert */
161 ret
= CertDeleteCertificateFromStore(context
);
162 ok(ret
, "CertDeleteCertificateFromStore failed: %08x\n",
165 /* try adding a "signed" CRL as a cert */
166 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
,
167 signedCRL
, sizeof(signedCRL
), CERT_STORE_ADD_ALWAYS
, &context
);
168 GLE
= GetLastError();
169 ok(!ret
&& (GLE
== CRYPT_E_ASN1_BADTAG
|| GLE
== CRYPT_E_ASN1_CORRUPT
||
170 GLE
== OSS_DATA_ERROR
),
171 "Expected CRYPT_E_ASN1_BADTAG or CRYPT_E_ASN1_CORRUPT or OSS_DATA_ERROR, got %08x\n",
173 /* add a cert to store1 */
174 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
, bigCert
,
175 sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, &context
);
176 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError());
177 ok(context
!= NULL
, "Expected a valid cert context\n");
183 ok(context
->cbCertEncoded
== sizeof(bigCert
),
184 "Wrong cert size %d\n", context
->cbCertEncoded
);
185 ok(!memcmp(context
->pbCertEncoded
, bigCert
, sizeof(bigCert
)),
186 "Unexpected encoded cert in context\n");
187 ok(context
->hCertStore
== store1
, "Unexpected store\n");
189 /* check serializing this element */
191 ret = CertSerializeCertificateStoreElement(NULL, 0, NULL, NULL);
192 ret = CertSerializeCertificateStoreElement(context, 0, NULL, NULL);
193 ret = CertSerializeCertificateStoreElement(NULL, 0, NULL, &size);
195 /* apparently flags are ignored */
196 ret
= CertSerializeCertificateStoreElement(context
, 1, NULL
, &size
);
197 ok(ret
, "CertSerializeCertificateStoreElement failed: %08x\n",
199 buf
= HeapAlloc(GetProcessHeap(), 0, size
);
202 ret
= CertSerializeCertificateStoreElement(context
, 0, buf
, &size
);
203 ok(ret
, "CertSerializeCertificateStoreElement failed: %08x\n", GetLastError());
204 ok(size
== sizeof(serializedCert
), "Wrong size %d\n", size
);
205 ok(!memcmp(serializedCert
, buf
, size
),
206 "Unexpected serialized cert\n");
207 HeapFree(GetProcessHeap(), 0, buf
);
210 ret
= CertFreeCertificateContext(context
);
211 ok(ret
, "CertFreeCertificateContext failed: %08x\n", GetLastError());
213 /* verify the cert's in store1 */
214 context
= CertEnumCertificatesInStore(store1
, NULL
);
215 ok(context
!= NULL
, "Expected a valid context\n");
216 context
= CertEnumCertificatesInStore(store1
, context
);
217 ok(!context
&& GetLastError() == CRYPT_E_NOT_FOUND
,
218 "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError());
219 /* verify store2 (the "open existing" mem store) is still empty */
220 context
= CertEnumCertificatesInStore(store2
, NULL
);
221 ok(!context
, "Expected an empty store\n");
222 /* delete the cert from store1, and check it's empty */
223 context
= CertEnumCertificatesInStore(store1
, NULL
);
226 /* Deleting a bitwise copy crashes with an access to an uninitialized
227 * pointer, so a cert context has some special data out there in memory
230 memcpy(©, context, sizeof(copy));
231 ret = CertDeleteCertificateFromStore(©);
233 PCCERT_CONTEXT copy
= CertDuplicateCertificateContext(context
);
235 ok(copy
!= NULL
, "CertDuplicateCertificateContext failed: %08x\n",
237 ret
= CertDeleteCertificateFromStore(context
);
238 ok(ret
, "CertDeleteCertificateFromStore failed: %08x\n",
240 /* try deleting a copy */
241 ret
= CertDeleteCertificateFromStore(copy
);
242 ok(ret
, "CertDeleteCertificateFromStore failed: %08x\n",
244 /* check that the store is empty */
245 context
= CertEnumCertificatesInStore(store1
, NULL
);
246 ok(!context
, "Expected an empty store\n");
249 /* close an empty store */
250 ret
= CertCloseStore(NULL
, 0);
251 ok(ret
, "CertCloseStore failed: %d\n", GetLastError());
252 ret
= CertCloseStore(store1
, 0);
253 ok(ret
, "CertCloseStore failed: %d\n", GetLastError());
254 ret
= CertCloseStore(store2
, 0);
255 ok(ret
, "CertCloseStore failed: %d\n", GetLastError());
257 /* This seems nonsensical, but you can open a read-only mem store, only
260 store1
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
261 CERT_STORE_READONLY_FLAG
, NULL
);
262 ok(store1
!= NULL
, "CertOpenStore failed: %d\n", GetLastError());
263 /* yep, this succeeds */
264 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
, bigCert
,
265 sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, &context
);
266 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError());
267 ok(context
!= NULL
, "Expected a valid cert context\n");
270 ok(context
->cbCertEncoded
== sizeof(bigCert
),
271 "Wrong cert size %d\n", context
->cbCertEncoded
);
272 ok(!memcmp(context
->pbCertEncoded
, bigCert
, sizeof(bigCert
)),
273 "Unexpected encoded cert in context\n");
274 ok(context
->hCertStore
== store1
, "Unexpected store\n");
275 ret
= CertDeleteCertificateFromStore(context
);
276 ok(ret
, "CertDeleteCertificateFromStore failed: %08x\n",
279 CertCloseStore(store1
, 0);
282 static void compareStore(HCERTSTORE store
, LPCSTR name
, const BYTE
*pb
,
286 CRYPT_DATA_BLOB blob
= { 0, NULL
};
288 ret
= CertSaveStore(store
, X509_ASN_ENCODING
, CERT_STORE_SAVE_AS_STORE
,
289 CERT_STORE_SAVE_TO_MEMORY
, &blob
, 0);
290 ok(ret
, "CertSaveStore failed: %08x\n", GetLastError());
293 ok(blob
.cbData
== cb
, "%s: expected size %d, got %d\n", name
, cb
,
296 ok(blob
.cbData
== cb
, "%s: expected size %d, got %d\n", name
, cb
,
298 blob
.pbData
= HeapAlloc(GetProcessHeap(), 0, blob
.cbData
);
301 ret
= CertSaveStore(store
, X509_ASN_ENCODING
, CERT_STORE_SAVE_AS_STORE
,
302 CERT_STORE_SAVE_TO_MEMORY
, &blob
, 0);
303 ok(ret
, "CertSaveStore failed: %08x\n", GetLastError());
306 ok(!memcmp(pb
, blob
.pbData
, cb
), "%s: unexpected value\n", name
);
308 ok(!memcmp(pb
, blob
.pbData
, cb
), "%s: unexpected value\n", name
);
309 HeapFree(GetProcessHeap(), 0, blob
.pbData
);
313 static const BYTE serializedStoreWithCert
[] = {
314 0x00,0x00,0x00,0x00,0x43,0x45,0x52,0x54,0x20,0x00,0x00,0x00,0x01,0x00,0x00,
315 0x00,0x7c,0x00,0x00,0x00,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,
316 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
317 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,
318 0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,
319 0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,
320 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
321 0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,
322 0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,
323 0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
324 0x00,0x00,0x00,0x00,0x00,0x00 };
326 static void testCollectionStore(void)
328 HCERTSTORE store1
, store2
, collection
, collection2
;
329 PCCERT_CONTEXT context
;
331 static const WCHAR szPrefix
[] = { 'c','e','r',0 };
332 static const WCHAR szDot
[] = { '.',0 };
333 WCHAR filename
[MAX_PATH
];
336 if (!pCertAddStoreToCollection
)
338 win_skip("CertAddStoreToCollection() is not available\n");
342 collection
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
343 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
345 /* Try adding a cert to any empty collection */
346 ret
= CertAddEncodedCertificateToStore(collection
, X509_ASN_ENCODING
,
347 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
348 ok(!ret
&& GetLastError() == E_ACCESSDENIED
,
349 "Expected E_ACCESSDENIED, got %08x\n", GetLastError());
351 /* Create and add a cert to a memory store */
352 store1
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
353 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
354 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
,
355 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
356 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError());
357 /* Add the memory store to the collection, without allowing adding */
358 ret
= pCertAddStoreToCollection(collection
, store1
, 0, 0);
359 ok(ret
, "CertAddStoreToCollection failed: %08x\n", GetLastError());
360 /* Verify the cert is in the collection */
361 context
= CertEnumCertificatesInStore(collection
, NULL
);
362 ok(context
!= NULL
, "Expected a valid context\n");
365 ok(context
->hCertStore
== collection
, "Unexpected store\n");
366 CertFreeCertificateContext(context
);
368 /* Check that adding to the collection isn't allowed */
369 ret
= CertAddEncodedCertificateToStore(collection
, X509_ASN_ENCODING
,
370 bigCert2
, sizeof(bigCert2
), CERT_STORE_ADD_ALWAYS
, NULL
);
371 ok(!ret
&& GetLastError() == E_ACCESSDENIED
,
372 "Expected E_ACCESSDENIED, got %08x\n", GetLastError());
374 /* Create a new memory store */
375 store2
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
376 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
377 /* Try adding a store to a non-collection store */
378 ret
= pCertAddStoreToCollection(store1
, store2
,
379 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG
, 0);
380 ok(!ret
&& GetLastError() == E_INVALIDARG
,
381 "Expected E_INVALIDARG, got %08x\n", GetLastError());
382 /* Try adding some bogus stores */
383 /* This crashes in Windows
384 ret = pCertAddStoreToCollection(0, store2,
385 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0);
387 /* This "succeeds"... */
388 ret
= pCertAddStoreToCollection(collection
, 0,
389 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG
, 0);
390 ok(ret
, "CertAddStoreToCollection failed: %08x\n", GetLastError());
391 /* while this crashes.
392 ret = pCertAddStoreToCollection(collection, 1,
393 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG, 0);
396 /* Add it to the collection, this time allowing adding */
397 ret
= pCertAddStoreToCollection(collection
, store2
,
398 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG
, 0);
399 ok(ret
, "CertAddStoreToCollection failed: %08x\n", GetLastError());
400 /* Check that adding to the collection is allowed */
401 ret
= CertAddEncodedCertificateToStore(collection
, X509_ASN_ENCODING
,
402 bigCert2
, sizeof(bigCert2
), CERT_STORE_ADD_ALWAYS
, NULL
);
403 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError());
404 /* Now check that it was actually added to store2 */
405 context
= CertEnumCertificatesInStore(store2
, NULL
);
406 ok(context
!= NULL
, "Expected a valid context\n");
409 ok(context
->hCertStore
== store2
, "Unexpected store\n");
410 CertFreeCertificateContext(context
);
412 /* Check that the collection has both bigCert and bigCert2. bigCert comes
413 * first because store1 was added first.
415 context
= CertEnumCertificatesInStore(collection
, NULL
);
416 ok(context
!= NULL
, "Expected a valid context\n");
419 ok(context
->hCertStore
== collection
, "Unexpected store\n");
420 ok(context
->cbCertEncoded
== sizeof(bigCert
),
421 "Wrong size %d\n", context
->cbCertEncoded
);
422 ok(!memcmp(context
->pbCertEncoded
, bigCert
, context
->cbCertEncoded
),
423 "Unexpected cert\n");
424 context
= CertEnumCertificatesInStore(collection
, context
);
425 ok(context
!= NULL
, "Expected a valid context\n");
428 ok(context
->hCertStore
== collection
, "Unexpected store\n");
429 ok(context
->cbCertEncoded
== sizeof(bigCert2
),
430 "Wrong size %d\n", context
->cbCertEncoded
);
431 ok(!memcmp(context
->pbCertEncoded
, bigCert2
,
432 context
->cbCertEncoded
), "Unexpected cert\n");
433 context
= CertEnumCertificatesInStore(collection
, context
);
434 ok(!context
, "Unexpected cert\n");
437 /* close store2, and check that the collection is unmodified */
438 CertCloseStore(store2
, 0);
439 context
= CertEnumCertificatesInStore(collection
, NULL
);
440 ok(context
!= NULL
, "Expected a valid context\n");
443 ok(context
->hCertStore
== collection
, "Unexpected store\n");
444 ok(context
->cbCertEncoded
== sizeof(bigCert
),
445 "Wrong size %d\n", context
->cbCertEncoded
);
446 ok(!memcmp(context
->pbCertEncoded
, bigCert
, context
->cbCertEncoded
),
447 "Unexpected cert\n");
448 context
= CertEnumCertificatesInStore(collection
, context
);
449 ok(context
!= NULL
, "Expected a valid context\n");
452 ok(context
->hCertStore
== collection
, "Unexpected store\n");
453 ok(context
->cbCertEncoded
== sizeof(bigCert2
),
454 "Wrong size %d\n", context
->cbCertEncoded
);
455 ok(!memcmp(context
->pbCertEncoded
, bigCert2
,
456 context
->cbCertEncoded
), "Unexpected cert\n");
457 context
= CertEnumCertificatesInStore(collection
, context
);
458 ok(!context
, "Unexpected cert\n");
462 /* Adding a collection to a collection is legal */
463 collection2
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
464 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
465 ret
= pCertAddStoreToCollection(collection2
, collection
,
466 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG
, 0);
467 ok(ret
, "CertAddStoreToCollection failed: %08x\n", GetLastError());
468 /* check the contents of collection2 */
469 context
= CertEnumCertificatesInStore(collection2
, NULL
);
470 ok(context
!= NULL
, "Expected a valid context\n");
473 ok(context
->hCertStore
== collection2
, "Unexpected store\n");
474 ok(context
->cbCertEncoded
== sizeof(bigCert
),
475 "Wrong size %d\n", context
->cbCertEncoded
);
476 ok(!memcmp(context
->pbCertEncoded
, bigCert
, context
->cbCertEncoded
),
477 "Unexpected cert\n");
478 context
= CertEnumCertificatesInStore(collection2
, context
);
479 ok(context
!= NULL
, "Expected a valid context\n");
482 ok(context
->hCertStore
== collection2
, "Unexpected store\n");
483 ok(context
->cbCertEncoded
== sizeof(bigCert2
),
484 "Wrong size %d\n", context
->cbCertEncoded
);
485 ok(!memcmp(context
->pbCertEncoded
, bigCert2
,
486 context
->cbCertEncoded
), "Unexpected cert\n");
487 context
= CertEnumCertificatesInStore(collection2
, context
);
488 ok(!context
, "Unexpected cert\n");
492 /* I'd like to test closing the collection in the middle of enumeration,
493 * but my tests have been inconsistent. The first time calling
494 * CertEnumCertificatesInStore on a closed collection succeeded, while the
495 * second crashed. So anything appears to be fair game.
496 * I'd also like to test removing a store from a collection in the middle
497 * of an enumeration, but my tests in Windows have been inconclusive.
498 * In one scenario it worked. In another scenario, about a third of the
499 * time this leads to "random" crashes elsewhere in the code. This
500 * probably means this is not allowed.
503 CertCloseStore(store1
, 0);
504 CertCloseStore(collection
, 0);
505 CertCloseStore(collection2
, 0);
507 /* Add the same cert to two memory stores, then put them in a collection */
508 store1
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
509 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
510 ok(store1
!= 0, "CertOpenStore failed: %08x\n", GetLastError());
511 store2
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
512 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
513 ok(store2
!= 0, "CertOpenStore failed: %08x\n", GetLastError());
515 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
,
516 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
517 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError());
518 ret
= CertAddEncodedCertificateToStore(store2
, X509_ASN_ENCODING
,
519 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
520 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError());
521 collection
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
522 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
523 ok(collection
!= 0, "CertOpenStore failed: %08x\n", GetLastError());
525 ret
= pCertAddStoreToCollection(collection
, store1
,
526 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG
, 0);
527 ok(ret
, "CertAddStoreToCollection failed: %08x\n", GetLastError());
528 ret
= pCertAddStoreToCollection(collection
, store2
,
529 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG
, 0);
530 ok(ret
, "CertAddStoreToCollection failed: %08x\n", GetLastError());
532 /* Check that the collection has two copies of the same cert */
533 context
= CertEnumCertificatesInStore(collection
, NULL
);
534 ok(context
!= NULL
, "Expected a valid context\n");
537 ok(context
->hCertStore
== collection
, "Unexpected store\n");
538 ok(context
->cbCertEncoded
== sizeof(bigCert
),
539 "Wrong size %d\n", context
->cbCertEncoded
);
540 ok(!memcmp(context
->pbCertEncoded
, bigCert
, context
->cbCertEncoded
),
541 "Unexpected cert\n");
542 context
= CertEnumCertificatesInStore(collection
, context
);
543 ok(context
!= NULL
, "Expected a valid context\n");
546 ok(context
->hCertStore
== collection
, "Unexpected store\n");
547 ok(context
->cbCertEncoded
== sizeof(bigCert
),
548 "Wrong size %d\n", context
->cbCertEncoded
);
549 ok(!memcmp(context
->pbCertEncoded
, bigCert
, context
->cbCertEncoded
),
550 "Unexpected cert\n");
551 context
= CertEnumCertificatesInStore(collection
, context
);
552 ok(context
== NULL
, "Unexpected cert\n");
556 /* The following would check whether I can delete an identical cert, rather
557 * than one enumerated from the store. It crashes, so that means I must
558 * only call CertDeleteCertificateFromStore with contexts enumerated from
560 context = CertCreateCertificateContext(X509_ASN_ENCODING, bigCert,
562 ok(context != NULL, "CertCreateCertificateContext failed: %08x\n",
566 ret = CertDeleteCertificateFromStore(collection, context);
567 printf("ret is %d, GetLastError is %08x\n", ret, GetLastError());
568 CertFreeCertificateContext(context);
572 /* Now check deleting from the collection. */
573 context
= CertEnumCertificatesInStore(collection
, NULL
);
574 ok(context
!= NULL
, "Expected a valid context\n");
577 CertDeleteCertificateFromStore(context
);
578 /* store1 should now be empty */
579 context
= CertEnumCertificatesInStore(store1
, NULL
);
580 ok(!context
, "Unexpected cert\n");
581 /* and there should be one certificate in the collection */
582 context
= CertEnumCertificatesInStore(collection
, NULL
);
583 ok(context
!= NULL
, "Expected a valid cert\n");
586 ok(context
->hCertStore
== collection
, "Unexpected store\n");
587 ok(context
->cbCertEncoded
== sizeof(bigCert
),
588 "Wrong size %d\n", context
->cbCertEncoded
);
589 ok(!memcmp(context
->pbCertEncoded
, bigCert
, context
->cbCertEncoded
),
590 "Unexpected cert\n");
592 context
= CertEnumCertificatesInStore(collection
, context
);
593 ok(context
== NULL
, "Unexpected cert\n");
596 if (!pCertRemoveStoreFromCollection
)
598 win_skip("CertRemoveStoreFromCollection() is not available\n");
602 /* Finally, test removing stores from the collection. No return
603 * value, so it's a bit funny to test.
606 * pCertRemoveStoreFromCollection(NULL, NULL);
608 /* This "succeeds," no crash, no last error set */
609 SetLastError(0xdeadbeef);
610 pCertRemoveStoreFromCollection(store2
, collection
);
611 ok(GetLastError() == 0xdeadbeef,
612 "Didn't expect an error to be set: %08x\n", GetLastError());
614 /* After removing store2, the collection should be empty */
615 SetLastError(0xdeadbeef);
616 pCertRemoveStoreFromCollection(collection
, store2
);
617 ok(GetLastError() == 0xdeadbeef,
618 "Didn't expect an error to be set: %08x\n", GetLastError());
619 context
= CertEnumCertificatesInStore(collection
, NULL
);
620 ok(!context
, "Unexpected cert\n");
623 CertCloseStore(collection
, 0);
624 CertCloseStore(store2
, 0);
625 CertCloseStore(store1
, 0);
627 /* Test adding certificates to and deleting certificates from collections.
629 store1
= CertOpenSystemStoreA(0, "My");
630 collection
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
631 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
633 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
,
634 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, &context
);
635 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError());
636 CertDeleteCertificateFromStore(context
);
638 pCertAddStoreToCollection(collection
, store1
,
639 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG
, 0);
641 ret
= CertAddEncodedCertificateToStore(collection
, X509_ASN_ENCODING
,
642 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, &context
);
643 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n", GetLastError());
644 CertDeleteCertificateFromStore(context
);
646 CertCloseStore(collection
, 0);
647 CertCloseStore(store1
, 0);
649 /* Test whether a collection store can be committed */
650 if (!pCertControlStore
)
652 win_skip("CertControlStore() is not available\n");
655 collection
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
656 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
658 SetLastError(0xdeadbeef);
659 ret
= pCertControlStore(collection
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
660 ok(ret
, "CertControlStore failed: %08x\n", GetLastError());
662 /* Adding a mem store that can't be committed prevents a successful commit.
664 store1
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
665 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
666 pCertAddStoreToCollection(collection
, store1
, 0, 0);
667 SetLastError(0xdeadbeef);
668 ret
= pCertControlStore(collection
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
669 ok(!ret
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
,
670 "expected ERROR_CALL_NOT_IMPLEMENTED, got %d\n", GetLastError());
671 pCertRemoveStoreFromCollection(collection
, store1
);
672 CertCloseStore(store1
, 0);
674 /* Test adding a cert to a collection with a file store, committing the
675 * change to the collection, and comparing the resulting file.
677 if (!GetTempFileNameW(szDot
, szPrefix
, 0, filename
))
680 DeleteFileW(filename
);
681 file
= CreateFileW(filename
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
682 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
683 if (file
== INVALID_HANDLE_VALUE
)
686 store1
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
687 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
, file
);
688 ok(store1
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
690 pCertAddStoreToCollection(collection
, store1
,
691 CERT_PHYSICAL_STORE_ADD_ENABLE_FLAG
, 0);
692 CertCloseStore(store1
, 0);
694 ret
= CertAddEncodedCertificateToStore(collection
, X509_ASN_ENCODING
,
695 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
696 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n",
698 ret
= pCertControlStore(collection
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
699 ok(ret
, "CertControlStore failed: %d\n", ret
);
700 compareStore(collection
, "serialized store with cert",
701 serializedStoreWithCert
, sizeof(serializedStoreWithCert
), FALSE
);
702 CertCloseStore(collection
, 0);
704 DeleteFileW(filename
);
707 /* Looks for the property with ID propID in the buffer buf. Returns a pointer
708 * to its header if found, NULL if not.
710 static const struct CertPropIDHeader
*findPropID(const BYTE
*buf
, DWORD size
,
713 const struct CertPropIDHeader
*ret
= NULL
;
716 while (size
&& !ret
&& !failed
)
718 if (size
< sizeof(struct CertPropIDHeader
))
722 const struct CertPropIDHeader
*hdr
=
723 (const struct CertPropIDHeader
*)buf
;
725 size
-= sizeof(struct CertPropIDHeader
);
726 buf
+= sizeof(struct CertPropIDHeader
);
729 else if (hdr
->propID
== propID
)
741 typedef DWORD (WINAPI
*SHDeleteKeyAFunc
)(HKEY
, LPCSTR
);
743 static void testRegStore(void)
745 static const char tempKey
[] = "Software\\Wine\\CryptTemp";
751 store
= CertOpenStore(CERT_STORE_PROV_REG
, 0, 0, 0, NULL
);
752 GLE
= GetLastError();
753 ok(!store
&& (GLE
== ERROR_INVALID_HANDLE
|| GLE
== ERROR_BADKEY
),
754 "Expected ERROR_INVALID_HANDLE or ERROR_BADKEY, got %d\n", GLE
);
755 store
= CertOpenStore(CERT_STORE_PROV_REG
, 0, 0, 0, key
);
756 GLE
= GetLastError();
757 ok(!store
&& (GLE
== ERROR_INVALID_HANDLE
|| GLE
== ERROR_BADKEY
),
758 "Expected ERROR_INVALID_HANDLE or ERROR_BADKEY, got %d\n", GLE
);
760 /* Opening up any old key works.. */
761 key
= HKEY_CURRENT_USER
;
762 store
= CertOpenStore(CERT_STORE_PROV_REG
, 0, 0, 0, key
);
763 /* Not sure if this is a bug in DuplicateHandle, marking todo_wine for now
765 todo_wine
ok(store
!= 0, "CertOpenStore failed: %08x\n", GetLastError());
766 CertCloseStore(store
, 0);
768 /* It looks like the remainder pretty much needs CertControlStore() */
769 if (!pCertControlStore
)
771 win_skip("CertControlStore() is not available\n");
775 rc
= RegCreateKeyExA(HKEY_CURRENT_USER
, tempKey
, 0, NULL
, 0, KEY_ALL_ACCESS
,
777 ok(!rc
, "RegCreateKeyExA failed: %d\n", rc
);
783 static const char certificates
[] = "Certificates\\";
784 char subKeyName
[sizeof(certificates
) + 20 * 2 + 1], *ptr
;
786 PCCERT_CONTEXT context
;
788 store
= CertOpenStore(CERT_STORE_PROV_REG
, 0, 0, 0, key
);
789 ok(store
!= 0, "CertOpenStore failed: %08x\n", GetLastError());
790 /* Add a certificate. It isn't persisted right away, since it's only
791 * added to the cache..
793 ret
= CertAddEncodedCertificateToStore(store
, X509_ASN_ENCODING
,
794 bigCert2
, sizeof(bigCert2
), CERT_STORE_ADD_ALWAYS
, NULL
);
795 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n",
797 /* so flush the cache to force a commit.. */
798 ret
= pCertControlStore(store
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
799 ok(ret
, "CertControlStore failed: %08x\n", GetLastError());
800 /* and check that the expected subkey was written. */
802 ret
= CryptHashCertificate(0, 0, 0, bigCert2
, sizeof(bigCert2
),
804 ok(ret
, "CryptHashCertificate failed: %d\n", GetLastError());
805 strcpy(subKeyName
, certificates
);
806 for (i
= 0, ptr
= subKeyName
+ sizeof(certificates
) - 1; i
< size
;
808 sprintf(ptr
, "%02X", hash
[i
]);
809 rc
= RegCreateKeyExA(key
, subKeyName
, 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
,
811 ok(!rc
, "RegCreateKeyExA failed: %d\n", rc
);
817 RegQueryValueExA(subKey
, "Blob", NULL
, NULL
, NULL
, &size
);
818 buf
= HeapAlloc(GetProcessHeap(), 0, size
);
821 rc
= RegQueryValueExA(subKey
, "Blob", NULL
, NULL
, buf
, &size
);
822 ok(!rc
, "RegQueryValueExA failed: %d\n", rc
);
825 const struct CertPropIDHeader
*hdr
;
827 /* Both the hash and the cert should be present */
828 hdr
= findPropID(buf
, size
, CERT_CERT_PROP_ID
);
829 ok(hdr
!= NULL
, "Expected to find a cert property\n");
832 ok(hdr
->cb
== sizeof(bigCert2
),
833 "Wrong size %d of cert property\n", hdr
->cb
);
834 ok(!memcmp((const BYTE
*)hdr
+ sizeof(*hdr
), bigCert2
,
835 hdr
->cb
), "Unexpected cert in cert property\n");
837 hdr
= findPropID(buf
, size
, CERT_HASH_PROP_ID
);
838 ok(hdr
!= NULL
, "Expected to find a hash property\n");
841 ok(hdr
->cb
== sizeof(hash
),
842 "Wrong size %d of hash property\n", hdr
->cb
);
843 ok(!memcmp((const BYTE
*)hdr
+ sizeof(*hdr
), hash
,
844 hdr
->cb
), "Unexpected hash in cert property\n");
847 HeapFree(GetProcessHeap(), 0, buf
);
852 /* Remove the existing context */
853 context
= CertEnumCertificatesInStore(store
, NULL
);
854 ok(context
!= NULL
, "Expected a cert context\n");
856 CertDeleteCertificateFromStore(context
);
857 ret
= pCertControlStore(store
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
858 ok(ret
, "CertControlStore failed: %08x\n", GetLastError());
860 /* Add a serialized cert with a bogus hash directly to the registry */
861 memset(hash
, 0, sizeof(hash
));
862 strcpy(subKeyName
, certificates
);
863 for (i
= 0, ptr
= subKeyName
+ sizeof(certificates
) - 1;
864 i
< sizeof(hash
); i
++, ptr
+= 2)
865 sprintf(ptr
, "%02X", hash
[i
]);
866 rc
= RegCreateKeyExA(key
, subKeyName
, 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
,
868 ok(!rc
, "RegCreateKeyExA failed: %d\n", rc
);
871 BYTE buf
[sizeof(struct CertPropIDHeader
) * 2 + sizeof(hash
) +
872 sizeof(bigCert
)], *ptr
;
874 struct CertPropIDHeader
*hdr
;
876 hdr
= (struct CertPropIDHeader
*)buf
;
877 hdr
->propID
= CERT_HASH_PROP_ID
;
879 hdr
->cb
= sizeof(hash
);
880 ptr
= buf
+ sizeof(*hdr
);
881 memcpy(ptr
, hash
, sizeof(hash
));
883 hdr
= (struct CertPropIDHeader
*)ptr
;
884 hdr
->propID
= CERT_CERT_PROP_ID
;
886 hdr
->cb
= sizeof(bigCert
);
888 memcpy(ptr
, bigCert
, sizeof(bigCert
));
890 rc
= RegSetValueExA(subKey
, "Blob", 0, REG_BINARY
, buf
,
892 ok(!rc
, "RegSetValueExA failed: %d\n", rc
);
894 ret
= pCertControlStore(store
, 0, CERT_STORE_CTRL_RESYNC
, NULL
);
895 ok(ret
, "CertControlStore failed: %08x\n", GetLastError());
897 /* Make sure the bogus hash cert gets loaded. */
901 context
= CertEnumCertificatesInStore(store
, context
);
904 } while (context
!= NULL
);
905 ok(certCount
== 1, "Expected 1 certificates, got %d\n", certCount
);
910 /* Add another serialized cert directly to the registry, this time
911 * under the correct key name (named with the correct hash value).
914 ret
= CryptHashCertificate(0, 0, 0, bigCert2
,
915 sizeof(bigCert2
), hash
, &size
);
916 ok(ret
, "CryptHashCertificate failed: %d\n", GetLastError());
917 strcpy(subKeyName
, certificates
);
918 for (i
= 0, ptr
= subKeyName
+ sizeof(certificates
) - 1;
919 i
< sizeof(hash
); i
++, ptr
+= 2)
920 sprintf(ptr
, "%02X", hash
[i
]);
921 rc
= RegCreateKeyExA(key
, subKeyName
, 0, NULL
, 0, KEY_ALL_ACCESS
, NULL
,
923 ok(!rc
, "RegCreateKeyExA failed: %d\n", rc
);
926 BYTE buf
[sizeof(struct CertPropIDHeader
) * 2 + sizeof(hash
) +
927 sizeof(bigCert2
)], *ptr
;
929 PCCERT_CONTEXT context
;
930 struct CertPropIDHeader
*hdr
;
932 /* First try with a bogus hash... */
933 hdr
= (struct CertPropIDHeader
*)buf
;
934 hdr
->propID
= CERT_HASH_PROP_ID
;
936 hdr
->cb
= sizeof(hash
);
937 ptr
= buf
+ sizeof(*hdr
);
938 memset(ptr
, 0, sizeof(hash
));
940 hdr
= (struct CertPropIDHeader
*)ptr
;
941 hdr
->propID
= CERT_CERT_PROP_ID
;
943 hdr
->cb
= sizeof(bigCert2
);
945 memcpy(ptr
, bigCert2
, sizeof(bigCert2
));
947 rc
= RegSetValueExA(subKey
, "Blob", 0, REG_BINARY
, buf
,
949 ok(!rc
, "RegSetValueExA failed: %d\n", rc
);
951 ret
= pCertControlStore(store
, 0, CERT_STORE_CTRL_RESYNC
, NULL
);
952 ok(ret
, "CertControlStore failed: %08x\n", GetLastError());
954 /* and make sure just one cert still gets loaded. */
958 context
= CertEnumCertificatesInStore(store
, context
);
961 } while (context
!= NULL
);
963 broken(certCount
== 2) /* NT4 */ ,
964 "Expected 1 certificates, got %d\n", certCount
);
966 /* Try again with the correct hash... */
967 ptr
= buf
+ sizeof(*hdr
);
968 memcpy(ptr
, hash
, sizeof(hash
));
970 rc
= RegSetValueExA(subKey
, "Blob", 0, REG_BINARY
, buf
,
972 ok(!rc
, "RegSetValueExA failed: %d\n", rc
);
974 ret
= pCertControlStore(store
, 0, CERT_STORE_CTRL_RESYNC
, NULL
);
975 ok(ret
, "CertControlStore failed: %08x\n", GetLastError());
977 /* and make sure two certs get loaded. */
981 context
= CertEnumCertificatesInStore(store
, context
);
984 } while (context
!= NULL
);
985 ok(certCount
== 2, "Expected 2 certificates, got %d\n", certCount
);
989 CertCloseStore(store
, 0);
990 /* Is delete allowed on a reg store? */
991 store
= CertOpenStore(CERT_STORE_PROV_REG
, 0, 0,
992 CERT_STORE_DELETE_FLAG
, key
);
993 ok(store
== NULL
, "Expected NULL return from CERT_STORE_DELETE_FLAG\n");
994 ok(GetLastError() == 0, "CertOpenStore failed: %08x\n",
999 /* The CertOpenStore with CERT_STORE_DELETE_FLAG above will delete the
1000 * contents of the key, but not the key itself.
1002 rc
= RegCreateKeyExA(HKEY_CURRENT_USER
, tempKey
, 0, NULL
, 0, KEY_ALL_ACCESS
,
1004 ok(!rc
, "RegCreateKeyExA failed: %d\n", rc
);
1005 ok(disp
== REG_OPENED_EXISTING_KEY
,
1006 "Expected REG_OPENED_EXISTING_KEY, got %d\n", disp
);
1010 rc
= RegDeleteKeyA(HKEY_CURRENT_USER
, tempKey
);
1013 HMODULE shlwapi
= LoadLibraryA("shlwapi");
1015 /* Use shlwapi's SHDeleteKeyA to _really_ blow away the key,
1016 * otherwise subsequent tests will fail.
1020 SHDeleteKeyAFunc pSHDeleteKeyA
=
1021 (SHDeleteKeyAFunc
)GetProcAddress(shlwapi
, "SHDeleteKeyA");
1024 pSHDeleteKeyA(HKEY_CURRENT_USER
, tempKey
);
1025 FreeLibrary(shlwapi
);
1031 static const char MyA
[] = { 'M','y',0,0 };
1032 static const WCHAR MyW
[] = { 'M','y',0 };
1033 static const WCHAR BogusW
[] = { 'B','o','g','u','s',0 };
1034 static const WCHAR BogusPathW
[] = { 'S','o','f','t','w','a','r','e','\\',
1035 'M','i','c','r','o','s','o','f','t','\\','S','y','s','t','e','m','C','e','r',
1036 't','i','f','i','c','a','t','e','s','\\','B','o','g','u','s',0 };
1038 static void testSystemRegStore(void)
1040 HCERTSTORE store
, memStore
;
1042 /* Check with a UNICODE name */
1043 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY
, 0, 0,
1044 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_OPEN_EXISTING_FLAG
, MyW
);
1045 /* Not all OSes support CERT_STORE_PROV_SYSTEM_REGISTRY, so don't continue
1046 * testing if they don't.
1051 /* Check that it isn't a collection store */
1052 memStore
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
1053 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
1056 if (pCertAddStoreToCollection
)
1058 BOOL ret
= pCertAddStoreToCollection(store
, memStore
, 0, 0);
1059 ok(!ret
&& GetLastError() == E_INVALIDARG
,
1060 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1062 CertCloseStore(memStore
, 0);
1064 CertCloseStore(store
, 0);
1066 /* Check opening a bogus store */
1067 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY
, 0, 0,
1068 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_OPEN_EXISTING_FLAG
, BogusW
);
1069 ok(!store
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
1070 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1071 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY
, 0, 0,
1072 CERT_SYSTEM_STORE_CURRENT_USER
, BogusW
);
1073 ok(store
!= 0, "CertOpenStore failed: %08x\n", GetLastError());
1075 CertCloseStore(store
, 0);
1076 /* Now check whether deleting is allowed */
1077 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY
, 0, 0,
1078 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_DELETE_FLAG
, BogusW
);
1079 ok(!store
, "CertOpenStore failed: %08x\n", GetLastError());
1080 RegDeleteKeyW(HKEY_CURRENT_USER
, BogusPathW
);
1082 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY
, 0, 0, 0, NULL
);
1083 ok(!store
&& GetLastError() == E_INVALIDARG
,
1084 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1085 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY
, 0, 0,
1086 CERT_SYSTEM_STORE_LOCAL_MACHINE
| CERT_SYSTEM_STORE_CURRENT_USER
, MyA
);
1087 ok(!store
&& GetLastError() == E_INVALIDARG
,
1088 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1089 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY
, 0, 0,
1090 CERT_SYSTEM_STORE_LOCAL_MACHINE
| CERT_SYSTEM_STORE_CURRENT_USER
, MyW
);
1091 ok(!store
&& GetLastError() == E_INVALIDARG
,
1092 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1093 /* The name is expected to be UNICODE, check with an ASCII name */
1094 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY
, 0, 0,
1095 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_OPEN_EXISTING_FLAG
, MyA
);
1096 ok(!store
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
1097 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1100 static void testSystemStore(void)
1102 static const WCHAR baskslashW
[] = { '\\',0 };
1104 WCHAR keyName
[MAX_PATH
];
1108 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0, 0, NULL
);
1109 ok(!store
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
1110 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1111 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0,
1112 CERT_SYSTEM_STORE_LOCAL_MACHINE
| CERT_SYSTEM_STORE_CURRENT_USER
, MyA
);
1113 ok(!store
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
1114 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1115 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0,
1116 CERT_SYSTEM_STORE_LOCAL_MACHINE
| CERT_SYSTEM_STORE_CURRENT_USER
, MyW
);
1117 ok(!store
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
1118 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1119 /* The name is expected to be UNICODE, first check with an ASCII name */
1120 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0,
1121 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_OPEN_EXISTING_FLAG
, MyA
);
1122 ok(!store
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
1123 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1124 /* Create the expected key */
1125 lstrcpyW(keyName
, CERT_LOCAL_MACHINE_SYSTEM_STORE_REGPATH
);
1126 lstrcatW(keyName
, baskslashW
);
1127 lstrcatW(keyName
, MyW
);
1128 rc
= RegCreateKeyExW(HKEY_CURRENT_USER
, keyName
, 0, NULL
, 0, KEY_READ
,
1130 ok(!rc
, "RegCreateKeyEx failed: %d\n", rc
);
1133 /* Check opening with a UNICODE name, specifying the create new flag */
1134 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0,
1135 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_CREATE_NEW_FLAG
, MyW
);
1136 ok(!store
&& GetLastError() == ERROR_FILE_EXISTS
,
1137 "Expected ERROR_FILE_EXISTS, got %08x\n", GetLastError());
1138 /* Now check opening with a UNICODE name, this time opening existing */
1139 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0,
1140 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_OPEN_EXISTING_FLAG
, MyW
);
1141 ok(store
!= 0, "CertOpenStore failed: %08x\n", GetLastError());
1144 HCERTSTORE memStore
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
1145 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
1147 /* Check that it's a collection store */
1150 if (pCertAddStoreToCollection
)
1152 BOOL ret
= pCertAddStoreToCollection(store
, memStore
, 0, 0);
1153 /* FIXME: this'll fail on NT4, but what error will it give? */
1154 ok(ret
, "CertAddStoreToCollection failed: %08x\n", GetLastError());
1156 CertCloseStore(memStore
, 0);
1158 CertCloseStore(store
, 0);
1161 /* Check opening a bogus store */
1162 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0,
1163 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_OPEN_EXISTING_FLAG
, BogusW
);
1164 ok(!store
, "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1165 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0,
1166 CERT_SYSTEM_STORE_CURRENT_USER
, BogusW
);
1167 ok(store
!= 0, "CertOpenStore failed: %08x\n", GetLastError());
1169 CertCloseStore(store
, 0);
1170 /* Now check whether deleting is allowed */
1171 store
= CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0,
1172 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_DELETE_FLAG
, BogusW
);
1173 ok(!store
, "Didn't expect a store to be returned when deleting\n");
1174 RegDeleteKeyW(HKEY_CURRENT_USER
, BogusPathW
);
1177 static const BYTE serializedStoreWithCertAndCRL
[] = {
1178 0x00,0x00,0x00,0x00,0x43,0x45,0x52,0x54,0x20,0x00,0x00,0x00,0x01,0x00,0x00,
1179 0x00,0x7c,0x00,0x00,0x00,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,
1180 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
1181 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,
1182 0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,
1183 0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,
1184 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
1185 0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,
1186 0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,
1187 0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01,0x21,0x00,0x00,0x00,0x01,0x00,
1188 0x00,0x00,0x47,0x00,0x00,0x00,0x30,0x45,0x30,0x2c,0x30,0x02,0x06,0x00,0x30,
1189 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
1190 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
1191 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00,0x03,0x11,
1192 0x00,0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,
1193 0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
1195 static void testFileStore(void)
1197 static const WCHAR szPrefix
[] = { 'c','e','r',0 };
1198 static const WCHAR szDot
[] = { '.',0 };
1199 WCHAR filename
[MAX_PATH
];
1202 PCCERT_CONTEXT cert
;
1205 if (!pCertControlStore
)
1207 win_skip("CertControlStore() is not available\n");
1211 store
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0, 0, NULL
);
1212 ok(!store
&& GetLastError() == ERROR_INVALID_HANDLE
,
1213 "Expected ERROR_INVALID_HANDLE, got %08x\n", GetLastError());
1215 if (!GetTempFileNameW(szDot
, szPrefix
, 0, filename
))
1218 DeleteFileW(filename
);
1219 file
= CreateFileW(filename
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
1220 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1221 if (file
== INVALID_HANDLE_VALUE
)
1224 store
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0, CERT_STORE_DELETE_FLAG
,
1226 ok(!store
&& GetLastError() == E_INVALIDARG
,
1227 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1228 store
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
1229 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
| CERT_STORE_READONLY_FLAG
, file
);
1230 ok(!store
&& GetLastError() == E_INVALIDARG
,
1231 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1233 /* A "read-only" file store.. */
1234 store
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
1235 CERT_STORE_OPEN_EXISTING_FLAG
| CERT_STORE_READONLY_FLAG
, file
);
1236 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1241 ret
= CertAddEncodedCertificateToStore(store
, X509_ASN_ENCODING
,
1242 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
1243 /* apparently allows adding certificates.. */
1244 ok(ret
, "CertAddEncodedCertificateToStore failed: %d\n", ret
);
1245 /* but not commits.. */
1246 ret
= pCertControlStore(store
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
1247 ok(!ret
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
,
1248 "Expected ERROR_CALL_NOT_IMPLEMENTED, got %08x\n", GetLastError());
1249 /* It still has certs in memory.. */
1250 cert
= CertEnumCertificatesInStore(store
, NULL
);
1251 ok(cert
!= NULL
, "CertEnumCertificatesInStore failed: %08x\n",
1253 CertFreeCertificateContext(cert
);
1254 /* but the file size is still 0. */
1255 size
= GetFileSize(file
, NULL
);
1256 ok(size
== 0, "Expected size 0, got %d\n", size
);
1257 CertCloseStore(store
, 0);
1260 /* The create new flag is allowed.. */
1261 store
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
1262 CERT_STORE_CREATE_NEW_FLAG
, file
);
1263 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1266 /* but without the commit enable flag, commits don't happen. */
1267 ret
= CertAddEncodedCertificateToStore(store
, X509_ASN_ENCODING
,
1268 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
1269 ok(ret
, "CertAddEncodedCertificateToStore failed: %d\n", ret
);
1270 ret
= pCertControlStore(store
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
1271 ok(!ret
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
,
1272 "Expected ERROR_CALL_NOT_IMPLEMENTED, got %08x\n", GetLastError());
1273 CertCloseStore(store
, 0);
1275 /* as is the open existing flag. */
1276 store
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
1277 CERT_STORE_OPEN_EXISTING_FLAG
, file
);
1278 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1281 /* but without the commit enable flag, commits don't happen. */
1282 ret
= CertAddEncodedCertificateToStore(store
, X509_ASN_ENCODING
,
1283 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
1284 ok(ret
, "CertAddEncodedCertificateToStore failed: %d\n", ret
);
1285 ret
= pCertControlStore(store
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
1286 ok(!ret
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
,
1287 "Expected ERROR_CALL_NOT_IMPLEMENTED, got %08x\n", GetLastError());
1288 CertCloseStore(store
, 0);
1290 store
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
1291 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
, file
);
1292 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1296 ret
= CertAddEncodedCertificateToStore(store
, X509_ASN_ENCODING
,
1297 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
1298 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n",
1300 /* with commits enabled, commit is allowed */
1301 ret
= pCertControlStore(store
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
1302 ok(ret
, "CertControlStore failed: %d\n", ret
);
1303 compareStore(store
, "serialized store with cert",
1304 serializedStoreWithCert
, sizeof(serializedStoreWithCert
), FALSE
);
1305 CertCloseStore(store
, 0);
1307 file
= CreateFileW(filename
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
1308 OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1309 if (file
== INVALID_HANDLE_VALUE
)
1311 store
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
1312 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
, file
);
1313 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1317 ret
= CertAddEncodedCRLToStore(store
, X509_ASN_ENCODING
, signedCRL
,
1318 sizeof(signedCRL
), CERT_STORE_ADD_ALWAYS
, NULL
);
1319 ok(ret
, "CertAddEncodedCRLToStore failed: %08x\n", GetLastError());
1320 compareStore(store
, "serialized store with cert and CRL",
1321 serializedStoreWithCertAndCRL
, sizeof(serializedStoreWithCertAndCRL
),
1323 CertCloseStore(store
, 0);
1326 DeleteFileW(filename
);
1329 static BOOL
initFileFromData(LPCWSTR filename
, const BYTE
*pb
, DWORD cb
)
1331 HANDLE file
= CreateFileW(filename
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
1332 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
1335 if (file
!= INVALID_HANDLE_VALUE
)
1339 ret
= WriteFile(file
, pb
, cb
, &written
, NULL
);
1347 static const BYTE base64SPC
[] =
1348 "MIICJQYJKoZIhvcNAQcCoIICFjCCAhICAQExADALBgkqhkiG9w0BBwGgggH6MIIB"
1349 "9jCCAV+gAwIBAgIQnP8+EF4opr9OxH7h4uBPWTANBgkqhkiG9w0BAQQFADAUMRIw"
1350 "EAYDVQQDEwlKdWFuIExhbmcwHhcNMDgxMjEyMTcxMDE0WhcNMzkxMjMxMjM1OTU5"
1351 "WjAUMRIwEAYDVQQDEwlKdWFuIExhbmcwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ"
1352 "AoGBALCgNjyNvOic0FOfjxvi43HbM+D5joDkhiGSXe+gbZlf8f16k07kkObFEunz"
1353 "mdB5coscmA7gyqiWNN4ZUyr2cA3lCbnpGPA/0IblyyOcuGIFmmCzeZaVa5ZG6xZP"
1354 "K7L7o+73Qo6jXVbGhBGnMZ7Q9sAn6s2933olnStnejnqwV0NAgMBAAGjSTBHMEUG"
1355 "A1UdAQQ+MDyAEFKbKEdXYyx+CWKcV6vxM6ShFjAUMRIwEAYDVQQDEwlKdWFuIExh"
1356 "bmeCEJz/PhBeKKa/TsR+4eLgT1kwDQYJKoZIhvcNAQEEBQADgYEALpkgLgW3mEaK"
1357 "idPQ3iPJYLG0Ub1wraqEl9bd42hrhzIdcDzlQgxnm8/5cHYVxIF/C20x/HJplb1R"
1358 "G6U1ipFe/q8byWD/9JpiBKMGPi9YlUTgXHfS9d4S/QWO1h9Z7KeipBYhoslQpHXu"
1359 "y9bUr8Adqi6SzgHpCnMu53dxgxUD1r4xAA==";
1360 /* Same as base64SPC, but as a wide-char string */
1361 static const WCHAR utf16Base64SPC
[] = {
1362 'M','I','I','C','J','Q','Y','J','K','o','Z','I','h','v','c','N','A',
1363 'Q','c','C','o','I','I','C','F','j','C','C','A','h','I','C','A','Q',
1364 'E','x','A','D','A','L','B','g','k','q','h','k','i','G','9','w','0',
1365 'B','B','w','G','g','g','g','H','6','M','I','I','B','9','j','C','C',
1366 'A','V','+','g','A','w','I','B','A','g','I','Q','n','P','8','+','E',
1367 'F','4','o','p','r','9','O','x','H','7','h','4','u','B','P','W','T',
1368 'A','N','B','g','k','q','h','k','i','G','9','w','0','B','A','Q','Q',
1369 'F','A','D','A','U','M','R','I','w','E','A','Y','D','V','Q','Q','D',
1370 'E','w','l','K','d','W','F','u','I','E','x','h','b','m','c','w','H',
1371 'h','c','N','M','D','g','x','M','j','E','y','M','T','c','x','M','D',
1372 'E','0','W','h','c','N','M','z','k','x','M','j','M','x','M','j','M',
1373 '1','O','T','U','5','W','j','A','U','M','R','I','w','E','A','Y','D',
1374 'V','Q','Q','D','E','w','l','K','d','W','F','u','I','E','x','h','b',
1375 'm','c','w','g','Z','8','w','D','Q','Y','J','K','o','Z','I','h','v',
1376 'c','N','A','Q','E','B','B','Q','A','D','g','Y','0','A','M','I','G',
1377 'J','A','o','G','B','A','L','C','g','N','j','y','N','v','O','i','c',
1378 '0','F','O','f','j','x','v','i','4','3','H','b','M','+','D','5','j',
1379 'o','D','k','h','i','G','S','X','e','+','g','b','Z','l','f','8','f',
1380 '1','6','k','0','7','k','k','O','b','F','E','u','n','z','m','d','B',
1381 '5','c','o','s','c','m','A','7','g','y','q','i','W','N','N','4','Z',
1382 'U','y','r','2','c','A','3','l','C','b','n','p','G','P','A','/','0',
1383 'I','b','l','y','y','O','c','u','G','I','F','m','m','C','z','e','Z',
1384 'a','V','a','5','Z','G','6','x','Z','P','K','7','L','7','o','+','7',
1385 '3','Q','o','6','j','X','V','b','G','h','B','G','n','M','Z','7','Q',
1386 '9','s','A','n','6','s','2','9','3','3','o','l','n','S','t','n','e',
1387 'j','n','q','w','V','0','N','A','g','M','B','A','A','G','j','S','T',
1388 'B','H','M','E','U','G','A','1','U','d','A','Q','Q','+','M','D','y',
1389 'A','E','F','K','b','K','E','d','X','Y','y','x','+','C','W','K','c',
1390 'V','6','v','x','M','6','S','h','F','j','A','U','M','R','I','w','E',
1391 'A','Y','D','V','Q','Q','D','E','w','l','K','d','W','F','u','I','E',
1392 'x','h','b','m','e','C','E','J','z','/','P','h','B','e','K','K','a',
1393 '/','T','s','R','+','4','e','L','g','T','1','k','w','D','Q','Y','J',
1394 'K','o','Z','I','h','v','c','N','A','Q','E','E','B','Q','A','D','g',
1395 'Y','E','A','L','p','k','g','L','g','W','3','m','E','a','K','i','d',
1396 'P','Q','3','i','P','J','Y','L','G','0','U','b','1','w','r','a','q',
1397 'E','l','9','b','d','4','2','h','r','h','z','I','d','c','D','z','l',
1398 'Q','g','x','n','m','8','/','5','c','H','Y','V','x','I','F','/','C',
1399 '2','0','x','/','H','J','p','l','b','1','R','G','6','U','1','i','p',
1400 'F','e','/','q','8','b','y','W','D','/','9','J','p','i','B','K','M',
1401 'G','P','i','9','Y','l','U','T','g','X','H','f','S','9','d','4','S',
1402 '/','Q','W','O','1','h','9','Z','7','K','e','i','p','B','Y','h','o',
1403 's','l','Q','p','H','X','u','y','9','b','U','r','8','A','d','q','i',
1404 '6','S','z','g','H','p','C','n','M','u','5','3','d','x','g','x','U',
1405 'D','1','r','4','x','A','A','=','=',0 };
1407 static void testFileNameStore(void)
1409 static const WCHAR szPrefix
[] = { 'c','e','r',0 };
1410 static const WCHAR spcPrefix
[] = { 's','p','c',0 };
1411 static const WCHAR szDot
[] = { '.',0 };
1412 WCHAR filename
[MAX_PATH
];
1419 /* Crashes on NT4 */
1420 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0, 0, NULL
);
1421 GLE
= GetLastError();
1422 ok(!store
&& (GLE
== ERROR_PATH_NOT_FOUND
|| GLE
== ERROR_INVALID_PARAMETER
),
1423 "Expected ERROR_PATH_NOT_FOUND or ERROR_INVALID_PARAMETER, got %08x\n",
1427 if (!GetTempFileNameW(szDot
, szPrefix
, 0, filename
))
1429 DeleteFileW(filename
);
1431 /* The two flags are mutually exclusive */
1432 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0,
1433 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
| CERT_STORE_READONLY_FLAG
, filename
);
1434 ok(!store
&& GetLastError() == E_INVALIDARG
,
1435 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1437 /* In all of the following tests, the encoding type seems to be ignored */
1438 if (initFileFromData(filename
, bigCert
, sizeof(bigCert
)))
1440 PCCERT_CONTEXT cert
;
1443 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0,
1444 CERT_STORE_READONLY_FLAG
, filename
);
1445 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1447 cert
= CertEnumCertificatesInStore(store
, NULL
);
1448 ok(cert
!= NULL
, "CertEnumCertificatesInStore failed: %08x\n",
1450 cert
= CertEnumCertificatesInStore(store
, cert
);
1451 ok(!cert
, "Expected only one cert\n");
1452 if (pCertEnumCRLsInStore
)
1454 crl
= pCertEnumCRLsInStore(store
, NULL
);
1455 ok(!crl
, "Expected no CRLs\n");
1458 CertCloseStore(store
, 0);
1459 DeleteFileW(filename
);
1461 if (initFileFromData(filename
, serializedStoreWithCert
,
1462 sizeof(serializedStoreWithCert
)))
1464 PCCERT_CONTEXT cert
;
1467 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0,
1468 CERT_STORE_READONLY_FLAG
, filename
);
1469 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1471 cert
= CertEnumCertificatesInStore(store
, NULL
);
1472 ok(cert
!= NULL
, "CertEnumCertificatesInStore failed: %08x\n",
1474 cert
= CertEnumCertificatesInStore(store
, cert
);
1475 ok(!cert
, "Expected only one cert\n");
1476 if (pCertEnumCRLsInStore
)
1478 crl
= pCertEnumCRLsInStore(store
, NULL
);
1479 ok(!crl
, "Expected no CRLs\n");
1482 CertCloseStore(store
, 0);
1483 DeleteFileW(filename
);
1485 if (initFileFromData(filename
, serializedStoreWithCertAndCRL
,
1486 sizeof(serializedStoreWithCertAndCRL
)))
1488 PCCERT_CONTEXT cert
;
1491 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0,
1492 CERT_STORE_READONLY_FLAG
, filename
);
1493 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1495 cert
= CertEnumCertificatesInStore(store
, NULL
);
1496 ok(cert
!= NULL
, "CertEnumCertificatesInStore failed: %08x\n",
1498 cert
= CertEnumCertificatesInStore(store
, cert
);
1499 ok(!cert
, "Expected only one cert\n");
1500 if (pCertEnumCRLsInStore
)
1502 crl
= pCertEnumCRLsInStore(store
, NULL
);
1503 ok(crl
!= NULL
, "CertEnumCRLsInStore failed: %08x\n", GetLastError());
1504 crl
= pCertEnumCRLsInStore(store
, crl
);
1505 ok(!crl
, "Expected only one CRL\n");
1508 CertCloseStore(store
, 0);
1509 /* Don't delete it this time, the next test uses it */
1511 /* Now that the file exists, we can open it read-only */
1512 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0,
1513 CERT_STORE_READONLY_FLAG
, filename
);
1514 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1515 CertCloseStore(store
, 0);
1516 DeleteFileW(filename
);
1518 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0,
1519 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
| CERT_STORE_CREATE_NEW_FLAG
, filename
);
1520 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1523 ret
= CertAddEncodedCertificateToStore(store
, X509_ASN_ENCODING
,
1524 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
1525 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n",
1527 compareStore(store
, "serialized store with cert",
1528 serializedStoreWithCert
, sizeof(serializedStoreWithCert
), FALSE
);
1529 CertCloseStore(store
, 0);
1531 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0,
1532 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
, filename
);
1533 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1536 ret
= CertAddEncodedCRLToStore(store
, X509_ASN_ENCODING
,
1537 signedCRL
, sizeof(signedCRL
), CERT_STORE_ADD_ALWAYS
, NULL
);
1538 ok(ret
, "CertAddEncodedCRLToStore failed: %08x\n", GetLastError());
1539 compareStore(store
, "serialized store with cert and CRL",
1540 serializedStoreWithCertAndCRL
, sizeof(serializedStoreWithCertAndCRL
),
1542 CertCloseStore(store
, 0);
1544 DeleteFileW(filename
);
1546 if (!GetTempFileNameW(szDot
, spcPrefix
, 0, filename
))
1548 DeleteFileW(filename
);
1550 if (initFileFromData(filename
, base64SPC
, sizeof(base64SPC
)))
1552 PCCERT_CONTEXT cert
;
1555 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0,
1556 CERT_STORE_READONLY_FLAG
, filename
);
1557 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1559 cert
= CertEnumCertificatesInStore(store
, NULL
);
1560 ok(cert
!= NULL
, "CertEnumCertificatesInStore failed: %08x\n",
1562 cert
= CertEnumCertificatesInStore(store
, cert
);
1563 ok(!cert
, "Expected only one cert\n");
1564 if (pCertEnumCRLsInStore
)
1566 crl
= pCertEnumCRLsInStore(store
, NULL
);
1567 ok(!crl
, "Expected no CRLs\n");
1570 CertCloseStore(store
, 0);
1571 DeleteFileW(filename
);
1573 if (initFileFromData(filename
, (BYTE
*)utf16Base64SPC
,
1574 sizeof(utf16Base64SPC
)))
1576 PCCERT_CONTEXT cert
;
1579 store
= CertOpenStore(CERT_STORE_PROV_FILENAME_W
, 0, 0,
1580 CERT_STORE_READONLY_FLAG
, filename
);
1581 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1583 cert
= CertEnumCertificatesInStore(store
, NULL
);
1584 ok(cert
!= NULL
, "CertEnumCertificatesInStore failed: %08x\n",
1586 cert
= CertEnumCertificatesInStore(store
, cert
);
1587 ok(!cert
, "Expected only one cert\n");
1588 if (pCertEnumCRLsInStore
)
1590 crl
= pCertEnumCRLsInStore(store
, NULL
);
1591 ok(!crl
, "Expected no CRLs\n");
1594 CertCloseStore(store
, 0);
1595 DeleteFileW(filename
);
1599 static const BYTE signedContent
[] = {
1600 0x30,0x81,0xb2,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
1601 0x81,0xa4,0x30,0x81,0xa1,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
1602 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,
1603 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,
1604 0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,
1605 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
1606 0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
1607 0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,
1608 0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,
1609 0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,
1610 0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,
1611 0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,
1613 static const BYTE signedWithCertAndCrlBareContent
[] = {
1614 0x30,0x82,0x01,0x4f,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,
1615 0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,
1616 0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0xa0,
1617 0x7c,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
1618 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
1619 0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
1620 0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
1621 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
1622 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
1623 0x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,
1624 0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,
1625 0x01,0xff,0x02,0x01,0x01,0xa1,0x2e,0x30,0x2c,0x30,0x02,0x06,0x00,0x30,0x15,
1626 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
1627 0x20,0x4c,0x61,0x6e,0x67,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
1628 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x31,0x77,0x30,0x75,0x02,0x01,0x01,
1629 0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,
1630 0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,
1631 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,
1632 0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,
1633 0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,
1634 0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,
1635 0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,
1636 0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
1637 static const BYTE hashContent
[] = {
1638 0x30,0x47,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x3a,
1639 0x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
1640 0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
1641 0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x04,0x10,0x08,0xd6,0xc0,
1642 0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
1643 static const BYTE hashBareContent
[] = {
1644 0x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
1645 0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
1646 0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x04,0x10,0x08,0xd6,0xc0,
1647 0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
1649 static void testMessageStore(void)
1652 HCRYPTMSG msg
= CryptMsgOpenToDecode(PKCS_7_ASN_ENCODING
, 0, 0, 0, NULL
,
1654 CRYPT_DATA_BLOB blob
= { sizeof(signedWithCertAndCrlBareContent
),
1655 (LPBYTE
)signedWithCertAndCrlBareContent
};
1660 store = CertOpenStore(CERT_STORE_PROV_MSG, 0, 0, 0, NULL);
1662 SetLastError(0xdeadbeef);
1663 store
= CertOpenStore(CERT_STORE_PROV_MSG
, 0, 0, 0, msg
);
1664 ok(!store
&& GetLastError() == CRYPT_E_INVALID_MSG_TYPE
,
1665 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
1666 CryptMsgUpdate(msg
, signedContent
, sizeof(signedContent
), TRUE
);
1667 store
= CertOpenStore(CERT_STORE_PROV_MSG
, 0, 0, 0, msg
);
1668 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1671 PCCERT_CONTEXT cert
= NULL
;
1672 PCCRL_CONTEXT crl
= NULL
;
1676 cert
= CertEnumCertificatesInStore(store
, cert
);
1680 ok(count
== 0, "Expected 0 certificates, got %d\n", count
);
1682 if (pCertEnumCRLsInStore
)
1686 crl
= pCertEnumCRLsInStore(store
, crl
);
1690 ok(count
== 0, "Expected 0 CRLs, got %d\n", count
);
1693 /* Can add certs to a message store */
1694 ret
= CertAddEncodedCertificateToStore(store
, X509_ASN_ENCODING
,
1695 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, NULL
);
1696 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n",
1700 cert
= CertEnumCertificatesInStore(store
, cert
);
1704 ok(count
== 1, "Expected 1 certificate, got %d\n", count
);
1706 CertCloseStore(store
, 0);
1708 /* but the added certs weren't actually added to the message */
1709 size
= sizeof(count
);
1710 ret
= CryptMsgGetParam(msg
, CMSG_CERT_COUNT_PARAM
, 0, &count
, &size
);
1711 ok(ret
, "CryptMsgGetParam failed: %08x\n", GetLastError());
1712 ok(count
== 0, "Expected 0 certificates, got %d\n", count
);
1716 store = CertOpenStore(CERT_STORE_PROV_PKCS7, 0, 0, 0, NULL);
1718 store
= CertOpenStore(CERT_STORE_PROV_PKCS7
, 0, 0, 0, &blob
);
1719 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1723 PCCERT_CONTEXT cert
= NULL
;
1724 PCCRL_CONTEXT crl
= NULL
;
1727 cert
= CertEnumCertificatesInStore(store
, cert
);
1731 ok(count
== 1, "Expected 1 certificate, got %d\n", count
);
1733 if (pCertEnumCRLsInStore
)
1737 crl
= pCertEnumCRLsInStore(store
, crl
);
1741 ok(count
== 1, "Expected 1 CRL, got %d\n", count
);
1743 CertCloseStore(store
, 0);
1745 /* Encoding appears to be ignored */
1746 store
= CertOpenStore(CERT_STORE_PROV_PKCS7
, X509_ASN_ENCODING
, 0, 0,
1748 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1750 CertCloseStore(store
, 0);
1751 /* Messages other than signed messages aren't allowed */
1752 blob
.cbData
= sizeof(hashContent
);
1753 blob
.pbData
= (LPBYTE
)hashContent
;
1754 SetLastError(0xdeadbeef);
1755 store
= CertOpenStore(CERT_STORE_PROV_PKCS7
, 0, 0, 0, &blob
);
1756 ok(!store
&& GetLastError() == CRYPT_E_INVALID_MSG_TYPE
,
1757 "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
1758 blob
.cbData
= sizeof(hashBareContent
);
1759 blob
.pbData
= (LPBYTE
)hashBareContent
;
1760 SetLastError(0xdeadbeef);
1761 store
= CertOpenStore(CERT_STORE_PROV_PKCS7
, 0, 0, 0, &blob
);
1763 (GetLastError() == CRYPT_E_ASN1_BADTAG
||
1764 broken(GetLastError() == OSS_DATA_ERROR
)), /* NT4 */
1765 "Expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError());
1768 static void testSerializedStore(void)
1771 CRYPT_DATA_BLOB blob
;
1776 store
= CertOpenStore(CERT_STORE_PROV_SERIALIZED
, 0, 0, 0, NULL
);
1777 store
= CertOpenStore(CERT_STORE_PROV_SERIALIZED
, 0, 0,
1778 CERT_STORE_DELETE_FLAG
, NULL
);
1780 blob
.cbData
= sizeof(serializedStoreWithCert
);
1781 blob
.pbData
= (BYTE
*)serializedStoreWithCert
;
1782 store
= CertOpenStore(CERT_STORE_PROV_SERIALIZED
, 0, 0,
1783 CERT_STORE_DELETE_FLAG
, &blob
);
1784 ok(!store
&& GetLastError() == ERROR_CALL_NOT_IMPLEMENTED
,
1785 "Expected ERROR_CALL_NOT_IMPLEMENTED, got %08x\n", GetLastError());
1786 store
= CertOpenStore(CERT_STORE_PROV_SERIALIZED
, 0, 0, 0, &blob
);
1787 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1790 PCCERT_CONTEXT cert
;
1793 cert
= CertEnumCertificatesInStore(store
, NULL
);
1794 ok(cert
!= NULL
, "CertEnumCertificatesInStore failed: %08x\n",
1796 cert
= CertEnumCertificatesInStore(store
, cert
);
1797 ok(!cert
, "Expected only one cert\n");
1798 if (pCertEnumCRLsInStore
)
1800 crl
= pCertEnumCRLsInStore(store
, NULL
);
1801 ok(!crl
, "Expected no CRLs\n");
1803 CertCloseStore(store
, 0);
1805 blob
.cbData
= sizeof(serializedStoreWithCertAndCRL
);
1806 blob
.pbData
= (BYTE
*)serializedStoreWithCertAndCRL
;
1807 store
= CertOpenStore(CERT_STORE_PROV_SERIALIZED
, 0, 0, 0, &blob
);
1808 ok(store
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
1811 PCCERT_CONTEXT cert
;
1814 cert
= CertEnumCertificatesInStore(store
, NULL
);
1815 ok(cert
!= NULL
, "CertEnumCertificatesInStore failed: %08x\n",
1817 cert
= CertEnumCertificatesInStore(store
, cert
);
1818 ok(!cert
, "Expected only one cert\n");
1819 if (pCertEnumCRLsInStore
)
1821 crl
= pCertEnumCRLsInStore(store
, NULL
);
1822 ok(crl
!= NULL
, "CertEnumCRLsInStore failed: %08x\n",
1824 crl
= pCertEnumCRLsInStore(store
, crl
);
1825 ok(!crl
, "Expected only one CRL\n");
1827 CertCloseStore(store
, 0);
1831 static void testCertOpenSystemStore(void)
1835 store
= CertOpenSystemStoreW(0, NULL
);
1836 ok(!store
&& GetLastError() == E_INVALIDARG
,
1837 "Expected E_INVALIDARG, got %08x\n", GetLastError());
1838 /* This succeeds, and on WinXP at least, the Bogus key is created under
1839 * HKCU (but not under HKLM, even when run as an administrator.)
1841 store
= CertOpenSystemStoreW(0, BogusW
);
1842 ok(store
!= 0, "CertOpenSystemStore failed: %08x\n", GetLastError());
1844 CertCloseStore(store
, 0);
1845 /* Delete it so other tests succeed next time around */
1846 CertOpenStore(CERT_STORE_PROV_SYSTEM
, 0, 0,
1847 CERT_SYSTEM_STORE_CURRENT_USER
| CERT_STORE_DELETE_FLAG
, BogusW
);
1848 RegDeleteKeyW(HKEY_CURRENT_USER
, BogusPathW
);
1851 struct EnumSystemStoreInfo
1857 static BOOL CALLBACK
enumSystemStoreCB(const void *systemStore
, DWORD dwFlags
,
1858 PCERT_SYSTEM_STORE_INFO pStoreInfo
, void *pvReserved
, void *pvArg
)
1860 struct EnumSystemStoreInfo
*info
= pvArg
;
1866 static void testCertEnumSystemStore(void)
1869 struct EnumSystemStoreInfo info
= { FALSE
, 0 };
1871 if (!pCertEnumSystemStore
)
1873 win_skip("CertEnumSystemStore() is not available\n");
1877 SetLastError(0xdeadbeef);
1878 ret
= pCertEnumSystemStore(0, NULL
, NULL
, NULL
);
1879 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
1880 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1882 ret = pCertEnumSystemStore(CERT_SYSTEM_STORE_LOCAL_MACHINE, NULL, NULL,
1886 SetLastError(0xdeadbeef);
1887 ret
= pCertEnumSystemStore(CERT_SYSTEM_STORE_LOCAL_MACHINE
, NULL
, &info
,
1889 /* Callback returning FALSE stops enumeration */
1890 ok(!ret
, "Expected CertEnumSystemStore to stop\n");
1891 ok(info
.storeCount
== 0 || info
.storeCount
== 1,
1892 "Expected 0 or 1 stores\n");
1895 info
.storeCount
= 0;
1896 ret
= pCertEnumSystemStore(CERT_SYSTEM_STORE_LOCAL_MACHINE
, NULL
, &info
,
1898 ok(ret
, "CertEnumSystemStore failed: %08x\n", GetLastError());
1899 /* There should always be at least My, Root, and CA stores */
1900 ok(info
.storeCount
== 0 || info
.storeCount
>= 3,
1901 "Expected at least 3 stores\n");
1904 static void testStoreProperty(void)
1908 DWORD propID
, size
= 0, state
;
1909 CRYPT_DATA_BLOB blob
;
1911 if (!pCertGetStoreProperty
|| !pCertSetStoreProperty
)
1913 win_skip("CertGet/SetStoreProperty() is not available\n");
1918 ret = pCertGetStoreProperty(NULL, 0, NULL, NULL);
1919 ret = pCertGetStoreProperty(NULL, 0, NULL, &size);
1920 ret = pCertGetStoreProperty(store, 0, NULL, NULL);
1923 store
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
1924 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
1925 /* Check a missing prop ID */
1926 SetLastError(0xdeadbeef);
1927 ret
= pCertGetStoreProperty(store
, 0, NULL
, &size
);
1928 ok(!ret
&& GetLastError() == CRYPT_E_NOT_FOUND
,
1929 "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError());
1930 /* Contrary to MSDN, CERT_ACCESS_STATE_PROP_ID is supported for stores.. */
1931 size
= sizeof(state
);
1932 ret
= pCertGetStoreProperty(store
, CERT_ACCESS_STATE_PROP_ID
, &state
, &size
);
1933 ok(ret
, "CertGetStoreProperty failed for CERT_ACCESS_STATE_PROP_ID: %08x\n",
1935 ok(!state
, "Expected a non-persisted store\n");
1936 /* and CERT_STORE_LOCALIZED_NAME_PROP_ID isn't supported by default. */
1938 ret
= pCertGetStoreProperty(store
, CERT_STORE_LOCALIZED_NAME_PROP_ID
, NULL
,
1940 ok(!ret
&& GetLastError() == CRYPT_E_NOT_FOUND
,
1941 "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError());
1942 /* Delete an arbitrary property on a store */
1943 ret
= pCertSetStoreProperty(store
, CERT_FIRST_USER_PROP_ID
, 0, NULL
);
1944 ok(ret
, "CertSetStoreProperty failed: %08x\n", GetLastError());
1945 /* Set an arbitrary property on a store */
1946 blob
.pbData
= (LPBYTE
)&state
;
1947 blob
.cbData
= sizeof(state
);
1948 ret
= pCertSetStoreProperty(store
, CERT_FIRST_USER_PROP_ID
, 0, &blob
);
1949 ok(ret
, "CertSetStoreProperty failed: %08x\n", GetLastError());
1950 /* Get an arbitrary property that's been set */
1951 ret
= pCertGetStoreProperty(store
, CERT_FIRST_USER_PROP_ID
, NULL
, &size
);
1952 ok(ret
, "CertGetStoreProperty failed: %08x\n", GetLastError());
1953 ok(size
== sizeof(state
), "Unexpected data size %d\n", size
);
1954 ret
= pCertGetStoreProperty(store
, CERT_FIRST_USER_PROP_ID
, &propID
, &size
);
1955 ok(ret
, "CertGetStoreProperty failed: %08x\n", GetLastError());
1956 ok(propID
== state
, "CertGetStoreProperty got the wrong value\n");
1957 /* Delete it again */
1958 ret
= pCertSetStoreProperty(store
, CERT_FIRST_USER_PROP_ID
, 0, NULL
);
1959 ok(ret
, "CertSetStoreProperty failed: %08x\n", GetLastError());
1960 /* And check that it's missing */
1961 SetLastError(0xdeadbeef);
1962 ret
= pCertGetStoreProperty(store
, CERT_FIRST_USER_PROP_ID
, NULL
, &size
);
1963 ok(!ret
&& GetLastError() == CRYPT_E_NOT_FOUND
,
1964 "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError());
1965 CertCloseStore(store
, 0);
1967 /* Recheck on the My store.. */
1968 store
= CertOpenSystemStoreW(0, MyW
);
1969 size
= sizeof(state
);
1970 ret
= pCertGetStoreProperty(store
, CERT_ACCESS_STATE_PROP_ID
, &state
, &size
);
1971 ok(ret
, "CertGetStoreProperty failed for CERT_ACCESS_STATE_PROP_ID: %08x\n",
1973 ok(state
, "Expected a persisted store\n");
1974 SetLastError(0xdeadbeef);
1976 ret
= pCertGetStoreProperty(store
, CERT_STORE_LOCALIZED_NAME_PROP_ID
, NULL
,
1978 ok(!ret
&& GetLastError() == CRYPT_E_NOT_FOUND
,
1979 "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError());
1980 CertCloseStore(store
, 0);
1983 static void testAddSerialized(void)
1987 BYTE buf
[sizeof(struct CertPropIDHeader
) * 2 + 20 + sizeof(bigCert
)] =
1990 struct CertPropIDHeader
*hdr
;
1991 PCCERT_CONTEXT context
;
1993 ret
= CertAddSerializedElementToStore(0, NULL
, 0, 0, 0, 0, NULL
, NULL
);
1994 ok(!ret
&& GetLastError() == ERROR_END_OF_MEDIA
,
1995 "Expected ERROR_END_OF_MEDIA, got %08x\n", GetLastError());
1997 store
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
1998 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
1999 ok(store
!= 0, "CertOpenStore failed: %08x\n", GetLastError());
2001 ret
= CertAddSerializedElementToStore(store
, NULL
, 0, 0, 0, 0, NULL
, NULL
);
2002 ok(!ret
&& GetLastError() == ERROR_END_OF_MEDIA
,
2003 "Expected ERROR_END_OF_MEDIA, got %08x\n", GetLastError());
2005 /* Test with an empty property */
2006 hdr
= (struct CertPropIDHeader
*)buf
;
2007 hdr
->propID
= CERT_CERT_PROP_ID
;
2010 ret
= CertAddSerializedElementToStore(store
, buf
, sizeof(buf
), 0, 0, 0,
2012 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2013 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2014 /* Test with a bad size in property header */
2015 hdr
->cb
= sizeof(bigCert
) - 1;
2016 memcpy(buf
+ sizeof(struct CertPropIDHeader
), bigCert
, sizeof(bigCert
));
2017 ret
= CertAddSerializedElementToStore(store
, buf
, sizeof(buf
), 0, 0, 0,
2019 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2020 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2021 ret
= CertAddSerializedElementToStore(store
, buf
,
2022 sizeof(struct CertPropIDHeader
) + sizeof(bigCert
), 0, 0, 0, NULL
,
2024 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2025 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2026 ret
= CertAddSerializedElementToStore(store
, buf
,
2027 sizeof(struct CertPropIDHeader
) + sizeof(bigCert
), CERT_STORE_ADD_NEW
,
2029 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2030 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2031 /* Kosher size in property header, but no context type */
2032 hdr
->cb
= sizeof(bigCert
);
2033 ret
= CertAddSerializedElementToStore(store
, buf
, sizeof(buf
), 0, 0, 0,
2035 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2036 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2037 ret
= CertAddSerializedElementToStore(store
, buf
,
2038 sizeof(struct CertPropIDHeader
) + sizeof(bigCert
), 0, 0, 0, NULL
,
2040 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2041 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2042 ret
= CertAddSerializedElementToStore(store
, buf
,
2043 sizeof(struct CertPropIDHeader
) + sizeof(bigCert
), CERT_STORE_ADD_NEW
,
2045 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2046 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2047 /* With a bad context type */
2048 ret
= CertAddSerializedElementToStore(store
, buf
, sizeof(buf
), 0, 0,
2049 CERT_STORE_CRL_CONTEXT_FLAG
, NULL
, NULL
);
2050 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2051 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2052 ret
= CertAddSerializedElementToStore(store
, buf
,
2053 sizeof(struct CertPropIDHeader
) + sizeof(bigCert
), 0, 0,
2054 CERT_STORE_CRL_CONTEXT_FLAG
, NULL
, NULL
);
2055 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2056 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2057 ret
= CertAddSerializedElementToStore(store
, buf
,
2058 sizeof(struct CertPropIDHeader
) + sizeof(bigCert
), CERT_STORE_ADD_NEW
,
2059 0, CERT_STORE_CRL_CONTEXT_FLAG
, NULL
, NULL
);
2060 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2061 "Expected E_INVALIDARG, got %08x\n", GetLastError());
2062 /* Bad unknown field, good type */
2064 ret
= CertAddSerializedElementToStore(store
, buf
, sizeof(buf
), 0, 0,
2065 CERT_STORE_CERTIFICATE_CONTEXT_FLAG
, NULL
, NULL
);
2066 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
2067 "Expected ERROR_FILE_NOT_FOUND got %08x\n", GetLastError());
2068 ret
= CertAddSerializedElementToStore(store
, buf
,
2069 sizeof(struct CertPropIDHeader
) + sizeof(bigCert
), 0, 0,
2070 CERT_STORE_CERTIFICATE_CONTEXT_FLAG
, NULL
, NULL
);
2071 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
2072 "Expected ERROR_FILE_NOT_FOUND got %08x\n", GetLastError());
2073 ret
= CertAddSerializedElementToStore(store
, buf
,
2074 sizeof(struct CertPropIDHeader
) + sizeof(bigCert
), CERT_STORE_ADD_NEW
,
2075 0, CERT_STORE_CERTIFICATE_CONTEXT_FLAG
, NULL
, NULL
);
2076 ok(!ret
&& GetLastError() == ERROR_FILE_NOT_FOUND
,
2077 "Expected ERROR_FILE_NOT_FOUND got %08x\n", GetLastError());
2078 /* Most everything okay, but bad add disposition */
2081 ret = CertAddSerializedElementToStore(store, buf, sizeof(buf), 0, 0,
2082 CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, NULL);
2084 ret = CertAddSerializedElementToStore(store, buf,
2085 sizeof(struct CertPropIDHeader) + sizeof(bigCert), 0, 0,
2086 CERT_STORE_CERTIFICATE_CONTEXT_FLAG, NULL, NULL);
2088 /* Everything okay, but buffer's too big */
2089 ret
= CertAddSerializedElementToStore(store
, buf
, sizeof(buf
),
2090 CERT_STORE_ADD_NEW
, 0, CERT_STORE_CERTIFICATE_CONTEXT_FLAG
, NULL
, NULL
);
2091 ok(ret
, "CertAddSerializedElementToStore failed: %08x\n", GetLastError());
2092 /* Everything okay, check it's not re-added */
2093 ret
= CertAddSerializedElementToStore(store
, buf
,
2094 sizeof(struct CertPropIDHeader
) + sizeof(bigCert
), CERT_STORE_ADD_NEW
,
2095 0, CERT_STORE_CERTIFICATE_CONTEXT_FLAG
, NULL
, NULL
);
2096 ok(!ret
&& GetLastError() == CRYPT_E_EXISTS
,
2097 "Expected CRYPT_E_EXISTS, got %08x\n", GetLastError());
2099 context
= CertEnumCertificatesInStore(store
, NULL
);
2100 ok(context
!= NULL
, "Expected a cert\n");
2102 CertDeleteCertificateFromStore(context
);
2104 /* Try adding with a bogus hash. Oddly enough, it succeeds, and the hash,
2105 * when queried, is the real hash rather than the bogus hash.
2107 hdr
= (struct CertPropIDHeader
*)(buf
+ sizeof(struct CertPropIDHeader
) +
2109 hdr
->propID
= CERT_HASH_PROP_ID
;
2111 hdr
->cb
= sizeof(hash
);
2112 memset(hash
, 0xc, sizeof(hash
));
2113 memcpy((LPBYTE
)hdr
+ sizeof(struct CertPropIDHeader
), hash
, sizeof(hash
));
2114 ret
= CertAddSerializedElementToStore(store
, buf
, sizeof(buf
),
2115 CERT_STORE_ADD_NEW
, 0, CERT_STORE_CERTIFICATE_CONTEXT_FLAG
, NULL
,
2116 (const void **)&context
);
2117 ok(ret
, "CertAddSerializedElementToStore failed: %08x\n", GetLastError());
2120 BYTE hashVal
[20], realHash
[20];
2121 DWORD size
= sizeof(hashVal
);
2123 ret
= CryptHashCertificate(0, 0, 0, bigCert
, sizeof(bigCert
),
2125 ok(ret
, "CryptHashCertificate failed: %08x\n", GetLastError());
2126 ret
= CertGetCertificateContextProperty(context
, CERT_HASH_PROP_ID
,
2128 ok(ret
, "CertGetCertificateContextProperty failed: %08x\n",
2130 ok(!memcmp(hashVal
, realHash
, size
), "Unexpected hash\n");
2131 CertFreeCertificateContext(context
);
2134 CertCloseStore(store
, 0);
2137 static const BYTE serializedCertWithFriendlyName
[] = {
2138 0x0b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x12,0x00,0x00,0x00,0x57,0x00,0x69,
2139 0x00,0x6e,0x00,0x65,0x00,0x54,0x00,0x65,0x00,0x73,0x00,0x74,0x00,0x00,0x00,
2140 0x20,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x7c,0x00,0x00,0x00,0x30,0x7a,0x02,
2141 0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,
2142 0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,
2143 0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,
2144 0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,
2145 0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,
2146 0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x07,
2147 0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,
2148 0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,
2150 static const BYTE serializedStoreWithCertWithFriendlyName
[] = {
2151 0x00,0x00,0x00,0x00,0x43,0x45,0x52,0x54,0x0b,0x00,0x00,0x00,0x01,0x00,0x00,
2152 0x00,0x12,0x00,0x00,0x00,0x57,0x00,0x69,0x00,0x6e,0x00,0x65,0x00,0x54,0x00,
2153 0x65,0x00,0x73,0x00,0x74,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x01,0x00,0x00,
2154 0x00,0x7c,0x00,0x00,0x00,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,
2155 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
2156 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,
2157 0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,
2158 0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,
2159 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
2160 0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,
2161 0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,
2162 0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
2163 0x00,0x00,0x00,0x00,0x00,0x00 };
2164 static const BYTE serializedStoreWithCertAndHash
[] = {
2165 0x00,0x00,0x00,0x00,0x43,0x45,0x52,0x54,0x03,0x00,0x00,0x00,0x01,0x00,0x00,
2166 0x00,0x14,0x00,0x00,0x00,0x6e,0x30,0x90,0x71,0x5f,0xd9,0x23,0x56,0xeb,0xae,
2167 0x25,0x40,0xe6,0x22,0xda,0x19,0x26,0x02,0xa6,0x08,0x20,0x00,0x00,0x00,0x01,
2168 0x00,0x00,0x00,0x7c,0x00,0x00,0x00,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,
2169 0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,
2170 0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,
2171 0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,
2172 0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,
2173 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,
2174 0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,
2175 0x01,0x00,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,
2176 0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01,0x00,0x00,0x00,0x00,
2177 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
2179 static void testAddCertificateLink(void)
2182 HCERTSTORE store1
, store2
;
2183 PCCERT_CONTEXT source
, linked
;
2186 CERT_NAME_BLOB blob
;
2187 static const WCHAR szPrefix
[] = { 'c','e','r',0 };
2188 static const WCHAR szDot
[] = { '.',0 };
2189 static const WCHAR WineTestW
[] = { 'W','i','n','e','T','e','s','t',0 };
2190 WCHAR filename1
[MAX_PATH
], filename2
[MAX_PATH
];
2193 if (!pCertAddCertificateLinkToStore
)
2195 win_skip("CertAddCertificateLinkToStore not found\n");
2201 /* Crashes, i.e. the store is dereferenced without checking. */
2202 ret
= pCertAddCertificateLinkToStore(NULL
, NULL
, 0, NULL
);
2205 /* Adding a certificate link to a store requires a valid add disposition */
2206 store1
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
2207 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
2208 SetLastError(0xdeadbeef);
2209 ret
= pCertAddCertificateLinkToStore(store1
, NULL
, 0, NULL
);
2210 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2211 "expected E_INVALIDARG, got %08x\n", GetLastError());
2212 source
= CertCreateCertificateContext(X509_ASN_ENCODING
, bigCert
,
2214 SetLastError(0xdeadbeef);
2215 ret
= pCertAddCertificateLinkToStore(store1
, source
, 0, NULL
);
2216 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2217 "expected E_INVALIDARG, got %08x\n", GetLastError());
2218 ret
= pCertAddCertificateLinkToStore(store1
, source
, CERT_STORE_ADD_ALWAYS
,
2220 ok(ret
, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError());
2223 /* Crashes, i.e. the source certificate is dereferenced without
2224 * checking when a valid add disposition is given.
2226 ret
= pCertAddCertificateLinkToStore(store1
, NULL
, CERT_STORE_ADD_ALWAYS
,
2229 CertCloseStore(store1
, 0);
2231 store1
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
2232 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
2233 ret
= pCertAddCertificateLinkToStore(store1
, source
, CERT_STORE_ADD_ALWAYS
,
2235 ok(ret
, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError());
2238 ok(linked
->hCertStore
== store1
, "unexpected store\n");
2239 ret
= CertSerializeCertificateStoreElement(linked
, 0, NULL
, &size
);
2240 ok(ret
, "CertSerializeCertificateStoreElement failed: %08x\n",
2242 buf
= HeapAlloc(GetProcessHeap(), 0, size
);
2245 ret
= CertSerializeCertificateStoreElement(linked
, 0, buf
, &size
);
2246 ok(ret
, "CertSerializeCertificateStoreElement failed: %08x\n",
2248 /* The serialized linked certificate is identical to the serialized
2249 * original certificate.
2251 ok(size
== sizeof(serializedCert
), "Wrong size %d\n", size
);
2252 ok(!memcmp(serializedCert
, buf
, size
),
2253 "Unexpected serialized cert\n");
2254 HeapFree(GetProcessHeap(), 0, buf
);
2256 /* Set a friendly name on the source certificate... */
2257 blob
.pbData
= (LPBYTE
)WineTestW
;
2258 blob
.cbData
= sizeof(WineTestW
);
2259 ret
= CertSetCertificateContextProperty(source
,
2260 CERT_FRIENDLY_NAME_PROP_ID
, 0, &blob
);
2261 ok(ret
, "CertSetCertificateContextProperty failed: %08x\n",
2263 /* and the linked certificate has the same friendly name. */
2264 ret
= CertGetCertificateContextProperty(linked
,
2265 CERT_FRIENDLY_NAME_PROP_ID
, NULL
, &size
);
2266 ok(ret
, "CertGetCertificateContextProperty failed: %08x\n",
2268 buf
= HeapAlloc(GetProcessHeap(), 0, size
);
2271 ret
= CertGetCertificateContextProperty(linked
,
2272 CERT_FRIENDLY_NAME_PROP_ID
, buf
, &size
);
2273 ok(ret
, "CertGetCertificateContextProperty failed: %08x\n",
2275 ok(!lstrcmpW((LPCWSTR
)buf
, WineTestW
),
2276 "unexpected friendly name\n");
2277 HeapFree(GetProcessHeap(), 0, buf
);
2279 CertFreeCertificateContext(linked
);
2281 CertFreeCertificateContext(source
);
2282 CertCloseStore(store1
, 0);
2284 /* Test adding a cert to a file store, committing the change to the store,
2285 * and creating a link to the resulting cert.
2287 if (!GetTempFileNameW(szDot
, szPrefix
, 0, filename1
))
2290 DeleteFileW(filename1
);
2291 file
= CreateFileW(filename1
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
2292 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2293 if (file
== INVALID_HANDLE_VALUE
)
2296 store1
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
2297 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
, file
);
2298 ok(store1
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
2301 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
,
2302 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, &source
);
2303 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n",
2306 /* Test adding a link to a memory store. */
2307 store2
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
2308 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
2309 ret
= pCertAddCertificateLinkToStore(store2
, source
, CERT_STORE_ADD_ALWAYS
,
2311 ok(ret
, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError());
2314 ok(linked
->hCertStore
== store2
, "unexpected store\n");
2315 ret
= CertSerializeCertificateStoreElement(linked
, 0, NULL
, &size
);
2316 ok(ret
, "CertSerializeCertificateStoreElement failed: %08x\n",
2318 buf
= HeapAlloc(GetProcessHeap(), 0, size
);
2321 ret
= CertSerializeCertificateStoreElement(linked
, 0, buf
, &size
);
2322 /* The serialized linked certificate is identical to the serialized
2323 * original certificate.
2325 ok(ret
, "CertSerializeCertificateStoreElement failed: %08x\n", GetLastError());
2326 ok(size
== sizeof(serializedCert
), "Wrong size %d\n", size
);
2327 ok(!memcmp(serializedCert
, buf
, size
),
2328 "Unexpected serialized cert\n");
2329 HeapFree(GetProcessHeap(), 0, buf
);
2331 /* Set a friendly name on the source certificate... */
2332 blob
.pbData
= (LPBYTE
)WineTestW
;
2333 blob
.cbData
= sizeof(WineTestW
);
2334 ret
= CertSetCertificateContextProperty(source
,
2335 CERT_FRIENDLY_NAME_PROP_ID
, 0, &blob
);
2336 ok(ret
, "CertSetCertificateContextProperty failed: %08x\n",
2338 /* and the linked certificate has the same friendly name. */
2339 ret
= CertGetCertificateContextProperty(linked
,
2340 CERT_FRIENDLY_NAME_PROP_ID
, NULL
, &size
);
2341 ok(ret
, "CertGetCertificateContextProperty failed: %08x\n",
2343 buf
= HeapAlloc(GetProcessHeap(), 0, size
);
2346 ret
= CertGetCertificateContextProperty(linked
,
2347 CERT_FRIENDLY_NAME_PROP_ID
, buf
, &size
);
2348 ok(ret
, "CertGetCertificateContextProperty failed: %08x\n", GetLastError());
2349 ok(!lstrcmpW((LPCWSTR
)buf
, WineTestW
),
2350 "unexpected friendly name\n");
2351 HeapFree(GetProcessHeap(), 0, buf
);
2353 CertFreeCertificateContext(linked
);
2355 CertCloseStore(store2
, 0);
2357 if (!GetTempFileNameW(szDot
, szPrefix
, 0, filename2
))
2360 DeleteFileW(filename2
);
2361 file
= CreateFileW(filename2
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
2362 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2363 if (file
== INVALID_HANDLE_VALUE
)
2366 store2
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
2367 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
, file
);
2368 ok(store2
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
2370 /* Test adding a link to a file store. */
2371 ret
= pCertAddCertificateLinkToStore(store2
, source
, CERT_STORE_ADD_ALWAYS
,
2373 ok(ret
, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError());
2376 ok(linked
->hCertStore
== store2
, "unexpected store\n");
2377 ret
= CertSerializeCertificateStoreElement(linked
, 0, NULL
, &size
);
2378 ok(ret
, "CertSerializeCertificateStoreElement failed: %08x\n",
2380 buf
= HeapAlloc(GetProcessHeap(), 0, size
);
2383 ret
= CertSerializeCertificateStoreElement(linked
, 0, buf
, &size
);
2384 ok(ret
, "CertSerializeCertificateStoreElement failed: %08x\n",
2386 /* The serialized linked certificate now contains the friendly
2389 ok(size
== sizeof(serializedCertWithFriendlyName
),
2390 "Wrong size %d\n", size
);
2391 ok(!memcmp(serializedCertWithFriendlyName
, buf
, size
),
2392 "Unexpected serialized cert\n");
2393 HeapFree(GetProcessHeap(), 0, buf
);
2395 CertFreeCertificateContext(linked
);
2396 compareStore(store2
, "file store -> file store",
2397 serializedStoreWithCertWithFriendlyName
,
2398 sizeof(serializedStoreWithCertWithFriendlyName
), FALSE
);
2400 CertCloseStore(store2
, 0);
2401 DeleteFileW(filename2
);
2403 CertFreeCertificateContext(source
);
2405 CertCloseStore(store1
, 0);
2406 DeleteFileW(filename1
);
2408 /* Test adding a link to a system store (which is a collection store.) */
2409 store1
= CertOpenSystemStoreA(0, "My");
2410 source
= CertCreateCertificateContext(X509_ASN_ENCODING
, bigCert
,
2412 SetLastError(0xdeadbeef);
2413 ret
= pCertAddCertificateLinkToStore(store1
, source
, CERT_STORE_ADD_ALWAYS
,
2415 ok(!ret
&& GetLastError() == E_INVALIDARG
,
2416 "expected E_INVALIDARG, got %08x\n", GetLastError());
2417 CertFreeCertificateContext(source
);
2419 /* Test adding a link to a file store, where the linked certificate is
2420 * in a system store.
2422 ret
= CertAddEncodedCertificateToStore(store1
, X509_ASN_ENCODING
,
2423 bigCert
, sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, &source
);
2424 ok(ret
, "CertAddEncodedCertificateToStore failed: %08x\n",
2426 if (!GetTempFileNameW(szDot
, szPrefix
, 0, filename1
))
2429 DeleteFileW(filename1
);
2430 file
= CreateFileW(filename1
, GENERIC_READ
| GENERIC_WRITE
, 0, NULL
,
2431 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
2432 if (file
== INVALID_HANDLE_VALUE
)
2435 store2
= CertOpenStore(CERT_STORE_PROV_FILE
, 0, 0,
2436 CERT_FILE_STORE_COMMIT_ENABLE_FLAG
, file
);
2437 ok(store2
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
2440 ret
= pCertAddCertificateLinkToStore(store2
, source
, CERT_STORE_ADD_ALWAYS
,
2442 ok(ret
, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError());
2445 ok(linked
->hCertStore
== store2
, "unexpected store\n");
2446 ret
= pCertControlStore(store2
, 0, CERT_STORE_CTRL_COMMIT
, NULL
);
2447 ok(ret
, "CertControlStore failed: %d\n", ret
);
2448 compareStore(store2
, "file store -> system store",
2449 serializedStoreWithCertAndHash
,
2450 sizeof(serializedStoreWithCertAndHash
), TRUE
);
2451 CertFreeCertificateContext(linked
);
2454 CertCloseStore(store2
, 0);
2455 DeleteFileW(filename1
);
2457 /* Test adding a link to a registry store, where the linked certificate is
2458 * in a system store.
2460 store2
= CertOpenStore(CERT_STORE_PROV_SYSTEM_REGISTRY
, 0, 0,
2461 CERT_SYSTEM_STORE_CURRENT_USER
, WineTestW
);
2462 ok(store2
!= NULL
, "CertOpenStore failed: %08x\n", GetLastError());
2463 ret
= pCertAddCertificateLinkToStore(store2
, source
, CERT_STORE_ADD_ALWAYS
,
2465 ok(ret
, "CertAddCertificateLinkToStore failed: %08x\n", GetLastError());
2468 ok(linked
->hCertStore
== store2
, "unexpected store\n");
2469 CertDeleteCertificateFromStore(linked
);
2471 CertCloseStore(store2
, 0);
2473 CertFreeCertificateContext(source
);
2474 CertCloseStore(store1
, 0);
2477 static DWORD
countCertsInStore(HCERTSTORE store
)
2479 PCCERT_CONTEXT cert
= NULL
;
2483 cert
= CertEnumCertificatesInStore(store
, cert
);
2490 static DWORD
countCRLsInStore(HCERTSTORE store
)
2492 PCCRL_CONTEXT crl
= NULL
;
2496 crl
= pCertEnumCRLsInStore(store
, crl
);
2503 static void test_I_UpdateStore(void)
2505 HMODULE lib
= GetModuleHandleA("crypt32");
2506 BOOL (WINAPI
*pI_CertUpdatestore
)(HCERTSTORE
, HCERTSTORE
, DWORD
, DWORD
) =
2507 (void *)GetProcAddress(lib
, "I_CertUpdateStore");
2509 HCERTSTORE store1
, store2
;
2510 PCCERT_CONTEXT cert
;
2513 if (!pI_CertUpdatestore
)
2515 win_skip("No I_CertUpdateStore\n");
2518 store1
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
2519 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
2520 store2
= CertOpenStore(CERT_STORE_PROV_MEMORY
, 0, 0,
2521 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
2524 ret = pI_CertUpdatestore(NULL, NULL, 0, 0);
2525 ret = pI_CertUpdatestore(store1, NULL, 0, 0);
2526 ret = pI_CertUpdatestore(NULL, store2, 0, 0);
2528 ret
= pI_CertUpdatestore(store1
, store2
, 0, 0);
2529 ok(ret
, "I_CertUpdateStore failed: %08x\n", GetLastError());
2531 CertAddEncodedCertificateToStore(store2
, X509_ASN_ENCODING
, bigCert
,
2532 sizeof(bigCert
), CERT_STORE_ADD_ALWAYS
, &cert
);
2533 /* I_CertUpdateStore adds the contexts from store2 to store1 */
2534 ret
= pI_CertUpdatestore(store1
, store2
, 0, 0);
2535 ok(ret
, "I_CertUpdateStore failed: %08x\n", GetLastError());
2536 certs
= countCertsInStore(store1
);
2537 ok(certs
== 1, "Expected 1 cert, got %d\n", certs
);
2538 /* Calling it a second time has no effect */
2539 ret
= pI_CertUpdatestore(store1
, store2
, 0, 0);
2540 ok(ret
, "I_CertUpdateStore failed: %08x\n", GetLastError());
2541 certs
= countCertsInStore(store1
);
2542 ok(certs
== 1, "Expected 1 cert, got %d\n", certs
);
2544 /* The last parameters to I_CertUpdateStore appear to be ignored */
2545 ret
= pI_CertUpdatestore(store1
, store2
, 1, 0);
2546 ok(ret
, "I_CertUpdateStore failed: %08x\n", GetLastError());
2547 ret
= pI_CertUpdatestore(store1
, store2
, 0, 1);
2548 ok(ret
, "I_CertUpdateStore failed: %08x\n", GetLastError());
2550 CertAddEncodedCRLToStore(store2
, X509_ASN_ENCODING
, signedCRL
,
2551 sizeof(signedCRL
), CERT_STORE_ADD_ALWAYS
, NULL
);
2553 /* I_CertUpdateStore also adds the CRLs from store2 to store1 */
2554 ret
= pI_CertUpdatestore(store1
, store2
, 0, 0);
2555 ok(ret
, "I_CertUpdateStore failed: %08x\n", GetLastError());
2556 certs
= countCertsInStore(store1
);
2557 ok(certs
== 1, "Expected 1 cert, got %d\n", certs
);
2558 if (pCertEnumCRLsInStore
)
2560 certs
= countCRLsInStore(store1
);
2561 ok(certs
== 1, "Expected 1 CRL, got %d\n", certs
);
2564 CertDeleteCertificateFromStore(cert
);
2565 /* If a context is deleted from store2, I_CertUpdateStore deletes it
2568 ret
= pI_CertUpdatestore(store1
, store2
, 0, 0);
2569 ok(ret
, "I_CertUpdateStore failed: %08x\n", GetLastError());
2570 certs
= countCertsInStore(store1
);
2571 ok(certs
== 0, "Expected 0 certs, got %d\n", certs
);
2573 CertCloseStore(store1
, 0);
2574 CertCloseStore(store2
, 0);
2581 hdll
= GetModuleHandleA("Crypt32.dll");
2582 pCertAddStoreToCollection
= (void*)GetProcAddress(hdll
, "CertAddStoreToCollection");
2583 pCertControlStore
= (void*)GetProcAddress(hdll
, "CertControlStore");
2584 pCertEnumCRLsInStore
= (void*)GetProcAddress(hdll
, "CertEnumCRLsInStore");
2585 pCertEnumSystemStore
= (void*)GetProcAddress(hdll
, "CertEnumSystemStore");
2586 pCertGetStoreProperty
= (void*)GetProcAddress(hdll
, "CertGetStoreProperty");
2587 pCertRemoveStoreFromCollection
= (void*)GetProcAddress(hdll
, "CertRemoveStoreFromCollection");
2588 pCertSetStoreProperty
= (void*)GetProcAddress(hdll
, "CertSetStoreProperty");
2589 pCertAddCertificateLinkToStore
= (void*)GetProcAddress(hdll
, "CertAddCertificateLinkToStore");
2591 /* various combinations of CertOpenStore */
2593 testCollectionStore();
2595 testSystemRegStore();
2598 testFileNameStore();
2600 testSerializedStore();
2602 testCertOpenSystemStore();
2603 testCertEnumSystemStore();
2604 testStoreProperty();
2606 testAddSerialized();
2607 testAddCertificateLink();
2609 test_I_UpdateStore();