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