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