#include <assert.h>#include <stdarg.h>#include <stdio.h>#include <stdlib.h>#include "windef.h"#include "winbase.h"#include "wincrypt.h"#include "snmp.h"#include "wine/debug.h"#include "wine/exception.h"#include "crypt32_private.h"
Include dependency graph for encode.c:
Go to the source code of this file.
Classes | |
| struct | AsnEncodeTagSwappedItem |
| struct | DERSetDescriptor |
| struct | CTLEntries |
| struct | ocsp_request_list |
Typedefs | |
| typedef BOOL(WINAPI * | CryptEncodeObjectFunc) (DWORD, LPCSTR, const void *, BYTE *, DWORD *) |
| typedef BOOL(WINAPI * | EncodePublicKeyAndParametersFunc) (DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, BYTE *pbPubKey, DWORD cbPubKey, DWORD dwFlags, void *pvAuxInfo, BYTE **ppPublicKey, DWORD *pcbPublicKey, BYTE **ppbParams, DWORD *pcbParams) |
| typedef BOOL(WINAPI * | ExportPublicKeyInfoExFunc) (HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo) |
| typedef BOOL(WINAPI * | ConvertPublicKeyInfoFunc) (DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, BYTE **ppbData, DWORD *dwDataLen) |
| typedef BOOL(WINAPI * | ImportPublicKeyInfoExFunc) (HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey) |
Functions | |
| WINE_DEFAULT_DEBUG_CHANNEL (cryptasn) | |
| WINE_DECLARE_DEBUG_CHANNEL (crypt) | |
| BOOL WINAPI | CRYPT_AsnEncodeOid (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeExtensions (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeSequenceOfAny (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeBool (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodePubKeyInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeBits (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeBitsSwapBytes (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeInt (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeInteger (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeUnsignedInteger (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeChoiceOfTime (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeEnhancedKeyUsage (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodePKCSAttributes (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| BOOL | CRYPT_EncodeEnsureSpace (DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded) |
| static void | CRYPT_FreeSpace (const CRYPT_ENCODE_PARA *pEncodePara, LPVOID pv) |
| BOOL | CRYPT_EncodeLen (DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded) |
| BOOL WINAPI | CRYPT_AsnEncodeSequence (DWORD dwCertEncodingType, struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| BOOL WINAPI | CRYPT_AsnEncodeConstructed (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeSwapTag (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCertVersion (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_CopyEncodedBlob (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeValidity (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeAlgorithmIdWithNullParams (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeAlgorithmId (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCert (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| BOOL WINAPI | CRYPT_AsnEncodePubKeyInfoNoNull (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCertInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeCRLEntry (const CRL_ENTRY *entry, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCRLEntries (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCRLVersion (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCRLInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeExtension (CERT_EXTENSION *ext, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeStringCoerce (const CERT_NAME_VALUE *value, BYTE tag, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeBMPString (const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeUTF8String (const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeNameValue (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeRdnAttr (DWORD dwCertEncodingType, const CERT_RDN_ATTR *attr, CryptEncodeObjectExFunc nameValueEncodeFunc, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static int __cdecl | BLOBComp (const void *l, const void *r) |
| static BOOL WINAPI | CRYPT_DEREncodeSet (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_DEREncodeItemsAsSet (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeRdn (DWORD dwCertEncodingType, const CERT_RDN *rdn, CryptEncodeObjectExFunc nameValueEncodeFunc, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeUnicodeNameValue (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeOrCopyUnicodeNameValue (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeUnicodeName (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCTLVersion (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCTLSubjectAlgorithm (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeCTLEntry (const CTL_ENTRY *entry, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCTLEntries (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCTL (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeSMIMECapability (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeSMIMECapabilities (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeNoticeNumbers (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeNoticeReference (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodePolicyQualifierUserNotice (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodePKCSAttribute (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodePKCSContentInfoInternal (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| BOOL | CRYPT_AsnEncodePKCSDigestedData (const CRYPT_DIGESTED_DATA *digestedData, void *pvData, DWORD *pcbData) |
| static BOOL WINAPI | CRYPT_AsnEncodePKCSContentInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeUnicodeStringCoerce (const CERT_NAME_VALUE *value, BYTE tag, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeNumericString (const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | isprintableW (WCHAR wc) |
| static BOOL | CRYPT_AsnEncodePrintableString (const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeIA5String (const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeUniversalString (const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeName (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeAltNameEntry (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeAuthorityKeyId (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeAltName (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeAuthorityKeyId2 (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeAccessDescription (const CERT_ACCESS_DESCRIPTION *descr, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeAuthorityInfoAccess (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeBasicConstraints (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeBasicConstraints2 (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCertPolicyQualifiers (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeCertPolicy (DWORD dwCertEncodingType, const CERT_POLICY_INFO *info, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCertPolicies (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeCertPolicyMapping (DWORD dwCertEncodingType, const CERT_POLICY_MAPPING *mapping, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCertPolicyMappings (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCertPolicyConstraints (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeRsaPubKey_Bcrypt (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeRsaPubKey (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| BOOL WINAPI | CRYPT_AsnEncodeOctets (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeEnumerated (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeUtcTime (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeGeneralizedTime (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeDistPoint (const CRL_DIST_POINT *distPoint, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCRLDistPoints (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeIssuingDistPoint (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeGeneralSubtree (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeNameConstraints (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeIssuerSerialNumber (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodePKCSSignerInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeCMSSignerInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| BOOL | CRYPT_AsnEncodeCMSSignedInfo (CRYPT_SIGNED_INFO *signedInfo, void *pvData, DWORD *pcbData) |
| static BOOL WINAPI | CRYPT_AsnEncodeRecipientInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeEncryptedContentInfo (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| BOOL | CRYPT_AsnEncodePKCSEnvelopedData (const CRYPT_ENVELOPED_DATA *envelopedData, void *pvData, DWORD *pcbData) |
| static BOOL WINAPI | CRYPT_AsnEncodeCertId (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL | CRYPT_AsnEncodeOCSPRequestEntry (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeOCSPRequestEntries (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeOCSPRequest (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static BOOL WINAPI | CRYPT_AsnEncodeOCSPSignedRequest (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded) |
| static CryptEncodeObjectExFunc | CRYPT_GetBuiltinEncoder (DWORD dwCertEncodingType, LPCSTR lpszStructType) |
| static CryptEncodeObjectFunc | CRYPT_LoadEncoderFunc (DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc) |
| static CryptEncodeObjectExFunc | CRYPT_LoadEncoderExFunc (DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc) |
| BOOL WINAPI | CryptEncodeObject (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded) |
| BOOL WINAPI | CryptEncodeObjectEx (DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, void *pvEncoded, DWORD *pcbEncoded) |
| BOOL WINAPI | CryptExportPublicKeyInfo (HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo) |
| static BOOL WINAPI | CRYPT_ExportPublicKeyInfoEx (HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo) |
| BOOL WINAPI | CryptExportPublicKeyInfoEx (HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo) |
| BOOL WINAPI | CryptImportPublicKeyInfo (HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, HCRYPTKEY *phKey) |
| static BOOL WINAPI | CRYPT_ImportPublicKeyInfoEx (HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey) |
| BOOL WINAPI | CryptImportPublicKeyInfoEx (HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey) |
| BOOL WINAPI | CryptImportPublicKeyInfoEx2 (DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD dwFlags, void *pvAuxInfo, BCRYPT_KEY_HANDLE *phKey) |
Typedef Documentation
◆ ConvertPublicKeyInfoFunc
◆ CryptEncodeObjectFunc
◆ EncodePublicKeyAndParametersFunc
◆ ExportPublicKeyInfoExFunc
◆ ImportPublicKeyInfoExFunc
| typedef BOOL(WINAPI * ImportPublicKeyInfoExFunc) (HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey) |
Function Documentation
◆ BLOBComp()
Definition at line 1183 of file encode.c.
Referenced by CRYPT_DEREncodeItemsAsSet(), and CRYPT_DEREncodeSet().
◆ CRYPT_AsnEncodeAccessDescription()
|
static |
Definition at line 2689 of file encode.c.
2691{
2695 };
2696
2698 {
2701 }
2702 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items), 0, NULL, pbEncoded, pcbEncoded);
2703}
BOOL WINAPI CRYPT_AsnEncodeSequence(DWORD dwCertEncodingType, struct AsnEncodeSequenceItem items[], DWORD cItem, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:174
BOOL WINAPI CRYPT_AsnEncodeOid(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:814
static BOOL WINAPI CRYPT_AsnEncodeAltNameEntry(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2392
Definition: crypt32_private.h:59
Referenced by CRYPT_AsnEncodeAuthorityInfoAccess().
◆ CRYPT_AsnEncodeAlgorithmId()
|
static |
Definition at line 402 of file encode.c.
405{
411 };
412
415 pcbEncoded);
417}
static BOOL WINAPI CRYPT_CopyEncodedBlob(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:329
Definition: wincrypt.h:134
Referenced by CRYPT_AsnEncodeCert(), CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeCRLInfo(), and CRYPT_AsnEncodePubKeyInfoNoNull().
◆ CRYPT_AsnEncodeAlgorithmIdWithNullParams()
|
static |
Definition at line 377 of file encode.c.
381{
385 (LPBYTE)asn1Null };
390 };
391
394 else
395 items[1].pvStructInfo = &nullBlob;
398 pcbEncoded);
400}
Referenced by CRYPT_AsnEncodeCertId(), CRYPT_AsnEncodeCMSSignedInfo(), CRYPT_AsnEncodeCMSSignerInfo(), CRYPT_AsnEncodeEncryptedContentInfo(), CRYPT_AsnEncodePKCSDigestedData(), CRYPT_AsnEncodePKCSSignerInfo(), CRYPT_AsnEncodePubKeyInfo(), and CRYPT_AsnEncodeRecipientInfo().
◆ CRYPT_AsnEncodeAltName()
|
static |
Definition at line 2552 of file encode.c.
2555{
2557
2558 __TRY
2559 {
2562
2564 /* FIXME: should check that cAltEntry is not bigger than 0xff, since we
2565 * can't encode an erroneous entry index if it's bigger than this.
2566 */
2568 {
2570
2574 dataLen += len;
2576 {
2577 /* CRYPT_AsnEncodeAltNameEntry encoded the index of
2578 * the bad character, now set the index of the bad
2579 * entry
2580 */
2583 }
2584 }
2586 {
2588 bytesNeeded = 1 + lenBytes + dataLen;
2589 if (!pbEncoded)
2590 {
2591 *pcbEncoded = bytesNeeded;
2593 }
2594 else
2595 {
2597 pbEncoded, pcbEncoded, bytesNeeded)))
2598 {
2600
2602 pbEncoded = *(BYTE **)pbEncoded;
2603 out = pbEncoded;
2606 out += lenBytes;
2608 {
2610
2614 {
2616 dataLen -= len;
2617 }
2618 }
2620 CRYPT_FreeSpace(pEncodePara, pbEncoded);
2621 }
2622 }
2623 }
2624 }
2625 __EXCEPT_PAGE_FAULT
2626 {
2629 }
2630 __ENDTRY
2632}
static void CRYPT_FreeSpace(const CRYPT_ENCODE_PARA *pEncodePara, LPVOID pv)
Definition: encode.c:124
BOOL CRYPT_EncodeLen(DWORD len, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:132
BOOL CRYPT_EncodeEnsureSpace(DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded, DWORD bytesNeeded)
Definition: encode.c:97
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
Definition: wincrypt.h:364
Definition: notification.c:70
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383
#define CERT_ALT_NAME_ENTRY_ERR_INDEX_SHIFT
Definition: wincrypt.h:370
Referenced by CRYPT_AsnEncodeAuthorityKeyId2(), CRYPT_AsnEncodeDistPoint(), CRYPT_AsnEncodeIssuingDistPoint(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeAltNameEntry()
|
static |
Definition at line 2392 of file encode.c.
2395{
2398 DWORD dataLen;
2400
2403 {
2409 {
2411
2412 /* Not + 1: don't encode the NULL-terminator */
2415 {
2417 {
2420 *pcbEncoded = i;
2421 }
2422 }
2423 }
2424 else
2425 dataLen = 0;
2426 break;
2429 dataLen = entry->DirectoryName.cbData;
2430 break;
2433 dataLen = entry->IPAddress.cbData;
2434 break;
2436 {
2439 CRYPT_AsnEncodeOid };
2440
2442 pcbEncoded);
2443 }
2447 default:
2450 }
2452 {
2453 DWORD bytesNeeded, lenBytes;
2454
2456 bytesNeeded = 1 + dataLen + lenBytes;
2457 if (!pbEncoded)
2458 *pcbEncoded = bytesNeeded;
2459 else if (*pcbEncoded < bytesNeeded)
2460 {
2462 *pcbEncoded = bytesNeeded;
2464 }
2465 else
2466 {
2467 *pbEncoded++ = tag;
2468 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
2469 pbEncoded += lenBytes;
2471 {
2475 {
2477
2480 break;
2481 }
2484 break;
2487 break;
2488 }
2490 *pcbEncoded = bytesNeeded;
2491 }
2492 }
2495}
static BOOL WINAPI CRYPT_AsnEncodeSwapTag(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:292
Definition: encode.c:282
Definition: wincrypt.h:341
Definition: ecma_167.h:138
Referenced by CRYPT_AsnEncodeAccessDescription(), CRYPT_AsnEncodeAltName(), CRYPT_AsnEncodeGeneralSubtree(), and CRYPT_AsnEncodeOCSPRequest().
◆ CRYPT_AsnEncodeAuthorityInfoAccess()
|
static |
Definition at line 2705 of file encode.c.
2708{
2710
2711 __TRY
2712 {
2715
2718 {
2720
2722 &size);
2724 dataLen += size;
2725 }
2727 {
2729 bytesNeeded = 1 + lenBytes + dataLen;
2730 if (!pbEncoded)
2731 *pcbEncoded = bytesNeeded;
2732 else
2733 {
2735 pbEncoded, pcbEncoded, bytesNeeded)))
2736 {
2738
2740 pbEncoded = *(BYTE **)pbEncoded;
2741 out = pbEncoded;
2744 out += lenBytes;
2746 {
2748
2752 dataLen -= size;
2753 }
2755 CRYPT_FreeSpace(pEncodePara, pbEncoded);
2756 }
2757 }
2758 }
2759 }
2760 __EXCEPT_PAGE_FAULT
2761 {
2764 }
2765 __ENDTRY
2767}
static BOOL CRYPT_AsnEncodeAccessDescription(const CERT_ACCESS_DESCRIPTION *descr, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2689
Definition: wincrypt.h:482
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeAuthorityKeyId()
|
static |
Definition at line 2497 of file encode.c.
2500{
2502
2503 __TRY
2504 {
2509 DWORD cItem = 0, cSwapped = 0;
2510
2512 {
2516 items[cItem].pvStructInfo = &swapped[cSwapped];
2518 cSwapped++;
2519 cItem++;
2520 }
2522 {
2523 constructed.tag = 1;
2526 items[cItem].pvStructInfo = &constructed;
2528 cItem++;
2529 }
2531 {
2535 items[cItem].pvStructInfo = &swapped[cSwapped];
2537 cSwapped++;
2538 cItem++;
2539 }
2541 pEncodePara, pbEncoded, pcbEncoded);
2542 }
2543 __EXCEPT_PAGE_FAULT
2544 {
2547 }
2548 __ENDTRY
2550}
BOOL WINAPI CRYPT_AsnEncodeConstructed(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:233
BOOL WINAPI CRYPT_AsnEncodeOctets(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3216
static BOOL WINAPI CRYPT_AsnEncodeInteger(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3381
Definition: crypt32_private.h:70
Definition: wincrypt.h:290
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeAuthorityKeyId2()
|
static |
Definition at line 2634 of file encode.c.
2637{
2639
2640 __TRY
2641 {
2645 DWORD cItem = 0, cSwapped = 0;
2646
2648 {
2652 items[cItem].pvStructInfo = &swapped[cSwapped];
2654 cSwapped++;
2655 cItem++;
2656 }
2658 {
2662 items[cItem].pvStructInfo = &swapped[cSwapped];
2664 cSwapped++;
2665 cItem++;
2666 }
2668 {
2672 items[cItem].pvStructInfo = &swapped[cSwapped];
2674 cSwapped++;
2675 cItem++;
2676 }
2678 pEncodePara, pbEncoded, pcbEncoded);
2679 }
2680 __EXCEPT_PAGE_FAULT
2681 {
2684 }
2685 __ENDTRY
2687}
static BOOL WINAPI CRYPT_AsnEncodeAltName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2552
Definition: wincrypt.h:471
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeBasicConstraints()
|
static |
Definition at line 2769 of file encode.c.
2772{
2774
2775 __TRY
2776 {
2780 { 0 }
2781 };
2782 DWORD cItem = 1;
2783
2785 {
2788 cItem++;
2789 }
2791 {
2794 cItem++;
2795 }
2797 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2798 }
2799 __EXCEPT_PAGE_FAULT
2800 {
2803 }
2804 __ENDTRY
2806}
static BOOL WINAPI CRYPT_AsnEncodeBits(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3262
static BOOL WINAPI CRYPT_AsnEncodeInt(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3371
static BOOL WINAPI CRYPT_AsnEncodeSequenceOfAny(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3694
Definition: wincrypt.h:379
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeBasicConstraints2()
|
static |
Definition at line 2808 of file encode.c.
2811{
2813
2814 __TRY
2815 {
2818 DWORD cItem = 0;
2819
2821 {
2824 cItem++;
2825 }
2827 {
2830 cItem++;
2831 }
2833 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2834 }
2835 __EXCEPT_PAGE_FAULT
2836 {
2839 }
2840 __ENDTRY
2842}
static BOOL WINAPI CRYPT_AsnEncodeBool(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2361
Definition: wincrypt.h:390
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeBits()
|
static |
Definition at line 3262 of file encode.c.
3265{
3267
3268 __TRY
3269 {
3271 DWORD bytesNeeded, lenBytes, dataBytes;
3272 BYTE unusedBits;
3273
3274 /* yep, MS allows cUnusedBits to be >= 8 */
3276 {
3277 dataBytes = blob->cbData;
3278 unusedBits = 0;
3279 }
3281 {
3284 blob->cUnusedBits;
3285 }
3286 else
3287 {
3288 dataBytes = 0;
3289 unusedBits = 0;
3290 }
3292 bytesNeeded = 1 + lenBytes + dataBytes + 1;
3293 if (!pbEncoded)
3294 {
3295 *pcbEncoded = bytesNeeded;
3297 }
3298 else
3299 {
3301 pcbEncoded, bytesNeeded)))
3302 {
3304 pbEncoded = *(BYTE **)pbEncoded;
3305 *pbEncoded++ = ASN_BITSTRING;
3306 CRYPT_EncodeLen(dataBytes + 1, pbEncoded, &lenBytes);
3307 pbEncoded += lenBytes;
3308 *pbEncoded++ = unusedBits;
3309 if (dataBytes)
3310 {
3312
3313 if (dataBytes > 1)
3314 {
3316 pbEncoded += dataBytes - 1;
3317 }
3319 }
3320 }
3321 }
3322 }
3323 __EXCEPT_PAGE_FAULT
3324 {
3327 }
3328 __ENDTRY
3330}
Definition: wincrypt.h:204
Definition: image.c:134
Referenced by CRYPT_AsnEncodeBasicConstraints(), CRYPT_AsnEncodeBitsSwapBytes(), CRYPT_AsnEncodeCert(), CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeDistPoint(), CRYPT_AsnEncodeIssuingDistPoint(), CRYPT_AsnEncodePubKeyInfo(), CRYPT_AsnEncodePubKeyInfoNoNull(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeBitsSwapBytes()
|
static |
Definition at line 3332 of file encode.c.
3335{
3337
3338 __TRY
3339 {
3342
3345 {
3348 {
3350
3353 }
3354 else
3356 }
3359 &newBlob, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3361 }
3362 __EXCEPT_PAGE_FAULT
3363 {
3366 }
3367 __ENDTRY
3369}
Referenced by CRYPT_AsnEncodeCert().
◆ CRYPT_AsnEncodeBMPString()
|
static |
Definition at line 961 of file encode.c.
964{
967 DWORD bytesNeeded, lenBytes, strLen;
968
973 else
974 strLen = 0;
976 bytesNeeded = 1 + lenBytes + strLen * 2;
977 if (!pbEncoded)
978 *pcbEncoded = bytesNeeded;
979 else
980 {
982 pbEncoded, pcbEncoded, bytesNeeded)))
983 {
985
987 pbEncoded = *(BYTE **)pbEncoded;
988 *pbEncoded++ = ASN_BMPSTRING;
989 CRYPT_EncodeLen(strLen * 2, pbEncoded, &lenBytes);
990 pbEncoded += lenBytes;
992 {
995 }
996 }
997 }
999}
Definition: pdh_main.c:96
Referenced by CRYPT_AsnEncodeNameValue(), and CRYPT_AsnEncodeUnicodeNameValue().
◆ CRYPT_AsnEncodeBool()
|
static |
Definition at line 2361 of file encode.c.
2364{
2366
2368
2369 if (!pbEncoded)
2370 {
2371 *pcbEncoded = 3;
2373 }
2374 else if (*pcbEncoded < 3)
2375 {
2376 *pcbEncoded = 3;
2379 }
2380 else
2381 {
2382 *pcbEncoded = 3;
2383 *pbEncoded++ = ASN_BOOL;
2384 *pbEncoded++ = 1;
2385 *pbEncoded++ = val ? 0xff : 0;
2387 }
2390}
Referenced by CRYPT_AsnEncodeBasicConstraints2(), CRYPT_AsnEncodeExtension(), and CRYPT_AsnEncodeIssuingDistPoint().
◆ CRYPT_AsnEncodeCert()
|
static |
Definition at line 448 of file encode.c.
451{
453
454 __TRY
455 {
461 };
462
467 pcbEncoded);
468 }
470 {
473 }
474 __ENDTRY
476}
static BOOL WINAPI CRYPT_AsnEncodeAlgorithmId(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:402
static BOOL WINAPI CRYPT_AsnEncodeBitsSwapBytes(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3332
Definition: wincrypt.h:629
#define CRYPT_ENCODE_NO_SIGNATURE_BYTE_REVERSAL_FLAG
Definition: wincrypt.h:3598
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeCertId()
|
static |
Definition at line 4457 of file encode.c.
4460{
4462
4463 __TRY
4464 {
4471 };
4472
4475 }
4476 __EXCEPT_PAGE_FAULT
4477 {
4480 }
4481 __ENDTRY
4483}
static BOOL WINAPI CRYPT_AsnEncodeAlgorithmIdWithNullParams(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:377
Definition: wincrypt.h:647
Referenced by CRYPT_AsnEncodeOCSPRequestEntry().
◆ CRYPT_AsnEncodeCertInfo()
|
static |
Definition at line 501 of file encode.c.
504{
506
507 __TRY
508 {
518 { 0 }
519 };
522 DWORD cItem = 7, cSwapped = 0;
523
525 {
529 items[cItem].pvStructInfo = &swapped[cSwapped];
531 cSwapped++;
532 cItem++;
533 }
535 {
539 items[cItem].pvStructInfo = &swapped[cSwapped];
541 cSwapped++;
542 cItem++;
543 }
545 {
546 constructed.tag = 3;
549 items[cItem].pvStructInfo = &constructed;
551 cItem++;
552 }
553
555 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
556 }
558 {
561 }
562 __ENDTRY
564}
BOOL WINAPI CRYPT_AsnEncodePubKeyInfoNoNull(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:478
static BOOL WINAPI CRYPT_AsnEncodeExtensions(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:751
static BOOL WINAPI CRYPT_AsnEncodeValidity(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:356
static BOOL WINAPI CRYPT_AsnEncodeCertVersion(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:306
Definition: wincrypt.h:249
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeCertPolicies()
|
static |
Definition at line 2937 of file encode.c.
2940{
2942
2943 __TRY
2944 {
2947
2950 {
2953 &size);
2955 bytesNeeded += size;
2956 }
2958 bytesNeeded += 1 + lenBytes;
2960 {
2961 if (!pbEncoded)
2962 *pcbEncoded = bytesNeeded;
2963 else
2964 {
2966 pbEncoded, pcbEncoded, bytesNeeded)))
2967 {
2969
2971 pbEncoded = *(BYTE **)pbEncoded;
2972 out = pbEncoded;
2975 out += lenBytes;
2977 {
2978 size = bytesNeeded;
2983 {
2985 bytesNeeded -= size;
2986 }
2987 }
2989 CRYPT_FreeSpace(pEncodePara, pbEncoded);
2990 }
2991 }
2992 }
2993 }
2994 __EXCEPT_PAGE_FAULT
2995 {
2997 }
2998 __ENDTRY
3000}
static BOOL CRYPT_AsnEncodeCertPolicy(DWORD dwCertEncodingType, const CERT_POLICY_INFO *info, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2918
Definition: wincrypt.h:407
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeCertPolicy()
|
static |
Definition at line 2918 of file encode.c.
2921{
2925 };
2927
2929 {
2932 }
2933 ret = CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, NULL, pbEncoded, pcbEncoded);
2935}
static BOOL WINAPI CRYPT_AsnEncodeCertPolicyQualifiers(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2844
Referenced by CRYPT_AsnEncodeCertPolicies().
◆ CRYPT_AsnEncodeCertPolicyConstraints()
|
static |
Definition at line 3084 of file encode.c.
3088{
3090
3091 __TRY
3092 {
3096 DWORD cItem = 0, cSwapped = 0;
3097
3099 {
3101 swapped[cSwapped].pvStructInfo =
3102 &info->dwRequireExplicitPolicySkipCerts;
3103 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt;
3104 items[cItem].pvStructInfo = &swapped[cSwapped];
3106 cSwapped++;
3107 cItem++;
3108 }
3110 {
3111 swapped[cSwapped].tag = ASN_CONTEXT | 1;
3112 swapped[cSwapped].pvStructInfo =
3113 &info->dwInhibitPolicyMappingSkipCerts;
3114 swapped[cSwapped].encodeFunc = CRYPT_AsnEncodeInt;
3115 items[cItem].pvStructInfo = &swapped[cSwapped];
3117 cSwapped++;
3118 cItem++;
3119 }
3122 }
3123 __EXCEPT_PAGE_FAULT
3124 {
3126 }
3127 __ENDTRY
3129}
Definition: wincrypt.h:448
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeCertPolicyMapping()
|
static |
Definition at line 3002 of file encode.c.
3005{
3009 };
3010
3012 {
3015 }
3016 return CRYPT_AsnEncodeSequence(dwCertEncodingType, items, ARRAY_SIZE(items), dwFlags, NULL, pbEncoded, pcbEncoded);
3017}
Referenced by CRYPT_AsnEncodeCertPolicyMappings().
◆ CRYPT_AsnEncodeCertPolicyMappings()
|
static |
Definition at line 3019 of file encode.c.
3022{
3024
3025 __TRY
3026 {
3029
3032 {
3037 bytesNeeded += size;
3038 }
3040 bytesNeeded += 1 + lenBytes;
3042 {
3043 if (!pbEncoded)
3044 *pcbEncoded = bytesNeeded;
3045 else
3046 {
3048 pbEncoded, pcbEncoded, bytesNeeded)))
3049 {
3051
3053 pbEncoded = *(BYTE **)pbEncoded;
3054 out = pbEncoded;
3057 out += lenBytes;
3059 {
3060 size = bytesNeeded;
3065 {
3067 bytesNeeded -= size;
3068 }
3069 }
3071 CRYPT_FreeSpace(pEncodePara, pbEncoded);
3072 }
3073 }
3074 }
3075 }
3076 __EXCEPT_PAGE_FAULT
3077 {
3079 }
3080 __ENDTRY
3082}
static BOOL CRYPT_AsnEncodeCertPolicyMapping(DWORD dwCertEncodingType, const CERT_POLICY_MAPPING *mapping, DWORD dwFlags, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3002
Definition: wincrypt.h:443
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeCertPolicyQualifiers()
|
static |
Definition at line 2844 of file encode.c.
2847{
2850
2852 {
2853 *pcbEncoded = 0;
2855 }
2856 else
2857 {
2861 };
2863
2866 {
2867 items[0].pvStructInfo =
2873 bytesNeeded += size;
2874 }
2876 bytesNeeded += 1 + lenBytes;
2878 {
2879 if (!pbEncoded)
2880 *pcbEncoded = bytesNeeded;
2881 else
2882 {
2884 pbEncoded, pcbEncoded, bytesNeeded)))
2885 {
2887
2889 pbEncoded = *(BYTE **)pbEncoded;
2890 out = pbEncoded;
2893 out += lenBytes;
2895 {
2896 items[0].pvStructInfo =
2898 items[1].pvStructInfo =
2900 size = bytesNeeded;
2904 {
2906 bytesNeeded -= size;
2907 }
2908 }
2910 CRYPT_FreeSpace(pEncodePara, pbEncoded);
2911 }
2912 }
2913 }
2914 }
2916}
Definition: wincrypt.h:401
Referenced by CRYPT_AsnEncodeCertPolicy().
◆ CRYPT_AsnEncodeCertVersion()
|
static |
Definition at line 306 of file encode.c.
309{
312
313 /* CERT_V1 is not encoded */
315 {
316 *pcbEncoded = 0;
318 }
319 else
320 {
322
325 }
327}
Definition: interpreter.c:37
Referenced by CRYPT_AsnEncodeCertInfo().
◆ CRYPT_AsnEncodeChoiceOfTime()
|
static |
Definition at line 3664 of file encode.c.
3667{
3669
3670 __TRY
3671 {
3672 SYSTEMTIME sysTime;
3673
3674 /* Check the year, if it's in the UTCTime range call that encode func */
3679 pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
3680 else
3682 lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded,
3683 pcbEncoded);
3684 }
3685 __EXCEPT_PAGE_FAULT
3686 {
3689 }
3690 __ENDTRY
3692}
static BOOL WINAPI CRYPT_AsnEncodeUtcTime(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3559
static BOOL CRYPT_AsnEncodeGeneralizedTime(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3616
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:183
Definition: minwinbase.h:255
Referenced by CRYPT_AsnEncodeCRLEntry(), CRYPT_AsnEncodeCRLInfo(), CRYPT_AsnEncodeCTL(), CRYPT_AsnEncodeValidity(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeCMSSignedInfo()
| BOOL CRYPT_AsnEncodeCMSSignedInfo | ( | CRYPT_SIGNED_INFO * | signedInfo, |
| void * | pvData, | ||
| DWORD * | pcbData | ||
| ) |
Definition at line 4345 of file encode.c.
4347{
4354 { &digestAlgorithmsSet, CRYPT_DEREncodeItemsAsSet, 0 },
4356 };
4359 DWORD cItem = 3, cSwapped = 0;
4360
4362 {
4366 certSet.itemOffset = 0;
4369 swapped[cSwapped].pvStructInfo = &certSet;
4371 items[cItem].pvStructInfo = &swapped[cSwapped];
4373 cSwapped++;
4374 cItem++;
4375 }
4377 {
4378 crlSet.cItems = signedInfo->cCrlEncoded;
4379 crlSet.items = signedInfo->rgCrlEncoded;
4381 crlSet.itemOffset = 0;
4382 crlSet.encode = CRYPT_CopyEncodedBlob;
4384 swapped[cSwapped].pvStructInfo = &crlSet;
4386 items[cItem].pvStructInfo = &swapped[cSwapped];
4388 cSwapped++;
4389 cItem++;
4390 }
4391 signerSet.cItems = signedInfo->cSignerInfo;
4392 signerSet.items = signedInfo->rgSignerInfo;
4394 signerSet.itemOffset = 0;
4395 signerSet.encode = CRYPT_AsnEncodeCMSSignerInfo;
4396 items[cItem].pvStructInfo = &signerSet;
4398 cItem++;
4399
4402}
static BOOL WINAPI CRYPT_AsnEncodeCMSSignerInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4256
static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfoInternal(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1920
static BOOL WINAPI CRYPT_DEREncodeItemsAsSet(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1239
_In_ _Out_writes_opt_ pcchValueName _Inout_opt_ LPDWORD _Out_opt_ _Out_writes_bytes_to_opt_ pcbData _Inout_opt_ LPDWORD pcbData
Definition: shlwapi.h:757
Definition: encode.c:1231
Definition: wincrypt.h:4126
struct _CRYPTOAPI_BLOB CRL_BLOB
struct _CMSG_CMS_SIGNER_INFO CMSG_CMS_SIGNER_INFO
struct _CRYPTOAPI_BLOB CERT_BLOB
Referenced by CRYPT_SavePKCSToMem(), and CSignedEncodeMsg_GetParam().
◆ CRYPT_AsnEncodeCMSSignerInfo()
|
static |
Definition at line 4256 of file encode.c.
4259{
4261
4263 {
4266 }
4267
4268 __TRY
4269 {
4271
4276 !info->SignerId.IssuerSerialNumber.Issuer.cbData)
4278 else
4279 {
4282 };
4284 DWORD cItem = 1, cSwapped = 0;
4285
4287 {
4288 items[cItem].pvStructInfo =
4289 &info->SignerId.IssuerSerialNumber.Issuer;
4290 items[cItem].encodeFunc =
4292 cItem++;
4293 }
4294 else
4295 {
4299 items[cItem].pvStructInfo = &swapped[cSwapped];
4301 cSwapped++;
4302 cItem++;
4303 }
4306 cItem++;
4308 {
4312 items[cItem].pvStructInfo = &swapped[cSwapped];
4314 cSwapped++;
4315 cItem++;
4316 }
4319 cItem++;
4322 cItem++;
4324 {
4328 items[cItem].pvStructInfo = &swapped[cSwapped];
4330 cSwapped++;
4331 cItem++;
4332 }
4334 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
4335 }
4336 }
4337 __EXCEPT_PAGE_FAULT
4338 {
4340 }
4341 __ENDTRY
4343}
static BOOL WINAPI CRYPT_AsnEncodePKCSAttributes(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1896
static BOOL WINAPI CRYPT_AsnEncodeIssuerSerialNumber(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4172
Referenced by CRYPT_AsnEncodeCMSSignedInfo(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeConstructed()
| BOOL WINAPI CRYPT_AsnEncodeConstructed | ( | DWORD | dwCertEncodingType, |
| LPCSTR | lpszStructType, | ||
| const void * | pvStructInfo, | ||
| DWORD | dwFlags, | ||
| PCRYPT_ENCODE_PARA | pEncodePara, | ||
| BYTE * | pbEncoded, | ||
| DWORD * | pcbEncoded | ||
| ) |
Definition at line 233 of file encode.c.
236{
240
243 {
244 DWORD dataLen, bytesNeeded;
245
247 bytesNeeded = 1 + dataLen + len;
248 if (!pbEncoded)
249 *pcbEncoded = bytesNeeded;
251 pbEncoded, pcbEncoded, bytesNeeded)))
252 {
254
256 pbEncoded = *(BYTE **)pbEncoded;
257 out = pbEncoded;
260 out += dataLen;
265 {
266 /* Some functions propagate their errors through the size */
267 *pcbEncoded = len;
269 CRYPT_FreeSpace(pEncodePara, pbEncoded);
270 }
271 }
272 }
273 else
274 {
275 /* Some functions propagate their errors through the size */
276 *pcbEncoded = len;
277 }
279}
Referenced by CRYPT_AsnEncodeAuthorityKeyId(), CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeCertVersion(), CRYPT_AsnEncodeCRLInfo(), CRYPT_AsnEncodeCTL(), CRYPT_AsnEncodeDistPoint(), CRYPT_AsnEncodeIssuingDistPoint(), CRYPT_AsnEncodeOCSPRequest(), CRYPT_AsnEncodePKCSContentInfoInternal(), and CRYPT_EncodeDataContentInfoHeader().
◆ CRYPT_AsnEncodeCRLDistPoints()
|
static |
Definition at line 3801 of file encode.c.
3804{
3806
3807 __TRY
3808 {
3810
3812 {
3815 }
3816 else
3817 {
3819
3822 {
3824
3826 &len);
3828 dataLen += len;
3830 {
3831 /* Have to propagate index of failing character */
3832 *pcbEncoded = len;
3833 }
3834 }
3836 {
3838 bytesNeeded = 1 + lenBytes + dataLen;
3839 if (!pbEncoded)
3840 {
3841 *pcbEncoded = bytesNeeded;
3843 }
3844 else
3845 {
3847 pbEncoded, pcbEncoded, bytesNeeded)))
3848 {
3850
3852 pbEncoded = *(BYTE **)pbEncoded;
3853 out = pbEncoded;
3856 out += lenBytes;
3858 {
3860
3864 {
3866 dataLen -= len;
3867 }
3868 }
3870 CRYPT_FreeSpace(pEncodePara, pbEncoded);
3871 }
3872 }
3873 }
3874 }
3875 }
3876 __EXCEPT_PAGE_FAULT
3877 {
3880 }
3881 __ENDTRY
3883}
static BOOL CRYPT_AsnEncodeDistPoint(const CRL_DIST_POINT *distPoint, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3742
Definition: wincrypt.h:540
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeCRLEntries()
|
static |
Definition at line 593 of file encode.c.
596{
601
603 {
605
608 dataLen += size;
609 }
611 {
613 bytesNeeded = 1 + lenBytes + dataLen;
614 if (!pbEncoded)
615 *pcbEncoded = bytesNeeded;
616 else
617 {
619 pcbEncoded, bytesNeeded)))
620 {
622
624 pbEncoded = *(BYTE **)pbEncoded;
625 out = pbEncoded;
628 out += lenBytes;
630 {
632
635 dataLen -= size;
636 }
638 CRYPT_FreeSpace(pEncodePara, pbEncoded);
639 }
640 }
641 }
643}
static BOOL CRYPT_AsnEncodeCRLEntry(const CRL_ENTRY *entry, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:566
Definition: wincrypt.h:496
Definition: wincrypt.h:503
Referenced by CRYPT_AsnEncodeCRLInfo().
◆ CRYPT_AsnEncodeCRLEntry()
|
static |
Definition at line 566 of file encode.c.
568{
572 { 0 }
573 };
574 DWORD cItem = 2;
576
578
580 {
583 cItem++;
584 }
585
587 pbEncoded, pcbEncoded);
588
591}
static BOOL WINAPI CRYPT_AsnEncodeChoiceOfTime(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3664
Referenced by CRYPT_AsnEncodeCRLEntries().
◆ CRYPT_AsnEncodeCRLInfo()
|
static |
Definition at line 668 of file encode.c.
671{
673
674 __TRY
675 {
682 { 0 }
683 };
685 DWORD cItem = 4, cConstructed = 0;
686
688 {
691 cItem++;
692 }
694 {
697 cItem++;
698 }
700 {
701 constructed[cConstructed].tag = 0;
704 items[cItem].pvStructInfo = &constructed[cConstructed];
706 cConstructed++;
707 cItem++;
708 }
709
711 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
712 }
714 {
717 }
718 __ENDTRY
720}
static BOOL WINAPI CRYPT_AsnEncodeCRLVersion(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:645
static BOOL WINAPI CRYPT_AsnEncodeCRLEntries(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:593
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeCRLVersion()
|
static |
Definition at line 645 of file encode.c.
648{
651
652 /* CRL_V1 is not encoded */
654 {
655 *pcbEncoded = 0;
657 }
658 else
660 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
662}
Referenced by CRYPT_AsnEncodeCRLInfo().
◆ CRYPT_AsnEncodeCTL()
|
static |
Definition at line 1590 of file encode.c.
1593{
1595
1596 __TRY
1597 {
1602 };
1604 DWORD cItem = 2;
1605
1607 {
1610 cItem++;
1611 }
1613 {
1616 cItem++;
1617 }
1620 cItem++;
1622 {
1625 cItem++;
1626 }
1629 cItem++;
1631 {
1634 cItem++;
1635 }
1637 {
1638 constructed.tag = 0;
1641 items[cItem].pvStructInfo = &constructed;
1643 cItem++;
1644 }
1646 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1647 }
1648 __EXCEPT_PAGE_FAULT
1649 {
1651 }
1652 __ENDTRY
1654}
static BOOL WINAPI CRYPT_AsnEncodeCTLSubjectAlgorithm(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1487
static BOOL WINAPI CRYPT_AsnEncodeCTLVersion(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1465
static BOOL WINAPI CRYPT_AsnEncodeEnhancedKeyUsage(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3885
static BOOL WINAPI CRYPT_AsnEncodeCTLEntries(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1537
Definition: wincrypt.h:841
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeCTLEntries()
|
static |
Definition at line 1537 of file encode.c.
1540{
1544
1547 {
1549
1552 dataLen += size;
1553 }
1555 {
1557 bytesNeeded = 1 + lenBytes + dataLen;
1558 if (!pbEncoded)
1559 *pcbEncoded = bytesNeeded;
1560 else
1561 {
1563 pbEncoded, pcbEncoded, bytesNeeded)))
1564 {
1566
1568 pbEncoded = *(BYTE **)pbEncoded;
1569 out = pbEncoded;
1572 out += lenBytes;
1574 {
1576
1580 dataLen -= size;
1581 }
1583 CRYPT_FreeSpace(pEncodePara, pbEncoded);
1584 }
1585 }
1586 }
1588}
static BOOL CRYPT_AsnEncodeCTLEntry(const CTL_ENTRY *entry, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1517
Definition: encode.c:1532
Referenced by CRYPT_AsnEncodeCTL().
◆ CRYPT_AsnEncodeCTLEntry()
|
static |
Definition at line 1517 of file encode.c.
1519{
1523 };
1525
1529}
Referenced by CRYPT_AsnEncodeCTLEntries().
◆ CRYPT_AsnEncodeCTLSubjectAlgorithm()
|
static |
◆ CRYPT_AsnEncodeCTLVersion()
|
static |
Definition at line 1465 of file encode.c.
1468{
1471
1472 /* CTL_V1 is not encoded */
1474 {
1475 *pcbEncoded = 0;
1477 }
1478 else
1480 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1482}
Referenced by CRYPT_AsnEncodeCTL().
◆ CRYPT_AsnEncodeDistPoint()
|
static |
Definition at line 3742 of file encode.c.
3744{
3749 DWORD cItem = 0, cSwapped = 0;
3750
3752 {
3754 /* do nothing */
3755 break;
3760 constructed.tag = 0;
3761 constructed.pvStructInfo = &swapped[cSwapped];
3763 items[cItem].pvStructInfo = &constructed;
3765 cSwapped++;
3766 cItem++;
3767 break;
3771 break;
3772 default:
3774 }
3776 {
3780 items[cItem].pvStructInfo = &swapped[cSwapped];
3782 cSwapped++;
3783 cItem++;
3784 }
3786 {
3790 items[cItem].pvStructInfo = &swapped[cSwapped];
3792 cSwapped++;
3793 cItem++;
3794 }
3797 pbEncoded, pcbEncoded);
3799}
Referenced by CRYPT_AsnEncodeCRLDistPoints().
◆ CRYPT_AsnEncodeEncryptedContentInfo()
|
static |
Definition at line 4422 of file encode.c.
4425{
4431 { &info->contentEncryptionAlgorithm,
4432 CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 },
4433 { &swapped, CRYPT_AsnEncodeSwapTag, 0 },
4434 };
4435
4438}
Referenced by CRYPT_AsnEncodePKCSEnvelopedData().
◆ CRYPT_AsnEncodeEnhancedKeyUsage()
|
static |
Definition at line 3885 of file encode.c.
3888{
3890
3891 __TRY
3892 {
3895
3898 {
3903 bytesNeeded += size;
3904 }
3906 bytesNeeded += 1 + lenBytes;
3908 {
3909 if (!pbEncoded)
3910 *pcbEncoded = bytesNeeded;
3911 else
3912 {
3914 pbEncoded, pcbEncoded, bytesNeeded)))
3915 {
3917
3919 pbEncoded = *(BYTE **)pbEncoded;
3920 out = pbEncoded;
3923 out += lenBytes;
3925 {
3926 size = bytesNeeded;
3931 {
3933 bytesNeeded -= size;
3934 }
3935 }
3937 CRYPT_FreeSpace(pEncodePara, pbEncoded);
3938 }
3939 }
3940 }
3941 }
3942 __EXCEPT_PAGE_FAULT
3943 {
3946 }
3947 __ENDTRY
3949}
Definition: wincrypt.h:830
Referenced by CRYPT_AsnEncodeCTL(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeEnumerated()
|
static |
Definition at line 3538 of file encode.c.
3541{
3544
3545 /* Encode as an unsigned integer, then change the tag to enumerated */
3551 {
3553 pbEncoded = *(BYTE **)pbEncoded;
3554 pbEncoded[0] = ASN_ENUMERATED;
3555 }
3557}
static BOOL WINAPI CRYPT_AsnEncodeUnsignedInteger(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3469
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeExtension()
|
static |
Definition at line 722 of file encode.c.
724{
730 };
731 DWORD cItem = 1;
732
734
736 {
739 cItem++;
740 }
743 cItem++;
744
746 pbEncoded, pcbEncoded);
749}
Referenced by CRYPT_AsnEncodeExtensions().
◆ CRYPT_AsnEncodeExtensions()
|
static |
Definition at line 751 of file encode.c.
754{
756
757 __TRY
758 {
761
764 {
766
769 dataLen += size;
770 }
772 {
774 bytesNeeded = 1 + lenBytes + dataLen;
775 if (!pbEncoded)
776 *pcbEncoded = bytesNeeded;
777 else
778 {
780 pbEncoded, pcbEncoded, bytesNeeded)))
781 {
783
785 pbEncoded = *(BYTE **)pbEncoded;
786 out = pbEncoded;
789 out += lenBytes;
791 {
793
797 dataLen -= size;
798 }
800 CRYPT_FreeSpace(pEncodePara, pbEncoded);
801 }
802 }
803 }
804 }
806 {
809 }
810 __ENDTRY
812}
static BOOL CRYPT_AsnEncodeExtension(CERT_EXTENSION *ext, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:722
Definition: wincrypt.h:244
Referenced by CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeCRLEntry(), CRYPT_AsnEncodeCRLInfo(), CRYPT_AsnEncodeCTL(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeGeneralizedTime()
|
static |
Definition at line 3616 of file encode.c.
3619{
3621
3622 __TRY
3623 {
3624 SYSTEMTIME sysTime;
3625 /* sorry, magic number: enough for tag, len, YYYYMMDDHHMMSSZ. I use a
3626 * temporary buffer because the output buffer is not NULL-terminated.
3627 */
3630
3631 if (!pbEncoded)
3632 {
3633 *pcbEncoded = bytesNeeded;
3635 }
3636 else
3637 {
3641 pcbEncoded, bytesNeeded);
3643 {
3645 pbEncoded = *(BYTE **)pbEncoded;
3647 buf[1] = bytesNeeded - 2;
3652 }
3653 }
3654 }
3655 __EXCEPT_PAGE_FAULT
3656 {
3659 }
3660 __ENDTRY
3662}
Referenced by CRYPT_AsnEncodeChoiceOfTime().
◆ CRYPT_AsnEncodeGeneralSubtree()
|
static |
Definition at line 4040 of file encode.c.
4043{
4048 { 0 }
4049 };
4051 DWORD cItem = 1, cSwapped = 0;
4052
4054 {
4058 items[cItem].pvStructInfo = &swapped[cSwapped];
4060 cSwapped++;
4061 cItem++;
4062 }
4064 {
4068 items[cItem].pvStructInfo = &swapped[cSwapped];
4070 cSwapped++;
4071 cItem++;
4072 }
4074 pEncodePara, pbEncoded, pcbEncoded);
4076}
Definition: wincrypt.h:583
Referenced by CRYPT_AsnEncodeNameConstraints().
◆ CRYPT_AsnEncodeIA5String()
|
static |
Definition at line 2129 of file encode.c.
2132{
2135 DWORD bytesNeeded, lenBytes, encodedLen;
2136
2141 else
2142 encodedLen = 0;
2144 bytesNeeded = 1 + lenBytes + encodedLen;
2145 if (!pbEncoded)
2146 *pcbEncoded = bytesNeeded;
2147 else
2148 {
2150 pbEncoded, pcbEncoded, bytesNeeded)))
2151 {
2154
2157 else
2158 ptr = pbEncoded;
2161 ptr += lenBytes;
2163 {
2166 else
2167 {
2168 *pcbEncoded = i;
2171 }
2172 }
2175 }
2176 }
2178}
Referenced by CRYPT_AsnEncodeUnicodeNameValue().
◆ CRYPT_AsnEncodeInt()
|
static |
Definition at line 3371 of file encode.c.
3374{
3376
3379}
Referenced by CRYPT_AsnEncodeBasicConstraints(), CRYPT_AsnEncodeBasicConstraints2(), CRYPT_AsnEncodeCertPolicyConstraints(), CRYPT_AsnEncodeCertVersion(), CRYPT_AsnEncodeCMSSignedInfo(), CRYPT_AsnEncodeCMSSignerInfo(), CRYPT_AsnEncodeCRLVersion(), CRYPT_AsnEncodeCTLVersion(), CRYPT_AsnEncodeGeneralSubtree(), CRYPT_AsnEncodeNoticeNumbers(), CRYPT_AsnEncodePKCSDigestedData(), CRYPT_AsnEncodePKCSEnvelopedData(), CRYPT_AsnEncodePKCSSignerInfo(), CRYPT_AsnEncodeRecipientInfo(), CRYPT_AsnEncodeRsaPubKey(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeInteger()
|
static |
Definition at line 3381 of file encode.c.
3384{
3386
3387 __TRY
3388 {
3389 DWORD significantBytes, lenBytes, bytesNeeded;
3390 BYTE padByte = 0;
3393
3394 significantBytes = blob->cbData;
3395 if (significantBytes)
3396 {
3398 {
3399 /* negative, lop off leading (little-endian) 0xffs */
3400 for (; significantBytes > 0 &&
3401 blob->pbData[significantBytes - 1] == 0xff; significantBytes--)
3402 ;
3404 {
3405 padByte = 0xff;
3406 pad = TRUE;
3407 }
3408 }
3409 else
3410 {
3411 /* positive, lop off leading (little-endian) zeroes */
3412 for (; significantBytes > 0 &&
3413 !blob->pbData[significantBytes - 1]; significantBytes--)
3414 ;
3415 if (significantBytes == 0)
3416 significantBytes = 1;
3418 {
3419 padByte = 0;
3420 pad = TRUE;
3421 }
3422 }
3423 }
3424 if (pad)
3426 else
3428 bytesNeeded = 1 + lenBytes + significantBytes;
3429 if (pad)
3430 bytesNeeded++;
3431 if (!pbEncoded)
3432 {
3433 *pcbEncoded = bytesNeeded;
3435 }
3436 else
3437 {
3439 pcbEncoded, bytesNeeded)))
3440 {
3442 pbEncoded = *(BYTE **)pbEncoded;
3443 *pbEncoded++ = ASN_INTEGER;
3444 if (pad)
3445 {
3446 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
3447 pbEncoded += lenBytes;
3448 *pbEncoded++ = padByte;
3449 }
3450 else
3451 {
3452 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
3453 pbEncoded += lenBytes;
3454 }
3455 for (; significantBytes > 0; significantBytes--)
3456 *(pbEncoded++) = blob->pbData[significantBytes - 1];
3457 }
3458 }
3459 }
3460 __EXCEPT_PAGE_FAULT
3461 {
3464 }
3465 __ENDTRY
3467}
Referenced by CRYPT_AsnEncodeAuthorityKeyId(), CRYPT_AsnEncodeAuthorityKeyId2(), CRYPT_AsnEncodeCertId(), CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeCRLEntry(), CRYPT_AsnEncodeCTL(), CRYPT_AsnEncodeInt(), CRYPT_AsnEncodeIssuerSerialNumber(), CRYPT_AsnEncodeRsaPubKey_Bcrypt(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeIssuerSerialNumber()
|
static |
Definition at line 4172 of file encode.c.
Referenced by CRYPT_AsnEncodeCMSSignerInfo(), CRYPT_AsnEncodePKCSSignerInfo(), and CRYPT_AsnEncodeRecipientInfo().
◆ CRYPT_AsnEncodeIssuingDistPoint()
|
static |
Definition at line 3951 of file encode.c.
3954{
3956
3957 __TRY
3958 {
3963 DWORD cItem = 0, cSwapped = 0;
3964
3967 {
3969 /* do nothing */
3970 break;
3975 constructed.tag = 0;
3976 constructed.pvStructInfo = &swapped[cSwapped];
3978 items[cItem].pvStructInfo = &constructed;
3980 cSwapped++;
3981 cItem++;
3982 break;
3983 default:
3986 }
3988 {
3992 items[cItem].pvStructInfo = &swapped[cSwapped];
3994 cSwapped++;
3995 cItem++;
3996 }
3998 {
4002 items[cItem].pvStructInfo = &swapped[cSwapped];
4004 cSwapped++;
4005 cItem++;
4006 }
4008 {
4012 items[cItem].pvStructInfo = &swapped[cSwapped];
4014 cSwapped++;
4015 cItem++;
4016 }
4018 {
4022 items[cItem].pvStructInfo = &swapped[cSwapped];
4024 cSwapped++;
4025 cItem++;
4026 }
4029 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
4030 }
4031 __EXCEPT_PAGE_FAULT
4032 {
4035 }
4036 __ENDTRY
4038}
Definition: wincrypt.h:575
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeName()
|
static |
Definition at line 2296 of file encode.c.
2299{
2301
2302 __TRY
2303 {
2306
2310 {
2314 bytesNeeded += size;
2315 }
2317 bytesNeeded += 1 + lenBytes;
2319 {
2320 if (!pbEncoded)
2321 *pcbEncoded = bytesNeeded;
2322 else
2323 {
2325 pbEncoded, pcbEncoded, bytesNeeded)))
2326 {
2328
2330 pbEncoded = *(BYTE **)pbEncoded;
2331 out = pbEncoded;
2334 out += lenBytes;
2336 {
2337 size = bytesNeeded;
2341 {
2343 bytesNeeded -= size;
2344 }
2345 }
2347 CRYPT_FreeSpace(pEncodePara, pbEncoded);
2348 }
2349 }
2350 }
2351 }
2352 __EXCEPT_PAGE_FAULT
2353 {
2356 }
2357 __ENDTRY
2359}
static BOOL CRYPT_AsnEncodeRdn(DWORD dwCertEncodingType, const CERT_RDN *rdn, CryptEncodeObjectExFunc nameValueEncodeFunc, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1313
static BOOL WINAPI CRYPT_AsnEncodeNameValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1038
Definition: wincrypt.h:275
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeNameConstraints()
|
static |
Definition at line 4078 of file encode.c.
4081{
4084
4086
4087 __TRY
4088 {
4093
4096 {
4100 {
4111 {
4113 swapped[cSwapped].pvStructInfo = &permitted;
4115 items[cItem].pvStructInfo = &swapped[cSwapped];
4117 cSwapped++;
4118 cItem++;
4119 }
4120 }
4121 else
4123 }
4125 {
4126 excluded.rgBlob = CryptMemAlloc(
4128 if (excluded.rgBlob)
4129 {
4130 excluded.cBlob = constraints->cExcludedSubtree;
4131 memset(excluded.rgBlob, 0,
4138 &excluded.rgBlob[i].cbData);
4140 {
4142 swapped[cSwapped].pvStructInfo = &excluded;
4144 items[cItem].pvStructInfo = &swapped[cSwapped];
4146 cSwapped++;
4147 cItem++;
4148 }
4149 }
4150 else
4152 }
4155 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
4160 }
4161 __EXCEPT_PAGE_FAULT
4162 {
4164 }
4165 __ENDTRY
4167 CryptMemFree(excluded.rgBlob);
4170}
static BOOL CRYPT_AsnEncodeGeneralSubtree(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4040
static BOOL WINAPI CRYPT_DEREncodeSet(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1195
Definition: wincrypt.h:590
PCERT_GENERAL_SUBTREE rgPermittedSubtree
Definition: wincrypt.h:592
PCERT_GENERAL_SUBTREE rgExcludedSubtree
Definition: wincrypt.h:594
Definition: wincrypt.h:1811
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeNameValue()
|
static |
Definition at line 1038 of file encode.c.
1041{
1043
1044 __TRY
1045 {
1047
1049 {
1051 /* explicitly disallowed */
1054 break;
1058 break;
1061 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1062 break;
1065 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1066 break;
1069 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1070 break;
1073 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1074 break;
1078 break;
1081 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1082 break;
1085 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1086 break;
1089 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1090 break;
1093 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1094 break;
1099 break;
1102 pbEncoded, pcbEncoded);
1103 break;
1106 pbEncoded, pcbEncoded);
1107 break;
1108 default:
1111 }
1112 }
1113 __EXCEPT_PAGE_FAULT
1114 {
1117 }
1118 __ENDTRY
1120}
static BOOL CRYPT_AsnEncodeBMPString(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:961
static BOOL CRYPT_AsnEncodeUTF8String(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1001
static BOOL CRYPT_AsnEncodeStringCoerce(const CERT_NAME_VALUE *value, BYTE tag, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:932
Definition: wincrypt.h:280
Referenced by CRYPT_AsnEncodeName(), CRYPT_AsnEncodeNoticeReference(), CRYPT_AsnEncodePolicyQualifierUserNotice(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeNoticeNumbers()
|
static |
Definition at line 1752 of file encode.c.
1755{
1759
1761 {
1763
1767 dataLen += size;
1768 }
1770 {
1772 bytesNeeded = 1 + lenBytes + dataLen;
1773 if (!pbEncoded)
1774 *pcbEncoded = bytesNeeded;
1775 else
1776 {
1778 pcbEncoded, bytesNeeded)))
1779 {
1781
1783 pbEncoded = *(BYTE **)pbEncoded;
1784 out = pbEncoded;
1787 out += lenBytes;
1789 {
1791
1795 dataLen -= size;
1796 }
1798 CRYPT_FreeSpace(pEncodePara, pbEncoded);
1799 }
1800 }
1801 }
1803}
int * rgNoticeNumbers
Definition: wincrypt.h:415
DWORD cNoticeNumbers
Definition: wincrypt.h:414
Referenced by CRYPT_AsnEncodeNoticeReference().
◆ CRYPT_AsnEncodeNoticeReference()
|
static |
Definition at line 1805 of file encode.c.
1808{
1814 { &orgValue, CRYPT_AsnEncodeNameValue, 0 },
1815 { noticeRef, CRYPT_AsnEncodeNoticeNumbers, 0 },
1816 };
1817
1820 pcbEncoded);
1822}
static BOOL WINAPI CRYPT_AsnEncodeNoticeNumbers(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1752
LPSTR pszOrganization
Definition: wincrypt.h:413
Referenced by CRYPT_AsnEncodePolicyQualifierUserNotice().
◆ CRYPT_AsnEncodeNumericString()
|
static |
Definition at line 2022 of file encode.c.
2025{
2028 DWORD bytesNeeded, lenBytes, encodedLen;
2029
2034 else
2035 encodedLen = 0;
2037 bytesNeeded = 1 + lenBytes + encodedLen;
2038 if (!pbEncoded)
2039 *pcbEncoded = bytesNeeded;
2040 else
2041 {
2043 pbEncoded, pcbEncoded, bytesNeeded)))
2044 {
2047
2050 else
2051 ptr = pbEncoded;
2054 ptr += lenBytes;
2056 {
2059 else
2060 {
2061 *pcbEncoded = i;
2064 }
2065 }
2068 }
2069 }
2071}
Referenced by CRYPT_AsnEncodeUnicodeNameValue().
◆ CRYPT_AsnEncodeOCSPRequest()
|
static |
Definition at line 4589 of file encode.c.
4592{
4594
4595 __TRY
4596 {
4598
4600 {
4604 }
4605 else
4606 {
4608 {
4612 }
4613 else
4614 {
4618
4620 {
4621 name.tag = 1;
4626 count++;
4627 }
4629 {
4632 count++;
4633 }
4634
4637 }
4638 }
4639 }
4640 __EXCEPT_PAGE_FAULT
4641 {
4644 }
4645 __ENDTRY
4647}
static BOOL WINAPI CRYPT_AsnEncodeOCSPRequestEntries(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4525
Definition: wincrypt.h:662
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeOCSPRequestEntries()
|
static |
Definition at line 4525 of file encode.c.
4528{
4530
4531 __TRY
4532 {
4535
4538 {
4543 dataLen += size;
4544 }
4546 {
4548 bytesNeeded = 1 + lenBytes + dataLen;
4549 if (!pbEncoded)
4550 *pcbEncoded = bytesNeeded;
4551 else
4552 {
4554 pbEncoded, pcbEncoded, bytesNeeded)))
4555 {
4557
4559 pbEncoded = *(BYTE **)pbEncoded;
4560 out = pbEncoded;
4563 out += lenBytes;
4565 {
4567
4571 dataLen -= size;
4572 }
4573
4575 CRYPT_FreeSpace(pEncodePara, pbEncoded);
4576 }
4577 }
4578 }
4579 }
4580 __EXCEPT_PAGE_FAULT
4581 {
4584 }
4585 __ENDTRY
4587}
static BOOL CRYPT_AsnEncodeOCSPRequestEntry(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4485
Definition: encode.c:4520
Referenced by CRYPT_AsnEncodeOCSPRequest().
◆ CRYPT_AsnEncodeOCSPRequestEntry()
|
static |
Definition at line 4485 of file encode.c.
4488{
4490
4491 __TRY
4492 {
4496 };
4497
4499 {
4503 }
4504 else
4505 {
4508 }
4509 }
4510 __EXCEPT_PAGE_FAULT
4511 {
4514 }
4515 __ENDTRY
4517}
static BOOL WINAPI CRYPT_AsnEncodeCertId(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4457
Definition: wincrypt.h:654
Referenced by CRYPT_AsnEncodeOCSPRequestEntries().
◆ CRYPT_AsnEncodeOCSPSignedRequest()
|
static |
Definition at line 4649 of file encode.c.
4652{
4654
4655 __TRY
4656 {
4660 };
4661
4663
4666 }
4667 __EXCEPT_PAGE_FAULT
4668 {
4671 }
4672 __ENDTRY
4674}
Definition: wincrypt.h:642
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeOctets()
| BOOL WINAPI CRYPT_AsnEncodeOctets | ( | DWORD | dwCertEncodingType, |
| LPCSTR | lpszStructType, | ||
| const void * | pvStructInfo, | ||
| DWORD | dwFlags, | ||
| PCRYPT_ENCODE_PARA | pEncodePara, | ||
| BYTE * | pbEncoded, | ||
| DWORD * | pcbEncoded | ||
| ) |
Definition at line 3216 of file encode.c.
3219{
3221
3222 __TRY
3223 {
3225 DWORD bytesNeeded, lenBytes;
3226
3228 dwFlags, pEncodePara, pbEncoded, pbEncoded ? *pcbEncoded : 0);
3229
3231 bytesNeeded = 1 + lenBytes + blob->cbData;
3232 if (!pbEncoded)
3233 {
3234 *pcbEncoded = bytesNeeded;
3236 }
3237 else
3238 {
3240 pcbEncoded, bytesNeeded)))
3241 {
3243 pbEncoded = *(BYTE **)pbEncoded;
3244 *pbEncoded++ = ASN_OCTETSTRING;
3246 pbEncoded += lenBytes;
3249 }
3250 }
3251 }
3252 __EXCEPT_PAGE_FAULT
3253 {
3256 }
3257 __ENDTRY
3260}
Referenced by CRYPT_AsnEncodeAuthorityKeyId(), CRYPT_AsnEncodeAuthorityKeyId2(), CRYPT_AsnEncodeCertId(), CRYPT_AsnEncodeCMSSignerInfo(), CRYPT_AsnEncodeCTL(), CRYPT_AsnEncodeCTLEntry(), CRYPT_AsnEncodeEncryptedContentInfo(), CRYPT_AsnEncodeExtension(), CRYPT_AsnEncodePKCSDigestedData(), CRYPT_AsnEncodePKCSSignerInfo(), CRYPT_AsnEncodeRecipientInfo(), CRYPT_EncodePKCSDigestedData(), CRYPT_GetBuiltinEncoder(), and CSignedMsgData_AppendMessageDigestAttribute().
◆ CRYPT_AsnEncodeOid()
| BOOL WINAPI CRYPT_AsnEncodeOid | ( | DWORD | dwCertEncodingType, |
| LPCSTR | lpszStructType, | ||
| const void * | pvStructInfo, | ||
| DWORD | dwFlags, | ||
| PCRYPT_ENCODE_PARA | pEncodePara, | ||
| BYTE * | pbEncoded, | ||
| DWORD * | pcbEncoded | ||
| ) |
Definition at line 814 of file encode.c.
817{
818 LPCSTR pszObjId = pvStructInfo;
819 DWORD bytesNeeded = 0, lenBytes;
821 int firstPos = 0;
822 BYTE firstByte = 0;
823
825
826 if (pszObjId)
827 {
829 int val1, val2;
830
832 {
835 }
836 bytesNeeded++;
837 firstByte = val1 * 40 + val2;
838 ptr = pszObjId + firstPos;
840 {
841 ptr++;
842 firstPos++;
843 }
845 {
847
848 /* note I assume each component is at most 32-bits long in base 2 */
850 {
851 if (val1 >= 0x10000000)
852 bytesNeeded += 5;
853 else if (val1 >= 0x200000)
854 bytesNeeded += 4;
855 else if (val1 >= 0x4000)
856 bytesNeeded += 3;
857 else if (val1 >= 0x80)
858 bytesNeeded += 2;
859 else
860 bytesNeeded += 1;
863 ptr++;
864 }
865 else
866 {
869 }
870 }
872 }
873 else
874 lenBytes = 1;
875 bytesNeeded += 1 + lenBytes;
876 if (pbEncoded)
877 {
878 if (*pcbEncoded < bytesNeeded)
879 {
882 }
883 else
884 {
885 *pbEncoded++ = ASN_OBJECTIDENTIFIER;
886 CRYPT_EncodeLen(bytesNeeded - 1 - lenBytes, pbEncoded, &lenBytes);
887 pbEncoded += lenBytes;
888 if (pszObjId)
889 {
892
893 *pbEncoded++ = firstByte;
894 ptr = pszObjId + firstPos;
896 {
898 {
899 unsigned char outBytes[5];
901
903 numBytes = 5;
905 numBytes = 4;
907 numBytes = 3;
909 numBytes = 2;
910 else
911 numBytes = 1;
913 {
915 val >>= 7;
916 }
918 *pbEncoded++ = outBytes[i] | 0x80;
919 *pbEncoded++ = outBytes[i];
922 ptr++;
923 }
924 }
925 }
926 }
927 }
928 *pcbEncoded = bytesNeeded;
930}
_ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl _ACRTIMP int __cdecl sscanf(const char *, const char *,...) __WINE_CRT_SCANF_ATTR(2
Referenced by CRYPT_AsnEncodeAccessDescription(), CRYPT_AsnEncodeAlgorithmId(), CRYPT_AsnEncodeAlgorithmIdWithNullParams(), CRYPT_AsnEncodeAltNameEntry(), CRYPT_AsnEncodeCertPolicy(), CRYPT_AsnEncodeCertPolicyMapping(), CRYPT_AsnEncodeCertPolicyQualifiers(), CRYPT_AsnEncodeCTLSubjectAlgorithm(), CRYPT_AsnEncodeEncryptedContentInfo(), CRYPT_AsnEncodeEnhancedKeyUsage(), CRYPT_AsnEncodeExtension(), CRYPT_AsnEncodePKCSAttribute(), CRYPT_AsnEncodePKCSContentInfoInternal(), CRYPT_AsnEncodeRdnAttr(), CRYPT_AsnEncodeSMIMECapability(), and CRYPT_EncodeDataContentInfoHeader().
◆ CRYPT_AsnEncodeOrCopyUnicodeNameValue()
|
static |
Definition at line 1378 of file encode.c.
1382{
1385
1388 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1389 else
1391 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1393}
static BOOL WINAPI CRYPT_AsnEncodeUnicodeNameValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2223
Referenced by CRYPT_AsnEncodeUnicodeName().
◆ CRYPT_AsnEncodePKCSAttribute()
|
static |
Definition at line 1864 of file encode.c.
1867{
1869
1870 __TRY
1871 {
1873
1876 else
1877 {
1881 };
1882
1885 pcbEncoded);
1886 }
1887 }
1888 __EXCEPT_PAGE_FAULT
1889 {
1891 }
1892 __ENDTRY
1894}
Definition: wincrypt.h:604
Definition: cookie.c:202
Referenced by CRYPT_AsnEncodePKCSAttributes(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodePKCSAttributes()
|
static |
Definition at line 1896 of file encode.c.
1899{
1901
1902 __TRY
1903 {
1907
1910 }
1911 __EXCEPT_PAGE_FAULT
1912 {
1914 }
1915 __ENDTRY
1917}
static BOOL WINAPI CRYPT_AsnEncodePKCSAttribute(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1864
Definition: wincrypt.h:610
struct _CRYPT_ATTRIBUTE CRYPT_ATTRIBUTE
Referenced by CRYPT_AsnEncodeCMSSignerInfo(), CRYPT_AsnEncodeCTLEntry(), CRYPT_AsnEncodePKCSSignerInfo(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodePKCSContentInfo()
|
static |
Definition at line 1960 of file encode.c.
1963{
1965
1966 __TRY
1967 {
1969
1972 else
1974 lpszStructType, pvStructInfo, dwFlags, pEncodePara, pbEncoded,
1975 pcbEncoded);
1976 }
1977 __EXCEPT_PAGE_FAULT
1978 {
1980 }
1981 __ENDTRY
1983}
Definition: wincrypt.h:461
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodePKCSContentInfoInternal()
|
static |
Definition at line 1920 of file encode.c.
1924{
1929 };
1931 DWORD cItem = 1;
1932
1934 {
1935 constructed.tag = 0;
1938 items[cItem].pvStructInfo = &constructed;
1940 cItem++;
1941 }
1943 cItem, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1944}
Referenced by CRYPT_AsnEncodeCMSSignedInfo(), CRYPT_AsnEncodePKCSContentInfo(), and CRYPT_AsnEncodePKCSDigestedData().
◆ CRYPT_AsnEncodePKCSDigestedData()
| BOOL CRYPT_AsnEncodePKCSDigestedData | ( | const CRYPT_DIGESTED_DATA * | digestedData, |
| void * | pvData, | ||
| DWORD * | pcbData | ||
| ) |
Definition at line 1946 of file encode.c.
1948{
1952 0 },
1955 };
1956
1957 return CRYPT_AsnEncodeSequence(X509_ASN_ENCODING, items, ARRAY_SIZE(items), 0, NULL, pvData, pcbData);
1958}
CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm
Definition: crypt32_private.h:89
Referenced by CRYPT_EncodePKCSDigestedData().
◆ CRYPT_AsnEncodePKCSEnvelopedData()
| BOOL CRYPT_AsnEncodePKCSEnvelopedData | ( | const CRYPT_ENVELOPED_DATA * | envelopedData, |
| void * | pvData, | ||
| DWORD * | pcbData | ||
| ) |
Definition at line 4440 of file encode.c.
4442{
4445 CRYPT_AsnEncodeRecipientInfo };
4448 { &recipientInfosSet, CRYPT_DEREncodeItemsAsSet, 0 },
4449 { &envelopedData->encryptedContentInfo,
4450 CRYPT_AsnEncodeEncryptedContentInfo, 0 },
4451 };
4452
4455}
static BOOL WINAPI CRYPT_AsnEncodeRecipientInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4404
static BOOL WINAPI CRYPT_AsnEncodeEncryptedContentInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4422
CRYPT_ENCRYPTED_CONTENT_INFO encryptedContentInfo
Definition: crypt32_private.h:109
PCMSG_KEY_TRANS_RECIPIENT_INFO rgRecipientInfo
Definition: crypt32_private.h:108
struct _CMSG_KEY_TRANS_RECIPIENT_INFO CMSG_KEY_TRANS_RECIPIENT_INFO
Referenced by CEnvelopedEncodeMsg_GetParam().
◆ CRYPT_AsnEncodePKCSSignerInfo()
|
static |
Definition at line 4189 of file encode.c.
4192{
4194
4196 {
4199 }
4200
4201 __TRY
4202 {
4204
4207 else
4208 {
4213 0 },
4214 };
4216 DWORD cItem = 3, cSwapped = 0;
4217
4219 {
4223 items[cItem].pvStructInfo = &swapped[cSwapped];
4225 cSwapped++;
4226 cItem++;
4227 }
4230 cItem++;
4233 cItem++;
4235 {
4239 items[cItem].pvStructInfo = &swapped[cSwapped];
4241 cSwapped++;
4242 cItem++;
4243 }
4245 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
4246 }
4247 }
4248 __EXCEPT_PAGE_FAULT
4249 {
4251 }
4252 __ENDTRY
4254}
Definition: wincrypt.h:880
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodePolicyQualifierUserNotice()
|
static |
Definition at line 1824 of file encode.c.
1828{
1830
1831 __TRY
1832 {
1835 CERT_NAME_VALUE displayTextValue;
1836 DWORD cItem = 0;
1837
1839 {
1842 cItem++;
1843 }
1845 {
1846 displayTextValue.dwValueType = CERT_RDN_BMP_STRING;
1847 displayTextValue.Value.cbData = 0;
1850 items[cItem].pvStructInfo = &displayTextValue;
1851 cItem++;
1852 }
1854 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
1855 }
1856 __EXCEPT_PAGE_FAULT
1857 {
1859 }
1860 __ENDTRY
1862}
static BOOL WINAPI CRYPT_AsnEncodeNoticeReference(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1805
Definition: wincrypt.h:419
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodePrintableString()
|
static |
Definition at line 2078 of file encode.c.
2081{
2084 DWORD bytesNeeded, lenBytes, encodedLen;
2085
2090 else
2091 encodedLen = 0;
2093 bytesNeeded = 1 + lenBytes + encodedLen;
2094 if (!pbEncoded)
2095 *pcbEncoded = bytesNeeded;
2096 else
2097 {
2099 pbEncoded, pcbEncoded, bytesNeeded)))
2100 {
2103
2106 else
2107 ptr = pbEncoded;
2110 ptr += lenBytes;
2112 {
2115 else
2116 {
2117 *pcbEncoded = i;
2120 }
2121 }
2124 }
2125 }
2127}
Referenced by CRYPT_AsnEncodeUnicodeNameValue().
◆ CRYPT_AsnEncodePubKeyInfo()
|
static |
Definition at line 419 of file encode.c.
422{
424
425 __TRY
426 {
431 };
432
437 pcbEncoded);
438 }
440 {
443 }
444 __ENDTRY
446}
Definition: wincrypt.h:233
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodePubKeyInfoNoNull()
| BOOL WINAPI CRYPT_AsnEncodePubKeyInfoNoNull | ( | DWORD | dwCertEncodingType, |
| LPCSTR | lpszStructType, | ||
| const void * | pvStructInfo, | ||
| DWORD | dwFlags, | ||
| PCRYPT_ENCODE_PARA | pEncodePara, | ||
| BYTE * | pbEncoded, | ||
| DWORD * | pcbEncoded | ||
| ) |
Definition at line 478 of file encode.c.
481{
487 };
488
493 pcbEncoded);
495}
Referenced by CRYPT_AsnEncodeCertInfo(), and CryptHashPublicKeyInfo().
◆ CRYPT_AsnEncodeRdn()
|
static |
Definition at line 1313 of file encode.c.
1316{
1319
1320 __TRY
1321 {
1323
1326 {
1331 else
1332 {
1335 }
1336 }
1338 {
1343 {
1347 else
1351 }
1353 {
1354 /* Have to propagate index of failing character */
1356 }
1357 }
1360 pbEncoded, pcbEncoded);
1363 }
1364 __EXCEPT_PAGE_FAULT
1365 {
1368 }
1369 __ENDTRY
1372}
static BOOL CRYPT_AsnEncodeRdnAttr(DWORD dwCertEncodingType, const CERT_RDN_ATTR *attr, CryptEncodeObjectExFunc nameValueEncodeFunc, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1122
Referenced by CRYPT_AsnEncodeName(), and CRYPT_AsnEncodeUnicodeName().
◆ CRYPT_AsnEncodeRdnAttr()
|
static |
Definition at line 1122 of file encode.c.
1125{
1128
1132 {
1133 bytesNeeded += size;
1134 /* hack: a CERT_RDN_ATTR is identical to a CERT_NAME_VALUE beginning
1135 * with dwValueType, so "cast" it to get its encoded size
1136 */
1140 {
1141 bytesNeeded += size;
1143 bytesNeeded += 1 + lenBytes;
1144 if (pbEncoded)
1145 {
1146 if (*pcbEncoded < bytesNeeded)
1147 {
1150 }
1151 else
1152 {
1153 *pbEncoded++ = ASN_SEQUENCE;
1154 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded,
1155 &lenBytes);
1156 pbEncoded += lenBytes;
1157 size = bytesNeeded - 1 - lenBytes;
1161 {
1162 pbEncoded += size;
1167 *pcbEncoded = size;
1168 }
1169 }
1170 }
1172 *pcbEncoded = bytesNeeded;
1173 }
1174 else
1175 {
1176 /* Have to propagate index of failing character */
1177 *pcbEncoded = size;
1178 }
1179 }
1181}
Referenced by CRYPT_AsnEncodeRdn().
◆ CRYPT_AsnEncodeRecipientInfo()
|
static |
Definition at line 4404 of file encode.c.
4407{
4411 { &info->RecipientId.IssuerSerialNumber,
4412 CRYPT_AsnEncodeIssuerSerialNumber, 0 },
4413 { &info->KeyEncryptionAlgorithm,
4414 CRYPT_AsnEncodeAlgorithmIdWithNullParams, 0 },
4416 };
4417
4420}
Definition: wincrypt.h:4158
Referenced by CRYPT_AsnEncodePKCSEnvelopedData().
◆ CRYPT_AsnEncodeRsaPubKey()
|
static |
Definition at line 3177 of file encode.c.
3180{
3182
3183 __TRY
3184 {
3186
3188 {
3191 }
3192 else
3193 {
3201 };
3202
3205 }
3206 }
3207 __EXCEPT_PAGE_FAULT
3208 {
3211 }
3212 __ENDTRY
3214}
Definition: wincrypt.h:144
Definition: wincrypt.h:151
struct _RSAPUBKEY RSAPUBKEY
struct _PUBLICKEYSTRUC BLOBHEADER
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeRsaPubKey_Bcrypt()
|
static |
Definition at line 3131 of file encode.c.
3134{
3136
3137 __TRY
3138 {
3140
3147
3149 { &modulus_int, CRYPT_AsnEncodeUnsignedInteger, 0 },
3150 { &pubexp_int, CRYPT_AsnEncodeInteger, 0 },
3151 };
3152
3153 /* CNG_RSA_PUBLIC_KEY_BLOB stores the exponent and modulus
3154 * in big-endian format, so we need to convert them
3155 * to little-endian format before encoding
3156 */
3159
3162
3163 CryptMemFree(pubexp_be);
3164 CryptMemFree(modulus_be);
3165 }
3166 __EXCEPT_PAGE_FAULT
3167 {
3170 }
3171 __ENDTRY
3173
3174}
void CRYPT_CopyReversed(BYTE *dst, const BYTE *src, size_t len)
Definition: decode.c:56
Definition: bcrypt.h:291
Definition: _function.h:69
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeSequence()
| BOOL WINAPI CRYPT_AsnEncodeSequence | ( | DWORD | dwCertEncodingType, |
| struct AsnEncodeSequenceItem | items[], | ||
| DWORD | cItem, | ||
| DWORD | dwFlags, | ||
| PCRYPT_ENCODE_PARA | pEncodePara, | ||
| BYTE * | pbEncoded, | ||
| DWORD * | pcbEncoded | ||
| ) |
Definition at line 174 of file encode.c.
177{
180
182 pbEncoded, pbEncoded ? *pcbEncoded : 0);
184 {
188 /* Some functions propagate their errors through the size */
192 }
194 {
195 DWORD lenBytes, bytesNeeded;
196
198 bytesNeeded = 1 + lenBytes + dataLen;
199 if (!pbEncoded)
200 *pcbEncoded = bytesNeeded;
201 else
202 {
204 pcbEncoded, bytesNeeded)))
205 {
207
209 pbEncoded = *(BYTE **)pbEncoded;
210 out = pbEncoded;
213 out += lenBytes;
215 {
219 /* Some functions propagate their errors through the size */
223 }
225 CRYPT_FreeSpace(pEncodePara, pbEncoded);
226 }
227 }
228 }
231}
Referenced by CRYPT_AsnEncodeAccessDescription(), CRYPT_AsnEncodeAlgorithmId(), CRYPT_AsnEncodeAlgorithmIdWithNullParams(), CRYPT_AsnEncodeAuthorityKeyId(), CRYPT_AsnEncodeAuthorityKeyId2(), CRYPT_AsnEncodeBasicConstraints(), CRYPT_AsnEncodeBasicConstraints2(), CRYPT_AsnEncodeCert(), CRYPT_AsnEncodeCertId(), CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeCertPolicy(), CRYPT_AsnEncodeCertPolicyConstraints(), CRYPT_AsnEncodeCertPolicyMapping(), CRYPT_AsnEncodeCertPolicyQualifiers(), CRYPT_AsnEncodeCMSSignedInfo(), CRYPT_AsnEncodeCMSSignerInfo(), CRYPT_AsnEncodeCRLEntry(), CRYPT_AsnEncodeCRLInfo(), CRYPT_AsnEncodeCTL(), CRYPT_AsnEncodeCTLEntry(), CRYPT_AsnEncodeCTLSubjectAlgorithm(), CRYPT_AsnEncodeDistPoint(), CRYPT_AsnEncodeEncryptedContentInfo(), CRYPT_AsnEncodeExtension(), CRYPT_AsnEncodeGeneralSubtree(), CRYPT_AsnEncodeIssuerSerialNumber(), CRYPT_AsnEncodeIssuingDistPoint(), CRYPT_AsnEncodeNameConstraints(), CRYPT_AsnEncodeNoticeReference(), CRYPT_AsnEncodeOCSPRequest(), CRYPT_AsnEncodeOCSPRequestEntry(), CRYPT_AsnEncodeOCSPSignedRequest(), CRYPT_AsnEncodePKCSAttribute(), CRYPT_AsnEncodePKCSContentInfoInternal(), CRYPT_AsnEncodePKCSDigestedData(), CRYPT_AsnEncodePKCSEnvelopedData(), CRYPT_AsnEncodePKCSSignerInfo(), CRYPT_AsnEncodePolicyQualifierUserNotice(), CRYPT_AsnEncodePubKeyInfo(), CRYPT_AsnEncodePubKeyInfoNoNull(), CRYPT_AsnEncodeRecipientInfo(), CRYPT_AsnEncodeRsaPubKey(), CRYPT_AsnEncodeRsaPubKey_Bcrypt(), CRYPT_AsnEncodeSMIMECapability(), CRYPT_AsnEncodeValidity(), and CRYPT_EncodeDataContentInfoHeader().
◆ CRYPT_AsnEncodeSequenceOfAny()
|
static |
Definition at line 3694 of file encode.c.
3697{
3699
3700 __TRY
3701 {
3704
3708 bytesNeeded = 1 + lenBytes + dataLen;
3709 if (!pbEncoded)
3710 {
3711 *pcbEncoded = bytesNeeded;
3713 }
3714 else
3715 {
3717 pcbEncoded, bytesNeeded)))
3718 {
3720 pbEncoded = *(BYTE **)pbEncoded;
3721 *pbEncoded++ = ASN_SEQUENCEOF;
3722 CRYPT_EncodeLen(dataLen, pbEncoded, &lenBytes);
3723 pbEncoded += lenBytes;
3725 {
3729 }
3730 }
3731 }
3732 }
3733 __EXCEPT_PAGE_FAULT
3734 {
3737 }
3738 __ENDTRY
3740}
Definition: wincrypt.h:466
Referenced by CRYPT_AsnEncodeBasicConstraints(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeSMIMECapabilities()
|
static |
Definition at line 1688 of file encode.c.
1691{
1693
1694 __TRY
1695 {
1698
1701 {
1703
1707 dataLen += size;
1708 }
1710 {
1712 bytesNeeded = 1 + lenBytes + dataLen;
1713 if (!pbEncoded)
1714 *pcbEncoded = bytesNeeded;
1715 else
1716 {
1718 pbEncoded, pcbEncoded, bytesNeeded)))
1719 {
1721
1723 pbEncoded = *(BYTE **)pbEncoded;
1724 out = pbEncoded;
1727 out += lenBytes;
1729 {
1731
1736 dataLen -= size;
1737 }
1739 CRYPT_FreeSpace(pEncodePara, pbEncoded);
1740 }
1741 }
1742 }
1743 }
1744 __EXCEPT_PAGE_FAULT
1745 {
1747 }
1748 __ENDTRY
1750}
static BOOL CRYPT_AsnEncodeSMIMECapability(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1656
Definition: wincrypt.h:803
PCRYPT_SMIME_CAPABILITY rgCapability
Definition: wincrypt.h:805
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeSMIMECapability()
|
static |
Definition at line 1656 of file encode.c.
1659{
1661
1662 __TRY
1663 {
1665
1668 else
1669 {
1673 };
1674
1677 pcbEncoded);
1678 }
1679 }
1680 __EXCEPT_PAGE_FAULT
1681 {
1683 }
1684 __ENDTRY
1686}
Definition: wincrypt.h:798
Referenced by CRYPT_AsnEncodeSMIMECapabilities().
◆ CRYPT_AsnEncodeStringCoerce()
|
static |
Definition at line 932 of file encode.c.
935{
938 DWORD bytesNeeded, lenBytes, encodedLen;
939
942 bytesNeeded = 1 + lenBytes + encodedLen;
943 if (!pbEncoded)
944 *pcbEncoded = bytesNeeded;
945 else
946 {
948 pbEncoded, pcbEncoded, bytesNeeded)))
949 {
951 pbEncoded = *(BYTE **)pbEncoded;
952 *pbEncoded++ = tag;
953 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
954 pbEncoded += lenBytes;
956 }
957 }
959}
Referenced by CRYPT_AsnEncodeNameValue().
◆ CRYPT_AsnEncodeSwapTag()
|
static |
Definition at line 292 of file encode.c.
Referenced by CRYPT_AsnEncodeAltNameEntry(), CRYPT_AsnEncodeAuthorityKeyId(), CRYPT_AsnEncodeAuthorityKeyId2(), CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeCertPolicyConstraints(), CRYPT_AsnEncodeCMSSignedInfo(), CRYPT_AsnEncodeCMSSignerInfo(), CRYPT_AsnEncodeDistPoint(), CRYPT_AsnEncodeEncryptedContentInfo(), CRYPT_AsnEncodeGeneralSubtree(), CRYPT_AsnEncodeIssuingDistPoint(), CRYPT_AsnEncodeNameConstraints(), and CRYPT_AsnEncodePKCSSignerInfo().
◆ CRYPT_AsnEncodeUnicodeName()
|
static |
Definition at line 1395 of file encode.c.
1398{
1400
1401 __TRY
1402 {
1405
1409 {
1413 bytesNeeded += size;
1414 else
1415 *pcbEncoded = size;
1416 }
1418 bytesNeeded += 1 + lenBytes;
1420 {
1421 if (!pbEncoded)
1422 *pcbEncoded = bytesNeeded;
1423 else
1424 {
1426 pbEncoded, pcbEncoded, bytesNeeded)))
1427 {
1429
1431 pbEncoded = *(BYTE **)pbEncoded;
1432 out = pbEncoded;
1435 out += lenBytes;
1437 {
1438 size = bytesNeeded;
1443 {
1445 bytesNeeded -= size;
1446 }
1447 else
1448 *pcbEncoded = size;
1449 }
1451 CRYPT_FreeSpace(pEncodePara, pbEncoded);
1452 }
1453 }
1454 }
1455 }
1456 __EXCEPT_PAGE_FAULT
1457 {
1460 }
1461 __ENDTRY
1463}
static BOOL WINAPI CRYPT_AsnEncodeOrCopyUnicodeNameValue(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1378
Referenced by CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeUnicodeNameValue()
|
static |
Definition at line 2223 of file encode.c.
2226{
2228
2229 __TRY
2230 {
2232
2234 {
2239 break;
2242 pbEncoded, pcbEncoded);
2243 break;
2246 pbEncoded, pcbEncoded);
2247 break;
2250 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2251 break;
2255 break;
2258 pbEncoded, pcbEncoded);
2259 break;
2262 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2263 break;
2266 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2267 break;
2270 dwFlags, pEncodePara, pbEncoded, pcbEncoded);
2271 break;
2274 pbEncoded, pcbEncoded);
2275 break;
2278 pbEncoded, pcbEncoded);
2279 break;
2282 pbEncoded, pcbEncoded);
2283 break;
2284 default:
2286 }
2287 }
2288 __EXCEPT_PAGE_FAULT
2289 {
2291 }
2292 __ENDTRY
2294}
static BOOL CRYPT_AsnEncodeIA5String(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2129
static BOOL CRYPT_AsnEncodeUniversalString(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2180
static BOOL CRYPT_AsnEncodePrintableString(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2078
static BOOL CRYPT_AsnEncodeNumericString(const CERT_NAME_VALUE *value, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2022
static BOOL CRYPT_AsnEncodeUnicodeStringCoerce(const CERT_NAME_VALUE *value, BYTE tag, DWORD dwFlags, const CRYPT_ENCODE_PARA *pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1985
Referenced by CRYPT_AsnEncodeOrCopyUnicodeNameValue(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeUnicodeStringCoerce()
|
static |
Definition at line 1985 of file encode.c.
1988{
1991 DWORD bytesNeeded, lenBytes, encodedLen;
1992
1997 else
1998 encodedLen = 0;
2000 bytesNeeded = 1 + lenBytes + encodedLen;
2001 if (!pbEncoded)
2002 *pcbEncoded = bytesNeeded;
2003 else
2004 {
2006 pbEncoded, pcbEncoded, bytesNeeded)))
2007 {
2009
2011 pbEncoded = *(BYTE **)pbEncoded;
2012 *pbEncoded++ = tag;
2013 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
2014 pbEncoded += lenBytes;
2017 }
2018 }
2020}
Referenced by CRYPT_AsnEncodeUnicodeNameValue().
◆ CRYPT_AsnEncodeUniversalString()
|
static |
Definition at line 2180 of file encode.c.
2183{
2186 DWORD bytesNeeded, lenBytes, strLen;
2187
2188 /* FIXME: doesn't handle composite characters */
2193 else
2194 strLen = 0;
2196 bytesNeeded = 1 + lenBytes + strLen * 4;
2197 if (!pbEncoded)
2198 *pcbEncoded = bytesNeeded;
2199 else
2200 {
2202 pbEncoded, pcbEncoded, bytesNeeded)))
2203 {
2205
2207 pbEncoded = *(BYTE **)pbEncoded;
2208 *pbEncoded++ = ASN_UNIVERSALSTRING;
2209 CRYPT_EncodeLen(strLen * 4, pbEncoded, &lenBytes);
2210 pbEncoded += lenBytes;
2212 {
2213 *pbEncoded++ = 0;
2214 *pbEncoded++ = 0;
2217 }
2218 }
2219 }
2221}
Referenced by CRYPT_AsnEncodeUnicodeNameValue().
◆ CRYPT_AsnEncodeUnsignedInteger()
|
static |
Definition at line 3469 of file encode.c.
3472{
3474
3475 __TRY
3476 {
3477 DWORD significantBytes, lenBytes, bytesNeeded;
3480
3481 significantBytes = blob->cbData;
3482 if (significantBytes)
3483 {
3484 /* positive, lop off leading (little-endian) zeroes */
3486 significantBytes--)
3487 ;
3488 if (significantBytes == 0)
3489 significantBytes = 1;
3491 pad = TRUE;
3492 }
3493 if (pad)
3495 else
3497 bytesNeeded = 1 + lenBytes + significantBytes;
3498 if (pad)
3499 bytesNeeded++;
3500 if (!pbEncoded)
3501 {
3502 *pcbEncoded = bytesNeeded;
3504 }
3505 else
3506 {
3508 pcbEncoded, bytesNeeded)))
3509 {
3511 pbEncoded = *(BYTE **)pbEncoded;
3512 *pbEncoded++ = ASN_INTEGER;
3513 if (pad)
3514 {
3515 CRYPT_EncodeLen(significantBytes + 1, pbEncoded, &lenBytes);
3516 pbEncoded += lenBytes;
3517 *pbEncoded++ = 0;
3518 }
3519 else
3520 {
3521 CRYPT_EncodeLen(significantBytes, pbEncoded, &lenBytes);
3522 pbEncoded += lenBytes;
3523 }
3524 for (; significantBytes > 0; significantBytes--)
3525 *(pbEncoded++) = blob->pbData[significantBytes - 1];
3526 }
3527 }
3528 }
3529 __EXCEPT_PAGE_FAULT
3530 {
3533 }
3534 __ENDTRY
3536}
Referenced by CRYPT_AsnEncodeEnumerated(), CRYPT_AsnEncodeRsaPubKey(), CRYPT_AsnEncodeRsaPubKey_Bcrypt(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeUtcTime()
|
static |
Definition at line 3559 of file encode.c.
3562{
3564
3565 __TRY
3566 {
3567 SYSTEMTIME sysTime;
3568 /* sorry, magic number: enough for tag, len, YYMMDDHHMMSSZ. I use a
3569 * temporary buffer because the output buffer is not NULL-terminated.
3570 */
3573
3574 if (!pbEncoded)
3575 {
3576 *pcbEncoded = bytesNeeded;
3578 }
3579 else
3580 {
3581 /* Sanity check the year, this is a two-digit year format */
3584 {
3587 }
3589 {
3591 pbEncoded, pcbEncoded, bytesNeeded)))
3592 {
3594 pbEncoded = *(BYTE **)pbEncoded;
3596 buf[1] = bytesNeeded - 2;
3603 }
3604 }
3605 }
3606 }
3607 __EXCEPT_PAGE_FAULT
3608 {
3611 }
3612 __ENDTRY
3614}
Referenced by CRYPT_AsnEncodeChoiceOfTime(), and CRYPT_GetBuiltinEncoder().
◆ CRYPT_AsnEncodeUTF8String()
|
static |
Definition at line 1001 of file encode.c.
1004{
1007 DWORD bytesNeeded, lenBytes, encodedLen, strLen;
1008
1013 else
1014 strLen = 0;
1016 NULL);
1018 bytesNeeded = 1 + lenBytes + encodedLen;
1019 if (!pbEncoded)
1020 *pcbEncoded = bytesNeeded;
1021 else
1022 {
1024 pbEncoded, pcbEncoded, bytesNeeded)))
1025 {
1027 pbEncoded = *(BYTE **)pbEncoded;
1028 *pbEncoded++ = ASN_UTF8STRING;
1029 CRYPT_EncodeLen(encodedLen, pbEncoded, &lenBytes);
1030 pbEncoded += lenBytes;
1033 }
1034 }
1036}
Referenced by CRYPT_AsnEncodeNameValue(), and CRYPT_AsnEncodeUnicodeNameValue().
◆ CRYPT_AsnEncodeValidity()
|
static |
Definition at line 356 of file encode.c.
359{
361 /* This has two filetimes in a row, a NotBefore and a NotAfter */
364 { timePtr, CRYPT_AsnEncodeChoiceOfTime, 0 },
365 { timePtr + 1, CRYPT_AsnEncodeChoiceOfTime, 0 },
366 };
367
370 pcbEncoded);
372}
Definition: mapidefs.h:60
Referenced by CRYPT_AsnEncodeCertInfo().
◆ CRYPT_CopyEncodedBlob()
|
static |
Definition at line 329 of file encode.c.
332{
335
336 if (!pbEncoded)
337 {
338 *pcbEncoded = blob->cbData;
340 }
341 else
342 {
344 pcbEncoded, blob->cbData)))
345 {
347 pbEncoded = *(BYTE **)pbEncoded;
350 *pcbEncoded = blob->cbData;
351 }
352 }
354}
Referenced by CRYPT_AsnEncodeAlgorithmId(), CRYPT_AsnEncodeAlgorithmIdWithNullParams(), CRYPT_AsnEncodeAuthorityKeyId(), CRYPT_AsnEncodeCert(), CRYPT_AsnEncodeCertInfo(), CRYPT_AsnEncodeCertPolicyQualifiers(), CRYPT_AsnEncodeCMSSignedInfo(), CRYPT_AsnEncodeCRLInfo(), CRYPT_AsnEncodeCTLSubjectAlgorithm(), CRYPT_AsnEncodeIssuerSerialNumber(), CRYPT_AsnEncodeNameValue(), CRYPT_AsnEncodeOCSPSignedRequest(), CRYPT_AsnEncodeOrCopyUnicodeNameValue(), CRYPT_AsnEncodePKCSContentInfoInternal(), and CRYPT_AsnEncodeSMIMECapability().
◆ CRYPT_DEREncodeItemsAsSet()
|
static |
Definition at line 1239 of file encode.c.
1242{
1247
1249 {
1253 else
1254 {
1257 }
1258 }
1260 {
1265 {
1269 else
1274 }
1275 /* Some functions propagate their errors through the size */
1278 }
1280 {
1281 DWORD bytesNeeded = 0, lenBytes;
1282
1286 bytesNeeded += 1 + lenBytes;
1287 if (!pbEncoded)
1288 *pcbEncoded = bytesNeeded;
1290 pbEncoded, pcbEncoded, bytesNeeded)))
1291 {
1293 pbEncoded = *(BYTE **)pbEncoded;
1295 BLOBComp);
1297 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes);
1298 pbEncoded += lenBytes;
1300 {
1304 }
1305 }
1306 }
1311}
_ACRTIMP void __cdecl qsort(void *, size_t, size_t, int(__cdecl *)(const void *, const void *))
Referenced by CRYPT_AsnEncodeCMSSignedInfo(), CRYPT_AsnEncodePKCSAttributes(), and CRYPT_AsnEncodePKCSEnvelopedData().
◆ CRYPT_DEREncodeSet()
|
static |
Definition at line 1195 of file encode.c.
1198{
1202
1206 bytesNeeded += 1 + lenBytes;
1207 if (!pbEncoded)
1208 {
1209 *pcbEncoded = bytesNeeded;
1211 }
1213 pbEncoded, pcbEncoded, bytesNeeded)))
1214 {
1216 pbEncoded = *(BYTE **)pbEncoded;
1219 CRYPT_EncodeLen(bytesNeeded - lenBytes - 1, pbEncoded, &lenBytes);
1220 pbEncoded += lenBytes;
1222 {
1225 }
1226 }
1228}
Referenced by CRYPT_AsnEncodeNameConstraints(), CRYPT_AsnEncodePKCSAttribute(), and CRYPT_AsnEncodeRdn().
◆ CRYPT_EncodeEnsureSpace()
| BOOL CRYPT_EncodeEnsureSpace | ( | DWORD | dwFlags, |
| const CRYPT_ENCODE_PARA * | pEncodePara, | ||
| BYTE * | pbEncoded, | ||
| DWORD * | pcbEncoded, | ||
| DWORD | bytesNeeded | ||
| ) |
Definition at line 97 of file encode.c.
99{
101
103 {
106 else
110 else
111 *pcbEncoded = bytesNeeded;
112 }
113 else if (bytesNeeded > *pcbEncoded)
114 {
115 *pcbEncoded = bytesNeeded;
118 }
119 else
120 *pcbEncoded = bytesNeeded;
122}
Referenced by CRYPT_AsnEncodeAltName(), CRYPT_AsnEncodeAuthorityInfoAccess(), CRYPT_AsnEncodeBits(), CRYPT_AsnEncodeBMPString(), CRYPT_AsnEncodeCertPolicies(), CRYPT_AsnEncodeCertPolicyMappings(), CRYPT_AsnEncodeCertPolicyQualifiers(), CRYPT_AsnEncodeConstructed(), CRYPT_AsnEncodeCRLDistPoints(), CRYPT_AsnEncodeCRLEntries(), CRYPT_AsnEncodeCTLEntries(), CRYPT_AsnEncodeEnhancedKeyUsage(), CRYPT_AsnEncodeExtensions(), CRYPT_AsnEncodeGeneralizedTime(), CRYPT_AsnEncodeIA5String(), CRYPT_AsnEncodeInteger(), CRYPT_AsnEncodeName(), CRYPT_AsnEncodeNoticeNumbers(), CRYPT_AsnEncodeNumericString(), CRYPT_AsnEncodeOCSPRequestEntries(), CRYPT_AsnEncodeOctets(), CRYPT_AsnEncodePrintableString(), CRYPT_AsnEncodeSequence(), CRYPT_AsnEncodeSequenceOfAny(), CRYPT_AsnEncodeSMIMECapabilities(), CRYPT_AsnEncodeStringCoerce(), CRYPT_AsnEncodeUnicodeName(), CRYPT_AsnEncodeUnicodeStringCoerce(), CRYPT_AsnEncodeUniversalString(), CRYPT_AsnEncodeUnsignedInteger(), CRYPT_AsnEncodeUtcTime(), CRYPT_AsnEncodeUTF8String(), CRYPT_CopyEncodedBlob(), CRYPT_DEREncodeItemsAsSet(), CRYPT_DEREncodeSet(), CRYPT_EncodeContentLength(), and CryptEncodeObjectEx().
◆ CRYPT_EncodeLen()
Definition at line 132 of file encode.c.
133{
134 DWORD bytesNeeded, significantBytes = 0;
135
137 bytesNeeded = 1;
138 else
139 {
141
143 temp <<= 8, significantBytes--)
144 ;
145 bytesNeeded = significantBytes + 1;
146 }
147 if (!pbEncoded)
148 {
149 *pcbEncoded = bytesNeeded;
151 }
152 if (*pcbEncoded < bytesNeeded)
153 {
156 }
159 else
160 {
162
163 *pbEncoded++ = significantBytes | 0x80;
165 {
167 len >>= 8;
168 }
169 }
170 *pcbEncoded = bytesNeeded;
172}
Referenced by CRYPT_AsnEncodeAltName(), CRYPT_AsnEncodeAltNameEntry(), CRYPT_AsnEncodeAuthorityInfoAccess(), CRYPT_AsnEncodeBits(), CRYPT_AsnEncodeBMPString(), CRYPT_AsnEncodeCertPolicies(), CRYPT_AsnEncodeCertPolicyMappings(), CRYPT_AsnEncodeCertPolicyQualifiers(), CRYPT_AsnEncodeConstructed(), CRYPT_AsnEncodeCRLDistPoints(), CRYPT_AsnEncodeCRLEntries(), CRYPT_AsnEncodeCTLEntries(), CRYPT_AsnEncodeEnhancedKeyUsage(), CRYPT_AsnEncodeExtensions(), CRYPT_AsnEncodeIA5String(), CRYPT_AsnEncodeInteger(), CRYPT_AsnEncodeName(), CRYPT_AsnEncodeNoticeNumbers(), CRYPT_AsnEncodeNumericString(), CRYPT_AsnEncodeOCSPRequestEntries(), CRYPT_AsnEncodeOctets(), CRYPT_AsnEncodeOid(), CRYPT_AsnEncodePrintableString(), CRYPT_AsnEncodeRdnAttr(), CRYPT_AsnEncodeSequence(), CRYPT_AsnEncodeSequenceOfAny(), CRYPT_AsnEncodeSMIMECapabilities(), CRYPT_AsnEncodeStringCoerce(), CRYPT_AsnEncodeUnicodeName(), CRYPT_AsnEncodeUnicodeStringCoerce(), CRYPT_AsnEncodeUniversalString(), CRYPT_AsnEncodeUnsignedInteger(), CRYPT_AsnEncodeUTF8String(), CRYPT_DEREncodeItemsAsSet(), CRYPT_DEREncodeSet(), and CRYPT_EncodeContentLength().
◆ CRYPT_ExportPublicKeyInfoEx()
|
static |
Definition at line 5026 of file encode.c.
5029{
5033
5036 pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
5037
5039 {
5040 DWORD keySize = 0;
5041
5044 {
5046
5048 {
5051 {
5052 DWORD encodedLen;
5053
5054 if (!pszPublicKeyObjId)
5055 {
5059
5062
5065
5066 CryptGetOIDFunctionAddress(set, dwCertEncodingType, pszPublicKeyObjId, 0, (void **)&encodeFunc, &hFunc);
5067 if (encodeFunc)
5068 {
5070 DWORD key_size = 0;
5072 DWORD params_size = 0;
5073
5077 {
5080
5081 if (!pInfo)
5082 *pcbInfo = size_needed;
5083 else if (*pcbInfo < size_needed)
5084 {
5085 *pcbInfo = size_needed;
5088 }
5089 else
5090 {
5091 *pcbInfo = size_needed;
5092 pInfo->Algorithm.pszObjId = (char *)(pInfo + 1);
5093 lstrcpyA(pInfo->Algorithm.pszObjId, pszPublicKeyObjId);
5095 {
5096 pInfo->Algorithm.Parameters.cbData = params_size;
5097 pInfo->Algorithm.Parameters.pbData = (BYTE *)pInfo->Algorithm.pszObjId + oid_size;
5099 }
5100 else
5101 {
5102 pInfo->Algorithm.Parameters.cbData = 0;
5103 pInfo->Algorithm.Parameters.pbData = NULL;
5104 }
5105 pInfo->PublicKey.pbData = (BYTE *)pInfo->Algorithm.pszObjId + oid_size + params_size;
5106 pInfo->PublicKey.cbData = key_size;
5107 memcpy(pInfo->PublicKey.pbData, key_data, key_size);
5108 pInfo->PublicKey.cUnusedBits = 0;
5109 }
5110
5111 CryptMemFree(key_data);
5113 }
5114
5116 CryptFreeOIDFunctionAddress(hFunc, 0);
5118 }
5119
5120 /* fallback to RSA */
5121 pszPublicKeyObjId = rsa_oid;
5122 }
5123
5124 encodedLen = 0;
5128 {
5130 strlen(pszPublicKeyObjId) + 1 + encodedLen;
5131
5132 if (!pInfo)
5133 *pcbInfo = sizeNeeded;
5134 else if (*pcbInfo < sizeNeeded)
5135 {
5137 *pcbInfo = sizeNeeded;
5139 }
5140 else
5141 {
5142 *pcbInfo = sizeNeeded;
5143 pInfo->Algorithm.pszObjId = (char *)pInfo +
5145 lstrcpyA(pInfo->Algorithm.pszObjId,
5146 pszPublicKeyObjId);
5147 pInfo->Algorithm.Parameters.cbData = 0;
5148 pInfo->Algorithm.Parameters.pbData = NULL;
5149 pInfo->PublicKey.pbData =
5150 (BYTE *)pInfo->Algorithm.pszObjId
5151 + lstrlenA(pInfo->Algorithm.pszObjId) + 1;
5152 pInfo->PublicKey.cbData = encodedLen;
5153 pInfo->PublicKey.cUnusedBits = 0;
5156 pInfo->PublicKey.pbData, &pInfo->PublicKey.cbData);
5157 }
5158 }
5159 }
5161 }
5162 else
5164 }
5166 }
5168}
BOOL WINAPI CryptExportKey(HCRYPTKEY hKey, HCRYPTKEY hExpKey, DWORD dwBlobType, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
Definition: crypt.c:1383
BOOL WINAPI CryptGetUserKey(HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey)
Definition: crypt.c:1694
BOOL WINAPI CryptEncodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4909
BOOL(WINAPI * EncodePublicKeyAndParametersFunc)(DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, BYTE *pbPubKey, DWORD cbPubKey, DWORD dwFlags, void *pvAuxInfo, BYTE **ppPublicKey, DWORD *pcbPublicKey, BYTE **ppbParams, DWORD *pcbParams)
Definition: encode.c:5022
HCRYPTOIDFUNCSET WINAPI CryptInitOIDFunctionSet(LPCSTR pszFuncName, DWORD dwFlags)
Definition: oid.c:103
BOOL WINAPI CryptGetOIDFunctionAddress(HCRYPTOIDFUNCSET hFuncSet, DWORD dwEncodingType, LPCSTR pszOID, DWORD dwFlags, void **ppvFuncAddr, HCRYPTOIDFUNCADDR *phFuncAddr)
Definition: oid.c:375
BOOL WINAPI CryptFreeOIDFunctionAddress(HCRYPTOIDFUNCADDR hFuncAddr, DWORD dwFlags)
Definition: oid.c:456
Definition: nsiface.idl:2307
struct _CERT_PUBLIC_KEY_INFO CERT_PUBLIC_KEY_INFO
Referenced by CryptExportPublicKeyInfoEx().
◆ CRYPT_FreeSpace()
|
static |
Definition at line 124 of file encode.c.
Referenced by CRYPT_AsnEncodeAltName(), CRYPT_AsnEncodeAuthorityInfoAccess(), CRYPT_AsnEncodeCertPolicies(), CRYPT_AsnEncodeCertPolicyMappings(), CRYPT_AsnEncodeCertPolicyQualifiers(), CRYPT_AsnEncodeConstructed(), CRYPT_AsnEncodeCRLDistPoints(), CRYPT_AsnEncodeCRLEntries(), CRYPT_AsnEncodeCTLEntries(), CRYPT_AsnEncodeEnhancedKeyUsage(), CRYPT_AsnEncodeExtensions(), CRYPT_AsnEncodeIA5String(), CRYPT_AsnEncodeName(), CRYPT_AsnEncodeNoticeNumbers(), CRYPT_AsnEncodeNumericString(), CRYPT_AsnEncodeOCSPRequestEntries(), CRYPT_AsnEncodePrintableString(), CRYPT_AsnEncodeSequence(), CRYPT_AsnEncodeSMIMECapabilities(), and CRYPT_AsnEncodeUnicodeName().
◆ CRYPT_GetBuiltinEncoder()
|
static |
Definition at line 4676 of file encode.c.
4678{
4680
4683 {
4686 }
4687
4689 {
4691 {
4693 encodeFunc = CRYPT_AsnEncodeCert;
4694 break;
4696 encodeFunc = CRYPT_AsnEncodeCertInfo;
4697 break;
4699 encodeFunc = CRYPT_AsnEncodeCRLInfo;
4700 break;
4702 encodeFunc = CRYPT_AsnEncodeExtensions;
4703 break;
4705 encodeFunc = CRYPT_AsnEncodeNameValue;
4706 break;
4708 encodeFunc = CRYPT_AsnEncodeName;
4709 break;
4711 encodeFunc = CRYPT_AsnEncodePubKeyInfo;
4712 break;
4714 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId;
4715 break;
4717 encodeFunc = CRYPT_AsnEncodeAltName;
4718 break;
4720 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
4721 break;
4723 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
4724 break;
4726 encodeFunc = CRYPT_AsnEncodeCertPolicies;
4727 break;
4729 encodeFunc = CRYPT_AsnEncodeRsaPubKey;
4730 break;
4732 encodeFunc = CRYPT_AsnEncodeUnicodeName;
4733 break;
4735 encodeFunc = CRYPT_AsnEncodePKCSContentInfo;
4736 break;
4738 encodeFunc = CRYPT_AsnEncodePKCSAttribute;
4739 break;
4741 encodeFunc = CRYPT_AsnEncodeUnicodeNameValue;
4742 break;
4744 encodeFunc = CRYPT_AsnEncodeOctets;
4745 break;
4748 encodeFunc = CRYPT_AsnEncodeBits;
4749 break;
4751 encodeFunc = CRYPT_AsnEncodeInt;
4752 break;
4754 encodeFunc = CRYPT_AsnEncodeInteger;
4755 break;
4757 encodeFunc = CRYPT_AsnEncodeUnsignedInteger;
4758 break;
4760 encodeFunc = CRYPT_AsnEncodeEnumerated;
4761 break;
4763 encodeFunc = CRYPT_AsnEncodeChoiceOfTime;
4764 break;
4766 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2;
4767 break;
4769 encodeFunc = CRYPT_AsnEncodeAuthorityInfoAccess;
4770 break;
4772 encodeFunc = CRYPT_AsnEncodeSequenceOfAny;
4773 break;
4775 encodeFunc = CRYPT_AsnEncodeUtcTime;
4776 break;
4778 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
4779 break;
4781 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
4782 break;
4784 encodeFunc = CRYPT_AsnEncodeCTL;
4785 break;
4787 encodeFunc = CRYPT_AsnEncodeSMIMECapabilities;
4788 break;
4790 encodeFunc = CRYPT_AsnEncodePolicyQualifierUserNotice;
4791 break;
4793 encodeFunc = CRYPT_AsnEncodePKCSAttributes;
4794 break;
4796 encodeFunc = CRYPT_AsnEncodeIssuingDistPoint;
4797 break;
4799 encodeFunc = CRYPT_AsnEncodeNameConstraints;
4800 break;
4802 encodeFunc = CRYPT_AsnEncodeCertPolicyMappings;
4803 break;
4805 encodeFunc = CRYPT_AsnEncodeCertPolicyConstraints;
4806 break;
4808 encodeFunc = CRYPT_AsnEncodePKCSSignerInfo;
4809 break;
4811 encodeFunc = CRYPT_AsnEncodeCMSSignerInfo;
4812 break;
4814 encodeFunc = CRYPT_AsnEncodeRsaPubKey_Bcrypt;
4815 break;
4817 encodeFunc = CRYPT_AsnEncodeOCSPRequest;
4818 break;
4820 encodeFunc = CRYPT_AsnEncodeOCSPSignedRequest;
4821 break;
4822 default:
4824 }
4825 }
4827 encodeFunc = CRYPT_AsnEncodeExtensions;
4829 encodeFunc = CRYPT_AsnEncodeUtcTime;
4831 encodeFunc = CRYPT_AsnEncodeUtcTime;
4833 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId;
4835 encodeFunc = CRYPT_AsnEncodeCertPolicyMappings;
4837 encodeFunc = CRYPT_AsnEncodeAuthorityKeyId2;
4839 encodeFunc = CRYPT_AsnEncodeEnumerated;
4841 encodeFunc = CRYPT_AsnEncodeBits;
4843 encodeFunc = CRYPT_AsnEncodeOctets;
4845 encodeFunc = CRYPT_AsnEncodeBasicConstraints;
4847 encodeFunc = CRYPT_AsnEncodeBasicConstraints2;
4849 encodeFunc = CRYPT_AsnEncodeAltName;
4851 encodeFunc = CRYPT_AsnEncodeAltName;
4853 encodeFunc = CRYPT_AsnEncodeAltName;
4855 encodeFunc = CRYPT_AsnEncodeAltName;
4857 encodeFunc = CRYPT_AsnEncodeAltName;
4859 encodeFunc = CRYPT_AsnEncodeCRLDistPoints;
4861 encodeFunc = CRYPT_AsnEncodeCertPolicies;
4863 encodeFunc = CRYPT_AsnEncodeCertPolicyMappings;
4865 encodeFunc = CRYPT_AsnEncodeCertPolicyConstraints;
4867 encodeFunc = CRYPT_AsnEncodeEnhancedKeyUsage;
4869 encodeFunc = CRYPT_AsnEncodeIssuingDistPoint;
4871 encodeFunc = CRYPT_AsnEncodeNameConstraints;
4873 encodeFunc = CRYPT_AsnEncodeAuthorityInfoAccess;
4875 encodeFunc = CRYPT_AsnEncodePolicyQualifierUserNotice;
4877 encodeFunc = CRYPT_AsnEncodeCTL;
4878 else
4880 return encodeFunc;
4881}
BOOL(WINAPI * CryptEncodeObjectExFunc)(DWORD, LPCSTR, const void *, DWORD, PCRYPT_ENCODE_PARA, BYTE *, DWORD *)
Definition: crypt32_private.h:55
static BOOL WINAPI CRYPT_AsnEncodeCertPolicyMappings(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3019
static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId2(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2634
static BOOL WINAPI CRYPT_AsnEncodeCRLInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:668
static BOOL WINAPI CRYPT_AsnEncodeAuthorityInfoAccess(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2705
static BOOL WINAPI CRYPT_AsnEncodeNameConstraints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4078
static BOOL WINAPI CRYPT_AsnEncodePKCSSignerInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4189
static BOOL WINAPI CRYPT_AsnEncodePolicyQualifierUserNotice(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1824
static BOOL WINAPI CRYPT_AsnEncodeUnicodeName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1395
static BOOL WINAPI CRYPT_AsnEncodeSMIMECapabilities(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1688
static BOOL WINAPI CRYPT_AsnEncodeAuthorityKeyId(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2497
static BOOL WINAPI CRYPT_AsnEncodeName(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2296
static BOOL WINAPI CRYPT_AsnEncodeIssuingDistPoint(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3951
static BOOL WINAPI CRYPT_AsnEncodeRsaPubKey(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3177
static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2769
static BOOL WINAPI CRYPT_AsnEncodeOCSPRequest(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4589
static BOOL WINAPI CRYPT_AsnEncodeCertPolicies(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2937
static BOOL WINAPI CRYPT_AsnEncodeCertPolicyConstraints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3084
static BOOL WINAPI CRYPT_AsnEncodePubKeyInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:419
static BOOL WINAPI CRYPT_AsnEncodeCertInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:501
static BOOL WINAPI CRYPT_AsnEncodeRsaPubKey_Bcrypt(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3131
static BOOL WINAPI CRYPT_AsnEncodeBasicConstraints2(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:2808
static BOOL WINAPI CRYPT_AsnEncodeCTL(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1590
static BOOL WINAPI CRYPT_AsnEncodeCert(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:448
static BOOL WINAPI CRYPT_AsnEncodePKCSContentInfo(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:1960
static BOOL WINAPI CRYPT_AsnEncodeEnumerated(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3538
static BOOL WINAPI CRYPT_AsnEncodeOCSPSignedRequest(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:4649
static BOOL WINAPI CRYPT_AsnEncodeCRLDistPoints(DWORD dwCertEncodingType, LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
Definition: encode.c:3801
#define szOID_PKIX_POLICY_QUALIFIER_USERNOTICE
Definition: wincrypt.h:3448
#define X509_PKIX_POLICY_QUALIFIER_USERNOTICE
Definition: wincrypt.h:3566
Referenced by CryptEncodeObject(), and CryptEncodeObjectEx().
◆ CRYPT_ImportPublicKeyInfoEx()
|
static |
Definition at line 5221 of file encode.c.
5224{
5229 DWORD pubKeySize;
5231
5233 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
5234
5238 0, (void **)&convertFunc, &hFunc);
5239 if (convertFunc)
5240 {
5242 pubKeySize = 0;
5245 {
5248 }
5249
5250 CryptFreeOIDFunctionAddress(hFunc, 0);
5252 }
5253
5255 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, NULL, &pubKeySize);
5257 {
5259
5261 {
5263 pInfo->PublicKey.pbData, pInfo->PublicKey.cbData, 0, pubKey,
5264 &pubKeySize);
5266 {
5267 if(aiKeyAlg)
5270 phKey);
5271 }
5273 }
5274 else
5276 }
5278}
BOOL WINAPI CryptDecodeObject(DWORD dwCertEncodingType, LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo)
Definition: decode.c:6990
BOOL WINAPI CryptImportKey(HCRYPTPROV hProv, const BYTE *pbData, DWORD dwDataLen, HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY *phKey)
Definition: crypt.c:1820
BOOL(WINAPI * ConvertPublicKeyInfoFunc)(DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, BYTE **ppbData, DWORD *dwDataLen)
Definition: encode.c:5217
#define CRYPT_OID_CONVERT_PUBLIC_KEY_INFO_FUNC
Definition: wincrypt.h:2677
Referenced by CryptImportPublicKeyInfoEx().
◆ CRYPT_LoadEncoderExFunc()
|
static |
Definition at line 4896 of file encode.c.
4898{
4901
4905 (void **)&encodeFunc, hFunc);
4906 return encodeFunc;
4907}
Referenced by CryptEncodeObject(), and CryptEncodeObjectEx().
◆ CRYPT_LoadEncoderFunc()
|
static |
Definition at line 4883 of file encode.c.
4885{
4888
4892 (void **)&encodeFunc, hFunc);
4893 return encodeFunc;
4894}
BOOL(WINAPI * CryptEncodeObjectFunc)(DWORD, LPCSTR, const void *, BYTE *, DWORD *)
Definition: encode.c:49
Referenced by CryptEncodeObject(), and CryptEncodeObjectEx().
◆ CryptEncodeObject()
| BOOL WINAPI CryptEncodeObject | ( | DWORD | dwCertEncodingType, |
| LPCSTR | lpszStructType, | ||
| const void * | pvStructInfo, | ||
| BYTE * | pbEncoded, | ||
| DWORD * | pcbEncoded | ||
| ) |
Definition at line 4909 of file encode.c.
4911{
4916
4918 debugstr_a(lpszStructType), pvStructInfo, pbEncoded,
4919 pcbEncoded);
4920
4921 if (!pbEncoded && !pcbEncoded)
4922 {
4925 }
4926
4928 lpszStructType)))
4929 {
4931 debugstr_a(lpszStructType));
4932 pCryptEncodeObject = CRYPT_LoadEncoderFunc(dwCertEncodingType,
4933 lpszStructType, &hFunc);
4934 if (!pCryptEncodeObject)
4935 pCryptEncodeObjectEx = CRYPT_LoadEncoderExFunc(dwCertEncodingType,
4936 lpszStructType, &hFunc);
4937 }
4938 if (pCryptEncodeObject)
4939 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
4940 pvStructInfo, pbEncoded, pcbEncoded);
4941 else if (pCryptEncodeObjectEx)
4942 ret = pCryptEncodeObjectEx(dwCertEncodingType, lpszStructType,
4943 pvStructInfo, 0, NULL, pbEncoded, pcbEncoded);
4944 if (hFunc)
4945 CryptFreeOIDFunctionAddress(hFunc, 0);
4948}
static CryptEncodeObjectExFunc CRYPT_LoadEncoderExFunc(DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
Definition: encode.c:4896
static CryptEncodeObjectFunc CRYPT_LoadEncoderFunc(DWORD dwCertEncodingType, LPCSTR lpszStructType, HCRYPTOIDFUNCADDR *hFunc)
Definition: encode.c:4883
static CryptEncodeObjectExFunc CRYPT_GetBuiltinEncoder(DWORD dwCertEncodingType, LPCSTR lpszStructType)
Definition: encode.c:4676
Referenced by CDataEncodeMsg_GetParam(), CRYPT_CopyKeyIdAsIssuerAndSerial(), CRYPT_ExportPublicKeyInfoEx(), CRYPT_SizeOfKeyIdAsIssuerAndSerial(), and CryptSignAndEncodeCertificate().
◆ CryptEncodeObjectEx()
| BOOL WINAPI CryptEncodeObjectEx | ( | DWORD | dwCertEncodingType, |
| LPCSTR | lpszStructType, | ||
| const void * | pvStructInfo, | ||
| DWORD | dwFlags, | ||
| PCRYPT_ENCODE_PARA | pEncodePara, | ||
| void * | pvEncoded, | ||
| DWORD * | pcbEncoded | ||
| ) |
Definition at line 4950 of file encode.c.
4953{
4957
4960 pvEncoded, pcbEncoded);
4961
4962 if (!pvEncoded && !pcbEncoded)
4963 {
4966 }
4967
4970 if (!pvEncoded) {
4973 }
4975 }
4976 encodeFunc = CRYPT_GetBuiltinEncoder(dwCertEncodingType, lpszStructType);
4977 if (!encodeFunc)
4978 {
4980 debugstr_a(lpszStructType));
4981 encodeFunc = CRYPT_LoadEncoderExFunc(dwCertEncodingType, lpszStructType,
4982 &hFunc);
4983 }
4984 if (encodeFunc)
4985 ret = encodeFunc(dwCertEncodingType, lpszStructType, pvStructInfo,
4986 dwFlags, pEncodePara, pvEncoded, pcbEncoded);
4987 else
4988 {
4989 CryptEncodeObjectFunc pCryptEncodeObject =
4990 CRYPT_LoadEncoderFunc(dwCertEncodingType, lpszStructType, &hFunc);
4991
4992 if (pCryptEncodeObject)
4993 {
4995 {
4996 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
4997 pvStructInfo, NULL, pcbEncoded);
4999 pvEncoded, pcbEncoded, *pcbEncoded)))
5000 ret = pCryptEncodeObject(dwCertEncodingType,
5001 lpszStructType, pvStructInfo, *(BYTE **)pvEncoded,
5002 pcbEncoded);
5003 }
5004 else
5005 ret = pCryptEncodeObject(dwCertEncodingType, lpszStructType,
5006 pvStructInfo, pvEncoded, pcbEncoded);
5007 }
5008 }
5009 if (hFunc)
5010 CryptFreeOIDFunctionAddress(hFunc, 0);
5013}
Referenced by build_ocsp_request(), CDataEncodeMsg_Update(), CDecodeSignedMsg_GetParam(), CEnvelopedEncodeMsg_GetParam(), CertCreateSelfSignCertificate(), CertSetEnhancedKeyUsage(), CertStrToNameW(), CHashEncodeMsg_GetParam(), CRYPT_CreateSignedCert(), CRYPT_EncodeValueWithType(), CryptMsgEncodeAndSignCTL(), CSignedEncodeMsg_GetParam(), CSignedMsgData_UpdateAuthenticatedAttributes(), test_encodeAltName(), test_encodeAuthorityInfoAccess(), test_encodeAuthorityKeyId(), test_encodeAuthorityKeyId2(), test_encodeBasicConstraints(), test_encodeBits(), test_encodeCert(), test_encodeCertPolicies(), test_encodeCertPolicyConstraints(), test_encodeCertPolicyMappings(), test_encodeCertToBeSigned(), test_encodeCMSSignerInfo(), test_encodeCRLDistPoints(), test_encodeCRLIssuingDistPoint(), test_encodeCRLToBeSigned(), test_encodeCTL(), test_encodeEnhancedKeyUsage(), test_encodeEnumerated(), test_encodeExtensions(), test_encodeInt(), test_encodeName(), test_encodeNameConstraints(), test_encodeNameValue(), test_encodeOCSPRequestInfo(), test_encodeOctets(), test_encodePKCSAttribute(), test_encodePKCSAttributes(), test_encodePKCSContentInfo(), test_encodePKCSSignerInfo(), test_encodePKCSSMimeCapabilities(), test_encodePolicyQualifierUserNotice(), test_encodePublicKeyInfo(), test_encodeRsaPublicKey(), test_encodeRsaPublicKey_Bcrypt(), test_encodeSequenceOfAny(), test_encodeUnicodeName(), test_encodeUnicodeNameValue(), test_quoted_RDN(), testAcquireCertPrivateKey(), testTimeEncoding(), testVerifyCertSig(), and testVerifyCertSigEx().
◆ CryptExportPublicKeyInfo()
| BOOL WINAPI CryptExportPublicKeyInfo | ( | HCRYPTPROV_OR_NCRYPT_KEY_HANDLE | hCryptProv, |
| DWORD | dwKeySpec, | ||
| DWORD | dwCertEncodingType, | ||
| PCERT_PUBLIC_KEY_INFO | pInfo, | ||
| DWORD * | pcbInfo | ||
| ) |
Definition at line 5015 of file encode.c.
5017{
5020}
BOOL WINAPI CryptExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
Definition: encode.c:5174
Referenced by CertCreateSelfSignCertificate().
◆ CryptExportPublicKeyInfoEx()
| BOOL WINAPI CryptExportPublicKeyInfoEx | ( | HCRYPTPROV_OR_NCRYPT_KEY_HANDLE | hCryptProv, |
| DWORD | dwKeySpec, | ||
| DWORD | dwCertEncodingType, | ||
| LPSTR | pszPublicKeyObjId, | ||
| DWORD | dwFlags, | ||
| void * | pvAuxInfo, | ||
| PCERT_PUBLIC_KEY_INFO | pInfo, | ||
| DWORD * | pcbInfo | ||
| ) |
Definition at line 5174 of file encode.c.
5177{
5182
5185 pvAuxInfo, pInfo, pInfo ? *pcbInfo : 0);
5186
5187 if (!hCryptProv)
5188 {
5191 }
5192
5193 if (pszPublicKeyObjId)
5194 {
5197 0);
5199 0, (void **)&exportFunc, &hFunc);
5200 }
5201 if (!exportFunc)
5202 exportFunc = CRYPT_ExportPublicKeyInfoEx;
5203 ret = exportFunc(hCryptProv, dwKeySpec, dwCertEncodingType,
5204 pszPublicKeyObjId, dwFlags, pvAuxInfo, pInfo, pcbInfo);
5205 if (hFunc)
5206 CryptFreeOIDFunctionAddress(hFunc, 0);
5208}
static BOOL WINAPI CRYPT_ExportPublicKeyInfoEx(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
Definition: encode.c:5026
BOOL(WINAPI * ExportPublicKeyInfoExFunc)(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec, DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags, void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
Definition: encode.c:5170
#define CRYPT_OID_EXPORT_PUBLIC_KEY_INFO_FUNC
Definition: wincrypt.h:2671
Referenced by CryptExportPublicKeyInfo(), testAcquireCertPrivateKey(), testExportPublicKey(), testVerifyCertSig(), and testVerifyCertSigEx().
◆ CryptImportPublicKeyInfo()
| BOOL WINAPI CryptImportPublicKeyInfo | ( | HCRYPTPROV | hCryptProv, |
| DWORD | dwCertEncodingType, | ||
| PCERT_PUBLIC_KEY_INFO | pInfo, | ||
| HCRYPTKEY * | phKey | ||
| ) |
Definition at line 5210 of file encode.c.
5212{
5214 0, 0, NULL, phKey);
5215}
BOOL WINAPI CryptImportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
Definition: encode.c:5284
Referenced by CDecodeSignedMsg_VerifySignatureWithKey(), CertGetPublicKeyLength(), CRYPT_ExportKeyTrans(), test_verify_ecc_signature(), and testAcquireCertPrivateKey().
◆ CryptImportPublicKeyInfoEx()
| BOOL WINAPI CryptImportPublicKeyInfoEx | ( | HCRYPTPROV | hCryptProv, |
| DWORD | dwCertEncodingType, | ||
| PCERT_PUBLIC_KEY_INFO | pInfo, | ||
| ALG_ID | aiKeyAlg, | ||
| DWORD | dwFlags, | ||
| void * | pvAuxInfo, | ||
| HCRYPTKEY * | phKey | ||
| ) |
Definition at line 5284 of file encode.c.
5287{
5292
5294 dwCertEncodingType, pInfo, aiKeyAlg, dwFlags, pvAuxInfo, phKey);
5295
5299 pInfo->Algorithm.pszObjId, 0, (void **)&importFunc, &hFunc);
5300 if (!importFunc)
5301 importFunc = CRYPT_ImportPublicKeyInfoEx;
5303 pvAuxInfo, phKey);
5304 if (hFunc)
5305 CryptFreeOIDFunctionAddress(hFunc, 0);
5307}
static BOOL WINAPI CRYPT_ImportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
Definition: encode.c:5221
BOOL(WINAPI * ImportPublicKeyInfoExFunc)(HCRYPTPROV hCryptProv, DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, ALG_ID aiKeyAlg, DWORD dwFlags, void *pvAuxInfo, HCRYPTKEY *phKey)
Definition: encode.c:5280
#define CRYPT_OID_IMPORT_PUBLIC_KEY_INFO_FUNC
Definition: wincrypt.h:2672
Referenced by CRYPT_VerifySignature(), CryptImportPublicKeyInfo(), rdssl_cert_to_rkey(), test_VerifySignature(), testImportPublicKey(), and verify_signed_ocsp_response_info().
◆ CryptImportPublicKeyInfoEx2()
| BOOL WINAPI CryptImportPublicKeyInfoEx2 | ( | DWORD | dwCertEncodingType, |
| PCERT_PUBLIC_KEY_INFO | pInfo, | ||
| DWORD | dwFlags, | ||
| void * | pvAuxInfo, | ||
| BCRYPT_KEY_HANDLE * | phKey | ||
| ) |
Definition at line 5309 of file encode.c.
5312{
5314 dwFlags, pvAuxInfo, phKey);
5315
5318
5320}
BOOL CNG_ImportPubKey(CERT_PUBLIC_KEY_INFO *pubKeyInfo, BCRYPT_KEY_HANDLE *key)
Definition: cert.c:2770
Referenced by cng_verify_msg_signature(), test_verify_ecc_signature(), test_VerifySignature(), and testImportPublicKey().
◆ isprintableW()
Definition at line 2073 of file encode.c.
2074{
2075 return wc && wcschr( L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 '()+,-./:=?", wc );
2076}
Referenced by CRYPT_AsnEncodePrintableString().
◆ WINE_DECLARE_DEBUG_CHANNEL()
| WINE_DECLARE_DEBUG_CHANNEL | ( | crypt | ) |
◆ WINE_DEFAULT_DEBUG_CHANNEL()
| WINE_DEFAULT_DEBUG_CHANNEL | ( | cryptasn | ) |
