mirror of
https://github.com/apple/swift-certificates
synced 2026-11-22 04:20:39 +00:00
Correctly require no padding bits in bit strings for signatures (#329)
Motivation We have a check that requires that the bit strings for Ed25519 signatures don't have any padding bits. That check is good, but the same check should have been applied to all the signatures, and it wasn't. There is no particular security risk with this: while it allows moderate signature malleability (as we accept multiple signatures that have different bits as equally valid), there is no way we can conceive of to launch an attack based on this malleability: the signature itself needs to remain valid. The only note is that the representation differs. Modifications Centralise the check and apply it to all the code paths. Make sure the OCSP code doesn't lose track of whether there was any padding. Add tests for the OCSP verifier and the signature code directly. Result No more signature malleability.
This commit is contained in:
1 parent
8789d7e78f
commit
8d6849435f
4 files changed
+303
-11
No files matched your search
@@ -542,7 +542,7 @@ extension OCSPVerifierPolicy.Storage {
|
||||
let signatureValidationResult = self.validateSignature(
|
||||
certificate: leafCertificate,
|
||||
tbsResponse: basicResponse.responseDataBytes,
|
||||
signatureBytes: basicResponse.signature.bytes,
|
||||
signatureBytes: basicResponse.signature,
|
||||
signatureAlgorithmIdentifier: basicResponse.signatureAlgorithm
|
||||
)
|
||||
|
||||
@@ -580,7 +580,7 @@ extension OCSPVerifierPolicy.Storage {
|
||||
private func validateSignature(
|
||||
certificate: Certificate,
|
||||
tbsResponse: ArraySlice<UInt8>,
|
||||
signatureBytes: ArraySlice<UInt8>,
|
||||
signatureBytes: ASN1BitString,
|
||||
signatureAlgorithmIdentifier: AlgorithmIdentifier
|
||||
) -> PolicyEvaluationResult {
|
||||
let signatureAlgorithm = Certificate.SignatureAlgorithm(algorithmIdentifier: signatureAlgorithmIdentifier)
|
||||
@@ -588,7 +588,7 @@ extension OCSPVerifierPolicy.Storage {
|
||||
do {
|
||||
signature = try Certificate.Signature(
|
||||
signatureAlgorithm: signatureAlgorithm,
|
||||
signatureBytes: .init(bytes: signatureBytes)
|
||||
signatureBytes: signatureBytes
|
||||
)
|
||||
} catch {
|
||||
return .failsToMeetPolicy(reason: "could not create signature for OCSP response \(error)")
|
||||
|
||||
@@ -50,23 +50,32 @@ extension Certificate {
|
||||
public init(signatureAlgorithm: SignatureAlgorithm, signatureBytes: ASN1BitString) throws {
|
||||
switch signatureAlgorithm {
|
||||
case .ecdsaWithSHA256, .ecdsaWithSHA384, .ecdsaWithSHA512:
|
||||
let signature = try ECDSASignature(derEncoded: signatureBytes.bytes)
|
||||
let signature = try ECDSASignature(derEncoded: Self.octetAlignedBytes(signatureBytes))
|
||||
self.backing = .ecdsa(signature)
|
||||
case .sha1WithRSAEncryption, .sha256WithRSAEncryption, .sha384WithRSAEncryption, .sha512WithRSAEncryption:
|
||||
let signature = _RSA.Signing.RSASignature(rawRepresentation: signatureBytes.bytes)
|
||||
let signature = _RSA.Signing.RSASignature(rawRepresentation: try Self.octetAlignedBytes(signatureBytes))
|
||||
self.backing = .rsa(signature)
|
||||
case .ed25519:
|
||||
guard signatureBytes.paddingBits == 0 else {
|
||||
throw CertificateError.invalidSignatureForCertificate(
|
||||
reason: "No padding bits are allowed on Ed25519 signatures"
|
||||
)
|
||||
}
|
||||
let signature = Data(signatureBytes.bytes)
|
||||
let signature = Data(try Self.octetAlignedBytes(signatureBytes))
|
||||
self.backing = .ed25519(signature)
|
||||
default:
|
||||
throw CertificateError.unsupportedSignatureAlgorithm(reason: "\(signatureAlgorithm)")
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the bytes of a signature BIT STRING, rejecting it if it has any padding bits.
|
||||
///
|
||||
/// All signature algorithms we support produce octet-aligned signatures, so padding bits are
|
||||
/// never valid. Accepting them would allow multiple distinct encodings of the same signature.
|
||||
@inlinable
|
||||
static func octetAlignedBytes(_ signatureBytes: ASN1BitString) throws -> ArraySlice<UInt8> {
|
||||
guard signatureBytes.paddingBits == 0 else {
|
||||
throw CertificateError.invalidSignatureForCertificate(
|
||||
reason: "Signature BIT STRING must not contain padding bits, found \(signatureBytes.paddingBits)"
|
||||
)
|
||||
}
|
||||
return signatureBytes.bytes
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -596,6 +596,84 @@ final class OCSPVerifierPolicyTests: XCTestCase {
|
||||
)
|
||||
}
|
||||
|
||||
func testResponderSignatureWithPaddingBits() async {
|
||||
// An ordinary, unpadded signature is accepted...
|
||||
await self.assertChain(
|
||||
soft: .meetsPolicy,
|
||||
hard: .meetsPolicy,
|
||||
chain: Self.chainWithSingleCertWithOCSP,
|
||||
requester: TestRequester.noThrow { [validationTime] request, uri -> OCSPResponse in
|
||||
try Self.goodResponse(for: request, uri: uri, now: validationTime, padSignature: false)
|
||||
}
|
||||
)
|
||||
|
||||
// ...but an otherwise identical response, whose signature BIT STRING claims that the final bit is
|
||||
// padding, is not.
|
||||
await self.assertChain(
|
||||
soft: .meetsPolicy,
|
||||
hard: .failsToMeetPolicy,
|
||||
chain: Self.chainWithSingleCertWithOCSP,
|
||||
requester: TestRequester.noThrow { [validationTime] request, uri -> OCSPResponse in
|
||||
try Self.goodResponse(for: request, uri: uri, now: validationTime, padSignature: true)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
/// Builds a response asserting that the certificate in `request` is good, signed by the intermediate.
|
||||
///
|
||||
/// If `padSignature` is true, the signature BIT STRING claims that the final bit of the signature is padding.
|
||||
private static func goodResponse(
|
||||
for request: OCSPRequest,
|
||||
uri: String,
|
||||
now: Date,
|
||||
padSignature: Bool
|
||||
) throws -> OCSPResponse {
|
||||
XCTAssertEqual(uri, Self.responderURI)
|
||||
XCTAssertNil(request.signature)
|
||||
let nonce = try XCTUnwrap(request.tbsRequest.requestExtensions?.ocspNonce)
|
||||
XCTAssertEqual(request.tbsRequest.requestList.count, 1)
|
||||
let singleRequest = try XCTUnwrap(request.tbsRequest.requestList.first)
|
||||
|
||||
let responseData = OCSPResponseData(
|
||||
version: .v1,
|
||||
responderID: .byName(Self.intermediate1Name),
|
||||
producedAt: .init(now),
|
||||
responses: [
|
||||
OCSPSingleResponse(
|
||||
certID: singleRequest.certID,
|
||||
certStatus: .good,
|
||||
thisUpdate: .init(now - .days(1)),
|
||||
nextUpdate: .init(now + .days(1))
|
||||
)
|
||||
],
|
||||
responseExtensions: try .init {
|
||||
nonce
|
||||
}
|
||||
)
|
||||
|
||||
let digest = SHA384.hash(data: try DER.Serializer.serialized(element: responseData))
|
||||
|
||||
// ECDSA signatures are randomised, so keep signing until the final byte has its lowest bit clear. Only then
|
||||
// can the signature be encoded as a BIT STRING with a padding bit. We do this regardless of `padSignature`,
|
||||
// so that both cases use the same kind of signature.
|
||||
var signatureBytes: [UInt8]? = nil
|
||||
for _ in 0..<64 {
|
||||
let candidate = Array(try Self.intermediatePrivateKey.signature(for: digest).derRepresentation)
|
||||
if let finalByte = candidate.last, finalByte & 0x01 == 0 {
|
||||
signatureBytes = candidate
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
let response = try BasicOCSPResponse(
|
||||
responseData: responseData,
|
||||
signatureAlgorithm: .ecdsaWithSHA384,
|
||||
signature: .init(bytes: try XCTUnwrap(signatureBytes)[...], paddingBits: padSignature ? 1 : 0),
|
||||
certs: []
|
||||
)
|
||||
return .successful(response)
|
||||
}
|
||||
|
||||
func testResponseDoesNotIncludeResponseForRequestedCert() async {
|
||||
let now = self.validationTime
|
||||
await self.assertChain(
|
||||
|
||||
@@ -1444,4 +1444,209 @@ final class SignatureTests: XCTestCase {
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
// MARK: Signature BIT STRING padding
|
||||
|
||||
/// Every supported signature algorithm, paired with a key that can produce it.
|
||||
private static var allSupportedSigningCombinations: [(Certificate.PrivateKey, Certificate.SignatureAlgorithm)] {
|
||||
[
|
||||
(.init(Self.p256Key), .ecdsaWithSHA256),
|
||||
(.init(Self.p384Key), .ecdsaWithSHA384),
|
||||
(.init(Self.p521Key), .ecdsaWithSHA512),
|
||||
(.init(Self.rsaKey), .sha1WithRSAEncryption),
|
||||
(.init(Self.rsaKey), .sha256WithRSAEncryption),
|
||||
(.init(Self.rsaKey), .sha384WithRSAEncryption),
|
||||
(.init(Self.rsaKey), .sha512WithRSAEncryption),
|
||||
(.init(Self.ed25519Key), .ed25519),
|
||||
]
|
||||
}
|
||||
|
||||
/// Repeatedly calls `make` until it produces a value whose signature has a final byte with its lowest bit clear.
|
||||
///
|
||||
/// Only such a signature can be re-encoded as a BIT STRING with a padding bit, as DER requires padding bits to be
|
||||
/// zero. `make` is passed the attempt number so that it can vary its input: this ensures that deterministic
|
||||
/// signature schemes (RSA PKCS#1 v1.5, Ed25519) also produce a fresh signature on each attempt. Each attempt has
|
||||
/// roughly a 50% chance of success.
|
||||
private static func withEvenFinalSignatureByte<T>(
|
||||
_ make: (Int) throws -> T,
|
||||
signature: (T) -> Certificate.Signature
|
||||
) rethrows -> T? {
|
||||
for attempt in 0..<64 {
|
||||
let value = try make(attempt)
|
||||
if let finalByte = signature(value).rawRepresentation.last, finalByte & 0x01 == 0 {
|
||||
return value
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
/// Returns `der` with the unused-bits octet of its trailing signature BIT STRING set to `paddingBits`.
|
||||
///
|
||||
/// Certificates and CSRs both end with the signature BIT STRING, so its unused-bits octet sits immediately
|
||||
/// before the final `signatureLength` bytes.
|
||||
private static func settingSignaturePaddingBits(
|
||||
_ paddingBits: UInt8,
|
||||
in der: [UInt8],
|
||||
signatureLength: Int,
|
||||
file: StaticString = #filePath,
|
||||
line: UInt = #line
|
||||
) -> [UInt8] {
|
||||
var der = der
|
||||
let paddingOctetIndex = der.endIndex - signatureLength - 1
|
||||
XCTAssertEqual(der[paddingOctetIndex], 0x00, "expected an unpadded signature", file: file, line: line)
|
||||
der[paddingOctetIndex] = paddingBits
|
||||
return der
|
||||
}
|
||||
|
||||
func testSignatureRejectsPaddingBits() throws {
|
||||
let input = Array("Hello World".utf8)
|
||||
|
||||
for (privateKey, signatureAlgorithm) in Self.allSupportedSigningCombinations {
|
||||
var signatureBytes = try privateKey.sign(bytes: input, signatureAlgorithm: signatureAlgorithm)
|
||||
.rawRepresentation
|
||||
// Clear the low 7 bits of the final byte, so these bytes form a valid BIT STRING with any
|
||||
// number of padding bits. This invalidates the signature, but parsing doesn't check that.
|
||||
signatureBytes[signatureBytes.endIndex - 1] &= 0x80
|
||||
|
||||
XCTAssertNoThrow(
|
||||
try Certificate.Signature(
|
||||
signatureAlgorithm: signatureAlgorithm,
|
||||
signatureBytes: ASN1BitString(bytes: signatureBytes[...], paddingBits: 0)
|
||||
),
|
||||
"\(signatureAlgorithm) with no padding bits"
|
||||
)
|
||||
|
||||
for paddingBits in 1..<8 {
|
||||
XCTAssertThrowsError(
|
||||
try Certificate.Signature(
|
||||
signatureAlgorithm: signatureAlgorithm,
|
||||
signatureBytes: ASN1BitString(bytes: signatureBytes[...], paddingBits: paddingBits)
|
||||
),
|
||||
"\(signatureAlgorithm) with \(paddingBits) padding bits"
|
||||
) { error in
|
||||
XCTAssertEqual(
|
||||
(error as? CertificateError)?.code,
|
||||
.invalidSignatureForCertificate,
|
||||
"wrong error \(error)"
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testUnsupportedSignatureAlgorithmWithPaddingBitsIsReportedAsUnsupported() throws {
|
||||
let unsupportedAlgorithm = Certificate.SignatureAlgorithm(
|
||||
algorithmIdentifier: AlgorithmIdentifier(algorithm: [1, 2, 3, 4], parameters: nil)
|
||||
)
|
||||
|
||||
XCTAssertThrowsError(
|
||||
try Certificate.Signature(
|
||||
signatureAlgorithm: unsupportedAlgorithm,
|
||||
signatureBytes: ASN1BitString(bytes: [0x00], paddingBits: 1)
|
||||
)
|
||||
) { error in
|
||||
XCTAssertEqual(
|
||||
(error as? CertificateError)?.code,
|
||||
.unsupportedSignatureAlgorithm,
|
||||
"wrong error \(error)"
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
func testCertificateWithPaddedSignatureIsRejected() throws {
|
||||
let name = try DistinguishedName {
|
||||
CommonName("Signature padding test")
|
||||
}
|
||||
|
||||
for (privateKey, signatureAlgorithm) in Self.allSupportedSigningCombinations {
|
||||
let certificate = try XCTUnwrap(
|
||||
Self.withEvenFinalSignatureByte(
|
||||
{ _ in
|
||||
// The serial number is random, so every attempt has a fresh signature.
|
||||
try Certificate(
|
||||
version: .v3,
|
||||
serialNumber: .init(),
|
||||
publicKey: privateKey.publicKey,
|
||||
notValidBefore: Self.now,
|
||||
notValidAfter: Self.oneYearFromNow,
|
||||
issuer: name,
|
||||
subject: name,
|
||||
signatureAlgorithm: signatureAlgorithm,
|
||||
extensions: Certificate.Extensions(),
|
||||
issuerPrivateKey: privateKey
|
||||
)
|
||||
},
|
||||
signature: \.signature
|
||||
),
|
||||
"Unable to produce a suitable \(signatureAlgorithm) certificate"
|
||||
)
|
||||
let der = try DER.Serializer.serialized(element: certificate)
|
||||
|
||||
// The unmodified certificate parses and has a valid signature.
|
||||
let parsed = try Certificate(derEncoded: der)
|
||||
XCTAssertTrue(
|
||||
privateKey.publicKey.isValidSignature(parsed.signature, for: parsed),
|
||||
"\(signatureAlgorithm)"
|
||||
)
|
||||
|
||||
// Marking the final (zero) bit of the signature as padding is still valid DER and leaves the signature
|
||||
// bytes unchanged, but must be rejected.
|
||||
let padded = Self.settingSignaturePaddingBits(
|
||||
1,
|
||||
in: der,
|
||||
signatureLength: certificate.signature.rawRepresentation.count
|
||||
)
|
||||
XCTAssertThrowsError(try Certificate(derEncoded: padded), "\(signatureAlgorithm)") { error in
|
||||
XCTAssertEqual(
|
||||
(error as? CertificateError)?.code,
|
||||
.invalidSignatureForCertificate,
|
||||
"wrong error \(error)"
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testCSRWithPaddedSignatureIsRejected() throws {
|
||||
for (privateKey, signatureAlgorithm) in Self.allSupportedSigningCombinations {
|
||||
let csr = try XCTUnwrap(
|
||||
Self.withEvenFinalSignatureByte(
|
||||
{ attempt in
|
||||
try CertificateSigningRequest(
|
||||
version: .v1,
|
||||
subject: DistinguishedName {
|
||||
CommonName("Signature padding test \(attempt)")
|
||||
},
|
||||
privateKey: privateKey,
|
||||
attributes: CertificateSigningRequest.Attributes(),
|
||||
signatureAlgorithm: signatureAlgorithm
|
||||
)
|
||||
},
|
||||
signature: \.signature
|
||||
),
|
||||
"Unable to produce a suitable \(signatureAlgorithm) CSR"
|
||||
)
|
||||
let der = try DER.Serializer.serialized(element: csr)
|
||||
|
||||
// The unmodified CSR parses and has a valid signature.
|
||||
let parsed = try CertificateSigningRequest(derEncoded: der)
|
||||
XCTAssertTrue(
|
||||
privateKey.publicKey.isValidSignature(parsed.signature, for: parsed),
|
||||
"\(signatureAlgorithm)"
|
||||
)
|
||||
|
||||
let padded = Self.settingSignaturePaddingBits(
|
||||
1,
|
||||
in: der,
|
||||
signatureLength: csr.signature.rawRepresentation.count
|
||||
)
|
||||
XCTAssertThrowsError(try CertificateSigningRequest(derEncoded: padded), "\(signatureAlgorithm)") {
|
||||
error in
|
||||
XCTAssertEqual(
|
||||
(error as? CertificateError)?.code,
|
||||
.invalidSignatureForCertificate,
|
||||
"wrong error \(error)"
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user