| /* |
| * crypt32 Crypt*Object functions |
| * |
| * Copyright 2007 Juan Lang |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| #include <stdarg.h> |
| #define NONAMELESSUNION |
| #include "windef.h" |
| #include "winbase.h" |
| #include "wincrypt.h" |
| #include "mssip.h" |
| #include "winuser.h" |
| #include "wintrust.h" |
| #include "crypt32_private.h" |
| #include "cryptres.h" |
| #include "wine/unicode.h" |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(crypt); |
| |
| static BOOL CRYPT_ReadBlobFromFile(LPCWSTR fileName, PCERT_BLOB blob) |
| { |
| BOOL ret = FALSE; |
| HANDLE file; |
| |
| TRACE("%s\n", debugstr_w(fileName)); |
| |
| file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, |
| OPEN_EXISTING, 0, NULL); |
| if (file != INVALID_HANDLE_VALUE) |
| { |
| ret = TRUE; |
| blob->cbData = GetFileSize(file, NULL); |
| if (blob->cbData) |
| { |
| blob->pbData = CryptMemAlloc(blob->cbData); |
| if (blob->pbData) |
| { |
| DWORD read; |
| |
| ret = ReadFile(file, blob->pbData, blob->cbData, &read, NULL); |
| } |
| } |
| CloseHandle(file); |
| } |
| TRACE("returning %d\n", ret); |
| return ret; |
| } |
| |
| static BOOL CRYPT_QueryContextBlob(const CERT_BLOB *blob, |
| DWORD dwExpectedContentTypeFlags, HCERTSTORE store, |
| DWORD *contentType, const void **ppvContext) |
| { |
| BOOL ret = FALSE; |
| |
| if (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CERT) |
| { |
| ret = pCertInterface->addEncodedToStore(store, X509_ASN_ENCODING, |
| blob->pbData, blob->cbData, CERT_STORE_ADD_ALWAYS, ppvContext); |
| if (ret && contentType) |
| *contentType = CERT_QUERY_CONTENT_CERT; |
| } |
| if (!ret && (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CRL)) |
| { |
| ret = pCRLInterface->addEncodedToStore(store, X509_ASN_ENCODING, |
| blob->pbData, blob->cbData, CERT_STORE_ADD_ALWAYS, ppvContext); |
| if (ret && contentType) |
| *contentType = CERT_QUERY_CONTENT_CRL; |
| } |
| if (!ret && (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CTL)) |
| { |
| ret = pCTLInterface->addEncodedToStore(store, X509_ASN_ENCODING, |
| blob->pbData, blob->cbData, CERT_STORE_ADD_ALWAYS, ppvContext); |
| if (ret && contentType) |
| *contentType = CERT_QUERY_CONTENT_CTL; |
| } |
| return ret; |
| } |
| |
| static BOOL CRYPT_QueryContextObject(DWORD dwObjectType, const void *pvObject, |
| DWORD dwExpectedContentTypeFlags, DWORD dwExpectedFormatTypeFlags, |
| DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, DWORD *pdwFormatType, |
| HCERTSTORE *phCertStore, const void **ppvContext) |
| { |
| CERT_BLOB fileBlob; |
| const CERT_BLOB *blob; |
| HCERTSTORE store; |
| BOOL ret; |
| DWORD formatType = 0; |
| |
| switch (dwObjectType) |
| { |
| case CERT_QUERY_OBJECT_FILE: |
| /* Cert, CRL, and CTL contexts can't be "embedded" in a file, so |
| * just read the file directly |
| */ |
| ret = CRYPT_ReadBlobFromFile(pvObject, &fileBlob); |
| blob = &fileBlob; |
| break; |
| case CERT_QUERY_OBJECT_BLOB: |
| blob = pvObject; |
| ret = TRUE; |
| break; |
| default: |
| SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */ |
| ret = FALSE; |
| } |
| if (!ret) |
| return FALSE; |
| |
| ret = FALSE; |
| store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| if (dwExpectedFormatTypeFlags & CERT_QUERY_FORMAT_FLAG_BINARY) |
| { |
| ret = CRYPT_QueryContextBlob(blob, dwExpectedContentTypeFlags, store, |
| pdwContentType, ppvContext); |
| if (ret) |
| formatType = CERT_QUERY_FORMAT_BINARY; |
| } |
| if (!ret && |
| (dwExpectedFormatTypeFlags & CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED)) |
| { |
| CRYPT_DATA_BLOB trimmed = { blob->cbData, blob->pbData }; |
| CRYPT_DATA_BLOB decoded; |
| |
| while (trimmed.cbData && !trimmed.pbData[trimmed.cbData - 1]) |
| trimmed.cbData--; |
| ret = CryptStringToBinaryA((LPSTR)trimmed.pbData, trimmed.cbData, |
| CRYPT_STRING_BASE64_ANY, NULL, &decoded.cbData, NULL, NULL); |
| if (ret) |
| { |
| decoded.pbData = CryptMemAlloc(decoded.cbData); |
| if (decoded.pbData) |
| { |
| ret = CryptStringToBinaryA((LPSTR)trimmed.pbData, |
| trimmed.cbData, CRYPT_STRING_BASE64_ANY, decoded.pbData, |
| &decoded.cbData, NULL, NULL); |
| if (ret) |
| { |
| ret = CRYPT_QueryContextBlob(&decoded, |
| dwExpectedContentTypeFlags, store, pdwContentType, |
| ppvContext); |
| if (ret) |
| formatType = CERT_QUERY_FORMAT_BASE64_ENCODED; |
| } |
| CryptMemFree(decoded.pbData); |
| } |
| else |
| ret = FALSE; |
| } |
| } |
| if (ret) |
| { |
| if (pdwMsgAndCertEncodingType) |
| *pdwMsgAndCertEncodingType = X509_ASN_ENCODING; |
| if (pdwFormatType) |
| *pdwFormatType = formatType; |
| if (phCertStore) |
| *phCertStore = CertDuplicateStore(store); |
| } |
| CertCloseStore(store, 0); |
| if (blob == &fileBlob) |
| CryptMemFree(blob->pbData); |
| TRACE("returning %d\n", ret); |
| return ret; |
| } |
| |
| static BOOL CRYPT_QuerySerializedContextObject(DWORD dwObjectType, |
| const void *pvObject, DWORD dwExpectedContentTypeFlags, |
| DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, |
| HCERTSTORE *phCertStore, const void **ppvContext) |
| { |
| CERT_BLOB fileBlob; |
| const CERT_BLOB *blob; |
| const WINE_CONTEXT_INTERFACE *contextInterface = NULL; |
| const void *context; |
| DWORD contextType; |
| BOOL ret; |
| |
| switch (dwObjectType) |
| { |
| case CERT_QUERY_OBJECT_FILE: |
| /* Cert, CRL, and CTL contexts can't be "embedded" in a file, so |
| * just read the file directly |
| */ |
| ret = CRYPT_ReadBlobFromFile(pvObject, &fileBlob); |
| blob = &fileBlob; |
| break; |
| case CERT_QUERY_OBJECT_BLOB: |
| blob = pvObject; |
| ret = TRUE; |
| break; |
| default: |
| SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */ |
| ret = FALSE; |
| } |
| if (!ret) |
| return FALSE; |
| |
| ret = FALSE; |
| context = CRYPT_ReadSerializedElement(blob->pbData, blob->cbData, |
| CERT_STORE_ALL_CONTEXT_FLAG, &contextType); |
| if (context) |
| { |
| DWORD contentType, certStoreOffset; |
| |
| ret = TRUE; |
| switch (contextType) |
| { |
| case CERT_STORE_CERTIFICATE_CONTEXT: |
| contextInterface = pCertInterface; |
| contentType = CERT_QUERY_CONTENT_SERIALIZED_CERT; |
| certStoreOffset = offsetof(CERT_CONTEXT, hCertStore); |
| if (!(dwExpectedContentTypeFlags & |
| CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT)) |
| { |
| SetLastError(ERROR_INVALID_DATA); |
| ret = FALSE; |
| goto end; |
| } |
| break; |
| case CERT_STORE_CRL_CONTEXT: |
| contextInterface = pCRLInterface; |
| contentType = CERT_QUERY_CONTENT_SERIALIZED_CRL; |
| certStoreOffset = offsetof(CRL_CONTEXT, hCertStore); |
| if (!(dwExpectedContentTypeFlags & |
| CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL)) |
| { |
| SetLastError(ERROR_INVALID_DATA); |
| ret = FALSE; |
| goto end; |
| } |
| break; |
| case CERT_STORE_CTL_CONTEXT: |
| contextInterface = pCTLInterface; |
| contentType = CERT_QUERY_CONTENT_SERIALIZED_CTL; |
| certStoreOffset = offsetof(CTL_CONTEXT, hCertStore); |
| if (!(dwExpectedContentTypeFlags & |
| CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL)) |
| { |
| SetLastError(ERROR_INVALID_DATA); |
| ret = FALSE; |
| goto end; |
| } |
| break; |
| default: |
| SetLastError(ERROR_INVALID_DATA); |
| ret = FALSE; |
| goto end; |
| } |
| if (pdwMsgAndCertEncodingType) |
| *pdwMsgAndCertEncodingType = X509_ASN_ENCODING; |
| if (pdwContentType) |
| *pdwContentType = contentType; |
| if (phCertStore) |
| *phCertStore = CertDuplicateStore( |
| *(HCERTSTORE *)((const BYTE *)context + certStoreOffset)); |
| if (ppvContext) |
| *ppvContext = contextInterface->duplicate(context); |
| } |
| |
| end: |
| if (contextInterface && context) |
| contextInterface->free(context); |
| if (blob == &fileBlob) |
| CryptMemFree(blob->pbData); |
| TRACE("returning %d\n", ret); |
| return ret; |
| } |
| |
| static BOOL CRYPT_QuerySerializedStoreFromFile(LPCWSTR fileName, |
| DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, |
| HCERTSTORE *phCertStore, HCRYPTMSG *phMsg) |
| { |
| HANDLE file; |
| BOOL ret = FALSE; |
| |
| TRACE("%s\n", debugstr_w(fileName)); |
| file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, |
| OPEN_EXISTING, 0, NULL); |
| if (file != INVALID_HANDLE_VALUE) |
| { |
| HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| |
| ret = CRYPT_ReadSerializedStoreFromFile(file, store); |
| if (ret) |
| { |
| if (pdwMsgAndCertEncodingType) |
| *pdwMsgAndCertEncodingType = X509_ASN_ENCODING; |
| if (pdwContentType) |
| *pdwContentType = CERT_QUERY_CONTENT_SERIALIZED_STORE; |
| if (phCertStore) |
| *phCertStore = CertDuplicateStore(store); |
| } |
| CertCloseStore(store, 0); |
| CloseHandle(file); |
| } |
| TRACE("returning %d\n", ret); |
| return ret; |
| } |
| |
| static BOOL CRYPT_QuerySerializedStoreFromBlob(const CRYPT_DATA_BLOB *blob, |
| DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, |
| HCERTSTORE *phCertStore, HCRYPTMSG *phMsg) |
| { |
| HCERTSTORE store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0, |
| CERT_STORE_CREATE_NEW_FLAG, NULL); |
| BOOL ret; |
| |
| TRACE("(%d, %p)\n", blob->cbData, blob->pbData); |
| |
| ret = CRYPT_ReadSerializedStoreFromBlob(blob, store); |
| if (ret) |
| { |
| if (pdwMsgAndCertEncodingType) |
| *pdwMsgAndCertEncodingType = X509_ASN_ENCODING; |
| if (pdwContentType) |
| *pdwContentType = CERT_QUERY_CONTENT_SERIALIZED_STORE; |
| if (phCertStore) |
| *phCertStore = CertDuplicateStore(store); |
| } |
| CertCloseStore(store, 0); |
| TRACE("returning %d\n", ret); |
| return ret; |
| } |
| |
| static BOOL CRYPT_QuerySerializedStoreObject(DWORD dwObjectType, |
| const void *pvObject, DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, |
| HCERTSTORE *phCertStore, HCRYPTMSG *phMsg) |
| { |
| switch (dwObjectType) |
| { |
| case CERT_QUERY_OBJECT_FILE: |
| return CRYPT_QuerySerializedStoreFromFile(pvObject, |
| pdwMsgAndCertEncodingType, pdwContentType, phCertStore, phMsg); |
| case CERT_QUERY_OBJECT_BLOB: |
| return CRYPT_QuerySerializedStoreFromBlob(pvObject, |
| pdwMsgAndCertEncodingType, pdwContentType, phCertStore, phMsg); |
| default: |
| FIXME("unimplemented for type %d\n", dwObjectType); |
| SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */ |
| return FALSE; |
| } |
| } |
| |
| static BOOL CRYPT_QuerySignedMessage(const CRYPT_DATA_BLOB *blob, |
| DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, HCRYPTMSG *phMsg) |
| { |
| DWORD encodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING; |
| BOOL ret = FALSE; |
| HCRYPTMSG msg; |
| |
| if ((msg = CryptMsgOpenToDecode(encodingType, 0, 0, 0, NULL, NULL))) |
| { |
| ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE); |
| if (ret) |
| { |
| DWORD type, len = sizeof(type); |
| |
| ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &type, &len); |
| if (ret) |
| { |
| if (type != CMSG_SIGNED) |
| { |
| SetLastError(ERROR_INVALID_DATA); |
| ret = FALSE; |
| } |
| } |
| } |
| if (!ret) |
| { |
| CryptMsgClose(msg); |
| msg = CryptMsgOpenToDecode(encodingType, 0, CMSG_SIGNED, 0, NULL, |
| NULL); |
| if (msg) |
| { |
| ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE); |
| if (!ret) |
| { |
| CryptMsgClose(msg); |
| msg = NULL; |
| } |
| } |
| } |
| } |
| if (ret) |
| { |
| if (pdwMsgAndCertEncodingType) |
| *pdwMsgAndCertEncodingType = encodingType; |
| if (pdwContentType) |
| *pdwContentType = CERT_QUERY_CONTENT_PKCS7_SIGNED; |
| if (phMsg) |
| *phMsg = msg; |
| } |
| return ret; |
| } |
| |
| static BOOL CRYPT_QueryUnsignedMessage(const CRYPT_DATA_BLOB *blob, |
| DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, HCRYPTMSG *phMsg) |
| { |
| DWORD encodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING; |
| BOOL ret = FALSE; |
| HCRYPTMSG msg; |
| |
| if ((msg = CryptMsgOpenToDecode(encodingType, 0, 0, 0, NULL, NULL))) |
| { |
| ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE); |
| if (ret) |
| { |
| DWORD type, len = sizeof(type); |
| |
| ret = CryptMsgGetParam(msg, CMSG_TYPE_PARAM, 0, &type, &len); |
| if (ret) |
| { |
| if (type != CMSG_DATA) |
| { |
| SetLastError(ERROR_INVALID_DATA); |
| ret = FALSE; |
| } |
| } |
| } |
| if (!ret) |
| { |
| CryptMsgClose(msg); |
| msg = CryptMsgOpenToDecode(encodingType, 0, CMSG_DATA, 0, |
| NULL, NULL); |
| if (msg) |
| { |
| ret = CryptMsgUpdate(msg, blob->pbData, blob->cbData, TRUE); |
| if (!ret) |
| { |
| CryptMsgClose(msg); |
| msg = NULL; |
| } |
| } |
| } |
| } |
| if (ret) |
| { |
| if (pdwMsgAndCertEncodingType) |
| *pdwMsgAndCertEncodingType = encodingType; |
| if (pdwContentType) |
| *pdwContentType = CERT_QUERY_CONTENT_PKCS7_SIGNED; |
| if (phMsg) |
| *phMsg = msg; |
| } |
| return ret; |
| } |
| |
| /* Used to decode non-embedded messages */ |
| static BOOL CRYPT_QueryMessageObject(DWORD dwObjectType, const void *pvObject, |
| DWORD dwExpectedContentTypeFlags, DWORD dwExpectedFormatTypeFlags, |
| DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, DWORD *pdwFormatType, |
| HCERTSTORE *phCertStore, HCRYPTMSG *phMsg) |
| { |
| CERT_BLOB fileBlob; |
| const CERT_BLOB *blob; |
| BOOL ret; |
| HCRYPTMSG msg = NULL; |
| DWORD encodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING; |
| DWORD formatType = 0; |
| |
| TRACE("(%d, %p, %08x, %08x, %p, %p, %p, %p, %p)\n", dwObjectType, pvObject, |
| dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags, |
| pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType, phCertStore, |
| phMsg); |
| |
| switch (dwObjectType) |
| { |
| case CERT_QUERY_OBJECT_FILE: |
| /* This isn't an embedded PKCS7 message, so just read the file |
| * directly |
| */ |
| ret = CRYPT_ReadBlobFromFile(pvObject, &fileBlob); |
| blob = &fileBlob; |
| break; |
| case CERT_QUERY_OBJECT_BLOB: |
| blob = pvObject; |
| ret = TRUE; |
| break; |
| default: |
| SetLastError(E_INVALIDARG); /* FIXME: is this the correct error? */ |
| ret = FALSE; |
| } |
| if (!ret) |
| return FALSE; |
| |
| ret = FALSE; |
| if (dwExpectedFormatTypeFlags & CERT_QUERY_FORMAT_FLAG_BINARY) |
| { |
| /* Try it first as a signed message */ |
| if (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED) |
| ret = CRYPT_QuerySignedMessage(blob, pdwMsgAndCertEncodingType, |
| pdwContentType, &msg); |
| /* Failing that, try as an unsigned message */ |
| if (!ret && |
| (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED)) |
| ret = CRYPT_QueryUnsignedMessage(blob, pdwMsgAndCertEncodingType, |
| pdwContentType, &msg); |
| if (ret) |
| formatType = CERT_QUERY_FORMAT_BINARY; |
| } |
| if (!ret && |
| (dwExpectedFormatTypeFlags & CERT_QUERY_FORMAT_FLAG_BASE64_ENCODED)) |
| { |
| CRYPT_DATA_BLOB trimmed = { blob->cbData, blob->pbData }; |
| CRYPT_DATA_BLOB decoded; |
| |
| while (trimmed.cbData && !trimmed.pbData[trimmed.cbData - 1]) |
| trimmed.cbData--; |
| ret = CryptStringToBinaryA((LPSTR)trimmed.pbData, trimmed.cbData, |
| CRYPT_STRING_BASE64_ANY, NULL, &decoded.cbData, NULL, NULL); |
| if (ret) |
| { |
| decoded.pbData = CryptMemAlloc(decoded.cbData); |
| if (decoded.pbData) |
| { |
| ret = CryptStringToBinaryA((LPSTR)trimmed.pbData, |
| trimmed.cbData, CRYPT_STRING_BASE64_ANY, decoded.pbData, |
| &decoded.cbData, NULL, NULL); |
| if (ret) |
| { |
| /* Try it first as a signed message */ |
| if (dwExpectedContentTypeFlags & |
| CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED) |
| ret = CRYPT_QuerySignedMessage(&decoded, |
| pdwMsgAndCertEncodingType, pdwContentType, &msg); |
| /* Failing that, try as an unsigned message */ |
| if (!ret && (dwExpectedContentTypeFlags & |
| CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED)) |
| ret = CRYPT_QueryUnsignedMessage(&decoded, |
| pdwMsgAndCertEncodingType, pdwContentType, &msg); |
| if (ret) |
| formatType = CERT_QUERY_FORMAT_BASE64_ENCODED; |
| } |
| CryptMemFree(decoded.pbData); |
| } |
| else |
| ret = FALSE; |
| } |
| if (!ret && !(blob->cbData % sizeof(WCHAR))) |
| { |
| CRYPT_DATA_BLOB decoded; |
| LPWSTR str = (LPWSTR)blob->pbData; |
| DWORD strLen = blob->cbData / sizeof(WCHAR); |
| |
| /* Try again, assuming the input string is UTF-16 base64 */ |
| while (strLen && !str[strLen - 1]) |
| strLen--; |
| ret = CryptStringToBinaryW(str, strLen, CRYPT_STRING_BASE64_ANY, |
| NULL, &decoded.cbData, NULL, NULL); |
| if (ret) |
| { |
| decoded.pbData = CryptMemAlloc(decoded.cbData); |
| if (decoded.pbData) |
| { |
| ret = CryptStringToBinaryW(str, strLen, |
| CRYPT_STRING_BASE64_ANY, decoded.pbData, &decoded.cbData, |
| NULL, NULL); |
| if (ret) |
| { |
| /* Try it first as a signed message */ |
| if (dwExpectedContentTypeFlags & |
| CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED) |
| ret = CRYPT_QuerySignedMessage(&decoded, |
| pdwMsgAndCertEncodingType, pdwContentType, &msg); |
| /* Failing that, try as an unsigned message */ |
| if (!ret && (dwExpectedContentTypeFlags & |
| CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED)) |
| ret = CRYPT_QueryUnsignedMessage(&decoded, |
| pdwMsgAndCertEncodingType, pdwContentType, &msg); |
| if (ret) |
| formatType = CERT_QUERY_FORMAT_BASE64_ENCODED; |
| } |
| CryptMemFree(decoded.pbData); |
| } |
| else |
| ret = FALSE; |
| } |
| } |
| } |
| if (ret) |
| { |
| if (pdwFormatType) |
| *pdwFormatType = formatType; |
| if (phCertStore) |
| *phCertStore = CertOpenStore(CERT_STORE_PROV_MSG, encodingType, 0, |
| 0, msg); |
| if (phMsg) |
| *phMsg = msg; |
| else |
| CryptMsgClose(msg); |
| } |
| if (blob == &fileBlob) |
| CryptMemFree(blob->pbData); |
| TRACE("returning %d\n", ret); |
| return ret; |
| } |
| |
| static BOOL CRYPT_QueryEmbeddedMessageObject(DWORD dwObjectType, |
| const void *pvObject, DWORD dwExpectedContentTypeFlags, |
| DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, |
| HCERTSTORE *phCertStore, HCRYPTMSG *phMsg) |
| { |
| HANDLE file; |
| GUID subject; |
| BOOL ret = FALSE; |
| |
| TRACE("%s\n", debugstr_w(pvObject)); |
| |
| if (dwObjectType != CERT_QUERY_OBJECT_FILE) |
| { |
| WARN("don't know what to do for type %d embedded signed messages\n", |
| dwObjectType); |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| file = CreateFileW(pvObject, GENERIC_READ, FILE_SHARE_READ, |
| NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); |
| if (file != INVALID_HANDLE_VALUE) |
| { |
| ret = CryptSIPRetrieveSubjectGuid(pvObject, file, &subject); |
| if (ret) |
| { |
| SIP_DISPATCH_INFO sip; |
| |
| memset(&sip, 0, sizeof(sip)); |
| sip.cbSize = sizeof(sip); |
| ret = CryptSIPLoad(&subject, 0, &sip); |
| if (ret) |
| { |
| SIP_SUBJECTINFO subjectInfo; |
| CERT_BLOB blob; |
| DWORD encodingType; |
| |
| memset(&subjectInfo, 0, sizeof(subjectInfo)); |
| subjectInfo.cbSize = sizeof(subjectInfo); |
| subjectInfo.pgSubjectType = &subject; |
| subjectInfo.hFile = file; |
| subjectInfo.pwsFileName = pvObject; |
| ret = sip.pfGet(&subjectInfo, &encodingType, 0, &blob.cbData, |
| NULL); |
| if (ret) |
| { |
| blob.pbData = CryptMemAlloc(blob.cbData); |
| if (blob.pbData) |
| { |
| ret = sip.pfGet(&subjectInfo, &encodingType, 0, |
| &blob.cbData, blob.pbData); |
| if (ret) |
| { |
| ret = CRYPT_QueryMessageObject( |
| CERT_QUERY_OBJECT_BLOB, &blob, |
| CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED, |
| CERT_QUERY_FORMAT_FLAG_BINARY, |
| pdwMsgAndCertEncodingType, NULL, NULL, |
| phCertStore, phMsg); |
| if (ret && pdwContentType) |
| *pdwContentType = |
| CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED; |
| } |
| CryptMemFree(blob.pbData); |
| } |
| else |
| { |
| SetLastError(ERROR_OUTOFMEMORY); |
| ret = FALSE; |
| } |
| } |
| } |
| } |
| CloseHandle(file); |
| } |
| TRACE("returning %d\n", ret); |
| return ret; |
| } |
| |
| BOOL WINAPI CryptQueryObject(DWORD dwObjectType, const void *pvObject, |
| DWORD dwExpectedContentTypeFlags, DWORD dwExpectedFormatTypeFlags, |
| DWORD dwFlags, DWORD *pdwMsgAndCertEncodingType, DWORD *pdwContentType, |
| DWORD *pdwFormatType, HCERTSTORE *phCertStore, HCRYPTMSG *phMsg, |
| const void **ppvContext) |
| { |
| static const DWORD unimplementedTypes = |
| CERT_QUERY_CONTENT_FLAG_PKCS10 | CERT_QUERY_CONTENT_FLAG_PFX | |
| CERT_QUERY_CONTENT_FLAG_CERT_PAIR; |
| BOOL ret = TRUE; |
| |
| TRACE("(%08x, %p, %08x, %08x, %08x, %p, %p, %p, %p, %p, %p)\n", |
| dwObjectType, pvObject, dwExpectedContentTypeFlags, |
| dwExpectedFormatTypeFlags, dwFlags, pdwMsgAndCertEncodingType, |
| pdwContentType, pdwFormatType, phCertStore, phMsg, ppvContext); |
| |
| if (dwObjectType != CERT_QUERY_OBJECT_BLOB && |
| dwObjectType != CERT_QUERY_OBJECT_FILE) |
| { |
| WARN("unsupported type %d\n", dwObjectType); |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if (!pvObject) |
| { |
| WARN("missing required argument\n"); |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if (dwExpectedContentTypeFlags & unimplementedTypes) |
| WARN("unimplemented for types %08x\n", |
| dwExpectedContentTypeFlags & unimplementedTypes); |
| |
| if (pdwFormatType) |
| *pdwFormatType = CERT_QUERY_FORMAT_BINARY; |
| if (phCertStore) |
| *phCertStore = NULL; |
| if (phMsg) |
| *phMsg = NULL; |
| if (ppvContext) |
| *ppvContext = NULL; |
| |
| ret = FALSE; |
| if ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CERT) || |
| (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CRL) || |
| (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_CTL)) |
| { |
| ret = CRYPT_QueryContextObject(dwObjectType, pvObject, |
| dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags, |
| pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType, phCertStore, |
| ppvContext); |
| } |
| if (!ret && |
| (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_STORE)) |
| { |
| ret = CRYPT_QuerySerializedStoreObject(dwObjectType, pvObject, |
| pdwMsgAndCertEncodingType, pdwContentType, phCertStore, phMsg); |
| } |
| if (!ret && |
| ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_CERT) || |
| (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_CRL) || |
| (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_SERIALIZED_CTL))) |
| { |
| ret = CRYPT_QuerySerializedContextObject(dwObjectType, pvObject, |
| dwExpectedContentTypeFlags, pdwMsgAndCertEncodingType, pdwContentType, |
| phCertStore, ppvContext); |
| } |
| if (!ret && |
| ((dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED) || |
| (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_UNSIGNED))) |
| { |
| ret = CRYPT_QueryMessageObject(dwObjectType, pvObject, |
| dwExpectedContentTypeFlags, dwExpectedFormatTypeFlags, |
| pdwMsgAndCertEncodingType, pdwContentType, pdwFormatType, |
| phCertStore, phMsg); |
| } |
| if (!ret && |
| (dwExpectedContentTypeFlags & CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED)) |
| { |
| ret = CRYPT_QueryEmbeddedMessageObject(dwObjectType, pvObject, |
| dwExpectedContentTypeFlags, pdwMsgAndCertEncodingType, pdwContentType, |
| phCertStore, phMsg); |
| } |
| if (!ret) |
| SetLastError(CRYPT_E_NO_MATCH); |
| TRACE("returning %d\n", ret); |
| return ret; |
| } |
| |
| static BOOL WINAPI CRYPT_FormatHexString(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| BOOL ret; |
| DWORD bytesNeeded; |
| |
| if (cbEncoded) |
| bytesNeeded = (cbEncoded * 3) * sizeof(WCHAR); |
| else |
| bytesNeeded = sizeof(WCHAR); |
| if (!pbFormat) |
| { |
| *pcbFormat = bytesNeeded; |
| ret = TRUE; |
| } |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| static const WCHAR fmt[] = { '%','0','2','x',' ',0 }; |
| static const WCHAR endFmt[] = { '%','0','2','x',0 }; |
| DWORD i; |
| LPWSTR ptr = pbFormat; |
| |
| *pcbFormat = bytesNeeded; |
| if (cbEncoded) |
| { |
| for (i = 0; i < cbEncoded; i++) |
| { |
| if (i < cbEncoded - 1) |
| ptr += sprintfW(ptr, fmt, pbEncoded[i]); |
| else |
| ptr += sprintfW(ptr, endFmt, pbEncoded[i]); |
| } |
| } |
| else |
| *ptr = 0; |
| ret = TRUE; |
| } |
| return ret; |
| } |
| |
| #define MAX_STRING_RESOURCE_LEN 128 |
| |
| static const WCHAR commaSpace[] = { ',',' ',0 }; |
| |
| struct BitToString |
| { |
| BYTE bit; |
| int id; |
| WCHAR str[MAX_STRING_RESOURCE_LEN]; |
| }; |
| |
| static BOOL CRYPT_FormatBits(BYTE bits, const struct BitToString *map, |
| DWORD mapEntries, void *pbFormat, DWORD *pcbFormat, BOOL *first) |
| { |
| DWORD bytesNeeded = sizeof(WCHAR); |
| int i; |
| BOOL ret = TRUE, localFirst = *first; |
| |
| for (i = 0; i < mapEntries; i++) |
| if (bits & map[i].bit) |
| { |
| if (!localFirst) |
| bytesNeeded += strlenW(commaSpace) * sizeof(WCHAR); |
| localFirst = FALSE; |
| bytesNeeded += strlenW(map[i].str) * sizeof(WCHAR); |
| } |
| if (!pbFormat) |
| { |
| *first = localFirst; |
| *pcbFormat = bytesNeeded; |
| } |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *first = localFirst; |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| localFirst = *first; |
| *pcbFormat = bytesNeeded; |
| for (i = 0; i < mapEntries; i++) |
| if (bits & map[i].bit) |
| { |
| if (!localFirst) |
| { |
| strcpyW(str, commaSpace); |
| str += strlenW(commaSpace); |
| } |
| localFirst = FALSE; |
| strcpyW(str, map[i].str); |
| str += strlenW(map[i].str); |
| } |
| *first = localFirst; |
| } |
| return ret; |
| } |
| |
| static struct BitToString keyUsageByte0Map[] = { |
| { CERT_DIGITAL_SIGNATURE_KEY_USAGE, IDS_DIGITAL_SIGNATURE, { 0 } }, |
| { CERT_NON_REPUDIATION_KEY_USAGE, IDS_NON_REPUDIATION, { 0 } }, |
| { CERT_KEY_ENCIPHERMENT_KEY_USAGE, IDS_KEY_ENCIPHERMENT, { 0 } }, |
| { CERT_DATA_ENCIPHERMENT_KEY_USAGE, IDS_DATA_ENCIPHERMENT, { 0 } }, |
| { CERT_KEY_AGREEMENT_KEY_USAGE, IDS_KEY_AGREEMENT, { 0 } }, |
| { CERT_KEY_CERT_SIGN_KEY_USAGE, IDS_CERT_SIGN, { 0 } }, |
| { CERT_OFFLINE_CRL_SIGN_KEY_USAGE, IDS_OFFLINE_CRL_SIGN, { 0 } }, |
| { CERT_CRL_SIGN_KEY_USAGE, IDS_CRL_SIGN, { 0 } }, |
| { CERT_ENCIPHER_ONLY_KEY_USAGE, IDS_ENCIPHER_ONLY, { 0 } }, |
| }; |
| static struct BitToString keyUsageByte1Map[] = { |
| { CERT_DECIPHER_ONLY_KEY_USAGE, IDS_DECIPHER_ONLY, { 0 } }, |
| }; |
| |
| static BOOL WINAPI CRYPT_FormatKeyUsage(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| DWORD size; |
| CRYPT_BIT_BLOB *bits; |
| BOOL ret; |
| |
| if (!cbEncoded) |
| { |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_KEY_USAGE, |
| pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &bits, &size))) |
| { |
| WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN]; |
| DWORD bytesNeeded = sizeof(WCHAR); |
| |
| LoadStringW(hInstance, IDS_INFO_NOT_AVAILABLE, infoNotAvailable, |
| sizeof(infoNotAvailable) / sizeof(infoNotAvailable[0])); |
| if (!bits->cbData || bits->cbData > 2) |
| { |
| bytesNeeded += strlenW(infoNotAvailable) * sizeof(WCHAR); |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| *pcbFormat = bytesNeeded; |
| strcpyW(str, infoNotAvailable); |
| } |
| } |
| else |
| { |
| static BOOL stringsLoaded = FALSE; |
| int i; |
| DWORD bitStringLen; |
| BOOL first = TRUE; |
| |
| if (!stringsLoaded) |
| { |
| for (i = 0; |
| i < sizeof(keyUsageByte0Map) / sizeof(keyUsageByte0Map[0]); |
| i++) |
| LoadStringW(hInstance, keyUsageByte0Map[i].id, |
| keyUsageByte0Map[i].str, MAX_STRING_RESOURCE_LEN); |
| for (i = 0; |
| i < sizeof(keyUsageByte1Map) / sizeof(keyUsageByte1Map[0]); |
| i++) |
| LoadStringW(hInstance, keyUsageByte1Map[i].id, |
| keyUsageByte1Map[i].str, MAX_STRING_RESOURCE_LEN); |
| stringsLoaded = TRUE; |
| } |
| CRYPT_FormatBits(bits->pbData[0], keyUsageByte0Map, |
| sizeof(keyUsageByte0Map) / sizeof(keyUsageByte0Map[0]), |
| NULL, &bitStringLen, &first); |
| bytesNeeded += bitStringLen; |
| if (bits->cbData == 2) |
| { |
| CRYPT_FormatBits(bits->pbData[1], keyUsageByte1Map, |
| sizeof(keyUsageByte1Map) / sizeof(keyUsageByte1Map[0]), |
| NULL, &bitStringLen, &first); |
| bytesNeeded += bitStringLen; |
| } |
| bytesNeeded += 3 * sizeof(WCHAR); /* " (" + ")" */ |
| CRYPT_FormatHexString(0, 0, 0, NULL, NULL, bits->pbData, |
| bits->cbData, NULL, &size); |
| bytesNeeded += size; |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| bitStringLen = bytesNeeded; |
| first = TRUE; |
| CRYPT_FormatBits(bits->pbData[0], keyUsageByte0Map, |
| sizeof(keyUsageByte0Map) / sizeof(keyUsageByte0Map[0]), |
| str, &bitStringLen, &first); |
| str += bitStringLen / sizeof(WCHAR) - 1; |
| if (bits->cbData == 2) |
| { |
| bitStringLen = bytesNeeded; |
| CRYPT_FormatBits(bits->pbData[1], keyUsageByte1Map, |
| sizeof(keyUsageByte1Map) / sizeof(keyUsageByte1Map[0]), |
| str, &bitStringLen, &first); |
| str += bitStringLen / sizeof(WCHAR) - 1; |
| } |
| *str++ = ' '; |
| *str++ = '('; |
| CRYPT_FormatHexString(0, 0, 0, NULL, NULL, bits->pbData, |
| bits->cbData, str, &size); |
| str += size / sizeof(WCHAR) - 1; |
| *str++ = ')'; |
| *str = 0; |
| } |
| } |
| LocalFree(bits); |
| } |
| return ret; |
| } |
| |
| static const WCHAR crlf[] = { '\r','\n',0 }; |
| |
| static WCHAR subjectTypeHeader[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR subjectTypeCA[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR subjectTypeEndCert[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR pathLengthHeader[MAX_STRING_RESOURCE_LEN]; |
| |
| static BOOL WINAPI CRYPT_FormatBasicConstraints2(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| DWORD size; |
| CERT_BASIC_CONSTRAINTS2_INFO *info; |
| BOOL ret; |
| |
| if (!cbEncoded) |
| { |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_BASIC_CONSTRAINTS2, |
| pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size))) |
| { |
| static const WCHAR pathFmt[] = { '%','d',0 }; |
| static BOOL stringsLoaded = FALSE; |
| DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */ |
| WCHAR pathLength[MAX_STRING_RESOURCE_LEN]; |
| LPCWSTR sep, subjectType; |
| DWORD sepLen; |
| |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| sep = crlf; |
| sepLen = strlenW(crlf) * sizeof(WCHAR); |
| } |
| else |
| { |
| sep = commaSpace; |
| sepLen = strlenW(commaSpace) * sizeof(WCHAR); |
| } |
| |
| if (!stringsLoaded) |
| { |
| LoadStringW(hInstance, IDS_SUBJECT_TYPE, subjectTypeHeader, |
| sizeof(subjectTypeHeader) / sizeof(subjectTypeHeader[0])); |
| LoadStringW(hInstance, IDS_SUBJECT_TYPE_CA, subjectTypeCA, |
| sizeof(subjectTypeCA) / sizeof(subjectTypeCA[0])); |
| LoadStringW(hInstance, IDS_SUBJECT_TYPE_END_CERT, |
| subjectTypeEndCert, |
| sizeof(subjectTypeEndCert) / sizeof(subjectTypeEndCert[0])); |
| LoadStringW(hInstance, IDS_PATH_LENGTH, pathLengthHeader, |
| sizeof(pathLengthHeader) / sizeof(pathLengthHeader[0])); |
| stringsLoaded = TRUE; |
| } |
| bytesNeeded += strlenW(subjectTypeHeader) * sizeof(WCHAR); |
| if (info->fCA) |
| subjectType = subjectTypeCA; |
| else |
| subjectType = subjectTypeEndCert; |
| bytesNeeded += strlenW(subjectType) * sizeof(WCHAR); |
| bytesNeeded += sepLen; |
| bytesNeeded += strlenW(pathLengthHeader) * sizeof(WCHAR); |
| if (info->fPathLenConstraint) |
| sprintfW(pathLength, pathFmt, info->dwPathLenConstraint); |
| else |
| LoadStringW(hInstance, IDS_PATH_LENGTH_NONE, pathLength, |
| sizeof(pathLength) / sizeof(pathLength[0])); |
| bytesNeeded += strlenW(pathLength) * sizeof(WCHAR); |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| *pcbFormat = bytesNeeded; |
| strcpyW(str, subjectTypeHeader); |
| str += strlenW(subjectTypeHeader); |
| strcpyW(str, subjectType); |
| str += strlenW(subjectType); |
| strcpyW(str, sep); |
| str += sepLen / sizeof(WCHAR); |
| strcpyW(str, pathLengthHeader); |
| str += strlenW(pathLengthHeader); |
| strcpyW(str, pathLength); |
| str += strlenW(pathLength); |
| } |
| LocalFree(info); |
| } |
| return ret; |
| } |
| |
| static BOOL CRYPT_FormatHexStringWithPrefix(const CRYPT_DATA_BLOB *blob, int id, |
| LPWSTR str, DWORD *pcbStr) |
| { |
| WCHAR buf[MAX_STRING_RESOURCE_LEN]; |
| DWORD bytesNeeded; |
| BOOL ret; |
| |
| LoadStringW(hInstance, id, buf, sizeof(buf) / sizeof(buf[0])); |
| CRYPT_FormatHexString(X509_ASN_ENCODING, 0, 0, NULL, NULL, |
| blob->pbData, blob->cbData, NULL, &bytesNeeded); |
| bytesNeeded += strlenW(buf) * sizeof(WCHAR); |
| if (!str) |
| { |
| *pcbStr = bytesNeeded; |
| ret = TRUE; |
| } |
| else if (*pcbStr < bytesNeeded) |
| { |
| *pcbStr = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| *pcbStr = bytesNeeded; |
| strcpyW(str, buf); |
| str += strlenW(str); |
| bytesNeeded -= strlenW(str) * sizeof(WCHAR); |
| ret = CRYPT_FormatHexString(X509_ASN_ENCODING, 0, 0, NULL, NULL, |
| blob->pbData, blob->cbData, str, &bytesNeeded); |
| } |
| return ret; |
| } |
| |
| static BOOL CRYPT_FormatKeyId(const CRYPT_DATA_BLOB *keyId, LPWSTR str, |
| DWORD *pcbStr) |
| { |
| return CRYPT_FormatHexStringWithPrefix(keyId, IDS_KEY_ID, str, pcbStr); |
| } |
| |
| static BOOL CRYPT_FormatCertSerialNumber(const CRYPT_DATA_BLOB *serialNum, LPWSTR str, |
| DWORD *pcbStr) |
| { |
| return CRYPT_FormatHexStringWithPrefix(serialNum, IDS_CERT_SERIAL_NUMBER, |
| str, pcbStr); |
| } |
| |
| static const WCHAR indent[] = { ' ',' ',' ',' ',' ',0 }; |
| static const WCHAR colonCrlf[] = { ':','\r','\n',0 }; |
| |
| static BOOL CRYPT_FormatAltNameEntry(DWORD dwFormatStrType, DWORD indentLevel, |
| CERT_ALT_NAME_ENTRY *entry, LPWSTR str, DWORD *pcbStr) |
| { |
| BOOL ret; |
| WCHAR buf[MAX_STRING_RESOURCE_LEN]; |
| WCHAR mask[MAX_STRING_RESOURCE_LEN]; |
| WCHAR ipAddrBuf[32]; |
| WCHAR maskBuf[16]; |
| DWORD bytesNeeded = sizeof(WCHAR); |
| DWORD strType = CERT_X500_NAME_STR | CERT_NAME_STR_REVERSE_FLAG; |
| |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| bytesNeeded += indentLevel * strlenW(indent) * sizeof(WCHAR); |
| switch (entry->dwAltNameChoice) |
| { |
| case CERT_ALT_NAME_RFC822_NAME: |
| LoadStringW(hInstance, IDS_ALT_NAME_RFC822_NAME, buf, |
| sizeof(buf) / sizeof(buf[0])); |
| bytesNeeded += strlenW(entry->u.pwszRfc822Name) * sizeof(WCHAR); |
| ret = TRUE; |
| break; |
| case CERT_ALT_NAME_DNS_NAME: |
| LoadStringW(hInstance, IDS_ALT_NAME_DNS_NAME, buf, |
| sizeof(buf) / sizeof(buf[0])); |
| bytesNeeded += strlenW(entry->u.pwszDNSName) * sizeof(WCHAR); |
| ret = TRUE; |
| break; |
| case CERT_ALT_NAME_DIRECTORY_NAME: |
| { |
| DWORD directoryNameLen; |
| |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| strType |= CERT_NAME_STR_CRLF_FLAG; |
| directoryNameLen = cert_name_to_str_with_indent(X509_ASN_ENCODING, |
| indentLevel + 1, &entry->u.DirectoryName, strType, NULL, 0); |
| LoadStringW(hInstance, IDS_ALT_NAME_DIRECTORY_NAME, buf, |
| sizeof(buf) / sizeof(buf[0])); |
| bytesNeeded += (directoryNameLen - 1) * sizeof(WCHAR); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| bytesNeeded += strlenW(colonCrlf) * sizeof(WCHAR); |
| else |
| bytesNeeded += sizeof(WCHAR); /* '=' */ |
| ret = TRUE; |
| break; |
| } |
| case CERT_ALT_NAME_URL: |
| LoadStringW(hInstance, IDS_ALT_NAME_URL, buf, |
| sizeof(buf) / sizeof(buf[0])); |
| bytesNeeded += strlenW(entry->u.pwszURL) * sizeof(WCHAR); |
| ret = TRUE; |
| break; |
| case CERT_ALT_NAME_IP_ADDRESS: |
| { |
| static const WCHAR ipAddrWithMaskFmt[] = { '%','d','.','%','d','.', |
| '%','d','.','%','d','/','%','d','.','%','d','.','%','d','.','%','d',0 |
| }; |
| static const WCHAR ipAddrFmt[] = { '%','d','.','%','d','.','%','d', |
| '.','%','d',0 }; |
| |
| LoadStringW(hInstance, IDS_ALT_NAME_IP_ADDRESS, buf, |
| sizeof(buf) / sizeof(buf[0])); |
| if (entry->u.IPAddress.cbData == 8) |
| { |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| LoadStringW(hInstance, IDS_ALT_NAME_MASK, mask, |
| sizeof(mask) / sizeof(mask[0])); |
| bytesNeeded += strlenW(mask) * sizeof(WCHAR); |
| sprintfW(ipAddrBuf, ipAddrFmt, |
| entry->u.IPAddress.pbData[0], |
| entry->u.IPAddress.pbData[1], |
| entry->u.IPAddress.pbData[2], |
| entry->u.IPAddress.pbData[3]); |
| bytesNeeded += strlenW(ipAddrBuf) * sizeof(WCHAR); |
| /* indent again, for the mask line */ |
| bytesNeeded += indentLevel * strlenW(indent) * sizeof(WCHAR); |
| sprintfW(maskBuf, ipAddrFmt, |
| entry->u.IPAddress.pbData[4], |
| entry->u.IPAddress.pbData[5], |
| entry->u.IPAddress.pbData[6], |
| entry->u.IPAddress.pbData[7]); |
| bytesNeeded += strlenW(maskBuf) * sizeof(WCHAR); |
| bytesNeeded += strlenW(crlf) * sizeof(WCHAR); |
| } |
| else |
| { |
| sprintfW(ipAddrBuf, ipAddrWithMaskFmt, |
| entry->u.IPAddress.pbData[0], |
| entry->u.IPAddress.pbData[1], |
| entry->u.IPAddress.pbData[2], |
| entry->u.IPAddress.pbData[3], |
| entry->u.IPAddress.pbData[4], |
| entry->u.IPAddress.pbData[5], |
| entry->u.IPAddress.pbData[6], |
| entry->u.IPAddress.pbData[7]); |
| bytesNeeded += (strlenW(ipAddrBuf) + 1) * sizeof(WCHAR); |
| } |
| ret = TRUE; |
| } |
| else |
| { |
| FIXME("unknown IP address format (%d bytes)\n", |
| entry->u.IPAddress.cbData); |
| ret = FALSE; |
| } |
| break; |
| } |
| default: |
| FIXME("unimplemented for %d\n", entry->dwAltNameChoice); |
| ret = FALSE; |
| } |
| if (ret) |
| { |
| bytesNeeded += strlenW(buf) * sizeof(WCHAR); |
| if (!str) |
| *pcbStr = bytesNeeded; |
| else if (*pcbStr < bytesNeeded) |
| { |
| *pcbStr = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| DWORD i; |
| |
| *pcbStr = bytesNeeded; |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| for (i = 0; i < indentLevel; i++) |
| { |
| strcpyW(str, indent); |
| str += strlenW(indent); |
| } |
| } |
| strcpyW(str, buf); |
| str += strlenW(str); |
| switch (entry->dwAltNameChoice) |
| { |
| case CERT_ALT_NAME_RFC822_NAME: |
| case CERT_ALT_NAME_DNS_NAME: |
| case CERT_ALT_NAME_URL: |
| strcpyW(str, entry->u.pwszURL); |
| break; |
| case CERT_ALT_NAME_DIRECTORY_NAME: |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| strcpyW(str, colonCrlf); |
| str += strlenW(colonCrlf); |
| } |
| else |
| *str++ = '='; |
| cert_name_to_str_with_indent(X509_ASN_ENCODING, |
| indentLevel + 1, &entry->u.DirectoryName, strType, str, |
| bytesNeeded / sizeof(WCHAR)); |
| break; |
| case CERT_ALT_NAME_IP_ADDRESS: |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| strcpyW(str, ipAddrBuf); |
| str += strlenW(ipAddrBuf); |
| strcpyW(str, crlf); |
| str += strlenW(crlf); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| for (i = 0; i < indentLevel; i++) |
| { |
| strcpyW(str, indent); |
| str += strlenW(indent); |
| } |
| } |
| strcpyW(str, mask); |
| str += strlenW(mask); |
| strcpyW(str, maskBuf); |
| } |
| else |
| strcpyW(str, ipAddrBuf); |
| break; |
| } |
| } |
| } |
| return ret; |
| } |
| |
| static BOOL CRYPT_FormatAltNameInfo(DWORD dwFormatStrType, DWORD indentLevel, |
| CERT_ALT_NAME_INFO *name, LPWSTR str, DWORD *pcbStr) |
| { |
| DWORD i, size, bytesNeeded = 0; |
| BOOL ret = TRUE; |
| LPCWSTR sep; |
| DWORD sepLen; |
| |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| sep = crlf; |
| sepLen = strlenW(crlf) * sizeof(WCHAR); |
| } |
| else |
| { |
| sep = commaSpace; |
| sepLen = strlenW(commaSpace) * sizeof(WCHAR); |
| } |
| |
| for (i = 0; ret && i < name->cAltEntry; i++) |
| { |
| ret = CRYPT_FormatAltNameEntry(dwFormatStrType, indentLevel, |
| &name->rgAltEntry[i], NULL, &size); |
| if (ret) |
| { |
| bytesNeeded += size - sizeof(WCHAR); |
| if (i < name->cAltEntry - 1) |
| bytesNeeded += sepLen; |
| } |
| } |
| if (ret) |
| { |
| bytesNeeded += sizeof(WCHAR); |
| if (!str) |
| *pcbStr = bytesNeeded; |
| else if (*pcbStr < bytesNeeded) |
| { |
| *pcbStr = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| *pcbStr = bytesNeeded; |
| for (i = 0; ret && i < name->cAltEntry; i++) |
| { |
| ret = CRYPT_FormatAltNameEntry(dwFormatStrType, indentLevel, |
| &name->rgAltEntry[i], str, &size); |
| if (ret) |
| { |
| str += size / sizeof(WCHAR) - 1; |
| if (i < name->cAltEntry - 1) |
| { |
| strcpyW(str, sep); |
| str += sepLen / sizeof(WCHAR); |
| } |
| } |
| } |
| } |
| } |
| return ret; |
| } |
| |
| static const WCHAR colonSep[] = { ':',' ',0 }; |
| |
| static BOOL WINAPI CRYPT_FormatAltName(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| BOOL ret; |
| CERT_ALT_NAME_INFO *info; |
| DWORD size; |
| |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_ALTERNATE_NAME, |
| pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size))) |
| { |
| ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 0, info, pbFormat, pcbFormat); |
| LocalFree(info); |
| } |
| return ret; |
| } |
| |
| static BOOL CRYPT_FormatCertIssuer(DWORD dwFormatStrType, |
| CERT_ALT_NAME_INFO *issuer, LPWSTR str, DWORD *pcbStr) |
| { |
| WCHAR buf[MAX_STRING_RESOURCE_LEN]; |
| DWORD bytesNeeded, sepLen; |
| LPCWSTR sep; |
| BOOL ret; |
| |
| LoadStringW(hInstance, IDS_CERT_ISSUER, buf, sizeof(buf) / sizeof(buf[0])); |
| ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 1, issuer, NULL, |
| &bytesNeeded); |
| bytesNeeded += strlenW(buf) * sizeof(WCHAR); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| sep = colonCrlf; |
| sepLen = strlenW(colonCrlf) * sizeof(WCHAR); |
| } |
| else |
| { |
| sep = colonSep; |
| sepLen = strlenW(colonSep) * sizeof(WCHAR); |
| } |
| bytesNeeded += sepLen; |
| if (ret) |
| { |
| if (!str) |
| *pcbStr = bytesNeeded; |
| else if (*pcbStr < bytesNeeded) |
| { |
| *pcbStr = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| *pcbStr = bytesNeeded; |
| strcpyW(str, buf); |
| bytesNeeded -= strlenW(str) * sizeof(WCHAR); |
| str += strlenW(str); |
| strcpyW(str, sep); |
| str += sepLen / sizeof(WCHAR); |
| ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 1, issuer, str, |
| &bytesNeeded); |
| } |
| } |
| return ret; |
| } |
| |
| static BOOL WINAPI CRYPT_FormatAuthorityKeyId2(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| CERT_AUTHORITY_KEY_ID2_INFO *info; |
| DWORD size; |
| BOOL ret = FALSE; |
| |
| if (!cbEncoded) |
| { |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_AUTHORITY_KEY_ID2, |
| pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size))) |
| { |
| DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */ |
| LPCWSTR sep; |
| DWORD sepLen; |
| BOOL needSeparator = FALSE; |
| |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| sep = crlf; |
| sepLen = strlenW(crlf) * sizeof(WCHAR); |
| } |
| else |
| { |
| sep = commaSpace; |
| sepLen = strlenW(commaSpace) * sizeof(WCHAR); |
| } |
| |
| if (info->KeyId.cbData) |
| { |
| needSeparator = TRUE; |
| ret = CRYPT_FormatKeyId(&info->KeyId, NULL, &size); |
| if (ret) |
| { |
| /* don't include NULL-terminator more than once */ |
| bytesNeeded += size - sizeof(WCHAR); |
| } |
| } |
| if (info->AuthorityCertIssuer.cAltEntry) |
| { |
| if (needSeparator) |
| bytesNeeded += sepLen; |
| needSeparator = TRUE; |
| ret = CRYPT_FormatCertIssuer(dwFormatStrType, |
| &info->AuthorityCertIssuer, NULL, &size); |
| if (ret) |
| { |
| /* don't include NULL-terminator more than once */ |
| bytesNeeded += size - sizeof(WCHAR); |
| } |
| } |
| if (info->AuthorityCertSerialNumber.cbData) |
| { |
| if (needSeparator) |
| bytesNeeded += sepLen; |
| ret = CRYPT_FormatCertSerialNumber( |
| &info->AuthorityCertSerialNumber, NULL, &size); |
| if (ret) |
| { |
| /* don't include NULL-terminator more than once */ |
| bytesNeeded += size - sizeof(WCHAR); |
| } |
| } |
| if (ret) |
| { |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| *pcbFormat = bytesNeeded; |
| needSeparator = FALSE; |
| if (info->KeyId.cbData) |
| { |
| needSeparator = TRUE; |
| /* Overestimate size available, it's already been checked |
| * above. |
| */ |
| size = bytesNeeded; |
| ret = CRYPT_FormatKeyId(&info->KeyId, str, &size); |
| if (ret) |
| str += size / sizeof(WCHAR) - 1; |
| } |
| if (info->AuthorityCertIssuer.cAltEntry) |
| { |
| if (needSeparator) |
| { |
| strcpyW(str, sep); |
| str += sepLen / sizeof(WCHAR); |
| } |
| needSeparator = TRUE; |
| /* Overestimate size available, it's already been checked |
| * above. |
| */ |
| size = bytesNeeded; |
| ret = CRYPT_FormatCertIssuer(dwFormatStrType, |
| &info->AuthorityCertIssuer, str, &size); |
| if (ret) |
| str += size / sizeof(WCHAR) - 1; |
| } |
| if (info->AuthorityCertSerialNumber.cbData) |
| { |
| if (needSeparator) |
| { |
| strcpyW(str, sep); |
| str += sepLen / sizeof(WCHAR); |
| } |
| /* Overestimate size available, it's already been checked |
| * above. |
| */ |
| size = bytesNeeded; |
| ret = CRYPT_FormatCertSerialNumber( |
| &info->AuthorityCertSerialNumber, str, &size); |
| } |
| } |
| } |
| LocalFree(info); |
| } |
| return ret; |
| } |
| |
| static WCHAR aia[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR accessMethod[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR ocsp[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR caIssuers[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR unknown[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR accessLocation[MAX_STRING_RESOURCE_LEN]; |
| |
| static BOOL WINAPI CRYPT_FormatAuthorityInfoAccess(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| CERT_AUTHORITY_INFO_ACCESS *info; |
| DWORD size; |
| BOOL ret = FALSE; |
| |
| if (!cbEncoded) |
| { |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, |
| X509_AUTHORITY_INFO_ACCESS, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, |
| NULL, &info, &size))) |
| { |
| DWORD bytesNeeded = sizeof(WCHAR); |
| |
| if (!info->cAccDescr) |
| { |
| WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN]; |
| |
| LoadStringW(hInstance, IDS_INFO_NOT_AVAILABLE, infoNotAvailable, |
| sizeof(infoNotAvailable) / sizeof(infoNotAvailable[0])); |
| bytesNeeded += strlenW(infoNotAvailable) * sizeof(WCHAR); |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| *pcbFormat = bytesNeeded; |
| strcpyW(pbFormat, infoNotAvailable); |
| } |
| } |
| else |
| { |
| static const WCHAR numFmt[] = { '%','d',0 }; |
| static const WCHAR equal[] = { '=',0 }; |
| static BOOL stringsLoaded = FALSE; |
| DWORD i; |
| LPCWSTR headingSep, accessMethodSep, locationSep; |
| WCHAR accessDescrNum[11]; |
| |
| if (!stringsLoaded) |
| { |
| LoadStringW(hInstance, IDS_AIA, aia, |
| sizeof(aia) / sizeof(aia[0])); |
| LoadStringW(hInstance, IDS_ACCESS_METHOD, accessMethod, |
| sizeof(accessMethod) / sizeof(accessMethod[0])); |
| LoadStringW(hInstance, IDS_ACCESS_METHOD_OCSP, ocsp, |
| sizeof(ocsp) / sizeof(ocsp[0])); |
| LoadStringW(hInstance, IDS_ACCESS_METHOD_CA_ISSUERS, caIssuers, |
| sizeof(caIssuers) / sizeof(caIssuers[0])); |
| LoadStringW(hInstance, IDS_ACCESS_METHOD_UNKNOWN, unknown, |
| sizeof(unknown) / sizeof(unknown[0])); |
| LoadStringW(hInstance, IDS_ACCESS_LOCATION, accessLocation, |
| sizeof(accessLocation) / sizeof(accessLocation[0])); |
| stringsLoaded = TRUE; |
| } |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| headingSep = crlf; |
| accessMethodSep = crlf; |
| locationSep = colonCrlf; |
| } |
| else |
| { |
| headingSep = colonSep; |
| accessMethodSep = commaSpace; |
| locationSep = equal; |
| } |
| |
| for (i = 0; ret && i < info->cAccDescr; i++) |
| { |
| /* Heading */ |
| bytesNeeded += sizeof(WCHAR); /* left bracket */ |
| sprintfW(accessDescrNum, numFmt, i + 1); |
| bytesNeeded += strlenW(accessDescrNum) * sizeof(WCHAR); |
| bytesNeeded += sizeof(WCHAR); /* right bracket */ |
| bytesNeeded += strlenW(aia) * sizeof(WCHAR); |
| bytesNeeded += strlenW(headingSep) * sizeof(WCHAR); |
| /* Access method */ |
| bytesNeeded += strlenW(accessMethod) * sizeof(WCHAR); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| bytesNeeded += strlenW(indent) * sizeof(WCHAR); |
| if (!strcmp(info->rgAccDescr[i].pszAccessMethod, |
| szOID_PKIX_OCSP)) |
| bytesNeeded += strlenW(ocsp) * sizeof(WCHAR); |
| else if (!strcmp(info->rgAccDescr[i].pszAccessMethod, |
| szOID_PKIX_CA_ISSUERS)) |
| bytesNeeded += strlenW(caIssuers) * sizeof(caIssuers); |
| else |
| bytesNeeded += strlenW(unknown) * sizeof(WCHAR); |
| bytesNeeded += sizeof(WCHAR); /* space */ |
| bytesNeeded += sizeof(WCHAR); /* left paren */ |
| bytesNeeded += strlen(info->rgAccDescr[i].pszAccessMethod) |
| * sizeof(WCHAR); |
| bytesNeeded += sizeof(WCHAR); /* right paren */ |
| /* Delimiter between access method and location */ |
| bytesNeeded += strlenW(accessMethodSep) * sizeof(WCHAR); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| bytesNeeded += strlenW(indent) * sizeof(WCHAR); |
| bytesNeeded += strlenW(accessLocation) * sizeof(WCHAR); |
| bytesNeeded += strlenW(locationSep) * sizeof(WCHAR); |
| ret = CRYPT_FormatAltNameEntry(dwFormatStrType, 2, |
| &info->rgAccDescr[i].AccessLocation, NULL, &size); |
| if (ret) |
| bytesNeeded += size - sizeof(WCHAR); |
| /* Need extra delimiter between access method entries */ |
| if (i < info->cAccDescr - 1) |
| bytesNeeded += strlenW(accessMethodSep) * sizeof(WCHAR); |
| } |
| if (ret) |
| { |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| DWORD altNameEntrySize; |
| |
| *pcbFormat = bytesNeeded; |
| for (i = 0; ret && i < info->cAccDescr; i++) |
| { |
| LPCSTR oidPtr; |
| |
| *str++ = '['; |
| sprintfW(accessDescrNum, numFmt, i + 1); |
| strcpyW(str, accessDescrNum); |
| str += strlenW(accessDescrNum); |
| *str++ = ']'; |
| strcpyW(str, aia); |
| str += strlenW(aia); |
| strcpyW(str, headingSep); |
| str += strlenW(headingSep); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| strcpyW(str, indent); |
| str += strlenW(indent); |
| } |
| strcpyW(str, accessMethod); |
| str += strlenW(accessMethod); |
| if (!strcmp(info->rgAccDescr[i].pszAccessMethod, |
| szOID_PKIX_OCSP)) |
| { |
| strcpyW(str, ocsp); |
| str += strlenW(ocsp); |
| } |
| else if (!strcmp(info->rgAccDescr[i].pszAccessMethod, |
| szOID_PKIX_CA_ISSUERS)) |
| { |
| strcpyW(str, caIssuers); |
| str += strlenW(caIssuers); |
| } |
| else |
| { |
| strcpyW(str, unknown); |
| str += strlenW(unknown); |
| } |
| *str++ = ' '; |
| *str++ = '('; |
| for (oidPtr = info->rgAccDescr[i].pszAccessMethod; |
| *oidPtr; oidPtr++, str++) |
| *str = *oidPtr; |
| *str++ = ')'; |
| strcpyW(str, accessMethodSep); |
| str += strlenW(accessMethodSep); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| strcpyW(str, indent); |
| str += strlenW(indent); |
| } |
| strcpyW(str, accessLocation); |
| str += strlenW(accessLocation); |
| strcpyW(str, locationSep); |
| str += strlenW(locationSep); |
| /* This overestimates the size available, but that |
| * won't matter since we checked earlier whether enough |
| * space for the entire string was available. |
| */ |
| altNameEntrySize = bytesNeeded; |
| ret = CRYPT_FormatAltNameEntry(dwFormatStrType, 2, |
| &info->rgAccDescr[i].AccessLocation, str, |
| &altNameEntrySize); |
| if (ret) |
| str += altNameEntrySize / sizeof(WCHAR) - 1; |
| if (i < info->cAccDescr - 1) |
| { |
| strcpyW(str, accessMethodSep); |
| str += strlenW(accessMethodSep); |
| } |
| } |
| } |
| } |
| } |
| LocalFree(info); |
| } |
| return ret; |
| } |
| |
| static WCHAR keyCompromise[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR caCompromise[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR affiliationChanged[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR superseded[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR operationCeased[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR certificateHold[MAX_STRING_RESOURCE_LEN]; |
| |
| struct reason_map_entry |
| { |
| BYTE reasonBit; |
| LPWSTR reason; |
| int id; |
| }; |
| static struct reason_map_entry reason_map[] = { |
| { CRL_REASON_KEY_COMPROMISE_FLAG, keyCompromise, IDS_REASON_KEY_COMPROMISE }, |
| { CRL_REASON_CA_COMPROMISE_FLAG, caCompromise, IDS_REASON_CA_COMPROMISE }, |
| { CRL_REASON_AFFILIATION_CHANGED_FLAG, affiliationChanged, |
| IDS_REASON_AFFILIATION_CHANGED }, |
| { CRL_REASON_SUPERSEDED_FLAG, superseded, IDS_REASON_SUPERSEDED }, |
| { CRL_REASON_CESSATION_OF_OPERATION_FLAG, operationCeased, |
| IDS_REASON_CESSATION_OF_OPERATION }, |
| { CRL_REASON_CERTIFICATE_HOLD_FLAG, certificateHold, |
| IDS_REASON_CERTIFICATE_HOLD }, |
| }; |
| |
| static BOOL CRYPT_FormatReason(DWORD dwFormatStrType, |
| const CRYPT_BIT_BLOB *reasonFlags, LPWSTR str, DWORD *pcbStr) |
| { |
| static const WCHAR sep[] = { ',',' ',0 }; |
| static const WCHAR bitsFmt[] = { ' ','(','%','0','2','x',')',0 }; |
| static BOOL stringsLoaded = FALSE; |
| int i, numReasons = 0; |
| BOOL ret = TRUE; |
| DWORD bytesNeeded = sizeof(WCHAR); |
| WCHAR bits[6]; |
| |
| if (!stringsLoaded) |
| { |
| for (i = 0; i < sizeof(reason_map) / sizeof(reason_map[0]); i++) |
| LoadStringW(hInstance, reason_map[i].id, reason_map[i].reason, |
| MAX_STRING_RESOURCE_LEN); |
| stringsLoaded = TRUE; |
| } |
| /* No need to check reasonFlags->cbData, we already know it's positive. |
| * Ignore any other bytes, as they're for undefined bits. |
| */ |
| for (i = 0; i < sizeof(reason_map) / sizeof(reason_map[0]); i++) |
| { |
| if (reasonFlags->pbData[0] & reason_map[i].reasonBit) |
| { |
| bytesNeeded += strlenW(reason_map[i].reason) * sizeof(WCHAR); |
| if (numReasons++) |
| bytesNeeded += strlenW(sep) * sizeof(WCHAR); |
| } |
| } |
| sprintfW(bits, bitsFmt, reasonFlags->pbData[0]); |
| bytesNeeded += strlenW(bits); |
| if (!str) |
| *pcbStr = bytesNeeded; |
| else if (*pcbStr < bytesNeeded) |
| { |
| *pcbStr = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| *pcbStr = bytesNeeded; |
| for (i = 0; i < sizeof(reason_map) / sizeof(reason_map[0]); i++) |
| { |
| if (reasonFlags->pbData[0] & reason_map[i].reasonBit) |
| { |
| strcpyW(str, reason_map[i].reason); |
| str += strlenW(reason_map[i].reason); |
| if (i < sizeof(reason_map) / sizeof(reason_map[0]) - 1 && |
| numReasons) |
| { |
| strcpyW(str, sep); |
| str += strlenW(sep); |
| } |
| } |
| } |
| strcpyW(str, bits); |
| } |
| return ret; |
| } |
| |
| static WCHAR crlDistPoint[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR distPointName[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR fullName[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR rdnName[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR reason[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR issuer[MAX_STRING_RESOURCE_LEN]; |
| |
| static BOOL WINAPI CRYPT_FormatCRLDistPoints(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| CRL_DIST_POINTS_INFO *info; |
| DWORD size; |
| BOOL ret = FALSE; |
| |
| if (!cbEncoded) |
| { |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_CRL_DIST_POINTS, |
| pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size))) |
| { |
| static const WCHAR numFmt[] = { '%','d',0 }; |
| static const WCHAR colon[] = { ':',0 }; |
| static BOOL stringsLoaded = FALSE; |
| DWORD bytesNeeded = sizeof(WCHAR); /* space for NULL terminator */ |
| BOOL haveAnEntry = FALSE; |
| LPCWSTR headingSep, nameSep; |
| WCHAR distPointNum[11]; |
| DWORD i; |
| |
| if (!stringsLoaded) |
| { |
| LoadStringW(hInstance, IDS_CRL_DIST_POINT, crlDistPoint, |
| sizeof(crlDistPoint) / sizeof(crlDistPoint[0])); |
| LoadStringW(hInstance, IDS_CRL_DIST_POINT_NAME, distPointName, |
| sizeof(distPointName) / sizeof(distPointName[0])); |
| LoadStringW(hInstance, IDS_CRL_DIST_POINT_FULL_NAME, fullName, |
| sizeof(fullName) / sizeof(fullName[0])); |
| LoadStringW(hInstance, IDS_CRL_DIST_POINT_RDN_NAME, rdnName, |
| sizeof(rdnName) / sizeof(rdnName[0])); |
| LoadStringW(hInstance, IDS_CRL_DIST_POINT_REASON, reason, |
| sizeof(reason) / sizeof(reason[0])); |
| LoadStringW(hInstance, IDS_CRL_DIST_POINT_ISSUER, issuer, |
| sizeof(issuer) / sizeof(issuer[0])); |
| stringsLoaded = TRUE; |
| } |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| headingSep = crlf; |
| nameSep = colonCrlf; |
| } |
| else |
| { |
| headingSep = colonSep; |
| nameSep = colon; |
| } |
| |
| for (i = 0; ret && i < info->cDistPoint; i++) |
| { |
| CRL_DIST_POINT *distPoint = &info->rgDistPoint[i]; |
| |
| if (distPoint->DistPointName.dwDistPointNameChoice != |
| CRL_DIST_POINT_NO_NAME) |
| { |
| bytesNeeded += strlenW(distPointName) * sizeof(WCHAR); |
| bytesNeeded += strlenW(nameSep) * sizeof(WCHAR); |
| if (distPoint->DistPointName.dwDistPointNameChoice == |
| CRL_DIST_POINT_FULL_NAME) |
| bytesNeeded += strlenW(fullName) * sizeof(WCHAR); |
| else |
| bytesNeeded += strlenW(rdnName) * sizeof(WCHAR); |
| bytesNeeded += strlenW(nameSep) * sizeof(WCHAR); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| bytesNeeded += 2 * strlenW(indent) * sizeof(WCHAR); |
| /* The indent level (3) is higher than when used as the issuer, |
| * because the name is subordinate to the name type (full vs. |
| * RDN.) |
| */ |
| ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 3, |
| &distPoint->DistPointName.u.FullName, NULL, &size); |
| if (ret) |
| bytesNeeded += size - sizeof(WCHAR); |
| haveAnEntry = TRUE; |
| } |
| else if (distPoint->ReasonFlags.cbData) |
| { |
| bytesNeeded += strlenW(reason) * sizeof(WCHAR); |
| ret = CRYPT_FormatReason(dwFormatStrType, |
| &distPoint->ReasonFlags, NULL, &size); |
| if (ret) |
| bytesNeeded += size - sizeof(WCHAR); |
| haveAnEntry = TRUE; |
| } |
| else if (distPoint->CRLIssuer.cAltEntry) |
| { |
| bytesNeeded += strlenW(issuer) * sizeof(WCHAR); |
| bytesNeeded += strlenW(nameSep) * sizeof(WCHAR); |
| ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 2, |
| &distPoint->CRLIssuer, NULL, &size); |
| if (ret) |
| bytesNeeded += size - sizeof(WCHAR); |
| haveAnEntry = TRUE; |
| } |
| if (haveAnEntry) |
| { |
| bytesNeeded += sizeof(WCHAR); /* left bracket */ |
| sprintfW(distPointNum, numFmt, i + 1); |
| bytesNeeded += strlenW(distPointNum) * sizeof(WCHAR); |
| bytesNeeded += sizeof(WCHAR); /* right bracket */ |
| bytesNeeded += strlenW(crlDistPoint) * sizeof(WCHAR); |
| bytesNeeded += strlenW(headingSep) * sizeof(WCHAR); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| bytesNeeded += strlenW(indent) * sizeof(WCHAR); |
| } |
| } |
| if (!haveAnEntry) |
| { |
| WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN]; |
| |
| LoadStringW(hInstance, IDS_INFO_NOT_AVAILABLE, infoNotAvailable, |
| sizeof(infoNotAvailable) / sizeof(infoNotAvailable[0])); |
| bytesNeeded += strlenW(infoNotAvailable) * sizeof(WCHAR); |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| *pcbFormat = bytesNeeded; |
| strcpyW(pbFormat, infoNotAvailable); |
| } |
| } |
| else |
| { |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| *pcbFormat = bytesNeeded; |
| for (i = 0; ret && i < info->cDistPoint; i++) |
| { |
| CRL_DIST_POINT *distPoint = &info->rgDistPoint[i]; |
| |
| *str++ = '['; |
| sprintfW(distPointNum, numFmt, i + 1); |
| strcpyW(str, distPointNum); |
| str += strlenW(distPointNum); |
| *str++ = ']'; |
| strcpyW(str, crlDistPoint); |
| str += strlenW(crlDistPoint); |
| strcpyW(str, headingSep); |
| str += strlenW(headingSep); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| strcpyW(str, indent); |
| str += strlenW(indent); |
| } |
| if (distPoint->DistPointName.dwDistPointNameChoice != |
| CRL_DIST_POINT_NO_NAME) |
| { |
| DWORD altNameSize = bytesNeeded; |
| |
| strcpyW(str, distPointName); |
| str += strlenW(distPointName); |
| strcpyW(str, nameSep); |
| str += strlenW(nameSep); |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| strcpyW(str, indent); |
| str += strlenW(indent); |
| strcpyW(str, indent); |
| str += strlenW(indent); |
| } |
| if (distPoint->DistPointName.dwDistPointNameChoice == |
| CRL_DIST_POINT_FULL_NAME) |
| { |
| strcpyW(str, fullName); |
| str += strlenW(fullName); |
| } |
| else |
| { |
| strcpyW(str, rdnName); |
| str += strlenW(rdnName); |
| } |
| strcpyW(str, nameSep); |
| str += strlenW(nameSep); |
| ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 3, |
| &distPoint->DistPointName.u.FullName, str, |
| &altNameSize); |
| if (ret) |
| str += altNameSize / sizeof(WCHAR) - 1; |
| } |
| else if (distPoint->ReasonFlags.cbData) |
| { |
| DWORD reasonSize = bytesNeeded; |
| |
| strcpyW(str, reason); |
| str += strlenW(reason); |
| ret = CRYPT_FormatReason(dwFormatStrType, |
| &distPoint->ReasonFlags, str, &reasonSize); |
| if (ret) |
| str += reasonSize / sizeof(WCHAR) - 1; |
| } |
| else if (distPoint->CRLIssuer.cAltEntry) |
| { |
| DWORD crlIssuerSize = bytesNeeded; |
| |
| strcpyW(str, issuer); |
| str += strlenW(issuer); |
| strcpyW(str, nameSep); |
| str += strlenW(nameSep); |
| ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 2, |
| &distPoint->CRLIssuer, str, |
| &crlIssuerSize); |
| if (ret) |
| str += crlIssuerSize / sizeof(WCHAR) - 1; |
| } |
| } |
| } |
| } |
| LocalFree(info); |
| } |
| return ret; |
| } |
| |
| static BOOL WINAPI CRYPT_FormatEnhancedKeyUsage(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| CERT_ENHKEY_USAGE *usage; |
| DWORD size; |
| BOOL ret = FALSE; |
| |
| if (!cbEncoded) |
| { |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_ENHANCED_KEY_USAGE, |
| pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &usage, &size))) |
| { |
| WCHAR unknown[MAX_STRING_RESOURCE_LEN]; |
| DWORD i; |
| DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */ |
| LPCWSTR sep; |
| DWORD sepLen; |
| |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| sep = crlf; |
| sepLen = strlenW(crlf) * sizeof(WCHAR); |
| } |
| else |
| { |
| sep = commaSpace; |
| sepLen = strlenW(commaSpace) * sizeof(WCHAR); |
| } |
| |
| LoadStringW(hInstance, IDS_USAGE_UNKNOWN, unknown, |
| sizeof(unknown) / sizeof(unknown[0])); |
| for (i = 0; i < usage->cUsageIdentifier; i++) |
| { |
| PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, |
| usage->rgpszUsageIdentifier[i], CRYPT_ENHKEY_USAGE_OID_GROUP_ID); |
| |
| if (info) |
| bytesNeeded += strlenW(info->pwszName) * sizeof(WCHAR); |
| else |
| bytesNeeded += strlenW(unknown) * sizeof(WCHAR); |
| bytesNeeded += sizeof(WCHAR); /* space */ |
| bytesNeeded += sizeof(WCHAR); /* left paren */ |
| bytesNeeded += strlen(usage->rgpszUsageIdentifier[i]) * |
| sizeof(WCHAR); |
| bytesNeeded += sizeof(WCHAR); /* right paren */ |
| if (i < usage->cUsageIdentifier - 1) |
| bytesNeeded += sepLen; |
| } |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| *pcbFormat = bytesNeeded; |
| for (i = 0; i < usage->cUsageIdentifier; i++) |
| { |
| PCCRYPT_OID_INFO info = CryptFindOIDInfo(CRYPT_OID_INFO_OID_KEY, |
| usage->rgpszUsageIdentifier[i], |
| CRYPT_ENHKEY_USAGE_OID_GROUP_ID); |
| LPCSTR oidPtr; |
| |
| if (info) |
| { |
| strcpyW(str, info->pwszName); |
| str += strlenW(info->pwszName); |
| } |
| else |
| { |
| strcpyW(str, unknown); |
| str += strlenW(unknown); |
| } |
| *str++ = ' '; |
| *str++ = '('; |
| for (oidPtr = usage->rgpszUsageIdentifier[i]; *oidPtr; oidPtr++) |
| *str++ = *oidPtr; |
| *str++ = ')'; |
| *str = 0; |
| if (i < usage->cUsageIdentifier - 1) |
| { |
| strcpyW(str, sep); |
| str += sepLen / sizeof(WCHAR); |
| } |
| } |
| } |
| LocalFree(usage); |
| } |
| return ret; |
| } |
| |
| static struct BitToString netscapeCertTypeMap[] = { |
| { NETSCAPE_SSL_CLIENT_AUTH_CERT_TYPE, IDS_NETSCAPE_SSL_CLIENT, { 0 } }, |
| { NETSCAPE_SSL_SERVER_AUTH_CERT_TYPE, IDS_NETSCAPE_SSL_SERVER, { 0 } }, |
| { NETSCAPE_SMIME_CERT_TYPE, IDS_NETSCAPE_SMIME, { 0 } }, |
| { NETSCAPE_SIGN_CERT_TYPE, IDS_NETSCAPE_SIGN, { 0 } }, |
| { NETSCAPE_SSL_CA_CERT_TYPE, IDS_NETSCAPE_SSL_CA, { 0 } }, |
| { NETSCAPE_SMIME_CA_CERT_TYPE, IDS_NETSCAPE_SMIME_CA, { 0 } }, |
| { NETSCAPE_SIGN_CA_CERT_TYPE, IDS_NETSCAPE_SIGN_CA, { 0 } }, |
| }; |
| |
| static BOOL WINAPI CRYPT_FormatNetscapeCertType(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| DWORD size; |
| CRYPT_BIT_BLOB *bits; |
| BOOL ret; |
| |
| if (!cbEncoded) |
| { |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_BITS, |
| pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &bits, &size))) |
| { |
| WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN]; |
| DWORD bytesNeeded = sizeof(WCHAR); |
| |
| LoadStringW(hInstance, IDS_INFO_NOT_AVAILABLE, infoNotAvailable, |
| sizeof(infoNotAvailable) / sizeof(infoNotAvailable[0])); |
| if (!bits->cbData || bits->cbData > 1) |
| { |
| bytesNeeded += strlenW(infoNotAvailable) * sizeof(WCHAR); |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| *pcbFormat = bytesNeeded; |
| strcpyW(str, infoNotAvailable); |
| } |
| } |
| else |
| { |
| static BOOL stringsLoaded = FALSE; |
| int i; |
| DWORD bitStringLen; |
| BOOL first = TRUE; |
| |
| if (!stringsLoaded) |
| { |
| for (i = 0; i < sizeof(netscapeCertTypeMap) / |
| sizeof(netscapeCertTypeMap[0]); i++) |
| LoadStringW(hInstance, netscapeCertTypeMap[i].id, |
| netscapeCertTypeMap[i].str, MAX_STRING_RESOURCE_LEN); |
| stringsLoaded = TRUE; |
| } |
| CRYPT_FormatBits(bits->pbData[0], netscapeCertTypeMap, |
| sizeof(netscapeCertTypeMap) / sizeof(netscapeCertTypeMap[0]), |
| NULL, &bitStringLen, &first); |
| bytesNeeded += bitStringLen; |
| bytesNeeded += 3 * sizeof(WCHAR); /* " (" + ")" */ |
| CRYPT_FormatHexString(0, 0, 0, NULL, NULL, bits->pbData, |
| bits->cbData, NULL, &size); |
| bytesNeeded += size; |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| bitStringLen = bytesNeeded; |
| first = TRUE; |
| CRYPT_FormatBits(bits->pbData[0], netscapeCertTypeMap, |
| sizeof(netscapeCertTypeMap) / sizeof(netscapeCertTypeMap[0]), |
| str, &bitStringLen, &first); |
| str += bitStringLen / sizeof(WCHAR) - 1; |
| *str++ = ' '; |
| *str++ = '('; |
| CRYPT_FormatHexString(0, 0, 0, NULL, NULL, bits->pbData, |
| bits->cbData, str, &size); |
| str += size / sizeof(WCHAR) - 1; |
| *str++ = ')'; |
| *str = 0; |
| } |
| } |
| LocalFree(bits); |
| } |
| return ret; |
| } |
| |
| static WCHAR financialCriteria[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR available[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR notAvailable[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR meetsCriteria[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR yes[MAX_STRING_RESOURCE_LEN]; |
| static WCHAR no[MAX_STRING_RESOURCE_LEN]; |
| |
| static BOOL WINAPI CRYPT_FormatSpcFinancialCriteria(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| SPC_FINANCIAL_CRITERIA criteria; |
| DWORD size = sizeof(criteria); |
| BOOL ret = FALSE; |
| |
| if (!cbEncoded) |
| { |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, |
| SPC_FINANCIAL_CRITERIA_STRUCT, pbEncoded, cbEncoded, 0, NULL, &criteria, |
| &size))) |
| { |
| static BOOL stringsLoaded = FALSE; |
| DWORD bytesNeeded = sizeof(WCHAR); |
| LPCWSTR sep; |
| DWORD sepLen; |
| |
| if (!stringsLoaded) |
| { |
| LoadStringW(hInstance, IDS_FINANCIAL_CRITERIA, financialCriteria, |
| sizeof(financialCriteria) / sizeof(financialCriteria[0])); |
| LoadStringW(hInstance, IDS_FINANCIAL_CRITERIA_AVAILABLE, available, |
| sizeof(available) / sizeof(available[0])); |
| LoadStringW(hInstance, IDS_FINANCIAL_CRITERIA_NOT_AVAILABLE, |
| notAvailable, sizeof(notAvailable) / sizeof(notAvailable[0])); |
| LoadStringW(hInstance, IDS_FINANCIAL_CRITERIA_MEETS_CRITERIA, |
| meetsCriteria, sizeof(meetsCriteria) / sizeof(meetsCriteria[0])); |
| LoadStringW(hInstance, IDS_YES, yes, sizeof(yes) / sizeof(yes[0])); |
| LoadStringW(hInstance, IDS_NO, no, sizeof(no) / sizeof(no[0])); |
| stringsLoaded = TRUE; |
| } |
| if (dwFormatStrType & CRYPT_FORMAT_STR_MULTI_LINE) |
| { |
| sep = crlf; |
| sepLen = strlenW(crlf) * sizeof(WCHAR); |
| } |
| else |
| { |
| sep = commaSpace; |
| sepLen = strlenW(commaSpace) * sizeof(WCHAR); |
| } |
| bytesNeeded += strlenW(financialCriteria) * sizeof(WCHAR); |
| if (criteria.fFinancialInfoAvailable) |
| { |
| bytesNeeded += strlenW(available) * sizeof(WCHAR); |
| bytesNeeded += sepLen; |
| bytesNeeded += strlenW(meetsCriteria) * sizeof(WCHAR); |
| if (criteria.fMeetsCriteria) |
| bytesNeeded += strlenW(yes) * sizeof(WCHAR); |
| else |
| bytesNeeded += strlenW(no) * sizeof(WCHAR); |
| } |
| else |
| bytesNeeded += strlenW(notAvailable) * sizeof(WCHAR); |
| if (!pbFormat) |
| *pcbFormat = bytesNeeded; |
| else if (*pcbFormat < bytesNeeded) |
| { |
| *pcbFormat = bytesNeeded; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| *pcbFormat = bytesNeeded; |
| strcpyW(str, financialCriteria); |
| str += strlenW(financialCriteria); |
| if (criteria.fFinancialInfoAvailable) |
| { |
| strcpyW(str, available); |
| str += strlenW(available); |
| strcpyW(str, sep); |
| str += sepLen / sizeof(WCHAR); |
| strcpyW(str, meetsCriteria); |
| str += strlenW(meetsCriteria); |
| if (criteria.fMeetsCriteria) |
| strcpyW(str, yes); |
| else |
| strcpyW(str, no); |
| } |
| else |
| { |
| strcpyW(str, notAvailable); |
| str += strlenW(notAvailable); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| static BOOL WINAPI CRYPT_FormatUnicodeString(DWORD dwCertEncodingType, |
| DWORD dwFormatType, DWORD dwFormatStrType, void *pFormatStruct, |
| LPCSTR lpszStructType, const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, |
| DWORD *pcbFormat) |
| { |
| CERT_NAME_VALUE *value; |
| DWORD size; |
| BOOL ret; |
| |
| if (!cbEncoded) |
| { |
| SetLastError(E_INVALIDARG); |
| return FALSE; |
| } |
| if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_UNICODE_ANY_STRING, |
| pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &value, &size))) |
| { |
| if (!pbFormat) |
| *pcbFormat = value->Value.cbData; |
| else if (*pcbFormat < value->Value.cbData) |
| { |
| *pcbFormat = value->Value.cbData; |
| SetLastError(ERROR_MORE_DATA); |
| ret = FALSE; |
| } |
| else |
| { |
| LPWSTR str = pbFormat; |
| |
| *pcbFormat = value->Value.cbData; |
| strcpyW(str, (LPWSTR)value->Value.pbData); |
| } |
| } |
| return ret; |
| } |
| |
| typedef BOOL (WINAPI *CryptFormatObjectFunc)(DWORD, DWORD, DWORD, void *, |
| LPCSTR, const BYTE *, DWORD, void *, DWORD *); |
| |
| static CryptFormatObjectFunc CRYPT_GetBuiltinFormatFunction(DWORD encodingType, |
| DWORD formatStrType, LPCSTR lpszStructType) |
| { |
| CryptFormatObjectFunc format = NULL; |
| |
| if ((encodingType & CERT_ENCODING_TYPE_MASK) != X509_ASN_ENCODING) |
| { |
| SetLastError(ERROR_FILE_NOT_FOUND); |
| return NULL; |
| } |
| if (IS_INTOID(lpszStructType)) |
| { |
| switch (LOWORD(lpszStructType)) |
| { |
| case LOWORD(X509_KEY_USAGE): |
| format = CRYPT_FormatKeyUsage; |
| break; |
| case LOWORD(X509_ALTERNATE_NAME): |
| format = CRYPT_FormatAltName; |
| break; |
| case LOWORD(X509_BASIC_CONSTRAINTS2): |
| format = CRYPT_FormatBasicConstraints2; |
| break; |
| case LOWORD(X509_AUTHORITY_KEY_ID2): |
| format = CRYPT_FormatAuthorityKeyId2; |
| break; |
| case LOWORD(X509_AUTHORITY_INFO_ACCESS): |
| format = CRYPT_FormatAuthorityInfoAccess; |
| break; |
| case LOWORD(X509_CRL_DIST_POINTS): |
| format = CRYPT_FormatCRLDistPoints; |
| break; |
| case LOWORD(X509_ENHANCED_KEY_USAGE): |
| format = CRYPT_FormatEnhancedKeyUsage; |
| break; |
| case LOWORD(SPC_FINANCIAL_CRITERIA_STRUCT): |
| format = CRYPT_FormatSpcFinancialCriteria; |
| break; |
| } |
| } |
| else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME)) |
| format = CRYPT_FormatAltName; |
| else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME)) |
| format = CRYPT_FormatAltName; |
| else if (!strcmp(lpszStructType, szOID_KEY_USAGE)) |
| format = CRYPT_FormatKeyUsage; |
| else if (!strcmp(lpszStructType, szOID_SUBJECT_ALT_NAME2)) |
| format = CRYPT_FormatAltName; |
| else if (!strcmp(lpszStructType, szOID_ISSUER_ALT_NAME2)) |
| format = CRYPT_FormatAltName; |
| else if (!strcmp(lpszStructType, szOID_BASIC_CONSTRAINTS2)) |
| format = CRYPT_FormatBasicConstraints2; |
| else if (!strcmp(lpszStructType, szOID_AUTHORITY_INFO_ACCESS)) |
| format = CRYPT_FormatAuthorityInfoAccess; |
| else if (!strcmp(lpszStructType, szOID_AUTHORITY_KEY_IDENTIFIER2)) |
| format = CRYPT_FormatAuthorityKeyId2; |
| else if (!strcmp(lpszStructType, szOID_CRL_DIST_POINTS)) |
| format = CRYPT_FormatCRLDistPoints; |
| else if (!strcmp(lpszStructType, szOID_ENHANCED_KEY_USAGE)) |
| format = CRYPT_FormatEnhancedKeyUsage; |
| else if (!strcmp(lpszStructType, szOID_NETSCAPE_CERT_TYPE)) |
| format = CRYPT_FormatNetscapeCertType; |
| else if (!strcmp(lpszStructType, szOID_NETSCAPE_BASE_URL) || |
| !strcmp(lpszStructType, szOID_NETSCAPE_REVOCATION_URL) || |
| !strcmp(lpszStructType, szOID_NETSCAPE_CA_REVOCATION_URL) || |
| !strcmp(lpszStructType, szOID_NETSCAPE_CERT_RENEWAL_URL) || |
| !strcmp(lpszStructType, szOID_NETSCAPE_CA_POLICY_URL) || |
| !strcmp(lpszStructType, szOID_NETSCAPE_SSL_SERVER_NAME) || |
| !strcmp(lpszStructType, szOID_NETSCAPE_COMMENT)) |
| format = CRYPT_FormatUnicodeString; |
| else if (!strcmp(lpszStructType, SPC_FINANCIAL_CRITERIA_OBJID)) |
| format = CRYPT_FormatSpcFinancialCriteria; |
| return format; |
| } |
| |
| BOOL WINAPI CryptFormatObject(DWORD dwCertEncodingType, DWORD dwFormatType, |
| DWORD dwFormatStrType, void *pFormatStruct, LPCSTR lpszStructType, |
| const BYTE *pbEncoded, DWORD cbEncoded, void *pbFormat, DWORD *pcbFormat) |
| { |
| CryptFormatObjectFunc format = NULL; |
| HCRYPTOIDFUNCADDR hFunc = NULL; |
| BOOL ret = FALSE; |
| |
| TRACE("(%08x, %d, %08x, %p, %s, %p, %d, %p, %p)\n", dwCertEncodingType, |
| dwFormatType, dwFormatStrType, pFormatStruct, debugstr_a(lpszStructType), |
| pbEncoded, cbEncoded, pbFormat, pcbFormat); |
| |
| if (!(format = CRYPT_GetBuiltinFormatFunction(dwCertEncodingType, |
| dwFormatStrType, lpszStructType))) |
| { |
| static HCRYPTOIDFUNCSET set = NULL; |
| |
| if (!set) |
| set = CryptInitOIDFunctionSet(CRYPT_OID_FORMAT_OBJECT_FUNC, 0); |
| CryptGetOIDFunctionAddress(set, dwCertEncodingType, lpszStructType, 0, |
| (void **)&format, &hFunc); |
| } |
| if (!format && (dwCertEncodingType & CERT_ENCODING_TYPE_MASK) == |
| X509_ASN_ENCODING && !(dwFormatStrType & CRYPT_FORMAT_STR_NO_HEX)) |
| format = CRYPT_FormatHexString; |
| if (format) |
| ret = format(dwCertEncodingType, dwFormatType, dwFormatStrType, |
| pFormatStruct, lpszStructType, pbEncoded, cbEncoded, pbFormat, |
| pcbFormat); |
| if (hFunc) |
| CryptFreeOIDFunctionAddress(hFunc, 0); |
| return ret; |
| } |
