[PATCH] cryptnet: Support verifying certificate revocation with OCSP.
Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/cryptnet/Makefile.in | 2 +- dlls/cryptnet/cryptnet_main.c | 391 ++++++++++++++++++++++++++++++++-- include/wincrypt.h | 4 + 3 files changed, 375 insertions(+), 22 deletions(-) diff --git a/dlls/cryptnet/Makefile.in b/dlls/cryptnet/Makefile.in index 8b13861da1e..af41122193f 100644 --- a/dlls/cryptnet/Makefile.in +++ b/dlls/cryptnet/Makefile.in @@ -1,6 +1,6 @@ MODULE = cryptnet.dll IMPORTLIB = cryptnet -IMPORTS = crypt32 shell32 ole32 +IMPORTS = crypt32 shell32 ole32 advapi32 DELAYIMPORTS = wininet C_SRCS = \ diff --git a/dlls/cryptnet/cryptnet_main.c b/dlls/cryptnet/cryptnet_main.c index 8aec76e9b81..6654ef77c8c 100644 --- a/dlls/cryptnet/cryptnet_main.c +++ b/dlls/cryptnet/cryptnet_main.c @@ -1720,37 +1720,386 @@ static DWORD verify_cert_revocation_from_dist_points_ext(const CRYPT_DATA_BLOB * return error; } +static void sha1_hash(const BYTE *data, DWORD datalen, BYTE *buf, DWORD *buflen) +{ + HCRYPTPROV prov; + HCRYPTHASH hash; + + CryptAcquireContextW(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT); + CryptCreateHash(prov, CALG_SHA1, 0, 0, &hash); + CryptHashData(hash, data, datalen, 0); + CryptGetHashParam(hash, HP_HASHVAL, buf, buflen, 0); + + CryptDestroyHash(hash); + CryptReleaseContext(prov, 0); +} + +static BYTE *build_ocsp_request(const CERT_CONTEXT *cert, const CERT_CONTEXT *issuer_cert, DWORD *ret_size) +{ + OCSP_REQUEST_ENTRY entry; + OCSP_REQUEST_INFO request; + OCSP_SIGNED_REQUEST_INFO request_signed; + CERT_INFO *issuer = issuer_cert->pCertInfo; + BYTE issuer_name_hash[20], issuer_key_hash[20], *buf, *ret; + DWORD size = 0, hash_len = sizeof(issuer_name_hash); + + memset(&entry, 0, sizeof(entry)); + entry.CertId.HashAlgorithm.pszObjId = (char *)szOID_OIWSEC_sha1; + + sha1_hash(issuer->Subject.pbData, issuer->Subject.cbData, issuer_name_hash, &hash_len); + entry.CertId.IssuerNameHash.cbData = sizeof(issuer_name_hash); + entry.CertId.IssuerNameHash.pbData = issuer_name_hash; + + sha1_hash(issuer->SubjectPublicKeyInfo.PublicKey.pbData, issuer->SubjectPublicKeyInfo.PublicKey.cbData, + issuer_key_hash, &hash_len); + entry.CertId.IssuerKeyHash.cbData = sizeof(issuer_key_hash); + entry.CertId.IssuerKeyHash.pbData = issuer_key_hash; + + entry.CertId.SerialNumber.cbData = cert->pCertInfo->SerialNumber.cbData; + entry.CertId.SerialNumber.pbData = cert->pCertInfo->SerialNumber.pbData; + + request.dwVersion = OCSP_REQUEST_V1; + request.pRequestorName = NULL; + request.cRequestEntry = 1; + request.rgRequestEntry = &entry; + request.cExtension = 0; + request.rgExtension = NULL; + if (!CryptEncodeObjectEx(X509_ASN_ENCODING, OCSP_REQUEST, &request, CRYPT_ENCODE_ALLOC_FLAG, NULL, &buf, &size)) + { + ERR("failed to encode request %#lx\n", GetLastError()); + return NULL; + } + + request_signed.ToBeSigned.pbData = buf; + request_signed.ToBeSigned.cbData = size; + request_signed.pOptionalSignatureInfo = NULL; + if (!CryptEncodeObjectEx(X509_ASN_ENCODING, OCSP_SIGNED_REQUEST, &request_signed, CRYPT_ENCODE_ALLOC_FLAG, NULL, + &ret, &size)) + { + ERR("failed to encode signed request %#lx\n", GetLastError()); + LocalFree(buf); + return NULL; + } + + LocalFree(buf); + *ret_size = size; + return ret; +} + +static void escape_path(const WCHAR *src, DWORD src_len, WCHAR *dst, DWORD *dst_len) +{ + static const WCHAR hex[] = L"0123456789ABCDEF"; + WCHAR *ptr = dst; + DWORD i; + + *dst_len = src_len; + for (i = 0; i < src_len; i++) + { + if (src[i] == '+' || src[i] == '/' || src[i] == '=') + { + if (dst) + { + ptr[0] = '%'; + ptr[1] = hex[(src[i] >> 4) & 0xf]; + ptr[2] = hex[src[i] & 0xf]; + ptr += 3; + } + *dst_len += 2; + } + else if (dst) *ptr++ = src[i]; + } +} + +static WCHAR *build_request_path(const BYTE *data, DWORD data_size) +{ + WCHAR *path, *ret; + DWORD path_len, ret_len; + + if (!CryptBinaryToStringW(data, data_size, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, NULL, &path_len)) return NULL; + if (!(path = malloc(path_len * sizeof(WCHAR)))) return NULL; + CryptBinaryToStringW(data, data_size, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCRLF, path, &path_len); + + escape_path(path, path_len, NULL, &ret_len); + if (!(ret = malloc((ret_len + 2) * sizeof(WCHAR)))) + { + free(path); + return NULL; + } + escape_path(path, path_len, ret + 1, &ret_len); + ret[ret_len + 1] = 0; + ret[0] = '/'; + + free(path); + return ret; +} + +static WCHAR *build_request_url(const WCHAR *base_url, const BYTE *data, DWORD data_size) +{ + WCHAR *path, *ret; + DWORD len = 0; + + if (!(path = build_request_path(data, data_size))) return NULL; + + InternetCombineUrlW(base_url, path, NULL, &len, 0); + if (!(ret = malloc(len * sizeof(WCHAR)))) + { + free(path); + return NULL; + } + InternetCombineUrlW(base_url, path, ret, &len, 0); + free(path); + return ret; +} + +static DWORD map_ocsp_status(DWORD status) +{ + switch (status) + { + case OCSP_BASIC_GOOD_CERT_STATUS: return ERROR_SUCCESS; + case OCSP_BASIC_REVOKED_CERT_STATUS: return CRYPT_E_REVOKED; + case OCSP_BASIC_UNKNOWN_CERT_STATUS: return CRYPT_E_REVOCATION_OFFLINE; + default: + FIXME("unhandled status %lu\n", status); + return CRYPT_E_REVOCATION_OFFLINE; + } +} + +static BOOL match_cert_id(const OCSP_CERT_ID *id, const CERT_INFO *cert, const CERT_INFO *issuer) +{ + BYTE hash[20]; + DWORD hash_len = sizeof(hash); + + if (!id->HashAlgorithm.pszObjId || strcmp(id->HashAlgorithm.pszObjId, szOID_OIWSEC_sha1)) + { + FIXME("hash algorithm %s not supported\n", debugstr_a(id->HashAlgorithm.pszObjId)); + return FALSE; + } + + sha1_hash(issuer->Subject.pbData, issuer->Subject.cbData, hash, &hash_len); + if (id->IssuerNameHash.cbData != hash_len) return FALSE; + if (memcmp(id->IssuerNameHash.pbData, hash, hash_len)) return FALSE; + + sha1_hash(issuer->SubjectPublicKeyInfo.PublicKey.pbData, + issuer->SubjectPublicKeyInfo.PublicKey.cbData, hash, &hash_len); + if (id->IssuerKeyHash.cbData != hash_len) return FALSE; + if (memcmp(id->IssuerKeyHash.pbData, hash, hash_len)) return FALSE; + + if (cert->SerialNumber.cbData != id->SerialNumber.cbData) return FALSE; + return !memcmp(cert->SerialNumber.pbData, id->SerialNumber.pbData, id->SerialNumber.cbData); +} + +static DWORD check_ocsp_response_info(const CERT_INFO *cert, const CERT_INFO *issuer, + const CRYPT_OBJID_BLOB *blob, DWORD *status) +{ + OCSP_BASIC_RESPONSE_INFO *info; + DWORD size, i; + + if (!CryptDecodeObjectEx(X509_ASN_ENCODING, OCSP_BASIC_RESPONSE, blob->pbData, blob->cbData, + CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)) return GetLastError(); + + FIXME("check responder id\n"); + for (i = 0; i < info->cResponseEntry; i++) + { + OCSP_BASIC_RESPONSE_ENTRY *entry = &info->rgResponseEntry[i]; + if (match_cert_id(&entry->CertId, cert, issuer)) *status = map_ocsp_status(entry->dwCertStatus); + } + + LocalFree(info); + return ERROR_SUCCESS; +} + +static DWORD verify_signed_ocsp_response_info(const CERT_INFO *cert, const CERT_INFO *issuer, + const CRYPT_OBJID_BLOB *blob) +{ + OCSP_BASIC_SIGNED_RESPONSE_INFO *info; + DWORD size, error, status = CRYPT_E_REVOCATION_OFFLINE; + CRYPT_ALGORITHM_IDENTIFIER *alg; + CRYPT_BIT_BLOB *sig; + HCRYPTPROV prov = 0; + HCRYPTHASH hash = 0; + HCRYPTKEY key = 0; + + if (!CryptDecodeObjectEx(X509_ASN_ENCODING, OCSP_BASIC_SIGNED_RESPONSE, blob->pbData, blob->cbData, + CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)) return GetLastError(); + + if ((error = check_ocsp_response_info(cert, issuer, &info->ToBeSigned, &status))) goto done; + + alg = &info->SignatureInfo.SignatureAlgorithm; + if (!alg->pszObjId || strcmp(alg->pszObjId, szOID_RSA_SHA256RSA)) + { + FIXME("unhandled signature algorithm %s\n", debugstr_a(alg->pszObjId)); + error = CRYPT_E_NO_REVOCATION_CHECK; + goto done; + } + + if (!CryptAcquireContextW(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) goto done; + if (!CryptCreateHash(prov, CALG_SHA_256, 0, 0, &hash)) goto done; + if (!CryptHashData(hash, info->ToBeSigned.pbData, info->ToBeSigned.cbData, 0)) goto done; + + sig = &info->SignatureInfo.Signature; + if (!CryptImportPublicKeyInfoEx(prov, X509_ASN_ENCODING, (CERT_PUBLIC_KEY_INFO *)&issuer->SubjectPublicKeyInfo, + 0, 0, NULL, &key)) + { + error = GetLastError(); + TRACE("failed to import public key %#lx\n", error); + } + else if (!CryptVerifySignatureW(hash, sig->pbData, sig->cbData, key, NULL, 0)) + { + error = GetLastError(); + TRACE("failed to verify signature %#lx\n", error); + } + else error = ERROR_SUCCESS; + +done: + CryptDestroyKey(key); + CryptDestroyHash(hash); + CryptReleaseContext(prov, 0); + LocalFree(info); + if (error) return error; + return status; +} + +static DWORD handle_ocsp_response(const CERT_INFO *cert, const CERT_INFO *issuer, const BYTE *encoded, + DWORD encoded_size) +{ + OCSP_RESPONSE_INFO *info; + DWORD size, error = CRYPT_E_NO_REVOCATION_CHECK; + + if (!CryptDecodeObjectEx(X509_ASN_ENCODING, OCSP_RESPONSE, encoded, encoded_size, CRYPT_DECODE_ALLOC_FLAG, NULL, + &info, &size)) return GetLastError(); + + switch (info->dwStatus) + { + case OCSP_SUCCESSFUL_RESPONSE: + if (!info->pszObjId || strcmp(info->pszObjId, szOID_PKIX_OCSP_BASIC_SIGNED_RESPONSE)) + { + FIXME("unhandled response type %s\n", debugstr_a(info->pszObjId)); + break; + } + error = verify_signed_ocsp_response_info(cert, issuer, &info->Value); + break; + + default: + FIXME("unhandled status %lu\n", info->dwStatus); + break; + } + + LocalFree(info); + return error; +} + +static DWORD verify_cert_revocation_with_ocsp(const CERT_CONTEXT *cert, const WCHAR *base_url, + const CERT_REVOCATION_PARA *revpara) +{ + HINTERNET ses, con, req = NULL; + BYTE *request_data = NULL, *response_data = NULL; + DWORD size, flags, status, request_len, response_len, count, ret = CRYPT_E_REVOCATION_OFFLINE; + URL_COMPONENTSW comp; + WCHAR *url; + + if (!revpara || !revpara->pIssuerCert) + { + TRACE("no issuer certificate\n"); + return CRYPT_E_REVOCATION_OFFLINE; + } + if (!(request_data = build_ocsp_request(cert, revpara->pIssuerCert, &request_len))) + return CRYPT_E_REVOCATION_OFFLINE; + + url = build_request_url(base_url, request_data, request_len); + LocalFree(request_data); + if (!url) return CRYPT_E_REVOCATION_OFFLINE; + + memset(&comp, 0, sizeof(comp)); + comp.dwStructSize = sizeof(comp); + comp.dwHostNameLength = ~0u; + comp.dwUrlPathLength = ~0u; + if (!InternetCrackUrlW(url, 0, 0, &comp)) + { + free(url); + return CRYPT_E_REVOCATION_OFFLINE; + } + + switch (comp.nScheme) + { + case INTERNET_SCHEME_HTTP: + flags = 0; + break; + case INTERNET_SCHEME_HTTPS: + flags = INTERNET_FLAG_SECURE; + break; + default: + FIXME("scheme %u not supported\n", comp.nScheme); + free(url); + return ERROR_NOT_SUPPORTED; + } + + if (!(ses = InternetOpenW(L"CryptoAPI", 0, NULL, NULL, 0))) return GetLastError(); + comp.lpszHostName[comp.dwHostNameLength] = 0; + if (!(con = InternetConnectW(ses, comp.lpszHostName, comp.nPort, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0))) + { + free(url); + InternetCloseHandle(ses); + return GetLastError(); + } + comp.lpszHostName[comp.dwHostNameLength] = '/'; + if (!(req = HttpOpenRequestW(con, NULL, comp.lpszUrlPath, NULL, NULL, NULL, flags, 0)) || + !HttpSendRequestW(req, NULL, 0, NULL, 0)) goto done; + + size = sizeof(status); + if (!HttpQueryInfoW(req, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL)) goto done; + if (status != HTTP_STATUS_OK) + { + WARN("request status %lu\n", status); + goto done; + } + + size = sizeof(response_len); + if (!HttpQueryInfoW(req, HTTP_QUERY_FLAG_NUMBER | HTTP_QUERY_CONTENT_LENGTH, &response_len, &size, 0) || + !response_len || !(response_data = malloc(response_len)) || + !InternetReadFile(req, response_data, response_len, &count) || count != response_len) goto done; + + ret = handle_ocsp_response(cert->pCertInfo, revpara->pIssuerCert->pCertInfo, response_data, response_len); + +done: + free(url); + free(response_data); + InternetCloseHandle(req); + InternetCloseHandle(con); + InternetCloseHandle(ses); + return ret; +} + static DWORD verify_cert_revocation_from_aia_ext(const CRYPT_DATA_BLOB *value, const CERT_CONTEXT *cert, FILETIME *pTime, DWORD dwFlags, CERT_REVOCATION_PARA *pRevPara, CERT_REVOCATION_STATUS *pRevStatus) { BOOL ret; - DWORD error, size; + DWORD size, i, error = CRYPT_E_NO_REVOCATION_CHECK; CERT_AUTHORITY_INFO_ACCESS *aia; - ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_AUTHORITY_INFO_ACCESS, - value->pbData, value->cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &aia, &size); - if (ret) - { - DWORD i; + ret = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_AUTHORITY_INFO_ACCESS, value->pbData, value->cbData, + CRYPT_DECODE_ALLOC_FLAG, NULL, &aia, &size); + if (!ret) return GetLastError(); - for (i = 0; i < aia->cAccDescr; i++) - if (!strcmp(aia->rgAccDescr[i].pszAccessMethod, - szOID_PKIX_OCSP)) + for (i = 0; i < aia->cAccDescr; i++) + { + if (!strcmp(aia->rgAccDescr[i].pszAccessMethod, szOID_PKIX_OCSP)) + { + if (aia->rgAccDescr[i].AccessLocation.dwAltNameChoice == CERT_ALT_NAME_URL) { - if (aia->rgAccDescr[i].AccessLocation.dwAltNameChoice == - CERT_ALT_NAME_URL) - FIXME("OCSP URL = %s\n", - debugstr_w(aia->rgAccDescr[i].AccessLocation.u.pwszURL)); - else - FIXME("unsupported AccessLocation type %ld\n", - aia->rgAccDescr[i].AccessLocation.dwAltNameChoice); + const WCHAR *url = aia->rgAccDescr[i].AccessLocation.u.pwszURL; + TRACE("OCSP URL = %s\n", debugstr_w(url)); + error = verify_cert_revocation_with_ocsp(cert, url, pRevPara); } - LocalFree(aia); - /* FIXME: lie and pretend OCSP validated the cert */ - error = ERROR_SUCCESS; + else + { + FIXME("unsupported AccessLocation type %lu\n", aia->rgAccDescr[i].AccessLocation.dwAltNameChoice); + error = ERROR_NOT_SUPPORTED; + } + break; + } } - else - error = GetLastError(); + + LocalFree(aia); return error; } diff --git a/include/wincrypt.h b/include/wincrypt.h index f5f05c1f8d0..2c1e3f0d4c3 100644 --- a/include/wincrypt.h +++ b/include/wincrypt.h @@ -669,6 +669,10 @@ typedef struct _OCSP_BASIC_REVOKED_INFO { DWORD dwCrlReasonCode; } OCSP_BASIC_REVOKED_INFO, *POCSP_BASIC_REVOKED_INFO; +#define OCSP_BASIC_GOOD_CERT_STATUS 0 +#define OCSP_BASIC_REVOKED_CERT_STATUS 1 +#define OCSP_BASIC_UNKNOWN_CERT_STATUS 2 + typedef struct _OCSP_BASIC_RESPONSE_ENTRY { OCSP_CERT_ID CertId; DWORD dwCertStatus; -- 2.30.2
participants (1)
-
Hans Leidekker