475 lines
20 KiB
Swift
475 lines
20 KiB
Swift
// Copyright © 2019 IBM. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
import Foundation
|
|
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
|
|
import CommonCrypto
|
|
#elseif os(Linux)
|
|
import OpenSSL
|
|
#endif
|
|
|
|
|
|
/**
|
|
Represents an elliptic curve private key.
|
|
Supported curves are:
|
|
- prime256v1
|
|
- secp384r1
|
|
- NID_secp521r1
|
|
You can generate an elliptic curve Key using OpenSSL:
|
|
https://wiki.openssl.org/index.php/Command_Line_Elliptic_Curve_Operations#Generating_EC_Keys_and_Parameters
|
|
|
|
### Usage Example:
|
|
```swift
|
|
let pemKey = """
|
|
-----BEGIN EC PRIVATE KEY-----
|
|
MHcCAQEEIJX+87WJ7Gh19sohyZnhxZeXYNOcuGv4Q+8MLge4UkaZoAoGCCqGSM49
|
|
AwEHoUQDQgAEikc5m6C2xtDWeeAeT18WElO37zvFOz8p4kAlhvgIHN23XIClNESg
|
|
KVmLgSSq2asqiwdrU5YHbcHFkgdABM1SPA==
|
|
-----END EC PRIVATE KEY-----
|
|
"""
|
|
let privateKey = try ECPrivateKey(key: pemKey)
|
|
let signature = "Hello world".sign(with: privateKey)
|
|
```
|
|
*/
|
|
@available(macOS 10.13, iOS 11, watchOS 4.0, tvOS 11.0, *)
|
|
public class ECPrivateKey {
|
|
/// A String description of the curve this key was generated from.
|
|
public let curveId: String
|
|
|
|
/// The `EllipticCurve` this key was generated from.
|
|
public let curve: EllipticCurve
|
|
|
|
/// The private key represented as a PEM String.
|
|
public let pemString: String
|
|
|
|
#if os(Linux)
|
|
typealias NativeKey = OpaquePointer?
|
|
deinit { EC_KEY_free(.make(optional: self.nativeKey)) }
|
|
#else
|
|
typealias NativeKey = SecKey
|
|
#endif
|
|
let nativeKey: NativeKey
|
|
let pubKeyBytes: Data
|
|
private var stripped: Bool = false
|
|
|
|
|
|
/**
|
|
Initialize an ECPrivateKey from a PEM String.
|
|
This can either be from a `.p8` file with the header "-----BEGIN PRIVATE KEY-----",
|
|
or from a `.pem` file with the header "-----BEGIN EC PRIVATE KEY-----".
|
|
### Usage Example: ###
|
|
```swift
|
|
let privateKeyString = """
|
|
-----BEGIN EC PRIVATE KEY-----
|
|
MHcCAQEEIJX+87WJ7Gh19sohyZnhxZeXYNOcuGv4Q+8MLge4UkaZoAoGCCqGSM49
|
|
AwEHoUQDQgAEikc5m6C2xtDWeeAeT18WElO37zvFOz8p4kAlhvgIHN23XIClNESg
|
|
KVmLgSSq2asqiwdrU5YHbcHFkgdABM1SPA==
|
|
-----END EC PRIVATE KEY-----
|
|
"""
|
|
let key = try ECPrivateKey(key: privateKeyString)
|
|
```
|
|
- Parameter key: The elliptic curve private key as a PEM string.
|
|
- Returns: An ECPrivateKey.
|
|
- Throws: An ECError if the PEM string can't be decoded or is not a valid key.
|
|
*/
|
|
public convenience init(key: String) throws {
|
|
// Strip whitespace characters
|
|
let strippedKey = String(key.filter { !" \n\t\r".contains($0) })
|
|
var pemComponents = strippedKey.components(separatedBy: "-----")
|
|
guard pemComponents.count >= 5 else {
|
|
throw ECError.invalidPEMString
|
|
}
|
|
// Remove any EC parameters since Curve is determined by OID
|
|
if pemComponents[1] == "BEGINECPARAMETERS" {
|
|
pemComponents.removeFirst(5)
|
|
guard pemComponents.count >= 5 else {
|
|
throw ECError.invalidPEMString
|
|
}
|
|
}
|
|
guard let der = Data(base64Encoded: pemComponents[2]) else {
|
|
throw ECError.failedBase64Encoding
|
|
}
|
|
if pemComponents[1] == "BEGINECPRIVATEKEY" {
|
|
try self.init(sec1DER: der)
|
|
} else if pemComponents[1] == "BEGINPRIVATEKEY" {
|
|
try self.init(pkcs8DER: der)
|
|
} else {
|
|
throw ECError.unknownPEMHeader
|
|
}
|
|
}
|
|
|
|
/// Initialize an ECPrivateKey from a PKCS8 `.der` file data.
|
|
/// This is equivalent to a PEM String that has had the "-----BEGIN PRIVATE KEY-----"
|
|
/// header and footer stripped and been base64 encoded to ASN1 Data.
|
|
/// - Parameter pkcs8DER: The elliptic curve private key Data.
|
|
/// - Returns: An ECPrivateKey.
|
|
/// - Throws: An ECError if the Data can't be decoded or is not a valid key.
|
|
public init(pkcs8DER: Data) throws {
|
|
let (result, _) = ASN1.toASN1Element(data: pkcs8DER)
|
|
guard case let ASN1.ASN1Element.seq(elements: es) = result,
|
|
es.count > 2,
|
|
case let ASN1.ASN1Element.seq(elements: ids) = es[1],
|
|
ids.count > 1,
|
|
case let ASN1.ASN1Element.bytes(data: privateKeyID) = ids[1]
|
|
else {
|
|
throw ECError.failedASN1Decoding
|
|
}
|
|
self.curve = try EllipticCurve.objectToCurve(ObjectIdentifier: privateKeyID)
|
|
guard case let ASN1.ASN1Element.bytes(data: privateOctest) = es[2] else {
|
|
throw ECError.failedASN1Decoding
|
|
}
|
|
let (octest, _) = ASN1.toASN1Element(data: privateOctest)
|
|
guard case let ASN1.ASN1Element.seq(elements: seq) = octest,
|
|
seq.count >= 3,
|
|
case let ASN1.ASN1Element.bytes(data: privateKeyData) = seq[1]
|
|
else {
|
|
throw ECError.failedASN1Decoding
|
|
}
|
|
let publicKeyData: Data
|
|
if case let ASN1.ASN1Element.constructed(tag: 1, elem: publicElement) = seq[2],
|
|
case let ASN1.ASN1Element.bytes(data: pubKeyData) = publicElement
|
|
{
|
|
publicKeyData = pubKeyData
|
|
} else if seq.count >= 4,
|
|
case let ASN1.ASN1Element.constructed(tag: 1, elem: publicElement) = seq[3],
|
|
case let ASN1.ASN1Element.bytes(data: pubKeyData) = publicElement
|
|
{
|
|
publicKeyData = pubKeyData
|
|
} else {
|
|
throw ECError.failedASN1Decoding
|
|
}
|
|
let trimmedPubBytes = publicKeyData.drop(while: { $0 == 0x00})
|
|
if trimmedPubBytes.count != publicKeyData.count {
|
|
stripped = true
|
|
}
|
|
self.nativeKey = try ECPrivateKey.bytesToNativeKey(privateKeyData: privateKeyData,
|
|
publicKeyData: trimmedPubBytes,
|
|
curve: curve)
|
|
let derData = ECPrivateKey.generateASN1(privateKey: privateKeyData,
|
|
publicKey: publicKeyData,
|
|
curve: curve)
|
|
self.pemString = ECPrivateKey.derToPrivatePEM(derData: derData)
|
|
self.pubKeyBytes = trimmedPubBytes
|
|
self.curveId = curve.description
|
|
}
|
|
|
|
/// Initialize an ECPrivateKey from a SEC1 `.der` file data.
|
|
/// This is equivalent to a PEM String that has had the "-----BEGIN EC PRIVATE KEY-----"
|
|
/// header and footer stripped and been base64 encoded to ASN1 Data.
|
|
/// - Parameter sec1DER: The elliptic curve private key Data.
|
|
/// - Returns: An ECPrivateKey.
|
|
/// - Throws: An ECError if the Data can't be decoded or is not a valid key.
|
|
public init(sec1DER: Data) throws {
|
|
self.pemString = ECPrivateKey.derToPrivatePEM(derData: sec1DER)
|
|
let (result, _) = ASN1.toASN1Element(data: sec1DER)
|
|
guard case let ASN1.ASN1Element.seq(elements: seq) = result,
|
|
seq.count > 3,
|
|
case let ASN1.ASN1Element.constructed(tag: _, elem: objectElement) = seq[2],
|
|
case let ASN1.ASN1Element.bytes(data: objectId) = objectElement,
|
|
case let ASN1.ASN1Element.bytes(data: privateKeyData) = seq[1]
|
|
else {
|
|
throw ECError.failedASN1Decoding
|
|
}
|
|
self.curve = try EllipticCurve.objectToCurve(ObjectIdentifier: objectId)
|
|
guard case let ASN1.ASN1Element.constructed(tag: _, elem: publicElement) = seq[3],
|
|
case let ASN1.ASN1Element.bytes(data: publicKeyData) = publicElement
|
|
else {
|
|
throw ECError.failedASN1Decoding
|
|
}
|
|
let trimmedPubBytes = publicKeyData.drop(while: { $0 == 0x00})
|
|
if trimmedPubBytes.count != publicKeyData.count {
|
|
stripped = true
|
|
}
|
|
self.nativeKey = try ECPrivateKey.bytesToNativeKey(privateKeyData: privateKeyData,
|
|
publicKeyData: trimmedPubBytes,
|
|
curve: curve)
|
|
self.pubKeyBytes = trimmedPubBytes
|
|
self.curveId = curve.description
|
|
}
|
|
|
|
/// Initialize the `ECPublicKey`for this private key by extracting the public key bytes.
|
|
/// - Returns: An ECPublicKey.
|
|
/// - Throws: An ECError if the public key fails to be initialized from this private key.
|
|
public func extractPublicKey() throws -> ECPublicKey {
|
|
let keyHeader: Data
|
|
// Add the ASN1 header for the public key. The bytes have the following structure:
|
|
// SEQUENCE (2 elem)
|
|
// SEQUENCE (2 elem)
|
|
// OBJECT IDENTIFIER
|
|
// OBJECT IDENTIFIER
|
|
// BIT STRING (This is the `pubKeyBytes` added afterwards)
|
|
if self.curve == .prime256v1 {
|
|
keyHeader = Data([0x30, 0x59,
|
|
0x30, 0x13,
|
|
0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01,
|
|
0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, 0x03, 0x42])
|
|
} else if self.curve == .secp384r1 {
|
|
keyHeader = Data([0x30, 0x76,
|
|
0x30, 0x10,
|
|
0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01,
|
|
0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22, 0x03, 0x62])
|
|
} else if self.curve == .secp521r1 {
|
|
keyHeader = Data([0x30, 0x81, 0x9B,
|
|
0x30, 0x10,
|
|
0x06, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01,
|
|
0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x23, 0x03, 0x81, 0x86])
|
|
} else {
|
|
throw ECError.unsupportedCurve
|
|
}
|
|
// If we stripped the leading zero earlier, add it back here
|
|
var pubBytes = self.pubKeyBytes
|
|
if stripped {
|
|
pubBytes = Data(count: 1) + self.pubKeyBytes
|
|
}
|
|
return try ECPublicKey(der: keyHeader + pubBytes)
|
|
}
|
|
|
|
/**
|
|
Make an new ECPrivate key from a supported `EllipticCurve`.
|
|
- Parameter for curve: The elliptic curve that is used to generate the key.
|
|
- Returns: An ECPrivateKey.
|
|
- Throws: An ECError if the key fails to be created.
|
|
*/
|
|
public static func make(for curve: EllipticCurve) throws -> ECPrivateKey {
|
|
return try ECPrivateKey(for: curve)
|
|
}
|
|
|
|
/**
|
|
Initialise an new ECPrivate key from a supported `Curve`
|
|
- Parameter for curve: The elliptic curve that is used to generate the key.
|
|
- Returns: An ECPrivateKey.
|
|
- Throws: An ECError if the key fails to be created.
|
|
*/
|
|
private init(for curve: EllipticCurve) throws {
|
|
self.curve = curve
|
|
self.curveId = curve.description
|
|
self.stripped = true
|
|
#if os(Linux)
|
|
let ec_key = EC_KEY_new_by_curve_name(curve.nativeCurve)
|
|
EC_KEY_generate_key(ec_key)
|
|
self.nativeKey = ec_key
|
|
let pub_bn_ctx = BN_CTX_new()
|
|
BN_CTX_start(pub_bn_ctx)
|
|
let pub = EC_KEY_get0_public_key(ec_key)
|
|
let ec_group = EC_KEY_get0_group(ec_key)
|
|
let pub_bn = BN_new()
|
|
EC_POINT_point2bn(ec_group, pub, POINT_CONVERSION_UNCOMPRESSED, pub_bn, pub_bn_ctx)
|
|
let pubk = UnsafeMutablePointer<UInt8>.allocate(capacity: curve.keySize)
|
|
BN_bn2bin(pub_bn, pubk)
|
|
self.pubKeyBytes = Data(bytes: pubk, count: curve.keySize)
|
|
defer {
|
|
BN_CTX_end(pub_bn_ctx)
|
|
BN_CTX_free(pub_bn_ctx)
|
|
BN_clear_free(pub_bn)
|
|
#if swift(>=4.1)
|
|
pubk.deallocate()
|
|
#else
|
|
pubk.deallocate(capacity: curve.keySize)
|
|
#endif
|
|
}
|
|
#else
|
|
let kAsymmetricCryptoManagerKeyType = kSecAttrKeyTypeECSECPrimeRandom
|
|
let kAsymmetricCryptoManagerKeySize: Int
|
|
if curve == .prime256v1 {
|
|
kAsymmetricCryptoManagerKeySize = 256
|
|
} else if curve == .secp384r1 {
|
|
kAsymmetricCryptoManagerKeySize = 384
|
|
} else {
|
|
kAsymmetricCryptoManagerKeySize = 521
|
|
}
|
|
// parameters
|
|
let parameters: [String: AnyObject] = [
|
|
kSecAttrKeyType as String: kAsymmetricCryptoManagerKeyType,
|
|
kSecAttrKeySizeInBits as String: kAsymmetricCryptoManagerKeySize as AnyObject,
|
|
]
|
|
var pubKey, privKey: SecKey?
|
|
let status = SecKeyGeneratePair(parameters as CFDictionary, &pubKey, &privKey)
|
|
guard status == 0, let newPubKey = pubKey, let newPrivKey = privKey else {
|
|
throw ECError.failedNativeKeyCreation
|
|
}
|
|
var error: Unmanaged<CFError>? = nil
|
|
guard let pubBytes = SecKeyCopyExternalRepresentation(newPubKey, &error) else {
|
|
guard let error = error?.takeRetainedValue() else {
|
|
throw ECError.failedNativeKeyCreation
|
|
}
|
|
throw error
|
|
}
|
|
self.pubKeyBytes = pubBytes as Data
|
|
self.nativeKey = newPrivKey
|
|
#endif
|
|
self.pemString = try ECPrivateKey.decodeToPEM(nativeKey: self.nativeKey, curve: self.curve)
|
|
}
|
|
|
|
/// Decode this ECPrivateKey to it's PEM format
|
|
private static func decodeToPEM(nativeKey: NativeKey, curve: EllipticCurve) throws -> String {
|
|
#if os(Linux)
|
|
let asn1Bio = BIO_new(BIO_s_mem())
|
|
defer { BIO_free_all(asn1Bio) }
|
|
// The return value of i2d_ECPrivateKey_bio is supposed to be the DER size.
|
|
// However it is just returning 1 for success.
|
|
// Since the size is fixed we have just used the known values here.
|
|
guard i2d_ECPrivateKey_bio(asn1Bio, nativeKey) >= 0 else {
|
|
throw ECError.failedNativeKeyCreation
|
|
}
|
|
let asn1Size: Int32
|
|
if curve == .prime256v1 {
|
|
asn1Size = 364
|
|
} else if curve == .secp384r1 {
|
|
asn1Size = 510
|
|
} else {
|
|
asn1Size = 673
|
|
}
|
|
let asn1 = UnsafeMutablePointer<UInt8>.allocate(capacity: Int(asn1Size))
|
|
let readLength = BIO_read(asn1Bio, asn1, asn1Size)
|
|
guard readLength > 0 else {
|
|
throw ECError.failedASN1Decoding
|
|
}
|
|
let asn1Data = Data(bytes: asn1, count: Int(readLength))
|
|
// OpenSSL 1.1 already returns the shortened ANS1 so can return it straight away
|
|
if readLength < asn1Size - 1 {
|
|
return ECPrivateKey.derToPrivatePEM(derData: asn1Data)
|
|
}
|
|
// Otherwise need to decode ASN1 to get public and private key
|
|
#if swift(>=4.1)
|
|
asn1.deallocate()
|
|
#else
|
|
asn1.deallocate(capacity: Int(asn1Size))
|
|
#endif
|
|
let (result, _) = ASN1.toASN1Element(data: asn1Data)
|
|
guard case let ASN1.ASN1Element.seq(elements: seq) = result,
|
|
seq.count > 3,
|
|
case let ASN1.ASN1Element.bytes(data: privateKeyData) = seq[1]
|
|
else {
|
|
throw ECError.failedASN1Decoding
|
|
}
|
|
guard case let ASN1.ASN1Element.constructed(tag: _, elem: publicElement) = seq[3],
|
|
case let ASN1.ASN1Element.bytes(data: publicKeyData) = publicElement
|
|
else {
|
|
throw ECError.failedASN1Decoding
|
|
}
|
|
#else
|
|
var error: Unmanaged<CFError>? = nil
|
|
/*
|
|
From Apple docs:
|
|
For an elliptic curve private key, `SecKeyCopyExternalRepresentation` output is formatted as the public key concatenated with the big endian encoding of the secret scalar, or 04 || X || Y || K.
|
|
*/
|
|
guard let keyBytes = SecKeyCopyExternalRepresentation(nativeKey, &error) else {
|
|
guard let error = error?.takeRetainedValue() else {
|
|
throw ECError.failedNativeKeyCreation
|
|
}
|
|
throw error
|
|
}
|
|
let keyData = keyBytes as Data
|
|
let privateKeyData = keyData.dropFirst(curve.keySize)
|
|
let publicKeyData = Data(count: 1) + keyData.dropLast(keyData.count - curve.keySize)
|
|
#endif
|
|
let derData = ECPrivateKey.generateASN1(privateKey: privateKeyData, publicKey: publicKeyData, curve: curve)
|
|
return ECPrivateKey.derToPrivatePEM(derData: derData)
|
|
}
|
|
|
|
private static func generateASN1(privateKey: Data, publicKey: Data, curve: EllipticCurve) -> Data {
|
|
var keyHeader: Data
|
|
// Add the ASN1 header for the private key. The bytes have the following structure:
|
|
// SEQUENCE (4 elem)
|
|
// INTEGER 1
|
|
// OCTET STRING (32 byte) (This is the `privateKeyBytes`)
|
|
// [0] (1 elem)
|
|
// OBJECT IDENTIFIER
|
|
// [1] (1 elem)
|
|
// BIT STRING (This is the `pubKeyBytes`)
|
|
if curve == .prime256v1 {
|
|
keyHeader = Data([0x30, 0x77,
|
|
0x02, 0x01, 0x01,
|
|
0x04, 0x20])
|
|
keyHeader += privateKey
|
|
keyHeader += Data([0xA0,
|
|
0x0A, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07,
|
|
0xA1,
|
|
0x44, 0x03, 0x42])
|
|
keyHeader += publicKey
|
|
} else if curve == .secp384r1 {
|
|
keyHeader = Data([0x30, 0x81, 0xA4,
|
|
0x02, 0x01, 0x01,
|
|
0x04, 0x30])
|
|
keyHeader += privateKey
|
|
keyHeader += Data([0xA0,
|
|
0x07, 0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22,
|
|
0xA1,
|
|
0x64, 0x03, 0x62])
|
|
keyHeader += publicKey
|
|
} else {
|
|
// 521 Private key can be 65 or 66 bytes long
|
|
if privateKey.count == 65 {
|
|
keyHeader = Data([0x30, 0x81, 0xDB,
|
|
0x02, 0x01, 0x01,
|
|
0x04, 0x41])
|
|
} else {
|
|
keyHeader = Data([0x30, 0x81, 0xDC,
|
|
0x02, 0x01, 0x01,
|
|
0x04, 0x42])
|
|
}
|
|
keyHeader += privateKey
|
|
keyHeader += Data([0xA0,
|
|
0x07, 0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x23,
|
|
0xA1,
|
|
0x81, 0x89, 0x03, 0x81, 0x86])
|
|
keyHeader += publicKey
|
|
}
|
|
return keyHeader
|
|
}
|
|
|
|
private static func bytesToNativeKey(privateKeyData: Data, publicKeyData: Data, curve: EllipticCurve) throws -> NativeKey {
|
|
#if os(Linux)
|
|
let bigNum = BN_new()
|
|
defer {
|
|
BN_free(bigNum)
|
|
}
|
|
privateKeyData.withUnsafeBytes({ (privateKeyBytes: UnsafeRawBufferPointer) -> Void in
|
|
BN_bin2bn(privateKeyBytes.baseAddress?.assumingMemoryBound(to: UInt8.self), Int32(privateKeyData.count), bigNum)
|
|
})
|
|
let ecKey = EC_KEY_new_by_curve_name(curve.nativeCurve)
|
|
guard EC_KEY_set_private_key(ecKey, bigNum) == 1 else {
|
|
EC_KEY_free(ecKey)
|
|
throw ECError.failedNativeKeyCreation
|
|
}
|
|
return ecKey
|
|
#else
|
|
let keyData = publicKeyData + privateKeyData
|
|
var error: Unmanaged<CFError>? = nil
|
|
guard let secKey = SecKeyCreateWithData(keyData as CFData,
|
|
[kSecAttrKeyType: kSecAttrKeyTypeECSECPrimeRandom,
|
|
kSecAttrKeyClass: kSecAttrKeyClassPrivate] as CFDictionary,
|
|
&error)
|
|
else {
|
|
if let secError = error?.takeRetainedValue() {
|
|
throw secError
|
|
} else {
|
|
throw ECError.failedNativeKeyCreation
|
|
}
|
|
}
|
|
return secKey
|
|
#endif
|
|
}
|
|
|
|
private static func derToPrivatePEM(derData: Data) -> String {
|
|
// First convert the DER data to a base64 string...
|
|
let base64String = derData.base64EncodedString()
|
|
// Split the string into strings of length 64.
|
|
let lines = base64String.split(to: 64)
|
|
// Join those lines with a new line...
|
|
let joinedLines = lines.joined(separator: "\n")
|
|
return "-----BEGIN EC PRIVATE KEY-----\n" + joinedLines + "\n-----END EC PRIVATE KEY-----"
|
|
}
|
|
}
|