9c211e14b1de12bfee17b2092f03147910b8339f
[reactos.git] / dll / win32 / crypt32 / filestore.c
1 /*
2 * Copyright 2004-2007 Juan Lang
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18 #include <stdarg.h>
19 #include "windef.h"
20 #include "winbase.h"
21 #include "wincrypt.h"
22 #include "winnls.h"
23 #include "wine/debug.h"
24 #include "wine/unicode.h"
25 #include "crypt32_private.h"
26
27 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
28
29 typedef struct _WINE_FILESTOREINFO
30 {
31 DWORD dwOpenFlags;
32 HCERTSTORE memStore;
33 HANDLE file;
34 DWORD type;
35 BOOL dirty;
36 } WINE_FILESTOREINFO;
37
38 static void WINAPI CRYPT_FileCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
39 {
40 WINE_FILESTOREINFO *store = hCertStore;
41
42 TRACE("(%p, %08x)\n", store, dwFlags);
43 if (store->dirty)
44 CertSaveStore(store->memStore, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
45 store->type, CERT_STORE_SAVE_TO_FILE, store->file, 0);
46 CloseHandle(store->file);
47 CryptMemFree(store);
48 }
49
50 static BOOL WINAPI CRYPT_FileWriteCert(HCERTSTORE hCertStore,
51 PCCERT_CONTEXT cert, DWORD dwFlags)
52 {
53 WINE_FILESTOREINFO *store = hCertStore;
54
55 TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
56 store->dirty = TRUE;
57 return TRUE;
58 }
59
60 static BOOL WINAPI CRYPT_FileDeleteCert(HCERTSTORE hCertStore,
61 PCCERT_CONTEXT pCertContext, DWORD dwFlags)
62 {
63 WINE_FILESTOREINFO *store = hCertStore;
64
65 TRACE("(%p, %p, %08x)\n", hCertStore, pCertContext, dwFlags);
66 store->dirty = TRUE;
67 return TRUE;
68 }
69
70 static BOOL WINAPI CRYPT_FileWriteCRL(HCERTSTORE hCertStore,
71 PCCRL_CONTEXT crl, DWORD dwFlags)
72 {
73 WINE_FILESTOREINFO *store = hCertStore;
74
75 TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
76 store->dirty = TRUE;
77 return TRUE;
78 }
79
80 static BOOL WINAPI CRYPT_FileDeleteCRL(HCERTSTORE hCertStore,
81 PCCRL_CONTEXT pCrlContext, DWORD dwFlags)
82 {
83 WINE_FILESTOREINFO *store = hCertStore;
84
85 TRACE("(%p, %p, %08x)\n", hCertStore, pCrlContext, dwFlags);
86 store->dirty = TRUE;
87 return TRUE;
88 }
89
90 static BOOL WINAPI CRYPT_FileWriteCTL(HCERTSTORE hCertStore,
91 PCCTL_CONTEXT ctl, DWORD dwFlags)
92 {
93 WINE_FILESTOREINFO *store = hCertStore;
94
95 TRACE("(%p, %p, %d)\n", hCertStore, ctl, dwFlags);
96 store->dirty = TRUE;
97 return TRUE;
98 }
99
100 static BOOL WINAPI CRYPT_FileDeleteCTL(HCERTSTORE hCertStore,
101 PCCTL_CONTEXT pCtlContext, DWORD dwFlags)
102 {
103 WINE_FILESTOREINFO *store = hCertStore;
104
105 TRACE("(%p, %p, %08x)\n", hCertStore, pCtlContext, dwFlags);
106 store->dirty = TRUE;
107 return TRUE;
108 }
109
110 static BOOL CRYPT_ReadBlobFromFile(HANDLE file, PCERT_BLOB blob)
111 {
112 BOOL ret = TRUE;
113
114 blob->cbData = GetFileSize(file, NULL);
115 if (blob->cbData)
116 {
117 blob->pbData = CryptMemAlloc(blob->cbData);
118 if (blob->pbData)
119 {
120 DWORD read;
121
122 ret = ReadFile(file, blob->pbData, blob->cbData, &read, NULL) && read == blob->cbData;
123 if (!ret) CryptMemFree(blob->pbData);
124 }
125 else
126 ret = FALSE;
127 }
128 return ret;
129 }
130
131 static BOOL WINAPI CRYPT_FileControl(HCERTSTORE hCertStore, DWORD dwFlags,
132 DWORD dwCtrlType, void const *pvCtrlPara)
133 {
134 WINE_FILESTOREINFO *store = hCertStore;
135 BOOL ret;
136
137 TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
138 pvCtrlPara);
139
140 switch (dwCtrlType)
141 {
142 case CERT_STORE_CTRL_RESYNC:
143 store->dirty = FALSE;
144 if (store->type == CERT_STORE_SAVE_AS_STORE)
145 {
146 HCERTSTORE memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
147 CERT_STORE_CREATE_NEW_FLAG, NULL);
148
149 /* FIXME: if I could translate a handle to a path, I could use
150 * CryptQueryObject instead, but there's no API to do so yet.
151 */
152 ret = CRYPT_ReadSerializedStoreFromFile(store->file, memStore);
153 if (ret)
154 I_CertUpdateStore(store->memStore, memStore, 0, 0);
155 CertCloseStore(memStore, 0);
156 }
157 else if (store->type == CERT_STORE_SAVE_AS_PKCS7)
158 {
159 CERT_BLOB blob = { 0, NULL };
160
161 ret = CRYPT_ReadBlobFromFile(store->file, &blob);
162 if (ret)
163 {
164 HCERTSTORE messageStore;
165
166 ret = CryptQueryObject(CERT_QUERY_OBJECT_BLOB, &blob,
167 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED,
168 CERT_QUERY_FORMAT_FLAG_BINARY, 0, NULL, NULL, NULL,
169 &messageStore, NULL, NULL);
170 I_CertUpdateStore(store->memStore, messageStore, 0, 0);
171 CertCloseStore(messageStore, 0);
172 CryptMemFree(blob.pbData);
173 }
174 }
175 else
176 {
177 WARN("unknown type %d\n", store->type);
178 ret = FALSE;
179 }
180 break;
181 case CERT_STORE_CTRL_COMMIT:
182 if (!(store->dwOpenFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
183 {
184 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
185 ret = FALSE;
186 }
187 else if (store->dirty)
188 ret = CertSaveStore(store->memStore,
189 X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
190 store->type, CERT_STORE_SAVE_TO_FILE, store->file, 0);
191 else
192 ret = TRUE;
193 break;
194 default:
195 FIXME("%d: stub\n", dwCtrlType);
196 ret = FALSE;
197 }
198 return ret;
199 }
200
201 static void *fileProvFuncs[] = {
202 CRYPT_FileCloseStore,
203 NULL, /* CERT_STORE_PROV_READ_CERT_FUNC */
204 CRYPT_FileWriteCert,
205 CRYPT_FileDeleteCert,
206 NULL, /* CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC */
207 NULL, /* CERT_STORE_PROV_READ_CRL_FUNC */
208 CRYPT_FileWriteCRL,
209 CRYPT_FileDeleteCRL,
210 NULL, /* CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC */
211 NULL, /* CERT_STORE_PROV_READ_CTL_FUNC */
212 CRYPT_FileWriteCTL,
213 CRYPT_FileDeleteCTL,
214 NULL, /* CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC */
215 CRYPT_FileControl,
216 };
217
218 static WINECRYPT_CERTSTORE *CRYPT_CreateFileStore(DWORD dwFlags,
219 HCERTSTORE memStore, HANDLE file, DWORD type)
220 {
221 WINECRYPT_CERTSTORE *store = NULL;
222 WINE_FILESTOREINFO *info = CryptMemAlloc(sizeof(WINE_FILESTOREINFO));
223
224 if (info)
225 {
226 CERT_STORE_PROV_INFO provInfo = { 0 };
227
228 info->dwOpenFlags = dwFlags;
229 info->memStore = memStore;
230 info->file = file;
231 info->type = type;
232 info->dirty = FALSE;
233 provInfo.cbSize = sizeof(provInfo);
234 provInfo.cStoreProvFunc = ARRAY_SIZE(fileProvFuncs);
235 provInfo.rgpvStoreProvFunc = fileProvFuncs;
236 provInfo.hStoreProv = info;
237 store = CRYPT_ProvCreateStore(dwFlags, memStore, &provInfo);
238 }
239 return store;
240 }
241
242 WINECRYPT_CERTSTORE *CRYPT_FileOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags,
243 const void *pvPara)
244 {
245 WINECRYPT_CERTSTORE *store = NULL;
246 HANDLE file = (HANDLE)pvPara;
247
248 TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
249
250 if (!pvPara)
251 {
252 SetLastError(ERROR_INVALID_HANDLE);
253 return NULL;
254 }
255 if (dwFlags & CERT_STORE_DELETE_FLAG)
256 {
257 SetLastError(E_INVALIDARG);
258 return NULL;
259 }
260 if ((dwFlags & CERT_STORE_READONLY_FLAG) &&
261 (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
262 {
263 SetLastError(E_INVALIDARG);
264 return NULL;
265 }
266
267 if (DuplicateHandle(GetCurrentProcess(), (HANDLE)pvPara,
268 GetCurrentProcess(), &file, dwFlags & CERT_STORE_READONLY_FLAG ?
269 GENERIC_READ : GENERIC_READ | GENERIC_WRITE, TRUE, 0))
270 {
271 HCERTSTORE memStore;
272
273 memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
274 CERT_STORE_CREATE_NEW_FLAG, NULL);
275 if (memStore)
276 {
277 if (CRYPT_ReadSerializedStoreFromFile(file, memStore))
278 {
279 store = CRYPT_CreateFileStore(dwFlags, memStore, file,
280 CERT_STORE_SAVE_AS_STORE);
281 /* File store doesn't need crypto provider, so close it */
282 if (hCryptProv &&
283 !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
284 CryptReleaseContext(hCryptProv, 0);
285 }
286 }
287 }
288 TRACE("returning %p\n", store);
289 return store;
290 }
291
292 WINECRYPT_CERTSTORE *CRYPT_FileNameOpenStoreW(HCRYPTPROV hCryptProv,
293 DWORD dwFlags, const void *pvPara)
294 {
295 HCERTSTORE store = 0;
296 LPCWSTR fileName = pvPara;
297 DWORD access, create;
298 HANDLE file;
299
300 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags, debugstr_w(fileName));
301
302 if (!fileName)
303 {
304 SetLastError(ERROR_PATH_NOT_FOUND);
305 return NULL;
306 }
307 if ((dwFlags & CERT_STORE_READONLY_FLAG) &&
308 (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
309 {
310 SetLastError(E_INVALIDARG);
311 return NULL;
312 }
313
314 access = GENERIC_READ;
315 if (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG)
316 access |= GENERIC_WRITE;
317 if (dwFlags & CERT_STORE_CREATE_NEW_FLAG)
318 create = CREATE_NEW;
319 else if (dwFlags & CERT_STORE_OPEN_EXISTING_FLAG)
320 create = OPEN_EXISTING;
321 else
322 create = OPEN_ALWAYS;
323 file = CreateFileW(fileName, access, FILE_SHARE_READ, NULL, create,
324 FILE_ATTRIBUTE_NORMAL, NULL);
325 if (file != INVALID_HANDLE_VALUE)
326 {
327 HCERTSTORE memStore = NULL;
328 DWORD size = GetFileSize(file, NULL), type = 0;
329
330 /* If the file isn't empty, try to get the type from the file itself */
331 if (size)
332 {
333 DWORD contentType;
334 BOOL ret;
335
336 /* Close the file so CryptQueryObject can succeed.. */
337 CloseHandle(file);
338 ret = CryptQueryObject(CERT_QUERY_OBJECT_FILE, fileName,
339 CERT_QUERY_CONTENT_FLAG_CERT |
340 CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
341 CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED,
342 CERT_QUERY_FORMAT_FLAG_ALL, 0, NULL, &contentType, NULL,
343 &memStore, NULL, NULL);
344 if (ret)
345 {
346 if (contentType == CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED)
347 type = CERT_STORE_SAVE_AS_PKCS7;
348 else
349 type = CERT_STORE_SAVE_AS_STORE;
350 /* and reopen the file. */
351 file = CreateFileW(fileName, access, FILE_SHARE_READ, NULL,
352 create, FILE_ATTRIBUTE_NORMAL, NULL);
353 }
354 }
355 else
356 {
357 static const WCHAR spc[] = { 's','p','c',0 };
358 static const WCHAR p7c[] = { 'p','7','c',0 };
359 LPCWSTR ext = strrchrW(fileName, '.');
360
361 if (ext)
362 {
363 ext++;
364 if (!lstrcmpiW(ext, spc) || !lstrcmpiW(ext, p7c))
365 type = CERT_STORE_SAVE_AS_PKCS7;
366 }
367 if (!type)
368 type = CERT_STORE_SAVE_AS_STORE;
369 memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
370 CERT_STORE_CREATE_NEW_FLAG, NULL);
371 }
372 if (memStore)
373 {
374 store = CRYPT_CreateFileStore(dwFlags, memStore, file, type);
375 /* File store doesn't need crypto provider, so close it */
376 if (hCryptProv && !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
377 CryptReleaseContext(hCryptProv, 0);
378 }
379 }
380 return store;
381 }
382
383 WINECRYPT_CERTSTORE *CRYPT_FileNameOpenStoreA(HCRYPTPROV hCryptProv,
384 DWORD dwFlags, const void *pvPara)
385 {
386 int len;
387 WINECRYPT_CERTSTORE *ret = NULL;
388
389 TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
390 debugstr_a(pvPara));
391
392 if (!pvPara)
393 {
394 SetLastError(ERROR_FILE_NOT_FOUND);
395 return NULL;
396 }
397 len = MultiByteToWideChar(CP_ACP, 0, pvPara, -1, NULL, 0);
398 if (len)
399 {
400 LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
401
402 if (storeName)
403 {
404 MultiByteToWideChar(CP_ACP, 0, pvPara, -1, storeName, len);
405 ret = CRYPT_FileNameOpenStoreW(hCryptProv, dwFlags, storeName);
406 CryptMemFree(storeName);
407 }
408 }
409 return ret;
410 }