mirror of
https://github.com/apple/swift-crypto
synced 2026-11-22 04:30:39 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e15b6234fe | ||
|
|
3280a5f728 | ||
|
|
1fa43495bc | ||
|
|
9f96b82711 | ||
|
|
281a92df6c | ||
|
|
32adcc5038 | ||
|
|
1586608eee | ||
|
|
f8fad2f95a | ||
|
|
6ff0a3b147 | ||
|
|
ab0beab369 | ||
|
|
57de8e7cb8 | ||
|
|
6a032cf17d | ||
|
|
404c818e35 | ||
|
|
47df2f1f6d |
No files matched your search
@@ -14,6 +14,7 @@ jobs:
|
||||
with:
|
||||
license_header_check_project_name: "SwiftCrypto"
|
||||
docs_check_enabled: false
|
||||
format_check_container_image: "swift:latest"
|
||||
|
||||
unit-tests:
|
||||
name: Unit tests
|
||||
@@ -47,6 +48,10 @@ jobs:
|
||||
|
||||
cmake-checks:
|
||||
name: CMake checks
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
swift_version: ["6.2", "6.3", "6.4"]
|
||||
uses: apple/swift-nio/.github/workflows/cmake_tests.yml@main
|
||||
with:
|
||||
update_cmake_lists_config: >-
|
||||
@@ -61,7 +66,7 @@ jobs:
|
||||
{ "name": "CCryptoBoringSSL", "type": "assembly", "exceptions": [ "*/AES/*.swift" ] }
|
||||
]
|
||||
}
|
||||
image: swift:6.2
|
||||
image: "swift:${{ matrix.swift_version }}"
|
||||
|
||||
macos-tests:
|
||||
name: macOS tests
|
||||
|
||||
@@ -21,7 +21,7 @@ import FoundationEssentials
|
||||
import Foundation
|
||||
#endif
|
||||
|
||||
let benchmarks = {
|
||||
let benchmarks: @Sendable () -> Void = {
|
||||
let defaultMetrics: [BenchmarkMetric] = [.mallocCountTotal, .cpuTotal]
|
||||
|
||||
Benchmark(
|
||||
@@ -208,4 +208,145 @@ let benchmarks = {
|
||||
blackHole(try key1.sharedSecretFromKeyAgreement(with: key2.publicKey))
|
||||
}
|
||||
}
|
||||
|
||||
Benchmark(
|
||||
"hmac-sha256-authenticate",
|
||||
configuration: Benchmark.Configuration(
|
||||
metrics: defaultMetrics,
|
||||
scalingFactor: .mega,
|
||||
maxDuration: .seconds(10_000_000),
|
||||
maxIterations: 5
|
||||
)
|
||||
) { benchmark in
|
||||
let key = SymmetricKey(size: .bits256)
|
||||
let message = Data(repeating: 0x41, count: 1024)
|
||||
|
||||
benchmark.startMeasurement()
|
||||
|
||||
for _ in benchmark.scaledIterations {
|
||||
blackHole(HMAC<SHA256>.authenticationCode(for: message, using: key))
|
||||
}
|
||||
}
|
||||
|
||||
Benchmark(
|
||||
"hkdf-sha256-derive",
|
||||
configuration: Benchmark.Configuration(
|
||||
metrics: defaultMetrics,
|
||||
scalingFactor: .kilo,
|
||||
maxDuration: .seconds(10_000_000),
|
||||
maxIterations: 10
|
||||
)
|
||||
) { benchmark in
|
||||
let inputKeyMaterial = SymmetricKey(size: .bits256)
|
||||
let salt = Data("benchmark salt".utf8)
|
||||
let info = Data("benchmark info".utf8)
|
||||
|
||||
benchmark.startMeasurement()
|
||||
|
||||
for _ in benchmark.scaledIterations {
|
||||
blackHole(
|
||||
HKDF<SHA256>.deriveKey(
|
||||
inputKeyMaterial: inputKeyMaterial,
|
||||
salt: salt,
|
||||
info: info,
|
||||
outputByteCount: 1024
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
Benchmark(
|
||||
"aes-keywrap-unwrap",
|
||||
configuration: Benchmark.Configuration(
|
||||
metrics: defaultMetrics,
|
||||
scalingFactor: .mega,
|
||||
maxDuration: .seconds(10_000_000),
|
||||
maxIterations: 5
|
||||
)
|
||||
) { benchmark in
|
||||
let kek = SymmetricKey(size: .bits256)
|
||||
let wrapped = try AES.KeyWrap.wrap(SymmetricKey(size: .bits256), using: kek)
|
||||
|
||||
benchmark.startMeasurement()
|
||||
|
||||
for _ in benchmark.scaledIterations {
|
||||
blackHole(try AES.KeyWrap.unwrap(wrapped, using: kek))
|
||||
}
|
||||
}
|
||||
|
||||
if #available(macOS 26.0, *) {
|
||||
Benchmark(
|
||||
"mlkem768-decapsulate",
|
||||
configuration: Benchmark.Configuration(
|
||||
metrics: defaultMetrics,
|
||||
scalingFactor: .kilo,
|
||||
maxDuration: .seconds(10_000_000),
|
||||
maxIterations: 10
|
||||
)
|
||||
) { benchmark in
|
||||
let privateKey = try MLKEM768.PrivateKey()
|
||||
let encapsulated = try privateKey.publicKey.encapsulate().encapsulated
|
||||
|
||||
benchmark.startMeasurement()
|
||||
|
||||
for _ in benchmark.scaledIterations {
|
||||
blackHole(try privateKey.decapsulate(encapsulated))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Benchmark(
|
||||
"pbkdf2-sha256-derive",
|
||||
configuration: Benchmark.Configuration(
|
||||
metrics: defaultMetrics,
|
||||
scalingFactor: .kilo,
|
||||
maxDuration: .seconds(10_000_000),
|
||||
maxIterations: 10
|
||||
)
|
||||
) { benchmark in
|
||||
let password = Data("benchmark password".utf8)
|
||||
let salt = Data("benchmark salt".utf8)
|
||||
|
||||
benchmark.startMeasurement()
|
||||
|
||||
for _ in benchmark.scaledIterations {
|
||||
blackHole(
|
||||
try KDF.Insecure.PBKDF2.deriveKey(
|
||||
from: password,
|
||||
salt: salt,
|
||||
using: .sha256,
|
||||
outputByteCount: 32,
|
||||
unsafeUncheckedRounds: 1_000
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
Benchmark(
|
||||
"scrypt-derive",
|
||||
configuration: Benchmark.Configuration(
|
||||
metrics: defaultMetrics,
|
||||
scalingFactor: .kilo,
|
||||
maxDuration: .seconds(10_000_000),
|
||||
maxIterations: 3
|
||||
)
|
||||
) { benchmark in
|
||||
let password = Data("benchmark password".utf8)
|
||||
let salt = Data("benchmark salt".utf8)
|
||||
|
||||
benchmark.startMeasurement()
|
||||
|
||||
for _ in benchmark.scaledIterations {
|
||||
blackHole(
|
||||
try KDF.Scrypt.deriveKey(
|
||||
from: password,
|
||||
salt: salt,
|
||||
outputByteCount: 32,
|
||||
rounds: 1 << 10,
|
||||
blockSize: 8,
|
||||
parallelism: 1
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
+6
-8
@@ -12,7 +12,7 @@
|
||||
##
|
||||
##===----------------------------------------------------------------------===##
|
||||
|
||||
cmake_minimum_required(VERSION 3.15.1)
|
||||
cmake_minimum_required(VERSION 3.16)
|
||||
|
||||
if(POLICY CMP0157)
|
||||
cmake_policy(SET CMP0157 NEW)
|
||||
@@ -25,13 +25,8 @@ list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
|
||||
|
||||
include(SwiftSupport)
|
||||
|
||||
if(CMAKE_VERSION VERSION_LESS 3.16 AND CMAKE_SYSTEM_NAME STREQUAL Windows)
|
||||
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
|
||||
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
|
||||
else()
|
||||
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
|
||||
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
|
||||
endif()
|
||||
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
|
||||
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
|
||||
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
|
||||
set(CMAKE_Swift_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/swift)
|
||||
|
||||
@@ -79,5 +74,8 @@ if(NOT SwiftASN1_FOUND)
|
||||
FetchContent_MakeAvailable(ASN1)
|
||||
endif()
|
||||
|
||||
# Set after vending swift-asn1 so its targets keep their own language mode.
|
||||
set(CMAKE_Swift_LANGUAGE_VERSION 6)
|
||||
|
||||
add_subdirectory(Sources)
|
||||
add_subdirectory(cmake/modules)
|
||||
+2
-3
@@ -49,9 +49,8 @@ var swiftSettings: [SwiftSetting] = [
|
||||
swiftSettings.append(.enableExperimentalFeature("CheckImplementationOnly"))
|
||||
#endif
|
||||
|
||||
// This doesn't work when cross-compiling: the privacy manifest will be included in the Bundle and
|
||||
// Foundation will be linked. This is, however, strictly better than unconditionally adding the
|
||||
// resource.
|
||||
// A resource makes SwiftPM generate a `Bundle.module` accessor that imports Foundation, not just FoundationEssentials.
|
||||
// `canImport(Darwin)` checks the host, not the target, so cross-compiling from Darwin still adds the resource.
|
||||
#if canImport(Darwin)
|
||||
let privacyManifestExclude: [String] = []
|
||||
let privacyManifestResource: [PackageDescription.Resource] = [.copy("PrivacyInfo.xcprivacy")]
|
||||
|
||||
@@ -72,7 +72,7 @@ extension AES {
|
||||
/// - nonce: The nonce the sealing process requires.
|
||||
/// - authenticatedData: Additional data to be authenticated, if provided.
|
||||
/// - tag: receives the 16-byte authentication tag
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
public static func seal(
|
||||
@@ -127,7 +127,7 @@ extension AES {
|
||||
/// - authenticatedData: Additional data that was authenticated.
|
||||
///
|
||||
/// The call throws an error if decryption or authentication fail.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
public static func open(
|
||||
|
||||
@@ -59,7 +59,7 @@ enum OpenSSLAESGCMImpl {
|
||||
return AES.GCM.SealedBox(combined: combined, nonceByteCount: nonce.count)
|
||||
}
|
||||
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
@inlinable
|
||||
@@ -119,7 +119,7 @@ enum OpenSSLAESGCMImpl {
|
||||
}
|
||||
|
||||
/// Open a given message in place.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
@inlinable
|
||||
|
||||
@@ -48,7 +48,7 @@ extension BoringSSLAEAD {
|
||||
}
|
||||
|
||||
/// Seal a given message in place
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
func seal(
|
||||
@@ -93,7 +93,7 @@ extension BoringSSLAEAD {
|
||||
}
|
||||
|
||||
/// Open a given message in place.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
public func open(
|
||||
@@ -150,7 +150,7 @@ enum OpenSSLChaChaPolyImpl {
|
||||
return ChaChaPoly.SealedBox(combined: combined, nonceByteCount: nonce.count)
|
||||
}
|
||||
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
static func encrypt(
|
||||
@@ -211,7 +211,7 @@ enum OpenSSLChaChaPolyImpl {
|
||||
}
|
||||
}
|
||||
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
static func decrypt(
|
||||
|
||||
@@ -70,7 +70,7 @@ public enum ChaChaPoly: Cipher, Sendable {
|
||||
/// - nonce: The nonce the sealing process requires.
|
||||
/// - authenticatedData: Additional data to be authenticated.
|
||||
/// - tag: Will be updated with the 16-byte authentication tag.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
public static func seal(
|
||||
@@ -124,7 +124,7 @@ public enum ChaChaPoly: Cipher, Sendable {
|
||||
/// - authenticatedData: Additional data that was authenticated.
|
||||
///
|
||||
/// The call throws an error if decryption or authentication fail.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
public static func open(
|
||||
|
||||
@@ -98,6 +98,7 @@ add_library(Crypto
|
||||
"Signatures/MLDSA.swift"
|
||||
"Signatures/Signature.swift"
|
||||
"Util/ArraySpanHelpers.swift"
|
||||
"Util/Backports.swift"
|
||||
"Util/BoringSSL/CryptoKitErrors_boring.swift"
|
||||
"Util/BoringSSL/InlineArray+withBytes_boring.swift"
|
||||
"Util/BoringSSL/Optional+withUnsafeBytes_boring.swift"
|
||||
|
||||
@@ -33,7 +33,6 @@ import Foundation
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
extension MLKEM768 {
|
||||
/// A ML-KEM-768 private key.
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
struct InternalPrivateKey: @unchecked Sendable, KEMPrivateKey {
|
||||
private var backing: Backing
|
||||
|
||||
@@ -150,14 +149,14 @@ extension MLKEM768 {
|
||||
throw CryptoKitError.incorrectParameterSize
|
||||
}
|
||||
|
||||
var symmetricKeyData = Data(repeating: 0, count: MLKEM.sharedSecretByteCount)
|
||||
|
||||
let rc: CInt = symmetricKeyData.withUnsafeMutableBytes { symmetricKeyDataPtr in
|
||||
return try SymmetricKey(unsafeUninitializedCapacity: MLKEM.sharedSecretByteCount) {
|
||||
symmetricKeyDataPtr,
|
||||
count in
|
||||
let bytes: ContiguousBytes =
|
||||
encapsulated.regions.count == 1
|
||||
? encapsulated.regions.first!
|
||||
: Array(encapsulated)
|
||||
return bytes.withUnsafeBytes { encapsulatedPtr in
|
||||
let rc: CInt = bytes.withUnsafeBytes { encapsulatedPtr in
|
||||
CCryptoBoringSSL_MLKEM768_decap(
|
||||
symmetricKeyDataPtr.baseAddress,
|
||||
encapsulatedPtr.baseAddress,
|
||||
@@ -165,13 +164,13 @@ extension MLKEM768 {
|
||||
&self.key
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
guard rc == 1 else {
|
||||
throw CryptoKitError.internalBoringSSLError()
|
||||
}
|
||||
guard rc == 1 else {
|
||||
throw CryptoKitError.internalBoringSSLError()
|
||||
}
|
||||
|
||||
return SymmetricKey(data: symmetricKeyData)
|
||||
count = MLKEM.sharedSecretByteCount
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -180,7 +179,6 @@ extension MLKEM768 {
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
extension MLKEM768 {
|
||||
/// A ML-KEM-768 public key.
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
struct InternalPublicKey: @unchecked Sendable, KEMPublicKey {
|
||||
private var backing: Backing
|
||||
|
||||
@@ -302,7 +300,6 @@ extension MLKEM768 {
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
extension MLKEM1024 {
|
||||
/// A ML-KEM-1024 private key.
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
struct InternalPrivateKey: @unchecked Sendable, KEMPrivateKey {
|
||||
private var backing: Backing
|
||||
|
||||
@@ -419,14 +416,14 @@ extension MLKEM1024 {
|
||||
throw CryptoKitError.incorrectParameterSize
|
||||
}
|
||||
|
||||
var symmetricKeyData = Data(repeating: 0, count: MLKEM.sharedSecretByteCount)
|
||||
|
||||
let rc: CInt = symmetricKeyData.withUnsafeMutableBytes { symmetricKeyDataPtr in
|
||||
return try SymmetricKey(unsafeUninitializedCapacity: MLKEM.sharedSecretByteCount) {
|
||||
symmetricKeyDataPtr,
|
||||
count in
|
||||
let bytes: ContiguousBytes =
|
||||
encapsulated.regions.count == 1
|
||||
? encapsulated.regions.first!
|
||||
: Array(encapsulated)
|
||||
return bytes.withUnsafeBytes { encapsulatedPtr in
|
||||
let rc: CInt = bytes.withUnsafeBytes { encapsulatedPtr in
|
||||
CCryptoBoringSSL_MLKEM1024_decap(
|
||||
symmetricKeyDataPtr.baseAddress,
|
||||
encapsulatedPtr.baseAddress,
|
||||
@@ -434,13 +431,13 @@ extension MLKEM1024 {
|
||||
&self.key
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
guard rc == 1 else {
|
||||
throw CryptoKitError.internalBoringSSLError()
|
||||
}
|
||||
guard rc == 1 else {
|
||||
throw CryptoKitError.internalBoringSSLError()
|
||||
}
|
||||
|
||||
return SymmetricKey(data: symmetricKeyData)
|
||||
count = MLKEM.sharedSecretByteCount
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -449,7 +446,6 @@ extension MLKEM1024 {
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
extension MLKEM1024 {
|
||||
/// A ML-KEM-1024 public key.
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
struct InternalPublicKey: @unchecked Sendable, KEMPublicKey {
|
||||
private var backing: Backing
|
||||
|
||||
@@ -568,7 +564,6 @@ extension MLKEM1024 {
|
||||
private static let ciphertextByteCount = Int(MLKEM1024_CIPHERTEXT_BYTES)
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
enum MLKEM {
|
||||
/// The size of the seed in bytes.
|
||||
static let seedByteCount = 64
|
||||
|
||||
@@ -153,14 +153,14 @@ extension MLKEM${parameter_set} {
|
||||
throw CryptoKitError.incorrectParameterSize
|
||||
}
|
||||
|
||||
var symmetricKeyData = Data(repeating: 0, count: MLKEM.sharedSecretByteCount)
|
||||
|
||||
let rc: CInt = symmetricKeyData.withUnsafeMutableBytes { symmetricKeyDataPtr in
|
||||
return try SymmetricKey(unsafeUninitializedCapacity: MLKEM.sharedSecretByteCount) {
|
||||
symmetricKeyDataPtr,
|
||||
count in
|
||||
let bytes: ContiguousBytes =
|
||||
encapsulated.regions.count == 1
|
||||
? encapsulated.regions.first!
|
||||
: Array(encapsulated)
|
||||
return bytes.withUnsafeBytes { encapsulatedPtr in
|
||||
let rc: CInt = bytes.withUnsafeBytes { encapsulatedPtr in
|
||||
CCryptoBoringSSL_MLKEM${parameter_set}_decap(
|
||||
symmetricKeyDataPtr.baseAddress,
|
||||
encapsulatedPtr.baseAddress,
|
||||
@@ -168,13 +168,13 @@ extension MLKEM${parameter_set} {
|
||||
&self.key
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
guard rc == 1 else {
|
||||
throw CryptoKitError.internalBoringSSLError()
|
||||
}
|
||||
guard rc == 1 else {
|
||||
throw CryptoKitError.internalBoringSSLError()
|
||||
}
|
||||
|
||||
return SymmetricKey(data: symmetricKeyData)
|
||||
count = MLKEM.sharedSecretByteCount
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -189,6 +189,9 @@ extension P256 {
|
||||
self = try .init(rawRepresentation: parsed.privateKey)
|
||||
case "PRIVATE KEY":
|
||||
let parsed = try ASN1.PKCS8PrivateKey(asn1Encoded: Array(pem.derBytes))
|
||||
guard parsed.algorithm == .ecdsaP256 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: parsed.privateKey.privateKey)
|
||||
default:
|
||||
throw CryptoKitASN1Error.invalidPEMDocument
|
||||
@@ -209,6 +212,9 @@ extension P256 {
|
||||
|
||||
do {
|
||||
let key = try ASN1.PKCS8PrivateKey(asn1Encoded: bytes)
|
||||
guard key.algorithm == .ecdsaP256 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: key.privateKey.privateKey)
|
||||
} catch {
|
||||
let key = try ASN1.SEC1PrivateKey(asn1Encoded: bytes)
|
||||
@@ -413,6 +419,9 @@ extension P256 {
|
||||
self = try .init(rawRepresentation: parsed.privateKey)
|
||||
case "PRIVATE KEY":
|
||||
let parsed = try ASN1.PKCS8PrivateKey(asn1Encoded: Array(pem.derBytes))
|
||||
guard parsed.algorithm == .ecdsaP256 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: parsed.privateKey.privateKey)
|
||||
default:
|
||||
throw CryptoKitASN1Error.invalidPEMDocument
|
||||
@@ -433,6 +442,9 @@ extension P256 {
|
||||
|
||||
do {
|
||||
let key = try ASN1.PKCS8PrivateKey(asn1Encoded: bytes)
|
||||
guard key.algorithm == .ecdsaP256 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: key.privateKey.privateKey)
|
||||
} catch {
|
||||
let key = try ASN1.SEC1PrivateKey(asn1Encoded: bytes)
|
||||
@@ -636,6 +648,9 @@ extension P384 {
|
||||
self = try .init(rawRepresentation: parsed.privateKey)
|
||||
case "PRIVATE KEY":
|
||||
let parsed = try ASN1.PKCS8PrivateKey(asn1Encoded: Array(pem.derBytes))
|
||||
guard parsed.algorithm == .ecdsaP384 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: parsed.privateKey.privateKey)
|
||||
default:
|
||||
throw CryptoKitASN1Error.invalidPEMDocument
|
||||
@@ -656,6 +671,9 @@ extension P384 {
|
||||
|
||||
do {
|
||||
let key = try ASN1.PKCS8PrivateKey(asn1Encoded: bytes)
|
||||
guard key.algorithm == .ecdsaP384 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: key.privateKey.privateKey)
|
||||
} catch {
|
||||
let key = try ASN1.SEC1PrivateKey(asn1Encoded: bytes)
|
||||
@@ -860,6 +878,9 @@ extension P384 {
|
||||
self = try .init(rawRepresentation: parsed.privateKey)
|
||||
case "PRIVATE KEY":
|
||||
let parsed = try ASN1.PKCS8PrivateKey(asn1Encoded: Array(pem.derBytes))
|
||||
guard parsed.algorithm == .ecdsaP384 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: parsed.privateKey.privateKey)
|
||||
default:
|
||||
throw CryptoKitASN1Error.invalidPEMDocument
|
||||
@@ -880,6 +901,9 @@ extension P384 {
|
||||
|
||||
do {
|
||||
let key = try ASN1.PKCS8PrivateKey(asn1Encoded: bytes)
|
||||
guard key.algorithm == .ecdsaP384 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: key.privateKey.privateKey)
|
||||
} catch {
|
||||
let key = try ASN1.SEC1PrivateKey(asn1Encoded: bytes)
|
||||
@@ -1083,6 +1107,9 @@ extension P521 {
|
||||
self = try .init(rawRepresentation: parsed.privateKey)
|
||||
case "PRIVATE KEY":
|
||||
let parsed = try ASN1.PKCS8PrivateKey(asn1Encoded: Array(pem.derBytes))
|
||||
guard parsed.algorithm == .ecdsaP521 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: parsed.privateKey.privateKey)
|
||||
default:
|
||||
throw CryptoKitASN1Error.invalidPEMDocument
|
||||
@@ -1103,6 +1130,9 @@ extension P521 {
|
||||
|
||||
do {
|
||||
let key = try ASN1.PKCS8PrivateKey(asn1Encoded: bytes)
|
||||
guard key.algorithm == .ecdsaP521 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: key.privateKey.privateKey)
|
||||
} catch {
|
||||
let key = try ASN1.SEC1PrivateKey(asn1Encoded: bytes)
|
||||
@@ -1307,6 +1337,9 @@ extension P521 {
|
||||
self = try .init(rawRepresentation: parsed.privateKey)
|
||||
case "PRIVATE KEY":
|
||||
let parsed = try ASN1.PKCS8PrivateKey(asn1Encoded: Array(pem.derBytes))
|
||||
guard parsed.algorithm == .ecdsaP521 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: parsed.privateKey.privateKey)
|
||||
default:
|
||||
throw CryptoKitASN1Error.invalidPEMDocument
|
||||
@@ -1327,6 +1360,9 @@ extension P521 {
|
||||
|
||||
do {
|
||||
let key = try ASN1.PKCS8PrivateKey(asn1Encoded: bytes)
|
||||
guard key.algorithm == .ecdsaP521 else {
|
||||
throw CryptoKitASN1Error.invalidASN1Object
|
||||
}
|
||||
self = try .init(rawRepresentation: key.privateKey.privateKey)
|
||||
} catch {
|
||||
let key = try ASN1.SEC1PrivateKey(asn1Encoded: bytes)
|
||||
|
||||
@@ -48,7 +48,7 @@ public struct HKDF<H: HashFunction>: Sendable {
|
||||
/// - info: The shared information to use for key derivation.
|
||||
/// - outputKey: An output span that will be populated with the derived
|
||||
/// symmetric key.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(outputKey: copy outputKey)
|
||||
#endif
|
||||
public static func deriveKey(inputKeyMaterial: SymmetricKey,
|
||||
@@ -258,7 +258,7 @@ public struct HKDF<H: HashFunction>: Sendable {
|
||||
/// - outputByteCount: The length in bytes of the resulting symmetric key.
|
||||
///
|
||||
/// - Returns: The derived symmetric key.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(output: copy output)
|
||||
#endif
|
||||
public static func expand(pseudoRandomKey prk: RawSpan, info: RawSpan?, into output: inout OutputRawSpan) {
|
||||
|
||||
@@ -72,8 +72,8 @@ enum BoringSSLAESWRAPImpl {
|
||||
key: SymmetricKey,
|
||||
contiguousWrappedKey: WrappedKey
|
||||
) throws -> SymmetricKey {
|
||||
let unwrapped = try contiguousWrappedKey.withUnsafeBytes { inPtr in
|
||||
try [UInt8](unsafeUninitializedCapacity: inPtr.count) { outputPtr, count in
|
||||
try contiguousWrappedKey.withUnsafeBytes { inPtr in
|
||||
try SymmetricKey(unsafeUninitializedCapacity: inPtr.count) { outputPtr, count in
|
||||
let rc = try key.withUnsafeAESKEY(mode: .decrypting) { aesKey in
|
||||
CCryptoBoringSSL_AES_unwrap_key(
|
||||
aesKey,
|
||||
@@ -93,8 +93,6 @@ enum BoringSSLAESWRAPImpl {
|
||||
count = Int(rc)
|
||||
}
|
||||
}
|
||||
|
||||
return SymmetricKey(data: unwrapped)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -121,10 +121,10 @@ extension Curve25519.KeyAgreement {
|
||||
) throws
|
||||
-> SharedSecret
|
||||
{
|
||||
let sharedSecret = SecureBytes(
|
||||
let sharedSecret = try SecureBytes(
|
||||
unsafeUninitializedCapacity: Curve25519.KeyAgreement.keySizeBytes
|
||||
) { secretPointer, secretSize in
|
||||
self.key.withUnsafeBytes { privateKeyPointer in
|
||||
try self.key.withUnsafeBytes { privateKeyPointer in
|
||||
// We precondition on all of these sizes because bounds checking is cool.
|
||||
// These are fatal instead of guards because we allocated the secret (so it must be right),
|
||||
// we either allocated the private key or validated it on construction (so it must be right),
|
||||
@@ -133,16 +133,17 @@ extension Curve25519.KeyAgreement {
|
||||
precondition(privateKeyPointer.count == Curve25519.KeyAgreement.keySizeBytes)
|
||||
precondition(publicKeyShare.keyBytes.count == Curve25519.KeyAgreement.keySizeBytes)
|
||||
|
||||
// We don't check the return code here. This return code only validates that the generated secret is not the weak all-zero
|
||||
// secret (it is not possible for BoringSSL's X25519 implementation to fail, which is nice). There is currently what I would
|
||||
// politely describe as a "lack of consensus" as to whether crypto libraries should reject this secret. CryptoKit on Apple
|
||||
// platforms currently does not, so for the sake of conformance with our peer implementation I will also refuse to check it.
|
||||
// We may elect to revisit this decision if the security best-practice thinking changes.
|
||||
CCryptoBoringSSL_X25519(
|
||||
secretPointer.baseAddress,
|
||||
privateKeyPointer.baseAddress,
|
||||
publicKeyShare.keyBytes
|
||||
)
|
||||
// BoringSSL returns 0 when the peer's public key has low order, which makes the shared secret
|
||||
// the weak all-zero value. CryptoKit rejects that key agreement, so we do too.
|
||||
guard
|
||||
CCryptoBoringSSL_X25519(
|
||||
secretPointer.baseAddress,
|
||||
privateKeyPointer.baseAddress,
|
||||
publicKeyShare.keyBytes
|
||||
) == 1
|
||||
else {
|
||||
throw CryptoKitError.internalBoringSSLError()
|
||||
}
|
||||
}
|
||||
|
||||
secretSize = Curve25519.KeyAgreement.keySizeBytes // We always use all of it.
|
||||
|
||||
@@ -65,34 +65,24 @@ public struct HMAC<H: HashFunction>: MACAlgorithm, Sendable {
|
||||
#if os(iOS) && (arch(arm) || arch(i386))
|
||||
fatalError("Unsupported architecture")
|
||||
#else
|
||||
var innerKey = SecureBytes(capacity: H.blockByteCount) { keyOutput in
|
||||
if key.byteCount <= keyOutput.freeCapacity {
|
||||
keyOutput.append(contentsOf: key.bytes)
|
||||
} else if key.byteCount > H.blockByteCount {
|
||||
let hash = H.hash(bytes: key.bytes)
|
||||
hash.withUnsafeBytes {
|
||||
keyOutput.append(contentsOf: $0.bytes)
|
||||
}
|
||||
}
|
||||
keyOutput.append(repeating: 0, count: keyOutput.freeCapacity, as: UInt8.self)
|
||||
}
|
||||
var outerKey = innerKey
|
||||
|
||||
// HMAC(K, m) = H((K0 ^ opad) || H((K0 ^ ipad) || m)), where K0 is the
|
||||
// key normalized to the hash block size (RFC 2104).
|
||||
self.innerHasher = H()
|
||||
innerKey.withUnsafeMutableBytes {
|
||||
for i in 0 ..< $0.count {
|
||||
$0[i] ^= 0x36
|
||||
}
|
||||
}
|
||||
innerHasher.update(bytes: innerKey.bytes)
|
||||
|
||||
self.outerHasher = H()
|
||||
outerKey.withUnsafeMutableBytes {
|
||||
for i in 0 ..< $0.count {
|
||||
$0[i] ^= 0x5c
|
||||
withTemporaryZeroingAllocation(byteCount: H.blockByteCount, alignment: 1) { keyBlock in
|
||||
if key.byteCount <= keyBlock.freeCapacity {
|
||||
keyBlock.append(contentsOf: key.bytes)
|
||||
} else if key.byteCount > H.blockByteCount {
|
||||
H.hash(bytes: key.bytes).withBytes { keyBlock.append(contentsOf: $0) }
|
||||
}
|
||||
keyBlock.append(repeating: 0, count: keyBlock.freeCapacity, as: UInt8.self)
|
||||
|
||||
var k0 = keyBlock.mutableBytes
|
||||
for i in 0 ..< k0.byteCount { k0[i] ^= 0x36 } // apply ipad
|
||||
self.innerHasher.update(bytes: k0.bytes)
|
||||
for i in 0 ..< k0.byteCount { k0[i] ^= 0x36 ^ 0x5c } // undo ipad, apply opad
|
||||
self.outerHasher.update(bytes: k0.bytes)
|
||||
}
|
||||
outerHasher.update(data: outerKey)
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
@@ -57,7 +57,7 @@ extension ContiguousArray where Element == UInt8 {
|
||||
|
||||
extension OutputRawSpan {
|
||||
/// Append the contents of the given raw span to this output span.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(self: copy self)
|
||||
#endif
|
||||
mutating func append(contentsOf bytes: RawSpan) {
|
||||
@@ -69,7 +69,7 @@ extension OutputRawSpan {
|
||||
|
||||
extension OutputSpan<UInt8> {
|
||||
/// Append the contents of the given raw span to this output span.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(self: copy self)
|
||||
#endif
|
||||
mutating func append(contentsOf bytes: RawSpan) {
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the SwiftCrypto open source project
|
||||
//
|
||||
// Copyright (c) 2026 Apple Inc. and the SwiftCrypto project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#if canImport(FoundationEssentials)
|
||||
import FoundationEssentials
|
||||
#else
|
||||
import Foundation
|
||||
#endif
|
||||
|
||||
#if compiler(<6.4)
|
||||
@available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *)
|
||||
extension ContiguousBytes {
|
||||
func withBytes<R>(_ body: (RawSpan) throws -> R) rethrows -> R {
|
||||
try withUnsafeBytes { try body(RawSpan(_unsafeBytes: $0)) }
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *)
|
||||
extension MutableRawSpan {
|
||||
subscript(_ byteOffset: Int) -> UInt8 {
|
||||
get { unsafeLoad(fromByteOffset: byteOffset, as: UInt8.self) }
|
||||
@_lifetime(self: copy self)
|
||||
set { storeBytes(of: newValue, toByteOffset: byteOffset, as: UInt8.self) }
|
||||
}
|
||||
}
|
||||
#endif
|
||||
@@ -45,7 +45,7 @@ extension UnsafeMutableRawBufferPointer {
|
||||
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
extension MutableRawSpan {
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(self: copy self)
|
||||
#endif
|
||||
mutating func initializeWithRandomBytes(count: Int) {
|
||||
@@ -55,7 +55,7 @@ extension MutableRawSpan {
|
||||
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
extension OutputRawSpan {
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(self: copy self)
|
||||
#endif
|
||||
mutating func appendingRandomBytes(count: Int) {
|
||||
|
||||
@@ -28,7 +28,7 @@ protocol Zeroization {
|
||||
extension UnsafeMutablePointer: Zeroization {
|
||||
/// Zeroizes the pointee
|
||||
func zeroize() {
|
||||
let size = MemoryLayout.size(ofValue: Pointee.self)
|
||||
let size = MemoryLayout<Pointee>.size
|
||||
memset_s(self, size, 0, size)
|
||||
}
|
||||
}
|
||||
@@ -54,4 +54,26 @@ extension Data: Zeroization {
|
||||
}
|
||||
}
|
||||
|
||||
func withUnsafeTemporaryZeroingAllocation<R>(
|
||||
byteCount: Int,
|
||||
alignment: Int,
|
||||
_ body: (UnsafeMutableRawBufferPointer) throws -> R
|
||||
) rethrows -> R {
|
||||
try withUnsafeTemporaryAllocation(byteCount: byteCount, alignment: alignment) { buffer in
|
||||
defer { buffer.zeroize() }
|
||||
return try body(buffer)
|
||||
}
|
||||
}
|
||||
|
||||
func withTemporaryZeroingAllocation<R>(
|
||||
byteCount: Int,
|
||||
alignment: Int,
|
||||
_ body: (inout OutputRawSpan) throws -> R
|
||||
) rethrows -> R {
|
||||
try withUnsafeTemporaryZeroingAllocation(byteCount: byteCount, alignment: alignment) { buffer in
|
||||
var output = OutputRawSpan(buffer: buffer, initializedCount: 0)
|
||||
return try body(&output)
|
||||
}
|
||||
}
|
||||
|
||||
#endif // canImport(CryptoKit)
|
||||
@@ -153,7 +153,7 @@ extension BoringSSLAEAD.AEADContext {
|
||||
|
||||
/// Lowest level seal operation that calls into BoringSSL directly and
|
||||
/// operates on already-allocated memory.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(tag: copy tag)
|
||||
#endif
|
||||
public func seal(
|
||||
@@ -303,7 +303,7 @@ extension BoringSSLAEAD.AEADContext {
|
||||
}
|
||||
|
||||
/// Lowest level call into BoringSSL that decrypts in place.
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(message: copy message)
|
||||
#endif
|
||||
public func open(
|
||||
|
||||
@@ -77,10 +77,6 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try self.multiply(by: rhs, on: group, context: context)
|
||||
}
|
||||
|
||||
// This enhancement can only be present on 6.1 or later because of the
|
||||
// absence of https://github.com/swiftlang/swift/pull/76186 in older
|
||||
// compilers.
|
||||
#if compiler(>=6.1)
|
||||
@usableFromInline
|
||||
package consuming func multiplying(
|
||||
by rhs: ArbitraryPrecisionInteger,
|
||||
@@ -90,18 +86,6 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try self.multiply(by: rhs, on: group, context: context)
|
||||
return self
|
||||
}
|
||||
#else
|
||||
@usableFromInline
|
||||
package func multiplying(
|
||||
by rhs: ArbitraryPrecisionInteger,
|
||||
on group: BoringSSLEllipticCurveGroup,
|
||||
context: FiniteFieldArithmeticContext? = nil
|
||||
) throws -> EllipticCurvePoint {
|
||||
var `self` = self
|
||||
try self.multiply(by: rhs, on: group, context: context)
|
||||
return self
|
||||
}
|
||||
#endif
|
||||
|
||||
@usableFromInline
|
||||
package static func multiplying(
|
||||
@@ -134,10 +118,6 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try self.add(rhs, on: group, context: context)
|
||||
}
|
||||
|
||||
// This enhancement can only be present on 6.1 or later because of the
|
||||
// absence of https://github.com/swiftlang/swift/pull/76186 in older
|
||||
// compilers.
|
||||
#if compiler(>=6.1)
|
||||
@usableFromInline
|
||||
package consuming func adding(
|
||||
_ rhs: consuming EllipticCurvePoint,
|
||||
@@ -147,23 +127,7 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try self.add(rhs, on: group, context: context)
|
||||
return self
|
||||
}
|
||||
#else
|
||||
@usableFromInline
|
||||
package func adding(
|
||||
_ rhs: consuming EllipticCurvePoint,
|
||||
on group: BoringSSLEllipticCurveGroup,
|
||||
context: FiniteFieldArithmeticContext? = nil
|
||||
) throws -> EllipticCurvePoint {
|
||||
var `self` = self
|
||||
try self.add(rhs, on: group, context: context)
|
||||
return self
|
||||
}
|
||||
#endif
|
||||
|
||||
// This enhancement can only be present on 6.1 or later because of the
|
||||
// absence of https://github.com/swiftlang/swift/pull/76186 in older
|
||||
// compilers.
|
||||
#if compiler(>=6.1)
|
||||
@usableFromInline
|
||||
package static func adding(
|
||||
_ lhs: consuming EllipticCurvePoint,
|
||||
@@ -174,19 +138,6 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try lhs.add(rhs, on: group, context: context)
|
||||
return lhs
|
||||
}
|
||||
#else
|
||||
@usableFromInline
|
||||
package static func adding(
|
||||
_ lhs: EllipticCurvePoint,
|
||||
_ rhs: EllipticCurvePoint,
|
||||
on group: BoringSSLEllipticCurveGroup,
|
||||
context: FiniteFieldArithmeticContext? = nil
|
||||
) throws -> EllipticCurvePoint {
|
||||
var lhs = lhs
|
||||
try lhs.add(rhs, on: group, context: context)
|
||||
return lhs
|
||||
}
|
||||
#endif
|
||||
|
||||
@usableFromInline
|
||||
package mutating func invert(
|
||||
@@ -207,10 +158,6 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try self.invert(on: group, context: context)
|
||||
}
|
||||
|
||||
// This enhancement can only be present on 6.1 or later because of the
|
||||
// absence of https://github.com/swiftlang/swift/pull/76186 in older
|
||||
// compilers.
|
||||
#if compiler(>=6.1)
|
||||
@usableFromInline
|
||||
package consuming func inverting(
|
||||
on group: BoringSSLEllipticCurveGroup,
|
||||
@@ -219,22 +166,7 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try self.invert(on: group, context: context)
|
||||
return self
|
||||
}
|
||||
#else
|
||||
@usableFromInline
|
||||
package func inverting(
|
||||
on group: BoringSSLEllipticCurveGroup,
|
||||
context: FiniteFieldArithmeticContext? = nil
|
||||
) throws -> EllipticCurvePoint {
|
||||
var `self` = self
|
||||
try self.invert(on: group, context: context)
|
||||
return self
|
||||
}
|
||||
#endif
|
||||
|
||||
// This enhancement can only be present on 6.1 or later because of the
|
||||
// absence of https://github.com/swiftlang/swift/pull/76186 in older
|
||||
// compilers.
|
||||
#if compiler(>=6.1)
|
||||
@usableFromInline
|
||||
package static func inverting(
|
||||
_ point: consuming EllipticCurvePoint,
|
||||
@@ -244,18 +176,6 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try point.invert(on: group, context: context)
|
||||
return point
|
||||
}
|
||||
#else
|
||||
@usableFromInline
|
||||
package static func inverting(
|
||||
_ point: EllipticCurvePoint,
|
||||
on group: BoringSSLEllipticCurveGroup,
|
||||
context: FiniteFieldArithmeticContext? = nil
|
||||
) throws -> EllipticCurvePoint {
|
||||
var point = point
|
||||
try point.invert(on: group, context: context)
|
||||
return point
|
||||
}
|
||||
#endif
|
||||
|
||||
@usableFromInline
|
||||
package mutating func subtract(
|
||||
@@ -278,10 +198,6 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try self.subtract(rhs, on: group, context: context)
|
||||
}
|
||||
|
||||
// This enhancement can only be present on 6.1 or later because of the
|
||||
// absence of https://github.com/swiftlang/swift/pull/76186 in older
|
||||
// compilers.
|
||||
#if compiler(>=6.1)
|
||||
@usableFromInline
|
||||
package consuming func subtracting(
|
||||
_ rhs: consuming EllipticCurvePoint,
|
||||
@@ -291,23 +207,7 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try self.subtract(rhs, on: group, context: context)
|
||||
return self
|
||||
}
|
||||
#else
|
||||
@usableFromInline
|
||||
package func subtracting(
|
||||
_ rhs: EllipticCurvePoint,
|
||||
on group: BoringSSLEllipticCurveGroup,
|
||||
context: FiniteFieldArithmeticContext? = nil
|
||||
) throws -> EllipticCurvePoint {
|
||||
var `self` = self
|
||||
try self.subtract(rhs, on: group, context: context)
|
||||
return self
|
||||
}
|
||||
#endif
|
||||
|
||||
// This enhancement can only be present on 6.1 or later because of the
|
||||
// absence of https://github.com/swiftlang/swift/pull/76186 in older
|
||||
// compilers.
|
||||
#if compiler(>=6.1)
|
||||
@usableFromInline
|
||||
package static func subtracting(
|
||||
_ rhs: consuming EllipticCurvePoint,
|
||||
@@ -318,19 +218,6 @@ package struct EllipticCurvePoint: @unchecked Sendable {
|
||||
try lhs.subtract(rhs, on: group, context: context)
|
||||
return lhs
|
||||
}
|
||||
#else
|
||||
@usableFromInline
|
||||
package static func subtracting(
|
||||
_ rhs: EllipticCurvePoint,
|
||||
from lhs: EllipticCurvePoint,
|
||||
on group: BoringSSLEllipticCurveGroup,
|
||||
context: FiniteFieldArithmeticContext? = nil
|
||||
) throws -> EllipticCurvePoint {
|
||||
var lhs = lhs
|
||||
try lhs.subtract(rhs, on: group, context: context)
|
||||
return lhs
|
||||
}
|
||||
#endif
|
||||
|
||||
@usableFromInline
|
||||
package init<MessageBytes: ContiguousBytes, DSTBytes: ContiguousBytes>(
|
||||
|
||||
@@ -47,7 +47,7 @@ extension UnsafeMutableRawBufferPointer {
|
||||
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
extension OutputRawSpan {
|
||||
#if swift(<6.3)
|
||||
#if compiler(<6.3)
|
||||
@_lifetime(self: copy self)
|
||||
#endif
|
||||
package mutating func appendingRandomBytes(count: Int) {
|
||||
|
||||
@@ -71,10 +71,6 @@ extension AES {
|
||||
self.backing.update(bufferPointer)
|
||||
}
|
||||
|
||||
// This enhancement can only be present on 6.1 or later because of the
|
||||
// absence of https://github.com/swiftlang/swift/pull/76186 in older
|
||||
// compilers.
|
||||
#if compiler(>=6.1)
|
||||
/// Finalizes the message authentication computation and returns the
|
||||
/// computed code.
|
||||
///
|
||||
@@ -87,16 +83,6 @@ extension AES {
|
||||
self.cowIfNeeded()
|
||||
return self.backing.finalize()
|
||||
}
|
||||
#else
|
||||
/// Finalizes the message authentication computation and returns the
|
||||
/// computed code.
|
||||
///
|
||||
/// - Returns: The message authentication code.
|
||||
public func finalize() -> AES.CMAC.MAC {
|
||||
var `self` = self
|
||||
return self.backing.finalize()
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Updates the MAC with data.
|
||||
///
|
||||
|
||||
@@ -78,6 +78,7 @@ add_library(CryptoExtras
|
||||
"Util/ThreadSpecific/ThreadPosix.swift"
|
||||
"Util/ThreadSpecific/ThreadSpecific.swift"
|
||||
"Util/ThreadSpecific/ThreadWindows.swift"
|
||||
"Util/Zeroization.swift"
|
||||
"ZKPs/DLEQ.swift"
|
||||
"ZKPs/Prover.swift"
|
||||
"ZKPs/Verifier.swift"
|
||||
|
||||
@@ -72,16 +72,3 @@ final class BoringSSLSHA512256Context {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension UnsafeMutablePointer {
|
||||
fileprivate func zeroize() {
|
||||
let size = MemoryLayout.size(ofValue: Pointee.self)
|
||||
memset_s(self, size, 0, size)
|
||||
}
|
||||
}
|
||||
|
||||
extension UnsafeMutableRawBufferPointer {
|
||||
fileprivate func zeroize() {
|
||||
memset_s(self.baseAddress!, self.count, 0, self.count)
|
||||
}
|
||||
}
|
||||
@@ -43,8 +43,9 @@ internal struct BoringSSLPBKDF2 {
|
||||
outputByteCount: Int,
|
||||
rounds: Int
|
||||
) throws -> SymmetricKey {
|
||||
// This should be SecureBytes, but we can't use that here.
|
||||
// SecureBytes is internal to Crypto, so zero the buffer by hand once the key has been copied out.
|
||||
var derivedKeyData = Data(count: outputByteCount)
|
||||
defer { derivedKeyData.withUnsafeMutableBytes { $0.zeroize() } }
|
||||
|
||||
let rc = derivedKeyData.withUnsafeMutableBytes { derivedKeyBytes -> Int32 in
|
||||
let saltBytes: ContiguousBytes = salt.regions.count == 1 ? salt.regions.first! : Array(salt)
|
||||
|
||||
@@ -39,8 +39,9 @@ internal struct CommonCryptoPBKDF2 {
|
||||
outputByteCount: Int,
|
||||
rounds: Int
|
||||
) throws -> SymmetricKey {
|
||||
// This should be SecureBytes, but we can't use that here.
|
||||
// SecureBytes is internal to Crypto, so zero the buffer by hand once the key has been copied out.
|
||||
var derivedKeyData = Data(count: outputByteCount)
|
||||
defer { derivedKeyData.withUnsafeMutableBytes { $0.zeroize() } }
|
||||
|
||||
let derivationStatus = derivedKeyData.withUnsafeMutableBytes { derivedKeyBytes -> Int32 in
|
||||
let saltBytes: ContiguousBytes = salt.regions.count == 1 ? salt.regions.first! : Array(salt)
|
||||
|
||||
@@ -81,12 +81,25 @@ internal struct BoringSSLScrypt {
|
||||
parallelism: Int,
|
||||
maxMemory: Int? = nil
|
||||
) throws -> SymmetricKey {
|
||||
// This should be SecureBytes, but we can't use that here.
|
||||
// SecureBytes is internal to Crypto, so zero the buffer by hand once the key has been copied out.
|
||||
var derivedKeyData = Data(count: outputByteCount)
|
||||
defer { derivedKeyData.withUnsafeMutableBytes { $0.zeroize() } }
|
||||
|
||||
// This computes the maximum amount of memory that will be used by the scrypt algorithm with an additional memory page to spare. This value will be used by the BoringSSL as the memory limit for the algorithm.
|
||||
// An additional memory page is added to the computed value (using POSIX specification) to ensure that the memory limit is not too tight.
|
||||
let maxMemory = maxMemory ?? (128 * rounds * blockSize * parallelism + getPageSize())
|
||||
let memoryLimit: Int
|
||||
if let maxMemory {
|
||||
memoryLimit = maxMemory
|
||||
} else {
|
||||
// This computes the maximum amount of memory that will be used by the scrypt algorithm with an additional memory page to spare. This value will be used by the BoringSSL as the memory limit for the algorithm.
|
||||
// An additional memory page is added to the computed value (using POSIX specification) to ensure that the memory limit is not too tight.
|
||||
let (blockBytes, blockBytesOverflowed) = 128.multipliedReportingOverflow(by: blockSize)
|
||||
let (laneBytes, laneBytesOverflowed) = blockBytes.multipliedReportingOverflow(by: rounds)
|
||||
let (stateBytes, stateBytesOverflowed) = laneBytes.multipliedReportingOverflow(by: parallelism)
|
||||
let (computedLimit, computedLimitOverflowed) = stateBytes.addingReportingOverflow(getPageSize())
|
||||
guard !blockBytesOverflowed, !laneBytesOverflowed, !stateBytesOverflowed, !computedLimitOverflowed else {
|
||||
throw CryptoKitError.incorrectParameterSize
|
||||
}
|
||||
memoryLimit = computedLimit
|
||||
}
|
||||
|
||||
let result = derivedKeyData.withUnsafeMutableBytes { derivedKeyBytes -> Int32 in
|
||||
let saltBytes: ContiguousBytes = salt.regions.count == 1 ? salt.regions.first! : Array(salt)
|
||||
@@ -102,7 +115,7 @@ internal struct BoringSSLScrypt {
|
||||
UInt64(rounds),
|
||||
UInt64(blockSize),
|
||||
UInt64(parallelism),
|
||||
maxMemory,
|
||||
memoryLimit,
|
||||
derivedKeyBytes.baseAddress!,
|
||||
derivedKeyBytes.count
|
||||
)
|
||||
|
||||
@@ -35,10 +35,16 @@ extension KDF {
|
||||
/// - rounds: The number of rounds which should be used to perform key derivation. Must be a power of 2 less than `2^(128 * blockSize / 8)`.
|
||||
/// - blockSize: The block size to use for key derivation.
|
||||
/// - parallelism: The parallelism factor to use for key derivation. Must be a positive integer less than or equal to `((2^32 - 1) * 32) / (128 * blockSize)`.
|
||||
/// - maxMemory: The maximum amount of memory allowed to use for key derivation. If not provided, the default value is computed for the provided parameters.
|
||||
/// - maxMemory: The maximum amount of memory allowed to use for key derivation. Must be positive. If not provided, the default value is computed for the provided parameters.
|
||||
/// - Returns: The derived symmetric key.
|
||||
public static func deriveKey<Passphrase: DataProtocol, Salt: DataProtocol>(from password: Passphrase, salt: Salt, outputByteCount: Int, rounds: Int, blockSize: Int, parallelism: Int, maxMemory: Int? = nil) throws -> SymmetricKey {
|
||||
return try BackingScrypt.deriveKey(from: password, salt: salt, outputByteCount: outputByteCount, rounds: rounds, blockSize: blockSize, parallelism: parallelism)
|
||||
guard rounds > 0, blockSize > 0, parallelism > 0, outputByteCount >= 0 else {
|
||||
throw CryptoKitError.incorrectParameterSize
|
||||
}
|
||||
if let maxMemory, maxMemory <= 0 {
|
||||
throw CryptoKitError.incorrectParameterSize
|
||||
}
|
||||
return try BackingScrypt.deriveKey(from: password, salt: salt, outputByteCount: outputByteCount, rounds: rounds, blockSize: blockSize, parallelism: parallelism, maxMemory: maxMemory)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -530,7 +530,7 @@ extension _RSA.Signing {
|
||||
extension _RSA.Encryption {
|
||||
/// Identical to ``_RSA/Signing/PublicKey``.
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
public struct PublicKey {
|
||||
public struct PublicKey: Sendable {
|
||||
public struct Primitives: Sendable, Hashable {
|
||||
public var modulus: Data
|
||||
public var publicExponent: Data
|
||||
@@ -612,7 +612,7 @@ extension _RSA.Encryption {
|
||||
|
||||
/// Identical to ``_RSA/Signing/PrivateKey``.
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
public struct PrivateKey {
|
||||
public struct PrivateKey: Sendable {
|
||||
private var backing: BackingPrivateKey
|
||||
|
||||
/// Construct an RSA private key from a PEM representation.
|
||||
|
||||
@@ -19,14 +19,9 @@ import Foundation
|
||||
#endif
|
||||
|
||||
extension Data {
|
||||
// This enhancement can only be present on 6.1 or later because of the
|
||||
// absence of https://github.com/swiftlang/swift/pull/76186 in older
|
||||
// compilers.
|
||||
#if compiler(>=6.1)
|
||||
// This overload reduces allocations when used in a chain of infix operations.
|
||||
static func + (lhs: consuming Data, rhs: consuming Data) -> Data {
|
||||
lhs.append(contentsOf: rhs)
|
||||
return lhs
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the SwiftCrypto open source project
|
||||
//
|
||||
// Copyright (c) 2019-2020 Apple Inc. and the SwiftCrypto project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#if canImport(FoundationEssentials)
|
||||
import FoundationEssentials
|
||||
#else
|
||||
import Foundation
|
||||
#endif
|
||||
|
||||
protocol Zeroization {
|
||||
mutating func zeroize()
|
||||
}
|
||||
|
||||
extension UnsafeMutablePointer: Zeroization {
|
||||
/// Zeroizes the pointee
|
||||
func zeroize() {
|
||||
let size = MemoryLayout<Pointee>.size
|
||||
memset_s(self, size, 0, size)
|
||||
}
|
||||
}
|
||||
|
||||
extension UnsafeMutableRawBufferPointer: Zeroization {
|
||||
func zeroize() {
|
||||
memset_s(self.baseAddress!, self.count, 0, self.count)
|
||||
}
|
||||
}
|
||||
|
||||
extension Array: Zeroization where Element == UInt8 {
|
||||
/// Zeroizes the array
|
||||
mutating func zeroize() {
|
||||
memset_s(&self, self.count, 0, self.count)
|
||||
}
|
||||
}
|
||||
|
||||
extension Data: Zeroization {
|
||||
internal mutating func zeroize() {
|
||||
_ = self.withUnsafeMutableBytes {
|
||||
memset_s($0.baseAddress!, $0.count, 0, $0.count)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func withUnsafeTemporaryZeroingAllocation<R>(
|
||||
byteCount: Int,
|
||||
alignment: Int,
|
||||
_ body: (UnsafeMutableRawBufferPointer) throws -> R
|
||||
) rethrows -> R {
|
||||
try withUnsafeTemporaryAllocation(byteCount: byteCount, alignment: alignment) { buffer in
|
||||
defer { buffer.zeroize() }
|
||||
return try body(buffer)
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *)
|
||||
func withTemporaryZeroingAllocation<R>(
|
||||
byteCount: Int,
|
||||
alignment: Int,
|
||||
_ body: (inout OutputRawSpan) throws -> R
|
||||
) rethrows -> R {
|
||||
try withUnsafeTemporaryZeroingAllocation(byteCount: byteCount, alignment: alignment) { buffer in
|
||||
var output = OutputRawSpan(buffer: buffer, initializedCount: 0)
|
||||
return try body(&output)
|
||||
}
|
||||
}
|
||||
@@ -325,28 +325,3 @@ extension P384._ARCV1: ARCV1 {}
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P384: ARCCurve {}
|
||||
|
||||
|
||||
// Swift 5.10 compiler needs a little more help to infer the conformances.
|
||||
#if swift(<6.0)
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
fileprivate extension P256._ARCV1.PrivateKey {
|
||||
typealias H2G = P256._ARCV1.H2G
|
||||
typealias Credential = P256._ARCV1.Credential
|
||||
typealias PublicKey = P256._ARCV1.PublicKey
|
||||
typealias CredentialRequest = P256._ARCV1.CredentialRequest
|
||||
typealias CredentialResponse = P256._ARCV1.CredentialResponse
|
||||
typealias Presentation = P256._ARCV1.Presentation
|
||||
}
|
||||
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
fileprivate extension P384._ARCV1.PrivateKey {
|
||||
typealias H2G = P384._ARCV1.H2G
|
||||
typealias Credential = P384._ARCV1.Credential
|
||||
typealias PublicKey = P384._ARCV1.PublicKey
|
||||
typealias CredentialRequest = P384._ARCV1.CredentialRequest
|
||||
typealias CredentialResponse = P384._ARCV1.CredentialResponse
|
||||
typealias Presentation = P384._ARCV1.Presentation
|
||||
}
|
||||
#endif
|
||||
@@ -84,4 +84,70 @@ class ScryptTests: XCTestCase {
|
||||
try orFail { try self.testRFCVector(vector) }
|
||||
}
|
||||
}
|
||||
|
||||
func testDeriveKeyWithMaxMemoryBelowRequirementThrows() throws {
|
||||
let password = Array("password".utf8)
|
||||
let salt = Array("salt".utf8)
|
||||
|
||||
// These parameters need 128 * blockSize * (rounds + parallelism + 1) bytes, just over 1 MiB.
|
||||
// BoringSSL reads a limit of zero as "use the default limit", and a negative limit as a huge size_t.
|
||||
for maxMemory in [1024, 0, -1] {
|
||||
XCTAssertThrowsError(
|
||||
try KDF.Scrypt.deriveKey(
|
||||
from: password,
|
||||
salt: salt,
|
||||
outputByteCount: 32,
|
||||
rounds: 1024,
|
||||
blockSize: 8,
|
||||
parallelism: 1,
|
||||
maxMemory: maxMemory
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
let bounded = try KDF.Scrypt.deriveKey(
|
||||
from: password,
|
||||
salt: salt,
|
||||
outputByteCount: 32,
|
||||
rounds: 1024,
|
||||
blockSize: 8,
|
||||
parallelism: 1,
|
||||
maxMemory: 2 << 20
|
||||
)
|
||||
let unbounded = try KDF.Scrypt.deriveKey(
|
||||
from: password,
|
||||
salt: salt,
|
||||
outputByteCount: 32,
|
||||
rounds: 1024,
|
||||
blockSize: 8,
|
||||
parallelism: 1
|
||||
)
|
||||
XCTAssertEqual(bounded, unbounded)
|
||||
}
|
||||
|
||||
func testDeriveKeyWithOutOfRangeParametersThrows() throws {
|
||||
let password = Array("password".utf8)
|
||||
let salt = Array("salt".utf8)
|
||||
|
||||
for (rounds, blockSize, parallelism, outputByteCount) in [
|
||||
// Negative values reach UInt64 conversions and Data(count:), both of which trap.
|
||||
(-1, 8, 1, 32),
|
||||
(1024, -1, 1, 32),
|
||||
(1024, 8, -1, 32),
|
||||
(1024, 8, 1, -1),
|
||||
// 128 * blockSize * rounds * parallelism overflows Int.
|
||||
(1 << 32, 1 << 30, 1, 32),
|
||||
] {
|
||||
XCTAssertThrowsError(
|
||||
try KDF.Scrypt.deriveKey(
|
||||
from: password,
|
||||
salt: salt,
|
||||
outputByteCount: outputByteCount,
|
||||
rounds: rounds,
|
||||
blockSize: blockSize,
|
||||
parallelism: parallelism
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -248,6 +248,13 @@ final class TestRSAEncryption: XCTestCase {
|
||||
XCTAssertEqual(191, publicKey.maximumEncryptSize(with: .PKCS1_OAEP_SHA256))
|
||||
}
|
||||
|
||||
func testKeysAreSendable() {
|
||||
func assertSendable<T: Sendable>(_: T.Type) {}
|
||||
|
||||
assertSendable(_RSA.Encryption.PublicKey.self)
|
||||
assertSendable(_RSA.Encryption.PrivateKey.self)
|
||||
}
|
||||
|
||||
func testPKCS1() throws {
|
||||
let pubKeyPEM = """
|
||||
-----BEGIN RSA PUBLIC KEY-----
|
||||
|
||||
@@ -219,6 +219,43 @@ class ASN1Tests: XCTestCase {
|
||||
XCTAssertEqual(serializer.serializedBytes, decodedPrivateKey)
|
||||
}
|
||||
|
||||
func testPKCS8PrivateKeyWithMismatchedCurveIsRejected() throws {
|
||||
func pkcs8(_ algorithm: ASN1.RFC5480AlgorithmIdentifier, _ privateKey: Data, _ publicKey: Data) throws -> (der: Data, pem: String) {
|
||||
let pkey = ASN1.PKCS8PrivateKey(algorithm: algorithm, privateKey: Array(privateKey), publicKey: Array(publicKey))
|
||||
var serializer = ASN1.Serializer()
|
||||
try serializer.serialize(pkey)
|
||||
let der = Data(serializer.serializedBytes)
|
||||
return (der, ASN1.PEMDocument(type: "PRIVATE KEY", derBytes: der).pemString)
|
||||
}
|
||||
|
||||
let p256 = P256.Signing.PrivateKey()
|
||||
let p384 = P384.Signing.PrivateKey()
|
||||
let p521 = P521.Signing.PrivateKey()
|
||||
|
||||
let p256InP384 = try pkcs8(.ecdsaP384, p256.rawRepresentation, p256.publicKey.x963Representation)
|
||||
XCTAssertThrowsError(try P256.Signing.PrivateKey(derRepresentation: p256InP384.der))
|
||||
XCTAssertThrowsError(try P256.Signing.PrivateKey(pemRepresentation: p256InP384.pem))
|
||||
XCTAssertThrowsError(try P256.KeyAgreement.PrivateKey(derRepresentation: p256InP384.der))
|
||||
XCTAssertThrowsError(try P256.KeyAgreement.PrivateKey(pemRepresentation: p256InP384.pem))
|
||||
|
||||
let p384InP521 = try pkcs8(.ecdsaP521, p384.rawRepresentation, p384.publicKey.x963Representation)
|
||||
XCTAssertThrowsError(try P384.Signing.PrivateKey(derRepresentation: p384InP521.der))
|
||||
XCTAssertThrowsError(try P384.Signing.PrivateKey(pemRepresentation: p384InP521.pem))
|
||||
XCTAssertThrowsError(try P384.KeyAgreement.PrivateKey(derRepresentation: p384InP521.der))
|
||||
XCTAssertThrowsError(try P384.KeyAgreement.PrivateKey(pemRepresentation: p384InP521.pem))
|
||||
|
||||
let p521InP256 = try pkcs8(.ecdsaP256, p521.rawRepresentation, p521.publicKey.x963Representation)
|
||||
XCTAssertThrowsError(try P521.Signing.PrivateKey(derRepresentation: p521InP256.der))
|
||||
XCTAssertThrowsError(try P521.Signing.PrivateKey(pemRepresentation: p521InP256.pem))
|
||||
XCTAssertThrowsError(try P521.KeyAgreement.PrivateKey(derRepresentation: p521InP256.der))
|
||||
XCTAssertThrowsError(try P521.KeyAgreement.PrivateKey(pemRepresentation: p521InP256.pem))
|
||||
|
||||
// The correctly labelled encodings still load.
|
||||
let p256InP256 = try pkcs8(.ecdsaP256, p256.rawRepresentation, p256.publicKey.x963Representation)
|
||||
XCTAssertEqual(try P256.Signing.PrivateKey(derRepresentation: p256InP256.der).rawRepresentation, p256.rawRepresentation)
|
||||
XCTAssertEqual(try P256.KeyAgreement.PrivateKey(pemRepresentation: p256InP256.pem).rawRepresentation, p256.rawRepresentation)
|
||||
}
|
||||
|
||||
func testRejectDripFedASN1SPKIP256() throws {
|
||||
// This test drip-feeds an ASN.1 P256 SPKI block. It should never parse correctly until we feed the entire block.
|
||||
let encodedSPKI = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2adMrdG7aUfZH57aeKFFM01dPnkxC18ScRb4Z6poMBgJtYlVtd9ly63URv57ZW0Ncs1LiZB7WATb3svu+1c7HQ=="
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the SwiftCrypto open source project
|
||||
//
|
||||
// Copyright (c) 2026 Apple Inc. and the SwiftCrypto project authors
|
||||
// Licensed under Apache License v2.0
|
||||
//
|
||||
// See LICENSE.txt for license information
|
||||
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
import XCTest
|
||||
|
||||
#if canImport(CryptoKit)
|
||||
// Skip tests that require @testable imports of CryptoKit.
|
||||
#else
|
||||
@testable import Crypto
|
||||
|
||||
extension X25519Tests {
|
||||
func testKeyAgreementWithLowOrderPublicKeyThrows() throws {
|
||||
// The vectors whose shared secret is all-zero: the seven low-order u-coordinates, which are
|
||||
// 0, 1, both points of order 8, p-1, p and p+1, plus a non-canonical spelling of each.
|
||||
try wycheproofTest(
|
||||
bundleType: self,
|
||||
jsonName: "x25519_test",
|
||||
testFunction: { (group: ECDHTestGroup) in
|
||||
let zeroSharedSecretTests = group.tests.filter { $0.flags.contains("ZeroSharedSecret") }
|
||||
XCTAssert(!zeroSharedSecretTests.isEmpty)
|
||||
|
||||
for testVector in zeroSharedSecretTests {
|
||||
// The public key itself is accepted, as it is by CryptoKit; only the agreement fails.
|
||||
let publicKey = try Curve25519.KeyAgreement.PublicKey(
|
||||
rawRepresentation: Array(hexString: testVector.publicKey)
|
||||
)
|
||||
let privateKey = try Curve25519.KeyAgreement.PrivateKey(
|
||||
rawRepresentation: Array(hexString: testVector.privateKey)
|
||||
)
|
||||
XCTAssertThrowsError(
|
||||
try privateKey.sharedSecretFromKeyAgreement(with: publicKey),
|
||||
"tcId \(testVector.tcId)"
|
||||
)
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#endif // canImport(CryptoKit)
|
||||
@@ -217,6 +217,12 @@ final class SecureBytesTests: XCTestCase {
|
||||
XCTAssertEqual(base.count, 22)
|
||||
XCTAssertEqual(Array(copy), [0, 1, 2, 3, 4])
|
||||
}
|
||||
|
||||
func testZeroizePointerToMultiWordValueClearsAllBytes() {
|
||||
var value: (UInt64, UInt64, UInt64, UInt64) = (1, 2, 3, 4)
|
||||
withUnsafeMutablePointer(to: &value) { $0.zeroize() }
|
||||
XCTAssertEqual(withUnsafeBytes(of: value) { Array($0) }, Array(repeating: UInt8(0), count: 32))
|
||||
}
|
||||
}
|
||||
|
||||
#endif // canImport(CryptoKit)
|
||||
@@ -34,7 +34,6 @@ struct RFCVectorDecoder {
|
||||
for _ in 0..<3 {
|
||||
fileURL!.deleteLastPathComponent()
|
||||
}
|
||||
#if compiler(>=6.0)
|
||||
if #available(macOS 13, iOS 16, watchOS 9, tvOS 16, visionOS 1, macCatalyst 16, *) {
|
||||
fileURL!.append(path: "Test Vectors", directoryHint: .isDirectory)
|
||||
fileURL!.append(path: "\(fileName).txt", directoryHint: .notDirectory)
|
||||
@@ -42,10 +41,6 @@ struct RFCVectorDecoder {
|
||||
fileURL! = fileURL!.appendingPathComponent("Test Vectors", isDirectory: true)
|
||||
fileURL! = fileURL!.appendingPathComponent("\(fileName).txt", isDirectory: false)
|
||||
}
|
||||
#else
|
||||
fileURL! = fileURL!.appendingPathComponent("Test Vectors", isDirectory: true)
|
||||
fileURL! = fileURL!.appendingPathComponent("\(fileName).txt", isDirectory: false)
|
||||
#endif
|
||||
|
||||
let rfcVectorData = try Data(contentsOf: fileURL!)
|
||||
self.rfcVectorData = String(decoding: rfcVectorData, as: Unicode.UTF8.self)
|
||||
|
||||
@@ -26,7 +26,6 @@ extension XCTestCase {
|
||||
for _ in 0..<3 {
|
||||
fileURL.deleteLastPathComponent()
|
||||
}
|
||||
#if compiler(>=6.0)
|
||||
if #available(macOS 13, iOS 16, watchOS 9, tvOS 16, visionOS 1, macCatalyst 16, *) {
|
||||
fileURL.append(path: "Test Vectors", directoryHint: .isDirectory)
|
||||
fileURL.append(path: "\(jsonName).json", directoryHint: .notDirectory)
|
||||
@@ -34,10 +33,6 @@ extension XCTestCase {
|
||||
fileURL = fileURL.appendingPathComponent("Test Vectors", isDirectory: true)
|
||||
fileURL = fileURL.appendingPathComponent("\(jsonName).json", isDirectory: false)
|
||||
}
|
||||
#else
|
||||
fileURL = fileURL.appendingPathComponent("Test Vectors", isDirectory: true)
|
||||
fileURL = fileURL.appendingPathComponent("\(jsonName).json", isDirectory: false)
|
||||
#endif
|
||||
|
||||
let data = try orFail(file: file, line: line) { try Data(contentsOf: unwrap(fileURL, file: file, line: line)) }
|
||||
|
||||
|
||||
Reference in new issue
Block a user