#include "winnls.h"
#include "rpc.h"
#include "wine/debug.h"
+#include "wine/unicode.h"
#include "crypt32_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(crypt);
ret = CryptDecodeObjectEx(dwCertEncodingType, X509_CERT_TO_BE_SIGNED,
pbCertEncoded, cbCertEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
- (BYTE *)&certInfo, &size);
+ &certInfo, &size);
if (ret)
{
BYTE *data = NULL;
}
end:
- return (PCCERT_CONTEXT)cert;
+ return cert;
}
PCCERT_CONTEXT WINAPI CertDuplicateCertificateContext(
PCCERT_CONTEXT pCertContext)
{
TRACE("(%p)\n", pCertContext);
+
+ if (!pCertContext)
+ return NULL;
+
Context_AddRef((void *)pCertContext, sizeof(CERT_CONTEXT));
return pCertContext;
}
static void CertDataContext_Free(void *context)
{
- PCERT_CONTEXT certContext = (PCERT_CONTEXT)context;
+ PCERT_CONTEXT certContext = context;
CryptMemFree(certContext->pbCertEncoded);
LocalFree(certContext->pCertInfo);
DWORD dwPropId)
{
PCONTEXT_PROPERTY_LIST properties = Context_GetProperties(
- (void *)pCertContext, sizeof(CERT_CONTEXT));
+ pCertContext, sizeof(CERT_CONTEXT));
DWORD ret;
TRACE("(%p, %d)\n", pCertContext, dwPropId);
static BOOL CertContext_GetProperty(void *context, DWORD dwPropId,
void *pvData, DWORD *pcbData)
{
- PCCERT_CONTEXT pCertContext = (PCCERT_CONTEXT)context;
+ PCCERT_CONTEXT pCertContext = context;
PCONTEXT_PROPERTY_LIST properties =
Context_GetProperties(context, sizeof(CERT_CONTEXT));
BOOL ret;
ret = CertContext_GetProperty((void *)pCertContext, dwPropId, pvData,
pcbData);
if (ret && pvData)
- CRYPT_FixKeyProvInfoPointers((PCRYPT_KEY_PROV_INFO)pvData);
+ CRYPT_FixKeyProvInfoPointers(pvData);
break;
default:
ret = CertContext_GetProperty((void *)pCertContext, dwPropId, pvData,
return ret;
}
+static BOOL key_prov_info_matches_cert(PCCERT_CONTEXT pCert,
+ const CRYPT_KEY_PROV_INFO *keyProvInfo)
+{
+ HCRYPTPROV csp;
+ BOOL matches = FALSE;
+
+ if (CryptAcquireContextW(&csp, keyProvInfo->pwszContainerName,
+ keyProvInfo->pwszProvName, keyProvInfo->dwProvType, keyProvInfo->dwFlags))
+ {
+ DWORD size;
+
+ /* Need to sign something to verify the sig. What to sign? Why not
+ * the certificate itself?
+ */
+ if (CryptSignAndEncodeCertificate(csp, AT_SIGNATURE,
+ pCert->dwCertEncodingType, X509_CERT_TO_BE_SIGNED, pCert->pCertInfo,
+ &pCert->pCertInfo->SignatureAlgorithm, NULL, NULL, &size))
+ {
+ BYTE *certEncoded = CryptMemAlloc(size);
+
+ if (certEncoded)
+ {
+ if (CryptSignAndEncodeCertificate(csp, AT_SIGNATURE,
+ pCert->dwCertEncodingType, X509_CERT_TO_BE_SIGNED,
+ pCert->pCertInfo, &pCert->pCertInfo->SignatureAlgorithm,
+ NULL, certEncoded, &size))
+ {
+ if (size == pCert->cbCertEncoded &&
+ !memcmp(certEncoded, pCert->pbCertEncoded, size))
+ matches = TRUE;
+ }
+ CryptMemFree(certEncoded);
+ }
+ }
+ CryptReleaseContext(csp, 0);
+ }
+ return matches;
+}
+
+static BOOL container_matches_cert(PCCERT_CONTEXT pCert, LPCSTR container,
+ CRYPT_KEY_PROV_INFO *keyProvInfo)
+{
+ CRYPT_KEY_PROV_INFO copy;
+ WCHAR containerW[MAX_PATH];
+ BOOL matches = FALSE;
+
+ MultiByteToWideChar(CP_ACP, 0, container, -1,
+ containerW, sizeof(containerW) / sizeof(containerW[0]));
+ /* We make a copy of the CRYPT_KEY_PROV_INFO because the caller expects
+ * keyProvInfo->pwszContainerName to be NULL or a heap-allocated container
+ * name.
+ */
+ memcpy(©, keyProvInfo, sizeof(copy));
+ copy.pwszContainerName = containerW;
+ matches = key_prov_info_matches_cert(pCert, ©);
+ if (matches)
+ {
+ keyProvInfo->pwszContainerName =
+ CryptMemAlloc((strlenW(containerW) + 1) * sizeof(WCHAR));
+ if (keyProvInfo->pwszContainerName)
+ {
+ strcpyW(keyProvInfo->pwszContainerName, containerW);
+ keyProvInfo->dwKeySpec = AT_SIGNATURE;
+ }
+ else
+ matches = FALSE;
+ }
+ return matches;
+}
+
+/* Searches the provider named keyProvInfo.pwszProvName for a container whose
+ * private key matches pCert's public key. Upon success, updates keyProvInfo
+ * with the matching container's info (free keyProvInfo.pwszContainerName upon
+ * success.)
+ * Returns TRUE if found, FALSE if not.
+ */
+static BOOL find_key_prov_info_in_provider(PCCERT_CONTEXT pCert,
+ CRYPT_KEY_PROV_INFO *keyProvInfo)
+{
+ HCRYPTPROV defProvider;
+ BOOL ret, found = FALSE;
+ char containerA[MAX_PATH];
+
+ assert(keyProvInfo->pwszContainerName == NULL);
+ if ((ret = CryptAcquireContextW(&defProvider, NULL,
+ keyProvInfo->pwszProvName, keyProvInfo->dwProvType,
+ keyProvInfo->dwFlags | CRYPT_VERIFYCONTEXT)))
+ {
+ DWORD enumFlags = keyProvInfo->dwFlags | CRYPT_FIRST;
+
+ while (ret && !found)
+ {
+ DWORD size = sizeof(containerA);
+
+ ret = CryptGetProvParam(defProvider, PP_ENUMCONTAINERS,
+ (BYTE *)containerA, &size, enumFlags);
+ if (ret)
+ found = container_matches_cert(pCert, containerA, keyProvInfo);
+ if (enumFlags & CRYPT_FIRST)
+ {
+ enumFlags &= ~CRYPT_FIRST;
+ enumFlags |= CRYPT_NEXT;
+ }
+ }
+ CryptReleaseContext(defProvider, 0);
+ }
+ return found;
+}
+
+static BOOL find_matching_provider(PCCERT_CONTEXT pCert, DWORD dwFlags)
+{
+ BOOL found = FALSE, ret = TRUE;
+ DWORD index = 0, cbProvName = 0;
+ CRYPT_KEY_PROV_INFO keyProvInfo;
+
+ TRACE("(%p, %08x)\n", pCert, dwFlags);
+
+ memset(&keyProvInfo, 0, sizeof(keyProvInfo));
+ while (ret && !found)
+ {
+ DWORD size = 0;
+
+ ret = CryptEnumProvidersW(index, NULL, 0, &keyProvInfo.dwProvType,
+ NULL, &size);
+ if (ret)
+ {
+ if (size <= cbProvName)
+ ret = CryptEnumProvidersW(index, NULL, 0,
+ &keyProvInfo.dwProvType, keyProvInfo.pwszProvName, &size);
+ else
+ {
+ CryptMemFree(keyProvInfo.pwszProvName);
+ keyProvInfo.pwszProvName = CryptMemAlloc(size);
+ if (keyProvInfo.pwszProvName)
+ {
+ cbProvName = size;
+ ret = CryptEnumProvidersW(index, NULL, 0,
+ &keyProvInfo.dwProvType, keyProvInfo.pwszProvName, &size);
+ if (ret)
+ {
+ if (dwFlags & CRYPT_FIND_SILENT_KEYSET_FLAG)
+ keyProvInfo.dwFlags |= CRYPT_SILENT;
+ if (dwFlags & CRYPT_FIND_USER_KEYSET_FLAG ||
+ !(dwFlags & (CRYPT_FIND_USER_KEYSET_FLAG |
+ CRYPT_FIND_MACHINE_KEYSET_FLAG)))
+ {
+ keyProvInfo.dwFlags |= CRYPT_USER_KEYSET;
+ found = find_key_prov_info_in_provider(pCert,
+ &keyProvInfo);
+ }
+ if (!found)
+ {
+ if (dwFlags & CRYPT_FIND_MACHINE_KEYSET_FLAG ||
+ !(dwFlags & (CRYPT_FIND_USER_KEYSET_FLAG |
+ CRYPT_FIND_MACHINE_KEYSET_FLAG)))
+ {
+ keyProvInfo.dwFlags &= ~CRYPT_USER_KEYSET;
+ keyProvInfo.dwFlags |= CRYPT_MACHINE_KEYSET;
+ found = find_key_prov_info_in_provider(pCert,
+ &keyProvInfo);
+ }
+ }
+ }
+ }
+ else
+ ret = FALSE;
+ }
+ index++;
+ }
+ }
+ if (found)
+ CertSetCertificateContextProperty(pCert, CERT_KEY_PROV_INFO_PROP_ID,
+ 0, &keyProvInfo);
+ CryptMemFree(keyProvInfo.pwszProvName);
+ CryptMemFree(keyProvInfo.pwszContainerName);
+ return found;
+}
+
+static BOOL cert_prov_info_matches_cert(PCCERT_CONTEXT pCert)
+{
+ BOOL matches = FALSE;
+ DWORD size;
+
+ if (CertGetCertificateContextProperty(pCert, CERT_KEY_PROV_INFO_PROP_ID,
+ NULL, &size))
+ {
+ CRYPT_KEY_PROV_INFO *keyProvInfo = CryptMemAlloc(size);
+
+ if (keyProvInfo)
+ {
+ if (CertGetCertificateContextProperty(pCert,
+ CERT_KEY_PROV_INFO_PROP_ID, keyProvInfo, &size))
+ matches = key_prov_info_matches_cert(pCert, keyProvInfo);
+ CryptMemFree(keyProvInfo);
+ }
+ }
+ return matches;
+}
+
+BOOL WINAPI CryptFindCertificateKeyProvInfo(PCCERT_CONTEXT pCert,
+ DWORD dwFlags, void *pvReserved)
+{
+ BOOL matches = FALSE;
+
+ TRACE("(%p, %08x, %p)\n", pCert, dwFlags, pvReserved);
+
+ matches = cert_prov_info_matches_cert(pCert);
+ if (!matches)
+ matches = find_matching_provider(pCert, dwFlags);
+ return matches;
+}
+
BOOL WINAPI CertCompareCertificate(DWORD dwCertEncodingType,
PCERT_INFO pCertId1, PCERT_INFO pCertId2)
{
CERT_MD5_HASH_PROP_ID, hash, &size);
if (ret)
{
- const CRYPT_HASH_BLOB *pHash = (const CRYPT_HASH_BLOB *)pvPara;
+ const CRYPT_HASH_BLOB *pHash = pvPara;
if (size == pHash->cbData)
ret = !memcmp(pHash->pbData, hash, size);
CERT_SHA1_HASH_PROP_ID, hash, &size);
if (ret)
{
- const CRYPT_HASH_BLOB *pHash = (const CRYPT_HASH_BLOB *)pvPara;
+ const CRYPT_HASH_BLOB *pHash = pvPara;
if (size == pHash->cbData)
ret = !memcmp(pHash->pbData, hash, size);
return ret;
}
+static BOOL compare_cert_by_public_key(PCCERT_CONTEXT pCertContext,
+ DWORD dwType, DWORD dwFlags, const void *pvPara)
+{
+ CERT_PUBLIC_KEY_INFO *publicKey = (CERT_PUBLIC_KEY_INFO *)pvPara;
+ BOOL ret;
+
+ ret = CertComparePublicKeyInfo(pCertContext->dwCertEncodingType,
+ &pCertContext->pCertInfo->SubjectPublicKeyInfo, publicKey);
+ return ret;
+}
+
static BOOL compare_cert_by_subject_cert(PCCERT_CONTEXT pCertContext,
DWORD dwType, DWORD dwFlags, const void *pvPara)
{
DWORD dwFlags, const void *pvPara)
{
BOOL ret = FALSE;
- PCCERT_CONTEXT subject = (PCCERT_CONTEXT)pvPara;
+ PCCERT_CONTEXT subject = pvPara;
PCERT_EXTENSION ext;
DWORD size;
static BOOL compare_existing_cert(PCCERT_CONTEXT pCertContext, DWORD dwType,
DWORD dwFlags, const void *pvPara)
{
- PCCERT_CONTEXT toCompare = (PCCERT_CONTEXT)pvPara;
+ PCCERT_CONTEXT toCompare = pvPara;
return CertCompareCertificate(pCertContext->dwCertEncodingType,
pCertContext->pCertInfo, toCompare->pCertInfo);
}
static BOOL compare_cert_by_signature_hash(PCCERT_CONTEXT pCertContext, DWORD dwType,
DWORD dwFlags, const void *pvPara)
{
- const CRYPT_HASH_BLOB *hash = (const CRYPT_HASH_BLOB *)pvPara;
+ const CRYPT_HASH_BLOB *hash = pvPara;
DWORD size = 0;
BOOL ret;
case CERT_COMPARE_NAME:
compare = compare_cert_by_name;
break;
+ case CERT_COMPARE_PUBLIC_KEY:
+ compare = compare_cert_by_public_key;
+ break;
case CERT_COMPARE_SUBJECT_CERT:
compare = compare_cert_by_subject_cert;
break;
pbEncoded, cbEncoded, pbComputedHash, *pcbComputedHash);
ret = CryptDecodeObjectEx(dwCertEncodingType, X509_CERT,
- pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, (void *)&info, &size);
+ pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size);
if (ret)
{
PCCRYPT_OID_INFO oidInfo;
{
case CRYPT_VERIFY_CERT_SIGN_SUBJECT_BLOB:
{
- PCRYPT_DATA_BLOB blob = (PCRYPT_DATA_BLOB)pvSubject;
+ PCRYPT_DATA_BLOB blob = pvSubject;
subjectBlob.pbData = blob->pbData;
subjectBlob.cbData = blob->cbData;
}
case CRYPT_VERIFY_CERT_SIGN_SUBJECT_CERT:
{
- PCERT_CONTEXT context = (PCERT_CONTEXT)pvSubject;
+ PCERT_CONTEXT context = pvSubject;
subjectBlob.pbData = context->pbCertEncoded;
subjectBlob.cbData = context->cbCertEncoded;
}
case CRYPT_VERIFY_CERT_SIGN_SUBJECT_CRL:
{
- PCRL_CONTEXT context = (PCRL_CONTEXT)pvSubject;
+ PCRL_CONTEXT context = pvSubject;
subjectBlob.pbData = context->pbCrlEncoded;
subjectBlob.cbData = context->cbCrlEncoded;
ret = CryptDecodeObjectEx(dwCertEncodingType, X509_CERT,
subjectBlob.pbData, subjectBlob.cbData,
CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_NOCOPY_FLAG, NULL,
- (BYTE *)&signedCert, &size);
+ &signedCert, &size);
if (ret)
{
switch (dwIssuerType)
{
case CRYPT_VERIFY_CERT_SIGN_ISSUER_PUBKEY:
ret = CRYPT_VerifyCertSignatureFromPublicKeyInfo(hCryptProv,
- dwCertEncodingType, (PCERT_PUBLIC_KEY_INFO)pvIssuer,
+ dwCertEncodingType, pvIssuer,
signedCert);
break;
case CRYPT_VERIFY_CERT_SIGN_ISSUER_CERT:
signedInfo.Signature.cUnusedBits = 0;
ret = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_CERT,
&signedInfo, CRYPT_ENCODE_ALLOC_FLAG, NULL,
- (BYTE *)&encodedSignedCert, &encodedSignedCertSize);
+ &encodedSignedCert, &encodedSignedCertSize);
if (ret)
{
context = CertCreateCertificateContext(X509_ASN_ENCODING,
CRYPT_MakeCertInfo(&info, &serialBlob, pSubjectIssuerBlob,
pSignatureAlgorithm, pStartTime, pEndTime, pubKey, pExtensions);
ret = CryptEncodeObjectEx(X509_ASN_ENCODING, X509_CERT_TO_BE_SIGNED,
- &info, CRYPT_ENCODE_ALLOC_FLAG, NULL, (BYTE *)&blob.pbData,
+ &info, CRYPT_ENCODE_ALLOC_FLAG, NULL, &blob.pbData,
&blob.cbData);
if (ret)
{
else
engine->CycleDetectionModulus = DEFAULT_CYCLE_MODULUS;
}
- return (HCERTCHAINENGINE)engine;
+ return engine;
}
BOOL WINAPI CertCreateCertificateChainEngine(PCERT_CHAIN_ENGINE_CONFIG pConfig,
ret = CryptDecodeObjectEx(X509_ASN_ENCODING, szOID_BASIC_CONSTRAINTS,
ext->Value.pbData, ext->Value.cbData, CRYPT_DECODE_ALLOC_FLAG,
- NULL, (LPBYTE)&info, &size);
+ NULL, &info, &size);
if (ret)
{
if (info->SubjectType.cbData == 1)
static void WINAPI CRYPT_CollectionCloseStore(HCERTSTORE store, DWORD dwFlags)
{
- PWINE_COLLECTIONSTORE cs = (PWINE_COLLECTIONSTORE)store;
+ PWINE_COLLECTIONSTORE cs = store;
PWINE_STORE_LIST_ENTRY entry, next;
TRACE("(%p, %08x)\n", store, dwFlags);
entry)
{
TRACE("closing %p\n", entry);
- CertCloseStore((HCERTSTORE)entry->store, dwFlags);
+ CertCloseStore(entry->store, dwFlags);
CryptMemFree(entry);
}
cs->cs.DebugInfo->Spare[0] = 0;
DeleteCriticalSection(&cs->cs);
- CRYPT_FreeStore((PWINECRYPT_CERTSTORE)store);
+ CRYPT_FreeStore(store);
}
static void *CRYPT_CollectionCreateContextFromChild(PWINE_COLLECTIONSTORE store,
contextFuncs = (PCONTEXT_FUNCS)((LPBYTE)storeEntry->store +
contextFuncsOffset);
ret = contextFuncs->addContext(storeEntry->store, context,
- existingLinked, childContext);
+ existingLinked, (const void **)&childContext);
}
else
{
context->hCertStore = store;
*ppStoreContext = context;
}
- CertFreeCertificateContext((PCCERT_CONTEXT)childContext);
+ CertFreeCertificateContext(childContext);
return ret;
}
TRACE("(%p, %p)\n", store, pCertContext);
- ret = CertDeleteCertificateFromStore((PCCERT_CONTEXT)
+ ret = CertDeleteCertificateFromStore(
Context_GetLinkedContext(pCertContext, sizeof(CERT_CONTEXT)));
return ret;
}
context->hCertStore = store;
*ppStoreContext = context;
}
- CertFreeCRLContext((PCCRL_CONTEXT)childContext);
+ CertFreeCRLContext(childContext);
return ret;
}
TRACE("(%p, %p)\n", store, pCrlContext);
- ret = CertDeleteCRLFromStore((PCCRL_CONTEXT)
+ ret = CertDeleteCRLFromStore(
Context_GetLinkedContext(pCrlContext, sizeof(CRL_CONTEXT)));
return ret;
}
context->hCertStore = store;
*ppStoreContext = context;
}
- CertFreeCTLContext((PCCTL_CONTEXT)childContext);
+ CertFreeCTLContext(childContext);
return ret;
}
TRACE("(%p, %p)\n", store, pCtlContext);
- ret = CertDeleteCTLFromStore((PCCTL_CONTEXT)
+ ret = CertDeleteCTLFromStore(
Context_GetLinkedContext(pCtlContext, sizeof(CTL_CONTEXT)));
return ret;
}
BOOL WINAPI CertAddStoreToCollection(HCERTSTORE hCollectionStore,
HCERTSTORE hSiblingStore, DWORD dwUpdateFlags, DWORD dwPriority)
{
- PWINE_COLLECTIONSTORE collection = (PWINE_COLLECTIONSTORE)hCollectionStore;
- WINECRYPT_CERTSTORE *sibling = (WINECRYPT_CERTSTORE *)hSiblingStore;
+ PWINE_COLLECTIONSTORE collection = hCollectionStore;
+ WINECRYPT_CERTSTORE *sibling = hSiblingStore;
PWINE_STORE_LIST_ENTRY entry;
BOOL ret;
void WINAPI CertRemoveStoreFromCollection(HCERTSTORE hCollectionStore,
HCERTSTORE hSiblingStore)
{
- PWINE_COLLECTIONSTORE collection = (PWINE_COLLECTIONSTORE)hCollectionStore;
- WINECRYPT_CERTSTORE *sibling = (WINECRYPT_CERTSTORE *)hSiblingStore;
+ PWINE_COLLECTIONSTORE collection = hCollectionStore;
+ WINECRYPT_CERTSTORE *sibling = hSiblingStore;
PWINE_STORE_LIST_ENTRY store, next;
TRACE("(%p, %p)\n", hCollectionStore, hSiblingStore);
{
PCONTEXT_PROPERTY_LIST toProperties, fromProperties;
- toProperties = Context_GetProperties((void *)to, contextSize);
- fromProperties = Context_GetProperties((void *)from, contextSize);
+ toProperties = Context_GetProperties(to, contextSize);
+ fromProperties = Context_GetProperties(from, contextSize);
assert(toProperties && fromProperties);
ContextPropertyList_Copy(toProperties, fromProperties);
}
}
ret = CryptDecodeObjectEx(dwCertEncodingType, X509_CERT_CRL_TO_BE_SIGNED,
pbCrlEncoded, cbCrlEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
- (BYTE *)&crlInfo, &size);
+ &crlInfo, &size);
if (ret)
{
BYTE *data = NULL;
}
end:
- return (PCCRL_CONTEXT)crl;
+ return crl;
}
BOOL WINAPI CertAddEncodedCRLToStore(HCERTSTORE hCertStore,
if (pvPara)
{
- PCCERT_CONTEXT issuer = (PCCERT_CONTEXT)pvPara;
+ PCCERT_CONTEXT issuer = pvPara;
ret = CertCompareCertificateName(issuer->dwCertEncodingType,
&issuer->pCertInfo->Issuer, &pCrlContext->pCrlInfo->Issuer);
if (pvPara)
{
- PCCRL_CONTEXT crl = (PCCRL_CONTEXT)pvPara;
+ PCCRL_CONTEXT crl = pvPara;
ret = CertCompareCertificateName(pCrlContext->dwCertEncodingType,
&pCrlContext->pCrlInfo->Issuer, &crl->pCrlInfo->Issuer);
static void CrlDataContext_Free(void *context)
{
- PCRL_CONTEXT crlContext = (PCRL_CONTEXT)context;
+ PCRL_CONTEXT crlContext = context;
CryptMemFree(crlContext->pbCrlEncoded);
LocalFree(crlContext->pCrlInfo);
DWORD dwPropId)
{
PCONTEXT_PROPERTY_LIST properties = Context_GetProperties(
- (void *)pCRLContext, sizeof(CRL_CONTEXT));
+ pCRLContext, sizeof(CRL_CONTEXT));
DWORD ret;
TRACE("(%p, %d)\n", pCRLContext, dwPropId);
}
case CERT_DATE_STAMP_PROP_ID:
ret = ContextPropertyList_SetProperty(properties, dwPropId,
- (const BYTE *)pvData, sizeof(FILETIME));
+ pvData, sizeof(FILETIME));
break;
default:
FIXME("%d: stub\n", dwPropId);
@ stub CryptExportPKCS8
@ stdcall CryptExportPublicKeyInfo(long long long ptr ptr)
@ stdcall CryptExportPublicKeyInfoEx(long long long str long ptr ptr ptr)
+@ stdcall CryptFindCertificateKeyProvInfo(ptr long ptr)
@ stdcall CryptFindLocalizedName(wstr)
@ stdcall CryptFindOIDInfo(long ptr long)
@ stdcall CryptFormatObject(long long long ptr str ptr long ptr ptr)
@ stdcall I_CryptSetTls(long ptr)
@ stdcall I_CryptUninstallAsn1Module(long)
@ stub I_CryptUninstallOssGlobal
-@ stub PFXExportCertStore
-@ stub PFXImportCertStore
+@ stdcall PFXExportCertStore(ptr ptr ptr long)
+@ stdcall PFXExportCertStoreEx(ptr ptr ptr ptr long)
+@ stdcall PFXImportCertStore(ptr ptr long)
+@ stdcall PFXIsPFXBlob(ptr)
@ stub RegCreateHKCUKeyExU
@ stub RegCreateKeyExU
@ stub RegDeleteValueU
IDS_LOCALIZEDNAME_MY "Personal"
IDS_LOCALIZEDNAME_CA "Intermediate Certification Authorities"
IDS_LOCALIZEDNAME_ADDRESSBOOK "Other People"
+ IDS_LOCALIZEDNAME_TRUSTEDPUBLISHER "Trusted Publishers"
}
STRINGTABLE DISCARDABLE
IDS_LOCALIZEDNAME_MY "Persoonlijk"
IDS_LOCALIZEDNAME_CA "Certificatie Tussen-Autoriteiten"
IDS_LOCALIZEDNAME_ADDRESSBOOK "Overige Personen"
+ IDS_LOCALIZEDNAME_TRUSTEDPUBLISHER "Vertrouwde uitgevers"
}
STRINGTABLE DISCARDABLE
{
#define IDS_LOCALIZEDNAME_MY 1142
#define IDS_LOCALIZEDNAME_CA 1143
#define IDS_LOCALIZEDNAME_ADDRESSBOOK 1144
+#define IDS_LOCALIZEDNAME_TRUSTEDPUBLISHER 1145
#define IDS_KEY_ID 1200
#define IDS_CERT_ISSUER 1201
PCCTL_CONTEXT pCtlContext, DWORD dwAddDisposition,
PCCTL_CONTEXT* ppStoreContext)
{
- PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)hCertStore;
+ PWINECRYPT_CERTSTORE store = hCertStore;
BOOL ret = TRUE;
PCCTL_CONTEXT toAdd = NULL, existing = NULL;
PCCTL_CONTEXT WINAPI CertEnumCTLsInStore(HCERTSTORE hCertStore,
PCCTL_CONTEXT pPrev)
{
- WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
+ WINECRYPT_CERTSTORE *hcs = hCertStore;
PCCTL_CONTEXT ret;
TRACE("(%p, %p)\n", hCertStore, pPrev);
&size);
if (ret)
{
- const CRYPT_HASH_BLOB *pHash = (const CRYPT_HASH_BLOB *)pvPara;
+ const CRYPT_HASH_BLOB *pHash = pvPara;
if (size == pHash->cbData)
ret = !memcmp(pHash->pbData, hash, size);
&size);
if (ret)
{
- const CRYPT_HASH_BLOB *pHash = (const CRYPT_HASH_BLOB *)pvPara;
+ const CRYPT_HASH_BLOB *pHash = pvPara;
if (size == pHash->cbData)
ret = !memcmp(pHash->pbData, hash, size);
if (pvPara)
{
- PCCTL_CONTEXT ctl = (PCCTL_CONTEXT)pvPara;
+ PCCTL_CONTEXT ctl = pvPara;
if (pCtlContext->cbCtlContext == ctl->cbCtlContext)
{
}
else
{
- PWINECRYPT_CERTSTORE hcs =
- (PWINECRYPT_CERTSTORE)pCtlContext->hCertStore;
+ PWINECRYPT_CERTSTORE hcs = pCtlContext->hCertStore;
if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
ret = FALSE;
{
ret = CryptDecodeObjectEx(dwMsgAndCertEncodingType, PKCS_CTL,
content, contentSize, CRYPT_DECODE_ALLOC_FLAG, NULL,
- (BYTE *)&ctlInfo, &size);
+ &ctlInfo, &size);
if (ret)
{
ctl = Context_CreateDataContext(sizeof(CTL_CONTEXT));
CryptMemFree(content);
CryptMsgClose(msg);
}
- return (PCCTL_CONTEXT)ctl;
+ return ctl;
}
PCCTL_CONTEXT WINAPI CertDuplicateCTLContext(PCCTL_CONTEXT pCtlContext)
static void CTLDataContext_Free(void *context)
{
- PCTL_CONTEXT ctlContext = (PCTL_CONTEXT)context;
+ PCTL_CONTEXT ctlContext = context;
CryptMsgClose(ctlContext->hCryptMsg);
CryptMemFree(ctlContext->pbCtlEncoded);
DWORD dwPropId)
{
PCONTEXT_PROPERTY_LIST properties = Context_GetProperties(
- (void *)pCTLContext, sizeof(CTL_CONTEXT));
+ pCTLContext, sizeof(CTL_CONTEXT));
DWORD ret;
TRACE("(%p, %d)\n", pCTLContext, dwPropId);
}
case CERT_DATE_STAMP_PROP_ID:
ret = ContextPropertyList_SetProperty(properties, dwPropId,
- (const BYTE *)pvData, sizeof(FILETIME));
+ pvData, sizeof(FILETIME));
break;
default:
FIXME("%d: stub\n", dwPropId);
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
if (startingPointer)
- nextData = (BYTE *)startingPointer;
+ nextData = startingPointer;
else
nextData = (BYTE *)pvStructInfo + structSize;
memset(pvStructInfo, 0, structSize);
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- array = (struct GenericArray *)pvStructInfo;
+ array = pvStructInfo;
array->cItems = cItems;
if (startingPointer)
array->rgItems = startingPointer;
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- blob = (CRYPT_DER_BLOB *)pvStructInfo;
+ blob = pvStructInfo;
blob->cbData = 1 + lenBytes + dataLen;
if (blob->cbData)
{
pcbDecoded);
if (ret && pvStructInfo)
{
- CRYPT_BIT_BLOB *blob = (CRYPT_BIT_BLOB *)pvStructInfo;
+ CRYPT_BIT_BLOB *blob = pvStructInfo;
if (blob->cbData)
{
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
info = *(CERT_INFO **)pvStructInfo;
else
- info = (CERT_INFO *)pvStructInfo;
+ info = pvStructInfo;
if (!info->SerialNumber.cbData || !info->Issuer.cbData ||
!info->Subject.cbData)
{
ret = CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType,
X509_CERT, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
- (BYTE *)&signedCert, &size);
+ &signedCert, &size);
if (ret)
{
size = 0;
CRYPT_AsnDecodeExtensionsInternal, sizeof(CERT_EXTENSIONS), TRUE, TRUE,
offsetof(CRL_ENTRY, rgExtension), 0 },
};
- PCRL_ENTRY entry = (PCRL_ENTRY)pvStructInfo;
+ PCRL_ENTRY entry = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, entry,
*pcbStructInfo);
struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
CRYPT_AsnDecodeCRLEntry, sizeof(CRL_ENTRY), TRUE,
offsetof(CRL_ENTRY, SerialNumber.pbData) };
- struct GenericArray *entries = (struct GenericArray *)pvStructInfo;
+ struct GenericArray *entries = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
ret = CRYPT_AsnDecodeCertSignedContent(dwCertEncodingType,
X509_CERT, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL,
- (BYTE *)&signedCrl, &size);
+ &signedCrl, &size);
if (ret)
{
size = 0;
offsetof(CERT_EXTENSION, Value.pbData) },
};
BOOL ret = TRUE;
- PCERT_EXTENSION ext = (PCERT_EXTENSION)pvStructInfo;
+ PCERT_EXTENSION ext = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, ext,
*pcbStructInfo);
struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
CRYPT_AsnDecodeExtension, sizeof(CERT_EXTENSION), TRUE,
offsetof(CERT_EXTENSION, pszObjId) };
- PCERT_EXTENSIONS exts = (PCERT_EXTENSIONS)pvStructInfo;
+ PCERT_EXTENSIONS exts = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- exts = (CERT_EXTENSIONS *)pvStructInfo;
+ exts = pvStructInfo;
exts->rgExtension = (CERT_EXTENSION *)((BYTE *)exts +
sizeof(CERT_EXTENSIONS));
ret = CRYPT_AsnDecodeExtensionsInternal(pbEncoded, cbEncoded,
{
BOOL ret = TRUE;
DWORD dataLen;
- CERT_NAME_VALUE *value = (CERT_NAME_VALUE *)pvStructInfo;
+ CERT_NAME_VALUE *value = pvStructInfo;
if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
{
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- value = (CERT_NAME_VALUE *)pvStructInfo;
+ value = pvStructInfo;
value->Value.pbData = ((BYTE *)value + sizeof(CERT_NAME_VALUE));
ret = CRYPT_AsnDecodeNameValueInternal( pbEncoded, cbEncoded,
dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
{
BOOL ret = TRUE;
DWORD dataLen;
- CERT_NAME_VALUE *value = (CERT_NAME_VALUE *)pvStructInfo;
+ CERT_NAME_VALUE *value = pvStructInfo;
if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
{
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- value = (CERT_NAME_VALUE *)pvStructInfo;
+ value = pvStructInfo;
value->Value.pbData = ((BYTE *)value + sizeof(CERT_NAME_VALUE));
ret = CRYPT_AsnDecodeUnicodeNameValueInternal(pbEncoded,
cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
CRYPT_AsnDecodeNameValueInternal, sizeof(CERT_NAME_VALUE),
FALSE, TRUE, offsetof(CERT_RDN_ATTR, Value.pbData), 0 },
};
- CERT_RDN_ATTR *attr = (CERT_RDN_ATTR *)pvStructInfo;
+ CERT_RDN_ATTR *attr = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo);
struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
CRYPT_AsnDecodeRdnAttr, sizeof(CERT_RDN_ATTR), TRUE,
offsetof(CERT_RDN_ATTR, pszObjId) };
- PCERT_RDN rdn = (PCERT_RDN)pvStructInfo;
+ PCERT_RDN rdn = pvStructInfo;
ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
CRYPT_AsnDecodeUnicodeNameValueInternal, sizeof(CERT_NAME_VALUE),
FALSE, TRUE, offsetof(CERT_RDN_ATTR, Value.pbData), 0 },
};
- CERT_RDN_ATTR *attr = (CERT_RDN_ATTR *)pvStructInfo;
+ CERT_RDN_ATTR *attr = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo);
struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
CRYPT_AsnDecodeUnicodeRdnAttr, sizeof(CERT_RDN_ATTR), TRUE,
offsetof(CERT_RDN_ATTR, pszObjId) };
- PCERT_RDN rdn = (PCERT_RDN)pvStructInfo;
+ PCERT_RDN rdn = pvStructInfo;
ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
}
else
{
- PCRYPT_OBJID_BLOB blob = (PCRYPT_OBJID_BLOB)pvStructInfo;
+ PCRYPT_OBJID_BLOB blob = pvStructInfo;
*pcbStructInfo = bytesNeeded;
blob->cbData = encodedLen;
BOOL ret;
struct AsnArrayDescriptor arrayDesc = { 0, CRYPT_AsnDecodeCopyBytes,
sizeof(CRYPT_DER_BLOB), TRUE, offsetof(CRYPT_DER_BLOB, pbData) };
- struct GenericArray *array = (struct GenericArray *)pvStructInfo;
+ struct GenericArray *array = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
BOOL ret;
struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
CRYPT_AsnDecodeOidInternal, sizeof(LPSTR), TRUE, 0 };
- CTL_USAGE *usage = (CTL_USAGE *)pvStructInfo;
+ CTL_USAGE *usage = pvStructInfo;
ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
NULL, pvStructInfo, pcbStructInfo, pcbDecoded,
TRUE, offsetof(CTL_ENTRY, rgAttribute), 0 },
};
BOOL ret = TRUE;
- CTL_ENTRY *entry = (CTL_ENTRY *)pvStructInfo;
+ CTL_ENTRY *entry = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags, entry,
*pcbStructInfo);
struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
CRYPT_AsnDecodeCTLEntry, sizeof(CTL_ENTRY), TRUE,
offsetof(CTL_ENTRY, SubjectIdentifier.pbData) };
- struct GenericArray *entries = (struct GenericArray *)pvStructInfo;
+ struct GenericArray *entries = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
CRYPT_AsnDecodeCopyBytes, sizeof(CRYPT_OBJID_BLOB), TRUE, TRUE,
offsetof(CRYPT_SMIME_CAPABILITY, Parameters.pbData), 0 },
};
- PCRYPT_SMIME_CAPABILITY capability = (PCRYPT_SMIME_CAPABILITY)pvStructInfo;
+ PCRYPT_SMIME_CAPABILITY capability = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo);
struct AsnArrayDescriptor arrayDesc = { 0,
CRYPT_AsnDecodeSMIMECapability, sizeof(CRYPT_SMIME_CAPABILITY), TRUE,
offsetof(CRYPT_SMIME_CAPABILITY, pszObjId) };
- PCRYPT_SMIME_CAPABILITIES capabilities =
- (PCRYPT_SMIME_CAPABILITIES)pvStructInfo;
+ PCRYPT_SMIME_CAPABILITIES capabilities = pvStructInfo;
BOOL ret;
ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- capabilities = (PCRYPT_SMIME_CAPABILITIES)pvStructInfo;
+ capabilities = pvStructInfo;
capabilities->rgCapability =
(PCRYPT_SMIME_CAPABILITY)((BYTE *)pvStructInfo +
sizeof(CRYPT_SMIME_CAPABILITIES));
CRYPT_DecodeDERArray, sizeof(struct GenericArray), FALSE, TRUE,
offsetof(CRYPT_ATTRIBUTE, rgValue), 0 },
};
- PCRYPT_ATTRIBUTE attr = (PCRYPT_ATTRIBUTE)pvStructInfo;
+ PCRYPT_ATTRIBUTE attr = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo);
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- attr = (PCRYPT_ATTRIBUTE)pvStructInfo;
+ attr = pvStructInfo;
attr->pszObjId = (LPSTR)((BYTE *)pvStructInfo +
sizeof(CRYPT_ATTRIBUTE));
ret = CRYPT_AsnDecodePKCSAttributeInternal(pbEncoded, cbEncoded,
struct AsnArrayDescriptor arrayDesc = { 0,
CRYPT_AsnDecodePKCSAttributeInternal, sizeof(CRYPT_ATTRIBUTE), TRUE,
offsetof(CRYPT_ATTRIBUTE, pszObjId) };
- PCRYPT_ATTRIBUTES attrs = (PCRYPT_ATTRIBUTES)pvStructInfo;
+ PCRYPT_ATTRIBUTES attrs = pvStructInfo;
BOOL ret;
ret = CRYPT_AsnDecodeArray(&arrayDesc, pbEncoded, cbEncoded, dwFlags,
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- attrs = (PCRYPT_ATTRIBUTES)pvStructInfo;
+ attrs = pvStructInfo;
attrs->rgAttr = (PCRYPT_ATTRIBUTE)((BYTE *)pvStructInfo +
sizeof(CRYPT_ATTRIBUTES));
ret = CRYPT_AsnDecodePKCSAttributesInternal(pbEncoded,
static BOOL CRYPT_AsnDecodeAlgorithmId(const BYTE *pbEncoded, DWORD cbEncoded,
DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
{
- CRYPT_ALGORITHM_IDENTIFIER *algo =
- (CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
+ CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
BOOL ret = TRUE;
struct AsnDecodeSequenceItem items[] = {
{ ASN_OBJECTIDENTIFIER, offsetof(CRYPT_ALGORITHM_IDENTIFIER, pszObjId),
CRYPT_AsnDecodeBitsInternal, sizeof(CRYPT_BIT_BLOB), FALSE, TRUE,
offsetof(CERT_PUBLIC_KEY_INFO, PublicKey.pbData) },
};
- PCERT_PUBLIC_KEY_INFO info = (PCERT_PUBLIC_KEY_INFO)pvStructInfo;
+ PCERT_PUBLIC_KEY_INFO info = pvStructInfo;
ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- info = (PCERT_PUBLIC_KEY_INFO)pvStructInfo;
+ info = pvStructInfo;
info->Algorithm.Parameters.pbData = (BYTE *)pvStructInfo +
sizeof(CERT_PUBLIC_KEY_INFO);
ret = CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded, cbEncoded,
static BOOL CRYPT_AsnDecodeAltNameEntry(const BYTE *pbEncoded, DWORD cbEncoded,
DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo, DWORD *pcbDecoded)
{
- PCERT_ALT_NAME_ENTRY entry = (PCERT_ALT_NAME_ENTRY)pvStructInfo;
+ PCERT_ALT_NAME_ENTRY entry = pvStructInfo;
DWORD dataLen, lenBytes, bytesNeeded = sizeof(CERT_ALT_NAME_ENTRY);
BOOL ret;
struct AsnArrayDescriptor arrayDesc = { 0,
CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), TRUE,
offsetof(CERT_ALT_NAME_ENTRY, u.pwszURL) };
- PCERT_ALT_NAME_INFO info = (PCERT_ALT_NAME_INFO)pvStructInfo;
+ PCERT_ALT_NAME_INFO info = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
pcbDecoded);
if (ret && pvStructInfo)
{
- CRYPT_DATA_BLOB *blob = (CRYPT_DATA_BLOB *)pvStructInfo;
+ CRYPT_DATA_BLOB *blob = pvStructInfo;
if (blob->cbData)
{
CRYPT_AsnDecodeAltNameEntry, sizeof(CERT_ALT_NAME_ENTRY), FALSE,
TRUE, offsetof(CERT_ACCESS_DESCRIPTION, AccessLocation.u.pwszURL), 0 },
};
- CERT_ACCESS_DESCRIPTION *descr = (CERT_ACCESS_DESCRIPTION *)pvStructInfo;
+ CERT_ACCESS_DESCRIPTION *descr = pvStructInfo;
return CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
DWORD *pcbDecoded)
{
- CRYPT_CONTENT_INFO *info = (CRYPT_CONTENT_INFO *)pvStructInfo;
+ CRYPT_CONTENT_INFO *info = pvStructInfo;
struct AsnDecodeSequenceItem items[] = {
{ ASN_OBJECTIDENTIFIER, offsetof(CRYPT_CONTENT_INFO, pszObjId),
CRYPT_AsnDecodeOidIgnoreTag, sizeof(LPSTR), FALSE, TRUE,
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- info = (CRYPT_CONTENT_INFO *)pvStructInfo;
+ info = pvStructInfo;
info->pszObjId = (LPSTR)((BYTE *)info +
sizeof(CRYPT_CONTENT_INFO));
ret = CRYPT_AsnDecodePKCSContentInfoInternal(pbEncoded,
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- name = (CERT_ALT_NAME_INFO *)pvStructInfo;
+ name = pvStructInfo;
name->rgAltEntry = (PCERT_ALT_NAME_ENTRY)
((BYTE *)pvStructInfo + sizeof(CERT_ALT_NAME_INFO));
ret = CRYPT_AsnDecodeAltNameInternal(pbEncoded, cbEncoded,
}
else
{
- struct PATH_LEN_CONSTRAINT *constraint =
- (struct PATH_LEN_CONSTRAINT *)pvStructInfo;
+ struct PATH_LEN_CONSTRAINT *constraint = pvStructInfo;
*pcbStructInfo = bytesNeeded;
size = sizeof(constraint->dwPathLenConstraint);
struct AsnArrayDescriptor arrayDesc = { ASN_SEQUENCEOF,
CRYPT_AsnDecodeCopyBytes, sizeof(CERT_NAME_BLOB), TRUE,
offsetof(CERT_NAME_BLOB, pbData) };
- struct GenericArray *entries = (struct GenericArray *)pvStructInfo;
+ struct GenericArray *entries = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- hdr = (BLOBHEADER *)pvStructInfo;
+ hdr = pvStructInfo;
hdr->bType = PUBLICKEYBLOB;
hdr->bVersion = CUR_BLOB_VERSION;
hdr->reserved = 0;
CRYPT_DATA_BLOB *blob;
*pcbStructInfo = bytesNeeded;
- blob = (CRYPT_DATA_BLOB *)pvStructInfo;
+ blob = pvStructInfo;
blob->cbData = dataLen;
if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
blob->pbData = (BYTE *)pbEncoded + 1 + lenBytes;
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- blob = (CRYPT_DATA_BLOB *)pvStructInfo;
+ blob = pvStructInfo;
blob->pbData = (BYTE *)pvStructInfo + sizeof(CRYPT_DATA_BLOB);
ret = CRYPT_AsnDecodeOctetsInternal(pbEncoded, cbEncoded,
dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
CRYPT_BIT_BLOB *blob;
*pcbStructInfo = bytesNeeded;
- blob = (CRYPT_BIT_BLOB *)pvStructInfo;
+ blob = pvStructInfo;
blob->cbData = dataLen - 1;
blob->cUnusedBits = *(pbEncoded + 1 + lenBytes);
if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- blob = (CRYPT_BIT_BLOB *)pvStructInfo;
+ blob = pvStructInfo;
blob->pbData = (BYTE *)pvStructInfo + sizeof(CRYPT_BIT_BLOB);
ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, pvStructInfo,
}
else
{
- CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)pvStructInfo;
+ CRYPT_INTEGER_BLOB *blob = pvStructInfo;
*pcbStructInfo = bytesNeeded;
blob->cbData = dataLen;
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- blob = (CRYPT_INTEGER_BLOB *)pvStructInfo;
+ blob = pvStructInfo;
blob->pbData = (BYTE *)pvStructInfo +
sizeof(CRYPT_INTEGER_BLOB);
ret = CRYPT_AsnDecodeIntegerInternal(pbEncoded, cbEncoded,
}
else
{
- CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)pvStructInfo;
+ CRYPT_INTEGER_BLOB *blob = pvStructInfo;
*pcbStructInfo = bytesNeeded;
blob->cbData = dataLen;
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- blob = (CRYPT_INTEGER_BLOB *)pvStructInfo;
+ blob = pvStructInfo;
blob->pbData = (BYTE *)pvStructInfo +
sizeof(CRYPT_INTEGER_BLOB);
ret = CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded,
*pcbStructInfo = sizeof(FILETIME);
else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
sizeof(FILETIME))))
- ret = SystemTimeToFileTime(&sysTime,
- (FILETIME *)pvStructInfo);
+ ret = SystemTimeToFileTime(&sysTime, pvStructInfo);
}
}
}
*pcbStructInfo = sizeof(FILETIME);
else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
sizeof(FILETIME))))
- ret = SystemTimeToFileTime(&sysTime,
- (FILETIME *)pvStructInfo);
+ ret = SystemTimeToFileTime(&sysTime, pvStructInfo);
}
}
}
{
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- seq = (CRYPT_SEQUENCE_OF_ANY *)pvStructInfo;
+ seq = pvStructInfo;
seq->cValue = cValue;
seq->rgValue = (CRYPT_DER_BLOB *)((BYTE *)seq +
sizeof(*seq));
}
else
{
- CRL_DIST_POINT_NAME *name = (CRL_DIST_POINT_NAME *)pvStructInfo;
+ CRL_DIST_POINT_NAME *name = pvStructInfo;
*pcbStructInfo = bytesNeeded;
if (dataLen)
CRYPT_AsnDecodeAltNameInternal, sizeof(CERT_ALT_NAME_INFO), TRUE, TRUE,
offsetof(CRL_DIST_POINT, CRLIssuer.rgAltEntry), 0 },
};
- CRL_DIST_POINT *point = (CRL_DIST_POINT *)pvStructInfo;
+ CRL_DIST_POINT *point = pvStructInfo;
BOOL ret;
ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
CRYPT_AsnDecodeMaximum, sizeof(BOOL) + sizeof(DWORD), TRUE, FALSE, 0,
0 },
};
- CERT_GENERAL_SUBTREE *subtree = (CERT_GENERAL_SUBTREE *)pvStructInfo;
+ CERT_GENERAL_SUBTREE *subtree = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
ret = CRYPT_AsnDecodeSequence(items, sizeof(items) / sizeof(items[0]),
pbEncoded, cbEncoded, dwFlags, NULL, pvStructInfo, pcbStructInfo,
- pcbDecoded, subtree ? (BYTE *)subtree->Base.u.pwszURL : NULL);
+ pcbDecoded, subtree ? subtree->Base.u.pwszURL : NULL);
if (pcbDecoded)
{
TRACE("%d\n", *pcbDecoded);
struct AsnArrayDescriptor arrayDesc = { 0,
CRYPT_AsnDecodeSubtree, sizeof(CERT_GENERAL_SUBTREE), TRUE,
offsetof(CERT_GENERAL_SUBTREE, Base.u.pwszURL) };
- struct GenericArray *array = (struct GenericArray *)pvStructInfo;
+ struct GenericArray *array = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
CRYPT_AsnDecodeIntegerInternal, sizeof(CRYPT_INTEGER_BLOB), FALSE,
TRUE, offsetof(CERT_ISSUER_SERIAL_NUMBER, SerialNumber.pbData), 0 },
};
- CERT_ISSUER_SERIAL_NUMBER *issuerSerial =
- (CERT_ISSUER_SERIAL_NUMBER *)pvStructInfo;
+ CERT_ISSUER_SERIAL_NUMBER *issuerSerial = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
DWORD *pcbDecoded)
{
- CMSG_SIGNER_INFO *info = (CMSG_SIGNER_INFO *)pvStructInfo;
+ CMSG_SIGNER_INFO *info = pvStructInfo;
struct AsnDecodeSequenceItem items[] = {
{ ASN_INTEGER, offsetof(CMSG_SIGNER_INFO, dwVersion),
CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- info = (CMSG_SIGNER_INFO *)pvStructInfo;
+ info = pvStructInfo;
info->Issuer.pbData = ((BYTE *)info +
sizeof(CMSG_SIGNER_INFO));
ret = CRYPT_AsnDecodePKCSSignerInfoInternal(pbEncoded,
DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
DWORD *pcbDecoded)
{
- CERT_ID *id = (CERT_ID *)pvStructInfo;
+ CERT_ID *id = pvStructInfo;
BOOL ret = FALSE;
if (*pbEncoded == ASN_SEQUENCEOF)
DWORD cbEncoded, DWORD dwFlags, void *pvStructInfo, DWORD *pcbStructInfo,
DWORD *pcbDecoded)
{
- CMSG_CMS_SIGNER_INFO *info = (CMSG_CMS_SIGNER_INFO *)pvStructInfo;
+ CMSG_CMS_SIGNER_INFO *info = pvStructInfo;
struct AsnDecodeSequenceItem items[] = {
{ ASN_INTEGER, offsetof(CMSG_CMS_SIGNER_INFO, dwVersion),
CRYPT_AsnDecodeIntInternal, sizeof(DWORD), FALSE, FALSE, 0, 0 },
if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
pvStructInfo = *(BYTE **)pvStructInfo;
- info = (CMSG_CMS_SIGNER_INFO *)pvStructInfo;
+ info = pvStructInfo;
info->SignerId.u.KeyId.pbData = ((BYTE *)info +
sizeof(CMSG_CMS_SIGNER_INFO));
ret = CRYPT_AsnDecodeCMSSignerInfoInternal(pbEncoded,
struct AsnArrayDescriptor arrayDesc = { ASN_CONSTRUCTOR | ASN_SETOF,
CRYPT_AsnDecodeCMSSignerInfoInternal, sizeof(CMSG_CMS_SIGNER_INFO), TRUE,
offsetof(CMSG_CMS_SIGNER_INFO, SignerId.u.KeyId.pbData) };
- struct GenericArray *array = (struct GenericArray *)pvStructInfo;
+ struct GenericArray *array = pvStructInfo;
TRACE("%p, %d, %08x, %p, %d, %p\n", pbEncoded, cbEncoded, dwFlags,
pvStructInfo, *pcbStructInfo, pcbDecoded);
TRACE_(crypt)("returning %d\n", ret);
return ret;
}
+
+BOOL WINAPI PFXIsPFXBlob(CRYPT_DATA_BLOB *pPFX)
+{
+ BOOL ret;
+
+ TRACE_(crypt)("(%p)\n", pPFX);
+
+ /* A PFX blob is an asn.1-encoded sequence, consisting of at least a
+ * version integer of length 1 (3 encoded byes) and at least one other
+ * datum (two encoded bytes), plus at least two bytes for the outer
+ * sequence. Thus, even an empty PFX blob is at least 7 bytes in length.
+ */
+ if (pPFX->cbData < 7)
+ ret = FALSE;
+ else if (pPFX->pbData[0] == ASN_SEQUENCE)
+ {
+ DWORD len;
+
+ if ((ret = CRYPT_GetLengthIndefinite(pPFX->pbData, pPFX->cbData, &len)))
+ {
+ BYTE lenLen = GET_LEN_BYTES(pPFX->pbData[1]);
+
+ /* Need at least three bytes for the integer version */
+ if (pPFX->cbData < 1 + lenLen + 3)
+ ret = FALSE;
+ else if (pPFX->pbData[1 + lenLen] != ASN_INTEGER || /* Tag */
+ pPFX->pbData[1 + lenLen + 1] != 1 || /* Definite length */
+ pPFX->pbData[1 + lenLen + 2] != 3) /* PFX version */
+ ret = FALSE;
+ }
+ }
+ else
+ ret = FALSE;
+ return ret;
+}
+
+HCERTSTORE WINAPI PFXImportCertStore(CRYPT_DATA_BLOB *pPFX, LPCWSTR szPassword,
+ DWORD dwFlags)
+{
+ FIXME_(crypt)("(%p, %p, %08x): stub\n", pPFX, szPassword, dwFlags);
+ return NULL;
+}
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
BOOL ret;
- const struct AsnConstructedItem *item =
- (const struct AsnConstructedItem *)pvStructInfo;
+ const struct AsnConstructedItem *item = pvStructInfo;
DWORD len;
if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
BOOL ret;
- const struct AsnEncodeTagSwappedItem *item =
- (const struct AsnEncodeTagSwappedItem *)pvStructInfo;
+ const struct AsnEncodeTagSwappedItem *item = pvStructInfo;
ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
item->pvStructInfo, dwFlags, pEncodePara, pbEncoded, pcbEncoded);
LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
- const DWORD *ver = (const DWORD *)pvStructInfo;
+ const DWORD *ver = pvStructInfo;
BOOL ret;
/* CERT_V1 is not encoded */
LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
- const CRYPT_DER_BLOB *blob = (const CRYPT_DER_BLOB *)pvStructInfo;
+ const CRYPT_DER_BLOB *blob = pvStructInfo;
BOOL ret;
if (!pbEncoded)
{
BOOL ret;
/* This has two filetimes in a row, a NotBefore and a NotAfter */
- const FILETIME *timePtr = (const FILETIME *)pvStructInfo;
+ const FILETIME *timePtr = pvStructInfo;
struct AsnEncodeSequenceItem items[] = {
{ timePtr, CRYPT_AsnEncodeChoiceOfTime, 0 },
{ timePtr + 1, CRYPT_AsnEncodeChoiceOfTime, 0 },
DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
DWORD *pcbEncoded)
{
- const CRYPT_ALGORITHM_IDENTIFIER *algo =
- (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
+ const CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
static const BYTE asn1Null[] = { ASN_NULL, 0 };
static const CRYPT_DATA_BLOB nullBlob = { sizeof(asn1Null),
(LPBYTE)asn1Null };
LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
- const CRYPT_ALGORITHM_IDENTIFIER *algo =
- (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
+ const CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
BOOL ret;
struct AsnEncodeSequenceItem items[] = {
{ algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
__TRY
{
- const CERT_PUBLIC_KEY_INFO *info =
- (const CERT_PUBLIC_KEY_INFO *)pvStructInfo;
+ const CERT_PUBLIC_KEY_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[] = {
{ &info->Algorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
{ &info->PublicKey, CRYPT_AsnEncodeBits, 0 },
__TRY
{
- const CERT_SIGNED_CONTENT_INFO *info =
- (const CERT_SIGNED_CONTENT_INFO *)pvStructInfo;
+ const CERT_SIGNED_CONTENT_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[] = {
{ &info->ToBeSigned, CRYPT_CopyEncodedBlob, 0 },
{ &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
__TRY
{
- const CERT_INFO *info = (const CERT_INFO *)pvStructInfo;
+ const CERT_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[10] = {
{ &info->dwVersion, CRYPT_AsnEncodeCertVersion, 0 },
{ &info->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
- const DWORD *ver = (const DWORD *)pvStructInfo;
+ const DWORD *ver = pvStructInfo;
BOOL ret;
/* CRL_V1 is not encoded */
__TRY
{
- const CRL_INFO *info = (const CRL_INFO *)pvStructInfo;
+ const CRL_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[7] = {
{ &info->dwVersion, CRYPT_AsnEncodeCRLVersion, 0 },
{ &info->SignatureAlgorithm, CRYPT_AsnEncodeAlgorithmId, 0 },
__TRY
{
DWORD bytesNeeded, dataLen, lenBytes, i;
- const CERT_EXTENSIONS *exts = (const CERT_EXTENSIONS *)pvStructInfo;
+ const CERT_EXTENSIONS *exts = pvStructInfo;
ret = TRUE;
for (i = 0, dataLen = 0; ret && i < exts->cExtension; i++)
LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
- LPCSTR pszObjId = (LPCSTR)pvStructInfo;
+ LPCSTR pszObjId = pvStructInfo;
DWORD bytesNeeded = 0, lenBytes;
BOOL ret = TRUE;
int firstPos = 0;
__TRY
{
- const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
+ const CERT_NAME_VALUE *value = pvStructInfo;
switch (value->dwValueType)
{
/* hack: a CERT_RDN_ATTR is identical to a CERT_NAME_VALUE beginning
* with dwValueType, so "cast" it to get its encoded size
*/
- ret = nameValueEncodeFunc(dwCertEncodingType, NULL,
- (CERT_NAME_VALUE *)&attr->dwValueType, 0, NULL, NULL, &size);
+ ret = nameValueEncodeFunc(dwCertEncodingType, NULL, &attr->dwValueType,
+ 0, NULL, NULL, &size);
if (ret)
{
bytesNeeded += size;
{
pbEncoded += size;
size = bytesNeeded - 1 - lenBytes - size;
- ret = nameValueEncodeFunc(dwCertEncodingType,
- NULL, (CERT_NAME_VALUE *)&attr->dwValueType,
- 0, NULL, pbEncoded, &size);
+ ret = nameValueEncodeFunc(dwCertEncodingType, NULL,
+ &attr->dwValueType, 0, NULL, pbEncoded, &size);
if (!ret)
*pcbEncoded = size;
}
static int BLOBComp(const void *l, const void *r)
{
- const CRYPT_DER_BLOB *a = (const CRYPT_DER_BLOB *)l, *b = (const CRYPT_DER_BLOB *)r;
+ const CRYPT_DER_BLOB *a = l, *b = r;
int ret;
if (!(ret = memcmp(a->pbData, b->pbData, min(a->cbData, b->cbData))))
LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
- const CRYPT_BLOB_ARRAY *set = (const CRYPT_BLOB_ARRAY *)pvStructInfo;
+ const CRYPT_BLOB_ARRAY *set = pvStructInfo;
DWORD bytesNeeded = 0, lenBytes, i;
BOOL ret;
LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
- const struct DERSetDescriptor *desc =
- (const struct DERSetDescriptor *)pvStructInfo;
+ const struct DERSetDescriptor *desc = pvStructInfo;
CRYPT_BLOB_ARRAY setOf = { 0, NULL };
BOOL ret = TRUE;
DWORD i;
DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
DWORD *pcbEncoded)
{
- const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
+ const CERT_NAME_VALUE *value = pvStructInfo;
BOOL ret;
if (value->dwValueType == CERT_RDN_ENCODED_BLOB)
__TRY
{
- const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
+ const CERT_NAME_INFO *info = pvStructInfo;
DWORD bytesNeeded = 0, lenBytes, size, i;
TRACE("encoding name with %d RDNs\n", info->cRDN);
LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
- const DWORD *ver = (const DWORD *)pvStructInfo;
+ const DWORD *ver = pvStructInfo;
BOOL ret;
/* CTL_V1 is not encoded */
DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
DWORD *pcbEncoded)
{
- const CRYPT_ALGORITHM_IDENTIFIER *algo =
- (const CRYPT_ALGORITHM_IDENTIFIER *)pvStructInfo;
+ const CRYPT_ALGORITHM_IDENTIFIER *algo = pvStructInfo;
BOOL ret;
struct AsnEncodeSequenceItem items[2] = {
{ algo->pszObjId, CRYPT_AsnEncodeOid, 0 },
{
BOOL ret;
DWORD bytesNeeded, dataLen, lenBytes, i;
- const struct CTLEntries *entries = (const struct CTLEntries *)pvStructInfo;
+ const struct CTLEntries *entries = pvStructInfo;
ret = TRUE;
for (i = 0, dataLen = 0; ret && i < entries->cEntry; i++)
__TRY
{
- const CTL_INFO *info = (const CTL_INFO *)pvStructInfo;
+ const CTL_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[9] = {
{ &info->dwVersion, CRYPT_AsnEncodeCTLVersion, 0 },
{ &info->SubjectUsage, CRYPT_AsnEncodeEnhancedKeyUsage, 0 },
__TRY
{
- const CRYPT_SMIME_CAPABILITY *capability =
- (const CRYPT_SMIME_CAPABILITY *)pvStructInfo;
+ const CRYPT_SMIME_CAPABILITY *capability = pvStructInfo;
if (!capability->pszObjId)
SetLastError(E_INVALIDARG);
__TRY
{
DWORD bytesNeeded, dataLen, lenBytes, i;
- const CRYPT_SMIME_CAPABILITIES *capabilities =
- (const CRYPT_SMIME_CAPABILITIES *)pvStructInfo;
+ const CRYPT_SMIME_CAPABILITIES *capabilities = pvStructInfo;
ret = TRUE;
for (i = 0, dataLen = 0; ret && i < capabilities->cCapability; i++)
__TRY
{
- const CRYPT_ATTRIBUTE *attr = (const CRYPT_ATTRIBUTE *)pvStructInfo;
+ const CRYPT_ATTRIBUTE *attr = pvStructInfo;
if (!attr->pszObjId)
SetLastError(E_INVALIDARG);
__TRY
{
- const CRYPT_ATTRIBUTES *attributes =
- (const CRYPT_ATTRIBUTES *)pvStructInfo;
+ const CRYPT_ATTRIBUTES *attributes = pvStructInfo;
struct DERSetDescriptor desc = { attributes->cAttr, attributes->rgAttr,
sizeof(CRYPT_ATTRIBUTE), 0, CRYPT_AsnEncodePKCSAttribute };
DWORD dwFlags, PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded,
DWORD *pcbEncoded)
{
- const CRYPT_CONTENT_INFO *info = (const CRYPT_CONTENT_INFO *)pvStructInfo;
+ const CRYPT_CONTENT_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[2] = {
{ info->pszObjId, CRYPT_AsnEncodeOid, 0 },
{ NULL, NULL, 0 },
__TRY
{
- const CRYPT_CONTENT_INFO *info =
- (const CRYPT_CONTENT_INFO *)pvStructInfo;
+ const CRYPT_CONTENT_INFO *info = pvStructInfo;
if (!info->pszObjId)
SetLastError(E_INVALIDARG);
__TRY
{
- const CERT_NAME_VALUE *value = (const CERT_NAME_VALUE *)pvStructInfo;
+ const CERT_NAME_VALUE *value = pvStructInfo;
switch (value->dwValueType)
{
__TRY
{
- const CERT_NAME_INFO *info = (const CERT_NAME_INFO *)pvStructInfo;
+ const CERT_NAME_INFO *info = pvStructInfo;
DWORD bytesNeeded = 0, lenBytes, size, i;
TRACE("encoding name with %d RDNs\n", info->cRDN);
LPCSTR lpszStructType, const void *pvStructInfo, DWORD dwFlags,
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
- const CERT_ALT_NAME_ENTRY *entry =
- (const CERT_ALT_NAME_ENTRY *)pvStructInfo;
+ const CERT_ALT_NAME_ENTRY *entry = pvStructInfo;
BOOL ret;
DWORD dataLen;
BYTE tag;
__TRY
{
- const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
+ const CRYPT_DATA_BLOB *blob = pvStructInfo;
CRYPT_DATA_BLOB newBlob = { blob->cbData, NULL };
ret = TRUE;
__TRY
{
- const CERT_AUTHORITY_KEY_ID_INFO *info =
- (const CERT_AUTHORITY_KEY_ID_INFO *)pvStructInfo;
+ const CERT_AUTHORITY_KEY_ID_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[3] = { { 0 } };
struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
struct AsnConstructedItem constructed = { 0 };
__TRY
{
- const CERT_ALT_NAME_INFO *info =
- (const CERT_ALT_NAME_INFO *)pvStructInfo;
+ const CERT_ALT_NAME_INFO *info = pvStructInfo;
DWORD bytesNeeded, dataLen, lenBytes, i;
ret = TRUE;
__TRY
{
- const CERT_AUTHORITY_KEY_ID2_INFO *info =
- (const CERT_AUTHORITY_KEY_ID2_INFO *)pvStructInfo;
+ const CERT_AUTHORITY_KEY_ID2_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[3] = { { 0 } };
struct AsnEncodeTagSwappedItem swapped[3] = { { 0 } };
DWORD cItem = 0, cSwapped = 0;
__TRY
{
DWORD bytesNeeded, dataLen, lenBytes, i;
- const CERT_AUTHORITY_INFO_ACCESS *info =
- (const CERT_AUTHORITY_INFO_ACCESS *)pvStructInfo;
+ const CERT_AUTHORITY_INFO_ACCESS *info = pvStructInfo;
ret = TRUE;
for (i = 0, dataLen = 0; ret && i < info->cAccDescr; i++)
__TRY
{
- const CERT_BASIC_CONSTRAINTS_INFO *info =
- (const CERT_BASIC_CONSTRAINTS_INFO *)pvStructInfo;
+ const CERT_BASIC_CONSTRAINTS_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[3] = {
{ &info->SubjectType, CRYPT_AsnEncodeBits, 0 },
{ 0 }
__TRY
{
- const CERT_BASIC_CONSTRAINTS2_INFO *info =
- (const CERT_BASIC_CONSTRAINTS2_INFO *)pvStructInfo;
+ const CERT_BASIC_CONSTRAINTS2_INFO *info = pvStructInfo;
struct AsnEncodeSequenceItem items[2] = { { 0 } };
DWORD cItem = 0;
__TRY
{
- const BLOBHEADER *hdr =
- (const BLOBHEADER *)pvStructInfo;
+ const BLOBHEADER *hdr = pvStructInfo;
if (hdr->bType != PUBLICKEYBLOB)
{
__TRY
{
- const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvStructInfo;
+ const CRYPT_DATA_BLOB *blob = pvStructInfo;
DWORD bytesNeeded, lenBytes;
TRACE("(%d, %p), %08x, %p, %p, %d\n", blob->cbData, blob->pbData,
__TRY
{
- const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
+ const CRYPT_BIT_BLOB *blob = pvStructInfo;
DWORD bytesNeeded, lenBytes, dataBytes;
BYTE unusedBits;
__TRY
{
- const CRYPT_BIT_BLOB *blob = (const CRYPT_BIT_BLOB *)pvStructInfo;
+ const CRYPT_BIT_BLOB *blob = pvStructInfo;
CRYPT_BIT_BLOB newBlob = { blob->cbData, NULL, blob->cUnusedBits };
ret = TRUE;
DWORD significantBytes, lenBytes, bytesNeeded;
BYTE padByte = 0;
BOOL pad = FALSE;
- const CRYPT_INTEGER_BLOB *blob =
- (const CRYPT_INTEGER_BLOB *)pvStructInfo;
+ const CRYPT_INTEGER_BLOB *blob = pvStructInfo;
significantBytes = blob->cbData;
if (significantBytes)
{
DWORD significantBytes, lenBytes, bytesNeeded;
BOOL pad = FALSE;
- const CRYPT_INTEGER_BLOB *blob =
- (const CRYPT_INTEGER_BLOB *)pvStructInfo;
+ const CRYPT_INTEGER_BLOB *blob = pvStructInfo;
significantBytes = blob->cbData;
if (significantBytes)
else
{
/* Sanity check the year, this is a two-digit year format */
- ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
- &sysTime);
+ ret = FileTimeToSystemTime(pvStructInfo, &sysTime);
if (ret && (sysTime.wYear < 1950 || sysTime.wYear > 2050))
{
SetLastError(CRYPT_E_BAD_ENCODE);
}
else
{
- ret = FileTimeToSystemTime((const FILETIME *)pvStructInfo,
- &sysTime);
+ ret = FileTimeToSystemTime(pvStructInfo, &sysTime);
if (ret)
ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
pcbEncoded, bytesNeeded);
SYSTEMTIME sysTime;
/* Check the year, if it's in the UTCTime range call that encode func */
- if (!FileTimeToSystemTime((const FILETIME *)pvStructInfo, &sysTime))
+ if (!FileTimeToSystemTime(pvStructInfo, &sysTime))
return FALSE;
if (sysTime.wYear >= 1950 && sysTime.wYear <= 2050)
ret = CRYPT_AsnEncodeUtcTime(dwCertEncodingType, lpszStructType,
__TRY
{
DWORD bytesNeeded, dataLen, lenBytes, i;
- const CRYPT_SEQUENCE_OF_ANY *seq =
- (const CRYPT_SEQUENCE_OF_ANY *)pvStructInfo;
+ const CRYPT_SEQUENCE_OF_ANY *seq = pvStructInfo;
for (i = 0, dataLen = 0; i < seq->cValue; i++)
dataLen += seq->rgValue[i].cbData;
__TRY
{
- const CRL_DIST_POINTS_INFO *info =
- (const CRL_DIST_POINTS_INFO *)pvStructInfo;
+ const CRL_DIST_POINTS_INFO *info = pvStructInfo;
if (!info->cDistPoint)
{
__TRY
{
- const CERT_ENHKEY_USAGE *usage =
- (const CERT_ENHKEY_USAGE *)pvStructInfo;
+ const CERT_ENHKEY_USAGE *usage = pvStructInfo;
DWORD bytesNeeded = 0, lenBytes, size, i;
ret = TRUE;
__TRY
{
- const CRL_ISSUING_DIST_POINT *point =
- (const CRL_ISSUING_DIST_POINT *)pvStructInfo;
+ const CRL_ISSUING_DIST_POINT *point = pvStructInfo;
struct AsnEncodeSequenceItem items[6] = { { 0 } };
struct AsnConstructedItem constructed = { 0 };
struct AsnEncodeTagSwappedItem swapped[5] = { { 0 } };
PCRYPT_ENCODE_PARA pEncodePara, BYTE *pbEncoded, DWORD *pcbEncoded)
{
BOOL ret;
- const CERT_GENERAL_SUBTREE *subtree =
- (const CERT_GENERAL_SUBTREE *)pvStructInfo;
+ const CERT_GENERAL_SUBTREE *subtree = pvStructInfo;
struct AsnEncodeSequenceItem items[3] = {
{ &subtree->Base, CRYPT_AsnEncodeAltNameEntry, 0 },
{ 0 }
__TRY
{
- const CERT_NAME_CONSTRAINTS_INFO *constraints =
- (const CERT_NAME_CONSTRAINTS_INFO *)pvStructInfo;
+ const CERT_NAME_CONSTRAINTS_INFO *constraints = pvStructInfo;
struct AsnEncodeSequenceItem items[2] = { { 0 } };
struct AsnEncodeTagSwappedItem swapped[2] = { { 0 } };
DWORD i, cItem = 0, cSwapped = 0;
DWORD *pcbEncoded)
{
BOOL ret;
- const CERT_ISSUER_SERIAL_NUMBER *issuerSerial =
- (const CERT_ISSUER_SERIAL_NUMBER *)pvStructInfo;
+ const CERT_ISSUER_SERIAL_NUMBER *issuerSerial = pvStructInfo;
struct AsnEncodeSequenceItem items[] = {
{ &issuerSerial->Issuer, CRYPT_CopyEncodedBlob, 0 },
{ &issuerSerial->SerialNumber, CRYPT_AsnEncodeInteger, 0 },
__TRY
{
- const CMSG_SIGNER_INFO *info = (const CMSG_SIGNER_INFO *)pvStructInfo;
+ const CMSG_SIGNER_INFO *info = pvStructInfo;
if (!info->Issuer.cbData)
SetLastError(E_INVALIDARG);
__TRY
{
- const CMSG_CMS_SIGNER_INFO *info = (const CMSG_CMS_SIGNER_INFO *)pvStructInfo;
+ const CMSG_CMS_SIGNER_INFO *info = pvStructInfo;
if (info->SignerId.dwIdChoice != CERT_ID_ISSUER_SERIAL_NUMBER &&
info->SignerId.dwIdChoice != CERT_ID_KEY_IDENTIFIER)
return ret;
}
+BOOL WINAPI PFXExportCertStore(HCERTSTORE hStore, CRYPT_DATA_BLOB *pPFX,
+ LPCWSTR szPassword, DWORD dwFlags)
+{
+ return PFXExportCertStoreEx(hStore, pPFX, szPassword, NULL, dwFlags);
+}
+
+BOOL WINAPI PFXExportCertStoreEx(HCERTSTORE hStore, CRYPT_DATA_BLOB *pPFX,
+ LPCWSTR szPassword, void *pvReserved, DWORD dwFlags)
+{
+ FIXME_(crypt)("(%p, %p, %p, %p, %08x): stub\n", hStore, pPFX, szPassword,
+ pvReserved, dwFlags);
+ return FALSE;
+}
+
BOOL WINAPI CryptExportPublicKeyInfo(HCRYPTPROV_OR_NCRYPT_KEY_HANDLE hCryptProv, DWORD dwKeySpec,
DWORD dwCertEncodingType, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo)
{
static void WINAPI CRYPT_FileCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{
- PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
+ PWINE_FILESTOREINFO store = hCertStore;
TRACE("(%p, %08x)\n", store, dwFlags);
if (store->dirty)
static BOOL WINAPI CRYPT_FileWriteCert(HCERTSTORE hCertStore,
PCCERT_CONTEXT cert, DWORD dwFlags)
{
- PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
+ PWINE_FILESTOREINFO store = hCertStore;
TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
store->dirty = TRUE;
static BOOL WINAPI CRYPT_FileDeleteCert(HCERTSTORE hCertStore,
PCCERT_CONTEXT pCertContext, DWORD dwFlags)
{
- PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
+ PWINE_FILESTOREINFO store = hCertStore;
TRACE("(%p, %p, %08x)\n", hCertStore, pCertContext, dwFlags);
store->dirty = TRUE;
static BOOL WINAPI CRYPT_FileWriteCRL(HCERTSTORE hCertStore,
PCCRL_CONTEXT crl, DWORD dwFlags)
{
- PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
+ PWINE_FILESTOREINFO store = hCertStore;
TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
store->dirty = TRUE;
static BOOL WINAPI CRYPT_FileDeleteCRL(HCERTSTORE hCertStore,
PCCRL_CONTEXT pCrlContext, DWORD dwFlags)
{
- PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
+ PWINE_FILESTOREINFO store = hCertStore;
TRACE("(%p, %p, %08x)\n", hCertStore, pCrlContext, dwFlags);
store->dirty = TRUE;
static BOOL WINAPI CRYPT_FileWriteCTL(HCERTSTORE hCertStore,
PCCTL_CONTEXT ctl, DWORD dwFlags)
{
- PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
+ PWINE_FILESTOREINFO store = hCertStore;
TRACE("(%p, %p, %d)\n", hCertStore, ctl, dwFlags);
store->dirty = TRUE;
static BOOL WINAPI CRYPT_FileDeleteCTL(HCERTSTORE hCertStore,
PCCTL_CONTEXT pCtlContext, DWORD dwFlags)
{
- PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
+ PWINE_FILESTOREINFO store = hCertStore;
TRACE("(%p, %p, %08x)\n", hCertStore, pCtlContext, dwFlags);
store->dirty = TRUE;
static BOOL WINAPI CRYPT_FileControl(HCERTSTORE hCertStore, DWORD dwFlags,
DWORD dwCtrlType, void const *pvCtrlPara)
{
- PWINE_FILESTOREINFO store = (PWINE_FILESTOREINFO)hCertStore;
+ PWINE_FILESTOREINFO store = hCertStore;
BOOL ret;
TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
DWORD dwFlags, const void *pvPara)
{
HCERTSTORE store = 0;
- LPCWSTR fileName = (LPCWSTR)pvPara;
+ LPCWSTR fileName = pvPara;
DWORD access, create;
HANDLE file;
CryptReleaseContext(hCryptProv, 0);
}
}
- return (PWINECRYPT_CERTSTORE)store;
+ return store;
}
PWINECRYPT_CERTSTORE CRYPT_FileNameOpenStoreA(HCRYPTPROV hCryptProv,
PWINECRYPT_CERTSTORE ret = NULL;
TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
- debugstr_a((LPCSTR)pvPara));
+ debugstr_a(pvPara));
if (!pvPara)
{
SetLastError(ERROR_FILE_NOT_FOUND);
return NULL;
}
- len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, NULL, 0);
+ len = MultiByteToWideChar(CP_ACP, 0, pvPara, -1, NULL, 0);
if (len)
{
LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
if (storeName)
{
- MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, storeName, len);
+ MultiByteToWideChar(CP_ACP, 0, pvPara, -1, storeName, len);
ret = CRYPT_FileNameOpenStoreW(hCryptProv, dwFlags, storeName);
CryptMemFree(storeName);
}
static void CDataEncodeMsg_Close(HCRYPTMSG hCryptMsg)
{
- CDataEncodeMsg *msg = (CDataEncodeMsg *)hCryptMsg;
+ CDataEncodeMsg *msg = hCryptMsg;
if (msg->bare_content != empty_data_content)
LocalFree(msg->bare_content);
static BOOL CDataEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
DWORD cbData, BOOL fFinal)
{
- CDataEncodeMsg *msg = (CDataEncodeMsg *)hCryptMsg;
+ CDataEncodeMsg *msg = hCryptMsg;
BOOL ret = FALSE;
if (msg->base.state == MsgStateFinalized)
static BOOL CDataEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
DWORD dwIndex, void *pvData, DWORD *pcbData)
{
- CDataEncodeMsg *msg = (CDataEncodeMsg *)hCryptMsg;
+ CDataEncodeMsg *msg = hCryptMsg;
BOOL ret = FALSE;
switch (dwParamType)
msg->bare_content_len = sizeof(empty_data_content);
msg->bare_content = (LPBYTE)empty_data_content;
}
- return (HCRYPTMSG)msg;
+ return msg;
}
typedef struct _CHashEncodeMsg
static void CHashEncodeMsg_Close(HCRYPTMSG hCryptMsg)
{
- CHashEncodeMsg *msg = (CHashEncodeMsg *)hCryptMsg;
+ CHashEncodeMsg *msg = hCryptMsg;
CryptMemFree(msg->data.pbData);
CryptDestroyHash(msg->hash);
static BOOL CHashEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
DWORD dwIndex, void *pvData, DWORD *pcbData)
{
- CHashEncodeMsg *msg = (CHashEncodeMsg *)hCryptMsg;
+ CHashEncodeMsg *msg = hCryptMsg;
BOOL ret = FALSE;
TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
break;
}
case CMSG_COMPUTED_HASH_PARAM:
- ret = CryptGetHashParam(msg->hash, HP_HASHVAL, (BYTE *)pvData, pcbData,
- 0);
+ ret = CryptGetHashParam(msg->hash, HP_HASHVAL, pvData, pcbData, 0);
break;
case CMSG_VERSION_PARAM:
if (msg->base.state != MsgStateFinalized)
static BOOL CHashEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
DWORD cbData, BOOL fFinal)
{
- CHashEncodeMsg *msg = (CHashEncodeMsg *)hCryptMsg;
+ CHashEncodeMsg *msg = hCryptMsg;
BOOL ret = FALSE;
TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
LPSTR pszInnerContentObjID, PCMSG_STREAM_INFO pStreamInfo)
{
CHashEncodeMsg *msg;
- const CMSG_HASHED_ENCODE_INFO *info =
- (const CMSG_HASHED_ENCODE_INFO *)pvMsgEncodeInfo;
+ const CMSG_HASHED_ENCODE_INFO *info = pvMsgEncodeInfo;
HCRYPTPROV prov;
ALG_ID algID;
msg = NULL;
}
}
- return (HCRYPTMSG)msg;
+ return msg;
}
typedef struct _CMSG_SIGNER_ENCODE_INFO_WITH_CMS
ret = CryptEncodeObjectEx(X509_ASN_ENCODING, PKCS_ATTRIBUTES,
&msg_data->info->rgSignerInfo[i].AuthAttrs,
- CRYPT_ENCODE_ALLOC_FLAG, NULL, (LPBYTE)&encodedAttrs, &size);
+ CRYPT_ENCODE_ALLOC_FLAG, NULL, &encodedAttrs, &size);
if (ret)
{
ret = CryptHashData(
static void CSignedEncodeMsg_Close(HCRYPTMSG hCryptMsg)
{
- CSignedEncodeMsg *msg = (CSignedEncodeMsg *)hCryptMsg;
+ CSignedEncodeMsg *msg = hCryptMsg;
DWORD i;
CryptMemFree(msg->innerOID);
static BOOL CSignedEncodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
DWORD dwIndex, void *pvData, DWORD *pcbData)
{
- CSignedEncodeMsg *msg = (CSignedEncodeMsg *)hCryptMsg;
+ CSignedEncodeMsg *msg = hCryptMsg;
BOOL ret = FALSE;
switch (dwParamType)
static BOOL CSignedEncodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
DWORD cbData, BOOL fFinal)
{
- CSignedEncodeMsg *msg = (CSignedEncodeMsg *)hCryptMsg;
+ CSignedEncodeMsg *msg = hCryptMsg;
BOOL ret = FALSE;
if (msg->base.state == MsgStateFinalized)
const void *pvMsgEncodeInfo, LPSTR pszInnerContentObjID,
PCMSG_STREAM_INFO pStreamInfo)
{
- const CMSG_SIGNED_ENCODE_INFO_WITH_CMS *info =
- (const CMSG_SIGNED_ENCODE_INFO_WITH_CMS *)pvMsgEncodeInfo;
+ const CMSG_SIGNED_ENCODE_INFO_WITH_CMS *info = pvMsgEncodeInfo;
DWORD i;
CSignedEncodeMsg *msg;
static void CDecodeMsg_Close(HCRYPTMSG hCryptMsg)
{
- CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
+ CDecodeMsg *msg = hCryptMsg;
if (msg->base.open_flags & CMSG_CRYPT_RELEASE_CONTEXT_FLAG)
CryptReleaseContext(msg->crypt_prov, 0);
DWORD size;
ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
- blob->pbData, blob->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, (LPBYTE)&data,
- &size);
+ blob->pbData, blob->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &data, &size);
if (ret)
{
ret = ContextPropertyList_SetProperty(msg->properties,
ret = CryptDecodeObjectEx(X509_ASN_ENCODING, PKCS_CONTENT_INFO,
msg->msg_data.pbData, msg->msg_data.cbData, CRYPT_DECODE_ALLOC_FLAG,
- NULL, (LPBYTE)&info, &size);
+ NULL, &info, &size);
if (ret)
{
if (!strcmp(info->pszObjId, szOID_RSA_data))
ret = CryptDecodeObjectEx(X509_ASN_ENCODING,
X509_OCTET_STRING, content->pbData, content->cbData,
- CRYPT_DECODE_ALLOC_FLAG, NULL, (LPBYTE)&blob, &size);
+ CRYPT_DECODE_ALLOC_FLAG, NULL, &blob, &size);
if (ret)
{
ret = CSignedMsgData_Update(&msg->u.signed_data,
static BOOL CDecodeMsg_Update(HCRYPTMSG hCryptMsg, const BYTE *pbData,
DWORD cbData, BOOL fFinal)
{
- CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
+ CDecodeMsg *msg = hCryptMsg;
BOOL ret = FALSE;
TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
{
ret = CRYPT_CopyParam(pvData, pcbData, blob.pbData, blob.cbData);
if (ret && pvData)
- CRYPT_FixUpAlgorithmID((CRYPT_ALGORITHM_IDENTIFIER *)pvData);
+ CRYPT_FixUpAlgorithmID(pvData);
}
else
SetLastError(CRYPT_E_INVALID_MSG_TYPE);
else
{
LPBYTE nextData = (BYTE *)pvData + sizeof(CMSG_SIGNER_INFO);
- CMSG_SIGNER_INFO *out = (CMSG_SIGNER_INFO *)pvData;
+ CMSG_SIGNER_INFO *out = pvData;
ret = TRUE;
out->dwVersion = in->dwVersion;
else
{
LPBYTE nextData = (BYTE *)pvData + sizeof(CMSG_CMS_SIGNER_INFO);
- CMSG_CMS_SIGNER_INFO *out = (CMSG_CMS_SIGNER_INFO *)pvData;
+ CMSG_CMS_SIGNER_INFO *out = pvData;
out->dwVersion = in->dwVersion;
out->SignerId.dwIdChoice = in->SignerId.dwIdChoice;
else
{
LPBYTE nextData = (BYTE *)pvData + sizeof(CERT_INFO);
- CERT_INFO *out = (CERT_INFO *)pvData;
+ CERT_INFO *out = pvData;
memset(out, 0, sizeof(CERT_INFO));
if (in->SignerId.dwIdChoice == CERT_ID_ISSUER_SERIAL_NUMBER)
ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_OCTET_STRING,
msg->u.signed_data.info->content.Content.pbData,
msg->u.signed_data.info->content.Content.cbData,
- CRYPT_DECODE_ALLOC_FLAG, NULL, (LPBYTE)&blob, &size);
+ CRYPT_DECODE_ALLOC_FLAG, NULL, &blob, &size);
if (ret)
{
ret = CRYPT_CopyParam(pvData, pcbData, blob->pbData,
static BOOL CDecodeMsg_GetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
DWORD dwIndex, void *pvData, DWORD *pcbData)
{
- CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
+ CDecodeMsg *msg = hCryptMsg;
BOOL ret = FALSE;
switch (msg->type)
{
case CMSG_VERIFY_SIGNER_PUBKEY:
ret = CDecodeSignedMsg_VerifySignatureWithKey(msg,
- para->hCryptProv, para->dwSignerIndex,
- (PCERT_PUBLIC_KEY_INFO)para->pvSigner);
+ para->hCryptProv, para->dwSignerIndex, para->pvSigner);
break;
case CMSG_VERIFY_SIGNER_CERT:
{
- PCCERT_CONTEXT cert = (PCCERT_CONTEXT)para->pvSigner;
+ PCCERT_CONTEXT cert = para->pvSigner;
ret = CDecodeSignedMsg_VerifySignatureWithKey(msg, para->hCryptProv,
para->dwSignerIndex, &cert->pCertInfo->SubjectPublicKeyInfo);
static BOOL CDecodeMsg_Control(HCRYPTMSG hCryptMsg, DWORD dwFlags,
DWORD dwCtrlType, const void *pvCtrlPara)
{
- CDecodeMsg *msg = (CDecodeMsg *)hCryptMsg;
+ CDecodeMsg *msg = hCryptMsg;
BOOL ret = FALSE;
switch (dwCtrlType)
if (hCryptMsg)
{
- CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
+ CryptMsgBase *msg = hCryptMsg;
InterlockedIncrement(&msg->ref);
}
if (hCryptMsg)
{
- CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
+ CryptMsgBase *msg = hCryptMsg;
if (InterlockedDecrement(&msg->ref) == 0)
{
BOOL WINAPI CryptMsgUpdate(HCRYPTMSG hCryptMsg, const BYTE *pbData,
DWORD cbData, BOOL fFinal)
{
- CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
+ CryptMsgBase *msg = hCryptMsg;
TRACE("(%p, %p, %d, %d)\n", hCryptMsg, pbData, cbData, fFinal);
BOOL WINAPI CryptMsgGetParam(HCRYPTMSG hCryptMsg, DWORD dwParamType,
DWORD dwIndex, void *pvData, DWORD *pcbData)
{
- CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
+ CryptMsgBase *msg = hCryptMsg;
TRACE("(%p, %d, %d, %p, %p)\n", hCryptMsg, dwParamType, dwIndex,
pvData, pcbData);
BOOL WINAPI CryptMsgControl(HCRYPTMSG hCryptMsg, DWORD dwFlags,
DWORD dwCtrlType, const void *pvCtrlPara)
{
- CryptMsgBase *msg = (CryptMsgBase *)hCryptMsg;
+ CryptMsgBase *msg = hCryptMsg;
TRACE("(%p, %08x, %d, %p)\n", hCryptMsg, dwFlags, dwCtrlType,
pvCtrlPara);
/* Cert, CRL, and CTL contexts can't be "embedded" in a file, so
* just read the file directly
*/
- ret = CRYPT_ReadBlobFromFile((LPCWSTR)pvObject, &fileBlob);
+ ret = CRYPT_ReadBlobFromFile(pvObject, &fileBlob);
blob = &fileBlob;
break;
case CERT_QUERY_OBJECT_BLOB:
- blob = (const CERT_BLOB *)pvObject;
+ blob = pvObject;
ret = TRUE;
break;
default:
/* Cert, CRL, and CTL contexts can't be "embedded" in a file, so
* just read the file directly
*/
- ret = CRYPT_ReadBlobFromFile((LPCWSTR)pvObject, &fileBlob);
+ ret = CRYPT_ReadBlobFromFile(pvObject, &fileBlob);
blob = &fileBlob;
break;
case CERT_QUERY_OBJECT_BLOB:
- blob = (const CERT_BLOB *)pvObject;
+ blob = pvObject;
ret = TRUE;
break;
default:
const void *pvObject, DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType,
HCERTSTORE *phCertStore, HCRYPTMSG *phMsg)
{
- LPCWSTR fileName = (LPCWSTR)pvObject;
+ LPCWSTR fileName = pvObject;
HANDLE file;
BOOL ret = FALSE;
/* This isn't an embedded PKCS7 message, so just read the file
* directly
*/
- ret = CRYPT_ReadBlobFromFile((LPCWSTR)pvObject, &fileBlob);
+ ret = CRYPT_ReadBlobFromFile(pvObject, &fileBlob);
blob = &fileBlob;
break;
case CERT_QUERY_OBJECT_BLOB:
- blob = (const CERT_BLOB *)pvObject;
+ blob = pvObject;
ret = TRUE;
break;
default:
GUID subject;
BOOL ret = FALSE;
- TRACE("%s\n", debugstr_w((LPCWSTR)pvObject));
+ TRACE("%s\n", debugstr_w(pvObject));
if (dwObjectType != CERT_QUERY_OBJECT_FILE)
{
SetLastError(E_INVALIDARG);
return FALSE;
}
- file = CreateFileW((LPCWSTR)pvObject, GENERIC_READ, FILE_SHARE_READ,
+ file = CreateFileW(pvObject, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (file != INVALID_HANDLE_VALUE)
{
- ret = CryptSIPRetrieveSubjectGuid((LPCWSTR)pvObject, file, &subject);
+ ret = CryptSIPRetrieveSubjectGuid(pvObject, file, &subject);
if (ret)
{
SIP_DISPATCH_INFO sip;
subjectInfo.cbSize = sizeof(subjectInfo);
subjectInfo.pgSubjectType = &subject;
subjectInfo.hFile = file;
- subjectInfo.pwsFileName = (LPCWSTR)pvObject;
+ subjectInfo.pwsFileName = pvObject;
ret = sip.pfGet(&subjectInfo, &encodingType, 0, &blob.cbData,
NULL);
if (ret)
else
{
*pcbFormat = bytesNeeded;
- strcpyW((LPWSTR)pbFormat, infoNotAvailable);
+ strcpyW(pbFormat, infoNotAvailable);
}
}
else
else
{
*pcbFormat = bytesNeeded;
- strcpyW((LPWSTR)pbFormat, infoNotAvailable);
+ strcpyW(pbFormat, infoNotAvailable);
}
}
else
static const WCHAR MY[] = {'M','Y',0};
static const WCHAR CA[] = {'C','A',0};
static const WCHAR ADDRESSBOOK[] = {'A','D','D','R','E','S','S','B','O','O','K',0};
-static const LPCWSTR LocalizedKeys[] = {ROOT,MY,CA,ADDRESSBOOK};
-static WCHAR LocalizedNames[4][256];
+static const WCHAR TRUSTEDPUBLISHER[] = {'T','r','u','s','t','e','d','P','u','b','l','i','s','h','e','r',0};
+static const LPCWSTR LocalizedKeys[] = {ROOT,MY,CA,ADDRESSBOOK,TRUSTEDPUBLISHER};
+static WCHAR LocalizedNames[sizeof(LocalizedKeys)/sizeof(LocalizedKeys[0])][256];
static void free_function_sets(void)
{
{
if (!strcasecmp(pszFuncName, cursor->name))
{
- ret = (HCRYPTOIDFUNCSET)cursor;
+ ret = cursor;
break;
}
}
}
LeaveCriticalSection(&funcSetCS);
- return (HCRYPTOIDFUNCSET)ret;
+ return ret;
}
static char *CRYPT_GetKeyName(DWORD dwEncodingType, LPCSTR pszFuncName,
DWORD dwEncodingType, LPWSTR pwszDllList, DWORD *pcchDllList)
{
BOOL ret = TRUE;
- struct OIDFunctionSet *set = (struct OIDFunctionSet *)hFuncSet;
+ struct OIDFunctionSet *set = hFuncSet;
char *keyName;
HKEY key;
long rc;
TRACE("(%p, %d, %s, %d, %p, %08x)\n", hModule, dwEncodingType,
debugstr_a(pszFuncName), cFuncEntry, rgFuncEntry, dwFlags);
- set = (struct OIDFunctionSet *)CryptInitOIDFunctionSet(pszFuncName, 0);
+ set = CryptInitOIDFunctionSet(pszFuncName, 0);
if (set)
{
DWORD i;
HCRYPTOIDFUNCADDR *phFuncAddr)
{
BOOL ret = FALSE;
- struct OIDFunctionSet *set = (struct OIDFunctionSet *)hFuncSet;
+ struct OIDFunctionSet *set = hFuncSet;
TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType,
debugstr_a(pszOID), dwFlags, ppvFuncAddr, phFuncAddr);
*/
if (hFuncAddr)
{
- struct FuncAddr *addr = (struct FuncAddr *)hFuncAddr;
+ struct FuncAddr *addr = hFuncAddr;
CryptMemFree(addr->dllList);
FreeLibrary(addr->lib);
DWORD dwEncodingType, LPCWSTR pwszDll, DWORD dwFlags, void **ppvFuncAddr,
HCRYPTOIDFUNCADDR *phFuncAddr)
{
- struct OIDFunctionSet *set = (struct OIDFunctionSet *)hFuncSet;
+ struct OIDFunctionSet *set = hFuncSet;
BOOL ret = FALSE;
TRACE("(%p, %d, %s, %08x, %p, %p)\n", hFuncSet, dwEncodingType,
}
else
{
- struct FuncAddr *addr = (struct FuncAddr *)*phFuncAddr;
+ struct FuncAddr *addr = *phFuncAddr;
if (!addr)
{
{
struct OIDInfo *info;
- TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w((LPWSTR)pvKey));
+ TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w(pvKey));
EnterCriticalSection(&oidInfoCS);
LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
{
- if (!lstrcmpW(info->info.pwszName, (LPWSTR)pvKey) &&
+ if (!lstrcmpW(info->info.pwszName, pvKey) &&
(!dwGroupId || info->info.dwGroupId == dwGroupId))
{
ret = &info->info;
case CRYPT_OID_INFO_OID_KEY:
{
struct OIDInfo *info;
- LPSTR oid = (LPSTR)pvKey;
+ LPSTR oid = pvKey;
TRACE("CRYPT_OID_INFO_OID_KEY: %s\n", debugstr_a(oid));
EnterCriticalSection(&oidInfoCS);
static void WINAPI CRYPT_ProvCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{
- PWINE_PROVIDERSTORE store = (PWINE_PROVIDERSTORE)hCertStore;
+ PWINE_PROVIDERSTORE store = hCertStore;
TRACE("(%p, %08x)\n", store, dwFlags);
{
ret = TRUE;
if (ps->provWriteCert)
- ret = ps->provWriteCert(ps->hStoreProv, (PCCERT_CONTEXT)cert,
+ ret = ps->provWriteCert(ps->hStoreProv, cert,
CERT_STORE_PROV_WRITE_ADD_FLAG);
if (ret)
ret = ps->memStore->certs.addContext(ps->memStore, cert, NULL,
{
ret = TRUE;
if (ps->provWriteCrl)
- ret = ps->provWriteCrl(ps->hStoreProv, (PCCRL_CONTEXT)crl,
+ ret = ps->provWriteCrl(ps->hStoreProv, crl,
CERT_STORE_PROV_WRITE_ADD_FLAG);
if (ret)
ret = ps->memStore->crls.addContext(ps->memStore, crl, NULL,
{
ret = TRUE;
if (ps->provWriteCtl)
- ret = ps->provWriteCtl(ps->hStoreProv, (PCCTL_CONTEXT)ctl,
+ ret = ps->provWriteCtl(ps->hStoreProv, ctl,
CERT_STORE_PROV_WRITE_ADD_FLAG);
if (ret)
ret = ps->memStore->ctls.addContext(ps->memStore, ctl, NULL,
static BOOL WINAPI CRYPT_ProvControl(HCERTSTORE hCertStore, DWORD dwFlags,
DWORD dwCtrlType, void const *pvCtrlPara)
{
- PWINE_PROVIDERSTORE store = (PWINE_PROVIDERSTORE)hCertStore;
+ PWINE_PROVIDERSTORE store = hCertStore;
BOOL ret = TRUE;
TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
static void WINAPI CRYPT_RegCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{
- PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
+ PWINE_REGSTOREINFO store = hCertStore;
TRACE("(%p, %08x)\n", store, dwFlags);
if (dwFlags)
static BOOL WINAPI CRYPT_RegWriteCert(HCERTSTORE hCertStore,
PCCERT_CONTEXT cert, DWORD dwFlags)
{
- PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
+ PWINE_REGSTOREINFO store = hCertStore;
TRACE("(%p, %p, %d)\n", hCertStore, cert, dwFlags);
static BOOL WINAPI CRYPT_RegDeleteCert(HCERTSTORE hCertStore,
PCCERT_CONTEXT pCertContext, DWORD dwFlags)
{
- PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
+ PWINE_REGSTOREINFO store = hCertStore;
TRACE("(%p, %p, %08x)\n", store, pCertContext, dwFlags);
static BOOL WINAPI CRYPT_RegWriteCRL(HCERTSTORE hCertStore,
PCCRL_CONTEXT crl, DWORD dwFlags)
{
- PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
+ PWINE_REGSTOREINFO store = hCertStore;
TRACE("(%p, %p, %d)\n", hCertStore, crl, dwFlags);
static BOOL WINAPI CRYPT_RegDeleteCRL(HCERTSTORE hCertStore,
PCCRL_CONTEXT pCrlContext, DWORD dwFlags)
{
- PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
+ PWINE_REGSTOREINFO store = hCertStore;
TRACE("(%p, %p, %08x)\n", store, pCrlContext, dwFlags);
static BOOL WINAPI CRYPT_RegWriteCTL(HCERTSTORE hCertStore,
PCCTL_CONTEXT ctl, DWORD dwFlags)
{
- PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
+ PWINE_REGSTOREINFO store = hCertStore;
TRACE("(%p, %p, %d)\n", hCertStore, ctl, dwFlags);
static BOOL WINAPI CRYPT_RegDeleteCTL(HCERTSTORE hCertStore,
PCCTL_CONTEXT pCtlContext, DWORD dwFlags)
{
- PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
+ PWINE_REGSTOREINFO store = hCertStore;
TRACE("(%p, %p, %08x)\n", store, pCtlContext, dwFlags);
static BOOL WINAPI CRYPT_RegControl(HCERTSTORE hCertStore, DWORD dwFlags,
DWORD dwCtrlType, void const *pvCtrlPara)
{
- PWINE_REGSTOREINFO store = (PWINE_REGSTOREINFO)hCertStore;
+ PWINE_REGSTOREINFO store = hCertStore;
BOOL ret;
TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
SetLastError(ERROR_ACCESS_DENIED);
return NULL;
}
- switch (dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK)
- {
- case CERT_SYSTEM_STORE_LOCAL_MACHINE:
- case CERT_SYSTEM_STORE_CURRENT_USER:
- break;
- default:
- TRACE("location %08x unsupported\n",
- dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK);
- SetLastError(E_INVALIDARG);
- return NULL;
- }
if (!CRYPT_rootStore)
{
HCERTSTORE root = create_root_store();
static BOOL CRYPT_SavePKCSToMem(HCERTSTORE store,
DWORD dwMsgAndCertEncodingType, void *handle)
{
- CERT_BLOB *blob = (CERT_BLOB *)handle;
+ CERT_BLOB *blob = handle;
CRYPT_SIGNED_INFO signedInfo = { 0 };
PCCERT_CONTEXT cert = NULL;
PCCRL_CONTEXT crl = NULL;
/* handle is a pointer to a MemWrittenTracker. Assumes its pointer is valid. */
static BOOL CRYPT_MemOutputFunc(void *handle, const void *buffer, DWORD size)
{
- struct MemWrittenTracker *tracker = (struct MemWrittenTracker *)handle;
+ struct MemWrittenTracker *tracker = handle;
BOOL ret;
if (tracker->written + size > tracker->cbData)
static BOOL CRYPT_SaveSerializedToMem(HCERTSTORE store,
DWORD dwMsgAndCertEncodingType, void *handle)
{
- CERT_BLOB *blob = (CERT_BLOB *)handle;
+ CERT_BLOB *blob = handle;
DWORD size = 0;
BOOL ret;
{
BOOL (*saveFunc)(HCERTSTORE, DWORD, void *);
void *handle;
- BOOL ret;
+ BOOL ret, closeFile = TRUE;
TRACE("(%p, %08x, %d, %d, %p, %08x)\n", hCertStore,
dwMsgAndCertEncodingType, dwSaveAs, dwSaveTo, pvSaveToPara, dwFlags);
switch (dwSaveAs)
{
case CERT_STORE_SAVE_AS_STORE:
+ if (dwSaveTo == CERT_STORE_SAVE_TO_MEMORY)
+ saveFunc = CRYPT_SaveSerializedToMem;
+ else
+ saveFunc = CRYPT_SaveSerializedToFile;
+ break;
case CERT_STORE_SAVE_AS_PKCS7:
+ if (dwSaveTo == CERT_STORE_SAVE_TO_MEMORY)
+ saveFunc = CRYPT_SavePKCSToMem;
+ else
+ saveFunc = CRYPT_SavePKCSToFile;
break;
default:
WARN("unimplemented for %d\n", dwSaveAs);
{
case CERT_STORE_SAVE_TO_FILE:
handle = pvSaveToPara;
- saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?
- CRYPT_SaveSerializedToFile : CRYPT_SavePKCSToFile;
+ closeFile = FALSE;
break;
case CERT_STORE_SAVE_TO_FILENAME_A:
- handle = CreateFileA((LPCSTR)pvSaveToPara, GENERIC_WRITE, 0, NULL,
+ handle = CreateFileA(pvSaveToPara, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, 0, NULL);
- saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?
- CRYPT_SaveSerializedToFile : CRYPT_SavePKCSToFile;
break;
case CERT_STORE_SAVE_TO_FILENAME_W:
- handle = CreateFileW((LPCWSTR)pvSaveToPara, GENERIC_WRITE, 0, NULL,
+ handle = CreateFileW(pvSaveToPara, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, 0, NULL);
- saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?
- CRYPT_SaveSerializedToFile : CRYPT_SavePKCSToFile;
break;
case CERT_STORE_SAVE_TO_MEMORY:
handle = pvSaveToPara;
- saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?
- CRYPT_SaveSerializedToMem : CRYPT_SavePKCSToMem;
break;
default:
WARN("unimplemented for %d\n", dwSaveTo);
return FALSE;
}
ret = saveFunc(hCertStore, dwMsgAndCertEncodingType, handle);
+ if (closeFile)
+ CloseHandle(handle);
TRACE("returning %d\n", ret);
return ret;
}
static void WINAPI CRYPT_MemCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{
- WINE_MEMSTORE *store = (WINE_MEMSTORE *)hCertStore;
+ WINE_MEMSTORE *store = hCertStore;
TRACE("(%p, %08x)\n", store, dwFlags);
if (dwFlags)
return (PWINECRYPT_CERTSTORE)store;
}
+static const WCHAR rootW[] = { 'R','o','o','t',0 };
+
static PWINECRYPT_CERTSTORE CRYPT_SysRegOpenStoreW(HCRYPTPROV hCryptProv,
DWORD dwFlags, const void *pvPara)
{
- static const WCHAR rootW[] = { 'R','o','o','t',0 };
static const WCHAR fmt[] = { '%','s','\\','%','s',0 };
- LPCWSTR storeName = (LPCWSTR)pvPara;
+ LPCWSTR storeName = pvPara;
LPWSTR storePath;
PWINECRYPT_CERTSTORE store = NULL;
HKEY root;
LPCWSTR base;
TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
- debugstr_w((LPCWSTR)pvPara));
+ debugstr_w(pvPara));
if (!pvPara)
{
SetLastError(E_INVALIDARG);
return NULL;
}
- if (!lstrcmpiW(storeName, rootW))
+ /* FIXME: In Windows, the root store (even the current user location) is
+ * protected: adding to it or removing from it present a user interface,
+ * and the keys are owned by the system process, not the current user.
+ * Wine's registry doesn't implement access controls, so a similar
+ * mechanism isn't possible yet.
+ */
+ if ((dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK) ==
+ CERT_SYSTEM_STORE_LOCAL_MACHINE && !lstrcmpiW(storeName, rootW))
return CRYPT_RootOpenStore(hCryptProv, dwFlags);
switch (dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK)
PWINECRYPT_CERTSTORE ret = NULL;
TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
- debugstr_a((LPCSTR)pvPara));
+ debugstr_a(pvPara));
if (!pvPara)
{
SetLastError(ERROR_FILE_NOT_FOUND);
return NULL;
}
- len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, NULL, 0);
+ len = MultiByteToWideChar(CP_ACP, 0, pvPara, -1, NULL, 0);
if (len)
{
LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
if (storeName)
{
- MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, storeName, len);
+ MultiByteToWideChar(CP_ACP, 0, pvPara, -1, storeName, len);
ret = CRYPT_SysRegOpenStoreW(hCryptProv, dwFlags, storeName);
CryptMemFree(storeName);
}
BOOL ret;
TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
- debugstr_w((LPCWSTR)pvPara));
+ debugstr_w(pvPara));
if (!pvPara)
{
CryptReleaseContext(hCryptProv, 0);
}
}
- return (PWINECRYPT_CERTSTORE)store;
+ return store;
}
static PWINECRYPT_CERTSTORE CRYPT_SysOpenStoreA(HCRYPTPROV hCryptProv,
PWINECRYPT_CERTSTORE ret = NULL;
TRACE("(%ld, %08x, %s)\n", hCryptProv, dwFlags,
- debugstr_a((LPCSTR)pvPara));
+ debugstr_a(pvPara));
if (!pvPara)
{
SetLastError(ERROR_FILE_NOT_FOUND);
return NULL;
}
- len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, NULL, 0);
+ len = MultiByteToWideChar(CP_ACP, 0, pvPara, -1, NULL, 0);
if (len)
{
LPWSTR storeName = CryptMemAlloc(len * sizeof(WCHAR));
if (storeName)
{
- MultiByteToWideChar(CP_ACP, 0, (LPCSTR)pvPara, -1, storeName, len);
+ MultiByteToWideChar(CP_ACP, 0, pvPara, -1, storeName, len);
ret = CRYPT_SysOpenStoreW(hCryptProv, dwFlags, storeName);
CryptMemFree(storeName);
}
{
HCRYPTMSG msg;
PWINECRYPT_CERTSTORE store = NULL;
- const CRYPT_DATA_BLOB *data = (const CRYPT_DATA_BLOB *)pvPara;
+ const CRYPT_DATA_BLOB *data = pvPara;
BOOL ret;
DWORD msgOpenFlags = dwFlags & CERT_STORE_NO_CRYPT_RELEASE_FLAG ? 0 :
CMSG_CRYPT_RELEASE_CONTEXT_FLAG;
FIXME("(%ld, %08x, %p): stub\n", hCryptProv, dwFlags, pvPara);
else
FIXME("(%ld, %08x, %s): stub\n", hCryptProv, dwFlags,
- debugstr_w((LPCWSTR)pvPara));
+ debugstr_w(pvPara));
return NULL;
}
hCryptProv, dwFlags, pvPara);
else
hcs = openFunc(hCryptProv, dwFlags, pvPara);
- return (HCERTSTORE)hcs;
+ return hcs;
}
HCERTSTORE WINAPI CertOpenSystemStoreA(HCRYPTPROV_LEGACY hProv,
PCCERT_CONTEXT pCertContext, DWORD dwAddDisposition,
PCCERT_CONTEXT *ppStoreContext)
{
- PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)hCertStore;
+ PWINECRYPT_CERTSTORE store = hCertStore;
BOOL ret = TRUE;
PCCERT_CONTEXT toAdd = NULL, existing = NULL;
PCCERT_CONTEXT WINAPI CertEnumCertificatesInStore(HCERTSTORE hCertStore,
PCCERT_CONTEXT pPrev)
{
- WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
+ WINECRYPT_CERTSTORE *hcs = hCertStore;
PCCERT_CONTEXT ret;
TRACE("(%p, %p)\n", hCertStore, pPrev);
}
else
{
- PWINECRYPT_CERTSTORE hcs =
- (PWINECRYPT_CERTSTORE)pCertContext->hCertStore;
+ PWINECRYPT_CERTSTORE hcs = pCertContext->hCertStore;
if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
ret = FALSE;
PCCRL_CONTEXT pCrlContext, DWORD dwAddDisposition,
PCCRL_CONTEXT* ppStoreContext)
{
- PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)hCertStore;
+ PWINECRYPT_CERTSTORE store = hCertStore;
BOOL ret = TRUE;
PCCRL_CONTEXT toAdd = NULL, existing = NULL;
}
else
{
- PWINECRYPT_CERTSTORE hcs =
- (PWINECRYPT_CERTSTORE)pCrlContext->hCertStore;
+ PWINECRYPT_CERTSTORE hcs = pCrlContext->hCertStore;
if (hcs->dwMagic != WINE_CRYPTCERTSTORE_MAGIC)
ret = FALSE;
PCCRL_CONTEXT WINAPI CertEnumCRLsInStore(HCERTSTORE hCertStore,
PCCRL_CONTEXT pPrev)
{
- WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
+ WINECRYPT_CERTSTORE *hcs = hCertStore;
PCCRL_CONTEXT ret;
TRACE("(%p, %p)\n", hCertStore, pPrev);
HCERTSTORE WINAPI CertDuplicateStore(HCERTSTORE hCertStore)
{
- WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
+ WINECRYPT_CERTSTORE *hcs = hCertStore;
TRACE("(%p)\n", hCertStore);
BOOL WINAPI CertCloseStore(HCERTSTORE hCertStore, DWORD dwFlags)
{
- WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *) hCertStore;
+ WINECRYPT_CERTSTORE *hcs = hCertStore;
TRACE("(%p, %08x)\n", hCertStore, dwFlags);
BOOL WINAPI CertControlStore(HCERTSTORE hCertStore, DWORD dwFlags,
DWORD dwCtrlType, void const *pvCtrlPara)
{
- WINECRYPT_CERTSTORE *hcs = (WINECRYPT_CERTSTORE *)hCertStore;
+ WINECRYPT_CERTSTORE *hcs = hCertStore;
BOOL ret;
TRACE("(%p, %08x, %d, %p)\n", hCertStore, dwFlags, dwCtrlType,
BOOL WINAPI CertGetStoreProperty(HCERTSTORE hCertStore, DWORD dwPropId,
void *pvData, DWORD *pcbData)
{
- PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)hCertStore;
+ PWINECRYPT_CERTSTORE store = hCertStore;
BOOL ret = FALSE;
TRACE("(%p, %d, %p, %p)\n", hCertStore, dwPropId, pvData, pcbData);
BOOL WINAPI CertSetStoreProperty(HCERTSTORE hCertStore, DWORD dwPropId,
DWORD dwFlags, const void *pvData)
{
- PWINECRYPT_CERTSTORE store = (PWINECRYPT_CERTSTORE)hCertStore;
+ PWINECRYPT_CERTSTORE store = hCertStore;
BOOL ret = FALSE;
TRACE("(%p, %d, %08x, %p)\n", hCertStore, dwPropId, dwFlags, pvData);
default:
if (pvData)
{
- const CRYPT_DATA_BLOB *blob = (const CRYPT_DATA_BLOB *)pvData;
+ const CRYPT_DATA_BLOB *blob = pvData;
ret = ContextPropertyList_SetProperty(store->properties, dwPropId,
blob->pbData, blob->cbData);
BOOL ret = FALSE;
LONG rc;
HKEY key;
+ CERT_SYSTEM_STORE_INFO info = { sizeof(info) };
TRACE("(%08x, %p, %p, %p)\n", dwFlags, pvSystemStoreLocationPara, pvArg,
pfnEnum);
if (!rc)
{
DWORD index = 0;
- CERT_SYSTEM_STORE_INFO info = { sizeof(info) };
ret = TRUE;
do {
}
else
SetLastError(rc);
+ /* Include root store for the local machine location (it isn't in the
+ * registry)
+ */
+ if (ret && (dwFlags & CERT_SYSTEM_STORE_LOCATION_MASK) ==
+ CERT_SYSTEM_STORE_LOCAL_MACHINE)
+ ret = pfnEnum(rootW, dwFlags, &info, NULL, pvArg);
return ret;
}
FIXME("(%p, %08x, %p, %p): stub\n", pvSystemStore, dwFlags, pvArg,
pfnEnum);
else
- FIXME("(%s, %08x, %p, %p): stub\n", debugstr_w((LPCWSTR)pvSystemStore),
+ FIXME("(%s, %08x, %p, %p): stub\n", debugstr_w(pvSystemStore),
dwFlags, pvArg,
pfnEnum);
return FALSE;
#define CRYPT_READ 0x0008
#define CRYPT_WRITE 0x0010
#define CRYPT_MAC 0x0020
+#define CRYPT_EXPORT_KEY 0x0040
+#define CRYPT_IMPORT_KEY 0x0080
+#define CRYPT_ARCHIVE 0x0100
/* Crypt*Key */
#define CRYPT_EXPORTABLE 0x00000001
#define CRYPT_ACQUIRE_COMPARE_KEY_FLAG 0x00000004
#define CRYPT_ACQUIRE_SILENT_FLAG 0x00000040
+/* flags for CryptFindCertificateKeyProvInfo */
+#define CRYPT_FIND_USER_KEYSET_FLAG 0x00000001
+#define CRYPT_FIND_MACHINE_KEYSET_FLAG 0x00000002
+#define CRYPT_FIND_SILENT_KEYSET_FLAG 0x00000040
+
/* Chain engines and chains */
typedef HANDLE HCERTCHAINENGINE;
#define HCCE_CURRENT_USER ((HCERTCHAINENGINE)NULL)
#define CMSG_ENCODED_SORTED_CTL_FLAG 0x1
#define CMSG_ENCODE_HASHED_SUBJECT_IDENTIFIER_FLAG 0x2
+/* PFXImportCertStore flags */
+#define CRYPT_USER_KEYSET 0x00001000
+#define PKCS12_IMPORT_RESERVED_MASK 0xffff0000
+/* PFXExportCertStore flags */
+#define REPORT_NO_PRIVATE_KEY 0x00000001
+#define REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY 0x00000002
+#define EXPORT_PRIVATE_KEYS 0x00000004
+#define PKCS12_EXPORT_RESERVED_MASK 0xffff0000
+
/* function declarations */
/* advapi32.dll */
WINADVAPI BOOL WINAPI CryptAcquireContextA(HCRYPTPROV *, LPCSTR, LPCSTR, DWORD, DWORD);
DWORD dwFlags, void *pvReserved, HCRYPTPROV_OR_NCRYPT_KEY_HANDLE *phCryptProv, DWORD *pdwKeySpec,
BOOL *pfCallerFreeProv);
+BOOL WINAPI CryptFindCertificateKeyProvInfo(PCCERT_CONTEXT pCert,
+ DWORD dwFlags, void *pvReserved);
+
BOOL WINAPI CryptProtectData( DATA_BLOB* pDataIn, LPCWSTR szDataDescr,
DATA_BLOB* pOptionalEntropy, PVOID pvReserved,
CRYPTPROTECT_PROMPTSTRUCT* pPromptStruct, DWORD dwFlags, DATA_BLOB* pDataOut );
const BYTE *rgpbToBeHashed[], DWORD rgcbToBeHashed[], BYTE *pbComputedHash,
DWORD *pcbComputedHash);
+/* PFX functions */
+HCERTSTORE WINAPI PFXImportCertStore(CRYPT_DATA_BLOB *pPFX, LPCWSTR szPassword,
+ DWORD dwFlags);
+BOOL WINAPI PFXIsPFXBlob(CRYPT_DATA_BLOB *pPFX);
+BOOL WINAPI PFXVerifyPassword(CRYPT_DATA_BLOB *pPFX, LPCWSTR szPassword,
+ DWORD dwFlags);
+BOOL WINAPI PFXExportCertStoreEx(HCERTSTORE hStore, CRYPT_DATA_BLOB *pPFX,
+ LPCWSTR szPassword, void *pvReserved, DWORD dwFlags);
+BOOL WINAPI PFXExportCertStore(HCERTSTORE hStore, CRYPT_DATA_BLOB *pPFX,
+ LPCWSTR szPassword, DWORD dwFlags);
+
/* cryptnet.dll functions */
BOOL WINAPI CryptCancelAsyncRetrieval(HCRYPTASYNC hAsyncRetrieval);
projects / reactos.git / commitdiff