gecko-dev/security/ct/CTPolicyEnforcer.cpp

278 lines
10 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "CTPolicyEnforcer.h"
#include <algorithm>
#include <stdint.h>
#include <vector>
namespace mozilla {
namespace ct {
using namespace mozilla::pkix;
// Returns the number of embedded SCTs required to be present on a
// certificate for Qualification Case #2 (embedded SCTs).
static size_t GetRequiredEmbeddedSctsCount(
size_t certLifetimeInFullCalendarMonths) {
// "there are Embedded SCTs from AT LEAST N+1 once or currently qualified
// logs, where N is the lifetime of the certificate in years (normally
// rounding up, but rounding down when up to 3 months over), and must be
// at least 1"
return 1 + (certLifetimeInFullCalendarMonths + 9) / 12;
}
// Whether a valid embedded SCT is present in the list.
static bool HasValidEmbeddedSct(const VerifiedSCTList& verifiedScts) {
for (const VerifiedSCT& verifiedSct : verifiedScts) {
if (verifiedSct.status == VerifiedSCT::Status::Valid &&
verifiedSct.origin == VerifiedSCT::Origin::Embedded) {
return true;
}
}
return false;
}
// Whether a valid non-embedded SCT is present in the list.
static bool HasValidNonEmbeddedSct(const VerifiedSCTList& verifiedScts) {
for (const VerifiedSCT& verifiedSct : verifiedScts) {
if (verifiedSct.status == VerifiedSCT::Status::Valid &&
(verifiedSct.origin == VerifiedSCT::Origin::TLSExtension ||
verifiedSct.origin == VerifiedSCT::Origin::OCSPResponse)) {
return true;
}
}
return false;
}
// Given a list of verified SCTs, counts the number of distinct CA-independent
// log operators running the CT logs that issued the SCTs which satisfy
// the provided boolean predicate.
template <typename SelectFunc>
void CountIndependentLogOperatorsForSelectedScts(
const VerifiedSCTList& verifiedScts,
const CTLogOperatorList& dependentOperators, size_t& count,
SelectFunc selected) {
CTLogOperatorList operatorIds;
for (const VerifiedSCT& verifiedSct : verifiedScts) {
CTLogOperatorId sctLogOperatorId = verifiedSct.logOperatorId;
// Check if |sctLogOperatorId| is CA-dependent.
bool isDependentOperator = false;
for (CTLogOperatorId dependentOperator : dependentOperators) {
if (sctLogOperatorId == dependentOperator) {
isDependentOperator = true;
break;
}
}
if (isDependentOperator || !selected(verifiedSct)) {
continue;
}
// Check if |sctLogOperatorId| is in |operatorIds|...
bool alreadyAdded = false;
for (CTLogOperatorId id : operatorIds) {
if (id == sctLogOperatorId) {
alreadyAdded = true;
break;
}
}
// ...and if not, add it.
if (!alreadyAdded) {
operatorIds.push_back(sctLogOperatorId);
}
}
count = operatorIds.size();
}
// Given a list of verified SCTs, counts the number of distinct CT logs
// that issued the SCTs that satisfy the |selected| predicate.
template <typename SelectFunc>
static void CountLogsForSelectedScts(const VerifiedSCTList& verifiedScts,
size_t& count, SelectFunc selected) {
// Keep pointers to log ids (of type Buffer) from |verifiedScts| to save on
// memory allocations.
std::vector<const Buffer*> logIds;
for (const VerifiedSCT& verifiedSct : verifiedScts) {
if (!selected(verifiedSct)) {
continue;
}
const Buffer* sctLogId = &verifiedSct.sct.logId;
// Check if |sctLogId| points to data already in |logIds|...
bool alreadyAdded = false;
for (const Buffer* logId : logIds) {
if (*logId == *sctLogId) {
alreadyAdded = true;
break;
}
}
// ...and if not, add it.
if (!alreadyAdded) {
logIds.push_back(sctLogId);
}
}
count = logIds.size();
}
// Calculates the effective issuance time of connection's certificate using
// the SCTs present on the connection (we can't rely on notBefore validity
// field of the certificate since it can be backdated).
// Used to determine whether to accept SCTs issued by past qualified logs.
// The effective issuance time is defined as the earliest of all SCTs,
// rather than the latest of embedded SCTs, in order to give CAs the benefit
// of the doubt in the event a log is revoked in the midst of processing
// a precertificate and issuing the certificate.
// It is acceptable to ignore the origin of the SCTs because SCTs
// delivered via OCSP/TLS extension will cover the full certificate,
// which necessarily will exist only after the precertificate
// has been logged and the actual certificate issued.
static uint64_t GetEffectiveCertIssuanceTime(
const VerifiedSCTList& verifiedScts) {
uint64_t result = UINT64_MAX;
for (const VerifiedSCT& verifiedSct : verifiedScts) {
if (verifiedSct.status == VerifiedSCT::Status::Valid) {
result = std::min(result, verifiedSct.sct.timestamp);
}
}
return result;
}
// Checks if the log that issued the given SCT is "once or currently qualified"
// (i.e. was qualified at the time of the certificate issuance). In addition,
// makes sure the SCT is before the disqualification.
static bool LogWasQualifiedForSct(const VerifiedSCT& verifiedSct,
uint64_t certIssuanceTime) {
if (verifiedSct.status == VerifiedSCT::Status::Valid) {
return true;
}
if (verifiedSct.status == VerifiedSCT::Status::ValidFromDisqualifiedLog) {
uint64_t logDisqualificationTime = verifiedSct.logDisqualificationTime;
return certIssuanceTime < logDisqualificationTime &&
verifiedSct.sct.timestamp < logDisqualificationTime;
}
return false;
}
// "A certificate is CT Qualified if it is presented with at least two SCTs
// from once or currently qualified logs run by a minimum of two entities
// independent of the CA and of each other."
// By the preexisting certificate exception provision (not currently
// implemented), certificates "are CT Qualified if they are presented with SCTs
// from once or currently qualified logs run by a minimum of one entity
// independent of the CA."
static void CheckOperatorDiversityCompliance(
const VerifiedSCTList& verifiedScts, uint64_t certIssuanceTime,
const CTLogOperatorList& dependentOperators, bool& compliant) {
size_t independentOperatorsCount;
CountIndependentLogOperatorsForSelectedScts(
verifiedScts, dependentOperators, independentOperatorsCount,
[certIssuanceTime](const VerifiedSCT& verifiedSct) -> bool {
return LogWasQualifiedForSct(verifiedSct, certIssuanceTime);
});
// Having at least 2 operators implies we have at least 2 SCTs.
// For the preexisting certificate exception provision (1 operator) we will
// need to include an additional SCTs count check using
// CountLogsForSelectedScts(verifiedScts, sctsCount,
// [certIssuanceTime](const VerifiedSCT& verifiedSct)->bool {
// return LogWasQualifiedForSct(verifiedSct, certIssuanceTime);
// });
compliant = independentOperatorsCount >= 2;
}
// Qualification Case #1 (non-embedded SCTs) - the following must hold:
// a. An SCT from a log qualified at the time of check is presented via the
// TLS extension OR is embedded within a stapled OCSP response;
// AND
// b. There are at least two SCTs from logs qualified at the time of check,
// presented via any method.
static void CheckNonEmbeddedCompliance(const VerifiedSCTList& verifiedScts,
bool& compliant) {
if (!HasValidNonEmbeddedSct(verifiedScts)) {
compliant = false;
return;
}
size_t validSctsCount;
CountLogsForSelectedScts(
verifiedScts, validSctsCount, [](const VerifiedSCT& verifiedSct) -> bool {
return verifiedSct.status == VerifiedSCT::Status::Valid;
});
compliant = validSctsCount >= 2;
}
// Qualification Case #2 (embedded SCTs) - the following must hold:
// a. An Embedded SCT from a log qualified at the time of check is presented;
// AND
// b. There are Embedded SCTs from AT LEAST N + 1 once or currently qualified
// logs, where N is the lifetime of the certificate in years (normally
// rounding up, but rounding down when up to 3 months over), and must be
// at least 1.
static void CheckEmbeddedCompliance(const VerifiedSCTList& verifiedScts,
size_t certLifetimeInCalendarMonths,
uint64_t certIssuanceTime,
bool& compliant) {
if (!HasValidEmbeddedSct(verifiedScts)) {
compliant = false;
return;
}
// Count the compliant embedded SCTs. Only a single SCT from each log
// is accepted. Note that a given log might return several different SCTs
// for the same precertificate (it is permitted, but advised against).
size_t embeddedSctsCount;
CountLogsForSelectedScts(
verifiedScts, embeddedSctsCount,
[certIssuanceTime](const VerifiedSCT& verifiedSct) -> bool {
return verifiedSct.origin == VerifiedSCT::Origin::Embedded &&
LogWasQualifiedForSct(verifiedSct, certIssuanceTime);
});
size_t requiredSctsCount =
GetRequiredEmbeddedSctsCount(certLifetimeInCalendarMonths);
compliant = embeddedSctsCount >= requiredSctsCount;
}
void CTPolicyEnforcer::CheckCompliance(
const VerifiedSCTList& verifiedScts, size_t certLifetimeInCalendarMonths,
const CTLogOperatorList& dependentOperators,
CTPolicyCompliance& compliance) {
uint64_t certIssuanceTime = GetEffectiveCertIssuanceTime(verifiedScts);
bool diversityOK;
CheckOperatorDiversityCompliance(verifiedScts, certIssuanceTime,
dependentOperators, diversityOK);
bool nonEmbeddedCaseOK;
CheckNonEmbeddedCompliance(verifiedScts, nonEmbeddedCaseOK);
bool embeddedCaseOK;
CheckEmbeddedCompliance(verifiedScts, certLifetimeInCalendarMonths,
certIssuanceTime, embeddedCaseOK);
if (nonEmbeddedCaseOK || embeddedCaseOK) {
compliance = diversityOK ? CTPolicyCompliance::Compliant
: CTPolicyCompliance::NotDiverseScts;
} else {
// Not enough SCTs are present to satisfy either case of the policy.
compliance = CTPolicyCompliance::NotEnoughScts;
}
switch (compliance) {
case CTPolicyCompliance::Compliant:
case CTPolicyCompliance::NotEnoughScts:
case CTPolicyCompliance::NotDiverseScts:
break;
case CTPolicyCompliance::Unknown:
default:
assert(false);
}
}
} // namespace ct
} // namespace mozilla