?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
UTF-8 resource files must explicitly say so with a pragma.
[wine.git] / dlls / crypt32 / msg.c
blob30c0ddbb1a1e5836a28d7ab23a1bc4877f0d2a23
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 } CSignerHandles;
805
806 typedef struct _CSignedMsgData
807 {
808 CRYPT_SIGNED_INFO *info;
809 DWORD cSignerHandle;
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 {
846 msg_data->cSignerHandle = msg_data->info->cSignerInfo;
847 memset(msg_data->signerHandles, 0,
848 msg_data->info->cSignerInfo * sizeof(CSignerHandles));
849 }
850 else
851 {
852 msg_data->cSignerHandle = 0;
853 ret = FALSE;
854 }
855 }
856 else
857 {
858 msg_data->cSignerHandle = 0;
859 msg_data->signerHandles = NULL;
860 }
861 return ret;
862 }
863
864 static void CSignedMsgData_CloseHandles(CSignedMsgData *msg_data)
865 {
866 DWORD i;
867
868 for (i = 0; i < msg_data->cSignerHandle; i++)
869 {
870 if (msg_data->signerHandles[i].contentHash)
871 CryptDestroyHash(msg_data->signerHandles[i].contentHash);
872 if (msg_data->signerHandles[i].authAttrHash)
873 CryptDestroyHash(msg_data->signerHandles[i].authAttrHash);
874 }
875 CryptMemFree(msg_data->signerHandles);
876 msg_data->signerHandles = NULL;
877 msg_data->cSignerHandle = 0;
878 }
879
880 static BOOL CSignedMsgData_UpdateHash(CSignedMsgData *msg_data,
881 const BYTE *pbData, DWORD cbData)
882 {
883 DWORD i;
884 BOOL ret = TRUE;
885
886 for (i = 0; ret && i < msg_data->cSignerHandle; i++)
887 ret = CryptHashData(msg_data->signerHandles[i].contentHash, pbData,
888 cbData, 0);
889 return ret;
890 }
891
892 static BOOL CRYPT_AppendAttribute(CRYPT_ATTRIBUTES *out,
893 const CRYPT_ATTRIBUTE *in)
894 {
895 BOOL ret = FALSE;
896
897 out->rgAttr = CryptMemRealloc(out->rgAttr,
898 (out->cAttr + 1) * sizeof(CRYPT_ATTRIBUTE));
899 if (out->rgAttr)
900 {
901 ret = CRYPT_ConstructAttribute(&out->rgAttr[out->cAttr], in);
902 if (ret)
903 out->cAttr++;
904 }
905 return ret;
906 }
907
908 static BOOL CSignedMsgData_AppendMessageDigestAttribute(
909 CSignedMsgData *msg_data, DWORD signerIndex)
910 {
911 BOOL ret;
912 DWORD size;
913 CRYPT_HASH_BLOB hash = { 0, NULL }, encodedHash = { 0, NULL };
914 char messageDigest[] = szOID_RSA_messageDigest;
915 CRYPT_ATTRIBUTE messageDigestAttr = { messageDigest, 1, &encodedHash };
916
917 size = sizeof(DWORD);
918 ret = CryptGetHashParam(
919 msg_data->signerHandles[signerIndex].contentHash, HP_HASHSIZE,
920 (LPBYTE)&hash.cbData, &size, 0);
921 if (ret)
922 {
923 hash.pbData = CryptMemAlloc(hash.cbData);
924 ret = CryptGetHashParam(
925 msg_data->signerHandles[signerIndex].contentHash, HP_HASHVAL,
926 hash.pbData, &hash.cbData, 0);
927 if (ret)
928 {
929 ret = CRYPT_AsnEncodeOctets(0, NULL, &hash, CRYPT_ENCODE_ALLOC_FLAG,
930 NULL, (LPBYTE)&encodedHash.pbData, &encodedHash.cbData);
931 if (ret)
932 {
933 ret = CRYPT_AppendAttribute(
934 &msg_data->info->rgSignerInfo[signerIndex].AuthAttrs,
935 &messageDigestAttr);
936 LocalFree(encodedHash.pbData);
937 }
938 }
939 CryptMemFree(hash.pbData);
940 }
941 return ret;
942 }
943
944 typedef enum {
945 Sign,
946 Verify
947 } SignOrVerify;
948
949 static BOOL CSignedMsgData_UpdateAuthenticatedAttributes(
950 CSignedMsgData *msg_data, SignOrVerify flag)
951 {
952 DWORD i;
953 BOOL ret = TRUE;
954
955 TRACE("(%p)\n", msg_data);
956
957 for (i = 0; ret && i < msg_data->info->cSignerInfo; i++)
958 {
959 if (msg_data->info->rgSignerInfo[i].AuthAttrs.cAttr)
960 {
961 if (flag == Sign)
962 {
963 BYTE oid_rsa_data_encoded[] = { 0x06,0x09,0x2a,0x86,0x48,0x86,
964 0xf7,0x0d,0x01,0x07,0x01 };
965 CRYPT_DATA_BLOB content = { sizeof(oid_rsa_data_encoded),
966 oid_rsa_data_encoded };
967 char contentType[] = szOID_RSA_contentType;
968 CRYPT_ATTRIBUTE contentTypeAttr = { contentType, 1, &content };
969
970 /* FIXME: does this depend on inner OID? */
971 ret = CRYPT_AppendAttribute(
972 &msg_data->info->rgSignerInfo[i].AuthAttrs, &contentTypeAttr);
973 if (ret)
974 ret = CSignedMsgData_AppendMessageDigestAttribute(msg_data,
975 i);
976 }
977 if (ret)
978 {
979 LPBYTE encodedAttrs;
980 DWORD size;
981
982 ret = CryptEncodeObjectEx(X509_ASN_ENCODING, PKCS_ATTRIBUTES,
983 &msg_data->info->rgSignerInfo[i].AuthAttrs,
984 CRYPT_ENCODE_ALLOC_FLAG, NULL, (LPBYTE)&encodedAttrs, &size);
985 if (ret)
986 {
987 ret = CryptHashData(
988 msg_data->signerHandles[i].authAttrHash, encodedAttrs,
989 size, 0);
990 LocalFree(encodedAttrs);
991 }
992 }
993 }
994 }
995 TRACE("returning %d\n", ret);
996 return ret;
997 }
998
999 static void CRYPT_ReverseBytes(CRYPT_HASH_BLOB *hash)
1000 {
1001 DWORD i;
1002 BYTE tmp;
1003
1004 for (i = 0; i < hash->cbData / 2; i++)
1005 {
1006 tmp = hash->pbData[hash->cbData - i - 1];
1007 hash->pbData[hash->cbData - i - 1] = hash->pbData[i];
1008 hash->pbData[i] = tmp;
1009 }
1010 }
1011
1012 static BOOL CSignedMsgData_Sign(CSignedMsgData *msg_data)
1013 {
1014 DWORD i;
1015 BOOL ret = TRUE;
1016
1017 TRACE("(%p)\n", msg_data);
1018
1019 for (i = 0; ret && i < msg_data->info->cSignerInfo; i++)
1020 {
1021 HCRYPTHASH hash;
1022
1023 if (msg_data->info->rgSignerInfo[i].AuthAttrs.cAttr)
1024 hash = msg_data->signerHandles[i].authAttrHash;
1025 else
1026 hash = msg_data->signerHandles[i].contentHash;
1027 ret = CryptSignHashW(hash, AT_SIGNATURE, NULL, 0, NULL,
1028 &msg_data->info->rgSignerInfo[i].EncryptedHash.cbData);
1029 if (ret)
1030 {
1031 msg_data->info->rgSignerInfo[i].EncryptedHash.pbData =
1032 CryptMemAlloc(
1033 msg_data->info->rgSignerInfo[i].EncryptedHash.cbData);
1034 if (msg_data->info->rgSignerInfo[i].EncryptedHash.pbData)
1035 {
1036 ret = CryptSignHashW(hash, AT_SIGNATURE, NULL, 0,
1037 msg_data->info->rgSignerInfo[i].EncryptedHash.pbData,
1038 &msg_data->info->rgSignerInfo[i].EncryptedHash.cbData);
1039 if (ret)
1040 CRYPT_ReverseBytes(
1041 &msg_data->info->rgSignerInfo[i].EncryptedHash);
1042 }
1043 else
1044 ret = FALSE;
1045 }
1046 }
1047 return ret;
1048 }
1049
1050 static BOOL CSignedMsgData_Update(CSignedMsgData *msg_data,
1051 const BYTE *pbData, DWORD cbData, BOOL fFinal, SignOrVerify flag)
1052 {
1053 BOOL ret = CSignedMsgData_UpdateHash(msg_data, pbData, cbData);
1054
1055 if (ret && fFinal)
1056 {
1057 ret = CSignedMsgData_UpdateAuthenticatedAttributes(msg_data, flag);
1058 if (ret && flag == Sign)
1059 ret = CSignedMsgData_Sign(msg_data);
1060 }
1061 return ret;
1062 }
1063
1064 typedef struct _CSignedEncodeMsg
1065 {
1066 CryptMsgBase base;
1067 CRYPT_DATA_BLOB data;
1068 CSignedMsgData msg_data;
1069 } CSignedEncodeMsg;
1070
1071 static void CSignedEncodeMsg_Close(HCRYPTMSG hCryptMsg)
1072 {
1073 CSignedEncodeMsg *msg = (CSignedEncodeMsg *)hCryptMsg;
1074 DWORD i;
1075
1076 CryptMemFree(msg->data.pbData);
1077 CRYPT_FreeBlobArray((BlobArray *)&msg->msg_data.info->cCertEncoded);
1078 CRYPT_FreeBlobArray((BlobArray *)&msg->msg_data.info->cCrlEncoded);
1079 for (i = 0; i < msg->msg_data.info->cSignerInfo; i++)
1080 CSignerInfo_Free(&msg->msg_data.info->rgSignerInfo[i]);
1081 CSignedMsgData_CloseHandles(&msg->msg_data);
1082 CryptMemFree(msg->msg_data.info->rgSignerInfo);
1083 CryptMemFree(msg->msg_data.info);
1084 }
1085
1086 static BOOL CSignedEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
1087 DWORD dwIndex, void *pvData, DWORD *pcbData)
1088 {
1089 CSignedEncodeMsg *msg = (CSignedEncodeMsg *)hCryptMsg;
1090 BOOL ret = FALSE;
1091
1092 switch (dwParamType)
1093 {
1094 case CMSG_CONTENT_PARAM:
1095 {
1096 CRYPT_CONTENT_INFO info;
1097
1098 ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0, NULL,
1099 &info.Content.cbData);
1100 if (ret)
1101 {
1102 info.Content.pbData = CryptMemAlloc(info.Content.cbData);
1103 if (info.Content.pbData)
1104 {
1105 ret = CryptMsgGetParam(hCryptMsg, CMSG_BARE_CONTENT_PARAM, 0,
1106 info.Content.pbData, &info.Content.cbData);
1107 if (ret)
1108 {
1109 char oid_rsa_signed[] = szOID_RSA_signedData;
1110
1111 info.pszObjId = oid_rsa_signed;
1112 ret = CryptEncodeObjectEx(X509_ASN_ENCODING,
1113 PKCS_CONTENT_INFO, &info, 0, NULL, pvData, pcbData);
1114 }
1115 CryptMemFree(info.Content.pbData);
1116 }
1117 else
1118 ret = FALSE;
1119 }
1120 break;
1121 }
1122 case CMSG_BARE_CONTENT_PARAM:
1123 {
1124 CRYPT_SIGNED_INFO info;
1125 char oid_rsa_data[] = szOID_RSA_data;
1126
1127 memcpy(&info, msg->msg_data.info, sizeof(info));
1128 /* Quirk: OID is only encoded messages if an update has happened */
1129 if (msg->base.state != MsgStateInit)
1130 info.content.pszObjId = oid_rsa_data;
1131 else
1132 info.content.pszObjId = NULL;
1133 if (msg->data.cbData)
1134 {
1135 CRYPT_DATA_BLOB blob = { msg->data.cbData, msg->data.pbData };
1136
1137 ret = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
1138 &blob, CRYPT_ENCODE_ALLOC_FLAG, NULL,
1139 &info.content.Content.pbData, &info.content.Content.cbData);
1140 }
1141 else
1142 {
1143 info.content.Content.cbData = 0;
1144 info.content.Content.pbData = NULL;
1145 ret = TRUE;
1146 }
1147 if (ret)
1148 {
1149 ret = CRYPT_AsnEncodePKCSSignedInfo(&info, pvData, pcbData);
1150 LocalFree(info.content.Content.pbData);
1151 }
1152 break;
1153 }
1154 case CMSG_COMPUTED_HASH_PARAM:
1155 if (dwIndex >= msg->msg_data.cSignerHandle)
1156 SetLastError(CRYPT_E_INVALID_INDEX);
1157 else
1158 ret = CryptGetHashParam(
1159 msg->msg_data.signerHandles[dwIndex].contentHash, HP_HASHVAL,
1160 pvData, pcbData, 0);
1161 break;
1162 case CMSG_ENCODED_SIGNER:
1163 if (dwIndex >= msg->msg_data.info->cSignerInfo)
1164 SetLastError(CRYPT_E_INVALID_INDEX);
1165 else
1166 ret = CryptEncodeObjectEx(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
1167 PKCS7_SIGNER_INFO, &msg->msg_data.info->rgSignerInfo[dwIndex], 0,
1168 NULL, pvData, pcbData);
1169 break;
1170 case CMSG_VERSION_PARAM:
1171 ret = CRYPT_CopyParam(pvData, pcbData, &msg->msg_data.info->version,
1172 sizeof(msg->msg_data.info->version));
1173 break;
1174 default:
1175 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1176 }
1177 return ret;
1178 }
1179
1180 static BOOL CSignedEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
1181 DWORD cbData, BOOL fFinal)
1182 {
1183 CSignedEncodeMsg *msg = (CSignedEncodeMsg *)hCryptMsg;
1184 BOOL ret = FALSE;
1185
1186 if (msg->base.streamed || (msg->base.open_flags & CMSG_DETACHED_FLAG))
1187 {
1188 ret = CSignedMsgData_Update(&msg->msg_data, pbData, cbData, fFinal,
1189 Sign);
1190 if (msg->base.streamed)
1191 FIXME("streamed partial stub\n");
1192 }
1193 else
1194 {
1195 if (!fFinal)
1196 SetLastError(CRYPT_E_MSG_ERROR);
1197 else
1198 {
1199 if (cbData)
1200 {
1201 msg->data.pbData = CryptMemAlloc(cbData);
1202 if (msg->data.pbData)
1203 {
1204 memcpy(msg->data.pbData, pbData, cbData);
1205 msg->data.cbData = cbData;
1206 ret = TRUE;
1207 }
1208 }
1209 else
1210 ret = TRUE;
1211 if (ret)
1212 ret = CSignedMsgData_Update(&msg->msg_data, pbData, cbData,
1213 fFinal, Sign);
1214 }
1215 }
1216 return ret;
1217 }
1218
1219 static HCRYPTMSG CSignedEncodeMsg_Open(DWORD dwFlags,
1220 const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID,
1221 PCMSG_STREAM_INFO pStreamInfo)
1222 {
1223 const CMSG_SIGNED_ENCODE_INFO_WITH_CMS *info =
1224 (const CMSG_SIGNED_ENCODE_INFO_WITH_CMS *)pvMsgEncodeInfo;
1225 DWORD i;
1226 CSignedEncodeMsg *msg;
1227
1228 if (info->cbSize != sizeof(CMSG_SIGNED_ENCODE_INFO) &&
1229 info->cbSize != sizeof(CMSG_SIGNED_ENCODE_INFO_WITH_CMS))
1230 {
1231 SetLastError(E_INVALIDARG);
1232 return NULL;
1233 }
1234 if (info->cbSize == sizeof(CMSG_SIGNED_ENCODE_INFO_WITH_CMS))
1235 {
1236 FIXME("CMSG_SIGNED_ENCODE_INFO with CMS fields unsupported\n");
1237 return NULL;
1238 }
1239 for (i = 0; i < info->cSigners; i++)
1240 if (!CRYPT_IsValidSigner(&info->rgSigners[i]))
1241 return NULL;
1242 msg = CryptMemAlloc(sizeof(CSignedEncodeMsg));
1243 if (msg)
1244 {
1245 BOOL ret = TRUE;
1246
1247 CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
1248 CSignedEncodeMsg_Close, CSignedEncodeMsg_GetParam,
1249 CSignedEncodeMsg_Update, CRYPT_DefaultMsgControl);
1250 msg->data.cbData = 0;
1251 msg->data.pbData = NULL;
1252 msg->msg_data.info = CryptMemAlloc(sizeof(CRYPT_SIGNED_INFO));
1253 if (msg->msg_data.info)
1254 {
1255 memset(msg->msg_data.info, 0, sizeof(CRYPT_SIGNED_INFO));
1256 msg->msg_data.info->version = CMSG_SIGNED_DATA_V1;
1257 }
1258 else
1259 ret = FALSE;
1260 if (ret)
1261 {
1262 if (info->cSigners)
1263 {
1264 msg->msg_data.info->rgSignerInfo =
1265 CryptMemAlloc(info->cSigners * sizeof(CMSG_SIGNER_INFO));
1266 if (msg->msg_data.info->rgSignerInfo)
1267 {
1268 msg->msg_data.info->cSignerInfo = info->cSigners;
1269 memset(msg->msg_data.info->rgSignerInfo, 0,
1270 msg->msg_data.info->cSignerInfo * sizeof(CMSG_SIGNER_INFO));
1271 ret = CSignedMsgData_AllocateHandles(&msg->msg_data);
1272 for (i = 0; ret && i < msg->msg_data.info->cSignerInfo; i++)
1273 {
1274 ret = CSignerInfo_Construct(
1275 &msg->msg_data.info->rgSignerInfo[i],
1276 &info->rgSigners[i]);
1277 if (ret)
1278 {
1279 ret = CSignedMsgData_ConstructSignerHandles(
1280 &msg->msg_data, i, info->rgSigners[i].hCryptProv);
1281 if (dwFlags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
1282 CryptReleaseContext(info->rgSigners[i].hCryptProv,
1283 0);
1284 }
1285 }
1286 }
1287 else
1288 ret = FALSE;
1289 }
1290 else
1291 {
1292 msg->msg_data.info->cSignerInfo = 0;
1293 msg->msg_data.signerHandles = NULL;
1294 msg->msg_data.cSignerHandle = 0;
1295 }
1296 }
1297 if (ret)
1298 ret = CRYPT_ConstructBlobArray(
1299 (BlobArray *)&msg->msg_data.info->cCertEncoded,
1300 (const BlobArray *)&info->cCertEncoded);
1301 if (ret)
1302 ret = CRYPT_ConstructBlobArray(
1303 (BlobArray *)&msg->msg_data.info->cCrlEncoded,
1304 (const BlobArray *)&info->cCrlEncoded);
1305 if (!ret)
1306 {
1307 CSignedEncodeMsg_Close(msg);
1308 msg = NULL;
1309 }
1310 }
1311 return msg;
1312 }
1313
1314 static inline const char *MSG_TYPE_STR(DWORD type)
1315 {
1316 switch (type)
1317 {
1318 #define _x(x) case (x): return #x
1319 _x(CMSG_DATA);
1320 _x(CMSG_SIGNED);
1321 _x(CMSG_ENVELOPED);
1322 _x(CMSG_SIGNED_AND_ENVELOPED);
1323 _x(CMSG_HASHED);
1324 _x(CMSG_ENCRYPTED);
1325 #undef _x
1326 default:
1327 return wine_dbg_sprintf("unknown (%d)", type);
1328 }
1329 }
1330
1331 HCRYPTMSG WINAPI CryptMsgOpenToEncode(DWORD dwMsgEncodingType, DWORD dwFlags,
1332 DWORD dwMsgType, const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID,
1333 PCMSG_STREAM_INFO pStreamInfo)
1334 {
1335 HCRYPTMSG msg = NULL;
1336
1337 TRACE("(%08x, %08x, %08x, %p, %s, %p)\n", dwMsgEncodingType, dwFlags,
1338 dwMsgType, pvMsgEncodeInfo, debugstr_a(pszInnerContentObjID), pStreamInfo);
1339
1340 if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType) != PKCS_7_ASN_ENCODING)
1341 {
1342 SetLastError(E_INVALIDARG);
1343 return NULL;
1344 }
1345 switch (dwMsgType)
1346 {
1347 case CMSG_DATA:
1348 msg = CDataEncodeMsg_Open(dwFlags, pvMsgEncodeInfo,
1349 pszInnerContentObjID, pStreamInfo);
1350 break;
1351 case CMSG_HASHED:
1352 msg = CHashEncodeMsg_Open(dwFlags, pvMsgEncodeInfo,
1353 pszInnerContentObjID, pStreamInfo);
1354 break;
1355 case CMSG_SIGNED:
1356 msg = CSignedEncodeMsg_Open(dwFlags, pvMsgEncodeInfo,
1357 pszInnerContentObjID, pStreamInfo);
1358 break;
1359 case CMSG_ENVELOPED:
1360 FIXME("unimplemented for type %s\n", MSG_TYPE_STR(dwMsgType));
1361 break;
1362 case CMSG_SIGNED_AND_ENVELOPED:
1363 case CMSG_ENCRYPTED:
1364 /* defined but invalid, fall through */
1365 default:
1366 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1367 }
1368 return msg;
1369 }
1370
1371 typedef struct _CDecodeMsg
1372 {
1373 CryptMsgBase base;
1374 DWORD type;
1375 HCRYPTPROV crypt_prov;
1376 union {
1377 HCRYPTHASH hash;
1378 CSignedMsgData signed_data;
1379 } u;
1380 CRYPT_DATA_BLOB msg_data;
1381 PCONTEXT_PROPERTY_LIST properties;
1382 } CDecodeMsg;
1383
1384 static void CDecodeMsg_Close(HCRYPTMSG hCryptMsg)
1385 {
1386 CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
1387
1388 if (msg->base.open_flags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
1389 CryptReleaseContext(msg->crypt_prov, 0);
1390 switch (msg->type)
1391 {
1392 case CMSG_HASHED:
1393 if (msg->u.hash)
1394 CryptDestroyHash(msg->u.hash);
1395 break;
1396 case CMSG_SIGNED:
1397 if (msg->u.signed_data.info)
1398 {
1399 LocalFree(msg->u.signed_data.info);
1400 CSignedMsgData_CloseHandles(&msg->u.signed_data);
1401 }
1402 break;
1403 }
1404 CryptMemFree(msg->msg_data.pbData);
1405 ContextPropertyList_Free(msg->properties);
1406 }
1407
1408 static BOOL CDecodeMsg_CopyData(CDecodeMsg *msg, const BYTE *pbData,
1409 DWORD cbData)
1410 {
1411 BOOL ret = TRUE;
1412
1413 if (cbData)
1414 {
1415 if (msg->msg_data.cbData)
1416 msg->msg_data.pbData = CryptMemRealloc(msg->msg_data.pbData,
1417 msg->msg_data.cbData + cbData);
1418 else
1419 msg->msg_data.pbData = CryptMemAlloc(cbData);
1420 if (msg->msg_data.pbData)
1421 {
1422 memcpy(msg->msg_data.pbData + msg->msg_data.cbData, pbData, cbData);
1423 msg->msg_data.cbData += cbData;
1424 }
1425 else
1426 ret = FALSE;
1427 }
1428 return ret;
1429 }
1430
1431 static BOOL CDecodeMsg_DecodeDataContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
1432 {
1433 BOOL ret;
1434 CRYPT_DATA_BLOB *data;
1435 DWORD size;
1436
1437 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
1438 blob->pbData, blob->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, (LPBYTE)&data,
1439 &size);
1440 if (ret)
1441 {
1442 ret = ContextPropertyList_SetProperty(msg->properties,
1443 CMSG_CONTENT_PARAM, data->pbData, data->cbData);
1444 LocalFree(data);
1445 }
1446 return ret;
1447 }
1448
1449 static void CDecodeMsg_SaveAlgorithmID(CDecodeMsg *msg, DWORD param,
1450 const CRYPT_ALGORITHM_IDENTIFIER *id)
1451 {
1452 static const BYTE nullParams[] = { ASN_NULL, 0 };
1453 CRYPT_ALGORITHM_IDENTIFIER *copy;
1454 DWORD len = sizeof(CRYPT_ALGORITHM_IDENTIFIER);
1455
1456 /* Linearize algorithm id */
1457 len += strlen(id->pszObjId) + 1;
1458 len += id->Parameters.cbData;
1459 copy = CryptMemAlloc(len);
1460 if (copy)
1461 {
1462 copy->pszObjId =
1463 (LPSTR)((BYTE *)copy + sizeof(CRYPT_ALGORITHM_IDENTIFIER));
1464 strcpy(copy->pszObjId, id->pszObjId);
1465 copy->Parameters.pbData = (BYTE *)copy->pszObjId + strlen(id->pszObjId)
1466 + 1;
1467 /* Trick: omit NULL parameters */
1468 if (id->Parameters.cbData == sizeof(nullParams) &&
1469 !memcmp(id->Parameters.pbData, nullParams, sizeof(nullParams)))
1470 {
1471 copy->Parameters.cbData = 0;
1472 len -= sizeof(nullParams);
1473 }
1474 else
1475 copy->Parameters.cbData = id->Parameters.cbData;
1476 if (copy->Parameters.cbData)
1477 memcpy(copy->Parameters.pbData, id->Parameters.pbData,
1478 id->Parameters.cbData);
1479 ContextPropertyList_SetProperty(msg->properties, param, (BYTE *)copy,
1480 len);
1481 CryptMemFree(copy);
1482 }
1483 }
1484
1485 static inline void CRYPT_FixUpAlgorithmID(CRYPT_ALGORITHM_IDENTIFIER *id)
1486 {
1487 id->pszObjId = (LPSTR)((BYTE *)id + sizeof(CRYPT_ALGORITHM_IDENTIFIER));
1488 id->Parameters.pbData = (BYTE *)id->pszObjId + strlen(id->pszObjId) + 1;
1489 }
1490
1491 static BOOL CDecodeMsg_DecodeHashedContent(CDecodeMsg *msg,
1492 CRYPT_DER_BLOB *blob)
1493 {
1494 BOOL ret;
1495 CRYPT_DIGESTED_DATA *digestedData;
1496 DWORD size;
1497
1498 ret = CRYPT_AsnDecodePKCSDigestedData(blob->pbData, blob->cbData,
1499 CRYPT_DECODE_ALLOC_FLAG, NULL, (CRYPT_DIGESTED_DATA *)&digestedData,
1500 &size);
1501 if (ret)
1502 {
1503 ContextPropertyList_SetProperty(msg->properties, CMSG_VERSION_PARAM,
1504 (const BYTE *)&digestedData->version, sizeof(digestedData->version));
1505 CDecodeMsg_SaveAlgorithmID(msg, CMSG_HASH_ALGORITHM_PARAM,
1506 &digestedData->DigestAlgorithm);
1507 ContextPropertyList_SetProperty(msg->properties,
1508 CMSG_INNER_CONTENT_TYPE_PARAM,
1509 (const BYTE *)digestedData->ContentInfo.pszObjId,
1510 digestedData->ContentInfo.pszObjId ?
1511 strlen(digestedData->ContentInfo.pszObjId) + 1 : 0);
1512 if (digestedData->ContentInfo.Content.cbData)
1513 CDecodeMsg_DecodeDataContent(msg,
1514 &digestedData->ContentInfo.Content);
1515 else
1516 ContextPropertyList_SetProperty(msg->properties,
1517 CMSG_CONTENT_PARAM, NULL, 0);
1518 ContextPropertyList_SetProperty(msg->properties, CMSG_HASH_DATA_PARAM,
1519 digestedData->hash.pbData, digestedData->hash.cbData);
1520 LocalFree(digestedData);
1521 }
1522 return ret;
1523 }
1524
1525 static BOOL CDecodeMsg_DecodeSignedContent(CDecodeMsg *msg,
1526 CRYPT_DER_BLOB *blob)
1527 {
1528 BOOL ret;
1529 CRYPT_SIGNED_INFO *signedInfo;
1530 DWORD size;
1531
1532 ret = CRYPT_AsnDecodePKCSSignedInfo(blob->pbData, blob->cbData,
1533 CRYPT_DECODE_ALLOC_FLAG, NULL, (CRYPT_SIGNED_INFO *)&signedInfo,
1534 &size);
1535 if (ret)
1536 {
1537 DWORD i;
1538
1539 msg->u.signed_data.info = signedInfo;
1540 ret = CSignedMsgData_AllocateHandles(&msg->u.signed_data);
1541 for (i = 0; ret && i < msg->u.signed_data.info->cSignerInfo; i++)
1542 ret = CSignedMsgData_ConstructSignerHandles(&msg->u.signed_data, i,
1543 msg->crypt_prov);
1544 if (ret)
1545 {
1546 /* Now that we have all the content, update the hash handles with
1547 * it. Have to decode it if the type is szOID_RSA_data.
1548 */
1549 if (msg->u.signed_data.info->content.Content.cbData)
1550 {
1551 if (!strcmp(msg->u.signed_data.info->content.pszObjId,
1552 szOID_RSA_data))
1553 {
1554 CRYPT_DATA_BLOB *blob;
1555
1556 ret = CryptDecodeObjectEx(X509_ASN_ENCODING,
1557 X509_OCTET_STRING,
1558 msg->u.signed_data.info->content.Content.pbData,
1559 msg->u.signed_data.info->content.Content.cbData,
1560 CRYPT_DECODE_ALLOC_FLAG, NULL, (LPBYTE)&blob, &size);
1561 if (ret)
1562 {
1563 ret = CSignedMsgData_Update(&msg->u.signed_data,
1564 blob->pbData, blob->cbData, TRUE, Verify);
1565 LocalFree(blob);
1566 }
1567 }
1568 else
1569 ret = CSignedMsgData_Update(&msg->u.signed_data,
1570 msg->u.signed_data.info->content.Content.pbData,
1571 msg->u.signed_data.info->content.Content.cbData, TRUE,
1572 Verify);
1573 }
1574 }
1575 }
1576 return ret;
1577 }
1578 /* Decodes the content in blob as the type given, and updates the value
1579 * (type, parameters, etc.) of msg based on what blob contains.
1580 * It doesn't just use msg's type, to allow a recursive call from an implicitly
1581 * typed message once the outer content info has been decoded.
1582 */
1583 static BOOL CDecodeMsg_DecodeContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob,
1584 DWORD type)
1585 {
1586 BOOL ret;
1587
1588 switch (type)
1589 {
1590 case CMSG_DATA:
1591 if ((ret = CDecodeMsg_DecodeDataContent(msg, blob)))
1592 msg->type = CMSG_DATA;
1593 break;
1594 case CMSG_HASHED:
1595 if ((ret = CDecodeMsg_DecodeHashedContent(msg, blob)))
1596 msg->type = CMSG_HASHED;
1597 break;
1598 case CMSG_ENVELOPED:
1599 FIXME("unimplemented for type %s\n", MSG_TYPE_STR(type));
1600 ret = TRUE;
1601 break;
1602 case CMSG_SIGNED:
1603 if ((ret = CDecodeMsg_DecodeSignedContent(msg, blob)))
1604 msg->type = CMSG_SIGNED;
1605 break;
1606 default:
1607 {
1608 CRYPT_CONTENT_INFO *info;
1609 DWORD size;
1610
1611 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, PKCS_CONTENT_INFO,
1612 msg->msg_data.pbData, msg->msg_data.cbData, CRYPT_DECODE_ALLOC_FLAG,
1613 NULL, (LPBYTE)&info, &size);
1614 if (ret)
1615 {
1616 if (!strcmp(info->pszObjId, szOID_RSA_data))
1617 ret = CDecodeMsg_DecodeContent(msg, &info->Content, CMSG_DATA);
1618 else if (!strcmp(info->pszObjId, szOID_RSA_digestedData))
1619 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
1620 CMSG_HASHED);
1621 else if (!strcmp(info->pszObjId, szOID_RSA_envelopedData))
1622 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
1623 CMSG_ENVELOPED);
1624 else if (!strcmp(info->pszObjId, szOID_RSA_signedData))
1625 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
1626 CMSG_SIGNED);
1627 else
1628 {
1629 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1630 ret = FALSE;
1631 }
1632 LocalFree(info);
1633 }
1634 }
1635 }
1636 return ret;
1637 }
1638
1639 static BOOL CDecodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
1640 DWORD cbData, BOOL fFinal)
1641 {
1642 CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
1643 BOOL ret = FALSE;
1644
1645 TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
1646
1647 if (msg->base.streamed)
1648 {
1649 ret = CDecodeMsg_CopyData(msg, pbData, cbData);
1650 FIXME("(%p, %p, %d, %d): streamed update stub\n", hCryptMsg, pbData,
1651 cbData, fFinal);
1652 }
1653 else
1654 {
1655 if (!fFinal)
1656 SetLastError(CRYPT_E_MSG_ERROR);
1657 else
1658 {
1659 ret = CDecodeMsg_CopyData(msg, pbData, cbData);
1660 if (ret)
1661 ret = CDecodeMsg_DecodeContent(msg, &msg->msg_data, msg->type);
1662
1663 }
1664 }
1665 return ret;
1666 }
1667
1668 static BOOL CDecodeHashMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType,
1669 DWORD dwIndex, void *pvData, DWORD *pcbData)
1670 {
1671 BOOL ret = FALSE;
1672
1673 switch (dwParamType)
1674 {
1675 case CMSG_TYPE_PARAM:
1676 ret = CRYPT_CopyParam(pvData, pcbData, &msg->type, sizeof(msg->type));
1677 break;
1678 case CMSG_HASH_ALGORITHM_PARAM:
1679 {
1680 CRYPT_DATA_BLOB blob;
1681
1682 ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
1683 &blob);
1684 if (ret)
1685 {
1686 ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData, blob.cbData);
1687 if (ret && pvData)
1688 CRYPT_FixUpAlgorithmID((CRYPT_ALGORITHM_IDENTIFIER *)pvData);
1689 }
1690 else
1691 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1692 break;
1693 }
1694 case CMSG_COMPUTED_HASH_PARAM:
1695 if (!msg->u.hash)
1696 {
1697 CRYPT_ALGORITHM_IDENTIFIER *hashAlgoID = NULL;
1698 DWORD size = 0;
1699 ALG_ID algID = 0;
1700
1701 CryptMsgGetParam(msg, CMSG_HASH_ALGORITHM_PARAM, 0, NULL, &size);
1702 hashAlgoID = CryptMemAlloc(size);
1703 ret = CryptMsgGetParam(msg, CMSG_HASH_ALGORITHM_PARAM, 0,
1704 hashAlgoID, &size);
1705 if (ret)
1706 algID = CertOIDToAlgId(hashAlgoID->pszObjId);
1707 ret = CryptCreateHash(msg->crypt_prov, algID, 0, 0, &msg->u.hash);
1708 if (ret)
1709 {
1710 CRYPT_DATA_BLOB content;
1711
1712 ret = ContextPropertyList_FindProperty(msg->properties,
1713 CMSG_CONTENT_PARAM, &content);
1714 if (ret)
1715 ret = CryptHashData(msg->u.hash, content.pbData,
1716 content.cbData, 0);
1717 }
1718 CryptMemFree(hashAlgoID);
1719 }
1720 else
1721 ret = TRUE;
1722 if (ret)
1723 ret = CryptGetHashParam(msg->u.hash, HP_HASHVAL, pvData, pcbData,
1724 0);
1725 break;
1726 default:
1727 {
1728 CRYPT_DATA_BLOB blob;
1729
1730 ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
1731 &blob);
1732 if (ret)
1733 ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData, blob.cbData);
1734 else
1735 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1736 }
1737 }
1738 return ret;
1739 }
1740
1741 /* nextData is an in/out parameter - on input it's the memory location in
1742 * which a copy of in's data should be made, and on output it's the memory
1743 * location immediately after out's copy of in's data.
1744 */
1745 static inline void CRYPT_CopyBlob(CRYPT_DATA_BLOB *out,
1746 const CRYPT_DATA_BLOB *in, LPBYTE *nextData)
1747 {
1748 out->cbData = in->cbData;
1749 if (in->cbData)
1750 {
1751 out->pbData = *nextData;
1752 memcpy(out->pbData, in->pbData, in->cbData);
1753 *nextData += in->cbData;
1754 }
1755 }
1756
1757 static inline void CRYPT_CopyAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER *out,
1758 const CRYPT_ALGORITHM_IDENTIFIER *in, LPBYTE *nextData)
1759 {
1760 if (in->pszObjId)
1761 {
1762 out->pszObjId = (LPSTR)*nextData;
1763 strcpy(out->pszObjId, in->pszObjId);
1764 *nextData += strlen(out->pszObjId) + 1;
1765 }
1766 CRYPT_CopyBlob(&out->Parameters, &in->Parameters, nextData);
1767 }
1768
1769 static inline void CRYPT_CopyAttributes(CRYPT_ATTRIBUTES *out,
1770 const CRYPT_ATTRIBUTES *in, LPBYTE *nextData)
1771 {
1772 out->cAttr = in->cAttr;
1773 if (in->cAttr)
1774 {
1775 DWORD i;
1776
1777 if ((*nextData - (LPBYTE)0) % sizeof(DWORD_PTR))
1778 *nextData += (*nextData - (LPBYTE)0) % sizeof(DWORD_PTR);
1779 out->rgAttr = (CRYPT_ATTRIBUTE *)*nextData;
1780 *nextData += in->cAttr * sizeof(CRYPT_ATTRIBUTE);
1781 for (i = 0; i < in->cAttr; i++)
1782 {
1783 if (in->rgAttr[i].pszObjId)
1784 {
1785 out->rgAttr[i].pszObjId = (LPSTR)*nextData;
1786 strcpy(out->rgAttr[i].pszObjId, in->rgAttr[i].pszObjId);
1787 *nextData += strlen(in->rgAttr[i].pszObjId) + 1;
1788 }
1789 if (in->rgAttr[i].cValue)
1790 {
1791 DWORD j;
1792
1793 out->rgAttr[i].cValue = in->rgAttr[i].cValue;
1794 if ((*nextData - (LPBYTE)0) % sizeof(DWORD_PTR))
1795 *nextData += (*nextData - (LPBYTE)0) % sizeof(DWORD_PTR);
1796 out->rgAttr[i].rgValue = (PCRYPT_DATA_BLOB)*nextData;
1797 *nextData += in->rgAttr[i].cValue * sizeof(CRYPT_DATA_BLOB);
1798 for (j = 0; j < in->rgAttr[i].cValue; j++)
1799 CRYPT_CopyBlob(&out->rgAttr[i].rgValue[j],
1800 &in->rgAttr[i].rgValue[j], nextData);
1801 }
1802 }
1803 }
1804 }
1805
1806 static DWORD CRYPT_SizeOfAttributes(const CRYPT_ATTRIBUTES *attr)
1807 {
1808 DWORD size = attr->cAttr * sizeof(CRYPT_ATTRIBUTE), i, j;
1809
1810 for (i = 0; i < attr->cAttr; i++)
1811 {
1812 if (attr->rgAttr[i].pszObjId)
1813 size += strlen(attr->rgAttr[i].pszObjId) + 1;
1814 /* align pointer */
1815 if (size % sizeof(DWORD_PTR))
1816 size += size % sizeof(DWORD_PTR);
1817 size += attr->rgAttr[i].cValue * sizeof(CRYPT_DATA_BLOB);
1818 for (j = 0; j < attr->rgAttr[i].cValue; j++)
1819 size += attr->rgAttr[i].rgValue[j].cbData;
1820 }
1821 /* align pointer again to be conservative */
1822 if (size % sizeof(DWORD_PTR))
1823 size += size % sizeof(DWORD_PTR);
1824 return size;
1825 }
1826
1827 static BOOL CRYPT_CopySignerInfo(void *pvData, DWORD *pcbData,
1828 const CMSG_SIGNER_INFO *in)
1829 {
1830 DWORD size = sizeof(CMSG_SIGNER_INFO);
1831 BOOL ret;
1832
1833 TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
1834
1835 size += in->Issuer.cbData;
1836 size += in->SerialNumber.cbData;
1837 if (in->HashAlgorithm.pszObjId)
1838 size += strlen(in->HashAlgorithm.pszObjId) + 1;
1839 size += in->HashAlgorithm.Parameters.cbData;
1840 if (in->HashEncryptionAlgorithm.pszObjId)
1841 size += strlen(in->HashEncryptionAlgorithm.pszObjId) + 1;
1842 size += in->HashEncryptionAlgorithm.Parameters.cbData;
1843 size += in->EncryptedHash.cbData;
1844 /* align pointer */
1845 if (size % sizeof(DWORD_PTR))
1846 size += size % sizeof(DWORD_PTR);
1847 size += CRYPT_SizeOfAttributes(&in->AuthAttrs);
1848 size += CRYPT_SizeOfAttributes(&in->UnauthAttrs);
1849 if (!pvData)
1850 {
1851 *pcbData = size;
1852 ret = TRUE;
1853 }
1854 else if (*pcbData < size)
1855 {
1856 *pcbData = size;
1857 SetLastError(ERROR_MORE_DATA);
1858 ret = FALSE;
1859 }
1860 else
1861 {
1862 LPBYTE nextData = (BYTE *)pvData + sizeof(CMSG_SIGNER_INFO);
1863 CMSG_SIGNER_INFO *out = (CMSG_SIGNER_INFO *)pvData;
1864
1865 out->dwVersion = in->dwVersion;
1866 CRYPT_CopyBlob(&out->Issuer, &in->Issuer, &nextData);
1867 CRYPT_CopyBlob(&out->SerialNumber, &in->SerialNumber, &nextData);
1868 CRYPT_CopyAlgorithmId(&out->HashAlgorithm, &in->HashAlgorithm,
1869 &nextData);
1870 CRYPT_CopyAlgorithmId(&out->HashEncryptionAlgorithm,
1871 &in->HashEncryptionAlgorithm, &nextData);
1872 CRYPT_CopyBlob(&out->EncryptedHash, &in->EncryptedHash, &nextData);
1873 /* align pointer */
1874 if ((nextData - (LPBYTE)0) % sizeof(DWORD_PTR))
1875 nextData += (nextData - (LPBYTE)0) % sizeof(DWORD_PTR);
1876 CRYPT_CopyAttributes(&out->AuthAttrs, &in->AuthAttrs, &nextData);
1877 CRYPT_CopyAttributes(&out->UnauthAttrs, &in->UnauthAttrs, &nextData);
1878 ret = TRUE;
1879 }
1880 TRACE("returning %d\n", ret);
1881 return ret;
1882 }
1883
1884 static BOOL CRYPT_CopySignerCertInfo(void *pvData, DWORD *pcbData,
1885 const CMSG_SIGNER_INFO *in)
1886 {
1887 DWORD size = sizeof(CERT_INFO);
1888 BOOL ret;
1889
1890 TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
1891
1892 size += in->Issuer.cbData;
1893 size += in->SerialNumber.cbData;
1894 if (!pvData)
1895 {
1896 *pcbData = size;
1897 ret = TRUE;
1898 }
1899 else if (*pcbData < size)
1900 {
1901 *pcbData = size;
1902 SetLastError(ERROR_MORE_DATA);
1903 ret = FALSE;
1904 }
1905 else
1906 {
1907 LPBYTE nextData = (BYTE *)pvData + sizeof(CERT_INFO);
1908 CERT_INFO *out = (CERT_INFO *)pvData;
1909
1910 memset(out, 0, sizeof(CERT_INFO));
1911 CRYPT_CopyBlob(&out->Issuer, &in->Issuer, &nextData);
1912 CRYPT_CopyBlob(&out->SerialNumber, &in->SerialNumber, &nextData);
1913 ret = TRUE;
1914 }
1915 TRACE("returning %d\n", ret);
1916 return ret;
1917 }
1918
1919 static BOOL CDecodeSignedMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType,
1920 DWORD dwIndex, void *pvData, DWORD *pcbData)
1921 {
1922 BOOL ret = FALSE;
1923
1924 switch (dwParamType)
1925 {
1926 case CMSG_TYPE_PARAM:
1927 ret = CRYPT_CopyParam(pvData, pcbData, &msg->type, sizeof(msg->type));
1928 break;
1929 case CMSG_CONTENT_PARAM:
1930 if (msg->u.signed_data.info)
1931 {
1932 if (!strcmp(msg->u.signed_data.info->content.pszObjId,
1933 szOID_RSA_data))
1934 {
1935 CRYPT_DATA_BLOB *blob;
1936 DWORD size;
1937
1938 ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
1939 msg->u.signed_data.info->content.Content.pbData,
1940 msg->u.signed_data.info->content.Content.cbData,
1941 CRYPT_DECODE_ALLOC_FLAG, NULL, (LPBYTE)&blob, &size);
1942 if (ret)
1943 {
1944 ret = CRYPT_CopyParam(pvData, pcbData, blob->pbData,
1945 blob->cbData);
1946 LocalFree(blob);
1947 }
1948 }
1949 else
1950 ret = CRYPT_CopyParam(pvData, pcbData,
1951 msg->u.signed_data.info->content.Content.pbData,
1952 msg->u.signed_data.info->content.Content.cbData);
1953 }
1954 else
1955 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1956 break;
1957 case CMSG_INNER_CONTENT_TYPE_PARAM:
1958 if (msg->u.signed_data.info)
1959 ret = CRYPT_CopyParam(pvData, pcbData,
1960 msg->u.signed_data.info->content.pszObjId,
1961 strlen(msg->u.signed_data.info->content.pszObjId) + 1);
1962 else
1963 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1964 break;
1965 case CMSG_SIGNER_COUNT_PARAM:
1966 if (msg->u.signed_data.info)
1967 ret = CRYPT_CopyParam(pvData, pcbData,
1968 &msg->u.signed_data.info->cSignerInfo, sizeof(DWORD));
1969 else
1970 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1971 break;
1972 case CMSG_SIGNER_INFO_PARAM:
1973 if (msg->u.signed_data.info)
1974 {
1975 if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
1976 SetLastError(CRYPT_E_INVALID_INDEX);
1977 else
1978 ret = CRYPT_CopySignerInfo(pvData, pcbData,
1979 &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
1980 }
1981 else
1982 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1983 break;
1984 case CMSG_SIGNER_CERT_INFO_PARAM:
1985 if (msg->u.signed_data.info)
1986 {
1987 if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
1988 SetLastError(CRYPT_E_INVALID_INDEX);
1989 else
1990 ret = CRYPT_CopySignerCertInfo(pvData, pcbData,
1991 &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
1992 }
1993 else
1994 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
1995 break;
1996 case CMSG_CERT_COUNT_PARAM:
1997 if (msg->u.signed_data.info)
1998 ret = CRYPT_CopyParam(pvData, pcbData,
1999 &msg->u.signed_data.info->cCertEncoded, sizeof(DWORD));
2000 else
2001 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2002 break;
2003 case CMSG_CERT_PARAM:
2004 if (msg->u.signed_data.info)
2005 {
2006 if (dwIndex >= msg->u.signed_data.info->cCertEncoded)
2007 SetLastError(CRYPT_E_INVALID_INDEX);
2008 else
2009 ret = CRYPT_CopyParam(pvData, pcbData,
2010 msg->u.signed_data.info->rgCertEncoded[dwIndex].pbData,
2011 msg->u.signed_data.info->rgCertEncoded[dwIndex].cbData);
2012 }
2013 else
2014 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2015 break;
2016 case CMSG_CRL_COUNT_PARAM:
2017 if (msg->u.signed_data.info)
2018 ret = CRYPT_CopyParam(pvData, pcbData,
2019 &msg->u.signed_data.info->cCrlEncoded, sizeof(DWORD));
2020 else
2021 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2022 break;
2023 case CMSG_CRL_PARAM:
2024 if (msg->u.signed_data.info)
2025 {
2026 if (dwIndex >= msg->u.signed_data.info->cCrlEncoded)
2027 SetLastError(CRYPT_E_INVALID_INDEX);
2028 else
2029 ret = CRYPT_CopyParam(pvData, pcbData,
2030 msg->u.signed_data.info->rgCrlEncoded[dwIndex].pbData,
2031 msg->u.signed_data.info->rgCrlEncoded[dwIndex].cbData);
2032 }
2033 else
2034 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2035 break;
2036 case CMSG_COMPUTED_HASH_PARAM:
2037 if (msg->u.signed_data.info)
2038 {
2039 if (dwIndex >= msg->u.signed_data.cSignerHandle)
2040 SetLastError(CRYPT_E_INVALID_INDEX);
2041 else
2042 ret = CryptGetHashParam(
2043 msg->u.signed_data.signerHandles[dwIndex].contentHash,
2044 HP_HASHVAL, pvData, pcbData, 0);
2045 }
2046 else
2047 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2048 break;
2049 case CMSG_ATTR_CERT_COUNT_PARAM:
2050 if (msg->u.signed_data.info)
2051 {
2052 DWORD attrCertCount = 0;
2053
2054 ret = CRYPT_CopyParam(pvData, pcbData,
2055 &attrCertCount, sizeof(DWORD));
2056 }
2057 else
2058 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2059 break;
2060 case CMSG_ATTR_CERT_PARAM:
2061 if (msg->u.signed_data.info)
2062 SetLastError(CRYPT_E_INVALID_INDEX);
2063 else
2064 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2065 break;
2066 default:
2067 FIXME("unimplemented for %d\n", dwParamType);
2068 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2069 }
2070 return ret;
2071 }
2072
2073 static BOOL CDecodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
2074 DWORD dwIndex, void *pvData, DWORD *pcbData)
2075 {
2076 CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
2077 BOOL ret = FALSE;
2078
2079 switch (msg->type)
2080 {
2081 case CMSG_HASHED:
2082 ret = CDecodeHashMsg_GetParam(msg, dwParamType, dwIndex, pvData,
2083 pcbData);
2084 break;
2085 case CMSG_SIGNED:
2086 ret = CDecodeSignedMsg_GetParam(msg, dwParamType, dwIndex, pvData,
2087 pcbData);
2088 break;
2089 default:
2090 switch (dwParamType)
2091 {
2092 case CMSG_TYPE_PARAM:
2093 ret = CRYPT_CopyParam(pvData, pcbData, &msg->type,
2094 sizeof(msg->type));
2095 break;
2096 default:
2097 {
2098 CRYPT_DATA_BLOB blob;
2099
2100 ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
2101 &blob);
2102 if (ret)
2103 ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData,
2104 blob.cbData);
2105 else
2106 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2107 }
2108 }
2109 }
2110 return ret;
2111 }
2112
2113 static BOOL CDecodeHashMsg_VerifyHash(CDecodeMsg *msg)
2114 {
2115 BOOL ret;
2116 CRYPT_DATA_BLOB hashBlob;
2117
2118 ret = ContextPropertyList_FindProperty(msg->properties,
2119 CMSG_HASH_DATA_PARAM, &hashBlob);
2120 if (ret)
2121 {
2122 DWORD computedHashSize = 0;
2123
2124 ret = CDecodeHashMsg_GetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0, NULL,
2125 &computedHashSize);
2126 if (hashBlob.cbData == computedHashSize)
2127 {
2128 LPBYTE computedHash = CryptMemAlloc(computedHashSize);
2129
2130 if (computedHash)
2131 {
2132 ret = CDecodeHashMsg_GetParam(msg, CMSG_COMPUTED_HASH_PARAM, 0,
2133 computedHash, &computedHashSize);
2134 if (ret)
2135 ret = !memcmp(hashBlob.pbData, computedHash,
2136 hashBlob.cbData);
2137 CryptMemFree(computedHash);
2138 }
2139 else
2140 ret = FALSE;
2141 }
2142 }
2143 return ret;
2144 }
2145
2146 static BOOL CDecodeSignedMsg_VerifySignatureWithKey(CDecodeMsg *msg,
2147 HCRYPTPROV prov, DWORD signerIndex, PCERT_PUBLIC_KEY_INFO keyInfo)
2148 {
2149 HCRYPTKEY key;
2150 BOOL ret;
2151
2152 if (!prov)
2153 prov = msg->crypt_prov;
2154 ret = CryptImportPublicKeyInfo(prov, X509_ASN_ENCODING, keyInfo, &key);
2155 if (ret)
2156 {
2157 HCRYPTHASH hash;
2158 CRYPT_HASH_BLOB reversedHash;
2159
2160 if (msg->u.signed_data.info->rgSignerInfo[signerIndex].AuthAttrs.cAttr)
2161 hash = msg->u.signed_data.signerHandles[signerIndex].authAttrHash;
2162 else
2163 hash = msg->u.signed_data.signerHandles[signerIndex].contentHash;
2164 ret = CRYPT_ConstructBlob(&reversedHash,
2165 &msg->u.signed_data.info->rgSignerInfo[signerIndex].EncryptedHash);
2166 if (ret)
2167 {
2168 CRYPT_ReverseBytes(&reversedHash);
2169 ret = CryptVerifySignatureW(hash, reversedHash.pbData,
2170 reversedHash.cbData, key, NULL, 0);
2171 CryptMemFree(reversedHash.pbData);
2172 }
2173 CryptDestroyKey(key);
2174 }
2175 return ret;
2176 }
2177
2178 static BOOL CDecodeSignedMsg_VerifySignature(CDecodeMsg *msg, PCERT_INFO info)
2179 {
2180 BOOL ret = FALSE;
2181 DWORD i;
2182
2183 for (i = 0; !ret && i < msg->u.signed_data.info->cSignerInfo; i++)
2184 {
2185 ret = CertCompareCertificateName(X509_ASN_ENCODING,
2186 &msg->u.signed_data.info->rgSignerInfo[i].Issuer, &info->Issuer);
2187 if (ret)
2188 {
2189 ret = CertCompareIntegerBlob(
2190 &msg->u.signed_data.info->rgSignerInfo[i].SerialNumber,
2191 &info->SerialNumber);
2192 if (ret)
2193 break;
2194 }
2195 }
2196 if (ret)
2197 ret = CDecodeSignedMsg_VerifySignatureWithKey(msg, 0, i,
2198 &info->SubjectPublicKeyInfo);
2199 else
2200 SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
2201
2202 return ret;
2203 }
2204
2205 static BOOL CDecodeSignedMsg_VerifySignatureEx(CDecodeMsg *msg,
2206 PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA para)
2207 {
2208 BOOL ret = FALSE;
2209
2210 if (para->cbSize != sizeof(CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA))
2211 SetLastError(ERROR_INVALID_PARAMETER);
2212 else if (para->dwSignerIndex >= msg->u.signed_data.info->cSignerInfo)
2213 SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
2214 else
2215 {
2216 switch (para->dwSignerType)
2217 {
2218 case CMSG_VERIFY_SIGNER_PUBKEY:
2219 ret = CDecodeSignedMsg_VerifySignatureWithKey(msg,
2220 para->hCryptProv, para->dwSignerIndex,
2221 (PCERT_PUBLIC_KEY_INFO)para->pvSigner);
2222 break;
2223 case CMSG_VERIFY_SIGNER_CERT:
2224 {
2225 PCCERT_CONTEXT cert = (PCCERT_CONTEXT)para->pvSigner;
2226
2227 ret = CDecodeSignedMsg_VerifySignatureWithKey(msg, para->hCryptProv,
2228 para->dwSignerIndex, &cert->pCertInfo->SubjectPublicKeyInfo);
2229 break;
2230 }
2231 default:
2232 FIXME("unimplemented for signer type %d\n", para->dwSignerType);
2233 SetLastError(CRYPT_E_SIGNER_NOT_FOUND);
2234 }
2235 }
2236 return ret;
2237 }
2238
2239 static BOOL CDecodeMsg_Control(HCRYPTMSG hCryptMsg, DWORD dwFlags,
2240 DWORD dwCtrlType, const void *pvCtrlPara)
2241 {
2242 CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
2243 BOOL ret = FALSE;
2244
2245 switch (dwCtrlType)
2246 {
2247 case CMSG_CTRL_VERIFY_SIGNATURE:
2248 switch (msg->type)
2249 {
2250 case CMSG_SIGNED:
2251 ret = CDecodeSignedMsg_VerifySignature(msg, (PCERT_INFO)pvCtrlPara);
2252 break;
2253 default:
2254 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2255 }
2256 break;
2257 case CMSG_CTRL_DECRYPT:
2258 switch (msg->type)
2259 {
2260 default:
2261 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2262 }
2263 break;
2264 case CMSG_CTRL_VERIFY_HASH:
2265 switch (msg->type)
2266 {
2267 case CMSG_HASHED:
2268 ret = CDecodeHashMsg_VerifyHash(msg);
2269 break;
2270 default:
2271 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2272 }
2273 break;
2274 case CMSG_CTRL_VERIFY_SIGNATURE_EX:
2275 switch (msg->type)
2276 {
2277 case CMSG_SIGNED:
2278 ret = CDecodeSignedMsg_VerifySignatureEx(msg,
2279 (PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA)pvCtrlPara);
2280 break;
2281 default:
2282 SetLastError(CRYPT_E_INVALID_MSG_TYPE);
2283 }
2284 break;
2285 default:
2286 SetLastError(CRYPT_E_CONTROL_TYPE);
2287 }
2288 return ret;
2289 }
2290
2291 HCRYPTMSG WINAPI CryptMsgOpenToDecode(DWORD dwMsgEncodingType, DWORD dwFlags,
2292 DWORD dwMsgType, HCRYPTPROV_LEGACY hCryptProv, PCERT_INFO pRecipientInfo,
2293 PCMSG_STREAM_INFO pStreamInfo)
2294 {
2295 CDecodeMsg *msg;
2296
2297 TRACE("(%08x, %08x, %08x, %08lx, %p, %p)\n", dwMsgEncodingType,
2298 dwFlags, dwMsgType, hCryptProv, pRecipientInfo, pStreamInfo);
2299
2300 if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType) != PKCS_7_ASN_ENCODING)
2301 {
2302 SetLastError(E_INVALIDARG);
2303 return NULL;
2304 }
2305 msg = CryptMemAlloc(sizeof(CDecodeMsg));
2306 if (msg)
2307 {
2308 CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
2309 CDecodeMsg_Close, CDecodeMsg_GetParam, CDecodeMsg_Update,
2310 CDecodeMsg_Control);
2311 msg->type = dwMsgType;
2312 if (hCryptProv)
2313 msg->crypt_prov = hCryptProv;
2314 else
2315 {
2316 msg->crypt_prov = CRYPT_GetDefaultProvider();
2317 msg->base.open_flags &= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG;
2318 }
2319 memset(&msg->u, 0, sizeof(msg->u));
2320 msg->msg_data.cbData = 0;
2321 msg->msg_data.pbData = NULL;
2322 msg->properties = ContextPropertyList_Create();
2323 }
2324 return msg;
2325 }
2326
2327 HCRYPTMSG WINAPI CryptMsgDuplicate(HCRYPTMSG hCryptMsg)
2328 {
2329 TRACE("(%p)\n", hCryptMsg);
2330
2331 if (hCryptMsg)
2332 {
2333 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2334
2335 InterlockedIncrement(&msg->ref);
2336 }
2337 return hCryptMsg;
2338 }
2339
2340 BOOL WINAPI CryptMsgClose(HCRYPTMSG hCryptMsg)
2341 {
2342 TRACE("(%p)\n", hCryptMsg);
2343
2344 if (hCryptMsg)
2345 {
2346 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2347
2348 if (InterlockedDecrement(&msg->ref) == 0)
2349 {
2350 TRACE("freeing %p\n", msg);
2351 if (msg->close)
2352 msg->close(msg);
2353 CryptMemFree(msg);
2354 }
2355 }
2356 return TRUE;
2357 }
2358
2359 BOOL WINAPI CryptMsgUpdate(HCRYPTMSG hCryptMsg, const BYTE *pbData,
2360 DWORD cbData, BOOL fFinal)
2361 {
2362 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2363 BOOL ret = FALSE;
2364
2365 TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
2366
2367 if (msg->state == MsgStateFinalized)
2368 SetLastError(CRYPT_E_MSG_ERROR);
2369 else
2370 {
2371 ret = msg->update(hCryptMsg, pbData, cbData, fFinal);
2372 msg->state = MsgStateUpdated;
2373 if (fFinal)
2374 msg->state = MsgStateFinalized;
2375 }
2376 return ret;
2377 }
2378
2379 BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
2380 DWORD dwIndex, void *pvData, DWORD *pcbData)
2381 {
2382 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2383
2384 TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
2385 pvData, pcbData);
2386 return msg->get_param(hCryptMsg, dwParamType, dwIndex, pvData, pcbData);
2387 }
2388
2389 BOOL WINAPI CryptMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags,
2390 DWORD dwCtrlType, const void *pvCtrlPara)
2391 {
2392 CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
2393
2394 TRACE("(%p, %08x, %d, %p)\n", hCryptMsg, dwFlags, dwCtrlType,
2395 pvCtrlPara);
2396 return msg->control(hCryptMsg, dwFlags, dwCtrlType, pvCtrlPara);
2397 }
2398
2399 HCERTSTORE WINAPI CryptGetMessageCertificates(DWORD dwMsgAndCertEncodingType,
2400 HCRYPTPROV_LEGACY hCryptProv, DWORD dwFlags, const BYTE* pbSignedBlob,
2401 DWORD cbSignedBlob)
2402 {
2403 CRYPT_DATA_BLOB blob = { cbSignedBlob, (LPBYTE)pbSignedBlob };
2404
2405 TRACE("(%08x, %ld, %d08x %p, %d)\n", dwMsgAndCertEncodingType, hCryptProv,
2406 dwFlags, pbSignedBlob, cbSignedBlob);
2407
2408 return CertOpenStore(CERT_STORE_PROV_PKCS7, dwMsgAndCertEncodingType,
2409 hCryptProv, dwFlags, &blob);
2410 }
2411
2412 LONG WINAPI CryptGetMessageSignerCount(DWORD dwMsgEncodingType,
2413 const BYTE *pbSignedBlob, DWORD cbSignedBlob)
2414 {
2415 HCRYPTMSG msg;
2416 LONG count = -1;
2417
2418 TRACE("(%08x, %p, %d)\n", dwMsgEncodingType, pbSignedBlob, cbSignedBlob);
2419
2420 msg = CryptMsgOpenToDecode(dwMsgEncodingType, 0, 0, 0, NULL, NULL);
2421 if (msg)
2422 {
2423 if (CryptMsgUpdate(msg, pbSignedBlob, cbSignedBlob, TRUE))
2424 {
2425 DWORD size = sizeof(count);
2426
2427 CryptMsgGetParam(msg, CMSG_SIGNER_COUNT_PARAM, 0, &count, &size);
2428 }
2429 CryptMsgClose(msg);
2430 }
2431 return count;
2432 }
2433
2434 static CERT_INFO *CRYPT_GetSignerCertInfoFromMsg(HCRYPTMSG msg,
2435 DWORD dwSignerIndex)
2436 {
2437 CERT_INFO *certInfo = NULL;
2438 DWORD size;
2439
2440 if (CryptMsgGetParam(msg, CMSG_SIGNER_CERT_INFO_PARAM, dwSignerIndex, NULL,
2441 &size))
2442 {
2443 certInfo = CryptMemAlloc(size);
2444 if (certInfo)
2445 {
2446 if (!CryptMsgGetParam(msg, CMSG_SIGNER_CERT_INFO_PARAM,
2447 dwSignerIndex, certInfo, &size))
2448 {
2449 CryptMemFree(certInfo);
2450 certInfo = NULL;
2451 }
2452 }
2453 }
2454 return certInfo;
2455 }
2456
2457 static PCCERT_CONTEXT WINAPI CRYPT_DefaultGetSignerCertificate(void *pvGetArg,
2458 DWORD dwCertEncodingType, PCERT_INFO pSignerId, HCERTSTORE hMsgCertStore)
2459 {
2460 return CertFindCertificateInStore(hMsgCertStore, dwCertEncodingType, 0,
2461 CERT_FIND_SUBJECT_CERT, pSignerId, NULL);
2462 }
2463
2464 static inline PCCERT_CONTEXT CRYPT_GetSignerCertificate(HCRYPTMSG msg,
2465 PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara, PCERT_INFO certInfo, HCERTSTORE store)
2466 {
2467 PFN_CRYPT_GET_SIGNER_CERTIFICATE getCert;
2468
2469 if (pVerifyPara->pfnGetSignerCertificate)
2470 getCert = pVerifyPara->pfnGetSignerCertificate;
2471 else
2472 getCert = CRYPT_DefaultGetSignerCertificate;
2473 return getCert(pVerifyPara->pvGetArg,
2474 pVerifyPara->dwMsgAndCertEncodingType, certInfo, store);
2475 }
2476
2477 BOOL WINAPI CryptVerifyMessageSignature(PCRYPT_VERIFY_MESSAGE_PARA pVerifyPara,
2478 DWORD dwSignerIndex, const BYTE* pbSignedBlob, DWORD cbSignedBlob,
2479 BYTE* pbDecoded, DWORD* pcbDecoded, PCCERT_CONTEXT* ppSignerCert)
2480 {
2481 BOOL ret = FALSE;
2482 DWORD size;
2483 CRYPT_CONTENT_INFO *contentInfo;
2484
2485 TRACE("(%p, %d, %p, %d, %p, %p, %p)\n",
2486 pVerifyPara, dwSignerIndex, pbSignedBlob, cbSignedBlob,
2487 pbDecoded, pcbDecoded, ppSignerCert);
2488
2489 if (ppSignerCert)
2490 *ppSignerCert = NULL;
2491 if (pcbDecoded)
2492 *pcbDecoded = 0;
2493 if (!pVerifyPara ||
2494 pVerifyPara->cbSize != sizeof(CRYPT_VERIFY_MESSAGE_PARA) ||
2495 GET_CMSG_ENCODING_TYPE(pVerifyPara->dwMsgAndCertEncodingType) !=
2496 PKCS_7_ASN_ENCODING)
2497 {
2498 SetLastError(E_INVALIDARG);
2499 return FALSE;
2500 }
2501
2502 ret = CryptDecodeObjectEx(pVerifyPara->dwMsgAndCertEncodingType,
2503 PKCS_CONTENT_INFO, pbSignedBlob, cbSignedBlob,
2504 CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
2505 (LPBYTE)&contentInfo, &size);
2506 if (ret)
2507 {
2508 if (strcmp(contentInfo->pszObjId, szOID_RSA_signedData))
2509 {
2510 SetLastError(CRYPT_E_UNEXPECTED_MSG_TYPE);
2511 ret = FALSE;
2512 }
2513 else
2514 {
2515 HCRYPTMSG msg = CryptMsgOpenToDecode(
2516 pVerifyPara->dwMsgAndCertEncodingType, 0, CMSG_SIGNED,
2517 pVerifyPara->hCryptProv, NULL, NULL);
2518
2519 if (msg)
2520 {
2521 ret = CryptMsgUpdate(msg, contentInfo->Content.pbData,
2522 contentInfo->Content.cbData, TRUE);
2523 if (ret && pcbDecoded)
2524 ret = CRYPT_CopyParam(pbDecoded, pcbDecoded,
2525 contentInfo->Content.pbData, contentInfo->Content.cbData);
2526 if (ret)
2527 {
2528 CERT_INFO *certInfo = CRYPT_GetSignerCertInfoFromMsg(msg,
2529 dwSignerIndex);
2530
2531 ret = FALSE;
2532 if (certInfo)
2533 {
2534 HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MSG,
2535 pVerifyPara->dwMsgAndCertEncodingType,
2536 pVerifyPara->hCryptProv, 0, msg);
2537
2538 if (store)
2539 {
2540 PCCERT_CONTEXT cert = CRYPT_GetSignerCertificate(
2541 msg, pVerifyPara, certInfo, store);
2542
2543 if (cert)
2544 {
2545 ret = CryptMsgControl(msg, 0,
2546 CMSG_CTRL_VERIFY_SIGNATURE, cert->pCertInfo);
2547 if (ret && ppSignerCert)
2548 *ppSignerCert = cert;
2549 else
2550 CertFreeCertificateContext(cert);
2551 }
2552 CertCloseStore(store, 0);
2553 }
2554 }
2555 CryptMemFree(certInfo);
2556 }
2557 CryptMsgClose(msg);
2558 }
2559 }
2560 LocalFree(contentInfo);
2561 }
2562 TRACE("returning %d\n", ret);
2563 return ret;
2564 }
Windows API implementation