VirtualBox

Ignore:
Timestamp:
Oct 12, 2020 11:59:53 PM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
140868
Message:

SUPHardNt,IPRT: If there are nested signatures (i.e. more than one signature), don't get grumpy if there are time or cert path issues with some of them, as long as one or more checks out perfectly. (Mind, all the signature data must check out, it's just the cert path or signing time we're relaxing here.) ticketref:19743 bugref:3103

Location:
trunk/src/VBox/HostDrivers/Support
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostDrivers/Support/darwin/SUPDrv-darwin.cpp

    r85172 r86549  
    13531353 * @callback_method_impl{FNRTLDRVALIDATESIGNEDDATA}
    13541354 */
    1355 static DECLCALLBACK(int) supdrvDarwinLdrOpenVerifyCallback(RTLDRMOD hLdrMod, RTLDRSIGNATURETYPE enmSignature,
    1356                                                            void const *pvSignature, size_t cbSignature,
    1357                                                            void const *pvExternalData, size_t cbExternalData,
     1355static DECLCALLBACK(int) supdrvDarwinLdrOpenVerifyCallback(RTLDRMOD hLdrMod, PCRTLDRSIGNATUREINFO pInfo,
    13581356                                                           PRTERRINFO pErrInfo, void *pvUser)
    13591357{
    13601358    PSUPDRVDEVEXT pDevExt = (PSUPDRVDEVEXT)pvUser;
    1361     RT_NOREF_PV(hLdrMod); RT_NOREF_PV(cbSignature);
    1362 
    1363     switch (enmSignature)
     1359    RT_NOREF_PV(hLdrMod);
     1360
     1361    switch (pInfo->enmType)
    13641362    {
    13651363        case RTLDRSIGNATURETYPE_PKCS7_SIGNED_DATA:
    1366             if (pvExternalData)
     1364            if (pInfo->pvExternalData)
    13671365            {
    1368                 PCRTCRPKCS7CONTENTINFO pContentInfo = (PCRTCRPKCS7CONTENTINFO)pvSignature;
     1366                PCRTCRPKCS7CONTENTINFO pContentInfo = (PCRTCRPKCS7CONTENTINFO)pInfo->pvSignature;
    13691367                RTTIMESPEC             ValidationTime;
    13701368                RTTimeNow(&ValidationTime);
    … …  
    13761374                                                                 pDevExt->hAdditionalStore, pDevExt->hRootStore, &ValidationTime,
    13771375                                                                 supdrvDarwinLdrOpenVerifyCertificatCallback, pDevExt,
    1378                                                                  pvExternalData, cbExternalData, pErrInfo);
     1376                                                                 pInfo->pvExternalData, pInfo->cbExternalData, pErrInfo);
    13791377            }
    13801378            return RTErrInfoSetF(pErrInfo, VERR_NOT_SUPPORTED, "Expected external data with signature!");
    13811379
    13821380        default:
    1383             return RTErrInfoSetF(pErrInfo, VERR_NOT_SUPPORTED, "Unsupported signature type: %d", enmSignature);
     1381            return RTErrInfoSetF(pErrInfo, VERR_NOT_SUPPORTED, "Unsupported signature type: %d", pInfo->enmType);
    13841382    }
    13851383}

  • trunk/src/VBox/HostDrivers/Support/win/SUPHardenedVerify-win.h

    r85127 r86549  
    9898    /** The file handle. */
    9999    HANDLE      hFile;
    100     /** Handle to event sempahore in case we're force to deal with asynchronous
    101      * I/O. */
     100    /** Handle to event sempahore in case we're force to deal with asynchronous I/O. */
    102101    HANDLE      hEvent;
    103102    /** Current file offset. */
    … …  
    107106    /** Flags for the verification callback, SUPHNTVI_F_XXX. */
    108107    uint32_t    fFlags;
    109     /** The executable timstamp in second since unix epoch. */
    110     uint64_t    uTimestamp;
     108    /** Number of signatures that verified okay. */
     109    uint16_t    cOkaySignatures;
     110    /** Number of signatures that couldn't be successfully verified (time stamp
     111     * issues, no certificate path, etc) but weren't fatal. */
     112    uint16_t    cNokSignatures;
     113    /** Total number of signatures. */
     114    uint16_t    cTotalSignatures;
     115    /** The last non-fatal signature failure. */
     116    int         rcLastSignatureFailure;
    111117    /** Log name. */
    112118    char        szFilename[1];

  • trunk/src/VBox/HostDrivers/Support/win/SUPHardenedVerifyImage-win.cpp

    r85127 r86549  
    10591059
    10601060
    1061 static DECLCALLBACK(int) supHardNtViCallback(RTLDRMOD hLdrMod, RTLDRSIGNATURETYPE enmSignature,
    1062                                              void const *pvSignature, size_t cbSignature,
    1063                                              void const *pvExternalData, size_t cbExternalData,
    1064                                              PRTERRINFO pErrInfo, void *pvUser)
    1065 {
    1066     RT_NOREF(hLdrMod, enmSignature, pvExternalData, cbExternalData);
     1061/**
     1062 * RTTimeNow equivaltent that handles ring-3 where we cannot use it.
     1063 *
     1064 * @returns pNow
     1065 * @param   pNow                Where to return the current time.
     1066 */
     1067static PRTTIMESPEC supHardNtTimeNow(PRTTIMESPEC pNow)
     1068{
     1069#ifdef IN_RING3
     1070    /*
     1071     * Just read system time.
     1072     */
     1073    KUSER_SHARED_DATA volatile *pUserSharedData = (KUSER_SHARED_DATA volatile *)MM_SHARED_USER_DATA_VA;
     1074# ifdef RT_ARCH_AMD64
     1075    uint64_t uRet = *(uint64_t volatile *)&pUserSharedData->SystemTime; /* This is what KeQuerySystemTime does (missaligned). */
     1076    return RTTimeSpecSetNtTime(pNow, uRet);
     1077# else
     1078
     1079    LARGE_INTEGER NtTime;
     1080    do
     1081    {
     1082        NtTime.HighPart = pUserSharedData->SystemTime.High1Time;
     1083        NtTime.LowPart  = pUserSharedData->SystemTime.LowPart;
     1084    } while (pUserSharedData->SystemTime.High2Time != NtTime.HighPart);
     1085    return RTTimeSpecSetNtTime(pNow, NtTime.QuadPart);
     1086# endif
     1087#else  /* IN_RING0 */
     1088    return RTTimeNow(pNow);
     1089#endif /* IN_RING0 */
     1090}
     1091
     1092
     1093/**
     1094 * @callback_method_impl{FNRTLDRVALIDATESIGNEDDATA}
     1095 */
     1096static DECLCALLBACK(int) supHardNtViCallback(RTLDRMOD hLdrMod, PCRTLDRSIGNATUREINFO pInfo, PRTERRINFO pErrInfo, void *pvUser)
     1097{
     1098    RT_NOREF(hLdrMod);
    10671099
    10681100    /*
    … …  
    10711103    PSUPHNTVIRDR pNtViRdr = (PSUPHNTVIRDR)pvUser;
    10721104    Assert(pNtViRdr->Core.uMagic == RTLDRREADER_MAGIC);
    1073 
    1074     AssertReturn(cbSignature == sizeof(RTCRPKCS7CONTENTINFO), VERR_INTERNAL_ERROR_5);
    1075     PCRTCRPKCS7CONTENTINFO pContentInfo = (PCRTCRPKCS7CONTENTINFO)pvSignature;
     1105    pNtViRdr->cTotalSignatures = pInfo->cSignatures;
     1106
     1107    AssertReturn(pInfo->enmType == RTLDRSIGNATURETYPE_PKCS7_SIGNED_DATA, VERR_INTERNAL_ERROR_5);
     1108    AssertReturn(!pInfo->pvExternalData, VERR_INTERNAL_ERROR_5);
     1109    AssertReturn(pInfo->cbSignature == sizeof(RTCRPKCS7CONTENTINFO), VERR_INTERNAL_ERROR_5);
     1110    PCRTCRPKCS7CONTENTINFO pContentInfo = (PCRTCRPKCS7CONTENTINFO)pInfo->pvSignature;
    10761111    AssertReturn(RTCrPkcs7ContentInfo_IsSignedData(pContentInfo), VERR_INTERNAL_ERROR_5);
    10771112    AssertReturn(pContentInfo->u.pSignedData->SignerInfos.cItems == 1, VERR_INTERNAL_ERROR_5);
    10781113    PCRTCRPKCS7SIGNERINFO pSignerInfo = pContentInfo->u.pSignedData->SignerInfos.papItems[0];
    10791114
    1080     AssertReturn(!pvExternalData, VERR_INTERNAL_ERROR_5);
    10811115
    10821116    /*
    10831117     * If special certificate requirements, check them out before validating
    1084      * the signature.
    1085      */
    1086     if (pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_BUILD_CERT)
     1118     * the signature.  These only apply to the first signature (for now).
     1119     */
     1120    if (   (pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_BUILD_CERT)
     1121        && pInfo->iSignature == 0)
    10871122    {
    10881123        if (!RTCrX509Certificate_MatchIssuerAndSerialNumber(&g_BuildX509Cert,
    … …  
    10981133
    10991134    /*
    1100      * Verify the signature.  We instruct the verifier to use the signing time
    1101      * counter signature present when present, falling back on the timestamp
    1102      * planted by the linker when absent.  In ring-0 we don't have all the
    1103      * necessary timestamp server root certificate info, so we have to allow
    1104      * using counter signatures unverified there.  Ditto for the early period
    1105      * of ring-3 hardened stub execution.
    1106      */
    1107     RTTIMESPEC ValidationTime;
    1108     RTTimeSpecSetSeconds(&ValidationTime, pNtViRdr->uTimestamp);
    1109 
     1135     * We instruction the verifier to use the signing time counter signature
     1136     * when present, but provides the linker time then the current time as
     1137     * fallbacks should the timestamp be missing or unusable.
     1138     *
     1139     * Update: Save the first timestamp we validate with build cert and
     1140     *         use this as a minimum timestamp for further build cert
     1141     *         validations.  This works around issues with old DLLs that
     1142     *         we sign against with our certificate (crt, sdl, qt).
     1143     *
     1144     * Update: If the validation fails, retry with the current timestamp. This
     1145     *         is a workaround for NTDLL.DLL in build 14971 having a weird
     1146     *         timestamp: 0xDF1E957E (Sat Aug 14 14:05:18 2088).
     1147     */
    11101148    uint32_t fFlags = RTCRPKCS7VERIFY_SD_F_ALWAYS_USE_SIGNING_TIME_IF_PRESENT
    11111149                    | RTCRPKCS7VERIFY_SD_F_ALWAYS_USE_MS_TIMESTAMP_IF_PRESENT
    11121150                    | RTCRPKCS7VERIFY_SD_F_COUNTER_SIGNATURE_SIGNING_TIME_ONLY;
     1151
     1152    /* In ring-0 we don't have all the necessary timestamp server root certificate
     1153     * info, so we have to allow using counter signatures unverified there.
     1154     * Ditto for the early period of ring-3 hardened stub execution. */
    11131155#ifndef IN_RING0
    11141156    if (!g_fHaveOtherRoots)
    11151157#endif
    11161158        fFlags |= RTCRPKCS7VERIFY_SD_F_USE_SIGNING_TIME_UNVERIFIED | RTCRPKCS7VERIFY_SD_F_USE_MS_TIMESTAMP_UNVERIFIED;
    1117     return RTCrPkcs7VerifySignedData(pContentInfo, fFlags, g_hSpcAndNtKernelSuppStore, g_hSpcAndNtKernelRootStore,
    1118                                      &ValidationTime, supHardNtViCertVerifyCallback, pNtViRdr, pErrInfo);
    1119 }
    1120 
    1121 
    1122 /**
    1123  * RTTimeNow equivaltent that handles ring-3 where we cannot use it.
    1124  *
    1125  * @returns pNow
    1126  * @param   pNow                Where to return the current time.
    1127  */
    1128 static PRTTIMESPEC supHardNtTimeNow(PRTTIMESPEC pNow)
    1129 {
    1130 #ifdef IN_RING3
    1131     /*
    1132      * Just read system time.
    1133      */
    1134     KUSER_SHARED_DATA volatile *pUserSharedData = (KUSER_SHARED_DATA volatile *)MM_SHARED_USER_DATA_VA;
    1135 # ifdef RT_ARCH_AMD64
    1136     uint64_t uRet = *(uint64_t volatile *)&pUserSharedData->SystemTime; /* This is what KeQuerySystemTime does (missaligned). */
    1137     return RTTimeSpecSetNtTime(pNow, uRet);
    1138 # else
    1139 
    1140     LARGE_INTEGER NtTime;
    1141     do
    1142     {
    1143         NtTime.HighPart = pUserSharedData->SystemTime.High1Time;
    1144         NtTime.LowPart  = pUserSharedData->SystemTime.LowPart;
    1145     } while (pUserSharedData->SystemTime.High2Time != NtTime.HighPart);
    1146     return RTTimeSpecSetNtTime(pNow, NtTime.QuadPart);
    1147 # endif
    1148 #else  /* IN_RING0 */
    1149     return RTTimeNow(pNow);
    1150 #endif /* IN_RING0 */
     1159
     1160    /* Fallback timestamps to try: */
     1161    struct { RTTIMESPEC TimeSpec; const char *pszDesc; } aTimes[2];
     1162    unsigned cTimes = 0;
     1163
     1164    /* 1. The linking timestamp: */
     1165    uint64_t uTimestamp = 0;
     1166    int rc = RTLdrQueryProp(hLdrMod, RTLDRPROP_TIMESTAMP_SECONDS, &uTimestamp, sizeof(uTimestamp));
     1167    if (RT_SUCCESS(rc))
     1168    {
     1169#ifdef IN_RING3 /* Hack alert! (see above) */
     1170        if (   (pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_KERNEL_CODE_SIGNING)
     1171            && (pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_SIGNATURE_ENFORCEMENT)
     1172            && uTimestamp < g_uBuildTimestampHack)
     1173            uTimestamp = g_uBuildTimestampHack;
     1174#endif
     1175        RTTimeSpecSetSeconds(&aTimes[0].TimeSpec, uTimestamp);
     1176        aTimes[0].pszDesc = "link";
     1177        cTimes++;
     1178    }
     1179    else
     1180        SUP_DPRINTF(("RTLdrQueryProp/RTLDRPROP_TIMESTAMP_SECONDS failed on %s: %Rrc", pNtViRdr->szFilename, rc));
     1181
     1182    /* 2. Current time. */
     1183    supHardNtTimeNow(&aTimes[cTimes].TimeSpec);
     1184    aTimes[cTimes].pszDesc = "now";
     1185    cTimes++;
     1186
     1187    /* Make the verfication attempts. */
     1188    for (unsigned i = 0; ; i++)
     1189    {
     1190        Assert(i < cTimes);
     1191        rc = RTCrPkcs7VerifySignedData(pContentInfo, fFlags, g_hSpcAndNtKernelSuppStore, g_hSpcAndNtKernelRootStore,
     1192                                       &aTimes[i].TimeSpec, supHardNtViCertVerifyCallback, pNtViRdr, pErrInfo);
     1193        if (RT_SUCCESS(rc))
     1194        {
     1195            if (rc != VINF_SUCCESS)
     1196            {
     1197                SUP_DPRINTF(("%s: Signature #%u/%u: info status: %d\n", pNtViRdr->szFilename, pInfo->iSignature, pInfo->cbSignature, rc));
     1198                if (pNtViRdr->rcLastSignatureFailure == VINF_SUCCESS)
     1199                    pNtViRdr->rcLastSignatureFailure = rc;
     1200            }
     1201            pNtViRdr->cOkaySignatures++;
     1202
     1203#ifdef IN_RING3 /* Hack alert! (see above) */
     1204            if ((pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_BUILD_CERT) && g_uBuildTimestampHack == 0 && cTimes > 1)
     1205                g_uBuildTimestampHack = uTimestamp;
     1206#endif
     1207            return VINF_SUCCESS;
     1208        }
     1209
     1210        if (rc == VERR_CR_X509_CPV_NOT_VALID_AT_TIME && i + 1 < cTimes)
     1211            SUP_DPRINTF(("%s: Signature #%u/%u: VERR_CR_X509_CPV_NOT_VALID_AT_TIME for %#RX64; retrying against current time: %#RX64.\n",
     1212                         pNtViRdr->szFilename, pInfo->iSignature, pInfo->cbSignature,
     1213                         RTTimeSpecGetSeconds(&aTimes[0].TimeSpec), RTTimeSpecGetSeconds(&aTimes[1].TimeSpec)));
     1214        else
     1215        {
     1216            /* There are a couple of failures we can tollerate if there are more than
     1217               one signature and one of them works out fine.  The RTLdrVerifySignature
     1218               caller will have to check the failure counts though to make sure
     1219               something succeeded. */
     1220            pNtViRdr->rcLastSignatureFailure = rc;
     1221            if (   rc == VERR_CR_X509_CPV_NOT_VALID_AT_TIME
     1222                || rc == VERR_CR_X509_CPV_NO_TRUSTED_PATHS)
     1223            {
     1224                SUP_DPRINTF(("%s: Signature #%u/%u: %s (%d) w/ timestamp=%#RX64/%s.\n", pNtViRdr->szFilename, pInfo->iSignature, pInfo->cbSignature,
     1225                             rc == VERR_CR_X509_CPV_NOT_VALID_AT_TIME ? "VERR_CR_X509_CPV_NOT_VALID_AT_TIME" : "VERR_CR_X509_CPV_NO_TRUSTED_PATHS", rc,
     1226                             RTTimeSpecGetSeconds(&aTimes[i].TimeSpec), aTimes[i].pszDesc));
     1227
     1228                /* This leniency is not applicable to build certificate requirements (signature #1 only). */
     1229                if (  !(pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_BUILD_CERT)
     1230                    || pInfo->iSignature != 0)
     1231                {
     1232                    pNtViRdr->cNokSignatures++;
     1233                    rc = VINF_SUCCESS;
     1234                }
     1235            }
     1236            else
     1237                SUP_DPRINTF(("%s: Signature #%u/%u: %Rrc w/ timestamp=%#RX64/%s.\n", pNtViRdr->szFilename, pInfo->iSignature, pInfo->cbSignature,
     1238                             rc, RTTimeSpecGetSeconds(&aTimes[i].TimeSpec), aTimes[i].pszDesc));
     1239            return rc;
     1240        }
     1241    }
    11511242}
    11521243
    … …  
    12221313     * The PKCS #7 SignedData signature is checked in the callback. Any
    12231314     * signing certificate restrictions are also enforced there.
    1224      *
    1225      * For the time being, we use the executable timestamp as the
    1226      * certificate validation date.  We must query that first to avoid
    1227      * potential issues re-entering the loader code from the callback.
    1228      *
    1229      * Update: Save the first timestamp we validate with build cert and
    1230      *         use this as a minimum timestamp for further build cert
    1231      *         validations.  This works around issues with old DLLs that
    1232      *         we sign against with our certificate (crt, sdl, qt).
    1233      *
    1234      * Update: If the validation fails, retry with the current timestamp. This
    1235      *         is a workaround for NTDLL.DLL in build 14971 having a weird
    1236      *         timestamp: 0xDF1E957E (Sat Aug 14 14:05:18 2088).
    1237      */
    1238     int rc = RTLdrQueryProp(hLdrMod, RTLDRPROP_TIMESTAMP_SECONDS, &pNtViRdr->uTimestamp, sizeof(pNtViRdr->uTimestamp));
     1315     */
     1316    pNtViRdr->cOkaySignatures        = 0;
     1317    pNtViRdr->cNokSignatures         = 0;
     1318    pNtViRdr->cTotalSignatures       = 0;
     1319    pNtViRdr->rcLastSignatureFailure = VINF_SUCCESS;
     1320    int rc = RTLdrVerifySignature(hLdrMod, supHardNtViCallback, pNtViRdr, pErrInfo);
    12391321    if (RT_SUCCESS(rc))
    12401322    {
    1241 #ifdef IN_RING3 /* Hack alert! (see above) */
    1242         if (   (pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_KERNEL_CODE_SIGNING)
    1243             && (pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_SIGNATURE_ENFORCEMENT)
    1244             && pNtViRdr->uTimestamp < g_uBuildTimestampHack)
    1245             pNtViRdr->uTimestamp = g_uBuildTimestampHack;
    1246 #endif
    1247 
    1248         rc = RTLdrVerifySignature(hLdrMod, supHardNtViCallback, pNtViRdr, pErrInfo);
    1249 
    1250 #ifdef IN_RING3 /* Hack alert! (see above) */
    1251         if ((pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_BUILD_CERT) && g_uBuildTimestampHack == 0 && RT_SUCCESS(rc))
    1252             g_uBuildTimestampHack = pNtViRdr->uTimestamp;
    1253 #endif
    1254 
    1255         if (rc == VERR_CR_X509_CPV_NOT_VALID_AT_TIME)
     1323        Assert(pNtViRdr->cOkaySignatures + pNtViRdr->cNokSignatures == pNtViRdr->cTotalSignatures);
     1324        if (   !pNtViRdr->cOkaySignatures
     1325            || pNtViRdr->cOkaySignatures + pNtViRdr->cNokSignatures < pNtViRdr->cTotalSignatures /* paranoia */)
    12561326        {
    1257             RTTIMESPEC Now;
    1258             uint64_t uOld = pNtViRdr->uTimestamp;
    1259             pNtViRdr->uTimestamp = RTTimeSpecGetSeconds(supHardNtTimeNow(&Now));
    1260             SUP_DPRINTF(("%ls: VERR_CR_X509_CPV_NOT_VALID_AT_TIME for %#RX64; retrying against current time: %#RX64.\n",
    1261                          pwszName, uOld, pNtViRdr->uTimestamp)); NOREF(uOld);
    1262             rc = RTLdrVerifySignature(hLdrMod, supHardNtViCallback, pNtViRdr, pErrInfo);
     1327            rc = pNtViRdr->rcLastSignatureFailure;
     1328            AssertStmt(RT_FAILURE_NP(rc), rc = VERR_INTERNAL_ERROR_3);
    12631329        }
    1264 
    1265         /*
    1266          * Microsoft doesn't sign a whole bunch of DLLs, so we have to
    1267          * ASSUME that a bunch of system DLLs are fine.
    1268          */
    1269         if (rc == VERR_LDRVI_NOT_SIGNED)
    1270             rc = supHardNtViCheckIfNotSignedOk(hLdrMod, pwszName, pNtViRdr->fFlags, pNtViRdr->hFile, rc);
    1271         if (RT_FAILURE(rc))
    1272             RTErrInfoAddF(pErrInfo, rc, ": %ls", pwszName);
    1273 
    1274         /*
    1275          * Check for the signature checking enforcement, if requested to do so.
    1276          */
    1277         if (RT_SUCCESS(rc) && (pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_SIGNATURE_ENFORCEMENT))
    1278         {
    1279             bool fEnforced = false;
    1280             int rc2 = RTLdrQueryProp(hLdrMod, RTLDRPROP_SIGNATURE_CHECKS_ENFORCED, &fEnforced, sizeof(fEnforced));
    1281             if (RT_FAILURE(rc2))
    1282                 rc = RTErrInfoSetF(pErrInfo, rc2, "Querying RTLDRPROP_SIGNATURE_CHECKS_ENFORCED failed on %ls: %Rrc.",
    1283                                    pwszName, rc2);
    1284             else if (!fEnforced)
    1285                 rc = RTErrInfoSetF(pErrInfo, VERR_SUP_VP_SIGNATURE_CHECKS_NOT_ENFORCED,
    1286                                    "The image '%ls' was not linked with /IntegrityCheck.", pwszName);
    1287         }
    1288     }
    1289     else
    1290         RTErrInfoSetF(pErrInfo, rc, "RTLdrQueryProp/RTLDRPROP_TIMESTAMP_SECONDS failed on %ls: %Rrc", pwszName, rc);
     1330        else if (rc == VINF_SUCCESS && RT_SUCCESS(pNtViRdr->rcLastSignatureFailure))
     1331            rc = pNtViRdr->rcLastSignatureFailure;
     1332    }
     1333
     1334    /*
     1335     * Microsoft doesn't sign a whole bunch of DLLs, so we have to
     1336     * ASSUME that a bunch of system DLLs are fine.
     1337     */
     1338    if (rc == VERR_LDRVI_NOT_SIGNED)
     1339        rc = supHardNtViCheckIfNotSignedOk(hLdrMod, pwszName, pNtViRdr->fFlags, pNtViRdr->hFile, rc);
     1340    if (RT_FAILURE(rc))
     1341        RTErrInfoAddF(pErrInfo, rc, ": %ls", pwszName);
     1342
     1343    /*
     1344     * Check for the signature checking enforcement, if requested to do so.
     1345     */
     1346    if (RT_SUCCESS(rc) && (pNtViRdr->fFlags & SUPHNTVI_F_REQUIRE_SIGNATURE_ENFORCEMENT))
     1347    {
     1348        bool fEnforced = false;
     1349        int rc2 = RTLdrQueryProp(hLdrMod, RTLDRPROP_SIGNATURE_CHECKS_ENFORCED, &fEnforced, sizeof(fEnforced));
     1350        if (RT_FAILURE(rc2))
     1351            rc = RTErrInfoSetF(pErrInfo, rc2, "Querying RTLDRPROP_SIGNATURE_CHECKS_ENFORCED failed on %ls: %Rrc.",
     1352                               pwszName, rc2);
     1353        else if (!fEnforced)
     1354            rc = RTErrInfoSetF(pErrInfo, VERR_SUP_VP_SIGNATURE_CHECKS_NOT_ENFORCED,
     1355                               "The image '%ls' was not linked with /IntegrityCheck.", pwszName);
     1356    }
    12911357
    12921358#ifdef IN_RING3
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette