ReactOS 0.4.15-dev-8348-gc1b9bb5
msg.c File Reference
#include "config.h"
#include "wine/port.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wincrypt.h"
#include "snmp.h"
#include "wine/debug.h"
#include "wine/exception.h"
#include "crypt32_private.h"
Include dependency graph for msg.c:

Go to the source code of this file.

Classes

struct  _CryptMsgBase
 
struct  _CDataEncodeMsg
 
struct  _CHashEncodeMsg
 
struct  _CMSG_SIGNER_ENCODE_INFO_WITH_CMS
 
struct  _CMSG_SIGNED_ENCODE_INFO_WITH_CMS
 
struct  _CSignerHandles
 
struct  _CSignedMsgData
 
struct  _CSignedEncodeMsg
 
struct  _CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS
 
struct  _CEnvelopedEncodeMsg
 
struct  _CEnvelopedDecodeMsg
 
struct  _CDecodeMsg
 

Macros

#define NONAMELESSUNION
 

Typedefs

typedef void(* CryptMsgCloseFunc) (HCRYPTMSG msg)
 
typedef BOOL(* CryptMsgGetParamFunc) (HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
typedef BOOL(* CryptMsgUpdateFunc) (HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
 
typedef BOOL(* CryptMsgControlFunc) (HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, const void *pvCtrlPara)
 
typedef enum _CryptMsgState CryptMsgState
 
typedef struct _CryptMsgBase CryptMsgBase
 
typedef struct _CDataEncodeMsg CDataEncodeMsg
 
typedef struct _CHashEncodeMsg CHashEncodeMsg
 
typedef struct _CMSG_SIGNER_ENCODE_INFO_WITH_CMS CMSG_SIGNER_ENCODE_INFO_WITH_CMS
 
typedef struct _CMSG_SIGNED_ENCODE_INFO_WITH_CMS CMSG_SIGNED_ENCODE_INFO_WITH_CMS
 
typedef struct _CSignerHandles CSignerHandles
 
typedef struct _CSignedMsgData CSignedMsgData
 
typedef struct _CSignedEncodeMsg CSignedEncodeMsg
 
typedef struct _CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS
 
typedef struct _CEnvelopedEncodeMsg CEnvelopedEncodeMsg
 
typedef struct _CEnvelopedDecodeMsg CEnvelopedDecodeMsg
 
typedef struct _CDecodeMsg CDecodeMsg
 

Enumerations

enum  _CryptMsgState { MsgStateInit , MsgStateUpdated , MsgStateDataFinalized , MsgStateFinalized }
 
enum  SignOrVerify { Sign , Verify }
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (crypt)
 
static BOOL CRYPT_DefaultMsgControl (HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, const void *pvCtrlPara)
 
static void CryptMsgBase_Init (CryptMsgBase *msg, DWORD dwFlags, PCMSG_STREAM_INFO pStreamInfo, CryptMsgCloseFunc close, CryptMsgGetParamFunc get_param, CryptMsgUpdateFunc update, CryptMsgControlFunc control)
 
static void CDataEncodeMsg_Close (HCRYPTMSG hCryptMsg)
 
static BOOL WINAPI CRYPT_EncodeContentLength (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL CRYPT_EncodeDataContentInfoHeader (const CDataEncodeMsg *msg, CRYPT_DATA_BLOB *header)
 
static BOOL CDataEncodeMsg_Update (HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
 
static BOOL CRYPT_CopyParam (void *pvData, DWORD *pcbData, const void *src, DWORD len)
 
static BOOL CDataEncodeMsg_GetParam (HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
static HCRYPTMSG CDataEncodeMsg_Open (DWORD dwFlags, const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
 
static void CHashEncodeMsg_Close (HCRYPTMSG hCryptMsg)
 
static BOOL CRYPT_EncodePKCSDigestedData (CHashEncodeMsg *msg, void *pvData, DWORD *pcbData)
 
static BOOL CHashEncodeMsg_GetParam (HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
static BOOL CHashEncodeMsg_Update (HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
 
static HCRYPTMSG CHashEncodeMsg_Open (DWORD dwFlags, const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
 
static BOOL CRYPT_IsValidSigner (const CMSG_SIGNER_ENCODE_INFO_WITH_CMS *signer)
 
static BOOL CRYPT_ConstructBlob (CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
 
static BOOL CRYPT_ConstructBlobArray (DWORD *outCBlobs, PCRYPT_DATA_BLOB *outPBlobs, DWORD cBlobs, const CRYPT_DATA_BLOB *pBlobs)
 
static void CRYPT_FreeBlobArray (DWORD cBlobs, PCRYPT_DATA_BLOB blobs)
 
static BOOL CRYPT_ConstructAttribute (CRYPT_ATTRIBUTE *out, const CRYPT_ATTRIBUTE *in)
 
static BOOL CRYPT_ConstructAttributes (CRYPT_ATTRIBUTES *out, const CRYPT_ATTRIBUTES *in)
 
static BOOL CSignerInfo_Construct (CMSG_CMS_SIGNER_INFO *info, const CMSG_SIGNER_ENCODE_INFO_WITH_CMS *in)
 
static void CSignerInfo_Free (CMSG_CMS_SIGNER_INFO *info)
 
static BOOL CSignedMsgData_ConstructSignerHandles (CSignedMsgData *msg_data, DWORD signerIndex, HCRYPTPROV *crypt_prov, DWORD *flags)
 
static BOOL CSignedMsgData_AllocateHandles (CSignedMsgData *msg_data)
 
static void CSignedMsgData_CloseHandles (CSignedMsgData *msg_data)
 
static BOOL CSignedMsgData_UpdateHash (CSignedMsgData *msg_data, const BYTE *pbData, DWORD cbData)
 
static BOOL CRYPT_AppendAttribute (CRYPT_ATTRIBUTES *out, const CRYPT_ATTRIBUTE *in)
 
static BOOL CSignedMsgData_AppendMessageDigestAttribute (CSignedMsgData *msg_data, DWORD signerIndex)
 
static BOOL CSignedMsgData_UpdateAuthenticatedAttributes (CSignedMsgData *msg_data, SignOrVerify flag)
 
static void CRYPT_ReverseBytes (CRYPT_HASH_BLOB *hash)
 
static BOOL CSignedMsgData_Sign (CSignedMsgData *msg_data)
 
static BOOL CSignedMsgData_Update (CSignedMsgData *msg_data, const BYTE *pbData, DWORD cbData, BOOL fFinal, SignOrVerify flag)
 
static void CSignedEncodeMsg_Close (HCRYPTMSG hCryptMsg)
 
static BOOL CSignedEncodeMsg_GetParam (HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
static BOOL CSignedEncodeMsg_Update (HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
 
static HCRYPTMSG CSignedEncodeMsg_Open (DWORD dwFlags, const void *pvMsgEncodeInfo, LPCSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
 
static BOOL CRYPT_ConstructAlgorithmId (CRYPT_ALGORITHM_IDENTIFIER *out, const CRYPT_ALGORITHM_IDENTIFIER *in)
 
static BOOL CRYPT_ConstructBitBlob (CRYPT_BIT_BLOB *out, const CRYPT_BIT_BLOB *in)
 
static BOOL CRYPT_GenKey (CMSG_CONTENT_ENCRYPT_INFO *info, ALG_ID algID)
 
static BOOL WINAPI CRYPT_ExportKeyTrans (PCMSG_CONTENT_ENCRYPT_INFO pContentEncryptInfo, PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO pKeyTransEncodeInfo, PCMSG_KEY_TRANS_ENCRYPT_INFO pKeyTransEncryptInfo, DWORD dwFlags, void *pvReserved)
 
static BOOL CRYPT_ExportEncryptedKey (CMSG_CONTENT_ENCRYPT_INFO *info, DWORD i, CRYPT_DATA_BLOB *key)
 
static LPVOID WINAPI mem_alloc (size_t size)
 
static VOID WINAPI mem_free (LPVOID pv)
 
static BOOL CContentEncryptInfo_Construct (CMSG_CONTENT_ENCRYPT_INFO *info, const CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS *in, HCRYPTPROV prov)
 
static void CContentEncryptInfo_Free (CMSG_CONTENT_ENCRYPT_INFO *info)
 
static BOOL CRecipientInfo_Construct (CMSG_KEY_TRANS_RECIPIENT_INFO *info, const CERT_INFO *cert, CRYPT_DATA_BLOB *key)
 
static void CRecipientInfo_Free (CMSG_KEY_TRANS_RECIPIENT_INFO *info)
 
static void CEnvelopedEncodeMsg_Close (HCRYPTMSG hCryptMsg)
 
static BOOL CEnvelopedEncodeMsg_GetParam (HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
static BOOL CEnvelopedEncodeMsg_Update (HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
 
static HCRYPTMSG CEnvelopedEncodeMsg_Open (DWORD dwFlags, const void *pvMsgEncodeInfo, LPCSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
 
HCRYPTMSG WINAPI CryptMsgOpenToEncode (DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
 
static void CDecodeMsg_Close (HCRYPTMSG hCryptMsg)
 
static BOOL CDecodeMsg_CopyData (CRYPT_DATA_BLOB *blob, const BYTE *pbData, DWORD cbData)
 
static BOOL CDecodeMsg_DecodeDataContent (CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
 
static void CDecodeMsg_SaveAlgorithmID (CDecodeMsg *msg, DWORD param, const CRYPT_ALGORITHM_IDENTIFIER *id)
 
static void CRYPT_FixUpAlgorithmID (CRYPT_ALGORITHM_IDENTIFIER *id)
 
static BOOL CDecodeMsg_DecodeHashedContent (CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
 
static BOOL CDecodeMsg_DecodeEnvelopedContent (CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
 
static BOOL CDecodeMsg_DecodeSignedContent (CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
 
static BOOL CDecodeMsg_DecodeContent (CDecodeMsg *msg, const CRYPT_DER_BLOB *blob, DWORD type)
 
static BOOL CDecodeMsg_FinalizeHashedContent (CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
 
static BOOL CDecodeMsg_FinalizeEnvelopedContent (CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
 
static BOOL CDecodeMsg_FinalizeSignedContent (CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
 
static BOOL CDecodeMsg_FinalizeContent (CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
 
static BOOL CDecodeMsg_Update (HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
 
static BOOL CDecodeHashMsg_GetParam (CDecodeMsg *msg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
static void CRYPT_CopyBlob (CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in, LPBYTE *nextData)
 
static void CRYPT_CopyAlgorithmId (CRYPT_ALGORITHM_IDENTIFIER *out, const CRYPT_ALGORITHM_IDENTIFIER *in, LPBYTE *nextData)
 
static void CRYPT_CopyAttributes (CRYPT_ATTRIBUTES *out, const CRYPT_ATTRIBUTES *in, LPBYTE *nextData)
 
static DWORD CRYPT_SizeOfAttributes (const CRYPT_ATTRIBUTES *attr)
 
static DWORD CRYPT_SizeOfKeyIdAsIssuerAndSerial (const CRYPT_DATA_BLOB *keyId)
 
static BOOL CRYPT_CopyKeyIdAsIssuerAndSerial (CERT_NAME_BLOB *issuer, CRYPT_INTEGER_BLOB *serialNumber, const CRYPT_DATA_BLOB *keyId, DWORD encodedLen, LPBYTE *nextData)
 
static BOOL CRYPT_CopySignerInfo (void *pvData, DWORD *pcbData, const CMSG_CMS_SIGNER_INFO *in)
 
static BOOL CRYPT_CopyCMSSignerInfo (void *pvData, DWORD *pcbData, const CMSG_CMS_SIGNER_INFO *in)
 
static BOOL CRYPT_CopySignerCertInfo (void *pvData, DWORD *pcbData, const CMSG_CMS_SIGNER_INFO *in)
 
static BOOL CRYPT_CopyRecipientInfo (void *pvData, DWORD *pcbData, const CERT_ISSUER_SERIAL_NUMBER *in)
 
static BOOL CDecodeEnvelopedMsg_GetParam (CDecodeMsg *msg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
static BOOL CDecodeSignedMsg_GetParam (CDecodeMsg *msg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
static BOOL CDecodeMsg_GetParam (HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
static BOOL CDecodeHashMsg_VerifyHash (CDecodeMsg *msg)
 
static BOOL CDecodeSignedMsg_VerifySignatureWithKey (CDecodeMsg *msg, HCRYPTPROV prov, DWORD signerIndex, PCERT_PUBLIC_KEY_INFO keyInfo)
 
static BOOL CDecodeSignedMsg_VerifySignature (CDecodeMsg *msg, PCERT_INFO info)
 
static BOOL CDecodeSignedMsg_VerifySignatureEx (CDecodeMsg *msg, PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA para)
 
static BOOL WINAPI CRYPT_ImportKeyTrans (PCRYPT_ALGORITHM_IDENTIFIER pContentEncryptionAlgorithm, PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA pKeyTransDecryptPara, DWORD dwFlags, void *pvReserved, HCRYPTKEY *phContentEncryptKey)
 
static BOOL CRYPT_ImportEncryptedKey (PCRYPT_ALGORITHM_IDENTIFIER contEncrAlg, PCMSG_CTRL_DECRYPT_PARA para, PCMSG_KEY_TRANS_RECIPIENT_INFO info, HCRYPTKEY *key)
 
static BOOL CDecodeEnvelopedMsg_CrtlDecrypt (CDecodeMsg *msg, PCMSG_CTRL_DECRYPT_PARA para)
 
static BOOL CDecodeMsg_Control (HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, const void *pvCtrlPara)
 
HCRYPTMSG WINAPI CryptMsgOpenToDecode (DWORD dwMsgEncodingType, DWORD dwFlags, DWORD dwMsgType, HCRYPTPROV_LEGACY hCryptProv, PCERT_INFO pRecipientInfo, PCMSG_STREAM_INFO pStreamInfo)
 
HCRYPTMSG WINAPI CryptMsgDuplicate (HCRYPTMSG hCryptMsg)
 
BOOL WINAPI CryptMsgClose (HCRYPTMSG hCryptMsg)
 
BOOL WINAPI CryptMsgUpdate (HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
 
BOOL WINAPI CryptMsgGetParam (HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
 
BOOL WINAPI CryptMsgControl (HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, const void *pvCtrlPara)
 
static CERT_INFOCRYPT_GetSignerCertInfoFromMsg (HCRYPTMSG msg, DWORD dwSignerIndex)
 
BOOL WINAPI CryptMsgGetAndVerifySigner (HCRYPTMSG hCryptMsg, DWORD cSignerStore, HCERTSTORE *rghSignerStore, DWORD dwFlags, PCCERT_CONTEXT *ppSigner, DWORD *pdwSignerIndex)
 
BOOL WINAPI CryptMsgVerifyCountersignatureEncoded (HCRYPTPROV_LEGACY hCryptProv, DWORD dwEncodingType, BYTE *pbSignerInfo, DWORD cbSignerInfo, PBYTE pbSignerInfoCountersignature, DWORD cbSignerInfoCountersignature, CERT_INFO *pciCountersigner)
 
BOOL WINAPI CryptMsgVerifyCountersignatureEncodedEx (HCRYPTPROV_LEGACY hCryptProv, DWORD dwEncodingType, PBYTE pbSignerInfo, DWORD cbSignerInfo, PBYTE pbSignerInfoCountersignature, DWORD cbSignerInfoCountersignature, DWORD dwSignerType, void *pvSigner, DWORD dwFlags, void *pvReserved)
 
BOOL WINAPI CryptMsgEncodeAndSignCTL (DWORD dwMsgEncodingType, PCTL_INFO pCtlInfo, PCMSG_SIGNED_ENCODE_INFO pSignInfo, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded)
 
BOOL WINAPI CryptMsgSignCTL (DWORD dwMsgEncodingType, BYTE *pbCtlContent, DWORD cbCtlContent, PCMSG_SIGNED_ENCODE_INFO pSignInfo, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded)
 

Variables

static const BYTE empty_data_content [] = { 0x04,0x00 }
 

Macro Definition Documentation

◆ NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 23 of file msg.c.

Typedef Documentation

◆ CDataEncodeMsg

◆ CDecodeMsg

◆ CEnvelopedDecodeMsg

◆ CEnvelopedEncodeMsg

◆ CHashEncodeMsg

◆ CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS

◆ CMSG_SIGNED_ENCODE_INFO_WITH_CMS

◆ CMSG_SIGNER_ENCODE_INFO_WITH_CMS

◆ CryptMsgBase

◆ CryptMsgCloseFunc

typedef void(* CryptMsgCloseFunc) (HCRYPTMSG msg)

Definition at line 38 of file msg.c.

◆ CryptMsgControlFunc

typedef BOOL(* CryptMsgControlFunc) (HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, const void *pvCtrlPara)

Definition at line 46 of file msg.c.

◆ CryptMsgGetParamFunc

typedef BOOL(* CryptMsgGetParamFunc) (HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)

Definition at line 40 of file msg.c.

◆ CryptMsgState

◆ CryptMsgUpdateFunc

typedef BOOL(* CryptMsgUpdateFunc) (HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)

Definition at line 43 of file msg.c.

◆ CSignedEncodeMsg

◆ CSignedMsgData

◆ CSignerHandles

Enumeration Type Documentation

◆ _CryptMsgState

Enumerator
MsgStateInit 
MsgStateUpdated 
MsgStateDataFinalized 
MsgStateFinalized 

Definition at line 57 of file msg.c.

57 {
enum _CryptMsgState CryptMsgState
@ MsgStateDataFinalized
Definition: msg.c:60
@ MsgStateInit
Definition: msg.c:58
@ MsgStateUpdated
Definition: msg.c:59
@ MsgStateFinalized
Definition: msg.c:61

◆ SignOrVerify

Enumerator
Sign 
Verify 

Definition at line 1063 of file msg.c.

1063 {
1064 Sign,
1065 Verify
1066} SignOrVerify;
SignOrVerify
Definition: msg.c:1063
@ Verify
Definition: msg.c:1065
@ Sign
Definition: msg.c:1064

Function Documentation

◆ CContentEncryptInfo_Construct()

static BOOL CContentEncryptInfo_Construct ( CMSG_CONTENT_ENCRYPT_INFO info,
const CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS in,
HCRYPTPROV  prov 
)
static

Definition at line 1681 of file msg.c.

1683{
1684 BOOL ret;
1685
1686 info->cbSize = sizeof(CMSG_CONTENT_ENCRYPT_INFO);
1687 info->hCryptProv = prov;
1688 ret = CRYPT_ConstructAlgorithmId(&info->ContentEncryptionAlgorithm,
1689 &in->ContentEncryptionAlgorithm);
1690 info->pvEncryptionAuxInfo = in->pvEncryptionAuxInfo;
1691 info->cRecipients = in->cRecipients;
1692 if (ret)
1693 {
1694 info->rgCmsRecipients = CryptMemAlloc(in->cRecipients *
1696 if (info->rgCmsRecipients)
1697 {
1698 DWORD i;
1699
1700 for (i = 0; ret && i < in->cRecipients; ++i)
1701 {
1703 CERT_INFO *cert = in->rgpRecipientCert[i];
1704
1705 info->rgCmsRecipients[i].dwRecipientChoice =
1707 encodeInfo = CryptMemAlloc(sizeof(*encodeInfo));
1708 info->rgCmsRecipients[i].u.pKeyTrans = encodeInfo;
1709 if (encodeInfo)
1710 {
1711 encodeInfo->cbSize = sizeof(*encodeInfo);
1713 &encodeInfo->KeyEncryptionAlgorithm,
1714 &cert->SubjectPublicKeyInfo.Algorithm);
1715 encodeInfo->pvKeyEncryptionAuxInfo = NULL;
1716 encodeInfo->hCryptProv = prov;
1717 if (ret)
1719 &encodeInfo->RecipientPublicKey,
1720 &cert->SubjectPublicKeyInfo.PublicKey);
1721 if (ret)
1723 &encodeInfo->RecipientId.u.IssuerSerialNumber.Issuer,
1724 &cert->Issuer);
1725 if (ret)
1728 &cert->SerialNumber);
1729 }
1730 else
1731 ret = FALSE;
1732 }
1733 }
1734 else
1735 ret = FALSE;
1736 }
1737 info->pfnAlloc = mem_alloc;
1738 info->pfnFree = mem_free;
1739 return ret;
1740}
#define mem_free(ptr, bsize)
Definition: types.h:124
#define NULL
Definition: types.h:112
#define mem_alloc(bsize)
Definition: types.h:123
#define FALSE
Definition: types.h:117
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
static BOOL CRYPT_ConstructAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER *out, const CRYPT_ALGORITHM_IDENTIFIER *in)
Definition: msg.c:1512
static BOOL CRYPT_ConstructBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
Definition: msg.c:704
static BOOL CRYPT_ConstructBitBlob(CRYPT_BIT_BLOB *out, const CRYPT_BIT_BLOB *in)
Definition: msg.c:1525
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint in
Definition: glext.h:9616
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static BYTE cert[]
Definition: msg.c:1437
CERT_ISSUER_SERIAL_NUMBER IssuerSerialNumber
Definition: wincrypt.h:3667
CERT_NAME_BLOB Issuer
Definition: wincrypt.h:3659
CRYPT_INTEGER_BLOB SerialNumber
Definition: wincrypt.h:3660
CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm
Definition: wincrypt.h:3745
int ret
struct _CMSG_CONTENT_ENCRYPT_INFO CMSG_CONTENT_ENCRYPT_INFO
#define CMSG_KEY_TRANS_RECIPIENT
Definition: wincrypt.h:3812

Referenced by CEnvelopedEncodeMsg_Open().

◆ CContentEncryptInfo_Free()

static void CContentEncryptInfo_Free ( CMSG_CONTENT_ENCRYPT_INFO info)
static

Definition at line 1742 of file msg.c.

1743{
1744 CryptMemFree(info->ContentEncryptionAlgorithm.pszObjId);
1745 CryptMemFree(info->ContentEncryptionAlgorithm.Parameters.pbData);
1746 if (info->rgCmsRecipients)
1747 {
1748 DWORD i;
1749
1750 for (i = 0; i < info->cRecipients; ++i)
1751 {
1753 info->rgCmsRecipients[i].u.pKeyTrans;
1754
1762 CryptMemFree(encodeInfo);
1763 }
1764 CryptMemFree(info->rgCmsRecipients);
1765 }
1766}
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
BYTE * pbData
Definition: wincrypt.h:103
CRYPT_OBJID_BLOB Parameters
Definition: wincrypt.h:127
BYTE * pbData
Definition: wincrypt.h:197

Referenced by CEnvelopedEncodeMsg_Open().

◆ CDataEncodeMsg_Close()

static void CDataEncodeMsg_Close ( HCRYPTMSG  hCryptMsg)
static

Definition at line 110 of file msg.c.

111{
112 CDataEncodeMsg *msg = hCryptMsg;
113
114 if (msg->bare_content != empty_data_content)
115 LocalFree(msg->bare_content);
116}
#define msg(x)
Definition: auth_time.c:54
static const BYTE empty_data_content[]
Definition: msg.c:108
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594

Referenced by CDataEncodeMsg_Open().

◆ CDataEncodeMsg_GetParam()

static BOOL CDataEncodeMsg_GetParam ( HCRYPTMSG  hCryptMsg,
DWORD  dwParamType,
DWORD  dwIndex,
void pvData,
DWORD pcbData 
)
static

Definition at line 315 of file msg.c.

317{
318 CDataEncodeMsg *msg = hCryptMsg;
319 BOOL ret = FALSE;
320
321 switch (dwParamType)
322 {
324 if (msg->base.streamed)
326 else
327 {
329 char rsa_data[] = "1.2.840.113549.1.7.1";
330
331 info.pszObjId = rsa_data;
332 info.Content.cbData = msg->bare_content_len;
333 info.Content.pbData = msg->bare_content;
335 pvData, pcbData);
336 }
337 break;
339 if (msg->base.streamed)
341 else
342 ret = CRYPT_CopyParam(pvData, pcbData, msg->bare_content,
343 msg->bare_content_len);
344 break;
345 default:
347 }
348 return ret;
349}
#define E_INVALIDARG
Definition: ddrawi.h:101
BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4655
static BOOL CRYPT_CopyParam(void *pvData, DWORD *pcbData, const void *src, DWORD len)
Definition: msg.c:294
#define SetLastError(x)
Definition: compat.h:752
#define CMSG_BARE_CONTENT_PARAM
Definition: wincrypt.h:3927
#define PKCS_CONTENT_INFO
Definition: wincrypt.h:3400
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4950
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3749
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988

Referenced by CDataEncodeMsg_Open().

◆ CDataEncodeMsg_Open()

static HCRYPTMSG CDataEncodeMsg_Open ( DWORD  dwFlags,
const void pvMsgEncodeInfo,
LPSTR  pszInnerContentObjID,
PCMSG_STREAM_INFO  pStreamInfo 
)
static

Definition at line 351 of file msg.c.

353{
355
356 if (pvMsgEncodeInfo)
357 {
359 return NULL;
360 }
362 if (msg)
363 {
364 CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
367 msg->bare_content_len = sizeof(empty_data_content);
368 msg->bare_content = (LPBYTE)empty_data_content;
369 }
370 return msg;
371}
static BOOL CRYPT_DefaultMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, const void *pvCtrlPara)
Definition: msg.c:49
static void CryptMsgBase_Init(CryptMsgBase *msg, DWORD dwFlags, PCMSG_STREAM_INFO pStreamInfo, CryptMsgCloseFunc close, CryptMsgGetParamFunc get_param, CryptMsgUpdateFunc update, CryptMsgControlFunc control)
Definition: msg.c:77
static BOOL CDataEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
Definition: msg.c:191
static void CDataEncodeMsg_Close(HCRYPTMSG hCryptMsg)
Definition: msg.c:110
static BOOL CDataEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:315
unsigned char * LPBYTE
Definition: typedefs.h:53
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

Referenced by CryptMsgOpenToEncode().

◆ CDataEncodeMsg_Update()

static BOOL CDataEncodeMsg_Update ( HCRYPTMSG  hCryptMsg,
const BYTE pbData,
DWORD  cbData,
BOOL  fFinal 
)
static

Definition at line 191 of file msg.c.

193{
194 CDataEncodeMsg *msg = hCryptMsg;
195 BOOL ret = FALSE;
196
197 if (msg->base.state == MsgStateFinalized)
199 else if (msg->base.streamed)
200 {
201 __TRY
202 {
203 if (msg->base.state != MsgStateUpdated)
204 {
206
208 if (ret)
209 {
210 ret = msg->base.stream_info.pfnStreamOutput(
211 msg->base.stream_info.pvArg, header.pbData, header.cbData,
212 FALSE);
213 LocalFree(header.pbData);
214 }
215 }
216 /* Curiously, every indefinite-length streamed update appears to
217 * get its own tag and length, regardless of fFinal.
218 */
219 if (msg->base.stream_info.cbContent == 0xffffffff)
220 {
221 BYTE *header;
222 DWORD headerLen;
223
226 &headerLen);
227 if (ret)
228 {
229 ret = msg->base.stream_info.pfnStreamOutput(
230 msg->base.stream_info.pvArg, header, headerLen,
231 FALSE);
233 }
234 }
235 if (!fFinal)
236 {
237 ret = msg->base.stream_info.pfnStreamOutput(
238 msg->base.stream_info.pvArg, (BYTE *)pbData, cbData,
239 FALSE);
240 msg->base.state = MsgStateUpdated;
241 }
242 else
243 {
244 msg->base.state = MsgStateFinalized;
245 if (msg->base.stream_info.cbContent == 0xffffffff)
246 {
247 BYTE indefinite_trailer[6] = { 0 };
248
249 ret = msg->base.stream_info.pfnStreamOutput(
250 msg->base.stream_info.pvArg, (BYTE *)pbData, cbData,
251 FALSE);
252 if (ret)
253 ret = msg->base.stream_info.pfnStreamOutput(
254 msg->base.stream_info.pvArg, indefinite_trailer,
255 sizeof(indefinite_trailer), TRUE);
256 }
257 else
258 ret = msg->base.stream_info.pfnStreamOutput(
259 msg->base.stream_info.pvArg, (BYTE *)pbData, cbData, TRUE);
260 }
261 }
263 {
265 ret = FALSE;
266 }
267 __ENDTRY;
268 }
269 else
270 {
271 if (!fFinal)
272 {
273 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
275 else
277 }
278 else
279 {
280 CRYPT_DATA_BLOB blob = { cbData, (LPBYTE)pbData };
281
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.
285 */
287 &blob, CRYPT_ENCODE_ALLOC_FLAG, NULL, &msg->bare_content,
288 &msg->bare_content_len);
289 }
290 }
291 return ret;
292}
#define TRUE
Definition: types.h:120
BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, void *pvEncoded, DWORD *pcbEncoded)
Definition: encode.c:4696
static BOOL CRYPT_EncodeDataContentInfoHeader(const CDataEncodeMsg *msg, CRYPT_DATA_BLOB *header)
Definition: msg.c:148
static BOOL WINAPI CRYPT_EncodeContentLength(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: msg.c:118
#define __TRY
Definition: compat.h:80
#define __ENDTRY
Definition: compat.h:82
#define __EXCEPT_PAGE_FAULT
Definition: compat.h:81
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
Definition: image.c:134
#define X509_OCTET_STRING
Definition: wincrypt.h:3391
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201
#define CRYPT_ENCODE_ALLOC_FLAG
Definition: wincrypt.h:3441
#define CRYPT_E_MSG_ERROR
Definition: winerror.h:2985
unsigned char BYTE
Definition: xxhash.c:193

Referenced by CDataEncodeMsg_Open().

◆ CDecodeEnvelopedMsg_CrtlDecrypt()

static BOOL CDecodeEnvelopedMsg_CrtlDecrypt ( CDecodeMsg msg,
PCMSG_CTRL_DECRYPT_PARA  para 
)
static

Definition at line 3455 of file msg.c.

3457{
3458 BOOL ret = FALSE;
3459 CEnvelopedDecodeMsg *enveloped_data = &msg->u.enveloped_data;
3460 CRYPT_ENVELOPED_DATA *data = enveloped_data->data;
3461
3462 if (para->cbSize != sizeof(CMSG_CTRL_DECRYPT_PARA))
3464 else if (!data)
3466 else if (para->dwRecipientIndex >= data->cRecipientInfo)
3468 else if (enveloped_data->decrypted)
3470 else if (!para->hCryptProv)
3472 else if (enveloped_data->content.cbData)
3473 {
3474 HCRYPTKEY key;
3475
3477 &data->encryptedContentInfo.contentEncryptionAlgorithm, para,
3478 data->rgRecipientInfo, &key);
3479 if (ret)
3480 {
3481 ret = CryptDecrypt(key, 0, TRUE, 0, enveloped_data->content.pbData,
3482 &enveloped_data->content.cbData);
3484 }
3485 }
3486 else
3487 ret = TRUE;
3488 if (ret)
3489 enveloped_data->decrypted = TRUE;
3490 return ret;
3491}
BOOL WINAPI CryptDestroyKey(HCRYPTKEY hKey)
Definition: crypt.c:930
BOOL WINAPI CryptDecrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
Definition: crypt.c:800
static BOOL CRYPT_ImportEncryptedKey(PCRYPT_ALGORITHM_IDENTIFIER contEncrAlg, PCMSG_CTRL_DECRYPT_PARA para, PCMSG_KEY_TRANS_RECIPIENT_INFO info, HCRYPTKEY *key)
Definition: msg.c:3426
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
CRYPT_ENVELOPED_DATA * data
Definition: msg.c:2077
CRYPT_DATA_BLOB content
Definition: msg.c:2079
Definition: copy.c:22
ULONG_PTR HCRYPTKEY
Definition: wincrypt.h:49
#define CRYPT_E_INVALID_INDEX
Definition: winerror.h:2992
#define CRYPT_E_ALREADY_DECRYPTED
Definition: winerror.h:2993

Referenced by CDecodeMsg_Control().

◆ CDecodeEnvelopedMsg_GetParam()

static BOOL CDecodeEnvelopedMsg_GetParam ( CDecodeMsg msg,
DWORD  dwParamType,
DWORD  dwIndex,
void pvData,
DWORD pcbData 
)
static

Definition at line 2952 of file msg.c.

2954{
2955 BOOL ret = FALSE;
2956
2957 switch (dwParamType)
2958 {
2959 case CMSG_TYPE_PARAM:
2960 ret = CRYPT_CopyParam(pvData, pcbData, &msg->type, sizeof(msg->type));
2961 break;
2962 case CMSG_CONTENT_PARAM:
2963 if (msg->u.enveloped_data.data)
2965 msg->u.enveloped_data.content.pbData,
2966 msg->u.enveloped_data.content.cbData);
2967 else
2969 break;
2971 if (msg->u.enveloped_data.data)
2973 &msg->u.enveloped_data.data->cRecipientInfo, sizeof(DWORD));
2974 else
2976 break;
2978 if (msg->u.enveloped_data.data)
2979 {
2980 if (dwIndex < msg->u.enveloped_data.data->cRecipientInfo)
2981 {
2982 PCMSG_KEY_TRANS_RECIPIENT_INFO recipientInfo =
2983 &msg->u.enveloped_data.data->rgRecipientInfo[dwIndex];
2984
2986 &recipientInfo->RecipientId.u.IssuerSerialNumber);
2987 }
2988 else
2990 }
2991 else
2993 break;
2994 default:
2995 FIXME("unimplemented for %d\n", dwParamType);
2997 }
2998 return ret;
2999}
#define FIXME(fmt,...)
Definition: precomp.h:53
static BOOL CRYPT_CopyRecipientInfo(void *pvData, DWORD *pcbData, const CERT_ISSUER_SERIAL_NUMBER *in)
Definition: msg.c:2918
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define CMSG_TYPE_PARAM
Definition: wincrypt.h:3925
#define CMSG_RECIPIENT_INFO_PARAM
Definition: wincrypt.h:3942
#define CMSG_RECIPIENT_COUNT_PARAM
Definition: wincrypt.h:3940

Referenced by CDecodeMsg_GetParam().

◆ CDecodeHashMsg_GetParam()

static BOOL CDecodeHashMsg_GetParam ( CDecodeMsg msg,
DWORD  dwParamType,
DWORD  dwIndex,
void pvData,
DWORD pcbData 
)
static

Definition at line 2554 of file msg.c.

2556{
2557 BOOL ret = FALSE;
2558
2559 switch (dwParamType)
2560 {
2561 case CMSG_TYPE_PARAM:
2562 ret = CRYPT_CopyParam(pvData, pcbData, &msg->type, sizeof(msg->type));
2563 break;
2565 {
2567
2568 ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
2569 &blob);
2570 if (ret)
2571 {
2572 ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData, blob.cbData);
2573 if (ret && pvData)
2575 }
2576 else
2578 break;
2579 }
2582 break;
2583 default:
2584 {
2586
2587 ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
2588 &blob);
2589 if (ret)
2590 ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData, blob.cbData);
2591 else
2593 }
2594 }
2595 return ret;
2596}
BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN
Definition: proplist.c:72
BOOL WINAPI CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags)
Definition: crypt.c:1610
static void CRYPT_FixUpAlgorithmID(CRYPT_ALGORITHM_IDENTIFIER *id)
Definition: msg.c:2205
#define CMSG_COMPUTED_HASH_PARAM
Definition: wincrypt.h:3945
#define CMSG_HASH_ALGORITHM_PARAM
Definition: wincrypt.h:3943
#define HP_HASHVAL
Definition: wincrypt.h:2183

Referenced by CDecodeHashMsg_VerifyHash(), and CDecodeMsg_GetParam().

◆ CDecodeHashMsg_VerifyHash()

static BOOL CDecodeHashMsg_VerifyHash ( CDecodeMsg msg)
static

Definition at line 3225 of file msg.c.

3226{
3227 BOOL ret;
3229
3232 if (ret)
3233 {
3234 DWORD computedHashSize = 0;
3235
3237 &computedHashSize);
3238 if (hashBlob.cbData == computedHashSize)
3239 {
3240 LPBYTE computedHash = CryptMemAlloc(computedHashSize);
3241
3242 if (computedHash)
3243 {
3245 computedHash, &computedHashSize);
3246 if (ret)
3247 {
3248 if (memcmp(hashBlob.pbData, computedHash, hashBlob.cbData))
3249 {
3251 ret = FALSE;
3252 }
3253 }
3254 CryptMemFree(computedHash);
3255 }
3256 else
3257 {
3259 ret = FALSE;
3260 }
3261 }
3262 else
3263 {
3265 ret = FALSE;
3266 }
3267 }
3268 return ret;
3269}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
static BOOL CDecodeHashMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:2554
static const BYTE hashBlob[]
Definition: message.c:644
#define CMSG_HASH_DATA_PARAM
Definition: wincrypt.h:3944
#define CRYPT_E_HASH_VALUE
Definition: winerror.h:2991

Referenced by CDecodeMsg_Control().

◆ CDecodeMsg_Close()

static void CDecodeMsg_Close ( HCRYPTMSG  hCryptMsg)
static

Definition at line 2098 of file msg.c.

2099{
2100 CDecodeMsg *msg = hCryptMsg;
2101
2102 if (msg->crypt_prov && msg->base.open_flags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
2103 CryptReleaseContext(msg->crypt_prov, 0);
2104 switch (msg->type)
2105 {
2106 case CMSG_HASHED:
2107 if (msg->u.hash)
2108 CryptDestroyHash(msg->u.hash);
2109 break;
2110 case CMSG_ENVELOPED:
2111 if (msg->u.enveloped_data.crypt_prov)
2112 CryptReleaseContext(msg->u.enveloped_data.crypt_prov, 0);
2113 LocalFree(msg->u.enveloped_data.data);
2114 CryptMemFree(msg->u.enveloped_data.content.pbData);
2115 break;
2116 case CMSG_SIGNED:
2117 if (msg->u.signed_data.info)
2118 {
2119 LocalFree(msg->u.signed_data.info);
2120 CSignedMsgData_CloseHandles(&msg->u.signed_data);
2121 }
2122 break;
2123 }
2124 CryptMemFree(msg->msg_data.pbData);
2125 CryptMemFree(msg->detached_data.pbData);
2126 ContextPropertyList_Free(msg->properties);
2127}
void ContextPropertyList_Free(CONTEXT_PROPERTY_LIST *list) DECLSPEC_HIDDEN
Definition: proplist.c:56
BOOL WINAPI CryptDestroyHash(HCRYPTHASH hHash)
Definition: crypt.c:890
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
Definition: crypt.c:648
static void CSignedMsgData_CloseHandles(CSignedMsgData *msg_data)
Definition: msg.c:983
#define CMSG_HASHED
Definition: wincrypt.h:3683
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867
#define CMSG_ENVELOPED
Definition: wincrypt.h:3681
#define CMSG_SIGNED
Definition: wincrypt.h:3680

Referenced by CryptMsgOpenToDecode().

◆ CDecodeMsg_Control()

static BOOL CDecodeMsg_Control ( HCRYPTMSG  hCryptMsg,
DWORD  dwFlags,
DWORD  dwCtrlType,
const void pvCtrlPara 
)
static

Definition at line 3493 of file msg.c.

3495{
3496 CDecodeMsg *msg = hCryptMsg;
3497 BOOL ret = FALSE;
3498
3499 switch (dwCtrlType)
3500 {
3502 switch (msg->type)
3503 {
3504 case CMSG_SIGNED:
3506 break;
3507 default:
3509 }
3510 break;
3511 case CMSG_CTRL_DECRYPT:
3512 switch (msg->type)
3513 {
3514 case CMSG_ENVELOPED:
3516 (PCMSG_CTRL_DECRYPT_PARA)pvCtrlPara);
3518 msg->u.enveloped_data.crypt_prov =
3519 ((PCMSG_CTRL_DECRYPT_PARA)pvCtrlPara)->hCryptProv;
3520 break;
3521 default:
3523 }
3524 break;
3526 switch (msg->type)
3527 {
3528 case CMSG_HASHED:
3530 break;
3531 default:
3533 }
3534 break;
3536 switch (msg->type)
3537 {
3538 case CMSG_SIGNED:
3541 break;
3542 default:
3544 }
3545 break;
3546 default:
3548 }
3549 return ret;
3550}
static BOOL CDecodeSignedMsg_VerifySignature(CDecodeMsg *msg, PCERT_INFO info)
Definition: msg.c:3303
static BOOL CDecodeSignedMsg_VerifySignatureEx(CDecodeMsg *msg, PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA para)
Definition: msg.c:3346
static BOOL CDecodeEnvelopedMsg_CrtlDecrypt(CDecodeMsg *msg, PCMSG_CTRL_DECRYPT_PARA para)
Definition: msg.c:3455
static BOOL CDecodeHashMsg_VerifyHash(CDecodeMsg *msg)
Definition: msg.c:3225
#define CMSG_CTRL_VERIFY_HASH
Definition: wincrypt.h:3871
#define CMSG_CTRL_VERIFY_SIGNATURE_EX
Definition: wincrypt.h:3885
#define CMSG_CTRL_DECRYPT
Definition: wincrypt.h:3870
struct _CMSG_CTRL_DECRYPT_PARA * PCMSG_CTRL_DECRYPT_PARA
#define CMSG_CTRL_VERIFY_SIGNATURE
Definition: wincrypt.h:3869
#define CRYPT_E_CONTROL_TYPE
Definition: winerror.h:2996

Referenced by CryptMsgOpenToDecode().

◆ CDecodeMsg_CopyData()

static BOOL CDecodeMsg_CopyData ( CRYPT_DATA_BLOB blob,
const BYTE pbData,
DWORD  cbData 
)
static

Definition at line 2129 of file msg.c.

2131{
2132 BOOL ret = TRUE;
2133
2134 if (cbData)
2135 {
2136 if (blob->cbData)
2137 blob->pbData = CryptMemRealloc(blob->pbData,
2138 blob->cbData + cbData);
2139 else
2140 blob->pbData = CryptMemAlloc(cbData);
2141 if (blob->pbData)
2142 {
2143 memcpy(blob->pbData + blob->cbData, pbData, cbData);
2144 blob->cbData += cbData;
2145 }
2146 else
2147 ret = FALSE;
2148 }
2149 return ret;
2150}
LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize)
Definition: main.c:136
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878

Referenced by CDecodeMsg_Update().

◆ CDecodeMsg_DecodeContent()

static BOOL CDecodeMsg_DecodeContent ( CDecodeMsg msg,
const CRYPT_DER_BLOB blob,
DWORD  type 
)
static

Definition at line 2283 of file msg.c.

2285{
2286 BOOL ret;
2287
2288 switch (type)
2289 {
2290 case CMSG_DATA:
2292 msg->type = CMSG_DATA;
2293 break;
2294 case CMSG_HASHED:
2296 msg->type = CMSG_HASHED;
2297 break;
2298 case CMSG_ENVELOPED:
2300 msg->type = CMSG_ENVELOPED;
2301 break;
2302 case CMSG_SIGNED:
2304 msg->type = CMSG_SIGNED;
2305 break;
2306 default:
2307 {
2309 DWORD size;
2310
2312 msg->msg_data.pbData, msg->msg_data.cbData, CRYPT_DECODE_ALLOC_FLAG,
2313 NULL, &info, &size);
2314 if (ret)
2315 {
2316 if (!strcmp(info->pszObjId, szOID_RSA_data))
2318 else if (!strcmp(info->pszObjId, szOID_RSA_digestedData))
2319 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
2320 CMSG_HASHED);
2321 else if (!strcmp(info->pszObjId, szOID_RSA_envelopedData))
2322 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
2324 else if (!strcmp(info->pszObjId, szOID_RSA_signedData))
2325 ret = CDecodeMsg_DecodeContent(msg, &info->Content,
2326 CMSG_SIGNED);
2327 else
2328 {
2330 ret = FALSE;
2331 }
2332 LocalFree(info);
2333 }
2334 }
2335 }
2336 return ret;
2337}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
BOOL WINAPI CryptDecodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6286
static BOOL CDecodeMsg_DecodeEnvelopedContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
Definition: msg.c:2248
static BOOL CDecodeMsg_DecodeSignedContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
Definition: msg.c:2263
static BOOL CDecodeMsg_DecodeContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob, DWORD type)
Definition: msg.c:2283
static BOOL CDecodeMsg_DecodeDataContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
Definition: msg.c:2152
static BOOL CDecodeMsg_DecodeHashedContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
Definition: msg.c:2211
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLsizeiptr size
Definition: glext.h:5919
#define szOID_RSA_envelopedData
Definition: wincrypt.h:3030
#define CMSG_DATA
Definition: wincrypt.h:3679
#define szOID_RSA_signedData
Definition: wincrypt.h:3029
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454
#define szOID_RSA_data
Definition: wincrypt.h:3028
#define szOID_RSA_digestedData
Definition: wincrypt.h:3032

Referenced by CDecodeMsg_DecodeContent(), and CDecodeMsg_Update().

◆ CDecodeMsg_DecodeDataContent()

static BOOL CDecodeMsg_DecodeDataContent ( CDecodeMsg msg,
const CRYPT_DER_BLOB blob 
)
static

Definition at line 2152 of file msg.c.

2153{
2154 BOOL ret;
2156 DWORD size;
2157
2159 blob->pbData, blob->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &data, &size);
2160 if (ret)
2161 {
2163 CMSG_CONTENT_PARAM, data->pbData, data->cbData);
2164 LocalFree(data);
2165 }
2166 return ret;
2167}
BOOL ContextPropertyList_SetProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, const BYTE *pbData, size_t cbData) DECLSPEC_HIDDEN
Definition: proplist.c:95

Referenced by CDecodeMsg_DecodeContent(), and CDecodeMsg_DecodeHashedContent().

◆ CDecodeMsg_DecodeEnvelopedContent()

static BOOL CDecodeMsg_DecodeEnvelopedContent ( CDecodeMsg msg,
const CRYPT_DER_BLOB blob 
)
static

Definition at line 2248 of file msg.c.

2250{
2251 BOOL ret;
2252 CRYPT_ENVELOPED_DATA *envelopedData;
2253 DWORD size;
2254
2255 ret = CRYPT_AsnDecodePKCSEnvelopedData(blob->pbData, blob->cbData,
2257 &size);
2258 if (ret)
2259 msg->u.enveloped_data.data = envelopedData;
2260 return ret;
2261}
BOOL CRYPT_AsnDecodePKCSEnvelopedData(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, CRYPT_ENVELOPED_DATA *envelopedData, DWORD *pcbEnvelopedData) DECLSPEC_HIDDEN
Definition: decode.c:5951

Referenced by CDecodeMsg_DecodeContent().

◆ CDecodeMsg_DecodeHashedContent()

static BOOL CDecodeMsg_DecodeHashedContent ( CDecodeMsg msg,
const CRYPT_DER_BLOB blob 
)
static

Definition at line 2211 of file msg.c.

2213{
2214 BOOL ret;
2215 CRYPT_DIGESTED_DATA *digestedData;
2216 DWORD size;
2217
2218 ret = CRYPT_AsnDecodePKCSDigestedData(blob->pbData, blob->cbData,
2220 &size);
2221 if (ret)
2222 {
2224 (const BYTE *)&digestedData->version, sizeof(digestedData->version));
2226 &digestedData->DigestAlgorithm);
2229 (const BYTE *)digestedData->ContentInfo.pszObjId,
2230 digestedData->ContentInfo.pszObjId ?
2231 strlen(digestedData->ContentInfo.pszObjId) + 1 : 0);
2232 if (!(msg->base.open_flags & CMSG_DETACHED_FLAG))
2233 {
2234 if (digestedData->ContentInfo.Content.cbData)
2236 &digestedData->ContentInfo.Content);
2237 else
2240 }
2242 digestedData->hash.pbData, digestedData->hash.cbData);
2243 LocalFree(digestedData);
2244 }
2245 return ret;
2246}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
BOOL CRYPT_AsnDecodePKCSDigestedData(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, CRYPT_DIGESTED_DATA *digestedData, DWORD *pcbDigestedData) DECLSPEC_HIDDEN
Definition: decode.c:3371
static void CDecodeMsg_SaveAlgorithmID(CDecodeMsg *msg, DWORD param, const CRYPT_ALGORITHM_IDENTIFIER *id)
Definition: msg.c:2169
CRYPT_DER_BLOB Content
Definition: wincrypt.h:454
CRYPT_CONTENT_INFO ContentInfo
CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm
CRYPT_HASH_BLOB hash
#define CMSG_VERSION_PARAM
Definition: wincrypt.h:3950
#define CMSG_INNER_CONTENT_TYPE_PARAM
Definition: wincrypt.h:3928

Referenced by CDecodeMsg_DecodeContent().

◆ CDecodeMsg_DecodeSignedContent()

static BOOL CDecodeMsg_DecodeSignedContent ( CDecodeMsg msg,
const CRYPT_DER_BLOB blob 
)
static

Definition at line 2263 of file msg.c.

2265{
2266 BOOL ret;
2267 CRYPT_SIGNED_INFO *signedInfo;
2268 DWORD size;
2269
2270 ret = CRYPT_AsnDecodeCMSSignedInfo(blob->pbData, blob->cbData,
2272 &size);
2273 if (ret)
2274 msg->u.signed_data.info = signedInfo;
2275 return ret;
2276}
BOOL CRYPT_AsnDecodeCMSSignedInfo(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, CRYPT_SIGNED_INFO *signedInfo, DWORD *pcbSignedInfo) DECLSPEC_HIDDEN
Definition: decode.c:5822

Referenced by CDecodeMsg_DecodeContent().

◆ CDecodeMsg_FinalizeContent()

static BOOL CDecodeMsg_FinalizeContent ( CDecodeMsg msg,
CRYPT_DER_BLOB blob 
)
static

Definition at line 2450 of file msg.c.

2451{
2452 BOOL ret = FALSE;
2453
2454 switch (msg->type)
2455 {
2456 case CMSG_HASHED:
2458 break;
2459 case CMSG_ENVELOPED:
2461 break;
2462 case CMSG_SIGNED:
2464 break;
2465 default:
2466 ret = TRUE;
2467 }
2468 return ret;
2469}
static BOOL CDecodeMsg_FinalizeHashedContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
Definition: msg.c:2339
static BOOL CDecodeMsg_FinalizeEnvelopedContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
Definition: msg.c:2384
static BOOL CDecodeMsg_FinalizeSignedContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
Definition: msg.c:2398

Referenced by CDecodeMsg_Update().

◆ CDecodeMsg_FinalizeEnvelopedContent()

static BOOL CDecodeMsg_FinalizeEnvelopedContent ( CDecodeMsg msg,
CRYPT_DER_BLOB blob 
)
static

Definition at line 2384 of file msg.c.

2386{
2388
2389 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
2390 content = &msg->detached_data;
2391 else
2392 content =
2393 &msg->u.enveloped_data.data->encryptedContentInfo.encryptedContent;
2394
2395 return CRYPT_ConstructBlob(&msg->u.enveloped_data.content, content);
2396}
content
Definition: atl_ax.c:994

Referenced by CDecodeMsg_FinalizeContent().

◆ CDecodeMsg_FinalizeHashedContent()

static BOOL CDecodeMsg_FinalizeHashedContent ( CDecodeMsg msg,
CRYPT_DER_BLOB blob 
)
static

Definition at line 2339 of file msg.c.

2341{
2342 CRYPT_ALGORITHM_IDENTIFIER *hashAlgoID = NULL;
2343 DWORD size = 0;
2344 ALG_ID algID = 0;
2345 BOOL ret;
2346
2348 hashAlgoID = CryptMemAlloc(size);
2350 &size);
2351 if (ret)
2352 algID = CertOIDToAlgId(hashAlgoID->pszObjId);
2353
2354 if (!msg->crypt_prov)
2355 {
2356 msg->crypt_prov = I_CryptGetDefaultCryptProv(algID);
2357 if (msg->crypt_prov)
2358 msg->base.open_flags &= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG;
2359 }
2360
2361 ret = CryptCreateHash(msg->crypt_prov, algID, 0, 0, &msg->u.hash);
2362 if (ret)
2363 {
2365
2366 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
2367 {
2368 /* Unlike for non-detached messages, the data were never stored as
2369 * the content param, but were saved in msg->detached_data instead.
2370 */
2371 content.pbData = msg->detached_data.pbData;
2372 content.cbData = msg->detached_data.cbData;
2373 }
2374 else
2377 if (ret)
2378 ret = CryptHashData(msg->u.hash, content.pbData, content.cbData, 0);
2379 }
2380 CryptMemFree(hashAlgoID);
2381 return ret;
2382}
HCRYPTPROV WINAPI I_CryptGetDefaultCryptProv(ALG_ID)
Definition: main.c:210
BOOL WINAPI CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash)
Definition: crypt.c:740
BOOL WINAPI CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)
Definition: crypt.c:1771
BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:3626
DWORD WINAPI CertOIDToAlgId(LPCSTR pszObjId)
Definition: oid.c:1901
unsigned int ALG_ID
Definition: wincrypt.h:45

Referenced by CDecodeMsg_FinalizeContent().

◆ CDecodeMsg_FinalizeSignedContent()

static BOOL CDecodeMsg_FinalizeSignedContent ( CDecodeMsg msg,
CRYPT_DER_BLOB blob 
)
static

Definition at line 2398 of file msg.c.

2400{
2401 BOOL ret;
2402 DWORD i, size;
2403
2404 ret = CSignedMsgData_AllocateHandles(&msg->u.signed_data);
2405 for (i = 0; ret && i < msg->u.signed_data.info->cSignerInfo; i++)
2407 &msg->crypt_prov, &msg->base.open_flags);
2408 if (ret)
2409 {
2411
2412 /* Now that we have all the content, update the hash handles with
2413 * it. If the message is a detached message, the content is stored
2414 * in msg->detached_data rather than in the signed message's
2415 * content.
2416 */
2417 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
2418 content = &msg->detached_data;
2419 else
2420 content = &msg->u.signed_data.info->content.Content;
2421 if (content->cbData)
2422 {
2423 /* If the message is not detached, have to decode the message's
2424 * content if the type is szOID_RSA_data.
2425 */
2426 if (!(msg->base.open_flags & CMSG_DETACHED_FLAG) &&
2427 !strcmp(msg->u.signed_data.info->content.pszObjId,
2429 {
2430 CRYPT_DATA_BLOB *rsa_blob;
2431
2433 X509_OCTET_STRING, content->pbData, content->cbData,
2434 CRYPT_DECODE_ALLOC_FLAG, NULL, &rsa_blob, &size);
2435 if (ret)
2436 {
2437 ret = CSignedMsgData_Update(&msg->u.signed_data,
2438 rsa_blob->pbData, rsa_blob->cbData, TRUE, Verify);
2439 LocalFree(rsa_blob);
2440 }
2441 }
2442 else
2443 ret = CSignedMsgData_Update(&msg->u.signed_data,
2444 content->pbData, content->cbData, TRUE, Verify);
2445 }
2446 }
2447 return ret;
2448}
static BOOL CSignedMsgData_Update(CSignedMsgData *msg_data, const BYTE *pbData, DWORD cbData, BOOL fFinal, SignOrVerify flag)
Definition: msg.c:1172
static BOOL CSignedMsgData_AllocateHandles(CSignedMsgData *msg_data)
Definition: msg.c:955
static BOOL CSignedMsgData_ConstructSignerHandles(CSignedMsgData *msg_data, DWORD signerIndex, HCRYPTPROV *crypt_prov, DWORD *flags)
Definition: msg.c:928

Referenced by CDecodeMsg_FinalizeContent().

◆ CDecodeMsg_GetParam()

static BOOL CDecodeMsg_GetParam ( HCRYPTMSG  hCryptMsg,
DWORD  dwParamType,
DWORD  dwIndex,
void pvData,
DWORD pcbData 
)
static

Definition at line 3181 of file msg.c.

3183{
3184 CDecodeMsg *msg = hCryptMsg;
3185 BOOL ret = FALSE;
3186
3187 switch (msg->type)
3188 {
3189 case CMSG_HASHED:
3190 ret = CDecodeHashMsg_GetParam(msg, dwParamType, dwIndex, pvData,
3191 pcbData);
3192 break;
3193 case CMSG_ENVELOPED:
3194 ret = CDecodeEnvelopedMsg_GetParam(msg, dwParamType, dwIndex, pvData,
3195 pcbData);
3196 break;
3197 case CMSG_SIGNED:
3198 ret = CDecodeSignedMsg_GetParam(msg, dwParamType, dwIndex, pvData,
3199 pcbData);
3200 break;
3201 default:
3202 switch (dwParamType)
3203 {
3204 case CMSG_TYPE_PARAM:
3206 sizeof(msg->type));
3207 break;
3208 default:
3209 {
3211
3212 ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
3213 &blob);
3214 if (ret)
3216 blob.cbData);
3217 else
3219 }
3220 }
3221 }
3222 return ret;
3223}
static BOOL CDecodeEnvelopedMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:2952
static BOOL CDecodeSignedMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:3001

Referenced by CryptMsgOpenToDecode().

◆ CDecodeMsg_SaveAlgorithmID()

static void CDecodeMsg_SaveAlgorithmID ( CDecodeMsg msg,
DWORD  param,
const CRYPT_ALGORITHM_IDENTIFIER id 
)
static

Definition at line 2169 of file msg.c.

2171{
2172 static const BYTE nullParams[] = { ASN_NULL, 0 };
2175
2176 /* Linearize algorithm id */
2177 len += strlen(id->pszObjId) + 1;
2178 len += id->Parameters.cbData;
2180 if (copy)
2181 {
2182 copy->pszObjId =
2183 (LPSTR)((BYTE *)copy + sizeof(CRYPT_ALGORITHM_IDENTIFIER));
2184 strcpy(copy->pszObjId, id->pszObjId);
2185 copy->Parameters.pbData = (BYTE *)copy->pszObjId + strlen(id->pszObjId)
2186 + 1;
2187 /* Trick: omit NULL parameters */
2188 if (id->Parameters.cbData == sizeof(nullParams) &&
2189 !memcmp(id->Parameters.pbData, nullParams, sizeof(nullParams)))
2190 {
2191 copy->Parameters.cbData = 0;
2192 len -= sizeof(nullParams);
2193 }
2194 else
2195 copy->Parameters.cbData = id->Parameters.cbData;
2196 if (copy->Parameters.cbData)
2197 memcpy(copy->Parameters.pbData, id->Parameters.pbData,
2198 id->Parameters.cbData);
2200 len);
2202 }
2203}
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
GLfloat param
Definition: glext.h:5796
GLenum GLsizei len
Definition: glext.h:6722
GLuint id
Definition: glext.h:5910
#define ASN_NULL
Definition: snmp.h:106
struct _CRYPT_ALGORITHM_IDENTIFIER CRYPT_ALGORITHM_IDENTIFIER
char * LPSTR
Definition: xmlstorage.h:182

Referenced by CDecodeMsg_DecodeHashedContent().

◆ CDecodeMsg_Update()

static BOOL CDecodeMsg_Update ( HCRYPTMSG  hCryptMsg,
const BYTE pbData,
DWORD  cbData,
BOOL  fFinal 
)
static

Definition at line 2471 of file msg.c.

2473{
2474 CDecodeMsg *msg = hCryptMsg;
2475 BOOL ret = FALSE;
2476
2477 TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
2478
2479 if (msg->base.state == MsgStateFinalized)
2481 else if (msg->base.streamed)
2482 {
2483 FIXME("(%p, %p, %d, %d): streamed update stub\n", hCryptMsg, pbData,
2484 cbData, fFinal);
2485 switch (msg->base.state)
2486 {
2487 case MsgStateInit:
2488 ret = CDecodeMsg_CopyData(&msg->msg_data, pbData, cbData);
2489 if (fFinal)
2490 {
2491 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
2492 msg->base.state = MsgStateDataFinalized;
2493 else
2494 msg->base.state = MsgStateFinalized;
2495 }
2496 else
2497 msg->base.state = MsgStateUpdated;
2498 break;
2499 case MsgStateUpdated:
2500 ret = CDecodeMsg_CopyData(&msg->msg_data, pbData, cbData);
2501 if (fFinal)
2502 {
2503 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
2504 msg->base.state = MsgStateDataFinalized;
2505 else
2506 msg->base.state = MsgStateFinalized;
2507 }
2508 break;
2510 ret = CDecodeMsg_CopyData(&msg->detached_data, pbData, cbData);
2511 if (fFinal)
2512 msg->base.state = MsgStateFinalized;
2513 break;
2514 default:
2516 break;
2517 }
2518 }
2519 else
2520 {
2521 if (!fFinal)
2523 else
2524 {
2525 switch (msg->base.state)
2526 {
2527 case MsgStateInit:
2528 ret = CDecodeMsg_CopyData(&msg->msg_data, pbData, cbData);
2529 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
2530 msg->base.state = MsgStateDataFinalized;
2531 else
2532 msg->base.state = MsgStateFinalized;
2533 break;
2535 ret = CDecodeMsg_CopyData(&msg->detached_data, pbData, cbData);
2536 msg->base.state = MsgStateFinalized;
2537 break;
2538 default:
2540 }
2541 }
2542 }
2543 if (ret && fFinal &&
2544 ((msg->base.open_flags & CMSG_DETACHED_FLAG && msg->base.state ==
2546 (!(msg->base.open_flags & CMSG_DETACHED_FLAG) && msg->base.state ==
2548 ret = CDecodeMsg_DecodeContent(msg, &msg->msg_data, msg->type);
2549 if (ret && msg->base.state == MsgStateFinalized)
2550 ret = CDecodeMsg_FinalizeContent(msg, &msg->msg_data);
2551 return ret;
2552}
static BOOL CDecodeMsg_FinalizeContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
Definition: msg.c:2450
static BOOL CDecodeMsg_CopyData(CRYPT_DATA_BLOB *blob, const BYTE *pbData, DWORD cbData)
Definition: msg.c:2129
#define TRACE(s)
Definition: solgame.cpp:4

Referenced by CryptMsgOpenToDecode().

◆ CDecodeSignedMsg_GetParam()

static BOOL CDecodeSignedMsg_GetParam ( CDecodeMsg msg,
DWORD  dwParamType,
DWORD  dwIndex,
void pvData,
DWORD pcbData 
)
static

Definition at line 3001 of file msg.c.

3003{
3004 BOOL ret = FALSE;
3005
3006 switch (dwParamType)
3007 {
3008 case CMSG_TYPE_PARAM:
3009 ret = CRYPT_CopyParam(pvData, pcbData, &msg->type, sizeof(msg->type));
3010 break;
3011 case CMSG_CONTENT_PARAM:
3012 if (msg->u.signed_data.info)
3013 {
3014 if (!strcmp(msg->u.signed_data.info->content.pszObjId,
3016 {
3018 DWORD size;
3019
3021 msg->u.signed_data.info->content.Content.pbData,
3022 msg->u.signed_data.info->content.Content.cbData,
3024 if (ret)
3025 {
3027 blob->cbData);
3028 LocalFree(blob);
3029 }
3030 }
3031 else
3033 msg->u.signed_data.info->content.Content.pbData,
3034 msg->u.signed_data.info->content.Content.cbData);
3035 }
3036 else
3038 break;
3040 if (msg->u.signed_data.info)
3042 msg->u.signed_data.info->content.pszObjId,
3043 strlen(msg->u.signed_data.info->content.pszObjId) + 1);
3044 else
3046 break;
3048 if (msg->u.signed_data.info)
3050 &msg->u.signed_data.info->cSignerInfo, sizeof(DWORD));
3051 else
3053 break;
3055 if (msg->u.signed_data.info)
3056 {
3057 if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
3059 else
3061 &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
3062 }
3063 else
3065 break;
3067 if (msg->u.signed_data.info)
3068 {
3069 if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
3071 else
3073 &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
3074 }
3075 else
3077 break;
3079 if (msg->u.signed_data.info)
3081 &msg->u.signed_data.info->cCertEncoded, sizeof(DWORD));
3082 else
3084 break;
3085 case CMSG_CERT_PARAM:
3086 if (msg->u.signed_data.info)
3087 {
3088 if (dwIndex >= msg->u.signed_data.info->cCertEncoded)
3090 else
3092 msg->u.signed_data.info->rgCertEncoded[dwIndex].pbData,
3093 msg->u.signed_data.info->rgCertEncoded[dwIndex].cbData);
3094 }
3095 else
3097 break;
3099 if (msg->u.signed_data.info)
3101 &msg->u.signed_data.info->cCrlEncoded, sizeof(DWORD));
3102 else
3104 break;
3105 case CMSG_CRL_PARAM:
3106 if (msg->u.signed_data.info)
3107 {
3108 if (dwIndex >= msg->u.signed_data.info->cCrlEncoded)
3110 else
3112 msg->u.signed_data.info->rgCrlEncoded[dwIndex].pbData,
3113 msg->u.signed_data.info->rgCrlEncoded[dwIndex].cbData);
3114 }
3115 else
3117 break;
3119 if (msg->u.signed_data.info)
3120 {
3121 if (dwIndex >= msg->u.signed_data.cSignerHandle)
3123 else
3125 msg->u.signed_data.signerHandles[dwIndex].contentHash,
3127 }
3128 else
3130 break;
3132 if (msg->u.signed_data.info)
3133 {
3134 if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
3136 else
3139 &msg->u.signed_data.info->rgSignerInfo[dwIndex], 0, NULL,
3140 pvData, pcbData);
3141 }
3142 else
3144 break;
3146 if (msg->u.signed_data.info)
3147 {
3148 DWORD attrCertCount = 0;
3149
3151 &attrCertCount, sizeof(DWORD));
3152 }
3153 else
3155 break;
3157 if (msg->u.signed_data.info)
3159 else
3161 break;
3163 if (msg->u.signed_data.info)
3164 {
3165 if (dwIndex >= msg->u.signed_data.info->cSignerInfo)
3167 else
3169 &msg->u.signed_data.info->rgSignerInfo[dwIndex]);
3170 }
3171 else
3173 break;
3174 default:
3175 FIXME("unimplemented for %d\n", dwParamType);
3177 }
3178 return ret;
3179}
static BOOL CRYPT_CopySignerInfo(void *pvData, DWORD *pcbData, const CMSG_CMS_SIGNER_INFO *in)
Definition: msg.c:2728
static BOOL CRYPT_CopyCMSSignerInfo(void *pvData, DWORD *pcbData, const CMSG_CMS_SIGNER_INFO *in)
Definition: msg.c:2800
static BOOL CRYPT_CopySignerCertInfo(void *pvData, DWORD *pcbData, const CMSG_CMS_SIGNER_INFO *in)
Definition: msg.c:2867
#define CMSG_ATTR_CERT_COUNT_PARAM
Definition: wincrypt.h:3951
#define CMSG_SIGNER_CERT_INFO_PARAM
Definition: wincrypt.h:3931
#define CMSG_ENCODED_SIGNER
Definition: wincrypt.h:3948
#define CMSG_CMS_SIGNER_INFO_PARAM
Definition: wincrypt.h:3959
#define CMSG_SIGNER_INFO_PARAM
Definition: wincrypt.h:3930
#define CMS_SIGNER_INFO
Definition: wincrypt.h:3437
#define CMSG_CRL_PARAM
Definition: wincrypt.h:3938
#define CMSG_SIGNER_COUNT_PARAM
Definition: wincrypt.h:3929
#define PKCS_7_ASN_ENCODING
Definition: wincrypt.h:2299
#define CMSG_ATTR_CERT_PARAM
Definition: wincrypt.h:3952
#define CMSG_CERT_COUNT_PARAM
Definition: wincrypt.h:3935
#define CMSG_CRL_COUNT_PARAM
Definition: wincrypt.h:3937
#define CMSG_CERT_PARAM
Definition: wincrypt.h:3936

Referenced by CDecodeMsg_GetParam().

◆ CDecodeSignedMsg_VerifySignature()

static BOOL CDecodeSignedMsg_VerifySignature ( CDecodeMsg msg,
PCERT_INFO  info 
)
static

Definition at line 3303 of file msg.c.

3304{
3305 BOOL ret = FALSE;
3306 DWORD i;
3307
3308 if (!msg->u.signed_data.signerHandles)
3309 {
3311 return FALSE;
3312 }
3313 for (i = 0; !ret && i < msg->u.signed_data.info->cSignerInfo; i++)
3314 {
3315 PCMSG_CMS_SIGNER_INFO signerInfo =
3316 &msg->u.signed_data.info->rgSignerInfo[i];
3317
3319 {
3321 &signerInfo->SignerId.u.IssuerSerialNumber.Issuer,
3322 &info->Issuer);
3323 if (ret)
3324 {
3327 &info->SerialNumber);
3328 if (ret)
3329 break;
3330 }
3331 }
3332 else
3333 {
3334 FIXME("signer %d: unimplemented for key id\n", i);
3335 }
3336 }
3337 if (ret)
3339 &info->SubjectPublicKeyInfo);
3340 else
3342
3343 return ret;
3344}
BOOL WINAPI CertCompareCertificateName(DWORD dwCertEncodingType, PCERT_NAME_BLOB pCertName1, PCERT_NAME_BLOB pCertName2)
Definition: cert.c:1180
BOOL WINAPI CertCompareIntegerBlob(PCRYPT_INTEGER_BLOB pInt1, PCRYPT_INTEGER_BLOB pInt2)
Definition: cert.c:1221
static BOOL CDecodeSignedMsg_VerifySignatureWithKey(CDecodeMsg *msg, HCRYPTPROV prov, DWORD signerIndex, PCERT_PUBLIC_KEY_INFO keyInfo)
Definition: msg.c:3271
DWORD dwIdChoice
Definition: wincrypt.h:3665
#define CERT_ID_ISSUER_SERIAL_NUMBER
Definition: wincrypt.h:3673
#define NTE_BAD_SIGNATURE
Definition: winerror.h:2874
#define CRYPT_E_SIGNER_NOT_FOUND
Definition: winerror.h:2998

Referenced by CDecodeMsg_Control().

◆ CDecodeSignedMsg_VerifySignatureEx()

static BOOL CDecodeSignedMsg_VerifySignatureEx ( CDecodeMsg msg,
PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA  para 
)
static

Definition at line 3346 of file msg.c.

3348{
3349 BOOL ret = FALSE;
3350
3351 if (para->cbSize != sizeof(CMSG_CTRL_VERIFY_SIGNATURE_EX_PARA))
3353 else if (para->dwSignerIndex >= msg->u.signed_data.info->cSignerInfo)
3355 else if (!msg->u.signed_data.signerHandles)
3357 else
3358 {
3359 switch (para->dwSignerType)
3360 {
3363 para->hCryptProv, para->dwSignerIndex, para->pvSigner);
3364 break;
3366 {
3368
3370 para->dwSignerIndex, &cert->pCertInfo->SubjectPublicKeyInfo);
3371 break;
3372 }
3373 default:
3374 FIXME("unimplemented for signer type %d\n", para->dwSignerType);
3376 }
3377 }
3378 return ret;
3379}
#define CMSG_VERIFY_SIGNER_CERT
Definition: wincrypt.h:3921
#define CMSG_VERIFY_SIGNER_PUBKEY
Definition: wincrypt.h:3920

Referenced by CDecodeMsg_Control().

◆ CDecodeSignedMsg_VerifySignatureWithKey()

static BOOL CDecodeSignedMsg_VerifySignatureWithKey ( CDecodeMsg msg,
HCRYPTPROV  prov,
DWORD  signerIndex,
PCERT_PUBLIC_KEY_INFO  keyInfo 
)
static

Definition at line 3271 of file msg.c.

3273{
3274 HCRYPTKEY key;
3275 BOOL ret;
3276
3277 if (!prov)
3278 prov = msg->crypt_prov;
3280 if (ret)
3281 {
3283 CRYPT_HASH_BLOB reversedHash;
3284
3285 if (msg->u.signed_data.info->rgSignerInfo[signerIndex].AuthAttrs.cAttr)
3286 hash = msg->u.signed_data.signerHandles[signerIndex].authAttrHash;
3287 else
3288 hash = msg->u.signed_data.signerHandles[signerIndex].contentHash;
3289 ret = CRYPT_ConstructBlob(&reversedHash,
3290 &msg->u.signed_data.info->rgSignerInfo[signerIndex].EncryptedHash);
3291 if (ret)
3292 {
3293 CRYPT_ReverseBytes(&reversedHash);
3294 ret = CryptVerifySignatureW(hash, reversedHash.pbData,
3295 reversedHash.cbData, key, NULL, 0);
3296 CryptMemFree(reversedHash.pbData);
3297 }
3299 }
3300 return ret;
3301}
BOOL WINAPI CryptVerifySignatureW(HCRYPTHASH hHash, const BYTE *pbSignature, DWORD dwSigLen, HCRYPTKEY hPubKey, LPCWSTR sDescription, DWORD dwFlags)
Definition: crypt.c:2238
BOOL WINAPI CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey)
Definition: encode.c:4970
static void CRYPT_ReverseBytes(CRYPT_HASH_BLOB *hash)
Definition: msg.c:1118
Definition: _hash_fun.h:40
ULONG_PTR HCRYPTHASH
Definition: wincrypt.h:50

Referenced by CDecodeSignedMsg_VerifySignature(), and CDecodeSignedMsg_VerifySignatureEx().

◆ CEnvelopedEncodeMsg_Close()

static void CEnvelopedEncodeMsg_Close ( HCRYPTMSG  hCryptMsg)
static

Definition at line 1798 of file msg.c.

1799{
1800 CEnvelopedEncodeMsg *msg = hCryptMsg;
1801
1802 CryptMemFree(msg->algo.pszObjId);
1803 CryptMemFree(msg->algo.Parameters.pbData);
1804 if (msg->base.open_flags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
1805 CryptReleaseContext(msg->prov, 0);
1806 CryptDestroyKey(msg->key);
1807 if (msg->recipientInfo)
1808 {
1809 DWORD i;
1810
1811 for (i = 0; i < msg->cRecipientInfo; ++i)
1812 CRecipientInfo_Free(&msg->recipientInfo[i]);
1813 CryptMemFree(msg->recipientInfo);
1814 }
1815 CryptMemFree(msg->data.pbData);
1816}
static void CRecipientInfo_Free(CMSG_KEY_TRANS_RECIPIENT_INFO *info)
Definition: msg.c:1789

Referenced by CEnvelopedEncodeMsg_Open().

◆ CEnvelopedEncodeMsg_GetParam()

static BOOL CEnvelopedEncodeMsg_GetParam ( HCRYPTMSG  hCryptMsg,
DWORD  dwParamType,
DWORD  dwIndex,
void pvData,
DWORD pcbData 
)
static

Definition at line 1818 of file msg.c.

1820{
1821 CEnvelopedEncodeMsg *msg = hCryptMsg;
1822 BOOL ret = FALSE;
1823
1824 switch (dwParamType)
1825 {
1827 if (msg->base.streamed)
1829 else
1830 {
1831 char oid_rsa_data[] = szOID_RSA_data;
1832 CRYPT_ENVELOPED_DATA envelopedData = {
1834 msg->recipientInfo, { oid_rsa_data, {
1835 msg->algo.pszObjId,
1836 { msg->algo.Parameters.cbData, msg->algo.Parameters.pbData }
1837 },
1838 { msg->data.cbData, msg->data.pbData }
1839 }
1840 };
1841
1843 pcbData);
1844 }
1845 break;
1846 case CMSG_CONTENT_PARAM:
1847 {
1849
1851 &info.Content.cbData);
1852 if (ret)
1853 {
1854 info.Content.pbData = CryptMemAlloc(info.Content.cbData);
1855 if (info.Content.pbData)
1856 {
1858 info.Content.pbData, &info.Content.cbData);
1859 if (ret)
1860 {
1861 char oid_rsa_enveloped[] = szOID_RSA_envelopedData;
1862
1863 info.pszObjId = oid_rsa_enveloped;
1866 }
1867 CryptMemFree(info.Content.pbData);
1868 }
1869 else
1870 ret = FALSE;
1871 }
1872 break;
1873 }
1874 default:
1876 }
1877 return ret;
1878}
BOOL CRYPT_AsnEncodePKCSEnvelopedData(const CRYPT_ENVELOPED_DATA *envelopedData, void *pvData, DWORD *pcbData) DECLSPEC_HIDDEN
Definition: encode.c:4418
#define CMSG_ENVELOPED_DATA_PKCS_1_5_VERSION
Definition: wincrypt.h:3990

Referenced by CEnvelopedEncodeMsg_Open().

◆ CEnvelopedEncodeMsg_Open()

static HCRYPTMSG CEnvelopedEncodeMsg_Open ( DWORD  dwFlags,
const void pvMsgEncodeInfo,
LPCSTR  pszInnerContentObjID,
PCMSG_STREAM_INFO  pStreamInfo 
)
static

Definition at line 1949 of file msg.c.

1952{
1954 const CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS *info = pvMsgEncodeInfo;
1955 HCRYPTPROV prov;
1956 ALG_ID algID;
1957
1958 if (info->cbSize != sizeof(CMSG_ENVELOPED_ENCODE_INFO) &&
1959 info->cbSize != sizeof(CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS))
1960 {
1962 return NULL;
1963 }
1964 if (info->cbSize == sizeof(CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS))
1965 FIXME("CMS fields unsupported\n");
1966 if (!(algID = CertOIDToAlgId(info->ContentEncryptionAlgorithm.pszObjId)))
1967 {
1969 return NULL;
1970 }
1971 if (info->cRecipients && !info->rgpRecipientCert)
1972 {
1974 return NULL;
1975 }
1976 if (info->hCryptProv)
1977 prov = info->hCryptProv;
1978 else
1979 {
1981 dwFlags &= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG;
1982 }
1984 if (msg)
1985 {
1986 CRYPT_DATA_BLOB encryptedKey = { 0, NULL };
1987 CMSG_CONTENT_ENCRYPT_INFO encryptInfo;
1988 BOOL ret;
1989 DWORD i;
1990
1991 CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
1995 &info->ContentEncryptionAlgorithm);
1996 msg->prov = prov;
1997 msg->data.cbData = 0;
1998 msg->data.pbData = NULL;
1999 msg->cRecipientInfo = info->cRecipients;
2000 msg->recipientInfo = CryptMemAlloc(info->cRecipients *
2002 if (!msg->recipientInfo)
2003 ret = FALSE;
2004 memset(&encryptInfo, 0, sizeof(encryptInfo));
2005 if (ret)
2006 {
2007 ret = CContentEncryptInfo_Construct(&encryptInfo, info, prov);
2008 if (ret)
2009 {
2010 ret = CRYPT_GenKey(&encryptInfo, algID);
2011 if (ret)
2012 msg->key = encryptInfo.hContentEncryptKey;
2013 }
2014 }
2015 for (i = 0; ret && i < msg->cRecipientInfo; ++i)
2016 {
2017 ret = CRYPT_ExportEncryptedKey(&encryptInfo, i, &encryptedKey);
2018 if (ret)
2019 ret = CRecipientInfo_Construct(&msg->recipientInfo[i],
2020 info->rgpRecipientCert[i], &encryptedKey);
2021 }
2022 CContentEncryptInfo_Free(&encryptInfo);
2023 if (!ret)
2024 {
2026 msg = NULL;
2027 }
2028 }
2030 CryptReleaseContext(prov, 0);
2031 return msg;
2032}
static void CEnvelopedEncodeMsg_Close(HCRYPTMSG hCryptMsg)
Definition: msg.c:1798
static void CContentEncryptInfo_Free(CMSG_CONTENT_ENCRYPT_INFO *info)
Definition: msg.c:1742
static BOOL CRYPT_ExportEncryptedKey(CMSG_CONTENT_ENCRYPT_INFO *info, DWORD i, CRYPT_DATA_BLOB *key)
Definition: msg.c:1629
static BOOL CEnvelopedEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
Definition: msg.c:1880
static BOOL CRecipientInfo_Construct(CMSG_KEY_TRANS_RECIPIENT_INFO *info, const CERT_INFO *cert, CRYPT_DATA_BLOB *key)
Definition: msg.c:1768
BOOL WINAPI CryptMsgClose(HCRYPTMSG hCryptMsg)
Definition: msg.c:3597
static BOOL CRYPT_GenKey(CMSG_CONTENT_ENCRYPT_INFO *info, ALG_ID algID)
Definition: msg.c:1542
static BOOL CContentEncryptInfo_Construct(CMSG_CONTENT_ENCRYPT_INFO *info, const CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS *in, HCRYPTPROV prov)
Definition: msg.c:1681
static BOOL CEnvelopedEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:1818
#define memset(x, y, z)
Definition: compat.h:39
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
#define CRYPT_E_UNKNOWN_ALGO
Definition: winerror.h:2986

Referenced by CryptMsgOpenToEncode().

◆ CEnvelopedEncodeMsg_Update()

static BOOL CEnvelopedEncodeMsg_Update ( HCRYPTMSG  hCryptMsg,
const BYTE pbData,
DWORD  cbData,
BOOL  fFinal 
)
static

Definition at line 1880 of file msg.c.

1882{
1883 CEnvelopedEncodeMsg *msg = hCryptMsg;
1884 BOOL ret = FALSE;
1885
1886 if (msg->base.state == MsgStateFinalized)
1888 else if (msg->base.streamed)
1889 {
1890 FIXME("streamed stub\n");
1891 msg->base.state = fFinal ? MsgStateFinalized : MsgStateUpdated;
1892 ret = TRUE;
1893 }
1894 else
1895 {
1896 if (!fFinal)
1897 {
1898 if (msg->base.open_flags & CMSG_DETACHED_FLAG)
1900 else
1902 }
1903 else
1904 {
1905 if (cbData)
1906 {
1907 DWORD dataLen = cbData;
1908
1909 msg->data.cbData = cbData;
1910 msg->data.pbData = CryptMemAlloc(cbData);
1911 if (msg->data.pbData)
1912 {
1913 memcpy(msg->data.pbData, pbData, cbData);
1914 ret = CryptEncrypt(msg->key, 0, TRUE, 0, msg->data.pbData,
1915 &dataLen, msg->data.cbData);
1916 msg->data.cbData = dataLen;
1917 if (dataLen > cbData)
1918 {
1919 msg->data.pbData = CryptMemRealloc(msg->data.pbData,
1920 dataLen);
1921 if (msg->data.pbData)
1922 {
1923 dataLen = cbData;
1924 ret = CryptEncrypt(msg->key, 0, TRUE, 0,
1925 msg->data.pbData, &dataLen, msg->data.cbData);
1926 }
1927 else
1928 ret = FALSE;
1929 }
1930 if (!ret)
1931 CryptMemFree(msg->data.pbData);
1932 }
1933 else
1934 ret = FALSE;
1935 if (!ret)
1936 {
1937 msg->data.cbData = 0;
1938 msg->data.pbData = NULL;
1939 }
1940 }
1941 else
1942 ret = TRUE;
1943 msg->base.state = MsgStateFinalized;
1944 }
1945 }
1946 return ret;
1947}
BOOL WINAPI CryptEncrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen)
Definition: crypt.c:1093

Referenced by CEnvelopedEncodeMsg_Open().

◆ CHashEncodeMsg_Close()

static void CHashEncodeMsg_Close ( HCRYPTMSG  hCryptMsg)
static

Definition at line 381 of file msg.c.

382{
383 CHashEncodeMsg *msg = hCryptMsg;
384
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);
389}

Referenced by CHashEncodeMsg_Open().

◆ CHashEncodeMsg_GetParam()

static BOOL CHashEncodeMsg_GetParam ( HCRYPTMSG  hCryptMsg,
DWORD  dwParamType,
DWORD  dwIndex,
void pvData,
DWORD pcbData 
)
static

Definition at line 439 of file msg.c.

441{
442 CHashEncodeMsg *msg = hCryptMsg;
443 BOOL ret = FALSE;
444
445 TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
446 pvData, pcbData);
447
448 switch (dwParamType)
449 {
451 if (msg->base.streamed)
453 else
455 break;
457 {
459
461 &info.Content.cbData);
462 if (ret)
463 {
464 info.Content.pbData = CryptMemAlloc(info.Content.cbData);
465 if (info.Content.pbData)
466 {
468 info.Content.pbData, &info.Content.cbData);
469 if (ret)
470 {
471 char oid_rsa_hashed[] = szOID_RSA_hashedData;
472
473 info.pszObjId = oid_rsa_hashed;
476 }
477 CryptMemFree(info.Content.pbData);
478 }
479 else
480 ret = FALSE;
481 }
482 break;
483 }
486 break;
488 if (msg->base.state != MsgStateFinalized)
490 else
491 {
493
494 /* Since the data are always encoded as octets, the version is
495 * always 0 (see rfc3852, section 7)
496 */
498 }
499 break;
500 default:
502 }
503 return ret;
504}
static BOOL CRYPT_EncodePKCSDigestedData(CHashEncodeMsg *msg, void *pvData, DWORD *pcbData)
Definition: msg.c:391
static const WCHAR version[]
Definition: asmname.c:66
#define szOID_RSA_hashedData
Definition: wincrypt.h:3033
#define CMSG_HASHED_DATA_PKCS_1_5_VERSION
Definition: wincrypt.h:3985

Referenced by CHashEncodeMsg_Open().

◆ CHashEncodeMsg_Open()

static HCRYPTMSG CHashEncodeMsg_Open ( DWORD  dwFlags,
const void pvMsgEncodeInfo,
LPSTR  pszInnerContentObjID,
PCMSG_STREAM_INFO  pStreamInfo 
)
static

Definition at line 548 of file msg.c.

550{
552 const CMSG_HASHED_ENCODE_INFO *info = pvMsgEncodeInfo;
553 HCRYPTPROV prov;
554 ALG_ID algID;
555
556 if (info->cbSize != sizeof(CMSG_HASHED_ENCODE_INFO))
557 {
559 return NULL;
560 }
561 if (!(algID = CertOIDToAlgId(info->HashAlgorithm.pszObjId)))
562 {
564 return NULL;
565 }
566 if (info->hCryptProv)
567 prov = info->hCryptProv;
568 else
569 {
570 prov = I_CryptGetDefaultCryptProv(algID);
571 if (!prov)
572 {
574 return NULL;
575 }
576 dwFlags &= ~CMSG_CRYPT_RELEASE_CONTEXT_FLAG;
577 }
579 if (msg)
580 {
581 CryptMsgBase_Init((CryptMsgBase *)msg, dwFlags, pStreamInfo,
584 msg->prov = prov;
585 msg->data.cbData = 0;
586 msg->data.pbData = NULL;
587 if (!CryptCreateHash(prov, algID, 0, 0, &msg->hash))
588 {
590 msg = NULL;
591 }
592 }
593 return msg;
594}
static BOOL CHashEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
Definition: msg.c:506
static BOOL CHashEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:439
static void CHashEncodeMsg_Close(HCRYPTMSG hCryptMsg)
Definition: msg.c:381

Referenced by CryptMsgOpenToEncode().

◆ CHashEncodeMsg_Update()

static BOOL CHashEncodeMsg_Update ( HCRYPTMSG  hCryptMsg,
const BYTE pbData,
DWORD  cbData,
BOOL  fFinal 
)
static

Definition at line 506 of file msg.c.

508{
509 CHashEncodeMsg *msg = hCryptMsg;
510 BOOL ret = FALSE;
511
512 TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
513
514 if (msg->base.state == MsgStateFinalized)
516 else if (msg->base.streamed || (msg->base.open_flags & CMSG_DETACHED_FLAG))
517 {
518 /* Doesn't do much, as stream output is never called, and you
519 * can't get the content.
520 */
521 ret = CryptHashData(msg->hash, pbData, cbData, 0);
522 msg->base.state = fFinal ? MsgStateFinalized : MsgStateUpdated;
523 }
524 else
525 {
526 if (!fFinal)
528 else
529 {
530 ret = CryptHashData(msg->hash, pbData, cbData, 0);
531 if (ret)
532 {
533 msg->data.pbData = CryptMemAlloc(cbData);
534 if (msg->data.pbData)
535 {
536 memcpy(msg->data.pbData + msg->data.cbData, pbData, cbData);
537 msg->data.cbData += cbData;
538 }
539 else
540 ret = FALSE;
541 }
542 msg->base.state = MsgStateFinalized;
543 }
544 }
545 return ret;
546}

Referenced by CHashEncodeMsg_Open().

◆ CRecipientInfo_Construct()

static BOOL CRecipientInfo_Construct ( CMSG_KEY_TRANS_RECIPIENT_INFO info,
const CERT_INFO cert,
CRYPT_DATA_BLOB key 
)
static

Definition at line 1768 of file msg.c.

1770{
1771 BOOL ret;
1772
1774 info->RecipientId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
1775 ret = CRYPT_ConstructBlob(&info->RecipientId.u.IssuerSerialNumber.Issuer,
1776 &cert->Issuer);
1777 if (ret)
1779 &info->RecipientId.u.IssuerSerialNumber.SerialNumber,
1780 &cert->SerialNumber);
1781 if (ret)
1782 ret = CRYPT_ConstructAlgorithmId(&info->KeyEncryptionAlgorithm,
1783 &cert->SubjectPublicKeyInfo.Algorithm);
1784 info->EncryptedKey.cbData = key->cbData;
1785 info->EncryptedKey.pbData = key->pbData;
1786 return ret;
1787}
#define CMSG_KEY_TRANS_PKCS_1_5_VERSION
Definition: wincrypt.h:4043

Referenced by CEnvelopedEncodeMsg_Open().

◆ CRecipientInfo_Free()

static void CRecipientInfo_Free ( CMSG_KEY_TRANS_RECIPIENT_INFO info)
static

Definition at line 1789 of file msg.c.

1790{
1791 CryptMemFree(info->RecipientId.u.IssuerSerialNumber.Issuer.pbData);
1792 CryptMemFree(info->RecipientId.u.IssuerSerialNumber.SerialNumber.pbData);
1793 CryptMemFree(info->KeyEncryptionAlgorithm.pszObjId);
1794 CryptMemFree(info->KeyEncryptionAlgorithm.Parameters.pbData);
1795 CryptMemFree(info->EncryptedKey.pbData);
1796}

Referenced by CEnvelopedEncodeMsg_Close().

◆ CRYPT_AppendAttribute()

static BOOL CRYPT_AppendAttribute ( CRYPT_ATTRIBUTES out,
const CRYPT_ATTRIBUTE in 
)
static

Definition at line 1011 of file msg.c.

1013{
1014 BOOL ret = FALSE;
1015
1016 out->rgAttr = CryptMemRealloc(out->rgAttr,
1017 (out->cAttr + 1) * sizeof(CRYPT_ATTRIBUTE));
1018 if (out->rgAttr)
1019 {
1020 ret = CRYPT_ConstructAttribute(&out->rgAttr[out->cAttr], in);
1021 if (ret)
1022 out->cAttr++;
1023 }
1024 return ret;
1025}
static BOOL CRYPT_ConstructAttribute(CRYPT_ATTRIBUTE *out, const CRYPT_ATTRIBUTE *in)
Definition: msg.c:754
static FILE * out
Definition: regtests2xml.c:44

Referenced by CSignedMsgData_AppendMessageDigestAttribute(), and CSignedMsgData_UpdateAuthenticatedAttributes().

◆ CRYPT_ConstructAlgorithmId()

static BOOL CRYPT_ConstructAlgorithmId ( CRYPT_ALGORITHM_IDENTIFIER out,
const CRYPT_ALGORITHM_IDENTIFIER in 
)
static

Definition at line 1512 of file msg.c.

1514{
1515 out->pszObjId = CryptMemAlloc(strlen(in->pszObjId) + 1);
1516 if (out->pszObjId)
1517 {
1518 strcpy(out->pszObjId, in->pszObjId);
1519 return CRYPT_ConstructBlob(&out->Parameters, &in->Parameters);
1520 }
1521 else
1522 return FALSE;
1523}

Referenced by CContentEncryptInfo_Construct(), CEnvelopedEncodeMsg_Open(), CRecipientInfo_Construct(), CRYPT_ExportEncryptedKey(), and CRYPT_ExportKeyTrans().

◆ CRYPT_ConstructAttribute()

static BOOL CRYPT_ConstructAttribute ( CRYPT_ATTRIBUTE out,
const CRYPT_ATTRIBUTE in 
)
static

Definition at line 754 of file msg.c.

756{
757 BOOL ret;
758
759 out->pszObjId = CryptMemAlloc(strlen(in->pszObjId) + 1);
760 if (out->pszObjId)
761 {
762 strcpy(out->pszObjId, in->pszObjId);
763 ret = CRYPT_ConstructBlobArray(&out->cValue, &out->rgValue,
764 in->cValue, in->rgValue);
765 }
766 else
767 ret = FALSE;
768 return ret;
769}
static BOOL CRYPT_ConstructBlobArray(DWORD *outCBlobs, PCRYPT_DATA_BLOB *outPBlobs, DWORD cBlobs, const CRYPT_DATA_BLOB *pBlobs)
Definition: msg.c:722

Referenced by CRYPT_AppendAttribute(), and CRYPT_ConstructAttributes().

◆ CRYPT_ConstructAttributes()

static BOOL CRYPT_ConstructAttributes ( CRYPT_ATTRIBUTES out,
const CRYPT_ATTRIBUTES in 
)
static

Definition at line 771 of file msg.c.

773{
774 BOOL ret = TRUE;
775
776 out->cAttr = in->cAttr;
777 if (out->cAttr)
778 {
779 out->rgAttr = CryptMemAlloc(out->cAttr * sizeof(CRYPT_ATTRIBUTE));
780 if (out->rgAttr)
781 {
782 DWORD i;
783
784 memset(out->rgAttr, 0, out->cAttr * sizeof(CRYPT_ATTRIBUTE));
785 for (i = 0; ret && i < out->cAttr; i++)
786 ret = CRYPT_ConstructAttribute(&out->rgAttr[i], &in->rgAttr[i]);
787 }
788 else
789 ret = FALSE;
790 }
791 else
792 out->rgAttr = NULL;
793 return ret;
794}

Referenced by CSignerInfo_Construct().

◆ CRYPT_ConstructBitBlob()

static BOOL CRYPT_ConstructBitBlob ( CRYPT_BIT_BLOB out,
const CRYPT_BIT_BLOB in 
)
static

Definition at line 1525 of file msg.c.

1526{
1527 out->cbData = in->cbData;
1528 out->cUnusedBits = in->cUnusedBits;
1529 if (out->cbData)
1530 {
1531 out->pbData = CryptMemAlloc(out->cbData);
1532 if (out->pbData)
1533 memcpy(out->pbData, in->pbData, out->cbData);
1534 else
1535 return FALSE;
1536 }
1537 else
1538 out->pbData = NULL;
1539 return TRUE;
1540}

Referenced by CContentEncryptInfo_Construct(), and CRYPT_ExportKeyTrans().

◆ CRYPT_ConstructBlob()

static BOOL CRYPT_ConstructBlob ( CRYPT_DATA_BLOB out,
const CRYPT_DATA_BLOB in 
)
static

Definition at line 704 of file msg.c.

705{
706 BOOL ret = TRUE;
707
708 out->cbData = in->cbData;
709 if (out->cbData)
710 {
711 out->pbData = CryptMemAlloc(out->cbData);
712 if (out->pbData)
713 memcpy(out->pbData, in->pbData, out->cbData);
714 else
715 ret = FALSE;
716 }
717 else
718 out->pbData = NULL;
719 return ret;
720}

Referenced by CContentEncryptInfo_Construct(), CDecodeMsg_FinalizeEnvelopedContent(), CDecodeSignedMsg_VerifySignatureWithKey(), CRecipientInfo_Construct(), CRYPT_ConstructAlgorithmId(), CRYPT_ConstructBlobArray(), and CSignerInfo_Construct().

◆ CRYPT_ConstructBlobArray()

static BOOL CRYPT_ConstructBlobArray ( DWORD outCBlobs,
PCRYPT_DATA_BLOB outPBlobs,
DWORD  cBlobs,
const CRYPT_DATA_BLOB pBlobs 
)
static

Definition at line 722 of file msg.c.

724{
725 BOOL ret = TRUE;
726
727 *outCBlobs = cBlobs;
728 if (cBlobs)
729 {
730 *outPBlobs = CryptMemAlloc(cBlobs * sizeof(CRYPT_DATA_BLOB));
731 if (*outPBlobs)
732 {
733 DWORD i;
734
735 memset(*outPBlobs, 0, cBlobs * sizeof(CRYPT_DATA_BLOB));
736 for (i = 0; ret && i < cBlobs; i++)
737 ret = CRYPT_ConstructBlob(&(*outPBlobs)[i], &pBlobs[i]);
738 }
739 else
740 ret = FALSE;
741 }
742 return ret;
743}

Referenced by CRYPT_ConstructAttribute(), and CSignedEncodeMsg_Open().

◆ CRYPT_CopyAlgorithmId()

static void CRYPT_CopyAlgorithmId ( CRYPT_ALGORITHM_IDENTIFIER out,
const CRYPT_ALGORITHM_IDENTIFIER in,
LPBYTE nextData 
)
inlinestatic

Definition at line 2614 of file msg.c.

2616{
2617 if (in->pszObjId)
2618 {
2619 out->pszObjId = (LPSTR)*nextData;
2620 strcpy(out->pszObjId, in->pszObjId);
2621 *nextData += strlen(out->pszObjId) + 1;
2622 }
2623 CRYPT_CopyBlob(&out->Parameters, &in->Parameters, nextData);
2624}
static void CRYPT_CopyBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in, LPBYTE *nextData)
Definition: msg.c:2602

Referenced by CRYPT_CopyCMSSignerInfo(), and CRYPT_CopySignerInfo().

◆ CRYPT_CopyAttributes()

static void CRYPT_CopyAttributes ( CRYPT_ATTRIBUTES out,
const CRYPT_ATTRIBUTES in,
LPBYTE nextData 
)
inlinestatic

Definition at line 2626 of file msg.c.

2628{
2629 out->cAttr = in->cAttr;
2630 if (in->cAttr)
2631 {
2632 DWORD i;
2633
2634 *nextData = POINTER_ALIGN_DWORD_PTR(*nextData);
2635 out->rgAttr = (CRYPT_ATTRIBUTE *)*nextData;
2636 *nextData += in->cAttr * sizeof(CRYPT_ATTRIBUTE);
2637 for (i = 0; i < in->cAttr; i++)
2638 {
2639 if (in->rgAttr[i].pszObjId)
2640 {
2641 out->rgAttr[i].pszObjId = (LPSTR)*nextData;
2642 strcpy(out->rgAttr[i].pszObjId, in->rgAttr[i].pszObjId);
2643 *nextData += strlen(in->rgAttr[i].pszObjId) + 1;
2644 }
2645 if (in->rgAttr[i].cValue)
2646 {
2647 DWORD j;
2648
2649 out->rgAttr[i].cValue = in->rgAttr[i].cValue;
2650 *nextData = POINTER_ALIGN_DWORD_PTR(*nextData);
2651 out->rgAttr[i].rgValue = (PCRYPT_DATA_BLOB)*nextData;
2652 *nextData += in->rgAttr[i].cValue * sizeof(CRYPT_DATA_BLOB);
2653 for (j = 0; j < in->rgAttr[i].cValue; j++)
2654 CRYPT_CopyBlob(&out->rgAttr[i].rgValue[j],
2655 &in->rgAttr[i].rgValue[j], nextData);
2656 }
2657 }
2658 }
2659}
#define POINTER_ALIGN_DWORD_PTR(p)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
struct _CRYPT_ATTRIBUTE CRYPT_ATTRIBUTE
struct _CRYPTOAPI_BLOB CRYPT_DATA_BLOB
struct _CRYPTOAPI_BLOB * PCRYPT_DATA_BLOB

Referenced by CRYPT_CopyCMSSignerInfo(), and CRYPT_CopySignerInfo().

◆ CRYPT_CopyBlob()

static void CRYPT_CopyBlob ( CRYPT_DATA_BLOB out,
const CRYPT_DATA_BLOB in,
LPBYTE nextData 
)
inlinestatic

Definition at line 2602 of file msg.c.

2604{
2605 out->cbData = in->cbData;
2606 if (in->cbData)
2607 {
2608 out->pbData = *nextData;
2609 memcpy(out->pbData, in->pbData, in->cbData);
2610 *nextData += in->cbData;
2611 }
2612}

Referenced by CRYPT_CopyAlgorithmId(), CRYPT_CopyAttributes(), CRYPT_CopyCMSSignerInfo(), CRYPT_CopyRecipientInfo(), CRYPT_CopySignerCertInfo(), and CRYPT_CopySignerInfo().

◆ CRYPT_CopyCMSSignerInfo()

static BOOL CRYPT_CopyCMSSignerInfo ( void pvData,
DWORD pcbData,
const CMSG_CMS_SIGNER_INFO in 
)
static

Definition at line 2800 of file msg.c.

2802{
2804 BOOL ret;
2805
2806 TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
2807
2808 if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2809 {
2810 size += in->SignerId.u.IssuerSerialNumber.Issuer.cbData;
2811 size += in->SignerId.u.IssuerSerialNumber.SerialNumber.cbData;
2812 }
2813 else
2814 size += in->SignerId.u.KeyId.cbData;
2815 if (in->HashAlgorithm.pszObjId)
2816 size += strlen(in->HashAlgorithm.pszObjId) + 1;
2817 size += in->HashAlgorithm.Parameters.cbData;
2818 if (in->HashEncryptionAlgorithm.pszObjId)
2819 size += strlen(in->HashEncryptionAlgorithm.pszObjId) + 1;
2820 size += in->HashEncryptionAlgorithm.Parameters.cbData;
2821 size += in->EncryptedHash.cbData;
2822 /* align pointer */
2824 size += CRYPT_SizeOfAttributes(&in->AuthAttrs);
2825 size += CRYPT_SizeOfAttributes(&in->UnauthAttrs);
2826 if (!pvData)
2827 {
2828 *pcbData = size;
2829 ret = TRUE;
2830 }
2831 else if (*pcbData < size)
2832 {
2833 *pcbData = size;
2835 ret = FALSE;
2836 }
2837 else
2838 {
2839 LPBYTE nextData = (BYTE *)pvData + sizeof(CMSG_CMS_SIGNER_INFO);
2841
2842 out->dwVersion = in->dwVersion;
2843 out->SignerId.dwIdChoice = in->SignerId.dwIdChoice;
2844 if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2845 {
2846 CRYPT_CopyBlob(&out->SignerId.u.IssuerSerialNumber.Issuer,
2847 &in->SignerId.u.IssuerSerialNumber.Issuer, &nextData);
2848 CRYPT_CopyBlob(&out->SignerId.u.IssuerSerialNumber.SerialNumber,
2849 &in->SignerId.u.IssuerSerialNumber.SerialNumber, &nextData);
2850 }
2851 else
2852 CRYPT_CopyBlob(&out->SignerId.u.KeyId, &in->SignerId.u.KeyId, &nextData);
2853 CRYPT_CopyAlgorithmId(&out->HashAlgorithm, &in->HashAlgorithm,
2854 &nextData);
2855 CRYPT_CopyAlgorithmId(&out->HashEncryptionAlgorithm,
2856 &in->HashEncryptionAlgorithm, &nextData);
2857 CRYPT_CopyBlob(&out->EncryptedHash, &in->EncryptedHash, &nextData);
2858 nextData = POINTER_ALIGN_DWORD_PTR(nextData);
2859 CRYPT_CopyAttributes(&out->AuthAttrs, &in->AuthAttrs, &nextData);
2860 CRYPT_CopyAttributes(&out->UnauthAttrs, &in->UnauthAttrs, &nextData);
2861 ret = TRUE;
2862 }
2863 TRACE("returning %d\n", ret);
2864 return ret;
2865}
#define ALIGN_DWORD_PTR(x)
#define ERROR_MORE_DATA
Definition: dderror.h:13
static void CRYPT_CopyAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER *out, const CRYPT_ALGORITHM_IDENTIFIER *in, LPBYTE *nextData)
Definition: msg.c:2614
static void CRYPT_CopyAttributes(CRYPT_ATTRIBUTES *out, const CRYPT_ATTRIBUTES *in, LPBYTE *nextData)
Definition: msg.c:2626
static DWORD CRYPT_SizeOfAttributes(const CRYPT_ATTRIBUTES *attr)
Definition: msg.c:2661
struct _CMSG_CMS_SIGNER_INFO CMSG_CMS_SIGNER_INFO

Referenced by CDecodeSignedMsg_GetParam().

◆ CRYPT_CopyKeyIdAsIssuerAndSerial()

static BOOL CRYPT_CopyKeyIdAsIssuerAndSerial ( CERT_NAME_BLOB issuer,
CRYPT_INTEGER_BLOB serialNumber,
const CRYPT_DATA_BLOB keyId,
DWORD  encodedLen,
LPBYTE nextData 
)
static

Definition at line 2697 of file msg.c.

2700{
2701 static char oid_key_rdn[] = szOID_KEYID_RDN;
2703 CERT_RDN rdn = { 1, &attr };
2704 CERT_NAME_INFO name = { 1, &rdn };
2705 BOOL ret;
2706
2707 /* Encode special zero serial number */
2708 serialNumber->cbData = 1;
2709 serialNumber->pbData = *nextData;
2710 **nextData = 0;
2711 (*nextData)++;
2712 /* Encode issuer */
2713 issuer->pbData = *nextData;
2714 attr.pszObjId = oid_key_rdn;
2715 attr.dwValueType = CERT_RDN_OCTET_STRING;
2716 attr.Value.cbData = keyId->cbData;
2717 attr.Value.pbData = keyId->pbData;
2719 &encodedLen);
2720 if (ret)
2721 {
2722 *nextData += encodedLen;
2723 issuer->cbData = encodedLen;
2724 }
2725 return ret;
2726}
static WCHAR issuer[MAX_STRING_RESOURCE_LEN]
Definition: object.c:1905
static BYTE keyId[]
Definition: encode.c:4920
static const BYTE serialNumber[]
Definition: msg.c:2848
Definition: cookie.c:202
Definition: name.c:39
#define X509_NAME
Definition: wincrypt.h:3372
#define szOID_KEYID_RDN
Definition: wincrypt.h:3287
#define CERT_RDN_OCTET_STRING
Definition: wincrypt.h:2778

Referenced by CRYPT_CopySignerCertInfo(), and CRYPT_CopySignerInfo().

◆ CRYPT_CopyParam()

static BOOL CRYPT_CopyParam ( void pvData,
DWORD pcbData,
const void src,
DWORD  len 
)
static

Definition at line 294 of file msg.c.

296{
297 BOOL ret = TRUE;
298
299 if (!pvData)
300 *pcbData = len;
301 else if (*pcbData < len)
302 {
303 *pcbData = len;
305 ret = FALSE;
306 }
307 else
308 {
309 *pcbData = len;
310 memcpy(pvData, src, len);
311 }
312 return ret;
313}
GLenum src
Definition: glext.h:6340

Referenced by CDataEncodeMsg_GetParam(), CDecodeEnvelopedMsg_GetParam(), CDecodeHashMsg_GetParam(), CDecodeMsg_GetParam(), CDecodeSignedMsg_GetParam(), CHashEncodeMsg_GetParam(), and CSignedEncodeMsg_GetParam().

◆ CRYPT_CopyRecipientInfo()

static BOOL CRYPT_CopyRecipientInfo ( void pvData,
DWORD pcbData,
const CERT_ISSUER_SERIAL_NUMBER in 
)
static

Definition at line 2918 of file msg.c.

2920{
2921 DWORD size = sizeof(CERT_INFO);
2922 BOOL ret;
2923
2924 TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
2925
2926 size += in->SerialNumber.cbData;
2927 size += in->Issuer.cbData;
2928 if (!pvData)
2929 {
2930 *pcbData = size;
2931 ret = TRUE;
2932 }
2933 else if (*pcbData < size)
2934 {
2935 *pcbData = size;
2937 ret = FALSE;
2938 }
2939 else
2940 {
2941 LPBYTE nextData = (BYTE *)pvData + sizeof(CERT_INFO);
2942 CERT_INFO *out = pvData;
2943
2944 CRYPT_CopyBlob(&out->SerialNumber, &in->SerialNumber, &nextData);
2945 CRYPT_CopyBlob(&out->Issuer, &in->Issuer, &nextData);
2946 ret = TRUE;
2947 }
2948 TRACE("returning %d\n", ret);
2949 return ret;
2950}
struct _CERT_INFO CERT_INFO

Referenced by CDecodeEnvelopedMsg_GetParam().

◆ CRYPT_CopySignerCertInfo()

static BOOL CRYPT_CopySignerCertInfo ( void pvData,
DWORD pcbData,
const CMSG_CMS_SIGNER_INFO in 
)
static

Definition at line 2867 of file msg.c.

2869{
2870 DWORD size = sizeof(CERT_INFO), rdnSize = 0;
2871 BOOL ret;
2872
2873 TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
2874
2875 if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2876 {
2877 size += in->SignerId.u.IssuerSerialNumber.Issuer.cbData;
2878 size += in->SignerId.u.IssuerSerialNumber.SerialNumber.cbData;
2879 }
2880 else
2881 {
2882 rdnSize = CRYPT_SizeOfKeyIdAsIssuerAndSerial(&in->SignerId.u.KeyId);
2883 size += rdnSize;
2884 }
2885 if (!pvData)
2886 {
2887 *pcbData = size;
2888 ret = TRUE;
2889 }
2890 else if (*pcbData < size)
2891 {
2892 *pcbData = size;
2894 ret = FALSE;
2895 }
2896 else
2897 {
2898 LPBYTE nextData = (BYTE *)pvData + sizeof(CERT_INFO);
2899 CERT_INFO *out = pvData;
2900
2901 memset(out, 0, sizeof(CERT_INFO));
2902 if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2903 {
2904 CRYPT_CopyBlob(&out->Issuer,
2905 &in->SignerId.u.IssuerSerialNumber.Issuer, &nextData);
2906 CRYPT_CopyBlob(&out->SerialNumber,
2907 &in->SignerId.u.IssuerSerialNumber.SerialNumber, &nextData);
2908 ret = TRUE;
2909 }
2910 else
2911 ret = CRYPT_CopyKeyIdAsIssuerAndSerial(&out->Issuer, &out->SerialNumber,
2912 &in->SignerId.u.KeyId, rdnSize, &nextData);
2913 }
2914 TRACE("returning %d\n", ret);
2915 return ret;
2916}
static DWORD CRYPT_SizeOfKeyIdAsIssuerAndSerial(const CRYPT_DATA_BLOB *keyId)
Definition: msg.c:2680
static BOOL CRYPT_CopyKeyIdAsIssuerAndSerial(CERT_NAME_BLOB *issuer, CRYPT_INTEGER_BLOB *serialNumber, const CRYPT_DATA_BLOB *keyId, DWORD encodedLen, LPBYTE *nextData)
Definition: msg.c:2697

Referenced by CDecodeSignedMsg_GetParam().

◆ CRYPT_CopySignerInfo()

static BOOL CRYPT_CopySignerInfo ( void pvData,
DWORD pcbData,
const CMSG_CMS_SIGNER_INFO in 
)
static

Definition at line 2728 of file msg.c.

2730{
2731 DWORD size = sizeof(CMSG_SIGNER_INFO), rdnSize = 0;
2732 BOOL ret;
2733
2734 TRACE("(%p, %d, %p)\n", pvData, pvData ? *pcbData : 0, in);
2735
2736 if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2737 {
2738 size += in->SignerId.u.IssuerSerialNumber.Issuer.cbData;
2739 size += in->SignerId.u.IssuerSerialNumber.SerialNumber.cbData;
2740 }
2741 else
2742 {
2743 rdnSize = CRYPT_SizeOfKeyIdAsIssuerAndSerial(&in->SignerId.u.KeyId);
2744 size += rdnSize;
2745 }
2746 if (in->HashAlgorithm.pszObjId)
2747 size += strlen(in->HashAlgorithm.pszObjId) + 1;
2748 size += in->HashAlgorithm.Parameters.cbData;
2749 if (in->HashEncryptionAlgorithm.pszObjId)
2750 size += strlen(in->HashEncryptionAlgorithm.pszObjId) + 1;
2751 size += in->HashEncryptionAlgorithm.Parameters.cbData;
2752 size += in->EncryptedHash.cbData;
2753 /* align pointer */
2755 size += CRYPT_SizeOfAttributes(&in->AuthAttrs);
2756 size += CRYPT_SizeOfAttributes(&in->UnauthAttrs);
2757 if (!pvData)
2758 {
2759 ret = TRUE;
2760 }
2761 else if (*pcbData < size)
2762 {
2764 ret = FALSE;
2765 }
2766 else
2767 {
2768 LPBYTE nextData = (BYTE *)pvData + sizeof(CMSG_SIGNER_INFO);
2770
2771 ret = TRUE;
2772 out->dwVersion = in->dwVersion;
2773 if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
2774 {
2775 CRYPT_CopyBlob(&out->Issuer,
2776 &in->SignerId.u.IssuerSerialNumber.Issuer, &nextData);
2777 CRYPT_CopyBlob(&out->SerialNumber,
2778 &in->SignerId.u.IssuerSerialNumber.SerialNumber, &nextData);
2779 }
2780 else
2781 ret = CRYPT_CopyKeyIdAsIssuerAndSerial(&out->Issuer, &out->SerialNumber,
2782 &in->SignerId.u.KeyId, rdnSize, &nextData);
2783 if (ret)
2784 {
2785 CRYPT_CopyAlgorithmId(&out->HashAlgorithm, &in->HashAlgorithm,
2786 &nextData);
2787 CRYPT_CopyAlgorithmId(&out->HashEncryptionAlgorithm,
2788 &in->HashEncryptionAlgorithm, &nextData);
2789 CRYPT_CopyBlob(&out->EncryptedHash, &in->EncryptedHash, &nextData);
2790 nextData = POINTER_ALIGN_DWORD_PTR(nextData);
2791 CRYPT_CopyAttributes(&out->AuthAttrs, &in->AuthAttrs, &nextData);
2792 CRYPT_CopyAttributes(&out->UnauthAttrs, &in->UnauthAttrs, &nextData);
2793 }
2794 }
2795 *pcbData = size;
2796 TRACE("returning %d\n", ret);
2797 return ret;
2798}
struct _CMSG_SIGNER_INFO CMSG_SIGNER_INFO

Referenced by CDecodeSignedMsg_GetParam().

◆ CRYPT_DefaultMsgControl()

static BOOL CRYPT_DefaultMsgControl ( HCRYPTMSG  hCryptMsg,
DWORD  dwFlags,
DWORD  dwCtrlType,
const void pvCtrlPara 
)
static

Definition at line 49 of file msg.c.

51{
52 TRACE("(%p, %08x, %d, %p)\n", hCryptMsg, dwFlags, dwCtrlType, pvCtrlPara);
54 return FALSE;
55}

Referenced by CDataEncodeMsg_Open(), CEnvelopedEncodeMsg_Open(), CHashEncodeMsg_Open(), and CSignedEncodeMsg_Open().

◆ CRYPT_EncodeContentLength()

static BOOL WINAPI CRYPT_EncodeContentLength ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void pvStructInfo,
DWORD  dwFlags,
PCRYPT_ENCODE_PARA  pEncodePara,
BYTE pbEncoded,
DWORD pcbEncoded 
)
static

Definition at line 118 of file msg.c.

121{
122 DWORD dataLen = *(DWORD *)pvStructInfo;
123 DWORD lenBytes;
124 BOOL ret = TRUE;
125
126 /* Trick: report bytes needed based on total message length, even though
127 * the message isn't available yet. The caller will use the length
128 * reported here to encode its length.
129 */
130 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
131 if (!pbEncoded)
132 *pcbEncoded = 1 + lenBytes + dataLen;
133 else
134 {
135 if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
136 pcbEncoded, 1 + lenBytes)))
137 {
139 pbEncoded = *(BYTE **)pbEncoded;
141 CRYPT_EncodeLen(dataLen, pbEncoded,
142 &lenBytes);
143 }
144 }
145 return ret;
146}
BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN
Definition: encode.c:138
BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded) DECLSPEC_HIDDEN
Definition: encode.c:103
static LPCSTR DWORD void BYTE * pbEncoded
Definition: str.c:196
static LPCSTR DWORD void BYTE DWORD * pcbEncoded
Definition: str.c:197
#define ASN_OCTETSTRING
Definition: snmp.h:105

Referenced by CDataEncodeMsg_Update(), and CRYPT_EncodeDataContentInfoHeader().

◆ CRYPT_EncodeDataContentInfoHeader()

static BOOL CRYPT_EncodeDataContentInfoHeader ( const CDataEncodeMsg msg,
CRYPT_DATA_BLOB header 
)
static

Definition at line 148 of file msg.c.

150{
151 BOOL ret;
152
153 if (msg->base.streamed && msg->base.stream_info.cbContent == 0xffffffff)
154 {
155 static const BYTE headerValue[] = { 0x30,0x80,0x06,0x09,0x2a,0x86,0x48,
156 0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x80,0x24,0x80 };
157
158 header->pbData = LocalAlloc(0, sizeof(headerValue));
159 if (header->pbData)
160 {
161 header->cbData = sizeof(headerValue);
162 memcpy(header->pbData, headerValue, sizeof(headerValue));
163 ret = TRUE;
164 }
165 else
166 ret = FALSE;
167 }
168 else
169 {
170 struct AsnConstructedItem constructed = { 0,
171 &msg->base.stream_info.cbContent, CRYPT_EncodeContentLength };
172 struct AsnEncodeSequenceItem items[2] = {
174 { &constructed, CRYPT_AsnEncodeConstructed, 0 },
175 };
176
179 (LPBYTE)&header->pbData, &header->cbData);
180 if (ret)
181 {
182 /* Trick: subtract the content length from the reported length,
183 * as the actual content hasn't come yet.
184 */
185 header->cbData -= msg->base.stream_info.cbContent;
186 }
187 }
188 return ret;
189}
#define ARRAY_SIZE(A)
Definition: main.h:33
BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN
Definition: encode.c:820
BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN
Definition: encode.c:239
BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType, struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN
Definition: encode.c:180
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
static TCHAR * items[]
Definition: page1.c:45

Referenced by CDataEncodeMsg_Update().

◆ CRYPT_EncodePKCSDigestedData()

static BOOL CRYPT_EncodePKCSDigestedData ( CHashEncodeMsg msg,
void pvData,
DWORD pcbData 
)
static

Definition at line 391 of file msg.c.

393{
394 BOOL ret;
395 ALG_ID algID;
396 DWORD size = sizeof(algID);
397
398 ret = CryptGetHashParam(msg->hash, HP_ALGID, (BYTE *)&algID, &size, 0);
399 if (ret)
400 {
401 CRYPT_DIGESTED_DATA digestedData = { 0 };
402 char oid_rsa_data[] = szOID_RSA_data;
403
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)
411 {
412 ret = CRYPT_AsnEncodeOctets(0, NULL, &msg->data,
414 (LPBYTE)&digestedData.ContentInfo.Content.pbData,
415 &digestedData.ContentInfo.Content.cbData);
416 }
417 if (msg->base.state == MsgStateFinalized)
418 {
419 size = sizeof(DWORD);
421 (LPBYTE)&digestedData.hash.cbData, &size, 0);
422 if (ret)
423 {
424 digestedData.hash.pbData = CryptMemAlloc(
425 digestedData.hash.cbData);
427 digestedData.hash.pbData, &digestedData.hash.cbData, 0);
428 }
429 }
430 if (ret)
432 pcbData);
433 CryptMemFree(digestedData.hash.pbData);
434 LocalFree(digestedData.ContentInfo.Content.pbData);
435 }
436 return ret;
437}
BOOL CRYPT_AsnEncodePKCSDigestedData(const CRYPT_DIGESTED_DATA *digestedData, void *pvData, DWORD *pcbData) DECLSPEC_HIDDEN
Definition: encode.c:1952
BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) DECLSPEC_HIDDEN
Definition: encode.c:3178
LPCSTR WINAPI CertAlgIdToOID(DWORD dwAlgId)
Definition: oid.c:1888
#define DWORD
Definition: nt_native.h:44
#define HP_HASHSIZE
Definition: wincrypt.h:2184
#define HP_ALGID
Definition: wincrypt.h:2182

Referenced by CHashEncodeMsg_GetParam().

◆ CRYPT_ExportEncryptedKey()

static BOOL CRYPT_ExportEncryptedKey ( CMSG_CONTENT_ENCRYPT_INFO info,
DWORD  i,
CRYPT_DATA_BLOB key 
)
static

Definition at line 1629 of file msg.c.

1631{
1632 static HCRYPTOIDFUNCSET set = NULL;
1633 PFN_CMSG_EXPORT_KEY_TRANS exportKeyFunc = NULL;
1634 HCRYPTOIDFUNCADDR hFunc = NULL;
1636 info->rgCmsRecipients[i].u.pKeyTrans;
1637 CMSG_KEY_TRANS_ENCRYPT_INFO encryptInfo;
1638 BOOL ret;
1639
1640 memset(&encryptInfo, 0, sizeof(encryptInfo));
1641 encryptInfo.cbSize = sizeof(encryptInfo);
1642 encryptInfo.dwRecipientIndex = i;
1644 &encodeInfo->KeyEncryptionAlgorithm);
1645
1646 if (!set)
1649 encryptInfo.KeyEncryptionAlgorithm.pszObjId, 0, (void **)&exportKeyFunc,
1650 &hFunc);
1651 if (!exportKeyFunc)
1652 exportKeyFunc = CRYPT_ExportKeyTrans;
1653 if (ret)
1654 {
1655 ret = exportKeyFunc(info, encodeInfo, &encryptInfo, 0, NULL);
1656 if (ret)
1657 {
1658 key->cbData = encryptInfo.EncryptedKey.cbData;
1659 key->pbData = encryptInfo.EncryptedKey.pbData;
1660 }
1661 }
1662 if (hFunc)
1664
1667 return ret;
1668}
Definition: _set.h:50
static BOOL WINAPI CRYPT_ExportKeyTrans(PCMSG_CONTENT_ENCRYPT_INFO pContentEncryptInfo, PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO pKeyTransEncodeInfo, PCMSG_KEY_TRANS_ENCRYPT_INFO pKeyTransEncryptInfo, DWORD dwFlags, void *pvReserved)
Definition: msg.c:1564
HCRYPTOIDFUNCSET WINAPI CryptInitOIDFunctionSet(LPCSTR pszFuncName, DWORD dwFlags)
Definition: oid.c:114
BOOL WINAPI CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet, DWORD dwEncodingType, LPCSTR pszOID, DWORD dwFlags, void **ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr)
Definition: oid.c:387
BOOL WINAPI CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr, DWORD dwFlags)
Definition: oid.c:468
CRYPT_DATA_BLOB EncryptedKey
Definition: wincrypt.h:4069
CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm
Definition: wincrypt.h:4068
BOOL(WINAPI * PFN_CMSG_EXPORT_KEY_TRANS)(_In_ PCMSG_CONTENT_ENCRYPT_INFO pContentEncryptInfo, _In_ PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO pKeyTransEncodeInfo, _Inout_ PCMSG_KEY_TRANS_ENCRYPT_INFO pKeyTransEncryptInfo, _In_ DWORD dwFlags, _Reserved_ void *pvReserved)
Definition: wincrypt.h:4104
#define CMSG_OID_EXPORT_KEY_TRANS_FUNC
Definition: wincrypt.h:2512

Referenced by CEnvelopedEncodeMsg_Open().

◆ CRYPT_ExportKeyTrans()

static BOOL WINAPI CRYPT_ExportKeyTrans ( PCMSG_CONTENT_ENCRYPT_INFO  pContentEncryptInfo,
PCMSG_KEY_TRANS_RECIPIENT_ENCODE_INFO  pKeyTransEncodeInfo,
PCMSG_KEY_TRANS_ENCRYPT_INFO  pKeyTransEncryptInfo,
DWORD  dwFlags,
void pvReserved 
)
static

Definition at line 1564 of file msg.c.

1569{
1570 CERT_PUBLIC_KEY_INFO keyInfo;
1571 HCRYPTKEY expKey;
1572 BOOL ret;
1573
1575 &pKeyTransEncodeInfo->KeyEncryptionAlgorithm);
1576 if (ret)
1578 &pKeyTransEncodeInfo->RecipientPublicKey);
1579 if (ret)
1580 ret = CryptImportPublicKeyInfo(pKeyTransEncodeInfo->hCryptProv,
1581 X509_ASN_ENCODING, &keyInfo, &expKey);
1582 if (ret)
1583 {
1584 DWORD size;
1585
1586 ret = CryptExportKey(pContentEncryptInfo->hContentEncryptKey, expKey,
1587 SIMPLEBLOB, 0, NULL, &size);
1588 if (ret)
1589 {
1590 BYTE *keyBlob;
1591
1592 keyBlob = CryptMemAlloc(size);
1593 if (keyBlob)
1594 {
1595 ret = CryptExportKey(pContentEncryptInfo->hContentEncryptKey,
1596 expKey, SIMPLEBLOB, 0, keyBlob, &size);
1597 if (ret)
1598 {
1599 DWORD head = sizeof(BLOBHEADER) + sizeof(ALG_ID);
1600
1601 pKeyTransEncryptInfo->EncryptedKey.pbData =
1603 if (pKeyTransEncryptInfo->EncryptedKey.pbData)
1604 {
1605 DWORD i, k = 0;
1606
1607 pKeyTransEncryptInfo->EncryptedKey.cbData = size - head;
1608 for (i = size - 1; i >= head; --i, ++k)
1609 pKeyTransEncryptInfo->EncryptedKey.pbData[k] =
1610 keyBlob[i];
1611 }
1612 else
1613 ret = FALSE;
1614 }
1615 CryptMemFree(keyBlob);
1616 }
1617 else
1618 ret = FALSE;
1619 }
1620 CryptDestroyKey(expKey);
1621 }
1622
1623 CryptMemFree(keyInfo.PublicKey.pbData);
1626 return ret;
1627}
struct outqueuenode * head
Definition: adnsresfilter.c:66
BOOL WINAPI CryptExportKey(HCRYPTKEY hKey, HCRYPTKEY hExpKey, DWORD dwBlobType, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
Definition: crypt.c:1416
int k
Definition: mpi.c:3369
CRYPT_BIT_BLOB PublicKey
Definition: wincrypt.h:226
CRYPT_ALGORITHM_IDENTIFIER Algorithm
Definition: wincrypt.h:225
#define SIMPLEBLOB
Definition: wincrypt.h:2239
struct _PUBLICKEYSTRUC BLOBHEADER

Referenced by CRYPT_ExportEncryptedKey().

◆ CRYPT_FixUpAlgorithmID()

static void CRYPT_FixUpAlgorithmID ( CRYPT_ALGORITHM_IDENTIFIER id)
inlinestatic

Definition at line 2205 of file msg.c.

2206{
2207 id->pszObjId = (LPSTR)((BYTE *)id + sizeof(CRYPT_ALGORITHM_IDENTIFIER));
2208 id->Parameters.pbData = (BYTE *)id->pszObjId + strlen(id->pszObjId) + 1;
2209}

Referenced by CDecodeHashMsg_GetParam().

◆ CRYPT_FreeBlobArray()

static void CRYPT_FreeBlobArray ( DWORD  cBlobs,
PCRYPT_DATA_BLOB  blobs 
)
static

Definition at line 745 of file msg.c.

746{
747 DWORD i;
748
749 for (i = 0; i < cBlobs; i++)
750 CryptMemFree(blobs[i].pbData);
751 CryptMemFree(blobs);
752}

Referenced by CSignedEncodeMsg_Close().

◆ CRYPT_GenKey()

static BOOL CRYPT_GenKey ( CMSG_CONTENT_ENCRYPT_INFO info,
ALG_ID  algID 
)
static

Definition at line 1542 of file msg.c.

1543{
1544 static HCRYPTOIDFUNCSET set = NULL;
1546 HCRYPTOIDFUNCADDR hFunc;
1547 BOOL ret;
1548
1549 if (!set)
1552 info->ContentEncryptionAlgorithm.pszObjId, 0, (void **)&genKeyFunc, &hFunc);
1553 if (genKeyFunc)
1554 {
1555 ret = genKeyFunc(info, 0, NULL);
1557 }
1558 else
1559 ret = CryptGenKey(info->hCryptProv, algID, CRYPT_EXPORTABLE,
1560 &info->hContentEncryptKey);
1561 return ret;
1562}
BOOL WINAPI CryptGenKey(HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey)
Definition: crypt.c:1451
#define CMSG_OID_GEN_CONTENT_ENCRYPT_KEY_FUNC
Definition: wincrypt.h:2511
BOOL(WINAPI * PFN_CMSG_GEN_CONTENT_ENCRYPT_KEY)(_Inout_ PCMSG_CONTENT_ENCRYPT_INFO pContentEncryptInfo, _In_ DWORD dwFlags, _Reserved_ void *pvReserved)
Definition: wincrypt.h:4098
#define CRYPT_EXPORTABLE
Definition: wincrypt.h:2206

Referenced by CEnvelopedEncodeMsg_Open().

◆ CRYPT_GetSignerCertInfoFromMsg()

static CERT_INFO * CRYPT_GetSignerCertInfoFromMsg ( HCRYPTMSG  msg,
DWORD  dwSignerIndex 
)
static

Definition at line 3646 of file msg.c.

3648{
3649 CERT_INFO *certInfo = NULL;
3650 DWORD size;
3651
3653 &size))
3654 {
3655 certInfo = CryptMemAlloc(size);
3656 if (certInfo)
3657 {
3659 dwSignerIndex, certInfo, &size))
3660 {
3661 CryptMemFree(certInfo);
3662 certInfo = NULL;
3663 }
3664 }
3665 }
3666 return certInfo;
3667}

Referenced by CryptMsgGetAndVerifySigner().

◆ CRYPT_ImportEncryptedKey()

static BOOL CRYPT_ImportEncryptedKey ( PCRYPT_ALGORITHM_IDENTIFIER  contEncrAlg,
PCMSG_CTRL_DECRYPT_PARA  para,
PCMSG_KEY_TRANS_RECIPIENT_INFO  info,
HCRYPTKEY key 
)
static

Definition at line 3426 of file msg.c.

3429{
3430 static HCRYPTOIDFUNCSET set = NULL;
3431 PFN_CMSG_IMPORT_KEY_TRANS importKeyFunc = NULL;
3432 HCRYPTOIDFUNCADDR hFunc = NULL;
3434 BOOL ret;
3435
3436 memset(&decryptPara, 0, sizeof(decryptPara));
3437 decryptPara.cbSize = sizeof(decryptPara);
3438 decryptPara.hCryptProv = para->hCryptProv;
3439 decryptPara.dwKeySpec = para->dwKeySpec;
3440 decryptPara.pKeyTrans = info;
3441 decryptPara.dwRecipientIndex = para->dwRecipientIndex;
3442
3443 if (!set)
3446 (void **)&importKeyFunc, &hFunc);
3447 if (!importKeyFunc)
3448 importKeyFunc = CRYPT_ImportKeyTrans;
3449 ret = importKeyFunc(contEncrAlg, &decryptPara, 0, NULL, key);
3450 if (hFunc)
3452 return ret;
3453}
static BOOL WINAPI CRYPT_ImportKeyTrans(PCRYPT_ALGORITHM_IDENTIFIER pContentEncryptionAlgorithm, PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA pKeyTransDecryptPara, DWORD dwFlags, void *pvReserved, HCRYPTKEY *phContentEncryptKey)
Definition: msg.c:3381
PCMSG_KEY_TRANS_RECIPIENT_INFO pKeyTrans
Definition: wincrypt.h:4077
#define CMSG_OID_IMPORT_KEY_TRANS_FUNC
Definition: wincrypt.h:2513
BOOL(WINAPI * PFN_CMSG_IMPORT_KEY_TRANS)(_In_ PCRYPT_ALGORITHM_IDENTIFIER pContentEncryptionAlgorithm, _In_ PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA pKeyTransDecryptPara, _In_ DWORD dwFlags, _Reserved_ void *pvReserved, _Out_ HCRYPTKEY *phContentEncryptKey)
Definition: wincrypt.h:4112

Referenced by CDecodeEnvelopedMsg_CrtlDecrypt().

◆ CRYPT_ImportKeyTrans()

static BOOL WINAPI CRYPT_ImportKeyTrans ( PCRYPT_ALGORITHM_IDENTIFIER  pContentEncryptionAlgorithm,
PCMSG_CTRL_KEY_TRANS_DECRYPT_PARA  pKeyTransDecryptPara,
DWORD  dwFlags,
void pvReserved,
HCRYPTKEY phContentEncryptKey 
)
static

Definition at line 3381 of file msg.c.

3385{
3386 BOOL ret;
3387 HCRYPTKEY key;
3388
3389 ret = CryptGetUserKey(pKeyTransDecryptPara->hCryptProv,
3390 pKeyTransDecryptPara->dwKeySpec ? pKeyTransDecryptPara->dwKeySpec :
3392 if (ret)
3393 {
3395 &pKeyTransDecryptPara->pKeyTrans[pKeyTransDecryptPara->dwRecipientIndex];
3396 CRYPT_DATA_BLOB *encryptedKey = &info->EncryptedKey;
3397 DWORD size = encryptedKey->cbData + sizeof(BLOBHEADER) + sizeof(ALG_ID);
3398 BYTE *keyBlob = CryptMemAlloc(size);
3399
3400 if (keyBlob)
3401 {
3402 DWORD i, k = size - 1;
3403 BLOBHEADER *blobHeader = (BLOBHEADER *)keyBlob;
3404 ALG_ID *algID = (ALG_ID *)(keyBlob + sizeof(BLOBHEADER));
3405
3406 blobHeader->bType = SIMPLEBLOB;
3407 blobHeader->bVersion = CUR_BLOB_VERSION;
3408 blobHeader->reserved = 0;
3409 blobHeader->aiKeyAlg = CertOIDToAlgId(
3410 pContentEncryptionAlgorithm->pszObjId);
3411 *algID = CertOIDToAlgId(info->KeyEncryptionAlgorithm.pszObjId);
3412 for (i = 0; i < encryptedKey->cbData; ++i, --k)
3413 keyBlob[k] = encryptedKey->pbData[i];
3414
3415 ret = CryptImportKey(pKeyTransDecryptPara->hCryptProv, keyBlob,
3416 size, key, 0, phContentEncryptKey);
3417 CryptMemFree(keyBlob);
3418 }
3419 else
3420 ret = FALSE;
3422 }
3423 return ret;
3424}
BOOL WINAPI CryptGetUserKey(HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey)
Definition: crypt.c:1718
BOOL WINAPI CryptImportKey(HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen, HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)
Definition: crypt.c:1850
ALG_ID aiKeyAlg
Definition: wincrypt.h:139
#define AT_KEYEXCHANGE
Definition: wincrypt.h:2035
#define CUR_BLOB_VERSION
Definition: wincrypt.h:2247

Referenced by CRYPT_ImportEncryptedKey().

◆ CRYPT_IsValidSigner()

static BOOL CRYPT_IsValidSigner ( const CMSG_SIGNER_ENCODE_INFO_WITH_CMS signer)
static

Definition at line 626 of file msg.c.

627{
628 if (signer->cbSize != sizeof(CMSG_SIGNER_ENCODE_INFO) &&
629 signer->cbSize != sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS))
630 {
632 return FALSE;
633 }
634 if (signer->cbSize == sizeof(CMSG_SIGNER_ENCODE_INFO))
635 {
636 if (!signer->pCertInfo->SerialNumber.cbData)
637 {
639 return FALSE;
640 }
641 if (!signer->pCertInfo->Issuer.cbData)
642 {
644 return FALSE;
645 }
646 }
647 else if (signer->cbSize == sizeof(CMSG_SIGNER_ENCODE_INFO_WITH_CMS))
648 {
649 switch (signer->SignerId.dwIdChoice)
650 {
651 case 0:
652 if (!signer->pCertInfo->SerialNumber.cbData)
653 {
655 return FALSE;
656 }
657 if (!signer->pCertInfo->Issuer.cbData)
658 {
660 return FALSE;
661 }
662 break;
665 {
667 return FALSE;
668 }
670 {
672 return FALSE;
673 }
674 break;
676 if (!signer->SignerId.u.KeyId.cbData)
677 {
679 return FALSE;
680 }
681 break;
682 default:
684 }
686 {
687 FIXME("CMSG_SIGNER_ENCODE_INFO with CMS fields unsupported\n");
688 return FALSE;
689 }
690 }
691 if (!signer->hCryptProv)
692 {
694 return FALSE;
695 }
697 {
699 return FALSE;
700 }
701 return TRUE;
702}
CRYPT_HASH_BLOB KeyId
Definition: wincrypt.h:3668
CERT_NAME_BLOB Issuer
Definition: wincrypt.h:244
CRYPT_INTEGER_BLOB SerialNumber
Definition: wincrypt.h:242
CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm
Definition: msg.c:602
CRYPT_ALGORITHM_IDENTIFIER HashEncryptionAlgorithm
Definition: msg.c:609
#define CERT_ID_KEY_IDENTIFIER
Definition: wincrypt.h:3674

Referenced by CSignedEncodeMsg_Open().

◆ CRYPT_ReverseBytes()

static void CRYPT_ReverseBytes ( CRYPT_HASH_BLOB hash)
static

Definition at line 1118 of file msg.c.

1119{
1120 DWORD i;
1121 BYTE tmp;
1122
1123 for (i = 0; i < hash->cbData / 2; i++)
1124 {
1125 tmp = hash->pbData[hash->cbData - i - 1];
1126 hash->pbData[hash->cbData - i - 1] = hash->pbData[i];
1127 hash->pbData[i] = tmp;
1128 }
1129}

Referenced by CDecodeSignedMsg_VerifySignatureWithKey(), and CSignedMsgData_Sign().

◆ CRYPT_SizeOfAttributes()

static DWORD CRYPT_SizeOfAttributes ( const CRYPT_ATTRIBUTES attr)
static

Definition at line 2661 of file msg.c.

2662{
2663 DWORD size = attr->cAttr * sizeof(CRYPT_ATTRIBUTE), i, j;
2664
2665 for (i = 0; i < attr->cAttr; i++)
2666 {
2667 if (attr->rgAttr[i].pszObjId)
2668 size += strlen(attr->rgAttr[i].pszObjId) + 1;
2669 /* align pointer */
2671 size += attr->rgAttr[i].cValue * sizeof(CRYPT_DATA_BLOB);
2672 for (j = 0; j < attr->rgAttr[i].cValue; j++)
2673 size += attr->rgAttr[i].rgValue[j].cbData;
2674 }
2675 /* align pointer again to be conservative */
2677 return size;
2678}

Referenced by CRYPT_CopyCMSSignerInfo(), and CRYPT_CopySignerInfo().

◆ CRYPT_SizeOfKeyIdAsIssuerAndSerial()

static DWORD CRYPT_SizeOfKeyIdAsIssuerAndSerial ( const CRYPT_DATA_BLOB keyId)
static

Definition at line 2680 of file msg.c.

2681{
2682 static char oid_key_rdn[] = szOID_KEYID_RDN;
2683 DWORD size = 0;
2685 CERT_RDN rdn = { 1, &attr };
2686 CERT_NAME_INFO name = { 1, &rdn };
2687
2688 attr.pszObjId = oid_key_rdn;
2689 attr.dwValueType = CERT_RDN_OCTET_STRING;
2690 attr.Value.cbData = keyId->cbData;
2691 attr.Value.pbData = keyId->pbData;
2693 size++; /* Only include size of special zero serial number on success */
2694 return size;
2695}

Referenced by CRYPT_CopySignerCertInfo(), and CRYPT_CopySignerInfo().

◆ CryptMsgBase_Init()

static void CryptMsgBase_Init ( CryptMsgBase msg,
DWORD  dwFlags,
PCMSG_STREAM_INFO  pStreamInfo,
CryptMsgCloseFunc  close,
CryptMsgGetParamFunc  get_param,
CryptMsgUpdateFunc