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