从 WinCrypt 到 OpenSSL：构建 PESignAnalyzer 跨平台版本

const std::size_t length = reader.u32(cursor);
if (length < 8) {
    throw ParseError("WIN_CERTIFICATE length is smaller than its header");
}
if (length > table_end - cursor) {
    throw ParseError("WIN_CERTIFICATE extends beyond the certificate table");
}
// Round using the remaining length, without length + 7 overflow.
const std::size_t padding = (8 - (length & 7U)) & 7U;
if (padding > table_end - cursor - length) {
    throw ParseError("WIN_CERTIFICATE alignment padding exceeds the certificate table");
}

const auto hash = [&](std::size_t start, std::size_t end) {
    if (end < start) throw ParseError("Invalid Authenticode digest interval");
    layout.require(start, end - start);
    if (end > start &&
        EVP_DigestUpdate(context.get(), bytes.data() + start, end - start) != 1)
        throw ParseError("Cannot update Authenticode digest");
};
hash(0, checksum);
if (has_security) {
    hash(checksum + 4, security);
    hash(security + 8, cert_size ? cert_offset : bytes.size());
} else hash(checksum + 4, bytes.size());
if (cert_size) {
    hash(cert_offset + cert_size, bytes.size());
}

bool signed_content(PKCS7* p7, Bytes& encoded, Bytes& content) {
    PKCS7* inner = p7 && p7->d.sign ? p7->d.sign->contents : nullptr;
    if (!inner) return false;
    if (PKCS7_type_is_data(inner)) {
        encoded = content = bytes(inner->d.data);
        return encoded.data != nullptr;
    }
    if (!PKCS7_type_is_other(inner) || !inner->d.other) return false;
    encoded = attribute_bytes(inner->d.other);
    if (!encoded.data || encoded.size > max_payload) return false;
    if (inner->d.other->type == V_ASN1_SEQUENCE)
        return sequence_body(encoded, content);
    if (inner->d.other->type == V_ASN1_OCTET_STRING) {
        content = encoded;
        return true;
    }
    return false;
}

ESS routines::ess cert id not found

if (!check_ess(signer, chain, true)) {
    // ... 写入首项绑定失败的诊断。
    return result;
}
ERR_clear_error();
if (!check_ess(signer, chain, false)) {
    const std::string error = errors();
    if (enforce_all_ess) {
        // ... 写入严格模式的失败诊断。
        return result;
    }
    // ... Microsoft 兼容分支记录 error，说明额外引用未能核验。
}

void finalize(Verification& verification) {
    const bool timestamp = verification.timestamp == "valid" ||
                           verification.timestamp == "absent";
    const bool valid = verification.content_digest == "valid" &&
        verification.cms_signature == "valid" &&
        verification.certificate_chain == "trusted" && timestamp &&
        verification.revocation != "revoked";
    verification.overall = !valid ? "invalid" :
        verification.revocation == "unknown" ? "indeterminate" : "valid";
}

const auto set = [&](CURLoption option, auto value) {
    if (curl_easy_setopt(handle.get(), option, value) != CURLE_OK)
        configured = false;
};
// ... 省略 URL、超时等配置。
set(CURLOPT_SSL_VERIFYPEER, 1L);
set(CURLOPT_SSL_VERIFYHOST, 2L);
#if defined(_WIN32) && defined(CURLSSLOPT_NATIVE_CA)
// Use Windows trust roots even when the curl DLL is distributed without
// its original installation's CA bundle.
set(CURLOPT_SSL_OPTIONS, static_cast<long>(CURLSSLOPT_NATIVE_CA));
#endif

content type is not Authenticode SpcIndirectDataContent: 1.3.6.1.4.1.311.10.1

bool match = false;
std::size_t entries_cursor = 0, entries = 0;
while (entries_cursor < field.body.size) {
    Element entry, identifier, attributes;
    if (++entries > 100000 || !next(field.body, entries_cursor, entry) ||
        entry.tag != 0x30) return false;
    std::size_t entry_cursor = 0;
    if (!next(entry.body, entry_cursor, identifier) || identifier.tag != 4 ||
        !next(entry.body, entry_cursor, attributes) || attributes.tag != 0x31 ||
        entry_cursor != entry.body.size) return false;
    // Only CTLEntry subjectIdentifier may match; unrelated OCTET STRINGs
    // in attributes, certificates or unsigned data can never satisfy this.
    if (identifier.body.size == digest.size() &&
        std::equal(digest.begin(), digest.end(), identifier.body.data)) match = true;
}
return match;

Microsoft Windows
  → Microsoft Windows Production PCA 2011
    → Microsoft Root Certificate Authority 2010

bool metadata_issuer_matches(X509* issuer, X509* certificate) {
    // Metadata describes a cryptographic issuer relationship, including chains
    // whose certificate usage would not permit verification of code signatures.
    const auto issued = X509_check_issued(issuer, certificate);
    if (issued != X509_V_OK && issued != X509_V_ERR_KEYUSAGE_NO_CERTSIGN)
        return false;
    auto* key = X509_get0_pubkey(issuer);
    const bool verified = key && X509_verify(certificate, key) == 1;
    ERR_clear_error();
    return verified;
}