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