crypt32: Allow messages to be opened when compiled with CMSG_SIGNER_ENCODE_INFO_HAS_C...
[wine] / dlls / 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, *PWINE_FILESTOREINFO;
37
38 static void WINAPI CRYPT_FileCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
39 {
40     PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)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     CertCloseStore(store->memStore, dwFlags);
47     CloseHandle(store->file);
48     CryptMemFree(store);
49 }
50
51 static BOOL WINAPI CRYPT_FileWriteCert(HCERTSTORE hCertStore,
52  PCCERT_CONTEXT cert, DWORD dwFlags)
53 {
54     PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
55
56     TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
57     store->dirty = TRUE;
58     return TRUE;
59 }
60
61 static BOOL WINAPI CRYPT_FileDeleteCert(HCERTSTORE hCertStore,
62  PCCERT_CONTEXT pCertContext, DWORD dwFlags)
63 {
64     PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
65
66     TRACE("(%p, %p, %08x)\n", hCertStore, pCertContext, dwFlags);
67     store->dirty = TRUE;
68     return TRUE;
69 }
70
71 static BOOL WINAPI CRYPT_FileWriteCRL(HCERTSTORE hCertStore,
72  PCCRL_CONTEXT crl, DWORD dwFlags)
73 {
74     PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
75
76     TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
77     store->dirty = TRUE;
78     return TRUE;
79 }
80
81 static BOOL WINAPI CRYPT_FileDeleteCRL(HCERTSTORE hCertStore,
82  PCCRL_CONTEXT pCrlContext, DWORD dwFlags)
83 {
84     PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
85
86     TRACE("(%p, %p, %08x)\n", hCertStore, pCrlContext, dwFlags);
87     store->dirty = TRUE;
88     return TRUE;
89 }
90
91 static BOOL CRYPT_ReadBlobFromFile(HANDLE file, PCERT_BLOB blob)
92 {
93     BOOL ret = TRUE;
94
95     blob->cbData = GetFileSize(file, NULL);
96     if (blob->cbData)
97     {
98         blob->pbData = CryptMemAlloc(blob->cbData);
99         if (blob->pbData)
100         {
101             DWORD read;
102
103             ret = ReadFile(file, blob->pbData, blob->cbData, &read, NULL);
104         }
105     }
106     return ret;
107 }
108
109 static BOOL WINAPI CRYPT_FileControl(HCERTSTORE hCertStore, DWORD dwFlags,
110  DWORD dwCtrlType, void const *pvCtrlPara)
111 {
112     PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
113     BOOL ret;
114
115     TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
116      pvCtrlPara);
117
118     switch (dwCtrlType)
119     {
120     case CERT_STORE_CTRL_RESYNC:
121         store->dirty = FALSE;
122         if (store->type == CERT_STORE_SAVE_AS_STORE)
123         {
124             HCERTSTORE memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
125              CERT_STORE_CREATE_NEW_FLAG, NULL);
126
127             /* FIXME: if I could translate a handle to a path, I could use
128              * CryptQueryObject instead, but there's no API to do so yet.
129              */
130             ret = CRYPT_ReadSerializedStoreFromFile(store->file, memStore);
131             if (ret)
132                 I_CertUpdateStore(store->memStore, memStore, 0, 0);
133             CertCloseStore(memStore, 0);
134         }
135         else if (store->type == CERT_STORE_SAVE_AS_PKCS7)
136         {
137             CERT_BLOB blob = { 0, NULL };
138
139             ret = CRYPT_ReadBlobFromFile(store->file, &blob);
140             if (ret)
141             {
142                 HCERTSTORE messageStore;
143
144                 ret = CryptQueryObject(CERT_QUERY_OBJECT_BLOB, &blob,
145                  CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED,
146                  CERT_QUERY_FORMAT_FLAG_BINARY, 0, NULL, NULL, NULL,
147                  &messageStore, NULL, NULL);
148                 I_CertUpdateStore(store->memStore, messageStore, 0, 0);
149                 CertCloseStore(messageStore, 0);
150                 CryptMemFree(blob.pbData);
151             }
152         }
153         else
154         {
155             WARN("unknown type %d\n", store->type);
156             ret = FALSE;
157         }
158         break;
159     case CERT_STORE_CTRL_COMMIT:
160         if (!(store->dwOpenFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
161         {
162             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
163             ret = FALSE;
164         }
165         else if (store->dirty)
166             ret = CertSaveStore(store->memStore,
167              X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
168              store->type, CERT_STORE_SAVE_TO_FILE, store->file, 0);
169         else
170             ret = TRUE;
171         break;
172     default:
173         FIXME("%d: stub\n", dwCtrlType);
174         ret = FALSE;
175     }
176     return ret;
177 }
178
179 static void *fileProvFuncs[] = {
180     CRYPT_FileCloseStore,
181     NULL, /* CERT_STORE_PROV_READ_CERT_FUNC */
182     CRYPT_FileWriteCert,
183     CRYPT_FileDeleteCert,
184     NULL, /* CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC */
185     NULL, /* CERT_STORE_PROV_READ_CRL_FUNC */
186     CRYPT_FileWriteCRL,
187     CRYPT_FileDeleteCRL,
188     NULL, /* CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC */
189     NULL, /* CERT_STORE_PROV_READ_CTL_FUNC */
190     NULL, /* CERT_STORE_PROV_WRITE_CTL_FUNC */
191     NULL, /* CERT_STORE_PROV_DELETE_CTL_FUNC */
192     NULL, /* CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC */
193     CRYPT_FileControl,
194 };
195
196 static PWINECRYPT_CERTSTORE CRYPT_CreateFileStore(DWORD dwFlags,
197  HCERTSTORE memStore, HANDLE file, DWORD type)
198 {
199     PWINECRYPT_CERTSTORE store = NULL;
200     PWINE_FILESTOREINFO info = CryptMemAlloc(sizeof(WINE_FILESTOREINFO));
201
202     if (info)
203     {
204         CERT_STORE_PROV_INFO provInfo = { 0 };
205
206         info->dwOpenFlags = dwFlags;
207         info->memStore = memStore;
208         info->file = file;
209         info->type = type;
210         info->dirty = FALSE;
211         provInfo.cbSize = sizeof(provInfo);
212         provInfo.cStoreProvFunc = sizeof(fileProvFuncs) /
213          sizeof(fileProvFuncs[0]);
214         provInfo.rgpvStoreProvFunc = fileProvFuncs;
215         provInfo.hStoreProv = info;
216         store = CRYPT_ProvCreateStore(dwFlags, memStore, &provInfo);
217     }
218     return store;
219 }
220
221 PWINECRYPT_CERTSTORE CRYPT_FileOpenStore(HCRYPTPROV hCryptProv, DWORD dwFlags,
222  const void *pvPara)
223 {
224     PWINECRYPT_CERTSTORE store = NULL;
225     HANDLE file = (HANDLE)pvPara;
226
227     TRACE("(%ld, %08x, %p)\n", hCryptProv, dwFlags, pvPara);
228
229     if (!pvPara)
230     {
231         SetLastError(ERROR_INVALID_HANDLE);
232         return NULL;
233     }
234     if (dwFlags & CERT_STORE_DELETE_FLAG)
235     {
236         SetLastError(E_INVALIDARG);
237         return NULL;
238     }
239     if ((dwFlags & CERT_STORE_READONLY_FLAG) &&
240      (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
241     {
242         SetLastError(E_INVALIDARG);
243         return NULL;
244     }
245
246     if (DuplicateHandle(GetCurrentProcess(), (HANDLE)pvPara,
247      GetCurrentProcess(), &file, dwFlags & CERT_STORE_READONLY_FLAG ?
248      GENERIC_READ : GENERIC_READ | GENERIC_WRITE, TRUE, 0))
249     {
250         HCERTSTORE memStore;
251
252         memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
253          CERT_STORE_CREATE_NEW_FLAG, NULL);
254         if (memStore)
255         {
256             if (CRYPT_ReadSerializedStoreFromFile(file, memStore))
257             {
258                 store = CRYPT_CreateFileStore(dwFlags, memStore, file,
259                  CERT_STORE_SAVE_AS_STORE);
260                 /* File store doesn't need crypto provider, so close it */
261                 if (hCryptProv &&
262                  !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
263                     CryptReleaseContext(hCryptProv, 0);
264             }
265         }
266     }
267     TRACE("returning %p\n", store);
268     return store;
269 }
270
271 PWINECRYPT_CERTSTORE CRYPT_FileNameOpenStoreW(HCRYPTPROV hCryptProv,
272  DWORD dwFlags, const void *pvPara)
273 {
274     HCERTSTORE store = 0;
275     LPCWSTR fileName = (LPCWSTR)pvPara;
276     DWORD access, create;
277     HANDLE file;
278
279     TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags, debugstr_w(fileName));
280
281     if (!fileName)
282     {
283         SetLastError(ERROR_PATH_NOT_FOUND);
284         return NULL;
285     }
286     if ((dwFlags & CERT_STORE_READONLY_FLAG) &&
287      (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG))
288     {
289         SetLastError(E_INVALIDARG);
290         return NULL;
291     }
292
293     access = GENERIC_READ;
294     if (dwFlags & CERT_FILE_STORE_COMMIT_ENABLE_FLAG)
295         access |= GENERIC_WRITE;
296     if (dwFlags & CERT_STORE_CREATE_NEW_FLAG)
297         create = CREATE_NEW;
298     else if (dwFlags & CERT_STORE_OPEN_EXISTING_FLAG)
299         create = OPEN_EXISTING;
300     else
301         create = OPEN_ALWAYS;
302     file = CreateFileW(fileName, access, FILE_SHARE_READ, NULL, create,
303      FILE_ATTRIBUTE_NORMAL, NULL);
304     if (file != INVALID_HANDLE_VALUE)
305     {
306         HCERTSTORE memStore = NULL;
307         DWORD size = GetFileSize(file, NULL), type = 0;
308
309         /* If the file isn't empty, try to get the type from the file itself */
310         if (size)
311         {
312             DWORD contentType;
313             BOOL ret;
314
315             /* Close the file so CryptQueryObject can succeed.. */
316             CloseHandle(file);
317             ret = CryptQueryObject(CERT_QUERY_OBJECT_FILE, fileName,
318              CERT_QUERY_CONTENT_FLAG_CERT |
319              CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE |
320              CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED,
321              CERT_QUERY_FORMAT_FLAG_BINARY, 0, NULL, &contentType, NULL,
322              &memStore, NULL, NULL);
323             if (ret)
324             {
325                 if (contentType == CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED)
326                     type = CERT_STORE_SAVE_AS_PKCS7;
327                 else
328                     type = CERT_STORE_SAVE_AS_STORE;
329                 /* and reopen the file. */
330                 file = CreateFileW(fileName, access, FILE_SHARE_READ, NULL,
331                  create, FILE_ATTRIBUTE_NORMAL, NULL);
332             }
333         }
334         else
335         {
336             static const WCHAR spc[] = { 's','p','c',0 };
337             static const WCHAR p7c[] = { 'p','7','c',0 };
338             LPCWSTR ext = strrchrW(fileName, '.');
339
340             if (ext)
341             {
342                 ext++;
343                 if (!lstrcmpiW(ext, spc) || !lstrcmpiW(ext, p7c))
344                     type = CERT_STORE_SAVE_AS_PKCS7;
345             }
346             if (!type)
347                 type = CERT_STORE_SAVE_AS_STORE;
348             memStore = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
349              CERT_STORE_CREATE_NEW_FLAG, NULL);
350         }
351         if (memStore)
352         {
353             store = CRYPT_CreateFileStore(dwFlags, memStore, file, type);
354             /* File store doesn't need crypto provider, so close it */
355             if (hCryptProv && !(dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG))
356                 CryptReleaseContext(hCryptProv, 0);
357         }
358     }
359     return (PWINECRYPT_CERTSTORE)store;
360 }
361
362 PWINECRYPT_CERTSTORE CRYPT_FileNameOpenStoreA(HCRYPTPROV hCryptProv,
363  DWORD dwFlags, const void *pvPara)
364 {
365     int len;
366     PWINECRYPT_CERTSTORE ret = NULL;
367
368     TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
369      debugstr_a((LPCSTR)pvPara));
370
371     if (!pvPara)
372     {
373         SetLastError(ERROR_FILE_NOT_FOUND);
374         return NULL;
375     }
376     len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, NULL, 0);
377     if (len)
378     {
379         LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
380
381         if (storeName)
382         {
383             MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, storeName, len);
384             ret = CRYPT_FileNameOpenStoreW(hCryptProv, dwFlags, storeName);
385             CryptMemFree(storeName);
386         }
387     }
388     return ret;
389 }