able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/security/cryptoapi/pkitrust/wintrust/ossfunc.cpp

2394 lines
68 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1997 - 1999
//
// File: ossfunc.cpp
//
//--------------------------------------------------------------------------
#include "global.hxx"
extern "C"
{
#include "wtasn.h"
}
#include "crypttls.h"
#include "unicode.h"
#include "pkiasn1.h"
#include <dbgdef.h>
#include "locals.h"
#define SpcAsnAlloc WVTNew
#define SpcAsnFree WVTDelete
// All the *pvInfo extra stuff needs to be aligned
#define INFO_LEN_ALIGN(Len) ((Len + 7) & ~7)
static const BYTE NullDer[2] = {0x05, 0x00};
static const CRYPT_OBJID_BLOB NullDerBlob = {2, (BYTE *)&NullDer[0]};
static HCRYPTASN1MODULE hAsn1Module;
extern "C"
{
BOOL WINAPI WVTAsn1SpcLinkEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_LINK pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
);
BOOL WINAPI WVTAsn1SpcLinkDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_LINK pInfo,
IN OUT DWORD *pcbInfo
);
BOOL WINAPI WVTAsn1SpcIndirectDataContentEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_INDIRECT_DATA_CONTENT pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
);
BOOL WINAPI WVTAsn1SpcIndirectDataContentDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_INDIRECT_DATA_CONTENT pInfo,
IN OUT DWORD *pcbInfo
);
BOOL WINAPI WVTAsn1SpcSpAgencyInfoEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_SP_AGENCY_INFO pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
);
BOOL WINAPI WVTAsn1SpcSpAgencyInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_SP_AGENCY_INFO pInfo,
IN OUT DWORD *pcbInfo
);
BOOL WINAPI WVTAsn1SpcMinimalCriteriaInfoEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN BOOL *pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
);
BOOL WINAPI WVTAsn1SpcMinimalCriteriaInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT BOOL *pInfo,
IN OUT DWORD *pcbInfo
);
BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_FINANCIAL_CRITERIA pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
);
BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_FINANCIAL_CRITERIA pInfo,
IN OUT DWORD *pcbInfo
);
BOOL WINAPI WVTAsn1SpcStatementTypeEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_STATEMENT_TYPE pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
);
BOOL WINAPI WVTAsn1SpcStatementTypeDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_STATEMENT_TYPE pInfo,
IN OUT DWORD *pcbInfo
);
BOOL WINAPI WVTAsn1SpcSpOpusInfoEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_SP_OPUS_INFO pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
);
BOOL WINAPI WVTAsn1SpcSpOpusInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_SP_OPUS_INFO pInfo,
IN OUT DWORD *pcbInfo
);
BOOL WINAPI WVTAsn1SpcPeImageDataEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_PE_IMAGE_DATA pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
);
BOOL WINAPI WVTAsn1SpcPeImageDataDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_PE_IMAGE_DATA pInfo,
IN OUT DWORD *pcbInfo
);
BOOL WINAPI WVTAsn1SpcSigInfoEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_SIGINFO pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
);
BOOL WINAPI WVTAsn1SpcSigInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_SIGINFO pInfo,
IN OUT DWORD *pcbInfo
);
BOOL WINAPI WVTAsn1UtcTimeDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT FILETIME * pFileTime,
IN OUT DWORD *pcbFileTime
);
BOOL WINAPI WVTAsn1CatNameValueEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PCAT_NAMEVALUE pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded);
BOOL WINAPI WVTAsn1CatMemberInfoEncode(
IN DWORD dwEncoding,
IN LPCSTR lpszStructType,
IN PCAT_MEMBERINFO pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded);
BOOL WINAPI WVTAsn1CatNameValueDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PCAT_NAMEVALUE pInfo,
IN OUT DWORD *pcbInfo);
BOOL WINAPI WVTAsn1CatMemberInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PCAT_MEMBERINFO pInfo,
IN OUT DWORD *pcbInfo);
};
static inline ASN1encoding_t GetEncoder(void)
{
return I_CryptGetAsn1Encoder(hAsn1Module);
}
static inline ASN1decoding_t GetDecoder(void)
{
return I_CryptGetAsn1Decoder(hAsn1Module);
}
//+-------------------------------------------------------------------------
// SPC ASN allocation and free functions
//--------------------------------------------------------------------------
HRESULT HError()
{
DWORD dw = GetLastError();
HRESULT hr;
if ( dw <= 0xFFFF )
hr = HRESULT_FROM_WIN32 ( dw );
else
hr = dw;
if ( ! FAILED ( hr ) )
{
// somebody failed a call without properly setting an error condition
hr = E_UNEXPECTED;
}
return hr;
}
typedef struct _OID_REG_ENTRY {
LPCSTR pszOID;
LPCSTR pszOverrideFuncName;
} OID_REG_ENTRY, *POID_REG_ENTRY;
static const OID_REG_ENTRY SpcRegEncodeTable[] =
{
SPC_PE_IMAGE_DATA_OBJID, "WVTAsn1SpcPeImageDataEncode",
SPC_PE_IMAGE_DATA_STRUCT, "WVTAsn1SpcPeImageDataEncode",
SPC_CAB_DATA_OBJID, "WVTAsn1SpcLinkEncode",
SPC_CAB_DATA_STRUCT, "WVTAsn1SpcLinkEncode",
SPC_JAVA_CLASS_DATA_OBJID, "WVTAsn1SpcLinkEncode",
SPC_JAVA_CLASS_DATA_STRUCT, "WVTAsn1SpcLinkEncode",
SPC_LINK_OBJID, "WVTAsn1SpcLinkEncode",
SPC_LINK_STRUCT, "WVTAsn1SpcLinkEncode",
SPC_SIGINFO_OBJID, "WVTAsn1SpcSigInfoEncode",
SPC_SIGINFO_STRUCT, "WVTAsn1SpcSigInfoEncode",
SPC_INDIRECT_DATA_OBJID, "WVTAsn1SpcIndirectDataContentEncode",
SPC_INDIRECT_DATA_CONTENT_STRUCT, "WVTAsn1SpcIndirectDataContentEncode",
SPC_SP_AGENCY_INFO_OBJID, "WVTAsn1SpcSpAgencyInfoEncode",
SPC_SP_AGENCY_INFO_STRUCT, "WVTAsn1SpcSpAgencyInfoEncode",
SPC_MINIMAL_CRITERIA_OBJID, "WVTAsn1SpcMinimalCriteriaInfoEncode",
SPC_MINIMAL_CRITERIA_STRUCT, "WVTAsn1SpcMinimalCriteriaInfoEncode",
SPC_FINANCIAL_CRITERIA_OBJID, "WVTAsn1SpcFinancialCriteriaInfoEncode",
SPC_FINANCIAL_CRITERIA_STRUCT, "WVTAsn1SpcFinancialCriteriaInfoEncode",
SPC_STATEMENT_TYPE_OBJID, "WVTAsn1SpcStatementTypeEncode",
SPC_STATEMENT_TYPE_STRUCT, "WVTAsn1SpcStatementTypeEncode",
CAT_NAMEVALUE_OBJID, "WVTAsn1CatNameValueEncode",
CAT_NAMEVALUE_STRUCT, "WVTAsn1CatNameValueEncode",
CAT_MEMBERINFO_OBJID, "WVTAsn1CatMemberInfoEncode",
CAT_MEMBERINFO_STRUCT, "WVTAsn1CatMemberInfoEncode",
SPC_SP_OPUS_INFO_OBJID, "WVTAsn1SpcSpOpusInfoEncode",
SPC_SP_OPUS_INFO_STRUCT, "WVTAsn1SpcSpOpusInfoEncode"
};
#define SPC_REG_ENCODE_COUNT (sizeof(SpcRegEncodeTable) / sizeof(SpcRegEncodeTable[0]))
static const OID_REG_ENTRY SpcRegDecodeTable[] =
{
SPC_PE_IMAGE_DATA_OBJID, "WVTAsn1SpcPeImageDataDecode",
SPC_PE_IMAGE_DATA_STRUCT, "WVTAsn1SpcPeImageDataDecode",
SPC_CAB_DATA_OBJID, "WVTAsn1SpcLinkDecode",
SPC_CAB_DATA_STRUCT, "WVTAsn1SpcLinkDecode",
SPC_JAVA_CLASS_DATA_OBJID, "WVTAsn1SpcLinkDecode",
SPC_JAVA_CLASS_DATA_STRUCT, "WVTAsn1SpcLinkDecode",
SPC_LINK_OBJID, "WVTAsn1SpcLinkDecode",
SPC_LINK_STRUCT, "WVTAsn1SpcLinkDecode",
SPC_SIGINFO_OBJID, "WVTAsn1SpcSigInfoDecode",
SPC_SIGINFO_STRUCT, "WVTAsn1SpcSigInfoDecode",
SPC_INDIRECT_DATA_OBJID, "WVTAsn1SpcIndirectDataContentDecode",
SPC_INDIRECT_DATA_CONTENT_STRUCT, "WVTAsn1SpcIndirectDataContentDecode",
SPC_SP_AGENCY_INFO_OBJID, "WVTAsn1SpcSpAgencyInfoDecode",
SPC_SP_AGENCY_INFO_STRUCT, "WVTAsn1SpcSpAgencyInfoDecode",
SPC_MINIMAL_CRITERIA_OBJID, "WVTAsn1SpcMinimalCriteriaInfoDecode",
SPC_MINIMAL_CRITERIA_STRUCT, "WVTAsn1SpcMinimalCriteriaInfoDecode",
SPC_FINANCIAL_CRITERIA_OBJID, "WVTAsn1SpcFinancialCriteriaInfoDecode",
SPC_FINANCIAL_CRITERIA_STRUCT, "WVTAsn1SpcFinancialCriteriaInfoDecode",
SPC_STATEMENT_TYPE_OBJID, "WVTAsn1SpcStatementTypeDecode",
SPC_STATEMENT_TYPE_STRUCT, "WVTAsn1SpcStatementTypeDecode",
CAT_NAMEVALUE_OBJID, "WVTAsn1CatNameValueDecode",
CAT_NAMEVALUE_STRUCT, "WVTAsn1CatNameValueDecode",
CAT_MEMBERINFO_OBJID, "WVTAsn1CatMemberInfoDecode",
CAT_MEMBERINFO_STRUCT, "WVTAsn1CatMemberInfoDecode",
SPC_SP_OPUS_INFO_OBJID, "WVTAsn1SpcSpOpusInfoDecode",
SPC_SP_OPUS_INFO_STRUCT, "WVTAsn1SpcSpOpusInfoDecode"
};
#define SPC_REG_DECODE_COUNT (sizeof(SpcRegDecodeTable) / sizeof(SpcRegDecodeTable[0]))
#define ASN1_OID_OFFSET
#define ASN1_OID_PREFIX
static const CRYPT_OID_FUNC_ENTRY SpcEncodeFuncTable[] =
{
ASN1_OID_OFFSET SPC_PE_IMAGE_DATA_STRUCT, WVTAsn1SpcPeImageDataEncode,
ASN1_OID_PREFIX SPC_PE_IMAGE_DATA_OBJID, WVTAsn1SpcPeImageDataEncode,
ASN1_OID_PREFIX SPC_CAB_DATA_OBJID, WVTAsn1SpcLinkEncode,
ASN1_OID_OFFSET SPC_CAB_DATA_STRUCT, WVTAsn1SpcLinkEncode,
ASN1_OID_OFFSET SPC_LINK_STRUCT, WVTAsn1SpcLinkEncode,
ASN1_OID_PREFIX SPC_LINK_OBJID, WVTAsn1SpcLinkEncode,
ASN1_OID_OFFSET SPC_SIGINFO_STRUCT, WVTAsn1SpcSigInfoEncode,
ASN1_OID_PREFIX SPC_SIGINFO_OBJID, WVTAsn1SpcSigInfoEncode,
ASN1_OID_PREFIX SPC_INDIRECT_DATA_OBJID, WVTAsn1SpcIndirectDataContentEncode,
ASN1_OID_OFFSET SPC_INDIRECT_DATA_CONTENT_STRUCT, WVTAsn1SpcIndirectDataContentEncode,
ASN1_OID_OFFSET SPC_SP_AGENCY_INFO_STRUCT, WVTAsn1SpcSpAgencyInfoEncode,
ASN1_OID_PREFIX SPC_SP_AGENCY_INFO_OBJID, WVTAsn1SpcSpAgencyInfoEncode,
ASN1_OID_OFFSET SPC_MINIMAL_CRITERIA_STRUCT, WVTAsn1SpcMinimalCriteriaInfoEncode,
ASN1_OID_PREFIX SPC_MINIMAL_CRITERIA_OBJID, WVTAsn1SpcMinimalCriteriaInfoEncode,
ASN1_OID_OFFSET SPC_FINANCIAL_CRITERIA_STRUCT, WVTAsn1SpcFinancialCriteriaInfoEncode,
ASN1_OID_PREFIX SPC_FINANCIAL_CRITERIA_OBJID, WVTAsn1SpcFinancialCriteriaInfoEncode,
ASN1_OID_OFFSET SPC_STATEMENT_TYPE_STRUCT, WVTAsn1SpcStatementTypeEncode,
ASN1_OID_PREFIX SPC_STATEMENT_TYPE_OBJID, WVTAsn1SpcStatementTypeEncode,
ASN1_OID_PREFIX CAT_NAMEVALUE_OBJID, WVTAsn1CatNameValueEncode,
ASN1_OID_OFFSET CAT_NAMEVALUE_STRUCT, WVTAsn1CatNameValueEncode,
ASN1_OID_PREFIX CAT_MEMBERINFO_OBJID, WVTAsn1CatMemberInfoEncode,
ASN1_OID_OFFSET CAT_MEMBERINFO_STRUCT, WVTAsn1CatMemberInfoEncode,
ASN1_OID_OFFSET SPC_SP_OPUS_INFO_STRUCT, WVTAsn1SpcSpOpusInfoEncode,
ASN1_OID_PREFIX SPC_SP_OPUS_INFO_OBJID, WVTAsn1SpcSpOpusInfoEncode
};
#define SPC_ENCODE_FUNC_COUNT (sizeof(SpcEncodeFuncTable) / \
sizeof(SpcEncodeFuncTable[0]))
static const CRYPT_OID_FUNC_ENTRY SpcDecodeFuncTable[] =
{
ASN1_OID_OFFSET SPC_PE_IMAGE_DATA_STRUCT, WVTAsn1SpcPeImageDataDecode,
ASN1_OID_PREFIX SPC_PE_IMAGE_DATA_OBJID, WVTAsn1SpcPeImageDataDecode,
ASN1_OID_OFFSET SPC_CAB_DATA_STRUCT, WVTAsn1SpcLinkDecode,
ASN1_OID_PREFIX SPC_CAB_DATA_OBJID, WVTAsn1SpcLinkDecode,
ASN1_OID_OFFSET SPC_LINK_STRUCT, WVTAsn1SpcLinkDecode,
ASN1_OID_PREFIX SPC_LINK_OBJID, WVTAsn1SpcLinkDecode,
ASN1_OID_OFFSET SPC_SIGINFO_STRUCT, WVTAsn1SpcSigInfoDecode,
ASN1_OID_PREFIX SPC_SIGINFO_OBJID, WVTAsn1SpcSigInfoDecode,
ASN1_OID_OFFSET PKCS_UTC_TIME, WVTAsn1UtcTimeDecode,
ASN1_OID_PREFIX szOID_RSA_signingTime, WVTAsn1UtcTimeDecode,
ASN1_OID_OFFSET SPC_SP_AGENCY_INFO_STRUCT, WVTAsn1SpcSpAgencyInfoDecode,
ASN1_OID_PREFIX SPC_SP_AGENCY_INFO_OBJID, WVTAsn1SpcSpAgencyInfoDecode,
ASN1_OID_OFFSET SPC_SP_OPUS_INFO_STRUCT, WVTAsn1SpcSpOpusInfoDecode,
ASN1_OID_PREFIX SPC_SP_OPUS_INFO_OBJID, WVTAsn1SpcSpOpusInfoDecode,
ASN1_OID_OFFSET SPC_INDIRECT_DATA_CONTENT_STRUCT, WVTAsn1SpcIndirectDataContentDecode,
ASN1_OID_PREFIX SPC_INDIRECT_DATA_OBJID, WVTAsn1SpcIndirectDataContentDecode,
ASN1_OID_OFFSET SPC_SP_AGENCY_INFO_STRUCT, WVTAsn1SpcSpAgencyInfoDecode,
ASN1_OID_PREFIX SPC_SP_AGENCY_INFO_OBJID, WVTAsn1SpcSpAgencyInfoDecode,
ASN1_OID_OFFSET SPC_MINIMAL_CRITERIA_STRUCT, WVTAsn1SpcMinimalCriteriaInfoDecode,
ASN1_OID_PREFIX SPC_MINIMAL_CRITERIA_OBJID, WVTAsn1SpcMinimalCriteriaInfoDecode,
ASN1_OID_OFFSET SPC_FINANCIAL_CRITERIA_STRUCT, WVTAsn1SpcFinancialCriteriaInfoDecode,
ASN1_OID_PREFIX SPC_FINANCIAL_CRITERIA_OBJID, WVTAsn1SpcFinancialCriteriaInfoDecode,
ASN1_OID_OFFSET SPC_STATEMENT_TYPE_STRUCT, WVTAsn1SpcStatementTypeDecode,
ASN1_OID_PREFIX SPC_STATEMENT_TYPE_OBJID, WVTAsn1SpcStatementTypeDecode,
ASN1_OID_OFFSET CAT_NAMEVALUE_STRUCT, WVTAsn1CatNameValueDecode,
ASN1_OID_PREFIX CAT_NAMEVALUE_OBJID, WVTAsn1CatNameValueDecode,
ASN1_OID_OFFSET CAT_MEMBERINFO_STRUCT, WVTAsn1CatMemberInfoDecode,
ASN1_OID_PREFIX CAT_MEMBERINFO_OBJID, WVTAsn1CatMemberInfoDecode,
ASN1_OID_OFFSET SPC_FINANCIAL_CRITERIA_STRUCT, WVTAsn1SpcFinancialCriteriaInfoDecode,
ASN1_OID_PREFIX SPC_FINANCIAL_CRITERIA_OBJID, WVTAsn1SpcFinancialCriteriaInfoDecode
};
#define SPC_DECODE_FUNC_COUNT (sizeof(SpcDecodeFuncTable) / \
sizeof(SpcDecodeFuncTable[0]))
//+-------------------------------------------------------------------------
// Dll initialization
//--------------------------------------------------------------------------
HRESULT WINAPI ASNRegisterServer(LPCWSTR dllName)
{
int i;
for (i = 0; i < SPC_REG_ENCODE_COUNT; i++)
{
if (!(CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_ENCODE_OBJECT_FUNC,
SpcRegEncodeTable[i].pszOID, dllName,
SpcRegEncodeTable[i].pszOverrideFuncName)))
{
return(HError());
}
}
for (i = 0; i < SPC_REG_DECODE_COUNT; i++)
{
if (!(CryptRegisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_DECODE_OBJECT_FUNC,
SpcRegDecodeTable[i].pszOID, dllName,
SpcRegDecodeTable[i].pszOverrideFuncName)))
{
return(HError());
}
}
return S_OK;
}
HRESULT WINAPI ASNUnregisterServer()
{
HRESULT hr = S_OK;
int i;
for (i = 0; i < SPC_REG_ENCODE_COUNT; i++)
{
if (!(CryptUnregisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_ENCODE_OBJECT_FUNC,
SpcRegEncodeTable[i].pszOID)))
{
if (ERROR_FILE_NOT_FOUND != GetLastError())
{
hr = HError();
}
}
}
for (i = 0; i < SPC_REG_DECODE_COUNT; i++)
{
if (!(CryptUnregisterOIDFunction(X509_ASN_ENCODING, CRYPT_OID_DECODE_OBJECT_FUNC,
SpcRegDecodeTable[i].pszOID)))
{
if (ERROR_FILE_NOT_FOUND != GetLastError())
{
hr = HError();
}
}
}
return(hr);
}
BOOL WINAPI ASNDllMain(HMODULE hInst, ULONG ulReason, LPVOID lpReserved)
{
BOOL fRet;
switch (ulReason)
{
case DLL_PROCESS_ATTACH:
WTASN_Module_Startup();
if (0 == (hAsn1Module = I_CryptInstallAsn1Module(
WTASN_Module, 0, NULL)))
{
goto CryptInstallAsn1ModuleError;
}
/*
if (!(CryptInstallOIDFunctionAddress(
hInst,
X509_ASN_ENCODING,
CRYPT_OID_ENCODE_OBJECT_FUNC,
SPC_ENCODE_FUNC_COUNT,
SpcEncodeFuncTable,
0)))
{
goto CryptInstallOIDFunctionAddressError;
}
if (!(CryptInstallOIDFunctionAddress(
hInst,
X509_ASN_ENCODING,
CRYPT_OID_DECODE_OBJECT_FUNC,
SPC_DECODE_FUNC_COUNT,
SpcDecodeFuncTable,
CRYPT_INSTALL_OID_FUNC_BEFORE_FLAG)))
{
goto CryptInstallOIDFunctionAddressError;
}
*/
break;
case DLL_PROCESS_DETACH:
I_CryptUninstallAsn1Module(hAsn1Module);
WTASN_Module_Cleanup();
break;
case DLL_THREAD_DETACH:
default:
break;
}
fRet = TRUE;
CommonReturn:
return(fRet);
ErrorReturn:
fRet = FALSE;
goto CommonReturn;
TRACE_ERROR_EX(DBG_SS,CryptInstallAsn1ModuleError)
//TRACE_ERROR_EX(DBG_SS,CryptInstallOIDFunctionAddressError)
}
//+-------------------------------------------------------------------------
// Set/Get "Any" DER BLOB
//--------------------------------------------------------------------------
inline void WVTAsn1SetAny(IN PCRYPT_OBJID_BLOB pInfo, OUT NOCOPYANY *pOss)
{
PkiAsn1SetAny(pInfo, pOss);
}
inline void WVTAsn1GetAny(IN NOCOPYANY *pOss, IN DWORD dwFlags, OUT PCRYPT_OBJID_BLOB pInfo,
IN OUT BYTE **ppbExtra, IN OUT LONG *plRemainExtra)
{
PkiAsn1GetAny(pOss, dwFlags, pInfo, ppbExtra, plRemainExtra);
}
//+-------------------------------------------------------------------------
// Set/Get CRYPT_DATA_BLOB (Octet String)
//--------------------------------------------------------------------------
inline void WVTAsn1SetOctetString(IN PCRYPT_DATA_BLOB pInfo, OUT OCTETSTRING *pOss)
{
pOss->value = pInfo->pbData;
pOss->length = pInfo->cbData;
}
inline void WVTAsn1GetOctetString(
IN OCTETSTRING *pOss,
IN DWORD dwFlags,
OUT PCRYPT_DATA_BLOB pInfo,
IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra
)
{
PkiAsn1GetOctetString(pOss->length, pOss->value, dwFlags,
pInfo, ppbExtra, plRemainExtra);
}
inline void WVTAsn1SetBit(IN PCRYPT_BIT_BLOB pInfo, OUT BITSTRING *pOss)
{
PkiAsn1SetBitString(pInfo, &pOss->length, &pOss->value);
}
inline void WVTAsn1GetBit(IN BITSTRING *pOss, IN DWORD dwFlags,
OUT PCRYPT_BIT_BLOB pInfo,
IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra)
{
PkiAsn1GetBitString(pOss->length, pOss->value, dwFlags,
pInfo, ppbExtra, plRemainExtra);
}
//+-------------------------------------------------------------------------
// Set/Free/Get Unicode mapped to IA5 String
//--------------------------------------------------------------------------
inline BOOL WVTAsn1SetUnicodeConvertedToIA5(
IN LPWSTR pwsz,
OUT IA5STRING *pOss
)
{
return PkiAsn1SetUnicodeConvertedToIA5String(pwsz,
&pOss->length, &pOss->value);
}
inline void WVTAsn1FreeUnicodeConvertedToIA5(IN IA5STRING *pOss)
{
PkiAsn1FreeUnicodeConvertedToIA5String(pOss->value);
pOss->value = NULL;
}
inline void WVTAsn1GetIA5ConvertedToUnicode(
IN IA5STRING *pOss,
IN DWORD dwFlags,
OUT LPWSTR *ppwsz,
IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra
)
{
PkiAsn1GetIA5StringConvertedToUnicode(pOss->length, pOss->value, dwFlags,
ppwsz, ppbExtra, plRemainExtra);
}
//+-------------------------------------------------------------------------
// Set/Get LPWSTR (BMP String)
//--------------------------------------------------------------------------
inline void WVTAsn1SetBMP(
IN LPWSTR pwsz,
OUT BMPSTRING *pOss
)
{
pOss->value = pwsz;
pOss->length = wcslen(pwsz);
}
inline void WVTAsn1GetBMP(
IN BMPSTRING *pOss,
IN DWORD dwFlags,
OUT LPWSTR *ppwsz,
IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra
)
{
PkiAsn1GetBMPString(pOss->length, pOss->value, dwFlags,
ppwsz, ppbExtra, plRemainExtra);
}
//+-------------------------------------------------------------------------
// Set/Get Spc String
//--------------------------------------------------------------------------
void WVTAsn1SetSpcString(
IN LPWSTR pwsz,
OUT SpcString *pOss
)
{
pOss->choice = unicode_chosen;
WVTAsn1SetBMP(pwsz, &pOss->u.unicode);
}
void WVTAsn1GetSpcString(
IN SpcString *pOss,
IN DWORD dwFlags,
OUT LPWSTR *ppwsz,
IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra
)
{
switch (pOss->choice) {
case unicode_chosen:
WVTAsn1GetBMP(&pOss->u.unicode, dwFlags,
ppwsz, ppbExtra, plRemainExtra);
break;
case ascii_chosen:
WVTAsn1GetIA5ConvertedToUnicode(&pOss->u.ascii, dwFlags,
ppwsz, ppbExtra, plRemainExtra);
break;
default:
if (*plRemainExtra >= 0)
*ppwsz = NULL;
}
}
//+-------------------------------------------------------------------------
// Set/Get Spc Link
//--------------------------------------------------------------------------
BOOL WVTAsn1SetSpcLink(
IN PSPC_LINK pInfo,
OUT SpcLink *pOss
)
{
BOOL fRet = TRUE;
memset(pOss, 0, sizeof(*pOss));
// Assumption: OSS choice == dwLinkChoice
// WVTAsn1GetSpcLink has asserts to verify
pOss->choice = (unsigned short) pInfo->dwLinkChoice;
switch (pInfo->dwLinkChoice) {
case SPC_URL_LINK_CHOICE:
fRet = WVTAsn1SetUnicodeConvertedToIA5(pInfo->pwszUrl, &pOss->u.url);
break;
case SPC_MONIKER_LINK_CHOICE:
pOss->u.moniker.classId.length = sizeof(pInfo->Moniker.ClassId);
pOss->u.moniker.classId.value = pInfo->Moniker.ClassId;
WVTAsn1SetOctetString(&pInfo->Moniker.SerializedData,
&pOss->u.moniker.serializedData);
break;
case SPC_FILE_LINK_CHOICE:
WVTAsn1SetSpcString(pInfo->pwszFile, &pOss->u.file);
break;
default:
SetLastError((DWORD) E_INVALIDARG);
fRet = FALSE;
}
return fRet;
}
void WVTAsn1FreeSpcLink(
IN SpcLink *pOss
)
{
if (pOss->choice == url_chosen)
WVTAsn1FreeUnicodeConvertedToIA5(&pOss->u.url);
}
BOOL WVTAsn1GetSpcLink(
IN SpcLink *pOss,
IN DWORD dwFlags,
OUT PSPC_LINK pInfo,
IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra
)
{
DWORD dwLinkChoice;
assert(url_chosen == SPC_URL_LINK_CHOICE);
assert(moniker_chosen == SPC_MONIKER_LINK_CHOICE);
assert(file_chosen == SPC_FILE_LINK_CHOICE);
dwLinkChoice = pOss->choice;
if (*plRemainExtra >= 0) {
memset(pInfo, 0, sizeof(*pInfo));
pInfo->dwLinkChoice = dwLinkChoice;
}
switch (dwLinkChoice) {
case SPC_URL_LINK_CHOICE:
WVTAsn1GetIA5ConvertedToUnicode(&pOss->u.url, dwFlags,
&pInfo->pwszUrl, ppbExtra, plRemainExtra);
break;
case SPC_MONIKER_LINK_CHOICE:
if (sizeof(pInfo->Moniker.ClassId) != pOss->u.moniker.classId.length) {
SetLastError((DWORD) CRYPT_E_BAD_ENCODE);
return FALSE;
}
if (*plRemainExtra >= 0) {
memcpy(pInfo->Moniker.ClassId, pOss->u.moniker.classId.value,
sizeof(pInfo->Moniker.ClassId));
}
WVTAsn1GetOctetString(&pOss->u.moniker.serializedData, dwFlags,
&pInfo->Moniker.SerializedData, ppbExtra, plRemainExtra);
break;
case SPC_FILE_LINK_CHOICE:
WVTAsn1GetSpcString(&pOss->u.file, dwFlags,
&pInfo->pwszFile, ppbExtra, plRemainExtra);
break;
default:
SetLastError((DWORD) CRYPT_E_BAD_ENCODE);
return FALSE;
}
return TRUE;
}
BOOL WVTAsn1GetSpcLinkPointer(
IN SpcLink *pOss,
IN DWORD dwFlags,
OUT PSPC_LINK *pInfo,
IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra
)
{
LONG lAlignExtra;
PSPC_LINK pLink;
lAlignExtra = INFO_LEN_ALIGN(sizeof(SPC_LINK));
*plRemainExtra -= lAlignExtra;
if (*plRemainExtra >= 0) {
pLink = (PSPC_LINK) *ppbExtra;
*pInfo = pLink;
*ppbExtra += lAlignExtra;
} else
pLink = NULL;
return WVTAsn1GetSpcLink(
pOss,
dwFlags,
pLink,
ppbExtra,
plRemainExtra
);
}
BOOL WVTAsn1SetSpcSigInfo(IN PSPC_SIGINFO pInfo, OUT SpcSigInfo *pOss)
{
memset(pOss, 0x00, sizeof(*pOss));
pOss->dwSIPversion = pInfo->dwSipVersion;
pOss->gSIPguid.length = sizeof(GUID);
pOss->gSIPguid.value = (BYTE *) &pInfo->gSIPGuid;
pOss->dwReserved1 = pInfo->dwReserved1;
pOss->dwReserved2 = pInfo->dwReserved2;
pOss->dwReserved3 = pInfo->dwReserved3;
pOss->dwReserved4 = pInfo->dwReserved4;
pOss->dwReserved5 = pInfo->dwReserved5;
return(TRUE);
}
BOOL WVTAsn1GetSpcSigInfo(IN SpcSigInfo *pOss, IN DWORD dwFlags,
OUT PSPC_SIGINFO pInfo, IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra)
{
if (!(pInfo))
{
return(TRUE);
}
pInfo->dwSipVersion = pOss->dwSIPversion;
if (sizeof(GUID) != pOss->gSIPguid.length) {
SetLastError((DWORD) CRYPT_E_BAD_ENCODE);
return FALSE;
}
memcpy(&pInfo->gSIPGuid, pOss->gSIPguid.value, sizeof(GUID));
pInfo->dwReserved1 = pOss->dwReserved1;
pInfo->dwReserved2 = pOss->dwReserved2;
pInfo->dwReserved3 = pOss->dwReserved3;
pInfo->dwReserved4 = pOss->dwReserved4;
pInfo->dwReserved5 = pOss->dwReserved5;
return(TRUE);
}
//+-------------------------------------------------------------------------
// Set/Get Object Identifier string
//--------------------------------------------------------------------------
BOOL WVTAsn1SetObjId(
IN LPSTR pszObjId,
OUT ObjectID *pOss
)
{
pOss->count = sizeof(pOss->value) / sizeof(pOss->value[0]);
if (PkiAsn1ToObjectIdentifier(pszObjId, &pOss->count, pOss->value))
return TRUE;
else {
SetLastError((DWORD) CRYPT_E_BAD_ENCODE);
return FALSE;
}
}
void WVTAsn1GetObjId(
IN ObjectID *pOss,
IN DWORD dwFlags,
OUT LPSTR *ppszObjId,
IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra
)
{
LONG lRemainExtra = *plRemainExtra;
BYTE *pbExtra = *ppbExtra;
LONG lAlignExtra;
DWORD cbObjId;
cbObjId = lRemainExtra > 0 ? lRemainExtra : 0;
PkiAsn1FromObjectIdentifier(
pOss->count,
pOss->value,
(LPSTR) pbExtra,
&cbObjId
);
lAlignExtra = INFO_LEN_ALIGN(cbObjId);
lRemainExtra -= lAlignExtra;
if (lRemainExtra >= 0) {
if(cbObjId) {
*ppszObjId = (LPSTR) pbExtra;
} else
*ppszObjId = NULL;
pbExtra += lAlignExtra;
}
*plRemainExtra = lRemainExtra;
*ppbExtra = pbExtra;
}
//+-------------------------------------------------------------------------
// Set/Get CRYPT_ALGORITHM_IDENTIFIER
//--------------------------------------------------------------------------
BOOL WVTAsn1SetAlgorithm(
IN PCRYPT_ALGORITHM_IDENTIFIER pInfo,
OUT AlgorithmIdentifier *pOss
)
{
memset(pOss, 0, sizeof(*pOss));
if (pInfo->pszObjId) {
if (!WVTAsn1SetObjId(pInfo->pszObjId, &pOss->algorithm))
return FALSE;
if (pInfo->Parameters.cbData)
WVTAsn1SetAny(&pInfo->Parameters, &pOss->parameters);
else
// Per PKCS #1: default to the ASN.1 type NULL.
WVTAsn1SetAny((PCRYPT_OBJID_BLOB) &NullDerBlob, &pOss->parameters);
pOss->bit_mask |= parameters_present;
}
return TRUE;
}
void WVTAsn1GetAlgorithm(
IN AlgorithmIdentifier *pOss,
IN DWORD dwFlags,
OUT PCRYPT_ALGORITHM_IDENTIFIER pInfo,
IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra
)
{
if (*plRemainExtra >= 0)
memset(pInfo, 0, sizeof(*pInfo));
WVTAsn1GetObjId(&pOss->algorithm, dwFlags, &pInfo->pszObjId,
ppbExtra, plRemainExtra);
if (pOss->bit_mask & parameters_present)
WVTAsn1GetAny(&pOss->parameters, dwFlags, &pInfo->Parameters,
ppbExtra, plRemainExtra);
}
//+-------------------------------------------------------------------------
// Encode an OSS formatted info structure
//
// Called by the WVTAsn1*Encode() functions.
//--------------------------------------------------------------------------
BOOL WVTAsn1InfoEncode(
IN int pdunum,
IN void *pOssInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
)
{
return PkiAsn1EncodeInfo(
GetEncoder(),
pdunum,
pOssInfo,
pbEncoded,
pcbEncoded);
}
//+-------------------------------------------------------------------------
// Decode into an allocated, OSS formatted info structure
//
// Called by the WVTAsn1*Decode() functions.
//--------------------------------------------------------------------------
BOOL WVTAsn1InfoDecodeAndAlloc(
IN int pdunum,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
OUT void **ppOssInfo
)
{
return PkiAsn1DecodeAndAllocInfo(
GetDecoder(),
pdunum,
pbEncoded,
cbEncoded,
ppOssInfo);
}
//+-------------------------------------------------------------------------
// Free an allocated, OSS formatted info structure
//
// Called by the WVTAsn1*Decode() functions.
//--------------------------------------------------------------------------
void WVTAsn1InfoFree(
IN int pdunum,
IN void *pOssInfo
)
{
if (pOssInfo) {
DWORD dwErr = GetLastError();
// TlsGetValue globbers LastError
PkiAsn1FreeInfo(GetDecoder(), pdunum, pOssInfo);
SetLastError(dwErr);
}
}
//+-------------------------------------------------------------------------
// SPC PKCS #7 Indirect Data Content Encode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcIndirectDataContentEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_INDIRECT_DATA_CONTENT pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
)
{
BOOL fResult;
SpcIndirectDataContent OssInfo;
memset(&OssInfo, 0, sizeof(OssInfo));
if (!WVTAsn1SetObjId(pInfo->Data.pszObjId, &OssInfo.data.type))
goto ErrorReturn;
if (pInfo->Data.Value.cbData) {
WVTAsn1SetAny(&pInfo->Data.Value, &OssInfo.data.value);
OssInfo.data.bit_mask |= value_present;
}
if (!WVTAsn1SetAlgorithm(&pInfo->DigestAlgorithm,
&OssInfo.messageDigest.digestAlgorithm))
goto ErrorReturn;
WVTAsn1SetOctetString(&pInfo->Digest, &OssInfo.messageDigest.digest);
fResult = WVTAsn1InfoEncode(
SpcIndirectDataContent_PDU,
&OssInfo,
pbEncoded,
pcbEncoded
);
goto CommonReturn;
ErrorReturn:
*pcbEncoded = 0;
fResult = FALSE;
CommonReturn:
return fResult;
}
//+-------------------------------------------------------------------------
// SPC PKCS #7 Indirect Data Content Decode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcIndirectDataContentDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_INDIRECT_DATA_CONTENT pInfo,
IN OUT DWORD *pcbInfo
)
{
BOOL fResult;
SpcIndirectDataContent *pOssInfo = NULL;
BYTE *pbExtra;
LONG lRemainExtra;
if (pInfo == NULL)
*pcbInfo = 0;
if (!WVTAsn1InfoDecodeAndAlloc(
SpcIndirectDataContent_PDU,
pbEncoded,
cbEncoded,
(void **) &pOssInfo))
goto ErrorReturn;
// for lRemainExtra < 0, LENGTH_ONLY calculation
lRemainExtra = (LONG) *pcbInfo - sizeof(SPC_INDIRECT_DATA_CONTENT);
if (lRemainExtra < 0) {
pbExtra = NULL;
} else {
// Default all optional fields to zero
memset(pInfo, 0, sizeof(SPC_INDIRECT_DATA_CONTENT));
pbExtra = (BYTE *) pInfo + sizeof(SPC_INDIRECT_DATA_CONTENT);
}
WVTAsn1GetObjId(&pOssInfo->data.type, dwFlags, &pInfo->Data.pszObjId,
&pbExtra, &lRemainExtra);
if (pOssInfo->data.bit_mask & value_present)
WVTAsn1GetAny(&pOssInfo->data.value, dwFlags, &pInfo->Data.Value,
&pbExtra, &lRemainExtra);
WVTAsn1GetAlgorithm(&pOssInfo->messageDigest.digestAlgorithm, dwFlags,
&pInfo->DigestAlgorithm, &pbExtra, &lRemainExtra);
WVTAsn1GetOctetString(&pOssInfo->messageDigest.digest, dwFlags,
&pInfo->Digest, &pbExtra, &lRemainExtra);
if (lRemainExtra >= 0)
*pcbInfo = *pcbInfo - (DWORD) lRemainExtra;
else {
*pcbInfo = *pcbInfo + (DWORD) -lRemainExtra;
if (pInfo) goto LengthError;
}
fResult = TRUE;
goto CommonReturn;
LengthError:
SetLastError((DWORD) ERROR_MORE_DATA);
fResult = FALSE;
goto CommonReturn;
ErrorReturn:
*pcbInfo = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1InfoFree(SpcIndirectDataContent_PDU, pOssInfo);
return fResult;
}
BOOL WINAPI WVTAsn1UtcTimeDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT FILETIME * pFileTime,
IN OUT DWORD *pcbFileTime
) {
BOOL fResult;
UtcTime * putcTime = NULL;
assert(pcbFileTime != NULL);
if(pFileTime == NULL) {
*pcbFileTime = sizeof(FILETIME);
return(TRUE);
}
if (*pcbFileTime < sizeof(FILETIME)) {
*pcbFileTime = sizeof(FILETIME);
SetLastError((DWORD) ERROR_MORE_DATA);
return(FALSE);
}
*pcbFileTime = sizeof(FILETIME);
if (!WVTAsn1InfoDecodeAndAlloc(
UtcTime_PDU,
pbEncoded,
cbEncoded,
(void **) &putcTime))
goto WVTAsn1InfoDecodeAndAllocError;
if( !PkiAsn1FromUTCTime(putcTime, pFileTime) )
goto PkiAsn1FromUTCTimeError;
fResult = TRUE;
CommonReturn:
WVTAsn1InfoFree(UtcTime_PDU, putcTime);
return fResult;
ErrorReturn:
*pcbFileTime = 0;
fResult = FALSE;
goto CommonReturn;
TRACE_ERROR_EX(DBG_SS,WVTAsn1InfoDecodeAndAllocError);
TRACE_ERROR_EX(DBG_SS,PkiAsn1FromUTCTimeError);
}
//+-------------------------------------------------------------------------
// SPC SP Agency Info Encode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcSpAgencyInfoEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_SP_AGENCY_INFO pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
)
{
BOOL fResult;
SpcSpAgencyInformation OssInfo;
memset(&OssInfo, 0, sizeof(OssInfo));
if (pInfo->pPolicyInformation) {
if (!WVTAsn1SetSpcLink(pInfo->pPolicyInformation,
&OssInfo.policyInformation))
goto ErrorReturn;
OssInfo.bit_mask |= policyInformation_present;
}
if (pInfo->pwszPolicyDisplayText) {
WVTAsn1SetSpcString(pInfo->pwszPolicyDisplayText,
&OssInfo.policyDisplayText);
OssInfo.bit_mask |= policyDisplayText_present;
}
if (pInfo->pLogoImage) {
PSPC_IMAGE pImage = pInfo->pLogoImage;
if (pImage->pImageLink) {
if (!WVTAsn1SetSpcLink(pImage->pImageLink,
&OssInfo.logoImage.imageLink))
goto ErrorReturn;
OssInfo.logoImage.bit_mask |= imageLink_present;
}
if (pImage->Bitmap.cbData != 0) {
WVTAsn1SetOctetString(&pImage->Bitmap, &OssInfo.logoImage.bitmap);
OssInfo.logoImage.bit_mask |= bitmap_present;
}
if (pImage->Metafile.cbData != 0) {
WVTAsn1SetOctetString(&pImage->Metafile,
&OssInfo.logoImage.metafile);
OssInfo.logoImage.bit_mask |= metafile_present;
}
if (pImage->EnhancedMetafile.cbData != 0) {
WVTAsn1SetOctetString(&pImage->EnhancedMetafile,
&OssInfo.logoImage.enhancedMetafile);
OssInfo.logoImage.bit_mask |= enhancedMetafile_present;
}
if (pImage->GifFile.cbData != 0) {
WVTAsn1SetOctetString(&pImage->GifFile,
&OssInfo.logoImage.gifFile);
OssInfo.logoImage.bit_mask |= gifFile_present;
}
OssInfo.bit_mask |= logoImage_present;
}
if (pInfo->pLogoLink) {
if (!WVTAsn1SetSpcLink(pInfo->pLogoLink, &OssInfo.logoLink))
goto ErrorReturn;
OssInfo.bit_mask |= logoLink_present;
}
fResult = WVTAsn1InfoEncode(
SpcSpAgencyInformation_PDU,
&OssInfo,
pbEncoded,
pcbEncoded
);
goto CommonReturn;
ErrorReturn:
*pcbEncoded = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1FreeSpcLink(&OssInfo.policyInformation);
WVTAsn1FreeSpcLink(&OssInfo.logoImage.imageLink);
WVTAsn1FreeSpcLink(&OssInfo.logoLink);
return fResult;
}
//+-------------------------------------------------------------------------
// SPC SP Agency Info Decode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcSpAgencyInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_SP_AGENCY_INFO pInfo,
IN OUT DWORD *pcbInfo
)
{
BOOL fResult;
SpcSpAgencyInformation *pOssInfo = NULL;
BYTE *pbExtra;
LONG lRemainExtra;
LONG lAlignExtra;
if (pInfo == NULL)
*pcbInfo = 0;
if (!WVTAsn1InfoDecodeAndAlloc(
SpcSpAgencyInformation_PDU,
pbEncoded,
cbEncoded,
(void **) &pOssInfo))
goto ErrorReturn;
// for lRemainExtra < 0, LENGTH_ONLY calculation
lRemainExtra = (LONG) *pcbInfo - sizeof(SPC_SP_AGENCY_INFO);
if (lRemainExtra < 0) {
pbExtra = NULL;
} else {
// Default all optional fields to zero
memset(pInfo, 0, sizeof(SPC_SP_AGENCY_INFO));
pbExtra = (BYTE *) pInfo + sizeof(SPC_SP_AGENCY_INFO);
}
if (pOssInfo->bit_mask & policyInformation_present) {
if (!WVTAsn1GetSpcLinkPointer(&pOssInfo->policyInformation, dwFlags,
&pInfo->pPolicyInformation, &pbExtra, &lRemainExtra))
goto ErrorReturn;
}
if (pOssInfo->bit_mask & policyDisplayText_present) {
WVTAsn1GetSpcString(&pOssInfo->policyDisplayText, dwFlags,
&pInfo->pwszPolicyDisplayText, &pbExtra, &lRemainExtra);
}
if (pOssInfo->bit_mask & logoImage_present) {
PSPC_IMAGE pImage;
SpcImage *pOssImage = &pOssInfo->logoImage;
lAlignExtra = INFO_LEN_ALIGN(sizeof(SPC_IMAGE));
lRemainExtra -= lAlignExtra;
if (lRemainExtra >= 0) {
pImage = (PSPC_IMAGE) pbExtra;
memset(pImage, 0, sizeof(SPC_IMAGE));
pInfo->pLogoImage = pImage;
pbExtra += lAlignExtra;
} else
pImage = NULL;
if (pOssImage->bit_mask & imageLink_present) {
if (!WVTAsn1GetSpcLinkPointer(&pOssImage->imageLink, dwFlags,
&pImage->pImageLink, &pbExtra, &lRemainExtra))
goto ErrorReturn;
}
if (pOssImage->bit_mask & bitmap_present) {
WVTAsn1GetOctetString(&pOssImage->bitmap, dwFlags,
&pImage->Bitmap, &pbExtra, &lRemainExtra);
}
if (pOssImage->bit_mask & metafile_present) {
WVTAsn1GetOctetString(&pOssImage->metafile, dwFlags,
&pImage->Metafile, &pbExtra, &lRemainExtra);
}
if (pOssImage->bit_mask & enhancedMetafile_present) {
WVTAsn1GetOctetString(&pOssImage->enhancedMetafile, dwFlags,
&pImage->EnhancedMetafile, &pbExtra, &lRemainExtra);
}
if (pOssImage->bit_mask & gifFile_present) {
WVTAsn1GetOctetString(&pOssImage->gifFile, dwFlags,
&pImage->GifFile, &pbExtra, &lRemainExtra);
}
}
if (pOssInfo->bit_mask & logoLink_present) {
if (!WVTAsn1GetSpcLinkPointer(&pOssInfo->logoLink, dwFlags,
&pInfo->pLogoLink, &pbExtra, &lRemainExtra))
goto ErrorReturn;
}
if (lRemainExtra >= 0)
*pcbInfo = *pcbInfo - (DWORD) lRemainExtra;
else {
*pcbInfo = *pcbInfo + (DWORD) -lRemainExtra;
if (pInfo) goto LengthError;
}
fResult = TRUE;
goto CommonReturn;
LengthError:
SetLastError((DWORD) ERROR_MORE_DATA);
fResult = FALSE;
goto CommonReturn;
ErrorReturn:
*pcbInfo = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1InfoFree(SpcSpAgencyInformation_PDU, pOssInfo);
return fResult;
}
//+-------------------------------------------------------------------------
// SPC Minimal Criteria Info Encode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcMinimalCriteriaInfoEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN BOOL *pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
)
{
ossBoolean OssInfo = (ossBoolean) *pInfo;
return WVTAsn1InfoEncode(
SpcMinimalCriteria_PDU,
&OssInfo,
pbEncoded,
pcbEncoded
);
}
//+-------------------------------------------------------------------------
// SPC Minimal Criteria Info Encode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcMinimalCriteriaInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT BOOL *pInfo,
IN OUT DWORD *pcbInfo
)
{
BOOL fResult;
ossBoolean *pOssInfo = NULL;
if (pInfo == NULL)
*pcbInfo = 0;
if ((fResult = WVTAsn1InfoDecodeAndAlloc(
SpcMinimalCriteria_PDU,
pbEncoded,
cbEncoded,
(void **) &pOssInfo))) {
if (*pcbInfo < sizeof(BOOL)) {
if (pInfo) {
fResult = FALSE;
SetLastError((DWORD) ERROR_MORE_DATA);
}
} else
*pInfo = (BOOL) *pOssInfo;
*pcbInfo = sizeof(BOOL);
} else {
if (*pcbInfo >= sizeof(BOOL))
*pInfo = FALSE;
*pcbInfo = 0;
}
WVTAsn1InfoFree(SpcMinimalCriteria_PDU, pOssInfo);
return fResult;
}
//+-------------------------------------------------------------------------
// SPC Financial Criteria Info Encode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_FINANCIAL_CRITERIA pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
)
{
SpcFinancialCriteria OssInfo;
OssInfo.financialInfoAvailable =
(ossBoolean) pInfo->fFinancialInfoAvailable;
OssInfo.meetsCriteria = (ossBoolean) pInfo->fMeetsCriteria;
return WVTAsn1InfoEncode(
SpcFinancialCriteria_PDU,
&OssInfo,
pbEncoded,
pcbEncoded
);
}
//+-------------------------------------------------------------------------
// SPC Financial Criteria Info Decode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_FINANCIAL_CRITERIA pInfo,
IN OUT DWORD *pcbInfo
)
{
BOOL fResult;
SpcFinancialCriteria *pOssInfo = NULL;
if (pInfo == NULL)
*pcbInfo = 0;
if ((fResult = WVTAsn1InfoDecodeAndAlloc(
SpcFinancialCriteria_PDU,
pbEncoded,
cbEncoded,
(void **) &pOssInfo))) {
if (*pcbInfo < sizeof(SPC_FINANCIAL_CRITERIA)) {
if (pInfo) {
fResult = FALSE;
SetLastError((DWORD) ERROR_MORE_DATA);
}
} else {
pInfo->fFinancialInfoAvailable =
(BOOL) pOssInfo->financialInfoAvailable;
pInfo->fMeetsCriteria = (BOOL) pOssInfo->meetsCriteria;
}
*pcbInfo = sizeof(SPC_FINANCIAL_CRITERIA);
} else
*pcbInfo = 0;
WVTAsn1InfoFree(SpcFinancialCriteria_PDU, pOssInfo);
return fResult;
}
//+-------------------------------------------------------------------------
// SPC statement type attribute value Encode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcStatementTypeEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_STATEMENT_TYPE pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
)
{
BOOL fResult;
DWORD cId;
LPSTR *ppszId;
SpcStatementType OssInfo;
ObjectID *pOssId;
cId = pInfo->cKeyPurposeId;
ppszId = pInfo->rgpszKeyPurposeId;
OssInfo.count = cId;
OssInfo.value = NULL;
if (cId > 0) {
pOssId = (ObjectID *) SpcAsnAlloc(cId * sizeof(ObjectID));
if (pOssId == NULL)
goto ErrorReturn;
memset(pOssId, 0, cId * sizeof(ObjectID));
OssInfo.value = pOssId;
}
// Array of Object Ids
for ( ; cId > 0; cId--, ppszId++, pOssId++) {
if (!WVTAsn1SetObjId(*ppszId, pOssId))
goto ErrorReturn;
}
fResult = WVTAsn1InfoEncode(
SpcStatementType_PDU,
&OssInfo,
pbEncoded,
pcbEncoded
);
goto CommonReturn;
ErrorReturn:
*pcbEncoded = 0;
fResult = FALSE;
CommonReturn:
if (OssInfo.value)
SpcAsnFree(OssInfo.value);
return fResult;
}
//+-------------------------------------------------------------------------
// SPC statement type attribute value Decode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcStatementTypeDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_STATEMENT_TYPE pInfo,
IN OUT DWORD *pcbInfo
)
{
BOOL fResult;
SpcStatementType *pOssInfo = NULL;
BYTE *pbExtra;
LONG lRemainExtra;
LONG lAlignExtra;
DWORD cId;
LPSTR *ppszId;
ObjectID *pOssId;
if (pInfo == NULL)
*pcbInfo = 0;
if (!WVTAsn1InfoDecodeAndAlloc(
SpcStatementType_PDU,
pbEncoded,
cbEncoded,
(void **) &pOssInfo))
goto ErrorReturn;
// for lRemainExtra < 0, LENGTH_ONLY calculation
lRemainExtra = (LONG) *pcbInfo - sizeof(SPC_STATEMENT_TYPE);
if (lRemainExtra < 0) {
pbExtra = NULL;
} else
pbExtra = (BYTE *) pInfo + sizeof(SPC_STATEMENT_TYPE);
cId = pOssInfo->count;
pOssId = pOssInfo->value;
lAlignExtra = INFO_LEN_ALIGN(cId * sizeof(LPSTR));
lRemainExtra -= lAlignExtra;
if (lRemainExtra >= 0) {
pInfo->cKeyPurposeId = cId;
ppszId = (LPSTR *) pbExtra;
pInfo->rgpszKeyPurposeId = ppszId;
pbExtra += lAlignExtra;
} else
ppszId = NULL;
// Array of Object Ids
for ( ; cId > 0; cId--, ppszId++, pOssId++) {
WVTAsn1GetObjId(pOssId, dwFlags, ppszId, &pbExtra, &lRemainExtra);
}
if (lRemainExtra >= 0)
*pcbInfo = *pcbInfo - (DWORD) lRemainExtra;
else {
*pcbInfo = *pcbInfo + (DWORD) -lRemainExtra;
if (pInfo) goto LengthError;
}
fResult = TRUE;
goto CommonReturn;
LengthError:
SetLastError((DWORD) ERROR_MORE_DATA);
fResult = FALSE;
goto CommonReturn;
ErrorReturn:
*pcbInfo = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1InfoFree(SpcStatementType_PDU, pOssInfo);
return fResult;
}
//+-------------------------------------------------------------------------
// SPC SP Opus info attribute value Encode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcSpOpusInfoEncode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_SP_OPUS_INFO pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded
)
{
BOOL fResult;
SpcSpOpusInfo OssInfo;
memset(&OssInfo, 0, sizeof(OssInfo));
if (pInfo->pwszProgramName) {
WVTAsn1SetSpcString((LPWSTR) pInfo->pwszProgramName, &OssInfo.programName);
OssInfo.bit_mask |= programName_present;
}
if (pInfo->pMoreInfo) {
if (!WVTAsn1SetSpcLink(pInfo->pMoreInfo, &OssInfo.moreInfo))
goto ErrorReturn;
OssInfo.bit_mask |= moreInfo_present;
}
if (pInfo->pPublisherInfo) {
if (!WVTAsn1SetSpcLink(pInfo->pPublisherInfo, &OssInfo.publisherInfo))
goto ErrorReturn;
OssInfo.bit_mask |= publisherInfo_present;
}
fResult = WVTAsn1InfoEncode(
SpcSpOpusInfo_PDU,
&OssInfo,
pbEncoded,
pcbEncoded
);
goto CommonReturn;
ErrorReturn:
*pcbEncoded = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1FreeSpcLink(&OssInfo.moreInfo);
WVTAsn1FreeSpcLink(&OssInfo.publisherInfo);
return fResult;
}
//+-------------------------------------------------------------------------
// SPC SP Opus info attribute value Encode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcSpOpusInfoDecode(
IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_SP_OPUS_INFO pInfo,
IN OUT DWORD *pcbInfo
)
{
BOOL fResult;
SpcSpOpusInfo *pOssInfo = NULL;
BYTE *pbExtra;
LONG lRemainExtra;
if (pInfo == NULL)
*pcbInfo = 0;
if (!WVTAsn1InfoDecodeAndAlloc(
SpcSpOpusInfo_PDU,
pbEncoded,
cbEncoded,
(void **) &pOssInfo))
goto ErrorReturn;
// for lRemainExtra < 0, LENGTH_ONLY calculation
lRemainExtra = (LONG) *pcbInfo - sizeof(SPC_SP_OPUS_INFO);
if (lRemainExtra < 0) {
pbExtra = NULL;
} else {
// Default all optional fields to zero
memset(pInfo, 0, sizeof(SPC_SP_OPUS_INFO));
pbExtra = (BYTE *) pInfo + sizeof(SPC_SP_OPUS_INFO);
}
if (pOssInfo->bit_mask & programName_present) {
WVTAsn1GetSpcString(&pOssInfo->programName, dwFlags,
(LPWSTR*) &pInfo->pwszProgramName, &pbExtra, &lRemainExtra);
}
if (pOssInfo->bit_mask & moreInfo_present) {
if (!WVTAsn1GetSpcLinkPointer(&pOssInfo->moreInfo, dwFlags,
&pInfo->pMoreInfo, &pbExtra, &lRemainExtra))
goto ErrorReturn;
}
if (pOssInfo->bit_mask & publisherInfo_present) {
if (!WVTAsn1GetSpcLinkPointer(&pOssInfo->publisherInfo, dwFlags,
&pInfo->pPublisherInfo, &pbExtra, &lRemainExtra))
goto ErrorReturn;
}
if (lRemainExtra >= 0)
*pcbInfo = *pcbInfo - (DWORD) lRemainExtra;
else {
*pcbInfo = *pcbInfo + (DWORD) -lRemainExtra;
if (pInfo) goto LengthError;
}
fResult = TRUE;
goto CommonReturn;
LengthError:
SetLastError((DWORD) ERROR_MORE_DATA);
fResult = FALSE;
goto CommonReturn;
ErrorReturn:
*pcbInfo = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1InfoFree(SpcSpOpusInfo_PDU, pOssInfo);
return fResult;
}
BOOL WINAPI WVTAsn1SpcLinkEncode( IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_LINK pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded)
{
BOOL fResult;
SpcLink OssSpcLink;
if (!(WVTAsn1SetSpcLink(pInfo, &OssSpcLink)))
{
goto ErrorReturn;
}
fResult = WVTAsn1InfoEncode(SpcLink_PDU, &OssSpcLink, pbEncoded,
pcbEncoded);
goto CommonReturn;
ErrorReturn:
*pcbEncoded = 0;
fResult = FALSE;
CommonReturn:
return(fResult);
}
BOOL WINAPI WVTAsn1SpcLinkDecode(IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_LINK pInfo,
IN OUT DWORD *pcbInfo)
{
BOOL fResult;
SpcLink *pSpcLink = NULL;
BYTE *pbExtra;
LONG lRemainExtra;
if (pInfo == NULL)
{
*pcbInfo = 0;
}
if (!(WVTAsn1InfoDecodeAndAlloc(SpcLink_PDU, pbEncoded, cbEncoded,
(void **)&pSpcLink)))
{
goto ErrorReturn;
}
// for lRemainExtra < 0, LENGTH_ONLY calculation
lRemainExtra = (LONG) *pcbInfo - sizeof(SPC_LINK);
if (lRemainExtra < 0)
{
pbExtra = NULL;
}
else
{
pbExtra = (BYTE *) pInfo + sizeof(SPC_LINK);
}
if (!(WVTAsn1GetSpcLink(pSpcLink, dwFlags, pInfo, &pbExtra, &lRemainExtra)))
{
goto ErrorReturn;
}
if (lRemainExtra >= 0)
{
*pcbInfo = *pcbInfo - (DWORD) lRemainExtra;
}
else
{
*pcbInfo = *pcbInfo + (DWORD) -lRemainExtra;
if (pInfo)
{
goto LengthError;
}
}
fResult = TRUE;
goto CommonReturn;
LengthError:
SetLastError((DWORD)ERROR_MORE_DATA);
fResult = FALSE;
goto CommonReturn;
ErrorReturn:
*pcbInfo = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1InfoFree(SpcLink_PDU, pSpcLink);
return fResult;
}
BOOL WINAPI WVTAsn1SpcPeImageDataEncode(IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PSPC_PE_IMAGE_DATA pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded)
{
BOOL fResult;
SpcPeImageData OssInfo;
memset(&OssInfo, 0, sizeof(OssInfo));
if (pInfo->Flags.cbData)
{
// SpcPeImageFlags has its own definition. It has a default
// bit (includeResources). Therefore, can't use the default BITSTRING.
// Note: BITSTRING's length is an unsigned int, while SpcPeImageFlags's
// length is an unsigned short.
BITSTRING OssBitString;
WVTAsn1SetBit(&pInfo->Flags, &OssBitString);
OssInfo.flags.length = (WORD)OssBitString.length;
OssInfo.flags.value = OssBitString.value;
OssInfo.bit_mask |= flags_present;
}
if (pInfo->pFile)
{
if (!WVTAsn1SetSpcLink(pInfo->pFile, &OssInfo.file))
{
goto ErrorReturn;
}
OssInfo.bit_mask |= file_present;
}
fResult = WVTAsn1InfoEncode(SpcPeImageData_PDU, &OssInfo, pbEncoded,
pcbEncoded);
goto CommonReturn;
ErrorReturn:
*pcbEncoded = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1FreeSpcLink(&OssInfo.file);
return(fResult);
}
//+-------------------------------------------------------------------------
// SPC Portable Executable (PE) Image Attribute Value Decode (OSS X509)
//--------------------------------------------------------------------------
BOOL WINAPI WVTAsn1SpcPeImageDataDecode(IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PSPC_PE_IMAGE_DATA pInfo,
IN OUT DWORD *pcbInfo)
{
BOOL fResult;
SpcPeImageData *pOssInfo = NULL;
BYTE *pbExtra;
LONG lRemainExtra;
if (pInfo == NULL)
{
*pcbInfo = 0;
}
if (!WVTAsn1InfoDecodeAndAlloc(SpcPeImageData_PDU, pbEncoded, cbEncoded,
(void **)&pOssInfo))
{
goto ErrorReturn;
}
// for lRemainExtra < 0, LENGTH_ONLY calculation
lRemainExtra = (LONG) *pcbInfo - sizeof(SPC_PE_IMAGE_DATA);
if (lRemainExtra < 0)
{
pbExtra = NULL;
}
else
{
// Default all optional fields to zero
memset(pInfo, 0, sizeof(SPC_PE_IMAGE_DATA));
pbExtra = (BYTE *) pInfo + sizeof(SPC_PE_IMAGE_DATA);
}
if (pOssInfo->bit_mask & flags_present)
{
// See above encode for why we need to do this extra indirect step
BITSTRING OssBitString;
OssBitString.length = pOssInfo->flags.length;
OssBitString.value = pOssInfo->flags.value;
WVTAsn1GetBit(&OssBitString, dwFlags,
&pInfo->Flags, &pbExtra, &lRemainExtra);
}
if (pOssInfo->bit_mask & file_present)
{
if (!WVTAsn1GetSpcLinkPointer(&pOssInfo->file, dwFlags,
&pInfo->pFile, &pbExtra, &lRemainExtra))
{
goto ErrorReturn;
}
}
if (lRemainExtra >= 0)
{
*pcbInfo = *pcbInfo - (DWORD) lRemainExtra;
}
else
{
*pcbInfo = *pcbInfo + (DWORD) -lRemainExtra;
if (pInfo)
{
goto LengthError;
}
}
fResult = TRUE;
goto CommonReturn;
LengthError:
SetLastError((DWORD) ERROR_MORE_DATA);
fResult = FALSE;
goto CommonReturn;
ErrorReturn:
*pcbInfo = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1InfoFree(SpcPeImageData_PDU, pOssInfo);
return(fResult);
}
BOOL WINAPI WVTAsn1SpcSigInfoEncode(DWORD dwCertEncodingType, LPCSTR lpszStructType,
PSPC_SIGINFO pInfo, BYTE *pbEncoded,
DWORD *pcbEncoded)
{
BOOL fResult;
SpcSigInfo OssSpcSigInfo;
if (!(WVTAsn1SetSpcSigInfo(pInfo, &OssSpcSigInfo)))
{
goto ErrorReturn;
}
fResult = WVTAsn1InfoEncode(SpcSigInfo_PDU, &OssSpcSigInfo, pbEncoded,
pcbEncoded);
goto CommonReturn;
ErrorReturn:
*pcbEncoded = 0;
fResult = FALSE;
CommonReturn:
return(fResult);
}
BOOL WINAPI WVTAsn1SpcSigInfoDecode(DWORD dwCertEncodingType, LPCSTR lpszStructType,
const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags,
PSPC_SIGINFO pInfo, OUT DWORD *pcbInfo)
{
BOOL fResult;
SpcSigInfo *pSpcSigInfo = NULL;
BYTE *pbExtra;
LONG lRemainExtra;
if (pInfo == NULL)
{
*pcbInfo = 0;
}
if (!(WVTAsn1InfoDecodeAndAlloc(SpcSigInfo_PDU, pbEncoded, cbEncoded, (void **)&pSpcSigInfo)))
{
goto ErrorReturn;
}
// for lRemainExtra < 0, LENGTH_ONLY calculation
lRemainExtra = (LONG) *pcbInfo - sizeof(SPC_SIGINFO);
if (lRemainExtra < 0)
{
pbExtra = NULL;
}
else
{
pbExtra = (BYTE *) pInfo + sizeof(SPC_SIGINFO);
}
if (!(WVTAsn1GetSpcSigInfo(pSpcSigInfo, dwFlags, pInfo, &pbExtra, &lRemainExtra)))
{
goto ErrorReturn;
}
if (lRemainExtra >= 0)
{
*pcbInfo = *pcbInfo - (DWORD) lRemainExtra;
}
else
{
*pcbInfo = *pcbInfo + (DWORD) -lRemainExtra;
if (pInfo)
{
goto LengthError;
}
}
fResult = TRUE;
goto CommonReturn;
LengthError:
SetLastError((DWORD)ERROR_MORE_DATA);
fResult = FALSE;
goto CommonReturn;
ErrorReturn:
*pcbInfo = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1InfoFree(SpcSigInfo_PDU, pSpcSigInfo);
return fResult;
}
BOOL WVTAsn1SetCatNameValue(IN PCAT_NAMEVALUE pInfo, OUT NameValue *pOss)
{
memset(pOss, 0x00, sizeof(*pOss));
// tag!
WVTAsn1SetBMP(pInfo->pwszTag, &pOss->refname);
// flags
pOss->typeaction = (int)pInfo->fdwFlags;
// value
WVTAsn1SetOctetString(&pInfo->Value, &pOss->value);
return(TRUE);
}
BOOL WVTAsn1SetCatMemberInfo(IN PCAT_MEMBERINFO pInfo, OUT MemberInfo *pOss)
{
memset(pOss, 0x00, sizeof(*pOss));
// subject guid (wide text)
WVTAsn1SetBMP(pInfo->pwszSubjGuid, &pOss->subguid);
// cert version
pOss->certversion = (int)pInfo->dwCertVersion;
return(TRUE);
}
BOOL WVTAsn1GetCatNameValue(IN NameValue *pOss, IN DWORD dwFlags,
OUT PCAT_NAMEVALUE pInfo, IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra)
{
if (*plRemainExtra >= 0)
{
memset(pInfo, 0, sizeof(*pInfo));
}
WVTAsn1GetOctetString(&pOss->value, dwFlags,
&pInfo->Value, ppbExtra, plRemainExtra);
if (*plRemainExtra >= 0)
{
pInfo->fdwFlags = (DWORD)pOss->typeaction;
}
WVTAsn1GetBMP(&pOss->refname, dwFlags, &pInfo->pwszTag, ppbExtra, plRemainExtra);
return(TRUE);
}
BOOL WVTAsn1GetCatMemberInfo(IN MemberInfo *pOss, IN DWORD dwFlags,
OUT PCAT_MEMBERINFO pInfo, IN OUT BYTE **ppbExtra,
IN OUT LONG *plRemainExtra)
{
if (*plRemainExtra >= 0)
{
memset(pInfo, 0, sizeof(*pInfo));
}
WVTAsn1GetBMP(&pOss->subguid, dwFlags, &pInfo->pwszSubjGuid, ppbExtra, plRemainExtra);
if (*plRemainExtra >= 0)
{
pInfo->dwCertVersion = pOss->certversion;
}
return(TRUE);
}
BOOL WINAPI WVTAsn1CatNameValueEncode( IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PCAT_NAMEVALUE pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded)
{
BOOL fResult;
NameValue OssNameValue;
if (!(WVTAsn1SetCatNameValue(pInfo, &OssNameValue)))
{
goto ErrorReturn;
}
fResult = WVTAsn1InfoEncode(NameValue_PDU, &OssNameValue, pbEncoded,
pcbEncoded);
goto CommonReturn;
ErrorReturn:
*pcbEncoded = 0;
fResult = FALSE;
CommonReturn:
return(fResult);
}
BOOL WINAPI WVTAsn1CatMemberInfoEncode( IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN PCAT_MEMBERINFO pInfo,
OUT BYTE *pbEncoded,
IN OUT DWORD *pcbEncoded)
{
BOOL fResult;
MemberInfo OssMemberInfo;
if (!(WVTAsn1SetCatMemberInfo(pInfo, &OssMemberInfo)))
{
goto ErrorReturn;
}
fResult = WVTAsn1InfoEncode(MemberInfo_PDU, &OssMemberInfo, pbEncoded,
pcbEncoded);
goto CommonReturn;
ErrorReturn:
*pcbEncoded = 0;
fResult = FALSE;
CommonReturn:
return(fResult);
}
BOOL WINAPI WVTAsn1CatNameValueDecode(IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PCAT_NAMEVALUE pInfo,
IN OUT DWORD *pcbInfo)
{
BOOL fResult;
NameValue *pNameValue = NULL;
BYTE *pbExtra;
LONG lRemainExtra;
if (pInfo == NULL)
{
*pcbInfo = 0;
}
if (!(WVTAsn1InfoDecodeAndAlloc(NameValue_PDU, pbEncoded, cbEncoded,
(void **)&pNameValue)))
{
goto ErrorReturn;
}
// for lRemainExtra < 0, LENGTH_ONLY calculation
lRemainExtra = (LONG) *pcbInfo - sizeof(CAT_NAMEVALUE);
if (lRemainExtra < 0)
{
pbExtra = NULL;
}
else
{
pbExtra = (BYTE *) pInfo + sizeof(CAT_NAMEVALUE);
}
if (!(WVTAsn1GetCatNameValue(pNameValue, dwFlags, pInfo, &pbExtra, &lRemainExtra)))
{
goto ErrorReturn;
}
if (lRemainExtra >= 0)
{
*pcbInfo = *pcbInfo - (DWORD) lRemainExtra;
}
else
{
*pcbInfo = *pcbInfo + (DWORD) -lRemainExtra;
if (pInfo)
{
goto LengthError;
}
}
fResult = TRUE;
goto CommonReturn;
LengthError:
SetLastError((DWORD)ERROR_MORE_DATA);
fResult = FALSE;
goto CommonReturn;
ErrorReturn:
*pcbInfo = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1InfoFree(NameValue_PDU, pNameValue);
return fResult;
}
BOOL WINAPI WVTAsn1CatMemberInfoDecode( IN DWORD dwCertEncodingType,
IN LPCSTR lpszStructType,
IN const BYTE *pbEncoded,
IN DWORD cbEncoded,
IN DWORD dwFlags,
OUT PCAT_MEMBERINFO pInfo,
IN OUT DWORD *pcbInfo)
{
BOOL fResult;
MemberInfo *pMemberInfo = NULL;
BYTE *pbExtra;
LONG lRemainExtra;
if (pInfo == NULL)
{
*pcbInfo = 0;
}
if (!(WVTAsn1InfoDecodeAndAlloc(MemberInfo_PDU, pbEncoded, cbEncoded,
(void **)&pMemberInfo)))
{
goto ErrorReturn;
}
// for lRemainExtra < 0, LENGTH_ONLY calculation
lRemainExtra = (LONG) *pcbInfo - sizeof(CAT_MEMBERINFO);
if (lRemainExtra < 0)
{
pbExtra = NULL;
}
else
{
pbExtra = (BYTE *) pInfo + sizeof(CAT_MEMBERINFO);
}
if (!(WVTAsn1GetCatMemberInfo(pMemberInfo, dwFlags, pInfo, &pbExtra, &lRemainExtra)))
{
goto ErrorReturn;
}
if (lRemainExtra >= 0)
{
*pcbInfo = *pcbInfo - (DWORD) lRemainExtra;
}
else
{
*pcbInfo = *pcbInfo + (DWORD) -lRemainExtra;
if (pInfo)
{
goto LengthError;
}
}
fResult = TRUE;
goto CommonReturn;
LengthError:
SetLastError((DWORD)ERROR_MORE_DATA);
fResult = FALSE;
goto CommonReturn;
ErrorReturn:
*pcbInfo = 0;
fResult = FALSE;
CommonReturn:
WVTAsn1InfoFree(MemberInfo_PDU, pMemberInfo);
return fResult;
}
Reference in a new issue Copy permalink