Merge branch 'main' into cb-basic-chain-builder

This commit is contained in:
Cory Benfield authored and GitHub committed 2023-01-24 14:47:22 +00:00
commit d2ef4164b1
17 files changed
+627 -65

No files matched your search

+1 -19
View File
@@ -64,13 +64,7 @@ extension Certificate {
@inlinable
public init() {
var rng = SystemRandomNumberGenerator()
var bytes = [UInt8]()
while bytes.count < 20 {
bytes.appendLittleEndianBytes(rng.next())
}
self.bytes = bytes[..<20]
self.bytes = rng.bytes(count: 20)
}
}
}
@@ -84,15 +78,3 @@ extension Certificate.SerialNumber: CustomStringConvertible {
return self.bytes.lazy.map { String($0, radix: 16) }.joined(separator: ":")
}
}
extension Array where Element == UInt8 {
@inlinable
mutating func appendLittleEndianBytes(_ number: UInt64) {
let number = number.littleEndian
for byte in 0..<(MemoryLayout<UInt64>.size) {
let shifted = number >> (byte * 8)
self.append(UInt8(truncatingIfNeeded: shifted))
}
}
}
+6 -4
View File
@@ -29,11 +29,13 @@ import SwiftASN1
struct OCSPCertID: DERImplicitlyTaggable, Hashable {
var hashAlgorithm: AlgorithmIdentifier
/// Hash of issuer's DN
var issuerNameHash: ASN1OctetString
/// Hash of issuer's public key
var issuerKeyHash: ASN1OctetString
var serialNumber: ArraySlice<UInt8>
var serialNumber: Certificate.SerialNumber
static var defaultIdentifier: ASN1Identifier {
.sequence
@@ -42,7 +44,7 @@ struct OCSPCertID: DERImplicitlyTaggable, Hashable {
init(hashAlgorithm: AlgorithmIdentifier,
issuerNameHash: ASN1OctetString,
issuerKeyHash: ASN1OctetString,
serialNumber: ArraySlice<UInt8>) {
serialNumber: Certificate.SerialNumber) {
self.hashAlgorithm = hashAlgorithm
self.issuerNameHash = issuerNameHash
self.issuerKeyHash = issuerKeyHash
@@ -59,7 +61,7 @@ struct OCSPCertID: DERImplicitlyTaggable, Hashable {
return .init(hashAlgorithm: hashAlgorithm,
issuerNameHash: issuerNameHash,
issuerKeyHash: issuerKeyHash,
serialNumber: serialNumber)
serialNumber: .init(bytes: serialNumber))
}
}
@@ -68,7 +70,7 @@ struct OCSPCertID: DERImplicitlyTaggable, Hashable {
try self.hashAlgorithm.serialize(into: &coder)
try self.issuerNameHash.serialize(into: &coder)
try self.issuerKeyHash.serialize(into: &coder)
try self.serialNumber.serialize(into: &coder)
try self.serialNumber.bytes.serialize(into: &coder)
}
}
}
+18
View File
@@ -149,3 +149,21 @@ struct CRLReason: DERImplicitlyTaggable, Hashable, RawRepresentable {
static let privilegeWithdrawn = CRLReason(rawValue: 9)
static let aaCompromise = CRLReason(rawValue: 10)
}
extension CRLReason: CustomStringConvertible {
var description: String {
switch rawValue {
case 0: return "unspecified"
case 1: return "keyCompromise"
case 2: return "caCompromise"
case 3: return "affiliationChanged"
case 4: return "superseded"
case 5: return "cessationOfOperation"
case 6: return "certificateHold"
case 8: return "removeFromCRL"
case 9: return "privilegeWithdrawn"
case 10: return "aaCompromise"
default: return "unknown reason \(rawValue)"
}
}
}
+20
View File
@@ -0,0 +1,20 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCertificates open source project
//
// Copyright (c) 2023 Apple Inc. and the SwiftCertificates project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftCertificates project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import SwiftASN1
extension ASN1ObjectIdentifier {
/// OIDs that identify known OCSP extensions,
enum OCSPExtensionID {}
}
+88
View File
@@ -0,0 +1,88 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCertificates open source project
//
// Copyright (c) 2023 Apple Inc. and the SwiftCertificates project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftCertificates project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import SwiftASN1
/// ``OCSPNonce`` is defined in ASN.1 as:
/// ```
/// Nonce ::= OCTET STRING(SIZE(1..32))
/// ```
/// RFC: https://www.rfc-editor.org/rfc/rfc8954.html
struct OCSPNonce: DERImplicitlyTaggable, Hashable, Sendable {
static var defaultIdentifier: ASN1Identifier {
ASN1OctetString.defaultIdentifier
}
var rawValue: ASN1OctetString
init() {
var generator = SystemRandomNumberGenerator()
self.init(generator: &generator)
}
init(generator: inout some RandomNumberGenerator) {
self.rawValue = .init(contentBytes: generator.bytes(count: 32))
}
init(_ ext: Certificate.Extension) throws {
guard ext.oid == .OCSPExtensionID.nonceIdentifier else {
throw CertificateError.incorrectOIDForExtension(reason: "Expected \(ASN1ObjectIdentifier.OCSPExtensionID.nonceIdentifier), got \(ext.oid)")
}
try self.init(derEncoded: ext.value)
}
init(derEncoded rootNode: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
self.rawValue = try ASN1OctetString(derEncoded: rootNode, withIdentifier: identifier)
guard (1...32).contains(self.rawValue.bytes.count) else {
throw ASN1Error.unsupportedFieldLength
}
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
try rawValue.serialize(into: &coder, withIdentifier: identifier)
}
}
extension ASN1ObjectIdentifier.OCSPExtensionID {
static let nonceIdentifier: ASN1ObjectIdentifier = [1, 3, 6, 1, 5, 5, 7, 48, 1, 2]
}
extension Certificate.Extension {
/// Construct an opaque ``Certificate/Extension`` from this Key Usage extension.
///
/// - Parameters:
/// - keyUsage: The extension to wrap
/// - critical: Whether this extension should have the critical bit set.
init(_ nonce: OCSPNonce, critical: Bool) throws {
var serializer = DER.Serializer()
try serializer.serialize(nonce)
self.init(oid: .OCSPExtensionID.nonceIdentifier, critical: critical, value: serializer.serializedBytes[...])
}
}
extension OCSPNonce: CertificateExtensionConvertible {
func makeCertificateExtension() throws -> Certificate.Extension {
try .init(self, critical: false)
}
}
extension Certificate.Extensions {
var ocspNonce: OCSPNonce? {
get throws {
try self[oid: .OCSPExtensionID.nonceIdentifier].map { try .init($0) }
}
}
}
+58
View File
@@ -0,0 +1,58 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCertificates open source project
//
// Copyright (c) 2022 Apple Inc. and the SwiftCertificates project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftCertificates project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import SwiftASN1
/// ``OCSPRequest`` is defined in ASN.1 as:
/// ```
/// OCSPRequest ::= SEQUENCE {
/// tbsRequest TBSRequest,
/// optionalSignature [0] EXPLICIT Signature OPTIONAL }
/// ```
struct OCSPRequest: DERImplicitlyTaggable, Hashable {
static var defaultIdentifier: ASN1Identifier {
.sequence
}
var tbsRequest: OCSPTBSRequest
var signature: OCSPSignature?
init(tbsRequest: OCSPTBSRequest, signature: OCSPSignature? = nil) {
self.tbsRequest = tbsRequest
self.signature = signature
}
init(derEncoded rootNode: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
self = try DER.sequence(rootNode, identifier: identifier) { nodes in
let tbsRequest = try OCSPTBSRequest(derEncoded: &nodes)
let signature = try DER.optionalExplicitlyTagged(&nodes, tagNumber: 0, tagClass: .contextSpecific) {
try OCSPSignature(derEncoded: $0)
}
return .init(tbsRequest: tbsRequest, signature: signature)
}
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
try coder.appendConstructedNode(identifier: identifier) { coder in
try coder.serialize(self.tbsRequest)
if let signature = self.signature {
try coder.serialize(signature, explicitlyTaggedWithTagNumber: 0, tagClass: .contextSpecific)
}
}
}
}
+66 -13
View File
@@ -23,19 +23,17 @@ import SwiftASN1
///
/// ```
///
struct OCSPResponse: DERImplicitlyTaggable, Hashable {
enum OCSPResponse: DERImplicitlyTaggable, Hashable {
static var defaultIdentifier: ASN1Identifier {
.sequence
}
var responseStatus: OCSPResponseStatus
var responseBytes: OCSPResponseBytes?
init(responseStatus: OCSPResponseStatus, responseBytes: OCSPResponseBytes?) {
self.responseStatus = responseStatus
self.responseBytes = responseBytes
}
case successful(BasicOCSPResponse)
case malformedRequest
case internalError
case tryLater
case sigRequired
case unauthorized
init(derEncoded rootNode: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
self = try DER.sequence(rootNode, identifier: identifier) { nodes in
@@ -43,17 +41,72 @@ struct OCSPResponse: DERImplicitlyTaggable, Hashable {
let responseBytes = try DER.optionalExplicitlyTagged(&nodes, tagNumber: 0, tagClass: .contextSpecific) { node in
try OCSPResponseBytes(derEncoded: node)
}
return .init(responseStatus: responseStatus, responseBytes: responseBytes)
switch responseStatus {
case .successful:
guard let responseBytes,
responseBytes.responseType == .OCSP.basicResponse
else {
throw ASN1Error.invalidASN1Object
}
return .successful(try BasicOCSPResponse(derEncoded: responseBytes.response.bytes))
case .malformedRequest:
return try .init(unsuccessfulStatus: .malformedRequest, responseBytes: responseBytes)
case .internalError:
return try .init(unsuccessfulStatus: .internalError, responseBytes: responseBytes)
case .tryLater:
return try .init(unsuccessfulStatus: .tryLater, responseBytes: responseBytes)
case .sigRequired:
return try .init(unsuccessfulStatus: .sigRequired, responseBytes: responseBytes)
case .unauthorized:
return try .init(unsuccessfulStatus: .unauthorized, responseBytes: responseBytes)
}
}
}
private init(unsuccessfulStatus: OCSPResponse, responseBytes: OCSPResponseBytes?) throws {
if case .successful = unsuccessfulStatus {
preconditionFailure("this init is not allowed to be called with a successful response status")
}
guard responseBytes == nil else { throw ASN1Error.invalidASN1Object }
self = unsuccessfulStatus
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
try coder.appendConstructedNode(identifier: identifier) { coder in
try coder.serialize(self.responseStatus)
if let responseBytes = self.responseBytes {
try coder.serialize(OCSPResponseStatus(self))
switch self {
case .successful(let basicResponse):
var serializer = DER.Serializer()
try serializer.serialize(basicResponse)
let responseBytes = OCSPResponseBytes(responseType: .OCSP.basicResponse, response: .init(contentBytes: serializer.serializedBytes[...]))
try coder.serialize(responseBytes, explicitlyTaggedWithTagNumber: 0, tagClass: .contextSpecific)
case .malformedRequest,
.internalError,
.tryLater,
.sigRequired,
.unauthorized:
break
}
}
}
}
extension OCSPResponseStatus {
init(_ response: OCSPResponse) {
switch response {
case .successful:
self = .successful
case .malformedRequest:
self = .malformedRequest
case .internalError:
self = .internalError
case .tryLater:
self = .tryLater
case .sigRequired:
self = .sigRequired
case .unauthorized:
self = .unauthorized
}
}
}
+7 -7
View File
@@ -32,7 +32,7 @@ struct OCSPResponseData: DERImplicitlyTaggable, Hashable {
.sequence
}
var version: Int
var version: OCSPVersion
var responderID: ResponderID
@@ -40,13 +40,13 @@ struct OCSPResponseData: DERImplicitlyTaggable, Hashable {
var responses: [OCSPSingleResponse]
var responseExtensions: [Certificate.Extension]?
var responseExtensions: Certificate.Extensions?
init(version: Int = 0,
init(version: OCSPVersion = .v1,
responderID: ResponderID,
producedAt: GeneralizedTime,
responses: [OCSPSingleResponse],
responseExtensions: [Certificate.Extension]?) {
responseExtensions: Certificate.Extensions? = nil) {
self.version = version
self.responderID = responderID
self.producedAt = producedAt
@@ -67,14 +67,14 @@ struct OCSPResponseData: DERImplicitlyTaggable, Hashable {
try DER.sequence(of: Certificate.Extension.self, identifier: .sequence, rootNode: node)
}
return .init(version: version, responderID: responderID, producedAt: producedAt, responses: responses, responseExtensions: responseExtensions)
return .init(version: .init(rawValue: version), responderID: responderID, producedAt: producedAt, responses: responses, responseExtensions: responseExtensions.map { .init($0) })
}
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
try coder.appendConstructedNode(identifier: identifier) { coder in
if self.version != 0 {
try coder.serialize(self.version, explicitlyTaggedWithTagNumber: 0, tagClass: .contextSpecific)
if self.version != .v1 {
try coder.serialize(self.version.rawValue, explicitlyTaggedWithTagNumber: 0, tagClass: .contextSpecific)
}
try coder.serialize(self.responderID)
+25 -18
View File
@@ -61,25 +61,32 @@ enum OCSPResponseStatus: DERImplicitlyTaggable, Hashable {
throw ASN1Error.invalidASN1Object
}
}
var integerValue: Int {
switch self {
case .successful: return 0
case .malformedRequest: return 1
case .internalError: return 2
case .tryLater: return 3
case .sigRequired: return 5
case .unauthorized: return 6
}
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
let integerValue: Int
switch self {
case .successful:
integerValue = 0
case .malformedRequest:
integerValue = 1
case .internalError:
integerValue = 2
case .tryLater:
integerValue = 3
case .sigRequired:
integerValue = 5
case .unauthorized:
integerValue = 6
}
try integerValue.serialize(into: &coder, withIdentifier: identifier)
try self.integerValue.serialize(into: &coder, withIdentifier: identifier)
}
}
extension OCSPResponseStatus: CustomStringConvertible {
var description: String {
switch self {
case .successful: return "successful"
case .malformedRequest: return "malformedRequest"
case .internalError: return "internalError"
case .tryLater: return "tryLater"
case .sigRequired: return "sigRequired"
case .unauthorized: return "unauthorized"
}
}
}
+63
View File
@@ -0,0 +1,63 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCertificates open source project
//
// Copyright (c) 2022 Apple Inc. and the SwiftCertificates project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftCertificates project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import SwiftASN1
/// ``OCSPSignature`` is defined in ASN.1 as:
/// ```
/// Signature ::= SEQUENCE {
/// signatureAlgorithm AlgorithmIdentifier,
/// signature BIT STRING,
/// certs [0] EXPLICIT SEQUENCE OF Certificate OPTIONAL }
/// ```
struct OCSPSignature: DERImplicitlyTaggable, Hashable {
static var defaultIdentifier: ASN1Identifier {
.sequence
}
var algorithmIIdentifier: AlgorithmIdentifier
var signature: ASN1BitString
var certs: [Certificate]?
init(algorithmIIdentifier: AlgorithmIdentifier, signature: ASN1BitString, certs: [Certificate]? = nil) {
self.algorithmIIdentifier = algorithmIIdentifier
self.signature = signature
self.certs = certs
}
init(derEncoded: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
self = try DER.sequence(derEncoded, identifier: identifier) { nodes in
let algorithmIdentifier = try AlgorithmIdentifier(derEncoded: &nodes)
let signature = try ASN1BitString(derEncoded: &nodes)
let certs = try DER.optionalExplicitlyTagged(&nodes, tagNumber: 0, tagClass: .contextSpecific) { node in
try DER.sequence(of: Certificate.self, identifier: .sequence, rootNode: node)
}
return .init(algorithmIIdentifier: algorithmIdentifier, signature: signature, certs: certs)
}
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
try coder.appendConstructedNode(identifier: identifier) { coder in
try self.algorithmIIdentifier.serialize(into: &coder)
try self.signature.serialize(into: &coder)
if let certs = self.certs {
try coder.serialize(explicitlyTaggedWithTagNumber: 0, tagClass: .contextSpecific) { coder in
try coder.serializeSequenceOf(certs)
}
}
}
}
}
+60
View File
@@ -0,0 +1,60 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCertificates open source project
//
// Copyright (c) 2022 Apple Inc. and the SwiftCertificates project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftCertificates project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import SwiftASN1
/// ``OCSPSingleRequest`` is defined in ASN.1 as:
/// ```
/// Request ::= SEQUENCE {
/// reqCert CertID,
/// singleRequestExtensions [0] EXPLICIT Extensions OPTIONAL }
/// ```
/// - note: originally named just `Request` in RFC 6960 but prefix `Single` added to avoid naming conflicts with ``OCSPRequest``
struct OCSPSingleRequest: DERImplicitlyTaggable, Hashable {
static var defaultIdentifier: ASN1Identifier {
.sequence
}
var certID: OCSPCertID
var singleRequestExtensions: Certificate.Extensions?
init(certID: OCSPCertID, singleRequestExtensions: Certificate.Extensions? = nil) {
self.certID = certID
self.singleRequestExtensions = singleRequestExtensions
}
init(derEncoded: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
self = try DER.sequence(derEncoded, identifier: identifier) { nodes in
let certID = try OCSPCertID(derEncoded: &nodes)
let singleRequestExtensions = try DER.optionalExplicitlyTagged(&nodes, tagNumber: 0, tagClass: .contextSpecific) { node in
Certificate.Extensions(
extensions: try DER.sequence(of: Certificate.Extension.self, identifier: .sequence, rootNode: node)
)
}
return .init(certID: certID, singleRequestExtensions: singleRequestExtensions)
}
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
try coder.appendConstructedNode(identifier: identifier) { coder in
try self.certID.serialize(into: &coder)
if let singleRequestExtensions = self.singleRequestExtensions {
try coder.serialize(explicitlyTaggedWithTagNumber: 0, tagClass: .contextSpecific) { coder in
try coder.serializeSequenceOf(singleRequestExtensions)
}
}
}
}
}
+1 -1
View File
@@ -44,7 +44,7 @@ struct OCSPSingleResponse: DERImplicitlyTaggable, Hashable {
certStatus: OCSPCertStatus,
thisUpdate: GeneralizedTime,
nextUpdate: GeneralizedTime?,
extensions: [Certificate.Extension]?) {
extensions: [Certificate.Extension]? = nil) {
self.certID = certID
self.certStatus = certStatus
self.thisUpdate = thisUpdate
+83
View File
@@ -0,0 +1,83 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCertificates open source project
//
// Copyright (c) 2022 Apple Inc. and the SwiftCertificates project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftCertificates project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import SwiftASN1
/// ``OCSPTBSRequest`` is defined in ASN.1 as:
/// ```
/// TBSRequest ::= SEQUENCE {
/// version [0] EXPLICIT Version DEFAULT v1,
/// requestorName [1] EXPLICIT GeneralName OPTIONAL,
/// requestList SEQUENCE OF Request,
/// requestExtensions [2] EXPLICIT Extensions OPTIONAL }
///
/// Version ::= INTEGER { v1(0) }
/// ```
struct OCSPTBSRequest: DERImplicitlyTaggable, Hashable {
static var defaultIdentifier: ASN1Identifier {
.sequence
}
var version: OCSPVersion
var requestorName: GeneralName?
var requestList: [OCSPSingleRequest]
var requestExtensions: Certificate.Extensions?
init(version: OCSPVersion, requestorName: GeneralName? = nil, requestList: [OCSPSingleRequest], requestExtensions: Certificate.Extensions? = nil) {
self.version = version
self.requestorName = requestorName
self.requestList = requestList
self.requestExtensions = requestExtensions
}
init(derEncoded rootNode: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
self = try DER.sequence(rootNode, identifier: identifier) { nodes in
let version = try DER.decodeDefaultExplicitlyTagged(&nodes, tagNumber: 0, tagClass: .contextSpecific, defaultValue: Int(0))
let requestorName = try DER.optionalExplicitlyTagged(&nodes, tagNumber: 1, tagClass: .contextSpecific) {
try GeneralName(derEncoded: $0)
}
let requestList = try DER.sequence(of: OCSPSingleRequest.self, identifier: .sequence, nodes: &nodes)
let extensions = try DER.optionalExplicitlyTagged(&nodes, tagNumber: 2, tagClass: .contextSpecific) {
try DER.sequence(of: Certificate.Extension.self, identifier: .sequence, rootNode: $0)
}
return .init(
version: .init(rawValue: version),
requestorName: requestorName,
requestList: requestList,
requestExtensions: extensions.map { .init(extensions: $0) }
)
}
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
try coder.appendConstructedNode(identifier: identifier) { coder in
if self.version != .v1 {
try coder.serialize(self.version.rawValue, explicitlyTaggedWithTagNumber: 0, tagClass: .contextSpecific)
}
if let requestorName = self.requestorName {
try coder.serialize(requestorName, explicitlyTaggedWithTagNumber: 1, tagClass: .contextSpecific)
}
try coder.serializeSequenceOf(requestList)
if let requestExtensions = self.requestExtensions {
try coder.serialize(explicitlyTaggedWithTagNumber: 2, tagClass: .contextSpecific) { coder in
try coder.serializeSequenceOf(requestExtensions._extensions)
}
}
}
}
}
+44
View File
@@ -0,0 +1,44 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCertificates open source project
//
// Copyright (c) 2022 Apple Inc. and the SwiftCertificates project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftCertificates project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
struct OCSPVersion {
var rawValue: Int
init(rawValue: Int) {
self.rawValue = rawValue
}
static let v1 = Self(rawValue: 0)
}
extension OCSPVersion: Hashable { }
extension OCSPVersion: Sendable { }
extension OCSPVersion: Comparable {
static func < (lhs: Self, rhs: Self) -> Bool {
lhs.rawValue < rhs.rawValue
}
}
extension OCSPVersion: CustomStringConvertible {
var description: String {
switch self {
case .v1:
return "OCSPv1"
case let unknown:
return "OCSPv\(unknown.rawValue + 1)"
}
}
}
@@ -0,0 +1,39 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCertificates open source project
//
// Copyright (c) 2023 Apple Inc. and the SwiftCertificates project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of SwiftCertificates project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
extension RandomNumberGenerator {
@inlinable
internal mutating func bytes(count: Int) -> ArraySlice<UInt8> {
precondition(count >= 0)
var bytes = [UInt8]()
while bytes.count < count {
bytes.appendLittleEndianBytes(self.next())
}
return bytes[..<count]
}
}
extension Array where Element == UInt8 {
@inlinable
mutating func appendLittleEndianBytes(_ number: UInt64) {
let number = number.littleEndian
for byte in 0..<(MemoryLayout<UInt64>.size) {
let shifted = number >> (byte * 8)
self.append(UInt8(truncatingIfNeeded: shifted))
}
}
}
+29 -3
View File
@@ -28,17 +28,43 @@
import XCTest
@testable import SwiftASN1
@testable import X509
final class OCSPTests: XCTestCase {
// TODO: Make these work.
#if false
private func assertRoundTrips<ASN1Object: DERParseable & DERSerializable & Equatable>(_ value: ASN1Object) throws {
var serializer = DER.Serializer()
try serializer.serialize(value)
let parsed = try ASN1Object(derEncoded: serializer.serializedBytes)
XCTAssertEqual(parsed, value)
}
func testRequestRoundtrip() throws {
let ocspRequest = OCSPRequest(
tbsRequest: OCSPTBSRequest(
version: .v1,
requestorName: GeneralName.dNSName("swift.org"),
requestList: [OCSPSingleRequest(
certID: OCSPCertID(
hashAlgorithm: .ecdsaWithSHA256,
issuerNameHash: .init(contentBytes: [0, 1, 2, 3, 4, 5, 6, 7, 8]),
issuerKeyHash: .init(contentBytes: [10, 11, 12, 13, 14, 15, 16, 17, 18]),
serialNumber: .init(bytes: [20, 21, 22, 23, 24, 25, 26, 27, 28])
),
singleRequestExtensions: nil
)],
requestExtensions: nil),
signature: OCSPSignature(
algorithmIIdentifier: .p256PublicKey,
signature: .init(bytes: [31, 32, 33, 34, 35, 36, 37, 38]),
certs: nil
)
)
try assertRoundTrips(ocspRequest)
}
// TODO: Make these work.
#if false
func testResponderIDByNameRoundTrips() throws {
let id = ASN1.ResponderID.byName(
ASN1.DistinguishedName(elements: [
+19
View File
@@ -0,0 +1,19 @@
version: "3"
services:
runtime-setup:
image: swift-certificates:22.04-5.8
build:
args:
base_image: "swiftlang/swift:nightly-5.8-jammy"
test:
image: swift-certificates:22.04-5.8
environment:
- WARN_AS_ERROR_ARG=-Xswiftc -warnings-as-errors
- IMPORT_CHECK_ARG=--explicit-target-dependency-import-check error
# - SANITIZER_ARG=--sanitize=thread # TSan broken still
shell:
image: swift-certificates:22.04-5.8