ReactOS  0.4.15-dev-489-g75a0787
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

◆ SignOrVerify

Enumerator
Sign 
Verify 

Definition at line 1063 of file msg.c.

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

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 *
1695  sizeof(CMSG_RECIPIENT_ENCODE_INFO));
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 }
static LPVOID WINAPI mem_alloc(size_t size)
Definition: msg.c:1670
static VOID WINAPI mem_free(LPVOID pv)
Definition: msg.c:1675
#define CMSG_KEY_TRANS_RECIPIENT
Definition: wincrypt.h:3812
static BOOL CRYPT_ConstructBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
Definition: msg.c:704
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
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
static BYTE cert[]
Definition: msg.c:1437
CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm
Definition: wincrypt.h:3745
static BOOL CRYPT_ConstructBitBlob(CRYPT_BIT_BLOB *out, const CRYPT_BIT_BLOB *in)
Definition: msg.c:1525
struct _CMSG_CONTENT_ENCRYPT_INFO CMSG_CONTENT_ENCRYPT_INFO
unsigned long DWORD
Definition: ntddk_ex.h:95
static BOOL CRYPT_ConstructAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER *out, const CRYPT_ALGORITHM_IDENTIFIER *in)
Definition: msg.c:1512
int ret
CERT_ISSUER_SERIAL_NUMBER IssuerSerialNumber
Definition: wincrypt.h:3667
GLuint in
Definition: glext.h:9616
CRYPT_INTEGER_BLOB SerialNumber
Definition: wincrypt.h:3660
CERT_NAME_BLOB Issuer
Definition: wincrypt.h:3659

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 
1757  CryptMemFree(encodeInfo->RecipientPublicKey.pbData);
1758  CryptMemFree(
1760  CryptMemFree(
1762  CryptMemFree(encodeInfo);
1763  }
1764  CryptMemFree(info->rgCmsRecipients);
1765  }
1766 }
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
CRYPT_OBJID_BLOB Parameters
Definition: wincrypt.h:127
CRYPT_ALGORITHM_IDENTIFIER KeyEncryptionAlgorithm
Definition: wincrypt.h:3745
unsigned long DWORD
Definition: ntddk_ex.h:95
BYTE * pbData
Definition: wincrypt.h:103
CERT_ISSUER_SERIAL_NUMBER IssuerSerialNumber
Definition: wincrypt.h:3667
CRYPT_INTEGER_BLOB SerialNumber
Definition: wincrypt.h:3660
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
CERT_NAME_BLOB Issuer
Definition: wincrypt.h:3659
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 }
static const BYTE empty_data_content[]
Definition: msg.c:108
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
#define msg(x)
Definition: auth_time.c:54

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  {
323  case CMSG_CONTENT_PARAM:
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 }
struct _test_info info[]
Definition: SetCursorPos.c:19
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
unsigned int BOOL
Definition: ntddk_ex.h:94
#define PKCS_CONTENT_INFO
Definition: wincrypt.h:3400
#define E_INVALIDARG
Definition: ddrawi.h:101
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3748
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
static BOOL CRYPT_CopyParam(void *pvData, DWORD *pcbData, const void *src, DWORD len)
Definition: msg.c:294
#define SetLastError(x)
Definition: compat.h:418
int ret
BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4655
#define CMSG_BARE_CONTENT_PARAM
Definition: wincrypt.h:3927
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
#define msg(x)
Definition: auth_time.c:54
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4949

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  }
361  msg = CryptMemAlloc(sizeof(CDataEncodeMsg));
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 const BYTE empty_data_content[]
Definition: msg.c:108
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned char * LPBYTE
Definition: typedefs.h:53
#define E_INVALIDARG
Definition: ddrawi.h:101
smooth NULL
Definition: ftsmooth.c:416
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_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:315
#define SetLastError(x)
Definition: compat.h:418
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define msg(x)
Definition: auth_time.c:54
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

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 
225  &cbData, CRYPT_ENCODE_ALLOC_FLAG, NULL, (BYTE *)&header,
226  &headerLen);
227  if (ret)
228  {
229  ret = msg->base.stream_info.pfnStreamOutput(
230  msg->base.stream_info.pvArg, header, headerLen,
231  FALSE);
232  LocalFree(header);
233  }
234  }
235  if (!fFinal)
236  {
237  ret = msg->base.stream_info.pfnStreamOutput(
238  msg->base.stream_info.pvArg, (BYTE *)pbData, cbData,
239  FALSE);
240  msg->base.state = MsgStateUpdated;
241  }
242  else
243  {
244  msg->base.state = MsgStateFinalized;
245  if (msg->base.stream_info.cbContent == 0xffffffff)
246  {
247  BYTE indefinite_trailer[6] = { 0 };
248 
249  ret = msg->base.stream_info.pfnStreamOutput(
250  msg->base.stream_info.pvArg, (BYTE *)pbData, cbData,
251  FALSE);
252  if (ret)
253  ret = msg->base.stream_info.pfnStreamOutput(
254  msg->base.stream_info.pvArg, indefinite_trailer,
255  sizeof(indefinite_trailer), TRUE);
256  }
257  else
258  ret = msg->base.stream_info.pfnStreamOutput(
259  msg->base.stream_info.pvArg, (BYTE *)pbData, cbData, TRUE);
260  }
261  }
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 CRYPT_E_MSG_ERROR
Definition: winerror.h:2985
#define TRUE
Definition: types.h:120
Definition: image.c:133
BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, void *pvEncoded, DWORD *pcbEncoded)
Definition: encode.c:4696
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
unsigned char * LPBYTE
Definition: typedefs.h:53
unsigned int BOOL
Definition: ntddk_ex.h:94
#define E_INVALIDARG
Definition: ddrawi.h:101
smooth NULL
Definition: ftsmooth.c:416
#define __TRY
Definition: compat.h:70
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
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:418
#define __ENDTRY
Definition: compat.h:72
int ret
unsigned char BYTE
Definition: xxhash.c:193
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:228
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
#define CRYPT_ENCODE_ALLOC_FLAG
Definition: wincrypt.h:3441
#define msg(x)
Definition: auth_time.c:54
#define X509_OCTET_STRING
Definition: wincrypt.h:3391
struct CFHEADER header
Definition: fdi.c:101
#define __EXCEPT_PAGE_FAULT
Definition: compat.h:71
static BOOL CRYPT_EncodeDataContentInfoHeader(const CDataEncodeMsg *msg, CRYPT_DATA_BLOB *header)
Definition: msg.c:148
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201

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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
CRYPT_DATA_BLOB content
Definition: msg.c:2079
#define TRUE
Definition: types.h:120
CRYPT_ENVELOPED_DATA * data
Definition: msg.c:2077
unsigned int BOOL
Definition: ntddk_ex.h:94
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 E_INVALIDARG
Definition: ddrawi.h:101
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
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
#define CRYPT_E_ALREADY_DECRYPTED
Definition: winerror.h:2993
#define CRYPT_E_INVALID_INDEX
Definition: winerror.h:2992
#define SetLastError(x)
Definition: compat.h:418
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
int ret
BYTE * pbData
Definition: wincrypt.h:103
HKEY key
Definition: reg.c:42
ULONG_PTR HCRYPTKEY
Definition: wincrypt.h:49
#define msg(x)
Definition: auth_time.c:54
Definition: path.c:41

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 }
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
static BOOL CRYPT_CopyRecipientInfo(void *pvData, DWORD *pcbData, const CERT_ISSUER_SERIAL_NUMBER *in)
Definition: msg.c:2918
unsigned int BOOL
Definition: ntddk_ex.h:94
#define FIXME(fmt,...)
Definition: debug.h:111
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3748
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
#define CRYPT_E_INVALID_INDEX
Definition: winerror.h:2992
static BOOL CRYPT_CopyParam(void *pvData, DWORD *pcbData, const void *src, DWORD len)
Definition: msg.c:294
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:418
int ret
CERT_ISSUER_SERIAL_NUMBER IssuerSerialNumber
Definition: wincrypt.h:3667
#define CMSG_TYPE_PARAM
Definition: wincrypt.h:3925
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
#define msg(x)
Definition: auth_time.c:54
#define CMSG_RECIPIENT_COUNT_PARAM
Definition: wincrypt.h:3940
#define CMSG_RECIPIENT_INFO_PARAM
Definition: wincrypt.h:3942
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4949

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  }
2581  ret = CryptGetHashParam(msg->u.hash, HP_HASHVAL, pvData, pcbData, 0);
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 }
#define CMSG_HASH_ALGORITHM_PARAM
Definition: wincrypt.h:3943
Definition: image.c:133
BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN
Definition: proplist.c:72
static void CRYPT_FixUpAlgorithmID(CRYPT_ALGORITHM_IDENTIFIER *id)
Definition: msg.c:2205
#define CMSG_COMPUTED_HASH_PARAM
Definition: wincrypt.h:3945
BOOL WINAPI CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags)
Definition: crypt.c:1610
unsigned int BOOL
Definition: ntddk_ex.h:94
const DWORD * blob
Definition: effect.c:999
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3748
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
static BOOL CRYPT_CopyParam(void *pvData, DWORD *pcbData, const void *src, DWORD len)
Definition: msg.c:294
#define SetLastError(x)
Definition: compat.h:418
int ret
#define CMSG_TYPE_PARAM
Definition: wincrypt.h:3925
#define msg(x)
Definition: auth_time.c:54
#define HP_HASHVAL
Definition: wincrypt.h:2183
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4949

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
BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN
Definition: proplist.c:72
static const BYTE hashBlob[]
Definition: message.c:644
#define CMSG_COMPUTED_HASH_PARAM
Definition: wincrypt.h:3945
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned char * LPBYTE
Definition: typedefs.h:53
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
#define CMSG_HASH_DATA_PARAM
Definition: wincrypt.h:3944
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:418
int ret
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define msg(x)
Definition: auth_time.c:54
static BOOL CDecodeHashMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:2554
#define CRYPT_E_HASH_VALUE
Definition: winerror.h:2991
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13

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 }
#define CMSG_SIGNED
Definition: wincrypt.h:3680
void ContextPropertyList_Free(CONTEXT_PROPERTY_LIST *list) DECLSPEC_HIDDEN
Definition: proplist.c:56
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
Definition: crypt.c:648
BOOL WINAPI CryptDestroyHash(HCRYPTHASH hHash)
Definition: crypt.c:890
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define msg(x)
Definition: auth_time.c:54
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867
#define CMSG_ENVELOPED
Definition: wincrypt.h:3681
#define CMSG_HASHED
Definition: wincrypt.h:3683
static void CSignedMsgData_CloseHandles(CSignedMsgData *msg_data)
Definition: msg.c:983

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;
3525  case CMSG_CTRL_VERIFY_HASH:
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 CDecodeEnvelopedMsg_CrtlDecrypt(CDecodeMsg *msg, PCMSG_CTRL_DECRYPT_PARA para)
Definition: msg.c:3455
#define CMSG_SIGNED
Definition: wincrypt.h:3680
#define CMSG_CTRL_VERIFY_SIGNATURE_EX
Definition: wincrypt.h:3885
#define CMSG_CTRL_DECRYPT
Definition: wincrypt.h:3870
unsigned int BOOL
Definition: ntddk_ex.h:94
struct _CMSG_CTRL_DECRYPT_PARA * PCMSG_CTRL_DECRYPT_PARA
#define CRYPT_E_CONTROL_TYPE
Definition: winerror.h:2996
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
#define CMSG_CTRL_VERIFY_SIGNATURE
Definition: wincrypt.h:3869
#define CMSG_CTRL_VERIFY_HASH
Definition: wincrypt.h:3871
static BOOL CDecodeSignedMsg_VerifySignatureEx(CDecodeMsg *msg, PCMSG_CTRL_VERIFY_SIGNATURE_EX_PARA para)
Definition: msg.c:3346
#define SetLastError(x)
Definition: compat.h:418
int ret
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
static BOOL CDecodeSignedMsg_VerifySignature(CDecodeMsg *msg, PCERT_INFO info)
Definition: msg.c:3303
#define msg(x)
Definition: auth_time.c:54
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867
#define CMSG_ENVELOPED
Definition: wincrypt.h:3681
#define CMSG_HASHED
Definition: wincrypt.h:3683
static BOOL CDecodeHashMsg_VerifyHash(CDecodeMsg *msg)
Definition: msg.c:3225

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 }
#define TRUE
Definition: types.h:120
Definition: image.c:133
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize)
Definition: main.c:136
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201

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,
2323  CMSG_ENVELOPED);
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 }
static BOOL CDecodeMsg_DecodeSignedContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
Definition: msg.c:2263
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
Definition: image.c:133
#define CMSG_SIGNED
Definition: wincrypt.h:3680
#define CMSG_DATA
Definition: wincrypt.h:3679
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
struct _test_info info[]
Definition: SetCursorPos.c:19
#define szOID_RSA_data
Definition: wincrypt.h:3028
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
unsigned int BOOL
Definition: ntddk_ex.h:94
#define PKCS_CONTENT_INFO
Definition: wincrypt.h:3400
smooth NULL
Definition: ftsmooth.c:416
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
#define szOID_RSA_envelopedData
Definition: wincrypt.h:3030
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:418
static BOOL CDecodeMsg_DecodeHashedContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
Definition: msg.c:2211
int ret
static BOOL CDecodeMsg_DecodeDataContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
Definition: msg.c:2152
#define szOID_RSA_signedData
Definition: wincrypt.h:3029
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
static BOOL CDecodeMsg_DecodeEnvelopedContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
Definition: msg.c:2248
#define msg(x)
Definition: auth_time.c:54
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define szOID_RSA_digestedData
Definition: wincrypt.h:3032
#define CMSG_ENVELOPED
Definition: wincrypt.h:3681
#define CMSG_HASHED
Definition: wincrypt.h:3683
static BOOL CDecodeMsg_DecodeContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob, DWORD type)
Definition: msg.c:2283

Referenced by 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  {
2162  ret = ContextPropertyList_SetProperty(msg->properties,
2163  CMSG_CONTENT_PARAM, data->pbData, data->cbData);
2164  LocalFree(data);
2165  }
2166  return ret;
2167 }
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
Definition: image.c:133
BOOL ContextPropertyList_SetProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, const BYTE *pbData, size_t cbData) DECLSPEC_HIDDEN
Definition: proplist.c:95
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
int ret
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
#define msg(x)
Definition: auth_time.c:54
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454
#define X509_OCTET_STRING
Definition: wincrypt.h:3391

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 }
Definition: image.c:133
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
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
#define msg(x)
Definition: auth_time.c:54
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454

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
2239  CMSG_CONTENT_PARAM, NULL, 0);
2240  }
2242  digestedData->hash.pbData, digestedData->hash.cbData);
2243  LocalFree(digestedData);
2244  }
2245  return ret;
2246 }
#define CMSG_HASH_ALGORITHM_PARAM
Definition: wincrypt.h:3943
Definition: image.c:133
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
BOOL ContextPropertyList_SetProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, const BYTE *pbData, size_t cbData) DECLSPEC_HIDDEN
Definition: proplist.c:95
CRYPT_DER_BLOB Content
Definition: wincrypt.h:454
#define CMSG_INNER_CONTENT_TYPE_PARAM
Definition: wincrypt.h:3928
CRYPT_HASH_BLOB hash
unsigned int BOOL
Definition: ntddk_ex.h:94
static void CDecodeMsg_SaveAlgorithmID(CDecodeMsg *msg, DWORD param, const CRYPT_ALGORITHM_IDENTIFIER *id)
Definition: msg.c:2169
smooth NULL
Definition: ftsmooth.c:416
CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm
CRYPT_CONTENT_INFO ContentInfo
GLsizeiptr size
Definition: glext.h:5919
#define CMSG_HASH_DATA_PARAM
Definition: wincrypt.h:3944
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
BYTE * pbData
Definition: wincrypt.h:103
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 BOOL CDecodeMsg_DecodeDataContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob)
Definition: msg.c:2152
unsigned char BYTE
Definition: xxhash.c:193
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
#define msg(x)
Definition: auth_time.c:54
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454
#define CMSG_VERSION_PARAM
Definition: wincrypt.h:3950

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 }
Definition: image.c:133
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
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
#define msg(x)
Definition: auth_time.c:54
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454

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 }
#define TRUE
Definition: types.h:120
Definition: image.c:133
#define CMSG_SIGNED
Definition: wincrypt.h:3680
static BOOL CDecodeMsg_FinalizeSignedContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
Definition: msg.c:2398
unsigned int BOOL
Definition: ntddk_ex.h:94
int ret
static BOOL CDecodeMsg_FinalizeEnvelopedContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
Definition: msg.c:2384
#define msg(x)
Definition: auth_time.c:54
static BOOL CDecodeMsg_FinalizeHashedContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
Definition: msg.c:2339
#define CMSG_ENVELOPED
Definition: wincrypt.h:3681
#define CMSG_HASHED
Definition: wincrypt.h:3683

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 }
static BOOL CRYPT_ConstructBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
Definition: msg.c:704
content
Definition: atl_ax.c:993
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
#define msg(x)
Definition: auth_time.c:54

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 }
#define CMSG_HASH_ALGORITHM_PARAM
Definition: wincrypt.h:3943
unsigned int ALG_ID
Definition: wincrypt.h:45
BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN
Definition: proplist.c:72
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
content
Definition: atl_ax.c:993
smooth NULL
Definition: ftsmooth.c:416
GLsizeiptr size
Definition: glext.h:5919
HCRYPTPROV WINAPI I_CryptGetDefaultCryptProv(ALG_ID)
Definition: main.c:210
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
BOOL WINAPI CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash)
Definition: crypt.c:740
DWORD WINAPI CertOIDToAlgId(LPCSTR pszObjId)
Definition: oid.c:1901
BOOL WINAPI CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)
Definition: crypt.c:1771
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
#define msg(x)
Definition: auth_time.c:54
BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:3626
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867

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++)
2406  ret = CSignedMsgData_ConstructSignerHandles(&msg->u.signed_data, 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,
2428  szOID_RSA_data))
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 }
#define TRUE
Definition: types.h:120
Definition: msg.c:1065
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 CSignedMsgData_AllocateHandles(CSignedMsgData *msg_data)
Definition: msg.c:955
#define szOID_RSA_data
Definition: wincrypt.h:3028
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
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
unsigned int BOOL
Definition: ntddk_ex.h:94
content
Definition: atl_ax.c:993
smooth NULL
Definition: ftsmooth.c:416
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
BYTE * pbData
Definition: wincrypt.h:103
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
static BOOL CSignedMsgData_Update(CSignedMsgData *msg_data, const BYTE *pbData, DWORD cbData, BOOL fFinal, SignOrVerify flag)
Definition: msg.c:1172
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
#define msg(x)
Definition: auth_time.c:54
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
static BOOL CSignedMsgData_ConstructSignerHandles(CSignedMsgData *msg_data, DWORD signerIndex, HCRYPTPROV *crypt_prov, DWORD *flags)
Definition: msg.c:928
#define X509_OCTET_STRING
Definition: wincrypt.h:3391

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:
3205  ret = CRYPT_CopyParam(pvData, pcbData, &msg->type,
3206  sizeof(msg->type));
3207  break;
3208  default:
3209  {
3211 
3212  ret = ContextPropertyList_FindProperty(msg->properties, dwParamType,
3213  &blob);
3214  if (ret)
3215  ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData,
3216  blob.cbData);
3217  else
3219  }
3220  }
3221  }
3222  return ret;
3223 }
Definition: image.c:133
#define CMSG_SIGNED
Definition: wincrypt.h:3680
BOOL ContextPropertyList_FindProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, PCRYPT_DATA_BLOB blob) DECLSPEC_HIDDEN
Definition: proplist.c:72
unsigned int BOOL
Definition: ntddk_ex.h:94
const DWORD * blob
Definition: effect.c:999
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3748
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
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
static BOOL CRYPT_CopyParam(void *pvData, DWORD *pcbData, const void *src, DWORD len)
Definition: msg.c:294
#define SetLastError(x)
Definition: compat.h:418
int ret
#define CMSG_TYPE_PARAM
Definition: wincrypt.h:3925
#define msg(x)
Definition: auth_time.c:54
static BOOL CDecodeHashMsg_GetParam(CDecodeMsg *msg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:2554
#define CMSG_ENVELOPED
Definition: wincrypt.h:3681
#define CMSG_HASHED
Definition: wincrypt.h:3683
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4949

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;
2179  copy = CryptMemAlloc(len);
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);
2201  CryptMemFree(copy);
2202  }
2203 }
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
BOOL ContextPropertyList_SetProperty(CONTEXT_PROPERTY_LIST *list, DWORD id, const BYTE *pbData, size_t cbData) DECLSPEC_HIDDEN
Definition: proplist.c:95
char * LPSTR
Definition: xmlstorage.h:182
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
GLfloat param
Definition: glext.h:5796
unsigned long DWORD
Definition: ntddk_ex.h:95
struct _CRYPT_ALGORITHM_IDENTIFIER CRYPT_ALGORITHM_IDENTIFIER
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
unsigned char BYTE
Definition: xxhash.c:193
#define ASN_NULL
Definition: snmp.h:106
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define msg(x)
Definition: auth_time.c:54
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
GLenum GLuint id
Definition: glext.h:5579

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;
2509  case MsgStateDataFinalized:
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;
2534  case MsgStateDataFinalized:
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 }
#define CRYPT_E_MSG_ERROR
Definition: winerror.h:2985
unsigned int BOOL
Definition: ntddk_ex.h:94
#define FIXME(fmt,...)
Definition: debug.h:111
static BOOL CDecodeMsg_FinalizeContent(CDecodeMsg *msg, CRYPT_DER_BLOB *blob)
Definition: msg.c:2450
#define TRACE(s)
Definition: solgame.cpp:4
#define SetLastError(x)
Definition: compat.h:418
int ret
static BOOL CDecodeMsg_CopyData(CRYPT_DATA_BLOB *blob, const BYTE *pbData, DWORD cbData)
Definition: msg.c:2129
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
#define msg(x)
Definition: auth_time.c:54
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201
static BOOL CDecodeMsg_DecodeContent(CDecodeMsg *msg, const CRYPT_DER_BLOB *blob, DWORD type)
Definition: msg.c:2283

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,
3015  szOID_RSA_data))
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  {
3026  ret = CRYPT_CopyParam(pvData, pcbData, blob->pbData,
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;
3078  case CMSG_CERT_COUNT_PARAM:
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;
3098  case CMSG_CRL_COUNT_PARAM:
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,
3126  HP_HASHVAL, pvData, pcbData, 0);
3127  }
3128  else
3130  break;
3131  case CMSG_ENCODED_SIGNER:
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;
3156  case CMSG_ATTR_CERT_PARAM:
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 }
#define CMSG_ATTR_CERT_COUNT_PARAM
Definition: wincrypt.h:3951
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
#define CMSG_CRL_PARAM
Definition: wincrypt.h:3938
Definition: image.c:133
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define CMSG_CERT_PARAM
Definition: wincrypt.h:3936
#define CMSG_CMS_SIGNER_INFO_PARAM
Definition: wincrypt.h:3959
BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, void *pvEncoded, DWORD *pcbEncoded)
Definition: encode.c:4696
#define CMSG_ATTR_CERT_PARAM
Definition: wincrypt.h:3952
#define PKCS_7_ASN_ENCODING
Definition: wincrypt.h:2299
static BOOL CRYPT_CopySignerInfo(void *pvData, DWORD *pcbData, const CMSG_CMS_SIGNER_INFO *in)
Definition: msg.c:2728
#define CMSG_COMPUTED_HASH_PARAM
Definition: wincrypt.h:3945
#define CMSG_INNER_CONTENT_TYPE_PARAM
Definition: wincrypt.h:3928
#define CMS_SIGNER_INFO
Definition: wincrypt.h:3437
#define szOID_RSA_data
Definition: wincrypt.h:3028
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
#define CMSG_CRL_COUNT_PARAM
Definition: wincrypt.h:3937
BOOL WINAPI CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags)
Definition: crypt.c:1610
unsigned int BOOL
Definition: ntddk_ex.h:94
const DWORD * blob
Definition: effect.c:999
#define FIXME(fmt,...)
Definition: debug.h:111
static BOOL CRYPT_CopySignerCertInfo(void *pvData, DWORD *pcbData, const CMSG_CMS_SIGNER_INFO *in)
Definition: msg.c:2867
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3748
smooth NULL
Definition: ftsmooth.c:416
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
#define CRYPT_E_INVALID_INDEX
Definition: winerror.h:2992
GLsizeiptr size
Definition: glext.h:5919
#define CMSG_ENCODED_SIGNER
Definition: wincrypt.h:3948
static BOOL CRYPT_CopyParam(void *pvData, DWORD *pcbData, const void *src, DWORD len)
Definition: msg.c:294
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:418
#define CMSG_CERT_COUNT_PARAM
Definition: wincrypt.h:3935
int ret
static BOOL CRYPT_CopyCMSSignerInfo(void *pvData, DWORD *pcbData, const CMSG_CMS_SIGNER_INFO *in)
Definition: msg.c:2800
#define CMSG_TYPE_PARAM
Definition: wincrypt.h:3925
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
#define msg(x)
Definition: auth_time.c:54
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3454
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define CMSG_SIGNER_CERT_INFO_PARAM
Definition: wincrypt.h:3931
#define CMSG_SIGNER_INFO_PARAM
Definition: wincrypt.h:3930
#define HP_HASHVAL
Definition: wincrypt.h:2183
#define X509_OCTET_STRING
Definition: wincrypt.h:3391
#define CMSG_SIGNER_COUNT_PARAM
Definition: wincrypt.h:3929
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4949

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  {
3326  &signerInfo->SignerId.u.IssuerSerialNumber.SerialNumber,
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 }
#define NTE_BAD_SIGNATURE
Definition: winerror.h:2874
static BOOL CDecodeSignedMsg_VerifySignatureWithKey(CDecodeMsg *msg, HCRYPTPROV prov, DWORD signerIndex, PCERT_PUBLIC_KEY_INFO keyInfo)
Definition: msg.c:3271
BOOL WINAPI CertCompareCertificateName(DWORD dwCertEncodingType, PCERT_NAME_BLOB pCertName1, PCERT_NAME_BLOB pCertName2)
Definition: cert.c:1180
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
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
unsigned int BOOL
Definition: ntddk_ex.h:94
#define FIXME(fmt,...)
Definition: debug.h:111
BOOL WINAPI CertCompareIntegerBlob(PCRYPT_INTEGER_BLOB pInt1, PCRYPT_INTEGER_BLOB pInt2)
Definition: cert.c:1221
DWORD dwIdChoice
Definition: wincrypt.h:3665
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:418
int ret
CERT_ISSUER_SERIAL_NUMBER IssuerSerialNumber
Definition: wincrypt.h:3667
#define CERT_ID_ISSUER_SERIAL_NUMBER
Definition: wincrypt.h:3673
CRYPT_INTEGER_BLOB SerialNumber
Definition: wincrypt.h:3660
#define msg(x)
Definition: auth_time.c:54
CERT_NAME_BLOB Issuer
Definition: wincrypt.h:3659
#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  {
3367  PCCERT_CONTEXT cert = para->pvSigner;
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 ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define NTE_BAD_SIGNATURE
Definition: winerror.h:2874
static BOOL CDecodeSignedMsg_VerifySignatureWithKey(CDecodeMsg *msg, HCRYPTPROV prov, DWORD signerIndex, PCERT_PUBLIC_KEY_INFO keyInfo)
Definition: msg.c:3271
unsigned int BOOL
Definition: ntddk_ex.h:94
#define FIXME(fmt,...)
Definition: debug.h:111
#define CMSG_VERIFY_SIGNER_CERT
Definition: wincrypt.h:3921
static BYTE cert[]
Definition: msg.c:1437
#define CMSG_VERIFY_SIGNER_PUBKEY
Definition: wincrypt.h:3920
#define SetLastError(x)
Definition: compat.h:418
int ret
#define msg(x)
Definition: auth_time.c:54
#define CRYPT_E_SIGNER_NOT_FOUND
Definition: winerror.h:2998

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;
3279  ret = CryptImportPublicKeyInfo(prov, X509_ASN_ENCODING, keyInfo, &key);
3280  if (ret)
3281  {
3282  HCRYPTHASH hash;
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 }
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
static BOOL CRYPT_ConstructBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
Definition: msg.c:704
int hash
Definition: main.c:58
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL WINAPI CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey)
Definition: encode.c:4970
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI CryptDestroyKey(HCRYPTKEY hKey)
Definition: crypt.c:930
BOOL WINAPI CryptVerifySignatureW(HCRYPTHASH hHash, const BYTE *pbSignature, DWORD dwSigLen, HCRYPTKEY hPubKey, LPCWSTR sDescription, DWORD dwFlags)
Definition: crypt.c:2238
int ret
BYTE * pbData
Definition: wincrypt.h:103
HKEY key
Definition: reg.c:42
ULONG_PTR HCRYPTHASH
Definition: wincrypt.h:50
ULONG_PTR HCRYPTKEY
Definition: wincrypt.h:49
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define msg(x)
Definition: auth_time.c:54
static void CRYPT_ReverseBytes(CRYPT_HASH_BLOB *hash)
Definition: msg.c:1118
Definition: _hash_fun.h:40
Definition: path.c:41

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
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
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
Definition: crypt.c:648
BOOL WINAPI CryptDestroyKey(HCRYPTKEY hKey)
Definition: crypt.c:930
unsigned long DWORD
Definition: ntddk_ex.h:95
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define msg(x)
Definition: auth_time.c:54
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867

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 = {
1833  CMSG_ENVELOPED_DATA_PKCS_1_5_VERSION, msg->cRecipientInfo,
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 
1842  ret = CRYPT_AsnEncodePKCSEnvelopedData(&envelopedData, pvData,
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 WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, void *pvEncoded, DWORD *pcbEncoded)
Definition: encode.c:4696
struct _test_info info[]
Definition: SetCursorPos.c:19
#define szOID_RSA_data
Definition: wincrypt.h:3028
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
#define PKCS_CONTENT_INFO
Definition: wincrypt.h:3400
#define E_INVALIDARG
Definition: ddrawi.h:101
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3748
smooth NULL
Definition: ftsmooth.c:416
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
#define szOID_RSA_envelopedData
Definition: wincrypt.h:3030
BOOL CRYPT_AsnEncodePKCSEnvelopedData(const CRYPT_ENVELOPED_DATA *envelopedData, void *pvData, DWORD *pcbData) DECLSPEC_HIDDEN
Definition: encode.c:4418
#define SetLastError(x)
Definition: compat.h:418
int ret
#define CMSG_ENVELOPED_DATA_PKCS_1_5_VERSION
Definition: wincrypt.h:3990
#define CMSG_BARE_CONTENT_PARAM
Definition: wincrypt.h:3927
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define msg(x)
Definition: auth_time.c:54
BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:3626
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4949

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  {
1980  prov = I_CryptGetDefaultCryptProv(0);
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  {
2025  CryptMsgClose(msg);
2026  msg = NULL;
2027  }
2028  }
2030  CryptReleaseContext(prov, 0);
2031  return msg;
2032 }
unsigned int ALG_ID
Definition: wincrypt.h:45
static void CContentEncryptInfo_Free(CMSG_CONTENT_ENCRYPT_INFO *info)
Definition: msg.c:1742
static BOOL CContentEncryptInfo_Construct(CMSG_CONTENT_ENCRYPT_INFO *info, const CMSG_ENVELOPED_ENCODE_INFO_WITH_CMS *in, HCRYPTPROV prov)
Definition: msg.c:1681
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
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
static BOOL CRYPT_ExportEncryptedKey(CMSG_CONTENT_ENCRYPT_INFO *info, DWORD i, CRYPT_DATA_BLOB *key)
Definition: msg.c:1629
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
Definition: crypt.c:648
#define FIXME(fmt,...)
Definition: debug.h:111
#define E_INVALIDARG
Definition: ddrawi.h:101
smooth NULL
Definition: ftsmooth.c:416
static BOOL CRYPT_DefaultMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags, DWORD dwCtrlType, const void *pvCtrlPara)
Definition: msg.c:49
static BOOL CEnvelopedEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData, DWORD cbData, BOOL fFinal)
Definition: msg.c:1880
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
HCRYPTPROV WINAPI I_CryptGetDefaultCryptProv(ALG_ID)
Definition: main.c:210
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:418
static void CEnvelopedEncodeMsg_Close(HCRYPTMSG hCryptMsg)
Definition: msg.c:1798
static BOOL CRYPT_ConstructAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER *out, const CRYPT_ALGORITHM_IDENTIFIER *in)
Definition: msg.c:1512
int ret
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define CRYPT_E_UNKNOWN_ALGO
Definition: winerror.h:2986
DWORD WINAPI CertOIDToAlgId(LPCSTR pszObjId)
Definition: oid.c:1901
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
static BOOL CRYPT_GenKey(CMSG_CONTENT_ENCRYPT_INFO *info, ALG_ID algID)
Definition: msg.c:1542
BOOL WINAPI CryptMsgClose(HCRYPTMSG hCryptMsg)
Definition: msg.c:3597
#define msg(x)
Definition: auth_time.c:54
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867
#define memset(x, y, z)
Definition: compat.h:39
static BOOL CEnvelopedEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:1818
static BOOL CRecipientInfo_Construct(CMSG_KEY_TRANS_RECIPIENT_INFO *info, const CERT_INFO *cert, CRYPT_DATA_BLOB *key)
Definition: msg.c:1768

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 }
#define CRYPT_E_MSG_ERROR
Definition: winerror.h:2985
#define TRUE
Definition: types.h:120
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
#define FIXME(fmt,...)
Definition: debug.h:111
#define E_INVALIDARG
Definition: ddrawi.h:101
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI CryptEncrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen)
Definition: crypt.c:1093
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:418
LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize)
Definition: main.c:136
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
#define msg(x)
Definition: auth_time.c:54
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201

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 }
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, DWORD dwFlags)
Definition: crypt.c:648
BOOL WINAPI CryptDestroyHash(HCRYPTHASH hHash)
Definition: crypt.c:890
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define msg(x)
Definition: auth_time.c:54
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867

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;
456  case CMSG_CONTENT_PARAM:
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;
487  case CMSG_VERSION_PARAM:
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 }
#define CRYPT_E_MSG_ERROR
Definition: winerror.h:2985
#define CMSG_HASHED_DATA_PKCS_1_5_VERSION
Definition: wincrypt.h:3985
BOOL WINAPI CryptEncodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, void *pvEncoded, DWORD *pcbEncoded)
Definition: encode.c:4696
#define CMSG_COMPUTED_HASH_PARAM
Definition: wincrypt.h:3945
static BOOL CRYPT_EncodePKCSDigestedData(CHashEncodeMsg *msg, void *pvData, DWORD *pcbData)
Definition: msg.c:391
#define szOID_RSA_hashedData
Definition: wincrypt.h:3033
struct _test_info info[]
Definition: SetCursorPos.c:19
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
BOOL WINAPI CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags)
Definition: crypt.c:1610
unsigned int BOOL
Definition: ntddk_ex.h:94
#define PKCS_CONTENT_INFO
Definition: wincrypt.h:3400
#define E_INVALIDARG
Definition: ddrawi.h:101
_In_ ULONG _In_opt_ PVOID pvData
Definition: winddi.h:3748
smooth NULL
Definition: ftsmooth.c:416
static const WCHAR version[]
Definition: asmname.c:66
#define CRYPT_E_INVALID_MSG_TYPE
Definition: winerror.h:2988
#define TRACE(s)
Definition: solgame.cpp:4
static BOOL CRYPT_CopyParam(void *pvData, DWORD *pcbData, const void *src, DWORD len)
Definition: msg.c:294
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:418
int ret
#define CMSG_BARE_CONTENT_PARAM
Definition: wincrypt.h:3927
#define CMSG_CONTENT_PARAM
Definition: wincrypt.h:3926
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define msg(x)
Definition: auth_time.c:54
BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType, DWORD dwIndex, void *pvData, DWORD *pcbData)
Definition: msg.c:3626
#define HP_HASHVAL
Definition: wincrypt.h:2183
#define CMSG_VERSION_PARAM
Definition: wincrypt.h:3950
_In_ DWORD _Out_writes_bytes_to_opt_ pcbData void _Inout_ DWORD * pcbData
Definition: wincrypt.h:4949

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  }
577  }
578  msg = CryptMemAlloc(sizeof(CHashEncodeMsg));
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 }
unsigned int ALG_ID
Definition: wincrypt.h:45
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
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
#define E_INVALIDARG
Definition: ddrawi.h:101
smooth NULL
Definition: ftsmooth.c:416
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
HCRYPTPROV WINAPI I_CryptGetDefaultCryptProv(ALG_ID)
Definition: main.c:210
#define SetLastError(x)
Definition: compat.h:418
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
BOOL WINAPI CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash)
Definition: crypt.c:740
#define CRYPT_E_UNKNOWN_ALGO
Definition: winerror.h:2986
DWORD WINAPI CertOIDToAlgId(LPCSTR pszObjId)
Definition: oid.c:1901
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
BOOL WINAPI CryptMsgClose(HCRYPTMSG hCryptMsg)
Definition: msg.c:3597
#define msg(x)
Definition: auth_time.c:54
#define CMSG_CRYPT_RELEASE_CONTEXT_FLAG
Definition: wincrypt.h:3867

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 }
#define CRYPT_E_MSG_ERROR
Definition: winerror.h:2985
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
#define TRACE(s)
Definition: solgame.cpp:4
#define SetLastError(x)
Definition: compat.h:418
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
BOOL WINAPI CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)
Definition: crypt.c:1771
#define CMSG_DETACHED_FLAG
Definition: wincrypt.h:3862
#define msg(x)
Definition: auth_time.c:54
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201

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 }
static BOOL CRYPT_ConstructBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
Definition: msg.c:704
#define CMSG_KEY_TRANS_PKCS_1_5_VERSION
Definition: wincrypt.h:4043
unsigned int BOOL
Definition: ntddk_ex.h:94
static BYTE cert[]
Definition: msg.c:1437
static BOOL CRYPT_ConstructAlgorithmId(CRYPT_ALGORITHM_IDENTIFIER *out, const CRYPT_ALGORITHM_IDENTIFIER *in)
Definition: msg.c:1512
int ret
#define CERT_ID_ISSUER_SERIAL_NUMBER
Definition: wincrypt.h:3673
Definition: path.c:41

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 }
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141

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
unsigned int BOOL
Definition: ntddk_ex.h:94
static FILE * out
Definition: regtests2xml.c:44
LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize)
Definition: main.c:136
int ret
GLuint in
Definition: glext.h:9616

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 }
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static BOOL CRYPT_ConstructBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
Definition: msg.c:704
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
static FILE * out
Definition: regtests2xml.c:44
GLuint in
Definition: glext.h:9616
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388

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 }
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
static BOOL CRYPT_ConstructBlobArray(DWORD *outCBlobs, PCRYPT_DATA_BLOB *outPBlobs, DWORD cBlobs, const CRYPT_DATA_BLOB *pBlobs)
Definition: msg.c:722
static FILE * out
Definition: regtests2xml.c:44
int ret
GLuint in
Definition: glext.h:9616
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388

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 }
#define TRUE
Definition: types.h:120
static BOOL CRYPT_ConstructAttribute(CRYPT_ATTRIBUTE *out, const CRYPT_ATTRIBUTE *in)
Definition: msg.c:754
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
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
static FILE * out
Definition: regtests2xml.c:44
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
GLuint in
Definition: glext.h:9616
#define memset(x, y, z)
Definition: compat.h:39

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 }
#define TRUE
Definition: types.h:120
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
smooth NULL
Definition: ftsmooth.c:416
static FILE * out
Definition: regtests2xml.c:44
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLuint in
Definition: glext.h:9616

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 }
#define TRUE
Definition: types.h:120
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
static FILE * out
Definition: regtests2xml.c:44
int ret
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLuint in
Definition: glext.h:9616

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 }
#define TRUE
Definition: types.h:120
static BOOL CRYPT_ConstructBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in)
Definition: msg.c:704
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
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
#define memset(x, y, z)
Definition: compat.h:39

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
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * LPSTR
Definition: xmlstorage.h:182
static FILE * out
Definition: regtests2xml.c:44
GLuint in
Definition: glext.h:9616
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388

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 }
static void CRYPT_CopyBlob(CRYPT_DATA_BLOB *out, const CRYPT_DATA_BLOB *in, LPBYTE *nextData)
Definition: msg.c:2602
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define POINTER_ALIGN_DWORD_PTR(p)
char * LPSTR
Definition: xmlstorage.h:182
struct _CRYPTOAPI_BLOB * PCRYPT_DATA_BLOB
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
struct _CRYPTOAPI_BLOB CRYPT_DATA_BLOB
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
static FILE * out
Definition: regtests2xml.c:44
unsigned long DWORD
Definition: ntddk_ex.h:95
struct _CRYPT_ATTRIBUTE CRYPT_ATTRIBUTE
GLuint in
Definition: glext.h:9616
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388

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 }
static FILE * out
Definition: regtests2xml.c:44
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLuint in
Definition: glext.h:9616

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 {
2803  DWORD size = sizeof(CMSG_CMS_SIGNER_INFO);
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)