1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
//===----------------------------------------------------------------------===//
//
// 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.md for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
#if CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
@_exported import CryptoKit
#else
import Foundation
// MARK: - Generated file, do NOT edit
// any edits of this file WILL be overwritten and thus discarded
// see section `gyb` in `README` for details.
%{
NIST_CURVES_AND_HF = [{"curve": "P256", "hf": "SHA256"},{"curve": "P384", "hf": "SHA384"},{"curve": "P521", "hf": "SHA512"}]
}%
protocol NISTECDSASignature {
init<D: DataProtocol>(rawRepresentation: D) throws
init<D: DataProtocol>(derRepresentation: D) throws
var derRepresentation: Data { get }
var rawRepresentation: Data { get }
}
protocol NISTSigning {
associatedtype PublicKey: NISTECPublicKey & DataValidator & DigestValidator
associatedtype PrivateKey: NISTECPrivateKey & Signer
associatedtype ECDSASignature: NISTECDSASignature
}
% for CURVE_AND_HF in NIST_CURVES_AND_HF:
%{
CURVE = CURVE_AND_HF["curve"]
HF = CURVE_AND_HF["hf"]
DISPLAY_CURVE = CURVE[:1] + "-" + CURVE[1:]
DISPLAY_HF = HF[:3] + "-" + HF[3:]
}%
// MARK: - ${CURVE} + Signing
extension ${CURVE}.Signing {
/// A ${DISPLAY_CURVE} elliptic curve digital signature algorithm (ECDSA) signature.
public struct ECDSASignature: ContiguousBytes, NISTECDSASignature {
/// A raw data representation of a ${DISPLAY_CURVE} digital signature.
public var rawRepresentation: Data
/// Creates a ${DISPLAY_CURVE} digital signature from a raw representation.
///
/// - Parameters:
/// - rawRepresentation: A raw representation of the signature as a
/// collection of contiguous bytes.
public init<D: DataProtocol>(rawRepresentation: D) throws {
guard rawRepresentation.count == 2 * ${CURVE}.coordinateByteCount else {
throw CryptoKitError.incorrectParameterSize
}
self.rawRepresentation = Data(rawRepresentation)
}
internal init(_ dataRepresentation: Data) throws {
guard dataRepresentation.count == 2 * ${CURVE}.coordinateByteCount else {
throw CryptoKitError.incorrectParameterSize
}
self.rawRepresentation = dataRepresentation
}
var composite: (r: Data, s: Data) {
let combined = rawRepresentation
assert(combined.count % 2 == 0)
let half = combined.count / 2
return (combined.prefix(upTo: half), combined.suffix(from: half))
}
/// Creates a ${DISPLAY_CURVE} digital signature from a Distinguished Encoding
/// Rules (DER) encoded representation.
///
/// - Parameters:
/// - derRepresentation: The DER-encoded representation of the
/// signature.
public init<D: DataProtocol>(derRepresentation: D) throws {
#if os(iOS) && (arch(arm) || arch(i386))
fatalError("Unsupported architecture")
#else
let parsed = try ASN1.parse(Array(derRepresentation))
let signature = try ASN1.ECDSASignature<ArraySlice<UInt8>>(asn1Encoded: parsed)
let coordinateByteCount = ${CURVE}.coordinateByteCount
guard signature.r.count <= coordinateByteCount && signature.s.count <= coordinateByteCount else {
throw CryptoKitError.incorrectParameterSize
}
// r and s must be padded out to the coordinate byte count.
var raw = Data()
raw.reserveCapacity(2 * ${CURVE}.coordinateByteCount)
raw.append(contentsOf: repeatElement(0, count: ${CURVE}.coordinateByteCount - signature.r.count))
raw.append(contentsOf: signature.r)
raw.append(contentsOf: repeatElement(0, count: ${CURVE}.coordinateByteCount - signature.s.count))
raw.append(contentsOf: signature.s)
self.rawRepresentation = raw
#endif
}
/// Invokes the given closure with a buffer pointer covering the raw
/// bytes of the signature.
public func withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R {
try self.rawRepresentation.withUnsafeBytes(body)
}
/// A Distinguished Encoding Rules (DER) encoded representation of a
/// ${DISPLAY_CURVE} digital signature.
public var derRepresentation: Data {
#if os(iOS) && (arch(arm) || arch(i386))
fatalError("Unsupported architecture")
#else
let raw = rawRepresentation
let half = raw.count / 2
let r = Array(raw.prefix(upTo: half))[...]
let s = Array(raw.suffix(from: half))[...]
let sig = ASN1.ECDSASignature(r: r, s: s)
var serializer = ASN1.Serializer()
try! serializer.serialize(sig)
return Data(serializer.serializedBytes)
#endif
}
}
}
extension ${CURVE}.Signing: NISTSigning {}
// MARK: - ${CURVE} + PrivateKey
extension ${CURVE}.Signing.PrivateKey: DigestSigner {
/// Generates an Elliptic Curve Digital Signature Algorithm (ECDSA)
/// signature of the digest you provide over the ${DISPLAY_CURVE} elliptic curve.
///
/// - Parameters:
/// - digest: The digest of the data to sign.
/// - Returns: The signature corresponding to the digest. The signing
/// algorithm employs randomization to generate a different signature on
/// every call, even for the same data and key.
public func signature<D: Digest>(for digest: D) throws -> ${CURVE}.Signing.ECDSASignature {
#if !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
return try self.coreCryptoSignature(for: digest)
#else
return try self.openSSLSignature(for: digest)
#endif
}
}
extension ${CURVE}.Signing.PrivateKey: Signer {
/// Generates an Elliptic Curve Digital Signature Algorithm (ECDSA)
/// signature of the data you provide over the ${DISPLAY_CURVE} elliptic curve,
/// using ${DISPLAY_HF} as the hash function.
///
/// - Parameters:
/// - data: The data to sign.
/// - Returns: The signature corresponding to the data. The signing
/// algorithm employs randomization to generate a different signature on
/// every call, even for the same data and key.
public func signature<D: DataProtocol>(for data: D) throws -> ${CURVE}.Signing.ECDSASignature {
return try self.signature(for: ${HF}.hash(data: data))
}
}
extension ${CURVE}.Signing.PublicKey: DigestValidator {
/// Verifies an elliptic curve digital signature algorithm (ECDSA)
/// signature on a digest over the ${DISPLAY_CURVE} elliptic curve.
///
/// - Parameters:
/// - signature: The signature to verify.
/// - digest: The signed digest.
/// - Returns: A Boolean value that’s `true` if the signature is valid for
/// the given digest; otherwise, `false`.
public func isValidSignature<D: Digest>(_ signature: ${CURVE}.Signing.ECDSASignature, for digest: D) -> Bool {
#if !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
return self.coreCryptoIsValidSignature(signature, for: digest)
#else
return self.openSSLIsValidSignature(signature, for: digest)
#endif
}
}
extension ${CURVE}.Signing.PublicKey: DataValidator {
/// Verifies an elliptic curve digital signature algorithm (ECDSA)
/// signature on a block of data over the ${DISPLAY_CURVE} elliptic curve.
///
/// - Parameters:
/// - signature: The signature to verify.
/// - data: The signed data.
/// - Returns: A Boolean value that’s `true` if the signature is valid for
/// the given data; otherwise, `false`.
public func isValidSignature<D: DataProtocol>(_ signature: ${CURVE}.Signing.ECDSASignature, for data: D) -> Bool {
return self.isValidSignature(signature, for: ${HF}.hash(data: data))
}
}
% end
#endif // Linux or !SwiftPM
|
