ReactOS 0.4.17-dev-470-gf9e3448
Classes | Macros | Typedefs | Functions
decode.c File Reference
#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "wincrypt.h"
#include "winnls.h"
#include "snmp.h"
#include "wine/debug.h"
#include "wine/exception.h"
#include "crypt32_private.h"
Include dependency graph for decode.c:

Go to the source code of this file.

Classes

struct  AsnDecodeSequenceItem
 
struct  AsnArrayDescriptor
 
struct  AsnArrayItemSize
 
struct  PATH_LEN_CONSTRAINT
 
struct  DECODED_RSA_PUB_KEY
 
struct  DECODED_RSA_PRIV_KEY
 

Macros

#define MAX_ENCODED_LEN   0x04000000
 
#define ASN_FLAGS_MASK   0xe0
 
#define ASN_TYPE_MASK   0x1f
 
#define GET_LEN_BYTES(b)   ((b) <= 0x80 ? 1 : 1 + ((b) & 0x7f))
 
#define FINALMEMBERSIZE(s, member)   (sizeof(s) - offsetof(s, member))
 
#define MEMBERSIZE(s, member, nextmember)    (offsetof(s, nextmember) - offsetof(s, member))
 
#define RSA1_MAGIC   0x31415352
 
#define RSA2_MAGIC   0x32415352
 
#define CRYPT_TIME_GET_DIGITS(pbEncoded, len, numDigits, word)
 
#define MIN_ENCODED_TIME_LENGTH   10
 

Typedefs

typedef BOOL(WINAPI * CryptDecodeObjectFunc) (DWORD, LPCSTR, const BYTE *, DWORD, DWORD, void *, DWORD *)
 
typedef BOOL(WINAPI * CryptDecodeObjectExFunc) (DWORD, LPCSTR, const BYTE *, DWORD, DWORD, PCRYPT_DECODE_PARA, void *, DWORD *)
 
typedef BOOL(* InternalDecodeFunc) (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (cryptasn)
 
 WINE_DECLARE_DEBUG_CHANNEL (crypt)
 
void CRYPT_CopyReversed (BYTE *dst, const BYTE *src, size_t len)
 
static BOOL CRYPT_AsnDecodeChoiceOfTimeInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodePubKeyInfoInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeExtension (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeAlgorithmId (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeBool (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeOctets (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeBitsInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeIntInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeIntegerInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeUnsignedIntegerInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodePKCSAttributeInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_GetLengthIndefinite (const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
 
static BOOL CRYPT_GetLen (const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
 
static BOOL CRYPT_DecodeEnsureSpace (DWORD dwFlags, const CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo, DWORD bytesNeeded)
 
static void CRYPT_FreeSpace (const CRYPT_DECODE_PARA *pDecodePara, LPVOID pv)
 
static BOOL CRYPT_DecodeCheckSpace (DWORD *pcbStructInfo, DWORD bytesNeeded)
 
static BOOL CRYPT_AsnDecodeSequenceItems (struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, BYTE *nextData, DWORD *cbDecoded)
 
static BOOL CRYPT_AsnDecodeSequence (struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded, void *startingPointer)
 
static BOOL CRYPT_AsnDecodeArray (const struct AsnArrayDescriptor *arrayDesc, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, const CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeDerBlob (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeBitsSwapBytes (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeCertSignedContent (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeCertVersion (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeValidity (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCertExtensionsInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCertExtensions (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCertInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeCert (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeCRLEntryExtensions (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCRLEntry (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCRLEntries (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCRLExtensionsInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCRLExtensions (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCRLInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeCRL (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeOidIgnoreTag (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeOidInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeExtensions (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeNameValueInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeNameValue (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeUnicodeNameValueInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeUnicodeNameValue (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeRdnAttr (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeRdn (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeName (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeUnicodeRdnAttr (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeUnicodeRdn (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeUnicodeName (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_FindEncodedLen (const BYTE *pbEncoded, DWORD cbEncoded, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCopyBytes (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCTLUsage (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCTLEntryAttributes (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCTLEntry (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCTLEntries (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCTLExtensionsInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCTLExtensions (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeCTL (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeSMIMECapability (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeSMIMECapabilities (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeIA5String (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeNoticeNumbers (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeNoticeReference (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeUnicodeString (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodePolicyQualifierUserNoticeInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodePolicyQualifierUserNotice (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodePKCSAttributeValue (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodePKCSAttribute (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodePKCSAttributesInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodePKCSAttributes (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodePubKeyInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeAltNameEntry (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeAltNameInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeAuthorityKeyId (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeAuthorityKeyId2 (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeAccessDescription (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeAuthorityInfoAccess (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodePKCSContent (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodePKCSContentInfoInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodePKCSContentInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL CRYPT_AsnDecodePKCSDigestedData (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, CRYPT_DIGESTED_DATA *digestedData, DWORD *pcbDigestedData)
 
static BOOL WINAPI CRYPT_AsnDecodeAltName (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodePathLenConstraint (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeSubtreeConstraints (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeBasicConstraints (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeBasicConstraints2 (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodePolicyQualifier (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodePolicyQualifiers (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCertPolicy (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeCertPolicies (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeCertPolicyMapping (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeCertPolicyMappings (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeRequireExplicit (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeInhibitMapping (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeCertPolicyConstraints (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_raw_decode_rsa_pub_key (struct DECODED_RSA_PUB_KEY **decodedKey, DWORD *size, const BYTE *pbEncoded, DWORD cbEncoded)
 
static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey_Bcrypt (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeRsaPrivKey (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeOctetStringInternal (const BYTE *encoded, DWORD encoded_size, DWORD flags, void *buf, DWORD *buf_size, DWORD *ret_decoded)
 
static BOOL WINAPI CRYPT_AsnDecodeOctetString (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeBits (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeInt (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeInteger (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeUnsignedInteger (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeEnumerated (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeTimeZone (const BYTE *pbEncoded, DWORD len, SYSTEMTIME *sysTime)
 
static BOOL CRYPT_AsnDecodeUtcTimeInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeUtcTime (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeGeneralizedTime (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeChoiceOfTime (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeSequenceOfAny (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeDistPointName (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeDistPoint (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeCRLDistPoints (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeEnhancedKeyUsage (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeIssuingDistPoint (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeMaximum (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeSubtree (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodePermittedSubtree (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeExcludedSubtree (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeNameConstraints (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeIssuerSerialNumber (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodePKCSSignerInfoInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodePKCSSignerInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL verify_and_copy_certificate (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCMSCertEncoded (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCMSCrlEncoded (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCMSSignerId (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCMSSignerInfoInternal (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeCMSSignerInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_DecodeSignerArray (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
BOOL CRYPT_AsnDecodeCMSSignedInfo (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, CRYPT_SIGNED_INFO *signedInfo, DWORD *pcbSignedInfo)
 
static BOOL CRYPT_AsnDecodeRecipientInfo (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_DecodeRecipientInfoArray (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeEncryptedContentInfo (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
BOOL CRYPT_AsnDecodePKCSEnvelopedData (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, CRYPT_ENVELOPED_DATA *envelopedData, DWORD *pcbEnvelopedData)
 
static BOOL WINAPI CRYPT_AsnDecodeObjectIdentifier (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL WINAPI CRYPT_AsnDecodeEccSignature (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeOCSPResponseStatus (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeOCSPResponseBytes (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeOCSPResponse (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeOCSPSignatureInfoCertEncoded (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeOCSPBasicSignedResponse (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static BOOL CRYPT_AsnDecodeOCSPHashAlgorithm (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeOCSPNextUpdate (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeCertStatus (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeOCSPBasicResponseEntry (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeOCSPBasicResponseEntriesArray (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeResponderIDByName (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeResponderIDByKey (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL CRYPT_AsnDecodeResponderID (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
 
static BOOL WINAPI CRYPT_AsnDecodeOCSPBasicResponse (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
static CryptDecodeObjectExFunc CRYPT_GetBuiltinDecoder (DWORD dwCertEncodingType, LPCSTR lpszStructType)
 
static CryptDecodeObjectFunc CRYPT_LoadDecoderFunc (DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
 
static CryptDecodeObjectExFunc CRYPT_LoadDecoderExFunc (DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
 
BOOL WINAPI CryptDecodeObject (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL WINAPI CryptDecodeObjectEx (DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
 
BOOL WINAPI PFXIsPFXBlob (CRYPT_DATA_BLOB *pPFX)
 

Macro Definition Documentation

◆ ASN_FLAGS_MASK

#define ASN_FLAGS_MASK   0xe0

Definition at line 50 of file decode.c.

◆ ASN_TYPE_MASK

#define ASN_TYPE_MASK   0x1f

Definition at line 51 of file decode.c.

◆ CRYPT_TIME_GET_DIGITS

#define CRYPT_TIME_GET_DIGITS (   pbEncoded,
  len,
  numDigits,
  word 
)
Value:
do { \
BYTE i; \
\
(word) = 0; \
for (i = 0; (len) > 0 && i < (numDigits); i++, (len)--) \
{ \
if (!isdigit(*(pbEncoded))) \
{ \
SetLastError(CRYPT_E_ASN1_CORRUPT); \
ret = FALSE; \
} \
else \
{ \
(word) *= 10; \
(word) += *(pbEncoded)++ - '0'; \
} \
} \
} while (0)
isdigit
#define isdigit(c)
Definition: acclib.h:68
FALSE
#define FALSE
Definition: types.h:117
ret
return ret
Definition: mutex.c:146
len
GLenum GLsizei len
Definition: glext.h:6722
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
word
const WCHAR * word
Definition: lex.c:36
CRYPT_E_ASN1_CORRUPT
#define CRYPT_E_ASN1_CORRUPT
Definition: winerror.h:4502
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Definition at line 4835 of file decode.c.

◆ FINALMEMBERSIZE

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

Definition at line 301 of file decode.c.

◆ GET_LEN_BYTES

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

Definition at line 116 of file decode.c.

◆ MAX_ENCODED_LEN

#define MAX_ENCODED_LEN   0x04000000

Definition at line 48 of file decode.c.

◆ MEMBERSIZE

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

Definition at line 302 of file decode.c.

◆ MIN_ENCODED_TIME_LENGTH

#define MIN_ENCODED_TIME_LENGTH   10

Definition at line 4910 of file decode.c.

◆ RSA1_MAGIC

#define RSA1_MAGIC   0x31415352

Definition at line 3870 of file decode.c.

◆ RSA2_MAGIC

#define RSA2_MAGIC   0x32415352

Definition at line 4035 of file decode.c.

Typedef Documentation

◆ CryptDecodeObjectExFunc

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

Definition at line 66 of file decode.c.

◆ CryptDecodeObjectFunc

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

Definition at line 64 of file decode.c.

◆ InternalDecodeFunc

typedef BOOL(* InternalDecodeFunc) (const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)

Definition at line 72 of file decode.c.

Function Documentation

◆ CRYPT_AsnDecodeAccessDescription()

static BOOL CRYPT_AsnDecodeAccessDescription ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3207 of file decode.c.

3210{
3211 struct AsnDecodeSequenceItem items[] = {
3212 { 0, offsetof(CERT_ACCESS_DESCRIPTION, pszAccessMethod),
3213 CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), FALSE, TRUE,
3214 offsetof(CERT_ACCESS_DESCRIPTION, pszAccessMethod), 0 },
3215 { 0, offsetof(CERT_ACCESS_DESCRIPTION, AccessLocation),
3216 CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), FALSE,
3217 TRUE, offsetof(CERT_ACCESS_DESCRIPTION, AccessLocation.pwszURL), 0 },
3218 };
3219 CERT_ACCESS_DESCRIPTION *descr = pvStructInfo;
3220
3221 return CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3222 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3223 pcbDecoded, descr ? descr->pszAccessMethod : NULL);
3224}
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
CRYPT_AsnDecodeOidInternal
static BOOL CRYPT_AsnDecodeOidInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1406
CRYPT_AsnDecodeAltNameEntry
static BOOL CRYPT_AsnDecodeAltNameEntry(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2992
CRYPT_AsnDecodeSequence
static BOOL CRYPT_AsnDecodeSequence(struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded, void *startingPointer)
Definition: decode.c:454
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
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
descr
const char * descr
Definition: boot.c:45
_CERT_ACCESS_DESCRIPTION
Definition: wincrypt.h:477
LPSTR
char * LPSTR
Definition: typedefs.h:51
CERT_ALT_NAME_ENTRY
struct _CERT_ALT_NAME_ENTRY CERT_ALT_NAME_ENTRY

Referenced by CRYPT_AsnDecodeAuthorityInfoAccess().

◆ CRYPT_AsnDecodeAlgorithmId()

static BOOL CRYPT_AsnDecodeAlgorithmId ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2857 of file decode.c.

2859{
2860 CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
2861 BOOL ret = TRUE;
2862 struct AsnDecodeSequenceItem items[] = {
2863 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId),
2864 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2865 offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId), 0 },
2866 { 0, offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters),
2867 CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2868 offsetof(CRYPT_ALGORITHM_IDENTIFIER, Parameters.pbData), 0 },
2869 };
2870
2871 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
2872 pvStructInfo, *pcbStructInfo, pcbDecoded);
2873
2874 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
2875 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2876 pcbDecoded, algo ? algo->pszObjId : NULL);
2877 if (ret && pvStructInfo)
2878 {
2879 TRACE("pszObjId is %p (%s)\n", algo->pszObjId,
2880 debugstr_a(algo->pszObjId));
2881 }
2882 return ret;
2883}
CRYPT_AsnDecodeOidIgnoreTag
static BOOL CRYPT_AsnDecodeOidIgnoreTag(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1307
CRYPT_AsnDecodeCopyBytes
static BOOL CRYPT_AsnDecodeCopyBytes(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2111
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
debugstr_a
#define debugstr_a
Definition: kernel32.h:31
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

Referenced by CRYPT_AsnDecodeCertInfo(), CRYPT_AsnDecodeCertSignedContent(), CRYPT_AsnDecodeCMSSignerInfoInternal(), CRYPT_AsnDecodeCRLInfo(), CRYPT_AsnDecodeCTL(), CRYPT_AsnDecodeEncryptedContentInfo(), CRYPT_AsnDecodeOCSPBasicSignedResponse(), CRYPT_AsnDecodeOCSPHashAlgorithm(), CRYPT_AsnDecodePKCSDigestedData(), CRYPT_AsnDecodePKCSSignerInfoInternal(), CRYPT_AsnDecodePubKeyInfoInternal(), and CRYPT_AsnDecodeRecipientInfo().

◆ CRYPT_AsnDecodeAltName()

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

Definition at line 3405 of file decode.c.

3408{
3409 BOOL ret = TRUE;
3410
3411 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3412 pDecodePara, pvStructInfo, *pcbStructInfo);
3413
3414 __TRY
3415 {
3416 DWORD bytesNeeded = 0;
3417
3418 if ((ret = CRYPT_AsnDecodeAltNameInternal(pbEncoded, cbEncoded,
3419 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
3420 {
3421 if (!pvStructInfo)
3422 *pcbStructInfo = bytesNeeded;
3423 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3424 pvStructInfo, pcbStructInfo, bytesNeeded)))
3425 {
3426 CERT_ALT_NAME_INFO *name;
3427
3428 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3429 pvStructInfo = *(BYTE **)pvStructInfo;
3430 name = pvStructInfo;
3431 name->rgAltEntry = (PCERT_ALT_NAME_ENTRY)
3432 ((BYTE *)pvStructInfo + sizeof(CERT_ALT_NAME_INFO));
3433 ret = CRYPT_AsnDecodeAltNameInternal(pbEncoded, cbEncoded,
3434 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3435 &bytesNeeded, NULL);
3436 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
3437 CRYPT_FreeSpace(pDecodePara, name);
3438 }
3439 }
3440 }
3441 __EXCEPT_PAGE_FAULT
3442 {
3443 SetLastError(STATUS_ACCESS_VIOLATION);
3444 ret = FALSE;
3445 }
3446 __ENDTRY
3447 return ret;
3448}
CRYPT_FreeSpace
static void CRYPT_FreeSpace(const CRYPT_DECODE_PARA *pDecodePara, LPVOID pv)
Definition: decode.c:238
CRYPT_DecodeEnsureSpace
static BOOL CRYPT_DecodeEnsureSpace(DWORD dwFlags, const CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo, DWORD bytesNeeded)
Definition: decode.c:210
CRYPT_AsnDecodeAltNameInternal
static BOOL CRYPT_AsnDecodeAltNameInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3115
SetLastError
#define SetLastError(x)
Definition: compat.h:752
__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
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: fpEnumPrinters.c:23
_CERT_ALT_NAME_INFO
Definition: wincrypt.h:364
name
Definition: name.c:39
CRYPT_DECODE_ALLOC_FLAG
#define CRYPT_DECODE_ALLOC_FLAG
Definition: wincrypt.h:3612
CERT_ALT_NAME_INFO
struct _CERT_ALT_NAME_INFO CERT_ALT_NAME_INFO
PCERT_ALT_NAME_ENTRY
struct _CERT_ALT_NAME_ENTRY * PCERT_ALT_NAME_ENTRY

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeAltNameEntry()

static BOOL CRYPT_AsnDecodeAltNameEntry ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2992 of file decode.c.

2994{
2995 PCERT_ALT_NAME_ENTRY entry = pvStructInfo;
2996 DWORD dataLen, lenBytes, bytesNeeded = sizeof(CERT_ALT_NAME_ENTRY);
2997 BOOL ret;
2998
2999 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3000 pvStructInfo, *pcbStructInfo);
3001
3002 if (cbEncoded < 2)
3003 {
3004 SetLastError(CRYPT_E_ASN1_CORRUPT);
3005 return FALSE;
3006 }
3007 lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3008 if (1 + lenBytes > cbEncoded)
3009 {
3010 SetLastError(CRYPT_E_ASN1_CORRUPT);
3011 return FALSE;
3012 }
3013 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
3014 {
3015 switch (pbEncoded[0] & ASN_TYPE_MASK)
3016 {
3017 case 1: /* rfc822Name */
3018 case 2: /* dNSName */
3019 case 6: /* uniformResourceIdentifier */
3020 if (memchr(pbEncoded + 1 + lenBytes, 0, dataLen))
3021 {
3022 SetLastError(CRYPT_E_ASN1_RULE);
3023 ret = FALSE;
3024 }
3025 else
3026 bytesNeeded += (dataLen + 1) * sizeof(WCHAR);
3027 break;
3028 case 4: /* directoryName */
3029 case 7: /* iPAddress */
3030 bytesNeeded += dataLen;
3031 break;
3032 case 8: /* registeredID */
3033 ret = CRYPT_AsnDecodeOidIgnoreTag(pbEncoded, cbEncoded, 0, NULL,
3034 &dataLen, NULL);
3035 if (ret)
3036 {
3037 /* FIXME: ugly, shouldn't need to know internals of OID decode
3038 * function to use it.
3039 */
3040 bytesNeeded += dataLen - sizeof(LPSTR);
3041 }
3042 break;
3043 case 0: /* otherName */
3044 FIXME("%d: stub\n", pbEncoded[0] & ASN_TYPE_MASK);
3045 SetLastError(CRYPT_E_ASN1_BADTAG);
3046 ret = FALSE;
3047 break;
3048 case 3: /* x400Address, unimplemented */
3049 case 5: /* ediPartyName, unimplemented */
3050 TRACE("type %d unimplemented\n", pbEncoded[0] & ASN_TYPE_MASK);
3051 SetLastError(CRYPT_E_ASN1_BADTAG);
3052 ret = FALSE;
3053 break;
3054 default:
3055 TRACE("type %d bad\n", pbEncoded[0] & ASN_TYPE_MASK);
3056 SetLastError(CRYPT_E_ASN1_CORRUPT);
3057 ret = FALSE;
3058 }
3059 if (ret)
3060 {
3061 if (pcbDecoded)
3062 *pcbDecoded = 1 + lenBytes + dataLen;
3063 if (!entry)
3064 *pcbStructInfo = bytesNeeded;
3065 else if (*pcbStructInfo < bytesNeeded)
3066 {
3067 *pcbStructInfo = bytesNeeded;
3068 SetLastError(ERROR_MORE_DATA);
3069 ret = FALSE;
3070 }
3071 else
3072 {
3073 *pcbStructInfo = bytesNeeded;
3074 /* MS used values one greater than the asn1 ones.. sigh */
3075 entry->dwAltNameChoice = (pbEncoded[0] & ASN_TYPE_MASK) + 1;
3076 switch (pbEncoded[0] & ASN_TYPE_MASK)
3077 {
3078 case 1: /* rfc822Name */
3079 case 2: /* dNSName */
3080 case 6: /* uniformResourceIdentifier */
3081 {
3082 DWORD i;
3083
3084 for (i = 0; i < dataLen; i++)
3085 entry->pwszURL[i] = (WCHAR)pbEncoded[1 + lenBytes + i];
3086 entry->pwszURL[i] = 0;
3087 TRACE("URL is %p (%s)\n", entry->pwszURL,
3088 debugstr_w(entry->pwszURL));
3089 break;
3090 }
3091 case 4: /* directoryName */
3092 /* The data are memory-equivalent with the IPAddress case,
3093 * fall-through
3094 */
3095 case 7: /* iPAddress */
3096 /* The next data pointer is in the pwszURL spot, that is,
3097 * the first 4 bytes. Need to move it to the next spot.
3098 */
3099 entry->IPAddress.pbData = (LPBYTE)entry->pwszURL;
3100 entry->IPAddress.cbData = dataLen;
3101 memcpy(entry->IPAddress.pbData, pbEncoded + 1 + lenBytes,
3102 dataLen);
3103 break;
3104 case 8: /* registeredID */
3105 ret = CRYPT_AsnDecodeOidIgnoreTag(pbEncoded, cbEncoded, 0,
3106 &entry->pszRegisteredID, &dataLen, NULL);
3107 break;
3108 }
3109 }
3110 }
3111 }
3112 return ret;
3113}
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
CRYPT_GetLen
static BOOL CRYPT_GetLen(const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
Definition: decode.c:192
ASN_TYPE_MASK
#define ASN_TYPE_MASK
Definition: decode.c:51
GET_LEN_BYTES
#define GET_LEN_BYTES(b)
Definition: decode.c:116
ERROR_MORE_DATA
#define ERROR_MORE_DATA
Definition: dderror.h:13
entry
uint32_t entry
Definition: isohybrid.c:63
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
memchr
#define memchr(s, c, n)
Definition: mkisofs.h:875
WCHAR
short WCHAR
Definition: pedump.c:58
_CERT_ALT_NAME_ENTRY
Definition: wincrypt.h:341
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
CRYPT_E_ASN1_RULE
#define CRYPT_E_ASN1_RULE
Definition: winerror.h:4512
CRYPT_E_ASN1_BADTAG
#define CRYPT_E_ASN1_BADTAG
Definition: winerror.h:4510

Referenced by CRYPT_AsnDecodeAccessDescription(), CRYPT_AsnDecodeAltNameInternal(), CRYPT_AsnDecodeDistPointName(), and CRYPT_AsnDecodeSubtree().

◆ CRYPT_AsnDecodeAltNameInternal()

static BOOL CRYPT_AsnDecodeAltNameInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3115 of file decode.c.

3118{
3119 BOOL ret;
3120 struct AsnArrayDescriptor arrayDesc = { 0,
3121 offsetof(CERT_ALT_NAME_INFO, cAltEntry),
3122 offsetof(CERT_ALT_NAME_INFO, rgAltEntry),
3123 sizeof(CERT_ALT_NAME_INFO),
3124 CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), TRUE,
3125 offsetof(CERT_ALT_NAME_ENTRY, pwszURL) };
3126
3127 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
3128 pvStructInfo, *pcbStructInfo, pcbDecoded);
3129
3130 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
3131 NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
3132 return ret;
3133}
CRYPT_AsnDecodeArray
static BOOL CRYPT_AsnDecodeArray(const struct AsnArrayDescriptor *arrayDesc, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, const CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:616

Referenced by CRYPT_AsnDecodeAltName(), CRYPT_AsnDecodeAuthorityKeyId2(), and CRYPT_AsnDecodeDistPoint().

◆ CRYPT_AsnDecodeArray()

static BOOL CRYPT_AsnDecodeArray ( const struct AsnArrayDescriptor *  arrayDesc,
const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
const CRYPT_DECODE_PARA *  pDecodePara,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 616 of file decode.c.

620{
621 BOOL ret = TRUE;
622
623 TRACE("%p, %p, %ld, %p, %ld\n", arrayDesc, pbEncoded,
624 cbEncoded, pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
625
626 if (!cbEncoded)
627 {
628 SetLastError(CRYPT_E_ASN1_EOD);
629 ret = FALSE;
630 }
631 else if (!arrayDesc->tag || pbEncoded[0] == arrayDesc->tag)
632 {
633 DWORD dataLen;
634
635 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
636 {
637 DWORD bytesNeeded = arrayDesc->minArraySize, cItems = 0, capacity = 0, decoded;
638 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
639 /* There can be arbitrarily many items, but there is often only one.
640 */
641 struct AsnArrayItemSize itemSize = { 0 }, *itemSizes = &itemSize;
642
643 decoded = 1 + lenBytes;
644 if (dataLen)
645 {
646 const BYTE *ptr;
647 BOOL doneDecoding = FALSE;
648
649 for (ptr = pbEncoded + 1 + lenBytes; ret && !doneDecoding; )
650 {
651 if (dataLen == CMSG_INDEFINITE_LENGTH)
652 {
653 if (ptr[0] == 0)
654 {
655 doneDecoding = TRUE;
656 if (ptr[1] != 0)
657 {
658 SetLastError(CRYPT_E_ASN1_CORRUPT);
659 ret = FALSE;
660 }
661 else
662 decoded += 2;
663 }
664 }
665 else if (ptr - pbEncoded - 1 - lenBytes >= dataLen)
666 doneDecoding = TRUE;
667 if (!doneDecoding)
668 {
669 DWORD itemEncoded, itemDataLen, itemDecoded, size = 0;
670
671 /* Each item decoded may not tolerate extraneous bytes,
672 * so get the length of the next element if known.
673 */
674 if ((ret = CRYPT_GetLengthIndefinite(ptr,
675 cbEncoded - (ptr - pbEncoded), &itemDataLen)))
676 {
677 if (itemDataLen == CMSG_INDEFINITE_LENGTH)
678 itemEncoded = cbEncoded - (ptr - pbEncoded);
679 else
680 itemEncoded = 1 + GET_LEN_BYTES(ptr[1]) +
681 itemDataLen;
682 }
683 if (ret)
684 ret = arrayDesc->decodeFunc(ptr, itemEncoded,
685 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &size,
686 &itemDecoded);
687 if (ret)
688 {
689 /* Ignore an item that failed to decode but the decoder doesn't want to fail the whole process */
690 if (!size)
691 {
692 ptr += itemEncoded;
693 continue;
694 }
695
696 if (++cItems <= 1)
697 itemSizes = &itemSize;
698 else if (itemSizes == &itemSize)
699 {
700 capacity = 1024;
701 itemSizes = CryptMemAlloc(capacity * sizeof(struct AsnArrayItemSize));
702 if (itemSizes) *itemSizes = itemSize;
703 }
704 else if (cItems > capacity)
705 {
706 capacity = capacity * 3 / 2;
707 itemSizes = CryptMemRealloc(itemSizes, capacity * sizeof(struct AsnArrayItemSize));
708 }
709 if (itemSizes)
710 {
711 decoded += itemDecoded;
712 itemSizes[cItems - 1].encodedLen = itemEncoded;
713 itemSizes[cItems - 1].size = size;
714 bytesNeeded += size;
715 ptr += itemEncoded;
716 }
717 else
718 ret = FALSE;
719 }
720 }
721 }
722 }
723 if (ret)
724 {
725 if (pcbDecoded)
726 *pcbDecoded = decoded;
727 if (!pvStructInfo)
728 *pcbStructInfo = bytesNeeded;
729 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
730 pvStructInfo, pcbStructInfo, bytesNeeded)))
731 {
732 DWORD i, *pcItems;
733 BYTE *nextData;
734 const BYTE *ptr;
735 void *rgItems;
736
737 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
738 pvStructInfo = *(void **)pvStructInfo;
739 pcItems = pvStructInfo;
740 *pcItems = cItems;
741 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
742 {
743 rgItems = (BYTE *)pvStructInfo +
744 arrayDesc->minArraySize;
745 *(void **)((BYTE *)pcItems -
746 arrayDesc->countOffset + arrayDesc->arrayOffset) =
747 rgItems;
748 }
749 else
750 rgItems = *(void **)((BYTE *)pcItems -
751 arrayDesc->countOffset + arrayDesc->arrayOffset);
752 nextData = (BYTE *)rgItems + cItems * arrayDesc->itemSize;
753 for (i = 0, ptr = pbEncoded + 1 + lenBytes; ret &&
754 i < cItems && ptr - pbEncoded - 1 - lenBytes <
755 dataLen; i++)
756 {
757 DWORD itemDecoded;
758
759 if (arrayDesc->hasPointer)
760 *(BYTE **)((BYTE *)rgItems + i * arrayDesc->itemSize
761 + arrayDesc->pointerOffset) = nextData;
762 ret = arrayDesc->decodeFunc(ptr,
763 itemSizes[i].encodedLen,
764 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
765 (BYTE *)rgItems + i * arrayDesc->itemSize,
766 &itemSizes[i].size, &itemDecoded);
767 if (ret)
768 {
769 nextData += itemSizes[i].size - arrayDesc->itemSize;
770 ptr += itemDecoded;
771 }
772 }
773 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
774 CRYPT_FreeSpace(pDecodePara, pvStructInfo);
775 }
776 }
777 if (itemSizes != &itemSize)
778 CryptMemFree(itemSizes);
779 }
780 }
781 else
782 {
783 SetLastError(CRYPT_E_ASN1_BADTAG);
784 ret = FALSE;
785 }
786 return ret;
787}
CRYPT_GetLengthIndefinite
static BOOL CRYPT_GetLengthIndefinite(const BYTE *pbEncoded, DWORD cbEncoded, DWORD *len)
Definition: decode.c:124
CryptMemAlloc
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:136
CryptMemRealloc
LPVOID WINAPI CryptMemRealloc(LPVOID pv, ULONG cbSize)
Definition: main.c:141
CryptMemFree
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:146
size
GLsizeiptr size
Definition: glext.h:5919
ptr
static PVOID ptr
Definition: dispmode.c:27
pcItems
static int int const SCRIPT_CONTROL const SCRIPT_STATE SCRIPT_ITEM ULONG int * pcItems
Definition: usp10.c:62
for
for(i=0;i< sizeof(testsuite)/sizeof(testsuite[0]);++i) ok(call_test(testsuite[i].func)
AsnArrayDescriptor::pointerOffset
DWORD pointerOffset
Definition: decode.c:604
AsnArrayDescriptor::arrayOffset
DWORD arrayOffset
Definition: decode.c:599
AsnArrayDescriptor::minArraySize
DWORD minArraySize
Definition: decode.c:600
AsnArrayDescriptor::countOffset
DWORD countOffset
Definition: decode.c:598
AsnArrayDescriptor::decodeFunc
InternalDecodeFunc decodeFunc
Definition: decode.c:601
AsnArrayItemSize::encodedLen
DWORD encodedLen
Definition: decode.c:609
CMSG_INDEFINITE_LENGTH
#define CMSG_INDEFINITE_LENGTH
Definition: wincrypt.h:3813
CRYPT_E_ASN1_EOD
#define CRYPT_E_ASN1_EOD
Definition: winerror.h:4501

Referenced by CRYPT_AsnDecodeAltNameInternal(), CRYPT_AsnDecodeAuthorityInfoAccess(), CRYPT_AsnDecodeCertExtensionsInternal(), CRYPT_AsnDecodeCertPolicies(), CRYPT_AsnDecodeCertPolicyMappings(), CRYPT_AsnDecodeCMSCertEncoded(), CRYPT_AsnDecodeCMSCrlEncoded(), CRYPT_AsnDecodeCRLDistPoints(), CRYPT_AsnDecodeCRLEntries(), CRYPT_AsnDecodeCRLEntryExtensions(), CRYPT_AsnDecodeCRLExtensionsInternal(), CRYPT_AsnDecodeCTLEntries(), CRYPT_AsnDecodeCTLEntryAttributes(), CRYPT_AsnDecodeCTLExtensionsInternal(), CRYPT_AsnDecodeCTLUsage(), CRYPT_AsnDecodeDistPointName(), CRYPT_AsnDecodeEnhancedKeyUsage(), CRYPT_AsnDecodeExcludedSubtree(), CRYPT_AsnDecodeExtensions(), CRYPT_AsnDecodeName(), CRYPT_AsnDecodeNoticeNumbers(), CRYPT_AsnDecodeOCSPBasicResponseEntriesArray(), CRYPT_AsnDecodeOCSPSignatureInfoCertEncoded(), CRYPT_AsnDecodePermittedSubtree(), CRYPT_AsnDecodePKCSAttributes(), CRYPT_AsnDecodePKCSAttributesInternal(), CRYPT_AsnDecodePKCSAttributeValue(), CRYPT_AsnDecodePolicyQualifiers(), CRYPT_AsnDecodeRdn(), CRYPT_AsnDecodeSMIMECapabilities(), CRYPT_AsnDecodeSubtreeConstraints(), CRYPT_AsnDecodeUnicodeName(), CRYPT_AsnDecodeUnicodeRdn(), CRYPT_DecodeRecipientInfoArray(), and CRYPT_DecodeSignerArray().

◆ CRYPT_AsnDecodeAuthorityInfoAccess()

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

Definition at line 3226 of file decode.c.

3229{
3230 BOOL ret;
3231
3232 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3233 pDecodePara, pvStructInfo, *pcbStructInfo);
3234
3235 __TRY
3236 {
3237 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3238 offsetof(CERT_AUTHORITY_INFO_ACCESS, cAccDescr),
3239 offsetof(CERT_AUTHORITY_INFO_ACCESS, rgAccDescr),
3240 sizeof(CERT_AUTHORITY_INFO_ACCESS),
3241 CRYPT_AsnDecodeAccessDescription, sizeof(CERT_ACCESS_DESCRIPTION),
3242 TRUE, offsetof(CERT_ACCESS_DESCRIPTION, pszAccessMethod) };
3243 CERT_AUTHORITY_INFO_ACCESS *info = pvStructInfo;
3244
3245 if (pvStructInfo && !(dwFlags & CRYPT_DECODE_ALLOC_FLAG))
3246 info->rgAccDescr = (CERT_ACCESS_DESCRIPTION *)(info + 1);
3247 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
3248 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo, NULL);
3249 }
3250 __EXCEPT_PAGE_FAULT
3251 {
3252 SetLastError(STATUS_ACCESS_VIOLATION);
3253 ret = FALSE;
3254 }
3255 __ENDTRY
3256 return ret;
3257}
CRYPT_AsnDecodeAccessDescription
static BOOL CRYPT_AsnDecodeAccessDescription(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3207
ASN_SEQUENCEOF
#define ASN_SEQUENCEOF
Definition: snmp.h:111
_CERT_AUTHORITY_INFO_ACCESS
Definition: wincrypt.h:482
CERT_AUTHORITY_INFO_ACCESS
struct _CERT_AUTHORITY_INFO_ACCESS CERT_AUTHORITY_INFO_ACCESS

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeAuthorityKeyId()

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

Definition at line 3135 of file decode.c.

3138{
3139 BOOL ret;
3140
3141 __TRY
3142 {
3143 struct AsnDecodeSequenceItem items[] = {
3144 { ASN_CONTEXT | 0, offsetof(CERT_AUTHORITY_KEY_ID_INFO, KeyId),
3145 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DATA_BLOB),
3146 TRUE, TRUE, offsetof(CERT_AUTHORITY_KEY_ID_INFO, KeyId.pbData), 0 },
3147 { ASN_CONTEXT | ASN_CONSTRUCTOR| 1,
3148 offsetof(CERT_AUTHORITY_KEY_ID_INFO, CertIssuer),
3149 CRYPT_AsnDecodeOctets, sizeof(CERT_NAME_BLOB), TRUE, TRUE,
3150 offsetof(CERT_AUTHORITY_KEY_ID_INFO, CertIssuer.pbData), 0 },
3151 { ASN_CONTEXT | 2, offsetof(CERT_AUTHORITY_KEY_ID_INFO,
3152 CertSerialNumber), CRYPT_AsnDecodeIntegerInternal,
3153 sizeof(CRYPT_INTEGER_BLOB), TRUE, TRUE,
3154 offsetof(CERT_AUTHORITY_KEY_ID_INFO, CertSerialNumber.pbData), 0 },
3155 };
3156
3157 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3158 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3159 pcbStructInfo, NULL, NULL);
3160 }
3161 __EXCEPT_PAGE_FAULT
3162 {
3163 SetLastError(STATUS_ACCESS_VIOLATION);
3164 ret = FALSE;
3165 }
3166 __ENDTRY
3167 return ret;
3168}
CRYPT_AsnDecodeOctets
static BOOL CRYPT_AsnDecodeOctets(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:4178
CRYPT_AsnDecodeIntegerInternal
static BOOL CRYPT_AsnDecodeIntegerInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:4570
ASN_CONSTRUCTOR
#define ASN_CONSTRUCTOR
Definition: snmp.h:92
ASN_CONTEXT
#define ASN_CONTEXT
Definition: snmp.h:89
_CERT_AUTHORITY_KEY_ID_INFO
Definition: wincrypt.h:290
CRYPT_INTEGER_BLOB
struct _CRYPTOAPI_BLOB CRYPT_INTEGER_BLOB
CRYPT_DATA_BLOB
struct _CRYPTOAPI_BLOB CRYPT_DATA_BLOB
CERT_NAME_BLOB
struct _CRYPTOAPI_BLOB CERT_NAME_BLOB

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeAuthorityKeyId2()

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

Definition at line 3170 of file decode.c.

3173{
3174 BOOL ret;
3175
3176 __TRY
3177 {
3178 struct AsnDecodeSequenceItem items[] = {
3179 { ASN_CONTEXT | 0, offsetof(CERT_AUTHORITY_KEY_ID2_INFO, KeyId),
3180 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DATA_BLOB),
3181 TRUE, TRUE, offsetof(CERT_AUTHORITY_KEY_ID2_INFO, KeyId.pbData), 0 },
3182 { ASN_CONTEXT | ASN_CONSTRUCTOR| 1,
3183 offsetof(CERT_AUTHORITY_KEY_ID2_INFO, AuthorityCertIssuer),
3184 CRYPT_AsnDecodeAltNameInternal, sizeof(CERT_ALT_NAME_INFO), TRUE,
3185 TRUE, offsetof(CERT_AUTHORITY_KEY_ID2_INFO,
3186 AuthorityCertIssuer.rgAltEntry), 0 },
3187 { ASN_CONTEXT | 2, offsetof(CERT_AUTHORITY_KEY_ID2_INFO,
3188 AuthorityCertSerialNumber), CRYPT_AsnDecodeIntegerInternal,
3189 sizeof(CRYPT_INTEGER_BLOB), TRUE, TRUE,
3190 offsetof(CERT_AUTHORITY_KEY_ID2_INFO,
3191 AuthorityCertSerialNumber.pbData), 0 },
3192 };
3193
3194 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3195 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3196 pcbStructInfo, NULL, NULL);
3197 }
3198 __EXCEPT_PAGE_FAULT
3199 {
3200 SetLastError(STATUS_ACCESS_VIOLATION);
3201 ret = FALSE;
3202 }
3203 __ENDTRY
3204 return ret;
3205}
_CERT_AUTHORITY_KEY_ID2_INFO
Definition: wincrypt.h:471

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeBasicConstraints()

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

Definition at line 3516 of file decode.c.

3519{
3520 BOOL ret;
3521
3522 __TRY
3523 {
3524 struct AsnDecodeSequenceItem items[] = {
3525 { ASN_BITSTRING, offsetof(CERT_BASIC_CONSTRAINTS_INFO, SubjectType),
3526 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
3527 offsetof(CERT_BASIC_CONSTRAINTS_INFO, SubjectType.pbData), 0 },
3528 { ASN_INTEGER, offsetof(CERT_BASIC_CONSTRAINTS_INFO,
3529 fPathLenConstraint), CRYPT_AsnDecodePathLenConstraint,
3530 sizeof(struct PATH_LEN_CONSTRAINT), TRUE, FALSE, 0, 0 },
3531 { ASN_SEQUENCEOF, offsetof(CERT_BASIC_CONSTRAINTS_INFO,
3532 cSubtreesConstraint), CRYPT_AsnDecodeSubtreeConstraints,
3533 FINALMEMBERSIZE(CERT_BASIC_CONSTRAINTS_INFO, cSubtreesConstraint),
3534 TRUE, TRUE,
3535 offsetof(CERT_BASIC_CONSTRAINTS_INFO, rgSubtreesConstraint), 0 },
3536 };
3537
3538 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3539 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3540 pcbStructInfo, NULL, NULL);
3541 }
3542 __EXCEPT_PAGE_FAULT
3543 {
3544 SetLastError(STATUS_ACCESS_VIOLATION);
3545 ret = FALSE;
3546 }
3547 __ENDTRY
3548 return ret;
3549}
CRYPT_AsnDecodeBitsInternal
static BOOL CRYPT_AsnDecodeBitsInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:4369
FINALMEMBERSIZE
#define FINALMEMBERSIZE(s, member)
Definition: decode.c:301
CRYPT_AsnDecodePathLenConstraint
static BOOL CRYPT_AsnDecodePathLenConstraint(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3456
CRYPT_AsnDecodeSubtreeConstraints
static BOOL CRYPT_AsnDecodeSubtreeConstraints(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3495
ASN_BITSTRING
#define ASN_BITSTRING
Definition: crypt32_private.h:31
ASN_INTEGER
#define ASN_INTEGER
Definition: snmp.h:103
PATH_LEN_CONSTRAINT
Definition: decode.c:3451
_CERT_BASIC_CONSTRAINTS_INFO
Definition: wincrypt.h:379
CRYPT_BIT_BLOB
struct _CRYPT_BIT_BLOB CRYPT_BIT_BLOB

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeBasicConstraints2()

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

Definition at line 3551 of file decode.c.

3554{
3555 BOOL ret;
3556
3557 __TRY
3558 {
3559 struct AsnDecodeSequenceItem items[] = {
3560 { ASN_BOOL, offsetof(CERT_BASIC_CONSTRAINTS2_INFO, fCA),
3561 CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE, FALSE, 0, 0 },
3562 { ASN_INTEGER, offsetof(CERT_BASIC_CONSTRAINTS2_INFO,
3563 fPathLenConstraint), CRYPT_AsnDecodePathLenConstraint,
3564 sizeof(struct PATH_LEN_CONSTRAINT), TRUE, FALSE, 0, 0 },
3565 };
3566
3567 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3568 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3569 pcbStructInfo, NULL, NULL);
3570 }
3571 __EXCEPT_PAGE_FAULT
3572 {
3573 SetLastError(STATUS_ACCESS_VIOLATION);
3574 ret = FALSE;
3575 }
3576 __ENDTRY
3577 return ret;
3578}
CRYPT_AsnDecodeBool
static BOOL CRYPT_AsnDecodeBool(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2949
ASN_BOOL
#define ASN_BOOL
Definition: crypt32_private.h:30
BOOL
#define BOOL
Definition: nt_native.h:43
_CERT_BASIC_CONSTRAINTS2_INFO
Definition: wincrypt.h:390

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeBits()

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

Definition at line 4424 of file decode.c.

4427{
4428 BOOL ret;
4429
4430 TRACE("(%p, %ld, 0x%08lx, %p, %p, %p)\n", pbEncoded, cbEncoded, dwFlags,
4431 pDecodePara, pvStructInfo, pcbStructInfo);
4432
4433 __TRY
4434 {
4435 DWORD bytesNeeded = 0;
4436
4437 if (!cbEncoded)
4438 {
4439 SetLastError(CRYPT_E_ASN1_CORRUPT);
4440 ret = FALSE;
4441 }
4442 else if (pbEncoded[0] != ASN_BITSTRING)
4443 {
4444 SetLastError(CRYPT_E_ASN1_BADTAG);
4445 ret = FALSE;
4446 }
4447 else if ((ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
4448 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
4449 {
4450 if (!pvStructInfo)
4451 *pcbStructInfo = bytesNeeded;
4452 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4453 pvStructInfo, pcbStructInfo, bytesNeeded)))
4454 {
4455 CRYPT_BIT_BLOB *blob;
4456
4457 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4458 pvStructInfo = *(BYTE **)pvStructInfo;
4459 blob = pvStructInfo;
4460 blob->pbData = (BYTE *)pvStructInfo + sizeof(CRYPT_BIT_BLOB);
4461 ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
4462 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
4463 &bytesNeeded, NULL);
4464 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
4465 CRYPT_FreeSpace(pDecodePara, blob);
4466 }
4467 }
4468 }
4469 __EXCEPT_PAGE_FAULT
4470 {
4471 SetLastError(STATUS_ACCESS_VIOLATION);
4472 ret = FALSE;
4473 }
4474 __ENDTRY
4475 TRACE("returning %d (%08lx)\n", ret, GetLastError());
4476 return ret;
4477}
_CRYPT_BIT_BLOB
Definition: wincrypt.h:204
blob
Definition: image.c:134
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeBitsInternal()

static BOOL CRYPT_AsnDecodeBitsInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 4369 of file decode.c.

4371{
4372 BOOL ret;
4373 DWORD bytesNeeded, dataLen;
4374 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4375
4376 TRACE("(%p, %ld, 0x%08lx, %p, %ld, %p)\n", pbEncoded, cbEncoded, dwFlags,
4377 pvStructInfo, *pcbStructInfo, pcbDecoded);
4378
4379 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4380 {
4381 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
4382 bytesNeeded = sizeof(CRYPT_BIT_BLOB);
4383 else
4384 bytesNeeded = dataLen - 1 + sizeof(CRYPT_BIT_BLOB);
4385 if (pcbDecoded)
4386 *pcbDecoded = 1 + lenBytes + dataLen;
4387 if (!pvStructInfo)
4388 *pcbStructInfo = bytesNeeded;
4389 else if (*pcbStructInfo < bytesNeeded)
4390 {
4391 *pcbStructInfo = bytesNeeded;
4392 SetLastError(ERROR_MORE_DATA);
4393 ret = FALSE;
4394 }
4395 else
4396 {
4397 CRYPT_BIT_BLOB *blob;
4398
4399 *pcbStructInfo = bytesNeeded;
4400 blob = pvStructInfo;
4401 blob->cbData = dataLen - 1;
4402 blob->cUnusedBits = *(pbEncoded + 1 + lenBytes);
4403 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
4404 {
4405 blob->pbData = (BYTE *)pbEncoded + 2 + lenBytes;
4406 }
4407 else
4408 {
4409 assert(blob->pbData);
4410 if (blob->cbData)
4411 {
4412 BYTE mask = 0xff << blob->cUnusedBits;
4413
4414 memcpy(blob->pbData, pbEncoded + 2 + lenBytes,
4415 blob->cbData);
4416 blob->pbData[blob->cbData - 1] &= mask;
4417 }
4418 }
4419 }
4420 }
4421 return ret;
4422}
assert
#define assert(_expr)
Definition: assert.h:32
mask
GLenum GLint GLuint mask
Definition: glext.h:6028
CRYPT_DECODE_NOCOPY_FLAG
#define CRYPT_DECODE_NOCOPY_FLAG
Definition: wincrypt.h:3608

Referenced by CRYPT_AsnDecodeBasicConstraints(), CRYPT_AsnDecodeBits(), CRYPT_AsnDecodeBitsSwapBytes(), CRYPT_AsnDecodeCertInfo(), CRYPT_AsnDecodeCertSignedContent(), CRYPT_AsnDecodeDistPoint(), CRYPT_AsnDecodeIssuingDistPoint(), CRYPT_AsnDecodeOCSPBasicSignedResponse(), and CRYPT_AsnDecodePubKeyInfoInternal().

◆ CRYPT_AsnDecodeBitsSwapBytes()

static BOOL CRYPT_AsnDecodeBitsSwapBytes ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 842 of file decode.c.

845{
846 BOOL ret;
847
848 TRACE("(%p, %ld, 0x%08lx, %p, %ld, %p)\n", pbEncoded, cbEncoded, dwFlags,
849 pvStructInfo, *pcbStructInfo, pcbDecoded);
850
851 /* Can't use the CRYPT_DECODE_NOCOPY_FLAG, because we modify the bytes in-
852 * place.
853 */
854 ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
855 dwFlags & ~CRYPT_DECODE_NOCOPY_FLAG, pvStructInfo, pcbStructInfo,
856 pcbDecoded);
857 if (ret && pvStructInfo)
858 {
859 CRYPT_BIT_BLOB *blob = pvStructInfo;
860
861 if (blob->cbData)
862 {
863 DWORD i;
864 BYTE temp;
865
866 for (i = 0; i < blob->cbData / 2; i++)
867 {
868 temp = blob->pbData[i];
869 blob->pbData[i] = blob->pbData[blob->cbData - i - 1];
870 blob->pbData[blob->cbData - i - 1] = temp;
871 }
872 }
873 }
874 TRACE("returning %d (%08lx)\n", ret, GetLastError());
875 return ret;
876}
temp
static calc_node_t temp
Definition: rpn_ieee.c:38

Referenced by CRYPT_AsnDecodeCertSignedContent().

◆ CRYPT_AsnDecodeBool()

static BOOL CRYPT_AsnDecodeBool ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2949 of file decode.c.

2951{
2952 BOOL ret;
2953
2954 if (cbEncoded < 3)
2955 {
2956 SetLastError(CRYPT_E_ASN1_CORRUPT);
2957 return FALSE;
2958 }
2959 if (GET_LEN_BYTES(pbEncoded[1]) > 1)
2960 {
2961 SetLastError(CRYPT_E_ASN1_CORRUPT);
2962 return FALSE;
2963 }
2964 if (pbEncoded[1] > 1)
2965 {
2966 SetLastError(CRYPT_E_ASN1_CORRUPT);
2967 return FALSE;
2968 }
2969 if (pcbDecoded)
2970 *pcbDecoded = 3;
2971 if (!pvStructInfo)
2972 {
2973 *pcbStructInfo = sizeof(BOOL);
2974 ret = TRUE;
2975 }
2976 else if (*pcbStructInfo < sizeof(BOOL))
2977 {
2978 *pcbStructInfo = sizeof(BOOL);
2979 SetLastError(ERROR_MORE_DATA);
2980 ret = FALSE;
2981 }
2982 else
2983 {
2984 *pcbStructInfo = sizeof(BOOL);
2985 *(BOOL *)pvStructInfo = pbEncoded[2] != 0;
2986 ret = TRUE;
2987 }
2988 TRACE("returning %d (%08lx)\n", ret, GetLastError());
2989 return ret;
2990}

Referenced by CRYPT_AsnDecodeBasicConstraints2(), CRYPT_AsnDecodeExtension(), and CRYPT_AsnDecodeIssuingDistPoint().

◆ CRYPT_AsnDecodeCert()

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

Definition at line 1060 of file decode.c.

1063{
1064 BOOL ret = FALSE;
1065
1066 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1067 pDecodePara, pvStructInfo, *pcbStructInfo);
1068
1069 __TRY
1070 {
1071 DWORD size = 0;
1072
1073 /* Unless told not to, first try to decode it as a signed cert. */
1074 if (!(dwFlags & CRYPT_DECODE_TO_BE_SIGNED_FLAG))
1075 {
1076 PCERT_SIGNED_CONTENT_INFO signedCert = NULL;
1077
1078 ret = CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType,
1079 X509_CERT, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
1080 &signedCert, &size);
1081 if (ret)
1082 {
1083 size = 0;
1084 ret = CRYPT_AsnDecodeCertInfo(dwCertEncodingType,
1085 X509_CERT_TO_BE_SIGNED, signedCert->ToBeSigned.pbData,
1086 signedCert->ToBeSigned.cbData, dwFlags, pDecodePara,
1087 pvStructInfo, pcbStructInfo);
1088 LocalFree(signedCert);
1089 }
1090 }
1091 /* Failing that, try it as an unsigned cert */
1092 if (!ret)
1093 {
1094 size = 0;
1095 ret = CRYPT_AsnDecodeCertInfo(dwCertEncodingType,
1096 X509_CERT_TO_BE_SIGNED, pbEncoded, cbEncoded, dwFlags,
1097 pDecodePara, pvStructInfo, pcbStructInfo);
1098 }
1099 }
1100 __EXCEPT_PAGE_FAULT
1101 {
1102 SetLastError(STATUS_ACCESS_VIOLATION);
1103 }
1104 __ENDTRY
1105
1106 TRACE("Returning %d (%08lx)\n", ret, GetLastError());
1107 return ret;
1108}
CRYPT_AsnDecodeCertInfo
static BOOL CRYPT_AsnDecodeCertInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:993
CRYPT_AsnDecodeCertSignedContent
static BOOL WINAPI CRYPT_AsnDecodeCertSignedContent(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:878
LocalFree
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
_CERT_SIGNED_CONTENT_INFO
Definition: wincrypt.h:629
_CERT_SIGNED_CONTENT_INFO::ToBeSigned
CRYPT_DER_BLOB ToBeSigned
Definition: wincrypt.h:630
_CRYPTOAPI_BLOB::cbData
DWORD cbData
Definition: wincrypt.h:111
_CRYPTOAPI_BLOB::pbData
BYTE * pbData
Definition: wincrypt.h:112
X509_CERT_TO_BE_SIGNED
#define X509_CERT_TO_BE_SIGNED
Definition: wincrypt.h:3518
X509_CERT
#define X509_CERT
Definition: wincrypt.h:3517
CRYPT_DECODE_TO_BE_SIGNED_FLAG
#define CRYPT_DECODE_TO_BE_SIGNED_FLAG
Definition: wincrypt.h:3609

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeCertExtensions()

static BOOL CRYPT_AsnDecodeCertExtensions ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 974 of file decode.c.

977{
978 BOOL ret;
979 DWORD dataLen;
980
981 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
982 {
983 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
984
985 ret = CRYPT_AsnDecodeCertExtensionsInternal(pbEncoded + 1 + lenBytes,
986 dataLen, dwFlags, pvStructInfo, pcbStructInfo, NULL);
987 if (ret && pcbDecoded)
988 *pcbDecoded = 1 + lenBytes + dataLen;
989 }
990 return ret;
991}
CRYPT_AsnDecodeCertExtensionsInternal
static BOOL CRYPT_AsnDecodeCertExtensionsInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:955

Referenced by CRYPT_AsnDecodeCertInfo(), CRYPT_AsnDecodeOCSPBasicResponse(), and CRYPT_AsnDecodeOCSPBasicResponseEntry().

◆ CRYPT_AsnDecodeCertExtensionsInternal()

static BOOL CRYPT_AsnDecodeCertExtensionsInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 955 of file decode.c.

958{
959 BOOL ret = TRUE;
960 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
961 offsetof(CERT_INFO, cExtension), offsetof(CERT_INFO, rgExtension),
962 FINALMEMBERSIZE(CERT_INFO, cExtension),
963 CRYPT_AsnDecodeExtension, sizeof(CERT_EXTENSION), TRUE,
964 offsetof(CERT_EXTENSION, pszObjId) };
965
966 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
967 pvStructInfo, *pcbStructInfo, pcbDecoded);
968
969 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
970 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
971 return ret;
972}
CRYPT_AsnDecodeExtension
static BOOL CRYPT_AsnDecodeExtension(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1425
_CERT_EXTENSION
Definition: wincrypt.h:238
_CERT_INFO
Definition: wincrypt.h:249
CERT_EXTENSION
struct _CERT_EXTENSION CERT_EXTENSION

Referenced by CRYPT_AsnDecodeCertExtensions().

◆ CRYPT_AsnDecodeCertInfo()

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

Definition at line 993 of file decode.c.

996{
997 BOOL ret = TRUE;
998 struct AsnDecodeSequenceItem items[] = {
999 { ASN_CONTEXT | ASN_CONSTRUCTOR, offsetof(CERT_INFO, dwVersion),
1000 CRYPT_AsnDecodeCertVersion, sizeof(DWORD), TRUE, FALSE, 0, 0 },
1001 { ASN_INTEGER, offsetof(CERT_INFO, SerialNumber),
1002 CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE,
1003 TRUE, offsetof(CERT_INFO, SerialNumber.pbData), 0 },
1004 { ASN_SEQUENCEOF, offsetof(CERT_INFO, SignatureAlgorithm),
1005 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
1006 FALSE, TRUE, offsetof(CERT_INFO, SignatureAlgorithm.pszObjId), 0 },
1007 { 0, offsetof(CERT_INFO, Issuer), CRYPT_AsnDecodeDerBlob,
1008 sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CERT_INFO,
1009 Issuer.pbData) },
1010 { ASN_SEQUENCEOF, offsetof(CERT_INFO, NotBefore),
1011 CRYPT_AsnDecodeValidity, sizeof(CERT_PRIVATE_KEY_VALIDITY), FALSE,
1012 FALSE, 0 },
1013 { 0, offsetof(CERT_INFO, Subject), CRYPT_AsnDecodeDerBlob,
1014 sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CERT_INFO,
1015 Subject.pbData) },
1016 { ASN_SEQUENCEOF, offsetof(CERT_INFO, SubjectPublicKeyInfo),
1017 CRYPT_AsnDecodePubKeyInfoInternal, sizeof(CERT_PUBLIC_KEY_INFO),
1018 FALSE, TRUE, offsetof(CERT_INFO,
1019 SubjectPublicKeyInfo.Algorithm.Parameters.pbData), 0 },
1020 { ASN_CONTEXT | 1, offsetof(CERT_INFO, IssuerUniqueId),
1021 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
1022 offsetof(CERT_INFO, IssuerUniqueId.pbData), 0 },
1023 { ASN_CONTEXT | 2, offsetof(CERT_INFO, SubjectUniqueId),
1024 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
1025 offsetof(CERT_INFO, SubjectUniqueId.pbData), 0 },
1026 { ASN_CONTEXT | ASN_CONSTRUCTOR | 3, offsetof(CERT_INFO, cExtension),
1027 CRYPT_AsnDecodeCertExtensions, FINALMEMBERSIZE(CERT_INFO, cExtension),
1028 TRUE, TRUE, offsetof(CERT_INFO, rgExtension), 0 },
1029 };
1030
1031 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1032 pDecodePara, pvStructInfo, *pcbStructInfo);
1033
1034 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
1035 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo,
1036 NULL, NULL);
1037 if (ret && pvStructInfo)
1038 {
1039 CERT_INFO *info;
1040
1041 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1042 info = *(CERT_INFO **)pvStructInfo;
1043 else
1044 info = pvStructInfo;
1045 if (!info->SerialNumber.cbData || !info->Issuer.cbData ||
1046 !info->Subject.cbData)
1047 {
1048 SetLastError(CRYPT_E_ASN1_CORRUPT);
1049 /* Don't need to deallocate, because it should have failed on the
1050 * first pass (and no memory was allocated.)
1051 */
1052 ret = FALSE;
1053 }
1054 }
1055
1056 TRACE("Returning %d (%08lx)\n", ret, GetLastError());
1057 return ret;
1058}
CRYPT_AsnDecodePubKeyInfoInternal
static BOOL CRYPT_AsnDecodePubKeyInfoInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2885
CRYPT_AsnDecodeValidity
static BOOL CRYPT_AsnDecodeValidity(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:937
CRYPT_AsnDecodeAlgorithmId
static BOOL CRYPT_AsnDecodeAlgorithmId(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2857
CRYPT_AsnDecodeDerBlob
static BOOL CRYPT_AsnDecodeDerBlob(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:795
CRYPT_AsnDecodeCertExtensions
static BOOL CRYPT_AsnDecodeCertExtensions(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:974
CRYPT_AsnDecodeCertVersion
static BOOL CRYPT_AsnDecodeCertVersion(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:919
dwVersion
_In_ DWORD dwVersion
Definition: netsh.h:85
DWORD
#define DWORD
Definition: nt_native.h:44
SerialNumber
ULONG SerialNumber
Definition: rxce.c:117
CRYPT_DER_BLOB
struct _CRYPTOAPI_BLOB CRYPT_DER_BLOB
CERT_PRIVATE_KEY_VALIDITY
struct _CERT_PRIVATE_KEY_VALIDITY CERT_PRIVATE_KEY_VALIDITY
CERT_PUBLIC_KEY_INFO
struct _CERT_PUBLIC_KEY_INFO CERT_PUBLIC_KEY_INFO
CRYPT_ALGORITHM_IDENTIFIER
struct _CRYPT_ALGORITHM_IDENTIFIER CRYPT_ALGORITHM_IDENTIFIER

Referenced by CRYPT_AsnDecodeCert().

◆ CRYPT_AsnDecodeCertPolicies()

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

Definition at line 3650 of file decode.c.

3653{
3654 BOOL ret = FALSE;
3655
3656 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3657 pDecodePara, pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3658
3659 __TRY
3660 {
3661 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3662 offsetof(CERT_POLICIES_INFO, cPolicyInfo),
3663 offsetof(CERT_POLICIES_INFO, rgPolicyInfo),
3664 sizeof(CERT_POLICIES_INFO),
3665 CRYPT_AsnDecodeCertPolicy, sizeof(CERT_POLICY_INFO), TRUE,
3666 offsetof(CERT_POLICY_INFO, pszPolicyIdentifier) };
3667 CERT_POLICIES_INFO *info = pvStructInfo;
3668
3669 if (pvStructInfo && !(dwFlags & CRYPT_DECODE_ALLOC_FLAG))
3670 info->rgPolicyInfo = (CERT_POLICY_INFO *)(info + 1);
3671
3672 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
3673 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo, NULL);
3674 }
3675 __EXCEPT_PAGE_FAULT
3676 {
3677 SetLastError(STATUS_ACCESS_VIOLATION);
3678 }
3679 __ENDTRY
3680 return ret;
3681}
CRYPT_AsnDecodeCertPolicy
static BOOL CRYPT_AsnDecodeCertPolicy(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3626
_CERT_POLICIES_INFO
Definition: wincrypt.h:407
_CERT_POLICY_INFO
Definition: wincrypt.h:401
CERT_POLICIES_INFO
struct _CERT_POLICIES_INFO CERT_POLICIES_INFO

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeCertPolicy()

static BOOL CRYPT_AsnDecodeCertPolicy ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3626 of file decode.c.

3628{
3629 struct AsnDecodeSequenceItem items[] = {
3630 { ASN_OBJECTIDENTIFIER, offsetof(CERT_POLICY_INFO, pszPolicyIdentifier),
3631 CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), FALSE, TRUE,
3632 offsetof(CERT_POLICY_INFO, pszPolicyIdentifier), 0 },
3633 { ASN_SEQUENCEOF, offsetof(CERT_POLICY_INFO, cPolicyQualifier),
3634 CRYPT_AsnDecodePolicyQualifiers,
3635 FINALMEMBERSIZE(CERT_POLICY_INFO, cPolicyQualifier), TRUE,
3636 TRUE, offsetof(CERT_POLICY_INFO, rgPolicyQualifier), 0 },
3637 };
3638 CERT_POLICY_INFO *info = pvStructInfo;
3639 BOOL ret;
3640
3641 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3642 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3643
3644 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3645 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3646 pcbDecoded, info ? info->pszPolicyIdentifier : NULL);
3647 return ret;
3648}
CRYPT_AsnDecodePolicyQualifiers
static BOOL CRYPT_AsnDecodePolicyQualifiers(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3605

Referenced by CRYPT_AsnDecodeCertPolicies().

◆ CRYPT_AsnDecodeCertPolicyConstraints()

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

Definition at line 3833 of file decode.c.

3837{
3838 BOOL ret = FALSE;
3839
3840 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3841 pDecodePara, pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3842
3843 __TRY
3844 {
3845 struct AsnDecodeSequenceItem items[] = {
3846 { ASN_CONTEXT | 0,
3847 offsetof(CERT_POLICY_CONSTRAINTS_INFO, fRequireExplicitPolicy),
3848 CRYPT_AsnDecodeRequireExplicit,
3849 MEMBERSIZE(CERT_POLICY_CONSTRAINTS_INFO, fRequireExplicitPolicy,
3850 fInhibitPolicyMapping), TRUE, FALSE, 0, 0 },
3851 { ASN_CONTEXT | 1,
3852 offsetof(CERT_POLICY_CONSTRAINTS_INFO, fInhibitPolicyMapping),
3853 CRYPT_AsnDecodeInhibitMapping,
3854 FINALMEMBERSIZE(CERT_POLICY_CONSTRAINTS_INFO, fInhibitPolicyMapping),
3855 TRUE, FALSE, 0, 0 },
3856 };
3857
3858 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3859 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
3860 pcbStructInfo, NULL, NULL);
3861 }
3862 __EXCEPT_PAGE_FAULT
3863 {
3864 SetLastError(STATUS_ACCESS_VIOLATION);
3865 }
3866 __ENDTRY
3867 return ret;
3868}
MEMBERSIZE
#define MEMBERSIZE(s, member, nextmember)
Definition: decode.c:302
CRYPT_AsnDecodeRequireExplicit
static BOOL CRYPT_AsnDecodeRequireExplicit(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3739
CRYPT_AsnDecodeInhibitMapping
static BOOL CRYPT_AsnDecodeInhibitMapping(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3786
_CERT_POLICY_CONSTRAINTS_INFO
Definition: wincrypt.h:448

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeCertPolicyMapping()

static BOOL CRYPT_AsnDecodeCertPolicyMapping ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3683 of file decode.c.

3686{
3687 struct AsnDecodeSequenceItem items[] = {
3688 { ASN_OBJECTIDENTIFIER, offsetof(CERT_POLICY_MAPPING,
3689 pszIssuerDomainPolicy), CRYPT_AsnDecodeOidInternal, sizeof(LPSTR),
3690 FALSE, TRUE, offsetof(CERT_POLICY_MAPPING, pszIssuerDomainPolicy), 0 },
3691 { ASN_OBJECTIDENTIFIER, offsetof(CERT_POLICY_MAPPING,
3692 pszSubjectDomainPolicy), CRYPT_AsnDecodeOidInternal, sizeof(LPSTR),
3693 FALSE, TRUE, offsetof(CERT_POLICY_MAPPING, pszSubjectDomainPolicy), 0 },
3694 };
3695 CERT_POLICY_MAPPING *mapping = pvStructInfo;
3696 BOOL ret;
3697
3698 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3699 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3700
3701 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3702 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3703 pcbDecoded, mapping ? mapping->pszIssuerDomainPolicy : NULL);
3704 return ret;
3705}
mapping
GLenum GLenum GLenum GLenum mapping
Definition: glext.h:9031
_CERT_POLICY_MAPPING
Definition: wincrypt.h:438

Referenced by CRYPT_AsnDecodeCertPolicyMappings().

◆ CRYPT_AsnDecodeCertPolicyMappings()

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

Definition at line 3707 of file decode.c.

3710{
3711 BOOL ret = FALSE;
3712
3713 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3714 pDecodePara, pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3715
3716 __TRY
3717 {
3718 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3719 offsetof(CERT_POLICY_MAPPINGS_INFO, cPolicyMapping),
3720 offsetof(CERT_POLICY_MAPPINGS_INFO, rgPolicyMapping),
3721 sizeof(CERT_POLICY_MAPPING),
3722 CRYPT_AsnDecodeCertPolicyMapping, sizeof(CERT_POLICY_MAPPING), TRUE,
3723 offsetof(CERT_POLICY_MAPPING, pszIssuerDomainPolicy) };
3724 CERT_POLICY_MAPPINGS_INFO *info = pvStructInfo;
3725
3726 if (pvStructInfo && !(dwFlags & CRYPT_DECODE_ALLOC_FLAG))
3727 info->rgPolicyMapping = (CERT_POLICY_MAPPING *)(info + 1);
3728 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
3729 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo, NULL);
3730 }
3731 __EXCEPT_PAGE_FAULT
3732 {
3733 SetLastError(STATUS_ACCESS_VIOLATION);
3734 }
3735 __ENDTRY
3736 return ret;
3737}
CRYPT_AsnDecodeCertPolicyMapping
static BOOL CRYPT_AsnDecodeCertPolicyMapping(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3683
_CERT_POLICY_MAPPINGS_INFO
Definition: wincrypt.h:443
CERT_POLICY_MAPPING
struct _CERT_POLICY_MAPPING CERT_POLICY_MAPPING

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeCertSignedContent()

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

Definition at line 878 of file decode.c.

881{
882 BOOL ret = TRUE;
883
884 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
885 pDecodePara, pvStructInfo, *pcbStructInfo);
886
887 __TRY
888 {
889 struct AsnDecodeSequenceItem items[] = {
890 { 0, offsetof(CERT_SIGNED_CONTENT_INFO, ToBeSigned),
891 CRYPT_AsnDecodeDerBlob, sizeof(CRYPT_DER_BLOB), FALSE, TRUE,
892 offsetof(CERT_SIGNED_CONTENT_INFO, ToBeSigned.pbData), 0 },
893 { ASN_SEQUENCEOF, offsetof(CERT_SIGNED_CONTENT_INFO,
894 SignatureAlgorithm), CRYPT_AsnDecodeAlgorithmId,
895 sizeof(CRYPT_ALGORITHM_IDENTIFIER), FALSE, TRUE,
896 offsetof(CERT_SIGNED_CONTENT_INFO, SignatureAlgorithm.pszObjId), 0 },
897 { ASN_BITSTRING, offsetof(CERT_SIGNED_CONTENT_INFO, Signature),
898 CRYPT_AsnDecodeBitsSwapBytes, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
899 offsetof(CERT_SIGNED_CONTENT_INFO, Signature.pbData), 0 },
900 };
901
902 if (dwFlags & CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG)
903 items[2].decodeFunc = CRYPT_AsnDecodeBitsInternal;
904 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
905 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
906 pcbStructInfo, NULL, NULL);
907 }
908 __EXCEPT_PAGE_FAULT
909 {
910 SetLastError(STATUS_ACCESS_VIOLATION);
911 ret = FALSE;
912 }
913 __ENDTRY
914
915 TRACE("Returning %d (%08lx)\n", ret, GetLastError());
916 return ret;
917}
CRYPT_AsnDecodeBitsSwapBytes
static BOOL CRYPT_AsnDecodeBitsSwapBytes(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:842
Signature
static const WCHAR Signature[]
Definition: parser.c:141
CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG
#define CRYPT_DECODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG
Definition: wincrypt.h:3611

Referenced by CRYPT_AsnDecodeCert(), CRYPT_AsnDecodeCRL(), and CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeCertStatus()

static BOOL CRYPT_AsnDecodeCertStatus ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6379 of file decode.c.

6382{
6383 BOOL ret = TRUE;
6384 BYTE tag = pbEncoded[0] & ~3, status = pbEncoded[0] & 3;
6385 DWORD bytesNeeded = FIELD_OFFSET(OCSP_BASIC_RESPONSE_ENTRY, ThisUpdate) -
6386 FIELD_OFFSET(OCSP_BASIC_RESPONSE_ENTRY, dwCertStatus);
6387
6388 if (!cbEncoded)
6389 {
6390 SetLastError(CRYPT_E_ASN1_EOD);
6391 return FALSE;
6392 }
6393
6394 switch (status)
6395 {
6396 case 0:
6397 if (tag != ASN_CONTEXT)
6398 {
6399 WARN("Unexpected tag %02x\n", tag);
6400 SetLastError(CRYPT_E_ASN1_BADTAG);
6401 return FALSE;
6402 }
6403 if (cbEncoded < 2 || pbEncoded[1])
6404 {
6405 SetLastError(CRYPT_E_ASN1_CORRUPT);
6406 return FALSE;
6407 }
6408 if (!pvStructInfo)
6409 *pcbStructInfo = bytesNeeded;
6410 else if (*pcbStructInfo < bytesNeeded)
6411 {
6412 *pcbStructInfo = bytesNeeded;
6413 SetLastError(ERROR_MORE_DATA);
6414 return FALSE;
6415 }
6416 if (pvStructInfo)
6417 {
6418 *(DWORD *)pvStructInfo = 0;
6419 *(OCSP_BASIC_REVOKED_INFO **)((char *)pvStructInfo
6420 + FIELD_OFFSET(OCSP_BASIC_RESPONSE_ENTRY, pRevokedInfo)
6421 - FIELD_OFFSET(OCSP_BASIC_RESPONSE_ENTRY, dwCertStatus)) = NULL;
6422 }
6423 *pcbStructInfo = bytesNeeded;
6424 *pcbDecoded = 2;
6425 break;
6426
6427 case 1:
6428 {
6429 DWORD dataLen;
6430
6431 if (tag != (ASN_CONTEXT | ASN_CONSTRUCTOR))
6432 {
6433 WARN("Unexpected tag %02x\n", tag);
6434 SetLastError(CRYPT_E_ASN1_BADTAG);
6435 return FALSE;
6436 }
6437 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
6438 {
6439 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
6440 DWORD bytesDecoded, size;
6441 FILETIME date;
6442
6443 if (dataLen)
6444 {
6445 size = sizeof(date);
6446 ret = CRYPT_AsnDecodeGeneralizedTime(pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
6447 dwFlags, &date, &size, &bytesDecoded);
6448 if (ret)
6449 {
6450 OCSP_BASIC_REVOKED_INFO *info;
6451
6452 bytesNeeded += sizeof(*info);
6453 if (!pvStructInfo)
6454 *pcbStructInfo = bytesNeeded;
6455 else if (*pcbStructInfo < bytesNeeded)
6456 {
6457 *pcbStructInfo = bytesNeeded;
6458 SetLastError(ERROR_MORE_DATA);
6459 return FALSE;
6460 }
6461 if (pvStructInfo)
6462 {
6463 *(DWORD *)pvStructInfo = 1;
6464 info = *(OCSP_BASIC_REVOKED_INFO **)((char *)pvStructInfo
6465 + FIELD_OFFSET(OCSP_BASIC_RESPONSE_ENTRY, pRevokedInfo)
6466 - FIELD_OFFSET(OCSP_BASIC_RESPONSE_ENTRY, dwCertStatus));
6467 info->RevocationDate = date;
6468 }
6469 *pcbStructInfo = bytesNeeded;
6470 *pcbDecoded = 1 + lenBytes + bytesDecoded;
6471 }
6472 }
6473 }
6474 break;
6475 }
6476 default:
6477 FIXME("Unhandled status %u\n", status);
6478 SetLastError(CRYPT_E_ASN1_BADTAG);
6479 return FALSE;
6480 }
6481
6482 return ret;
6483}
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
CRYPT_AsnDecodeGeneralizedTime
static BOOL CRYPT_AsnDecodeGeneralizedTime(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5015
date
__u16 date
Definition: mkdosfs.c:8
_FILETIME
Definition: mapidefs.h:60
_OCSP_BASIC_RESPONSE_ENTRY
Definition: wincrypt.h:700
_OCSP_BASIC_REVOKED_INFO
Definition: wincrypt.h:691
status
Definition: ps.c:97
tag
Definition: ecma_167.h:138
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255

Referenced by CRYPT_AsnDecodeOCSPBasicResponseEntry().

◆ CRYPT_AsnDecodeCertVersion()

static BOOL CRYPT_AsnDecodeCertVersion ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 919 of file decode.c.

921{
922 BOOL ret;
923 DWORD dataLen;
924
925 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
926 {
927 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
928
929 ret = CRYPT_AsnDecodeIntInternal(pbEncoded + 1 + lenBytes, dataLen,
930 dwFlags, pvStructInfo, pcbStructInfo, NULL);
931 if (pcbDecoded)
932 *pcbDecoded = 1 + lenBytes + dataLen;
933 }
934 return ret;
935}
CRYPT_AsnDecodeIntInternal
static BOOL CRYPT_AsnDecodeIntInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:4480

Referenced by CRYPT_AsnDecodeCertInfo().

◆ CRYPT_AsnDecodeChoiceOfTime()

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

Definition at line 5109 of file decode.c.

5112{
5113 BOOL ret;
5114
5115 __TRY
5116 {
5117 DWORD bytesNeeded = 0;
5118
5119 ret = CRYPT_AsnDecodeChoiceOfTimeInternal(pbEncoded, cbEncoded,
5120 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
5121 if (ret)
5122 {
5123 if (!pvStructInfo)
5124 *pcbStructInfo = bytesNeeded;
5125 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
5126 pvStructInfo, pcbStructInfo, bytesNeeded)))
5127 {
5128 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
5129 pvStructInfo = *(BYTE **)pvStructInfo;
5130 ret = CRYPT_AsnDecodeChoiceOfTimeInternal(pbEncoded, cbEncoded,
5131 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
5132 &bytesNeeded, NULL);
5133 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
5134 CRYPT_FreeSpace(pDecodePara, pvStructInfo);
5135 }
5136 }
5137 }
5138 __EXCEPT_PAGE_FAULT
5139 {
5140 SetLastError(STATUS_ACCESS_VIOLATION);
5141 ret = FALSE;
5142 }
5143 __ENDTRY
5144 return ret;
5145}
CRYPT_AsnDecodeChoiceOfTimeInternal
static BOOL CRYPT_AsnDecodeChoiceOfTimeInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5087

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeChoiceOfTimeInternal()

static BOOL CRYPT_AsnDecodeChoiceOfTimeInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5087 of file decode.c.

5090{
5091 BOOL ret;
5092 InternalDecodeFunc decode = NULL;
5093
5094 if (pbEncoded[0] == ASN_UTCTIME)
5095 decode = CRYPT_AsnDecodeUtcTimeInternal;
5096 else if (pbEncoded[0] == ASN_GENERALTIME)
5097 decode = CRYPT_AsnDecodeGeneralizedTime;
5098 if (decode)
5099 ret = decode(pbEncoded, cbEncoded, dwFlags, pvStructInfo,
5100 pcbStructInfo, pcbDecoded);
5101 else
5102 {
5103 SetLastError(CRYPT_E_ASN1_BADTAG);
5104 ret = FALSE;
5105 }
5106 return ret;
5107}
decode
static BYTE decode(char c)
Definition: base64_codec.c:97
CRYPT_AsnDecodeUtcTimeInternal
static BOOL CRYPT_AsnDecodeUtcTimeInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:4912
InternalDecodeFunc
BOOL(* InternalDecodeFunc)(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:72
ASN_UTCTIME
#define ASN_UTCTIME
Definition: crypt32_private.h:40
ASN_GENERALTIME
#define ASN_GENERALTIME
Definition: crypt32_private.h:41

Referenced by CRYPT_AsnDecodeChoiceOfTime(), CRYPT_AsnDecodeCRLEntry(), CRYPT_AsnDecodeCRLInfo(), CRYPT_AsnDecodeCTL(), and CRYPT_AsnDecodeValidity().

◆ CRYPT_AsnDecodeCMSCertEncoded()

static BOOL CRYPT_AsnDecodeCMSCertEncoded ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5751 of file decode.c.

5754{
5755 BOOL ret;
5756 struct AsnArrayDescriptor arrayDesc = { 0,
5757 offsetof(CRYPT_SIGNED_INFO, cCertEncoded),
5758 offsetof(CRYPT_SIGNED_INFO, rgCertEncoded),
5759 MEMBERSIZE(CRYPT_SIGNED_INFO, cCertEncoded, cCrlEncoded),
5760 verify_and_copy_certificate,
5761 sizeof(CRYPT_DER_BLOB), TRUE, offsetof(CRYPT_DER_BLOB, pbData) };
5762
5763 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
5764 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0, pcbDecoded);
5765
5766 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
5767 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
5768 return ret;
5769}
verify_and_copy_certificate
static BOOL verify_and_copy_certificate(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5732
_CRYPTOAPI_BLOB
Definition: wincrypt.h:110
_CRYPT_SIGNED_INFO
Definition: crypt32_private.h:120

Referenced by CRYPT_AsnDecodeCMSSignedInfo().

◆ CRYPT_AsnDecodeCMSCrlEncoded()

static BOOL CRYPT_AsnDecodeCMSCrlEncoded ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5771 of file decode.c.

5774{
5775 BOOL ret;
5776 struct AsnArrayDescriptor arrayDesc = { 0,
5777 offsetof(CRYPT_SIGNED_INFO, cCrlEncoded),
5778 offsetof(CRYPT_SIGNED_INFO, rgCrlEncoded),
5779 MEMBERSIZE(CRYPT_SIGNED_INFO, cCrlEncoded, content),
5780 CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_DER_BLOB),
5781 TRUE, offsetof(CRYPT_DER_BLOB, pbData) };
5782
5783 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
5784 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0, pcbDecoded);
5785
5786 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
5787 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
5788 return ret;
5789}
content
content
Definition: atl_ax.c:994

Referenced by CRYPT_AsnDecodeCMSSignedInfo().

◆ CRYPT_AsnDecodeCMSSignedInfo()

BOOL CRYPT_AsnDecodeCMSSignedInfo ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
PCRYPT_DECODE_PARA  pDecodePara,
CRYPT_SIGNED_INFO *  signedInfo,
DWORD *  pcbSignedInfo 
)

Definition at line 5936 of file decode.c.

5939{
5940 BOOL ret = FALSE;
5941 struct AsnDecodeSequenceItem items[] = {
5942 { ASN_INTEGER, offsetof(CRYPT_SIGNED_INFO, version),
5943 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
5944 /* Placeholder for the hash algorithms - redundant with those in the
5945 * signers, so just ignore them.
5946 */
5947 { ASN_CONSTRUCTOR | ASN_SETOF, 0, NULL, 0, TRUE, FALSE, 0, 0 },
5948 { ASN_SEQUENCE, offsetof(CRYPT_SIGNED_INFO, content),
5949 CRYPT_AsnDecodePKCSContentInfoInternal, sizeof(CRYPT_CONTENT_INFO),
5950 FALSE, TRUE, offsetof(CRYPT_SIGNED_INFO, content.pszObjId), 0 },
5951 { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
5952 offsetof(CRYPT_SIGNED_INFO, cCertEncoded), CRYPT_AsnDecodeCMSCertEncoded,
5953 MEMBERSIZE(CRYPT_SIGNED_INFO, cCertEncoded, cCrlEncoded), TRUE, TRUE,
5954 offsetof(CRYPT_SIGNED_INFO, rgCertEncoded), 0 },
5955 { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
5956 offsetof(CRYPT_SIGNED_INFO, cCrlEncoded), CRYPT_AsnDecodeCMSCrlEncoded,
5957 MEMBERSIZE(CRYPT_SIGNED_INFO, cCrlEncoded, content), TRUE, TRUE,
5958 offsetof(CRYPT_SIGNED_INFO, rgCrlEncoded), 0 },
5959 { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CRYPT_SIGNED_INFO, cSignerInfo),
5960 CRYPT_DecodeSignerArray,
5961 FINALMEMBERSIZE(CRYPT_SIGNED_INFO, cSignerInfo), TRUE, TRUE,
5962 offsetof(CRYPT_SIGNED_INFO, rgSignerInfo), 0 },
5963 };
5964
5965 TRACE("%p, %ld, %08lx, %p, %p, %p\n", pbEncoded, cbEncoded, dwFlags,
5966 pDecodePara, signedInfo, pcbSignedInfo);
5967
5968 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
5969 pbEncoded, cbEncoded, dwFlags, pDecodePara, signedInfo, pcbSignedInfo,
5970 NULL, NULL);
5971 TRACE("returning %d\n", ret);
5972 return ret;
5973}
CRYPT_AsnDecodeCMSCrlEncoded
static BOOL CRYPT_AsnDecodeCMSCrlEncoded(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5771
CRYPT_AsnDecodePKCSContentInfoInternal
static BOOL CRYPT_AsnDecodePKCSContentInfoInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3311
CRYPT_DecodeSignerArray
static BOOL CRYPT_DecodeSignerArray(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5917
CRYPT_AsnDecodeCMSCertEncoded
static BOOL CRYPT_AsnDecodeCMSCertEncoded(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5751
ASN_SETOF
#define ASN_SETOF
Definition: crypt32_private.h:34
version
static const WCHAR version[]
Definition: asmname.c:66
ASN_SEQUENCE
#define ASN_SEQUENCE
Definition: snmp.h:110
CRYPT_CONTENT_INFO
struct _CRYPT_CONTENT_INFO CRYPT_CONTENT_INFO

Referenced by CDecodeMsg_DecodeSignedContent().

◆ CRYPT_AsnDecodeCMSSignerId()

static BOOL CRYPT_AsnDecodeCMSSignerId ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5791 of file decode.c.

5794{
5795 CERT_ID *id = pvStructInfo;
5796 BOOL ret = FALSE;
5797
5798 if (*pbEncoded == ASN_SEQUENCEOF)
5799 {
5800 ret = CRYPT_AsnDecodeIssuerSerialNumber(pbEncoded, cbEncoded, dwFlags,
5801 id ? &id->IssuerSerialNumber : NULL, pcbStructInfo, pcbDecoded);
5802 if (ret)
5803 {
5804 if (id)
5805 id->dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
5806 if (*pcbStructInfo > sizeof(CERT_ISSUER_SERIAL_NUMBER))
5807 *pcbStructInfo = sizeof(CERT_ID) + *pcbStructInfo -
5808 sizeof(CERT_ISSUER_SERIAL_NUMBER);
5809 else
5810 *pcbStructInfo = sizeof(CERT_ID);
5811 }
5812 }
5813 else if (*pbEncoded == (ASN_CONTEXT | 0))
5814 {
5815 ret = CRYPT_AsnDecodeOctets(pbEncoded, cbEncoded, dwFlags,
5816 id ? &id->KeyId : NULL, pcbStructInfo, pcbDecoded);
5817 if (ret)
5818 {
5819 if (id)
5820 id->dwIdChoice = CERT_ID_KEY_IDENTIFIER;
5821 if (*pcbStructInfo > sizeof(CRYPT_DATA_BLOB))
5822 *pcbStructInfo = sizeof(CERT_ID) + *pcbStructInfo -
5823 sizeof(CRYPT_DATA_BLOB);
5824 else
5825 *pcbStructInfo = sizeof(CERT_ID);
5826 }
5827 }
5828 else
5829 SetLastError(CRYPT_E_ASN1_BADTAG);
5830 return ret;
5831}
CRYPT_AsnDecodeIssuerSerialNumber
static BOOL CRYPT_AsnDecodeIssuerSerialNumber(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5618
id
GLuint id
Definition: glext.h:5910
_CERT_ID
Definition: wincrypt.h:3829
_CERT_ISSUER_SERIAL_NUMBER
Definition: wincrypt.h:3823
CERT_ID_ISSUER_SERIAL_NUMBER
#define CERT_ID_ISSUER_SERIAL_NUMBER
Definition: wincrypt.h:3838
CERT_ID_KEY_IDENTIFIER
#define CERT_ID_KEY_IDENTIFIER
Definition: wincrypt.h:3839
CERT_ID
struct _CERT_ID CERT_ID

Referenced by CRYPT_AsnDecodeCMSSignerInfoInternal().

◆ CRYPT_AsnDecodeCMSSignerInfo()

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

Definition at line 5874 of file decode.c.

5877{
5878 BOOL ret = FALSE;
5879
5880 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
5881 pDecodePara, pvStructInfo, *pcbStructInfo);
5882
5883 __TRY
5884 {
5885 ret = CRYPT_AsnDecodeCMSSignerInfoInternal(pbEncoded, cbEncoded,
5886 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
5887 if (ret && pvStructInfo)
5888 {
5889 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
5890 pcbStructInfo, *pcbStructInfo);
5891 if (ret)
5892 {
5893 CMSG_CMS_SIGNER_INFO *info;
5894
5895 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
5896 pvStructInfo = *(BYTE **)pvStructInfo;
5897 info = pvStructInfo;
5898 info->SignerId.KeyId.pbData = ((BYTE *)info +
5899 sizeof(CMSG_CMS_SIGNER_INFO));
5900 ret = CRYPT_AsnDecodeCMSSignerInfoInternal(pbEncoded,
5901 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
5902 pcbStructInfo, NULL);
5903 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
5904 CRYPT_FreeSpace(pDecodePara, info);
5905 }
5906 }
5907 }
5908 __EXCEPT_PAGE_FAULT
5909 {
5910 SetLastError(STATUS_ACCESS_VIOLATION);
5911 }
5912 __ENDTRY
5913 TRACE("returning %d\n", ret);
5914 return ret;
5915}
CRYPT_AsnDecodeCMSSignerInfoInternal
static BOOL CRYPT_AsnDecodeCMSSignerInfoInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5833
_CMSG_CMS_SIGNER_INFO
Definition: wincrypt.h:4126

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeCMSSignerInfoInternal()

static BOOL CRYPT_AsnDecodeCMSSignerInfoInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5833 of file decode.c.

5836{
5837 CMSG_CMS_SIGNER_INFO *info = pvStructInfo;
5838 struct AsnDecodeSequenceItem items[] = {
5839 { ASN_INTEGER, offsetof(CMSG_CMS_SIGNER_INFO, dwVersion),
5840 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
5841 { 0, offsetof(CMSG_CMS_SIGNER_INFO, SignerId),
5842 CRYPT_AsnDecodeCMSSignerId, sizeof(CERT_ID), FALSE, TRUE,
5843 offsetof(CMSG_CMS_SIGNER_INFO, SignerId.KeyId.pbData), 0 },
5844 { ASN_SEQUENCEOF, offsetof(CMSG_CMS_SIGNER_INFO, HashAlgorithm),
5845 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
5846 FALSE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, HashAlgorithm.pszObjId), 0 },
5847 { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
5848 offsetof(CMSG_CMS_SIGNER_INFO, AuthAttrs),
5849 CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
5850 TRUE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, AuthAttrs.rgAttr), 0 },
5851 { ASN_SEQUENCEOF, offsetof(CMSG_CMS_SIGNER_INFO, HashEncryptionAlgorithm),
5852 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
5853 FALSE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO,
5854 HashEncryptionAlgorithm.pszObjId), 0 },
5855 { ASN_OCTETSTRING, offsetof(CMSG_CMS_SIGNER_INFO, EncryptedHash),
5856 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB),
5857 FALSE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, EncryptedHash.pbData), 0 },
5858 { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
5859 offsetof(CMSG_CMS_SIGNER_INFO, UnauthAttrs),
5860 CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
5861 TRUE, TRUE, offsetof(CMSG_CMS_SIGNER_INFO, UnauthAttrs.rgAttr), 0 },
5862 };
5863 BOOL ret;
5864
5865 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
5866 pvStructInfo, *pcbStructInfo);
5867
5868 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
5869 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
5870 pcbDecoded, info ? info->SignerId.KeyId.pbData : NULL);
5871 return ret;
5872}
CRYPT_AsnDecodePKCSAttributesInternal
static BOOL CRYPT_AsnDecodePKCSAttributesInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2809
CRYPT_AsnDecodeCMSSignerId
static BOOL CRYPT_AsnDecodeCMSSignerId(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5791
ASN_OCTETSTRING
#define ASN_OCTETSTRING
Definition: snmp.h:105
CRYPT_ATTRIBUTES
struct _CRYPT_ATTRIBUTES CRYPT_ATTRIBUTES
HashAlgorithm
_In_ BOOLEAN _In_ ULONG HashAlgorithm
Definition: rtlfuncs.h:2055

Referenced by CRYPT_AsnDecodeCMSSignerInfo(), and CRYPT_DecodeSignerArray().

◆ CRYPT_AsnDecodeCopyBytes()

static BOOL CRYPT_AsnDecodeCopyBytes ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2111 of file decode.c.

2114{
2115 BOOL ret = TRUE;
2116 DWORD bytesNeeded = sizeof(CRYPT_OBJID_BLOB), encodedLen = 0;
2117
2118 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2119 pvStructInfo, *pcbStructInfo);
2120
2121 if ((ret = CRYPT_FindEncodedLen(pbEncoded, cbEncoded, &encodedLen)))
2122 {
2123 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
2124 bytesNeeded += encodedLen;
2125 if (!pvStructInfo)
2126 *pcbStructInfo = bytesNeeded;
2127 else if (*pcbStructInfo < bytesNeeded)
2128 {
2129 SetLastError(ERROR_MORE_DATA);
2130 *pcbStructInfo = bytesNeeded;
2131 ret = FALSE;
2132 }
2133 else
2134 {
2135 PCRYPT_OBJID_BLOB blob = pvStructInfo;
2136
2137 *pcbStructInfo = bytesNeeded;
2138 blob->cbData = encodedLen;
2139 if (encodedLen)
2140 {
2141 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
2142 blob->pbData = (LPBYTE)pbEncoded;
2143 else
2144 {
2145 assert(blob->pbData);
2146 memcpy(blob->pbData, pbEncoded, blob->cbData);
2147 }
2148 }
2149 else
2150 blob->pbData = NULL;
2151 }
2152 if (pcbDecoded)
2153 *pcbDecoded = encodedLen;
2154 }
2155 return ret;
2156}
CRYPT_FindEncodedLen
static BOOL CRYPT_FindEncodedLen(const BYTE *pbEncoded, DWORD cbEncoded, DWORD *pcbDecoded)
Definition: decode.c:2055

Referenced by CRYPT_AsnDecodeAlgorithmId(), CRYPT_AsnDecodeCMSCrlEncoded(), CRYPT_AsnDecodePKCSAttributeValue(), CRYPT_AsnDecodePKCSContent(), CRYPT_AsnDecodeSMIMECapability(), CRYPT_AsnDecodeSubtreeConstraints(), and verify_and_copy_certificate().

◆ CRYPT_AsnDecodeCRL()

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

Definition at line 1257 of file decode.c.

1260{
1261 BOOL ret = FALSE;
1262
1263 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1264 pDecodePara, pvStructInfo, *pcbStructInfo);
1265
1266 __TRY
1267 {
1268 DWORD size = 0;
1269
1270 /* Unless told not to, first try to decode it as a signed crl. */
1271 if (!(dwFlags & CRYPT_DECODE_TO_BE_SIGNED_FLAG))
1272 {
1273 PCERT_SIGNED_CONTENT_INFO signedCrl = NULL;
1274
1275 ret = CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType,
1276 X509_CERT, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
1277 &signedCrl, &size);
1278 if (ret)
1279 {
1280 size = 0;
1281 ret = CRYPT_AsnDecodeCRLInfo(dwCertEncodingType,
1282 X509_CERT_CRL_TO_BE_SIGNED, signedCrl->ToBeSigned.pbData,
1283 signedCrl->ToBeSigned.cbData, dwFlags, pDecodePara,
1284 pvStructInfo, pcbStructInfo);
1285 LocalFree(signedCrl);
1286 }
1287 }
1288 /* Failing that, try it as an unsigned crl */
1289 if (!ret)
1290 {
1291 size = 0;
1292 ret = CRYPT_AsnDecodeCRLInfo(dwCertEncodingType,
1293 X509_CERT_CRL_TO_BE_SIGNED, pbEncoded, cbEncoded,
1294 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);
1295 }
1296 }
1297 __EXCEPT_PAGE_FAULT
1298 {
1299 SetLastError(STATUS_ACCESS_VIOLATION);
1300 }
1301 __ENDTRY
1302
1303 TRACE("Returning %d (%08lx)\n", ret, GetLastError());
1304 return ret;
1305}
CRYPT_AsnDecodeCRLInfo
static BOOL CRYPT_AsnDecodeCRLInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:1221
X509_CERT_CRL_TO_BE_SIGNED
#define X509_CERT_CRL_TO_BE_SIGNED
Definition: wincrypt.h:3519

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeCRLDistPoints()

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

Definition at line 5346 of file decode.c.

5349{
5350 BOOL ret;
5351
5352 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
5353 pDecodePara, pvStructInfo, *pcbStructInfo);
5354
5355 __TRY
5356 {
5357 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
5358 offsetof(CRL_DIST_POINTS_INFO, cDistPoint),
5359 offsetof(CRL_DIST_POINTS_INFO, rgDistPoint),
5360 sizeof(CRL_DIST_POINTS_INFO),
5361 CRYPT_AsnDecodeDistPoint, sizeof(CRL_DIST_POINT), TRUE,
5362 offsetof(CRL_DIST_POINT, DistPointName.FullName.rgAltEntry) };
5363 CRL_DIST_POINTS_INFO *info = pvStructInfo;
5364
5365 if (pvStructInfo && !(dwFlags & CRYPT_DECODE_ALLOC_FLAG))
5366 info->rgDistPoint = (CRL_DIST_POINT *)(info + 1);
5367 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
5368 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo, NULL);
5369 }
5370 __EXCEPT_PAGE_FAULT
5371 {
5372 SetLastError(STATUS_ACCESS_VIOLATION);
5373 ret = FALSE;
5374 }
5375 __ENDTRY
5376 return ret;
5377}
CRYPT_AsnDecodeDistPoint
static BOOL CRYPT_AsnDecodeDistPoint(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5322
_CRL_DIST_POINTS_INFO
Definition: wincrypt.h:540
_CRL_DIST_POINT
Definition: wincrypt.h:526
CRL_DIST_POINTS_INFO
struct _CRL_DIST_POINTS_INFO CRL_DIST_POINTS_INFO

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeCRLEntries()

static BOOL CRYPT_AsnDecodeCRLEntries ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1164 of file decode.c.

1166{
1167 BOOL ret;
1168 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1169 offsetof(CRL_INFO, cCRLEntry), offsetof(CRL_INFO, rgCRLEntry),
1170 MEMBERSIZE(CRL_INFO, cCRLEntry, cExtension),
1171 CRYPT_AsnDecodeCRLEntry, sizeof(CRL_ENTRY), TRUE,
1172 offsetof(CRL_ENTRY, SerialNumber.pbData) };
1173
1174 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
1175 pvStructInfo, *pcbStructInfo, pcbDecoded);
1176
1177 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
1178 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
1179 TRACE("Returning %d (%08lx)\n", ret, GetLastError());
1180 return ret;
1181}
CRYPT_AsnDecodeCRLEntry
static BOOL CRYPT_AsnDecodeCRLEntry(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1129
_CRL_ENTRY
Definition: wincrypt.h:496
_CRL_INFO
Definition: wincrypt.h:503
CRL_ENTRY
struct _CRL_ENTRY CRL_ENTRY

Referenced by CRYPT_AsnDecodeCRLInfo().

◆ CRYPT_AsnDecodeCRLEntry()

static BOOL CRYPT_AsnDecodeCRLEntry ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1129 of file decode.c.

1131{
1132 BOOL ret;
1133 struct AsnDecodeSequenceItem items[] = {
1134 { ASN_INTEGER, offsetof(CRL_ENTRY, SerialNumber),
1135 CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE, TRUE,
1136 offsetof(CRL_ENTRY, SerialNumber.pbData), 0 },
1137 { 0, offsetof(CRL_ENTRY, RevocationDate),
1138 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE, 0 },
1139 { ASN_SEQUENCEOF, offsetof(CRL_ENTRY, cExtension),
1140 CRYPT_AsnDecodeCRLEntryExtensions,
1141 FINALMEMBERSIZE(CRL_ENTRY, cExtension), TRUE, TRUE,
1142 offsetof(CRL_ENTRY, rgExtension), 0 },
1143 };
1144 PCRL_ENTRY entry = pvStructInfo;
1145
1146 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, entry,
1147 *pcbStructInfo);
1148
1149 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
1150 pbEncoded, cbEncoded, dwFlags, NULL, entry, pcbStructInfo, pcbDecoded,
1151 entry ? entry->SerialNumber.pbData : NULL);
1152 if (ret && entry && !entry->SerialNumber.cbData)
1153 {
1154 WARN("empty CRL entry serial number\n");
1155 SetLastError(CRYPT_E_ASN1_CORRUPT);
1156 ret = FALSE;
1157 }
1158 return ret;
1159}
CRYPT_AsnDecodeCRLEntryExtensions
static BOOL CRYPT_AsnDecodeCRLEntryExtensions(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1110
FILETIME
struct _FILETIME FILETIME

Referenced by CRYPT_AsnDecodeCRLEntries().

◆ CRYPT_AsnDecodeCRLEntryExtensions()

static BOOL CRYPT_AsnDecodeCRLEntryExtensions ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1110 of file decode.c.

1113{
1114 BOOL ret = TRUE;
1115 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1116 offsetof(CRL_ENTRY, cExtension), offsetof(CRL_ENTRY, rgExtension),
1117 FINALMEMBERSIZE(CRL_ENTRY, cExtension),
1118 CRYPT_AsnDecodeExtension, sizeof(CERT_EXTENSION), TRUE,
1119 offsetof(CERT_EXTENSION, pszObjId) };
1120
1121 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
1122 pvStructInfo, *pcbStructInfo, pcbDecoded);
1123
1124 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
1125 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
1126 return ret;
1127}

Referenced by CRYPT_AsnDecodeCRLEntry().

◆ CRYPT_AsnDecodeCRLExtensions()

static BOOL CRYPT_AsnDecodeCRLExtensions ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1202 of file decode.c.

1205{
1206 BOOL ret;
1207 DWORD dataLen;
1208
1209 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1210 {
1211 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1212
1213 ret = CRYPT_AsnDecodeCRLExtensionsInternal(pbEncoded + 1 + lenBytes,
1214 dataLen, dwFlags, pvStructInfo, pcbStructInfo, NULL);
1215 if (ret && pcbDecoded)
1216 *pcbDecoded = 1 + lenBytes + dataLen;
1217 }
1218 return ret;
1219}
CRYPT_AsnDecodeCRLExtensionsInternal
static BOOL CRYPT_AsnDecodeCRLExtensionsInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1183

Referenced by CRYPT_AsnDecodeCRLInfo().

◆ CRYPT_AsnDecodeCRLExtensionsInternal()

static BOOL CRYPT_AsnDecodeCRLExtensionsInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1183 of file decode.c.

1186{
1187 BOOL ret = TRUE;
1188 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1189 offsetof(CRL_INFO, cExtension), offsetof(CRL_INFO, rgExtension),
1190 FINALMEMBERSIZE(CRL_INFO, cExtension),
1191 CRYPT_AsnDecodeExtension, sizeof(CERT_EXTENSION), TRUE,
1192 offsetof(CERT_EXTENSION, pszObjId) };
1193
1194 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
1195 pvStructInfo, *pcbStructInfo, pcbDecoded);
1196
1197 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
1198 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
1199 return ret;
1200}

Referenced by CRYPT_AsnDecodeCRLExtensions().

◆ CRYPT_AsnDecodeCRLInfo()

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

Definition at line 1221 of file decode.c.

1224{
1225 struct AsnDecodeSequenceItem items[] = {
1226 { ASN_INTEGER, offsetof(CRL_INFO, dwVersion),
1227 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), TRUE, FALSE, 0, 0 },
1228 { ASN_SEQUENCEOF, offsetof(CRL_INFO, SignatureAlgorithm),
1229 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
1230 FALSE, TRUE, offsetof(CRL_INFO, SignatureAlgorithm.pszObjId), 0 },
1231 { 0, offsetof(CRL_INFO, Issuer), CRYPT_AsnDecodeDerBlob,
1232 sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CRL_INFO,
1233 Issuer.pbData) },
1234 { 0, offsetof(CRL_INFO, ThisUpdate), CRYPT_AsnDecodeChoiceOfTimeInternal,
1235 sizeof(FILETIME), FALSE, FALSE, 0 },
1236 { 0, offsetof(CRL_INFO, NextUpdate), CRYPT_AsnDecodeChoiceOfTimeInternal,
1237 sizeof(FILETIME), TRUE, FALSE, 0 },
1238 { ASN_SEQUENCEOF, offsetof(CRL_INFO, cCRLEntry),
1239 CRYPT_AsnDecodeCRLEntries, MEMBERSIZE(CRL_INFO, cCRLEntry, cExtension),
1240 TRUE, TRUE, offsetof(CRL_INFO, rgCRLEntry), 0 },
1241 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CRL_INFO, cExtension),
1242 CRYPT_AsnDecodeCRLExtensions, FINALMEMBERSIZE(CRL_INFO, cExtension),
1243 TRUE, TRUE, offsetof(CRL_INFO, rgExtension), 0 },
1244 };
1245 BOOL ret = TRUE;
1246
1247 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1248 pDecodePara, pvStructInfo, *pcbStructInfo);
1249
1250 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items), pbEncoded, cbEncoded, dwFlags,
1251 pDecodePara, pvStructInfo, pcbStructInfo, NULL, NULL);
1252
1253 TRACE("Returning %d (%08lx)\n", ret, GetLastError());
1254 return ret;
1255}
CRYPT_AsnDecodeCRLEntries
static BOOL CRYPT_AsnDecodeCRLEntries(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1164
CRYPT_AsnDecodeCRLExtensions
static BOOL CRYPT_AsnDecodeCRLExtensions(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1202

Referenced by CRYPT_AsnDecodeCRL().

◆ CRYPT_AsnDecodeCTL()

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

Definition at line 2269 of file decode.c.

2272{
2273 BOOL ret = FALSE;
2274
2275 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2276 pDecodePara, pvStructInfo, *pcbStructInfo);
2277
2278 __TRY
2279 {
2280 struct AsnDecodeSequenceItem items[] = {
2281 { ASN_INTEGER, offsetof(CTL_INFO, dwVersion),
2282 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), TRUE, FALSE, 0, 0 },
2283 { ASN_SEQUENCEOF, offsetof(CTL_INFO, SubjectUsage),
2284 CRYPT_AsnDecodeCTLUsage, sizeof(CTL_USAGE), FALSE, TRUE,
2285 offsetof(CTL_INFO, SubjectUsage.rgpszUsageIdentifier), 0 },
2286 { ASN_OCTETSTRING, offsetof(CTL_INFO, ListIdentifier),
2287 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DATA_BLOB), TRUE,
2288 TRUE, offsetof(CTL_INFO, ListIdentifier.pbData), 0 },
2289 { ASN_INTEGER, offsetof(CTL_INFO, SequenceNumber),
2290 CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
2291 TRUE, TRUE, offsetof(CTL_INFO, SequenceNumber.pbData), 0 },
2292 { 0, offsetof(CTL_INFO, ThisUpdate),
2293 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE,
2294 0 },
2295 { 0, offsetof(CTL_INFO, NextUpdate),
2296 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), TRUE, FALSE,
2297 0 },
2298 { ASN_SEQUENCEOF, offsetof(CTL_INFO, SubjectAlgorithm),
2299 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2300 FALSE, TRUE, offsetof(CTL_INFO, SubjectAlgorithm.pszObjId), 0 },
2301 { ASN_SEQUENCEOF, offsetof(CTL_INFO, cCTLEntry),
2302 CRYPT_AsnDecodeCTLEntries,
2303 MEMBERSIZE(CTL_INFO, cCTLEntry, cExtension),
2304 TRUE, TRUE, offsetof(CTL_INFO, rgCTLEntry), 0 },
2305 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CTL_INFO, cExtension),
2306 CRYPT_AsnDecodeCTLExtensions, FINALMEMBERSIZE(CTL_INFO, cExtension),
2307 TRUE, TRUE, offsetof(CTL_INFO, rgExtension), 0 },
2308 };
2309
2310 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
2311 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
2312 pcbStructInfo, NULL, NULL);
2313 }
2314 __EXCEPT_PAGE_FAULT
2315 {
2316 SetLastError(STATUS_ACCESS_VIOLATION);
2317 }
2318 __ENDTRY
2319 return ret;
2320}
ListIdentifier
_In_ PTRANSFER_PACKET _In_ ULONG _In_ PIRP _In_ ULONG ListIdentifier
Definition: classp.h:1759
CRYPT_AsnDecodeCTLEntries
static BOOL CRYPT_AsnDecodeCTLEntries(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2213
CRYPT_AsnDecodeCTLExtensions
static BOOL CRYPT_AsnDecodeCTLExtensions(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2250
CRYPT_AsnDecodeCTLUsage
static BOOL CRYPT_AsnDecodeCTLUsage(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2158
_CTL_INFO
Definition: wincrypt.h:841
CTL_USAGE
struct _CTL_USAGE CTL_USAGE

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeCTLEntries()

static BOOL CRYPT_AsnDecodeCTLEntries ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2213 of file decode.c.

2215{
2216 BOOL ret;
2217 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2218 offsetof(CTL_INFO, cCTLEntry), offsetof(CTL_INFO, rgCTLEntry),
2219 FINALMEMBERSIZE(CTL_INFO, cExtension),
2220 CRYPT_AsnDecodeCTLEntry, sizeof(CTL_ENTRY), TRUE,
2221 offsetof(CTL_ENTRY, SubjectIdentifier.pbData) };
2222
2223 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
2224 pvStructInfo, *pcbStructInfo, pcbDecoded);
2225
2226 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
2227 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
2228 return ret;
2229}
CRYPT_AsnDecodeCTLEntry
static BOOL CRYPT_AsnDecodeCTLEntry(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2189
_CTL_ENTRY
Definition: wincrypt.h:835
CTL_ENTRY
struct _CTL_ENTRY CTL_ENTRY

Referenced by CRYPT_AsnDecodeCTL().

◆ CRYPT_AsnDecodeCTLEntry()

static BOOL CRYPT_AsnDecodeCTLEntry ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2189 of file decode.c.

2191{
2192 struct AsnDecodeSequenceItem items[] = {
2193 { ASN_OCTETSTRING, offsetof(CTL_ENTRY, SubjectIdentifier),
2194 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DATA_BLOB), FALSE, TRUE,
2195 offsetof(CTL_ENTRY, SubjectIdentifier.pbData), 0 },
2196 { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CTL_ENTRY, cAttribute),
2197 CRYPT_AsnDecodeCTLEntryAttributes,
2198 FINALMEMBERSIZE(CTL_ENTRY, cAttribute), FALSE, TRUE,
2199 offsetof(CTL_ENTRY, rgAttribute), 0 },
2200 };
2201 BOOL ret = TRUE;
2202 CTL_ENTRY *entry = pvStructInfo;
2203
2204 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, entry,
2205 *pcbStructInfo);
2206
2207 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
2208 pbEncoded, cbEncoded, dwFlags, NULL, entry, pcbStructInfo,
2209 pcbDecoded, entry ? entry->SubjectIdentifier.pbData : NULL);
2210 return ret;
2211}
CRYPT_AsnDecodeCTLEntryAttributes
static BOOL CRYPT_AsnDecodeCTLEntryAttributes(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2173

Referenced by CRYPT_AsnDecodeCTLEntries().

◆ CRYPT_AsnDecodeCTLEntryAttributes()

static BOOL CRYPT_AsnDecodeCTLEntryAttributes ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2173 of file decode.c.

2176{
2177 struct AsnArrayDescriptor arrayDesc = { 0,
2178 offsetof(CTL_ENTRY, cAttribute), offsetof(CTL_ENTRY, rgAttribute),
2179 FINALMEMBERSIZE(CTL_ENTRY, cAttribute),
2180 CRYPT_AsnDecodePKCSAttributeInternal, sizeof(CRYPT_ATTRIBUTE), TRUE,
2181 offsetof(CRYPT_ATTRIBUTE, pszObjId) };
2182 BOOL ret;
2183
2184 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
2185 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
2186 return ret;
2187}
CRYPT_AsnDecodePKCSAttributeInternal
static BOOL CRYPT_AsnDecodePKCSAttributeInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2737
_CRYPT_ATTRIBUTE
Definition: wincrypt.h:604
CRYPT_ATTRIBUTE
struct _CRYPT_ATTRIBUTE CRYPT_ATTRIBUTE

Referenced by CRYPT_AsnDecodeCTLEntry().

◆ CRYPT_AsnDecodeCTLExtensions()

static BOOL CRYPT_AsnDecodeCTLExtensions ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2250 of file decode.c.

2253{
2254 BOOL ret;
2255 DWORD dataLen;
2256
2257 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2258 {
2259 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2260
2261 ret = CRYPT_AsnDecodeCTLExtensionsInternal(pbEncoded + 1 + lenBytes,
2262 dataLen, dwFlags, pvStructInfo, pcbStructInfo, NULL);
2263 if (ret && pcbDecoded)
2264 *pcbDecoded = 1 + lenBytes + dataLen;
2265 }
2266 return ret;
2267}
CRYPT_AsnDecodeCTLExtensionsInternal
static BOOL CRYPT_AsnDecodeCTLExtensionsInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2231

Referenced by CRYPT_AsnDecodeCTL().

◆ CRYPT_AsnDecodeCTLExtensionsInternal()

static BOOL CRYPT_AsnDecodeCTLExtensionsInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2231 of file decode.c.

2234{
2235 BOOL ret = TRUE;
2236 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2237 offsetof(CTL_INFO, cExtension), offsetof(CTL_INFO, rgExtension),
2238 FINALMEMBERSIZE(CTL_INFO, cExtension),
2239 CRYPT_AsnDecodeExtension, sizeof(CERT_EXTENSION), TRUE,
2240 offsetof(CERT_EXTENSION, pszObjId) };
2241
2242 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
2243 pvStructInfo, *pcbStructInfo, pcbDecoded);
2244
2245 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
2246 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
2247 return ret;
2248}

Referenced by CRYPT_AsnDecodeCTLExtensions().

◆ CRYPT_AsnDecodeCTLUsage()

static BOOL CRYPT_AsnDecodeCTLUsage ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2158 of file decode.c.

2160{
2161 BOOL ret;
2162 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2163 offsetof(CTL_USAGE, cUsageIdentifier),
2164 offsetof(CTL_USAGE, rgpszUsageIdentifier),
2165 sizeof(CTL_USAGE),
2166 CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), TRUE, 0 };
2167
2168 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2169 NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
2170 return ret;
2171}
_CTL_USAGE
Definition: wincrypt.h:830

Referenced by CRYPT_AsnDecodeCTL().

◆ CRYPT_AsnDecodeDerBlob()

static BOOL CRYPT_AsnDecodeDerBlob ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 795 of file decode.c.

797{
798 BOOL ret;
799 DWORD dataLen;
800
801 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
802 {
803 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
804 DWORD bytesNeeded = sizeof(CRYPT_DER_BLOB);
805
806 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
807 bytesNeeded += 1 + lenBytes + dataLen;
808
809 if (pcbDecoded)
810 *pcbDecoded = 1 + lenBytes + dataLen;
811 if (!pvStructInfo)
812 *pcbStructInfo = bytesNeeded;
813 else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, bytesNeeded)))
814 {
815 CRYPT_DER_BLOB *blob;
816
817 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
818 pvStructInfo = *(BYTE **)pvStructInfo;
819 blob = pvStructInfo;
820 blob->cbData = 1 + lenBytes + dataLen;
821 if (blob->cbData)
822 {
823 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
824 blob->pbData = (BYTE *)pbEncoded;
825 else
826 {
827 assert(blob->pbData);
828 memcpy(blob->pbData, pbEncoded, blob->cbData);
829 }
830 }
831 else
832 {
833 SetLastError(CRYPT_E_ASN1_CORRUPT);
834 ret = FALSE;
835 }
836 }
837 }
838 return ret;
839}
CRYPT_DecodeCheckSpace
static BOOL CRYPT_DecodeCheckSpace(DWORD *pcbStructInfo, DWORD bytesNeeded)
Definition: decode.c:249

Referenced by CRYPT_AsnDecodeCertInfo(), CRYPT_AsnDecodeCertSignedContent(), CRYPT_AsnDecodeCRLInfo(), CRYPT_AsnDecodeIssuerSerialNumber(), CRYPT_AsnDecodeOCSPBasicSignedResponse(), and CRYPT_AsnDecodePolicyQualifier().

◆ CRYPT_AsnDecodeDistPoint()

static BOOL CRYPT_AsnDecodeDistPoint ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5322 of file decode.c.

5324{
5325 struct AsnDecodeSequenceItem items[] = {
5326 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CRL_DIST_POINT,
5327 DistPointName), CRYPT_AsnDecodeDistPointName,
5328 sizeof(CRL_DIST_POINT_NAME), TRUE, TRUE, offsetof(CRL_DIST_POINT,
5329 DistPointName.FullName.rgAltEntry), 0 },
5330 { ASN_CONTEXT | 1, offsetof(CRL_DIST_POINT, ReasonFlags),
5331 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), TRUE, TRUE,
5332 offsetof(CRL_DIST_POINT, ReasonFlags.pbData), 0 },
5333 { ASN_CONTEXT | ASN_CONSTRUCTOR | 2, offsetof(CRL_DIST_POINT, CRLIssuer),
5334 CRYPT_AsnDecodeAltNameInternal, sizeof(CERT_ALT_NAME_INFO), TRUE, TRUE,
5335 offsetof(CRL_DIST_POINT, CRLIssuer.rgAltEntry), 0 },
5336 };
5337 CRL_DIST_POINT *point = pvStructInfo;
5338 BOOL ret;
5339
5340 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
5341 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
5342 pcbDecoded, point ? point->DistPointName.FullName.rgAltEntry : NULL);
5343 return ret;
5344}
CRYPT_AsnDecodeDistPointName
static BOOL CRYPT_AsnDecodeDistPointName(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5254
point
POINTL point
Definition: edittest.c:50
CRL_DIST_POINT_NAME
struct _CRL_DIST_POINT_NAME CRL_DIST_POINT_NAME

Referenced by CRYPT_AsnDecodeCRLDistPoints().

◆ CRYPT_AsnDecodeDistPointName()

static BOOL CRYPT_AsnDecodeDistPointName ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5254 of file decode.c.

5257{
5258 BOOL ret;
5259
5260 if (pbEncoded[0] == (ASN_CONTEXT | ASN_CONSTRUCTOR | 0))
5261 {
5262 DWORD bytesNeeded = 0, dataLen;
5263
5264 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
5265 {
5266 struct AsnArrayDescriptor arrayDesc = {
5267 ASN_CONTEXT | ASN_CONSTRUCTOR | 0,
5268 offsetof(CRL_DIST_POINT_NAME, FullName.cAltEntry),
5269 offsetof(CRL_DIST_POINT_NAME, FullName.rgAltEntry),
5270 FINALMEMBERSIZE(CRL_DIST_POINT_NAME, FullName),
5271 CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), TRUE,
5272 offsetof(CERT_ALT_NAME_ENTRY, pwszURL) };
5273 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
5274 DWORD nameLen;
5275
5276 if (dataLen)
5277 {
5278 ret = CRYPT_AsnDecodeArray(&arrayDesc,
5279 pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
5280 dwFlags, NULL, NULL, &nameLen, NULL);
5281 bytesNeeded = sizeof(CRL_DIST_POINT_NAME) + nameLen -
5282 FINALMEMBERSIZE(CRL_DIST_POINT_NAME, FullName);
5283 }
5284 else
5285 bytesNeeded = sizeof(CRL_DIST_POINT_NAME);
5286 if (pcbDecoded)
5287 *pcbDecoded = 1 + lenBytes + dataLen;
5288 if (!pvStructInfo)
5289 *pcbStructInfo = bytesNeeded;
5290 else if (*pcbStructInfo < bytesNeeded)
5291 {
5292 *pcbStructInfo = bytesNeeded;
5293 SetLastError(ERROR_MORE_DATA);
5294 ret = FALSE;
5295 }
5296 else
5297 {
5298 CRL_DIST_POINT_NAME *name = pvStructInfo;
5299
5300 *pcbStructInfo = bytesNeeded;
5301 if (dataLen)
5302 {
5303 name->dwDistPointNameChoice = CRL_DIST_POINT_FULL_NAME;
5304 ret = CRYPT_AsnDecodeArray(&arrayDesc,
5305 pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes,
5306 dwFlags, NULL, &name->FullName.cAltEntry, &nameLen,
5307 NULL);
5308 }
5309 else
5310 name->dwDistPointNameChoice = CRL_DIST_POINT_NO_NAME;
5311 }
5312 }
5313 }
5314 else
5315 {
5316 SetLastError(CRYPT_E_ASN1_BADTAG);
5317 ret = FALSE;
5318 }
5319 return ret;
5320}
_CRL_DIST_POINT_NAME
Definition: wincrypt.h:515
CRL_DIST_POINT_NO_NAME
#define CRL_DIST_POINT_NO_NAME
Definition: wincrypt.h:522
CRL_DIST_POINT_FULL_NAME
#define CRL_DIST_POINT_FULL_NAME
Definition: wincrypt.h:523
FullName
_In_ PSTRING FullName
Definition: rtlfuncs.h:1665

Referenced by CRYPT_AsnDecodeDistPoint(), and CRYPT_AsnDecodeIssuingDistPoint().

◆ CRYPT_AsnDecodeEccSignature()

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

Definition at line 6133 of file decode.c.

6136{
6137 BOOL ret;
6138 struct AsnDecodeSequenceItem items[] = {
6139 { ASN_INTEGER, offsetof(CERT_ECC_SIGNATURE, r),
6140 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_UINT_BLOB), FALSE,
6141 TRUE, offsetof(CERT_ECC_SIGNATURE, r.pbData), 0 },
6142 { ASN_INTEGER, offsetof(CERT_ECC_SIGNATURE, s),
6143 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_UINT_BLOB), FALSE,
6144 TRUE, offsetof(CERT_ECC_SIGNATURE, s.pbData), 0 },
6145 };
6146
6147 __TRY
6148 {
6149 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
6150 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
6151 pcbStructInfo, NULL, NULL);
6152 }
6153 __EXCEPT_PAGE_FAULT
6154 {
6155 SetLastError(STATUS_ACCESS_VIOLATION);
6156 ret = FALSE;
6157 }
6158 __ENDTRY
6159 return ret;
6160}
CRYPT_AsnDecodeUnsignedIntegerInternal
static BOOL CRYPT_AsnDecodeUnsignedIntegerInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:4663
s
GLdouble s
Definition: gl.h:2039
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
_CERT_ECC_SIGNATURE
Definition: wincrypt.h:307
CRYPT_UINT_BLOB
struct _CRYPTOAPI_BLOB CRYPT_UINT_BLOB

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeEncryptedContentInfo()

static BOOL CRYPT_AsnDecodeEncryptedContentInfo ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6033 of file decode.c.

6036{
6037 BOOL ret;
6038 CRYPT_ENCRYPTED_CONTENT_INFO *info = pvStructInfo;
6039 struct AsnDecodeSequenceItem items[] = {
6040 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ENCRYPTED_CONTENT_INFO,
6041 contentType), CRYPT_AsnDecodeOidInternal, sizeof(LPSTR),
6042 FALSE, TRUE, offsetof(CRYPT_ENCRYPTED_CONTENT_INFO,
6043 contentType), 0 },
6044 { ASN_SEQUENCEOF, offsetof(CRYPT_ENCRYPTED_CONTENT_INFO,
6045 contentEncryptionAlgorithm), CRYPT_AsnDecodeAlgorithmId,
6046 sizeof(CRYPT_ALGORITHM_IDENTIFIER), FALSE, TRUE,
6047 offsetof(CRYPT_ENCRYPTED_CONTENT_INFO,
6048 contentEncryptionAlgorithm.pszObjId), 0 },
6049 { ASN_CONTEXT | 0, offsetof(CRYPT_ENCRYPTED_CONTENT_INFO,
6050 encryptedContent), CRYPT_AsnDecodeOctets,
6051 sizeof(CRYPT_DATA_BLOB), TRUE, TRUE,
6052 offsetof(CRYPT_ENCRYPTED_CONTENT_INFO, encryptedContent.pbData) },
6053 };
6054
6055 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
6056 pvStructInfo, *pcbStructInfo, pcbDecoded);
6057
6058 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
6059 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
6060 pcbDecoded, info ? info->contentType : NULL);
6061 TRACE("returning %d\n", ret);
6062 return ret;
6063}
_CRYPT_ENCRYPTED_CONTENT_INFO
Definition: crypt32_private.h:98

Referenced by CRYPT_AsnDecodePKCSEnvelopedData().

◆ CRYPT_AsnDecodeEnhancedKeyUsage()

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

Definition at line 5379 of file decode.c.

5382{
5383 BOOL ret;
5384
5385 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
5386 pDecodePara, pvStructInfo, *pcbStructInfo);
5387
5388 __TRY
5389 {
5390 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
5391 offsetof(CERT_ENHKEY_USAGE, cUsageIdentifier),
5392 offsetof(CERT_ENHKEY_USAGE, rgpszUsageIdentifier),
5393 sizeof(CERT_ENHKEY_USAGE),
5394 CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), TRUE, 0 };
5395 CERT_ENHKEY_USAGE *usage = pvStructInfo;
5396
5397 if (pvStructInfo && !(dwFlags & CRYPT_DECODE_ALLOC_FLAG))
5398 usage->rgpszUsageIdentifier = (LPSTR *)(usage + 1);
5399 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
5400 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo, NULL);
5401 }
5402 __EXCEPT_PAGE_FAULT
5403 {
5404 SetLastError(STATUS_ACCESS_VIOLATION);
5405 ret = FALSE;
5406 }
5407 __ENDTRY
5408 return ret;
5409}
usage
GLsizeiptr const GLvoid GLenum usage
Definition: glext.h:5919
CERT_ENHKEY_USAGE
struct _CTL_USAGE CERT_ENHKEY_USAGE

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeEnumerated()

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

Definition at line 4764 of file decode.c.

4767{
4768 BOOL ret;
4769
4770 if (!pvStructInfo)
4771 {
4772 *pcbStructInfo = sizeof(int);
4773 return TRUE;
4774 }
4775 __TRY
4776 {
4777 if (pbEncoded[0] == ASN_ENUMERATED)
4778 {
4779 unsigned int val = 0, i;
4780
4781 if (cbEncoded <= 1)
4782 {
4783 SetLastError(CRYPT_E_ASN1_EOD);
4784 ret = FALSE;
4785 }
4786 else if (pbEncoded[1] == 0)
4787 {
4788 SetLastError(CRYPT_E_ASN1_CORRUPT);
4789 ret = FALSE;
4790 }
4791 else
4792 {
4793 /* A little strange looking, but we have to accept a sign byte:
4794 * 0xffffffff gets encoded as 0a 05 00 ff ff ff ff. Also,
4795 * assuming a small length is okay here, it has to be in short
4796 * form.
4797 */
4798 if (pbEncoded[1] > sizeof(unsigned int) + 1)
4799 {
4800 SetLastError(CRYPT_E_ASN1_LARGE);
4801 return FALSE;
4802 }
4803 for (i = 0; i < pbEncoded[1]; i++)
4804 {
4805 val <<= 8;
4806 val |= pbEncoded[2 + i];
4807 }
4808 if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4809 pvStructInfo, pcbStructInfo, sizeof(unsigned int))))
4810 {
4811 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4812 pvStructInfo = *(BYTE **)pvStructInfo;
4813 memcpy(pvStructInfo, &val, sizeof(unsigned int));
4814 }
4815 }
4816 }
4817 else
4818 {
4819 SetLastError(CRYPT_E_ASN1_BADTAG);
4820 ret = FALSE;
4821 }
4822 }
4823 __EXCEPT_PAGE_FAULT
4824 {
4825 SetLastError(STATUS_ACCESS_VIOLATION);
4826 ret = FALSE;
4827 }
4828 __ENDTRY
4829 return ret;
4830}
ASN_ENUMERATED
#define ASN_ENUMERATED
Definition: crypt32_private.h:32
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 CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeExcludedSubtree()

static BOOL CRYPT_AsnDecodeExcludedSubtree ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5560 of file decode.c.

5563{
5564 BOOL ret = TRUE;
5565 struct AsnArrayDescriptor arrayDesc = { 0,
5566 offsetof(CERT_NAME_CONSTRAINTS_INFO, cExcludedSubtree),
5567 offsetof(CERT_NAME_CONSTRAINTS_INFO, rgExcludedSubtree),
5568 FINALMEMBERSIZE(CERT_NAME_CONSTRAINTS_INFO, cExcludedSubtree),
5569 CRYPT_AsnDecodeSubtree, sizeof(CERT_GENERAL_SUBTREE), TRUE,
5570 offsetof(CERT_GENERAL_SUBTREE, Base.pwszURL) };
5571
5572 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
5573 pvStructInfo, *pcbStructInfo, pcbDecoded);
5574
5575 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
5576 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
5577 return ret;
5578}
CRYPT_AsnDecodeSubtree
static BOOL CRYPT_AsnDecodeSubtree(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5505
Base
_In_opt_ ULONG Base
Definition: rtlfuncs.h:2486
_CERT_GENERAL_SUBTREE
Definition: wincrypt.h:583
_CERT_NAME_CONSTRAINTS_INFO
Definition: wincrypt.h:590
CERT_GENERAL_SUBTREE
struct _CERT_GENERAL_SUBTREE CERT_GENERAL_SUBTREE

Referenced by CRYPT_AsnDecodeNameConstraints().

◆ CRYPT_AsnDecodeExtension()

static BOOL CRYPT_AsnDecodeExtension ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1425 of file decode.c.

1427{
1428 struct AsnDecodeSequenceItem items[] = {
1429 { ASN_OBJECTIDENTIFIER, offsetof(CERT_EXTENSION, pszObjId),
1430 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
1431 offsetof(CERT_EXTENSION, pszObjId), 0 },
1432 { ASN_BOOL, offsetof(CERT_EXTENSION, fCritical), CRYPT_AsnDecodeBool,
1433 sizeof(BOOL), TRUE, FALSE, 0, 0 },
1434 { ASN_OCTETSTRING, offsetof(CERT_EXTENSION, Value),
1435 CRYPT_AsnDecodeOctets, sizeof(CRYPT_OBJID_BLOB), FALSE, TRUE,
1436 offsetof(CERT_EXTENSION, Value.pbData) },
1437 };
1438 BOOL ret = TRUE;
1439 PCERT_EXTENSION ext = pvStructInfo;
1440
1441 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags, ext,
1442 *pcbStructInfo);
1443
1444 if (ext)
1445 TRACE("ext->pszObjId is %p\n", ext->pszObjId);
1446 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
1447 pbEncoded, cbEncoded, dwFlags, NULL, ext, pcbStructInfo,
1448 pcbDecoded, ext ? ext->pszObjId : NULL);
1449 if (ext)
1450 TRACE("ext->pszObjId is %p (%s)\n", ext->pszObjId,
1451 debugstr_a(ext->pszObjId));
1452 TRACE("returning %d (%08lx)\n", ret, GetLastError());
1453 return ret;
1454}
ext
static const WCHAR *const ext[]
Definition: module.c:53
Value
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413

Referenced by CRYPT_AsnDecodeCertExtensionsInternal(), CRYPT_AsnDecodeCRLEntryExtensions(), CRYPT_AsnDecodeCRLExtensionsInternal(), CRYPT_AsnDecodeCTLExtensionsInternal(), and CRYPT_AsnDecodeExtensions().

◆ CRYPT_AsnDecodeExtensions()

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

Definition at line 1456 of file decode.c.

1459{
1460 BOOL ret = TRUE;
1461
1462 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1463 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
1464
1465 __TRY
1466 {
1467 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1468 offsetof(CERT_EXTENSIONS, cExtension),
1469 offsetof(CERT_EXTENSIONS, rgExtension),
1470 sizeof(CERT_EXTENSIONS),
1471 CRYPT_AsnDecodeExtension, sizeof(CERT_EXTENSION), TRUE,
1472 offsetof(CERT_EXTENSION, pszObjId) };
1473 CERT_EXTENSIONS *exts = pvStructInfo;
1474
1475 if (pvStructInfo && !(dwFlags & CRYPT_DECODE_ALLOC_FLAG))
1476 exts->rgExtension = (CERT_EXTENSION *)(exts + 1);
1477 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
1478 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo, NULL);
1479 }
1480 __EXCEPT_PAGE_FAULT
1481 {
1482 SetLastError(STATUS_ACCESS_VIOLATION);
1483 ret = FALSE;
1484 }
1485 __ENDTRY
1486 return ret;
1487}
exts
static const struct encodedExtensions exts[]
Definition: encode.c:2738
_CERT_EXTENSIONS
Definition: wincrypt.h:244
CERT_EXTENSIONS
struct _CERT_EXTENSIONS CERT_EXTENSIONS

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeGeneralizedTime()

static BOOL CRYPT_AsnDecodeGeneralizedTime ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5015 of file decode.c.

5018{
5019 BOOL ret = FALSE;
5020
5021 if (pbEncoded[0] == ASN_GENERALTIME)
5022 {
5023 if (cbEncoded <= 1)
5024 SetLastError(CRYPT_E_ASN1_EOD);
5025 else if (pbEncoded[1] > 0x7f)
5026 {
5027 /* long-form date strings really can't be valid */
5028 SetLastError(CRYPT_E_ASN1_CORRUPT);
5029 }
5030 else
5031 {
5032 BYTE len = pbEncoded[1];
5033
5034 if (len < MIN_ENCODED_TIME_LENGTH)
5035 SetLastError(CRYPT_E_ASN1_CORRUPT);
5036 else
5037 {
5038 SYSTEMTIME sysTime = { 0 };
5039
5040 ret = TRUE;
5041 if (pcbDecoded)
5042 *pcbDecoded = 2 + len;
5043 pbEncoded += 2;
5044 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 4, sysTime.wYear);
5045 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wMonth);
5046 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wDay);
5047 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wHour);
5048 if (ret && len > 0)
5049 {
5050 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2,
5051 sysTime.wMinute);
5052 if (ret && len > 0)
5053 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2,
5054 sysTime.wSecond);
5055 if (ret && len > 0 && (*pbEncoded == '.' ||
5056 *pbEncoded == ','))
5057 {
5058 BYTE digits;
5059
5060 pbEncoded++;
5061 len--;
5062 /* workaround macro weirdness */
5063 digits = min(len, 3);
5064 CRYPT_TIME_GET_DIGITS(pbEncoded, len, digits,
5065 sysTime.wMilliseconds);
5066 }
5067 if (ret)
5068 ret = CRYPT_AsnDecodeTimeZone(pbEncoded, len,
5069 &sysTime);
5070 }
5071 if (ret)
5072 {
5073 if (!pvStructInfo)
5074 *pcbStructInfo = sizeof(FILETIME);
5075 else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
5076 sizeof(FILETIME))))
5077 ret = SystemTimeToFileTime(&sysTime, pvStructInfo);
5078 }
5079 }
5080 }
5081 }
5082 else
5083 SetLastError(CRYPT_E_ASN1_BADTAG);
5084 return ret;
5085}
CRYPT_AsnDecodeTimeZone
static BOOL CRYPT_AsnDecodeTimeZone(const BYTE *pbEncoded, DWORD len, SYSTEMTIME *sysTime)
Definition: decode.c:4855
MIN_ENCODED_TIME_LENGTH
#define MIN_ENCODED_TIME_LENGTH
Definition: decode.c:4910
CRYPT_TIME_GET_DIGITS
#define CRYPT_TIME_GET_DIGITS(pbEncoded, len, numDigits, word)
Definition: decode.c:4835
SystemTimeToFileTime
BOOL WINAPI SystemTimeToFileTime(IN CONST SYSTEMTIME *lpSystemTime, OUT LPFILETIME lpFileTime)
Definition: time.c:153
digits
static const int digits[]
Definition: decode.c:71
min
#define min(a, b)
Definition: monoChain.cc:55
_SYSTEMTIME
Definition: minwinbase.h:255
_SYSTEMTIME::wYear
WORD wYear
Definition: minwinbase.h:256
_SYSTEMTIME::wMilliseconds
WORD wMilliseconds
Definition: minwinbase.h:263
_SYSTEMTIME::wMonth
WORD wMonth
Definition: minwinbase.h:257
_SYSTEMTIME::wHour
WORD wHour
Definition: minwinbase.h:260
_SYSTEMTIME::wSecond
WORD wSecond
Definition: minwinbase.h:262
_SYSTEMTIME::wMinute
WORD wMinute
Definition: minwinbase.h:261
_SYSTEMTIME::wDay
WORD wDay
Definition: minwinbase.h:259

Referenced by CRYPT_AsnDecodeCertStatus(), CRYPT_AsnDecodeChoiceOfTimeInternal(), CRYPT_AsnDecodeOCSPBasicResponse(), CRYPT_AsnDecodeOCSPBasicResponseEntry(), and CRYPT_AsnDecodeOCSPNextUpdate().

◆ CRYPT_AsnDecodeIA5String()

static BOOL CRYPT_AsnDecodeIA5String ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2380 of file decode.c.

2383{
2384 BOOL ret = TRUE;
2385 DWORD dataLen;
2386 LPSTR *pStr = pvStructInfo;
2387
2388 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2389 {
2390 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2391 DWORD bytesNeeded = sizeof(LPSTR) + sizeof(char);
2392
2393 if (pbEncoded[0] != ASN_IA5STRING)
2394 {
2395 SetLastError(CRYPT_E_ASN1_CORRUPT);
2396 ret = FALSE;
2397 }
2398 else
2399 {
2400 bytesNeeded += dataLen;
2401 if (pcbDecoded)
2402 *pcbDecoded = 1 + lenBytes + dataLen;
2403 if (!pvStructInfo)
2404 *pcbStructInfo = bytesNeeded;
2405 else if (*pcbStructInfo < bytesNeeded)
2406 {
2407 *pcbStructInfo = bytesNeeded;
2408 SetLastError(ERROR_MORE_DATA);
2409 ret = FALSE;
2410 }
2411 else
2412 {
2413 *pcbStructInfo = bytesNeeded;
2414 if (dataLen)
2415 {
2416 LPSTR str = *pStr;
2417
2418 assert(str);
2419 memcpy(str, pbEncoded + 1 + lenBytes, dataLen);
2420 str[dataLen] = 0;
2421 }
2422 else
2423 *pStr = NULL;
2424 }
2425 }
2426 }
2427 return ret;
2428}
ASN_IA5STRING
#define ASN_IA5STRING
Definition: crypt32_private.h:39
str
const WCHAR * str
Definition: rpc_transport.c:2696

Referenced by CRYPT_AsnDecodeNoticeReference().

◆ CRYPT_AsnDecodeInhibitMapping()

static BOOL CRYPT_AsnDecodeInhibitMapping ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3786 of file decode.c.

3789{
3790 BOOL ret;
3791 DWORD skip, size = sizeof(skip);
3792
3793 if (!cbEncoded)
3794 {
3795 SetLastError(CRYPT_E_ASN1_EOD);
3796 return FALSE;
3797 }
3798 if (pbEncoded[0] != (ASN_CONTEXT | 1))
3799 {
3800 SetLastError(CRYPT_E_ASN1_BADTAG);
3801 return FALSE;
3802 }
3803 if ((ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags,
3804 &skip, &size, pcbDecoded)))
3805 {
3806 DWORD bytesNeeded = FINALMEMBERSIZE(CERT_POLICY_CONSTRAINTS_INFO,
3807 fInhibitPolicyMapping);
3808
3809 if (!pvStructInfo)
3810 *pcbStructInfo = bytesNeeded;
3811 else if (*pcbStructInfo < bytesNeeded)
3812 {
3813 *pcbStructInfo = bytesNeeded;
3814 SetLastError(ERROR_MORE_DATA);
3815 ret = FALSE;
3816 }
3817 else
3818 {
3819 CERT_POLICY_CONSTRAINTS_INFO *info = CONTAINING_RECORD(pvStructInfo,
3820 CERT_POLICY_CONSTRAINTS_INFO, fInhibitPolicyMapping);
3821
3822 *pcbStructInfo = bytesNeeded;
3823 /* The BOOL is implicit: if the integer is present, then it's
3824 * TRUE.
3825 */
3826 info->fInhibitPolicyMapping = TRUE;
3827 info->dwInhibitPolicyMappingSkipCerts = skip;
3828 }
3829 }
3830 return ret;
3831}
skip
#define skip(...)
Definition: atltest.h:64
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by CRYPT_AsnDecodeCertPolicyConstraints().

◆ CRYPT_AsnDecodeInt()

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

Definition at line 4521 of file decode.c.

4524{
4525 BOOL ret;
4526
4527 __TRY
4528 {
4529 DWORD bytesNeeded = 0;
4530
4531 if (!cbEncoded)
4532 {
4533 SetLastError(CRYPT_E_ASN1_EOD);
4534 ret = FALSE;
4535 }
4536 else if (pbEncoded[0] != ASN_INTEGER)
4537 {
4538 SetLastError(CRYPT_E_ASN1_BADTAG);
4539 ret = FALSE;
4540 }
4541 else
4542 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded,
4543 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
4544 if (ret)
4545 {
4546 if (!pvStructInfo)
4547 *pcbStructInfo = bytesNeeded;
4548 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4549 pvStructInfo, pcbStructInfo, bytesNeeded)))
4550 {
4551 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4552 pvStructInfo = *(BYTE **)pvStructInfo;
4553 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded,
4554 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
4555 &bytesNeeded, NULL);
4556 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
4557 CRYPT_FreeSpace(pDecodePara, pvStructInfo);
4558 }
4559 }
4560 }
4561 __EXCEPT_PAGE_FAULT
4562 {
4563 SetLastError(STATUS_ACCESS_VIOLATION);
4564 ret = FALSE;
4565 }
4566 __ENDTRY
4567 return ret;
4568}

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeInteger()

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

Definition at line 4614 of file decode.c.

4617{
4618 BOOL ret;
4619
4620 __TRY
4621 {
4622 DWORD bytesNeeded = 0;
4623
4624 if (pbEncoded[0] != ASN_INTEGER)
4625 {
4626 SetLastError(CRYPT_E_ASN1_BADTAG);
4627 ret = FALSE;
4628 }
4629 else
4630 ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded,
4631 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
4632 if (ret)
4633 {
4634 if (!pvStructInfo)
4635 *pcbStructInfo = bytesNeeded;
4636 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4637 pvStructInfo, pcbStructInfo, bytesNeeded)))
4638 {
4639 CRYPT_INTEGER_BLOB *blob;
4640
4641 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4642 pvStructInfo = *(BYTE **)pvStructInfo;
4643 blob = pvStructInfo;
4644 blob->pbData = (BYTE *)pvStructInfo +
4645 sizeof(CRYPT_INTEGER_BLOB);
4646 ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded,
4647 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, pvStructInfo,
4648 &bytesNeeded, NULL);
4649 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
4650 CRYPT_FreeSpace(pDecodePara, blob);
4651 }
4652 }
4653 }
4654 __EXCEPT_PAGE_FAULT
4655 {
4656 SetLastError(STATUS_ACCESS_VIOLATION);
4657 ret = FALSE;
4658 }
4659 __ENDTRY
4660 return ret;
4661}
CRYPT_ENCODE_ALLOC_FLAG
#define CRYPT_ENCODE_ALLOC_FLAG
Definition: wincrypt.h:3599

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeIntegerInternal()

static BOOL CRYPT_AsnDecodeIntegerInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 4570 of file decode.c.

4573{
4574 BOOL ret;
4575 DWORD bytesNeeded, dataLen;
4576
4577 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4578 {
4579 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4580
4581 bytesNeeded = dataLen + sizeof(CRYPT_INTEGER_BLOB);
4582 if (pcbDecoded)
4583 *pcbDecoded = 1 + lenBytes + dataLen;
4584 if (!pvStructInfo)
4585 *pcbStructInfo = bytesNeeded;
4586 else if (*pcbStructInfo < bytesNeeded)
4587 {
4588 *pcbStructInfo = bytesNeeded;
4589 SetLastError(ERROR_MORE_DATA);
4590 ret = FALSE;
4591 }
4592 else
4593 {
4594 CRYPT_INTEGER_BLOB *blob = pvStructInfo;
4595
4596 *pcbStructInfo = bytesNeeded;
4597 blob->cbData = dataLen;
4598 assert(blob->pbData);
4599 if (blob->cbData)
4600 {
4601 DWORD i;
4602
4603 for (i = 0; i < blob->cbData; i++)
4604 {
4605 blob->pbData[i] = *(pbEncoded + 1 + lenBytes +
4606 dataLen - i - 1);
4607 }
4608 }
4609 }
4610 }
4611 return ret;
4612}

Referenced by CRYPT_AsnDecodeAuthorityKeyId(), CRYPT_AsnDecodeAuthorityKeyId2(), CRYPT_AsnDecodeCertInfo(), CRYPT_AsnDecodeCRLEntry(), CRYPT_AsnDecodeCTL(), CRYPT_AsnDecodeInteger(), CRYPT_AsnDecodeIssuerSerialNumber(), and CRYPT_AsnDecodeOCSPBasicResponseEntry().

◆ CRYPT_AsnDecodeIntInternal()

static BOOL CRYPT_AsnDecodeIntInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 4480 of file decode.c.

4482{
4483 BOOL ret;
4484 DWORD dataLen;
4485
4486 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4487 {
4488 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4489
4490 if (pcbDecoded)
4491 *pcbDecoded = 1 + lenBytes + dataLen;
4492 if (dataLen > sizeof(int))
4493 {
4494 SetLastError(CRYPT_E_ASN1_LARGE);
4495 ret = FALSE;
4496 }
4497 else if (!pvStructInfo)
4498 *pcbStructInfo = sizeof(int);
4499 else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, sizeof(int))))
4500 {
4501 int val, i;
4502
4503 if (dataLen && pbEncoded[1 + lenBytes] & 0x80)
4504 {
4505 /* initialize to a negative value to sign-extend */
4506 val = -1;
4507 }
4508 else
4509 val = 0;
4510 for (i = 0; i < dataLen; i++)
4511 {
4512 val <<= 8;
4513 val |= pbEncoded[1 + lenBytes + i];
4514 }
4515 memcpy(pvStructInfo, &val, sizeof(int));
4516 }
4517 }
4518 return ret;
4519}

Referenced by CRYPT_AsnDecodeCertVersion(), CRYPT_AsnDecodeCMSSignedInfo(), CRYPT_AsnDecodeCMSSignerInfoInternal(), CRYPT_AsnDecodeCRLInfo(), CRYPT_AsnDecodeCTL(), CRYPT_AsnDecodeInhibitMapping(), CRYPT_AsnDecodeInt(), CRYPT_AsnDecodeMaximum(), CRYPT_AsnDecodeNoticeNumbers(), CRYPT_AsnDecodeOCSPResponseStatus(), CRYPT_AsnDecodePathLenConstraint(), CRYPT_AsnDecodePKCSDigestedData(), CRYPT_AsnDecodePKCSEnvelopedData(), CRYPT_AsnDecodePKCSSignerInfoInternal(), CRYPT_AsnDecodeRecipientInfo(), CRYPT_AsnDecodeRequireExplicit(), CRYPT_AsnDecodeRsaPrivKey(), and CRYPT_AsnDecodeSubtree().

◆ CRYPT_AsnDecodeIssuerSerialNumber()

static BOOL CRYPT_AsnDecodeIssuerSerialNumber ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5618 of file decode.c.

5621{
5622 BOOL ret;
5623 struct AsnDecodeSequenceItem items[] = {
5624 { 0, offsetof(CERT_ISSUER_SERIAL_NUMBER, Issuer), CRYPT_AsnDecodeDerBlob,
5625 sizeof(CRYPT_DER_BLOB), FALSE, TRUE, offsetof(CERT_ISSUER_SERIAL_NUMBER,
5626 Issuer.pbData) },
5627 { ASN_INTEGER, offsetof(CERT_ISSUER_SERIAL_NUMBER, SerialNumber),
5628 CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE,
5629 TRUE, offsetof(CERT_ISSUER_SERIAL_NUMBER, SerialNumber.pbData), 0 },
5630 };
5631 CERT_ISSUER_SERIAL_NUMBER *issuerSerial = pvStructInfo;
5632
5633 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
5634 pvStructInfo, *pcbStructInfo, pcbDecoded);
5635
5636 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
5637 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
5638 pcbDecoded, issuerSerial ? issuerSerial->Issuer.pbData : NULL);
5639 if (ret && issuerSerial && !issuerSerial->SerialNumber.cbData)
5640 {
5641 SetLastError(CRYPT_E_ASN1_CORRUPT);
5642 ret = FALSE;
5643 }
5644 TRACE("returning %d\n", ret);
5645 return ret;
5646}
_CERT_ISSUER_SERIAL_NUMBER::Issuer
CERT_NAME_BLOB Issuer
Definition: wincrypt.h:3824
_CERT_ISSUER_SERIAL_NUMBER::SerialNumber
CRYPT_INTEGER_BLOB SerialNumber
Definition: wincrypt.h:3825

Referenced by CRYPT_AsnDecodeCMSSignerId(), CRYPT_AsnDecodePKCSSignerInfoInternal(), and CRYPT_AsnDecodeRecipientInfo().

◆ CRYPT_AsnDecodeIssuingDistPoint()

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

Definition at line 5411 of file decode.c.

5414{
5415 BOOL ret;
5416
5417 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
5418 pDecodePara, pvStructInfo, *pcbStructInfo);
5419
5420 __TRY
5421 {
5422 struct AsnDecodeSequenceItem items[] = {
5423 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0, offsetof(CRL_ISSUING_DIST_POINT,
5424 DistPointName), CRYPT_AsnDecodeDistPointName,
5425 sizeof(CRL_DIST_POINT_NAME), TRUE, TRUE,
5426 offsetof(CRL_ISSUING_DIST_POINT,
5427 DistPointName.FullName.rgAltEntry), 0 },
5428 { ASN_CONTEXT | 1, offsetof(CRL_ISSUING_DIST_POINT,
5429 fOnlyContainsUserCerts), CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE,
5430 FALSE, 0 },
5431 { ASN_CONTEXT | 2, offsetof(CRL_ISSUING_DIST_POINT,
5432 fOnlyContainsCACerts), CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE,
5433 FALSE, 0 },
5434 { ASN_CONTEXT | 3, offsetof(CRL_ISSUING_DIST_POINT,
5435 OnlySomeReasonFlags), CRYPT_AsnDecodeBitsInternal,
5436 sizeof(CRYPT_BIT_BLOB), TRUE, TRUE, offsetof(CRL_ISSUING_DIST_POINT,
5437 OnlySomeReasonFlags.pbData), 0 },
5438 { ASN_CONTEXT | 4, offsetof(CRL_ISSUING_DIST_POINT,
5439 fIndirectCRL), CRYPT_AsnDecodeBool, sizeof(BOOL), TRUE, FALSE, 0 },
5440 };
5441
5442 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
5443 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
5444 pcbStructInfo, NULL, NULL);
5445 }
5446 __EXCEPT_PAGE_FAULT
5447 {
5448 SetLastError(STATUS_ACCESS_VIOLATION);
5449 ret = FALSE;
5450 }
5451 __ENDTRY
5452 return ret;
5453}
_CRL_ISSUING_DIST_POINT
Definition: wincrypt.h:575

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeMaximum()

static BOOL CRYPT_AsnDecodeMaximum ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5455 of file decode.c.

5458{
5459 BOOL ret;
5460 DWORD max, size = sizeof(max);
5461
5462 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
5463 pvStructInfo, *pcbStructInfo, pcbDecoded);
5464
5465 if (!cbEncoded)
5466 {
5467 SetLastError(CRYPT_E_ASN1_EOD);
5468 return FALSE;
5469 }
5470 if (pbEncoded[0] != (ASN_CONTEXT | 1))
5471 {
5472 SetLastError(CRYPT_E_ASN1_BADTAG);
5473 return FALSE;
5474 }
5475 if ((ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags,
5476 &max, &size, pcbDecoded)))
5477 {
5478 DWORD bytesNeeded = FINALMEMBERSIZE(CERT_GENERAL_SUBTREE, fMaximum);
5479
5480 if (!pvStructInfo)
5481 *pcbStructInfo = bytesNeeded;
5482 else if (*pcbStructInfo < bytesNeeded)
5483 {
5484 *pcbStructInfo = bytesNeeded;
5485 SetLastError(ERROR_MORE_DATA);
5486 ret = FALSE;
5487 }
5488 else
5489 {
5490 CERT_GENERAL_SUBTREE *subtree = CONTAINING_RECORD(pvStructInfo,
5491 CERT_GENERAL_SUBTREE, fMaximum);
5492
5493 *pcbStructInfo = bytesNeeded;
5494 /* The BOOL is implicit: if the integer is present, then it's
5495 * TRUE.
5496 */
5497 subtree->fMaximum = TRUE;
5498 subtree->dwMaximum = max;
5499 }
5500 }
5501 TRACE("returning %d\n", ret);
5502 return ret;
5503}
_CERT_GENERAL_SUBTREE::fMaximum
BOOL fMaximum
Definition: wincrypt.h:586
_CERT_GENERAL_SUBTREE::dwMaximum
DWORD dwMaximum
Definition: wincrypt.h:587
max
#define max(a, b)
Definition: svc.c:63

Referenced by CRYPT_AsnDecodeSubtree().

◆ CRYPT_AsnDecodeName()

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

Definition at line 1909 of file decode.c.

1912{
1913 BOOL ret = TRUE;
1914
1915 __TRY
1916 {
1917 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
1918 offsetof(CERT_NAME_INFO, cRDN), offsetof(CERT_NAME_INFO, rgRDN),
1919 sizeof(CERT_NAME_INFO),
1920 CRYPT_AsnDecodeRdn, sizeof(CERT_RDN), TRUE,
1921 offsetof(CERT_RDN, rgRDNAttr) };
1922 DWORD bytesNeeded = 0;
1923
1924 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
1925 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, NULL, &bytesNeeded,
1926 NULL);
1927 if (ret)
1928 {
1929 if (!pvStructInfo)
1930 *pcbStructInfo = bytesNeeded;
1931 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
1932 pvStructInfo, pcbStructInfo, bytesNeeded)))
1933 {
1934 CERT_NAME_INFO *info;
1935
1936 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1937 pvStructInfo = *(BYTE **)pvStructInfo;
1938 info = pvStructInfo;
1939 info->rgRDN = (CERT_RDN *)((BYTE *)pvStructInfo +
1940 sizeof(CERT_NAME_INFO));
1941 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
1942 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pvStructInfo,
1943 &bytesNeeded, NULL);
1944 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
1945 CRYPT_FreeSpace(pDecodePara, info);
1946 }
1947 }
1948 }
1949 __EXCEPT_PAGE_FAULT
1950 {
1951 SetLastError(STATUS_ACCESS_VIOLATION);
1952 ret = FALSE;
1953 }
1954 __ENDTRY
1955 return ret;
1956}
CRYPT_AsnDecodeRdn
static BOOL CRYPT_AsnDecodeRdn(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1894
_CERT_NAME_INFO
Definition: wincrypt.h:275
_CERT_RDN
Definition: wincrypt.h:270
CERT_NAME_INFO
struct _CERT_NAME_INFO CERT_NAME_INFO

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeNameConstraints()

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

Definition at line 5580 of file decode.c.

5583{
5584 BOOL ret = FALSE;
5585
5586 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
5587 pDecodePara, pvStructInfo, *pcbStructInfo);
5588
5589 __TRY
5590 {
5591 struct AsnDecodeSequenceItem items[] = {
5592 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0,
5593 offsetof(CERT_NAME_CONSTRAINTS_INFO, cPermittedSubtree),
5594 CRYPT_AsnDecodePermittedSubtree,
5595 MEMBERSIZE(CERT_NAME_CONSTRAINTS_INFO, cPermittedSubtree,
5596 cExcludedSubtree), TRUE, TRUE,
5597 offsetof(CERT_NAME_CONSTRAINTS_INFO, rgPermittedSubtree), 0 },
5598 { ASN_CONTEXT | ASN_CONSTRUCTOR | 1,
5599 offsetof(CERT_NAME_CONSTRAINTS_INFO, cExcludedSubtree),
5600 CRYPT_AsnDecodeExcludedSubtree,
5601 FINALMEMBERSIZE(CERT_NAME_CONSTRAINTS_INFO, cExcludedSubtree),
5602 TRUE, TRUE,
5603 offsetof(CERT_NAME_CONSTRAINTS_INFO, rgExcludedSubtree), 0 },
5604 };
5605
5606 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
5607 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
5608 pcbStructInfo, NULL, NULL);
5609 }
5610 __EXCEPT_PAGE_FAULT
5611 {
5612 SetLastError(STATUS_ACCESS_VIOLATION);
5613 }
5614 __ENDTRY
5615 return ret;
5616}
CRYPT_AsnDecodePermittedSubtree
static BOOL CRYPT_AsnDecodePermittedSubtree(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5539
CRYPT_AsnDecodeExcludedSubtree
static BOOL CRYPT_AsnDecodeExcludedSubtree(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5560

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeNameValue()

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

Definition at line 1640 of file decode.c.

1643{
1644 BOOL ret = TRUE;
1645
1646 __TRY
1647 {
1648 ret = CRYPT_AsnDecodeNameValueInternal(pbEncoded, cbEncoded,
1649 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
1650 if (ret && pvStructInfo)
1651 {
1652 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
1653 pcbStructInfo, *pcbStructInfo);
1654 if (ret)
1655 {
1656 CERT_NAME_VALUE *value;
1657
1658 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1659 pvStructInfo = *(BYTE **)pvStructInfo;
1660 value = pvStructInfo;
1661 value->Value.pbData = ((BYTE *)value + sizeof(CERT_NAME_VALUE));
1662 ret = CRYPT_AsnDecodeNameValueInternal( pbEncoded, cbEncoded,
1663 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
1664 pcbStructInfo, NULL);
1665 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
1666 CRYPT_FreeSpace(pDecodePara, value);
1667 }
1668 }
1669 }
1670 __EXCEPT_PAGE_FAULT
1671 {
1672 SetLastError(STATUS_ACCESS_VIOLATION);
1673 ret = FALSE;
1674 }
1675 __ENDTRY
1676 return ret;
1677}
CRYPT_AsnDecodeNameValueInternal
static BOOL CRYPT_AsnDecodeNameValueInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1493
_CERT_NAME_VALUE
Definition: wincrypt.h:280
value
Definition: pdh_main.c:96

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeNameValueInternal()

static BOOL CRYPT_AsnDecodeNameValueInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1493 of file decode.c.

1496{
1497 BOOL ret = TRUE;
1498 DWORD dataLen;
1499 CERT_NAME_VALUE *value = pvStructInfo;
1500
1501 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1502 {
1503 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1504 DWORD bytesNeeded = sizeof(CERT_NAME_VALUE), valueType;
1505
1506 switch (pbEncoded[0])
1507 {
1508 case ASN_OCTETSTRING:
1509 valueType = CERT_RDN_OCTET_STRING;
1510 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1511 bytesNeeded += dataLen;
1512 break;
1513 case ASN_NUMERICSTRING:
1514 valueType = CERT_RDN_NUMERIC_STRING;
1515 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1516 bytesNeeded += dataLen;
1517 break;
1518 case ASN_PRINTABLESTRING:
1519 valueType = CERT_RDN_PRINTABLE_STRING;
1520 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1521 bytesNeeded += dataLen;
1522 break;
1523 case ASN_IA5STRING:
1524 valueType = CERT_RDN_IA5_STRING;
1525 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1526 bytesNeeded += dataLen;
1527 break;
1528 case ASN_T61STRING:
1529 valueType = CERT_RDN_T61_STRING;
1530 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1531 bytesNeeded += dataLen;
1532 break;
1533 case ASN_VIDEOTEXSTRING:
1534 valueType = CERT_RDN_VIDEOTEX_STRING;
1535 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1536 bytesNeeded += dataLen;
1537 break;
1538 case ASN_GRAPHICSTRING:
1539 valueType = CERT_RDN_GRAPHIC_STRING;
1540 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1541 bytesNeeded += dataLen;
1542 break;
1543 case ASN_VISIBLESTRING:
1544 valueType = CERT_RDN_VISIBLE_STRING;
1545 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1546 bytesNeeded += dataLen;
1547 break;
1548 case ASN_GENERALSTRING:
1549 valueType = CERT_RDN_GENERAL_STRING;
1550 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1551 bytesNeeded += dataLen;
1552 break;
1553 case ASN_UNIVERSALSTRING:
1554 FIXME("ASN_UNIVERSALSTRING: unimplemented\n");
1555 SetLastError(CRYPT_E_ASN1_BADTAG);
1556 return FALSE;
1557 case ASN_BMPSTRING:
1558 valueType = CERT_RDN_BMP_STRING;
1559 bytesNeeded += dataLen;
1560 break;
1561 case ASN_UTF8STRING:
1562 valueType = CERT_RDN_UTF8_STRING;
1563 bytesNeeded += MultiByteToWideChar(CP_UTF8, 0,
1564 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen, NULL, 0) * sizeof(WCHAR);
1565 break;
1566 default:
1567 SetLastError(CRYPT_E_ASN1_BADTAG);
1568 return FALSE;
1569 }
1570
1571 if (pcbDecoded)
1572 *pcbDecoded = 1 + lenBytes + dataLen;
1573 if (!value)
1574 *pcbStructInfo = bytesNeeded;
1575 else if (*pcbStructInfo < bytesNeeded)
1576 {
1577 *pcbStructInfo = bytesNeeded;
1578 SetLastError(ERROR_MORE_DATA);
1579 ret = FALSE;
1580 }
1581 else
1582 {
1583 *pcbStructInfo = bytesNeeded;
1584 value->dwValueType = valueType;
1585 if (dataLen)
1586 {
1587 DWORD i;
1588
1589 assert(value->Value.pbData);
1590 switch (pbEncoded[0])
1591 {
1592 case ASN_OCTETSTRING:
1593 case ASN_NUMERICSTRING:
1594 case ASN_PRINTABLESTRING:
1595 case ASN_IA5STRING:
1596 case ASN_T61STRING:
1597 case ASN_VIDEOTEXSTRING:
1598 case ASN_GRAPHICSTRING:
1599 case ASN_VISIBLESTRING:
1600 case ASN_GENERALSTRING:
1601 value->Value.cbData = dataLen;
1602 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
1603 memcpy(value->Value.pbData,
1604 pbEncoded + 1 + lenBytes, dataLen);
1605 else
1606 value->Value.pbData = (LPBYTE)pbEncoded + 1 +
1607 lenBytes;
1608 break;
1609 case ASN_BMPSTRING:
1610 {
1611 LPWSTR str = (LPWSTR)value->Value.pbData;
1612
1613 value->Value.cbData = dataLen;
1614 for (i = 0; i < dataLen / 2; i++)
1615 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
1616 pbEncoded[1 + lenBytes + 2 * i + 1];
1617 break;
1618 }
1619 case ASN_UTF8STRING:
1620 {
1621 LPWSTR str = (LPWSTR)value->Value.pbData;
1622
1623 value->Value.cbData = MultiByteToWideChar(CP_UTF8, 0,
1624 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen,
1625 str, bytesNeeded - sizeof(CERT_NAME_VALUE)) * 2;
1626 break;
1627 }
1628 }
1629 }
1630 else
1631 {
1632 value->Value.cbData = 0;
1633 value->Value.pbData = NULL;
1634 }
1635 }
1636 }
1637 return ret;
1638}
ASN_BMPSTRING
#define ASN_BMPSTRING
Definition: crypt32_private.h:46
ASN_GENERALSTRING
#define ASN_GENERALSTRING
Definition: crypt32_private.h:44
ASN_VIDEOTEXSTRING
#define ASN_VIDEOTEXSTRING
Definition: crypt32_private.h:38
ASN_NUMERICSTRING
#define ASN_NUMERICSTRING
Definition: crypt32_private.h:35
ASN_GRAPHICSTRING
#define ASN_GRAPHICSTRING
Definition: crypt32_private.h:42
ASN_UTF8STRING
#define ASN_UTF8STRING
Definition: crypt32_private.h:33
ASN_UNIVERSALSTRING
#define ASN_UNIVERSALSTRING
Definition: crypt32_private.h:45
ASN_T61STRING
#define ASN_T61STRING
Definition: crypt32_private.h:37
ASN_PRINTABLESTRING
#define ASN_PRINTABLESTRING
Definition: crypt32_private.h:36
ASN_VISIBLESTRING
#define ASN_VISIBLESTRING
Definition: crypt32_private.h:43
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
CP_UTF8
#define CP_UTF8
Definition: nls.h:20
LPCSTR
const char * LPCSTR
Definition: typedefs.h:52
LPWSTR
uint16_t * LPWSTR
Definition: typedefs.h:56
CERT_RDN_UTF8_STRING
#define CERT_RDN_UTF8_STRING
Definition: wincrypt.h:2940
CERT_RDN_IA5_STRING
#define CERT_RDN_IA5_STRING
Definition: wincrypt.h:2931
CERT_RDN_GENERAL_STRING
#define CERT_RDN_GENERAL_STRING
Definition: wincrypt.h:2935
CERT_RDN_PRINTABLE_STRING
#define CERT_RDN_PRINTABLE_STRING
Definition: wincrypt.h:2927
CERT_NAME_VALUE
struct _CERT_NAME_VALUE CERT_NAME_VALUE
CERT_RDN_VISIBLE_STRING
#define CERT_RDN_VISIBLE_STRING
Definition: wincrypt.h:2933
CERT_RDN_VIDEOTEX_STRING
#define CERT_RDN_VIDEOTEX_STRING
Definition: wincrypt.h:2930
CERT_RDN_T61_STRING
#define CERT_RDN_T61_STRING
Definition: wincrypt.h:2929
CERT_RDN_OCTET_STRING
#define CERT_RDN_OCTET_STRING
Definition: wincrypt.h:2925
CERT_RDN_NUMERIC_STRING
#define CERT_RDN_NUMERIC_STRING
Definition: wincrypt.h:2926
CERT_RDN_BMP_STRING
#define CERT_RDN_BMP_STRING
Definition: wincrypt.h:2938
CERT_RDN_GRAPHIC_STRING
#define CERT_RDN_GRAPHIC_STRING
Definition: wincrypt.h:2932

Referenced by CRYPT_AsnDecodeNameValue(), and CRYPT_AsnDecodeRdnAttr().

◆ CRYPT_AsnDecodeNoticeNumbers()

static BOOL CRYPT_AsnDecodeNoticeNumbers ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2430 of file decode.c.

2433{
2434 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2435 offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, cNoticeNumbers),
2436 offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, rgNoticeNumbers),
2437 FINALMEMBERSIZE(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, cNoticeNumbers),
2438 CRYPT_AsnDecodeIntInternal, sizeof(int), FALSE, 0 };
2439 BOOL ret;
2440
2441 TRACE("(%p, %ld, %08lx, %p, %ld)\n", pbEncoded, cbEncoded, dwFlags,
2442 pvStructInfo, pvStructInfo ? *pcbDecoded : 0);
2443
2444 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
2445 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
2446 TRACE("returning %d\n", ret);
2447 return ret;
2448}
_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE
Definition: wincrypt.h:412

Referenced by CRYPT_AsnDecodeNoticeReference().

◆ CRYPT_AsnDecodeNoticeReference()

static BOOL CRYPT_AsnDecodeNoticeReference ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2450 of file decode.c.

2453{
2454 BOOL ret;
2455 struct AsnDecodeSequenceItem items[] = {
2456 { ASN_IA5STRING, offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
2457 pszOrganization), CRYPT_AsnDecodeIA5String, sizeof(LPSTR), FALSE, TRUE,
2458 offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, pszOrganization), 0 },
2459 { ASN_SEQUENCEOF, offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
2460 cNoticeNumbers), CRYPT_AsnDecodeNoticeNumbers,
2461 FINALMEMBERSIZE(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, cNoticeNumbers),
2462 FALSE, TRUE, offsetof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
2463 rgNoticeNumbers), 0 },
2464 };
2465 DWORD bytesNeeded = 0;
2466
2467 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2468 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
2469
2470 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
2471 pbEncoded, cbEncoded, dwFlags, NULL, NULL, &bytesNeeded, pcbDecoded,
2472 NULL);
2473 if (ret)
2474 {
2475 /* The caller is expecting a pointer to a
2476 * CERT_POLICY_QUALIFIER_NOTICE_REFERENCE to be decoded, whereas
2477 * CRYPT_AsnDecodeSequence is decoding a
2478 * CERT_POLICY_QUALIFIER_NOTICE_REFERENCE. Increment the bytes
2479 * needed, and decode again if the requisite space is available.
2480 */
2481 bytesNeeded += sizeof(PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE);
2482 if (!pvStructInfo)
2483 *pcbStructInfo = bytesNeeded;
2484 else if (*pcbStructInfo < bytesNeeded)
2485 {
2486 *pcbStructInfo = bytesNeeded;
2487 SetLastError(ERROR_MORE_DATA);
2488 ret = FALSE;
2489 }
2490 else
2491 {
2492 PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE noticeRef;
2493
2494 *pcbStructInfo = bytesNeeded;
2495 /* The pointer (pvStructInfo) passed in points to the first dynamic
2496 * pointer, so use it as the pointer to the
2497 * CERT_POLICY_QUALIFIER_NOTICE_REFERENCE, and create the
2498 * appropriate offset for the first dynamic pointer within the
2499 * notice reference by pointing to the first memory location past
2500 * the CERT_POLICY_QUALIFIER_NOTICE_REFERENCE.
2501 */
2502 noticeRef =
2503 *(PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE *)pvStructInfo;
2504 noticeRef->pszOrganization = (LPSTR)((LPBYTE)noticeRef +
2505 sizeof(CERT_POLICY_QUALIFIER_NOTICE_REFERENCE));
2506 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items), pbEncoded, cbEncoded, dwFlags,
2507 NULL, noticeRef, &bytesNeeded, pcbDecoded, noticeRef->pszOrganization);
2508 }
2509 }
2510 TRACE("returning %d\n", ret);
2511 return ret;
2512}
CRYPT_AsnDecodeNoticeNumbers
static BOOL CRYPT_AsnDecodeNoticeNumbers(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2430
CRYPT_AsnDecodeIA5String
static BOOL CRYPT_AsnDecodeIA5String(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2380
_CERT_POLICY_QUALIFIER_NOTICE_REFERENCE::pszOrganization
LPSTR pszOrganization
Definition: wincrypt.h:413
CERT_POLICY_QUALIFIER_NOTICE_REFERENCE
struct _CERT_POLICY_QUALIFIER_NOTICE_REFERENCE CERT_POLICY_QUALIFIER_NOTICE_REFERENCE
PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE
struct _CERT_POLICY_QUALIFIER_NOTICE_REFERENCE * PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE

Referenced by CRYPT_AsnDecodePolicyQualifierUserNoticeInternal().

◆ CRYPT_AsnDecodeObjectIdentifier()

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

Definition at line 6093 of file decode.c.

6096{
6097 DWORD bytesNeeded = 0;
6098 BOOL ret;
6099
6100 __TRY
6101 {
6102 ret = CRYPT_AsnDecodeOidInternal(pbEncoded, cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
6103 NULL, &bytesNeeded, NULL);
6104 if (ret)
6105 {
6106 if (!pvStructInfo)
6107 *pcbStructInfo = bytesNeeded;
6108 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
6109 {
6110 LPSTR *info;
6111
6112 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
6113 pvStructInfo = *(BYTE **)pvStructInfo;
6114
6115 info = pvStructInfo;
6116 *info = (void *)((BYTE *)info + sizeof(*info));
6117 ret = CRYPT_AsnDecodeOidInternal(pbEncoded, cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
6118 pvStructInfo, &bytesNeeded, NULL);
6119 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
6120 CRYPT_FreeSpace(pDecodePara, info);
6121 }
6122 }
6123 }
6124 __EXCEPT_PAGE_FAULT
6125 {
6126 SetLastError(STATUS_ACCESS_VIOLATION);
6127 ret = FALSE;
6128 }
6129 __ENDTRY
6130 return ret;
6131}

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeOCSPBasicResponse()

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

Definition at line 6711 of file decode.c.

6714{
6715 struct AsnDecodeSequenceItem items[] = {
6716 { 0, 0,
6717 CRYPT_AsnDecodeResponderID, offsetof(OCSP_BASIC_RESPONSE_INFO, ProducedAt), FALSE, TRUE,
6718 offsetof(OCSP_BASIC_RESPONSE_INFO, ByNameResponderId.pbData), 0 },
6719 { ASN_GENERALTIME, offsetof(OCSP_BASIC_RESPONSE_INFO, ProducedAt),
6720 CRYPT_AsnDecodeGeneralizedTime, sizeof(FILETIME), FALSE, FALSE,
6721 0, 0 },
6722 { ASN_SEQUENCEOF, offsetof(OCSP_BASIC_RESPONSE_INFO, cResponseEntry),
6723 CRYPT_AsnDecodeOCSPBasicResponseEntriesArray, MEMBERSIZE(OCSP_BASIC_RESPONSE_INFO, cResponseEntry, cExtension),
6724 TRUE, TRUE, offsetof(OCSP_BASIC_RESPONSE_INFO, rgResponseEntry) },
6725 { ASN_CONTEXT | ASN_CONSTRUCTOR, offsetof(OCSP_BASIC_RESPONSE_INFO, cExtension),
6726 CRYPT_AsnDecodeCertExtensions, FINALMEMBERSIZE(OCSP_BASIC_RESPONSE_INFO, cExtension),
6727 TRUE, TRUE, offsetof(OCSP_BASIC_RESPONSE_INFO, rgExtension), 0 },
6728 };
6729 BOOL ret;
6730
6731 __TRY
6732 {
6733 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
6734 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
6735 pcbStructInfo, NULL, NULL);
6736 }
6737 __EXCEPT_PAGE_FAULT
6738 {
6739 SetLastError(STATUS_ACCESS_VIOLATION);
6740 ret = FALSE;
6741 }
6742 __ENDTRY
6743 return ret;
6744}
CRYPT_AsnDecodeResponderID
static BOOL CRYPT_AsnDecodeResponderID(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6689
CRYPT_AsnDecodeOCSPBasicResponseEntriesArray
static BOOL CRYPT_AsnDecodeOCSPBasicResponseEntriesArray(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6520
_OCSP_BASIC_RESPONSE_INFO
Definition: wincrypt.h:716

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeOCSPBasicResponseEntriesArray()

static BOOL CRYPT_AsnDecodeOCSPBasicResponseEntriesArray ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6520 of file decode.c.

6523{
6524 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
6525 offsetof(OCSP_BASIC_RESPONSE_INFO, cResponseEntry), offsetof(OCSP_BASIC_RESPONSE_INFO, rgResponseEntry),
6526 MEMBERSIZE(OCSP_BASIC_RESPONSE_INFO, cResponseEntry, cExtension),
6527 CRYPT_AsnDecodeOCSPBasicResponseEntry, sizeof(OCSP_BASIC_RESPONSE_ENTRY),
6528 FALSE, 0 };
6529
6530 return CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
6531 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
6532}
CRYPT_AsnDecodeOCSPBasicResponseEntry
static BOOL CRYPT_AsnDecodeOCSPBasicResponseEntry(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6485
OCSP_BASIC_RESPONSE_ENTRY
struct _OCSP_BASIC_RESPONSE_ENTRY OCSP_BASIC_RESPONSE_ENTRY

Referenced by CRYPT_AsnDecodeOCSPBasicResponse().

◆ CRYPT_AsnDecodeOCSPBasicResponseEntry()

static BOOL CRYPT_AsnDecodeOCSPBasicResponseEntry ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6485 of file decode.c.

6487{
6488 struct AsnDecodeSequenceItem items[] = {
6489 { ASN_SEQUENCEOF, offsetof(OCSP_BASIC_RESPONSE_ENTRY, CertId.HashAlgorithm.pszObjId),
6490 CRYPT_AsnDecodeOCSPHashAlgorithm, sizeof(CRYPT_ALGORITHM_IDENTIFIER), FALSE, TRUE,
6491 offsetof(OCSP_BASIC_RESPONSE_ENTRY, CertId.HashAlgorithm.pszObjId), 0 },
6492 { ASN_OCTETSTRING, offsetof(OCSP_BASIC_RESPONSE_ENTRY, CertId.IssuerNameHash),
6493 CRYPT_AsnDecodeOctets, sizeof(CRYPT_HASH_BLOB), FALSE, TRUE,
6494 offsetof(OCSP_BASIC_RESPONSE_ENTRY, CertId.IssuerNameHash.pbData), 0 },
6495 { ASN_OCTETSTRING, offsetof(OCSP_BASIC_RESPONSE_ENTRY, CertId.IssuerKeyHash),
6496 CRYPT_AsnDecodeOctets, sizeof(CRYPT_HASH_BLOB), FALSE, TRUE,
6497 offsetof(OCSP_BASIC_RESPONSE_ENTRY, CertId.IssuerKeyHash.pbData), 0 },
6498 { ASN_INTEGER, offsetof(OCSP_BASIC_RESPONSE_ENTRY, CertId.SerialNumber),
6499 CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE, TRUE,
6500 offsetof(OCSP_BASIC_RESPONSE_ENTRY, CertId.SerialNumber.pbData), 0 },
6501 { 0, offsetof(OCSP_BASIC_RESPONSE_ENTRY, dwCertStatus),
6502 CRYPT_AsnDecodeCertStatus, sizeof(DWORD), FALSE, TRUE,
6503 offsetof(OCSP_BASIC_RESPONSE_ENTRY, pRevokedInfo), 0 },
6504 { ASN_GENERALTIME, offsetof(OCSP_BASIC_RESPONSE_ENTRY, ThisUpdate),
6505 CRYPT_AsnDecodeGeneralizedTime, sizeof(FILETIME), FALSE, FALSE,
6506 0, 0 },
6507 { ASN_CONTEXT | ASN_CONSTRUCTOR, offsetof(OCSP_BASIC_RESPONSE_ENTRY, NextUpdate),
6508 CRYPT_AsnDecodeOCSPNextUpdate, sizeof(FILETIME), TRUE, FALSE,
6509 0, 0 },
6510 { ASN_CONTEXT | ASN_CONSTRUCTOR /* FIXME */, offsetof(OCSP_BASIC_RESPONSE_ENTRY, cExtension),
6511 CRYPT_AsnDecodeCertExtensions, FINALMEMBERSIZE(OCSP_BASIC_RESPONSE_ENTRY, cExtension),
6512 TRUE, TRUE, offsetof(OCSP_BASIC_RESPONSE_ENTRY, rgExtension), 0 },
6513 };
6514
6515 return CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
6516 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo,
6517 pcbStructInfo, pcbDecoded, NULL);
6518}
CRYPT_AsnDecodeOCSPNextUpdate
static BOOL CRYPT_AsnDecodeOCSPNextUpdate(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6347
CRYPT_AsnDecodeCertStatus
static BOOL CRYPT_AsnDecodeCertStatus(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6379
CRYPT_AsnDecodeOCSPHashAlgorithm
static BOOL CRYPT_AsnDecodeOCSPHashAlgorithm(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6315
CRYPT_HASH_BLOB
struct _CRYPTOAPI_BLOB CRYPT_HASH_BLOB

Referenced by CRYPT_AsnDecodeOCSPBasicResponseEntriesArray().

◆ CRYPT_AsnDecodeOCSPBasicSignedResponse()

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

Definition at line 6280 of file decode.c.

6283{
6284 BOOL ret;
6285 struct AsnDecodeSequenceItem items[] = {
6286 { 0, offsetof(OCSP_BASIC_SIGNED_RESPONSE_INFO, ToBeSigned),
6287 CRYPT_AsnDecodeDerBlob, sizeof(CRYPT_DER_BLOB), FALSE, TRUE,
6288 offsetof(OCSP_BASIC_SIGNED_RESPONSE_INFO, ToBeSigned.pbData), 0 },
6289 { ASN_SEQUENCEOF, offsetof(OCSP_BASIC_SIGNED_RESPONSE_INFO, SignatureInfo.SignatureAlgorithm),
6290 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER), FALSE, TRUE,
6291 offsetof(OCSP_BASIC_SIGNED_RESPONSE_INFO, SignatureInfo.SignatureAlgorithm.pszObjId), 0 },
6292 { ASN_BITSTRING, offsetof(OCSP_BASIC_SIGNED_RESPONSE_INFO, SignatureInfo.Signature),
6293 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
6294 offsetof(OCSP_BASIC_SIGNED_RESPONSE_INFO, SignatureInfo.Signature.pbData) },
6295 { 0, offsetof(OCSP_BASIC_SIGNED_RESPONSE_INFO, SignatureInfo.cCertEncoded),
6296 CRYPT_AsnDecodeOCSPSignatureInfoCertEncoded, FINALMEMBERSIZE(OCSP_SIGNATURE_INFO, cCertEncoded),
6297 TRUE, TRUE, offsetof(OCSP_BASIC_SIGNED_RESPONSE_INFO, SignatureInfo.rgCertEncoded) },
6298 };
6299
6300 __TRY
6301 {
6302 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
6303 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
6304 pcbStructInfo, NULL, NULL);
6305 }
6306 __EXCEPT_PAGE_FAULT
6307 {
6308 SetLastError(STATUS_ACCESS_VIOLATION);
6309 ret = FALSE;
6310 }
6311 __ENDTRY
6312 return ret;
6313}
CRYPT_AsnDecodeOCSPSignatureInfoCertEncoded
static BOOL CRYPT_AsnDecodeOCSPSignatureInfoCertEncoded(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6252
_OCSP_BASIC_SIGNED_RESPONSE_INFO
Definition: wincrypt.h:686
_OCSP_SIGNATURE_INFO
Definition: wincrypt.h:635

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeOCSPHashAlgorithm()

static BOOL CRYPT_AsnDecodeOCSPHashAlgorithm ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6315 of file decode.c.

6318{
6319 DWORD dataLen;
6320 BOOL ret;
6321
6322 if (!cbEncoded)
6323 {
6324 SetLastError(CRYPT_E_ASN1_EOD);
6325 return FALSE;
6326 }
6327 if (pbEncoded[0] != ASN_SEQUENCEOF)
6328 {
6329 SetLastError(CRYPT_E_ASN1_BADTAG);
6330 return FALSE;
6331 }
6332
6333 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
6334 {
6335 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
6336 DWORD bytesDecoded;
6337 if (dataLen)
6338 {
6339 ret = CRYPT_AsnDecodeAlgorithmId(pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes, dwFlags,
6340 pvStructInfo, pcbStructInfo, &bytesDecoded);
6341 if (ret) *pcbDecoded = bytesDecoded + lenBytes + 1;
6342 }
6343 }
6344 return ret;
6345}

Referenced by CRYPT_AsnDecodeOCSPBasicResponseEntry().

◆ CRYPT_AsnDecodeOCSPNextUpdate()

static BOOL CRYPT_AsnDecodeOCSPNextUpdate ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6347 of file decode.c.

6350{
6351 DWORD dataLen;
6352 BOOL ret;
6353
6354 if (!cbEncoded)
6355 {
6356 SetLastError(CRYPT_E_ASN1_EOD);
6357 return FALSE;
6358 }
6359 if (pbEncoded[0] != (ASN_CONTEXT | ASN_CONSTRUCTOR))
6360 {
6361 SetLastError(CRYPT_E_ASN1_BADTAG);
6362 return FALSE;
6363 }
6364
6365 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
6366 {
6367 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
6368 DWORD bytesDecoded;
6369 if (dataLen)
6370 {
6371 ret = CRYPT_AsnDecodeGeneralizedTime(pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes, dwFlags,
6372 pvStructInfo, pcbStructInfo, &bytesDecoded);
6373 if (ret) *pcbDecoded = bytesDecoded + lenBytes + 1;
6374 }
6375 }
6376 return ret;
6377}

Referenced by CRYPT_AsnDecodeOCSPBasicResponseEntry().

◆ CRYPT_AsnDecodeOCSPResponse()

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

Definition at line 6223 of file decode.c.

6226{
6227 BOOL ret;
6228 struct AsnDecodeSequenceItem items[] = {
6229 { ASN_ENUMERATED, offsetof(OCSP_RESPONSE_INFO, dwStatus),
6230 CRYPT_AsnDecodeOCSPResponseStatus, sizeof(DWORD), FALSE, FALSE,
6231 0, 0 },
6232 { ASN_CONTEXT | ASN_CONSTRUCTOR, offsetof(OCSP_RESPONSE_INFO, pszObjId),
6233 CRYPT_AsnDecodeOCSPResponseBytes, sizeof(LPSTR) + sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
6234 offsetof(OCSP_RESPONSE_INFO, pszObjId), 0 },
6235 };
6236
6237 __TRY
6238 {
6239 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
6240 pbEncoded, cbEncoded, dwFlags, pDecodePara, pvStructInfo,
6241 pcbStructInfo, NULL, NULL);
6242 }
6243 __EXCEPT_PAGE_FAULT
6244 {
6245 SetLastError(STATUS_ACCESS_VIOLATION);
6246 ret = FALSE;
6247 }
6248 __ENDTRY
6249 return ret;
6250}
CRYPT_AsnDecodeOCSPResponseStatus
static BOOL CRYPT_AsnDecodeOCSPResponseStatus(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6162
CRYPT_AsnDecodeOCSPResponseBytes
static BOOL CRYPT_AsnDecodeOCSPResponseBytes(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6181
dwStatus
DWORD dwStatus
Definition: mediaobj.idl:95
_OCSP_RESPONSE_INFO
Definition: wincrypt.h:680

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeOCSPResponseBytes()

static BOOL CRYPT_AsnDecodeOCSPResponseBytes ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6181 of file decode.c.

6184{
6185 DWORD dataLen;
6186 BOOL ret;
6187
6188 if (!cbEncoded)
6189 {
6190 SetLastError(CRYPT_E_ASN1_EOD);
6191 return FALSE;
6192 }
6193 if (pbEncoded[0] != (ASN_CONTEXT | ASN_CONSTRUCTOR))
6194 {
6195 SetLastError(CRYPT_E_ASN1_BADTAG);
6196 return FALSE;
6197 }
6198
6199 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
6200 {
6201 struct AsnDecodeSequenceItem items[] = {
6202 { ASN_OBJECTIDENTIFIER, 0,
6203 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
6204 0, 0 },
6205 { ASN_OCTETSTRING, sizeof(LPSTR),
6206 CRYPT_AsnDecodeOctets, sizeof(CRYPT_OBJID_BLOB), FALSE, TRUE,
6207 sizeof(LPSTR) + offsetof(CRYPT_OBJID_BLOB, pbData), 0 },
6208 };
6209 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
6210 DWORD bytesNeeded;
6211
6212 if (dataLen)
6213 {
6214 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
6215 pbEncoded + 1 + lenBytes, cbEncoded - 1 - lenBytes, dwFlags, NULL,
6216 pvStructInfo, pcbStructInfo, &bytesNeeded, NULL);
6217 if (ret) *pcbDecoded = bytesNeeded + lenBytes + 1;
6218 }
6219 }
6220 return ret;
6221}

Referenced by CRYPT_AsnDecodeOCSPResponse().

◆ CRYPT_AsnDecodeOCSPResponseStatus()

static BOOL CRYPT_AsnDecodeOCSPResponseStatus ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6162 of file decode.c.

6165{
6166 if (!cbEncoded)
6167 {
6168 SetLastError(CRYPT_E_ASN1_EOD);
6169 return FALSE;
6170 }
6171 if (pbEncoded[0] != ASN_ENUMERATED)
6172 {
6173 SetLastError(CRYPT_E_ASN1_BADTAG);
6174 return FALSE;
6175 }
6176
6177 return CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags, pvStructInfo,
6178 pcbStructInfo, pcbDecoded);
6179}

Referenced by CRYPT_AsnDecodeOCSPResponse().

◆ CRYPT_AsnDecodeOCSPSignatureInfoCertEncoded()

static BOOL CRYPT_AsnDecodeOCSPSignatureInfoCertEncoded ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6252 of file decode.c.

6255{
6256 BOOL ret;
6257 DWORD data_len, len_bytes;
6258 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCE,
6259 offsetof(OCSP_SIGNATURE_INFO, cCertEncoded), offsetof(OCSP_SIGNATURE_INFO, rgCertEncoded),
6260 FINALMEMBERSIZE(OCSP_SIGNATURE_INFO, cCertEncoded), verify_and_copy_certificate,
6261 sizeof(CRYPT_DER_BLOB), TRUE, offsetof(CRYPT_DER_BLOB, pbData) };
6262
6263 if (pbEncoded[0] != (ASN_CONTEXT | ASN_CONSTRUCTOR))
6264 {
6265 WARN("Unexpected tag %#x.\n", pbEncoded[0]);
6266 SetLastError(CRYPT_E_ASN1_BADTAG);
6267 return FALSE;
6268 }
6269
6270 if (!(ret = CRYPT_GetLen(pbEncoded, cbEncoded, &data_len))) return FALSE;
6271 len_bytes = GET_LEN_BYTES(pbEncoded[1]);
6272
6273 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded + 1 + len_bytes, cbEncoded - 1 - len_bytes,
6274 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
6275 if (pcbDecoded)
6276 *pcbDecoded = 1 + len_bytes + data_len;
6277 return ret;
6278}

Referenced by CRYPT_AsnDecodeOCSPBasicSignedResponse().

◆ CRYPT_AsnDecodeOctets()

static BOOL CRYPT_AsnDecodeOctets ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 4178 of file decode.c.

4181{
4182 BOOL ret;
4183 DWORD bytesNeeded, dataLen;
4184
4185 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
4186 pvStructInfo, *pcbStructInfo, pcbDecoded);
4187
4188 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4189 {
4190 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4191
4192 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
4193 bytesNeeded = sizeof(CRYPT_DATA_BLOB);
4194 else
4195 bytesNeeded = dataLen + sizeof(CRYPT_DATA_BLOB);
4196 if (pcbDecoded)
4197 *pcbDecoded = 1 + lenBytes + dataLen;
4198 if (!pvStructInfo)
4199 *pcbStructInfo = bytesNeeded;
4200 else if (*pcbStructInfo < bytesNeeded)
4201 {
4202 SetLastError(ERROR_MORE_DATA);
4203 *pcbStructInfo = bytesNeeded;
4204 ret = FALSE;
4205 }
4206 else
4207 {
4208 CRYPT_DATA_BLOB *blob;
4209
4210 *pcbStructInfo = bytesNeeded;
4211 blob = pvStructInfo;
4212 blob->cbData = dataLen;
4213 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
4214 blob->pbData = (BYTE *)pbEncoded + 1 + lenBytes;
4215 else
4216 {
4217 assert(blob->pbData);
4218 if (blob->cbData)
4219 memcpy(blob->pbData, pbEncoded + 1 + lenBytes,
4220 blob->cbData);
4221 }
4222 }
4223 }
4224 return ret;
4225}

Referenced by CRYPT_AsnDecodeAuthorityKeyId(), CRYPT_AsnDecodeAuthorityKeyId2(), CRYPT_AsnDecodeCMSSignerId(), CRYPT_AsnDecodeCMSSignerInfoInternal(), CRYPT_AsnDecodeCTL(), CRYPT_AsnDecodeCTLEntry(), CRYPT_AsnDecodeEncryptedContentInfo(), CRYPT_AsnDecodeExtension(), CRYPT_AsnDecodeOCSPBasicResponseEntry(), CRYPT_AsnDecodeOCSPResponseBytes(), CRYPT_AsnDecodePKCSDigestedData(), CRYPT_AsnDecodePKCSSignerInfoInternal(), and CRYPT_AsnDecodeRecipientInfo().

◆ CRYPT_AsnDecodeOctetString()

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

Definition at line 4319 of file decode.c.

4322{
4323 BOOL ret;
4324
4325 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
4326 pDecodePara, pvStructInfo, *pcbStructInfo);
4327
4328 if (!cbEncoded)
4329 {
4330 SetLastError(CRYPT_E_ASN1_CORRUPT);
4331 return FALSE;
4332 }
4333
4334 __TRY
4335 {
4336 DWORD bytesNeeded = 0;
4337
4338 if ((ret = CRYPT_AsnDecodeOctetStringInternal(pbEncoded, cbEncoded,
4339 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
4340 {
4341 if (!pvStructInfo)
4342 *pcbStructInfo = bytesNeeded;
4343 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4344 pvStructInfo, pcbStructInfo, bytesNeeded)))
4345 {
4346 CRYPT_DATA_BLOB *blob;
4347
4348 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4349 pvStructInfo = *(BYTE **)pvStructInfo;
4350 blob = pvStructInfo;
4351 blob->pbData = (BYTE *)pvStructInfo + sizeof(CRYPT_DATA_BLOB);
4352 ret = CRYPT_AsnDecodeOctetStringInternal(pbEncoded, cbEncoded,
4353 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
4354 &bytesNeeded, NULL);
4355 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
4356 CRYPT_FreeSpace(pDecodePara, blob);
4357 }
4358 }
4359 }
4360 __EXCEPT_PAGE_FAULT
4361 {
4362 SetLastError(STATUS_ACCESS_VIOLATION);
4363 ret = FALSE;
4364 }
4365 __ENDTRY
4366 return ret;
4367}
CRYPT_AsnDecodeOctetStringInternal
static BOOL CRYPT_AsnDecodeOctetStringInternal(const BYTE *encoded, DWORD encoded_size, DWORD flags, void *buf, DWORD *buf_size, DWORD *ret_decoded)
Definition: decode.c:4227

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeOctetStringInternal()

static BOOL CRYPT_AsnDecodeOctetStringInternal ( const BYTE *  encoded,
DWORD  encoded_size,
DWORD  flags,
void *  buf,
DWORD *  buf_size,
DWORD *  ret_decoded 
)
static

Definition at line 4227 of file decode.c.

4229{
4230 DWORD decoded = 0, indefinite_len_depth = 0, len_size, len, bytes_needed;
4231 CRYPT_DATA_BLOB *blob;
4232 const BYTE *string;
4233
4234 while (encoded[0] == (ASN_CONSTRUCTOR | ASN_OCTETSTRING))
4235 {
4236 if (!CRYPT_GetLengthIndefinite(encoded, encoded_size, &len))
4237 return FALSE;
4238
4239 len_size = GET_LEN_BYTES(encoded[1]);
4240 encoded += 1 + len_size;
4241 encoded_size -= 1 + len_size;
4242 decoded += 1 + len_size;
4243
4244 if (len == CMSG_INDEFINITE_LENGTH)
4245 {
4246 indefinite_len_depth++;
4247 if (encoded_size < 2)
4248 {
4249 SetLastError(CRYPT_E_ASN1_EOD);
4250 return FALSE;
4251 }
4252 encoded_size -= 2;
4253 decoded += 2;
4254 }
4255 }
4256
4257 if (encoded[0] != ASN_OCTETSTRING)
4258 {
4259 WARN("Unexpected tag %02x\n", encoded[0]);
4260 SetLastError(CRYPT_E_ASN1_BADTAG);
4261 return FALSE;
4262 }
4263
4264 if (!CRYPT_GetLen(encoded, encoded_size, &len))
4265 return FALSE;
4266 len_size = GET_LEN_BYTES(encoded[1]);
4267 decoded += 1 + len_size + len;
4268 encoded_size -= 1 + len_size;
4269
4270 if (len > encoded_size)
4271 {
4272 SetLastError(CRYPT_E_ASN1_EOD);
4273 return FALSE;
4274 }
4275 if (ret_decoded)
4276 *ret_decoded = decoded;
4277
4278 encoded += 1 + len_size;
4279 string = encoded;
4280 encoded += len;
4281
4282 while (indefinite_len_depth--)
4283 {
4284 if (encoded[0] || encoded[1])
4285 {
4286 TRACE("expected 0 TLV, got %02x %02x\n", encoded[0], encoded[1]);
4287 SetLastError(CRYPT_E_ASN1_CORRUPT);
4288 return FALSE;
4289 }
4290 }
4291
4292 bytes_needed = sizeof(*blob);
4293 if (!(flags & CRYPT_DECODE_NOCOPY_FLAG)) bytes_needed += len;
4294 if (!buf)
4295 {
4296 *buf_size = bytes_needed;
4297 return TRUE;
4298 }
4299 if (*buf_size < bytes_needed)
4300 {
4301 SetLastError(ERROR_MORE_DATA);
4302 *buf_size = bytes_needed;
4303 return FALSE;
4304 }
4305
4306 *buf_size = bytes_needed;
4307 blob = buf;
4308 blob->cbData = len;
4309 if (flags & CRYPT_DECODE_NOCOPY_FLAG)
4310 blob->pbData = (BYTE*)string;
4311 else if (blob->cbData)
4312 memcpy(blob->pbData, string, blob->cbData);
4313
4314 if (ret_decoded)
4315 *ret_decoded = decoded;
4316 return TRUE;
4317}
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
flags
GLbitfield flags
Definition: glext.h:7161
string
char string[160]
Definition: util.h:11

Referenced by CRYPT_AsnDecodeOctetString().

◆ CRYPT_AsnDecodeOidIgnoreTag()

static BOOL CRYPT_AsnDecodeOidIgnoreTag ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1307 of file decode.c.

1309{
1310 BOOL ret = TRUE;
1311 DWORD dataLen;
1312
1313 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1314 pvStructInfo, *pcbStructInfo);
1315
1316 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1317 {
1318 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1319 DWORD bytesNeeded = sizeof(LPSTR);
1320
1321 if (dataLen)
1322 {
1323 const BYTE *ptr;
1324 char str[32];
1325
1326 snprintf(str, sizeof(str), "%d.%d",
1327 pbEncoded[1 + lenBytes] / 40,
1328 pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] / 40)
1329 * 40);
1330 bytesNeeded += strlen(str) + 1;
1331 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1332 ptr - pbEncoded - 1 - lenBytes < dataLen; )
1333 {
1334 int val = 0;
1335
1336 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1337 (*ptr & 0x80))
1338 {
1339 val <<= 7;
1340 val |= *ptr & 0x7f;
1341 ptr++;
1342 }
1343 if (ptr - pbEncoded - 1 - lenBytes >= dataLen ||
1344 (*ptr & 0x80))
1345 {
1346 SetLastError(CRYPT_E_ASN1_CORRUPT);
1347 ret = FALSE;
1348 }
1349 else
1350 {
1351 val <<= 7;
1352 val |= *ptr++;
1353 snprintf(str, sizeof(str), ".%d", val);
1354 bytesNeeded += strlen(str);
1355 }
1356 }
1357 }
1358 if (pcbDecoded)
1359 *pcbDecoded = 1 + lenBytes + dataLen;
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 if (dataLen)
1371 {
1372 const BYTE *ptr;
1373 LPSTR pszObjId = *(LPSTR *)pvStructInfo;
1374
1375 *pszObjId = 0;
1376 sprintf(pszObjId, "%d.%d", pbEncoded[1 + lenBytes] / 40,
1377 pbEncoded[1 + lenBytes] - (pbEncoded[1 + lenBytes] /
1378 40) * 40);
1379 pszObjId += strlen(pszObjId);
1380 for (ptr = pbEncoded + 2 + lenBytes; ret &&
1381 ptr - pbEncoded - 1 - lenBytes < dataLen; )
1382 {
1383 int val = 0;
1384
1385 while (ptr - pbEncoded - 1 - lenBytes < dataLen &&
1386 (*ptr & 0x80))
1387 {
1388 val <<= 7;
1389 val |= *ptr & 0x7f;
1390 ptr++;
1391 }
1392 val <<= 7;
1393 val |= *ptr++;
1394 sprintf(pszObjId, ".%d", val);
1395 pszObjId += strlen(pszObjId);
1396 }
1397 }
1398 else
1399 *(LPSTR *)pvStructInfo = NULL;
1400 *pcbStructInfo = bytesNeeded;
1401 }
1402 }
1403 return ret;
1404}
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1597
sprintf
#define sprintf
Definition: sprintf.c:45
snprintf
#define snprintf
Definition: wintirpc.h:48

Referenced by CRYPT_AsnDecodeAlgorithmId(), CRYPT_AsnDecodeAltNameEntry(), CRYPT_AsnDecodeExtension(), CRYPT_AsnDecodeOCSPResponseBytes(), CRYPT_AsnDecodeOidInternal(), CRYPT_AsnDecodePKCSAttributeInternal(), CRYPT_AsnDecodePKCSContentInfoInternal(), CRYPT_AsnDecodeRdnAttr(), CRYPT_AsnDecodeSMIMECapability(), and CRYPT_AsnDecodeUnicodeRdnAttr().

◆ CRYPT_AsnDecodeOidInternal()

static BOOL CRYPT_AsnDecodeOidInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1406 of file decode.c.

1408{
1409 BOOL ret;
1410
1411 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1412 pvStructInfo, *pcbStructInfo);
1413
1414 if (pbEncoded[0] == ASN_OBJECTIDENTIFIER)
1415 ret = CRYPT_AsnDecodeOidIgnoreTag(pbEncoded, cbEncoded, dwFlags,
1416 pvStructInfo, pcbStructInfo, pcbDecoded);
1417 else
1418 {
1419 SetLastError(CRYPT_E_ASN1_BADTAG);
1420 ret = FALSE;
1421 }
1422 return ret;
1423}

Referenced by CRYPT_AsnDecodeAccessDescription(), CRYPT_AsnDecodeCertPolicy(), CRYPT_AsnDecodeCertPolicyMapping(), CRYPT_AsnDecodeCTLUsage(), CRYPT_AsnDecodeEncryptedContentInfo(), CRYPT_AsnDecodeEnhancedKeyUsage(), CRYPT_AsnDecodeObjectIdentifier(), and CRYPT_AsnDecodePolicyQualifier().

◆ CRYPT_AsnDecodePathLenConstraint()

static BOOL CRYPT_AsnDecodePathLenConstraint ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3456 of file decode.c.

3459{
3460 BOOL ret = TRUE;
3461 DWORD bytesNeeded = sizeof(struct PATH_LEN_CONSTRAINT), size;
3462
3463 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
3464 pvStructInfo, *pcbStructInfo, pcbDecoded);
3465
3466 if (!pvStructInfo)
3467 {
3468 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags, NULL,
3469 &size, pcbDecoded);
3470 *pcbStructInfo = bytesNeeded;
3471 }
3472 else if (*pcbStructInfo < bytesNeeded)
3473 {
3474 SetLastError(ERROR_MORE_DATA);
3475 *pcbStructInfo = bytesNeeded;
3476 ret = FALSE;
3477 }
3478 else
3479 {
3480 struct PATH_LEN_CONSTRAINT *constraint = pvStructInfo;
3481
3482 *pcbStructInfo = bytesNeeded;
3483 size = sizeof(constraint->dwPathLenConstraint);
3484 ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags,
3485 &constraint->dwPathLenConstraint, &size, pcbDecoded);
3486 if (ret)
3487 constraint->fPathLenConstraint = TRUE;
3488 TRACE("got an int, dwPathLenConstraint is %ld\n",
3489 constraint->dwPathLenConstraint);
3490 }
3491 TRACE("returning %d (%08lx)\n", ret, GetLastError());
3492 return ret;
3493}
PATH_LEN_CONSTRAINT::dwPathLenConstraint
DWORD dwPathLenConstraint
Definition: decode.c:3453
PATH_LEN_CONSTRAINT::fPathLenConstraint
BOOL fPathLenConstraint
Definition: decode.c:3452

Referenced by CRYPT_AsnDecodeBasicConstraints(), and CRYPT_AsnDecodeBasicConstraints2().

◆ CRYPT_AsnDecodePermittedSubtree()

static BOOL CRYPT_AsnDecodePermittedSubtree ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5539 of file decode.c.

5542{
5543 BOOL ret = TRUE;
5544 struct AsnArrayDescriptor arrayDesc = { 0,
5545 offsetof(CERT_NAME_CONSTRAINTS_INFO, cPermittedSubtree),
5546 offsetof(CERT_NAME_CONSTRAINTS_INFO, rgPermittedSubtree),
5547 MEMBERSIZE(CERT_NAME_CONSTRAINTS_INFO, cPermittedSubtree,
5548 cExcludedSubtree),
5549 CRYPT_AsnDecodeSubtree, sizeof(CERT_GENERAL_SUBTREE), TRUE,
5550 offsetof(CERT_GENERAL_SUBTREE, Base.pwszURL) };
5551
5552 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
5553 pvStructInfo, *pcbStructInfo, pcbDecoded);
5554
5555 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
5556 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
5557 return ret;
5558}

Referenced by CRYPT_AsnDecodeNameConstraints().

◆ CRYPT_AsnDecodePKCSAttribute()

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

Definition at line 2763 of file decode.c.

2766{
2767 BOOL ret = FALSE;
2768
2769 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2770 pDecodePara, pvStructInfo, *pcbStructInfo);
2771
2772 __TRY
2773 {
2774 DWORD bytesNeeded = 0;
2775
2776 ret = CRYPT_AsnDecodePKCSAttributeInternal(pbEncoded, cbEncoded,
2777 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
2778 if (ret)
2779 {
2780 if (!pvStructInfo)
2781 *pcbStructInfo = bytesNeeded;
2782 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2783 pvStructInfo, pcbStructInfo, bytesNeeded)))
2784 {
2785 PCRYPT_ATTRIBUTE attr;
2786
2787 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2788 pvStructInfo = *(BYTE **)pvStructInfo;
2789 attr = pvStructInfo;
2790 attr->pszObjId = (LPSTR)((BYTE *)pvStructInfo +
2791 sizeof(CRYPT_ATTRIBUTE));
2792 ret = CRYPT_AsnDecodePKCSAttributeInternal(pbEncoded, cbEncoded,
2793 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo, &bytesNeeded,
2794 NULL);
2795 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
2796 CRYPT_FreeSpace(pDecodePara, attr);
2797 }
2798 }
2799 }
2800 __EXCEPT_PAGE_FAULT
2801 {
2802 SetLastError(STATUS_ACCESS_VIOLATION);
2803 }
2804 __ENDTRY
2805 TRACE("returning %d\n", ret);
2806 return ret;
2807}
attr
Definition: cookie.c:202

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodePKCSAttributeInternal()

static BOOL CRYPT_AsnDecodePKCSAttributeInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2737 of file decode.c.

2740{
2741 BOOL ret;
2742 struct AsnDecodeSequenceItem items[] = {
2743 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ATTRIBUTE, pszObjId),
2744 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2745 offsetof(CRYPT_ATTRIBUTE, pszObjId), 0 },
2746 { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CRYPT_ATTRIBUTE, cValue),
2747 CRYPT_AsnDecodePKCSAttributeValue,
2748 FINALMEMBERSIZE(CRYPT_ATTRIBUTE, cValue), FALSE,
2749 TRUE, offsetof(CRYPT_ATTRIBUTE, rgValue), 0 },
2750 };
2751 PCRYPT_ATTRIBUTE attr = pvStructInfo;
2752
2753 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2754 pvStructInfo, *pcbStructInfo);
2755
2756 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
2757 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2758 pcbDecoded, attr ? attr->pszObjId : NULL);
2759 TRACE("returning %d\n", ret);
2760 return ret;
2761}
CRYPT_AsnDecodePKCSAttributeValue
static BOOL CRYPT_AsnDecodePKCSAttributeValue(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2718

Referenced by CRYPT_AsnDecodeCTLEntryAttributes(), CRYPT_AsnDecodePKCSAttribute(), CRYPT_AsnDecodePKCSAttributes(), and CRYPT_AsnDecodePKCSAttributesInternal().

◆ CRYPT_AsnDecodePKCSAttributes()

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

Definition at line 2825 of file decode.c.

2828{
2829 BOOL ret = FALSE;
2830
2831 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2832 pDecodePara, pvStructInfo, *pcbStructInfo);
2833
2834 __TRY
2835 {
2836 struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
2837 offsetof(CRYPT_ATTRIBUTES, cAttr), offsetof(CRYPT_ATTRIBUTES, rgAttr),
2838 sizeof(CRYPT_ATTRIBUTES),
2839 CRYPT_AsnDecodePKCSAttributeInternal, sizeof(CRYPT_ATTRIBUTE),
2840 TRUE, offsetof(CRYPT_ATTRIBUTE, pszObjId) };
2841 CRYPT_ATTRIBUTES *attrs = pvStructInfo;
2842
2843 if (pvStructInfo && !(dwFlags & CRYPT_DECODE_ALLOC_FLAG))
2844 attrs->rgAttr = (CRYPT_ATTRIBUTE *)(attrs + 1);
2845 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
2846 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo, NULL);
2847 }
2848 __EXCEPT_PAGE_FAULT
2849 {
2850 SetLastError(STATUS_ACCESS_VIOLATION);
2851 }
2852 __ENDTRY
2853 TRACE("returning %d\n", ret);
2854 return ret;
2855}
_CRYPT_ATTRIBUTES
Definition: wincrypt.h:610
_CRYPT_ATTRIBUTES::rgAttr
PCRYPT_ATTRIBUTE rgAttr
Definition: wincrypt.h:612

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodePKCSAttributesInternal()

static BOOL CRYPT_AsnDecodePKCSAttributesInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2809 of file decode.c.

2812{
2813 struct AsnArrayDescriptor arrayDesc = { 0,
2814 offsetof(CRYPT_ATTRIBUTES, cAttr), offsetof(CRYPT_ATTRIBUTES, rgAttr),
2815 sizeof(CRYPT_ATTRIBUTES),
2816 CRYPT_AsnDecodePKCSAttributeInternal, sizeof(CRYPT_ATTRIBUTE), TRUE,
2817 offsetof(CRYPT_ATTRIBUTE, pszObjId) };
2818 BOOL ret;
2819
2820 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2821 NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
2822 return ret;
2823}

Referenced by CRYPT_AsnDecodeCMSSignerInfoInternal(), and CRYPT_AsnDecodePKCSSignerInfoInternal().

◆ CRYPT_AsnDecodePKCSAttributeValue()

static BOOL CRYPT_AsnDecodePKCSAttributeValue ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2718 of file decode.c.

2721{
2722 BOOL ret;
2723 struct AsnArrayDescriptor arrayDesc = { 0,
2724 offsetof(CRYPT_ATTRIBUTE, cValue), offsetof(CRYPT_ATTRIBUTE, rgValue),
2725 FINALMEMBERSIZE(CRYPT_ATTRIBUTE, cValue),
2726 CRYPT_AsnDecodeCopyBytes,
2727 sizeof(CRYPT_DER_BLOB), TRUE, offsetof(CRYPT_DER_BLOB, pbData) };
2728
2729 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
2730 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0, pcbDecoded);
2731
2732 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
2733 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
2734 return ret;
2735}

Referenced by CRYPT_AsnDecodePKCSAttributeInternal().

◆ CRYPT_AsnDecodePKCSContent()

static BOOL CRYPT_AsnDecodePKCSContent ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3259 of file decode.c.

3261{
3262 BOOL ret;
3263 DWORD dataLen;
3264
3265 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
3266 pvStructInfo, *pcbStructInfo, pcbDecoded);
3267
3268 /* The caller has already checked the tag, no need to check it again.
3269 * Check the outer length is valid:
3270 */
3271 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
3272 {
3273 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
3274 DWORD innerLen;
3275
3276 pbEncoded += 1 + lenBytes;
3277 cbEncoded -= 1 + lenBytes;
3278 if (dataLen == CMSG_INDEFINITE_LENGTH)
3279 cbEncoded -= 2; /* space for 0 TLV */
3280 /* Check the inner length is valid: */
3281 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &innerLen)))
3282 {
3283 DWORD decodedLen;
3284
3285 ret = CRYPT_AsnDecodeCopyBytes(pbEncoded, cbEncoded, dwFlags,
3286 pvStructInfo, pcbStructInfo, &decodedLen);
3287 if (dataLen == CMSG_INDEFINITE_LENGTH)
3288 {
3289 if (*(pbEncoded + decodedLen) != 0 ||
3290 *(pbEncoded + decodedLen + 1) != 0)
3291 {
3292 TRACE("expected 0 TLV, got {%02x,%02x}\n",
3293 *(pbEncoded + decodedLen),
3294 *(pbEncoded + decodedLen + 1));
3295 SetLastError(CRYPT_E_ASN1_CORRUPT);
3296 ret = FALSE;
3297 }
3298 else
3299 decodedLen += 2;
3300 }
3301 if (ret && pcbDecoded)
3302 {
3303 *pcbDecoded = 1 + lenBytes + decodedLen;
3304 TRACE("decoded %ld bytes\n", *pcbDecoded);
3305 }
3306 }
3307 }
3308 return ret;
3309}

Referenced by CRYPT_AsnDecodePKCSContentInfoInternal().

◆ CRYPT_AsnDecodePKCSContentInfo()

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

Definition at line 3336 of file decode.c.

3339{
3340 BOOL ret = FALSE;
3341
3342 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3343 pDecodePara, pvStructInfo, *pcbStructInfo);
3344
3345 __TRY
3346 {
3347 ret = CRYPT_AsnDecodePKCSContentInfoInternal(pbEncoded, cbEncoded,
3348 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
3349 if (ret && pvStructInfo)
3350 {
3351 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
3352 pcbStructInfo, *pcbStructInfo);
3353 if (ret)
3354 {
3355 CRYPT_CONTENT_INFO *info;
3356
3357 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3358 pvStructInfo = *(BYTE **)pvStructInfo;
3359 info = pvStructInfo;
3360 info->pszObjId = (LPSTR)((BYTE *)info +
3361 sizeof(CRYPT_CONTENT_INFO));
3362 ret = CRYPT_AsnDecodePKCSContentInfoInternal(pbEncoded,
3363 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
3364 pcbStructInfo, NULL);
3365 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
3366 CRYPT_FreeSpace(pDecodePara, info);
3367 }
3368 }
3369 }
3370 __EXCEPT_PAGE_FAULT
3371 {
3372 SetLastError(STATUS_ACCESS_VIOLATION);
3373 }
3374 __ENDTRY
3375 return ret;
3376}
_CRYPT_CONTENT_INFO
Definition: wincrypt.h:461

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodePKCSContentInfoInternal()

static BOOL CRYPT_AsnDecodePKCSContentInfoInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3311 of file decode.c.

3314{
3315 CRYPT_CONTENT_INFO *info = pvStructInfo;
3316 struct AsnDecodeSequenceItem items[] = {
3317 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_CONTENT_INFO, pszObjId),
3318 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
3319 offsetof(CRYPT_CONTENT_INFO, pszObjId), 0 },
3320 { ASN_CONTEXT | ASN_CONSTRUCTOR | 0,
3321 offsetof(CRYPT_CONTENT_INFO, Content), CRYPT_AsnDecodePKCSContent,
3322 sizeof(CRYPT_DER_BLOB), TRUE, TRUE,
3323 offsetof(CRYPT_CONTENT_INFO, Content.pbData), 0 },
3324 };
3325 BOOL ret;
3326
3327 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
3328 pvStructInfo, *pcbStructInfo, pcbDecoded);
3329
3330 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3331 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3332 pcbDecoded, info ? info->pszObjId : NULL);
3333 return ret;
3334}
CRYPT_AsnDecodePKCSContent
static BOOL CRYPT_AsnDecodePKCSContent(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3259

Referenced by CRYPT_AsnDecodeCMSSignedInfo(), CRYPT_AsnDecodePKCSContentInfo(), and CRYPT_AsnDecodePKCSDigestedData().

◆ CRYPT_AsnDecodePKCSDigestedData()

BOOL CRYPT_AsnDecodePKCSDigestedData ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
PCRYPT_DECODE_PARA  pDecodePara,
CRYPT_DIGESTED_DATA *  digestedData,
DWORD *  pcbDigestedData 
)

Definition at line 3378 of file decode.c.

3381{
3382 BOOL ret;
3383 struct AsnDecodeSequenceItem items[] = {
3384 { ASN_INTEGER, offsetof(CRYPT_DIGESTED_DATA, version),
3385 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
3386 { ASN_SEQUENCEOF, offsetof(CRYPT_DIGESTED_DATA, DigestAlgorithm),
3387 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
3388 FALSE, TRUE, offsetof(CRYPT_DIGESTED_DATA, DigestAlgorithm.pszObjId),
3389 0 },
3390 { ASN_SEQUENCEOF, offsetof(CRYPT_DIGESTED_DATA, ContentInfo),
3391 CRYPT_AsnDecodePKCSContentInfoInternal,
3392 sizeof(CRYPT_CONTENT_INFO), FALSE, TRUE, offsetof(CRYPT_DIGESTED_DATA,
3393 ContentInfo.pszObjId), 0 },
3394 { ASN_OCTETSTRING, offsetof(CRYPT_DIGESTED_DATA, hash),
3395 CRYPT_AsnDecodeOctets, sizeof(CRYPT_HASH_BLOB), FALSE, TRUE,
3396 offsetof(CRYPT_DIGESTED_DATA, hash.pbData), 0 },
3397 };
3398
3399 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3400 pbEncoded, cbEncoded, dwFlags, pDecodePara, digestedData, pcbDigestedData,
3401 NULL, NULL);
3402 return ret;
3403}
_CRYPT_DIGESTED_DATA
Definition: crypt32_private.h:87
hash
Definition: _hash_fun.h:40

Referenced by CDecodeMsg_DecodeHashedContent().

◆ CRYPT_AsnDecodePKCSEnvelopedData()

BOOL CRYPT_AsnDecodePKCSEnvelopedData ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
PCRYPT_DECODE_PARA  pDecodePara,
CRYPT_ENVELOPED_DATA *  envelopedData,
DWORD *  pcbEnvelopedData 
)

Definition at line 6065 of file decode.c.

6068{
6069 BOOL ret;
6070 struct AsnDecodeSequenceItem items[] = {
6071 { ASN_INTEGER, offsetof(CRYPT_ENVELOPED_DATA, version),
6072 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
6073 { ASN_CONSTRUCTOR | ASN_SETOF, offsetof(CRYPT_ENVELOPED_DATA,
6074 cRecipientInfo), CRYPT_DecodeRecipientInfoArray,
6075 MEMBERSIZE(CRYPT_ENVELOPED_DATA, cRecipientInfo, encryptedContentInfo),
6076 FALSE, TRUE, offsetof(CRYPT_ENVELOPED_DATA, rgRecipientInfo), 0 },
6077 { ASN_SEQUENCEOF, offsetof(CRYPT_ENVELOPED_DATA, encryptedContentInfo),
6078 CRYPT_AsnDecodeEncryptedContentInfo,
6079 sizeof(CRYPT_ENCRYPTED_CONTENT_INFO), FALSE, TRUE,
6080 offsetof(CRYPT_ENVELOPED_DATA, encryptedContentInfo.contentType), 0 },
6081 };
6082
6083 TRACE("%p, %ld, %08lx, %p, %p, %p\n", pbEncoded, cbEncoded, dwFlags,
6084 pDecodePara, envelopedData, pcbEnvelopedData);
6085
6086 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
6087 pbEncoded, cbEncoded, dwFlags, pDecodePara, envelopedData,
6088 pcbEnvelopedData, NULL, NULL);
6089 TRACE("returning %d\n", ret);
6090 return ret;
6091}
CRYPT_DecodeRecipientInfoArray
static BOOL CRYPT_DecodeRecipientInfoArray(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6011
CRYPT_AsnDecodeEncryptedContentInfo
static BOOL CRYPT_AsnDecodeEncryptedContentInfo(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6033
CRYPT_ENCRYPTED_CONTENT_INFO
struct _CRYPT_ENCRYPTED_CONTENT_INFO CRYPT_ENCRYPTED_CONTENT_INFO
_CRYPT_ENVELOPED_DATA
Definition: crypt32_private.h:105

Referenced by CDecodeMsg_DecodeEnvelopedContent().

◆ CRYPT_AsnDecodePKCSSignerInfo()

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

Definition at line 5689 of file decode.c.

5692{
5693 BOOL ret = FALSE;
5694
5695 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
5696 pDecodePara, pvStructInfo, *pcbStructInfo);
5697
5698 __TRY
5699 {
5700 ret = CRYPT_AsnDecodePKCSSignerInfoInternal(pbEncoded, cbEncoded,
5701 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
5702 if (ret && pvStructInfo)
5703 {
5704 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
5705 pcbStructInfo, *pcbStructInfo);
5706 if (ret)
5707 {
5708 CMSG_SIGNER_INFO *info;
5709
5710 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
5711 pvStructInfo = *(BYTE **)pvStructInfo;
5712 info = pvStructInfo;
5713 info->Issuer.pbData = ((BYTE *)info +
5714 sizeof(CMSG_SIGNER_INFO));
5715 ret = CRYPT_AsnDecodePKCSSignerInfoInternal(pbEncoded,
5716 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
5717 pcbStructInfo, NULL);
5718 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
5719 CRYPT_FreeSpace(pDecodePara, info);
5720 }
5721 }
5722 }
5723 __EXCEPT_PAGE_FAULT
5724 {
5725 SetLastError(STATUS_ACCESS_VIOLATION);
5726 }
5727 __ENDTRY
5728 TRACE("returning %d\n", ret);
5729 return ret;
5730}
CRYPT_AsnDecodePKCSSignerInfoInternal
static BOOL CRYPT_AsnDecodePKCSSignerInfoInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5648
_CMSG_SIGNER_INFO
Definition: wincrypt.h:880

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodePKCSSignerInfoInternal()

static BOOL CRYPT_AsnDecodePKCSSignerInfoInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5648 of file decode.c.

5651{
5652 CMSG_SIGNER_INFO *info = pvStructInfo;
5653 struct AsnDecodeSequenceItem items[] = {
5654 { ASN_INTEGER, offsetof(CMSG_SIGNER_INFO, dwVersion),
5655 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
5656 { ASN_SEQUENCEOF, offsetof(CMSG_SIGNER_INFO, Issuer),
5657 CRYPT_AsnDecodeIssuerSerialNumber, sizeof(CERT_ISSUER_SERIAL_NUMBER),
5658 FALSE, TRUE, offsetof(CMSG_SIGNER_INFO, Issuer.pbData), 0 },
5659 { ASN_SEQUENCEOF, offsetof(CMSG_SIGNER_INFO, HashAlgorithm),
5660 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
5661 FALSE, TRUE, offsetof(CMSG_SIGNER_INFO, HashAlgorithm.pszObjId), 0 },
5662 { ASN_CONSTRUCTOR | ASN_CONTEXT | 0,
5663 offsetof(CMSG_SIGNER_INFO, AuthAttrs),
5664 CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
5665 TRUE, TRUE, offsetof(CMSG_SIGNER_INFO, AuthAttrs.rgAttr), 0 },
5666 { ASN_SEQUENCEOF, offsetof(CMSG_SIGNER_INFO, HashEncryptionAlgorithm),
5667 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
5668 FALSE, TRUE, offsetof(CMSG_SIGNER_INFO,
5669 HashEncryptionAlgorithm.pszObjId), 0 },
5670 { ASN_OCTETSTRING, offsetof(CMSG_SIGNER_INFO, EncryptedHash),
5671 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DER_BLOB),
5672 FALSE, TRUE, offsetof(CMSG_SIGNER_INFO, EncryptedHash.pbData), 0 },
5673 { ASN_CONSTRUCTOR | ASN_CONTEXT | 1,
5674 offsetof(CMSG_SIGNER_INFO, UnauthAttrs),
5675 CRYPT_AsnDecodePKCSAttributesInternal, sizeof(CRYPT_ATTRIBUTES),
5676 TRUE, TRUE, offsetof(CMSG_SIGNER_INFO, UnauthAttrs.rgAttr), 0 },
5677 };
5678 BOOL ret;
5679
5680 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
5681 pvStructInfo, *pcbStructInfo);
5682
5683 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
5684 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
5685 pcbDecoded, info ? info->Issuer.pbData : NULL);
5686 return ret;
5687}
CERT_ISSUER_SERIAL_NUMBER
struct _CERT_ISSUER_SERIAL_NUMBER CERT_ISSUER_SERIAL_NUMBER

Referenced by CRYPT_AsnDecodePKCSSignerInfo().

◆ CRYPT_AsnDecodePolicyQualifier()

static BOOL CRYPT_AsnDecodePolicyQualifier ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3580 of file decode.c.

3583{
3584 struct AsnDecodeSequenceItem items[] = {
3585 { ASN_OBJECTIDENTIFIER, offsetof(CERT_POLICY_QUALIFIER_INFO,
3586 pszPolicyQualifierId), CRYPT_AsnDecodeOidInternal, sizeof(LPSTR),
3587 FALSE, TRUE, offsetof(CERT_POLICY_QUALIFIER_INFO, pszPolicyQualifierId),
3588 0 },
3589 { 0, offsetof(CERT_POLICY_QUALIFIER_INFO, Qualifier),
3590 CRYPT_AsnDecodeDerBlob, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
3591 offsetof(CERT_POLICY_QUALIFIER_INFO, Qualifier.pbData), 0 },
3592 };
3593 BOOL ret;
3594 CERT_POLICY_QUALIFIER_INFO *qualifier = pvStructInfo;
3595
3596 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3597 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3598
3599 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3600 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
3601 pcbDecoded, qualifier ? qualifier->pszPolicyQualifierId : NULL);
3602 return ret;
3603}
qualifier
static APTTYPEQUALIFIER * qualifier
Definition: compobj.c:77
_CERT_POLICY_QUALIFIER_INFO
Definition: wincrypt.h:396

Referenced by CRYPT_AsnDecodePolicyQualifiers().

◆ CRYPT_AsnDecodePolicyQualifiers()

static BOOL CRYPT_AsnDecodePolicyQualifiers ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3605 of file decode.c.

3608{
3609 BOOL ret;
3610 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3611 offsetof(CERT_POLICY_INFO, cPolicyQualifier),
3612 offsetof(CERT_POLICY_INFO, rgPolicyQualifier),
3613 FINALMEMBERSIZE(CERT_POLICY_INFO, cPolicyQualifier),
3614 CRYPT_AsnDecodePolicyQualifier, sizeof(CERT_POLICY_QUALIFIER_INFO), TRUE,
3615 offsetof(CERT_POLICY_QUALIFIER_INFO, pszPolicyQualifierId) };
3616
3617 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3618 pvStructInfo, pvStructInfo ? *pcbStructInfo : 0);
3619
3620 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
3621 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
3622 TRACE("Returning %d (%08lx)\n", ret, GetLastError());
3623 return ret;
3624}
CRYPT_AsnDecodePolicyQualifier
static BOOL CRYPT_AsnDecodePolicyQualifier(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:3580
CERT_POLICY_QUALIFIER_INFO
struct _CERT_POLICY_QUALIFIER_INFO CERT_POLICY_QUALIFIER_INFO

Referenced by CRYPT_AsnDecodeCertPolicy().

◆ CRYPT_AsnDecodePolicyQualifierUserNotice()

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

Definition at line 2668 of file decode.c.

2672{
2673 BOOL ret = FALSE;
2674
2675 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2676 pDecodePara, pvStructInfo, *pcbStructInfo);
2677
2678 __TRY
2679 {
2680 DWORD bytesNeeded = 0;
2681
2682 ret = CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(pbEncoded,
2683 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded,
2684 NULL);
2685 if (ret)
2686 {
2687 if (!pvStructInfo)
2688 *pcbStructInfo = bytesNeeded;
2689 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2690 pvStructInfo, pcbStructInfo, bytesNeeded)))
2691 {
2692 PCERT_POLICY_QUALIFIER_USER_NOTICE notice;
2693
2694 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2695 pvStructInfo = *(BYTE **)pvStructInfo;
2696 notice = pvStructInfo;
2697 notice->pNoticeReference =
2698 (PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE)
2699 ((BYTE *)pvStructInfo +
2700 sizeof(CERT_POLICY_QUALIFIER_USER_NOTICE));
2701 ret = CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(
2702 pbEncoded, cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
2703 pvStructInfo, &bytesNeeded, NULL);
2704 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
2705 CRYPT_FreeSpace(pDecodePara, notice);
2706 }
2707 }
2708 }
2709 __EXCEPT_PAGE_FAULT
2710 {
2711 SetLastError(STATUS_ACCESS_VIOLATION);
2712 }
2713 __ENDTRY
2714 TRACE("returning %d\n", ret);
2715 return ret;
2716}
CRYPT_AsnDecodePolicyQualifierUserNoticeInternal
static BOOL CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2642
_CERT_POLICY_QUALIFIER_USER_NOTICE
Definition: wincrypt.h:419
notice
notice
Definition: t1tokens.h:26
CERT_POLICY_QUALIFIER_USER_NOTICE
struct _CERT_POLICY_QUALIFIER_USER_NOTICE CERT_POLICY_QUALIFIER_USER_NOTICE

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodePolicyQualifierUserNoticeInternal()

static BOOL CRYPT_AsnDecodePolicyQualifierUserNoticeInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2642 of file decode.c.

2645{
2646 BOOL ret;
2647 struct AsnDecodeSequenceItem items[] = {
2648 { ASN_SEQUENCE, offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE,
2649 pNoticeReference), CRYPT_AsnDecodeNoticeReference,
2650 sizeof(PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE), TRUE, TRUE,
2651 offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE, pNoticeReference), 0 },
2652 { 0, offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE, pszDisplayText),
2653 CRYPT_AsnDecodeUnicodeString, sizeof(LPWSTR), TRUE, TRUE,
2654 offsetof(CERT_POLICY_QUALIFIER_USER_NOTICE, pszDisplayText), 0 },
2655 };
2656 PCERT_POLICY_QUALIFIER_USER_NOTICE notice = pvStructInfo;
2657
2658 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2659 pvStructInfo, *pcbStructInfo);
2660
2661 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
2662 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2663 pcbDecoded, notice ? notice->pNoticeReference : NULL);
2664 TRACE("returning %d\n", ret);
2665 return ret;
2666}
CRYPT_AsnDecodeNoticeReference
static BOOL CRYPT_AsnDecodeNoticeReference(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2450
CRYPT_AsnDecodeUnicodeString
static BOOL CRYPT_AsnDecodeUnicodeString(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2514

Referenced by CRYPT_AsnDecodePolicyQualifierUserNotice().

◆ CRYPT_AsnDecodePubKeyInfo()

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

Definition at line 2907 of file decode.c.

2910{
2911 BOOL ret = TRUE;
2912
2913 __TRY
2914 {
2915 DWORD bytesNeeded = 0;
2916
2917 if ((ret = CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded, cbEncoded,
2918 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
2919 {
2920 if (!pvStructInfo)
2921 *pcbStructInfo = bytesNeeded;
2922 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2923 pvStructInfo, pcbStructInfo, bytesNeeded)))
2924 {
2925 PCERT_PUBLIC_KEY_INFO info;
2926
2927 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2928 pvStructInfo = *(BYTE **)pvStructInfo;
2929 info = pvStructInfo;
2930 info->Algorithm.Parameters.pbData = (BYTE *)pvStructInfo +
2931 sizeof(CERT_PUBLIC_KEY_INFO);
2932 ret = CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded, cbEncoded,
2933 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
2934 &bytesNeeded, NULL);
2935 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
2936 CRYPT_FreeSpace(pDecodePara, info);
2937 }
2938 }
2939 }
2940 __EXCEPT_PAGE_FAULT
2941 {
2942 SetLastError(STATUS_ACCESS_VIOLATION);
2943 ret = FALSE;
2944 }
2945 __ENDTRY
2946 return ret;
2947}
_CERT_PUBLIC_KEY_INFO
Definition: wincrypt.h:233

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodePubKeyInfoInternal()

static BOOL CRYPT_AsnDecodePubKeyInfoInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2885 of file decode.c.

2888{
2889 BOOL ret = TRUE;
2890 struct AsnDecodeSequenceItem items[] = {
2891 { ASN_SEQUENCEOF, offsetof(CERT_PUBLIC_KEY_INFO, Algorithm),
2892 CRYPT_AsnDecodeAlgorithmId, sizeof(CRYPT_ALGORITHM_IDENTIFIER),
2893 FALSE, TRUE, offsetof(CERT_PUBLIC_KEY_INFO,
2894 Algorithm.pszObjId) },
2895 { ASN_BITSTRING, offsetof(CERT_PUBLIC_KEY_INFO, PublicKey),
2896 CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
2897 offsetof(CERT_PUBLIC_KEY_INFO, PublicKey.pbData) },
2898 };
2899 PCERT_PUBLIC_KEY_INFO info = pvStructInfo;
2900
2901 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
2902 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2903 pcbDecoded, info ? info->Algorithm.Parameters.pbData : NULL);
2904 return ret;
2905}

Referenced by CRYPT_AsnDecodeCertInfo(), and CRYPT_AsnDecodePubKeyInfo().

◆ CRYPT_AsnDecodeRdn()

static BOOL CRYPT_AsnDecodeRdn ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1894 of file decode.c.

1896{
1897 BOOL ret = TRUE;
1898 struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
1899 offsetof(CERT_RDN, cRDNAttr), offsetof(CERT_RDN, rgRDNAttr),
1900 sizeof(CERT_RDN),
1901 CRYPT_AsnDecodeRdnAttr, sizeof(CERT_RDN_ATTR), TRUE,
1902 offsetof(CERT_RDN_ATTR, pszObjId) };
1903
1904 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
1905 NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
1906 return ret;
1907}
CRYPT_AsnDecodeRdnAttr
static BOOL CRYPT_AsnDecodeRdnAttr(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1862
_CERT_RDN_ATTR
Definition: wincrypt.h:264
CERT_RDN
struct _CERT_RDN CERT_RDN

Referenced by CRYPT_AsnDecodeName().

◆ CRYPT_AsnDecodeRdnAttr()

static BOOL CRYPT_AsnDecodeRdnAttr ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1862 of file decode.c.

1864{
1865 BOOL ret;
1866 struct AsnDecodeSequenceItem items[] = {
1867 { ASN_OBJECTIDENTIFIER, offsetof(CERT_RDN_ATTR, pszObjId),
1868 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
1869 offsetof(CERT_RDN_ATTR, pszObjId), 0 },
1870 { 0, offsetof(CERT_RDN_ATTR, dwValueType),
1871 CRYPT_AsnDecodeNameValueInternal, sizeof(CERT_NAME_VALUE),
1872 FALSE, TRUE, offsetof(CERT_RDN_ATTR, Value.pbData), 0 },
1873 };
1874 CERT_RDN_ATTR *attr = pvStructInfo;
1875
1876 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1877 pvStructInfo, *pcbStructInfo);
1878
1879 if (attr)
1880 TRACE("attr->pszObjId is %p\n", attr->pszObjId);
1881 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
1882 pbEncoded, cbEncoded, dwFlags, NULL, attr, pcbStructInfo, pcbDecoded,
1883 attr ? attr->pszObjId : NULL);
1884 if (attr)
1885 {
1886 TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId,
1887 debugstr_a(attr->pszObjId));
1888 TRACE("attr->dwValueType is %ld\n", attr->dwValueType);
1889 }
1890 TRACE("returning %d (%08lx)\n", ret, GetLastError());
1891 return ret;
1892}

Referenced by CRYPT_AsnDecodeRdn().

◆ CRYPT_AsnDecodeRecipientInfo()

static BOOL CRYPT_AsnDecodeRecipientInfo ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5975 of file decode.c.

5977{
5978 BOOL ret;
5979 CMSG_KEY_TRANS_RECIPIENT_INFO *info = pvStructInfo;
5980 struct AsnDecodeSequenceItem items[] = {
5981 { ASN_INTEGER, offsetof(CMSG_KEY_TRANS_RECIPIENT_INFO, dwVersion),
5982 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
5983 { ASN_SEQUENCEOF, offsetof(CMSG_KEY_TRANS_RECIPIENT_INFO,
5984 RecipientId.IssuerSerialNumber), CRYPT_AsnDecodeIssuerSerialNumber,
5985 sizeof(CERT_ISSUER_SERIAL_NUMBER), FALSE, TRUE,
5986 offsetof(CMSG_KEY_TRANS_RECIPIENT_INFO,
5987 RecipientId.IssuerSerialNumber.Issuer.pbData), 0 },
5988 { ASN_SEQUENCEOF, offsetof(CMSG_KEY_TRANS_RECIPIENT_INFO,
5989 KeyEncryptionAlgorithm), CRYPT_AsnDecodeAlgorithmId,
5990 sizeof(CRYPT_ALGORITHM_IDENTIFIER), FALSE, TRUE,
5991 offsetof(CMSG_KEY_TRANS_RECIPIENT_INFO,
5992 KeyEncryptionAlgorithm.pszObjId), 0 },
5993 { ASN_OCTETSTRING, offsetof(CMSG_KEY_TRANS_RECIPIENT_INFO, EncryptedKey),
5994 CRYPT_AsnDecodeOctets, sizeof(CRYPT_DATA_BLOB), FALSE, TRUE,
5995 offsetof(CMSG_KEY_TRANS_RECIPIENT_INFO, EncryptedKey.pbData), 0 },
5996 };
5997
5998 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
5999 pvStructInfo, *pcbStructInfo, pcbDecoded);
6000
6001 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
6002 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
6003 pcbDecoded, info ? info->RecipientId.IssuerSerialNumber.Issuer.pbData :
6004 NULL);
6005 if (info)
6006 info->RecipientId.dwIdChoice = CERT_ID_ISSUER_SERIAL_NUMBER;
6007 TRACE("returning %d\n", ret);
6008 return ret;
6009}
_CMSG_KEY_TRANS_RECIPIENT_INFO
Definition: wincrypt.h:4158

Referenced by CRYPT_DecodeRecipientInfoArray().

◆ CRYPT_AsnDecodeRequireExplicit()

static BOOL CRYPT_AsnDecodeRequireExplicit ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3739 of file decode.c.

3742{
3743 BOOL ret;
3744 DWORD skip, size = sizeof(skip);
3745
3746 if (!cbEncoded)
3747 {
3748 SetLastError(CRYPT_E_ASN1_EOD);
3749 return FALSE;
3750 }
3751 if (pbEncoded[0] != (ASN_CONTEXT | 0))
3752 {
3753 SetLastError(CRYPT_E_ASN1_BADTAG);
3754 return FALSE;
3755 }
3756 if ((ret = CRYPT_AsnDecodeIntInternal(pbEncoded, cbEncoded, dwFlags,
3757 &skip, &size, pcbDecoded)))
3758 {
3759 DWORD bytesNeeded = MEMBERSIZE(CERT_POLICY_CONSTRAINTS_INFO,
3760 fRequireExplicitPolicy, fInhibitPolicyMapping);
3761
3762 if (!pvStructInfo)
3763 *pcbStructInfo = bytesNeeded;
3764 else if (*pcbStructInfo < bytesNeeded)
3765 {
3766 *pcbStructInfo = bytesNeeded;
3767 SetLastError(ERROR_MORE_DATA);
3768 ret = FALSE;
3769 }
3770 else
3771 {
3772 CERT_POLICY_CONSTRAINTS_INFO *info = CONTAINING_RECORD(pvStructInfo,
3773 CERT_POLICY_CONSTRAINTS_INFO, fRequireExplicitPolicy);
3774
3775 *pcbStructInfo = bytesNeeded;
3776 /* The BOOL is implicit: if the integer is present, then it's
3777 * TRUE.
3778 */
3779 info->fRequireExplicitPolicy = TRUE;
3780 info->dwRequireExplicitPolicySkipCerts = skip;
3781 }
3782 }
3783 return ret;
3784}

Referenced by CRYPT_AsnDecodeCertPolicyConstraints().

◆ CRYPT_AsnDecodeResponderID()

static BOOL CRYPT_AsnDecodeResponderID ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6689 of file decode.c.

6692{
6693 BYTE choice = pbEncoded[0] & 3;
6694
6695 TRACE("choice %02x\n", choice);
6696 switch (choice)
6697 {
6698 case 1:
6699 return CRYPT_AsnDecodeResponderIDByName(pbEncoded, cbEncoded, dwFlags,
6700 pvStructInfo, pcbStructInfo, pcbDecoded);
6701 case 2:
6702 return CRYPT_AsnDecodeResponderIDByKey(pbEncoded, cbEncoded, dwFlags,
6703 pvStructInfo, pcbStructInfo, pcbDecoded);
6704 default:
6705 WARN("Unexpected choice %02x\n", choice);
6706 SetLastError(CRYPT_E_ASN1_CORRUPT);
6707 return FALSE;
6708 }
6709}
CRYPT_AsnDecodeResponderIDByKey
static BOOL CRYPT_AsnDecodeResponderIDByKey(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6606
CRYPT_AsnDecodeResponderIDByName
static BOOL CRYPT_AsnDecodeResponderIDByName(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:6534

Referenced by CRYPT_AsnDecodeOCSPBasicResponse().

◆ CRYPT_AsnDecodeResponderIDByKey()

static BOOL CRYPT_AsnDecodeResponderIDByKey ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6606 of file decode.c.

6609{
6610 OCSP_BASIC_RESPONSE_INFO *info = pvStructInfo;
6611 DWORD dataLen, decodedLen, lenBytes, bytesNeeded = sizeof(*info), len;
6612 BYTE tag = pbEncoded[0] & ~3;
6613 CRYPT_HASH_BLOB *blob;
6614
6615 if (tag != (ASN_CONTEXT | ASN_CONSTRUCTOR))
6616 {
6617 WARN("Unexpected tag %02x\n", tag);
6618 SetLastError(CRYPT_E_ASN1_BADTAG);
6619 return FALSE;
6620 }
6621
6622 if (!CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen))
6623 return FALSE;
6624 lenBytes = GET_LEN_BYTES(pbEncoded[1]);
6625 cbEncoded -= 1 + lenBytes;
6626 decodedLen = 1 + lenBytes;
6627
6628 if (dataLen > cbEncoded)
6629 {
6630 SetLastError(CRYPT_E_ASN1_EOD);
6631 return FALSE;
6632 }
6633 pbEncoded += 1 + lenBytes;
6634 if (pbEncoded[0] != ASN_OCTETSTRING)
6635 {
6636 WARN("Unexpected tag %02x\n", pbEncoded[0]);
6637 SetLastError(CRYPT_E_ASN1_BADTAG);
6638 return FALSE;
6639 }
6640
6641 if (!CRYPT_GetLen(pbEncoded, cbEncoded, &len))
6642 return FALSE;
6643 lenBytes = GET_LEN_BYTES(pbEncoded[1]);
6644 decodedLen += 1 + lenBytes + len;
6645 cbEncoded -= 1 + lenBytes;
6646
6647 if (len > cbEncoded)
6648 {
6649 SetLastError(CRYPT_E_ASN1_EOD);
6650 return FALSE;
6651 }
6652 pbEncoded += 1 + lenBytes;
6653
6654 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG)) bytesNeeded += len;
6655 if (pvStructInfo && *pcbStructInfo >= bytesNeeded)
6656 {
6657 info->dwResponderIdChoice = 2;
6658 blob = &info->ByKeyResponderId;
6659 blob->cbData = len;
6660 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
6661 blob->pbData = (BYTE *)pbEncoded;
6662 else if (blob->cbData)
6663 {
6664 blob->pbData = (BYTE *)(info + 1);
6665 memcpy(blob->pbData, pbEncoded, blob->cbData);
6666 }
6667 }
6668
6669 if (pcbDecoded)
6670 *pcbDecoded = decodedLen;
6671
6672 if (!pvStructInfo)
6673 {
6674 *pcbStructInfo = bytesNeeded;
6675 return TRUE;
6676 }
6677
6678 if (*pcbStructInfo < bytesNeeded)
6679 {
6680 SetLastError(ERROR_MORE_DATA);
6681 *pcbStructInfo = bytesNeeded;
6682 return FALSE;
6683 }
6684
6685 *pcbStructInfo = bytesNeeded;
6686 return TRUE;
6687}

Referenced by CRYPT_AsnDecodeResponderID().

◆ CRYPT_AsnDecodeResponderIDByName()

static BOOL CRYPT_AsnDecodeResponderIDByName ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6534 of file decode.c.

6537{
6538 OCSP_BASIC_RESPONSE_INFO *info = pvStructInfo;
6539 DWORD dataLen, decodedLen, lenBytes, bytesNeeded = sizeof(*info);
6540 BYTE tag = pbEncoded[0] & ~3;
6541 CERT_NAME_BLOB *blob;
6542
6543 if (tag != (ASN_CONTEXT | ASN_CONSTRUCTOR))
6544 {
6545 WARN("Unexpected tag %02x\n", tag);
6546 SetLastError(CRYPT_E_ASN1_BADTAG);
6547 return FALSE;
6548 }
6549
6550 if (!CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen))
6551 return FALSE;
6552 lenBytes = GET_LEN_BYTES(pbEncoded[1]);
6553 cbEncoded -= 1 + lenBytes;
6554
6555 if (dataLen > cbEncoded)
6556 {
6557 SetLastError(CRYPT_E_ASN1_EOD);
6558 return FALSE;
6559 }
6560 pbEncoded += 1 + lenBytes;
6561 decodedLen = 1 + lenBytes + dataLen;
6562
6563 if (pbEncoded[0] != ASN_SEQUENCE)
6564 {
6565 WARN("Unexpected tag %02x %02x\n", pbEncoded[0], pbEncoded[1]);
6566 SetLastError(CRYPT_E_ASN1_BADTAG);
6567 return FALSE;
6568 }
6569
6570 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG)) bytesNeeded += dataLen;
6571 if (pvStructInfo && *pcbStructInfo >= bytesNeeded)
6572 {
6573 info->dwResponderIdChoice = 1;
6574
6575 blob = &info->ByNameResponderId;
6576 blob->cbData = dataLen;
6577 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
6578 blob->pbData = (BYTE *)pbEncoded;
6579 else if (blob->cbData)
6580 {
6581 blob->pbData = (BYTE *)(info + 1);
6582 memcpy(blob->pbData, pbEncoded, blob->cbData);
6583 }
6584 }
6585
6586 if (pcbDecoded)
6587 *pcbDecoded = decodedLen;
6588
6589 if (!pvStructInfo)
6590 {
6591 *pcbStructInfo = bytesNeeded;
6592 return TRUE;
6593 }
6594
6595 if (*pcbStructInfo < bytesNeeded)
6596 {
6597 SetLastError(ERROR_MORE_DATA);
6598 *pcbStructInfo = bytesNeeded;
6599 return FALSE;
6600 }
6601
6602 *pcbStructInfo = bytesNeeded;
6603 return TRUE;
6604}

Referenced by CRYPT_AsnDecodeResponderID().

◆ CRYPT_AsnDecodeRsaPrivKey()

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

Definition at line 4050 of file decode.c.

4053{
4054 BOOL ret;
4055 DWORD halflen;
4056
4057 __TRY
4058 {
4059 struct AsnDecodeSequenceItem items[] = {
4060 { ASN_INTEGER, offsetof(struct DECODED_RSA_PRIV_KEY, version),
4061 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
4062 { ASN_INTEGER, offsetof(struct DECODED_RSA_PRIV_KEY, modulus),
4063 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
4064 FALSE, TRUE, offsetof(struct DECODED_RSA_PRIV_KEY, modulus.pbData),
4065 0 },
4066 { ASN_INTEGER, offsetof(struct DECODED_RSA_PRIV_KEY, pubexp),
4067 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
4068 { ASN_INTEGER, offsetof(struct DECODED_RSA_PRIV_KEY, privexp),
4069 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
4070 FALSE, TRUE, offsetof(struct DECODED_RSA_PRIV_KEY, privexp.pbData),
4071 0 },
4072 { ASN_INTEGER, offsetof(struct DECODED_RSA_PRIV_KEY, prime1),
4073 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
4074 FALSE, TRUE, offsetof(struct DECODED_RSA_PRIV_KEY, prime1.pbData),
4075 0 },
4076 { ASN_INTEGER, offsetof(struct DECODED_RSA_PRIV_KEY, prime2),
4077 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
4078 FALSE, TRUE, offsetof(struct DECODED_RSA_PRIV_KEY, prime2.pbData),
4079 0 },
4080 { ASN_INTEGER, offsetof(struct DECODED_RSA_PRIV_KEY, exponent1),
4081 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
4082 FALSE, TRUE, offsetof(struct DECODED_RSA_PRIV_KEY, exponent1.pbData),
4083 0 },
4084 { ASN_INTEGER, offsetof(struct DECODED_RSA_PRIV_KEY, exponent2),
4085 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
4086 FALSE, TRUE, offsetof(struct DECODED_RSA_PRIV_KEY, exponent2.pbData),
4087 0 },
4088 { ASN_INTEGER, offsetof(struct DECODED_RSA_PRIV_KEY, coefficient),
4089 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
4090 FALSE, TRUE, offsetof(struct DECODED_RSA_PRIV_KEY, coefficient.pbData),
4091 0 },
4092 };
4093 struct DECODED_RSA_PRIV_KEY *decodedKey = NULL;
4094 DWORD size = 0;
4095
4096 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
4097 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &decodedKey,
4098 &size, NULL, NULL);
4099 if (ret)
4100 {
4101 halflen = decodedKey->prime1.cbData;
4102 if (halflen < decodedKey->prime2.cbData)
4103 halflen = decodedKey->prime2.cbData;
4104 if (halflen < decodedKey->exponent1.cbData)
4105 halflen = decodedKey->exponent1.cbData;
4106 if (halflen < decodedKey->exponent2.cbData)
4107 halflen = decodedKey->exponent2.cbData;
4108 if (halflen < decodedKey->coefficient.cbData)
4109 halflen = decodedKey->coefficient.cbData;
4110 if (halflen * 2 < decodedKey->modulus.cbData)
4111 halflen = decodedKey->modulus.cbData / 2 + decodedKey->modulus.cbData % 2;
4112 if (halflen * 2 < decodedKey->privexp.cbData)
4113 halflen = decodedKey->privexp.cbData / 2 + decodedKey->privexp.cbData % 2;
4114
4115 if (ret)
4116 {
4117 DWORD bytesNeeded = sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) +
4118 (halflen * 9);
4119
4120 if (!pvStructInfo)
4121 {
4122 *pcbStructInfo = bytesNeeded;
4123 ret = TRUE;
4124 }
4125 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4126 pvStructInfo, pcbStructInfo, bytesNeeded)))
4127 {
4128 BLOBHEADER *hdr;
4129 RSAPUBKEY *rsaPubKey;
4130 BYTE *vardata;
4131
4132 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4133 pvStructInfo = *(BYTE **)pvStructInfo;
4134
4135 hdr = pvStructInfo;
4136 hdr->bType = PRIVATEKEYBLOB;
4137 hdr->bVersion = CUR_BLOB_VERSION;
4138 hdr->reserved = 0;
4139 hdr->aiKeyAlg = CALG_RSA_KEYX;
4140
4141 rsaPubKey = (RSAPUBKEY *)((BYTE *)pvStructInfo +
4142 sizeof(BLOBHEADER));
4143 rsaPubKey->magic = RSA2_MAGIC;
4144 rsaPubKey->pubexp = decodedKey->pubexp;
4145 rsaPubKey->bitlen = halflen * 16;
4146
4147 vardata = (BYTE*)(rsaPubKey + 1);
4148 memset(vardata, 0, halflen * 9);
4149 memcpy(vardata,
4150 decodedKey->modulus.pbData, decodedKey->modulus.cbData);
4151 memcpy(vardata + halflen * 2,
4152 decodedKey->prime1.pbData, decodedKey->prime1.cbData);
4153 memcpy(vardata + halflen * 3,
4154 decodedKey->prime2.pbData, decodedKey->prime2.cbData);
4155 memcpy(vardata + halflen * 4,
4156 decodedKey->exponent1.pbData, decodedKey->exponent1.cbData);
4157 memcpy(vardata + halflen * 5,
4158 decodedKey->exponent2.pbData, decodedKey->exponent2.cbData);
4159 memcpy(vardata + halflen * 6,
4160 decodedKey->coefficient.pbData, decodedKey->coefficient.cbData);
4161 memcpy(vardata + halflen * 7,
4162 decodedKey->privexp.pbData, decodedKey->privexp.cbData);
4163 }
4164 }
4165
4166 LocalFree(decodedKey);
4167 }
4168 }
4169 __EXCEPT_PAGE_FAULT
4170 {
4171 SetLastError(STATUS_ACCESS_VIOLATION);
4172 ret = FALSE;
4173 }
4174 __ENDTRY
4175 return ret;
4176}
RSA2_MAGIC
#define RSA2_MAGIC
Definition: decode.c:4035
hdr
char hdr[14]
Definition: iptest.cpp:33
memset
#define memset(x, y, z)
Definition: compat.h:39
DECODED_RSA_PRIV_KEY
Definition: decode.c:4038
DECODED_RSA_PRIV_KEY::privexp
CRYPT_INTEGER_BLOB privexp
Definition: decode.c:4042
DECODED_RSA_PRIV_KEY::exponent1
CRYPT_INTEGER_BLOB exponent1
Definition: decode.c:4045
DECODED_RSA_PRIV_KEY::modulus
CRYPT_INTEGER_BLOB modulus
Definition: decode.c:4041
DECODED_RSA_PRIV_KEY::coefficient
CRYPT_INTEGER_BLOB coefficient
Definition: decode.c:4047
DECODED_RSA_PRIV_KEY::pubexp
DWORD pubexp
Definition: decode.c:4040
DECODED_RSA_PRIV_KEY::prime2
CRYPT_INTEGER_BLOB prime2
Definition: decode.c:4044
DECODED_RSA_PRIV_KEY::prime1
CRYPT_INTEGER_BLOB prime1
Definition: decode.c:4043
DECODED_RSA_PRIV_KEY::exponent2
CRYPT_INTEGER_BLOB exponent2
Definition: decode.c:4046
_PUBLICKEYSTRUC
Definition: wincrypt.h:144
_RSAPUBKEY
Definition: wincrypt.h:151
_RSAPUBKEY::pubexp
DWORD pubexp
Definition: wincrypt.h:154
_RSAPUBKEY::bitlen
DWORD bitlen
Definition: wincrypt.h:153
_RSAPUBKEY::magic
DWORD magic
Definition: wincrypt.h:152
PRIVATEKEYBLOB
#define PRIVATEKEYBLOB
Definition: wincrypt.h:2445
CALG_RSA_KEYX
#define CALG_RSA_KEYX
Definition: wincrypt.h:2080
BLOBHEADER
struct _PUBLICKEYSTRUC BLOBHEADER
CUR_BLOB_VERSION
#define CUR_BLOB_VERSION
Definition: wincrypt.h:2451

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeRsaPubKey()

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

Definition at line 3976 of file decode.c.

3979{
3980 BOOL ret;
3981
3982 __TRY
3983 {
3984 struct DECODED_RSA_PUB_KEY *decodedKey = NULL;
3985 DWORD size = 0;
3986 ret = CRYPT_raw_decode_rsa_pub_key(&decodedKey, &size, pbEncoded, cbEncoded);
3987 if (ret)
3988 {
3989 DWORD bytesNeeded = sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) +
3990 decodedKey->modulus.cbData;
3991
3992 if (!pvStructInfo)
3993 {
3994 *pcbStructInfo = bytesNeeded;
3995 }
3996 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3997 pvStructInfo, pcbStructInfo, bytesNeeded)))
3998 {
3999 BLOBHEADER *hdr;
4000 RSAPUBKEY *rsaPubKey;
4001 unsigned int i;
4002
4003 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4004 pvStructInfo = *(BYTE **)pvStructInfo;
4005 hdr = pvStructInfo;
4006 hdr->bType = PUBLICKEYBLOB;
4007 hdr->bVersion = CUR_BLOB_VERSION;
4008 hdr->reserved = 0;
4009 hdr->aiKeyAlg = CALG_RSA_KEYX;
4010 rsaPubKey = (RSAPUBKEY *)((BYTE *)pvStructInfo +
4011 sizeof(BLOBHEADER));
4012 rsaPubKey->magic = RSA1_MAGIC;
4013 rsaPubKey->pubexp = 0;
4014 assert(decodedKey->pubexp.cbData <= sizeof(rsaPubKey->pubexp));
4015 for (i = 0; i < decodedKey->pubexp.cbData; ++i)
4016 rsaPubKey->pubexp |= decodedKey->pubexp.pbData[i] << (i * 8);
4017
4018 rsaPubKey->bitlen = decodedKey->modulus.cbData * 8;
4019 memcpy((BYTE *)pvStructInfo + sizeof(BLOBHEADER) +
4020 sizeof(RSAPUBKEY), decodedKey->modulus.pbData,
4021 decodedKey->modulus.cbData);
4022 }
4023 LocalFree(decodedKey);
4024 }
4025 }
4026 __EXCEPT_PAGE_FAULT
4027 {
4028 SetLastError(STATUS_ACCESS_VIOLATION);
4029 ret = FALSE;
4030 }
4031 __ENDTRY
4032 return ret;
4033}
RSA1_MAGIC
#define RSA1_MAGIC
Definition: decode.c:3870
CRYPT_raw_decode_rsa_pub_key
static BOOL CRYPT_raw_decode_rsa_pub_key(struct DECODED_RSA_PUB_KEY **decodedKey, DWORD *size, const BYTE *pbEncoded, DWORD cbEncoded)
Definition: decode.c:3882
DECODED_RSA_PUB_KEY
Definition: decode.c:3873
DECODED_RSA_PUB_KEY::pubexp
CRYPT_INTEGER_BLOB pubexp
Definition: decode.c:3874
DECODED_RSA_PUB_KEY::modulus
CRYPT_INTEGER_BLOB modulus
Definition: decode.c:3875
PUBLICKEYBLOB
#define PUBLICKEYBLOB
Definition: wincrypt.h:2444

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeRsaPubKey_Bcrypt()

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

Definition at line 3913 of file decode.c.

3916{
3917 BOOL ret;
3918
3919 __TRY
3920 {
3921 struct DECODED_RSA_PUB_KEY *decodedKey = NULL;
3922 DWORD size = 0;
3923
3924 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
3925 pvStructInfo, *pcbStructInfo);
3926
3927 ret = CRYPT_raw_decode_rsa_pub_key(&decodedKey, &size, pbEncoded, cbEncoded);
3928 if (ret)
3929 {
3930 /* Header, exponent, and modulus */
3931 DWORD bytesNeeded = sizeof(BCRYPT_RSAKEY_BLOB) + decodedKey->pubexp.cbData +
3932 decodedKey->modulus.cbData;
3933
3934 if (!pvStructInfo)
3935 {
3936 *pcbStructInfo = bytesNeeded;
3937 ret = TRUE;
3938 }
3939 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
3940 pvStructInfo, pcbStructInfo, bytesNeeded)))
3941 {
3942 BCRYPT_RSAKEY_BLOB *hdr;
3943
3944 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
3945 pvStructInfo = *(BYTE **)pvStructInfo;
3946
3947 hdr = pvStructInfo;
3948 hdr->Magic = BCRYPT_RSAPUBLIC_MAGIC;
3949 hdr->BitLength = decodedKey->modulus.cbData * 8;
3950 hdr->cbPublicExp = decodedKey->pubexp.cbData;
3951 hdr->cbModulus = decodedKey->modulus.cbData;
3952 hdr->cbPrime1 = 0;
3953 hdr->cbPrime2 = 0;
3954 /* CNG_RSA_PUBLIC_KEY_BLOB always stores the exponent and modulus
3955 * in big-endian format, so we need to convert from little-endian
3956 */
3957 CRYPT_CopyReversed((BYTE *)pvStructInfo + sizeof(BCRYPT_RSAKEY_BLOB),
3958 decodedKey->pubexp.pbData, hdr->cbPublicExp);
3959 CRYPT_CopyReversed((BYTE *)pvStructInfo + sizeof(BCRYPT_RSAKEY_BLOB) +
3960 hdr->cbPublicExp, decodedKey->modulus.pbData,
3961 decodedKey->modulus.cbData);
3962 }
3963 LocalFree(decodedKey);
3964 }
3965 }
3966 __EXCEPT_PAGE_FAULT
3967 {
3968 SetLastError(STATUS_ACCESS_VIOLATION);
3969 ret = FALSE;
3970 }
3971 __ENDTRY
3972 return ret;
3973}
BCRYPT_RSAKEY_BLOB
struct _BCRYPT_RSAKEY_BLOB BCRYPT_RSAKEY_BLOB
BCRYPT_RSAPUBLIC_MAGIC
#define BCRYPT_RSAPUBLIC_MAGIC
Definition: bcrypt.h:286
CRYPT_CopyReversed
void CRYPT_CopyReversed(BYTE *dst, const BYTE *src, size_t len)
Definition: decode.c:56
if
if(dx< 0)
Definition: linetemp.h:194
_BCRYPT_RSAKEY_BLOB
Definition: bcrypt.h:291

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeSequence()

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

Definition at line 454 of file decode.c.

458{
459 BOOL ret;
460
461 TRACE("%p, %ld, %p, %ld, %08lx, %p, %p, %ld, %p\n", items, cItem, pbEncoded,
462 cbEncoded, dwFlags, pDecodePara, pvStructInfo, *pcbStructInfo,
463 startingPointer);
464
465 if (!cbEncoded)
466 {
467 SetLastError(CRYPT_E_ASN1_EOD);
468 return FALSE;
469 }
470 if (pbEncoded[0] == ASN_SEQUENCE)
471 {
472 DWORD dataLen;
473
474 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
475 {
476 DWORD lenBytes = GET_LEN_BYTES(pbEncoded[1]), cbDecoded;
477 const BYTE *ptr = pbEncoded + 1 + lenBytes;
478 BOOL indefinite = FALSE;
479
480 cbEncoded -= 1 + lenBytes;
481 if (dataLen == CMSG_INDEFINITE_LENGTH)
482 {
483 dataLen = cbEncoded;
484 indefinite = TRUE;
485 lenBytes += 2;
486 }
487 else if (cbEncoded < dataLen)
488 {
489 TRACE("dataLen %ld exceeds cbEncoded %ld, failing\n", dataLen,
490 cbEncoded);
491 SetLastError(CRYPT_E_ASN1_CORRUPT);
492 ret = FALSE;
493 }
494 if (ret)
495 {
496 ret = CRYPT_AsnDecodeSequenceItems(items, cItem,
497 ptr, dataLen, dwFlags, NULL, NULL, &cbDecoded);
498 if (ret && dataLen == CMSG_INDEFINITE_LENGTH)
499 {
500 if (cbDecoded > cbEncoded - 2)
501 {
502 /* Not enough space for 0 TLV */
503 SetLastError(CRYPT_E_ASN1_CORRUPT);
504 ret = FALSE;
505 }
506 else if (*(ptr + cbDecoded) != 0 ||
507 *(ptr + cbDecoded + 1) != 0)
508 {
509 TRACE("expected 0 TLV\n");
510 SetLastError(CRYPT_E_ASN1_CORRUPT);
511 ret = FALSE;
512 }
513 else
514 cbDecoded += 2;
515 }
516 }
517 if (ret && !indefinite && cbDecoded != dataLen)
518 {
519 TRACE("expected %ld decoded, got %ld, failing\n", dataLen,
520 cbDecoded);
521 SetLastError(CRYPT_E_ASN1_CORRUPT);
522 ret = FALSE;
523 }
524 if (ret)
525 {
526 DWORD i, bytesNeeded = 0, structSize = 0;
527
528 for (i = 0; i < cItem; i++)
529 {
530 if (items[i].size > items[i].minSize)
531 bytesNeeded += items[i].size - items[i].minSize;
532 structSize = max( structSize, items[i].offset + items[i].minSize );
533 }
534 bytesNeeded += structSize;
535 if (pcbDecoded)
536 *pcbDecoded = 1 + lenBytes + cbDecoded;
537 if (!pvStructInfo)
538 *pcbStructInfo = bytesNeeded;
539 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
540 pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
541 {
542 BYTE *nextData;
543
544 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
545 pvStructInfo = *(BYTE **)pvStructInfo;
546 if (startingPointer)
547 nextData = startingPointer;
548 else
549 nextData = (BYTE *)pvStructInfo + structSize;
550 memset(pvStructInfo, 0, structSize);
551 ret = CRYPT_AsnDecodeSequenceItems(items, cItem,
552 ptr, dataLen, dwFlags, pvStructInfo, nextData,
553 &cbDecoded);
554 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
555 CRYPT_FreeSpace(pDecodePara, pvStructInfo);
556 }
557 }
558 }
559 }
560 else
561 {
562 SetLastError(CRYPT_E_ASN1_BADTAG);
563 ret = FALSE;
564 }
565 TRACE("returning %d (%08lx)\n", ret, GetLastError());
566 return ret;
567}
CRYPT_AsnDecodeSequenceItems
static BOOL CRYPT_AsnDecodeSequenceItems(struct AsnDecodeSequenceItem items[], DWORD cItem, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, BYTE *nextData, DWORD *cbDecoded)
Definition: decode.c:312
offset
GLintptr offset
Definition: glext.h:5920

Referenced by CRYPT_AsnDecodeAccessDescription(), CRYPT_AsnDecodeAlgorithmId(), CRYPT_AsnDecodeAuthorityKeyId(), CRYPT_AsnDecodeAuthorityKeyId2(), CRYPT_AsnDecodeBasicConstraints(), CRYPT_AsnDecodeBasicConstraints2(), CRYPT_AsnDecodeCertInfo(), CRYPT_AsnDecodeCertPolicy(), CRYPT_AsnDecodeCertPolicyConstraints(), CRYPT_AsnDecodeCertPolicyMapping(), CRYPT_AsnDecodeCertSignedContent(), CRYPT_AsnDecodeCMSSignedInfo(), CRYPT_AsnDecodeCMSSignerInfoInternal(), CRYPT_AsnDecodeCRLEntry(), CRYPT_AsnDecodeCRLInfo(), CRYPT_AsnDecodeCTL(), CRYPT_AsnDecodeCTLEntry(), CRYPT_AsnDecodeDistPoint(), CRYPT_AsnDecodeEccSignature(), CRYPT_AsnDecodeEncryptedContentInfo(), CRYPT_AsnDecodeExtension(), CRYPT_AsnDecodeIssuerSerialNumber(), CRYPT_AsnDecodeIssuingDistPoint(), CRYPT_AsnDecodeNameConstraints(), CRYPT_AsnDecodeNoticeReference(), CRYPT_AsnDecodeOCSPBasicResponse(), CRYPT_AsnDecodeOCSPBasicResponseEntry(), CRYPT_AsnDecodeOCSPBasicSignedResponse(), CRYPT_AsnDecodeOCSPResponse(), CRYPT_AsnDecodeOCSPResponseBytes(), CRYPT_AsnDecodePKCSAttributeInternal(), CRYPT_AsnDecodePKCSContentInfoInternal(), CRYPT_AsnDecodePKCSDigestedData(), CRYPT_AsnDecodePKCSEnvelopedData(), CRYPT_AsnDecodePKCSSignerInfoInternal(), CRYPT_AsnDecodePolicyQualifier(), CRYPT_AsnDecodePolicyQualifierUserNoticeInternal(), CRYPT_AsnDecodePubKeyInfoInternal(), CRYPT_AsnDecodeRdnAttr(), CRYPT_AsnDecodeRecipientInfo(), CRYPT_AsnDecodeRsaPrivKey(), CRYPT_AsnDecodeSMIMECapability(), CRYPT_AsnDecodeSubtree(), CRYPT_AsnDecodeUnicodeRdnAttr(), CRYPT_AsnDecodeValidity(), and CRYPT_raw_decode_rsa_pub_key().

◆ CRYPT_AsnDecodeSequenceItems()

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

Definition at line 312 of file decode.c.

315{
316 BOOL ret;
317 DWORD i, decoded = 0;
318 const BYTE *ptr = pbEncoded;
319
320 TRACE("%p, %ld, %p, %ld, %08lx, %p, %p, %p\n", items, cItem, pbEncoded,
321 cbEncoded, dwFlags, pvStructInfo, nextData, cbDecoded);
322
323 for (i = 0, ret = TRUE; ret && i < cItem; i++)
324 {
325 if (cbEncoded - (ptr - pbEncoded) != 0)
326 {
327 DWORD itemLen;
328
329 if ((ret = CRYPT_GetLengthIndefinite(ptr,
330 cbEncoded - (ptr - pbEncoded), &itemLen)))
331 {
332 BYTE itemLenBytes = GET_LEN_BYTES(ptr[1]);
333
334 if (ptr[0] == items[i].tag || !items[i].tag)
335 {
336 DWORD itemEncodedLen;
337
338 if (itemLen == CMSG_INDEFINITE_LENGTH)
339 itemEncodedLen = cbEncoded - (ptr - pbEncoded);
340 else
341 itemEncodedLen = 1 + itemLenBytes + itemLen;
342 if (nextData && pvStructInfo && items[i].hasPointer)
343 {
344 TRACE("Setting next pointer to %p\n",
345 nextData);
346 *(BYTE **)((BYTE *)pvStructInfo +
347 items[i].pointerOffset) = nextData;
348 }
349 if (items[i].decodeFunc)
350 {
351 DWORD itemDecoded;
352
353 if (pvStructInfo)
354 TRACE("decoding item %ld\n", i);
355 else
356 TRACE("sizing item %ld\n", i);
357 ret = items[i].decodeFunc(ptr, itemEncodedLen,
358 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG,
359 pvStructInfo ? (BYTE *)pvStructInfo + items[i].offset
360 : NULL, &items[i].size, &itemDecoded);
361 if (ret)
362 {
363 if (items[i].size < items[i].minSize)
364 items[i].size = items[i].minSize;
365 else if (items[i].size > items[i].minSize)
366 {
367 /* Account for alignment padding */
368 items[i].size = ALIGN_DWORD_PTR(items[i].size);
369 }
370 TRACE("item %ld size: %ld\n", i, items[i].size);
371 if (nextData && items[i].hasPointer &&
372 items[i].size > items[i].minSize)
373 nextData += items[i].size - items[i].minSize;
374 if (itemDecoded > itemEncodedLen)
375 {
376 WARN("decoded length %ld exceeds encoded %ld\n",
377 itemDecoded, itemEncodedLen);
378 SetLastError(CRYPT_E_ASN1_CORRUPT);
379 ret = FALSE;
380 }
381 else
382 {
383 ptr += itemDecoded;
384 decoded += itemDecoded;
385 TRACE("item %ld: decoded %ld bytes\n", i,
386 itemDecoded);
387 }
388 }
389 else if (items[i].optional &&
390 GetLastError() == CRYPT_E_ASN1_BADTAG)
391 {
392 TRACE("skipping optional item %ld\n", i);
393 items[i].size = items[i].minSize;
394 SetLastError(NOERROR);
395 ret = TRUE;
396 }
397 else
398 TRACE("item %ld failed: %08lx\n", i,
399 GetLastError());
400 }
401 else if (itemLen == CMSG_INDEFINITE_LENGTH)
402 {
403 ERR("can't use indefinite length encoding without a decoder\n");
404 SetLastError(CRYPT_E_ASN1_CORRUPT);
405 ret = FALSE;
406 }
407 else
408 {
409 TRACE("item %ld: decoded %ld bytes\n", i, itemEncodedLen);
410 ptr += itemEncodedLen;
411 decoded += itemEncodedLen;
412 items[i].size = items[i].minSize;
413 }
414 }
415 else if (items[i].optional)
416 {
417 TRACE("skipping optional item %ld\n", i);
418 items[i].size = items[i].minSize;
419 }
420 else
421 {
422 TRACE("item %ld: tag %02x doesn't match expected %02x\n",
423 i, ptr[0], items[i].tag);
424 SetLastError(CRYPT_E_ASN1_BADTAG);
425 ret = FALSE;
426 }
427 }
428 }
429 else if (items[i].optional)
430 {
431 TRACE("missing optional item %ld, skipping\n", i);
432 items[i].size = items[i].minSize;
433 }
434 else
435 {
436 TRACE("not enough bytes for item %ld, failing\n", i);
437 SetLastError(CRYPT_E_ASN1_CORRUPT);
438 ret = FALSE;
439 }
440 }
441 if (cbDecoded)
442 *cbDecoded = decoded;
443 TRACE("returning %d\n", ret);
444 return ret;
445}
optional
@ optional
Definition: SystemMenu.c:34
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
ALIGN_DWORD_PTR
#define ALIGN_DWORD_PTR(x)
Definition: crypt32_private.h:459
NOERROR
#define NOERROR
Definition: winerror.h:3448

Referenced by CRYPT_AsnDecodeSequence().

◆ CRYPT_AsnDecodeSequenceOfAny()

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

Definition at line 5147 of file decode.c.

5150{
5151 BOOL ret = TRUE;
5152
5153 __TRY
5154 {
5155 if (pbEncoded[0] == ASN_SEQUENCEOF)
5156 {
5157 DWORD bytesNeeded, dataLen, remainingLen, cValue;
5158
5159 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
5160 {
5161 BYTE lenBytes;
5162 const BYTE *ptr;
5163
5164 lenBytes = GET_LEN_BYTES(pbEncoded[1]);
5165 bytesNeeded = sizeof(CRYPT_SEQUENCE_OF_ANY);
5166 cValue = 0;
5167 ptr = pbEncoded + 1 + lenBytes;
5168 remainingLen = dataLen;
5169 while (ret && remainingLen)
5170 {
5171 DWORD nextLen;
5172
5173 ret = CRYPT_GetLen(ptr, remainingLen, &nextLen);
5174 if (ret)
5175 {
5176 DWORD nextLenBytes = GET_LEN_BYTES(ptr[1]);
5177
5178 remainingLen -= 1 + nextLenBytes + nextLen;
5179 ptr += 1 + nextLenBytes + nextLen;
5180 bytesNeeded += sizeof(CRYPT_DER_BLOB);
5181 if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
5182 bytesNeeded += 1 + nextLenBytes + nextLen;
5183 cValue++;
5184 }
5185 }
5186 if (ret)
5187 {
5188 CRYPT_SEQUENCE_OF_ANY *seq;
5189 BYTE *nextPtr;
5190 DWORD i;
5191
5192 if (!pvStructInfo)
5193 *pcbStructInfo = bytesNeeded;
5194 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
5195 pvStructInfo, pcbStructInfo, bytesNeeded)))
5196 {
5197 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
5198 pvStructInfo = *(BYTE **)pvStructInfo;
5199 seq = pvStructInfo;
5200 seq->cValue = cValue;
5201 seq->rgValue = (CRYPT_DER_BLOB *)((BYTE *)seq +
5202 sizeof(*seq));
5203 nextPtr = (BYTE *)seq->rgValue +
5204 cValue * sizeof(CRYPT_DER_BLOB);
5205 ptr = pbEncoded + 1 + lenBytes;
5206 remainingLen = dataLen;
5207 i = 0;
5208 while (ret && remainingLen)
5209 {
5210 DWORD nextLen;
5211
5212 ret = CRYPT_GetLen(ptr, remainingLen, &nextLen);
5213 if (ret)
5214 {
5215 DWORD nextLenBytes = GET_LEN_BYTES(ptr[1]);
5216
5217 seq->rgValue[i].cbData = 1 + nextLenBytes +
5218 nextLen;
5219 if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
5220 seq->rgValue[i].pbData = (BYTE *)ptr;
5221 else
5222 {
5223 seq->rgValue[i].pbData = nextPtr;
5224 memcpy(nextPtr, ptr, 1 + nextLenBytes +
5225 nextLen);
5226 nextPtr += 1 + nextLenBytes + nextLen;
5227 }
5228 remainingLen -= 1 + nextLenBytes + nextLen;
5229 ptr += 1 + nextLenBytes + nextLen;
5230 i++;
5231 }
5232 }
5233 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
5234 CRYPT_FreeSpace(pDecodePara, seq);
5235 }
5236 }
5237 }
5238 }
5239 else
5240 {
5241 SetLastError(CRYPT_E_ASN1_BADTAG);
5242 ret = FALSE;
5243 }
5244 }
5245 __EXCEPT_PAGE_FAULT
5246 {
5247 SetLastError(STATUS_ACCESS_VIOLATION);
5248 ret = FALSE;
5249 }
5250 __ENDTRY
5251 return ret;
5252}
_CRYPT_SEQUENCE_OF_ANY
Definition: wincrypt.h:466
_CRYPT_SEQUENCE_OF_ANY::rgValue
PCRYPT_DER_BLOB rgValue
Definition: wincrypt.h:468
_CRYPT_SEQUENCE_OF_ANY::cValue
DWORD cValue
Definition: wincrypt.h:467
CRYPT_SEQUENCE_OF_ANY
struct _CRYPT_SEQUENCE_OF_ANY CRYPT_SEQUENCE_OF_ANY

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeSMIMECapabilities()

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

Definition at line 2347 of file decode.c.

2350{
2351 BOOL ret = FALSE;
2352
2353 TRACE("%p, %ld, %08lx, %p, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2354 pDecodePara, pvStructInfo, *pcbStructInfo);
2355
2356 __TRY
2357 {
2358 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2359 offsetof(CRYPT_SMIME_CAPABILITIES, cCapability),
2360 offsetof(CRYPT_SMIME_CAPABILITIES, rgCapability),
2361 sizeof(CRYPT_SMIME_CAPABILITIES),
2362 CRYPT_AsnDecodeSMIMECapability, sizeof(CRYPT_SMIME_CAPABILITY), TRUE,
2363 offsetof(CRYPT_SMIME_CAPABILITY, pszObjId) };
2364 CRYPT_SMIME_CAPABILITIES *capabilities = pvStructInfo;
2365
2366 if (pvStructInfo && !(dwFlags & CRYPT_DECODE_ALLOC_FLAG))
2367 capabilities->rgCapability = (CRYPT_SMIME_CAPABILITY *)(capabilities + 1);
2368 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
2369 dwFlags, pDecodePara, pvStructInfo, pcbStructInfo, NULL);
2370 }
2371 __EXCEPT_PAGE_FAULT
2372 {
2373 SetLastError(STATUS_ACCESS_VIOLATION);
2374 }
2375 __ENDTRY
2376 TRACE("returning %d\n", ret);
2377 return ret;
2378}
CRYPT_AsnDecodeSMIMECapability
static BOOL CRYPT_AsnDecodeSMIMECapability(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:2322
_CRYPT_SMIME_CAPABILITIES
Definition: wincrypt.h:803
_CRYPT_SMIME_CAPABILITIES::rgCapability
PCRYPT_SMIME_CAPABILITY rgCapability
Definition: wincrypt.h:805
_CRYPT_SMIME_CAPABILITY
Definition: wincrypt.h:798
CRYPT_SMIME_CAPABILITIES
struct _CRYPT_SMIME_CAPABILITIES CRYPT_SMIME_CAPABILITIES

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeSMIMECapability()

static BOOL CRYPT_AsnDecodeSMIMECapability ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2322 of file decode.c.

2325{
2326 BOOL ret;
2327 struct AsnDecodeSequenceItem items[] = {
2328 { ASN_OBJECTIDENTIFIER, offsetof(CRYPT_SMIME_CAPABILITY, pszObjId),
2329 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
2330 offsetof(CRYPT_SMIME_CAPABILITY, pszObjId), 0 },
2331 { 0, offsetof(CRYPT_SMIME_CAPABILITY, Parameters),
2332 CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
2333 offsetof(CRYPT_SMIME_CAPABILITY, Parameters.pbData), 0 },
2334 };
2335 PCRYPT_SMIME_CAPABILITY capability = pvStructInfo;
2336
2337 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
2338 pvStructInfo, *pcbStructInfo);
2339
2340 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
2341 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
2342 pcbDecoded, capability ? capability->pszObjId : NULL);
2343 TRACE("returning %d\n", ret);
2344 return ret;
2345}
_CRYPT_SMIME_CAPABILITY::pszObjId
LPSTR pszObjId
Definition: wincrypt.h:799

Referenced by CRYPT_AsnDecodeSMIMECapabilities().

◆ CRYPT_AsnDecodeSubtree()

static BOOL CRYPT_AsnDecodeSubtree ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5505 of file decode.c.

5508{
5509 BOOL ret;
5510 struct AsnDecodeSequenceItem items[] = {
5511 { 0, offsetof(CERT_GENERAL_SUBTREE, Base),
5512 CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), TRUE, TRUE,
5513 offsetof(CERT_ALT_NAME_ENTRY, pwszURL), 0 },
5514 { ASN_CONTEXT | 0, offsetof(CERT_GENERAL_SUBTREE, dwMinimum),
5515 CRYPT_AsnDecodeIntInternal, sizeof(DWORD), TRUE, FALSE, 0, 0 },
5516 { ASN_CONTEXT | 1, offsetof(CERT_GENERAL_SUBTREE, fMaximum),
5517 CRYPT_AsnDecodeMaximum, FINALMEMBERSIZE(CERT_GENERAL_SUBTREE, fMaximum),
5518 TRUE, FALSE, 0, 0 },
5519 };
5520 CERT_GENERAL_SUBTREE *subtree = pvStructInfo;
5521
5522 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
5523 pvStructInfo, *pcbStructInfo, pcbDecoded);
5524
5525 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
5526 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
5527 pcbDecoded, subtree ? subtree->Base.pwszURL : NULL);
5528 if (pcbDecoded)
5529 {
5530 TRACE("%ld\n", *pcbDecoded);
5531 if (*pcbDecoded < cbEncoded)
5532 TRACE("%02x %02x\n", *(pbEncoded + *pcbDecoded),
5533 *(pbEncoded + *pcbDecoded + 1));
5534 }
5535 TRACE("returning %d\n", ret);
5536 return ret;
5537}
CRYPT_AsnDecodeMaximum
static BOOL CRYPT_AsnDecodeMaximum(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5455
dwMinimum
DWORD dwMinimum
Definition: mmsystem.h:0
_CERT_ALT_NAME_ENTRY::pwszURL
LPWSTR pwszURL
Definition: wincrypt.h:348
_CERT_GENERAL_SUBTREE::Base
CERT_ALT_NAME_ENTRY Base
Definition: wincrypt.h:584

Referenced by CRYPT_AsnDecodeExcludedSubtree(), and CRYPT_AsnDecodePermittedSubtree().

◆ CRYPT_AsnDecodeSubtreeConstraints()

static BOOL CRYPT_AsnDecodeSubtreeConstraints ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 3495 of file decode.c.

3498{
3499 BOOL ret;
3500 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
3501 offsetof(CERT_BASIC_CONSTRAINTS_INFO, cSubtreesConstraint),
3502 offsetof(CERT_BASIC_CONSTRAINTS_INFO, rgSubtreesConstraint),
3503 FINALMEMBERSIZE(CERT_BASIC_CONSTRAINTS_INFO, cSubtreesConstraint),
3504 CRYPT_AsnDecodeCopyBytes, sizeof(CERT_NAME_BLOB), TRUE,
3505 offsetof(CERT_NAME_BLOB, pbData) };
3506
3507 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
3508 pvStructInfo, *pcbStructInfo, pcbDecoded);
3509
3510 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
3511 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
3512 TRACE("Returning %d (%08lx)\n", ret, GetLastError());
3513 return ret;
3514}

Referenced by CRYPT_AsnDecodeBasicConstraints().

◆ CRYPT_AsnDecodeTimeZone()

static BOOL CRYPT_AsnDecodeTimeZone ( const BYTE *  pbEncoded,
DWORD  len,
SYSTEMTIME *  sysTime 
)
static

Definition at line 4855 of file decode.c.

4857{
4858 BOOL ret = TRUE;
4859
4860 if (len >= 3 && (*pbEncoded == '+' || *pbEncoded == '-'))
4861 {
4862 WORD hours, minutes = 0;
4863 BYTE sign = *pbEncoded++;
4864
4865 len--;
4866 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, hours);
4867 if (ret && hours >= 24)
4868 {
4869 SetLastError(CRYPT_E_ASN1_CORRUPT);
4870 ret = FALSE;
4871 }
4872 else if (len >= 2)
4873 {
4874 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, minutes);
4875 if (ret && minutes >= 60)
4876 {
4877 SetLastError(CRYPT_E_ASN1_CORRUPT);
4878 ret = FALSE;
4879 }
4880 }
4881 if (ret)
4882 {
4883 if (sign == '+')
4884 {
4885 sysTime->wHour += hours;
4886 sysTime->wMinute += minutes;
4887 }
4888 else
4889 {
4890 if (hours > sysTime->wHour)
4891 {
4892 sysTime->wDay--;
4893 sysTime->wHour = 24 - (hours - sysTime->wHour);
4894 }
4895 else
4896 sysTime->wHour -= hours;
4897 if (minutes > sysTime->wMinute)
4898 {
4899 sysTime->wHour--;
4900 sysTime->wMinute = 60 - (minutes - sysTime->wMinute);
4901 }
4902 else
4903 sysTime->wMinute -= minutes;
4904 }
4905 }
4906 }
4907 return ret;
4908}
WORD
unsigned short WORD
Definition: ntddk_ex.h:93
sign
#define sign(x)
Definition: mapdesc.cc:613

Referenced by CRYPT_AsnDecodeGeneralizedTime(), and CRYPT_AsnDecodeUtcTimeInternal().

◆ CRYPT_AsnDecodeUnicodeName()

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

Definition at line 2006 of file decode.c.

2009{
2010 BOOL ret = TRUE;
2011
2012 __TRY
2013 {
2014 struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
2015 offsetof(CERT_NAME_INFO, cRDN), offsetof(CERT_NAME_INFO, rgRDN),
2016 sizeof(CERT_NAME_INFO),
2017 CRYPT_AsnDecodeUnicodeRdn, sizeof(CERT_RDN), TRUE,
2018 offsetof(CERT_RDN, rgRDNAttr) };
2019 DWORD bytesNeeded = 0;
2020
2021 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
2022 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, NULL, &bytesNeeded,
2023 NULL);
2024 if (ret)
2025 {
2026 if (!pvStructInfo)
2027 *pcbStructInfo = bytesNeeded;
2028 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
2029 pvStructInfo, pcbStructInfo, bytesNeeded)))
2030 {
2031 CERT_NAME_INFO *info;
2032
2033 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
2034 pvStructInfo = *(BYTE **)pvStructInfo;
2035 info = pvStructInfo;
2036 info->rgRDN = (CERT_RDN *)((BYTE *)pvStructInfo +
2037 sizeof(CERT_NAME_INFO));
2038 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
2039 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pvStructInfo,
2040 &bytesNeeded, NULL);
2041 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
2042 CRYPT_FreeSpace(pDecodePara, info);
2043 }
2044 }
2045 }
2046 __EXCEPT_PAGE_FAULT
2047 {
2048 SetLastError(STATUS_ACCESS_VIOLATION);
2049 ret = FALSE;
2050 }
2051 __ENDTRY
2052 return ret;
2053}
CRYPT_AsnDecodeUnicodeRdn
static BOOL CRYPT_AsnDecodeUnicodeRdn(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1991

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeUnicodeNameValue()

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

Definition at line 1823 of file decode.c.

1826{
1827 BOOL ret = TRUE;
1828
1829 __TRY
1830 {
1831 ret = CRYPT_AsnDecodeUnicodeNameValueInternal(pbEncoded, cbEncoded,
1832 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, pcbStructInfo, NULL);
1833 if (ret && pvStructInfo)
1834 {
1835 ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara, pvStructInfo,
1836 pcbStructInfo, *pcbStructInfo);
1837 if (ret)
1838 {
1839 CERT_NAME_VALUE *value;
1840
1841 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
1842 pvStructInfo = *(BYTE **)pvStructInfo;
1843 value = pvStructInfo;
1844 value->Value.pbData = ((BYTE *)value + sizeof(CERT_NAME_VALUE));
1845 ret = CRYPT_AsnDecodeUnicodeNameValueInternal(pbEncoded,
1846 cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
1847 pcbStructInfo, NULL);
1848 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
1849 CRYPT_FreeSpace(pDecodePara, value);
1850 }
1851 }
1852 }
1853 __EXCEPT_PAGE_FAULT
1854 {
1855 SetLastError(STATUS_ACCESS_VIOLATION);
1856 ret = FALSE;
1857 }
1858 __ENDTRY
1859 return ret;
1860}
CRYPT_AsnDecodeUnicodeNameValueInternal
static BOOL CRYPT_AsnDecodeUnicodeNameValueInternal(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1679

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeUnicodeNameValueInternal()

static BOOL CRYPT_AsnDecodeUnicodeNameValueInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1679 of file decode.c.

1682{
1683 BOOL ret = TRUE;
1684 DWORD dataLen;
1685 CERT_NAME_VALUE *value = pvStructInfo;
1686
1687 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
1688 {
1689 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
1690 DWORD bytesNeeded = sizeof(CERT_NAME_VALUE), valueType;
1691
1692 switch (pbEncoded[0])
1693 {
1694 case ASN_NUMERICSTRING:
1695 valueType = CERT_RDN_NUMERIC_STRING;
1696 if (dataLen)
1697 bytesNeeded += (dataLen + 1) * 2;
1698 break;
1699 case ASN_PRINTABLESTRING:
1700 valueType = CERT_RDN_PRINTABLE_STRING;
1701 if (dataLen)
1702 bytesNeeded += (dataLen + 1) * 2;
1703 break;
1704 case ASN_IA5STRING:
1705 valueType = CERT_RDN_IA5_STRING;
1706 if (dataLen)
1707 bytesNeeded += (dataLen + 1) * 2;
1708 break;
1709 case ASN_T61STRING:
1710 valueType = CERT_RDN_T61_STRING;
1711 if (dataLen)
1712 bytesNeeded += (dataLen + 1) * 2;
1713 break;
1714 case ASN_VIDEOTEXSTRING:
1715 valueType = CERT_RDN_VIDEOTEX_STRING;
1716 if (dataLen)
1717 bytesNeeded += (dataLen + 1) * 2;
1718 break;
1719 case ASN_GRAPHICSTRING:
1720 valueType = CERT_RDN_GRAPHIC_STRING;
1721 if (dataLen)
1722 bytesNeeded += (dataLen + 1) * 2;
1723 break;
1724 case ASN_VISIBLESTRING:
1725 valueType = CERT_RDN_VISIBLE_STRING;
1726 if (dataLen)
1727 bytesNeeded += (dataLen + 1) * 2;
1728 break;
1729 case ASN_GENERALSTRING:
1730 valueType = CERT_RDN_GENERAL_STRING;
1731 if (dataLen)
1732 bytesNeeded += (dataLen + 1) * 2;
1733 break;
1734 case ASN_UNIVERSALSTRING:
1735 valueType = CERT_RDN_UNIVERSAL_STRING;
1736 if (dataLen)
1737 bytesNeeded += dataLen / 2 + sizeof(WCHAR);
1738 break;
1739 case ASN_BMPSTRING:
1740 valueType = CERT_RDN_BMP_STRING;
1741 if (dataLen)
1742 bytesNeeded += dataLen + sizeof(WCHAR);
1743 break;
1744 case ASN_UTF8STRING:
1745 valueType = CERT_RDN_UTF8_STRING;
1746 if (dataLen)
1747 bytesNeeded += (MultiByteToWideChar(CP_UTF8, 0,
1748 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen, NULL, 0) + 1) * 2;
1749 break;
1750 default:
1751 SetLastError(CRYPT_E_ASN1_BADTAG);
1752 return FALSE;
1753 }
1754
1755 if (pcbDecoded)
1756 *pcbDecoded = 1 + lenBytes + dataLen;
1757 if (!value)
1758 *pcbStructInfo = bytesNeeded;
1759 else if (*pcbStructInfo < bytesNeeded)
1760 {
1761 *pcbStructInfo = bytesNeeded;
1762 SetLastError(ERROR_MORE_DATA);
1763 ret = FALSE;
1764 }
1765 else
1766 {
1767 *pcbStructInfo = bytesNeeded;
1768 value->dwValueType = valueType;
1769 if (dataLen)
1770 {
1771 DWORD i;
1772 LPWSTR str = (LPWSTR)value->Value.pbData;
1773
1774 assert(value->Value.pbData);
1775 switch (pbEncoded[0])
1776 {
1777 case ASN_NUMERICSTRING:
1778 case ASN_PRINTABLESTRING:
1779 case ASN_IA5STRING:
1780 case ASN_T61STRING:
1781 case ASN_VIDEOTEXSTRING:
1782 case ASN_GRAPHICSTRING:
1783 case ASN_VISIBLESTRING:
1784 case ASN_GENERALSTRING:
1785 value->Value.cbData = dataLen * 2;
1786 for (i = 0; i < dataLen; i++)
1787 str[i] = pbEncoded[1 + lenBytes + i];
1788 str[i] = 0;
1789 break;
1790 case ASN_UNIVERSALSTRING:
1791 value->Value.cbData = dataLen / 2;
1792 for (i = 0; i < dataLen / 4; i++)
1793 str[i] = (pbEncoded[1 + lenBytes + 2 * i + 2] << 8)
1794 | pbEncoded[1 + lenBytes + 2 * i + 3];
1795 str[i] = 0;
1796 break;
1797 case ASN_BMPSTRING:
1798 value->Value.cbData = dataLen;
1799 for (i = 0; i < dataLen / 2; i++)
1800 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
1801 pbEncoded[1 + lenBytes + 2 * i + 1];
1802 str[i] = 0;
1803 break;
1804 case ASN_UTF8STRING:
1805 value->Value.cbData = MultiByteToWideChar(CP_UTF8, 0,
1806 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen,
1807 str, bytesNeeded - sizeof(CERT_NAME_VALUE)) * sizeof(WCHAR);
1808 *(WCHAR *)(value->Value.pbData + value->Value.cbData) = 0;
1809 value->Value.cbData += sizeof(WCHAR);
1810 break;
1811 }
1812 }
1813 else
1814 {
1815 value->Value.cbData = 0;
1816 value->Value.pbData = NULL;
1817 }
1818 }
1819 }
1820 return ret;
1821}
CERT_RDN_UNIVERSAL_STRING
#define CERT_RDN_UNIVERSAL_STRING
Definition: wincrypt.h:2936

Referenced by CRYPT_AsnDecodeUnicodeNameValue(), and CRYPT_AsnDecodeUnicodeRdnAttr().

◆ CRYPT_AsnDecodeUnicodeRdn()

static BOOL CRYPT_AsnDecodeUnicodeRdn ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1991 of file decode.c.

1993{
1994 BOOL ret = TRUE;
1995 struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
1996 offsetof(CERT_RDN, cRDNAttr), offsetof(CERT_RDN, rgRDNAttr),
1997 sizeof(CERT_RDN),
1998 CRYPT_AsnDecodeUnicodeRdnAttr, sizeof(CERT_RDN_ATTR), TRUE,
1999 offsetof(CERT_RDN_ATTR, pszObjId) };
2000
2001 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
2002 NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
2003 return ret;
2004}
CRYPT_AsnDecodeUnicodeRdnAttr
static BOOL CRYPT_AsnDecodeUnicodeRdnAttr(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:1958

Referenced by CRYPT_AsnDecodeUnicodeName().

◆ CRYPT_AsnDecodeUnicodeRdnAttr()

static BOOL CRYPT_AsnDecodeUnicodeRdnAttr ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 1958 of file decode.c.

1961{
1962 BOOL ret;
1963 struct AsnDecodeSequenceItem items[] = {
1964 { ASN_OBJECTIDENTIFIER, offsetof(CERT_RDN_ATTR, pszObjId),
1965 CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
1966 offsetof(CERT_RDN_ATTR, pszObjId), 0 },
1967 { 0, offsetof(CERT_RDN_ATTR, dwValueType),
1968 CRYPT_AsnDecodeUnicodeNameValueInternal, sizeof(CERT_NAME_VALUE),
1969 FALSE, TRUE, offsetof(CERT_RDN_ATTR, Value.pbData), 0 },
1970 };
1971 CERT_RDN_ATTR *attr = pvStructInfo;
1972
1973 TRACE("%p, %ld, %08lx, %p, %ld\n", pbEncoded, cbEncoded, dwFlags,
1974 pvStructInfo, *pcbStructInfo);
1975
1976 if (attr)
1977 TRACE("attr->pszObjId is %p\n", attr->pszObjId);
1978 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
1979 pbEncoded, cbEncoded, dwFlags, NULL, attr, pcbStructInfo, pcbDecoded,
1980 attr ? attr->pszObjId : NULL);
1981 if (attr)
1982 {
1983 TRACE("attr->pszObjId is %p (%s)\n", attr->pszObjId,
1984 debugstr_a(attr->pszObjId));
1985 TRACE("attr->dwValueType is %ld\n", attr->dwValueType);
1986 }
1987 TRACE("returning %d (%08lx)\n", ret, GetLastError());
1988 return ret;
1989}

Referenced by CRYPT_AsnDecodeUnicodeRdn().

◆ CRYPT_AsnDecodeUnicodeString()

static BOOL CRYPT_AsnDecodeUnicodeString ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 2514 of file decode.c.

2517{
2518 BOOL ret = TRUE;
2519 DWORD dataLen;
2520
2521 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
2522 {
2523 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2524 DWORD bytesNeeded = sizeof(LPWSTR);
2525
2526 switch (pbEncoded[0])
2527 {
2528 case ASN_NUMERICSTRING:
2529 if (dataLen)
2530 bytesNeeded += (dataLen + 1) * 2;
2531 break;
2532 case ASN_PRINTABLESTRING:
2533 if (dataLen)
2534 bytesNeeded += (dataLen + 1) * 2;
2535 break;
2536 case ASN_IA5STRING:
2537 if (dataLen)
2538 bytesNeeded += (dataLen + 1) * 2;
2539 break;
2540 case ASN_T61STRING:
2541 if (dataLen)
2542 bytesNeeded += (dataLen + 1) * 2;
2543 break;
2544 case ASN_VIDEOTEXSTRING:
2545 if (dataLen)
2546 bytesNeeded += (dataLen + 1) * 2;
2547 break;
2548 case ASN_GRAPHICSTRING:
2549 if (dataLen)
2550 bytesNeeded += (dataLen + 1) * 2;
2551 break;
2552 case ASN_VISIBLESTRING:
2553 if (dataLen)
2554 bytesNeeded += (dataLen + 1) * 2;
2555 break;
2556 case ASN_GENERALSTRING:
2557 if (dataLen)
2558 bytesNeeded += (dataLen + 1) * 2;
2559 break;
2560 case ASN_UNIVERSALSTRING:
2561 if (dataLen)
2562 bytesNeeded += dataLen / 2 + sizeof(WCHAR);
2563 break;
2564 case ASN_BMPSTRING:
2565 if (dataLen)
2566 bytesNeeded += dataLen + sizeof(WCHAR);
2567 break;
2568 case ASN_UTF8STRING:
2569 if (dataLen)
2570 bytesNeeded += (MultiByteToWideChar(CP_UTF8, 0,
2571 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen, NULL, 0) + 1) * 2;
2572 break;
2573 default:
2574 SetLastError(CRYPT_E_ASN1_BADTAG);
2575 return FALSE;
2576 }
2577
2578 if (pcbDecoded)
2579 *pcbDecoded = 1 + lenBytes + dataLen;
2580 if (!pvStructInfo)
2581 *pcbStructInfo = bytesNeeded;
2582 else if (*pcbStructInfo < bytesNeeded)
2583 {
2584 *pcbStructInfo = bytesNeeded;
2585 SetLastError(ERROR_MORE_DATA);
2586 ret = FALSE;
2587 }
2588 else
2589 {
2590 LPWSTR *pStr = pvStructInfo;
2591
2592 *pcbStructInfo = bytesNeeded;
2593 if (dataLen)
2594 {
2595 DWORD i;
2596 LPWSTR str = *pStr;
2597
2598 assert(str);
2599 switch (pbEncoded[0])
2600 {
2601 case ASN_NUMERICSTRING:
2602 case ASN_PRINTABLESTRING:
2603 case ASN_IA5STRING:
2604 case ASN_T61STRING:
2605 case ASN_VIDEOTEXSTRING:
2606 case ASN_GRAPHICSTRING:
2607 case ASN_VISIBLESTRING:
2608 case ASN_GENERALSTRING:
2609 for (i = 0; i < dataLen; i++)
2610 str[i] = pbEncoded[1 + lenBytes + i];
2611 str[i] = 0;
2612 break;
2613 case ASN_UNIVERSALSTRING:
2614 for (i = 0; i < dataLen / 4; i++)
2615 str[i] = (pbEncoded[1 + lenBytes + 2 * i + 2] << 8)
2616 | pbEncoded[1 + lenBytes + 2 * i + 3];
2617 str[i] = 0;
2618 break;
2619 case ASN_BMPSTRING:
2620 for (i = 0; i < dataLen / 2; i++)
2621 str[i] = (pbEncoded[1 + lenBytes + 2 * i] << 8) |
2622 pbEncoded[1 + lenBytes + 2 * i + 1];
2623 str[i] = 0;
2624 break;
2625 case ASN_UTF8STRING:
2626 {
2627 int len = MultiByteToWideChar(CP_UTF8, 0,
2628 (LPCSTR)pbEncoded + 1 + lenBytes, dataLen,
2629 str, bytesNeeded - sizeof(CERT_NAME_VALUE)) * 2;
2630 str[len] = 0;
2631 break;
2632 }
2633 }
2634 }
2635 else
2636 *pStr = NULL;
2637 }
2638 }
2639 return ret;
2640}

Referenced by CRYPT_AsnDecodePolicyQualifierUserNoticeInternal().

◆ CRYPT_AsnDecodeUnsignedInteger()

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

Definition at line 4722 of file decode.c.

4725{
4726 BOOL ret;
4727
4728 __TRY
4729 {
4730 DWORD bytesNeeded = 0;
4731
4732 if ((ret = CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded, cbEncoded,
4733 dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
4734 {
4735 if (!pvStructInfo)
4736 *pcbStructInfo = bytesNeeded;
4737 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
4738 pvStructInfo, pcbStructInfo, bytesNeeded)))
4739 {
4740 CRYPT_INTEGER_BLOB *blob;
4741
4742 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4743 pvStructInfo = *(BYTE **)pvStructInfo;
4744 blob = pvStructInfo;
4745 blob->pbData = (BYTE *)pvStructInfo +
4746 sizeof(CRYPT_INTEGER_BLOB);
4747 ret = CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded,
4748 cbEncoded, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, pvStructInfo,
4749 &bytesNeeded, NULL);
4750 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
4751 CRYPT_FreeSpace(pDecodePara, blob);
4752 }
4753 }
4754 }
4755 __EXCEPT_PAGE_FAULT
4756 {
4757 SetLastError(STATUS_ACCESS_VIOLATION);
4758 ret = FALSE;
4759 }
4760 __ENDTRY
4761 return ret;
4762}

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeUnsignedIntegerInternal()

static BOOL CRYPT_AsnDecodeUnsignedIntegerInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 4663 of file decode.c.

4666{
4667 BOOL ret;
4668
4669 if (pbEncoded[0] == ASN_INTEGER)
4670 {
4671 DWORD bytesNeeded, dataLen;
4672
4673 if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
4674 {
4675 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
4676
4677 if (pcbDecoded)
4678 *pcbDecoded = 1 + lenBytes + dataLen;
4679 bytesNeeded = dataLen + sizeof(CRYPT_INTEGER_BLOB);
4680 if (!pvStructInfo)
4681 *pcbStructInfo = bytesNeeded;
4682 else if (*pcbStructInfo < bytesNeeded)
4683 {
4684 *pcbStructInfo = bytesNeeded;
4685 SetLastError(ERROR_MORE_DATA);
4686 ret = FALSE;
4687 }
4688 else
4689 {
4690 CRYPT_INTEGER_BLOB *blob = pvStructInfo;
4691
4692 *pcbStructInfo = bytesNeeded;
4693 blob->cbData = dataLen;
4694 assert(blob->pbData);
4695 /* remove leading zero byte if it exists */
4696 if (blob->cbData && *(pbEncoded + 1 + lenBytes) == 0)
4697 {
4698 blob->cbData--;
4699 blob->pbData++;
4700 }
4701 if (blob->cbData)
4702 {
4703 DWORD i;
4704
4705 for (i = 0; i < blob->cbData; i++)
4706 {
4707 blob->pbData[i] = *(pbEncoded + 1 + lenBytes +
4708 dataLen - i - 1);
4709 }
4710 }
4711 }
4712 }
4713 }
4714 else
4715 {
4716 SetLastError(CRYPT_E_ASN1_BADTAG);
4717 ret = FALSE;
4718 }
4719 return ret;
4720}

Referenced by CRYPT_AsnDecodeEccSignature(), CRYPT_AsnDecodeRsaPrivKey(), CRYPT_AsnDecodeUnsignedInteger(), and CRYPT_raw_decode_rsa_pub_key().

◆ CRYPT_AsnDecodeUtcTime()

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

Definition at line 4978 of file decode.c.

4981{
4982 BOOL ret = FALSE;
4983
4984 __TRY
4985 {
4986 DWORD bytesNeeded = 0;
4987
4988 ret = CRYPT_AsnDecodeUtcTimeInternal(pbEncoded, cbEncoded,
4989 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL);
4990 if (ret)
4991 {
4992 if (!pvStructInfo)
4993 *pcbStructInfo = bytesNeeded;
4994 else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
4995 pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
4996 {
4997 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
4998 pvStructInfo = *(BYTE **)pvStructInfo;
4999 ret = CRYPT_AsnDecodeUtcTimeInternal(pbEncoded, cbEncoded,
5000 dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
5001 &bytesNeeded, NULL);
5002 if (!ret && (dwFlags & CRYPT_DECODE_ALLOC_FLAG))
5003 CRYPT_FreeSpace(pDecodePara, pvStructInfo);
5004 }
5005 }
5006 }
5007 __EXCEPT_PAGE_FAULT
5008 {
5009 SetLastError(STATUS_ACCESS_VIOLATION);
5010 }
5011 __ENDTRY
5012 return ret;
5013}

Referenced by CRYPT_GetBuiltinDecoder().

◆ CRYPT_AsnDecodeUtcTimeInternal()

static BOOL CRYPT_AsnDecodeUtcTimeInternal ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 4912 of file decode.c.

4915{
4916 BOOL ret = FALSE;
4917
4918 if (pbEncoded[0] == ASN_UTCTIME)
4919 {
4920 if (cbEncoded <= 1)
4921 SetLastError(CRYPT_E_ASN1_EOD);
4922 else if (pbEncoded[1] > 0x7f)
4923 {
4924 /* long-form date strings really can't be valid */
4925 SetLastError(CRYPT_E_ASN1_CORRUPT);
4926 }
4927 else
4928 {
4929 SYSTEMTIME sysTime = { 0 };
4930 BYTE len = pbEncoded[1];
4931
4932 if (len < MIN_ENCODED_TIME_LENGTH)
4933 SetLastError(CRYPT_E_ASN1_CORRUPT);
4934 else
4935 {
4936 ret = TRUE;
4937 if (pcbDecoded)
4938 *pcbDecoded = 2 + len;
4939 pbEncoded += 2;
4940 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wYear);
4941 if (sysTime.wYear >= 50)
4942 sysTime.wYear += 1900;
4943 else
4944 sysTime.wYear += 2000;
4945 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wMonth);
4946 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wDay);
4947 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wHour);
4948 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2, sysTime.wMinute);
4949 if (ret && len > 0)
4950 {
4951 if (len >= 2 && isdigit(*pbEncoded) &&
4952 isdigit(*(pbEncoded + 1)))
4953 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 2,
4954 sysTime.wSecond);
4955 else if (isdigit(*pbEncoded))
4956 CRYPT_TIME_GET_DIGITS(pbEncoded, len, 1,
4957 sysTime.wSecond);
4958 if (ret)
4959 ret = CRYPT_AsnDecodeTimeZone(pbEncoded, len,
4960 &sysTime);
4961 }
4962 if (ret)
4963 {
4964 if (!pvStructInfo)
4965 *pcbStructInfo = sizeof(FILETIME);
4966 else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
4967 sizeof(FILETIME))))
4968 ret = SystemTimeToFileTime(&sysTime, pvStructInfo);
4969 }
4970 }
4971 }
4972 }
4973 else
4974 SetLastError(CRYPT_E_ASN1_BADTAG);
4975 return ret;
4976}

Referenced by CRYPT_AsnDecodeChoiceOfTimeInternal(), and CRYPT_AsnDecodeUtcTime().

◆ CRYPT_AsnDecodeValidity()

static BOOL CRYPT_AsnDecodeValidity ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 937 of file decode.c.

939{
940 BOOL ret;
941
942 struct AsnDecodeSequenceItem items[] = {
943 { 0, offsetof(CERT_PRIVATE_KEY_VALIDITY, NotBefore),
944 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE, 0 },
945 { 0, offsetof(CERT_PRIVATE_KEY_VALIDITY, NotAfter),
946 CRYPT_AsnDecodeChoiceOfTimeInternal, sizeof(FILETIME), FALSE, FALSE, 0 },
947 };
948
949 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
950 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
951 pcbDecoded, NULL);
952 return ret;
953}
_CERT_PRIVATE_KEY_VALIDITY
Definition: wincrypt.h:296

Referenced by CRYPT_AsnDecodeCertInfo().

◆ CRYPT_CopyReversed()

void CRYPT_CopyReversed ( BYTE *  dst,
const BYTE *  src,
size_t  len 
)

Definition at line 56 of file decode.c.

57{
58 DWORD i;
59 for (i = 0; i < len; i++) {
60 dst[len - i - 1] = src[i];
61 }
62}
src
GLenum src
Definition: glext.h:6340
dst
GLenum GLenum dst
Definition: glext.h:6340

Referenced by CRYPT_AsnDecodeRsaPubKey_Bcrypt().

◆ CRYPT_DecodeCheckSpace()

static BOOL CRYPT_DecodeCheckSpace ( DWORD *  pcbStructInfo,
DWORD  bytesNeeded 
)
static

Definition at line 249 of file decode.c.

250{
251 BOOL ret;
252
253 if (*pcbStructInfo < bytesNeeded)
254 {
255 *pcbStructInfo = bytesNeeded;
256 SetLastError(ERROR_MORE_DATA);
257 ret = FALSE;
258 }
259 else
260 {
261 *pcbStructInfo = bytesNeeded;
262 ret = TRUE;
263 }
264 return ret;
265}

Referenced by CRYPT_AsnDecodeDerBlob(), CRYPT_AsnDecodeGeneralizedTime(), CRYPT_AsnDecodeIntInternal(), and CRYPT_AsnDecodeUtcTimeInternal().

◆ CRYPT_DecodeEnsureSpace()

static BOOL CRYPT_DecodeEnsureSpace ( DWORD  dwFlags,
const CRYPT_DECODE_PARA *  pDecodePara,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD  bytesNeeded 
)
static

Definition at line 210 of file decode.c.

213{
214 BOOL ret = TRUE;
215
216 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
217 {
218 if (pDecodePara && pDecodePara->pfnAlloc)
219 *(BYTE **)pvStructInfo = pDecodePara->pfnAlloc(bytesNeeded);
220 else
221 *(BYTE **)pvStructInfo = LocalAlloc(LPTR, bytesNeeded);
222 if (!*(BYTE **)pvStructInfo)
223 ret = FALSE;
224 else
225 *pcbStructInfo = bytesNeeded;
226 }
227 else if (*pcbStructInfo < bytesNeeded)
228 {
229 *pcbStructInfo = bytesNeeded;
230 SetLastError(ERROR_MORE_DATA);
231 ret = FALSE;
232 }
233 else
234 *pcbStructInfo = bytesNeeded;
235 return ret;
236}
LocalAlloc
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
LPTR
#define LPTR
Definition: minwinbase.h:93
_CRYPT_DECODE_PARA::pfnAlloc
PFN_CRYPT_ALLOC pfnAlloc
Definition: wincrypt.h:1268

Referenced by CRYPT_AsnDecodeAltName(), CRYPT_AsnDecodeArray(), CRYPT_AsnDecodeBits(), CRYPT_AsnDecodeChoiceOfTime(), CRYPT_AsnDecodeCMSSignerInfo(), CRYPT_AsnDecodeEnumerated(), CRYPT_AsnDecodeInt(), CRYPT_AsnDecodeInteger(), CRYPT_AsnDecodeName(), CRYPT_AsnDecodeNameValue(), CRYPT_AsnDecodeObjectIdentifier(), CRYPT_AsnDecodeOctetString(), CRYPT_AsnDecodePKCSAttribute(), CRYPT_AsnDecodePKCSContentInfo(), CRYPT_AsnDecodePKCSSignerInfo(), CRYPT_AsnDecodePolicyQualifierUserNotice(), CRYPT_AsnDecodePubKeyInfo(), CRYPT_AsnDecodeRsaPrivKey(), CRYPT_AsnDecodeRsaPubKey(), CRYPT_AsnDecodeRsaPubKey_Bcrypt(), CRYPT_AsnDecodeSequence(), CRYPT_AsnDecodeSequenceOfAny(), CRYPT_AsnDecodeUnicodeName(), CRYPT_AsnDecodeUnicodeNameValue(), CRYPT_AsnDecodeUnsignedInteger(), CRYPT_AsnDecodeUtcTime(), and CryptDecodeObjectEx().

◆ CRYPT_DecodeRecipientInfoArray()

static BOOL CRYPT_DecodeRecipientInfoArray ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 6011 of file decode.c.

6014{
6015 BOOL ret;
6016 struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
6017 offsetof(CRYPT_ENVELOPED_DATA, cRecipientInfo),
6018 offsetof(CRYPT_ENVELOPED_DATA, rgRecipientInfo),
6019 MEMBERSIZE(CRYPT_ENVELOPED_DATA, cRecipientInfo, encryptedContentInfo),
6020 CRYPT_AsnDecodeRecipientInfo, sizeof(CMSG_KEY_TRANS_RECIPIENT_INFO), TRUE,
6021 offsetof(CMSG_KEY_TRANS_RECIPIENT_INFO,
6022 RecipientId.IssuerSerialNumber.Issuer.pbData) };
6023
6024 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
6025 pvStructInfo, *pcbStructInfo, pcbDecoded);
6026
6027 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
6028 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
6029 TRACE("returning %d\n", ret);
6030 return ret;
6031}
CRYPT_AsnDecodeRecipientInfo
static BOOL CRYPT_AsnDecodeRecipientInfo(const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
Definition: decode.c:5975
CMSG_KEY_TRANS_RECIPIENT_INFO
struct _CMSG_KEY_TRANS_RECIPIENT_INFO CMSG_KEY_TRANS_RECIPIENT_INFO

Referenced by CRYPT_AsnDecodePKCSEnvelopedData().

◆ CRYPT_DecodeSignerArray()

static BOOL CRYPT_DecodeSignerArray ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5917 of file decode.c.

5919{
5920 BOOL ret;
5921 struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
5922 offsetof(CRYPT_SIGNED_INFO, cSignerInfo),
5923 offsetof(CRYPT_SIGNED_INFO, rgSignerInfo),
5924 FINALMEMBERSIZE(CRYPT_SIGNED_INFO, cSignerInfo),
5925 CRYPT_AsnDecodeCMSSignerInfoInternal, sizeof(CMSG_CMS_SIGNER_INFO), TRUE,
5926 offsetof(CMSG_CMS_SIGNER_INFO, SignerId.KeyId.pbData) };
5927
5928 TRACE("%p, %ld, %08lx, %p, %ld, %p\n", pbEncoded, cbEncoded, dwFlags,
5929 pvStructInfo, *pcbStructInfo, pcbDecoded);
5930
5931 ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded,
5932 dwFlags, NULL, pvStructInfo, pcbStructInfo, pcbDecoded);
5933 return ret;
5934}
CMSG_CMS_SIGNER_INFO
struct _CMSG_CMS_SIGNER_INFO CMSG_CMS_SIGNER_INFO

Referenced by CRYPT_AsnDecodeCMSSignedInfo().

◆ CRYPT_FindEncodedLen()

static BOOL CRYPT_FindEncodedLen ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD *  pcbDecoded 
)
static

Definition at line 2055 of file decode.c.

2057{
2058 BOOL ret = TRUE, done = FALSE;
2059 DWORD indefiniteNestingLevels = 0, decoded = 0;
2060
2061 TRACE("(%p, %ld)\n", pbEncoded, cbEncoded);
2062
2063 do {
2064 DWORD dataLen;
2065
2066 if (!cbEncoded)
2067 done = TRUE;
2068 else if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded,
2069 &dataLen)))
2070 {
2071 BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
2072
2073 if (dataLen == CMSG_INDEFINITE_LENGTH)
2074 {
2075 indefiniteNestingLevels++;
2076 pbEncoded += 1 + lenBytes;
2077 cbEncoded -= 1 + lenBytes;
2078 decoded += 1 + lenBytes;
2079 TRACE("indefiniteNestingLevels = %ld\n",
2080 indefiniteNestingLevels);
2081 }
2082 else
2083 {
2084 if (pbEncoded[0] == 0 && pbEncoded[1] == 0 &&
2085 indefiniteNestingLevels)
2086 {
2087 indefiniteNestingLevels--;
2088 TRACE("indefiniteNestingLevels = %ld\n",
2089 indefiniteNestingLevels);
2090 }
2091 pbEncoded += 1 + lenBytes + dataLen;
2092 cbEncoded -= 1 + lenBytes + dataLen;
2093 decoded += 1 + lenBytes + dataLen;
2094 if (!indefiniteNestingLevels)
2095 done = TRUE;
2096 }
2097 }
2098 } while (ret && !done);
2099 /* If we haven't found all 0 TLVs, we haven't found the end */
2100 if (ret && indefiniteNestingLevels)
2101 {
2102 SetLastError(CRYPT_E_ASN1_EOD);
2103 ret = FALSE;
2104 }
2105 if (ret)
2106 *pcbDecoded = decoded;
2107 TRACE("returning %d (%ld)\n", ret, ret ? *pcbDecoded : 0);
2108 return ret;
2109}

Referenced by CRYPT_AsnDecodeCopyBytes().

◆ CRYPT_FreeSpace()

static void CRYPT_FreeSpace ( const CRYPT_DECODE_PARA *  pDecodePara,
LPVOID  pv 
)
static

Definition at line 238 of file decode.c.

239{
240 if (pDecodePara && pDecodePara->pfnFree)
241 pDecodePara->pfnFree(pv);
242 else
243 LocalFree(pv);
244}
_CRYPT_DECODE_PARA::pfnFree
PFN_CRYPT_FREE pfnFree
Definition: wincrypt.h:1269

Referenced by CRYPT_AsnDecodeAltName(), CRYPT_AsnDecodeArray(), CRYPT_AsnDecodeBits(), CRYPT_AsnDecodeChoiceOfTime(), CRYPT_AsnDecodeCMSSignerInfo(), CRYPT_AsnDecodeInt(), CRYPT_AsnDecodeInteger(), CRYPT_AsnDecodeName(), CRYPT_AsnDecodeNameValue(), CRYPT_AsnDecodeObjectIdentifier(), CRYPT_AsnDecodeOctetString(), CRYPT_AsnDecodePKCSAttribute(), CRYPT_AsnDecodePKCSContentInfo(), CRYPT_AsnDecodePKCSSignerInfo(), CRYPT_AsnDecodePolicyQualifierUserNotice(), CRYPT_AsnDecodePubKeyInfo(), CRYPT_AsnDecodeSequence(), CRYPT_AsnDecodeSequenceOfAny(), CRYPT_AsnDecodeUnicodeName(), CRYPT_AsnDecodeUnicodeNameValue(), CRYPT_AsnDecodeUnsignedInteger(), CRYPT_AsnDecodeUtcTime(), and CryptDecodeObjectEx().

◆ CRYPT_GetBuiltinDecoder()

static CryptDecodeObjectExFunc CRYPT_GetBuiltinDecoder ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType 
)
static

Definition at line 6746 of file decode.c.

6748{
6749 CryptDecodeObjectExFunc decodeFunc = NULL;
6750
6751 if ((dwCertEncodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING
6752 && (dwCertEncodingType & CMSG_ENCODING_TYPE_MASK) != PKCS_7_ASN_ENCODING)
6753 {
6754 SetLastError(ERROR_FILE_NOT_FOUND);
6755 return NULL;
6756 }
6757 if (IS_INTOID(lpszStructType))
6758 {
6759 switch (LOWORD(lpszStructType))
6760 {
6761 case LOWORD(X509_CERT):
6762 decodeFunc = CRYPT_AsnDecodeCertSignedContent;
6763 break;
6764 case LOWORD(X509_CERT_TO_BE_SIGNED):
6765 decodeFunc = CRYPT_AsnDecodeCert;
6766 break;
6767 case LOWORD(X509_CERT_CRL_TO_BE_SIGNED):
6768 decodeFunc = CRYPT_AsnDecodeCRL;
6769 break;
6770 case LOWORD(X509_EXTENSIONS):
6771 decodeFunc = CRYPT_AsnDecodeExtensions;
6772 break;
6773 case LOWORD(X509_NAME_VALUE):
6774 decodeFunc = CRYPT_AsnDecodeNameValue;
6775 break;
6776 case LOWORD(X509_NAME):
6777 decodeFunc = CRYPT_AsnDecodeName;
6778 break;
6779 case LOWORD(X509_PUBLIC_KEY_INFO):
6780 decodeFunc = CRYPT_AsnDecodePubKeyInfo;
6781 break;
6782 case LOWORD(X509_AUTHORITY_KEY_ID):
6783 decodeFunc = CRYPT_AsnDecodeAuthorityKeyId;
6784 break;
6785 case LOWORD(X509_ALTERNATE_NAME):
6786 decodeFunc = CRYPT_AsnDecodeAltName;
6787 break;
6788 case LOWORD(X509_BASIC_CONSTRAINTS):
6789 decodeFunc = CRYPT_AsnDecodeBasicConstraints;
6790 break;
6791 case LOWORD(X509_BASIC_CONSTRAINTS2):
6792 decodeFunc = CRYPT_AsnDecodeBasicConstraints2;
6793 break;
6794 case LOWORD(X509_CERT_POLICIES):
6795 decodeFunc = CRYPT_AsnDecodeCertPolicies;
6796 break;
6797 case LOWORD(RSA_CSP_PUBLICKEYBLOB):
6798 decodeFunc = CRYPT_AsnDecodeRsaPubKey;
6799 break;
6800 case LOWORD(PKCS_RSA_PRIVATE_KEY):
6801 decodeFunc = CRYPT_AsnDecodeRsaPrivKey;
6802 break;
6803 case LOWORD(X509_UNICODE_NAME):
6804 decodeFunc = CRYPT_AsnDecodeUnicodeName;
6805 break;
6806 case LOWORD(PKCS_ATTRIBUTE):
6807 decodeFunc = CRYPT_AsnDecodePKCSAttribute;
6808 break;
6809 case LOWORD(X509_UNICODE_NAME_VALUE):
6810 decodeFunc = CRYPT_AsnDecodeUnicodeNameValue;
6811 break;
6812 case LOWORD(X509_OCTET_STRING):
6813 decodeFunc = CRYPT_AsnDecodeOctetString;
6814 break;
6815 case LOWORD(X509_BITS):
6816 case LOWORD(X509_KEY_USAGE):
6817 decodeFunc = CRYPT_AsnDecodeBits;
6818 break;
6819 case LOWORD(X509_INTEGER):
6820 decodeFunc = CRYPT_AsnDecodeInt;
6821 break;
6822 case LOWORD(X509_MULTI_BYTE_INTEGER):
6823 decodeFunc = CRYPT_AsnDecodeInteger;
6824 break;
6825 case LOWORD(X509_MULTI_BYTE_UINT):
6826 decodeFunc = CRYPT_AsnDecodeUnsignedInteger;
6827 break;
6828 case LOWORD(X509_ENUMERATED):
6829 decodeFunc = CRYPT_AsnDecodeEnumerated;
6830 break;
6831 case LOWORD(X509_CHOICE_OF_TIME):
6832 decodeFunc = CRYPT_AsnDecodeChoiceOfTime;
6833 break;
6834 case LOWORD(X509_AUTHORITY_KEY_ID2):
6835 decodeFunc = CRYPT_AsnDecodeAuthorityKeyId2;
6836 break;
6837 case LOWORD(X509_AUTHORITY_INFO_ACCESS):
6838 decodeFunc = CRYPT_AsnDecodeAuthorityInfoAccess;
6839 break;
6840 case LOWORD(PKCS_CONTENT_INFO):
6841 decodeFunc = CRYPT_AsnDecodePKCSContentInfo;
6842 break;
6843 case LOWORD(X509_SEQUENCE_OF_ANY):
6844 decodeFunc = CRYPT_AsnDecodeSequenceOfAny;
6845 break;
6846 case LOWORD(PKCS_UTC_TIME):
6847 decodeFunc = CRYPT_AsnDecodeUtcTime;
6848 break;
6849 case LOWORD(X509_CRL_DIST_POINTS):
6850 decodeFunc = CRYPT_AsnDecodeCRLDistPoints;
6851 break;
6852 case LOWORD(X509_ENHANCED_KEY_USAGE):
6853 decodeFunc = CRYPT_AsnDecodeEnhancedKeyUsage;
6854 break;
6855 case LOWORD(PKCS_CTL):
6856 decodeFunc = CRYPT_AsnDecodeCTL;
6857 break;
6858 case LOWORD(PKCS_SMIME_CAPABILITIES):
6859 decodeFunc = CRYPT_AsnDecodeSMIMECapabilities;
6860 break;
6861 case LOWORD(X509_PKIX_POLICY_QUALIFIER_USERNOTICE):
6862 decodeFunc = CRYPT_AsnDecodePolicyQualifierUserNotice;
6863 break;
6864 case LOWORD(PKCS_ATTRIBUTES):
6865 decodeFunc = CRYPT_AsnDecodePKCSAttributes;
6866 break;
6867 case LOWORD(X509_ISSUING_DIST_POINT):
6868 decodeFunc = CRYPT_AsnDecodeIssuingDistPoint;
6869 break;
6870 case LOWORD(X509_NAME_CONSTRAINTS):
6871 decodeFunc = CRYPT_AsnDecodeNameConstraints;
6872 break;
6873 case LOWORD(X509_POLICY_MAPPINGS):
6874 decodeFunc = CRYPT_AsnDecodeCertPolicyMappings;
6875 break;
6876 case LOWORD(X509_POLICY_CONSTRAINTS):
6877 decodeFunc = CRYPT_AsnDecodeCertPolicyConstraints;
6878 break;
6879 case LOWORD(PKCS7_SIGNER_INFO):
6880 decodeFunc = CRYPT_AsnDecodePKCSSignerInfo;
6881 break;
6882 case LOWORD(CMS_SIGNER_INFO):
6883 decodeFunc = CRYPT_AsnDecodeCMSSignerInfo;
6884 break;
6885 case LOWORD(X509_OBJECT_IDENTIFIER):
6886 decodeFunc = CRYPT_AsnDecodeObjectIdentifier;
6887 break;
6888 case LOWORD(X509_ECC_SIGNATURE):
6889 decodeFunc = CRYPT_AsnDecodeEccSignature;
6890 break;
6891 case LOWORD(CNG_RSA_PUBLIC_KEY_BLOB):
6892 decodeFunc = CRYPT_AsnDecodeRsaPubKey_Bcrypt;
6893 break;
6894 case LOWORD(OCSP_RESPONSE):
6895 decodeFunc = CRYPT_AsnDecodeOCSPResponse;
6896 break;
6897 case LOWORD(OCSP_BASIC_SIGNED_RESPONSE):
6898 decodeFunc = CRYPT_AsnDecodeOCSPBasicSignedResponse;
6899 break;
6900 case LOWORD(OCSP_BASIC_RESPONSE):
6901 decodeFunc = CRYPT_AsnDecodeOCSPBasicResponse;
6902 break;
6903 default:
6904 break;
6905 }
6906 }
6907 else if (!strcmp(lpszStructType, szOID_CERT_EXTENSIONS))
6908 decodeFunc = CRYPT_AsnDecodeExtensions;
6909 else if (!strcmp(lpszStructType, szOID_RSA_signingTime))
6910 decodeFunc = CRYPT_AsnDecodeUtcTime;
6911 else if (!strcmp(lpszStructType, szOID_RSA_SMIMECapabilities))
6912 decodeFunc = CRYPT_AsnDecodeSMIMECapabilities;
6913 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER))
6914 decodeFunc = CRYPT_AsnDecodeAuthorityKeyId;
6915 else if (!strcmp(lpszStructType, szOID_LEGACY_POLICY_MAPPINGS))
6916 decodeFunc = CRYPT_AsnDecodeCertPolicyMappings;
6917 else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2))
6918 decodeFunc = CRYPT_AsnDecodeAuthorityKeyId2;
6919 else if (!strcmp(lpszStructType, szOID_CRL_REASON_CODE))
6920 decodeFunc = CRYPT_AsnDecodeEnumerated;
6921 else if (!strcmp(lpszStructType, szOID_KEY_USAGE))
6922 decodeFunc = CRYPT_AsnDecodeBits;
6923 else if (!strcmp(lpszStructType, szOID_SUBJECT_KEY_IDENTIFIER))
6924 decodeFunc = CRYPT_AsnDecodeOctetString;
6925 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS))
6926 decodeFunc = CRYPT_AsnDecodeBasicConstraints;
6927 else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2))
6928 decodeFunc = CRYPT_AsnDecodeBasicConstraints2;
6929 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME))
6930 decodeFunc = CRYPT_AsnDecodeAltName;
6931 else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2))
6932 decodeFunc = CRYPT_AsnDecodeAltName;
6933 else if (!strcmp(lpszStructType, szOID_NEXT_UPDATE_LOCATION))
6934 decodeFunc = CRYPT_AsnDecodeAltName;
6935 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME))
6936 decodeFunc = CRYPT_AsnDecodeAltName;
6937 else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2))
6938 decodeFunc = CRYPT_AsnDecodeAltName;
6939 else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS))
6940 decodeFunc = CRYPT_AsnDecodeCRLDistPoints;
6941 else if (!strcmp(lpszStructType, szOID_CERT_POLICIES))
6942 decodeFunc = CRYPT_AsnDecodeCertPolicies;
6943 else if (!strcmp(lpszStructType, szOID_POLICY_MAPPINGS))
6944 decodeFunc = CRYPT_AsnDecodeCertPolicyMappings;
6945 else if (!strcmp(lpszStructType, szOID_POLICY_CONSTRAINTS))
6946 decodeFunc = CRYPT_AsnDecodeCertPolicyConstraints;
6947 else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE))
6948 decodeFunc = CRYPT_AsnDecodeEnhancedKeyUsage;
6949 else if (!strcmp(lpszStructType, szOID_ISSUING_DIST_POINT))
6950 decodeFunc = CRYPT_AsnDecodeIssuingDistPoint;
6951 else if (!strcmp(lpszStructType, szOID_NAME_CONSTRAINTS))
6952 decodeFunc = CRYPT_AsnDecodeNameConstraints;
6953 else if (!strcmp(lpszStructType, szOID_AUTHORITY_INFO_ACCESS))
6954 decodeFunc = CRYPT_AsnDecodeAuthorityInfoAccess;
6955 else if (!strcmp(lpszStructType, szOID_PKIX_POLICY_QUALIFIER_USERNOTICE))
6956 decodeFunc = CRYPT_AsnDecodePolicyQualifierUserNotice;
6957 else if (!strcmp(lpszStructType, szOID_CTL))
6958 decodeFunc = CRYPT_AsnDecodeCTL;
6959 else if (!strcmp(lpszStructType, szOID_ECC_PUBLIC_KEY))
6960 decodeFunc = CRYPT_AsnDecodeObjectIdentifier;
6961 return decodeFunc;
6962}
CRYPT_AsnDecodeInt
static BOOL WINAPI CRYPT_AsnDecodeInt(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:4521
CRYPT_AsnDecodeAuthorityInfoAccess
static BOOL WINAPI CRYPT_AsnDecodeAuthorityInfoAccess(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3226
CRYPT_AsnDecodeBasicConstraints
static BOOL WINAPI CRYPT_AsnDecodeBasicConstraints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3516
CRYPT_AsnDecodePubKeyInfo
static BOOL WINAPI CRYPT_AsnDecodePubKeyInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:2907
CRYPT_AsnDecodeOCSPBasicResponse
static BOOL WINAPI CRYPT_AsnDecodeOCSPBasicResponse(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6711
CRYPT_AsnDecodeInteger
static BOOL WINAPI CRYPT_AsnDecodeInteger(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:4614
CRYPT_AsnDecodePKCSSignerInfo
static BOOL WINAPI CRYPT_AsnDecodePKCSSignerInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:5689
CRYPT_AsnDecodeRsaPubKey_Bcrypt
static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey_Bcrypt(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3913
CRYPT_AsnDecodeCertPolicyConstraints
static BOOL WINAPI CRYPT_AsnDecodeCertPolicyConstraints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3833
CRYPT_AsnDecodePKCSAttribute
static BOOL WINAPI CRYPT_AsnDecodePKCSAttribute(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:2763
CRYPT_AsnDecodePolicyQualifierUserNotice
static BOOL WINAPI CRYPT_AsnDecodePolicyQualifierUserNotice(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:2668
CRYPT_AsnDecodeExtensions
static BOOL WINAPI CRYPT_AsnDecodeExtensions(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:1456
CRYPT_AsnDecodeIssuingDistPoint
static BOOL WINAPI CRYPT_AsnDecodeIssuingDistPoint(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:5411
CRYPT_AsnDecodeSequenceOfAny
static BOOL WINAPI CRYPT_AsnDecodeSequenceOfAny(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:5147
CRYPT_AsnDecodeNameConstraints
static BOOL WINAPI CRYPT_AsnDecodeNameConstraints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:5580
CRYPT_AsnDecodeUnicodeName
static BOOL WINAPI CRYPT_AsnDecodeUnicodeName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:2006
CRYPT_AsnDecodeRsaPubKey
static BOOL WINAPI CRYPT_AsnDecodeRsaPubKey(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3976
CRYPT_AsnDecodeAltName
static BOOL WINAPI CRYPT_AsnDecodeAltName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3405
CRYPT_AsnDecodeOCSPResponse
static BOOL WINAPI CRYPT_AsnDecodeOCSPResponse(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6223
CRYPT_AsnDecodeSMIMECapabilities
static BOOL WINAPI CRYPT_AsnDecodeSMIMECapabilities(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:2347
CRYPT_AsnDecodePKCSContentInfo
static BOOL WINAPI CRYPT_AsnDecodePKCSContentInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3336
CRYPT_AsnDecodeRsaPrivKey
static BOOL WINAPI CRYPT_AsnDecodeRsaPrivKey(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:4050
CRYPT_AsnDecodeAuthorityKeyId2
static BOOL WINAPI CRYPT_AsnDecodeAuthorityKeyId2(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3170
CRYPT_AsnDecodePKCSAttributes
static BOOL WINAPI CRYPT_AsnDecodePKCSAttributes(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:2825
CRYPT_AsnDecodeUtcTime
static BOOL WINAPI CRYPT_AsnDecodeUtcTime(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:4978
CRYPT_AsnDecodeEnumerated
static BOOL WINAPI CRYPT_AsnDecodeEnumerated(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:4764
CRYPT_AsnDecodeName
static BOOL WINAPI CRYPT_AsnDecodeName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:1909
CRYPT_AsnDecodeOctetString
static BOOL WINAPI CRYPT_AsnDecodeOctetString(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:4319
CryptDecodeObjectExFunc
BOOL(WINAPI * CryptDecodeObjectExFunc)(DWORD, LPCSTR, const BYTE *, DWORD, DWORD, PCRYPT_DECODE_PARA, void *, DWORD *)
Definition: decode.c:66
CRYPT_AsnDecodeUnicodeNameValue
static BOOL WINAPI CRYPT_AsnDecodeUnicodeNameValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:1823
CRYPT_AsnDecodeCertPolicies
static BOOL WINAPI CRYPT_AsnDecodeCertPolicies(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3650
CRYPT_AsnDecodeCRL
static BOOL WINAPI CRYPT_AsnDecodeCRL(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:1257
CRYPT_AsnDecodeObjectIdentifier
static BOOL WINAPI CRYPT_AsnDecodeObjectIdentifier(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6093
CRYPT_AsnDecodeNameValue
static BOOL WINAPI CRYPT_AsnDecodeNameValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:1640
CRYPT_AsnDecodeChoiceOfTime
static BOOL WINAPI CRYPT_AsnDecodeChoiceOfTime(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:5109
CRYPT_AsnDecodeUnsignedInteger
static BOOL WINAPI CRYPT_AsnDecodeUnsignedInteger(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:4722
CRYPT_AsnDecodeEccSignature
static BOOL WINAPI CRYPT_AsnDecodeEccSignature(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6133
CRYPT_AsnDecodeOCSPBasicSignedResponse
static BOOL WINAPI CRYPT_AsnDecodeOCSPBasicSignedResponse(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, CRYPT_DECODE_PARA *pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6280
CRYPT_AsnDecodeCRLDistPoints
static BOOL WINAPI CRYPT_AsnDecodeCRLDistPoints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:5346
CRYPT_AsnDecodeAuthorityKeyId
static BOOL WINAPI CRYPT_AsnDecodeAuthorityKeyId(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3135
CRYPT_AsnDecodeEnhancedKeyUsage
static BOOL WINAPI CRYPT_AsnDecodeEnhancedKeyUsage(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:5379
CRYPT_AsnDecodeBits
static BOOL WINAPI CRYPT_AsnDecodeBits(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:4424
CRYPT_AsnDecodeCMSSignerInfo
static BOOL WINAPI CRYPT_AsnDecodeCMSSignerInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:5874
CRYPT_AsnDecodeCert
static BOOL WINAPI CRYPT_AsnDecodeCert(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:1060
CRYPT_AsnDecodeCertPolicyMappings
static BOOL WINAPI CRYPT_AsnDecodeCertPolicyMappings(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3707
CRYPT_AsnDecodeCTL
static BOOL WINAPI CRYPT_AsnDecodeCTL(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:2269
CRYPT_AsnDecodeBasicConstraints2
static BOOL WINAPI CRYPT_AsnDecodeBasicConstraints2(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:3551
IS_INTOID
#define IS_INTOID(x)
Definition: crypt32_private.h:464
strcmp
_ACRTIMP int __cdecl strcmp(const char *, const char *)
Definition: string.c:3324
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
LOWORD
#define LOWORD(l)
Definition: pedump.c:82
X509_OBJECT_IDENTIFIER
#define X509_OBJECT_IDENTIFIER
Definition: wincrypt.h:3593
X509_ISSUING_DIST_POINT
#define X509_ISSUING_DIST_POINT
Definition: wincrypt.h:3576
X509_AUTHORITY_KEY_ID2
#define X509_AUTHORITY_KEY_ID2
Definition: wincrypt.h:3550
szOID_AUTHORITY_KEY_IDENTIFIER
#define szOID_AUTHORITY_KEY_IDENTIFIER
Definition: wincrypt.h:3331
CERT_ENCODING_TYPE_MASK
#define CERT_ENCODING_TYPE_MASK
Definition: wincrypt.h:2494
PKCS_UTC_TIME
#define PKCS_UTC_TIME
Definition: wincrypt.h:3534
szOID_RSA_SMIMECapabilities
#define szOID_RSA_SMIMECapabilities
Definition: wincrypt.h:3198
szOID_CERT_EXTENSIONS
#define szOID_CERT_EXTENSIONS
Definition: wincrypt.h:3364
X509_POLICY_MAPPINGS
#define X509_POLICY_MAPPINGS
Definition: wincrypt.h:3578
X509_NAME
#define X509_NAME
Definition: wincrypt.h:3524
X509_UNICODE_NAME
#define X509_UNICODE_NAME
Definition: wincrypt.h:3537
szOID_POLICY_MAPPINGS
#define szOID_POLICY_MAPPINGS
Definition: wincrypt.h:3355
X509_MULTI_BYTE_UINT
#define X509_MULTI_BYTE_UINT
Definition: wincrypt.h:3557
PKCS_ATTRIBUTE
#define PKCS_ATTRIBUTE
Definition: wincrypt.h:3539
szOID_CRL_DIST_POINTS
#define szOID_CRL_DIST_POINTS
Definition: wincrypt.h:3352
X509_OCTET_STRING
#define X509_OCTET_STRING
Definition: wincrypt.h:3543
szOID_BASIC_CONSTRAINTS2
#define szOID_BASIC_CONSTRAINTS2
Definition: wincrypt.h:3345
X509_MULTI_BYTE_INTEGER
#define X509_MULTI_BYTE_INTEGER
Definition: wincrypt.h:3546
szOID_LEGACY_POLICY_MAPPINGS
#define szOID_LEGACY_POLICY_MAPPINGS
Definition: wincrypt.h:3335
X509_AUTHORITY_INFO_ACCESS
#define X509_AUTHORITY_INFO_ACCESS
Definition: wincrypt.h:3551
OCSP_BASIC_RESPONSE
#define OCSP_BASIC_RESPONSE
Definition: wincrypt.h:3591
szOID_NAME_CONSTRAINTS
#define szOID_NAME_CONSTRAINTS
Definition: wincrypt.h:3351
X509_ENUMERATED
#define X509_ENUMERATED
Definition: wincrypt.h:3547
CMSG_ENCODING_TYPE_MASK
#define CMSG_ENCODING_TYPE_MASK
Definition: wincrypt.h:2495
szOID_ISSUER_ALT_NAME2
#define szOID_ISSUER_ALT_NAME2
Definition: wincrypt.h:3344
X509_INTEGER
#define X509_INTEGER
Definition: wincrypt.h:3545
PKCS_CONTENT_INFO
#define PKCS_CONTENT_INFO
Definition: wincrypt.h:3552
OCSP_BASIC_SIGNED_RESPONSE
#define OCSP_BASIC_SIGNED_RESPONSE
Definition: wincrypt.h:3590
szOID_KEY_USAGE
#define szOID_KEY_USAGE
Definition: wincrypt.h:3341
CNG_RSA_PUBLIC_KEY_BLOB
#define CNG_RSA_PUBLIC_KEY_BLOB
Definition: wincrypt.h:3592
X509_NAME_VALUE
#define X509_NAME_VALUE
Definition: wincrypt.h:3522
szOID_ECC_PUBLIC_KEY
#define szOID_ECC_PUBLIC_KEY
Definition: wincrypt.h:3216
X509_EXTENSIONS
#define X509_EXTENSIONS
Definition: wincrypt.h:3521
X509_ASN_ENCODING
#define X509_ASN_ENCODING
Definition: wincrypt.h:2501
X509_CHOICE_OF_TIME
#define X509_CHOICE_OF_TIME
Definition: wincrypt.h:3549
szOID_BASIC_CONSTRAINTS
#define szOID_BASIC_CONSTRAINTS
Definition: wincrypt.h:3339
X509_ECC_SIGNATURE
#define X509_ECC_SIGNATURE
Definition: wincrypt.h:3569
szOID_SUBJECT_KEY_IDENTIFIER
#define szOID_SUBJECT_KEY_IDENTIFIER
Definition: wincrypt.h:3340
X509_AUTHORITY_KEY_ID
#define X509_AUTHORITY_KEY_ID
Definition: wincrypt.h:3526
szOID_CRL_REASON_CODE
#define szOID_CRL_REASON_CODE
Definition: wincrypt.h:3347
X509_CERT_POLICIES
#define X509_CERT_POLICIES
Definition: wincrypt.h:3533
RSA_CSP_PUBLICKEYBLOB
#define RSA_CSP_PUBLICKEYBLOB
Definition: wincrypt.h:3536
szOID_RSA_signingTime
#define szOID_RSA_signingTime
Definition: wincrypt.h:3192
X509_SEQUENCE_OF_ANY
#define X509_SEQUENCE_OF_ANY
Definition: wincrypt.h:3553
szOID_SUBJECT_ALT_NAME
#define szOID_SUBJECT_ALT_NAME
Definition: wincrypt.h:3336
szOID_CERT_POLICIES
#define szOID_CERT_POLICIES
Definition: wincrypt.h:3353
PKCS7_SIGNER_INFO
#define PKCS7_SIGNER_INFO
Definition: wincrypt.h:3594
X509_BITS
#define X509_BITS
Definition: wincrypt.h:3544
szOID_ENHANCED_KEY_USAGE
#define szOID_ENHANCED_KEY_USAGE
Definition: wincrypt.h:3358
szOID_SUBJECT_ALT_NAME2
#define szOID_SUBJECT_ALT_NAME2
Definition: wincrypt.h:3343
PKCS_RSA_PRIVATE_KEY
#define PKCS_RSA_PRIVATE_KEY
Definition: wincrypt.h:3563
X509_BASIC_CONSTRAINTS2
#define X509_BASIC_CONSTRAINTS2
Definition: wincrypt.h:3532
PKCS_SMIME_CAPABILITIES
#define PKCS_SMIME_CAPABILITIES
Definition: wincrypt.h:3562
CMS_SIGNER_INFO
#define CMS_SIGNER_INFO
Definition: wincrypt.h:3595
szOID_PKIX_POLICY_QUALIFIER_USERNOTICE
#define szOID_PKIX_POLICY_QUALIFIER_USERNOTICE
Definition: wincrypt.h:3448
szOID_NEXT_UPDATE_LOCATION
#define szOID_NEXT_UPDATE_LOCATION
Definition: wincrypt.h:3365
X509_PUBLIC_KEY_INFO
#define X509_PUBLIC_KEY_INFO
Definition: wincrypt.h:3525
szOID_AUTHORITY_INFO_ACCESS
#define szOID_AUTHORITY_INFO_ACCESS
Definition: wincrypt.h:3446
szOID_CTL
#define szOID_CTL
Definition: wincrypt.h:3401
X509_ALTERNATE_NAME
#define X509_ALTERNATE_NAME
Definition: wincrypt.h:3529
szOID_AUTHORITY_KEY_IDENTIFIER2
#define szOID_AUTHORITY_KEY_IDENTIFIER2
Definition: wincrypt.h:3356
PKCS_7_ASN_ENCODING
#define PKCS_7_ASN_ENCODING
Definition: wincrypt.h:2503
PKCS_ATTRIBUTES
#define PKCS_ATTRIBUTES
Definition: wincrypt.h:3570
X509_NAME_CONSTRAINTS
#define X509_NAME_CONSTRAINTS
Definition: wincrypt.h:3577
szOID_POLICY_CONSTRAINTS
#define szOID_POLICY_CONSTRAINTS
Definition: wincrypt.h:3357
szOID_ISSUING_DIST_POINT
#define szOID_ISSUING_DIST_POINT
Definition: wincrypt.h:3350
PKCS_CTL
#define PKCS_CTL
Definition: wincrypt.h:3556
X509_CRL_DIST_POINTS
#define X509_CRL_DIST_POINTS
Definition: wincrypt.h:3554
X509_BASIC_CONSTRAINTS
#define X509_BASIC_CONSTRAINTS
Definition: wincrypt.h:3530
X509_ENHANCED_KEY_USAGE
#define X509_ENHANCED_KEY_USAGE
Definition: wincrypt.h:3555
X509_PKIX_POLICY_QUALIFIER_USERNOTICE
#define X509_PKIX_POLICY_QUALIFIER_USERNOTICE
Definition: wincrypt.h:3566
szOID_ISSUER_ALT_NAME
#define szOID_ISSUER_ALT_NAME
Definition: wincrypt.h:3337
X509_KEY_USAGE
#define X509_KEY_USAGE
Definition: wincrypt.h:3531
X509_POLICY_CONSTRAINTS
#define X509_POLICY_CONSTRAINTS
Definition: wincrypt.h:3579
X509_UNICODE_NAME_VALUE
#define X509_UNICODE_NAME_VALUE
Definition: wincrypt.h:3541
OCSP_RESPONSE
#define OCSP_RESPONSE
Definition: wincrypt.h:3589

Referenced by CryptDecodeObjectEx().

◆ CRYPT_GetLen()

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

Definition at line 192 of file decode.c.

193{
194 BOOL ret;
195
196 if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, len)) &&
197 *len == CMSG_INDEFINITE_LENGTH)
198 {
199 SetLastError(CRYPT_E_ASN1_CORRUPT);
200 ret = FALSE;
201 }
202 return ret;
203}

Referenced by CRYPT_AsnDecodeAltNameEntry(), CRYPT_AsnDecodeBitsInternal(), CRYPT_AsnDecodeCertExtensions(), CRYPT_AsnDecodeCertStatus(), CRYPT_AsnDecodeCertVersion(), CRYPT_AsnDecodeCRLExtensions(), CRYPT_AsnDecodeCTLExtensions(), CRYPT_AsnDecodeDerBlob(), CRYPT_AsnDecodeDistPointName(), CRYPT_AsnDecodeIA5String(), CRYPT_AsnDecodeIntegerInternal(), CRYPT_AsnDecodeIntInternal(), CRYPT_AsnDecodeNameValueInternal(), CRYPT_AsnDecodeOCSPHashAlgorithm(), CRYPT_AsnDecodeOCSPNextUpdate(), CRYPT_AsnDecodeOCSPResponseBytes(), CRYPT_AsnDecodeOCSPSignatureInfoCertEncoded(), CRYPT_AsnDecodeOctets(), CRYPT_AsnDecodeOctetStringInternal(), CRYPT_AsnDecodeOidIgnoreTag(), CRYPT_AsnDecodeResponderIDByKey(), CRYPT_AsnDecodeResponderIDByName(), CRYPT_AsnDecodeSequenceOfAny(), CRYPT_AsnDecodeUnicodeNameValueInternal(), CRYPT_AsnDecodeUnicodeString(), and CRYPT_AsnDecodeUnsignedIntegerInternal().

◆ CRYPT_GetLengthIndefinite()

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

Definition at line 124 of file decode.c.

126{
127 BOOL ret;
128
129 if (cbEncoded <= 1)
130 {
131 SetLastError(CRYPT_E_ASN1_CORRUPT);
132 ret = FALSE;
133 }
134 else if (pbEncoded[1] <= 0x7f)
135 {
136 if (pbEncoded[1] + 1 > cbEncoded)
137 {
138 SetLastError(CRYPT_E_ASN1_EOD);
139 ret = FALSE;
140 }
141 else
142 {
143 *len = pbEncoded[1];
144 ret = TRUE;
145 }
146 }
147 else if (pbEncoded[1] == 0x80)
148 {
149 *len = CMSG_INDEFINITE_LENGTH;
150 ret = TRUE;
151 }
152 else
153 {
154 BYTE lenLen = GET_LEN_BYTES(pbEncoded[1]);
155
156 if (lenLen > sizeof(DWORD) + 1)
157 {
158 SetLastError(CRYPT_E_ASN1_LARGE);
159 ret = FALSE;
160 }
161 else if (lenLen + 2 > cbEncoded)
162 {
163 SetLastError(CRYPT_E_ASN1_CORRUPT);
164 ret = FALSE;
165 }
166 else
167 {
168 DWORD out = 0;
169
170 pbEncoded += 2;
171 while (--lenLen)
172 {
173 out <<= 8;
174 out |= *pbEncoded++;
175 }
176 if (out + lenLen + 1 > cbEncoded)
177 {
178 SetLastError(CRYPT_E_ASN1_EOD);
179 ret = FALSE;
180 }
181 else
182 {
183 *len = out;
184 ret = TRUE;
185 }
186 }
187 }
188 return ret;
189}
out
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383

Referenced by CRYPT_AsnDecodeArray(), CRYPT_AsnDecodeOctetStringInternal(), CRYPT_AsnDecodePKCSContent(), CRYPT_AsnDecodeSequence(), CRYPT_AsnDecodeSequenceItems(), CRYPT_FindEncodedLen(), CRYPT_GetLen(), and PFXIsPFXBlob().

◆ CRYPT_LoadDecoderExFunc()

static CryptDecodeObjectExFunc CRYPT_LoadDecoderExFunc ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
HCRYPTOIDFUNCADDR *  hFunc 
)
static

Definition at line 6977 of file decode.c.

6979{
6980 static HCRYPTOIDFUNCSET set = NULL;
6981 CryptDecodeObjectExFunc decodeFunc = NULL;
6982
6983 if (!set)
6984 set = CryptInitOIDFunctionSet(CRYPT_OID_DECODE_OBJECT_EX_FUNC, 0);
6985 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
6986 (void **)&decodeFunc, hFunc);
6987 return decodeFunc;
6988}
set
Definition: _set.h:50
CryptInitOIDFunctionSet
HCRYPTOIDFUNCSET WINAPI CryptInitOIDFunctionSet(LPCSTR pszFuncName, DWORD dwFlags)
Definition: oid.c:103
CryptGetOIDFunctionAddress
BOOL WINAPI CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet, DWORD dwEncodingType, LPCSTR pszOID, DWORD dwFlags, void **ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr)
Definition: oid.c:375
CRYPT_OID_DECODE_OBJECT_EX_FUNC
#define CRYPT_OID_DECODE_OBJECT_EX_FUNC
Definition: wincrypt.h:2664

Referenced by CryptDecodeObjectEx().

◆ CRYPT_LoadDecoderFunc()

static CryptDecodeObjectFunc CRYPT_LoadDecoderFunc ( DWORD  dwCertEncodingType,
LPCSTR  lpszStructType,
HCRYPTOIDFUNCADDR *  hFunc 
)
static

Definition at line 6964 of file decode.c.

6966{
6967 static HCRYPTOIDFUNCSET set = NULL;
6968 CryptDecodeObjectFunc decodeFunc = NULL;
6969
6970 if (!set)
6971 set = CryptInitOIDFunctionSet(CRYPT_OID_DECODE_OBJECT_FUNC, 0);
6972 CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0,
6973 (void **)&decodeFunc, hFunc);
6974 return decodeFunc;
6975}
CryptDecodeObjectFunc
BOOL(WINAPI * CryptDecodeObjectFunc)(DWORD, LPCSTR, const BYTE *, DWORD, DWORD, void *, DWORD *)
Definition: decode.c:64
CRYPT_OID_DECODE_OBJECT_FUNC
#define CRYPT_OID_DECODE_OBJECT_FUNC
Definition: wincrypt.h:2662

Referenced by CryptDecodeObjectEx().

◆ CRYPT_raw_decode_rsa_pub_key()

static BOOL CRYPT_raw_decode_rsa_pub_key ( struct DECODED_RSA_PUB_KEY **  decodedKey,
DWORD *  size,
const BYTE *  pbEncoded,
DWORD  cbEncoded 
)
static

Definition at line 3882 of file decode.c.

3884{
3885 BOOL ret;
3886
3887 struct AsnDecodeSequenceItem items[] = {
3888 { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, modulus),
3889 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
3890 FALSE, TRUE, offsetof(struct DECODED_RSA_PUB_KEY, modulus.pbData),
3891 0 },
3892 { ASN_INTEGER, offsetof(struct DECODED_RSA_PUB_KEY, pubexp),
3893 CRYPT_AsnDecodeUnsignedIntegerInternal, sizeof(CRYPT_INTEGER_BLOB),
3894 FALSE, TRUE, offsetof(struct DECODED_RSA_PUB_KEY, pubexp.pbData),
3895 0 },
3896 };
3897
3898 ret = CRYPT_AsnDecodeSequence(items, ARRAY_SIZE(items),
3899 pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, decodedKey,
3900 size, NULL, NULL);
3901
3902 if (ret && (*decodedKey)->pubexp.cbData > sizeof(DWORD))
3903 {
3904 WARN("Unexpected exponent length %lu.\n", (*decodedKey)->pubexp.cbData);
3905 LocalFree(*decodedKey);
3906 SetLastError(CRYPT_E_ASN1_LARGE);
3907 ret = FALSE;
3908 }
3909
3910 return ret;
3911}

Referenced by CRYPT_AsnDecodeRsaPubKey(), and CRYPT_AsnDecodeRsaPubKey_Bcrypt().

◆ CryptDecodeObject()

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

Definition at line 6990 of file decode.c.

6993{
6994 return CryptDecodeObjectEx(dwCertEncodingType, lpszStructType,
6995 pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo);
6996}
CryptDecodeObjectEx
BOOL WINAPI CryptDecodeObjectEx(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, PCRYPT_DECODE_PARA pDecodePara, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6998

Referenced by CertComparePublicKeyInfo(), CRYPT_ImportPublicKeyInfoEx(), CryptCATEnumerateMember(), decode_inner_content(), and SOFTPUB_DecodeInnerContent().

◆ CryptDecodeObjectEx()

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

Definition at line 6998 of file decode.c.

7001{
7002 BOOL ret = FALSE;
7003 CryptDecodeObjectExFunc decodeFunc;
7004 HCRYPTOIDFUNCADDR hFunc = NULL;
7005
7006 TRACE_(crypt)("(0x%08lx, %s, %p, %ld, 0x%08lx, %p, %p, %p)\n",
7007 dwCertEncodingType, debugstr_a(lpszStructType), pbEncoded,
7008 cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);
7009
7010 if (!pvStructInfo && !pcbStructInfo)
7011 {
7012 SetLastError(ERROR_INVALID_PARAMETER);
7013 return FALSE;
7014 }
7015 if (cbEncoded > MAX_ENCODED_LEN)
7016 {
7017 FIXME_(crypt)("Returning CRYPT_E_ASN1_LARGE, cbEncoded %lu.\n", cbEncoded);
7018 SetLastError(CRYPT_E_ASN1_LARGE);
7019 return FALSE;
7020 }
7021
7022 SetLastError(NOERROR);
7023 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
7024 {
7025 if (!pvStructInfo)
7026 {
7027 SetLastError(ERROR_INVALID_PARAMETER);
7028 return FALSE;
7029 }
7030 *(BYTE **)pvStructInfo = NULL;
7031 }
7032 decodeFunc = CRYPT_GetBuiltinDecoder(dwCertEncodingType, lpszStructType);
7033 if (!decodeFunc)
7034 {
7035 TRACE_(crypt)("OID %s not found or unimplemented, looking for DLL\n",
7036 debugstr_a(lpszStructType));
7037 decodeFunc = CRYPT_LoadDecoderExFunc(dwCertEncodingType, lpszStructType,
7038 &hFunc);
7039 if (!decodeFunc)
7040 {
7041 if (IS_INTOID(lpszStructType))
7042 FIXME("Unimplemented decoder for lpszStructType OID %d\n", LOWORD(lpszStructType));
7043 else
7044 FIXME("Unsupported decoder for lpszStructType %s\n", lpszStructType);
7045 }
7046 }
7047 if (decodeFunc)
7048 ret = decodeFunc(dwCertEncodingType, lpszStructType, pbEncoded,
7049 cbEncoded, dwFlags, pDecodePara, pvStructInfo, pcbStructInfo);
7050 else
7051 {
7052 CryptDecodeObjectFunc pCryptDecodeObject =
7053 CRYPT_LoadDecoderFunc(dwCertEncodingType, lpszStructType, &hFunc);
7054
7055 /* Try CryptDecodeObject function. Don't call CryptDecodeObject
7056 * directly, as that could cause an infinite loop.
7057 */
7058 if (pCryptDecodeObject)
7059 {
7060 if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
7061 {
7062 ret = pCryptDecodeObject(dwCertEncodingType, lpszStructType,
7063 pbEncoded, cbEncoded, dwFlags, NULL, pcbStructInfo);
7064 if (ret && (ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
7065 pvStructInfo, pcbStructInfo, *pcbStructInfo)))
7066 {
7067 ret = pCryptDecodeObject(dwCertEncodingType,
7068 lpszStructType, pbEncoded, cbEncoded, dwFlags,
7069 *(BYTE **)pvStructInfo, pcbStructInfo);
7070 if (!ret)
7071 CRYPT_FreeSpace(pDecodePara, *(BYTE **)pvStructInfo);
7072 }
7073 }
7074 else
7075 ret = pCryptDecodeObject(dwCertEncodingType, lpszStructType,
7076 pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo);
7077 }
7078 }
7079 if (hFunc)
7080 CryptFreeOIDFunctionAddress(hFunc, 0);
7081 TRACE_(crypt)("returning %d\n", ret);
7082 return ret;
7083}
MAX_ENCODED_LEN
#define MAX_ENCODED_LEN
Definition: decode.c:48
CRYPT_LoadDecoderExFunc
static CryptDecodeObjectExFunc CRYPT_LoadDecoderExFunc(DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
Definition: decode.c:6977
CRYPT_GetBuiltinDecoder
static CryptDecodeObjectExFunc CRYPT_GetBuiltinDecoder(DWORD dwCertEncodingType, LPCSTR lpszStructType)
Definition: decode.c:6746
CRYPT_LoadDecoderFunc
static CryptDecodeObjectFunc CRYPT_LoadDecoderFunc(DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
Definition: decode.c:6964
CryptFreeOIDFunctionAddress
BOOL WINAPI CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr, DWORD dwFlags)
Definition: oid.c:456
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
FIXME_
#define FIXME_(x)
Definition: compat.h:77
TRACE_
#define TRACE_(x)
Definition: compat.h:76

Referenced by CDecodeMsg_DecodeContent(), CDecodeMsg_DecodeDataContent(), CDecodeMsg_FinalizeSignedContent(), CDecodeSignedMsg_GetParam(), Cert_clone(), cert_get_alt_name_info(), cert_get_name_from_rdn_attr(), cert_name_to_str_with_indent(), CertContext_GetProperty(), CertCreateCertificateContext(), CertCreateCRLContext(), CertCreateCTLContext(), CertGetEnhancedKeyUsage(), CertGetIntendedKeyUsage(), CertGetNameStringW(), CertGetPublicKeyLength(), CertIsRDNAttrsInCertificateName(), CertIsValidCRLForCertificate(), check_ocsp_response_info(), CNG_ImportECCPubKey(), CNG_ImportRSAPubKey(), CNG_PrepareSignatureECC(), compare_alt_name_with_constraints(), compare_crl_issued_by(), compare_subject_with_email_constraints(), CRYPT_CheckUsages(), CRYPT_DecodeBasicConstraints(), CRYPT_FormatAltName(), CRYPT_FormatAuthorityInfoAccess(), CRYPT_FormatAuthorityKeyId2(), CRYPT_FormatBasicConstraints2(), CRYPT_FormatCPS(), CRYPT_FormatCRLDistPoints(), CRYPT_FormatEnhancedKeyUsage(), CRYPT_FormatKeyUsage(), CRYPT_FormatNetscapeCertType(), CRYPT_FormatSpcFinancialCriteria(), CRYPT_FormatUnicodeString(), CRYPT_FormatUserNotice(), CRYPT_GetIssuer(), CRYPT_GetNameConstraints(), CRYPT_GetPolicies(), CRYPT_GetUrlFromCertificateIssuer(), CRYPT_GetUrlFromCRLDistPointsExt(), CRYPT_IsCertificateSelfSigned(), CRYPT_KeyUsageValid(), CryptDecodeObject(), CryptHashToBeSigned(), CryptVerifyCertificateSignatureEx(), directory_name_matches(), display_app_usages(), dump_alt_name(), dump_basic_constraints(), dump_basic_constraints2(), dump_cert_policies(), dump_enhanced_key_usage(), dump_key_usage(), dump_name_constraints(), dump_netscape_cert_type(), find_cert_by_issuer(), FormatVerisignExtension(), get_cert_common_name(), get_cps_str_from_qualifier(), get_user_notice_from_qualifier(), handle_ocsp_response(), is_ca_cert(), match_dns_to_subject_alt_name(), match_dns_to_subject_dn(), set_issuer_statement(), test_decodeAltName(), test_decodeAuthorityInfoAccess(), test_decodeAuthorityKeyId(), test_decodeAuthorityKeyId2(), test_decodeBasicConstraints(), test_decodeBits(), test_decodeCert(), test_decodeCertPolicies(), test_decodeCertPolicyConstraints(), test_decodeCertPolicyMappings(), test_decodeCertToBeSigned(), test_decodeCMSSignerInfo(), test_decodeCRLDistPoints(), test_decodeCRLIssuingDistPoint(), test_decodeCRLToBeSigned(), test_decodeCTL(), test_decodeEnhancedKeyUsage(), test_decodeEnumerated(), test_decodeExtensions(), test_decodeFiletime(), test_decodeInt(), test_decodeName(), test_decodeNameConstraints(), test_decodeNameValue(), test_decodeOCSPBasicResponseInfo(), test_decodeOCSPBasicSignedResponseInfo(), test_decodeOCSPResponseInfo(), test_decodeOctets(), test_decodePKCSAttribute(), test_decodePKCSAttributes(), test_decodePKCSContentInfo(), test_decodePKCSSignerInfo(), test_decodePKCSSMimeCapabilities(), test_decodePolicyQualifierUserNotice(), test_decodePublicKeyInfo(), test_decodeRsaPrivateKey(), test_decodeRsaPublicKey(), test_decodeRsaPublicKey_Bcrypt(), test_decodeSequenceOfAny(), test_decodeUnicodeName(), test_decodeUnicodeNameValue(), test_VerifySignature(), testTimeDecoding(), TrustIsCertificateSelfSigned(), verify_cert_revocation(), verify_cert_revocation_from_aia_ext(), verify_signed_ocsp_response_info(), WINTRUST_GetTimeFromCounterSigner(), and WINTRUST_GetTimeFromSigner().

◆ PFXIsPFXBlob()

BOOL WINAPI PFXIsPFXBlob ( CRYPT_DATA_BLOB *  pPFX)

Definition at line 7085 of file decode.c.

7086{
7087 BOOL ret;
7088
7089 TRACE_(crypt)("(%p)\n", pPFX);
7090
7091 /* A PFX blob is an asn.1-encoded sequence, consisting of at least a
7092 * version integer of length 1 (3 encoded byes) and at least one other
7093 * datum (two encoded bytes), plus at least two bytes for the outer
7094 * sequence. Thus, even an empty PFX blob is at least 7 bytes in length.
7095 */
7096 if (pPFX->cbData < 7)
7097 ret = FALSE;
7098 else if (pPFX->pbData[0] == ASN_SEQUENCE)
7099 {
7100 DWORD len;
7101
7102 if ((ret = CRYPT_GetLengthIndefinite(pPFX->pbData, pPFX->cbData, &len)))
7103 {
7104 BYTE lenLen = GET_LEN_BYTES(pPFX->pbData[1]);
7105
7106 /* Need at least three bytes for the integer version */
7107 if (pPFX->cbData < 1 + lenLen + 3)
7108 ret = FALSE;
7109 else if (pPFX->pbData[1 + lenLen] != ASN_INTEGER || /* Tag */
7110 pPFX->pbData[1 + lenLen + 1] != 1 || /* Definite length */
7111 pPFX->pbData[1 + lenLen + 2] != 3) /* PFX version */
7112 ret = FALSE;
7113 }
7114 }
7115 else
7116 ret = FALSE;
7117 return ret;
7118}

Referenced by CRYPT_QueryPFXObject().

◆ verify_and_copy_certificate()

static BOOL verify_and_copy_certificate ( const BYTE *  pbEncoded,
DWORD  cbEncoded,
DWORD  dwFlags,
void *  pvStructInfo,
DWORD *  pcbStructInfo,
DWORD *  pcbDecoded 
)
static

Definition at line 5732 of file decode.c.

5734{
5735 PCCERT_CONTEXT cert;
5736
5737 cert = CertCreateCertificateContext(X509_ASN_ENCODING, pbEncoded, cbEncoded);
5738 if (!cert)
5739 {
5740 WARN("CertCreateCertificateContext error %#lx\n", GetLastError());
5741 *pcbStructInfo = 0;
5742 *pcbDecoded = 0;
5743 return TRUE;
5744 }
5745
5746 CertFreeCertificateContext(cert);
5747
5748 return CRYPT_AsnDecodeCopyBytes(pbEncoded, cbEncoded, dwFlags, pvStructInfo, pcbStructInfo, pcbDecoded);
5749}
CertFreeCertificateContext
BOOL WINAPI CertFreeCertificateContext(PCCERT_CONTEXT pCertContext)
Definition: cert.c:369
CertCreateCertificateContext
PCCERT_CONTEXT WINAPI CertCreateCertificateContext(DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded)
Definition: cert.c:314
cert
static BYTE cert[]
Definition: msg.c:1374
_CERT_CONTEXT
Definition: wincrypt.h:487

Referenced by CRYPT_AsnDecodeCMSCertEncoded(), and CRYPT_AsnDecodeOCSPSignatureInfoCertEncoded().

◆ WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL ( crypt  )

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( cryptasn  )