Follow-up to #324: require CMake 3.29 instead of checking for CMP0157,
and leave `CMAKE_Swift_COMPILATION_MODE` to the caller. The toolchain
build passes it (swiftlang/swift#94066).
Tracking: swiftlang/swift#93995
assisted by Claude
Co-authored-by: Cory Benfield <lukasa@apple.com>
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.
Enable CMP0157 so Ninja compiles each Swift module in its own step,
separate from the link. Optimized configurations keep `-wmo`, as under
the old policy.
Tracking: swiftlang/swift#93995
assisted by Claude
## Motivation:
Swift Crypto 5 is released, but this package only accepts Swift Crypto
versions below 5.0.0, so projects cannot use the two together.
## Modifications:
Widen the accepted Swift Crypto versions to `..<"6.0.0"`, keeping the
existing lower bound.
## Result:
Projects can use Swift Crypto 5 with this package.
Replace repo-level CODE_OF_CONDUCT file with the inherited org-wide
[Code of
Conduct](https://github.com/apple/.github/blob/main/CODE_OF_CONDUCT.md)
in .github repo.
Co-authored-by: apple-ospo[bot] <326325757+apple-ospo[bot]@users.noreply.github.com>
### Motivation
`NameConstraintsPolicy` read an all-zero CIDR mask as matching nothing.
An all-zero mask constrains no bits, so it matches every address: the
CA/Browser Forum Baseline Requirements express "this subordinate CA must
not issue for IP addresses" as `excludedSubtrees` of `0.0.0.0/0` and
`::/0`, and against this code those exclusions constrained nothing, so a
leaf with an IP SAN under such a CA verified.
### Modifications
The leading-zero shortcut in `isValidCIDRMask` is removed and the
general leading-ones-then-zeros check decides. The two
`IPAddressNameTests` rows that pinned the old reading now expect a
match. `testAllZeroMaskIsValidCIDRMask` asserts the IPv4 and IPv6
all-zero masks directly, and two `RFC5280PolicyTests1` tests run
`RFC5280Policy` with `0.0.0.0/0` and `::/0` as permitted and as excluded
subtrees. All of them fail on main.
### Result
A `/0` iPAddress constraint covers the whole address space, as RFC 5280
4.2.1.10 defines it. `swift test` passes under the CI flags (`-Xswiftc
-warnings-as-errors --explicit-target-dependency-import-check error
-Xswiftc -require-explicit-sendable`) on Swift 6.1.2; `swift-format lint
--strict` is clean on the changed files.
---------
Co-authored-by: Raphael Hiesgen <r_hiesgen@apple.com>
### Motivation:
Building `_CertificateInternals` with library evolution enabled fails
because `_TinyArray` and its `@usableFromInline` storage are referenced
from `@inlinable` code while their layout and cases are not fixed.
### Modifications:
- Marked `_TinyArray` as `@frozen`.
- Marked its nested `Storage` enum as `@frozen`.
### Result:
`_CertificateInternals` now builds with library evolution enabled in
both Swift 5 and Swift 6 language modes.
Co-authored-by: Volodymyr Klymenko <ceo@build-succeeded.io>
Co-authored-by: Cory Benfield <lukasa@apple.com>
Co-authored-by: Raphael Hiesgen <r_hiesgen@apple.com>
Motivation:
The final release of Swift Crypto 5 is now available, so we don't need
the `SWIFT_CERTIFICATES_ALLOW_SWIFT_CRYPTO_BETA` env flag anymore and we
can accept the version range `"3.12.3"..<"6.0.0"`
Modifications:
Remove the `SWIFT_CERTIFICATES_ALLOW_SWIFT_CRYPTO_BETA` env var logic
and accept Swift Crypto `"3.12.3"..<"6.0.0"`
Result:
Projects can require both the final release of Swift Crypto 5 and the
latest Swift Certificates release
### Motivation
`CMSSignerInfo` could not round-trip `unsignedAttrs`: it serializes them
as `[1] IMPLICIT SET` but the DER and BER parsers asked for the inner
set with implicit tag `[0]`, so parsing any SignerInfo with unsigned
attributes threw `unexpectedFieldType: [1]`.
### Changes
Fixes issue #306 by:
- Correcting the `unsignedAttrs` inner set identifier from `[0]` to
`[1]` in the DER and BER initializers of `CMSSignerInfo`.
- Adding a round-trip unit test for a `CMSSignerInfo` carrying
`unsignedAttrs`.
### Result
`unsignedAttrs` now round-trip correctly; no behavior change to the
(already correct) serialized output.
### Motivation
Tagged releases can only have other tagged releases in their
dependencies. Tagging a package that depends on a swift-crypto beta and
swift-certificates requires a swift-certificates release that accepts a
swift-crypto beta release.
### Modifications
Introduce an environment flag that allows swift-certificates to depend
on swift-crypto beta releases.
### Results
Setting an environment flag can widen the upper limit of accepted
swift-cryto version to include 5.0.0 beta release.
- **Fix stale DocC disambiguation hash for PrivateKey init**
- **Fix documentation errors, typos, and a bug in
CertificateStore.appending**
- **code example fixes within the existing articles:**
- **Lots of smaller fixes across the board - some copy/pasta errors,
consistency in usage, typos and grammar issues - added documentation
comments where missing to get all public types covered - applied
internal style guidelines for representing the types**
---------
Co-authored-by: David Nadoba <dnadoba@gmail.com>
Co-authored-by: Cory Benfield <lukasa@apple.com>
Co-authored-by: Raphael <josephnoir@users.noreply.github.com>
Motivation
* The shared `macos_tests.yml` workflow no longer accepts
`xcode_16_2_build_arguments_override` and the `xcode_16_3` input is a
no-op. Passing the removed input causes CI to fail.
* Older Xcodes are being removed from the runners; Swift version inputs
are the replacement.
Modifications
* Replace `xcode_16_2/16_3_build_arguments_override` with
`swift_6_1/6_2/6_3_build_arguments_override` carrying the same
`-Xswiftc -Xfrontend -Xswiftc -require-explicit-sendable` value.
Result
* macOS CI passes again using the Swift version inputs.
## Summary
- Fixed typo in `SignatureAlgorithm.swift:180`: "unsupprted" →
"unsupported"
## Details
The error message thrown when an unsupported signature algorithm value
is encountered contained a spelling error. This has been corrected.
## Test plan
- Existing tests continue to pass
- The error message is only shown when an invalid algorithm is used, so
no new tests are needed
Motivation:
Swift 6.0 is no longer supported, we should bump the tools version and
remove it from our CI.
Modifications:
* Bump the Swift tools version to Swift 6.1
* Remove Swift 6.0 jobs where appropriate in main.yml, pull_request.yml
Result:
Code reflects our support window.
Motivation:
Swift 6.3 has been released, we should add it to our CI coverage.
Modifications:
Add additional Swift 6.3 jobs where appropriate in main.yml,
pull_request.yml
Result:
Improved test coverage.
Motivation
* Following [GitHub's
announcement](https://github.blog/changelog/2025-09-19-deprecation-of-node-20-on-github-actions-runners/),
Node 20 is being deprecated and runners will begin using Node 24 by
default starting March 4th, 2026. Node 20 will reach end-of-life in
April 2026.
Modifications
* Upgrade GitHub Actions to their latest versions to ensure
compatibility with Node 24.
* Replace `actions/checkout@v4` with `actions/checkout@v6` in all
workflow files.
Result
* Workflow files reference `actions/checkout@v6`.
Motivation
* `@main` references to `swiftlang/github-workflows` are deprecated.
Modifications
* Replace `@main` with `@0.0.7` in all workflow files.
Result
* Workflow files reference a pinned version of
`swiftlang/github-workflows`.
## Motivation:
In some cases a developer may want to sign a certificate using a method
other than a private key. For example: if a private key is protected by
hardware which signs asynchronously.
## Modifications:
- Create `CustomPrivateKey` protocol
- Create `async` initializers for `Certificate` and
`CertificateSigningRequest`.
- `CustomPrivateKey` can now back a`Certificate.PrivateKey`
- Make `Certificate.Signature` initializer public
## Result:
Developers can now sign a certificate with greater flexibility.
## Alternatives Considered:
### Implementations
#### Pass the `CustomPrivateKey` into `Certificate` and
`CertificateSigningRequest` initializers directly.
There is concern this could add too much duplication of api.
### Various names for the protocol:
- `Certificate.PrivateKeyProtocol` and
`Certificate.AsyncPrivateKeyProtocol`
- `Certificate.Signer`/`Certificate.AsyncSigner`
- `Certificate.SignatureProvider`/`Certificate.AsyncSignatureProvider`
---------
Co-authored-by: Cory Benfield <cbenfield@apple.com>
When `signingTime` was provided to `CMS.sign`, the
`additionalIntermediateCertificates`
parameter was not being forwarded to `signWithSigningTime`, causing
signature verification
to fail for certificates that require an intermediate CA chain.
Fixes#287
### Motivation
Signatures can be performed on any kind of data, e.g., to prove
ownership of the private key for a given certificate. This data usually
comes as a blob of bytes.
### Modification
Add a signature verification function that operates on bytes represented
by the `DataProtocol`. The bytes are converted to the signature type
matching the key and share an implementation with the verification
function for `Certificate.Signature`.
### Result
Easy validation of signatures represented as bytes.
---------
Co-authored-by: Cory Benfield <lukasa@apple.com>
Motivation:
The various 'withMumbleContinuation' APIs are supposed to be invoked
synchronously with the caller. This assumption allows a lock to be
acquired before the call and released from the body of the
'withMumbleContinuation' after e.g. storing the continuation. However
this isn't the case and the job may be re-enqueued on the executor
meaning that this is pattern is vulnerable to deadlocks.
Modifications:
- Drop and reacquire the lock in Promise
- Avoid resuming continuations while holding the lock
Result:
Lower chance of deadlock
Motivation:
Swift 5.10 is no longer supported. We should raise the minimum Swift
tools version to 6.0, fix consequent build warnings/errors, and remove
5.10 CI jobs.
Modifications:
- Raised the Swift tools version to 6.0 in both the main
`swift-certificates` package and the Benchmark package.
- Removed the now redundant `StrictConcurrency=complete` flag in
`swift-certificates`' `Package.swift`.
- Removed 5.10 CI job arguments.
- Removed 5.10 benchmark thresholds.
- Added an explicit type annotation to the `package-benchmark` setup
closure to address a build error.
- Updated `VerifierBenchmark` to use newer, non-deprecated
`RFC5280Policy` initializers (as a result of #276).
- Updated a test case in `Tests/X509Tests/PEMTests.swift` to no longer
use a deprecated `String` initializer.
Result:
Code reflects our support window.
### Motivation:
When loading a private key from disk as a `Certificate.PrivateKey` there
is no straight forward way to query the supported signature algorithms.
For signature algorithm negotiation, the raw values defined in RFC are
useful as well.
### Modifications:
Add a new property to query the supported signature algorithms for a
given key. Add a new property that translates a signature algorithm to
the respective value defined in RFC 8446.
### Results:
Working with certificate private keys and signature algorithms gets
easier.
Motivation:
swift-crypto just added `derRepresentation` to
`Curve25519.Signing.PrivateKey`, however swift-certificates already
provides the same API internally but returning an array of bytes (as
opposed to Data). This causes ambiguity in the swift-certificates tests.
Modifications:
- Specify the type to disambiguate. We do this rather than using the new
API as swift-crypto has stricter availability requirements which we
don't need to impose on our tests.
Result:
No ambiguity
### Motivation:
`LockStorage` has a redundant `@available(*, unavailable)` annotation
for `Sendable` conformance. Since `LockStorage` inherits from
`ManagedBuffer`, which is [already
non-Sendable](https://github.com/swiftlang/swift/blob/d7bb1fe25f4f50a08d9f6ec54768e08c90c17c9d/stdlib/public/core/ManagedBuffer.swift#L72),
this annotation is unnecessary and results in a warning.
### Modifications:
Removed the redundant non-Sendable annotation in `LockStorage`
### Result:
swift-certificates compiles warning-free
### Motivation:
New initializers for `ExpiryPolicy`, `RFC5280Policy`, and
`OCSPVerifierPolicy` were introduced in #266. These initializers were
added to prevent users from specifying `Date.now` as the time to
validate certificate expiry against. For context, the problem was that
`Date.now` would be evaluated at initialization, but validation could
occur at a later stage, at which point the validation time would become
stale.
These initializers had a `fixedValidationTime: Date? = nil` argument,
where a non-`nil` value denoted a *fixed* time to validate against, and
a `nil` value denoted that the current time, evaluated at the point of
validation, would be used for validation (the common case). Although the
dangers of specifying `fixedValidationTime = .now` were documented, in
practice, it is very easy for users to miss this and continue using the
API in an incorrect way.
Given that most users will validate certificate expiry against the
current time, we want to default to this and remove the validation time
argument from the public initializers entirely. Users who want to
specify a fixed predetermined time **must explicitly opt-in** by using
`@_spi(FixedExpiryValidationTime)` to access the initializers that have
a *non-optional* `fixedExpiryValidationTime` argument.
### Modifications:
- Deprecated the initializers of `RFC5280Policy` and
`OCSPVerifierPolicy` and introduced two new initializers for each: one
without a validation time argument (common case), and one with a
*non-optional* validation time argument guarded behind an SPI
- Updated the initializers of `ExpiryPolicy` (an internal type)
- Additional changes:
- Updated test cases to use new initializers
- Updated examples in documentation to use new initializers
### Result:
`RFC5280Policy` and `OCSPVerifierPolicy` can be used more safely
Motivation:
Swift 6.2 has been released, we should add it to our CI coverage.
Modifications:
Add additional Swift 6.2 jobs where appropriate in main.yml,
pull_request.yml
Result:
Improved test coverage.
### Motivation:
The certificate chain returned by validation has properties that are
currently not expressed in the API. Introducing a type that does so
allows other APIs to build on these properties.
### Modifications:
* Add a new `ValidatedCertificateChain` type and use it as a result type
for certificate validation. Since a validated chain always has at least
a leaf and a root, the type gives direct access to them.
* Deprecate the previous validate function and introduce a replacement.
Update use of the now-deprecated API and duplicate tests to include both
APIs.
### Result:
Certificate validation returns a type that conceptually holds meaning.
Motivation
While conceptually it is possible for verifier policies to have isolated
conformance, in practice the way PolicyBuilder is implemented makes that
nearly impossible. Given that the utility of an isolated VerifierPolicy
is very limited, let's just disallow it.
Modifications
Require VerifierPolicy to have a SendableMetatype
Result
Easier to build correct compositions over PolicyBuilder
### Motivation:
Some errors do not show up in debug builds. Enabling release mode builds
improves the CI coverage.
### Modifications:
Enable release mode builds for pull requests and scheduled builds on
main.
### Result:
Improved CI coverage.
Right now, `Certificate` uses the default implementations of `hash` and
`==`, which are member-wise.
We can make this more efficient by only comparing the raw bytes for the
TBS certificate, the signature, and the signature's algorithm.
## Motivation:
The initializers of `RFC5280Policy` and `OCSPPolicy` require a
validation time as an argument. If this argument is set to `Date.now`,
the timestamp would be captured at the point of initialization. As such,
if the validation method is invoked on the policy instance long after
initialization, the timestamp can become stale at that point. This means
that the validation function could incorrectly determine a certificate
(`RFC5280Policy`) or an OCSP response (`OCSPPolicy`) to be valid, when
it has actually expired by the time the validation is performed.
This is not an issue in common use-cases where the policy is initialized
(with `validationTime` set to `.now`) inside a `PolicyBuilder` closure,
because the closure is evaluated at the point of validation. However,
some use-cases may initialize the policy independently; the issue can
potentially arise here.
## Modifications:
This patch deprecates the current initializers of `RFC5280Policy` and
`OCSPPolicy` to guide users toward using a safer initializer which
requires a `fixedValidationTime: Date?` argument:
- Passing `nil` (default) will lead to the current time being obtained
*at the point of validation*. This will prevent the bug described above.
- Passing a specific `Date` instance preserves the ability to validate
against a fixed point in time, i.e. a time in the past or future, but
*not* the current time.
## Result:
Users now have the option to use a safer initializer to construct
`RFC5280Policy` and `OCSPPolicy`.
This PR introduces two key changes to improve flexibility when working
with signatures in swift-certificates. Previously, it was only possible
to verify signatures using `Certificate.PrivateKey`, but not to generate
them.
- The internal `sign(bytes:signatureAlgorithm:)` method on
`Certificate.PrivateKey` is now public, allowing users to generate
signatures directly.
- `Certificate.Signature` gains a new `rawRepresentation` property that
exposes the raw byte representation of a signature.
This PR removes `main` branch name from API docs URLs, making them
always point to the latest stable release instead of the main branch.
For most of developers this README.md is the main entry point when
installing the library, so pointing them to API docs for the latest
stable release makes more sense then the main branch which may contain
un-released API or breaking changes.
This change adds support for implementing a `CustomCertificateStore` in
a backwards compatible way with minimal impact to performance. A custom
certificate store can be implemented, and then the new
`CertificateStore(custom:)` constructor can be used so that the custom
certificate store can be used interchangeably with a "normal"
certificate store.
Additionally, a test case verifies that this new protocol will work for
our use case. More specifically, the use case we have is for
normalization of distinguished names so that an exact match of
distinguished names is no longer required. For example, if
`printableString` should be used interchangeably with a `utf8String`.
This pull request has two commits:
- One that adds support for a `CustomCertificateStore`
- One that modifies the implementation to support `async` lookup of
certificiates.
The second change is not required for our use-case, however I would
expect that there may be a future use-case that requires looking up
certificates in a database, and supporting an `async` protocol would be
valuable. Also, the `verify()` method is already async, so supporting an
`async` lookup does not disrupt any existing public APIs.
Much like OpenBSD, the FreeBSD pthread APIs are not imported with the
appropriate nullability annotations, so the base pthread mutex type
should be an optional value. Eventually we should provide API notes to
fix this issue, but that is not in place today.
See https://github.com/swiftlang/swift/issues/81407
Teach the CMake build to install swiftmodules using the full module
triple. This uses the compiler to determine the appropriate module
triple instead of attempting to compute the architecture in CMake
script, making the build more robust for new platforms and
architectures.
Also removing redundant policies. CMP0077 and CMP0091 were added before
the minimum CMake version and therefore will always be active in this
project.
Base on `macOS 11 and iOS 14 (iPadOS 14)`, I think the correct is
`macCatalyst 14` . Maybe it is a copy issue above available condition in
this file `@available(macOS 13.3, iOS 16.4, watchOS 9.4, tvOS 16.4,
macCatalyst 16.4, visionOS 1.0, *)` .
Motivation:
Swift 5.9 is no longer supported, we should bump the tools version and
remove it from our CI.
Modifications:
* Bump the Swift tools version to Swift 5.10
* Remove Swift 5.9 jobs where appropriate in main.yml, pull_request.yml
Result:
Code reflects our support window.