2 * Copyright 2007 Juan Lang
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.
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.
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
20 #include "wine/port.h"
23 #define NONAMELESSUNION
29 #include "wine/debug.h"
30 #include "wine/exception.h"
31 #include "crypt32_private.h"
33 WINE_DEFAULT_DEBUG_CHANNEL(crypt
);
35 /* Called when a message's ref count reaches zero. Free any message-specific
38 typedef void (*CryptMsgCloseFunc
)(HCRYPTMSG msg
);
40 typedef BOOL (*CryptMsgGetParamFunc
)(HCRYPTMSG hCryptMsg
, DWORD dwParamType
,
41 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
);
43 typedef BOOL (*CryptMsgUpdateFunc
)(HCRYPTMSG hCryptMsg
, const BYTE
*pbData
,
44 DWORD cbData
, BOOL fFinal
);
46 typedef BOOL (*CryptMsgControlFunc
)(HCRYPTMSG hCryptMsg
, DWORD dwFlags
,
47 DWORD dwCtrlType
, const void *pvCtrlPara
);
49 static BOOL
CRYPT_DefaultMsgControl(HCRYPTMSG hCryptMsg
, DWORD dwFlags
,
50 DWORD dwCtrlType
, const void *pvCtrlPara
)
52 TRACE("(%p, %08x, %d, %p)\n", hCryptMsg
, dwFlags
, dwCtrlType
, pvCtrlPara
);
53 SetLastError(E_INVALIDARG
);
57 typedef enum _CryptMsgState
{
60 MsgStateDataFinalized
,
64 typedef struct _CryptMsgBase
69 CMSG_STREAM_INFO stream_info
;
71 CryptMsgCloseFunc close
;
72 CryptMsgUpdateFunc update
;
73 CryptMsgGetParamFunc get_param
;
74 CryptMsgControlFunc control
;
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
)
83 msg
->open_flags
= dwFlags
;
87 msg
->stream_info
= *pStreamInfo
;
91 msg
->streamed
= FALSE
;
92 memset(&msg
->stream_info
, 0, sizeof(msg
->stream_info
));
95 msg
->get_param
= get_param
;
97 msg
->control
= control
;
98 msg
->state
= MsgStateInit
;
101 typedef struct _CDataEncodeMsg
104 DWORD bare_content_len
;
108 static const BYTE empty_data_content
[] = { 0x04,0x00 };
110 static void CDataEncodeMsg_Close(HCRYPTMSG hCryptMsg
)
112 CDataEncodeMsg
*msg
= hCryptMsg
;
114 if (msg
->bare_content
!= empty_data_content
)
115 LocalFree(msg
->bare_content
);
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
)
122 DWORD dataLen
= *(DWORD
*)pvStructInfo
;
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.
130 CRYPT_EncodeLen(dataLen
, NULL
, &lenBytes
);
132 *pcbEncoded
= 1 + lenBytes
+ dataLen
;
135 if ((ret
= CRYPT_EncodeEnsureSpace(dwFlags
, pEncodePara
, pbEncoded
,
136 pcbEncoded
, 1 + lenBytes
)))
138 if (dwFlags
& CRYPT_ENCODE_ALLOC_FLAG
)
139 pbEncoded
= *(BYTE
**)pbEncoded
;
140 *pbEncoded
++ = ASN_OCTETSTRING
;
141 CRYPT_EncodeLen(dataLen
, pbEncoded
,
148 static BOOL
CRYPT_EncodeDataContentInfoHeader(const CDataEncodeMsg
*msg
,
149 CRYPT_DATA_BLOB
*header
)
153 if (msg
->base
.streamed
&& msg
->base
.stream_info
.cbContent
== 0xffffffff)
155 static const BYTE headerValue
[] = { 0x30,0x80,0x06,0x09,0x2a,0x86,0x48,
156 0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x80,0x24,0x80 };
158 header
->pbData
= LocalAlloc(0, sizeof(headerValue
));
161 header
->cbData
= sizeof(headerValue
);
162 memcpy(header
->pbData
, headerValue
, sizeof(headerValue
));
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 },
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
);
182 /* Trick: subtract the content length from the reported length,
183 * as the actual content hasn't come yet.
185 header
->cbData
-= msg
->base
.stream_info
.cbContent
;
191 static BOOL
CDataEncodeMsg_Update(HCRYPTMSG hCryptMsg
, const BYTE
*pbData
,
192 DWORD cbData
, BOOL fFinal
)
194 CDataEncodeMsg
*msg
= hCryptMsg
;
197 if (msg
->base
.state
== MsgStateFinalized
)
198 SetLastError(CRYPT_E_MSG_ERROR
);
199 else if (msg
->base
.streamed
)
203 if (msg
->base
.state
!= MsgStateUpdated
)
205 CRYPT_DATA_BLOB header
;
207 ret
= CRYPT_EncodeDataContentInfoHeader(msg
, &header
);
210 ret
= msg
->base
.stream_info
.pfnStreamOutput(
211 msg
->base
.stream_info
.pvArg
, header
.pbData
, header
.cbData
,
213 LocalFree(header
.pbData
);
216 /* Curiously, every indefinite-length streamed update appears to
217 * get its own tag and length, regardless of fFinal.
219 if (msg
->base
.stream_info
.cbContent
== 0xffffffff)
224 ret
= CRYPT_EncodeContentLength(X509_ASN_ENCODING
, NULL
,
225 &cbData
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, (BYTE
*)&header
,
229 ret
= msg
->base
.stream_info
.pfnStreamOutput(
230 msg
->base
.stream_info
.pvArg
, header
, headerLen
,
237 ret
= msg
->base
.stream_info
.pfnStreamOutput(
238 msg
->base
.stream_info
.pvArg
, (BYTE
*)pbData
, cbData
,
240 msg
->base
.state
= MsgStateUpdated
;
244 msg
->base
.state
= MsgStateFinalized
;
245 if (msg
->base
.stream_info
.cbContent
== 0xffffffff)
247 BYTE indefinite_trailer
[6] = { 0 };
249 ret
= msg
->base
.stream_info
.pfnStreamOutput(
250 msg
->base
.stream_info
.pvArg
, (BYTE
*)pbData
, cbData
,
253 ret
= msg
->base
.stream_info
.pfnStreamOutput(
254 msg
->base
.stream_info
.pvArg
, indefinite_trailer
,
255 sizeof(indefinite_trailer
), TRUE
);
258 ret
= msg
->base
.stream_info
.pfnStreamOutput(
259 msg
->base
.stream_info
.pvArg
, (BYTE
*)pbData
, cbData
, TRUE
);
264 SetLastError(STATUS_ACCESS_VIOLATION
);
273 if (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
)
274 SetLastError(E_INVALIDARG
);
276 SetLastError(CRYPT_E_MSG_ERROR
);
280 CRYPT_DATA_BLOB blob
= { cbData
, (LPBYTE
)pbData
};
282 msg
->base
.state
= MsgStateFinalized
;
283 /* non-streamed data messages don't allow non-final updates,
284 * don't bother checking whether data already exist, they can't.
286 ret
= CryptEncodeObjectEx(X509_ASN_ENCODING
, X509_OCTET_STRING
,
287 &blob
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &msg
->bare_content
,
288 &msg
->bare_content_len
);
294 static BOOL
CRYPT_CopyParam(void *pvData
, DWORD
*pcbData
, const void *src
,
301 else if (*pcbData
< len
)
304 SetLastError(ERROR_MORE_DATA
);
310 memcpy(pvData
, src
, len
);
315 static BOOL
CDataEncodeMsg_GetParam(HCRYPTMSG hCryptMsg
, DWORD dwParamType
,
316 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
)
318 CDataEncodeMsg
*msg
= hCryptMsg
;
323 case CMSG_CONTENT_PARAM
:
324 if (msg
->base
.streamed
)
325 SetLastError(E_INVALIDARG
);
328 CRYPT_CONTENT_INFO info
;
329 char rsa_data
[] = "1.2.840.113549.1.7.1";
331 info
.pszObjId
= rsa_data
;
332 info
.Content
.cbData
= msg
->bare_content_len
;
333 info
.Content
.pbData
= msg
->bare_content
;
334 ret
= CryptEncodeObject(X509_ASN_ENCODING
, PKCS_CONTENT_INFO
, &info
,
338 case CMSG_BARE_CONTENT_PARAM
:
339 if (msg
->base
.streamed
)
340 SetLastError(E_INVALIDARG
);
342 ret
= CRYPT_CopyParam(pvData
, pcbData
, msg
->bare_content
,
343 msg
->bare_content_len
);
346 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
351 static HCRYPTMSG
CDataEncodeMsg_Open(DWORD dwFlags
, const void *pvMsgEncodeInfo
,
352 LPSTR pszInnerContentObjID
, PCMSG_STREAM_INFO pStreamInfo
)
358 SetLastError(E_INVALIDARG
);
361 msg
= CryptMemAlloc(sizeof(CDataEncodeMsg
));
364 CryptMsgBase_Init((CryptMsgBase
*)msg
, dwFlags
, pStreamInfo
,
365 CDataEncodeMsg_Close
, CDataEncodeMsg_GetParam
, CDataEncodeMsg_Update
,
366 CRYPT_DefaultMsgControl
);
367 msg
->bare_content_len
= sizeof(empty_data_content
);
368 msg
->bare_content
= (LPBYTE
)empty_data_content
;
373 typedef struct _CHashEncodeMsg
378 CRYPT_DATA_BLOB data
;
381 static void CHashEncodeMsg_Close(HCRYPTMSG hCryptMsg
)
383 CHashEncodeMsg
*msg
= hCryptMsg
;
385 CryptMemFree(msg
->data
.pbData
);
386 CryptDestroyHash(msg
->hash
);
387 if (msg
->base
.open_flags
& CMSG_CRYPT_RELEASE_CONTEXT_FLAG
)
388 CryptReleaseContext(msg
->prov
, 0);
391 static BOOL
CRYPT_EncodePKCSDigestedData(CHashEncodeMsg
*msg
, void *pvData
,
396 DWORD size
= sizeof(algID
);
398 ret
= CryptGetHashParam(msg
->hash
, HP_ALGID
, (BYTE
*)&algID
, &size
, 0);
401 CRYPT_DIGESTED_DATA digestedData
= { 0 };
402 char oid_rsa_data
[] = szOID_RSA_data
;
404 digestedData
.version
= CMSG_HASHED_DATA_PKCS_1_5_VERSION
;
405 digestedData
.DigestAlgorithm
.pszObjId
= (LPSTR
)CertAlgIdToOID(algID
);
406 /* FIXME: what about digestedData.DigestAlgorithm.Parameters? */
407 /* Quirk: OID is only encoded messages if an update has happened */
408 if (msg
->base
.state
!= MsgStateInit
)
409 digestedData
.ContentInfo
.pszObjId
= oid_rsa_data
;
410 if (!(msg
->base
.open_flags
& CMSG_DETACHED_FLAG
) && msg
->data
.cbData
)
412 ret
= CRYPT_AsnEncodeOctets(0, NULL
, &msg
->data
,
413 CRYPT_ENCODE_ALLOC_FLAG
, NULL
,
414 (LPBYTE
)&digestedData
.ContentInfo
.Content
.pbData
,
415 &digestedData
.ContentInfo
.Content
.cbData
);
417 if (msg
->base
.state
== MsgStateFinalized
)
419 size
= sizeof(DWORD
);
420 ret
= CryptGetHashParam(msg
->hash
, HP_HASHSIZE
,
421 (LPBYTE
)&digestedData
.hash
.cbData
, &size
, 0);
424 digestedData
.hash
.pbData
= CryptMemAlloc(
425 digestedData
.hash
.cbData
);
426 ret
= CryptGetHashParam(msg
->hash
, HP_HASHVAL
,
427 digestedData
.hash
.pbData
, &digestedData
.hash
.cbData
, 0);
431 ret
= CRYPT_AsnEncodePKCSDigestedData(&digestedData
, pvData
,
433 CryptMemFree(digestedData
.hash
.pbData
);
434 LocalFree(digestedData
.ContentInfo
.Content
.pbData
);
439 static BOOL
CHashEncodeMsg_GetParam(HCRYPTMSG hCryptMsg
, DWORD dwParamType
,
440 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
)
442 CHashEncodeMsg
*msg
= hCryptMsg
;
445 TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg
, dwParamType
, dwIndex
,
450 case CMSG_BARE_CONTENT_PARAM
:
451 if (msg
->base
.streamed
)
452 SetLastError(E_INVALIDARG
);
454 ret
= CRYPT_EncodePKCSDigestedData(msg
, pvData
, pcbData
);
456 case CMSG_CONTENT_PARAM
:
458 CRYPT_CONTENT_INFO info
;
460 ret
= CryptMsgGetParam(hCryptMsg
, CMSG_BARE_CONTENT_PARAM
, 0, NULL
,
461 &info
.Content
.cbData
);
464 info
.Content
.pbData
= CryptMemAlloc(info
.Content
.cbData
);
465 if (info
.Content
.pbData
)
467 ret
= CryptMsgGetParam(hCryptMsg
, CMSG_BARE_CONTENT_PARAM
, 0,
468 info
.Content
.pbData
, &info
.Content
.cbData
);
471 char oid_rsa_hashed
[] = szOID_RSA_hashedData
;
473 info
.pszObjId
= oid_rsa_hashed
;
474 ret
= CryptEncodeObjectEx(X509_ASN_ENCODING
,
475 PKCS_CONTENT_INFO
, &info
, 0, NULL
, pvData
, pcbData
);
477 CryptMemFree(info
.Content
.pbData
);
484 case CMSG_COMPUTED_HASH_PARAM
:
485 ret
= CryptGetHashParam(msg
->hash
, HP_HASHVAL
, pvData
, pcbData
, 0);
487 case CMSG_VERSION_PARAM
:
488 if (msg
->base
.state
!= MsgStateFinalized
)
489 SetLastError(CRYPT_E_MSG_ERROR
);
492 DWORD version
= CMSG_HASHED_DATA_PKCS_1_5_VERSION
;
494 /* Since the data are always encoded as octets, the version is
495 * always 0 (see rfc3852, section 7)
497 ret
= CRYPT_CopyParam(pvData
, pcbData
, &version
, sizeof(version
));
501 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
506 static BOOL
CHashEncodeMsg_Update(HCRYPTMSG hCryptMsg
, const BYTE
*pbData
,
507 DWORD cbData
, BOOL fFinal
)
509 CHashEncodeMsg
*msg
= hCryptMsg
;
512 TRACE("(%p, %p, %d, %d)\n", hCryptMsg
, pbData
, cbData
, fFinal
);
514 if (msg
->base
.state
== MsgStateFinalized
)
515 SetLastError(CRYPT_E_MSG_ERROR
);
516 else if (msg
->base
.streamed
|| (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
))
518 /* Doesn't do much, as stream output is never called, and you
519 * can't get the content.
521 ret
= CryptHashData(msg
->hash
, pbData
, cbData
, 0);
522 msg
->base
.state
= fFinal
? MsgStateFinalized
: MsgStateUpdated
;
527 SetLastError(CRYPT_E_MSG_ERROR
);
530 ret
= CryptHashData(msg
->hash
, pbData
, cbData
, 0);
533 msg
->data
.pbData
= CryptMemAlloc(cbData
);
534 if (msg
->data
.pbData
)
536 memcpy(msg
->data
.pbData
+ msg
->data
.cbData
, pbData
, cbData
);
537 msg
->data
.cbData
+= cbData
;
542 msg
->base
.state
= MsgStateFinalized
;
548 static HCRYPTMSG
CHashEncodeMsg_Open(DWORD dwFlags
, const void *pvMsgEncodeInfo
,
549 LPSTR pszInnerContentObjID
, PCMSG_STREAM_INFO pStreamInfo
)
552 const CMSG_HASHED_ENCODE_INFO
*info
= pvMsgEncodeInfo
;
556 if (info
->cbSize
!= sizeof(CMSG_HASHED_ENCODE_INFO
))
558 SetLastError(E_INVALIDARG
);
561 if (!(algID
= CertOIDToAlgId(info
->HashAlgorithm
.pszObjId
)))
563 SetLastError(CRYPT_E_UNKNOWN_ALGO
);
566 if (info
->hCryptProv
)
567 prov
= info
->hCryptProv
;
570 prov
= CRYPT_GetDefaultProvider();
571 dwFlags
&= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG
;
573 msg
= CryptMemAlloc(sizeof(CHashEncodeMsg
));
576 CryptMsgBase_Init((CryptMsgBase
*)msg
, dwFlags
, pStreamInfo
,
577 CHashEncodeMsg_Close
, CHashEncodeMsg_GetParam
, CHashEncodeMsg_Update
,
578 CRYPT_DefaultMsgControl
);
580 msg
->data
.cbData
= 0;
581 msg
->data
.pbData
= NULL
;
582 if (!CryptCreateHash(prov
, algID
, 0, 0, &msg
->hash
))
591 typedef struct _CMSG_SIGNER_ENCODE_INFO_WITH_CMS
594 PCERT_INFO pCertInfo
;
595 HCRYPTPROV hCryptProv
;
597 CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm
;
600 PCRYPT_ATTRIBUTE rgAuthAttr
;
602 PCRYPT_ATTRIBUTE rgUnauthAttr
;
604 CRYPT_ALGORITHM_IDENTIFIER HashEncryptionAlgorithm
;
605 void *pvHashEncryptionAuxInfo
;
606 } CMSG_SIGNER_ENCODE_INFO_WITH_CMS
, *PCMSG_SIGNER_ENCODE_INFO_WITH_CMS
;
608 typedef struct _CMSG_SIGNED_ENCODE_INFO_WITH_CMS
612 PCMSG_SIGNER_ENCODE_INFO_WITH_CMS rgSigners
;
614 PCERT_BLOB rgCertEncoded
;
616 PCRL_BLOB rgCrlEncoded
;
617 DWORD cAttrCertEncoded
;
618 PCERT_BLOB rgAttrCertEncoded
;
619 } CMSG_SIGNED_ENCODE_INFO_WITH_CMS
, *PCMSG_SIGNED_ENCODE_INFO_WITH_CMS
;
621 static BOOL
CRYPT_IsValidSigner(const CMSG_SIGNER_ENCODE_INFO_WITH_CMS
*signer
)
623 if (signer
->cbSize
!= sizeof(CMSG_SIGNER_ENCODE_INFO
) &&
624 signer
->cbSize
!= sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS
))
626 SetLastError(E_INVALIDARG
);
629 if (signer
->cbSize
== sizeof(CMSG_SIGNER_ENCODE_INFO
))
631 if (!signer
->pCertInfo
->SerialNumber
.cbData
)
633 SetLastError(E_INVALIDARG
);
636 if (!signer
->pCertInfo
->Issuer
.cbData
)
638 SetLastError(E_INVALIDARG
);
642 else if (signer
->cbSize
== sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS
))
644 switch (signer
->SignerId
.dwIdChoice
)
647 if (!signer
->pCertInfo
->SerialNumber
.cbData
)
649 SetLastError(E_INVALIDARG
);
652 if (!signer
->pCertInfo
->Issuer
.cbData
)
654 SetLastError(E_INVALIDARG
);
658 case CERT_ID_ISSUER_SERIAL_NUMBER
:
659 if (!signer
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
.cbData
)
661 SetLastError(E_INVALIDARG
);
664 if (!signer
->SignerId
.u
.IssuerSerialNumber
.Issuer
.cbData
)
666 SetLastError(E_INVALIDARG
);
670 case CERT_ID_KEY_IDENTIFIER
:
671 if (!signer
->SignerId
.u
.KeyId
.cbData
)
673 SetLastError(E_INVALIDARG
);
678 SetLastError(E_INVALIDARG
);
680 if (signer
->HashEncryptionAlgorithm
.pszObjId
)
682 FIXME("CMSG_SIGNER_ENCODE_INFO with CMS fields unsupported\n");
686 if (!signer
->hCryptProv
)
688 SetLastError(E_INVALIDARG
);
691 if (!CertOIDToAlgId(signer
->HashAlgorithm
.pszObjId
))
693 SetLastError(CRYPT_E_UNKNOWN_ALGO
);
699 static BOOL
CRYPT_ConstructBlob(CRYPT_DATA_BLOB
*out
, const CRYPT_DATA_BLOB
*in
)
703 out
->cbData
= in
->cbData
;
706 out
->pbData
= CryptMemAlloc(out
->cbData
);
708 memcpy(out
->pbData
, in
->pbData
, out
->cbData
);
717 static BOOL
CRYPT_ConstructBlobArray(DWORD
*outCBlobs
,
718 PCRYPT_DATA_BLOB
*outPBlobs
, DWORD cBlobs
, const CRYPT_DATA_BLOB
*pBlobs
)
725 *outPBlobs
= CryptMemAlloc(cBlobs
* sizeof(CRYPT_DATA_BLOB
));
730 memset(*outPBlobs
, 0, cBlobs
* sizeof(CRYPT_DATA_BLOB
));
731 for (i
= 0; ret
&& i
< cBlobs
; i
++)
732 ret
= CRYPT_ConstructBlob(&(*outPBlobs
)[i
], &pBlobs
[i
]);
740 static void CRYPT_FreeBlobArray(DWORD cBlobs
, PCRYPT_DATA_BLOB blobs
)
744 for (i
= 0; i
< cBlobs
; i
++)
745 CryptMemFree(blobs
[i
].pbData
);
749 static BOOL
CRYPT_ConstructAttribute(CRYPT_ATTRIBUTE
*out
,
750 const CRYPT_ATTRIBUTE
*in
)
754 out
->pszObjId
= CryptMemAlloc(strlen(in
->pszObjId
) + 1);
757 strcpy(out
->pszObjId
, in
->pszObjId
);
758 ret
= CRYPT_ConstructBlobArray(&out
->cValue
, &out
->rgValue
,
759 in
->cValue
, in
->rgValue
);
766 static BOOL
CRYPT_ConstructAttributes(CRYPT_ATTRIBUTES
*out
,
767 const CRYPT_ATTRIBUTES
*in
)
771 out
->cAttr
= in
->cAttr
;
774 out
->rgAttr
= CryptMemAlloc(out
->cAttr
* sizeof(CRYPT_ATTRIBUTE
));
779 memset(out
->rgAttr
, 0, out
->cAttr
* sizeof(CRYPT_ATTRIBUTE
));
780 for (i
= 0; ret
&& i
< out
->cAttr
; i
++)
781 ret
= CRYPT_ConstructAttribute(&out
->rgAttr
[i
], &in
->rgAttr
[i
]);
791 /* Constructs a CMSG_CMS_SIGNER_INFO from a CMSG_SIGNER_ENCODE_INFO_WITH_CMS. */
792 static BOOL
CSignerInfo_Construct(CMSG_CMS_SIGNER_INFO
*info
,
793 const CMSG_SIGNER_ENCODE_INFO_WITH_CMS
*in
)
797 if (in
->cbSize
== sizeof(CMSG_SIGNER_ENCODE_INFO
))
799 info
->dwVersion
= CMSG_SIGNER_INFO_V1
;
800 ret
= CRYPT_ConstructBlob(&info
->SignerId
.u
.IssuerSerialNumber
.Issuer
,
801 &in
->pCertInfo
->Issuer
);
803 ret
= CRYPT_ConstructBlob(
804 &info
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
,
805 &in
->pCertInfo
->SerialNumber
);
806 info
->SignerId
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
807 info
->HashEncryptionAlgorithm
.pszObjId
=
808 in
->pCertInfo
->SubjectPublicKeyInfo
.Algorithm
.pszObjId
;
810 ret
= CRYPT_ConstructBlob(&info
->HashEncryptionAlgorithm
.Parameters
,
811 &in
->pCertInfo
->SubjectPublicKeyInfo
.Algorithm
.Parameters
);
815 const CRYPT_ALGORITHM_IDENTIFIER
*pEncrAlg
;
817 /* Implicitly in->cbSize == sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS).
818 * See CRYPT_IsValidSigner.
820 if (!in
->SignerId
.dwIdChoice
)
822 info
->dwVersion
= CMSG_SIGNER_INFO_V1
;
823 ret
= CRYPT_ConstructBlob(&info
->SignerId
.u
.IssuerSerialNumber
.Issuer
,
824 &in
->pCertInfo
->Issuer
);
826 ret
= CRYPT_ConstructBlob(
827 &info
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
,
828 &in
->pCertInfo
->SerialNumber
);
829 info
->SignerId
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
831 else if (in
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
)
833 info
->dwVersion
= CMSG_SIGNER_INFO_V1
;
834 info
->SignerId
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
835 ret
= CRYPT_ConstructBlob(&info
->SignerId
.u
.IssuerSerialNumber
.Issuer
,
836 &in
->SignerId
.u
.IssuerSerialNumber
.Issuer
);
838 ret
= CRYPT_ConstructBlob(
839 &info
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
,
840 &in
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
);
844 /* Implicitly dwIdChoice == CERT_ID_KEY_IDENTIFIER */
845 info
->dwVersion
= CMSG_SIGNER_INFO_V3
;
846 info
->SignerId
.dwIdChoice
= CERT_ID_KEY_IDENTIFIER
;
847 ret
= CRYPT_ConstructBlob(&info
->SignerId
.u
.KeyId
,
848 &in
->SignerId
.u
.KeyId
);
850 pEncrAlg
= in
->HashEncryptionAlgorithm
.pszObjId
?
851 &in
->HashEncryptionAlgorithm
:
852 &in
->pCertInfo
->SubjectPublicKeyInfo
.Algorithm
;
853 info
->HashEncryptionAlgorithm
.pszObjId
= pEncrAlg
->pszObjId
;
855 ret
= CRYPT_ConstructBlob(&info
->HashEncryptionAlgorithm
.Parameters
,
856 &pEncrAlg
->Parameters
);
858 /* Assumption: algorithm IDs will point to static strings, not
859 * stack-based ones, so copying the pointer values is safe.
861 info
->HashAlgorithm
.pszObjId
= in
->HashAlgorithm
.pszObjId
;
863 ret
= CRYPT_ConstructBlob(&info
->HashAlgorithm
.Parameters
,
864 &in
->HashAlgorithm
.Parameters
);
866 ret
= CRYPT_ConstructAttributes(&info
->AuthAttrs
,
867 (CRYPT_ATTRIBUTES
*)&in
->cAuthAttr
);
869 ret
= CRYPT_ConstructAttributes(&info
->UnauthAttrs
,
870 (CRYPT_ATTRIBUTES
*)&in
->cUnauthAttr
);
874 static void CSignerInfo_Free(CMSG_CMS_SIGNER_INFO
*info
)
878 if (info
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
)
880 CryptMemFree(info
->SignerId
.u
.IssuerSerialNumber
.Issuer
.pbData
);
881 CryptMemFree(info
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
.pbData
);
884 CryptMemFree(info
->SignerId
.u
.KeyId
.pbData
);
885 CryptMemFree(info
->HashAlgorithm
.Parameters
.pbData
);
886 CryptMemFree(info
->HashEncryptionAlgorithm
.Parameters
.pbData
);
887 CryptMemFree(info
->EncryptedHash
.pbData
);
888 for (i
= 0; i
< info
->AuthAttrs
.cAttr
; i
++)
890 for (j
= 0; j
< info
->AuthAttrs
.rgAttr
[i
].cValue
; j
++)
891 CryptMemFree(info
->AuthAttrs
.rgAttr
[i
].rgValue
[j
].pbData
);
892 CryptMemFree(info
->AuthAttrs
.rgAttr
[i
].rgValue
);
893 CryptMemFree(info
->AuthAttrs
.rgAttr
[i
].pszObjId
);
895 CryptMemFree(info
->AuthAttrs
.rgAttr
);
896 for (i
= 0; i
< info
->UnauthAttrs
.cAttr
; i
++)
898 for (j
= 0; j
< info
->UnauthAttrs
.rgAttr
[i
].cValue
; j
++)
899 CryptMemFree(info
->UnauthAttrs
.rgAttr
[i
].rgValue
[j
].pbData
);
900 CryptMemFree(info
->UnauthAttrs
.rgAttr
[i
].rgValue
);
901 CryptMemFree(info
->UnauthAttrs
.rgAttr
[i
].pszObjId
);
903 CryptMemFree(info
->UnauthAttrs
.rgAttr
);
906 typedef struct _CSignerHandles
908 HCRYPTHASH contentHash
;
909 HCRYPTHASH authAttrHash
;
912 typedef struct _CSignedMsgData
914 CRYPT_SIGNED_INFO
*info
;
916 CSignerHandles
*signerHandles
;
919 /* Constructs the signer handles for the signerIndex'th signer of msg_data.
920 * Assumes signerIndex is a valid idnex, and that msg_data's info has already
923 static BOOL
CSignedMsgData_ConstructSignerHandles(CSignedMsgData
*msg_data
,
924 DWORD signerIndex
, HCRYPTPROV crypt_prov
)
929 algID
= CertOIDToAlgId(
930 msg_data
->info
->rgSignerInfo
[signerIndex
].HashAlgorithm
.pszObjId
);
931 ret
= CryptCreateHash(crypt_prov
, algID
, 0, 0,
932 &msg_data
->signerHandles
->contentHash
);
933 if (ret
&& msg_data
->info
->rgSignerInfo
[signerIndex
].AuthAttrs
.cAttr
> 0)
934 ret
= CryptCreateHash(crypt_prov
, algID
, 0, 0,
935 &msg_data
->signerHandles
->authAttrHash
);
939 /* Allocates a CSignedMsgData's handles. Assumes its info has already been
942 static BOOL
CSignedMsgData_AllocateHandles(CSignedMsgData
*msg_data
)
946 if (msg_data
->info
->cSignerInfo
)
948 msg_data
->signerHandles
=
949 CryptMemAlloc(msg_data
->info
->cSignerInfo
* sizeof(CSignerHandles
));
950 if (msg_data
->signerHandles
)
952 msg_data
->cSignerHandle
= msg_data
->info
->cSignerInfo
;
953 memset(msg_data
->signerHandles
, 0,
954 msg_data
->info
->cSignerInfo
* sizeof(CSignerHandles
));
958 msg_data
->cSignerHandle
= 0;
964 msg_data
->cSignerHandle
= 0;
965 msg_data
->signerHandles
= NULL
;
970 static void CSignedMsgData_CloseHandles(CSignedMsgData
*msg_data
)
974 for (i
= 0; i
< msg_data
->cSignerHandle
; i
++)
976 if (msg_data
->signerHandles
[i
].contentHash
)
977 CryptDestroyHash(msg_data
->signerHandles
[i
].contentHash
);
978 if (msg_data
->signerHandles
[i
].authAttrHash
)
979 CryptDestroyHash(msg_data
->signerHandles
[i
].authAttrHash
);
981 CryptMemFree(msg_data
->signerHandles
);
982 msg_data
->signerHandles
= NULL
;
983 msg_data
->cSignerHandle
= 0;
986 static BOOL
CSignedMsgData_UpdateHash(CSignedMsgData
*msg_data
,
987 const BYTE
*pbData
, DWORD cbData
)
992 for (i
= 0; ret
&& i
< msg_data
->cSignerHandle
; i
++)
993 ret
= CryptHashData(msg_data
->signerHandles
[i
].contentHash
, pbData
,
998 static BOOL
CRYPT_AppendAttribute(CRYPT_ATTRIBUTES
*out
,
999 const CRYPT_ATTRIBUTE
*in
)
1003 out
->rgAttr
= CryptMemRealloc(out
->rgAttr
,
1004 (out
->cAttr
+ 1) * sizeof(CRYPT_ATTRIBUTE
));
1007 ret
= CRYPT_ConstructAttribute(&out
->rgAttr
[out
->cAttr
], in
);
1014 static BOOL
CSignedMsgData_AppendMessageDigestAttribute(
1015 CSignedMsgData
*msg_data
, DWORD signerIndex
)
1019 CRYPT_HASH_BLOB hash
= { 0, NULL
}, encodedHash
= { 0, NULL
};
1020 char messageDigest
[] = szOID_RSA_messageDigest
;
1021 CRYPT_ATTRIBUTE messageDigestAttr
= { messageDigest
, 1, &encodedHash
};
1023 size
= sizeof(DWORD
);
1024 ret
= CryptGetHashParam(
1025 msg_data
->signerHandles
[signerIndex
].contentHash
, HP_HASHSIZE
,
1026 (LPBYTE
)&hash
.cbData
, &size
, 0);
1029 hash
.pbData
= CryptMemAlloc(hash
.cbData
);
1030 ret
= CryptGetHashParam(
1031 msg_data
->signerHandles
[signerIndex
].contentHash
, HP_HASHVAL
,
1032 hash
.pbData
, &hash
.cbData
, 0);
1035 ret
= CRYPT_AsnEncodeOctets(0, NULL
, &hash
, CRYPT_ENCODE_ALLOC_FLAG
,
1036 NULL
, (LPBYTE
)&encodedHash
.pbData
, &encodedHash
.cbData
);
1039 ret
= CRYPT_AppendAttribute(
1040 &msg_data
->info
->rgSignerInfo
[signerIndex
].AuthAttrs
,
1041 &messageDigestAttr
);
1042 LocalFree(encodedHash
.pbData
);
1045 CryptMemFree(hash
.pbData
);
1055 static BOOL
CSignedMsgData_UpdateAuthenticatedAttributes(
1056 CSignedMsgData
*msg_data
, SignOrVerify flag
)
1061 TRACE("(%p)\n", msg_data
);
1063 for (i
= 0; ret
&& i
< msg_data
->info
->cSignerInfo
; i
++)
1065 if (msg_data
->info
->rgSignerInfo
[i
].AuthAttrs
.cAttr
)
1069 BYTE oid_rsa_data_encoded
[] = { 0x06,0x09,0x2a,0x86,0x48,0x86,
1070 0xf7,0x0d,0x01,0x07,0x01 };
1071 CRYPT_DATA_BLOB content
= { sizeof(oid_rsa_data_encoded
),
1072 oid_rsa_data_encoded
};
1073 char contentType
[] = szOID_RSA_contentType
;
1074 CRYPT_ATTRIBUTE contentTypeAttr
= { contentType
, 1, &content
};
1076 /* FIXME: does this depend on inner OID? */
1077 ret
= CRYPT_AppendAttribute(
1078 &msg_data
->info
->rgSignerInfo
[i
].AuthAttrs
, &contentTypeAttr
);
1080 ret
= CSignedMsgData_AppendMessageDigestAttribute(msg_data
,
1085 LPBYTE encodedAttrs
;
1088 ret
= CryptEncodeObjectEx(X509_ASN_ENCODING
, PKCS_ATTRIBUTES
,
1089 &msg_data
->info
->rgSignerInfo
[i
].AuthAttrs
,
1090 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &encodedAttrs
, &size
);
1093 ret
= CryptHashData(
1094 msg_data
->signerHandles
[i
].authAttrHash
, encodedAttrs
,
1096 LocalFree(encodedAttrs
);
1101 TRACE("returning %d\n", ret
);
1105 static void CRYPT_ReverseBytes(CRYPT_HASH_BLOB
*hash
)
1110 for (i
= 0; i
< hash
->cbData
/ 2; i
++)
1112 tmp
= hash
->pbData
[hash
->cbData
- i
- 1];
1113 hash
->pbData
[hash
->cbData
- i
- 1] = hash
->pbData
[i
];
1114 hash
->pbData
[i
] = tmp
;
1118 static BOOL
CSignedMsgData_Sign(CSignedMsgData
*msg_data
)
1123 TRACE("(%p)\n", msg_data
);
1125 for (i
= 0; ret
&& i
< msg_data
->info
->cSignerInfo
; i
++)
1129 if (msg_data
->info
->rgSignerInfo
[i
].AuthAttrs
.cAttr
)
1130 hash
= msg_data
->signerHandles
[i
].authAttrHash
;
1132 hash
= msg_data
->signerHandles
[i
].contentHash
;
1133 ret
= CryptSignHashW(hash
, AT_SIGNATURE
, NULL
, 0, NULL
,
1134 &msg_data
->info
->rgSignerInfo
[i
].EncryptedHash
.cbData
);
1137 msg_data
->info
->rgSignerInfo
[i
].EncryptedHash
.pbData
=
1139 msg_data
->info
->rgSignerInfo
[i
].EncryptedHash
.cbData
);
1140 if (msg_data
->info
->rgSignerInfo
[i
].EncryptedHash
.pbData
)
1142 ret
= CryptSignHashW(hash
, AT_SIGNATURE
, NULL
, 0,
1143 msg_data
->info
->rgSignerInfo
[i
].EncryptedHash
.pbData
,
1144 &msg_data
->info
->rgSignerInfo
[i
].EncryptedHash
.cbData
);
1147 &msg_data
->info
->rgSignerInfo
[i
].EncryptedHash
);
1156 static BOOL
CSignedMsgData_Update(CSignedMsgData
*msg_data
,
1157 const BYTE
*pbData
, DWORD cbData
, BOOL fFinal
, SignOrVerify flag
)
1159 BOOL ret
= CSignedMsgData_UpdateHash(msg_data
, pbData
, cbData
);
1163 ret
= CSignedMsgData_UpdateAuthenticatedAttributes(msg_data
, flag
);
1164 if (ret
&& flag
== Sign
)
1165 ret
= CSignedMsgData_Sign(msg_data
);
1170 typedef struct _CSignedEncodeMsg
1174 CRYPT_DATA_BLOB data
;
1175 CSignedMsgData msg_data
;
1178 static void CSignedEncodeMsg_Close(HCRYPTMSG hCryptMsg
)
1180 CSignedEncodeMsg
*msg
= hCryptMsg
;
1183 CryptMemFree(msg
->innerOID
);
1184 CryptMemFree(msg
->data
.pbData
);
1185 CRYPT_FreeBlobArray(msg
->msg_data
.info
->cCertEncoded
,
1186 msg
->msg_data
.info
->rgCertEncoded
);
1187 CRYPT_FreeBlobArray(msg
->msg_data
.info
->cCrlEncoded
,
1188 msg
->msg_data
.info
->rgCrlEncoded
);
1189 for (i
= 0; i
< msg
->msg_data
.info
->cSignerInfo
; i
++)
1190 CSignerInfo_Free(&msg
->msg_data
.info
->rgSignerInfo
[i
]);
1191 CSignedMsgData_CloseHandles(&msg
->msg_data
);
1192 CryptMemFree(msg
->msg_data
.info
->rgSignerInfo
);
1193 CryptMemFree(msg
->msg_data
.info
);
1196 static BOOL
CSignedEncodeMsg_GetParam(HCRYPTMSG hCryptMsg
, DWORD dwParamType
,
1197 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
)
1199 CSignedEncodeMsg
*msg
= hCryptMsg
;
1202 switch (dwParamType
)
1204 case CMSG_CONTENT_PARAM
:
1206 CRYPT_CONTENT_INFO info
;
1208 ret
= CryptMsgGetParam(hCryptMsg
, CMSG_BARE_CONTENT_PARAM
, 0, NULL
,
1209 &info
.Content
.cbData
);
1212 info
.Content
.pbData
= CryptMemAlloc(info
.Content
.cbData
);
1213 if (info
.Content
.pbData
)
1215 ret
= CryptMsgGetParam(hCryptMsg
, CMSG_BARE_CONTENT_PARAM
, 0,
1216 info
.Content
.pbData
, &info
.Content
.cbData
);
1219 char oid_rsa_signed
[] = szOID_RSA_signedData
;
1221 info
.pszObjId
= oid_rsa_signed
;
1222 ret
= CryptEncodeObjectEx(X509_ASN_ENCODING
,
1223 PKCS_CONTENT_INFO
, &info
, 0, NULL
, pvData
, pcbData
);
1225 CryptMemFree(info
.Content
.pbData
);
1232 case CMSG_BARE_CONTENT_PARAM
:
1234 CRYPT_SIGNED_INFO info
;
1235 BOOL freeContent
= FALSE
;
1237 info
= *msg
->msg_data
.info
;
1238 if (!msg
->innerOID
|| !strcmp(msg
->innerOID
, szOID_RSA_data
))
1240 char oid_rsa_data
[] = szOID_RSA_data
;
1242 /* Quirk: OID is only encoded messages if an update has happened */
1243 if (msg
->base
.state
!= MsgStateInit
)
1244 info
.content
.pszObjId
= oid_rsa_data
;
1246 info
.content
.pszObjId
= NULL
;
1247 if (msg
->data
.cbData
)
1249 CRYPT_DATA_BLOB blob
= { msg
->data
.cbData
, msg
->data
.pbData
};
1251 ret
= CryptEncodeObjectEx(X509_ASN_ENCODING
, X509_OCTET_STRING
,
1252 &blob
, CRYPT_ENCODE_ALLOC_FLAG
, NULL
,
1253 &info
.content
.Content
.pbData
, &info
.content
.Content
.cbData
);
1258 info
.content
.Content
.cbData
= 0;
1259 info
.content
.Content
.pbData
= NULL
;
1265 info
.content
.pszObjId
= msg
->innerOID
;
1266 info
.content
.Content
.cbData
= msg
->data
.cbData
;
1267 info
.content
.Content
.pbData
= msg
->data
.pbData
;
1272 ret
= CRYPT_AsnEncodeCMSSignedInfo(&info
, pvData
, pcbData
);
1274 LocalFree(info
.content
.Content
.pbData
);
1278 case CMSG_COMPUTED_HASH_PARAM
:
1279 if (dwIndex
>= msg
->msg_data
.cSignerHandle
)
1280 SetLastError(CRYPT_E_INVALID_INDEX
);
1282 ret
= CryptGetHashParam(
1283 msg
->msg_data
.signerHandles
[dwIndex
].contentHash
, HP_HASHVAL
,
1284 pvData
, pcbData
, 0);
1286 case CMSG_ENCODED_SIGNER
:
1287 if (dwIndex
>= msg
->msg_data
.info
->cSignerInfo
)
1288 SetLastError(CRYPT_E_INVALID_INDEX
);
1290 ret
= CryptEncodeObjectEx(X509_ASN_ENCODING
| PKCS_7_ASN_ENCODING
,
1291 CMS_SIGNER_INFO
, &msg
->msg_data
.info
->rgSignerInfo
[dwIndex
], 0,
1292 NULL
, pvData
, pcbData
);
1294 case CMSG_VERSION_PARAM
:
1295 ret
= CRYPT_CopyParam(pvData
, pcbData
, &msg
->msg_data
.info
->version
,
1296 sizeof(msg
->msg_data
.info
->version
));
1299 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
1304 static BOOL
CSignedEncodeMsg_Update(HCRYPTMSG hCryptMsg
, const BYTE
*pbData
,
1305 DWORD cbData
, BOOL fFinal
)
1307 CSignedEncodeMsg
*msg
= hCryptMsg
;
1310 if (msg
->base
.state
== MsgStateFinalized
)
1311 SetLastError(CRYPT_E_MSG_ERROR
);
1312 else if (msg
->base
.streamed
|| (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
))
1314 ret
= CSignedMsgData_Update(&msg
->msg_data
, pbData
, cbData
, fFinal
,
1316 if (msg
->base
.streamed
)
1317 FIXME("streamed partial stub\n");
1318 msg
->base
.state
= fFinal
? MsgStateFinalized
: MsgStateUpdated
;
1323 SetLastError(CRYPT_E_MSG_ERROR
);
1328 msg
->data
.pbData
= CryptMemAlloc(cbData
);
1329 if (msg
->data
.pbData
)
1331 memcpy(msg
->data
.pbData
, pbData
, cbData
);
1332 msg
->data
.cbData
= cbData
;
1339 ret
= CSignedMsgData_Update(&msg
->msg_data
, pbData
, cbData
,
1341 msg
->base
.state
= MsgStateFinalized
;
1347 static HCRYPTMSG
CSignedEncodeMsg_Open(DWORD dwFlags
,
1348 const void *pvMsgEncodeInfo
, LPCSTR pszInnerContentObjID
,
1349 PCMSG_STREAM_INFO pStreamInfo
)
1351 const CMSG_SIGNED_ENCODE_INFO_WITH_CMS
*info
= pvMsgEncodeInfo
;
1353 CSignedEncodeMsg
*msg
;
1355 if (info
->cbSize
!= sizeof(CMSG_SIGNED_ENCODE_INFO
) &&
1356 info
->cbSize
!= sizeof(CMSG_SIGNED_ENCODE_INFO_WITH_CMS
))
1358 SetLastError(E_INVALIDARG
);
1361 if (info
->cbSize
== sizeof(CMSG_SIGNED_ENCODE_INFO_WITH_CMS
) &&
1362 info
->cAttrCertEncoded
)
1364 FIXME("CMSG_SIGNED_ENCODE_INFO with CMS fields unsupported\n");
1367 for (i
= 0; i
< info
->cSigners
; i
++)
1368 if (!CRYPT_IsValidSigner(&info
->rgSigners
[i
]))
1370 msg
= CryptMemAlloc(sizeof(CSignedEncodeMsg
));
1375 CryptMsgBase_Init((CryptMsgBase
*)msg
, dwFlags
, pStreamInfo
,
1376 CSignedEncodeMsg_Close
, CSignedEncodeMsg_GetParam
,
1377 CSignedEncodeMsg_Update
, CRYPT_DefaultMsgControl
);
1378 if (pszInnerContentObjID
)
1380 msg
->innerOID
= CryptMemAlloc(strlen(pszInnerContentObjID
) + 1);
1382 strcpy(msg
->innerOID
, pszInnerContentObjID
);
1387 msg
->innerOID
= NULL
;
1388 msg
->data
.cbData
= 0;
1389 msg
->data
.pbData
= NULL
;
1391 msg
->msg_data
.info
= CryptMemAlloc(sizeof(CRYPT_SIGNED_INFO
));
1393 msg
->msg_data
.info
= NULL
;
1394 if (msg
->msg_data
.info
)
1396 memset(msg
->msg_data
.info
, 0, sizeof(CRYPT_SIGNED_INFO
));
1397 msg
->msg_data
.info
->version
= CMSG_SIGNED_DATA_V1
;
1405 msg
->msg_data
.info
->rgSignerInfo
=
1406 CryptMemAlloc(info
->cSigners
* sizeof(CMSG_CMS_SIGNER_INFO
));
1407 if (msg
->msg_data
.info
->rgSignerInfo
)
1409 msg
->msg_data
.info
->cSignerInfo
= info
->cSigners
;
1410 memset(msg
->msg_data
.info
->rgSignerInfo
, 0,
1411 msg
->msg_data
.info
->cSignerInfo
*
1412 sizeof(CMSG_CMS_SIGNER_INFO
));
1413 ret
= CSignedMsgData_AllocateHandles(&msg
->msg_data
);
1414 for (i
= 0; ret
&& i
< msg
->msg_data
.info
->cSignerInfo
; i
++)
1416 if (info
->rgSigners
[i
].SignerId
.dwIdChoice
==
1417 CERT_ID_KEY_IDENTIFIER
)
1418 msg
->msg_data
.info
->version
= CMSG_SIGNED_DATA_V3
;
1419 ret
= CSignerInfo_Construct(
1420 &msg
->msg_data
.info
->rgSignerInfo
[i
],
1421 &info
->rgSigners
[i
]);
1424 ret
= CSignedMsgData_ConstructSignerHandles(
1425 &msg
->msg_data
, i
, info
->rgSigners
[i
].hCryptProv
);
1426 if (dwFlags
& CMSG_CRYPT_RELEASE_CONTEXT_FLAG
)
1427 CryptReleaseContext(info
->rgSigners
[i
].hCryptProv
,
1437 msg
->msg_data
.info
->cSignerInfo
= 0;
1438 msg
->msg_data
.signerHandles
= NULL
;
1439 msg
->msg_data
.cSignerHandle
= 0;
1443 ret
= CRYPT_ConstructBlobArray(&msg
->msg_data
.info
->cCertEncoded
,
1444 &msg
->msg_data
.info
->rgCertEncoded
, info
->cCertEncoded
,
1445 info
->rgCertEncoded
);
1447 ret
= CRYPT_ConstructBlobArray(&msg
->msg_data
.info
->cCrlEncoded
,
1448 &msg
->msg_data
.info
->rgCrlEncoded
, info
->cCrlEncoded
,
1449 info
->rgCrlEncoded
);
1452 CSignedEncodeMsg_Close(msg
);
1460 typedef struct _CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS
1463 HCRYPTPROV_LEGACY hCryptProv
;
1464 CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm
;
1465 void *pvEncryptionAuxInfo
;
1467 PCERT_INFO
*rgpRecipientCert
;
1468 PCMSG_RECIPIENT_ENCODE_INFO rgCmsRecipients
;
1470 PCERT_BLOB rgCertEncoded
;
1472 PCRL_BLOB rgCrlEncoded
;
1473 DWORD cAttrCertEncoded
;
1474 PCERT_BLOB rgAttrCertEncoded
;
1475 DWORD cUnprotectedAttr
;
1476 PCRYPT_ATTRIBUTE rgUnprotectedAttr
;
1477 } CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS
, *PCMSG_ENVELOPED_ENCODE_INFO_WITH_CMS
;
1479 typedef struct _CEnvelopedEncodeMsg
1482 CRYPT_ALGORITHM_IDENTIFIER algo
;
1485 DWORD cRecipientInfo
;
1486 CMSG_KEY_TRANS_RECIPIENT_INFO
*recipientInfo
;
1487 CRYPT_DATA_BLOB data
;
1488 } CEnvelopedEncodeMsg
;
1490 static BOOL
CRYPT_ConstructAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER
*out
,
1491 const CRYPT_ALGORITHM_IDENTIFIER
*in
)
1493 out
->pszObjId
= CryptMemAlloc(strlen(in
->pszObjId
) + 1);
1496 strcpy(out
->pszObjId
, in
->pszObjId
);
1497 return CRYPT_ConstructBlob(&out
->Parameters
, &in
->Parameters
);
1503 static BOOL
CRYPT_ConstructBitBlob(CRYPT_BIT_BLOB
*out
, const CRYPT_BIT_BLOB
*in
)
1505 out
->cbData
= in
->cbData
;
1506 out
->cUnusedBits
= in
->cUnusedBits
;
1509 out
->pbData
= CryptMemAlloc(out
->cbData
);
1511 memcpy(out
->pbData
, in
->pbData
, out
->cbData
);
1520 static BOOL
CRYPT_GenKey(CMSG_CONTENT_ENCRYPT_INFO
*info
, ALG_ID algID
)
1522 static HCRYPTOIDFUNCSET set
= NULL
;
1523 PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY genKeyFunc
= NULL
;
1524 HCRYPTOIDFUNCADDR hFunc
;
1528 set
= CryptInitOIDFunctionSet(CMSG_OID_GEN_CONTENT_ENCRYPT_KEY_FUNC
, 0);
1529 CryptGetOIDFunctionAddress(set
, X509_ASN_ENCODING
,
1530 info
->ContentEncryptionAlgorithm
.pszObjId
, 0, (void **)&genKeyFunc
, &hFunc
);
1533 ret
= genKeyFunc(info
, 0, NULL
);
1534 CryptFreeOIDFunctionAddress(hFunc
, 0);
1537 ret
= CryptGenKey(info
->hCryptProv
, algID
, CRYPT_EXPORTABLE
,
1538 &info
->hContentEncryptKey
);
1542 static BOOL WINAPI
CRYPT_ExportKeyTrans(
1543 PCMSG_CONTENT_ENCRYPT_INFO pContentEncryptInfo
,
1544 PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO pKeyTransEncodeInfo
,
1545 PCMSG_KEY_TRANS_ENCRYPT_INFO pKeyTransEncryptInfo
,
1546 DWORD dwFlags
, void *pvReserved
)
1548 CERT_PUBLIC_KEY_INFO keyInfo
;
1552 ret
= CRYPT_ConstructAlgorithmId(&keyInfo
.Algorithm
,
1553 &pKeyTransEncodeInfo
->KeyEncryptionAlgorithm
);
1555 CRYPT_ConstructBitBlob(&keyInfo
.PublicKey
,
1556 &pKeyTransEncodeInfo
->RecipientPublicKey
);
1559 ret
= CryptImportPublicKeyInfo(pKeyTransEncodeInfo
->hCryptProv
,
1560 X509_ASN_ENCODING
, &keyInfo
, &expKey
);
1565 ret
= CryptExportKey(pContentEncryptInfo
->hContentEncryptKey
, expKey
,
1566 SIMPLEBLOB
, 0, NULL
, &size
);
1571 keyBlob
= CryptMemAlloc(size
);
1574 ret
= CryptExportKey(pContentEncryptInfo
->hContentEncryptKey
,
1575 expKey
, SIMPLEBLOB
, 0, keyBlob
, &size
);
1578 DWORD head
= sizeof(BLOBHEADER
) + sizeof(ALG_ID
);
1580 pKeyTransEncryptInfo
->EncryptedKey
.pbData
=
1581 CryptMemAlloc(size
- head
);
1582 if (pKeyTransEncryptInfo
->EncryptedKey
.pbData
)
1586 pKeyTransEncryptInfo
->EncryptedKey
.cbData
= size
- head
;
1587 for (i
= size
- 1; i
>= head
; --i
, ++k
)
1588 pKeyTransEncryptInfo
->EncryptedKey
.pbData
[k
] =
1594 CryptMemFree(keyBlob
);
1599 CryptDestroyKey(expKey
);
1602 CryptMemFree(keyInfo
.PublicKey
.pbData
);
1603 CryptMemFree(keyInfo
.Algorithm
.pszObjId
);
1604 CryptMemFree(keyInfo
.Algorithm
.Parameters
.pbData
);
1608 static BOOL
CRYPT_ExportEncryptedKey(CMSG_CONTENT_ENCRYPT_INFO
*info
, DWORD i
,
1609 CRYPT_DATA_BLOB
*key
)
1611 static HCRYPTOIDFUNCSET set
= NULL
;
1612 PFN_CMSG_EXPORT_KEY_TRANS exportKeyFunc
= NULL
;
1613 HCRYPTOIDFUNCADDR hFunc
= NULL
;
1614 CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO
*encodeInfo
=
1615 info
->rgCmsRecipients
[i
].u
.pKeyTrans
;
1616 CMSG_KEY_TRANS_ENCRYPT_INFO encryptInfo
;
1619 memset(&encryptInfo
, 0, sizeof(encryptInfo
));
1620 encryptInfo
.cbSize
= sizeof(encryptInfo
);
1621 encryptInfo
.dwRecipientIndex
= i
;
1622 ret
= CRYPT_ConstructAlgorithmId(&encryptInfo
.KeyEncryptionAlgorithm
,
1623 &encodeInfo
->KeyEncryptionAlgorithm
);
1626 set
= CryptInitOIDFunctionSet(CMSG_OID_EXPORT_KEY_TRANS_FUNC
, 0);
1627 CryptGetOIDFunctionAddress(set
, X509_ASN_ENCODING
,
1628 encryptInfo
.KeyEncryptionAlgorithm
.pszObjId
, 0, (void **)&exportKeyFunc
,
1631 exportKeyFunc
= CRYPT_ExportKeyTrans
;
1634 ret
= exportKeyFunc(info
, encodeInfo
, &encryptInfo
, 0, NULL
);
1637 key
->cbData
= encryptInfo
.EncryptedKey
.cbData
;
1638 key
->pbData
= encryptInfo
.EncryptedKey
.pbData
;
1642 CryptFreeOIDFunctionAddress(hFunc
, 0);
1644 CryptMemFree(encryptInfo
.KeyEncryptionAlgorithm
.pszObjId
);
1645 CryptMemFree(encryptInfo
.KeyEncryptionAlgorithm
.Parameters
.pbData
);
1649 static LPVOID WINAPI
mem_alloc(size_t size
)
1651 return HeapAlloc(GetProcessHeap(), 0, size
);
1654 static VOID WINAPI
mem_free(LPVOID pv
)
1656 HeapFree(GetProcessHeap(), 0, pv
);
1660 static BOOL
CContentEncryptInfo_Construct(CMSG_CONTENT_ENCRYPT_INFO
*info
,
1661 const CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS
*in
, HCRYPTPROV prov
)
1665 info
->cbSize
= sizeof(CMSG_CONTENT_ENCRYPT_INFO
);
1666 info
->hCryptProv
= prov
;
1667 ret
= CRYPT_ConstructAlgorithmId(&info
->ContentEncryptionAlgorithm
,
1668 &in
->ContentEncryptionAlgorithm
);
1669 info
->pvEncryptionAuxInfo
= in
->pvEncryptionAuxInfo
;
1670 info
->cRecipients
= in
->cRecipients
;
1673 info
->rgCmsRecipients
= CryptMemAlloc(in
->cRecipients
*
1674 sizeof(CMSG_RECIPIENT_ENCODE_INFO
));
1675 if (info
->rgCmsRecipients
)
1679 for (i
= 0; ret
&& i
< in
->cRecipients
; ++i
)
1681 CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO
*encodeInfo
;
1682 CERT_INFO
*cert
= in
->rgpRecipientCert
[i
];
1684 info
->rgCmsRecipients
[i
].dwRecipientChoice
=
1685 CMSG_KEY_TRANS_RECIPIENT
;
1686 encodeInfo
= CryptMemAlloc(sizeof(*encodeInfo
));
1687 info
->rgCmsRecipients
[i
].u
.pKeyTrans
= encodeInfo
;
1690 encodeInfo
->cbSize
= sizeof(*encodeInfo
);
1691 ret
= CRYPT_ConstructAlgorithmId(
1692 &encodeInfo
->KeyEncryptionAlgorithm
,
1693 &cert
->SubjectPublicKeyInfo
.Algorithm
);
1694 encodeInfo
->pvKeyEncryptionAuxInfo
= NULL
;
1695 encodeInfo
->hCryptProv
= prov
;
1697 ret
= CRYPT_ConstructBitBlob(
1698 &encodeInfo
->RecipientPublicKey
,
1699 &cert
->SubjectPublicKeyInfo
.PublicKey
);
1701 ret
= CRYPT_ConstructBlob(
1702 &encodeInfo
->RecipientId
.u
.IssuerSerialNumber
.Issuer
,
1705 ret
= CRYPT_ConstructBlob(
1706 &encodeInfo
->RecipientId
.u
.IssuerSerialNumber
.SerialNumber
,
1707 &cert
->SerialNumber
);
1716 info
->pfnAlloc
= mem_alloc
;
1717 info
->pfnFree
= mem_free
;
1721 static void CContentEncryptInfo_Free(CMSG_CONTENT_ENCRYPT_INFO
*info
)
1723 CryptMemFree(info
->ContentEncryptionAlgorithm
.pszObjId
);
1724 CryptMemFree(info
->ContentEncryptionAlgorithm
.Parameters
.pbData
);
1725 if (info
->rgCmsRecipients
)
1729 for (i
= 0; i
< info
->cRecipients
; ++i
)
1731 CMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO
*encodeInfo
=
1732 info
->rgCmsRecipients
[i
].u
.pKeyTrans
;
1734 CryptMemFree(encodeInfo
->KeyEncryptionAlgorithm
.pszObjId
);
1735 CryptMemFree(encodeInfo
->KeyEncryptionAlgorithm
.Parameters
.pbData
);
1736 CryptMemFree(encodeInfo
->RecipientPublicKey
.pbData
);
1738 encodeInfo
->RecipientId
.u
.IssuerSerialNumber
.Issuer
.pbData
);
1740 encodeInfo
->RecipientId
.u
.IssuerSerialNumber
.SerialNumber
.pbData
);
1741 CryptMemFree(encodeInfo
);
1743 CryptMemFree(info
->rgCmsRecipients
);
1747 static BOOL
CRecipientInfo_Construct(CMSG_KEY_TRANS_RECIPIENT_INFO
*info
,
1748 const CERT_INFO
*cert
, CRYPT_DATA_BLOB
*key
)
1752 info
->dwVersion
= CMSG_KEY_TRANS_PKCS_1_5_VERSION
;
1753 info
->RecipientId
.dwIdChoice
= CERT_ID_ISSUER_SERIAL_NUMBER
;
1754 ret
= CRYPT_ConstructBlob(&info
->RecipientId
.u
.IssuerSerialNumber
.Issuer
,
1757 ret
= CRYPT_ConstructBlob(
1758 &info
->RecipientId
.u
.IssuerSerialNumber
.SerialNumber
,
1759 &cert
->SerialNumber
);
1761 ret
= CRYPT_ConstructAlgorithmId(&info
->KeyEncryptionAlgorithm
,
1762 &cert
->SubjectPublicKeyInfo
.Algorithm
);
1763 info
->EncryptedKey
.cbData
= key
->cbData
;
1764 info
->EncryptedKey
.pbData
= key
->pbData
;
1768 static void CRecipientInfo_Free(CMSG_KEY_TRANS_RECIPIENT_INFO
*info
)
1770 CryptMemFree(info
->RecipientId
.u
.IssuerSerialNumber
.Issuer
.pbData
);
1771 CryptMemFree(info
->RecipientId
.u
.IssuerSerialNumber
.SerialNumber
.pbData
);
1772 CryptMemFree(info
->KeyEncryptionAlgorithm
.pszObjId
);
1773 CryptMemFree(info
->KeyEncryptionAlgorithm
.Parameters
.pbData
);
1774 CryptMemFree(info
->EncryptedKey
.pbData
);
1777 static void CEnvelopedEncodeMsg_Close(HCRYPTMSG hCryptMsg
)
1779 CEnvelopedEncodeMsg
*msg
= hCryptMsg
;
1781 CryptMemFree(msg
->algo
.pszObjId
);
1782 CryptMemFree(msg
->algo
.Parameters
.pbData
);
1783 if (msg
->base
.open_flags
& CMSG_CRYPT_RELEASE_CONTEXT_FLAG
)
1784 CryptReleaseContext(msg
->prov
, 0);
1785 CryptDestroyKey(msg
->key
);
1786 if (msg
->recipientInfo
)
1790 for (i
= 0; i
< msg
->cRecipientInfo
; ++i
)
1791 CRecipientInfo_Free(&msg
->recipientInfo
[i
]);
1792 CryptMemFree(msg
->recipientInfo
);
1794 CryptMemFree(msg
->data
.pbData
);
1797 static BOOL
CEnvelopedEncodeMsg_GetParam(HCRYPTMSG hCryptMsg
, DWORD dwParamType
,
1798 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
)
1800 CEnvelopedEncodeMsg
*msg
= hCryptMsg
;
1803 switch (dwParamType
)
1805 case CMSG_BARE_CONTENT_PARAM
:
1806 if (msg
->base
.streamed
)
1807 SetLastError(E_INVALIDARG
);
1810 char oid_rsa_data
[] = szOID_RSA_data
;
1811 CRYPT_ENVELOPED_DATA envelopedData
= {
1812 CMSG_ENVELOPED_DATA_PKCS_1_5_VERSION
, msg
->cRecipientInfo
,
1813 msg
->recipientInfo
, { oid_rsa_data
, {
1815 { msg
->algo
.Parameters
.cbData
, msg
->algo
.Parameters
.pbData
}
1817 { msg
->data
.cbData
, msg
->data
.pbData
}
1821 ret
= CRYPT_AsnEncodePKCSEnvelopedData(&envelopedData
, pvData
,
1825 case CMSG_CONTENT_PARAM
:
1827 CRYPT_CONTENT_INFO info
;
1829 ret
= CryptMsgGetParam(hCryptMsg
, CMSG_BARE_CONTENT_PARAM
, 0, NULL
,
1830 &info
.Content
.cbData
);
1833 info
.Content
.pbData
= CryptMemAlloc(info
.Content
.cbData
);
1834 if (info
.Content
.pbData
)
1836 ret
= CryptMsgGetParam(hCryptMsg
, CMSG_BARE_CONTENT_PARAM
, 0,
1837 info
.Content
.pbData
, &info
.Content
.cbData
);
1840 char oid_rsa_enveloped
[] = szOID_RSA_envelopedData
;
1842 info
.pszObjId
= oid_rsa_enveloped
;
1843 ret
= CryptEncodeObjectEx(X509_ASN_ENCODING
,
1844 PKCS_CONTENT_INFO
, &info
, 0, NULL
, pvData
, pcbData
);
1846 CryptMemFree(info
.Content
.pbData
);
1854 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
1859 static BOOL
CEnvelopedEncodeMsg_Update(HCRYPTMSG hCryptMsg
, const BYTE
*pbData
,
1860 DWORD cbData
, BOOL fFinal
)
1862 CEnvelopedEncodeMsg
*msg
= hCryptMsg
;
1865 if (msg
->base
.state
== MsgStateFinalized
)
1866 SetLastError(CRYPT_E_MSG_ERROR
);
1867 else if (msg
->base
.streamed
)
1869 FIXME("streamed stub\n");
1870 msg
->base
.state
= fFinal
? MsgStateFinalized
: MsgStateUpdated
;
1877 if (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
)
1878 SetLastError(E_INVALIDARG
);
1880 SetLastError(CRYPT_E_MSG_ERROR
);
1886 DWORD dataLen
= cbData
;
1888 msg
->data
.cbData
= cbData
;
1889 msg
->data
.pbData
= CryptMemAlloc(cbData
);
1890 if (msg
->data
.pbData
)
1892 memcpy(msg
->data
.pbData
, pbData
, cbData
);
1893 ret
= CryptEncrypt(msg
->key
, 0, TRUE
, 0, msg
->data
.pbData
,
1894 &dataLen
, msg
->data
.cbData
);
1895 msg
->data
.cbData
= dataLen
;
1896 if (dataLen
> cbData
)
1898 msg
->data
.pbData
= CryptMemRealloc(msg
->data
.pbData
,
1900 if (msg
->data
.pbData
)
1903 ret
= CryptEncrypt(msg
->key
, 0, TRUE
, 0,
1904 msg
->data
.pbData
, &dataLen
, msg
->data
.cbData
);
1910 CryptMemFree(msg
->data
.pbData
);
1916 msg
->data
.cbData
= 0;
1917 msg
->data
.pbData
= NULL
;
1922 msg
->base
.state
= MsgStateFinalized
;
1928 static HCRYPTMSG
CEnvelopedEncodeMsg_Open(DWORD dwFlags
,
1929 const void *pvMsgEncodeInfo
, LPCSTR pszInnerContentObjID
,
1930 PCMSG_STREAM_INFO pStreamInfo
)
1932 CEnvelopedEncodeMsg
*msg
;
1933 const CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS
*info
= pvMsgEncodeInfo
;
1937 if (info
->cbSize
!= sizeof(CMSG_ENVELOPED_ENCODE_INFO
) &&
1938 info
->cbSize
!= sizeof(CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS
))
1940 SetLastError(E_INVALIDARG
);
1943 if (info
->cbSize
== sizeof(CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS
))
1944 FIXME("CMS fields unsupported\n");
1945 if (!(algID
= CertOIDToAlgId(info
->ContentEncryptionAlgorithm
.pszObjId
)))
1947 SetLastError(CRYPT_E_UNKNOWN_ALGO
);
1950 if (info
->cRecipients
&& !info
->rgpRecipientCert
)
1952 SetLastError(E_INVALIDARG
);
1955 if (info
->hCryptProv
)
1956 prov
= info
->hCryptProv
;
1959 prov
= CRYPT_GetDefaultProvider();
1960 dwFlags
&= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG
;
1962 msg
= CryptMemAlloc(sizeof(CEnvelopedEncodeMsg
));
1965 CRYPT_DATA_BLOB encryptedKey
= { 0, NULL
};
1966 CMSG_CONTENT_ENCRYPT_INFO encryptInfo
;
1970 CryptMsgBase_Init((CryptMsgBase
*)msg
, dwFlags
, pStreamInfo
,
1971 CEnvelopedEncodeMsg_Close
, CEnvelopedEncodeMsg_GetParam
,
1972 CEnvelopedEncodeMsg_Update
, CRYPT_DefaultMsgControl
);
1973 ret
= CRYPT_ConstructAlgorithmId(&msg
->algo
,
1974 &info
->ContentEncryptionAlgorithm
);
1976 msg
->data
.cbData
= 0;
1977 msg
->data
.pbData
= NULL
;
1978 msg
->cRecipientInfo
= info
->cRecipients
;
1979 msg
->recipientInfo
= CryptMemAlloc(info
->cRecipients
*
1980 sizeof(CMSG_KEY_TRANS_RECIPIENT_INFO
));
1981 if (!msg
->recipientInfo
)
1983 memset(&encryptInfo
, 0, sizeof(encryptInfo
));
1986 ret
= CContentEncryptInfo_Construct(&encryptInfo
, info
, prov
);
1989 ret
= CRYPT_GenKey(&encryptInfo
, algID
);
1991 msg
->key
= encryptInfo
.hContentEncryptKey
;
1994 for (i
= 0; ret
&& i
< msg
->cRecipientInfo
; ++i
)
1996 ret
= CRYPT_ExportEncryptedKey(&encryptInfo
, i
, &encryptedKey
);
1998 ret
= CRecipientInfo_Construct(&msg
->recipientInfo
[i
],
1999 info
->rgpRecipientCert
[i
], &encryptedKey
);
2001 CContentEncryptInfo_Free(&encryptInfo
);
2008 if (!msg
&& (dwFlags
& CMSG_CRYPT_RELEASE_CONTEXT_FLAG
))
2009 CryptReleaseContext(prov
, 0);
2013 HCRYPTMSG WINAPI
CryptMsgOpenToEncode(DWORD dwMsgEncodingType
, DWORD dwFlags
,
2014 DWORD dwMsgType
, const void *pvMsgEncodeInfo
, LPSTR pszInnerContentObjID
,
2015 PCMSG_STREAM_INFO pStreamInfo
)
2017 HCRYPTMSG msg
= NULL
;
2019 TRACE("(%08x, %08x, %08x, %p, %s, %p)\n", dwMsgEncodingType
, dwFlags
,
2020 dwMsgType
, pvMsgEncodeInfo
, debugstr_a(pszInnerContentObjID
), pStreamInfo
);
2022 if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType
) != PKCS_7_ASN_ENCODING
)
2024 SetLastError(E_INVALIDARG
);
2030 msg
= CDataEncodeMsg_Open(dwFlags
, pvMsgEncodeInfo
,
2031 pszInnerContentObjID
, pStreamInfo
);
2034 msg
= CHashEncodeMsg_Open(dwFlags
, pvMsgEncodeInfo
,
2035 pszInnerContentObjID
, pStreamInfo
);
2038 msg
= CSignedEncodeMsg_Open(dwFlags
, pvMsgEncodeInfo
,
2039 pszInnerContentObjID
, pStreamInfo
);
2041 case CMSG_ENVELOPED
:
2042 msg
= CEnvelopedEncodeMsg_Open(dwFlags
, pvMsgEncodeInfo
,
2043 pszInnerContentObjID
, pStreamInfo
);
2045 case CMSG_SIGNED_AND_ENVELOPED
:
2046 case CMSG_ENCRYPTED
:
2047 /* defined but invalid, fall through */
2049 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
2054 typedef struct _CEnvelopedDecodeMsg
2056 CRYPT_ENVELOPED_DATA
*data
;
2057 HCRYPTPROV crypt_prov
;
2058 CRYPT_DATA_BLOB content
;
2060 } CEnvelopedDecodeMsg
;
2062 typedef struct _CDecodeMsg
2066 HCRYPTPROV crypt_prov
;
2069 CSignedMsgData signed_data
;
2070 CEnvelopedDecodeMsg enveloped_data
;
2072 CRYPT_DATA_BLOB msg_data
;
2073 CRYPT_DATA_BLOB detached_data
;
2074 CONTEXT_PROPERTY_LIST
*properties
;
2077 static void CDecodeMsg_Close(HCRYPTMSG hCryptMsg
)
2079 CDecodeMsg
*msg
= hCryptMsg
;
2081 if (msg
->base
.open_flags
& CMSG_CRYPT_RELEASE_CONTEXT_FLAG
)
2082 CryptReleaseContext(msg
->crypt_prov
, 0);
2087 CryptDestroyHash(msg
->u
.hash
);
2089 case CMSG_ENVELOPED
:
2090 if (msg
->u
.enveloped_data
.crypt_prov
)
2091 CryptReleaseContext(msg
->u
.enveloped_data
.crypt_prov
, 0);
2092 LocalFree(msg
->u
.enveloped_data
.data
);
2093 CryptMemFree(msg
->u
.enveloped_data
.content
.pbData
);
2096 if (msg
->u
.signed_data
.info
)
2098 LocalFree(msg
->u
.signed_data
.info
);
2099 CSignedMsgData_CloseHandles(&msg
->u
.signed_data
);
2103 CryptMemFree(msg
->msg_data
.pbData
);
2104 CryptMemFree(msg
->detached_data
.pbData
);
2105 ContextPropertyList_Free(msg
->properties
);
2108 static BOOL
CDecodeMsg_CopyData(CRYPT_DATA_BLOB
*blob
, const BYTE
*pbData
,
2116 blob
->pbData
= CryptMemRealloc(blob
->pbData
,
2117 blob
->cbData
+ cbData
);
2119 blob
->pbData
= CryptMemAlloc(cbData
);
2122 memcpy(blob
->pbData
+ blob
->cbData
, pbData
, cbData
);
2123 blob
->cbData
+= cbData
;
2131 static BOOL
CDecodeMsg_DecodeDataContent(CDecodeMsg
*msg
, const CRYPT_DER_BLOB
*blob
)
2134 CRYPT_DATA_BLOB
*data
;
2137 ret
= CryptDecodeObjectEx(X509_ASN_ENCODING
, X509_OCTET_STRING
,
2138 blob
->pbData
, blob
->cbData
, CRYPT_DECODE_ALLOC_FLAG
, NULL
, &data
, &size
);
2141 ret
= ContextPropertyList_SetProperty(msg
->properties
,
2142 CMSG_CONTENT_PARAM
, data
->pbData
, data
->cbData
);
2148 static void CDecodeMsg_SaveAlgorithmID(CDecodeMsg
*msg
, DWORD param
,
2149 const CRYPT_ALGORITHM_IDENTIFIER
*id
)
2151 static const BYTE nullParams
[] = { ASN_NULL
, 0 };
2152 CRYPT_ALGORITHM_IDENTIFIER
*copy
;
2153 DWORD len
= sizeof(CRYPT_ALGORITHM_IDENTIFIER
);
2155 /* Linearize algorithm id */
2156 len
+= strlen(id
->pszObjId
) + 1;
2157 len
+= id
->Parameters
.cbData
;
2158 copy
= CryptMemAlloc(len
);
2162 (LPSTR
)((BYTE
*)copy
+ sizeof(CRYPT_ALGORITHM_IDENTIFIER
));
2163 strcpy(copy
->pszObjId
, id
->pszObjId
);
2164 copy
->Parameters
.pbData
= (BYTE
*)copy
->pszObjId
+ strlen(id
->pszObjId
)
2166 /* Trick: omit NULL parameters */
2167 if (id
->Parameters
.cbData
== sizeof(nullParams
) &&
2168 !memcmp(id
->Parameters
.pbData
, nullParams
, sizeof(nullParams
)))
2170 copy
->Parameters
.cbData
= 0;
2171 len
-= sizeof(nullParams
);
2174 copy
->Parameters
.cbData
= id
->Parameters
.cbData
;
2175 if (copy
->Parameters
.cbData
)
2176 memcpy(copy
->Parameters
.pbData
, id
->Parameters
.pbData
,
2177 id
->Parameters
.cbData
);
2178 ContextPropertyList_SetProperty(msg
->properties
, param
, (BYTE
*)copy
,
2184 static inline void CRYPT_FixUpAlgorithmID(CRYPT_ALGORITHM_IDENTIFIER
*id
)
2186 id
->pszObjId
= (LPSTR
)((BYTE
*)id
+ sizeof(CRYPT_ALGORITHM_IDENTIFIER
));
2187 id
->Parameters
.pbData
= (BYTE
*)id
->pszObjId
+ strlen(id
->pszObjId
) + 1;
2190 static BOOL
CDecodeMsg_DecodeHashedContent(CDecodeMsg
*msg
,
2191 const CRYPT_DER_BLOB
*blob
)
2194 CRYPT_DIGESTED_DATA
*digestedData
;
2197 ret
= CRYPT_AsnDecodePKCSDigestedData(blob
->pbData
, blob
->cbData
,
2198 CRYPT_DECODE_ALLOC_FLAG
, NULL
, (CRYPT_DIGESTED_DATA
*)&digestedData
,
2202 ContextPropertyList_SetProperty(msg
->properties
, CMSG_VERSION_PARAM
,
2203 (const BYTE
*)&digestedData
->version
, sizeof(digestedData
->version
));
2204 CDecodeMsg_SaveAlgorithmID(msg
, CMSG_HASH_ALGORITHM_PARAM
,
2205 &digestedData
->DigestAlgorithm
);
2206 ContextPropertyList_SetProperty(msg
->properties
,
2207 CMSG_INNER_CONTENT_TYPE_PARAM
,
2208 (const BYTE
*)digestedData
->ContentInfo
.pszObjId
,
2209 digestedData
->ContentInfo
.pszObjId
?
2210 strlen(digestedData
->ContentInfo
.pszObjId
) + 1 : 0);
2211 if (!(msg
->base
.open_flags
& CMSG_DETACHED_FLAG
))
2213 if (digestedData
->ContentInfo
.Content
.cbData
)
2214 CDecodeMsg_DecodeDataContent(msg
,
2215 &digestedData
->ContentInfo
.Content
);
2217 ContextPropertyList_SetProperty(msg
->properties
,
2218 CMSG_CONTENT_PARAM
, NULL
, 0);
2220 ContextPropertyList_SetProperty(msg
->properties
, CMSG_HASH_DATA_PARAM
,
2221 digestedData
->hash
.pbData
, digestedData
->hash
.cbData
);
2222 LocalFree(digestedData
);
2227 static BOOL
CDecodeMsg_DecodeEnvelopedContent(CDecodeMsg
*msg
,
2228 const CRYPT_DER_BLOB
*blob
)
2231 CRYPT_ENVELOPED_DATA
*envelopedData
;
2234 ret
= CRYPT_AsnDecodePKCSEnvelopedData(blob
->pbData
, blob
->cbData
,
2235 CRYPT_DECODE_ALLOC_FLAG
, NULL
, (CRYPT_ENVELOPED_DATA
*)&envelopedData
,
2238 msg
->u
.enveloped_data
.data
= envelopedData
;
2242 static BOOL
CDecodeMsg_DecodeSignedContent(CDecodeMsg
*msg
,
2243 const CRYPT_DER_BLOB
*blob
)
2246 CRYPT_SIGNED_INFO
*signedInfo
;
2249 ret
= CRYPT_AsnDecodeCMSSignedInfo(blob
->pbData
, blob
->cbData
,
2250 CRYPT_DECODE_ALLOC_FLAG
, NULL
, (CRYPT_SIGNED_INFO
*)&signedInfo
,
2253 msg
->u
.signed_data
.info
= signedInfo
;
2257 /* Decodes the content in blob as the type given, and updates the value
2258 * (type, parameters, etc.) of msg based on what blob contains.
2259 * It doesn't just use msg's type, to allow a recursive call from an implicitly
2260 * typed message once the outer content info has been decoded.
2262 static BOOL
CDecodeMsg_DecodeContent(CDecodeMsg
*msg
, const CRYPT_DER_BLOB
*blob
,
2270 if ((ret
= CDecodeMsg_DecodeDataContent(msg
, blob
)))
2271 msg
->type
= CMSG_DATA
;
2274 if ((ret
= CDecodeMsg_DecodeHashedContent(msg
, blob
)))
2275 msg
->type
= CMSG_HASHED
;
2277 case CMSG_ENVELOPED
:
2278 if ((ret
= CDecodeMsg_DecodeEnvelopedContent(msg
, blob
)))
2279 msg
->type
= CMSG_ENVELOPED
;
2282 if ((ret
= CDecodeMsg_DecodeSignedContent(msg
, blob
)))
2283 msg
->type
= CMSG_SIGNED
;
2287 CRYPT_CONTENT_INFO
*info
;
2290 ret
= CryptDecodeObjectEx(X509_ASN_ENCODING
, PKCS_CONTENT_INFO
,
2291 msg
->msg_data
.pbData
, msg
->msg_data
.cbData
, CRYPT_DECODE_ALLOC_FLAG
,
2292 NULL
, &info
, &size
);
2295 if (!strcmp(info
->pszObjId
, szOID_RSA_data
))
2296 ret
= CDecodeMsg_DecodeContent(msg
, &info
->Content
, CMSG_DATA
);
2297 else if (!strcmp(info
->pszObjId
, szOID_RSA_digestedData
))
2298 ret
= CDecodeMsg_DecodeContent(msg
, &info
->Content
,
2300 else if (!strcmp(info
->pszObjId
, szOID_RSA_envelopedData
))
2301 ret
= CDecodeMsg_DecodeContent(msg
, &info
->Content
,
2303 else if (!strcmp(info
->pszObjId
, szOID_RSA_signedData
))
2304 ret
= CDecodeMsg_DecodeContent(msg
, &info
->Content
,
2308 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
2318 static BOOL
CDecodeMsg_FinalizeHashedContent(CDecodeMsg
*msg
,
2319 CRYPT_DER_BLOB
*blob
)
2321 CRYPT_ALGORITHM_IDENTIFIER
*hashAlgoID
= NULL
;
2326 CryptMsgGetParam(msg
, CMSG_HASH_ALGORITHM_PARAM
, 0, NULL
, &size
);
2327 hashAlgoID
= CryptMemAlloc(size
);
2328 ret
= CryptMsgGetParam(msg
, CMSG_HASH_ALGORITHM_PARAM
, 0, hashAlgoID
,
2331 algID
= CertOIDToAlgId(hashAlgoID
->pszObjId
);
2332 ret
= CryptCreateHash(msg
->crypt_prov
, algID
, 0, 0, &msg
->u
.hash
);
2335 CRYPT_DATA_BLOB content
;
2337 if (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
)
2339 /* Unlike for non-detached messages, the data were never stored as
2340 * the content param, but were saved in msg->detached_data instead.
2342 content
.pbData
= msg
->detached_data
.pbData
;
2343 content
.cbData
= msg
->detached_data
.cbData
;
2346 ret
= ContextPropertyList_FindProperty(msg
->properties
,
2347 CMSG_CONTENT_PARAM
, &content
);
2349 ret
= CryptHashData(msg
->u
.hash
, content
.pbData
, content
.cbData
, 0);
2351 CryptMemFree(hashAlgoID
);
2355 static BOOL
CDecodeMsg_FinalizeEnvelopedContent(CDecodeMsg
*msg
,
2356 CRYPT_DER_BLOB
*blob
)
2358 CRYPT_DATA_BLOB
*content
;
2360 if (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
)
2361 content
= &msg
->detached_data
;
2364 &msg
->u
.enveloped_data
.data
->encryptedContentInfo
.encryptedContent
;
2366 return CRYPT_ConstructBlob(&msg
->u
.enveloped_data
.content
, content
);
2369 static BOOL
CDecodeMsg_FinalizeSignedContent(CDecodeMsg
*msg
,
2370 CRYPT_DER_BLOB
*blob
)
2375 ret
= CSignedMsgData_AllocateHandles(&msg
->u
.signed_data
);
2376 for (i
= 0; ret
&& i
< msg
->u
.signed_data
.info
->cSignerInfo
; i
++)
2377 ret
= CSignedMsgData_ConstructSignerHandles(&msg
->u
.signed_data
, i
,
2381 CRYPT_DATA_BLOB
*content
;
2383 /* Now that we have all the content, update the hash handles with
2384 * it. If the message is a detached message, the content is stored
2385 * in msg->detached_data rather than in the signed message's
2388 if (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
)
2389 content
= &msg
->detached_data
;
2391 content
= &msg
->u
.signed_data
.info
->content
.Content
;
2392 if (content
->cbData
)
2394 /* If the message is not detached, have to decode the message's
2395 * content if the type is szOID_RSA_data.
2397 if (!(msg
->base
.open_flags
& CMSG_DETACHED_FLAG
) &&
2398 !strcmp(msg
->u
.signed_data
.info
->content
.pszObjId
,
2401 CRYPT_DATA_BLOB
*rsa_blob
;
2403 ret
= CryptDecodeObjectEx(X509_ASN_ENCODING
,
2404 X509_OCTET_STRING
, content
->pbData
, content
->cbData
,
2405 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &rsa_blob
, &size
);
2408 ret
= CSignedMsgData_Update(&msg
->u
.signed_data
,
2409 rsa_blob
->pbData
, rsa_blob
->cbData
, TRUE
, Verify
);
2410 LocalFree(rsa_blob
);
2414 ret
= CSignedMsgData_Update(&msg
->u
.signed_data
,
2415 content
->pbData
, content
->cbData
, TRUE
, Verify
);
2421 static BOOL
CDecodeMsg_FinalizeContent(CDecodeMsg
*msg
, CRYPT_DER_BLOB
*blob
)
2428 ret
= CDecodeMsg_FinalizeHashedContent(msg
, blob
);
2430 case CMSG_ENVELOPED
:
2431 ret
= CDecodeMsg_FinalizeEnvelopedContent(msg
, blob
);
2434 ret
= CDecodeMsg_FinalizeSignedContent(msg
, blob
);
2442 static BOOL
CDecodeMsg_Update(HCRYPTMSG hCryptMsg
, const BYTE
*pbData
,
2443 DWORD cbData
, BOOL fFinal
)
2445 CDecodeMsg
*msg
= hCryptMsg
;
2448 TRACE("(%p, %p, %d, %d)\n", hCryptMsg
, pbData
, cbData
, fFinal
);
2450 if (msg
->base
.state
== MsgStateFinalized
)
2451 SetLastError(CRYPT_E_MSG_ERROR
);
2452 else if (msg
->base
.streamed
)
2454 FIXME("(%p, %p, %d, %d): streamed update stub\n", hCryptMsg
, pbData
,
2456 switch (msg
->base
.state
)
2459 ret
= CDecodeMsg_CopyData(&msg
->msg_data
, pbData
, cbData
);
2462 if (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
)
2463 msg
->base
.state
= MsgStateDataFinalized
;
2465 msg
->base
.state
= MsgStateFinalized
;
2468 msg
->base
.state
= MsgStateUpdated
;
2470 case MsgStateUpdated
:
2471 ret
= CDecodeMsg_CopyData(&msg
->msg_data
, pbData
, cbData
);
2474 if (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
)
2475 msg
->base
.state
= MsgStateDataFinalized
;
2477 msg
->base
.state
= MsgStateFinalized
;
2480 case MsgStateDataFinalized
:
2481 ret
= CDecodeMsg_CopyData(&msg
->detached_data
, pbData
, cbData
);
2483 msg
->base
.state
= MsgStateFinalized
;
2486 SetLastError(CRYPT_E_MSG_ERROR
);
2493 SetLastError(CRYPT_E_MSG_ERROR
);
2496 switch (msg
->base
.state
)
2499 ret
= CDecodeMsg_CopyData(&msg
->msg_data
, pbData
, cbData
);
2500 if (msg
->base
.open_flags
& CMSG_DETACHED_FLAG
)
2501 msg
->base
.state
= MsgStateDataFinalized
;
2503 msg
->base
.state
= MsgStateFinalized
;
2505 case MsgStateDataFinalized
:
2506 ret
= CDecodeMsg_CopyData(&msg
->detached_data
, pbData
, cbData
);
2507 msg
->base
.state
= MsgStateFinalized
;
2510 SetLastError(CRYPT_E_MSG_ERROR
);
2514 if (ret
&& fFinal
&&
2515 ((msg
->base
.open_flags
& CMSG_DETACHED_FLAG
&& msg
->base
.state
==
2516 MsgStateDataFinalized
) ||
2517 (!(msg
->base
.open_flags
& CMSG_DETACHED_FLAG
) && msg
->base
.state
==
2518 MsgStateFinalized
)))
2519 ret
= CDecodeMsg_DecodeContent(msg
, &msg
->msg_data
, msg
->type
);
2520 if (ret
&& msg
->base
.state
== MsgStateFinalized
)
2521 ret
= CDecodeMsg_FinalizeContent(msg
, &msg
->msg_data
);
2525 static BOOL
CDecodeHashMsg_GetParam(CDecodeMsg
*msg
, DWORD dwParamType
,
2526 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
)
2530 switch (dwParamType
)
2532 case CMSG_TYPE_PARAM
:
2533 ret
= CRYPT_CopyParam(pvData
, pcbData
, &msg
->type
, sizeof(msg
->type
));
2535 case CMSG_HASH_ALGORITHM_PARAM
:
2537 CRYPT_DATA_BLOB blob
;
2539 ret
= ContextPropertyList_FindProperty(msg
->properties
, dwParamType
,
2543 ret
= CRYPT_CopyParam(pvData
, pcbData
, blob
.pbData
, blob
.cbData
);
2545 CRYPT_FixUpAlgorithmID(pvData
);
2548 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
2551 case CMSG_COMPUTED_HASH_PARAM
:
2552 ret
= CryptGetHashParam(msg
->u
.hash
, HP_HASHVAL
, pvData
, pcbData
, 0);
2556 CRYPT_DATA_BLOB blob
;
2558 ret
= ContextPropertyList_FindProperty(msg
->properties
, dwParamType
,
2561 ret
= CRYPT_CopyParam(pvData
, pcbData
, blob
.pbData
, blob
.cbData
);
2563 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
2569 /* nextData is an in/out parameter - on input it's the memory location in
2570 * which a copy of in's data should be made, and on output it's the memory
2571 * location immediately after out's copy of in's data.
2573 static inline void CRYPT_CopyBlob(CRYPT_DATA_BLOB
*out
,
2574 const CRYPT_DATA_BLOB
*in
, LPBYTE
*nextData
)
2576 out
->cbData
= in
->cbData
;
2579 out
->pbData
= *nextData
;
2580 memcpy(out
->pbData
, in
->pbData
, in
->cbData
);
2581 *nextData
+= in
->cbData
;
2585 static inline void CRYPT_CopyAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER
*out
,
2586 const CRYPT_ALGORITHM_IDENTIFIER
*in
, LPBYTE
*nextData
)
2590 out
->pszObjId
= (LPSTR
)*nextData
;
2591 strcpy(out
->pszObjId
, in
->pszObjId
);
2592 *nextData
+= strlen(out
->pszObjId
) + 1;
2594 CRYPT_CopyBlob(&out
->Parameters
, &in
->Parameters
, nextData
);
2597 static inline void CRYPT_CopyAttributes(CRYPT_ATTRIBUTES
*out
,
2598 const CRYPT_ATTRIBUTES
*in
, LPBYTE
*nextData
)
2600 out
->cAttr
= in
->cAttr
;
2605 *nextData
= POINTER_ALIGN_DWORD_PTR(*nextData
);
2606 out
->rgAttr
= (CRYPT_ATTRIBUTE
*)*nextData
;
2607 *nextData
+= in
->cAttr
* sizeof(CRYPT_ATTRIBUTE
);
2608 for (i
= 0; i
< in
->cAttr
; i
++)
2610 if (in
->rgAttr
[i
].pszObjId
)
2612 out
->rgAttr
[i
].pszObjId
= (LPSTR
)*nextData
;
2613 strcpy(out
->rgAttr
[i
].pszObjId
, in
->rgAttr
[i
].pszObjId
);
2614 *nextData
+= strlen(in
->rgAttr
[i
].pszObjId
) + 1;
2616 if (in
->rgAttr
[i
].cValue
)
2620 out
->rgAttr
[i
].cValue
= in
->rgAttr
[i
].cValue
;
2621 *nextData
= POINTER_ALIGN_DWORD_PTR(*nextData
);
2622 out
->rgAttr
[i
].rgValue
= (PCRYPT_DATA_BLOB
)*nextData
;
2623 *nextData
+= in
->rgAttr
[i
].cValue
* sizeof(CRYPT_DATA_BLOB
);
2624 for (j
= 0; j
< in
->rgAttr
[i
].cValue
; j
++)
2625 CRYPT_CopyBlob(&out
->rgAttr
[i
].rgValue
[j
],
2626 &in
->rgAttr
[i
].rgValue
[j
], nextData
);
2632 static DWORD
CRYPT_SizeOfAttributes(const CRYPT_ATTRIBUTES
*attr
)
2634 DWORD size
= attr
->cAttr
* sizeof(CRYPT_ATTRIBUTE
), i
, j
;
2636 for (i
= 0; i
< attr
->cAttr
; i
++)
2638 if (attr
->rgAttr
[i
].pszObjId
)
2639 size
+= strlen(attr
->rgAttr
[i
].pszObjId
) + 1;
2641 size
= ALIGN_DWORD_PTR(size
);
2642 size
+= attr
->rgAttr
[i
].cValue
* sizeof(CRYPT_DATA_BLOB
);
2643 for (j
= 0; j
< attr
->rgAttr
[i
].cValue
; j
++)
2644 size
+= attr
->rgAttr
[i
].rgValue
[j
].cbData
;
2646 /* align pointer again to be conservative */
2647 size
= ALIGN_DWORD_PTR(size
);
2651 static DWORD
CRYPT_SizeOfKeyIdAsIssuerAndSerial(const CRYPT_DATA_BLOB
*keyId
)
2653 static char oid_key_rdn
[] = szOID_KEYID_RDN
;
2656 CERT_RDN rdn
= { 1, &attr
};
2657 CERT_NAME_INFO name
= { 1, &rdn
};
2659 attr
.pszObjId
= oid_key_rdn
;
2660 attr
.dwValueType
= CERT_RDN_OCTET_STRING
;
2661 attr
.Value
.cbData
= keyId
->cbData
;
2662 attr
.Value
.pbData
= keyId
->pbData
;
2663 if (CryptEncodeObject(X509_ASN_ENCODING
, X509_NAME
, &name
, NULL
, &size
))
2664 size
++; /* Only include size of special zero serial number on success */
2668 static BOOL
CRYPT_CopyKeyIdAsIssuerAndSerial(CERT_NAME_BLOB
*issuer
,
2669 CRYPT_INTEGER_BLOB
*serialNumber
, const CRYPT_DATA_BLOB
*keyId
, DWORD encodedLen
,
2672 static char oid_key_rdn
[] = szOID_KEYID_RDN
;
2674 CERT_RDN rdn
= { 1, &attr
};
2675 CERT_NAME_INFO name
= { 1, &rdn
};
2678 /* Encode special zero serial number */
2679 serialNumber
->cbData
= 1;
2680 serialNumber
->pbData
= *nextData
;
2684 issuer
->pbData
= *nextData
;
2685 attr
.pszObjId
= oid_key_rdn
;
2686 attr
.dwValueType
= CERT_RDN_OCTET_STRING
;
2687 attr
.Value
.cbData
= keyId
->cbData
;
2688 attr
.Value
.pbData
= keyId
->pbData
;
2689 ret
= CryptEncodeObject(X509_ASN_ENCODING
, X509_NAME
, &name
, *nextData
,
2693 *nextData
+= encodedLen
;
2694 issuer
->cbData
= encodedLen
;
2699 static BOOL
CRYPT_CopySignerInfo(void *pvData
, DWORD
*pcbData
,
2700 const CMSG_CMS_SIGNER_INFO
*in
)
2702 DWORD size
= sizeof(CMSG_SIGNER_INFO
), rdnSize
= 0;
2705 TRACE("(%p, %d, %p)\n", pvData
, pvData
? *pcbData
: 0, in
);
2707 if (in
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
)
2709 size
+= in
->SignerId
.u
.IssuerSerialNumber
.Issuer
.cbData
;
2710 size
+= in
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
.cbData
;
2714 rdnSize
= CRYPT_SizeOfKeyIdAsIssuerAndSerial(&in
->SignerId
.u
.KeyId
);
2717 if (in
->HashAlgorithm
.pszObjId
)
2718 size
+= strlen(in
->HashAlgorithm
.pszObjId
) + 1;
2719 size
+= in
->HashAlgorithm
.Parameters
.cbData
;
2720 if (in
->HashEncryptionAlgorithm
.pszObjId
)
2721 size
+= strlen(in
->HashEncryptionAlgorithm
.pszObjId
) + 1;
2722 size
+= in
->HashEncryptionAlgorithm
.Parameters
.cbData
;
2723 size
+= in
->EncryptedHash
.cbData
;
2725 size
= ALIGN_DWORD_PTR(size
);
2726 size
+= CRYPT_SizeOfAttributes(&in
->AuthAttrs
);
2727 size
+= CRYPT_SizeOfAttributes(&in
->UnauthAttrs
);
2733 else if (*pcbData
< size
)
2736 SetLastError(ERROR_MORE_DATA
);
2741 LPBYTE nextData
= (BYTE
*)pvData
+ sizeof(CMSG_SIGNER_INFO
);
2742 CMSG_SIGNER_INFO
*out
= pvData
;
2745 out
->dwVersion
= in
->dwVersion
;
2746 if (in
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
)
2748 CRYPT_CopyBlob(&out
->Issuer
,
2749 &in
->SignerId
.u
.IssuerSerialNumber
.Issuer
, &nextData
);
2750 CRYPT_CopyBlob(&out
->SerialNumber
,
2751 &in
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
, &nextData
);
2754 ret
= CRYPT_CopyKeyIdAsIssuerAndSerial(&out
->Issuer
, &out
->SerialNumber
,
2755 &in
->SignerId
.u
.KeyId
, rdnSize
, &nextData
);
2758 CRYPT_CopyAlgorithmId(&out
->HashAlgorithm
, &in
->HashAlgorithm
,
2760 CRYPT_CopyAlgorithmId(&out
->HashEncryptionAlgorithm
,
2761 &in
->HashEncryptionAlgorithm
, &nextData
);
2762 CRYPT_CopyBlob(&out
->EncryptedHash
, &in
->EncryptedHash
, &nextData
);
2763 nextData
= POINTER_ALIGN_DWORD_PTR(nextData
);
2764 CRYPT_CopyAttributes(&out
->AuthAttrs
, &in
->AuthAttrs
, &nextData
);
2765 CRYPT_CopyAttributes(&out
->UnauthAttrs
, &in
->UnauthAttrs
, &nextData
);
2768 TRACE("returning %d\n", ret
);
2772 static BOOL
CRYPT_CopyCMSSignerInfo(void *pvData
, DWORD
*pcbData
,
2773 const CMSG_CMS_SIGNER_INFO
*in
)
2775 DWORD size
= sizeof(CMSG_CMS_SIGNER_INFO
);
2778 TRACE("(%p, %d, %p)\n", pvData
, pvData
? *pcbData
: 0, in
);
2780 if (in
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
)
2782 size
+= in
->SignerId
.u
.IssuerSerialNumber
.Issuer
.cbData
;
2783 size
+= in
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
.cbData
;
2786 size
+= in
->SignerId
.u
.KeyId
.cbData
;
2787 if (in
->HashAlgorithm
.pszObjId
)
2788 size
+= strlen(in
->HashAlgorithm
.pszObjId
) + 1;
2789 size
+= in
->HashAlgorithm
.Parameters
.cbData
;
2790 if (in
->HashEncryptionAlgorithm
.pszObjId
)
2791 size
+= strlen(in
->HashEncryptionAlgorithm
.pszObjId
) + 1;
2792 size
+= in
->HashEncryptionAlgorithm
.Parameters
.cbData
;
2793 size
+= in
->EncryptedHash
.cbData
;
2795 size
= ALIGN_DWORD_PTR(size
);
2796 size
+= CRYPT_SizeOfAttributes(&in
->AuthAttrs
);
2797 size
+= CRYPT_SizeOfAttributes(&in
->UnauthAttrs
);
2803 else if (*pcbData
< size
)
2806 SetLastError(ERROR_MORE_DATA
);
2811 LPBYTE nextData
= (BYTE
*)pvData
+ sizeof(CMSG_CMS_SIGNER_INFO
);
2812 CMSG_CMS_SIGNER_INFO
*out
= pvData
;
2814 out
->dwVersion
= in
->dwVersion
;
2815 out
->SignerId
.dwIdChoice
= in
->SignerId
.dwIdChoice
;
2816 if (in
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
)
2818 CRYPT_CopyBlob(&out
->SignerId
.u
.IssuerSerialNumber
.Issuer
,
2819 &in
->SignerId
.u
.IssuerSerialNumber
.Issuer
, &nextData
);
2820 CRYPT_CopyBlob(&out
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
,
2821 &in
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
, &nextData
);
2824 CRYPT_CopyBlob(&out
->SignerId
.u
.KeyId
, &in
->SignerId
.u
.KeyId
, &nextData
);
2825 CRYPT_CopyAlgorithmId(&out
->HashAlgorithm
, &in
->HashAlgorithm
,
2827 CRYPT_CopyAlgorithmId(&out
->HashEncryptionAlgorithm
,
2828 &in
->HashEncryptionAlgorithm
, &nextData
);
2829 CRYPT_CopyBlob(&out
->EncryptedHash
, &in
->EncryptedHash
, &nextData
);
2830 nextData
= POINTER_ALIGN_DWORD_PTR(nextData
);
2831 CRYPT_CopyAttributes(&out
->AuthAttrs
, &in
->AuthAttrs
, &nextData
);
2832 CRYPT_CopyAttributes(&out
->UnauthAttrs
, &in
->UnauthAttrs
, &nextData
);
2835 TRACE("returning %d\n", ret
);
2839 static BOOL
CRYPT_CopySignerCertInfo(void *pvData
, DWORD
*pcbData
,
2840 const CMSG_CMS_SIGNER_INFO
*in
)
2842 DWORD size
= sizeof(CERT_INFO
), rdnSize
= 0;
2845 TRACE("(%p, %d, %p)\n", pvData
, pvData
? *pcbData
: 0, in
);
2847 if (in
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
)
2849 size
+= in
->SignerId
.u
.IssuerSerialNumber
.Issuer
.cbData
;
2850 size
+= in
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
.cbData
;
2854 rdnSize
= CRYPT_SizeOfKeyIdAsIssuerAndSerial(&in
->SignerId
.u
.KeyId
);
2862 else if (*pcbData
< size
)
2865 SetLastError(ERROR_MORE_DATA
);
2870 LPBYTE nextData
= (BYTE
*)pvData
+ sizeof(CERT_INFO
);
2871 CERT_INFO
*out
= pvData
;
2873 memset(out
, 0, sizeof(CERT_INFO
));
2874 if (in
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
)
2876 CRYPT_CopyBlob(&out
->Issuer
,
2877 &in
->SignerId
.u
.IssuerSerialNumber
.Issuer
, &nextData
);
2878 CRYPT_CopyBlob(&out
->SerialNumber
,
2879 &in
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
, &nextData
);
2883 ret
= CRYPT_CopyKeyIdAsIssuerAndSerial(&out
->Issuer
, &out
->SerialNumber
,
2884 &in
->SignerId
.u
.KeyId
, rdnSize
, &nextData
);
2886 TRACE("returning %d\n", ret
);
2890 static BOOL
CRYPT_CopyRecipientInfo(void *pvData
, DWORD
*pcbData
,
2891 const CERT_ISSUER_SERIAL_NUMBER
*in
)
2893 DWORD size
= sizeof(CERT_INFO
);
2896 TRACE("(%p, %d, %p)\n", pvData
, pvData
? *pcbData
: 0, in
);
2898 size
+= in
->SerialNumber
.cbData
;
2899 size
+= in
->Issuer
.cbData
;
2905 else if (*pcbData
< size
)
2908 SetLastError(ERROR_MORE_DATA
);
2913 LPBYTE nextData
= (BYTE
*)pvData
+ sizeof(CERT_INFO
);
2914 CERT_INFO
*out
= pvData
;
2916 CRYPT_CopyBlob(&out
->SerialNumber
, &in
->SerialNumber
, &nextData
);
2917 CRYPT_CopyBlob(&out
->Issuer
, &in
->Issuer
, &nextData
);
2920 TRACE("returning %d\n", ret
);
2924 static BOOL
CDecodeEnvelopedMsg_GetParam(CDecodeMsg
*msg
, DWORD dwParamType
,
2925 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
)
2929 switch (dwParamType
)
2931 case CMSG_TYPE_PARAM
:
2932 ret
= CRYPT_CopyParam(pvData
, pcbData
, &msg
->type
, sizeof(msg
->type
));
2934 case CMSG_CONTENT_PARAM
:
2935 if (msg
->u
.enveloped_data
.data
)
2936 ret
= CRYPT_CopyParam(pvData
, pcbData
,
2937 msg
->u
.enveloped_data
.content
.pbData
,
2938 msg
->u
.enveloped_data
.content
.cbData
);
2940 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
2942 case CMSG_RECIPIENT_COUNT_PARAM
:
2943 if (msg
->u
.enveloped_data
.data
)
2944 ret
= CRYPT_CopyParam(pvData
, pcbData
,
2945 &msg
->u
.enveloped_data
.data
->cRecipientInfo
, sizeof(DWORD
));
2947 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
2949 case CMSG_RECIPIENT_INFO_PARAM
:
2950 if (msg
->u
.enveloped_data
.data
)
2952 if (dwIndex
< msg
->u
.enveloped_data
.data
->cRecipientInfo
)
2954 PCMSG_KEY_TRANS_RECIPIENT_INFO recipientInfo
=
2955 &msg
->u
.enveloped_data
.data
->rgRecipientInfo
[dwIndex
];
2957 ret
= CRYPT_CopyRecipientInfo(pvData
, pcbData
,
2958 &recipientInfo
->RecipientId
.u
.IssuerSerialNumber
);
2961 SetLastError(CRYPT_E_INVALID_INDEX
);
2964 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
2967 FIXME("unimplemented for %d\n", dwParamType
);
2968 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
2973 static BOOL
CDecodeSignedMsg_GetParam(CDecodeMsg
*msg
, DWORD dwParamType
,
2974 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
)
2978 switch (dwParamType
)
2980 case CMSG_TYPE_PARAM
:
2981 ret
= CRYPT_CopyParam(pvData
, pcbData
, &msg
->type
, sizeof(msg
->type
));
2983 case CMSG_CONTENT_PARAM
:
2984 if (msg
->u
.signed_data
.info
)
2986 if (!strcmp(msg
->u
.signed_data
.info
->content
.pszObjId
,
2989 CRYPT_DATA_BLOB
*blob
;
2992 ret
= CryptDecodeObjectEx(X509_ASN_ENCODING
, X509_OCTET_STRING
,
2993 msg
->u
.signed_data
.info
->content
.Content
.pbData
,
2994 msg
->u
.signed_data
.info
->content
.Content
.cbData
,
2995 CRYPT_DECODE_ALLOC_FLAG
, NULL
, &blob
, &size
);
2998 ret
= CRYPT_CopyParam(pvData
, pcbData
, blob
->pbData
,
3004 ret
= CRYPT_CopyParam(pvData
, pcbData
,
3005 msg
->u
.signed_data
.info
->content
.Content
.pbData
,
3006 msg
->u
.signed_data
.info
->content
.Content
.cbData
);
3009 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3011 case CMSG_INNER_CONTENT_TYPE_PARAM
:
3012 if (msg
->u
.signed_data
.info
)
3013 ret
= CRYPT_CopyParam(pvData
, pcbData
,
3014 msg
->u
.signed_data
.info
->content
.pszObjId
,
3015 strlen(msg
->u
.signed_data
.info
->content
.pszObjId
) + 1);
3017 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3019 case CMSG_SIGNER_COUNT_PARAM
:
3020 if (msg
->u
.signed_data
.info
)
3021 ret
= CRYPT_CopyParam(pvData
, pcbData
,
3022 &msg
->u
.signed_data
.info
->cSignerInfo
, sizeof(DWORD
));
3024 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3026 case CMSG_SIGNER_INFO_PARAM
:
3027 if (msg
->u
.signed_data
.info
)
3029 if (dwIndex
>= msg
->u
.signed_data
.info
->cSignerInfo
)
3030 SetLastError(CRYPT_E_INVALID_INDEX
);
3032 ret
= CRYPT_CopySignerInfo(pvData
, pcbData
,
3033 &msg
->u
.signed_data
.info
->rgSignerInfo
[dwIndex
]);
3036 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3038 case CMSG_SIGNER_CERT_INFO_PARAM
:
3039 if (msg
->u
.signed_data
.info
)
3041 if (dwIndex
>= msg
->u
.signed_data
.info
->cSignerInfo
)
3042 SetLastError(CRYPT_E_INVALID_INDEX
);
3044 ret
= CRYPT_CopySignerCertInfo(pvData
, pcbData
,
3045 &msg
->u
.signed_data
.info
->rgSignerInfo
[dwIndex
]);
3048 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3050 case CMSG_CERT_COUNT_PARAM
:
3051 if (msg
->u
.signed_data
.info
)
3052 ret
= CRYPT_CopyParam(pvData
, pcbData
,
3053 &msg
->u
.signed_data
.info
->cCertEncoded
, sizeof(DWORD
));
3055 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3057 case CMSG_CERT_PARAM
:
3058 if (msg
->u
.signed_data
.info
)
3060 if (dwIndex
>= msg
->u
.signed_data
.info
->cCertEncoded
)
3061 SetLastError(CRYPT_E_INVALID_INDEX
);
3063 ret
= CRYPT_CopyParam(pvData
, pcbData
,
3064 msg
->u
.signed_data
.info
->rgCertEncoded
[dwIndex
].pbData
,
3065 msg
->u
.signed_data
.info
->rgCertEncoded
[dwIndex
].cbData
);
3068 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3070 case CMSG_CRL_COUNT_PARAM
:
3071 if (msg
->u
.signed_data
.info
)
3072 ret
= CRYPT_CopyParam(pvData
, pcbData
,
3073 &msg
->u
.signed_data
.info
->cCrlEncoded
, sizeof(DWORD
));
3075 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3077 case CMSG_CRL_PARAM
:
3078 if (msg
->u
.signed_data
.info
)
3080 if (dwIndex
>= msg
->u
.signed_data
.info
->cCrlEncoded
)
3081 SetLastError(CRYPT_E_INVALID_INDEX
);
3083 ret
= CRYPT_CopyParam(pvData
, pcbData
,
3084 msg
->u
.signed_data
.info
->rgCrlEncoded
[dwIndex
].pbData
,
3085 msg
->u
.signed_data
.info
->rgCrlEncoded
[dwIndex
].cbData
);
3088 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3090 case CMSG_COMPUTED_HASH_PARAM
:
3091 if (msg
->u
.signed_data
.info
)
3093 if (dwIndex
>= msg
->u
.signed_data
.cSignerHandle
)
3094 SetLastError(CRYPT_E_INVALID_INDEX
);
3096 ret
= CryptGetHashParam(
3097 msg
->u
.signed_data
.signerHandles
[dwIndex
].contentHash
,
3098 HP_HASHVAL
, pvData
, pcbData
, 0);
3101 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3103 case CMSG_ENCODED_SIGNER
:
3104 if (msg
->u
.signed_data
.info
)
3106 if (dwIndex
>= msg
->u
.signed_data
.info
->cSignerInfo
)
3107 SetLastError(CRYPT_E_INVALID_INDEX
);
3109 ret
= CryptEncodeObjectEx(
3110 X509_ASN_ENCODING
| PKCS_7_ASN_ENCODING
, CMS_SIGNER_INFO
,
3111 &msg
->u
.signed_data
.info
->rgSignerInfo
[dwIndex
], 0, NULL
,
3115 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3117 case CMSG_ATTR_CERT_COUNT_PARAM
:
3118 if (msg
->u
.signed_data
.info
)
3120 DWORD attrCertCount
= 0;
3122 ret
= CRYPT_CopyParam(pvData
, pcbData
,
3123 &attrCertCount
, sizeof(DWORD
));
3126 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3128 case CMSG_ATTR_CERT_PARAM
:
3129 if (msg
->u
.signed_data
.info
)
3130 SetLastError(CRYPT_E_INVALID_INDEX
);
3132 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3134 case CMSG_CMS_SIGNER_INFO_PARAM
:
3135 if (msg
->u
.signed_data
.info
)
3137 if (dwIndex
>= msg
->u
.signed_data
.info
->cSignerInfo
)
3138 SetLastError(CRYPT_E_INVALID_INDEX
);
3140 ret
= CRYPT_CopyCMSSignerInfo(pvData
, pcbData
,
3141 &msg
->u
.signed_data
.info
->rgSignerInfo
[dwIndex
]);
3144 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3147 FIXME("unimplemented for %d\n", dwParamType
);
3148 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3153 static BOOL
CDecodeMsg_GetParam(HCRYPTMSG hCryptMsg
, DWORD dwParamType
,
3154 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
)
3156 CDecodeMsg
*msg
= hCryptMsg
;
3162 ret
= CDecodeHashMsg_GetParam(msg
, dwParamType
, dwIndex
, pvData
,
3165 case CMSG_ENVELOPED
:
3166 ret
= CDecodeEnvelopedMsg_GetParam(msg
, dwParamType
, dwIndex
, pvData
,
3170 ret
= CDecodeSignedMsg_GetParam(msg
, dwParamType
, dwIndex
, pvData
,
3174 switch (dwParamType
)
3176 case CMSG_TYPE_PARAM
:
3177 ret
= CRYPT_CopyParam(pvData
, pcbData
, &msg
->type
,
3182 CRYPT_DATA_BLOB blob
;
3184 ret
= ContextPropertyList_FindProperty(msg
->properties
, dwParamType
,
3187 ret
= CRYPT_CopyParam(pvData
, pcbData
, blob
.pbData
,
3190 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3197 static BOOL
CDecodeHashMsg_VerifyHash(CDecodeMsg
*msg
)
3200 CRYPT_DATA_BLOB hashBlob
;
3202 ret
= ContextPropertyList_FindProperty(msg
->properties
,
3203 CMSG_HASH_DATA_PARAM
, &hashBlob
);
3206 DWORD computedHashSize
= 0;
3208 ret
= CDecodeHashMsg_GetParam(msg
, CMSG_COMPUTED_HASH_PARAM
, 0, NULL
,
3210 if (hashBlob
.cbData
== computedHashSize
)
3212 LPBYTE computedHash
= CryptMemAlloc(computedHashSize
);
3216 ret
= CDecodeHashMsg_GetParam(msg
, CMSG_COMPUTED_HASH_PARAM
, 0,
3217 computedHash
, &computedHashSize
);
3220 if (memcmp(hashBlob
.pbData
, computedHash
, hashBlob
.cbData
))
3222 SetLastError(CRYPT_E_HASH_VALUE
);
3226 CryptMemFree(computedHash
);
3230 SetLastError(ERROR_OUTOFMEMORY
);
3236 SetLastError(CRYPT_E_HASH_VALUE
);
3243 static BOOL
CDecodeSignedMsg_VerifySignatureWithKey(CDecodeMsg
*msg
,
3244 HCRYPTPROV prov
, DWORD signerIndex
, PCERT_PUBLIC_KEY_INFO keyInfo
)
3250 prov
= msg
->crypt_prov
;
3251 ret
= CryptImportPublicKeyInfo(prov
, X509_ASN_ENCODING
, keyInfo
, &key
);
3255 CRYPT_HASH_BLOB reversedHash
;
3257 if (msg
->u
.signed_data
.info
->rgSignerInfo
[signerIndex
].AuthAttrs
.cAttr
)
3258 hash
= msg
->u
.signed_data
.signerHandles
[signerIndex
].authAttrHash
;
3260 hash
= msg
->u
.signed_data
.signerHandles
[signerIndex
].contentHash
;
3261 ret
= CRYPT_ConstructBlob(&reversedHash
,
3262 &msg
->u
.signed_data
.info
->rgSignerInfo
[signerIndex
].EncryptedHash
);
3265 CRYPT_ReverseBytes(&reversedHash
);
3266 ret
= CryptVerifySignatureW(hash
, reversedHash
.pbData
,
3267 reversedHash
.cbData
, key
, NULL
, 0);
3268 CryptMemFree(reversedHash
.pbData
);
3270 CryptDestroyKey(key
);
3275 static BOOL
CDecodeSignedMsg_VerifySignature(CDecodeMsg
*msg
, PCERT_INFO info
)
3280 if (!msg
->u
.signed_data
.signerHandles
)
3282 SetLastError(NTE_BAD_SIGNATURE
);
3285 for (i
= 0; !ret
&& i
< msg
->u
.signed_data
.info
->cSignerInfo
; i
++)
3287 PCMSG_CMS_SIGNER_INFO signerInfo
=
3288 &msg
->u
.signed_data
.info
->rgSignerInfo
[i
];
3290 if (signerInfo
->SignerId
.dwIdChoice
== CERT_ID_ISSUER_SERIAL_NUMBER
)
3292 ret
= CertCompareCertificateName(X509_ASN_ENCODING
,
3293 &signerInfo
->SignerId
.u
.IssuerSerialNumber
.Issuer
,
3297 ret
= CertCompareIntegerBlob(
3298 &signerInfo
->SignerId
.u
.IssuerSerialNumber
.SerialNumber
,
3299 &info
->SerialNumber
);
3306 FIXME("signer %d: unimplemented for key id\n", i
);
3310 ret
= CDecodeSignedMsg_VerifySignatureWithKey(msg
, 0, i
,
3311 &info
->SubjectPublicKeyInfo
);
3313 SetLastError(CRYPT_E_SIGNER_NOT_FOUND
);
3318 static BOOL
CDecodeSignedMsg_VerifySignatureEx(CDecodeMsg
*msg
,
3319 PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA para
)
3323 if (para
->cbSize
!= sizeof(CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA
))
3324 SetLastError(ERROR_INVALID_PARAMETER
);
3325 else if (para
->dwSignerIndex
>= msg
->u
.signed_data
.info
->cSignerInfo
)
3326 SetLastError(CRYPT_E_SIGNER_NOT_FOUND
);
3327 else if (!msg
->u
.signed_data
.signerHandles
)
3328 SetLastError(NTE_BAD_SIGNATURE
);
3331 switch (para
->dwSignerType
)
3333 case CMSG_VERIFY_SIGNER_PUBKEY
:
3334 ret
= CDecodeSignedMsg_VerifySignatureWithKey(msg
,
3335 para
->hCryptProv
, para
->dwSignerIndex
, para
->pvSigner
);
3337 case CMSG_VERIFY_SIGNER_CERT
:
3339 PCCERT_CONTEXT cert
= para
->pvSigner
;
3341 ret
= CDecodeSignedMsg_VerifySignatureWithKey(msg
, para
->hCryptProv
,
3342 para
->dwSignerIndex
, &cert
->pCertInfo
->SubjectPublicKeyInfo
);
3346 FIXME("unimplemented for signer type %d\n", para
->dwSignerType
);
3347 SetLastError(CRYPT_E_SIGNER_NOT_FOUND
);
3353 static BOOL WINAPI
CRYPT_ImportKeyTrans(
3354 PCRYPT_ALGORITHM_IDENTIFIER pContentEncryptionAlgorithm
,
3355 PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA pKeyTransDecryptPara
, DWORD dwFlags
,
3356 void *pvReserved
, HCRYPTKEY
*phContentEncryptKey
)
3361 ret
= CryptGetUserKey(pKeyTransDecryptPara
->hCryptProv
,
3362 pKeyTransDecryptPara
->dwKeySpec
? pKeyTransDecryptPara
->dwKeySpec
:
3363 AT_KEYEXCHANGE
, &key
);
3366 CMSG_KEY_TRANS_RECIPIENT_INFO
*info
=
3367 &pKeyTransDecryptPara
->pKeyTrans
[pKeyTransDecryptPara
->dwRecipientIndex
];
3368 CRYPT_DATA_BLOB
*encryptedKey
= &info
->EncryptedKey
;
3369 DWORD size
= encryptedKey
->cbData
+ sizeof(BLOBHEADER
) + sizeof(ALG_ID
);
3370 BYTE
*keyBlob
= CryptMemAlloc(size
);
3374 DWORD i
, k
= size
- 1;
3375 BLOBHEADER
*blobHeader
= (BLOBHEADER
*)keyBlob
;
3376 ALG_ID
*algID
= (ALG_ID
*)(keyBlob
+ sizeof(BLOBHEADER
));
3378 blobHeader
->bType
= SIMPLEBLOB
;
3379 blobHeader
->bVersion
= CUR_BLOB_VERSION
;
3380 blobHeader
->reserved
= 0;
3381 blobHeader
->aiKeyAlg
= CertOIDToAlgId(
3382 pContentEncryptionAlgorithm
->pszObjId
);
3383 *algID
= CertOIDToAlgId(info
->KeyEncryptionAlgorithm
.pszObjId
);
3384 for (i
= 0; i
< encryptedKey
->cbData
; ++i
, --k
)
3385 keyBlob
[k
] = encryptedKey
->pbData
[i
];
3387 ret
= CryptImportKey(pKeyTransDecryptPara
->hCryptProv
, keyBlob
,
3388 size
, key
, 0, phContentEncryptKey
);
3389 CryptMemFree(keyBlob
);
3393 CryptDestroyKey(key
);
3398 static BOOL
CRYPT_ImportEncryptedKey(PCRYPT_ALGORITHM_IDENTIFIER contEncrAlg
,
3399 PCMSG_CTRL_DECRYPT_PARA para
, PCMSG_KEY_TRANS_RECIPIENT_INFO info
,
3402 static HCRYPTOIDFUNCSET set
= NULL
;
3403 PFN_CMSG_IMPORT_KEY_TRANS importKeyFunc
= NULL
;
3404 HCRYPTOIDFUNCADDR hFunc
= NULL
;
3405 CMSG_CTRL_KEY_TRANS_DECRYPT_PARA decryptPara
;
3408 memset(&decryptPara
, 0, sizeof(decryptPara
));
3409 decryptPara
.cbSize
= sizeof(decryptPara
);
3410 decryptPara
.hCryptProv
= para
->hCryptProv
;
3411 decryptPara
.dwKeySpec
= para
->dwKeySpec
;
3412 decryptPara
.pKeyTrans
= info
;
3413 decryptPara
.dwRecipientIndex
= para
->dwRecipientIndex
;
3416 set
= CryptInitOIDFunctionSet(CMSG_OID_IMPORT_KEY_TRANS_FUNC
, 0);
3417 CryptGetOIDFunctionAddress(set
, X509_ASN_ENCODING
, contEncrAlg
->pszObjId
, 0,
3418 (void **)&importKeyFunc
, &hFunc
);
3420 importKeyFunc
= CRYPT_ImportKeyTrans
;
3421 ret
= importKeyFunc(contEncrAlg
, &decryptPara
, 0, NULL
, key
);
3423 CryptFreeOIDFunctionAddress(hFunc
, 0);
3427 static BOOL
CDecodeEnvelopedMsg_CrtlDecrypt(CDecodeMsg
*msg
,
3428 PCMSG_CTRL_DECRYPT_PARA para
)
3431 CEnvelopedDecodeMsg
*enveloped_data
= &msg
->u
.enveloped_data
;
3432 CRYPT_ENVELOPED_DATA
*data
= enveloped_data
->data
;
3434 if (para
->cbSize
!= sizeof(CMSG_CTRL_DECRYPT_PARA
))
3435 SetLastError(E_INVALIDARG
);
3437 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3438 else if (para
->dwRecipientIndex
>= data
->cRecipientInfo
)
3439 SetLastError(CRYPT_E_INVALID_INDEX
);
3440 else if (enveloped_data
->decrypted
)
3441 SetLastError(CRYPT_E_ALREADY_DECRYPTED
);
3442 else if (!para
->hCryptProv
)
3443 SetLastError(ERROR_INVALID_PARAMETER
);
3444 else if (enveloped_data
->content
.cbData
)
3448 ret
= CRYPT_ImportEncryptedKey(
3449 &data
->encryptedContentInfo
.contentEncryptionAlgorithm
, para
,
3450 data
->rgRecipientInfo
, &key
);
3453 ret
= CryptDecrypt(key
, 0, TRUE
, 0, enveloped_data
->content
.pbData
,
3454 &enveloped_data
->content
.cbData
);
3455 CryptDestroyKey(key
);
3461 enveloped_data
->decrypted
= TRUE
;
3465 static BOOL
CDecodeMsg_Control(HCRYPTMSG hCryptMsg
, DWORD dwFlags
,
3466 DWORD dwCtrlType
, const void *pvCtrlPara
)
3468 CDecodeMsg
*msg
= hCryptMsg
;
3473 case CMSG_CTRL_VERIFY_SIGNATURE
:
3477 ret
= CDecodeSignedMsg_VerifySignature(msg
, (PCERT_INFO
)pvCtrlPara
);
3480 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3483 case CMSG_CTRL_DECRYPT
:
3486 case CMSG_ENVELOPED
:
3487 ret
= CDecodeEnvelopedMsg_CrtlDecrypt(msg
,
3488 (PCMSG_CTRL_DECRYPT_PARA
)pvCtrlPara
);
3489 if (ret
&& (dwFlags
& CMSG_CRYPT_RELEASE_CONTEXT_FLAG
))
3490 msg
->u
.enveloped_data
.crypt_prov
=
3491 ((PCMSG_CTRL_DECRYPT_PARA
)pvCtrlPara
)->hCryptProv
;
3494 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3497 case CMSG_CTRL_VERIFY_HASH
:
3501 ret
= CDecodeHashMsg_VerifyHash(msg
);
3504 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3507 case CMSG_CTRL_VERIFY_SIGNATURE_EX
:
3511 ret
= CDecodeSignedMsg_VerifySignatureEx(msg
,
3512 (PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA
)pvCtrlPara
);
3515 SetLastError(CRYPT_E_INVALID_MSG_TYPE
);
3519 SetLastError(CRYPT_E_CONTROL_TYPE
);
3524 HCRYPTMSG WINAPI
CryptMsgOpenToDecode(DWORD dwMsgEncodingType
, DWORD dwFlags
,
3525 DWORD dwMsgType
, HCRYPTPROV_LEGACY hCryptProv
, PCERT_INFO pRecipientInfo
,
3526 PCMSG_STREAM_INFO pStreamInfo
)
3530 TRACE("(%08x, %08x, %08x, %08lx, %p, %p)\n", dwMsgEncodingType
,
3531 dwFlags
, dwMsgType
, hCryptProv
, pRecipientInfo
, pStreamInfo
);
3533 if (GET_CMSG_ENCODING_TYPE(dwMsgEncodingType
) != PKCS_7_ASN_ENCODING
)
3535 SetLastError(E_INVALIDARG
);
3538 msg
= CryptMemAlloc(sizeof(CDecodeMsg
));
3541 CryptMsgBase_Init((CryptMsgBase
*)msg
, dwFlags
, pStreamInfo
,
3542 CDecodeMsg_Close
, CDecodeMsg_GetParam
, CDecodeMsg_Update
,
3543 CDecodeMsg_Control
);
3544 msg
->type
= dwMsgType
;
3546 msg
->crypt_prov
= hCryptProv
;
3549 msg
->crypt_prov
= CRYPT_GetDefaultProvider();
3550 msg
->base
.open_flags
&= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG
;
3552 memset(&msg
->u
, 0, sizeof(msg
->u
));
3553 msg
->msg_data
.cbData
= 0;
3554 msg
->msg_data
.pbData
= NULL
;
3555 msg
->detached_data
.cbData
= 0;
3556 msg
->detached_data
.pbData
= NULL
;
3557 msg
->properties
= ContextPropertyList_Create();
3562 HCRYPTMSG WINAPI
CryptMsgDuplicate(HCRYPTMSG hCryptMsg
)
3564 TRACE("(%p)\n", hCryptMsg
);
3568 CryptMsgBase
*msg
= hCryptMsg
;
3570 InterlockedIncrement(&msg
->ref
);
3575 BOOL WINAPI
CryptMsgClose(HCRYPTMSG hCryptMsg
)
3577 TRACE("(%p)\n", hCryptMsg
);
3581 CryptMsgBase
*msg
= hCryptMsg
;
3583 if (InterlockedDecrement(&msg
->ref
) == 0)
3585 TRACE("freeing %p\n", msg
);
3594 BOOL WINAPI
CryptMsgUpdate(HCRYPTMSG hCryptMsg
, const BYTE
*pbData
,
3595 DWORD cbData
, BOOL fFinal
)
3597 CryptMsgBase
*msg
= hCryptMsg
;
3599 TRACE("(%p, %p, %d, %d)\n", hCryptMsg
, pbData
, cbData
, fFinal
);
3601 return msg
->update(hCryptMsg
, pbData
, cbData
, fFinal
);
3604 BOOL WINAPI
CryptMsgGetParam(HCRYPTMSG hCryptMsg
, DWORD dwParamType
,
3605 DWORD dwIndex
, void *pvData
, DWORD
*pcbData
)
3607 CryptMsgBase
*msg
= hCryptMsg
;
3609 TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg
, dwParamType
, dwIndex
,
3611 return msg
->get_param(hCryptMsg
, dwParamType
, dwIndex
, pvData
, pcbData
);
3614 BOOL WINAPI
CryptMsgControl(HCRYPTMSG hCryptMsg
, DWORD dwFlags
,
3615 DWORD dwCtrlType
, const void *pvCtrlPara
)
3617 CryptMsgBase
*msg
= hCryptMsg
;
3619 TRACE("(%p, %08x, %d, %p)\n", hCryptMsg
, dwFlags
, dwCtrlType
,
3621 return msg
->control(hCryptMsg
, dwFlags
, dwCtrlType
, pvCtrlPara
);
3624 static CERT_INFO
*CRYPT_GetSignerCertInfoFromMsg(HCRYPTMSG msg
,
3625 DWORD dwSignerIndex
)
3627 CERT_INFO
*certInfo
= NULL
;
3630 if (CryptMsgGetParam(msg
, CMSG_SIGNER_CERT_INFO_PARAM
, dwSignerIndex
, NULL
,
3633 certInfo
= CryptMemAlloc(size
);
3636 if (!CryptMsgGetParam(msg
, CMSG_SIGNER_CERT_INFO_PARAM
,
3637 dwSignerIndex
, certInfo
, &size
))
3639 CryptMemFree(certInfo
);
3647 BOOL WINAPI
CryptMsgGetAndVerifySigner(HCRYPTMSG hCryptMsg
, DWORD cSignerStore
,
3648 HCERTSTORE
*rghSignerStore
, DWORD dwFlags
, PCCERT_CONTEXT
*ppSigner
,
3649 DWORD
*pdwSignerIndex
)
3652 DWORD i
, signerIndex
= 0;
3653 PCCERT_CONTEXT signerCert
= NULL
;
3656 TRACE("(%p, %d, %p, %08x, %p, %p)\n", hCryptMsg
, cSignerStore
,
3657 rghSignerStore
, dwFlags
, ppSigner
, pdwSignerIndex
);
3659 /* Clear output parameters */
3662 if (pdwSignerIndex
&& !(dwFlags
& CMSG_USE_SIGNER_INDEX_FLAG
))
3663 *pdwSignerIndex
= 0;
3665 /* Create store to search for signer certificates */
3666 store
= CertOpenStore(CERT_STORE_PROV_COLLECTION
, 0, 0,
3667 CERT_STORE_CREATE_NEW_FLAG
, NULL
);
3668 if (!(dwFlags
& CMSG_TRUSTED_SIGNER_FLAG
))
3670 HCERTSTORE msgStore
= CertOpenStore(CERT_STORE_PROV_MSG
, 0, 0, 0,
3673 CertAddStoreToCollection(store
, msgStore
, 0, 0);
3674 CertCloseStore(msgStore
, 0);
3676 for (i
= 0; i
< cSignerStore
; i
++)
3677 CertAddStoreToCollection(store
, rghSignerStore
[i
], 0, 0);
3679 /* Find signer cert */
3680 if (dwFlags
& CMSG_USE_SIGNER_INDEX_FLAG
)
3682 CERT_INFO
*signer
= CRYPT_GetSignerCertInfoFromMsg(hCryptMsg
,
3687 signerIndex
= *pdwSignerIndex
;
3688 signerCert
= CertFindCertificateInStore(store
, X509_ASN_ENCODING
,
3689 0, CERT_FIND_SUBJECT_CERT
, signer
, NULL
);
3690 CryptMemFree(signer
);
3695 DWORD count
, size
= sizeof(count
);
3697 if (CryptMsgGetParam(hCryptMsg
, CMSG_SIGNER_COUNT_PARAM
, 0, &count
,
3700 for (i
= 0; !signerCert
&& i
< count
; i
++)
3702 CERT_INFO
*signer
= CRYPT_GetSignerCertInfoFromMsg(hCryptMsg
,
3707 signerCert
= CertFindCertificateInStore(store
,
3708 X509_ASN_ENCODING
, 0, CERT_FIND_SUBJECT_CERT
, signer
,
3712 CryptMemFree(signer
);
3717 SetLastError(CRYPT_E_NO_TRUSTED_SIGNER
);
3721 if (!(dwFlags
& CMSG_SIGNER_ONLY_FLAG
))
3722 ret
= CryptMsgControl(hCryptMsg
, 0, CMSG_CTRL_VERIFY_SIGNATURE
,
3723 signerCert
->pCertInfo
);
3729 *ppSigner
= CertDuplicateCertificateContext(signerCert
);
3731 *pdwSignerIndex
= signerIndex
;
3733 CertFreeCertificateContext(signerCert
);
3736 CertCloseStore(store
, 0);
3740 BOOL WINAPI
CryptMsgVerifyCountersignatureEncodedEx(HCRYPTPROV_LEGACY hCryptProv
,
3741 DWORD dwEncodingType
, PBYTE pbSignerInfo
, DWORD cbSignerInfo
,
3742 PBYTE pbSignerInfoCountersignature
, DWORD cbSignerInfoCountersignature
,
3743 DWORD dwSignerType
, void *pvSigner
, DWORD dwFlags
, void *pvReserved
)
3745 FIXME("(%08lx, %08x, %p, %d, %p, %d, %d, %p, %08x, %p): stub\n", hCryptProv
,
3746 dwEncodingType
, pbSignerInfo
, cbSignerInfo
, pbSignerInfoCountersignature
,
3747 cbSignerInfoCountersignature
, dwSignerType
, pvSigner
, dwFlags
, pvReserved
);
3751 BOOL WINAPI
CryptMsgEncodeAndSignCTL(DWORD dwMsgEncodingType
,
3752 PCTL_INFO pCtlInfo
, PCMSG_SIGNED_ENCODE_INFO pSignInfo
, DWORD dwFlags
,
3753 BYTE
*pbEncoded
, DWORD
*pcbEncoded
)
3759 TRACE("(%08x, %p, %p, %08x, %p, %p)\n", dwMsgEncodingType
, pCtlInfo
,
3760 pSignInfo
, dwFlags
, pbEncoded
, pcbEncoded
);
3764 FIXME("unimplemented for flags %08x\n", dwFlags
);
3767 if ((ret
= CryptEncodeObjectEx(dwMsgEncodingType
, PKCS_CTL
, pCtlInfo
,
3768 CRYPT_ENCODE_ALLOC_FLAG
, NULL
, &pbCtlContent
, &cbCtlContent
)))
3770 ret
= CryptMsgSignCTL(dwMsgEncodingType
, pbCtlContent
, cbCtlContent
,
3771 pSignInfo
, dwFlags
, pbEncoded
, pcbEncoded
);
3772 LocalFree(pbCtlContent
);
3777 BOOL WINAPI
CryptMsgSignCTL(DWORD dwMsgEncodingType
, BYTE
*pbCtlContent
,
3778 DWORD cbCtlContent
, PCMSG_SIGNED_ENCODE_INFO pSignInfo
, DWORD dwFlags
,
3779 BYTE
*pbEncoded
, DWORD
*pcbEncoded
)
3781 static char oid_ctl
[] = szOID_CTL
;
3785 TRACE("(%08x, %p, %d, %p, %08x, %p, %p)\n", dwMsgEncodingType
,
3786 pbCtlContent
, cbCtlContent
, pSignInfo
, dwFlags
, pbEncoded
, pcbEncoded
);
3790 FIXME("unimplemented for flags %08x\n", dwFlags
);
3793 msg
= CryptMsgOpenToEncode(dwMsgEncodingType
, 0, CMSG_SIGNED
, pSignInfo
,
3797 ret
= CryptMsgUpdate(msg
, pbCtlContent
, cbCtlContent
, TRUE
);
3799 ret
= CryptMsgGetParam(msg
, CMSG_CONTENT_PARAM
, 0, pbEncoded
,