ReactOS 0.4.16-dev-2498-g8632030
Classes | Macros | Typedefs | Functions
asn.c File Reference
#include <stdarg.h>
#include <stdio.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wincrypt.h"
#include "wintrust.h"
#include "snmp.h"
#include "winternl.h"
#include "wine/debug.h"
#include "wine/exception.h"
Include dependency graph for asn.c:

Go to the source code of this file.

Classes

struct  AsnEncodeSequenceItem
 
struct  AsnConstructedItem
 
struct  SPCDigest
 
struct  AsnEncodeTagSwappedItem
 
struct  AsnDecodeSequenceItem
 

Macros

#define hton16(x)   RtlUshortByteSwap(x)
 
#define n16toh(x)   RtlUshortByteSwap(x)
 
#define ASN_BOOL   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x01)
 
#define ASN_BITSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x03)
 
#define ASN_BMPSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e)
 
#define GET_LEN_BYTES(b)   ((b) <= 0x7f ? 1 : 1 + ((b) & 0x7f))
 
#define ALIGN_DWORD_PTR(x)   (((x) + sizeof(DWORD_PTR) - 1) & ~(sizeof(DWORD_PTR) - 1))
 
#define FINALMEMBERSIZE(s, member)   (sizeof(s) - offsetof(s, member))
 
#define MEMBERSIZE(s, member, nextmember)    (offsetof(s, nextmember) - offsetof(s, member))
 

Typedefs

typedef BOOL(WINAPI * CryptEncodeObjectFunc) (DWORD, LPCSTR, const void *, BYTE *, DWORD *)
 
typedef BOOL(WINAPI * CryptDecodeObjectFunc) (DWORD, LPCSTR, const BYTE *, DWORD, DWORD, void *, DWORD *)
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (cryptasn)
 
static BOOL CRYPT_EncodeLen (DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeOctets (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
BOOL WINAPI WVTAsn1SpcLinkEncode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL CRYPT_AsnEncodeSequence (DWORD dwCertEncodingType, struct AsnEncodeSequenceItem items[], DWORD cItem, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeBits (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeConstructed (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
BOOL WINAPI WVTAsn1SpcPeImageDataEncode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeOid (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_CopyEncodedBlob (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeAttributeTypeValue (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeSPCDigest (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
BOOL WINAPI WVTAsn1SpcIndirectDataContentEncode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeBMPString (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeSwapTag (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
BOOL WINAPI WVTAsn1SpcSpOpusInfoEncode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL CRYPT_AsnEncodeInteger (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeInt (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
BOOL WINAPI WVTAsn1CatMemberInfoEncode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
BOOL WINAPI WVTAsn1CatNameValueEncode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL WINAPI CRYPT_AsnEncodeBool (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoEncode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
 
static BOOL CRYPT_GetLen (const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
 
static BOOL WINAPI CRYPT_AsnDecodeOctets (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeSPCLinkInternal (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL WINAPI WVTAsn1SpcLinkDecode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeSequenceItems (DWORD dwCertEncodingType, struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, BYTE *nextData, DWORD *cbDecoded)
 
static BOOL CRYPT_AsnDecodeSequence (DWORD dwCertEncodingType, struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, void *startingPointer)
 
static BOOL WINAPI CRYPT_AsnDecodeBitsInternal (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeSPCLinkPointer (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL WINAPI WVTAsn1SpcPeImageDataDecode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeOidIgnoreTag (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeOid (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeCopyBytes (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeAttributeTypeValue (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeAlgorithmId (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeSPCDigest (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL WINAPI WVTAsn1SpcIndirectDataContentDecode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeBMPString (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeProgramName (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL WINAPI WVTAsn1SpcSpOpusInfoDecode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeInt (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL WINAPI WVTAsn1CatMemberInfoDecode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL WINAPI WVTAsn1CatNameValueDecode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeBool (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoDecode (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 

Macro Definition Documentation

◆ ALIGN_DWORD_PTR

#define ALIGN_DWORD_PTR (   x)    (((x) + sizeof(DWORD_PTR) - 1) & ~(sizeof(DWORD_PTR) - 1))

Definition at line 1471 of file asn.c.

◆ ASN_BITSTRING

#define ASN_BITSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x03)

Definition at line 50 of file asn.c.

◆ ASN_BMPSTRING

#define ASN_BMPSTRING   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x1e)

Definition at line 51 of file asn.c.

◆ ASN_BOOL

#define ASN_BOOL   (ASN_UNIVERSAL | ASN_PRIMITIVE | 0x01)

Definition at line 49 of file asn.c.

◆ FINALMEMBERSIZE

#define FINALMEMBERSIZE (   s,
  member 
)    (sizeof(s) - offsetof(s, member))

Definition at line 1473 of file asn.c.

◆ GET_LEN_BYTES

#define GET_LEN_BYTES (   b)    ((b) <= 0x7f ? 1 : 1 + ((b) & 0x7f))

Definition at line 1100 of file asn.c.

◆ hton16

#define hton16 (   x)    RtlUshortByteSwap(x)

Definition at line 44 of file asn.c.

◆ MEMBERSIZE

#define MEMBERSIZE (   s,
  member,
  nextmember 
)     (offsetof(s, nextmember) - offsetof(s, member))

Definition at line 1474 of file asn.c.

◆ n16toh

#define n16toh (   x)    RtlUshortByteSwap(x)

Definition at line 45 of file asn.c.

Typedef Documentation

◆ CryptDecodeObjectFunc

typedef BOOL(WINAPI * CryptDecodeObjectFunc) (DWORD, LPCSTR, const BYTE *, DWORD, DWORD, void *, DWORD *)

Definition at line 1432 of file asn.c.

◆ CryptEncodeObjectFunc

typedef BOOL(WINAPI * CryptEncodeObjectFunc) (DWORD, LPCSTR, const void *, BYTE *, DWORD *)

Definition at line 282 of file asn.c.

Function Documentation

◆ CRYPT_AsnDecodeAlgorithmId()

static BOOL WINAPI CRYPT_AsnDecodeAlgorithmId ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 2004 of file asn.c.

2007{
2008 CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
2009 BOOL ret = TRUE;
2010 struct AsnDecodeSequenceItem items[] = {
2011 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId),
2012 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2013 offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId), 0 },
2014 { 0, offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters),
2015 CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2016 offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters.pbData), 0 },
2017 };
2018
2019 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2020 pvStructInfo, *pcbStructInfo);
2021
2022 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items),
2023 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo, algo ? algo->pszObjId : NULL);
2024 if (ret && pvStructInfo)
2025 {
2026 TRACE("pszObjId is %p (%s)\n", algo->pszObjId,
2027 debugstr_a(algo->pszObjId));
2028 }
2029 return ret;
2030}
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
CRYPT_AsnDecodeCopyBytes
static BOOL WINAPI CRYPT_AsnDecodeCopyBytes(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:1945
CRYPT_AsnDecodeOidIgnoreTag
static BOOL WINAPI CRYPT_AsnDecodeOidIgnoreTag(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:1824
CRYPT_AsnDecodeSequence
static BOOL CRYPT_AsnDecodeSequence(DWORD dwCertEncodingType, struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, void *startingPointer)
Definition: asn.c:1605
ret
return ret
Definition: mutex.c:146
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
dwFlags
_In_ LPWSTR _In_ DWORD _In_ DWORD _In_ DWORD dwFlags
Definition: netsh.h:141
items
static TCHAR * items[]
Definition: page1.c:45
offsetof
#define offsetof(TYPE, MEMBER)
Definition: sdbstringtable.c:26
ASN_OBJECTIDENTIFIER
#define ASN_OBJECTIDENTIFIER
Definition: snmp.h:107
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
_CRYPT_ALGORITHM_IDENTIFIER
Definition: wincrypt.h:134
_CRYPT_ALGORITHM_IDENTIFIER::pszObjId
LPSTR pszObjId
Definition: wincrypt.h:135
Parameters
_Must_inspect_result_ _In_ WDFQUEUE _In_opt_ WDFREQUEST _In_opt_ WDFFILEOBJECT _Inout_opt_ PWDF_REQUEST_PARAMETERS Parameters
Definition: wdfio.h:869
CRYPT_OBJID_BLOB
struct _CRYPTOAPI_BLOB CRYPT_OBJID_BLOB
LPSTR
char * LPSTR
Definition: xmlstorage.h:182

Referenced by CRYPT_AsnDecodeSPCDigest().

◆ CRYPT_AsnDecodeAttributeTypeValue()

static BOOL WINAPI CRYPT_AsnDecodeAttributeTypeValue ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 1982 of file asn.c.

1985{
1986 CRYPT_ATTRIBUTE_TYPE_VALUE *typeValue = pvStructInfo;
1987 struct AsnDecodeSequenceItem items[] = {
1988 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, pszObjId),
1989 CRYPT_AsnDecodeOid, sizeof(LPSTR), FALSE, TRUE,
1990 offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, pszObjId), 0 },
1991 { 0, offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, Value),
1992 CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_DATA_BLOB), TRUE, TRUE,
1993 offsetof(CRYPT_ATTRIBUTE_TYPE_VALUE, Value.pbData), 0 },
1994 };
1995
1996 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1997 pvStructInfo, *pcbStructInfo);
1998
1999 return CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items),
2000 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo,
2001 typeValue ? typeValue->pszObjId : NULL);
2002}
CRYPT_AsnDecodeOid
static BOOL WINAPI CRYPT_AsnDecodeOid(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:1926
_CRYPT_ATTRIBUTE_TYPE_VALUE
Definition: wincrypt.h:139
_CRYPT_ATTRIBUTE_TYPE_VALUE::pszObjId
LPSTR pszObjId
Definition: wincrypt.h:140
Value
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
CRYPT_DATA_BLOB
struct _CRYPTOAPI_BLOB CRYPT_DATA_BLOB

Referenced by WVTAsn1SpcIndirectDataContentDecode().

◆ CRYPT_AsnDecodeBitsInternal()

static BOOL WINAPI CRYPT_AsnDecodeBitsInternal ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 1685 of file asn.c.

1688{
1689 BOOL ret;
1690
1691 TRACE("(%p, %ld, 0x%08lx, %p, %ld)\n", pbEncoded, cbEncoded, dwFlags,
1692 pvStructInfo, *pcbStructInfo);
1693
1694 if (pbEncoded[0] == ASN_BITSTRING)
1695 {
1696 DWORD bytesNeeded, dataLen;
1697
1698 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1699 {
1700 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1701 bytesNeeded = sizeof(CRYPT_BIT_BLOB);
1702 else
1703 bytesNeeded = dataLen - 1 + sizeof(CRYPT_BIT_BLOB);
1704 if (!pvStructInfo)
1705 *pcbStructInfo = bytesNeeded;
1706 else if (*pcbStructInfo < bytesNeeded)
1707 {
1708 *pcbStructInfo = bytesNeeded;
1709 SetLastError(ERROR_MORE_DATA);
1710 ret = FALSE;
1711 }
1712 else
1713 {
1714 CRYPT_BIT_BLOB *blob;
1715
1716 blob = pvStructInfo;
1717 blob->cbData = dataLen - 1;
1718 blob->cUnusedBits = *(pbEncoded + 1 +
1719 GET_LEN_BYTES(pbEncoded[1]));
1720 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1721 {
1722 blob->pbData = (BYTE *)pbEncoded + 2 +
1723 GET_LEN_BYTES(pbEncoded[1]);
1724 }
1725 else
1726 {
1727 assert(blob->pbData);
1728 if (blob->cbData)
1729 {
1730 BYTE mask = 0xff << blob->cUnusedBits;
1731
1732 memcpy(blob->pbData, pbEncoded + 2 +
1733 GET_LEN_BYTES(pbEncoded[1]), blob->cbData);
1734 blob->pbData[blob->cbData - 1] &= mask;
1735 }
1736 }
1737 }
1738 }
1739 }
1740 else
1741 {
1742 SetLastError(CRYPT_E_ASN1_BADTAG);
1743 ret = FALSE;
1744 }
1745 TRACE("returning %d (%08lx)\n", ret, GetLastError());
1746 return ret;
1747}
ERROR_MORE_DATA
#define ERROR_MORE_DATA
Definition: dderror.h:13
SetLastError
#define SetLastError(x)
Definition: compat.h:752
assert
#define assert(_expr)
Definition: assert.h:32
CRYPT_GetLen
static BOOL CRYPT_GetLen(const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
Definition: asn.c:1107
ASN_BITSTRING
#define ASN_BITSTRING
Definition: asn.c:50
GET_LEN_BYTES
#define GET_LEN_BYTES(b)
Definition: asn.c:1100
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
_CRYPT_BIT_BLOB
Definition: wincrypt.h:204
blob
Definition: image.c:134
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
CRYPT_DECODE_NOCOPY_FLAG
#define CRYPT_DECODE_NOCOPY_FLAG
Definition: wincrypt.h:3608
CRYPT_BIT_BLOB
struct _CRYPT_BIT_BLOB CRYPT_BIT_BLOB
CRYPT_E_ASN1_BADTAG
#define CRYPT_E_ASN1_BADTAG
Definition: winerror.h:4510
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Referenced by WVTAsn1SpcPeImageDataDecode().

◆ CRYPT_AsnDecodeBMPString()

static BOOL WINAPI CRYPT_AsnDecodeBMPString ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 2089 of file asn.c.

2092{
2093 BOOL ret;
2094 DWORD bytesNeeded, dataLen;
2095
2096 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2097 {
2098 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2099
2100 bytesNeeded = dataLen + 2 + sizeof(LPWSTR);
2101 if (!pvStructInfo)
2102 *pcbStructInfo = bytesNeeded;
2103 else if (*pcbStructInfo < bytesNeeded)
2104 {
2105 *pcbStructInfo = bytesNeeded;
2106 SetLastError(ERROR_MORE_DATA);
2107 ret = FALSE;
2108 }
2109 else
2110 {
2111 LPWSTR str;
2112 DWORD i;
2113
2114 *pcbStructInfo = bytesNeeded;
2115 assert(pvStructInfo);
2116 str = *(LPWSTR *)pvStructInfo;
2117 for (i = 0; i < dataLen / 2; i++)
2118 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
2119 pbEncoded[1 + lenBytes + 2 * i + 1];
2120 /* Decoded string is always NULL-terminated */
2121 str[i] = '\0';
2122 }
2123 }
2124 return ret;
2125}
i
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
str
const WCHAR * str
Definition: rpc_transport.c:2696
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by CRYPT_AsnDecodeProgramName(), WVTAsn1CatMemberInfoDecode(), and WVTAsn1CatNameValueDecode().

◆ CRYPT_AsnDecodeBool()

static BOOL WINAPI CRYPT_AsnDecodeBool ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 2302 of file asn.c.

2305{
2306 BOOL ret;
2307
2308 if (cbEncoded < 3)
2309 {
2310 SetLastError(CRYPT_E_ASN1_CORRUPT);
2311 return FALSE;
2312 }
2313 if (GET_LEN_BYTES(pbEncoded[1]) > 1)
2314 {
2315 SetLastError(CRYPT_E_ASN1_CORRUPT);
2316 return FALSE;
2317 }
2318 if (pbEncoded[1] > 1)
2319 {
2320 SetLastError(CRYPT_E_ASN1_CORRUPT);
2321 return FALSE;
2322 }
2323 if (!pvStructInfo)
2324 {
2325 *pcbStructInfo = sizeof(BOOL);
2326 ret = TRUE;
2327 }
2328 else if (*pcbStructInfo < sizeof(BOOL))
2329 {
2330 *pcbStructInfo = sizeof(BOOL);
2331 SetLastError(ERROR_MORE_DATA);
2332 ret = FALSE;
2333 }
2334 else
2335 {
2336 *pcbStructInfo = sizeof(BOOL);
2337 *(BOOL *)pvStructInfo = pbEncoded[2] != 0;
2338 ret = TRUE;
2339 }
2340 TRACE("returning %d (%08lx)\n", ret, GetLastError());
2341 return ret;
2342}
BOOL
#define BOOL
Definition: nt_native.h:43
CRYPT_E_ASN1_CORRUPT
#define CRYPT_E_ASN1_CORRUPT
Definition: winerror.h:4502

Referenced by WVTAsn1SpcFinancialCriteriaInfoDecode().

◆ CRYPT_AsnDecodeCopyBytes()

static BOOL WINAPI CRYPT_AsnDecodeCopyBytes ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 1945 of file asn.c.

1948{
1949 BOOL ret = TRUE;
1950 DWORD bytesNeeded = sizeof(CRYPT_OBJID_BLOB);
1951
1952 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1953 pvStructInfo, *pcbStructInfo);
1954
1955 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1956 bytesNeeded += cbEncoded;
1957 if (!pvStructInfo)
1958 *pcbStructInfo = bytesNeeded;
1959 else if (*pcbStructInfo < bytesNeeded)
1960 {
1961 SetLastError(ERROR_MORE_DATA);
1962 *pcbStructInfo = bytesNeeded;
1963 ret = FALSE;
1964 }
1965 else
1966 {
1967 PCRYPT_OBJID_BLOB blob = pvStructInfo;
1968
1969 *pcbStructInfo = bytesNeeded;
1970 blob->cbData = cbEncoded;
1971 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1972 blob->pbData = (LPBYTE)pbEncoded;
1973 else
1974 {
1975 assert(blob->pbData);
1976 memcpy(blob->pbData, pbEncoded, blob->cbData);
1977 }
1978 }
1979 return ret;
1980}
_CRYPTOAPI_BLOB
Definition: wincrypt.h:110
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53

Referenced by CRYPT_AsnDecodeAlgorithmId(), and CRYPT_AsnDecodeAttributeTypeValue().

◆ CRYPT_AsnDecodeInt()

static BOOL WINAPI CRYPT_AsnDecodeInt ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 2187 of file asn.c.

2190{
2191 BOOL ret;
2192 DWORD dataLen;
2193
2194 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2195 {
2196 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2197
2198 if (dataLen > sizeof(int))
2199 {
2200 SetLastError(CRYPT_E_ASN1_LARGE);
2201 ret = FALSE;
2202 }
2203 else if (!pvStructInfo)
2204 *pcbStructInfo = sizeof(int);
2205 else if (*pcbStructInfo < sizeof(int))
2206 {
2207 *pcbStructInfo = sizeof(int);
2208 SetLastError(ERROR_MORE_DATA);
2209 ret = FALSE;
2210 }
2211 else
2212 {
2213 int val;
2214 DWORD i;
2215
2216 *pcbStructInfo = sizeof(int);
2217 if (dataLen && pbEncoded[1 + lenBytes] & 0x80)
2218 {
2219 /* initialize to a negative value to sign-extend */
2220 val = -1;
2221 }
2222 else
2223 val = 0;
2224 for (i = 0; i < dataLen; i++)
2225 {
2226 val <<= 8;
2227 val |= pbEncoded[1 + lenBytes + i];
2228 }
2229 memcpy(pvStructInfo, &val, sizeof(int));
2230 }
2231 }
2232 return ret;
2233}
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
val
GLuint GLfloat * val
Definition: glext.h:7180
CRYPT_E_ASN1_LARGE
#define CRYPT_E_ASN1_LARGE
Definition: winerror.h:4503

Referenced by WVTAsn1CatMemberInfoDecode(), and WVTAsn1CatNameValueDecode().

◆ CRYPT_AsnDecodeOctets()

static BOOL WINAPI CRYPT_AsnDecodeOctets ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 1174 of file asn.c.

1177{
1178 BOOL ret;
1179 DWORD bytesNeeded, dataLen;
1180
1181 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1182 pvStructInfo, *pcbStructInfo);
1183
1184 if (!cbEncoded)
1185 {
1186 SetLastError(CRYPT_E_ASN1_CORRUPT);
1187 ret = FALSE;
1188 }
1189 else if (pbEncoded[0] != ASN_OCTETSTRING)
1190 {
1191 SetLastError(CRYPT_E_ASN1_BADTAG);
1192 ret = FALSE;
1193 }
1194 else if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1195 {
1196 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1197 bytesNeeded = sizeof(CRYPT_DATA_BLOB);
1198 else
1199 bytesNeeded = dataLen + sizeof(CRYPT_DATA_BLOB);
1200 if (!pvStructInfo)
1201 *pcbStructInfo = bytesNeeded;
1202 else if (*pcbStructInfo < bytesNeeded)
1203 {
1204 SetLastError(ERROR_MORE_DATA);
1205 *pcbStructInfo = bytesNeeded;
1206 ret = FALSE;
1207 }
1208 else
1209 {
1210 CRYPT_DATA_BLOB *blob;
1211 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1212
1213 blob = pvStructInfo;
1214 blob->cbData = dataLen;
1215 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
1216 blob->pbData = (BYTE *)pbEncoded + 1 + lenBytes;
1217 else
1218 {
1219 assert(blob->pbData);
1220 if (blob->cbData)
1221 memcpy(blob->pbData, pbEncoded + 1 + lenBytes,
1222 blob->cbData);
1223 }
1224 }
1225 }
1226 return ret;
1227}
ASN_OCTETSTRING
#define ASN_OCTETSTRING
Definition: snmp.h:105

Referenced by CRYPT_AsnDecodeSPCDigest(), CRYPT_AsnDecodeSPCLinkInternal(), and WVTAsn1CatNameValueDecode().

◆ CRYPT_AsnDecodeOid()

static BOOL WINAPI CRYPT_AsnDecodeOid ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 1926 of file asn.c.

1929{
1930 BOOL ret = FALSE;
1931
1932 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1933 pvStructInfo, *pcbStructInfo);
1934
1935 if (!cbEncoded)
1936 SetLastError(CRYPT_E_ASN1_CORRUPT);
1937 else if (pbEncoded[0] == ASN_OBJECTIDENTIFIER)
1938 ret = CRYPT_AsnDecodeOidIgnoreTag(dwCertEncodingType, lpszStructType,
1939 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo);
1940 else
1941 SetLastError(CRYPT_E_ASN1_BADTAG);
1942 return ret;
1943}

Referenced by CRYPT_AsnDecodeAttributeTypeValue().

◆ CRYPT_AsnDecodeOidIgnoreTag()

static BOOL WINAPI CRYPT_AsnDecodeOidIgnoreTag ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 1824 of file asn.c.

1827{
1828 BOOL ret = TRUE;
1829 DWORD dataLen;
1830
1831 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1832 pvStructInfo, *pcbStructInfo);
1833
1834 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1835 {
1836 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1837 DWORD bytesNeeded = sizeof(LPSTR);
1838
1839 if (dataLen)
1840 {
1841 /* The largest possible string for the first two components
1842 * is 2.175 (= 2 * 40 + 175 = 255), so this is big enough.
1843 */
1844 char firstTwo[8];
1845 const BYTE *ptr;
1846
1847 sprintf(firstTwo, "%d.%d",
1848 pbEncoded[1 + lenBytes] / 40,
1849 pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] / 40)
1850 * 40);
1851 bytesNeeded += strlen(firstTwo) + 1;
1852 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1853 ptr - pbEncoded - 1 - lenBytes < dataLen; )
1854 {
1855 /* large enough for ".4000000" */
1856 char str[9];
1857 int val = 0;
1858
1859 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1860 (*ptr & 0x80))
1861 {
1862 val <<= 7;
1863 val |= *ptr & 0x7f;
1864 ptr++;
1865 }
1866 if (ptr - pbEncoded - 1 - lenBytes >= dataLen ||
1867 (*ptr & 0x80))
1868 {
1869 SetLastError(CRYPT_E_ASN1_CORRUPT);
1870 ret = FALSE;
1871 }
1872 else
1873 {
1874 val <<= 7;
1875 val |= *ptr++;
1876 snprintf(str, sizeof(str), ".%d", val);
1877 bytesNeeded += strlen(str);
1878 }
1879 }
1880 }
1881 else
1882 bytesNeeded += 1;
1883 if (!pvStructInfo)
1884 *pcbStructInfo = bytesNeeded;
1885 else if (*pcbStructInfo < bytesNeeded)
1886 {
1887 *pcbStructInfo = bytesNeeded;
1888 SetLastError(ERROR_MORE_DATA);
1889 ret = FALSE;
1890 }
1891 else
1892 {
1893 LPSTR pszObjId = *(LPSTR *)pvStructInfo;
1894
1895 *pszObjId = 0;
1896 if (dataLen)
1897 {
1898 const BYTE *ptr;
1899
1900 pszObjId += sprintf(pszObjId, "%d.%d", pbEncoded[1 + lenBytes] / 40,
1901 pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] /
1902 40) * 40);
1903 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1904 ptr - pbEncoded - 1 - lenBytes < dataLen; )
1905 {
1906 int val = 0;
1907
1908 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1909 (*ptr & 0x80))
1910 {
1911 val <<= 7;
1912 val |= *ptr & 0x7f;
1913 ptr++;
1914 }
1915 val <<= 7;
1916 val |= *ptr++;
1917 pszObjId += sprintf(pszObjId, ".%d", val);
1918 }
1919 }
1920 *pcbStructInfo = bytesNeeded;
1921 }
1922 }
1923 return ret;
1924}
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1592
ptr
static PVOID ptr
Definition: dispmode.c:27
sprintf
#define sprintf
Definition: sprintf.c:45
snprintf
#define snprintf
Definition: wintirpc.h:48

Referenced by CRYPT_AsnDecodeAlgorithmId(), and CRYPT_AsnDecodeOid().

◆ CRYPT_AsnDecodeProgramName()

static BOOL WINAPI CRYPT_AsnDecodeProgramName ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 2127 of file asn.c.

2130{
2131 BOOL ret = FALSE;
2132 DWORD dataLen;
2133
2134 TRACE("(%p, %ld, %08lx, %p, %ld)\n", pbEncoded, cbEncoded, dwFlags,
2135 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
2136
2137 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2138 {
2139 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2140
2141 ret = CRYPT_AsnDecodeBMPString(dwCertEncodingType, lpszStructType,
2142 pbEncoded + 1 + lenBytes, dataLen, dwFlags, pvStructInfo,
2143 pcbStructInfo);
2144 }
2145 return ret;
2146}
CRYPT_AsnDecodeBMPString
static BOOL WINAPI CRYPT_AsnDecodeBMPString(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:2089

Referenced by WVTAsn1SpcSpOpusInfoDecode().

◆ CRYPT_AsnDecodeSequence()

static BOOL CRYPT_AsnDecodeSequence ( DWORD  dwCertEncodingType,
struct AsnDecodeSequenceItem  items[],
DWORD  cItem,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
void *  startingPointer 
)
static

Definition at line 1605 of file asn.c.

1609{
1610 BOOL ret;
1611
1612 TRACE("%p, %ld, %p, %ld, %08lx, %p, %ld, %p\n", items, cItem, pbEncoded,
1613 cbEncoded, dwFlags, pvStructInfo, *pcbStructInfo, startingPointer);
1614
1615 if (pbEncoded[0] == ASN_SEQUENCE)
1616 {
1617 DWORD dataLen;
1618
1619 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1620 {
1621 DWORD lenBytes = GET_LEN_BYTES(pbEncoded[1]), cbDecoded;
1622 const BYTE *ptr = pbEncoded + 1 + lenBytes;
1623
1624 cbEncoded -= 1 + lenBytes;
1625 if (cbEncoded < dataLen)
1626 {
1627 TRACE("dataLen %ld exceeds cbEncoded %ld, failing\n", dataLen,
1628 cbEncoded);
1629 SetLastError(CRYPT_E_ASN1_CORRUPT);
1630 ret = FALSE;
1631 }
1632 else
1633 ret = CRYPT_AsnDecodeSequenceItems(dwFlags, items, cItem, ptr,
1634 cbEncoded, dwFlags, NULL, NULL, &cbDecoded);
1635 if (ret && cbDecoded != dataLen)
1636 {
1637 TRACE("expected %ld decoded, got %ld, failing\n", dataLen,
1638 cbDecoded);
1639 SetLastError(CRYPT_E_ASN1_CORRUPT);
1640 ret = FALSE;
1641 }
1642 if (ret)
1643 {
1644 DWORD i, bytesNeeded = 0, structSize = 0;
1645
1646 for (i = 0; i < cItem; i++)
1647 {
1648 bytesNeeded += items[i].size;
1649 structSize += items[i].minSize;
1650 }
1651 if (!pvStructInfo)
1652 *pcbStructInfo = bytesNeeded;
1653 else if (*pcbStructInfo < bytesNeeded)
1654 {
1655 SetLastError(ERROR_MORE_DATA);
1656 *pcbStructInfo = bytesNeeded;
1657 ret = FALSE;
1658 }
1659 else
1660 {
1661 BYTE *nextData;
1662
1663 *pcbStructInfo = bytesNeeded;
1664 if (startingPointer)
1665 nextData = startingPointer;
1666 else
1667 nextData = (BYTE *)pvStructInfo + structSize;
1668 memset(pvStructInfo, 0, structSize);
1669 ret = CRYPT_AsnDecodeSequenceItems(dwFlags, items, cItem,
1670 ptr, cbEncoded, dwFlags, pvStructInfo, nextData,
1671 &cbDecoded);
1672 }
1673 }
1674 }
1675 }
1676 else
1677 {
1678 SetLastError(CRYPT_E_ASN1_BADTAG);
1679 ret = FALSE;
1680 }
1681 TRACE("returning %d (%08lx)\n", ret, GetLastError());
1682 return ret;
1683}
CRYPT_AsnDecodeSequenceItems
static BOOL CRYPT_AsnDecodeSequenceItems(DWORD dwCertEncodingType, struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, BYTE *nextData, DWORD *cbDecoded)
Definition: asn.c:1484
ASN_SEQUENCE
#define ASN_SEQUENCE
Definition: snmp.h:110
memset
#define memset(x, y, z)
Definition: compat.h:39

Referenced by CRYPT_AsnDecodeAlgorithmId(), CRYPT_AsnDecodeAttributeTypeValue(), CRYPT_AsnDecodeSPCDigest(), WVTAsn1CatMemberInfoDecode(), WVTAsn1CatNameValueDecode(), WVTAsn1SpcFinancialCriteriaInfoDecode(), WVTAsn1SpcIndirectDataContentDecode(), WVTAsn1SpcPeImageDataDecode(), and WVTAsn1SpcSpOpusInfoDecode().

◆ CRYPT_AsnDecodeSequenceItems()

static BOOL CRYPT_AsnDecodeSequenceItems ( DWORD  dwCertEncodingType,
struct AsnDecodeSequenceItem  items[],
DWORD  cItem,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
BYTE *  nextData,
DWORD *  cbDecoded 
)
static

Definition at line 1484 of file asn.c.

1488{
1489 BOOL ret;
1490 DWORD i, decoded = 0;
1491 const BYTE *ptr = pbEncoded;
1492
1493 TRACE("%p, %ld, %p, %ld, %08lx, %p, %p, %p\n", items, cItem, pbEncoded,
1494 cbEncoded, dwFlags, pvStructInfo, nextData, cbDecoded);
1495
1496 for (i = 0, ret = TRUE; ret && i < cItem; i++)
1497 {
1498 if (cbEncoded - (ptr - pbEncoded) != 0)
1499 {
1500 DWORD nextItemLen;
1501
1502 if ((ret = CRYPT_GetLen(ptr, cbEncoded - (ptr - pbEncoded),
1503 &nextItemLen)))
1504 {
1505 BYTE nextItemLenBytes = GET_LEN_BYTES(ptr[1]);
1506
1507 if (ptr[0] == items[i].tag || !items[i].tag)
1508 {
1509 if (nextData && pvStructInfo && items[i].hasPointer)
1510 {
1511 TRACE("Setting next pointer to %p\n",
1512 nextData);
1513 *(BYTE **)((BYTE *)pvStructInfo +
1514 items[i].pointerOffset) = nextData;
1515 }
1516 if (items[i].decodeFunc)
1517 {
1518 if (pvStructInfo)
1519 TRACE("decoding item %ld\n", i);
1520 else
1521 TRACE("sizing item %ld\n", i);
1522 ret = items[i].decodeFunc(dwCertEncodingType,
1523 NULL, ptr, 1 + nextItemLenBytes + nextItemLen,
1524 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
1525 pvStructInfo ? (BYTE *)pvStructInfo + items[i].offset
1526 : NULL, &items[i].size);
1527 if (ret)
1528 {
1529 if (items[i].size < items[i].minSize)
1530 items[i].size = items[i].minSize;
1531 else if (items[i].size > items[i].minSize)
1532 {
1533 /* Account for alignment padding */
1534 items[i].size = ALIGN_DWORD_PTR(items[i].size);
1535 }
1536 TRACE("item %ld size: %ld\n", i, items[i].size);
1537 if (nextData && items[i].hasPointer &&
1538 items[i].size > items[i].minSize)
1539 nextData += items[i].size - items[i].minSize;
1540 ptr += 1 + nextItemLenBytes + nextItemLen;
1541 decoded += 1 + nextItemLenBytes + nextItemLen;
1542 TRACE("item %ld: decoded %ld bytes\n", i,
1543 1 + nextItemLenBytes + nextItemLen);
1544 }
1545 else if (items[i].optional &&
1546 GetLastError() == CRYPT_E_ASN1_BADTAG)
1547 {
1548 TRACE("skipping optional item %ld\n", i);
1549 items[i].size = items[i].minSize;
1550 SetLastError(NOERROR);
1551 ret = TRUE;
1552 }
1553 else
1554 TRACE("item %ld failed: %08lx\n", i,
1555 GetLastError());
1556 }
1557 else
1558 {
1559 TRACE("item %ld: decoded %ld bytes\n", i,
1560 1 + nextItemLenBytes + nextItemLen);
1561 ptr += 1 + nextItemLenBytes + nextItemLen;
1562 decoded += 1 + nextItemLenBytes + nextItemLen;
1563 items[i].size = items[i].minSize;
1564 }
1565 }
1566 else if (items[i].optional)
1567 {
1568 TRACE("skipping optional item %ld\n", i);
1569 items[i].size = items[i].minSize;
1570 }
1571 else
1572 {
1573 TRACE("item %ld: tag %02x doesn't match expected %02x\n",
1574 i, ptr[0], items[i].tag);
1575 SetLastError(CRYPT_E_ASN1_BADTAG);
1576 ret = FALSE;
1577 }
1578 }
1579 }
1580 else if (items[i].optional)
1581 {
1582 TRACE("missing optional item %ld, skipping\n", i);
1583 items[i].size = items[i].minSize;
1584 }
1585 else
1586 {
1587 TRACE("not enough bytes for item %ld, failing\n", i);
1588 SetLastError(CRYPT_E_ASN1_CORRUPT);
1589 ret = FALSE;
1590 }
1591 }
1592 if (ret)
1593 *cbDecoded = decoded;
1594 TRACE("returning %d\n", ret);
1595 return ret;
1596}
optional
@ optional
Definition: SystemMenu.c:34
ALIGN_DWORD_PTR
#define ALIGN_DWORD_PTR(x)
Definition: asn.c:1471
size
GLsizeiptr size
Definition: glext.h:5919
offset
GLintptr offset
Definition: glext.h:5920
tag
Definition: ecma_167.h:138
CRYPT_DECODE_ALLOC_FLAG
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3612
NOERROR
#define NOERROR
Definition: winerror.h:3448

Referenced by CRYPT_AsnDecodeSequence().

◆ CRYPT_AsnDecodeSPCDigest()

static BOOL WINAPI CRYPT_AsnDecodeSPCDigest ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 2032 of file asn.c.

2035{
2036 struct SPCDigest *digest = pvStructInfo;
2037 struct AsnDecodeSequenceItem items[] = {
2038 { ASN_SEQUENCEOF, offsetof(struct SPCDigest, DigestAlgorithm),
2039 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2040 FALSE, TRUE,
2041 offsetof(struct SPCDigest, DigestAlgorithm.pszObjId), 0 },
2042 { ASN_OCTETSTRING, offsetof(struct SPCDigest, Digest),
2043 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB),
2044 FALSE, TRUE, offsetof(struct SPCDigest, Digest.pbData), 0 },
2045 };
2046
2047 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2048 pvStructInfo, *pcbStructInfo);
2049
2050 return CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items),
2051 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo,
2052 digest ? digest->DigestAlgorithm.pszObjId : NULL);
2053}
CRYPT_AsnDecodeAlgorithmId
static BOOL WINAPI CRYPT_AsnDecodeAlgorithmId(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:2004
CRYPT_AsnDecodeOctets
static BOOL WINAPI CRYPT_AsnDecodeOctets(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:1174
ASN_SEQUENCEOF
#define ASN_SEQUENCEOF
Definition: snmp.h:111
SPCDigest
Definition: asn.c:697
SPCDigest::DigestAlgorithm
CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm
Definition: asn.c:698
CRYPT_DER_BLOB
struct _CRYPTOAPI_BLOB CRYPT_DER_BLOB
CRYPT_ALGORITHM_IDENTIFIER
struct _CRYPT_ALGORITHM_IDENTIFIER CRYPT_ALGORITHM_IDENTIFIER

Referenced by WVTAsn1SpcIndirectDataContentDecode().

◆ CRYPT_AsnDecodeSPCLinkInternal()

static BOOL CRYPT_AsnDecodeSPCLinkInternal ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 1229 of file asn.c.

1232{
1233 BOOL ret = FALSE;
1234 DWORD bytesNeeded = sizeof(SPC_LINK), dataLen;
1235
1236 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1237 pvStructInfo, *pcbStructInfo);
1238
1239 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1240 {
1241 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1242 DWORD realDataLen;
1243
1244 switch (pbEncoded[0])
1245 {
1246 case ASN_CONTEXT:
1247 bytesNeeded += (dataLen + 1) * sizeof(WCHAR);
1248 if (!pvStructInfo)
1249 *pcbStructInfo = bytesNeeded;
1250 else if (*pcbStructInfo < bytesNeeded)
1251 {
1252 *pcbStructInfo = bytesNeeded;
1253 SetLastError(ERROR_MORE_DATA);
1254 ret = FALSE;
1255 }
1256 else
1257 {
1258 PSPC_LINK link = pvStructInfo;
1259 DWORD i;
1260
1261 link->dwLinkChoice = SPC_URL_LINK_CHOICE;
1262 for (i = 0; i < dataLen; i++)
1263 link->pwszUrl[i] =
1264 *(pbEncoded + 1 + lenBytes + i);
1265 link->pwszUrl[i] = '\0';
1266 TRACE("returning url %s\n", debugstr_w(link->pwszUrl));
1267 }
1268 break;
1269 case ASN_CONSTRUCTOR | ASN_CONTEXT | 1:
1270 {
1271 CRYPT_DATA_BLOB classId;
1272 DWORD size = sizeof(classId);
1273
1274 if ((ret = CRYPT_AsnDecodeOctets(dwCertEncodingType, NULL,
1275 pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
1276 CRYPT_DECODE_NOCOPY_FLAG, &classId, &size)))
1277 {
1278 if (classId.cbData != sizeof(SPC_UUID))
1279 {
1280 SetLastError(CRYPT_E_BAD_ENCODE);
1281 ret = FALSE;
1282 }
1283 else
1284 {
1285 CRYPT_DATA_BLOB data;
1286
1287 /* The tag length for the classId must be 1 since the
1288 * length is correct.
1289 */
1290 size = sizeof(data);
1291 if ((ret = CRYPT_AsnDecodeOctets(dwCertEncodingType, NULL,
1292 pbEncoded + 3 + lenBytes + classId.cbData,
1293 cbEncoded - 3 - lenBytes - classId.cbData,
1294 CRYPT_DECODE_NOCOPY_FLAG, &data, &size)))
1295 {
1296 bytesNeeded += data.cbData;
1297 if (!pvStructInfo)
1298 *pcbStructInfo = bytesNeeded;
1299 else if (*pcbStructInfo < bytesNeeded)
1300 {
1301 *pcbStructInfo = bytesNeeded;
1302 SetLastError(ERROR_MORE_DATA);
1303 ret = FALSE;
1304 }
1305 else
1306 {
1307 PSPC_LINK link = pvStructInfo;
1308
1309 link->dwLinkChoice = SPC_MONIKER_LINK_CHOICE;
1310 /* pwszFile pointer was set by caller, copy it
1311 * before overwriting it
1312 */
1313 link->Moniker.SerializedData.pbData =
1314 (BYTE *)link->pwszFile;
1315 memcpy(link->Moniker.ClassId, classId.pbData,
1316 classId.cbData);
1317 memcpy(link->Moniker.SerializedData.pbData,
1318 data.pbData, data.cbData);
1319 link->Moniker.SerializedData.cbData = data.cbData;
1320 }
1321 }
1322 }
1323 }
1324 break;
1325 }
1326 case ASN_CONSTRUCTOR | ASN_CONTEXT | 2:
1327 if (dataLen && pbEncoded[1 + lenBytes] != ASN_CONTEXT)
1328 SetLastError(CRYPT_E_ASN1_BADTAG);
1329 else if ((ret = CRYPT_GetLen(pbEncoded + 1 + lenBytes, dataLen,
1330 &realDataLen)))
1331 {
1332 BYTE realLenBytes = GET_LEN_BYTES(pbEncoded[2 + lenBytes]);
1333
1334 bytesNeeded += realDataLen + sizeof(WCHAR);
1335 if (!pvStructInfo)
1336 *pcbStructInfo = bytesNeeded;
1337 else if (*pcbStructInfo < bytesNeeded)
1338 {
1339 *pcbStructInfo = bytesNeeded;
1340 SetLastError(ERROR_MORE_DATA);
1341 ret = FALSE;
1342 }
1343 else
1344 {
1345 PSPC_LINK link = pvStructInfo;
1346 DWORD i;
1347 const BYTE *ptr = pbEncoded + 2 + lenBytes + realLenBytes;
1348
1349 link->dwLinkChoice = SPC_FILE_LINK_CHOICE;
1350 for (i = 0; i < dataLen / sizeof(WCHAR); i++)
1351 link->pwszFile[i] =
1352 hton16(*(const WORD *)(ptr + i * sizeof(WCHAR)));
1353 link->pwszFile[realDataLen / sizeof(WCHAR)] = '\0';
1354 TRACE("returning file %s\n", debugstr_w(link->pwszFile));
1355 }
1356 }
1357 else
1358 {
1359 bytesNeeded += sizeof(WCHAR);
1360 if (!pvStructInfo)
1361 *pcbStructInfo = bytesNeeded;
1362 else if (*pcbStructInfo < bytesNeeded)
1363 {
1364 *pcbStructInfo = bytesNeeded;
1365 SetLastError(ERROR_MORE_DATA);
1366 ret = FALSE;
1367 }
1368 else
1369 {
1370 PSPC_LINK link = pvStructInfo;
1371
1372 link->dwLinkChoice = SPC_FILE_LINK_CHOICE;
1373 link->pwszFile[0] = '\0';
1374 ret = TRUE;
1375 }
1376 }
1377 break;
1378 default:
1379 SetLastError(CRYPT_E_ASN1_BADTAG);
1380 }
1381 }
1382 TRACE("returning %d\n", ret);
1383 return ret;
1384}
link
const WCHAR * link
Definition: db.cpp:998
hton16
#define hton16(x)
Definition: asn.c:44
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
ASN_CONSTRUCTOR
#define ASN_CONSTRUCTOR
Definition: snmp.h:92
ASN_CONTEXT
#define ASN_CONTEXT
Definition: snmp.h:89
SPC_LINK_
Definition: wintrust.h:539
_CRYPTOAPI_BLOB::cbData
DWORD cbData
Definition: wincrypt.h:111
_CRYPTOAPI_BLOB::pbData
BYTE * pbData
Definition: wincrypt.h:112
CRYPT_E_BAD_ENCODE
#define CRYPT_E_BAD_ENCODE
Definition: winerror.h:4419
SPC_UUID
BYTE SPC_UUID[SPC_UUID_LENGTH]
Definition: wintrust.h:515
SPC_LINK
struct SPC_LINK_ SPC_LINK
SPC_FILE_LINK_CHOICE
#define SPC_FILE_LINK_CHOICE
Definition: wintrust.h:536
SPC_MONIKER_LINK_CHOICE
#define SPC_MONIKER_LINK_CHOICE
Definition: wintrust.h:535
SPC_URL_LINK_CHOICE
#define SPC_URL_LINK_CHOICE
Definition: wintrust.h:534
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by CRYPT_AsnDecodeSPCLinkPointer(), and WVTAsn1SpcLinkDecode().

◆ CRYPT_AsnDecodeSPCLinkPointer()

static BOOL WINAPI CRYPT_AsnDecodeSPCLinkPointer ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)
static

Definition at line 1749 of file asn.c.

1752{
1753 BOOL ret = FALSE;
1754 DWORD dataLen;
1755
1756 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1757 {
1758 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1759 DWORD size;
1760 SPC_LINK **pLink = pvStructInfo;
1761
1762 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType, lpszStructType,
1763 pbEncoded + 1 + lenBytes, dataLen, dwFlags, NULL, &size);
1764 if (ret)
1765 {
1766 if (!pvStructInfo)
1767 *pcbStructInfo = size + sizeof(PSPC_LINK);
1768 else if (*pcbStructInfo < size + sizeof(PSPC_LINK))
1769 {
1770 *pcbStructInfo = size + sizeof(PSPC_LINK);
1771 SetLastError(ERROR_MORE_DATA);
1772 ret = FALSE;
1773 }
1774 else
1775 {
1776 *pcbStructInfo = size + sizeof(PSPC_LINK);
1777 /* Set imageData's pointer if necessary */
1778 if (size > sizeof(SPC_LINK))
1779 {
1780 (*pLink)->pwszUrl =
1781 (LPWSTR)((BYTE *)*pLink + sizeof(SPC_LINK));
1782 }
1783 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1784 lpszStructType, pbEncoded + 1 + lenBytes, dataLen, dwFlags,
1785 *pLink, pcbStructInfo);
1786 }
1787 }
1788 }
1789 return ret;
1790}
CRYPT_AsnDecodeSPCLinkInternal
static BOOL CRYPT_AsnDecodeSPCLinkInternal(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:1229
PSPC_LINK
struct SPC_LINK_ * PSPC_LINK

Referenced by WVTAsn1SpcPeImageDataDecode(), and WVTAsn1SpcSpOpusInfoDecode().

◆ CRYPT_AsnEncodeAlgorithmIdWithNullParams()

static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 656 of file asn.c.

659{
660 const CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
661 static const BYTE asn1Null[] = { ASN_NULL, 0 };
662 static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null),
663 (LPBYTE)asn1Null };
664 BOOL ret;
665 struct AsnEncodeSequenceItem items[2] = {
666 { algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
667 { NULL, CRYPT_CopyEncodedBlob, 0 },
668 };
669 DWORD cItem = 2;
670
671 if (algo->Parameters.cbData)
672 items[1].pvStructInfo = &algo->Parameters;
673 else if (algo->pszObjId)
674 items[1].pvStructInfo = &nullBlob;
675 else
676 cItem -= 1;
677 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
678 pbEncoded, pcbEncoded);
679 return ret;
680}
CRYPT_AsnEncodeSequence
static BOOL CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType, struct AsnEncodeSequenceItem items[], DWORD cItem, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:292
CRYPT_AsnEncodeOid
static BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:513
CRYPT_CopyEncodedBlob
static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:631
ASN_NULL
#define ASN_NULL
Definition: snmp.h:106
_CRYPT_ALGORITHM_IDENTIFIER::Parameters
CRYPT_OBJID_BLOB Parameters
Definition: wincrypt.h:136

Referenced by CRYPT_AsnEncodeSPCDigest().

◆ CRYPT_AsnEncodeAttributeTypeValue()

static BOOL WINAPI CRYPT_AsnEncodeAttributeTypeValue ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 682 of file asn.c.

685{
686 const CRYPT_ATTRIBUTE_TYPE_VALUE *typeValue = pvStructInfo;
687 struct AsnEncodeSequenceItem items[] = {
688 { typeValue->pszObjId, CRYPT_AsnEncodeOid, 0 },
689 { &typeValue->Value, CRYPT_CopyEncodedBlob, 0 },
690 };
691
692 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items),
693 pbEncoded, pcbEncoded);
694}
_CRYPT_ATTRIBUTE_TYPE_VALUE::Value
CRYPT_OBJID_BLOB Value
Definition: wincrypt.h:141
X509_ASN_ENCODING
#define X509_ASN_ENCODING
Definition: wincrypt.h:2501

Referenced by WVTAsn1SpcIndirectDataContentEncode().

◆ CRYPT_AsnEncodeBits()

static BOOL WINAPI CRYPT_AsnEncodeBits ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 344 of file asn.c.

347{
348 BOOL ret = FALSE;
349
350 __TRY
351 {
352 const CRYPT_BIT_BLOB *blob = pvStructInfo;
353 DWORD bytesNeeded, lenBytes, dataBytes;
354 BYTE unusedBits;
355
356 /* yep, MS allows cUnusedBits to be >= 8 */
357 if (!blob->cUnusedBits)
358 {
359 dataBytes = blob->cbData;
360 unusedBits = 0;
361 }
362 else if (blob->cbData * 8 > blob->cUnusedBits)
363 {
364 dataBytes = (blob->cbData * 8 - blob->cUnusedBits) / 8 + 1;
365 unusedBits = blob->cUnusedBits >= 8 ? blob->cUnusedBits / 8 :
366 blob->cUnusedBits;
367 }
368 else
369 {
370 dataBytes = 0;
371 unusedBits = 0;
372 }
373 CRYPT_EncodeLen(dataBytes + 1, NULL, &lenBytes);
374 bytesNeeded = 1 + lenBytes + dataBytes + 1;
375 if (!pbEncoded)
376 {
377 *pcbEncoded = bytesNeeded;
378 ret = TRUE;
379 }
380 else if (*pcbEncoded < bytesNeeded)
381 {
382 *pcbEncoded = bytesNeeded;
383 SetLastError(ERROR_MORE_DATA);
384 }
385 else
386 {
387 ret = TRUE;
388 *pcbEncoded = bytesNeeded;
389 *pbEncoded++ = ASN_BITSTRING;
390 CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes);
391 pbEncoded += lenBytes;
392 *pbEncoded++ = unusedBits;
393 if (dataBytes)
394 {
395 BYTE mask = 0xff << unusedBits;
396
397 if (dataBytes > 1)
398 {
399 memcpy(pbEncoded, blob->pbData, dataBytes - 1);
400 pbEncoded += dataBytes - 1;
401 }
402 *pbEncoded = *(blob->pbData + dataBytes - 1) & mask;
403 }
404 }
405 }
406 __EXCEPT_PAGE_FAULT
407 {
408 SetLastError(STATUS_ACCESS_VIOLATION);
409 }
410 __ENDTRY
411 return ret;
412}
__TRY
#define __TRY
Definition: compat.h:80
__ENDTRY
#define __ENDTRY
Definition: compat.h:82
__EXCEPT_PAGE_FAULT
#define __EXCEPT_PAGE_FAULT
Definition: compat.h:81
CRYPT_EncodeLen
static BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:53
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: fpEnumPrinters.c:23

Referenced by WVTAsn1SpcPeImageDataEncode().

◆ CRYPT_AsnEncodeBMPString()

static BOOL WINAPI CRYPT_AsnEncodeBMPString ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 744 of file asn.c.

747{
748 BOOL ret = TRUE;
749 LPCWSTR str = pvStructInfo;
750 DWORD bytesNeeded, lenBytes, strLen;
751
752 if (str)
753 strLen = lstrlenW(str);
754 else
755 strLen = 0;
756 CRYPT_EncodeLen(strLen * 2, NULL, &lenBytes);
757 bytesNeeded = 1 + lenBytes + strLen * 2;
758 if (!pbEncoded)
759 *pcbEncoded = bytesNeeded;
760 else if (*pcbEncoded < bytesNeeded)
761 {
762 *pcbEncoded = bytesNeeded;
763 SetLastError(ERROR_MORE_DATA);
764 ret = FALSE;
765 }
766 else
767 {
768 DWORD i;
769
770 *pcbEncoded = bytesNeeded;
771 *pbEncoded++ = ASN_BMPSTRING;
772 CRYPT_EncodeLen(strLen * 2, pbEncoded, &lenBytes);
773 pbEncoded += lenBytes;
774 for (i = 0; i < strLen; i++)
775 {
776 *pbEncoded++ = (str[i] & 0xff00) >> 8;
777 *pbEncoded++ = str[i] & 0x00ff;
778 }
779 }
780 return ret;
781}
lstrlenW
#define lstrlenW
Definition: compat.h:750
ASN_BMPSTRING
#define ASN_BMPSTRING
Definition: asn.c:51
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

Referenced by WVTAsn1CatMemberInfoEncode(), WVTAsn1CatNameValueEncode(), and WVTAsn1SpcSpOpusInfoEncode().

◆ CRYPT_AsnEncodeBool()

static BOOL WINAPI CRYPT_AsnEncodeBool ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 1040 of file asn.c.

1043{
1044 BOOL val = *(const BOOL *)pvStructInfo, ret;
1045
1046 TRACE("%d\n", val);
1047
1048 if (!pbEncoded)
1049 {
1050 *pcbEncoded = 3;
1051 ret = TRUE;
1052 }
1053 else if (*pcbEncoded < 3)
1054 {
1055 *pcbEncoded = 3;
1056 SetLastError(ERROR_MORE_DATA);
1057 ret = FALSE;
1058 }
1059 else
1060 {
1061 *pcbEncoded = 3;
1062 *pbEncoded++ = ASN_BOOL;
1063 *pbEncoded++ = 1;
1064 *pbEncoded++ = val ? 0xff : 0;
1065 ret = TRUE;
1066 }
1067 TRACE("returning %d (%08lx)\n", ret, GetLastError());
1068 return ret;
1069}
ASN_BOOL
#define ASN_BOOL
Definition: asn.c:49

Referenced by WVTAsn1SpcFinancialCriteriaInfoEncode().

◆ CRYPT_AsnEncodeConstructed()

static BOOL WINAPI CRYPT_AsnEncodeConstructed ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 421 of file asn.c.

424{
425 BOOL ret;
426 const struct AsnConstructedItem *item = pvStructInfo;
427 DWORD len;
428
429 if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
430 item->pvStructInfo, NULL, &len)))
431 {
432 DWORD dataLen, bytesNeeded;
433
434 CRYPT_EncodeLen(len, NULL, &dataLen);
435 bytesNeeded = 1 + dataLen + len;
436 if (!pbEncoded)
437 *pcbEncoded = bytesNeeded;
438 else if (*pcbEncoded < bytesNeeded)
439 {
440 *pcbEncoded = bytesNeeded;
441 SetLastError(ERROR_MORE_DATA);
442 ret = FALSE;
443 }
444 else
445 {
446 *pcbEncoded = bytesNeeded;
447 *pbEncoded++ = ASN_CONTEXT | ASN_CONSTRUCTOR | item->tag;
448 CRYPT_EncodeLen(len, pbEncoded, &dataLen);
449 pbEncoded += dataLen;
450 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
451 item->pvStructInfo, pbEncoded, &len);
452 if (!ret)
453 {
454 /* Some functions propagate their errors through the size */
455 *pcbEncoded = len;
456 }
457 }
458 }
459 else
460 {
461 /* Some functions propagate their errors through the size */
462 *pcbEncoded = len;
463 }
464 return ret;
465}
len
GLenum GLsizei len
Definition: glext.h:6722
AsnConstructedItem::pvStructInfo
const void * pvStructInfo
Definition: crypt32_private.h:62

Referenced by WVTAsn1SpcPeImageDataEncode(), and WVTAsn1SpcSpOpusInfoEncode().

◆ CRYPT_AsnEncodeInt()

static BOOL WINAPI CRYPT_AsnEncodeInt ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 973 of file asn.c.

976{
977 CRYPT_INTEGER_BLOB blob = { sizeof(INT), (BYTE *)pvStructInfo };
978
979 return CRYPT_AsnEncodeInteger(dwCertEncodingType, X509_MULTI_BYTE_INTEGER,
980 &blob, pbEncoded, pcbEncoded);
981}
CRYPT_AsnEncodeInteger
static BOOL CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:883
INT
#define INT
Definition: polytest.cpp:20
X509_MULTI_BYTE_INTEGER
#define X509_MULTI_BYTE_INTEGER
Definition: wincrypt.h:3546

Referenced by WVTAsn1CatMemberInfoEncode(), and WVTAsn1CatNameValueEncode().

◆ CRYPT_AsnEncodeInteger()

static BOOL CRYPT_AsnEncodeInteger ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 883 of file asn.c.

886{
887 BOOL ret;
888
889 __TRY
890 {
891 DWORD significantBytes, lenBytes, bytesNeeded;
892 BYTE padByte = 0;
893 BOOL pad = FALSE;
894 const CRYPT_INTEGER_BLOB *blob = pvStructInfo;
895
896 significantBytes = blob->cbData;
897 if (significantBytes)
898 {
899 if (blob->pbData[significantBytes - 1] & 0x80)
900 {
901 /* negative, lop off leading (little-endian) 0xffs */
902 for (; significantBytes > 0 &&
903 blob->pbData[significantBytes - 1] == 0xff; significantBytes--)
904 ;
905 if (blob->pbData[significantBytes - 1] < 0x80)
906 {
907 padByte = 0xff;
908 pad = TRUE;
909 }
910 }
911 else
912 {
913 /* positive, lop off leading (little-endian) zeroes */
914 for (; significantBytes > 0 &&
915 !blob->pbData[significantBytes - 1]; significantBytes--)
916 ;
917 if (significantBytes == 0)
918 significantBytes = 1;
919 if (blob->pbData[significantBytes - 1] > 0x7f)
920 {
921 padByte = 0;
922 pad = TRUE;
923 }
924 }
925 }
926 if (pad)
927 CRYPT_EncodeLen(significantBytes + 1, NULL, &lenBytes);
928 else
929 CRYPT_EncodeLen(significantBytes, NULL, &lenBytes);
930 bytesNeeded = 1 + lenBytes + significantBytes;
931 if (pad)
932 bytesNeeded++;
933 if (!pbEncoded)
934 {
935 *pcbEncoded = bytesNeeded;
936 ret = TRUE;
937 }
938 else if (*pcbEncoded < bytesNeeded)
939 {
940 *pcbEncoded = bytesNeeded;
941 SetLastError(ERROR_MORE_DATA);
942 ret = FALSE;
943 }
944 else
945 {
946 *pcbEncoded = bytesNeeded;
947 *pbEncoded++ = ASN_INTEGER;
948 if (pad)
949 {
950 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
951 pbEncoded += lenBytes;
952 *pbEncoded++ = padByte;
953 }
954 else
955 {
956 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
957 pbEncoded += lenBytes;
958 }
959 for (; significantBytes > 0; significantBytes--)
960 *(pbEncoded++) = blob->pbData[significantBytes - 1];
961 ret = TRUE;
962 }
963 }
964 __EXCEPT_PAGE_FAULT
965 {
966 SetLastError(STATUS_ACCESS_VIOLATION);
967 ret = FALSE;
968 }
969 __ENDTRY
970 return ret;
971}
ASN_INTEGER
#define ASN_INTEGER
Definition: snmp.h:103

Referenced by CRYPT_AsnEncodeInt().

◆ CRYPT_AsnEncodeOctets()

static BOOL WINAPI CRYPT_AsnEncodeOctets ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 95 of file asn.c.

98{
99 BOOL ret = TRUE;
100 const CRYPT_DATA_BLOB *blob = pvStructInfo;
101 DWORD bytesNeeded, lenBytes;
102
103 TRACE("(%ld, %p), %p, %ld\n", blob->cbData, blob->pbData, pbEncoded,
104 *pcbEncoded);
105
106 CRYPT_EncodeLen(blob->cbData, NULL, &lenBytes);
107 bytesNeeded = 1 + lenBytes + blob->cbData;
108 if (!pbEncoded)
109 *pcbEncoded = bytesNeeded;
110 else if (*pcbEncoded < bytesNeeded)
111 {
112 *pcbEncoded = bytesNeeded;
113 SetLastError(ERROR_MORE_DATA);
114 ret = FALSE;
115 }
116 else
117 {
118 *pbEncoded++ = ASN_OCTETSTRING;
119 CRYPT_EncodeLen(blob->cbData, pbEncoded, &lenBytes);
120 pbEncoded += lenBytes;
121 if (blob->cbData)
122 memcpy(pbEncoded, blob->pbData, blob->cbData);
123 }
124 TRACE("returning %d\n", ret);
125 return ret;
126}

Referenced by CRYPT_AsnEncodeSPCDigest(), WVTAsn1CatNameValueEncode(), and WVTAsn1SpcLinkEncode().

◆ CRYPT_AsnEncodeOid()

static BOOL WINAPI CRYPT_AsnEncodeOid ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 513 of file asn.c.

516{
517 LPCSTR pszObjId = pvStructInfo;
518 DWORD bytesNeeded = 0, lenBytes;
519 BOOL ret = TRUE;
520 int firstPos = 0;
521 BYTE firstByte = 0;
522
523 TRACE("%s\n", debugstr_a(pszObjId));
524
525 if (pszObjId)
526 {
527 const char *ptr;
528 int val1, val2;
529
530 if (sscanf(pszObjId, "%d.%d%n", &val1, &val2, &firstPos) != 2)
531 {
532 SetLastError(CRYPT_E_ASN1_ERROR);
533 return FALSE;
534 }
535 bytesNeeded++;
536 firstByte = val1 * 40 + val2;
537 ptr = pszObjId + firstPos;
538 if (*ptr == '.')
539 {
540 ptr++;
541 firstPos++;
542 }
543 while (ret && *ptr)
544 {
545 int pos;
546
547 /* note I assume each component is at most 32-bits long in base 2 */
548 if (sscanf(ptr, "%d%n", &val1, &pos) == 1)
549 {
550 if (val1 >= 0x10000000)
551 bytesNeeded += 5;
552 else if (val1 >= 0x200000)
553 bytesNeeded += 4;
554 else if (val1 >= 0x4000)
555 bytesNeeded += 3;
556 else if (val1 >= 0x80)
557 bytesNeeded += 2;
558 else
559 bytesNeeded += 1;
560 ptr += pos;
561 if (*ptr == '.')
562 ptr++;
563 }
564 else
565 {
566 SetLastError(CRYPT_E_ASN1_ERROR);
567 return FALSE;
568 }
569 }
570 CRYPT_EncodeLen(bytesNeeded, NULL, &lenBytes);
571 }
572 else
573 lenBytes = 1;
574 bytesNeeded += 1 + lenBytes;
575 if (pbEncoded)
576 {
577 if (*pcbEncoded < bytesNeeded)
578 {
579 SetLastError(ERROR_MORE_DATA);
580 ret = FALSE;
581 }
582 else
583 {
584 *pbEncoded++ = ASN_OBJECTIDENTIFIER;
585 CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes);
586 pbEncoded += lenBytes;
587 if (pszObjId)
588 {
589 const char *ptr;
590 int val, pos;
591
592 *pbEncoded++ = firstByte;
593 ptr = pszObjId + firstPos;
594 while (ret && *ptr)
595 {
596 sscanf(ptr, "%d%n", &val, &pos);
597 {
598 unsigned char outBytes[5];
599 int numBytes, i;
600
601 if (val >= 0x10000000)
602 numBytes = 5;
603 else if (val >= 0x200000)
604 numBytes = 4;
605 else if (val >= 0x4000)
606 numBytes = 3;
607 else if (val >= 0x80)
608 numBytes = 2;
609 else
610 numBytes = 1;
611 for (i = numBytes; i > 0; i--)
612 {
613 outBytes[i - 1] = val & 0x7f;
614 val >>= 7;
615 }
616 for (i = 0; i < numBytes - 1; i++)
617 *pbEncoded++ = outBytes[i] | 0x80;
618 *pbEncoded++ = outBytes[i];
619 ptr += pos;
620 if (*ptr == '.')
621 ptr++;
622 }
623 }
624 }
625 }
626 }
627 *pcbEncoded = bytesNeeded;
628 return ret;
629}
sscanf
_ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl sscanf(const char *, const char *,...) __WINE_CRT_SCANF_ATTR(2
CRYPT_E_ASN1_ERROR
#define CRYPT_E_ASN1_ERROR
Definition: winerror.h:4499
LPCSTR
const char * LPCSTR
Definition: xmlstorage.h:183

Referenced by CRYPT_AsnEncodeAlgorithmIdWithNullParams(), and CRYPT_AsnEncodeAttributeTypeValue().

◆ CRYPT_AsnEncodeSequence()

static BOOL CRYPT_AsnEncodeSequence ( DWORD  dwCertEncodingType,
struct AsnEncodeSequenceItem  items[],
DWORD  cItem,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 292 of file asn.c.

295{
296 BOOL ret;
297 DWORD i, dataLen = 0;
298
299 TRACE("%p, %ld, %p, %ld\n", items, cItem, pbEncoded, *pcbEncoded);
300 for (i = 0, ret = TRUE; ret && i < cItem; i++)
301 {
302 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
303 items[i].pvStructInfo, NULL, &items[i].size);
304 /* Some functions propagate their errors through the size */
305 if (!ret)
306 *pcbEncoded = items[i].size;
307 dataLen += items[i].size;
308 }
309 if (ret)
310 {
311 DWORD lenBytes, bytesNeeded;
312
313 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
314 bytesNeeded = 1 + lenBytes + dataLen;
315 if (!pbEncoded)
316 *pcbEncoded = bytesNeeded;
317 else if (*pcbEncoded < bytesNeeded)
318 {
319 *pcbEncoded = bytesNeeded;
320 SetLastError(ERROR_MORE_DATA);
321 ret = FALSE;
322 }
323 else
324 {
325 *pcbEncoded = bytesNeeded;
326 *pbEncoded++ = ASN_SEQUENCE;
327 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
328 pbEncoded += lenBytes;
329 for (i = 0; ret && i < cItem; i++)
330 {
331 ret = items[i].encodeFunc(dwCertEncodingType, NULL,
332 items[i].pvStructInfo, pbEncoded, &items[i].size);
333 /* Some functions propagate their errors through the size */
334 if (!ret)
335 *pcbEncoded = items[i].size;
336 pbEncoded += items[i].size;
337 }
338 }
339 }
340 TRACE("returning %d\n", ret);
341 return ret;
342}

Referenced by CRYPT_AsnEncodeAlgorithmIdWithNullParams(), CRYPT_AsnEncodeAttributeTypeValue(), CRYPT_AsnEncodeSPCDigest(), WVTAsn1CatMemberInfoEncode(), WVTAsn1CatNameValueEncode(), WVTAsn1SpcFinancialCriteriaInfoEncode(), WVTAsn1SpcIndirectDataContentEncode(), WVTAsn1SpcPeImageDataEncode(), and WVTAsn1SpcSpOpusInfoEncode().

◆ CRYPT_AsnEncodeSPCDigest()

static BOOL WINAPI CRYPT_AsnEncodeSPCDigest ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 702 of file asn.c.

705{
706 const struct SPCDigest *digest = pvStructInfo;
707 struct AsnEncodeSequenceItem items[] = {
708 { &digest->DigestAlgorithm, CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 },
709 { &digest->Digest, CRYPT_AsnEncodeOctets, 0 },
710 };
711
712 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items),
713 pbEncoded, pcbEncoded);
714}
CRYPT_AsnEncodeOctets
static BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:95
CRYPT_AsnEncodeAlgorithmIdWithNullParams
static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:656
SPCDigest::Digest
CRYPT_HASH_BLOB Digest
Definition: asn.c:699

Referenced by WVTAsn1SpcIndirectDataContentEncode().

◆ CRYPT_AsnEncodeSwapTag()

static BOOL WINAPI CRYPT_AsnEncodeSwapTag ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 794 of file asn.c.

797{
798 BOOL ret;
799 const struct AsnEncodeTagSwappedItem *item = pvStructInfo;
800
801 ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
802 item->pvStructInfo, pbEncoded, pcbEncoded);
803 if (ret && pbEncoded)
804 *pbEncoded = item->tag;
805 return ret;
806}
AsnEncodeTagSwappedItem::pvStructInfo
const void * pvStructInfo
Definition: encode.c:290

Referenced by WVTAsn1SpcSpOpusInfoEncode().

◆ CRYPT_CopyEncodedBlob()

static BOOL WINAPI CRYPT_CopyEncodedBlob ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 631 of file asn.c.

634{
635 const CRYPT_DER_BLOB *blob = pvStructInfo;
636 BOOL ret = TRUE;
637
638 if (!pbEncoded)
639 *pcbEncoded = blob->cbData;
640 else if (*pcbEncoded < blob->cbData)
641 {
642 *pcbEncoded = blob->cbData;
643 SetLastError(ERROR_MORE_DATA);
644 ret = FALSE;
645 }
646 else
647 {
648 if (blob->cbData)
649 memcpy(pbEncoded, blob->pbData, blob->cbData);
650 *pcbEncoded = blob->cbData;
651 }
652 return ret;
653}
cbData
_In_opt_ _In_opt_ _In_ _In_ DWORD cbData
Definition: shlwapi.h:761

Referenced by CRYPT_AsnEncodeAlgorithmIdWithNullParams(), and CRYPT_AsnEncodeAttributeTypeValue().

◆ CRYPT_EncodeLen()

static BOOL CRYPT_EncodeLen ( DWORD  len,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)
static

Definition at line 53 of file asn.c.

54{
55 DWORD bytesNeeded, significantBytes = 0;
56
57 if (len <= 0x7f)
58 bytesNeeded = 1;
59 else
60 {
61 DWORD temp;
62
63 for (temp = len, significantBytes = sizeof(temp); !(temp & 0xff000000);
64 temp <<= 8, significantBytes--)
65 ;
66 bytesNeeded = significantBytes + 1;
67 }
68 if (!pbEncoded)
69 {
70 *pcbEncoded = bytesNeeded;
71 return TRUE;
72 }
73 if (*pcbEncoded < bytesNeeded)
74 {
75 SetLastError(ERROR_MORE_DATA);
76 return FALSE;
77 }
78 if (len <= 0x7f)
79 *pbEncoded = (BYTE)len;
80 else
81 {
82 DWORD i;
83
84 *pbEncoded++ = significantBytes | 0x80;
85 for (i = 0; i < significantBytes; i++)
86 {
87 *(pbEncoded + significantBytes - i - 1) = (BYTE)(len & 0xff);
88 len >>= 8;
89 }
90 }
91 *pcbEncoded = bytesNeeded;
92 return TRUE;
93}
temp
static calc_node_t temp
Definition: rpn_ieee.c:38

Referenced by CRYPT_AsnEncodeBits(), CRYPT_AsnEncodeBMPString(), CRYPT_AsnEncodeConstructed(), CRYPT_AsnEncodeInteger(), CRYPT_AsnEncodeOctets(), CRYPT_AsnEncodeOid(), CRYPT_AsnEncodeSequence(), and WVTAsn1SpcLinkEncode().

◆ CRYPT_GetLen()

static BOOL CRYPT_GetLen ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD *  len 
)
static

Definition at line 1107 of file asn.c.

1108{
1109 BOOL ret;
1110
1111 if (cbEncoded <= 1)
1112 {
1113 SetLastError(CRYPT_E_ASN1_CORRUPT);
1114 ret = FALSE;
1115 }
1116 else if (pbEncoded[1] <= 0x7f)
1117 {
1118 if (pbEncoded[1] + 1 > cbEncoded)
1119 {
1120 SetLastError(CRYPT_E_ASN1_EOD);
1121 ret = FALSE;
1122 }
1123 else
1124 {
1125 *len = pbEncoded[1];
1126 ret = TRUE;
1127 }
1128 }
1129 else if (pbEncoded[1] == 0x80)
1130 {
1131 FIXME("unimplemented for indefinite-length encoding\n");
1132 SetLastError(CRYPT_E_ASN1_CORRUPT);
1133 ret = FALSE;
1134 }
1135 else
1136 {
1137 BYTE lenLen = GET_LEN_BYTES(pbEncoded[1]);
1138
1139 if (lenLen > sizeof(DWORD) + 1)
1140 {
1141 SetLastError(CRYPT_E_ASN1_LARGE);
1142 ret = FALSE;
1143 }
1144 else if (lenLen + 2 > cbEncoded)
1145 {
1146 SetLastError(CRYPT_E_ASN1_CORRUPT);
1147 ret = FALSE;
1148 }
1149 else
1150 {
1151 DWORD out = 0;
1152
1153 pbEncoded += 2;
1154 while (--lenLen)
1155 {
1156 out <<= 8;
1157 out |= *pbEncoded++;
1158 }
1159 if (out + lenLen + 1 > cbEncoded)
1160 {
1161 SetLastError(CRYPT_E_ASN1_EOD);
1162 ret = FALSE;
1163 }
1164 else
1165 {
1166 *len = out;
1167 ret = TRUE;
1168 }
1169 }
1170 }
1171 return ret;
1172}
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
out
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383
CRYPT_E_ASN1_EOD
#define CRYPT_E_ASN1_EOD
Definition: winerror.h:4501

Referenced by CRYPT_AsnDecodeBitsInternal(), CRYPT_AsnDecodeBMPString(), CRYPT_AsnDecodeInt(), CRYPT_AsnDecodeOctets(), CRYPT_AsnDecodeOidIgnoreTag(), CRYPT_AsnDecodeProgramName(), CRYPT_AsnDecodeSequence(), CRYPT_AsnDecodeSequenceItems(), CRYPT_AsnDecodeSPCLinkInternal(), and CRYPT_AsnDecodeSPCLinkPointer().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( cryptasn  )

◆ WVTAsn1CatMemberInfoDecode()

BOOL WINAPI WVTAsn1CatMemberInfoDecode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)

Definition at line 2235 of file asn.c.

2238{
2239 BOOL ret = FALSE;
2240
2241 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2242 pvStructInfo, *pcbStructInfo);
2243
2244 __TRY
2245 {
2246 struct AsnDecodeSequenceItem items[] = {
2247 { ASN_BMPSTRING, offsetof(CAT_MEMBERINFO, pwszSubjGuid),
2248 CRYPT_AsnDecodeBMPString, sizeof(LPWSTR), FALSE, TRUE,
2249 offsetof(CAT_MEMBERINFO, pwszSubjGuid), 0 },
2250 { ASN_INTEGER, offsetof(CAT_MEMBERINFO, dwCertVersion),
2251 CRYPT_AsnDecodeInt, FINALMEMBERSIZE(CAT_MEMBERINFO, dwCertVersion),
2252 FALSE, FALSE, 0, 0 },
2253 };
2254
2255 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items),
2256 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo, NULL);
2257 }
2258 __EXCEPT_PAGE_FAULT
2259 {
2260 SetLastError(STATUS_ACCESS_VIOLATION);
2261 }
2262 __ENDTRY
2263 TRACE("returning %d\n", ret);
2264 return ret;
2265}
CRYPT_AsnDecodeInt
static BOOL WINAPI CRYPT_AsnDecodeInt(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:2187
FINALMEMBERSIZE
#define FINALMEMBERSIZE(s, member)
Definition: asn.c:1473
_CAT_MEMBERINFO
Definition: wintrust.h:606

◆ WVTAsn1CatMemberInfoEncode()

BOOL WINAPI WVTAsn1CatMemberInfoEncode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)

Definition at line 983 of file asn.c.

986{
987 BOOL ret = FALSE;
988
989 TRACE("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType,
990 debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
991
992 __TRY
993 {
994 const CAT_MEMBERINFO *info = pvStructInfo;
995 struct AsnEncodeSequenceItem items[] = {
996 { info->pwszSubjGuid, CRYPT_AsnEncodeBMPString, 0 },
997 { &info->dwCertVersion, CRYPT_AsnEncodeInt, 0 },
998 };
999
1000 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items),
1001 pbEncoded, pcbEncoded);
1002 }
1003 __EXCEPT_PAGE_FAULT
1004 {
1005 SetLastError(STATUS_ACCESS_VIOLATION);
1006 }
1007 __ENDTRY
1008 return ret;
1009}
CRYPT_AsnEncodeBMPString
static BOOL WINAPI CRYPT_AsnEncodeBMPString(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:744
CRYPT_AsnEncodeInt
static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:973

◆ WVTAsn1CatNameValueDecode()

BOOL WINAPI WVTAsn1CatNameValueDecode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)

Definition at line 2267 of file asn.c.

2270{
2271 BOOL ret = FALSE;
2272
2273 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2274 pvStructInfo, *pcbStructInfo);
2275
2276 __TRY
2277 {
2278 struct AsnDecodeSequenceItem items[] = {
2279 { ASN_BMPSTRING, offsetof(CAT_NAMEVALUE, pwszTag),
2280 CRYPT_AsnDecodeBMPString, sizeof(LPWSTR), FALSE, TRUE,
2281 offsetof(CAT_NAMEVALUE, pwszTag), 0 },
2282 { ASN_INTEGER, offsetof(CAT_NAMEVALUE, fdwFlags),
2283 CRYPT_AsnDecodeInt, MEMBERSIZE(CAT_NAMEVALUE, fdwFlags, Value),
2284 FALSE, FALSE, 0, 0 },
2285 { ASN_OCTETSTRING, offsetof(CAT_NAMEVALUE, Value),
2286 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB), FALSE, TRUE,
2287 offsetof(CAT_NAMEVALUE, Value.pbData), 0 },
2288 };
2289
2290 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items),
2291 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo, NULL);
2292 }
2293 __EXCEPT_PAGE_FAULT
2294 {
2295 SetLastError(STATUS_ACCESS_VIOLATION);
2296 }
2297 __ENDTRY
2298 TRACE("returning %d\n", ret);
2299 return ret;
2300}
MEMBERSIZE
#define MEMBERSIZE(s, member, nextmember)
Definition: asn.c:1474
_CAT_NAMEVALUE
Definition: wintrust.h:599

◆ WVTAsn1CatNameValueEncode()

BOOL WINAPI WVTAsn1CatNameValueEncode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)

Definition at line 1011 of file asn.c.

1014{
1015 BOOL ret = FALSE;
1016
1017 TRACE("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType,
1018 debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
1019
1020 __TRY
1021 {
1022 const CAT_NAMEVALUE *value = pvStructInfo;
1023 struct AsnEncodeSequenceItem items[] = {
1024 { value->pwszTag, CRYPT_AsnEncodeBMPString, 0 },
1025 { &value->fdwFlags, CRYPT_AsnEncodeInt, 0 },
1026 { &value->Value, CRYPT_AsnEncodeOctets, 0 },
1027 };
1028
1029 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items),
1030 pbEncoded, pcbEncoded);
1031 }
1032 __EXCEPT_PAGE_FAULT
1033 {
1034 SetLastError(STATUS_ACCESS_VIOLATION);
1035 }
1036 __ENDTRY
1037 return ret;
1038}
value
Definition: pdh_main.c:96

◆ WVTAsn1SpcFinancialCriteriaInfoDecode()

BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoDecode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)

Definition at line 2344 of file asn.c.

2347{
2348 BOOL ret = FALSE;
2349
2350 TRACE("(%p, %ld, %08lx, %p, %ld)\n", pbEncoded, cbEncoded, dwFlags,
2351 pvStructInfo, *pcbStructInfo);
2352
2353 __TRY
2354 {
2355 struct AsnDecodeSequenceItem items[] = {
2356 { ASN_BOOL, offsetof(SPC_FINANCIAL_CRITERIA, fFinancialInfoAvailable),
2357 CRYPT_AsnDecodeBool, MEMBERSIZE(SPC_FINANCIAL_CRITERIA,
2358 fFinancialInfoAvailable, fMeetsCriteria), FALSE, FALSE, 0, 0 },
2359 { ASN_BOOL, offsetof(SPC_FINANCIAL_CRITERIA, fMeetsCriteria),
2360 CRYPT_AsnDecodeBool, FINALMEMBERSIZE(SPC_FINANCIAL_CRITERIA,
2361 fMeetsCriteria), FALSE, FALSE, 0, 0 },
2362 };
2363
2364 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items),
2365 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo, NULL);
2366 }
2367 __EXCEPT_PAGE_FAULT
2368 {
2369 SetLastError(STATUS_ACCESS_VIOLATION);
2370 }
2371 __ENDTRY
2372 TRACE("returning %d\n", ret);
2373 return ret;
2374}
CRYPT_AsnDecodeBool
static BOOL WINAPI CRYPT_AsnDecodeBool(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:2302
_SPC_FINANCIAL_CRITERIA
Definition: wintrust.h:563

◆ WVTAsn1SpcFinancialCriteriaInfoEncode()

BOOL WINAPI WVTAsn1SpcFinancialCriteriaInfoEncode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)

Definition at line 1071 of file asn.c.

1074{
1075 BOOL ret = FALSE;
1076
1077 TRACE("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType,
1078 debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
1079
1080 __TRY
1081 {
1082 const SPC_FINANCIAL_CRITERIA *criteria = pvStructInfo;
1083 struct AsnEncodeSequenceItem items[] = {
1084 { &criteria->fFinancialInfoAvailable, CRYPT_AsnEncodeBool, 0 },
1085 { &criteria->fMeetsCriteria, CRYPT_AsnEncodeBool, 0 },
1086 };
1087
1088 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items),
1089 pbEncoded, pcbEncoded);
1090 }
1091 __EXCEPT_PAGE_FAULT
1092 {
1093 SetLastError(STATUS_ACCESS_VIOLATION);
1094 }
1095 __ENDTRY
1096 return ret;
1097}
CRYPT_AsnEncodeBool
static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:1040
_SPC_FINANCIAL_CRITERIA::fFinancialInfoAvailable
BOOL fFinancialInfoAvailable
Definition: wintrust.h:564
_SPC_FINANCIAL_CRITERIA::fMeetsCriteria
BOOL fMeetsCriteria
Definition: wintrust.h:565

◆ WVTAsn1SpcIndirectDataContentDecode()

BOOL WINAPI WVTAsn1SpcIndirectDataContentDecode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)

Definition at line 2055 of file asn.c.

2058{
2059 BOOL ret = FALSE;
2060
2061 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2062 pvStructInfo, *pcbStructInfo);
2063
2064 __TRY
2065 {
2066 struct AsnDecodeSequenceItem items[] = {
2067 { ASN_SEQUENCEOF, offsetof(SPC_INDIRECT_DATA_CONTENT, Data),
2068 CRYPT_AsnDecodeAttributeTypeValue,
2069 sizeof(CRYPT_ATTRIBUTE_TYPE_VALUE), FALSE, TRUE,
2070 offsetof(SPC_INDIRECT_DATA_CONTENT, Data.pszObjId), 0 },
2071 { ASN_SEQUENCEOF, offsetof(SPC_INDIRECT_DATA_CONTENT, DigestAlgorithm),
2072 CRYPT_AsnDecodeSPCDigest, sizeof(struct SPCDigest),
2073 FALSE, TRUE,
2074 offsetof(SPC_INDIRECT_DATA_CONTENT, DigestAlgorithm.pszObjId), 0 },
2075 };
2076
2077 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items),
2078 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo, NULL);
2079 }
2080 __EXCEPT_PAGE_FAULT
2081 {
2082 SetLastError(STATUS_ACCESS_VIOLATION);
2083 }
2084 __ENDTRY
2085 TRACE("returning %d\n", ret);
2086 return ret;
2087}
CRYPT_AsnDecodeAttributeTypeValue
static BOOL WINAPI CRYPT_AsnDecodeAttributeTypeValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:1982
CRYPT_AsnDecodeSPCDigest
static BOOL WINAPI CRYPT_AsnDecodeSPCDigest(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:2032
_SPC_INDIRECT_DATA_CONTENT
Definition: wintrust.h:556
CRYPT_ATTRIBUTE_TYPE_VALUE
struct _CRYPT_ATTRIBUTE_TYPE_VALUE CRYPT_ATTRIBUTE_TYPE_VALUE

◆ WVTAsn1SpcIndirectDataContentEncode()

BOOL WINAPI WVTAsn1SpcIndirectDataContentEncode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)

Definition at line 716 of file asn.c.

719{
720 BOOL ret = FALSE;
721
722 TRACE("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType,
723 debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
724
725 __TRY
726 {
727 const SPC_INDIRECT_DATA_CONTENT *data = pvStructInfo;
728 struct AsnEncodeSequenceItem items[] = {
729 { &data->Data, CRYPT_AsnEncodeAttributeTypeValue, 0 },
730 { &data->DigestAlgorithm, CRYPT_AsnEncodeSPCDigest, 0 },
731 };
732
733 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items),
734 pbEncoded, pcbEncoded);
735 }
736 __EXCEPT_PAGE_FAULT
737 {
738 SetLastError(STATUS_ACCESS_VIOLATION);
739 }
740 __ENDTRY
741 return ret;
742}
CRYPT_AsnEncodeSPCDigest
static BOOL WINAPI CRYPT_AsnEncodeSPCDigest(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:702
CRYPT_AsnEncodeAttributeTypeValue
static BOOL WINAPI CRYPT_AsnEncodeAttributeTypeValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:682

◆ WVTAsn1SpcLinkDecode()

BOOL WINAPI WVTAsn1SpcLinkDecode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)

Definition at line 1386 of file asn.c.

1389{
1390 BOOL ret = FALSE;
1391
1392 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1393 pvStructInfo, *pcbStructInfo);
1394
1395 __TRY
1396 {
1397 DWORD bytesNeeded;
1398
1399 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1400 lpszStructType, pbEncoded, cbEncoded, dwFlags, NULL, &bytesNeeded);
1401 if (ret)
1402 {
1403 if (!pvStructInfo)
1404 *pcbStructInfo = bytesNeeded;
1405 else if (*pcbStructInfo < bytesNeeded)
1406 {
1407 *pcbStructInfo = bytesNeeded;
1408 SetLastError(ERROR_MORE_DATA);
1409 ret = FALSE;
1410 }
1411 else
1412 {
1413 SPC_LINK *link = pvStructInfo;
1414
1415 link->pwszFile =
1416 (LPWSTR)((BYTE *)pvStructInfo + sizeof(SPC_LINK));
1417 ret = CRYPT_AsnDecodeSPCLinkInternal(dwCertEncodingType,
1418 lpszStructType, pbEncoded, cbEncoded, dwFlags, pvStructInfo,
1419 pcbStructInfo);
1420 }
1421 }
1422 }
1423 __EXCEPT_PAGE_FAULT
1424 {
1425 SetLastError(STATUS_ACCESS_VIOLATION);
1426 }
1427 __ENDTRY
1428 TRACE("returning %d\n", ret);
1429 return ret;
1430}

◆ WVTAsn1SpcLinkEncode()

BOOL WINAPI WVTAsn1SpcLinkEncode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)

Definition at line 128 of file asn.c.

131{
132 BOOL ret = FALSE;
133
134 TRACE("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType,
135 debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
136 pcbEncoded);
137
138 __TRY
139 {
140 const SPC_LINK *link = pvStructInfo;
141 DWORD bytesNeeded, lenBytes;
142
143 switch (link->dwLinkChoice)
144 {
145 case SPC_FILE_LINK_CHOICE:
146 {
147 DWORD fileNameLen, fileNameLenBytes;
148 LPWSTR ptr;
149
150 fileNameLen = link->pwszFile ?
151 lstrlenW(link->pwszFile) * sizeof(WCHAR) : 0;
152 CRYPT_EncodeLen(fileNameLen, NULL, &fileNameLenBytes);
153 CRYPT_EncodeLen(1 + fileNameLenBytes + fileNameLen, NULL,
154 &lenBytes);
155 bytesNeeded = 2 + lenBytes + fileNameLenBytes + fileNameLen;
156 if (!pbEncoded)
157 {
158 *pcbEncoded = bytesNeeded;
159 ret = TRUE;
160 }
161 else if (*pcbEncoded < bytesNeeded)
162 {
163 SetLastError(ERROR_MORE_DATA);
164 *pcbEncoded = bytesNeeded;
165 }
166 else
167 {
168 *pcbEncoded = bytesNeeded;
169 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_CONTEXT | 2;
170 CRYPT_EncodeLen(1 + fileNameLenBytes + fileNameLen, pbEncoded,
171 &lenBytes);
172 pbEncoded += lenBytes;
173 *pbEncoded++ = ASN_CONTEXT;
174 CRYPT_EncodeLen(fileNameLen, pbEncoded, &fileNameLenBytes);
175 pbEncoded += fileNameLenBytes;
176 for (ptr = link->pwszFile; ptr && *ptr; ptr++)
177 {
178 *(WCHAR *)pbEncoded = hton16(*ptr);
179 pbEncoded += sizeof(WCHAR);
180 }
181 ret = TRUE;
182 }
183 break;
184 }
185 case SPC_MONIKER_LINK_CHOICE:
186 {
187 DWORD classIdLenBytes, dataLenBytes, dataLen;
188 CRYPT_DATA_BLOB classId = { sizeof(link->Moniker.ClassId),
189 (BYTE *)link->Moniker.ClassId };
190
191 CRYPT_EncodeLen(classId.cbData, NULL, &classIdLenBytes);
192 CRYPT_EncodeLen(link->Moniker.SerializedData.cbData, NULL,
193 &dataLenBytes);
194 dataLen = 2 + classIdLenBytes + classId.cbData +
195 dataLenBytes + link->Moniker.SerializedData.cbData;
196 CRYPT_EncodeLen(dataLen, NULL, &lenBytes);
197 bytesNeeded = 1 + dataLen + lenBytes;
198 if (!pbEncoded)
199 {
200 *pcbEncoded = bytesNeeded;
201 ret = TRUE;
202 }
203 else if (*pcbEncoded < bytesNeeded)
204 {
205 SetLastError(ERROR_MORE_DATA);
206 *pcbEncoded = bytesNeeded;
207 }
208 else
209 {
210 DWORD size;
211
212 *pcbEncoded = bytesNeeded;
213 *pbEncoded++ = ASN_CONSTRUCTOR | ASN_CONTEXT | 1;
214 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
215 pbEncoded += lenBytes;
216 size = 1 + classIdLenBytes + classId.cbData;
217 CRYPT_AsnEncodeOctets(X509_ASN_ENCODING, NULL, &classId,
218 pbEncoded, &size);
219 pbEncoded += size;
220 size = 1 + dataLenBytes + link->Moniker.SerializedData.cbData;
221 CRYPT_AsnEncodeOctets(X509_ASN_ENCODING, NULL,
222 &link->Moniker.SerializedData, pbEncoded, &size);
223 pbEncoded += size;
224 ret = TRUE;
225 }
226 break;
227 }
228 case SPC_URL_LINK_CHOICE:
229 {
230 LPWSTR ptr;
231 DWORD urlLen;
232
233 /* Check for invalid characters in URL */
234 ret = TRUE;
235 urlLen = 0;
236 for (ptr = link->pwszUrl; ptr && *ptr && ret; ptr++)
237 if (*ptr > 0x7f)
238 {
239 *pcbEncoded = 0;
240 SetLastError(CRYPT_E_INVALID_IA5_STRING);
241 ret = FALSE;
242 }
243 else
244 urlLen++;
245 if (ret)
246 {
247 CRYPT_EncodeLen(urlLen, NULL, &lenBytes);
248 bytesNeeded = 1 + lenBytes + urlLen;
249 if (!pbEncoded)
250 *pcbEncoded = bytesNeeded;
251 else if (*pcbEncoded < bytesNeeded)
252 {
253 SetLastError(ERROR_MORE_DATA);
254 *pcbEncoded = bytesNeeded;
255 ret = FALSE;
256 }
257 else
258 {
259 *pcbEncoded = bytesNeeded;
260 *pbEncoded++ = ASN_CONTEXT;
261 CRYPT_EncodeLen(urlLen, pbEncoded, &lenBytes);
262 pbEncoded += lenBytes;
263 for (ptr = link->pwszUrl; ptr && *ptr; ptr++)
264 *pbEncoded++ = (BYTE)*ptr;
265 }
266 }
267 break;
268 }
269 default:
270 SetLastError(E_INVALIDARG);
271 }
272 }
273 __EXCEPT_PAGE_FAULT
274 {
275 SetLastError(STATUS_ACCESS_VIOLATION);
276 }
277 __ENDTRY
278 TRACE("returning %d\n", ret);
279 return ret;
280}
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101
CRYPT_E_INVALID_IA5_STRING
#define CRYPT_E_INVALID_IA5_STRING
Definition: winerror.h:4440

Referenced by WVTAsn1SpcPeImageDataEncode(), and WVTAsn1SpcSpOpusInfoEncode().

◆ WVTAsn1SpcPeImageDataDecode()

BOOL WINAPI WVTAsn1SpcPeImageDataDecode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)

Definition at line 1792 of file asn.c.

1795{
1796 BOOL ret = FALSE;
1797
1798 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1799 pvStructInfo, *pcbStructInfo);
1800
1801 __TRY
1802 {
1803 struct AsnDecodeSequenceItem items[] = {
1804 { ASN_BITSTRING, offsetof(SPC_PE_IMAGE_DATA, Flags),
1805 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
1806 offsetof(SPC_PE_IMAGE_DATA, Flags.pbData), 0 },
1807 { ASN_CONSTRUCTOR | ASN_CONTEXT, offsetof(SPC_PE_IMAGE_DATA, pFile),
1808 CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
1809 offsetof(SPC_PE_IMAGE_DATA, pFile), 0 },
1810 };
1811
1812 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items),
1813 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo, NULL);
1814 }
1815 __EXCEPT_PAGE_FAULT
1816 {
1817 SetLastError(STATUS_ACCESS_VIOLATION);
1818 }
1819 __ENDTRY
1820 TRACE("returning %d\n", ret);
1821 return ret;
1822}
CRYPT_AsnDecodeSPCLinkPointer
static BOOL WINAPI CRYPT_AsnDecodeSPCLinkPointer(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:1749
CRYPT_AsnDecodeBitsInternal
static BOOL WINAPI CRYPT_AsnDecodeBitsInternal(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:1685
pFile
MdFileObject pFile
Definition: fxiotargetapikm.cpp:149
_SPC_PE_IMAGE_DATA
Definition: wintrust.h:550
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

◆ WVTAsn1SpcPeImageDataEncode()

BOOL WINAPI WVTAsn1SpcPeImageDataEncode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)

Definition at line 468 of file asn.c.

471{
472 const SPC_PE_IMAGE_DATA *imageData = pvStructInfo;
473 BOOL ret = FALSE;
474
475 TRACE("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType,
476 debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
477 pcbEncoded);
478
479 __TRY
480 {
481 struct AsnEncodeSequenceItem items[2] = {
482 { 0 }
483 };
484 struct AsnConstructedItem constructed = { 0, imageData->pFile,
485 WVTAsn1SpcLinkEncode };
486 DWORD cItem = 0;
487
488 if (imageData->Flags.cbData)
489 {
490 items[cItem].pvStructInfo = &imageData->Flags;
491 items[cItem].encodeFunc = CRYPT_AsnEncodeBits;
492 cItem++;
493 }
494 if (imageData->pFile)
495 {
496 items[cItem].pvStructInfo = &constructed;
497 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
498 cItem++;
499 }
500
501 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, cItem,
502 pbEncoded, pcbEncoded);
503 }
504 __EXCEPT_PAGE_FAULT
505 {
506 SetLastError(STATUS_ACCESS_VIOLATION);
507 }
508 __ENDTRY
509 TRACE("returning %d\n", ret);
510 return ret;
511}
CRYPT_AsnEncodeBits
static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:344
WVTAsn1SpcLinkEncode
BOOL WINAPI WVTAsn1SpcLinkEncode(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:128
CRYPT_AsnEncodeConstructed
static BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:421
_CRYPT_BIT_BLOB::cbData
DWORD cbData
Definition: wincrypt.h:205
_SPC_PE_IMAGE_DATA::Flags
CRYPT_BIT_BLOB Flags
Definition: wintrust.h:551
_SPC_PE_IMAGE_DATA::pFile
PSPC_LINK pFile
Definition: wintrust.h:552

◆ WVTAsn1SpcSpOpusInfoDecode()

BOOL WINAPI WVTAsn1SpcSpOpusInfoDecode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo 
)

Definition at line 2148 of file asn.c.

2151{
2152 BOOL ret = FALSE;
2153
2154 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2155 pvStructInfo, *pcbStructInfo);
2156
2157 __TRY
2158 {
2159 struct AsnDecodeSequenceItem items[] = {
2160 { ASN_CONSTRUCTOR | ASN_CONTEXT,
2161 offsetof(SPC_SP_OPUS_INFO, pwszProgramName),
2162 CRYPT_AsnDecodeProgramName, sizeof(LPCWSTR), TRUE, TRUE,
2163 offsetof(SPC_SP_OPUS_INFO, pwszProgramName), 0 },
2164 { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
2165 offsetof(SPC_SP_OPUS_INFO, pMoreInfo),
2166 CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
2167 offsetof(SPC_SP_OPUS_INFO, pMoreInfo), 0 },
2168 { ASN_CONSTRUCTOR | ASN_CONTEXT | 2,
2169 offsetof(SPC_SP_OPUS_INFO, pPublisherInfo),
2170 CRYPT_AsnDecodeSPCLinkPointer, sizeof(PSPC_LINK), TRUE, TRUE,
2171 offsetof(SPC_SP_OPUS_INFO, pPublisherInfo), 0 },
2172 };
2173
2174 ret = CRYPT_AsnDecodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items),
2175 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo, NULL);
2176 }
2177 __EXCEPT_PAGE_FAULT
2178 {
2179 SetLastError(STATUS_ACCESS_VIOLATION);
2180 }
2181 __ENDTRY
2182 TRACE("returning %d\n", ret);
2183 return ret;
2184}
CRYPT_AsnDecodeProgramName
static BOOL WINAPI CRYPT_AsnDecodeProgramName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: asn.c:2127
_SPC_SP_OPUS_INFO
Definition: wintrust.h:592

◆ WVTAsn1SpcSpOpusInfoEncode()

BOOL WINAPI WVTAsn1SpcSpOpusInfoEncode ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
const void *  pvStructInfo,
BYTE *  pbEncoded,
DWORD *  pcbEncoded 
)

Definition at line 808 of file asn.c.

811{
812 BOOL ret = FALSE;
813
814 TRACE("(0x%08lx, %s, %p, %p, %p)\n", dwCertEncodingType,
815 debugstr_a(lpszStructType), pvStructInfo, pbEncoded, pcbEncoded);
816
817 __TRY
818 {
819 const SPC_SP_OPUS_INFO *info = pvStructInfo;
820
821 if (info->pMoreInfo &&
822 info->pMoreInfo->dwLinkChoice != SPC_URL_LINK_CHOICE &&
823 info->pMoreInfo->dwLinkChoice != SPC_MONIKER_LINK_CHOICE &&
824 info->pMoreInfo->dwLinkChoice != SPC_FILE_LINK_CHOICE)
825 SetLastError(E_INVALIDARG);
826 else if (info->pPublisherInfo &&
827 info->pPublisherInfo->dwLinkChoice != SPC_URL_LINK_CHOICE &&
828 info->pPublisherInfo->dwLinkChoice != SPC_MONIKER_LINK_CHOICE &&
829 info->pPublisherInfo->dwLinkChoice != SPC_FILE_LINK_CHOICE)
830 SetLastError(E_INVALIDARG);
831 else
832 {
833 struct AsnEncodeSequenceItem items[3] = { { 0 } };
834 struct AsnConstructedItem constructed[3] = { { 0 } };
835 struct AsnEncodeTagSwappedItem swapped;
836 DWORD cItem = 0, cConstructed = 0;
837
838 if (info->pwszProgramName)
839 {
840 swapped.tag = ASN_CONTEXT;
841 swapped.pvStructInfo = info->pwszProgramName;
842 swapped.encodeFunc = CRYPT_AsnEncodeBMPString;
843 constructed[cConstructed].tag = 0;
844 constructed[cConstructed].pvStructInfo = &swapped;
845 constructed[cConstructed].encodeFunc = CRYPT_AsnEncodeSwapTag;
846 items[cItem].pvStructInfo = &constructed[cConstructed];
847 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
848 cConstructed++;
849 cItem++;
850 }
851 if (info->pMoreInfo)
852 {
853 constructed[cConstructed].tag = 1;
854 constructed[cConstructed].pvStructInfo = info->pMoreInfo;
855 constructed[cConstructed].encodeFunc = WVTAsn1SpcLinkEncode;
856 items[cItem].pvStructInfo = &constructed[cConstructed];
857 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
858 cConstructed++;
859 cItem++;
860 }
861 if (info->pPublisherInfo)
862 {
863 constructed[cConstructed].tag = 2;
864 constructed[cConstructed].pvStructInfo = info->pPublisherInfo;
865 constructed[cConstructed].encodeFunc = WVTAsn1SpcLinkEncode;
866 items[cItem].pvStructInfo = &constructed[cConstructed];
867 items[cItem].encodeFunc = CRYPT_AsnEncodeConstructed;
868 cConstructed++;
869 cItem++;
870 }
871 ret = CRYPT_AsnEncodeSequence(X509_ASN_ENCODING,
872 items, cItem, pbEncoded, pcbEncoded);
873 }
874 }
875 __EXCEPT_PAGE_FAULT
876 {
877 SetLastError(STATUS_ACCESS_VIOLATION);
878 }
879 __ENDTRY
880 return ret;
881}
CRYPT_AsnEncodeSwapTag
static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: asn.c:794
AsnConstructedItem::encodeFunc
CryptEncodeObjectExFunc encodeFunc
Definition: crypt32_private.h:63