Files
swift-crypto/Sources/_CryptoExtras/ECToolbox/BoringSSL/ECToolbox_boring.swift
T
dc4c2c14e7 Enable swift-format in CI (#302)
## Motivation

As part of the Github Actions CI migration we held off enabling the
format check and moving to the same formatting rules as Swift NIO, but
we'd like to do that now.

## Modifications

- Add a script to generate (and update) the `.swiftformatignore` file
since this repo only wants to format a specific set of files matching a
pattern.
- Generate and commit the `.swiftformatignore` file.
- Run the fomatter and commit the results.
- Additional commits to satisfy the remaining linter rules that weren't
auto-fixed by swift-format.
- Enable the format check in CI.

## Result

- Code that's not shared is formatted with a style consistent with the
other repos this team maintain.
- CI is now checking code format again.

---------

Co-authored-by: Cory Benfield <lukasa@apple.com>
Co-authored-by: Rick Newton-Rogers <rnro@apple.com>
2024-11-28 14:46:23 +00:00

287 lines
10 KiB
Swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCrypto open source project
//
// Copyright (c) 2024 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 Crypto
import CryptoBoringWrapper
import Foundation
/// NOTE: This protocol is different from `Crypto.OpenSSLSupportedNISTCurve` module and has additional requirements to
/// support ECToolbox. It is (re-)defined here because its counterpart in the Crypto module is only conditionally
/// compiled on _non-Darwin_ platforms, but we implement ECToolbox on both Darwin and non-Darwin platforms.
@usableFromInline
protocol OpenSSLSupportedNISTCurve {
associatedtype H: HashFunction
@inlinable
static var group: BoringSSLEllipticCurveGroup { get }
// TODO: we could use EC_GROUP_get_cofactor for this and drop this requirement.
@inlinable
static var cofactor: Int { get }
@inlinable
static var orderByteCount: Int { get }
@inlinable
static var compressedx962PointByteCount: Int { get }
// TODO: could this be moved to the group or to the HashFunction?
@inlinable
static var hashToFieldByteCount: Int { get }
}
/// NOTE: This conformance applies to this type from the Crypto module even if it comes from the SDK.
extension P256: OpenSSLSupportedNISTCurve {
@usableFromInline
typealias H = SHA256
@inlinable
static var group: BoringSSLEllipticCurveGroup { try! BoringSSLEllipticCurveGroup(.p256) }
@inlinable
static var cofactor: Int { 1 }
@inlinable
static var orderByteCount: Int { 32 }
@inlinable
static var compressedx962PointByteCount: Int { 33 }
@inlinable
static var hashToFieldByteCount: Int { 48 }
}
/// NOTE: This conformance applies to this type from the Crypto module even if it comes from the SDK.
extension P384: OpenSSLSupportedNISTCurve {
@usableFromInline
typealias H = SHA384
@inlinable
static var group: BoringSSLEllipticCurveGroup { try! BoringSSLEllipticCurveGroup(.p384) }
@inlinable
static var cofactor: Int { 1 }
@inlinable
static var orderByteCount: Int { 48 }
@inlinable
static var compressedx962PointByteCount: Int { 49 }
@inlinable
static var hashToFieldByteCount: Int { 72 }
}
/// NOTE: This conformance applies to this type from the Crypto module even if it comes from the SDK.
extension P521: OpenSSLSupportedNISTCurve {
@usableFromInline
typealias H = SHA512
@inlinable
static var group: BoringSSLEllipticCurveGroup { try! BoringSSLEllipticCurveGroup(.p521) }
@inlinable
static var cofactor: Int { 1 }
@inlinable
static var orderByteCount: Int { 66 }
@inlinable
static var compressedx962PointByteCount: Int { 67 }
@inlinable
static var hashToFieldByteCount: Int { 98 }
}
struct OpenSSLGroupScalar<C: OpenSSLSupportedNISTCurve>: GroupScalar, CustomStringConvertible {
var openSSLScalar: ArbitraryPrecisionInteger
init(_ openSSLScalar: ArbitraryPrecisionInteger) {
self.openSSLScalar = openSSLScalar
}
/// Deserializes a scalar from data.
/// - Parameters:
/// - data: The serialized scalar
/// - reductionIsModOrder: Resulting number is taken "mod q" (characteristic) by default. Override by setting true if "mod p" (order) is desired.
/// - Returns: The deserialized scalar
init(bytes: Data, reductionIsModOrder: Bool = false) throws {
if reductionIsModOrder {
self.init(
try ArbitraryPrecisionInteger(bytes: bytes).modulo(C.group.weierstrassCoefficients.field)
)
} else {
self.init(try ArbitraryPrecisionInteger(bytes: bytes).modulo(C.group.order))
}
}
static var random: Self {
// Force-try: Protocol requires non-throwing and this can only throw if bounds are invalid.
try! Self(.random(inclusiveMin: 0, exclusiveMax: C.group.order))
}
static func + (left: Self, right: Self) -> Self {
// Force-try: Protocol requires non-throwing and this can only throw if modulus is invalid.
try! Self(left.openSSLScalar.add(right.openSSLScalar, modulo: C.group.order))
}
static func - (left: Self, right: Self) -> Self {
// Force-try: Protocol requires non-throwing and this can only throw if modulus is invalid.
try! Self(left.openSSLScalar.sub(right.openSSLScalar, modulo: C.group.order))
}
static func ^ (left: Self, right: Int) -> Self {
precondition(right == -1, "Unimplemented arbitrary exponentiation")
// Force-try: Protocol requires non-throwing and this can only throw if modulus is invalid.
return try! Self(left.openSSLScalar.inverse(modulo: C.group.order))
}
static func * (left: Self, right: Self) -> Self {
// Force-try: Protocol requires non-throwing and this can only throw if modulus is invalid.
try! Self(left.openSSLScalar.mul(right.openSSLScalar, modulo: C.group.order))
}
static prefix func - (left: Self) -> Self {
// Force-try: Protocol requires non-throwing and this can only throw if modulus is invalid.
try! Self(.zero.sub(left.openSSLScalar, modulo: C.group.order))
}
static func == (left: Self, right: Self) -> Bool {
left.openSSLScalar == right.openSSLScalar
}
var rawRepresentation: Data {
// Force-try: This can only throw if the requested size is not big enough to represent the point.
try! Data(bytesOf: self.openSSLScalar, paddedToSize: C.orderByteCount)
}
var description: String {
self.rawRepresentation.hexString
}
}
struct OpenSSLCurvePoint<C: OpenSSLSupportedNISTCurve>: GroupElement {
var ecPoint: EllipticCurvePoint
typealias Scalar = OpenSSLGroupScalar<C>
init(ecPoint: EllipticCurvePoint) {
self.ecPoint = ecPoint
}
static var generator: Self {
// Force-try: Protocol requires non-throwing and this can only throw if group has no generator.
// TODO: `BoringSSLEllipticCurveGroup.generator` should probably be non-throwing, like `.order`.
try! Self(ecPoint: C.group.generator)
}
static var random: Self {
let randomBytes = SystemRandomNumberGenerator.randomBytes(count: C.group.order.byteCount)
let dst = Data("Random EC Point Generation".utf8)
// Force-try: Protocol requires non-throwing and this can only throw if called with the wrong group.
let point = try! EllipticCurvePoint(hashing: randomBytes, to: C.group, domainSeparationTag: dst)
return Self(ecPoint: point)
}
static func + (left: Self, right: Self) -> Self {
// Force-try: Protocol requires non-throwing.
try! Self(ecPoint: left.ecPoint.adding(right.ecPoint, on: C.group))
}
static func - (left: Self, right: Self) -> Self {
// Force-try: Protocol requires non-throwing.
try! Self(ecPoint: left.ecPoint.subtracting(right.ecPoint, on: C.group))
}
static prefix func - (left: Self) -> Self {
// Force-try: Protocol requires non-throwing.
try! Self(ecPoint: left.ecPoint.inverting(on: C.group))
}
static func * (left: Scalar, right: Self) -> Self {
// Force-try: Protocol requires non-throwing.
try! Self(ecPoint: .multiplying(right.ecPoint, by: left.openSSLScalar, on: C.group))
}
static func == (left: Self, right: Self) -> Bool {
left.ecPoint.isEqual(to: right.ecPoint, on: C.group)
}
}
extension OpenSSLCurvePoint {
var compressedRepresentation: Data {
try! self.ecPoint.x962Representation(compressed: true, on: C.group)
}
}
extension OpenSSLCurvePoint: OPRFGroupElement {
init(oprfRepresentation data: Data) throws {
let point = try EllipticCurvePoint(x962Representation: data, on: C.group)
self.init(ecPoint: point)
}
var oprfRepresentation: Data { self.compressedRepresentation }
}
struct OpenSSLGroup<C: OpenSSLSupportedNISTCurve>: Group {
typealias Element = OpenSSLCurvePoint<C>
static var cofactor: Int {
// NOTE: Practically, this is always 1, because this type is only generic over our NIST curves.
C.cofactor
}
}
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, *)
struct OpenSSLHashToCurve<C: OpenSSLSupportedNISTCurve>: HashToGroup {
typealias H = C.H
typealias GE = OpenSSLCurvePoint<C>
typealias G = OpenSSLGroup<C>
static func hashToScalar(_ data: Data, domainSeparationString: Data) throws -> GE.Scalar {
// Force-unwrap: HashToField is guaranteed to produce one or more elements, so .first is always non-nil.
try HashToField<C>.hashToField(
data,
outputElementCount: 1,
dst: Data("HashToScalar-".utf8) + domainSeparationString,
outputSize: C.hashToFieldByteCount,
reductionIsModOrder: false
).first!
}
static func hashToGroup(_ data: Data, domainSeparationString: Data) -> GE {
precondition(G.cofactor == 1, "H2C doesn't have support for clearing co-factors.")
precondition(!domainSeparationString.isEmpty, "DST must be non-empty.")
switch C.self {
case is P256.Type:
let point = try! EllipticCurvePoint(
hashing: data,
to: P256.group,
domainSeparationTag: domainSeparationString
)
return OpenSSLCurvePoint(ecPoint: point)
case is P384.Type:
let point = try! EllipticCurvePoint(
hashing: data,
to: P384.group,
domainSeparationTag: domainSeparationString
)
return OpenSSLCurvePoint(ecPoint: point)
case is P521.Type:
// BoringSSL doesn't have implementation of P521_XMD:SHA-512_SSWU_RO_.
fatalError("HashToGroup not supported for type: \(C.self).")
default:
fatalError("HashToGroup not supported for type: \(C.self).")
}
}
}