?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push a4e6cd544f3f0a66d1be479be027045d2ab3dba0
[wine/hacks.git] / dlls / crypt32 / msg.c
blob2d19736dec2445abca1d09d89eb7a1442ef7048c
1 /*
2 * Copyright 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 "snmp.h"
23
24 #include "wine/debug.h"
25 #include "wine/exception.h"
26 #include "crypt32_private.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
29
30 /* Called when a message's ref count reaches zero. Free any message-specific
31 * data here.
32 */
33 typedef void (*CryptMsgCloseFunc)(HCRYPTMSG msg);
34
35 typedef BOOL (*CryptMsgGetParamFunc)(HCRYPTMSG hCryptMsg, DWORD dwParamType,
36 DWORD dwIndex, void *pvData, DWORD *pcbData);
37
38 typedef BOOL (*CryptMsgUpdateFunc)(HCRYPTMSG hCryptMsg, const BYTE *pbData,
39 DWORD cbData, BOOL fFinal);
40
41 typedef BOOL (*CryptMsgControlFunc)(HCRYPTMSG hCryptMsg, DWORD dwFlags,
42 DWORD dwCtrlType, const void *pvCtrlPara);
43
44 BOOL CRYPT_DefaultMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags,
45 DWORD dwCtrlType, const void *pvCtrlPara)
46 {
47 TRACE("(%p, %08x, %d, %p)\n", hCryptMsg, dwFlags, dwCtrlType, pvCtrlPara);
48 SetLastError(E_INVALIDARG);
49 return FALSE;
50 }
51
52 typedef enum _CryptMsgState {
53 MsgStateInit,
54 MsgStateUpdated,
55 MsgStateFinalized
56 } CryptMsgState;
57
58 typedef struct _CryptMsgBase
59 {
60 LONG ref;
61 DWORD open_flags;
62 BOOL streamed;
63 CMSG_STREAM_INFO stream_info;
64 CryptMsgState state;
65 CryptMsgCloseFunc close;
66 CryptMsgUpdateFunc update;
67 CryptMsgGetParamFunc get_param;
68 CryptMsgControlFunc control;
69 } CryptMsgBase;
70
71 static inline void CryptMsgBase_Init(CryptMsgBase *msg, DWORD dwFlags,
72 PCMSG_STREAM_INFO pStreamInfo, CryptMsgCloseFunc close,
73 CryptMsgGetParamFunc get_param, CryptMsgUpdateFunc update,
74 CryptMsgControlFunc control)
75 {
76 msg->ref = 1;
77 msg->open_flags = dwFlags;
78 if (pStreamInfo)
79 {
80 msg->streamed = TRUE;
81 memcpy(&msg->stream_info, pStreamInfo, sizeof(msg->stream_info));
82 }
83 else
84 {
85 msg->streamed = FALSE;
86 memset(&msg->stream_info, 0, sizeof(msg->stream_info));
87 }
88 msg->close = close;
89 msg->get_param = get_param;
90 msg->update = update;
91 msg->control = control;
92 msg->state = MsgStateInit;
93 }
94
95 typedef struct _CDataEncodeMsg
96 {
97 CryptMsgBase base;
98 DWORD bare_content_len;
99 LPBYTE bare_content;
100 } CDataEncodeMsg;
101
102 static const BYTE empty_data_content[] = { 0x04,0x00 };
103
104 static void CDataEncodeMsg_Close(HCRYPTMSG hCryptMsg)
105 {
106 CDataEncodeMsg *msg = (CDataEncodeMsg *)hCryptMsg;
107
108 if (msg->bare_content != empty_data_content)
109 LocalFree(msg->bare_content);
110 }
111
112 static WINAPI BOOL CRYPT_EncodeContentLength(DWORD dwCertEncodingType,
113 LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
114 PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
115 {
116 DWORD dataLen = *(DWORD *)pvStructInfo;
117 DWORD lenBytes;
118 BOOL ret = TRUE;
119
120 /* Trick: report bytes needed based on total message length, even though
121 * the message isn't available yet. The caller will use the length
122 * reported here to encode its length.
123 */
124 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
125 if (!pbEncoded)
126 *pcbEncoded = 1 + lenBytes + dataLen;
127 else
128 {
129 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
130 pcbEncoded, 1 + lenBytes)))
131 {
132 if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
133 pbEncoded = *(BYTE **)pbEncoded;
134 *pbEncoded++ = ASN_OCTETSTRING;
135 CRYPT_EncodeLen(dataLen, pbEncoded,
136 &lenBytes);
137 }
138 }
139 return ret;
140 }
141
142 static BOOL CRYPT_EncodeDataContentInfoHeader(CDataEncodeMsg *msg,
143 CRYPT_DATA_BLOB *header)
144 {
145 BOOL ret;
146
147 if (msg->base.streamed && msg->base.stream_info.cbContent == 0xffffffff)
148 {
149 static const BYTE headerValue[] = { 0x30,0x80,0x06,0x09,0x2a,0x86,0x48,
150 0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x80,0x24,0x80 };
151
152 header->pbData = LocalAlloc(0, sizeof(headerValue));
153 if (header->pbData)
154 {
155 header->cbData = sizeof(headerValue);
156 memcpy(header->pbData, headerValue, sizeof(headerValue));
157 ret = TRUE;
158 }
159 else
160 ret = FALSE;
161 }
162 else
163 {
164 struct AsnConstructedItem constructed = { 0,
165 &msg->base.stream_info.cbContent, CRYPT_EncodeContentLength };
166 struct AsnEncodeSequenceItem items[2] = {
167 { szOID_RSA_data, CRYPT_AsnEncodeOid, 0 },
168 { &constructed, CRYPT_AsnEncodeConstructed, 0 },
169 };
170
171 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items,
172 sizeof(items) / sizeof(items[0]), CRYPT_ENCODE_ALLOC_FLAG, NULL,
173 (LPBYTE)&header->pbData, &header->cbData);
174 if (ret)
175 {
176 /* Trick: subtract the content length from the reported length,
177 * as the actual content hasn't come yet.
178 */
179 header->cbData -= msg->base.stream_info.cbContent;
180 }
181 }
182 return ret;
183 }
184
185 static BOOL CDataEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
186 DWORD cbData, BOOL fFinal)
187 {
188 CDataEncodeMsg *msg = (CDataEncodeMsg *)hCryptMsg;
189 BOOL ret = FALSE;
190
191 if (msg->base.streamed)
192 {
193 __TRY
194 {
195 if (msg->base.state != MsgStateUpdated)
196 {
197 CRYPT_DATA_BLOB header;
198
199 ret = CRYPT_EncodeDataContentInfoHeader(msg, &header);
200 if (ret)
201 {
202 ret = msg->base.stream_info.pfnStreamOutput(
203 msg->base.stream_info.pvArg, header.pbData, header.cbData,
204 FALSE);
205 LocalFree(header.pbData);
206 }
207 }
208 /* Curiously, every indefinite-length streamed update appears to
209 * get its own tag and length, regardless of fFinal.
210 */
211 if (msg->base.stream_info.cbContent == 0xffffffff)
212 {
213 BYTE *header;
214 DWORD headerLen;
215
216 ret = CRYPT_EncodeContentLength(X509_ASN_ENCODING, NULL,
217 &cbData, CRYPT_ENCODE_ALLOC_FLAG, NULL, (BYTE *)&header,
218 &headerLen);
219 if (ret)
220 {
221 ret = msg->base.stream_info.pfnStreamOutput(
222 msg->base.stream_info.pvArg, header, headerLen,
223 FALSE);
224 LocalFree(header);
225 }
226 }
227 if (!fFinal)
228 ret = msg->base.stream_info.pfnStreamOutput(
229 msg->base.stream_info.pvArg, (BYTE *)pbData, cbData,
230 FALSE);
231 else
232 {
233 if (msg->base.stream_info.cbContent == 0xffffffff)
234 {
235 BYTE indefinite_trailer[6] = { 0 };
236
237 ret = msg->base.stream_info.pfnStreamOutput(
238 msg->base.stream_info.pvArg, (BYTE *)pbData, cbData,
239 FALSE);
240 if (ret)
241 ret = msg->base.stream_info.pfnStreamOutput(
242 msg->base.stream_info.pvArg, indefinite_trailer,
243 sizeof(indefinite_trailer), TRUE);
244 }
245 else
246 ret = msg->base.stream_info.pfnStreamOutput(
247 msg->base.stream_info.pvArg, (BYTE *)pbData, cbData, TRUE);
248 }
249 }
250 __EXCEPT_PAGE_FAULT
251 {
252 SetLastError(STATUS_ACCESS_VIOLATION);
253 ret = FALSE;
254 }
255 __ENDTRY;
256 }
257 else
258 {
259 if (!fFinal)
260 {
261 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
262 SetLastError(E_INVALIDARG);
263 else
264 SetLastError(CRYPT_E_MSG_ERROR);
265 }
266 else
267 {
268 if (!cbData)
269 SetLastError(E_INVALIDARG);
270 else
271 {
272 CRYPT_DATA_BLOB blob = { cbData, (LPBYTE)pbData };
273
274 /* non-streamed data messages don't allow non-final updates,
275 * don't bother checking whether data already exist, they can't.
276 */
277 ret = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
278 &blob, CRYPT_ENCODE_ALLOC_FLAG, NULL, &msg->bare_content,
279 &msg->bare_content_len);
280 }
281 }
282 }
283 return ret;
284 }
285
286 static BOOL CRYPT_CopyParam(void *pvData, DWORD *pcbData, const void *src,
287 DWORD len)
288 {
289 BOOL ret = TRUE;
290
291 if (!pvData)
292 *pcbData = len;
293 else if (*pcbData < len)
294 {
295 *pcbData = len;
296 SetLastError(ERROR_MORE_DATA);
297 ret = FALSE;
298 }
299 else
300 {
301 *pcbData = len;
302 memcpy(pvData, src, len);
303 }
304 return ret;
305 }
306
307 static BOOL CDataEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
308 DWORD dwIndex, void *pvData, DWORD *pcbData)
309 {
310 CDataEncodeMsg *msg = (CDataEncodeMsg *)hCryptMsg;
311 BOOL ret = FALSE;
312
313 switch (dwParamType)
314 {
315 case CMSG_CONTENT_PARAM:
316 if (msg->base.streamed)
317 SetLastError(E_INVALIDARG);
318 else
319 {
320 CRYPT_CONTENT_INFO info;
321 char rsa_data[] = "1.2.840.113549.1.7.1";
322
323 info.pszObjId = rsa_data;
324 info.Content.cbData = msg->bare_content_len;
325 info.Content.pbData = msg->bare_content;
326 ret = CryptEncodeObject(X509_ASN_ENCODING, PKCS_CONTENT_INFO, &info,
327 pvData, pcbData);
328 }
329 break;
330 case CMSG_BARE_CONTENT_PARAM:
331 if (msg->base.streamed)
332 SetLastError(E_INVALIDARG);
333 else
334 ret = CRYPT_CopyParam(pvData, pcbData, msg->bare_content,
335 msg->bare_content_len);
336 break;
337 default:
338 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
339 }
340 return ret;
341 }
342
343 static HCRYPTMSG CDataEncodeMsg_Open(DWORD dwFlags, const void *pvMsgEncodeInfo,
344 LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
345 {
346 CDataEncodeMsg *msg;
347
348 if (pvMsgEncodeInfo)
349 {
350 SetLastError(E_INVALIDARG);
351 return NULL;
352 }
353 msg = CryptMemAlloc(sizeof(CDataEncodeMsg));
354 if (msg)
355 {
356 CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
357 CDataEncodeMsg_Close, CDataEncodeMsg_GetParam, CDataEncodeMsg_Update,
358 CRYPT_DefaultMsgControl);
359 msg->bare_content_len = sizeof(empty_data_content);
360 msg->bare_content = (LPBYTE)empty_data_content;
361 }
362 return (HCRYPTMSG)msg;
363 }
364
365 typedef struct _CHashEncodeMsg
366 {
367 CryptMsgBase base;
368 HCRYPTPROV prov;
369 HCRYPTHASH hash;
370 CRYPT_DATA_BLOB data;
371 } CHashEncodeMsg;
372
373 static void CHashEncodeMsg_Close(HCRYPTMSG hCryptMsg)
374 {
375 CHashEncodeMsg *msg = (CHashEncodeMsg *)hCryptMsg;
376
377 CryptMemFree(msg->data.pbData);
378 CryptDestroyHash(msg->hash);
379 if (msg->base.open_flags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
380 CryptReleaseContext(msg->prov, 0);
381 }
382
383 static BOOL CRYPT_EncodePKCSDigestedData(CHashEncodeMsg *msg, void *pvData,
384 DWORD *pcbData)
385 {
386 BOOL ret;
387 ALG_ID algID;
388 DWORD size = sizeof(algID);
389
390 ret = CryptGetHashParam(msg->hash, HP_ALGID, (BYTE *)&algID, &size, 0);
391 if (ret)
392 {
393 CRYPT_DIGESTED_DATA digestedData = { 0 };
394 char oid_rsa_data[] = szOID_RSA_data;
395
396 digestedData.version = CMSG_HASHED_DATA_PKCS_1_5_VERSION;
397 digestedData.DigestAlgorithm.pszObjId = (LPSTR)CertAlgIdToOID(algID);
398 /* FIXME: what about digestedData.DigestAlgorithm.Parameters? */
399 /* Quirk: OID is only encoded messages if an update has happened */
400 if (msg->base.state != MsgStateInit)
401 digestedData.ContentInfo.pszObjId = oid_rsa_data;
402 if (!(msg->base.open_flags & CMSG_DETACHED_FLAG) && msg->data.cbData)
403 {
404 ret = CRYPT_AsnEncodeOctets(0, NULL, &msg->data,
405 CRYPT_ENCODE_ALLOC_FLAG, NULL,
406 (LPBYTE)&digestedData.ContentInfo.Content.pbData,
407 &digestedData.ContentInfo.Content.cbData);
408 }
409 if (msg->base.state == MsgStateFinalized)
410 {
411 size = sizeof(DWORD);
412 ret = CryptGetHashParam(msg->hash, HP_HASHSIZE,
413 (LPBYTE)&digestedData.hash.cbData, &size, 0);
414 if (ret)
415 {
416 digestedData.hash.pbData = CryptMemAlloc(
417 digestedData.hash.cbData);
418 ret = CryptGetHashParam(msg->hash, HP_HASHVAL,
419 digestedData.hash.pbData, &digestedData.hash.cbData, 0);
420 }
421 }
422 if (ret)
423 ret = CRYPT_AsnEncodePKCSDigestedData(&digestedData, pvData,
424 pcbData);
425 CryptMemFree(digestedData.hash.pbData);
426 LocalFree(digestedData.ContentInfo.Content.pbData);
427 }
428 return ret;
429 }
430
431 static BOOL CHashEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
432 DWORD dwIndex, void *pvData, DWORD *pcbData)
433 {
434 CHashEncodeMsg *msg = (CHashEncodeMsg *)hCryptMsg;
435 BOOL ret = FALSE;
436
437 TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
438 pvData, pcbData);
439
440 switch (dwParamType)
441 {
442 case CMSG_BARE_CONTENT_PARAM:
443 if (msg->base.streamed)
444 SetLastError(E_INVALIDARG);
445 else
446 ret = CRYPT_EncodePKCSDigestedData(msg, pvData, pcbData);
447 break;
448 case CMSG_CONTENT_PARAM:
449 {
450 CRYPT_CONTENT_INFO info;
451
452 ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0, NULL,
453 &info.Content.cbData);
454 if (ret)
455 {
456 info.Content.pbData = CryptMemAlloc(info.Content.cbData);
457 if (info.Content.pbData)
458 {
459 ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0,
460 info.Content.pbData, &info.Content.cbData);
461 if (ret)
462 {
463 char oid_rsa_hashed[] = szOID_RSA_hashedData;
464
465 info.pszObjId = oid_rsa_hashed;
466 ret = CryptEncodeObjectEx(X509_ASN_ENCODING,
467 PKCS_CONTENT_INFO, &info, 0, NULL, pvData, pcbData);
468 }
469 CryptMemFree(info.Content.pbData);
470 }
471 else
472 ret = FALSE;
473 }
474 break;
475 }
476 case CMSG_COMPUTED_HASH_PARAM:
477 ret = CryptGetHashParam(msg->hash, HP_HASHVAL, (BYTE *)pvData, pcbData,
478 0);
479 break;
480 case CMSG_VERSION_PARAM:
481 if (msg->base.state != MsgStateFinalized)
482 SetLastError(CRYPT_E_MSG_ERROR);
483 else
484 {
485 DWORD version = CMSG_HASHED_DATA_PKCS_1_5_VERSION;
486
487 /* Since the data are always encoded as octets, the version is
488 * always 0 (see rfc3852, section 7)
489 */
490 ret = CRYPT_CopyParam(pvData, pcbData, &version, sizeof(version));
491 }
492 break;
493 default:
494 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
495 }
496 return ret;
497 }
498
499 static BOOL CHashEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
500 DWORD cbData, BOOL fFinal)
501 {
502 CHashEncodeMsg *msg = (CHashEncodeMsg *)hCryptMsg;
503 BOOL ret = FALSE;
504
505 TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
506
507 if (msg->base.streamed || (msg->base.open_flags & CMSG_DETACHED_FLAG))
508 {
509 /* Doesn't do much, as stream output is never called, and you
510 * can't get the content.
511 */
512 ret = CryptHashData(msg->hash, pbData, cbData, 0);
513 }
514 else
515 {
516 if (!fFinal)
517 SetLastError(CRYPT_E_MSG_ERROR);
518 else
519 {
520 ret = CryptHashData(msg->hash, pbData, cbData, 0);
521 if (ret)
522 {
523 msg->data.pbData = CryptMemAlloc(cbData);
524 if (msg->data.pbData)
525 {
526 memcpy(msg->data.pbData + msg->data.cbData, pbData, cbData);
527 msg->data.cbData += cbData;
528 }
529 else
530 ret = FALSE;
531 }
532 }
533 }
534 return ret;
535 }
536
537 static HCRYPTMSG CHashEncodeMsg_Open(DWORD dwFlags, const void *pvMsgEncodeInfo,
538 LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
539 {
540 CHashEncodeMsg *msg;
541 const CMSG_HASHED_ENCODE_INFO *info =
542 (const CMSG_HASHED_ENCODE_INFO *)pvMsgEncodeInfo;
543 HCRYPTPROV prov;
544 ALG_ID algID;
545
546 if (info->cbSize != sizeof(CMSG_HASHED_ENCODE_INFO))
547 {
548 SetLastError(E_INVALIDARG);
549 return NULL;
550 }
551 if (!(algID = CertOIDToAlgId(info->HashAlgorithm.pszObjId)))
552 {
553 SetLastError(CRYPT_E_UNKNOWN_ALGO);
554 return NULL;
555 }
556 if (info->hCryptProv)
557 prov = info->hCryptProv;
558 else
559 {
560 prov = CRYPT_GetDefaultProvider();
561 dwFlags &= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG;
562 }
563 msg = CryptMemAlloc(sizeof(CHashEncodeMsg));
564 if (msg)
565 {
566 CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
567 CHashEncodeMsg_Close, CHashEncodeMsg_GetParam, CHashEncodeMsg_Update,
568 CRYPT_DefaultMsgControl);
569 msg->prov = prov;
570 msg->data.cbData = 0;
571 msg->data.pbData = NULL;
572 if (!CryptCreateHash(prov, algID, 0, 0, &msg->hash))
573 {
574 CryptMsgClose(msg);
575 msg = NULL;
576 }
577 }
578 return (HCRYPTMSG)msg;
579 }
580
581 typedef struct _CMSG_SIGNER_ENCODE_INFO_WITH_CMS
582 {
583 DWORD cbSize;
584 PCERT_INFO pCertInfo;
585 HCRYPTPROV hCryptProv;
586 DWORD dwKeySpec;
587 CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
588 void *pvHashAuxInfo;
589 DWORD cAuthAttr;
590 PCRYPT_ATTRIBUTE rgAuthAttr;
591 DWORD cUnauthAttr;
592 PCRYPT_ATTRIBUTE rgUnauthAttr;
593 CERT_ID SignerId;
594 CRYPT_ALGORITHM_IDENTIFIER HashEncryptionAlgorithm;
595 void *pvHashEncryptionAuxInfo;
596 } CMSG_SIGNER_ENCODE_INFO_WITH_CMS, *PCMSG_SIGNER_ENCODE_INFO_WITH_CMS;
597
598 typedef struct _CMSG_SIGNED_ENCODE_INFO_WITH_CMS
599 {
600 DWORD cbSize;
601 DWORD cSigners;
602 PCMSG_SIGNER_ENCODE_INFO_WITH_CMS rgSigners;
603 DWORD cCertEncoded;
604 PCERT_BLOB rgCertEncoded;
605 DWORD cCrlEncoded;
606 PCRL_BLOB rgCrlEncoded;
607 DWORD cAttrCertEncoded;
608 PCERT_BLOB rgAttrCertEncoded;
609 } CMSG_SIGNED_ENCODE_INFO_WITH_CMS, *PCMSG_SIGNED_ENCODE_INFO_WITH_CMS;
610
611 static BOOL CRYPT_IsValidSigner(CMSG_SIGNER_ENCODE_INFO_WITH_CMS *signer)
612 {
613 if (signer->cbSize != sizeof(CMSG_SIGNER_ENCODE_INFO) &&
614 signer->cbSize != sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS))
615 {
616 SetLastError(E_INVALIDARG);
617 return FALSE;
618 }
619 if (signer->cbSize == sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS))
620 {
621 FIXME("CMSG_SIGNER_ENCODE_INFO with CMS fields unsupported\n");
622 return FALSE;
623 }
624 if (!signer->pCertInfo->SerialNumber.cbData)
625 {
626 SetLastError(E_INVALIDARG);
627 return FALSE;
628 }
629 if (!signer->pCertInfo->Issuer.cbData)
630 {
631 SetLastError(E_INVALIDARG);
632 return FALSE;
633 }
634 if (!signer->hCryptProv)
635 {
636 SetLastError(E_INVALIDARG);
637 return FALSE;
638 }
639 if (!CertOIDToAlgId(signer->HashAlgorithm.pszObjId))
640 {
641 SetLastError(CRYPT_E_UNKNOWN_ALGO);
642 return FALSE;
643 }
644 return TRUE;
645 }
646
647 static BOOL CRYPT_ConstructBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
648 {
649 BOOL ret = TRUE;
650
651 out->cbData = in->cbData;
652 if (out->cbData)
653 {
654 out->pbData = CryptMemAlloc(out->cbData);
655 if (out->pbData)
656 memcpy(out->pbData, in->pbData, out->cbData);
657 else
658 ret = FALSE;
659 }
660 else
661 out->pbData = NULL;
662 return ret;
663 }
664
665 typedef struct _BlobArray
666 {
667 DWORD cBlobs;
668 PCRYPT_DATA_BLOB blobs;
669 } BlobArray;
670
671 static BOOL CRYPT_ConstructBlobArray(BlobArray *out, const BlobArray *in)
672 {
673 BOOL ret = TRUE;
674
675 out->cBlobs = in->cBlobs;
676 if (out->cBlobs)
677 {
678 out->blobs = CryptMemAlloc(out->cBlobs * sizeof(CRYPT_DATA_BLOB));
679 if (out->blobs)
680 {
681 DWORD i;
682
683 memset(out->blobs, 0, out->cBlobs * sizeof(CRYPT_DATA_BLOB));
684 for (i = 0; ret && i < out->cBlobs; i++)
685 ret = CRYPT_ConstructBlob(&out->blobs[i], &in->blobs[i]);
686 }
687 else
688 ret = FALSE;
689 }
690 return ret;
691 }
692
693 static void CRYPT_FreeBlobArray(BlobArray *array)
694 {
695 DWORD i;
696
697 for (i = 0; i < array->cBlobs; i++)
698 CryptMemFree(array->blobs[i].pbData);
699 CryptMemFree(array->blobs);
700 }
701
702 static BOOL CRYPT_ConstructAttribute(CRYPT_ATTRIBUTE *out,
703 const CRYPT_ATTRIBUTE *in)
704 {
705 BOOL ret;
706
707 out->pszObjId = CryptMemAlloc(strlen(in->pszObjId) + 1);
708 if (out->pszObjId)
709 {
710 strcpy(out->pszObjId, in->pszObjId);
711 ret = CRYPT_ConstructBlobArray((BlobArray *)&out->cValue,
712 (const BlobArray *)&in->cValue);
713 }
714 else
715 ret = FALSE;
716 return ret;
717 }
718
719 static BOOL CRYPT_ConstructAttributes(CRYPT_ATTRIBUTES *out,
720 const CRYPT_ATTRIBUTES *in)
721 {
722 BOOL ret = TRUE;
723
724 out->cAttr = in->cAttr;
725 if (out->cAttr)
726 {
727 out->rgAttr = CryptMemAlloc(out->cAttr * sizeof(CRYPT_ATTRIBUTE));
728 if (out->rgAttr)
729 {
730 DWORD i;
731
732 memset(out->rgAttr, 0, out->cAttr * sizeof(CRYPT_ATTRIBUTE));
733 for (i = 0; ret && i < out->cAttr; i++)
734 ret = CRYPT_ConstructAttribute(&out->rgAttr[i], &in->rgAttr[i]);
735 }
736 else
737 ret = FALSE;
738 }
739 else
740 out->rgAttr = NULL;
741 return ret;
742 }
743
744 /* Constructs a CMSG_SIGNER_INFO from a CMSG_SIGNER_ENCODE_INFO_WITH_CMS. */
745 static BOOL CSignerInfo_Construct(CMSG_SIGNER_INFO *info,
746 CMSG_SIGNER_ENCODE_INFO_WITH_CMS *in)
747 {
748 BOOL ret;
749
750 /* Note: needs to change if CMS fields are supported */
751 info->dwVersion = CMSG_SIGNER_INFO_V1;
752 ret = CRYPT_ConstructBlob(&info->Issuer, &in->pCertInfo->Issuer);
753 if (ret)
754 ret = CRYPT_ConstructBlob(&info->SerialNumber,
755 &in->pCertInfo->SerialNumber);
756 /* Assumption: algorithm IDs will point to static strings, not
757 * stack-based ones, so copying the pointer values is safe.
758 */
759 info->HashAlgorithm.pszObjId = in->HashAlgorithm.pszObjId;
760 if (ret)
761 ret = CRYPT_ConstructBlob(&info->HashAlgorithm.Parameters,
762 &in->HashAlgorithm.Parameters);
763 memset(&info->HashEncryptionAlgorithm, 0,
764 sizeof(info->HashEncryptionAlgorithm));
765 if (ret)
766 ret = CRYPT_ConstructAttributes(&info->AuthAttrs,
767 (CRYPT_ATTRIBUTES *)&in->cAuthAttr);
768 if (ret)
769 ret = CRYPT_ConstructAttributes(&info->UnauthAttrs,
770 (CRYPT_ATTRIBUTES *)&in->cUnauthAttr);
771 return ret;
772 }
773
774 static void CSignerInfo_Free(CMSG_SIGNER_INFO *info)
775 {
776 DWORD i, j;
777
778 CryptMemFree(info->Issuer.pbData);
779 CryptMemFree(info->SerialNumber.pbData);
780 CryptMemFree(info->HashAlgorithm.Parameters.pbData);
781 CryptMemFree(info->EncryptedHash.pbData);
782 for (i = 0; i < info->AuthAttrs.cAttr; i++)
783 {
784 for (j = 0; j < info->AuthAttrs.rgAttr[i].cValue; j++)
785 CryptMemFree(info->AuthAttrs.rgAttr[i].rgValue[j].pbData);
786 CryptMemFree(info->AuthAttrs.rgAttr[i].rgValue);
787 CryptMemFree(info->AuthAttrs.rgAttr[i].pszObjId);
788 }
789 CryptMemFree(info->AuthAttrs.rgAttr);
790 for (i = 0; i < info->UnauthAttrs.cAttr; i++)
791 {
792 for (j = 0; j < info->UnauthAttrs.rgAttr[i].cValue; j++)
793 CryptMemFree(info->UnauthAttrs.rgAttr[i].rgValue[j].pbData);
794 CryptMemFree(info->UnauthAttrs.rgAttr[i].rgValue);
795 CryptMemFree(info->UnauthAttrs.rgAttr[i].pszObjId);
796 }
797 CryptMemFree(info->UnauthAttrs.rgAttr);
798 }
799
800 typedef struct _CSignerHandles
801 {
802 HCRYPTHASH contentHash;
803 HCRYPTHASH authAttrHash;
804 HCRYPTKEY key;
805 } CSignerHandles;
806
807 typedef struct _CSignedMsgData
808 {
809 CRYPT_SIGNED_INFO *info;
810 CSignerHandles *signerHandles;
811 } CSignedMsgData;
812
813 /* Constructs the signer handles for the signerIndex'th signer of msg_data.
814 * Assumes signerIndex is a valid idnex, and that msg_data's info has already
815 * been constructed.
816 */
817 static BOOL CSignedMsgData_ConstructSignerHandles(CSignedMsgData *msg_data,
818 DWORD signerIndex, HCRYPTPROV crypt_prov)
819 {
820 ALG_ID algID;
821 BOOL ret;
822
823 algID = CertOIDToAlgId(
824 msg_data->info->rgSignerInfo[signerIndex].HashAlgorithm.pszObjId);
825 ret = CryptCreateHash(crypt_prov, algID, 0, 0,
826 &msg_data->signerHandles->contentHash);
827 if (ret && msg_data->info->rgSignerInfo[signerIndex].AuthAttrs.cAttr > 0)
828 ret = CryptCreateHash(crypt_prov, algID, 0, 0,
829 &msg_data->signerHandles->authAttrHash);
830 return ret;
831 }
832
833 /* Allocates a CSignedMsgData's handles. Assumes its info has already been
834 * constructed.
835 */
836 static BOOL CSignedMsgData_AllocateHandles(CSignedMsgData *msg_data)
837 {
838 BOOL ret = TRUE;
839
840 if (msg_data->info->cSignerInfo)
841 {
842 msg_data->signerHandles =
843 CryptMemAlloc(msg_data->info->cSignerInfo * sizeof(CSignerHandles));
844 if (msg_data->signerHandles)
845 memset(msg_data->signerHandles, 0,
846 msg_data->info->cSignerInfo * sizeof(CSignerHandles));
847 else
848 ret = FALSE;
849 }
850 else
851 msg_data->signerHandles = NULL;
852 return ret;
853 }
854
855 static void CSignedMsgData_CloseHandles(CSignedMsgData *msg_data)
856 {
857 DWORD i;
858
859 for (i = 0; i < msg_data->info->cSignerInfo; i++)
860 {
861 if (msg_data->signerHandles[i].key)
862 CryptDestroyKey(msg_data->signerHandles[i].key);
863 if (msg_data->signerHandles[i].contentHash)
864 CryptDestroyHash(msg_data->signerHandles[i].contentHash);
865 if (msg_data->signerHandles[i].authAttrHash)
866 CryptDestroyHash(msg_data->signerHandles[i].authAttrHash);
867 }
868 CryptMemFree(msg_data->signerHandles);
869 }
870
871 static BOOL CSignedMsgData_UpdateHash(CSignedMsgData *msg_data,
872 const BYTE *pbData, DWORD cbData)
873 {
874 DWORD i;
875 BOOL ret = TRUE;
876
877 for (i = 0; ret && i < msg_data->info->cSignerInfo; i++)
878 ret = CryptHashData(msg_data->signerHandles[i].contentHash, pbData,
879 cbData, 0);
880 return ret;
881 }
882
883 static BOOL CRYPT_AppendAttribute(CRYPT_ATTRIBUTES *out,
884 const CRYPT_ATTRIBUTE *in)
885 {
886 BOOL ret = FALSE;
887
888 out->rgAttr = CryptMemRealloc(out->rgAttr,
889 (out->cAttr + 1) * sizeof(CRYPT_ATTRIBUTE));
890 if (out->rgAttr)
891 {
892 ret = CRYPT_ConstructAttribute(&out->rgAttr[out->cAttr], in);
893 if (ret)
894 out->cAttr++;
895 }
896 return ret;
897 }
898
899 static BOOL CSignedMsgData_AppendMessageDigestAttribute(
900 CSignedMsgData *msg_data, DWORD signerIndex)
901 {
902 BOOL ret;
903 DWORD size;
904 CRYPT_HASH_BLOB hash = { 0, NULL }, encodedHash = { 0, NULL };
905 char messageDigest[] = szOID_RSA_messageDigest;
906 CRYPT_ATTRIBUTE messageDigestAttr = { messageDigest, 1, &encodedHash };
907
908 size = sizeof(DWORD);
909 ret = CryptGetHashParam(
910 msg_data->signerHandles[signerIndex].contentHash, HP_HASHSIZE,
911 (LPBYTE)&hash.cbData, &size, 0);
912 if (ret)
913 {
914 hash.pbData = CryptMemAlloc(hash.cbData);
915 ret = CryptGetHashParam(
916 msg_data->signerHandles[signerIndex].contentHash, HP_HASHVAL,
917 hash.pbData, &hash.cbData, 0);
918 if (ret)
919 {
920 ret = CRYPT_AsnEncodeOctets(0, NULL, &hash, CRYPT_ENCODE_ALLOC_FLAG,
921 NULL, (LPBYTE)&encodedHash.pbData, &encodedHash.cbData);
922 if (ret)
923 {
924 ret = CRYPT_AppendAttribute(
925 &msg_data->info->rgSignerInfo[signerIndex].AuthAttrs,
926 &messageDigestAttr);
927 LocalFree(encodedHash.pbData);
928 }
929 }
930 CryptMemFree(hash.pbData);
931 }
932 return ret;
933 }
934
935 typedef enum {
936 Sign,
937 Verify
938 } SignOrVerify;
939
940 static BOOL CSignedMsgData_UpdateAuthenticatedAttributes(
941 CSignedMsgData *msg_data, SignOrVerify flag)
942 {
943 DWORD i;
944 BOOL ret = TRUE;
945
946 TRACE("(%p)\n", msg_data);
947
948 for (i = 0; ret && i < msg_data->info->cSignerInfo; i++)
949 {
950 if (msg_data->info->rgSignerInfo[i].AuthAttrs.cAttr)
951 {
952 if (flag == Sign)
953 {
954 BYTE oid_rsa_data_encoded[] = { 0x06,0x09,0x2a,0x86,0x48,0x86,
955 0xf7,0x0d,0x01,0x07,0x01 };
956 CRYPT_DATA_BLOB content = { sizeof(oid_rsa_data_encoded),
957 oid_rsa_data_encoded };
958 char contentType[] = szOID_RSA_contentType;
959 CRYPT_ATTRIBUTE contentTypeAttr = { contentType, 1, &content };
960
961 /* FIXME: does this depend on inner OID? */
962 ret = CRYPT_AppendAttribute(
963 &msg_data->info->rgSignerInfo[i].AuthAttrs, &contentTypeAttr);
964 if (ret)
965 ret = CSignedMsgData_AppendMessageDigestAttribute(msg_data,
966 i);
967 }
968 if (ret)
969 {
970 LPBYTE encodedAttrs;
971 DWORD size;
972
973 ret = CryptEncodeObjectEx(X509_ASN_ENCODING, PKCS_ATTRIBUTES,
974 &msg_data->info->rgSignerInfo[i].AuthAttrs,
975 CRYPT_ENCODE_ALLOC_FLAG, NULL, (LPBYTE)&encodedAttrs, &size);
976 if (ret)
977 {
978 ret = CryptHashData(
979 msg_data->signerHandles[i].authAttrHash, encodedAttrs,
980 size, 0);
981 LocalFree(encodedAttrs);
982 }
983 }
984 }
985 }
986 TRACE("returning %d\n", ret);
987 return ret;
988 }
989
990 static void CRYPT_ReverseBytes(CRYPT_HASH_BLOB *hash)
991 {
992 DWORD i;
993 BYTE tmp;
994
995 for (i = 0; i < hash->cbData / 2; i++)
996 {
997 tmp = hash->pbData[hash->cbData - i - 1];
998 hash->pbData[hash->cbData - i - 1] = hash->pbData[i];
999 hash->pbData[i] = tmp;
1000 }
1001 }
1002
1003 static BOOL CSignedMsgData_Sign(CSignedMsgData *msg_data)
1004 {
1005 DWORD i;
1006 BOOL ret = TRUE;
1007
1008 TRACE("(%p)\n", msg_data);
1009
1010 for (i = 0; ret && i < msg_data->info->cSignerInfo; i++)
1011 {
1012 HCRYPTHASH hash;
1013
1014 if (msg_data->info->rgSignerInfo[i].AuthAttrs.cAttr)
1015 hash = msg_data->signerHandles[i].authAttrHash;
1016 else
1017 hash = msg_data->signerHandles[i].contentHash;
1018 ret = CryptSignHashW(hash, AT_SIGNATURE, NULL, 0, NULL,
1019 &msg_data->info->rgSignerInfo[i].EncryptedHash.cbData);
1020 if (ret)
1021 {
1022 msg_data->info->rgSignerInfo[i].EncryptedHash.pbData =
1023 CryptMemAlloc(
1024 msg_data->info->rgSignerInfo[i].EncryptedHash.cbData);
1025 if (msg_data->info->rgSignerInfo[i].EncryptedHash.pbData)
1026 {
1027 ret = CryptSignHashW(hash, AT_SIGNATURE, NULL, 0,
1028 msg_data->info->rgSignerInfo[i].EncryptedHash.pbData,
1029 &msg_data->info->rgSignerInfo[i].EncryptedHash.cbData);
1030 if (ret)
1031 CRYPT_ReverseBytes(
1032 &msg_data->info->rgSignerInfo[i].EncryptedHash);
1033 }
1034 else
1035 ret = FALSE;
1036 }
1037 }
1038 return ret;
1039 }
1040
1041 static BOOL CSignedMsgData_Update(CSignedMsgData *msg_data,
1042 const BYTE *pbData, DWORD cbData, BOOL fFinal, SignOrVerify flag)
1043 {
1044 BOOL ret = CSignedMsgData_UpdateHash(msg_data, pbData, cbData);
1045
1046 if (ret && fFinal)
1047 {
1048 ret = CSignedMsgData_UpdateAuthenticatedAttributes(msg_data, flag);
1049 if (ret && flag == Sign)
1050 ret = CSignedMsgData_Sign(msg_data);
1051 }
1052 return ret;
1053 }
1054
1055 typedef struct _CSignedEncodeMsg
1056 {
1057 CryptMsgBase base;
1058 CRYPT_DATA_BLOB data;
1059 CSignedMsgData msg_data;
1060 } CSignedEncodeMsg;
1061
1062 static void CSignedEncodeMsg_Close(HCRYPTMSG hCryptMsg)
1063 {
1064 CSignedEncodeMsg *msg = (CSignedEncodeMsg *)hCryptMsg;
1065 DWORD i;
1066
1067 CryptMemFree(msg->data.pbData);
1068 CRYPT_FreeBlobArray((BlobArray *)&msg->msg_data.info->cCertEncoded);
1069 CRYPT_FreeBlobArray((BlobArray *)&msg->msg_data.info->cCrlEncoded);
1070 for (i = 0; i < msg->msg_data.info->cSignerInfo; i++)
1071 CSignerInfo_Free(&msg->msg_data.info->rgSignerInfo[i]);
1072 CSignedMsgData_CloseHandles(&msg->msg_data);
1073 CryptMemFree(msg->msg_data.info->rgSignerInfo);
1074 CryptMemFree(msg->msg_data.info);
1075 }
1076
1077 static BOOL CSignedEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
1078 DWORD dwIndex, void *pvData, DWORD *pcbData)
1079 {
1080 CSignedEncodeMsg *msg = (CSignedEncodeMsg *)hCryptMsg;
1081 BOOL ret = FALSE;
1082
1083 switch (dwParamType)
1084 {
1085 case CMSG_CONTENT_PARAM:
1086 {
1087 CRYPT_CONTENT_INFO info;
1088
1089 ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0, NULL,
1090 &info.Content.cbData);
1091 if (ret)
1092 {
1093 info.Content.pbData = CryptMemAlloc(info.Content.cbData);
1094 if (info.Content.pbData)
1095 {
1096 ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0,
1097 info.Content.pbData, &info.Content.cbData);
1098 if (ret)
1099 {
1100 char oid_rsa_signed[] = szOID_RSA_signedData;
1101
1102 info.pszObjId = oid_rsa_signed;
1103 ret = CryptEncodeObjectEx(X509_ASN_ENCODING,
1104 PKCS_CONTENT_INFO, &info, 0, NULL, pvData, pcbData);
1105 }
1106 CryptMemFree(info.Content.pbData);
1107 }
1108 else
1109 ret = FALSE;
1110 }
1111 break;
1112 }
1113 case CMSG_BARE_CONTENT_PARAM:
1114 {
1115 CRYPT_SIGNED_INFO info;
1116 char oid_rsa_data[] = szOID_RSA_data;
1117
1118 memcpy(&info, msg->msg_data.info, sizeof(info));
1119 /* Quirk: OID is only encoded messages if an update has happened */
1120 if (msg->base.state != MsgStateInit)
1121 info.content.pszObjId = oid_rsa_data;
1122 else
1123 info.content.pszObjId = NULL;
1124 if (msg->data.cbData)
1125 {
1126 CRYPT_DATA_BLOB blob = { msg->data.cbData, msg->data.pbData };
1127
1128 ret = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
1129 &blob, CRYPT_ENCODE_ALLOC_FLAG, NULL,
1130 &info.content.Content.pbData, &info.content.Content.cbData);
1131 }
1132 else
1133 {
1134 info.content.Content.cbData = 0;
1135 info.content.Content.pbData = NULL;
1136 ret = TRUE;
1137 }
1138 if (ret)
1139 {
1140 ret = CRYPT_AsnEncodePKCSSignedInfo(&info, pvData, pcbData);
1141 LocalFree(info.content.Content.pbData);
1142 }
1143 break;
1144 }
1145 case CMSG_COMPUTED_HASH_PARAM:
1146 if (dwIndex >= msg->msg_data.info->cSignerInfo)
1147 SetLastError(CRYPT_E_INVALID_INDEX);
1148 else
1149 ret = CryptGetHashParam(
1150 msg->msg_data.signerHandles[dwIndex].contentHash, HP_HASHVAL,
1151 pvData, pcbData, 0);
1152 break;
1153 case CMSG_ENCODED_SIGNER:
1154 if (dwIndex >= msg->msg_data.info->cSignerInfo)
1155 SetLastError(CRYPT_E_INVALID_INDEX);
1156 else
1157 ret = CryptEncodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
1158 PKCS7_SIGNER_INFO, &msg->msg_data.info->rgSignerInfo[dwIndex], 0,
1159 NULL, pvData, pcbData);
1160 break;
1161 case CMSG_VERSION_PARAM:
1162 ret = CRYPT_CopyParam(pvData, pcbData, &msg->msg_data.info->version,
1163 sizeof(msg->msg_data.info->version));
1164 break;
1165 default:
1166 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1167 }
1168 return ret;
1169 }
1170
1171 static BOOL CSignedEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
1172 DWORD cbData, BOOL fFinal)
1173 {
1174 CSignedEncodeMsg *msg = (CSignedEncodeMsg *)hCryptMsg;
1175 BOOL ret = FALSE;
1176
1177 if (msg->base.streamed || (msg->base.open_flags & CMSG_DETACHED_FLAG))
1178 {
1179 ret = CSignedMsgData_Update(&msg->msg_data, pbData, cbData, fFinal,
1180 Sign);
1181 if (msg->base.streamed)
1182 FIXME("streamed partial stub\n");
1183 }
1184 else
1185 {
1186 if (!fFinal)
1187 SetLastError(CRYPT_E_MSG_ERROR);
1188 else
1189 {
1190 if (cbData)
1191 {
1192 msg->data.pbData = CryptMemAlloc(cbData);
1193 if (msg->data.pbData)
1194 {
1195 memcpy(msg->data.pbData, pbData, cbData);
1196 msg->data.cbData = cbData;
1197 ret = TRUE;
1198 }
1199 }
1200 else
1201 ret = TRUE;
1202 if (ret)
1203 ret = CSignedMsgData_Update(&msg->msg_data, pbData, cbData,
1204 fFinal, Sign);
1205 }
1206 }
1207 return ret;
1208 }
1209
1210 static HCRYPTMSG CSignedEncodeMsg_Open(DWORD dwFlags,
1211 const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID,
1212 PCMSG_STREAM_INFO pStreamInfo)
1213 {
1214 const CMSG_SIGNED_ENCODE_INFO_WITH_CMS *info =
1215 (const CMSG_SIGNED_ENCODE_INFO_WITH_CMS *)pvMsgEncodeInfo;
1216 DWORD i;
1217 CSignedEncodeMsg *msg;
1218
1219 if (info->cbSize != sizeof(CMSG_SIGNED_ENCODE_INFO) &&
1220 info->cbSize != sizeof(CMSG_SIGNED_ENCODE_INFO_WITH_CMS))
1221 {
1222 SetLastError(E_INVALIDARG);
1223 return NULL;
1224 }
1225 if (info->cbSize == sizeof(CMSG_SIGNED_ENCODE_INFO_WITH_CMS))
1226 {
1227 FIXME("CMSG_SIGNED_ENCODE_INFO with CMS fields unsupported\n");
1228 return NULL;
1229 }
1230 for (i = 0; i < info->cSigners; i++)
1231 if (!CRYPT_IsValidSigner(&info->rgSigners[i]))
1232 return NULL;
1233 msg = CryptMemAlloc(sizeof(CSignedEncodeMsg));
1234 if (msg)
1235 {
1236 BOOL ret = TRUE;
1237
1238 CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
1239 CSignedEncodeMsg_Close, CSignedEncodeMsg_GetParam,
1240 CSignedEncodeMsg_Update, CRYPT_DefaultMsgControl);
1241 msg->data.cbData = 0;
1242 msg->data.pbData = NULL;
1243 msg->msg_data.info = CryptMemAlloc(sizeof(CRYPT_SIGNED_INFO));
1244 if (msg->msg_data.info)
1245 {
1246 memset(msg->msg_data.info, 0, sizeof(CRYPT_SIGNED_INFO));
1247 msg->msg_data.info->version = CMSG_SIGNED_DATA_V1;
1248 }
1249 else
1250 ret = FALSE;
1251 if (ret && info->cSigners)
1252 {
1253 msg->msg_data.info->rgSignerInfo =
1254 CryptMemAlloc(info->cSigners * sizeof(CMSG_SIGNER_INFO));
1255 if (msg->msg_data.info->rgSignerInfo)
1256 {
1257 msg->msg_data.info->cSignerInfo = info->cSigners;
1258 memset(msg->msg_data.info->rgSignerInfo, 0,
1259 msg->msg_data.info->cSignerInfo * sizeof(CMSG_SIGNER_INFO));
1260 ret = CSignedMsgData_AllocateHandles(&msg->msg_data);
1261 for (i = 0; ret && i < msg->msg_data.info->cSignerInfo; i++)
1262 {
1263 ret = CSignerInfo_Construct(
1264 &msg->msg_data.info->rgSignerInfo[i],
1265 &info->rgSigners[i]);
1266 if (ret)
1267 {
1268 ret = CSignedMsgData_ConstructSignerHandles(
1269 &msg->msg_data, i, info->rgSigners[i].hCryptProv);
1270 if (dwFlags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
1271 CryptReleaseContext(info->rgSigners[i].hCryptProv,
1272 0);
1273 }
1274 }
1275 }
1276 else
1277 ret = FALSE;
1278 }
1279 if (ret)
1280 ret = CRYPT_ConstructBlobArray(
1281 (BlobArray *)&msg->msg_data.info->cCertEncoded,
1282 (const BlobArray *)&info->cCertEncoded);
1283 if (ret)
1284 ret = CRYPT_ConstructBlobArray(
1285 (BlobArray *)&msg->msg_data.info->cCrlEncoded,
1286 (const BlobArray *)&info->cCrlEncoded);
1287 if (!ret)
1288 {
1289 CSignedEncodeMsg_Close(msg);
1290 msg = NULL;
1291 }
1292 }
1293 return msg;
1294 }
1295
1296 static inline const char *MSG_TYPE_STR(DWORD type)
1297 {
1298 switch (type)
1299 {
1300 #define _x(x) case (x): return #x
1301 _x(CMSG_DATA);
1302 _x(CMSG_SIGNED);
1303 _x(CMSG_ENVELOPED);
1304 _x(CMSG_SIGNED_AND_ENVELOPED);
1305 _x(CMSG_HASHED);
1306 _x(CMSG_ENCRYPTED);
1307 #undef _x
1308 default:
1309 return wine_dbg_sprintf("unknown (%d)", type);
1310 }
1311 }
1312
1313 HCRYPTMSG WINAPI CryptMsgOpenToEncode(DWORD dwMsgEncodingType, DWORD dwFlags,
1314 DWORD dwMsgType, const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID,
1315 PCMSG_STREAM_INFO pStreamInfo)
1316 {
1317 HCRYPTMSG msg = NULL;
1318
1319 TRACE("(%08x, %08x, %08x, %p, %s, %p)\n", dwMsgEncodingType, dwFlags,
1320 dwMsgType, pvMsgEncodeInfo, debugstr_a(pszInnerContentObjID), pStreamInfo);
1321
1322 if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType) != PKCS_7_ASN_ENCODING)
1323 {
1324 SetLastError(E_INVALIDARG);
1325 return NULL;
1326 }
1327 switch (dwMsgType)
1328 {
1329 case CMSG_DATA:
1330 msg = CDataEncodeMsg_Open(dwFlags, pvMsgEncodeInfo,
1331 pszInnerContentObjID, pStreamInfo);
1332 break;
1333 case CMSG_HASHED:
1334 msg = CHashEncodeMsg_Open(dwFlags, pvMsgEncodeInfo,
1335 pszInnerContentObjID, pStreamInfo);
1336 break;
1337 case CMSG_SIGNED:
1338 msg = CSignedEncodeMsg_Open(dwFlags, pvMsgEncodeInfo,
1339 pszInnerContentObjID, pStreamInfo);
1340 break;
1341 case CMSG_ENVELOPED:
1342 FIXME("unimplemented for type %s\n", MSG_TYPE_STR(dwMsgType));
1343 break;
1344 case CMSG_SIGNED_AND_ENVELOPED:
1345 case CMSG_ENCRYPTED:
1346 /* defined but invalid, fall through */
1347 default:
1348 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1349 }
1350 return msg;
1351 }
1352
1353 typedef struct _CDecodeMsg
1354 {
1355 CryptMsgBase base;
1356 DWORD type;
1357 HCRYPTPROV crypt_prov;
1358 union {
1359 HCRYPTHASH hash;
1360 CSignedMsgData signed_data;
1361 } u;
1362 CRYPT_DATA_BLOB msg_data;
1363 PCONTEXT_PROPERTY_LIST properties;
1364 } CDecodeMsg;
1365
1366 static void CDecodeMsg_Close(HCRYPTMSG hCryptMsg)
1367 {
1368 CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
1369
1370 if (msg->base.open_flags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
1371 CryptReleaseContext(msg->crypt_prov, 0);
1372 switch (msg->type)
1373 {
1374 case CMSG_HASHED:
1375 if (msg->u.hash)
1376 CryptDestroyHash(msg->u.hash);
1377 break;
1378 case CMSG_SIGNED:
1379 if (msg->u.signed_data.info)
1380 {
1381 LocalFree(msg->u.signed_data.info);
1382 CSignedMsgData_CloseHandles(&msg->u.signed_data);
1383 }
1384 break;
1385 }
1386 CryptMemFree(msg->msg_data.pbData);
1387 ContextPropertyList_Free(msg->properties);
1388 }
1389
1390 static BOOL CDecodeMsg_CopyData(CDecodeMsg *msg, const BYTE *pbData,
1391 DWORD cbData)
1392 {
1393 BOOL ret = TRUE;
1394
1395 if (cbData)
1396 {
1397 if (msg->msg_data.cbData)
1398 msg->msg_data.pbData = CryptMemRealloc(msg->msg_data.pbData,
1399 msg->msg_data.cbData + cbData);
1400 else
1401 msg->msg_data.pbData = CryptMemAlloc(cbData);
1402 if (msg->msg_data.pbData)
1403 {
1404 memcpy(msg->msg_data.pbData + msg->msg_data.cbData, pbData, cbData);
1405 msg->msg_data.cbData += cbData;
1406 }
1407 else
1408 ret = FALSE;
1409 }
1410 return ret;
1411 }
1412
1413 static BOOL CDecodeMsg_DecodeDataContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
1414 {
1415 BOOL ret;
1416 CRYPT_DATA_BLOB *data;
1417 DWORD size;
1418
1419 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
1420 blob->pbData, blob->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, (LPBYTE)&data,
1421 &size);
1422 if (ret)
1423 {
1424 ret = ContextPropertyList_SetProperty(msg->properties,
1425 CMSG_CONTENT_PARAM, data->pbData, data->cbData);
1426 LocalFree(data);
1427 }
1428 return ret;
1429 }
1430
1431 static void CDecodeMsg_SaveAlgorithmID(CDecodeMsg *msg, DWORD param,
1432 const CRYPT_ALGORITHM_IDENTIFIER *id)
1433 {
1434 static const BYTE nullParams[] = { ASN_NULL, 0 };
1435 CRYPT_ALGORITHM_IDENTIFIER *copy;
1436 DWORD len = sizeof(CRYPT_ALGORITHM_IDENTIFIER);
1437
1438 /* Linearize algorithm id */
1439 len += strlen(id->pszObjId) + 1;
1440 len += id->Parameters.cbData;
1441 copy = CryptMemAlloc(len);
1442 if (copy)
1443 {
1444 copy->pszObjId =
1445 (LPSTR)((BYTE *)copy + sizeof(CRYPT_ALGORITHM_IDENTIFIER));
1446 strcpy(copy->pszObjId, id->pszObjId);
1447 copy->Parameters.pbData = (BYTE *)copy->pszObjId + strlen(id->pszObjId)
1448 + 1;
1449 /* Trick: omit NULL parameters */
1450 if (id->Parameters.cbData == sizeof(nullParams) &&
1451 !memcmp(id->Parameters.pbData, nullParams, sizeof(nullParams)))
1452 {
1453 copy->Parameters.cbData = 0;
1454 len -= sizeof(nullParams);
1455 }
1456 else
1457 copy->Parameters.cbData = id->Parameters.cbData;
1458 if (copy->Parameters.cbData)
1459 memcpy(copy->Parameters.pbData, id->Parameters.pbData,
1460 id->Parameters.cbData);
1461 ContextPropertyList_SetProperty(msg->properties, param, (BYTE *)copy,
1462 len);
1463 CryptMemFree(copy);
1464 }
1465 }
1466
1467 static inline void CRYPT_FixUpAlgorithmID(CRYPT_ALGORITHM_IDENTIFIER *id)
1468 {
1469 id->pszObjId = (LPSTR)((BYTE *)id + sizeof(CRYPT_ALGORITHM_IDENTIFIER));
1470 id->Parameters.pbData = (BYTE *)id->pszObjId + strlen(id->pszObjId) + 1;
1471 }
1472
1473 static BOOL CDecodeMsg_DecodeHashedContent(CDecodeMsg *msg,
1474 CRYPT_DER_BLOB *blob)
1475 {
1476 BOOL ret;
1477 CRYPT_DIGESTED_DATA *digestedData;
1478 DWORD size;
1479
1480 ret = CRYPT_AsnDecodePKCSDigestedData(blob->pbData, blob->cbData,
1481 CRYPT_DECODE_ALLOC_FLAG, NULL, (CRYPT_DIGESTED_DATA *)&digestedData,
1482 &size);
1483 if (ret)
1484 {
1485 ContextPropertyList_SetProperty(msg->properties, CMSG_VERSION_PARAM,
1486 (const BYTE *)&digestedData->version, sizeof(digestedData->version));
1487 CDecodeMsg_SaveAlgorithmID(msg, CMSG_HASH_ALGORITHM_PARAM,
1488 &digestedData->DigestAlgorithm);
1489 ContextPropertyList_SetProperty(msg->properties,
1490 CMSG_INNER_CONTENT_TYPE_PARAM,
1491 (const BYTE *)digestedData->ContentInfo.pszObjId,
1492 digestedData->ContentInfo.pszObjId ?
1493 strlen(digestedData->ContentInfo.pszObjId) + 1 : 0);
1494 if (digestedData->ContentInfo.Content.cbData)
1495 CDecodeMsg_DecodeDataContent(msg,
1496 &digestedData->ContentInfo.Content);
1497 else
1498 ContextPropertyList_SetProperty(msg->properties,
1499 CMSG_CONTENT_PARAM, NULL, 0);
1500 ContextPropertyList_SetProperty(msg->properties, CMSG_HASH_DATA_PARAM,
1501 digestedData->hash.pbData, digestedData->hash.cbData);
1502 LocalFree(digestedData);
1503 }
1504 return ret;
1505 }
1506
1507 static BOOL CDecodeMsg_DecodeSignedContent(CDecodeMsg *msg,
1508 CRYPT_DER_BLOB *blob)
1509 {
1510 BOOL ret;
1511 CRYPT_SIGNED_INFO *signedInfo;
1512 DWORD size;
1513
1514 ret = CRYPT_AsnDecodePKCSSignedInfo(blob->pbData, blob->cbData,
1515 CRYPT_DECODE_ALLOC_FLAG, NULL, (CRYPT_SIGNED_INFO *)&signedInfo,
1516 &size);
1517 if (ret)
1518 {
1519 DWORD i;
1520
1521 msg->u.signed_data.info = signedInfo;
1522 ret = CSignedMsgData_AllocateHandles(&msg->u.signed_data);
1523 for (i = 0; ret && i < msg->u.signed_data.info->cSignerInfo; i++)
1524 ret = CSignedMsgData_ConstructSignerHandles(&msg->u.signed_data, i,
1525 msg->crypt_prov);
1526 if (ret)
1527 {
1528 /* Now that we have all the content, update the hash handles with
1529 * it. Have to decode it if the type is szOID_RSA_data.
1530 */
1531 if (msg->u.signed_data.info->content.Content.cbData)
1532 {
1533 if (!strcmp(msg->u.signed_data.info->content.pszObjId,
1534 szOID_RSA_data))
1535 {
1536 CRYPT_DATA_BLOB *blob;
1537
1538 ret = CryptDecodeObjectEx(X509_ASN_ENCODING,
1539 X509_OCTET_STRING,
1540 msg->u.signed_data.info->content.Content.pbData,
1541 msg->u.signed_data.info->content.Content.cbData,
1542 CRYPT_DECODE_ALLOC_FLAG, NULL, (LPBYTE)&blob, &size);
1543 if (ret)
1544 {
1545 ret = CSignedMsgData_Update(&msg->u.signed_data,
1546 blob->pbData, blob->cbData, TRUE, Verify);
1547 LocalFree(blob);
1548 }
1549 }
1550 else
1551 ret = CSignedMsgData_Update(&msg->u.signed_data,
1552 msg->u.signed_data.info->content.Content.pbData,
1553 msg->u.signed_data.info->content.Content.cbData, TRUE,
1554 Verify);
1555 }
1556 }
1557 }
1558 return ret;
1559 }
1560 /* Decodes the content in blob as the type given, and updates the value
1561 * (type, parameters, etc.) of msg based on what blob contains.
1562 * It doesn't just use msg's type, to allow a recursive call from an implicitly
1563 * typed message once the outer content info has been decoded.
1564 */
1565 static BOOL CDecodeMsg_DecodeContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob,
1566 DWORD type)
1567 {
1568 BOOL ret;
1569
1570 switch (type)
1571 {
1572 case CMSG_DATA:
1573 if ((ret = CDecodeMsg_DecodeDataContent(msg, blob)))
1574 msg->type = CMSG_DATA;
1575 break;
1576 case CMSG_HASHED:
1577 if ((ret = CDecodeMsg_DecodeHashedContent(msg, blob)))
1578 msg->type = CMSG_HASHED;
1579 break;
1580 case CMSG_ENVELOPED:
1581 FIXME("unimplemented for type %s\n", MSG_TYPE_STR(type));
1582 ret = TRUE;
1583 break;
1584 case CMSG_SIGNED:
1585 if ((ret = CDecodeMsg_DecodeSignedContent(msg, blob)))
1586 msg->type = CMSG_SIGNED;
1587 break;
1588 default:
1589 {
1590 CRYPT_CONTENT_INFO *info;
1591 DWORD size;
1592
1593 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, PKCS_CONTENT_INFO,
1594 msg->msg_data.pbData, msg->msg_data.cbData, CRYPT_DECODE_ALLOC_FLAG,
1595 NULL, (LPBYTE)&info, &size);
1596 if (ret)
1597 {
1598 if (!strcmp(info->pszObjId, szOID_RSA_data))
1599 ret = CDecodeMsg_DecodeContent(msg, &info->Content, CMSG_DATA);
1600 else if (!strcmp(info->pszObjId, szOID_RSA_digestedData))
1601 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
1602 CMSG_HASHED);
1603 else if (!strcmp(info->pszObjId, szOID_RSA_envelopedData))
1604 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
1605 CMSG_ENVELOPED);
1606 else if (!strcmp(info->pszObjId, szOID_RSA_signedData))
1607 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
1608 CMSG_SIGNED);
1609 else
1610 {
1611 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1612 ret = FALSE;
1613 }
1614 LocalFree(info);
1615 }
1616 }
1617 }
1618 return ret;
1619 }
1620
1621 static BOOL CDecodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
1622 DWORD cbData, BOOL fFinal)
1623 {
1624 CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
1625 BOOL ret = FALSE;
1626
1627 TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
1628
1629 if (msg->base.streamed)
1630 {
1631 ret = CDecodeMsg_CopyData(msg, pbData, cbData);
1632 FIXME("(%p, %p, %d, %d): streamed update stub\n", hCryptMsg, pbData,
1633 cbData, fFinal);
1634 }
1635 else
1636 {
1637 if (!fFinal)
1638 SetLastError(CRYPT_E_MSG_ERROR);
1639 else
1640 {
1641 ret = CDecodeMsg_CopyData(msg, pbData, cbData);
1642 if (ret)
1643 ret = CDecodeMsg_DecodeContent(msg, &msg->msg_data, msg->type);
1644
1645 }
1646 }
1647 return ret;
1648 }
1649
1650 static BOOL CDecodeHashMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType,
1651 DWORD dwIndex, void *pvData, DWORD *pcbData)
1652 {
1653 BOOL ret = FALSE;
1654
1655 switch (dwParamType)
1656 {
1657 case CMSG_TYPE_PARAM:
1658 ret = CRYPT_CopyParam(pvData, pcbData, &msg->type, sizeof(msg->type));
1659 break;
1660 case CMSG_HASH_ALGORITHM_PARAM:
1661 {
1662 CRYPT_DATA_BLOB blob;
1663
1664 ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
1665 &blob);
1666 if (ret)
1667 {
1668 ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData, blob.cbData);
1669 if (ret && pvData)
1670 CRYPT_FixUpAlgorithmID((CRYPT_ALGORITHM_IDENTIFIER *)pvData);
1671 }
1672 else
1673 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1674 break;
1675 }
1676 case CMSG_COMPUTED_HASH_PARAM:
1677 if (!msg->u.hash)
1678 {
1679 CRYPT_ALGORITHM_IDENTIFIER *hashAlgoID = NULL;
1680 DWORD size = 0;
1681 ALG_ID algID = 0;
1682
1683 CryptMsgGetParam(msg, CMSG_HASH_ALGORITHM_PARAM, 0, NULL, &size);
1684 hashAlgoID = CryptMemAlloc(size);
1685 ret = CryptMsgGetParam(msg, CMSG_HASH_ALGORITHM_PARAM, 0,
1686 hashAlgoID, &size);
1687 if (ret)
1688 algID = CertOIDToAlgId(hashAlgoID->pszObjId);
1689 ret = CryptCreateHash(msg->crypt_prov, algID, 0, 0, &msg->u.hash);
1690 if (ret)
1691 {
1692 CRYPT_DATA_BLOB content;
1693
1694 ret = ContextPropertyList_FindProperty(msg->properties,
1695 CMSG_CONTENT_PARAM, &content);
1696 if (ret)
1697 ret = CryptHashData(msg->u.hash, content.pbData,
1698 content.cbData, 0);
1699 }
1700 CryptMemFree(hashAlgoID);
1701 }
1702 else
1703 ret = TRUE;
1704 if (ret)
1705 ret = CryptGetHashParam(msg->u.hash, HP_HASHVAL, pvData, pcbData,
1706 0);
1707 break;
1708 default:
1709 {
1710 CRYPT_DATA_BLOB blob;
1711
1712 ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
1713 &blob);
1714 if (ret)
1715 ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData, blob.cbData);
1716 else
1717 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1718 }
1719 }
1720 return ret;
1721 }
1722
1723 /* nextData is an in/out parameter - on input it's the memory location in
1724 * which a copy of in's data should be made, and on output it's the memory
1725 * location immediately after out's copy of in's data.
1726 */
1727 static inline void CRYPT_CopyBlob(CRYPT_DATA_BLOB *out,
1728 const CRYPT_DATA_BLOB *in, LPBYTE *nextData)
1729 {
1730 out->cbData = in->cbData;
1731 if (in->cbData)
1732 {
1733 out->pbData = *nextData;
1734 memcpy(out->pbData, in->pbData, in->cbData);
1735 *nextData += in->cbData;
1736 }
1737 }
1738
1739 static inline void CRYPT_CopyAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER *out,
1740 const CRYPT_ALGORITHM_IDENTIFIER *in, LPBYTE *nextData)
1741 {
1742 if (in->pszObjId)
1743 {
1744 out->pszObjId = (LPSTR)*nextData;
1745 strcpy(out->pszObjId, in->pszObjId);
1746 *nextData += strlen(out->pszObjId) + 1;
1747 }
1748 CRYPT_CopyBlob(&out->Parameters, &in->Parameters, nextData);
1749 }
1750
1751 static inline void CRYPT_CopyAttributes(CRYPT_ATTRIBUTES *out,
1752 const CRYPT_ATTRIBUTES *in, LPBYTE *nextData)
1753 {
1754 out->cAttr = in->cAttr;
1755 if (in->cAttr)
1756 {
1757 DWORD i;
1758
1759 if ((*nextData - (LPBYTE)0) % sizeof(DWORD_PTR))
1760 *nextData += (*nextData - (LPBYTE)0) % sizeof(DWORD_PTR);
1761 out->rgAttr = (CRYPT_ATTRIBUTE *)*nextData;
1762 *nextData += in->cAttr * sizeof(CRYPT_ATTRIBUTE);
1763 for (i = 0; i < in->cAttr; i++)
1764 {
1765 if (in->rgAttr[i].pszObjId)
1766 {
1767 out->rgAttr[i].pszObjId = (LPSTR)*nextData;
1768 strcpy(out->rgAttr[i].pszObjId, in->rgAttr[i].pszObjId);
1769 *nextData += strlen(in->rgAttr[i].pszObjId) + 1;
1770 }
1771 if (in->rgAttr[i].cValue)
1772 {
1773 DWORD j;
1774
1775 out->rgAttr[i].cValue = in->rgAttr[i].cValue;
1776 if ((*nextData - (LPBYTE)0) % sizeof(DWORD_PTR))
1777 *nextData += (*nextData - (LPBYTE)0) % sizeof(DWORD_PTR);
1778 out->rgAttr[i].rgValue = (PCRYPT_DATA_BLOB)*nextData;
1779 *nextData += in->rgAttr[i].cValue * sizeof(CRYPT_DATA_BLOB);
1780 for (j = 0; j < in->rgAttr[i].cValue; j++)
1781 CRYPT_CopyBlob(&out->rgAttr[i].rgValue[j],
1782 &in->rgAttr[i].rgValue[j], nextData);
1783 }
1784 }
1785 }
1786 }
1787
1788 static DWORD CRYPT_SizeOfAttributes(const CRYPT_ATTRIBUTES *attr)
1789 {
1790 DWORD size = attr->cAttr * sizeof(CRYPT_ATTRIBUTE), i, j;
1791
1792 for (i = 0; i < attr->cAttr; i++)
1793 {
1794 if (attr->rgAttr[i].pszObjId)
1795 size += strlen(attr->rgAttr[i].pszObjId) + 1;
1796 /* align pointer */
1797 if (size % sizeof(DWORD_PTR))
1798 size += size % sizeof(DWORD_PTR);
1799 size += attr->rgAttr[i].cValue * sizeof(CRYPT_DATA_BLOB);
1800 for (j = 0; j < attr->rgAttr[i].cValue; j++)
1801 size += attr->rgAttr[i].rgValue[j].cbData;
1802 }
1803 /* align pointer again to be conservative */
1804 if (size % sizeof(DWORD_PTR))
1805 size += size % sizeof(DWORD_PTR);
1806 return size;
1807 }
1808
1809 static BOOL CRYPT_CopySignerInfo(void *pvData, DWORD *pcbData,
1810 const CMSG_SIGNER_INFO *in)
1811 {
1812 DWORD size = sizeof(CMSG_SIGNER_INFO);
1813 BOOL ret;
1814
1815 TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
1816
1817 size += in->Issuer.cbData;
1818 size += in->SerialNumber.cbData;
1819 if (in->HashAlgorithm.pszObjId)
1820 size += strlen(in->HashAlgorithm.pszObjId) + 1;
1821 size += in->HashAlgorithm.Parameters.cbData;
1822 if (in->HashEncryptionAlgorithm.pszObjId)
1823 size += strlen(in->HashEncryptionAlgorithm.pszObjId) + 1;
1824 size += in->HashEncryptionAlgorithm.Parameters.cbData;
1825 size += in->EncryptedHash.cbData;
1826 /* align pointer */
1827 if (size % sizeof(DWORD_PTR))
1828 size += size % sizeof(DWORD_PTR);
1829 size += CRYPT_SizeOfAttributes(&in->AuthAttrs);
1830 size += CRYPT_SizeOfAttributes(&in->UnauthAttrs);
1831 if (!pvData)
1832 {
1833 *pcbData = size;
1834 ret = TRUE;
1835 }
1836 else if (*pcbData < size)
1837 {
1838 *pcbData = size;
1839 SetLastError(ERROR_MORE_DATA);
1840 ret = FALSE;
1841 }
1842 else
1843 {
1844 LPBYTE nextData = (BYTE *)pvData + sizeof(CMSG_SIGNER_INFO);
1845 CMSG_SIGNER_INFO *out = (CMSG_SIGNER_INFO *)pvData;
1846
1847 out->dwVersion = in->dwVersion;
1848 CRYPT_CopyBlob(&out->Issuer, &in->Issuer, &nextData);
1849 CRYPT_CopyBlob(&out->SerialNumber, &in->SerialNumber, &nextData);
1850 CRYPT_CopyAlgorithmId(&out->HashAlgorithm, &in->HashAlgorithm,
1851 &nextData);
1852 CRYPT_CopyAlgorithmId(&out->HashEncryptionAlgorithm,
1853 &in->HashEncryptionAlgorithm, &nextData);
1854 CRYPT_CopyBlob(&out->EncryptedHash, &in->EncryptedHash, &nextData);
1855 /* align pointer */
1856 if ((nextData - (LPBYTE)0) % sizeof(DWORD_PTR))
1857 nextData += (nextData - (LPBYTE)0) % sizeof(DWORD_PTR);
1858 CRYPT_CopyAttributes(&out->AuthAttrs, &in->AuthAttrs, &nextData);
1859 CRYPT_CopyAttributes(&out->UnauthAttrs, &in->UnauthAttrs, &nextData);
1860 ret = TRUE;
1861 }
1862 TRACE("returning %d\n", ret);
1863 return ret;
1864 }
1865
1866 static BOOL CRYPT_CopySignerCertInfo(void *pvData, DWORD *pcbData,
1867 const CMSG_SIGNER_INFO *in)
1868 {
1869 DWORD size = sizeof(CERT_INFO);
1870 BOOL ret;
1871
1872 TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
1873
1874 size += in->Issuer.cbData;
1875 size += in->SerialNumber.cbData;
1876 if (!pvData)
1877 {
1878 *pcbData = size;
1879 ret = TRUE;
1880 }
1881 else if (*pcbData < size)
1882 {
1883 *pcbData = size;
1884 SetLastError(ERROR_MORE_DATA);
1885 ret = FALSE;
1886 }
1887 else
1888 {
1889 LPBYTE nextData = (BYTE *)pvData + sizeof(CERT_INFO);
1890 CERT_INFO *out = (CERT_INFO *)pvData;
1891
1892 memset(out, 0, sizeof(CERT_INFO));
1893 CRYPT_CopyBlob(&out->Issuer, &in->Issuer, &nextData);
1894 CRYPT_CopyBlob(&out->SerialNumber, &in->SerialNumber, &nextData);
1895 ret = TRUE;
1896 }
1897 TRACE("returning %d\n", ret);
1898 return ret;
1899 }
1900
1901 static BOOL CDecodeSignedMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType,
1902 DWORD dwIndex, void *pvData, DWORD *pcbData)
1903 {
1904 BOOL ret = FALSE;
1905
1906 switch (dwParamType)
1907 {
1908 case CMSG_TYPE_PARAM:
1909 ret = CRYPT_CopyParam(pvData, pcbData, &msg->type, sizeof(msg->type));
1910 break;
1911 case CMSG_CONTENT_PARAM:
1912 if (msg->u.signed_data.info)
1913 {
1914 if (!strcmp(msg->u.signed_data.info->content.pszObjId,
1915 szOID_RSA_data))
1916 {
1917 CRYPT_DATA_BLOB *blob;
1918 DWORD size;
1919
1920 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
1921 msg->u.signed_data.info->content.Content.pbData,
1922 msg->u.signed_data.info->content.Content.cbData,
1923 CRYPT_DECODE_ALLOC_FLAG, NULL, (LPBYTE)&blob, &size);
1924 if (ret)
1925 {
1926 ret = CRYPT_CopyParam(pvData, pcbData, blob->pbData,
1927 blob->cbData);
1928 LocalFree(blob);
1929 }
1930 }
1931 else
1932 ret = CRYPT_CopyParam(pvData, pcbData,
1933 msg->u.signed_data.info->content.Content.pbData,
1934 msg->u.signed_data.info->content.Content.cbData);
1935 }
1936 else
1937 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1938 break;
1939 case CMSG_INNER_CONTENT_TYPE_PARAM:
1940 if (msg->u.signed_data.info)
1941 ret = CRYPT_CopyParam(pvData, pcbData,
1942 msg->u.signed_data.info->content.pszObjId,
1943 strlen(msg->u.signed_data.info->content.pszObjId) + 1);
1944 else
1945 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1946 break;
1947 case CMSG_SIGNER_COUNT_PARAM:
1948 if (msg->u.signed_data.info)
1949 ret = CRYPT_CopyParam(pvData, pcbData,
1950 &msg->u.signed_data.info->cSignerInfo, sizeof(DWORD));
1951 else
1952 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1953 break;
1954 case CMSG_SIGNER_INFO_PARAM:
1955 if (msg->u.signed_data.info)
1956 {
1957 if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
1958 SetLastError(CRYPT_E_INVALID_INDEX);
1959 else
1960 ret = CRYPT_CopySignerInfo(pvData, pcbData,
1961 &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
1962 }
1963 else
1964 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1965 break;
1966 case CMSG_SIGNER_CERT_INFO_PARAM:
1967 if (msg->u.signed_data.info)
1968 {
1969 if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
1970 SetLastError(CRYPT_E_INVALID_INDEX);
1971 else
1972 ret = CRYPT_CopySignerCertInfo(pvData, pcbData,
1973 &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
1974 }
1975 else
1976 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1977 break;
1978 case CMSG_CERT_COUNT_PARAM:
1979 if (msg->u.signed_data.info)
1980 ret = CRYPT_CopyParam(pvData, pcbData,
1981 &msg->u.signed_data.info->cCertEncoded, sizeof(DWORD));
1982 else
1983 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1984 break;
1985 case CMSG_CERT_PARAM:
1986 if (msg->u.signed_data.info)
1987 {
1988 if (dwIndex >= msg->u.signed_data.info->cCertEncoded)
1989 SetLastError(CRYPT_E_INVALID_INDEX);
1990 else
1991 ret = CRYPT_CopyParam(pvData, pcbData,
1992 msg->u.signed_data.info->rgCertEncoded[dwIndex].pbData,
1993 msg->u.signed_data.info->rgCertEncoded[dwIndex].cbData);
1994 }
1995 else
1996 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1997 break;
1998 case CMSG_CRL_COUNT_PARAM:
1999 if (msg->u.signed_data.info)
2000 ret = CRYPT_CopyParam(pvData, pcbData,
2001 &msg->u.signed_data.info->cCrlEncoded, sizeof(DWORD));
2002 else
2003 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2004 break;
2005 case CMSG_CRL_PARAM:
2006 if (msg->u.signed_data.info)
2007 {
2008 if (dwIndex >= msg->u.signed_data.info->cCrlEncoded)
2009 SetLastError(CRYPT_E_INVALID_INDEX);
2010 else
2011 ret = CRYPT_CopyParam(pvData, pcbData,
2012 msg->u.signed_data.info->rgCrlEncoded[dwIndex].pbData,
2013 msg->u.signed_data.info->rgCrlEncoded[dwIndex].cbData);
2014 }
2015 else
2016 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2017 break;
2018 case CMSG_COMPUTED_HASH_PARAM:
2019 if (msg->u.signed_data.info)
2020 {
2021 if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
2022 SetLastError(CRYPT_E_INVALID_INDEX);
2023 else
2024 ret = CryptGetHashParam(
2025 msg->u.signed_data.signerHandles[dwIndex].contentHash,
2026 HP_HASHVAL, pvData, pcbData, 0);
2027 }
2028 else
2029 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2030 break;
2031 case CMSG_ATTR_CERT_COUNT_PARAM:
2032 if (msg->u.signed_data.info)
2033 {
2034 DWORD attrCertCount = 0;
2035
2036 ret = CRYPT_CopyParam(pvData, pcbData,
2037 &attrCertCount, sizeof(DWORD));
2038 }
2039 else
2040 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2041 break;
2042 case CMSG_ATTR_CERT_PARAM:
2043 if (msg->u.signed_data.info)
2044 SetLastError(CRYPT_E_INVALID_INDEX);
2045 else
2046 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2047 break;
2048 default:
2049 FIXME("unimplemented for %d\n", dwParamType);
2050 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2051 }
2052 return ret;
2053 }
2054
2055 static BOOL CDecodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
2056 DWORD dwIndex, void *pvData, DWORD *pcbData)
2057 {
2058 CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
2059 BOOL ret = FALSE;
2060
2061 switch (msg->type)
2062 {
2063 case CMSG_HASHED:
2064 ret = CDecodeHashMsg_GetParam(msg, dwParamType, dwIndex, pvData,
2065 pcbData);
2066 break;
2067 case CMSG_SIGNED:
2068 ret = CDecodeSignedMsg_GetParam(msg, dwParamType, dwIndex, pvData,
2069 pcbData);
2070 break;
2071 default:
2072 switch (dwParamType)
2073 {
2074 case CMSG_TYPE_PARAM:
2075 ret = CRYPT_CopyParam(pvData, pcbData, &msg->type,
2076 sizeof(msg->type));
2077 break;
2078 default:
2079 {
2080 CRYPT_DATA_BLOB blob;
2081
2082 ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
2083 &blob);
2084 if (ret)
2085 ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData,
2086 blob.cbData);
2087 else
2088 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2089 }
2090 }
2091 }
2092 return ret;
2093 }
2094
2095 static BOOL CDecodeHashMsg_VerifyHash(CDecodeMsg *msg)
2096 {
2097 BOOL ret;
2098 CRYPT_DATA_BLOB hashBlob;
2099
2100 ret = ContextPropertyList_FindProperty(msg->properties,
2101 CMSG_HASH_DATA_PARAM, &hashBlob);
2102 if (ret)
2103 {
2104 DWORD computedHashSize = 0;
2105
2106 ret = CDecodeHashMsg_GetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, NULL,
2107 &computedHashSize);
2108 if (hashBlob.cbData == computedHashSize)
2109 {
2110 LPBYTE computedHash = CryptMemAlloc(computedHashSize);
2111
2112 if (computedHash)
2113 {
2114 ret = CDecodeHashMsg_GetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0,
2115 computedHash, &computedHashSize);
2116 if (ret)
2117 ret = !memcmp(hashBlob.pbData, computedHash,
2118 hashBlob.cbData);
2119 CryptMemFree(computedHash);
2120 }
2121 else
2122 ret = FALSE;
2123 }
2124 }
2125 return ret;
2126 }
2127
2128 static BOOL CDecodeSignedMsg_VerifySignatureWithKey(CDecodeMsg *msg,
2129 HCRYPTPROV prov, DWORD signerIndex, PCERT_PUBLIC_KEY_INFO keyInfo)
2130 {
2131 HCRYPTKEY key;
2132 BOOL ret;
2133
2134 if (!prov)
2135 prov = msg->crypt_prov;
2136 ret = CryptImportPublicKeyInfo(prov, X509_ASN_ENCODING, keyInfo, &key);
2137 if (ret)
2138 {
2139 HCRYPTHASH hash;
2140 CRYPT_HASH_BLOB reversedHash;
2141
2142 if (msg->u.signed_data.info->rgSignerInfo[signerIndex].AuthAttrs.cAttr)
2143 hash = msg->u.signed_data.signerHandles[signerIndex].authAttrHash;
2144 else
2145 hash = msg->u.signed_data.signerHandles[signerIndex].contentHash;
2146 ret = CRYPT_ConstructBlob(&reversedHash,
2147 &msg->u.signed_data.info->rgSignerInfo[signerIndex].EncryptedHash);
2148 if (ret)
2149 {
2150 CRYPT_ReverseBytes(&reversedHash);
2151 ret = CryptVerifySignatureW(hash, reversedHash.pbData,
2152 reversedHash.cbData, key, NULL, 0);
2153 CryptMemFree(reversedHash.pbData);
2154 }
2155 CryptDestroyKey(key);
2156 }
2157 return ret;
2158 }
2159
2160 static BOOL CDecodeSignedMsg_VerifySignature(CDecodeMsg *msg, PCERT_INFO info)
2161 {
2162 BOOL ret = FALSE;
2163 DWORD i;
2164
2165 for (i = 0; !ret && i < msg->u.signed_data.info->cSignerInfo; i++)
2166 {
2167 ret = CertCompareCertificateName(X509_ASN_ENCODING,
2168 &msg->u.signed_data.info->rgSignerInfo[i].Issuer, &info->Issuer);
2169 if (ret)
2170 {
2171 ret = CertCompareIntegerBlob(
2172 &msg->u.signed_data.info->rgSignerInfo[i].SerialNumber,
2173 &info->SerialNumber);
2174 if (ret)
2175 break;
2176 }
2177 }
2178 if (ret)
2179 ret = CDecodeSignedMsg_VerifySignatureWithKey(msg, 0, i,
2180 &info->SubjectPublicKeyInfo);
2181 else
2182 SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
2183
2184 return ret;
2185 }
2186
2187 static BOOL CDecodeSignedMsg_VerifySignatureEx(CDecodeMsg *msg,
2188 PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA para)
2189 {
2190 BOOL ret = FALSE;
2191
2192 if (para->cbSize != sizeof(CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA))
2193 SetLastError(ERROR_INVALID_PARAMETER);
2194 else if (para->dwSignerIndex >= msg->u.signed_data.info->cSignerInfo)
2195 SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
2196 else
2197 {
2198 switch (para->dwSignerType)
2199 {
2200 case CMSG_VERIFY_SIGNER_PUBKEY:
2201 ret = CDecodeSignedMsg_VerifySignatureWithKey(msg,
2202 para->hCryptProv, para->dwSignerIndex,
2203 (PCERT_PUBLIC_KEY_INFO)para->pvSigner);
2204 break;
2205 case CMSG_VERIFY_SIGNER_CERT:
2206 {
2207 PCCERT_CONTEXT cert = (PCCERT_CONTEXT)para->pvSigner;
2208
2209 ret = CDecodeSignedMsg_VerifySignatureWithKey(msg, para->hCryptProv,
2210 para->dwSignerIndex, &cert->pCertInfo->SubjectPublicKeyInfo);
2211 break;
2212 }
2213 default:
2214 FIXME("unimplemented for signer type %d\n", para->dwSignerType);
2215 SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
2216 }
2217 }
2218 return ret;
2219 }
2220
2221 static BOOL CDecodeMsg_Control(HCRYPTMSG hCryptMsg, DWORD dwFlags,
2222 DWORD dwCtrlType, const void *pvCtrlPara)
2223 {
2224 CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
2225 BOOL ret = FALSE;
2226
2227 switch (dwCtrlType)
2228 {
2229 case CMSG_CTRL_VERIFY_SIGNATURE:
2230 switch (msg->type)
2231 {
2232 case CMSG_SIGNED:
2233 ret = CDecodeSignedMsg_VerifySignature(msg, (PCERT_INFO)pvCtrlPara);
2234 break;
2235 default:
2236 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2237 }
2238 break;
2239 case CMSG_CTRL_DECRYPT:
2240 switch (msg->type)
2241 {
2242 default:
2243 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2244 }
2245 break;
2246 case CMSG_CTRL_VERIFY_HASH:
2247 switch (msg->type)
2248 {
2249 case CMSG_HASHED:
2250 ret = CDecodeHashMsg_VerifyHash(msg);
2251 break;
2252 default:
2253 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2254 }
2255 break;
2256 case CMSG_CTRL_VERIFY_SIGNATURE_EX:
2257 switch (msg->type)
2258 {
2259 case CMSG_SIGNED:
2260 ret = CDecodeSignedMsg_VerifySignatureEx(msg,
2261 (PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA)pvCtrlPara);
2262 break;
2263 default:
2264 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2265 }
2266 break;
2267 default:
2268 SetLastError(CRYPT_E_CONTROL_TYPE);
2269 }
2270 return ret;
2271 }
2272
2273 HCRYPTMSG WINAPI CryptMsgOpenToDecode(DWORD dwMsgEncodingType, DWORD dwFlags,
2274 DWORD dwMsgType, HCRYPTPROV_LEGACY hCryptProv, PCERT_INFO pRecipientInfo,
2275 PCMSG_STREAM_INFO pStreamInfo)
2276 {
2277 CDecodeMsg *msg;
2278
2279 TRACE("(%08x, %08x, %08x, %08lx, %p, %p)\n", dwMsgEncodingType,
2280 dwFlags, dwMsgType, hCryptProv, pRecipientInfo, pStreamInfo);
2281
2282 if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType) != PKCS_7_ASN_ENCODING)
2283 {
2284 SetLastError(E_INVALIDARG);
2285 return NULL;
2286 }
2287 msg = CryptMemAlloc(sizeof(CDecodeMsg));
2288 if (msg)
2289 {
2290 CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
2291 CDecodeMsg_Close, CDecodeMsg_GetParam, CDecodeMsg_Update,
2292 CDecodeMsg_Control);
2293 msg->type = dwMsgType;
2294 if (hCryptProv)
2295 msg->crypt_prov = hCryptProv;
2296 else
2297 {
2298 msg->crypt_prov = CRYPT_GetDefaultProvider();
2299 msg->base.open_flags &= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG;
2300 }
2301 memset(&msg->u, 0, sizeof(msg->u));
2302 msg->msg_data.cbData = 0;
2303 msg->msg_data.pbData = NULL;
2304 msg->properties = ContextPropertyList_Create();
2305 }
2306 return msg;
2307 }
2308
2309 HCRYPTMSG WINAPI CryptMsgDuplicate(HCRYPTMSG hCryptMsg)
2310 {
2311 TRACE("(%p)\n", hCryptMsg);
2312
2313 if (hCryptMsg)
2314 {
2315 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2316
2317 InterlockedIncrement(&msg->ref);
2318 }
2319 return hCryptMsg;
2320 }
2321
2322 BOOL WINAPI CryptMsgClose(HCRYPTMSG hCryptMsg)
2323 {
2324 TRACE("(%p)\n", hCryptMsg);
2325
2326 if (hCryptMsg)
2327 {
2328 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2329
2330 if (InterlockedDecrement(&msg->ref) == 0)
2331 {
2332 TRACE("freeing %p\n", msg);
2333 if (msg->close)
2334 msg->close(msg);
2335 CryptMemFree(msg);
2336 }
2337 }
2338 return TRUE;
2339 }
2340
2341 BOOL WINAPI CryptMsgUpdate(HCRYPTMSG hCryptMsg, const BYTE *pbData,
2342 DWORD cbData, BOOL fFinal)
2343 {
2344 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2345 BOOL ret = FALSE;
2346
2347 TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
2348
2349 if (msg->state == MsgStateFinalized)
2350 SetLastError(CRYPT_E_MSG_ERROR);
2351 else
2352 {
2353 ret = msg->update(hCryptMsg, pbData, cbData, fFinal);
2354 msg->state = MsgStateUpdated;
2355 if (fFinal)
2356 msg->state = MsgStateFinalized;
2357 }
2358 return ret;
2359 }
2360
2361 BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
2362 DWORD dwIndex, void *pvData, DWORD *pcbData)
2363 {
2364 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2365
2366 TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
2367 pvData, pcbData);
2368 return msg->get_param(hCryptMsg, dwParamType, dwIndex, pvData, pcbData);
2369 }
2370
2371 BOOL WINAPI CryptMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags,
2372 DWORD dwCtrlType, const void *pvCtrlPara)
2373 {
2374 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2375
2376 TRACE("(%p, %08x, %d, %p)\n", hCryptMsg, dwFlags, dwCtrlType,
2377 pvCtrlPara);
2378 return msg->control(hCryptMsg, dwFlags, dwCtrlType, pvCtrlPara);
2379 }
2380
2381 HCERTSTORE WINAPI CryptGetMessageCertificates(DWORD dwMsgAndCertEncodingType,
2382 HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, const BYTE* pbSignedBlob,
2383 DWORD cbSignedBlob)
2384 {
2385 CRYPT_DATA_BLOB blob = { cbSignedBlob, (LPBYTE)pbSignedBlob };
2386
2387 TRACE("(%08x, %ld, %d08x %p, %d)\n", dwMsgAndCertEncodingType, hCryptProv,
2388 dwFlags, pbSignedBlob, cbSignedBlob);
2389
2390 return CertOpenStore(CERT_STORE_PROV_PKCS7, dwMsgAndCertEncodingType,
2391 hCryptProv, dwFlags, &blob);
2392 }
2393
2394 LONG WINAPI CryptGetMessageSignerCount(DWORD dwMsgEncodingType,
2395 const BYTE *pbSignedBlob, DWORD cbSignedBlob)
2396 {
2397 HCRYPTMSG msg;
2398 LONG count = -1;
2399
2400 TRACE("(%08x, %p, %d)\n", dwMsgEncodingType, pbSignedBlob, cbSignedBlob);
2401
2402 msg = CryptMsgOpenToDecode(dwMsgEncodingType, 0, 0, 0, NULL, NULL);
2403 if (msg)
2404 {
2405 if (CryptMsgUpdate(msg, pbSignedBlob, cbSignedBlob, TRUE))
2406 {
2407 DWORD size = sizeof(count);
2408
2409 CryptMsgGetParam(msg, CMSG_SIGNER_COUNT_PARAM, 0, &count, &size);
2410 }
2411 CryptMsgClose(msg);
2412 }
2413 return count;
2414 }
2415
2416 static CERT_INFO *CRYPT_GetSignerCertInfoFromMsg(HCRYPTMSG msg,
2417 DWORD dwSignerIndex)
2418 {
2419 CERT_INFO *certInfo = NULL;
2420 DWORD size;
2421
2422 if (CryptMsgGetParam(msg, CMSG_SIGNER_CERT_INFO_PARAM, dwSignerIndex, NULL,
2423 &size))
2424 {
2425 certInfo = CryptMemAlloc(size);
2426 if (certInfo)
2427 {
2428 if (!CryptMsgGetParam(msg, CMSG_SIGNER_CERT_INFO_PARAM,
2429 dwSignerIndex, certInfo, &size))
2430 {
2431 CryptMemFree(certInfo);
2432 certInfo = NULL;
2433 }
2434 }
2435 }
2436 return certInfo;
2437 }
2438
2439 static PCCERT_CONTEXT WINAPI CRYPT_DefaultGetSignerCertificate(void *pvGetArg,
2440 DWORD dwCertEncodingType, PCERT_INFO pSignerId, HCERTSTORE hMsgCertStore)
2441 {
2442 return CertFindCertificateInStore(hMsgCertStore, dwCertEncodingType, 0,
2443 CERT_FIND_SUBJECT_CERT, pSignerId, NULL);
2444 }
2445
2446 static inline PCCERT_CONTEXT CRYPT_GetSignerCertificate(HCRYPTMSG msg,
2447 PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, PCERT_INFO certInfo, HCERTSTORE store)
2448 {
2449 PFN_CRYPT_GET_SIGNER_CERTIFICATE getCert;
2450
2451 if (pVerifyPara->pfnGetSignerCertificate)
2452 getCert = pVerifyPara->pfnGetSignerCertificate;
2453 else
2454 getCert = CRYPT_DefaultGetSignerCertificate;
2455 return getCert(pVerifyPara->pvGetArg,
2456 pVerifyPara->dwMsgAndCertEncodingType, certInfo, store);
2457 }
2458
2459 BOOL WINAPI CryptVerifyMessageSignature(PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara,
2460 DWORD dwSignerIndex, const BYTE* pbSignedBlob, DWORD cbSignedBlob,
2461 BYTE* pbDecoded, DWORD* pcbDecoded, PCCERT_CONTEXT* ppSignerCert)
2462 {
2463 BOOL ret = FALSE;
2464 DWORD size;
2465 CRYPT_CONTENT_INFO *contentInfo;
2466
2467 TRACE("(%p, %d, %p, %d, %p, %p, %p)\n",
2468 pVerifyPara, dwSignerIndex, pbSignedBlob, cbSignedBlob,
2469 pbDecoded, pcbDecoded, ppSignerCert);
2470
2471 if (ppSignerCert)
2472 *ppSignerCert = NULL;
2473 if (pcbDecoded)
2474 *pcbDecoded = 0;
2475 if (!pVerifyPara ||
2476 pVerifyPara->cbSize != sizeof(CRYPT_VERIFY_MESSAGE_PARA) ||
2477 GET_CMSG_ENCODING_TYPE(pVerifyPara->dwMsgAndCertEncodingType) !=
2478 PKCS_7_ASN_ENCODING)
2479 {
2480 SetLastError(E_INVALIDARG);
2481 return FALSE;
2482 }
2483
2484 ret = CryptDecodeObjectEx(pVerifyPara->dwMsgAndCertEncodingType,
2485 PKCS_CONTENT_INFO, pbSignedBlob, cbSignedBlob,
2486 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
2487 (LPBYTE)&contentInfo, &size);
2488 if (ret)
2489 {
2490 if (strcmp(contentInfo->pszObjId, szOID_RSA_signedData))
2491 {
2492 SetLastError(CRYPT_E_UNEXPECTED_MSG_TYPE);
2493 ret = FALSE;
2494 }
2495 else
2496 {
2497 HCRYPTMSG msg = CryptMsgOpenToDecode(
2498 pVerifyPara->dwMsgAndCertEncodingType, 0, CMSG_SIGNED,
2499 pVerifyPara->hCryptProv, NULL, NULL);
2500
2501 if (msg)
2502 {
2503 ret = CryptMsgUpdate(msg, contentInfo->Content.pbData,
2504 contentInfo->Content.cbData, TRUE);
2505 if (ret && pcbDecoded)
2506 ret = CRYPT_CopyParam(pbDecoded, pcbDecoded,
2507 contentInfo->Content.pbData, contentInfo->Content.cbData);
2508 if (ret)
2509 {
2510 CERT_INFO *certInfo = CRYPT_GetSignerCertInfoFromMsg(msg,
2511 dwSignerIndex);
2512
2513 ret = FALSE;
2514 if (certInfo)
2515 {
2516 HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MSG,
2517 pVerifyPara->dwMsgAndCertEncodingType,
2518 pVerifyPara->hCryptProv, 0, msg);
2519
2520 if (store)
2521 {
2522 PCCERT_CONTEXT cert = CRYPT_GetSignerCertificate(
2523 msg, pVerifyPara, certInfo, store);
2524
2525 if (cert)
2526 {
2527 ret = CryptMsgControl(msg, 0,
2528 CMSG_CTRL_VERIFY_SIGNATURE, cert->pCertInfo);
2529 if (ret && ppSignerCert)
2530 *ppSignerCert = cert;
2531 else
2532 CertFreeCertificateContext(cert);
2533 }
2534 CertCloseStore(store, 0);
2535 }
2536 }
2537 CryptMemFree(certInfo);
2538 }
2539 CryptMsgClose(msg);
2540 }
2541 }
2542 LocalFree(contentInfo);
2543 }
2544 TRACE("returning %d\n", ret);
2545 return ret;
2546 }
useful hacks and other patches not (yet) suitable for mainline