mirror of
https://github.com/apple/swift-crypto
synced 2026-11-22 04:30:39 +00:00
Add API for ARC(P-256) and deprecate ARC(P-384) (#374)
## Motivation The ARC IETF draft has been updated to now support P256 and drop support for P384. ## Modifications - Update the internal ARC implementation to accommodate multiple curves - Add API surface for P256 - Deprecate API for P384 - Add tests for P256 with test vectors from the draft - Move over the end-to-end API tests to P256 - Add benchmarks for P256 ## Result - New API `P256._ARCV1`, which provides an implementation of ARC(P-256). - Deprecate `P384._ARCV1`, which provides an implementation of ARC(P-256). [^1]: https://chris-wood.github.io/draft-arc/draft-yun-cfrg-arc.html#name-arcv1-p256 --------- Co-authored-by: Cory Benfield <lukasa@apple.com>
This commit is contained in:
1 parent
9fb2fd8d3c
commit
93a2ebfad7
15 files changed
+923
-200
No files matched your search
@@ -19,6 +19,65 @@ import _CryptoExtras
|
||||
let benchmarks = {
|
||||
let defaultMetrics: [BenchmarkMetric] = [.mallocCountTotal, .cpuTotal]
|
||||
|
||||
Benchmark(
|
||||
"arc-issue-p256",
|
||||
configuration: Benchmark.Configuration(
|
||||
metrics: defaultMetrics,
|
||||
scalingFactor: .kilo,
|
||||
maxDuration: .seconds(10_000_000),
|
||||
maxIterations: 3
|
||||
)
|
||||
) { benchmark in
|
||||
let privateKey = P256._ARCV1.PrivateKey()
|
||||
let publicKey = privateKey.publicKey
|
||||
let requestContext = Data("shared request context".utf8)
|
||||
let precredential = try publicKey.prepareCredentialRequest(requestContext: requestContext)
|
||||
let credentialRequest = precredential.credentialRequest
|
||||
|
||||
benchmark.startMeasurement()
|
||||
|
||||
for _ in benchmark.scaledIterations {
|
||||
blackHole(try privateKey.issue(credentialRequest))
|
||||
}
|
||||
}
|
||||
|
||||
Benchmark(
|
||||
"arc-verify-p256",
|
||||
configuration: Benchmark.Configuration(
|
||||
metrics: defaultMetrics,
|
||||
scalingFactor: .kilo,
|
||||
maxDuration: .seconds(10_000_000),
|
||||
maxIterations: 10
|
||||
)
|
||||
) { benchmark in
|
||||
let privateKey = P256._ARCV1.PrivateKey()
|
||||
let publicKey = privateKey.publicKey
|
||||
let requestContext = Data("shared request context".utf8)
|
||||
let (presentationContext, presentationLimit) = (Data("shared presentation context".utf8), 2)
|
||||
let precredential = try publicKey.prepareCredentialRequest(requestContext: requestContext)
|
||||
let credentialRequest = precredential.credentialRequest
|
||||
let credentialResponse = try privateKey.issue(credentialRequest)
|
||||
var credential = try publicKey.finalize(credentialResponse, for: precredential)
|
||||
let (presentation, nonce) = try credential.makePresentation(
|
||||
context: presentationContext,
|
||||
presentationLimit: presentationLimit
|
||||
)
|
||||
|
||||
benchmark.startMeasurement()
|
||||
|
||||
for _ in benchmark.scaledIterations {
|
||||
blackHole(
|
||||
try privateKey.verify(
|
||||
presentation,
|
||||
requestContext: requestContext,
|
||||
presentationContext: presentationContext,
|
||||
presentationLimit: presentationLimit,
|
||||
nonce: nonce
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
Benchmark(
|
||||
"arc-issue-p384",
|
||||
configuration: Benchmark.Configuration(
|
||||
|
||||
@@ -14,8 +14,388 @@
|
||||
import Crypto
|
||||
import Foundation
|
||||
|
||||
// MARK: - P256 + ARC(P-256)
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256 {
|
||||
/// Anonymous Rate-Limited Credentials (ARC).
|
||||
///
|
||||
/// A specialization of keyed-verification anonymous credentials with support for rate limiting.
|
||||
///
|
||||
/// - Seealso: [IETF Internet Draft: draft-yun-cfrg-arc-00](https://datatracker.ietf.org/doc/draft-yun-cfrg-arc).
|
||||
public enum _ARCV1 {
|
||||
internal typealias H2G = HashToCurveImpl<P256>
|
||||
internal typealias Ciphersuite = ARC.Ciphersuite<H2G>
|
||||
fileprivate typealias Server = ARC.Server<H2G>
|
||||
|
||||
internal static let ciphersuite = Ciphersuite(H2G.self)
|
||||
}
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1 {
|
||||
/// The server secrets used to issue and verify credentials.
|
||||
public struct PrivateKey: Sendable {
|
||||
fileprivate var backing: ARC.Server<H2G>
|
||||
|
||||
/// Creates a random private key for ARC(P-256).
|
||||
public init() {
|
||||
self.backing = ARC.Server(ciphersuite: P256._ARCV1.ciphersuite)
|
||||
}
|
||||
|
||||
// The spec does not define a serialization of the private key since, unlike the public key, it is not an
|
||||
// interop concern.
|
||||
//
|
||||
// This initializer expects a concatenation of the binary representations of the private scalars:
|
||||
//
|
||||
// struct {
|
||||
// uint8 x0[Ne];
|
||||
// uint8 x1[Ne];
|
||||
// uint8 x2[Ne];
|
||||
// uint8 x0Blinding[Ne];
|
||||
// } ServerPrivateKey;
|
||||
//
|
||||
public init<D: DataProtocol>(rawRepresentation: D) throws {
|
||||
guard rawRepresentation.count == 4 * P256.orderByteCount else {
|
||||
throw ARC.Errors.incorrectPrivateKeyDataSize
|
||||
}
|
||||
|
||||
var bytes = Data(rawRepresentation)[...]
|
||||
let x0 = try H2G.G.Scalar(bytes: bytes[..<bytes.startIndex.advanced(by: P256.orderByteCount)])
|
||||
bytes.removeFirst(P256.orderByteCount)
|
||||
let x1 = try H2G.G.Scalar(bytes: bytes[..<bytes.startIndex.advanced(by: P256.orderByteCount)])
|
||||
bytes.removeFirst(P256.orderByteCount)
|
||||
let x2 = try H2G.G.Scalar(bytes: bytes[..<bytes.startIndex.advanced(by: P256.orderByteCount)])
|
||||
bytes.removeFirst(P256.orderByteCount)
|
||||
let x0Blinding = try H2G.G.Scalar(bytes: bytes[..<bytes.startIndex.advanced(by: P256.orderByteCount)])
|
||||
bytes.removeFirst(P256.orderByteCount)
|
||||
assert(bytes.isEmpty)
|
||||
|
||||
self.backing = ARC.Server(ciphersuite: P256._ARCV1.ciphersuite, x0: x0, x1: x1, x2: x2, x0Blinding: x0Blinding)
|
||||
}
|
||||
|
||||
// The spec does not define a serialization of the private key since, unlike the public key, it is not an
|
||||
// interop concern.
|
||||
//
|
||||
// This initializer expects a concatenation of the binary representations of the private scalars:
|
||||
//
|
||||
// struct {
|
||||
// uint8 x0[Ns];
|
||||
// uint8 x1[Ns];
|
||||
// uint8 x2[Ns];
|
||||
// uint8 x0Blinding[Ns];
|
||||
// } ServerPrivateKey;
|
||||
//
|
||||
public var rawRepresentation: Data {
|
||||
let serializedByteCount = 4 * P256.orderByteCount
|
||||
var result = Data(capacity: serializedByteCount)
|
||||
|
||||
result.append(self.backing.serverPrivateKey.x0.rawRepresentation)
|
||||
result.append(self.backing.serverPrivateKey.x1.rawRepresentation)
|
||||
result.append(self.backing.serverPrivateKey.x2.rawRepresentation)
|
||||
result.append(self.backing.serverPrivateKey.x0Blinding.rawRepresentation)
|
||||
assert(result.count == serializedByteCount)
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
public var publicKey: P256._ARCV1.PublicKey {
|
||||
P256._ARCV1.PublicKey(backing: self.backing.serverPublicKey)
|
||||
}
|
||||
}
|
||||
|
||||
/// The server public key, used by clients to create anonymous credentials in conjunction with the server.
|
||||
public struct PublicKey: Sendable {
|
||||
fileprivate var backing: ARC.ServerPublicKey<H2G>
|
||||
|
||||
fileprivate init(backing: ARC.ServerPublicKey<H2G>) {
|
||||
self.backing = backing
|
||||
}
|
||||
|
||||
fileprivate static var serializedByteCount: Int { 3 * P256.compressedx962PointByteCount }
|
||||
|
||||
// The spec defines this serialization of the public key:
|
||||
//
|
||||
// struct {
|
||||
// uint8 X0[Ne];
|
||||
// uint8 X1[Ne];
|
||||
// uint8 X2[Ne];
|
||||
// } ServerPublicKey;
|
||||
//
|
||||
public init<D: DataProtocol>(rawRepresentation: D) throws {
|
||||
guard rawRepresentation.count == Self.serializedByteCount else { throw ARC.Errors.incorrectPublicKeyDataSize }
|
||||
|
||||
var bytes = Data(rawRepresentation)[...]
|
||||
let X0 = try H2G.G.Element(oprfRepresentation: bytes[..<bytes.startIndex.advanced(by: P256.compressedx962PointByteCount)])
|
||||
bytes.removeFirst(P256.compressedx962PointByteCount)
|
||||
let X1 = try H2G.G.Element(oprfRepresentation: bytes[..<bytes.startIndex.advanced(by: P256.compressedx962PointByteCount)])
|
||||
bytes.removeFirst(P256.compressedx962PointByteCount)
|
||||
let X2 = try H2G.G.Element(oprfRepresentation: bytes[..<bytes.startIndex.advanced(by: P256.compressedx962PointByteCount)])
|
||||
bytes.removeFirst(P256.compressedx962PointByteCount)
|
||||
assert(bytes.isEmpty)
|
||||
|
||||
self.backing = ARC.ServerPublicKey(X0: X0, X1: X1, X2: X2)
|
||||
}
|
||||
|
||||
// The spec defines this serialization of the public key:
|
||||
//
|
||||
// struct {
|
||||
// uint8 X0[Ne];
|
||||
// uint8 X1[Ne];
|
||||
// uint8 X2[Ne];
|
||||
// } ServerPublicKey;
|
||||
//
|
||||
public var rawRepresentation: Data {
|
||||
var result = Data(capacity: Self.serializedByteCount)
|
||||
|
||||
result.append(self.backing.X0.oprfRepresentation)
|
||||
result.append(self.backing.X1.oprfRepresentation)
|
||||
result.append(self.backing.X2.oprfRepresentation)
|
||||
assert(result.count == Self.serializedByteCount)
|
||||
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
/// A credential request, created by the client, to be sent to the server.
|
||||
///
|
||||
/// Clients should not create values of this type manually; they should use the prepare method on the public key.
|
||||
///
|
||||
/// Servers should reconstruct values of this type from the serialized bytes sent by the client.
|
||||
public struct CredentialRequest: Sendable {
|
||||
var backing: ARC.CredentialRequest<H2G>
|
||||
|
||||
fileprivate init(backing: ARC.CredentialRequest<H2G>) {
|
||||
self.backing = backing
|
||||
}
|
||||
|
||||
public init<D: DataProtocol>(rawRepresentation: D) throws {
|
||||
self.backing = try ARC.CredentialRequest.deserialize(requestData: rawRepresentation, ciphersuite: P256._ARCV1.ciphersuite)
|
||||
}
|
||||
|
||||
public var rawRepresentation: Data {
|
||||
self.backing.serialize(ciphersuite: P256._ARCV1.ciphersuite)
|
||||
}
|
||||
}
|
||||
|
||||
/// A credential request to be sent to the server, and associated client secrets.
|
||||
///
|
||||
/// Users cannot create values of this type manually; they are created using the prepare method on the public key.
|
||||
public struct Precredential: Sendable {
|
||||
/// This backing type binds many things together, including the server commitments, client secrets, credential
|
||||
/// request, and presentation limit.
|
||||
internal var backing: ARC.Precredential<H2G>
|
||||
|
||||
/// The credential request to be sent to the server.
|
||||
public var credentialRequest: CredentialRequest {
|
||||
CredentialRequest(backing: self.backing.credentialRequest)
|
||||
}
|
||||
}
|
||||
|
||||
/// A credential response, created by the server, to be sent to the client.
|
||||
///
|
||||
/// Servers should not create values of this type manually; they should use the issue method on the private key.
|
||||
///
|
||||
/// Clients should reconstruct values of this type from the serialized bytes sent by the server.
|
||||
public struct CredentialResponse: Sendable {
|
||||
var backing: ARC.CredentialResponse<H2G>
|
||||
|
||||
fileprivate init(backing: ARC.CredentialResponse<H2G>) {
|
||||
self.backing = backing
|
||||
}
|
||||
|
||||
public init<D: DataProtocol>(rawRepresentation: D) throws {
|
||||
self.backing = try ARC.CredentialResponse.deserialize(responseData: rawRepresentation, ciphersuite: P256._ARCV1.ciphersuite)
|
||||
}
|
||||
|
||||
public var rawRepresentation: Data {
|
||||
self.backing.serialize(ciphersuite: P256._ARCV1.ciphersuite)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// A credential, created by the client using the response from the server.
|
||||
///
|
||||
/// Users cannot create values of this type manually; they are created using the issue method on the public key.
|
||||
public struct Credential: Sendable {
|
||||
var backing: ARC.Credential<H2G>
|
||||
|
||||
fileprivate init(backing: ARC.Credential<H2G>) {
|
||||
self.backing = backing
|
||||
}
|
||||
}
|
||||
|
||||
/// A presentation, created by the client from a credential, to be sent to the server to verify.
|
||||
///
|
||||
/// Users cannot create values of this type manually; they are created using the present method on the credential.
|
||||
public struct Presentation: Sendable {
|
||||
internal var backing: ARC.Presentation<H2G>
|
||||
|
||||
fileprivate init(backing: ARC.Presentation<H2G>) {
|
||||
self.backing = backing
|
||||
}
|
||||
|
||||
public init<D: DataProtocol>(rawRepresentation: D) throws {
|
||||
self.backing = try ARC.Presentation.deserialize(presentationData: rawRepresentation, ciphersuite: P256._ARCV1.ciphersuite)
|
||||
}
|
||||
|
||||
public var rawRepresentation: Data {
|
||||
self.backing.serialize(ciphersuite: P256._ARCV1.ciphersuite)
|
||||
}
|
||||
|
||||
public var tag: Data {
|
||||
self.backing.tag.compressedRepresentation
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.PublicKey {
|
||||
internal func prepareCredentialRequest<D: DataProtocol>(
|
||||
requestContext: D,
|
||||
m1: P256._ARCV1.H2G.G.Scalar,
|
||||
r1: P256._ARCV1.H2G.G.Scalar,
|
||||
r2: P256._ARCV1.H2G.G.Scalar
|
||||
) throws -> P256._ARCV1.Precredential {
|
||||
let precedential = try ARC.Precredential(
|
||||
ciphersuite: P256._ARCV1.ciphersuite,
|
||||
m1: m1,
|
||||
requestContext: Data(requestContext),
|
||||
r1: r1,
|
||||
r2: r2,
|
||||
serverPublicKey: self.backing
|
||||
)
|
||||
return P256._ARCV1.Precredential(backing: precedential)
|
||||
}
|
||||
|
||||
/// Prepare a credential request for a given request context.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - requestContext: Request context, agreed with the server.
|
||||
///
|
||||
/// - Returns: A precredential containing the client secrets, and request to be sent to the server.
|
||||
public func prepareCredentialRequest<D: DataProtocol>(
|
||||
requestContext: D
|
||||
) throws -> P256._ARCV1.Precredential {
|
||||
try self.prepareCredentialRequest(
|
||||
requestContext: requestContext,
|
||||
m1: .random,
|
||||
r1: .random,
|
||||
r2: .random
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.PrivateKey {
|
||||
internal func issue(
|
||||
_ credentialRequest: P256._ARCV1.CredentialRequest,
|
||||
b: P256._ARCV1.H2G.G.Scalar
|
||||
) throws -> P256._ARCV1.CredentialResponse {
|
||||
let response = try self.backing.respond(credentialRequest: credentialRequest.backing, b: b)
|
||||
return P256._ARCV1.CredentialResponse(backing: response)
|
||||
}
|
||||
|
||||
/// Generate a credential response from a credential request.
|
||||
public func issue(_ credentialRequest: P256._ARCV1.CredentialRequest) throws -> P256._ARCV1.CredentialResponse {
|
||||
try self.issue(credentialRequest, b: .random)
|
||||
}
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.PublicKey {
|
||||
/// Create a credential from the issuer response.
|
||||
public func finalize(
|
||||
_ credentialResponse: P256._ARCV1.CredentialResponse,
|
||||
for precredential: P256._ARCV1.Precredential
|
||||
) throws -> P256._ARCV1.Credential {
|
||||
let credential = try precredential.backing.makeCredential(credentialResponse: credentialResponse.backing)
|
||||
return P256._ARCV1.Credential(backing: credential)
|
||||
}
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.Credential {
|
||||
internal mutating func makePresentation<D: DataProtocol>(
|
||||
context: D,
|
||||
presentationLimit: Int,
|
||||
fixedNonce: Int?,
|
||||
a: P256._ARCV1.H2G.G.Scalar,
|
||||
r: P256._ARCV1.H2G.G.Scalar,
|
||||
z: P256._ARCV1.H2G.G.Scalar
|
||||
) throws -> (presentation: P256._ARCV1.Presentation, nonce: Int) {
|
||||
let (presentation, nonce) = try self.backing.makePresentation(
|
||||
presentationContext: Data(context),
|
||||
presentationLimit: presentationLimit,
|
||||
a: a,
|
||||
r: r,
|
||||
z: z,
|
||||
optionalNonce: fixedNonce
|
||||
)
|
||||
return (P256._ARCV1.Presentation(backing: presentation), nonce)
|
||||
}
|
||||
|
||||
/// Create a presentation to provide to a verifier.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - context: The presentation context agreed with the verifier.
|
||||
/// - presentationLimit: The presentation limit to enforce.
|
||||
///
|
||||
/// - Returns: A presentation of this credential.
|
||||
///
|
||||
/// - Throws: An error if the presentation limit for this credential has been exceeded.
|
||||
public mutating func makePresentation<D: DataProtocol>(
|
||||
context: D,
|
||||
presentationLimit: Int
|
||||
) throws -> (presentation: P256._ARCV1.Presentation, nonce: Int) {
|
||||
try self.makePresentation(
|
||||
context: context,
|
||||
presentationLimit: presentationLimit,
|
||||
fixedNonce: nil,
|
||||
a: .random,
|
||||
r: .random,
|
||||
z: .random
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.PrivateKey {
|
||||
/// Verify a presentation is valid for a given attribute.
|
||||
///
|
||||
/// Presentation verification includes checking that:
|
||||
/// 1. The presentation is for the expected request context.
|
||||
/// 2. The presentation is for the expected presentation context.
|
||||
/// 3. The presentation nonce is appropriate for the presentation limit.
|
||||
/// 4. The presentation proof is valid.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - presentation: The presentation to verify.
|
||||
/// - requestContext: The expected request context encoded within the presentation.
|
||||
/// - presentationContext: The expected presentation context encoded within the presentation.
|
||||
/// - presentationLimit: The presentation limit to enforce.
|
||||
/// - nonce: The expected nonce encoded within the presentation.
|
||||
///
|
||||
/// - Returns: True if the presentation is valid, false otherwise.
|
||||
public func verify<D1: DataProtocol, D2: DataProtocol>(
|
||||
_ presentation: P256._ARCV1.Presentation,
|
||||
requestContext: D1,
|
||||
presentationContext: D2,
|
||||
presentationLimit: Int,
|
||||
nonce: Int
|
||||
) throws -> Bool {
|
||||
try self.backing.verify(
|
||||
presentation: presentation.backing,
|
||||
requestContext: Data(requestContext),
|
||||
presentationContext: Data(presentationContext),
|
||||
presentationLimit: presentationLimit,
|
||||
nonce: nonce
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - P384 + ARC(P-384)
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
extension P384 {
|
||||
/// Anonymous Rate-Limited Credentials (ARC).
|
||||
///
|
||||
@@ -24,14 +404,15 @@ extension P384 {
|
||||
/// - Seealso: [IETF Internet Draft: draft-yun-cfrg-arc-00](https://datatracker.ietf.org/doc/draft-yun-cfrg-arc).
|
||||
public enum _ARCV1 {
|
||||
internal typealias H2G = HashToCurveImpl<P384>
|
||||
fileprivate typealias Ciphersuite = ARC.Ciphersuite<H2G>
|
||||
internal typealias Ciphersuite = ARC.Ciphersuite<H2G>
|
||||
fileprivate typealias Server = ARC.Server<H2G>
|
||||
|
||||
fileprivate static var ciphersuite: Ciphersuite { Ciphersuite(H2G.self) }
|
||||
internal static let ciphersuite = Ciphersuite(H2G.self)
|
||||
}
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
extension P384._ARCV1 {
|
||||
/// The server secrets used to issue and verify credentials.
|
||||
public struct PrivateKey: Sendable {
|
||||
@@ -169,11 +550,11 @@ extension P384._ARCV1 {
|
||||
}
|
||||
|
||||
public init<D: DataProtocol>(rawRepresentation: D) throws {
|
||||
self.backing = try ARC.CredentialRequest.deserialize(requestData: rawRepresentation)
|
||||
self.backing = try ARC.CredentialRequest.deserialize(requestData: rawRepresentation, ciphersuite: P384._ARCV1.ciphersuite)
|
||||
}
|
||||
|
||||
public var rawRepresentation: Data {
|
||||
self.backing.serialize()
|
||||
self.backing.serialize(ciphersuite: P384._ARCV1.ciphersuite)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -204,11 +585,11 @@ extension P384._ARCV1 {
|
||||
}
|
||||
|
||||
public init<D: DataProtocol>(rawRepresentation: D) throws {
|
||||
self.backing = try ARC.CredentialResponse.deserialize(responseData: rawRepresentation)
|
||||
self.backing = try ARC.CredentialResponse.deserialize(responseData: rawRepresentation, ciphersuite: P384._ARCV1.ciphersuite)
|
||||
}
|
||||
|
||||
public var rawRepresentation: Data {
|
||||
self.backing.serialize()
|
||||
self.backing.serialize(ciphersuite: P384._ARCV1.ciphersuite)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -235,11 +616,11 @@ extension P384._ARCV1 {
|
||||
}
|
||||
|
||||
public init<D: DataProtocol>(rawRepresentation: D) throws {
|
||||
self.backing = try ARC.Presentation.deserialize(presentationData: rawRepresentation)
|
||||
self.backing = try ARC.Presentation.deserialize(presentationData: rawRepresentation, ciphersuite: P384._ARCV1.ciphersuite)
|
||||
}
|
||||
|
||||
public var rawRepresentation: Data {
|
||||
self.backing.serialize()
|
||||
self.backing.serialize(ciphersuite: P384._ARCV1.ciphersuite)
|
||||
}
|
||||
|
||||
public var tag: Data {
|
||||
@@ -249,6 +630,7 @@ extension P384._ARCV1 {
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
extension P384._ARCV1.PublicKey {
|
||||
internal func prepareCredentialRequest<D: DataProtocol>(
|
||||
requestContext: D,
|
||||
@@ -286,6 +668,7 @@ extension P384._ARCV1.PublicKey {
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
extension P384._ARCV1.PrivateKey {
|
||||
internal func issue(
|
||||
_ credentialRequest: P384._ARCV1.CredentialRequest,
|
||||
@@ -302,6 +685,7 @@ extension P384._ARCV1.PrivateKey {
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
extension P384._ARCV1.PublicKey {
|
||||
/// Create a credential from the issuer response.
|
||||
public func finalize(
|
||||
@@ -314,6 +698,7 @@ extension P384._ARCV1.PublicKey {
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
extension P384._ARCV1.Credential {
|
||||
internal mutating func makePresentation<D: DataProtocol>(
|
||||
context: D,
|
||||
@@ -359,6 +744,7 @@ extension P384._ARCV1.Credential {
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
extension P384._ARCV1.PrivateKey {
|
||||
/// Verify a presentation is valid for a given attribute.
|
||||
///
|
||||
|
||||
@@ -21,8 +21,6 @@ enum ARC {}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
extension ARC {
|
||||
static let domain = "ARCV1-P384"
|
||||
|
||||
enum Errors: Error {
|
||||
case invalidProof
|
||||
case invalidPresentationLimit
|
||||
@@ -40,26 +38,33 @@ extension ARC {
|
||||
/// Ciphersuites for Anonymous Rate-Limited Credentials (ARC)
|
||||
struct Ciphersuite<H2G: HashToGroup> {
|
||||
let suiteID: Int
|
||||
let domain: String
|
||||
let scalarByteCount: Int
|
||||
let pointByteCount: Int
|
||||
|
||||
init(_ h2g: H2G.Type) {
|
||||
switch h2g.self {
|
||||
case is HashToCurveImpl<P256>.Type:
|
||||
self.suiteID = 3
|
||||
self.domain = "ARCV1-P256"
|
||||
self.scalarByteCount = P256.orderByteCount
|
||||
self.pointByteCount = P256.compressedx962PointByteCount
|
||||
case is HashToCurveImpl<P384>.Type:
|
||||
self.suiteID = 4
|
||||
case is HashToCurveImpl<P521>.Type:
|
||||
self.suiteID = 5
|
||||
self.domain = "ARCV1-P384"
|
||||
self.scalarByteCount = P384.orderByteCount
|
||||
self.pointByteCount = P384.compressedx962PointByteCount
|
||||
default:
|
||||
fatalError("Anonymous Rate-Limited Credentials (ARC) only support corecrypto H2G.")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static func getGenerators<H2G: HashToGroup>(suite _: Ciphersuite<H2G>) -> (
|
||||
static func getGenerators<H2G: HashToGroup>(suite: Ciphersuite<H2G>) -> (
|
||||
generatorG: H2G.G.Element, generatorH: H2G.G.Element
|
||||
) {
|
||||
let generatorG = H2G.G.Element.generator
|
||||
let generatorH = H2G.hashToGroup(generatorG.oprfRepresentation, domainSeparationString: Data(("HashToGroup-" + ARC.domain + "generatorH").utf8))
|
||||
let generatorH = H2G.hashToGroup(generatorG.oprfRepresentation, domainSeparationString: Data(("HashToGroup-" + suite.domain + "generatorH").utf8))
|
||||
return (generatorG, generatorH)
|
||||
}
|
||||
}
|
||||
@@ -30,7 +30,7 @@ extension ARC {
|
||||
init(credentialResponse: CredentialResponse<H2G>, credentialRequest: CredentialRequest<H2G>, clientSecrets: ClientSecrets<Group.Scalar>, serverPublicKey: ServerPublicKey<H2G>, ciphersuite: Ciphersuite<H2G>, generatorG: Group.Element, generatorH: Group.Element) throws {
|
||||
// Verify credential response proof
|
||||
guard
|
||||
try credentialResponse.verify(request: credentialRequest, serverPublicKey: serverPublicKey, generatorG: generatorG, generatorH: generatorH)
|
||||
try credentialResponse.verify(request: credentialRequest, serverPublicKey: serverPublicKey, generatorG: generatorG, generatorH: generatorH, ciphersuite: ciphersuite)
|
||||
else {
|
||||
throw ARC.Errors.invalidProof
|
||||
}
|
||||
|
||||
@@ -14,148 +14,155 @@
|
||||
import Foundation
|
||||
import Crypto
|
||||
|
||||
@available(macOS 10.15, iOS 13, watchOS 6, tvOS 13, macCatalyst 13, visionOS 1.0, *)
|
||||
typealias ARCCurve = P384
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
typealias ARCH2G = HashToCurveImpl<ARCCurve>
|
||||
typealias ARCP256 = HashToCurveImpl<P256>
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
typealias ARCP384 = HashToCurveImpl<P384>
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
extension ARC.CredentialRequest where H2G == ARCH2G {
|
||||
static let scalarCount = 5
|
||||
static let serializedByteCount = 2 * ARCCurve.compressedx962PointByteCount + Self.scalarCount * ARCCurve.orderByteCount
|
||||
extension ARC.CredentialRequest {
|
||||
static func getScalarCount() -> Int { return 5 }
|
||||
static func getSerializedByteCount(_ ciphersuite: ARC.Ciphersuite<H2G>) -> Int {
|
||||
return 2 * ciphersuite.pointByteCount + Self.getScalarCount() * ciphersuite.scalarByteCount
|
||||
}
|
||||
|
||||
func serialize() -> Data {
|
||||
var result = Data(capacity: Self.serializedByteCount)
|
||||
result.append(self.m1Enc.compressedRepresentation)
|
||||
result.append(self.m2Enc.compressedRepresentation)
|
||||
result.append(self.proof.serialize())
|
||||
func serialize(ciphersuite: ARC.Ciphersuite<H2G>) -> Data {
|
||||
var result = Data(capacity: Self.getSerializedByteCount(ciphersuite))
|
||||
result.append(self.m1Enc.oprfRepresentation)
|
||||
result.append(self.m2Enc.oprfRepresentation)
|
||||
result.append(self.proof.serialize(ciphersuite: ciphersuite))
|
||||
return result
|
||||
}
|
||||
|
||||
static func deserialize<D: DataProtocol>(requestData: D) throws -> ARC.CredentialRequest<ARCH2G> {
|
||||
guard requestData.count == Self.serializedByteCount else {
|
||||
static func deserialize<D: DataProtocol>(requestData: D, ciphersuite: ARC.Ciphersuite<H2G>) throws -> ARC.CredentialRequest<H2G> {
|
||||
guard requestData.count == Self.getSerializedByteCount(ciphersuite) else {
|
||||
throw ARC.Errors.incorrectRequestDataSize
|
||||
}
|
||||
|
||||
var bytes = Data(requestData)
|
||||
|
||||
let m1Enc = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let m2Enc = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let proof = try Proof.deserialize(proofData: bytes, scalarCount: Self.scalarCount)
|
||||
let m1Enc = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let m2Enc = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let proof = try Proof<H2G>.deserialize(proofData: bytes, scalarCount: Self.getScalarCount(), ciphersuite: ciphersuite)
|
||||
|
||||
return ARC.CredentialRequest(m1Enc: m1Enc, m2Enc: m2Enc, proof: proof)
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
extension ARC.CredentialResponse where H2G == ARCH2G {
|
||||
static let scalarCount = 8
|
||||
static let serializedByteCount = 6 * ARCCurve.compressedx962PointByteCount + Self.scalarCount * ARCCurve.orderByteCount
|
||||
extension ARC.CredentialResponse {
|
||||
static func getScalarCount() -> Int { return 8 }
|
||||
static func getSerializedByteCount(_ ciphersuite: ARC.Ciphersuite<H2G>) -> Int {
|
||||
return 6 * ciphersuite.pointByteCount + Self.getScalarCount() * ciphersuite.scalarByteCount
|
||||
}
|
||||
|
||||
func serialize() -> Data {
|
||||
var result = Data(capacity: Self.serializedByteCount)
|
||||
func serialize(ciphersuite: ARC.Ciphersuite<H2G>) -> Data {
|
||||
var result = Data(capacity: Self.getSerializedByteCount(ciphersuite))
|
||||
|
||||
result.append(self.U.compressedRepresentation)
|
||||
result.append(self.encUPrime.compressedRepresentation)
|
||||
result.append(self.X0Aux.compressedRepresentation)
|
||||
result.append(self.X1Aux.compressedRepresentation)
|
||||
result.append(self.X2Aux.compressedRepresentation)
|
||||
result.append(self.HAux.compressedRepresentation)
|
||||
result.append(self.proof.serialize())
|
||||
result.append(self.U.oprfRepresentation)
|
||||
result.append(self.encUPrime.oprfRepresentation)
|
||||
result.append(self.X0Aux.oprfRepresentation)
|
||||
result.append(self.X1Aux.oprfRepresentation)
|
||||
result.append(self.X2Aux.oprfRepresentation)
|
||||
result.append(self.HAux.oprfRepresentation)
|
||||
result.append(self.proof.serialize(ciphersuite: ciphersuite))
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
static func deserialize<D: DataProtocol>(responseData: D) throws -> ARC.CredentialResponse<ARCH2G> {
|
||||
guard responseData.count == self.serializedByteCount else {
|
||||
static func deserialize<D: DataProtocol>(responseData: D, ciphersuite: ARC.Ciphersuite<H2G>) throws -> ARC.CredentialResponse<H2G> {
|
||||
guard responseData.count == self.getSerializedByteCount(ciphersuite) else {
|
||||
throw ARC.Errors.incorrectResponseDataSize
|
||||
}
|
||||
|
||||
var bytes = Data(responseData)
|
||||
|
||||
let U = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let encUPrime = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let X0Aux = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let X1Aux = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let X2Aux = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let HAux = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let U = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let encUPrime = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let X0Aux = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let X1Aux = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let X2Aux = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let HAux = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
|
||||
let proof = try Proof.deserialize(proofData: bytes, scalarCount: self.scalarCount)
|
||||
let proof = try Proof<H2G>.deserialize(proofData: bytes, scalarCount: Self.getScalarCount(), ciphersuite: ciphersuite)
|
||||
|
||||
return ARC.CredentialResponse(U: U, encUPrime: encUPrime, X0Aux: X0Aux, X1Aux: X1Aux, X2Aux: X2Aux, HAux: HAux, proof: proof)
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
extension ARC.Presentation where H2G == ARCH2G {
|
||||
static let scalarCount = 5
|
||||
static let pointCount = 4
|
||||
static let serializedByteCount = pointCount * ARCCurve.compressedx962PointByteCount + scalarCount * ARCCurve.orderByteCount
|
||||
extension ARC.Presentation {
|
||||
static func getScalarCount() -> Int { return 5 }
|
||||
static func getPointCount() -> Int { return 4 }
|
||||
static func getSerializedByteCount(_ ciphersuite: ARC.Ciphersuite<H2G>) -> Int {
|
||||
return Self.getPointCount() * ciphersuite.pointByteCount + Self.getScalarCount() * ciphersuite.scalarByteCount
|
||||
}
|
||||
|
||||
func serialize() -> Data {
|
||||
var result = Data(capacity: Self.serializedByteCount)
|
||||
func serialize(ciphersuite: ARC.Ciphersuite<H2G>) -> Data {
|
||||
var result = Data(capacity: Self.getSerializedByteCount(ciphersuite))
|
||||
|
||||
result.append(self.U.compressedRepresentation)
|
||||
result.append(self.UPrimeCommit.compressedRepresentation)
|
||||
result.append(self.m1Commit.compressedRepresentation)
|
||||
result.append(self.tag.compressedRepresentation)
|
||||
result.append(self.proof.serialize())
|
||||
result.append(self.U.oprfRepresentation)
|
||||
result.append(self.UPrimeCommit.oprfRepresentation)
|
||||
result.append(self.m1Commit.oprfRepresentation)
|
||||
result.append(self.tag.oprfRepresentation)
|
||||
result.append(self.proof.serialize(ciphersuite: ciphersuite))
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
static func deserialize<D: DataProtocol>(presentationData: D) throws -> ARC.Presentation<ARCH2G> {
|
||||
guard presentationData.count == self.serializedByteCount else {
|
||||
static func deserialize<D: DataProtocol>(presentationData: D, ciphersuite: ARC.Ciphersuite<H2G>) throws -> ARC.Presentation<H2G> {
|
||||
guard presentationData.count == self.getSerializedByteCount(ciphersuite) else {
|
||||
throw ARC.Errors.incorrectPresentationDataSize
|
||||
}
|
||||
|
||||
var bytes = Data(presentationData)
|
||||
|
||||
let U = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let UPrimeCommit = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let m1Commit = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let tag = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let presentationProof = try Proof.deserialize(proofData: bytes, scalarCount: Self.scalarCount)
|
||||
let U = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let UPrimeCommit = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let m1Commit = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let tag = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let presentationProof = try Proof<H2G>.deserialize(proofData: bytes, scalarCount: Self.getScalarCount(), ciphersuite: ciphersuite)
|
||||
|
||||
return ARC.Presentation(U: U, UPrimeCommit: UPrimeCommit, m1Commit: m1Commit, tag: tag, proof: presentationProof)
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
extension ARC.ServerPublicKey where H2G == ARCH2G {
|
||||
static let serializedByteCount = 3 * ARCCurve.compressedx962PointByteCount
|
||||
static let pointCount = 3 // TODO: delete
|
||||
extension ARC.ServerPublicKey {
|
||||
static func getSerializedByteCount(_ ciphersuite: ARC.Ciphersuite<H2G>) -> Int {
|
||||
return 3 * ciphersuite.pointByteCount
|
||||
}
|
||||
|
||||
func serialize() -> Data {
|
||||
var result = Data(capacity: Self.serializedByteCount)
|
||||
func serialize(ciphersuite: ARC.Ciphersuite<H2G>) -> Data {
|
||||
var result = Data(capacity: Self.getSerializedByteCount(ciphersuite))
|
||||
|
||||
result.append(self.X0.compressedRepresentation)
|
||||
result.append(self.X1.compressedRepresentation)
|
||||
result.append(self.X2.compressedRepresentation)
|
||||
result.append(self.X0.oprfRepresentation)
|
||||
result.append(self.X1.oprfRepresentation)
|
||||
result.append(self.X2.oprfRepresentation)
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
static func deserialize<D: DataProtocol>(serverPublicKeyData: D) throws -> ARC.ServerPublicKey<ARCH2G> {
|
||||
guard serverPublicKeyData.count == self.pointCount * ARCCurve.compressedx962PointByteCount else {
|
||||
static func deserialize<D: DataProtocol>(serverPublicKeyData: D, ciphersuite: ARC.Ciphersuite<H2G>) throws -> ARC.ServerPublicKey<H2G> {
|
||||
guard serverPublicKeyData.count == self.getSerializedByteCount(ciphersuite) else {
|
||||
throw ARC.Errors.incorrectServerCommitmentsSize
|
||||
}
|
||||
|
||||
var bytes = Data(serverPublicKeyData)
|
||||
|
||||
let X0 = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let X1 = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let X2 = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let X0 = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let X1 = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let X2 = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
|
||||
return ARC.ServerPublicKey(X0: X0, X1: X1, X2: X2)
|
||||
}
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
extension Proof where H2G == ARCH2G {
|
||||
func serialize() -> Data {
|
||||
extension Proof {
|
||||
func serialize(ciphersuite: ARC.Ciphersuite<H2G>) -> Data {
|
||||
let scalarCount = self.responses.count + 1
|
||||
var result = Data(capacity: scalarCount * ARCCurve.orderByteCount)
|
||||
var result = Data(capacity: scalarCount * ciphersuite.scalarByteCount)
|
||||
|
||||
// Serialize challenge
|
||||
result.append(self.challenge.rawRepresentation)
|
||||
@@ -166,21 +173,21 @@ extension Proof where H2G == ARCH2G {
|
||||
return result
|
||||
}
|
||||
|
||||
static func deserialize<D: DataProtocol>(proofData: D, scalarCount: Int) throws -> Proof<ARCH2G> {
|
||||
guard proofData.count == scalarCount * ARCCurve.orderByteCount else {
|
||||
static func deserialize<D: DataProtocol>(proofData: D, scalarCount: Int, ciphersuite: ARC.Ciphersuite<H2G>) throws -> Proof<H2G> {
|
||||
guard proofData.count == scalarCount * ciphersuite.scalarByteCount else {
|
||||
throw ARC.Errors.incorrectProofDataSize
|
||||
}
|
||||
|
||||
var bytes = Data(proofData)
|
||||
|
||||
// Deserialize challenge
|
||||
let challenge = try ARCH2G.G.Scalar(bytes: bytes.popFirst(ARCCurve.orderByteCount))
|
||||
let challenge = try H2G.G.Scalar(bytes: bytes.popFirst(ciphersuite.scalarByteCount), reductionIsModOrder: true)
|
||||
|
||||
// Deserialize responses
|
||||
var responses: [GroupImpl<ARCCurve>.Scalar] = []
|
||||
var responses: [H2G.G.Scalar] = []
|
||||
responses.reserveCapacity(scalarCount - 1)
|
||||
for _ in (0..<scalarCount-1) {
|
||||
let response = try ARCH2G.G.Scalar(bytes: bytes.popFirst(ARCCurve.orderByteCount))
|
||||
let response = try H2G.G.Scalar(bytes: bytes.popFirst(ciphersuite.scalarByteCount), reductionIsModOrder: true)
|
||||
responses.append(response)
|
||||
}
|
||||
|
||||
@@ -191,47 +198,47 @@ extension Proof where H2G == ARCH2G {
|
||||
// Serialize a ARC credential, to save and restore client state.
|
||||
// This will only be called client-side, and never be sent over the wire.
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
extension ARC.Credential where H2G == ARCH2G {
|
||||
static let scalarCount = 1
|
||||
static let pointCount = 5
|
||||
extension ARC.Credential {
|
||||
static func getScalarCount() -> Int { return 1 }
|
||||
static func getPointCount() -> Int { return 5 }
|
||||
static func getSerializedByteCountExcludingPresentationState(_ ciphersuite: ARC.Ciphersuite<H2G>) -> Int {
|
||||
return Self.getPointCount() * ciphersuite.pointByteCount + Self.getScalarCount() * ciphersuite.scalarByteCount
|
||||
}
|
||||
|
||||
static let serializedByteCountExcludingPresentationState = 1 * ARCCurve.orderByteCount + 5 * ARCCurve.compressedx962PointByteCount
|
||||
|
||||
func serialize() throws -> Data {
|
||||
func serialize(ciphersuite: ARC.Ciphersuite<H2G>) throws -> Data {
|
||||
let presentationStateBytes = try self.presentationState.serialize()
|
||||
|
||||
var result = Data(capacity: Self.serializedByteCountExcludingPresentationState + presentationStateBytes.count)
|
||||
var result = Data(capacity: Self.getSerializedByteCountExcludingPresentationState(ciphersuite) + presentationStateBytes.count)
|
||||
|
||||
result.append(self.m1.rawRepresentation)
|
||||
result.append(self.U.compressedRepresentation)
|
||||
result.append(self.UPrime.compressedRepresentation)
|
||||
result.append(self.X1.compressedRepresentation)
|
||||
result.append(self.generatorG.compressedRepresentation)
|
||||
result.append(self.generatorH.compressedRepresentation)
|
||||
result.append(self.U.oprfRepresentation)
|
||||
result.append(self.UPrime.oprfRepresentation)
|
||||
result.append(self.X1.oprfRepresentation)
|
||||
result.append(self.generatorG.oprfRepresentation)
|
||||
result.append(self.generatorH.oprfRepresentation)
|
||||
result.append(presentationStateBytes)
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
static func deserialize<D: DataProtocol>(credentialData: D) throws -> ARC.Credential<ARCH2G> {
|
||||
guard credentialData.count - Self.serializedByteCountExcludingPresentationState >= 0 else {
|
||||
static func deserialize<D: DataProtocol>(credentialData: D, ciphersuite: ARC.Ciphersuite<H2G>) throws -> ARC.Credential<H2G> {
|
||||
guard credentialData.count - Self.getSerializedByteCountExcludingPresentationState(ciphersuite) >= 0 else {
|
||||
throw ARC.Errors.incorrectCredentialDataSize
|
||||
}
|
||||
let credentialData = Data(credentialData)
|
||||
|
||||
var bytes = Data(credentialData)
|
||||
|
||||
let m1 = try ARCH2G.G.Scalar(bytes: bytes.popFirst(ARCCurve.orderByteCount))
|
||||
let U = try ARCH2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let UPrime = try ARCH2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let X1 = try ARCH2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let genG = try ARCH2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let genH = try ARCH2G.G.Element(oprfRepresentation: bytes.popFirst(ARCCurve.compressedx962PointByteCount))
|
||||
let m1 = try H2G.G.Scalar(bytes: bytes.popFirst(ciphersuite.scalarByteCount), reductionIsModOrder: true)
|
||||
let U = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let UPrime = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let X1 = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let genG = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
let genH = try H2G.G.Element(oprfRepresentation: bytes.popFirst(ciphersuite.pointByteCount))
|
||||
|
||||
// Deserialize presentationState from remaining bytes.
|
||||
let presentationState = try ARC.PresentationState.deserialize(presentationStateData: bytes)
|
||||
|
||||
let ciphersuite = ARC.Ciphersuite(ARCH2G.self)
|
||||
let ciphersuite = ARC.Ciphersuite(H2G.self)
|
||||
return ARC.Credential(m1: m1, U: U, UPrime: UPrime, X1: X1, ciphersuite: ciphersuite, generatorG: genG, generatorH: genH, presentationState: presentationState)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -40,12 +40,12 @@ extension ARC {
|
||||
let credentialRequest: CredentialRequest<H2G>
|
||||
|
||||
init(ciphersuite: Ciphersuite<H2G>, m1: Group.Scalar = Group.Scalar.random, requestContext: Data, r1: Group.Scalar = Group.Scalar.random, r2: Group.Scalar = Group.Scalar.random, serverPublicKey: ServerPublicKey<H2G>) throws {
|
||||
let m2 = try H2G.hashToScalar(requestContext, domainSeparationString: Data((ARC.domain + "requestContext").utf8))
|
||||
let m2 = try H2G.hashToScalar(requestContext, domainSeparationString: Data((ciphersuite.domain + "requestContext").utf8))
|
||||
self.clientSecrets = ClientSecrets(m1: m1, m2: m2, r1: r1, r2: r2)
|
||||
self.serverPublicKey = serverPublicKey
|
||||
self.ciphersuite = ciphersuite
|
||||
(self.generatorG, self.generatorH) = ARC.getGenerators(suite: ciphersuite)
|
||||
self.credentialRequest = try CredentialRequest(clientSecrets: self.clientSecrets, generatorG: generatorG, generatorH: generatorH)
|
||||
self.credentialRequest = try CredentialRequest(clientSecrets: self.clientSecrets, generatorG: generatorG, generatorH: generatorH, ciphersuite: ciphersuite)
|
||||
}
|
||||
|
||||
func makeCredential(credentialResponse: CredentialResponse<H2G>) throws -> Credential<H2G> {
|
||||
|
||||
@@ -45,9 +45,9 @@ extension ARC {
|
||||
let V = z * credential.X1 - r * generatorG
|
||||
|
||||
// Create tag: (m1 + nonce)^(-1) * H2G(presentationContext)
|
||||
let nonceScalar = try Group.Scalar(bytes: I2OSP(value: nonce, outputByteCount: ARCCurve.orderByteCount), reductionIsModOrder: true)
|
||||
let nonceScalar = try Group.Scalar(bytes: I2OSP(value: nonce, outputByteCount: credential.ciphersuite.scalarByteCount), reductionIsModOrder: true)
|
||||
let inverse = (nonceScalar + credential.m1) ^ (-1)
|
||||
let T = H2G.hashToGroup(presentationContext, domainSeparationString: Data(("HashToGroup-" + ARC.domain + "Tag").utf8))
|
||||
let T = H2G.hashToGroup(presentationContext, domainSeparationString: Data(("HashToGroup-" + credential.ciphersuite.domain + "Tag").utf8))
|
||||
let tag = inverse * T
|
||||
|
||||
// m1Tag is a helper element in the ZKP, and is needed to ensure the
|
||||
@@ -55,7 +55,7 @@ extension ARC {
|
||||
let m1Tag = credential.m1 * tag
|
||||
|
||||
// Create a prover, and allocate variables for the constrained scalars.
|
||||
var prover = Prover<H2G>(label: ARC.domain + ARC.domain + "CredentialPresentation")
|
||||
var prover = Prover<H2G>(label: credential.ciphersuite.domain + credential.ciphersuite.domain + "CredentialPresentation")
|
||||
let m1Var = prover.appendScalar(label: "m1", assignment: credential.m1)
|
||||
let zVar = prover.appendScalar(label: "z", assignment: z)
|
||||
let rNegVar = prover.appendScalar(label: "-r", assignment: -r)
|
||||
@@ -86,12 +86,10 @@ extension ARC {
|
||||
- nonce: Integer which is used for rate limiting, which should be in `[0, presentationLimit)`.
|
||||
- generatorG: Public generator G
|
||||
- generatorH: Public generator H
|
||||
- ciphersuite: The ciphersuite for ARC
|
||||
- Returns: a boolean for if the tag is valid and the tag proof verifies correctly.
|
||||
*/
|
||||
func verify(
|
||||
serverPrivateKey: ServerPrivateKey<Group.Scalar>, X1: Group.Element, m2: Group.Scalar, presentationContext: Data, presentationLimit: Int, nonce: Int,
|
||||
generatorG: Group.Element, generatorH: Group.Element
|
||||
) throws -> Bool {
|
||||
func verify(serverPrivateKey: ServerPrivateKey<Group.Scalar>, X1: Group.Element, m2: Group.Scalar, presentationContext: Data, presentationLimit: Int, nonce: Int, generatorG: Group.Element, generatorH: Group.Element, ciphersuite: Ciphersuite<H2G>) throws -> Bool {
|
||||
if nonce < 0 || nonce >= presentationLimit {
|
||||
return false // nonce is outside of the presentationLimit
|
||||
}
|
||||
@@ -103,14 +101,14 @@ extension ARC {
|
||||
let V = serverPrivateKey.x0 * self.U + serverPrivateKey.x1 * self.m1Commit + serverPrivateKey.x2 * m2 * self.U - self.UPrimeCommit
|
||||
|
||||
// Recompute T = H2G(presentationContext)
|
||||
let T = H2G.hashToGroup(presentationContext, domainSeparationString: Data(("HashToGroup-" + ARC.domain + "Tag").utf8))
|
||||
let T = H2G.hashToGroup(presentationContext, domainSeparationString: Data(("HashToGroup-" + ciphersuite.domain + "Tag").utf8))
|
||||
|
||||
// Recompute m1Tag = H2G(presentationContext) - nonce * tag
|
||||
var m1Tag = T
|
||||
for _ in 0..<nonce { m1Tag = m1Tag - self.tag }
|
||||
|
||||
// Create a verifier, and allocate variables for the constrained scalars.
|
||||
var verifier = Verifier<H2G>(label: ARC.domain + ARC.domain + "CredentialPresentation")
|
||||
var verifier = Verifier<H2G>(label: ciphersuite.domain + ciphersuite.domain + "CredentialPresentation")
|
||||
let m1Var = verifier.appendScalar(label: "m1")
|
||||
let zVar = verifier.appendScalar(label: "z")
|
||||
let rNegVar = verifier.appendScalar(label: "-r")
|
||||
|
||||
@@ -26,12 +26,12 @@ extension ARC {
|
||||
let m2Enc: Group.Element
|
||||
let proof: Proof<H2G>
|
||||
|
||||
init(clientSecrets: ClientSecrets<Group.Scalar>, generatorG: Group.Element, generatorH: Group.Element) throws {
|
||||
init(clientSecrets: ClientSecrets<Group.Scalar>, generatorG: Group.Element, generatorH: Group.Element, ciphersuite: Ciphersuite<H2G>) throws {
|
||||
let m1Enc = clientSecrets.m1 * generatorG + clientSecrets.r1 * generatorH
|
||||
let m2Enc = clientSecrets.m2 * generatorG + clientSecrets.r2 * generatorH
|
||||
|
||||
// Create a prover, and allocate variables for the constrained scalars.
|
||||
var prover = Prover<H2G>(label: ARC.domain + ARC.domain + "CredentialRequest")
|
||||
var prover = Prover<H2G>(label: ciphersuite.domain + ciphersuite.domain + "CredentialRequest")
|
||||
let m1Var = prover.appendScalar(label: "m1", assignment: clientSecrets.m1)
|
||||
let m2Var = prover.appendScalar(label: "m2", assignment: clientSecrets.m2)
|
||||
let r1Var = prover.appendScalar(label: "r1", assignment: clientSecrets.r1)
|
||||
@@ -50,7 +50,7 @@ extension ARC {
|
||||
self.proof = proof
|
||||
}
|
||||
|
||||
func verify(generatorG: Group.Element, generatorH: Group.Element) throws -> Bool {
|
||||
func verify(generatorG: Group.Element, generatorH: Group.Element, ciphersuite: Ciphersuite<H2G>) throws -> Bool {
|
||||
// Check that the encrypted attributes were generated with nonzero `m` and `r` values.
|
||||
if (self.m1Enc == generatorG || self.m1Enc == generatorH || self.m1Enc == self.m1Enc + self.m1Enc) ||
|
||||
(self.m2Enc == generatorG || self.m2Enc == generatorH || self.m2Enc == self.m2Enc + self.m2Enc) {
|
||||
@@ -58,7 +58,7 @@ extension ARC {
|
||||
}
|
||||
|
||||
// Create a verifier, and allocate variables for the constrained scalars.
|
||||
var verifier = Verifier<H2G>(label: ARC.domain + ARC.domain + "CredentialRequest")
|
||||
var verifier = Verifier<H2G>(label: ciphersuite.domain + ciphersuite.domain + "CredentialRequest")
|
||||
let m1Var = verifier.appendScalar(label: "m1")
|
||||
let m2Var = verifier.appendScalar(label: "m2")
|
||||
let r1Var = verifier.appendScalar(label: "r1")
|
||||
|
||||
@@ -48,7 +48,8 @@ extension ARC {
|
||||
serverPublicKey: ServerPublicKey<H2G>,
|
||||
generatorG: Group.Element,
|
||||
generatorH: Group.Element,
|
||||
b: Group.Scalar = Group.Scalar.random
|
||||
b: Group.Scalar = Group.Scalar.random,
|
||||
ciphersuite: Ciphersuite<H2G>
|
||||
) throws {
|
||||
let U = b * generatorG
|
||||
let X0Aux = b * serverPrivateKey.x0Blinding * generatorH
|
||||
@@ -61,7 +62,7 @@ extension ARC {
|
||||
let encUPrime = b * (serverPublicKey.X0 + serverPrivateKey.x1 * request.m1Enc + serverPrivateKey.x2 * request.m2Enc)
|
||||
|
||||
// Create a prover, and allocate variables for the constrained scalars.
|
||||
var prover = Prover<H2G>(label: ARC.domain + ARC.domain + "CredentialResponse")
|
||||
var prover = Prover<H2G>(label: ciphersuite.domain + ciphersuite.domain + "CredentialResponse")
|
||||
let x0Var = prover.appendScalar(label: "x0", assignment: serverPrivateKey.x0)
|
||||
let x1Var = prover.appendScalar(label: "x1", assignment: serverPrivateKey.x1)
|
||||
let x2Var = prover.appendScalar(label: "x2", assignment: serverPrivateKey.x2)
|
||||
@@ -95,15 +96,14 @@ extension ARC {
|
||||
self.proof = proof
|
||||
}
|
||||
|
||||
func verify(request: CredentialRequest<H2G>, serverPublicKey: ServerPublicKey<H2G>, generatorG: Group.Element, generatorH: Group.Element
|
||||
) throws -> Bool {
|
||||
func verify(request: CredentialRequest<H2G>, serverPublicKey: ServerPublicKey<H2G>, generatorG: Group.Element, generatorH: Group.Element, ciphersuite: Ciphersuite<H2G>) throws -> Bool {
|
||||
// Check that U, encUPrime are not 0
|
||||
if (self.U == self.U + self.U) || (self.encUPrime == self.encUPrime + self.encUPrime) {
|
||||
return false
|
||||
}
|
||||
|
||||
// Create a verifier, and allocate variables for the constrained scalars.
|
||||
var verifier = Verifier<H2G>(label: ARC.domain + ARC.domain + "CredentialResponse")
|
||||
var verifier = Verifier<H2G>(label: ciphersuite.domain + ciphersuite.domain + "CredentialResponse")
|
||||
let x0Var = verifier.appendScalar(label: "x0")
|
||||
let x1Var = verifier.appendScalar(label: "x1")
|
||||
let x2Var = verifier.appendScalar(label: "x2")
|
||||
|
||||
@@ -68,7 +68,7 @@ extension ARC {
|
||||
|
||||
func respond(credentialRequest: CredentialRequest<H2G>, b: Group.Scalar = Group.Scalar.random) throws -> CredentialResponse<H2G> {
|
||||
guard
|
||||
try credentialRequest.verify(generatorG: generatorG, generatorH: generatorH)
|
||||
try credentialRequest.verify(generatorG: generatorG, generatorH: generatorH, ciphersuite: self.ciphersuite)
|
||||
else {
|
||||
throw ARC.Errors.invalidProof
|
||||
}
|
||||
@@ -78,12 +78,13 @@ extension ARC {
|
||||
serverPublicKey: self.serverPublicKey,
|
||||
generatorG: generatorG,
|
||||
generatorH: generatorH,
|
||||
b: b
|
||||
b: b,
|
||||
ciphersuite: self.ciphersuite
|
||||
)
|
||||
}
|
||||
|
||||
func verify(presentation: Presentation<H2G>, requestContext: Data, presentationContext: Data, presentationLimit: Int, nonce: Int) throws -> Bool {
|
||||
let m2 = try H2G.hashToScalar(requestContext, domainSeparationString: Data((ARC.domain + "requestContext").utf8))
|
||||
let m2 = try H2G.hashToScalar(requestContext, domainSeparationString: Data((self.ciphersuite.domain + "requestContext").utf8))
|
||||
return try presentation.verify(
|
||||
serverPrivateKey: self.serverPrivateKey,
|
||||
X1: self.serverPublicKey.X1,
|
||||
@@ -92,7 +93,8 @@ extension ARC {
|
||||
presentationLimit: presentationLimit,
|
||||
nonce: nonce,
|
||||
generatorG: generatorG,
|
||||
generatorH: generatorH
|
||||
generatorH: generatorH,
|
||||
ciphersuite: self.ciphersuite
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -18,17 +18,24 @@ import XCTest
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
final class ARCAPITests: XCTestCase {
|
||||
|
||||
@available(*, deprecated, message: "ARC(P-384) has been removed from the IETF draft; use ARC(P-256) instead.")
|
||||
func testVectors() throws {
|
||||
let data = ARCEncodedTestVector.data(using: .utf8)!
|
||||
let decoder = JSONDecoder()
|
||||
for vector in try decoder.decode([ARCTestVector].self, from: data) {
|
||||
try testVector(vector)
|
||||
let vectors = try decoder.decode([ARCTestVector].self, from: data)
|
||||
XCTAssert(vectors.count > 0, "No test vectors found")
|
||||
for vector in vectors {
|
||||
switch vector.suite {
|
||||
case "ARCV1-P256": try testVector(vector, using: P256.self)
|
||||
case "ARCV1-P384": try testVector(vector, using: P384.self)
|
||||
default: XCTFail("Test vector suite not supported: \(vector.suite)")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testVector(_ vector: ARCTestVector) throws {
|
||||
fileprivate func testVector<Curve: ARCCurve>(_ vector: ARCTestVector, using _: Curve.Type = Curve.self) throws {
|
||||
// [Issuer] Create the server secrets.
|
||||
let privateKey = try P384._ARCV1.PrivateKey(rawRepresentation: Data(
|
||||
let privateKey = try Curve._ARCV1.PrivateKey(rawRepresentation: Data(
|
||||
hexString: vector.ServerKey.x0 + vector.ServerKey.x1 + vector.ServerKey.x2 + vector.ServerKey.xb
|
||||
))
|
||||
|
||||
@@ -52,14 +59,14 @@ final class ARCAPITests: XCTestCase {
|
||||
_ = (publicKeyBytes, requestContext, presentationContext, presentationLimit)
|
||||
|
||||
// [Client] Obtain public key out of band (other serializations may be available).
|
||||
let publicKey = try P384._ARCV1.PublicKey(rawRepresentation: publicKeyBytes)
|
||||
let publicKey = try Curve._ARCV1.PublicKey(rawRepresentation: publicKeyBytes)
|
||||
|
||||
// [Client] Prepare a credential request using fixed values from test vector.
|
||||
let precredential = try publicKey.prepareCredentialRequest(
|
||||
requestContext: requestContext,
|
||||
m1: P384._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.CredentialRequest.m1)),
|
||||
r1: P384._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.CredentialRequest.r1)),
|
||||
r2: P384._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.CredentialRequest.r2))
|
||||
m1: Curve._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.CredentialRequest.m1)),
|
||||
r1: Curve._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.CredentialRequest.r1)),
|
||||
r2: Curve._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.CredentialRequest.r2))
|
||||
)
|
||||
|
||||
// [Client -> Issuer] Send the credential request.
|
||||
@@ -67,17 +74,17 @@ final class ARCAPITests: XCTestCase {
|
||||
|
||||
// [CHECK] Credential request scalars match test vector.
|
||||
XCTAssertEqual(
|
||||
credentialRequestBytes[..<(2 * P384.compressedx962PointByteCount)].hexString,
|
||||
credentialRequestBytes[..<(2 * Curve.compressedx962PointByteCount)].hexString,
|
||||
vector.CredentialRequest.m1_enc + vector.CredentialRequest.m2_enc
|
||||
)
|
||||
|
||||
// [Issuer] Receive the credential request.
|
||||
let credentialRequest = try P384._ARCV1.CredentialRequest(rawRepresentation: credentialRequestBytes)
|
||||
let credentialRequest = try Curve._ARCV1.CredentialRequest(rawRepresentation: credentialRequestBytes)
|
||||
|
||||
// [Issuer] Generate a credential response with fixed value from test vector.
|
||||
let credentialResponse = try privateKey.issue(
|
||||
credentialRequest,
|
||||
b: P384._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.CredentialResponse.b))
|
||||
b: Curve._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.CredentialResponse.b))
|
||||
)
|
||||
|
||||
// [Issuer -> Client] Send the credential response.
|
||||
@@ -85,7 +92,7 @@ final class ARCAPITests: XCTestCase {
|
||||
|
||||
// [CHECK] Credential response scalars match test vector, excluding proof.
|
||||
XCTAssertEqual(
|
||||
credentialResponseBytes[..<(6 * P384.compressedx962PointByteCount)].hexString,
|
||||
credentialResponseBytes[..<(6 * Curve.compressedx962PointByteCount)].hexString,
|
||||
vector.CredentialResponse.U
|
||||
+ vector.CredentialResponse.enc_U_prime
|
||||
+ vector.CredentialResponse.X0_aux
|
||||
@@ -95,7 +102,7 @@ final class ARCAPITests: XCTestCase {
|
||||
)
|
||||
|
||||
// [Client] Receive the credential response.
|
||||
let _ = try P384._ARCV1.CredentialResponse(rawRepresentation: credentialResponseBytes)
|
||||
let _ = try Curve._ARCV1.CredentialResponse(rawRepresentation: credentialResponseBytes)
|
||||
|
||||
// [Client] Generate a credential.
|
||||
var credential = try publicKey.finalize(credentialResponse, for: precredential)
|
||||
@@ -111,9 +118,9 @@ final class ARCAPITests: XCTestCase {
|
||||
context: presentationContext,
|
||||
presentationLimit: presentationLimit,
|
||||
fixedNonce: Int(vector.Presentation1.nonce.dropFirst(2), radix: 16)!,
|
||||
a: P384._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.Presentation1.a)),
|
||||
r: P384._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.Presentation1.r)),
|
||||
z: P384._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.Presentation1.z))
|
||||
a: Curve._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.Presentation1.a)),
|
||||
r: Curve._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.Presentation1.r)),
|
||||
z: Curve._ARCV1.H2G.G.Scalar(bytes: Data(hexString: vector.Presentation1.z))
|
||||
)
|
||||
|
||||
// NOTE: The presentation proof depends on randomly generated blinding factors. This layer doesn't expose
|
||||
@@ -135,14 +142,14 @@ final class ARCAPITests: XCTestCase {
|
||||
|
||||
// [CHECK]: Serialization of presentation (ecluding proof) matches spec.
|
||||
XCTAssertEqual(
|
||||
presentation.rawRepresentation[..<(4 * P384.compressedx962PointByteCount)].hexString,
|
||||
presentation.rawRepresentation[..<(4 * Curve.compressedx962PointByteCount)].hexString,
|
||||
vector.Presentation1.U
|
||||
+ vector.Presentation1.U_prime_commit
|
||||
+ vector.Presentation1.m1_commit
|
||||
+ vector.Presentation1.tag
|
||||
)
|
||||
XCTAssertEqual(
|
||||
presentation.rawRepresentation[(4 * P384.compressedx962PointByteCount)...].hexString.count,
|
||||
presentation.rawRepresentation[(4 * Curve.compressedx962PointByteCount)...].hexString.count,
|
||||
vector.Presentation1.proof.count
|
||||
)
|
||||
|
||||
@@ -155,12 +162,12 @@ final class ARCAPITests: XCTestCase {
|
||||
+ vector.Presentation1.proof
|
||||
)
|
||||
XCTAssertEqual(
|
||||
try P384._ARCV1.Presentation(rawRepresentation: testVectorPresentationBytes).rawRepresentation.hexString,
|
||||
try Curve._ARCV1.Presentation(rawRepresentation: testVectorPresentationBytes).rawRepresentation.hexString,
|
||||
testVectorPresentationBytes.hexString
|
||||
)
|
||||
|
||||
// [Verifier] Receive the presentation (and the nonce, out of band).
|
||||
let receivedPresentation = try P384._ARCV1.Presentation(rawRepresentation: testVectorPresentationBytes)
|
||||
let receivedPresentation = try Curve._ARCV1.Presentation(rawRepresentation: testVectorPresentationBytes)
|
||||
let nonce = Int(vector.Presentation1.nonce.dropFirst(2), radix: 16)!
|
||||
|
||||
// [Verifier] Verify the presentation.
|
||||
@@ -174,3 +181,172 @@ final class ARCAPITests: XCTestCase {
|
||||
XCTAssertTrue(validPresentation)
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Fileprivate protocols to create a unified test over the ARC curves.
|
||||
|
||||
fileprivate protocol ARCCredentialRequest {
|
||||
init(rawRepresentation: some DataProtocol) throws
|
||||
var rawRepresentation: Data { get }
|
||||
}
|
||||
|
||||
fileprivate protocol ARCCredentialResponse {
|
||||
init(rawRepresentation: some DataProtocol) throws
|
||||
var rawRepresentation: Data { get }
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
fileprivate protocol ARCPresentation<H2G> {
|
||||
associatedtype H2G: HashToGroup
|
||||
var backing: ARC.Presentation<H2G> { get }
|
||||
init(rawRepresentation: some DataProtocol) throws
|
||||
var rawRepresentation: Data { get }
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
fileprivate protocol ARCCredential<H2G, Presentation> {
|
||||
associatedtype H2G: HashToGroup
|
||||
associatedtype Presentation: ARCPresentation
|
||||
var backing: ARC.Credential<H2G> { get }
|
||||
mutating func makePresentation(
|
||||
context: some DataProtocol,
|
||||
presentationLimit: Int,
|
||||
fixedNonce: Int?,
|
||||
a: H2G.G.Scalar,
|
||||
r: H2G.G.Scalar,
|
||||
z: H2G.G.Scalar
|
||||
) throws -> (presentation: Presentation, nonce: Int)
|
||||
mutating func makePresentation(context: some DataProtocol, presentationLimit: Int) throws -> (presentation: Presentation, nonce: Int)
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
fileprivate protocol ARCPrivateKey<H2G, CredentialRequest, CredentialResponse, Credential, Presentation> {
|
||||
associatedtype H2G: HashToGroup
|
||||
associatedtype Credential
|
||||
associatedtype PublicKey: ARCPublicKey<H2G, CredentialResponse, Credential>
|
||||
associatedtype CredentialRequest: ARCCredentialRequest
|
||||
associatedtype CredentialResponse: ARCCredentialResponse
|
||||
associatedtype Presentation: ARCPresentation
|
||||
init(rawRepresentation: some DataProtocol) throws
|
||||
var rawRepresentation: Data { get }
|
||||
var publicKey: PublicKey { get }
|
||||
func issue(_ credentialRequest: CredentialRequest, b: H2G.G.Scalar) throws -> CredentialResponse
|
||||
func verify(
|
||||
_: Presentation,
|
||||
requestContext: some DataProtocol,
|
||||
presentationContext: some DataProtocol,
|
||||
presentationLimit: Int,
|
||||
nonce: Int
|
||||
) throws -> Bool
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
fileprivate protocol ARCPublicKey<H2G, CredentialResponse, Credential> {
|
||||
associatedtype H2G: HashToGroup
|
||||
associatedtype Precredential: ARCPrecredential
|
||||
associatedtype CredentialResponse: ARCCredentialResponse
|
||||
associatedtype Credential: ARCCredential
|
||||
init(rawRepresentation: some DataProtocol) throws
|
||||
var rawRepresentation: Data { get }
|
||||
func prepareCredentialRequest(requestContext: some DataProtocol, m1: H2G.G.Scalar, r1: H2G.G.Scalar, r2: H2G.G.Scalar) throws -> Precredential
|
||||
func prepareCredentialRequest(requestContext: some DataProtocol) throws -> Precredential
|
||||
func finalize(_ credentialResponse: CredentialResponse, for precredential: Precredential) throws -> Credential
|
||||
}
|
||||
|
||||
fileprivate protocol ARCPrecredential {
|
||||
associatedtype CredentialRequest: ARCCredentialRequest
|
||||
var credentialRequest: CredentialRequest { get }
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
fileprivate protocol ARCV1<H2G> {
|
||||
associatedtype H2G: HashToGroup
|
||||
associatedtype CredentialRequest: ARCCredentialRequest
|
||||
associatedtype CredentialResponse: ARCCredentialResponse
|
||||
associatedtype Presentation: ARCPresentation<H2G>
|
||||
associatedtype Credential: ARCCredential<H2G, Presentation>
|
||||
associatedtype PrivateKey: ARCPrivateKey<H2G, CredentialRequest, CredentialResponse, Credential, Presentation>
|
||||
associatedtype PublicKey: ARCPublicKey<H2G, CredentialResponse, Credential>
|
||||
}
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
fileprivate protocol ARCCurve: OpenSSLSupportedNISTCurve {
|
||||
associatedtype H2G: HashToGroup where H2G == OpenSSLHashToCurve<Self>
|
||||
associatedtype _ARCV1: ARCV1<H2G>
|
||||
}
|
||||
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.Precredential: ARCPrecredential {}
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.CredentialRequest: ARCCredentialRequest {}
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.CredentialResponse: ARCCredentialResponse {}
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.Credential: ARCCredential {}
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.Presentation: ARCPresentation {}
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.PublicKey: ARCPublicKey {
|
||||
typealias H2G = P256._ARCV1.H2G
|
||||
}
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1.PrivateKey: ARCPrivateKey {}
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256._ARCV1: ARCV1 {}
|
||||
@available(iOS 16.0, macOS 13.0, watchOS 9.0, tvOS 16.0, macCatalyst 16.0, visionOS 2.0, *)
|
||||
extension P256: ARCCurve {}
|
||||
|
||||
|
||||
@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._ARCV1.Precredential: ARCPrecredential {}
|
||||
@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._ARCV1.CredentialRequest: ARCCredentialRequest {}
|
||||
@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._ARCV1.CredentialResponse: ARCCredentialResponse {}
|
||||
@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._ARCV1.Credential: ARCCredential {}
|
||||
@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._ARCV1.Presentation: ARCPresentation {}
|
||||
@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._ARCV1.PublicKey: ARCPublicKey {
|
||||
typealias H2G = P384._ARCV1.H2G
|
||||
}
|
||||
@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._ARCV1.PrivateKey: ARCPrivateKey {}
|
||||
@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._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
|
||||
@@ -17,30 +17,35 @@ import Crypto
|
||||
|
||||
@available(macOS 10.15, iOS 13.2, tvOS 13.2, watchOS 6.1, macCatalyst 13.2, visionOS 1.2, *)
|
||||
class ARCEncodingTests: XCTestCase {
|
||||
func testserverPublicKeyEncoding() throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<ARCCurve>.self)
|
||||
func serverPublicKeyEncoding<Curve: SupportedCurveDetailsImpl>(CurveType _: Curve.Type) throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<Curve>.self)
|
||||
let server = ARC.Server(ciphersuite: ciphersuite)
|
||||
let publicKey = server.serverPublicKey
|
||||
|
||||
let publicKeyData = publicKey.serialize()
|
||||
let publicKey2 = try ARC.ServerPublicKey.deserialize(serverPublicKeyData: publicKeyData)
|
||||
let publicKeyData = publicKey.serialize(ciphersuite: ciphersuite)
|
||||
let publicKey2 = try ARC.ServerPublicKey.deserialize(serverPublicKeyData: publicKeyData, ciphersuite: ciphersuite)
|
||||
XCTAssert(publicKey.X0 == publicKey2.X0)
|
||||
XCTAssert(publicKey.X1 == publicKey2.X1)
|
||||
XCTAssert(publicKey.X2 == publicKey2.X2)
|
||||
|
||||
let publicKeyData2 = publicKey2.serialize()
|
||||
let publicKeyData2 = publicKey2.serialize(ciphersuite: ciphersuite)
|
||||
XCTAssertEqual(publicKeyData, publicKeyData2)
|
||||
}
|
||||
|
||||
func testRequestEncoding() throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<ARCCurve>.self)
|
||||
func testServerPublicKeyEncoding() throws {
|
||||
try serverPublicKeyEncoding(CurveType: P256.self)
|
||||
try serverPublicKeyEncoding(CurveType: P384.self)
|
||||
}
|
||||
|
||||
func requestEncoding<Curve: SupportedCurveDetailsImpl>(CurveType _: Curve.Type) throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<Curve>.self)
|
||||
let server = ARC.Server(ciphersuite: ciphersuite)
|
||||
let requestContext = Data("test request context".utf8)
|
||||
let precredential = try ARC.Precredential(ciphersuite: ciphersuite, requestContext: requestContext, serverPublicKey: server.serverPublicKey)
|
||||
let request = precredential.credentialRequest
|
||||
|
||||
let requestData = request.serialize()
|
||||
let request2 = try ARC.CredentialRequest.deserialize(requestData: requestData)
|
||||
let requestData = request.serialize(ciphersuite: ciphersuite)
|
||||
let request2 = try ARC.CredentialRequest.deserialize(requestData: requestData, ciphersuite: ciphersuite)
|
||||
XCTAssert(request.m1Enc == request2.m1Enc)
|
||||
XCTAssert(request.m2Enc == request2.m2Enc)
|
||||
XCTAssert(request.proof.challenge == request2.proof.challenge)
|
||||
@@ -48,20 +53,25 @@ class ARCEncodingTests: XCTestCase {
|
||||
XCTAssert(response == request2.proof.responses[index])
|
||||
}
|
||||
|
||||
let requestData2 = request2.serialize()
|
||||
let requestData2 = request2.serialize(ciphersuite: ciphersuite)
|
||||
XCTAssertEqual(requestData, requestData2)
|
||||
}
|
||||
|
||||
func testResponseEncoding() throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<ARCCurve>.self)
|
||||
func testRequestEncoding() throws {
|
||||
try requestEncoding(CurveType: P256.self)
|
||||
try requestEncoding(CurveType: P384.self)
|
||||
}
|
||||
|
||||
func responseEncoding<Curve: SupportedCurveDetailsImpl>(CurveType _: Curve.Type) throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<Curve>.self)
|
||||
let server = ARC.Server(ciphersuite: ciphersuite)
|
||||
let requestContext = Data("test request context".utf8)
|
||||
let precredential = try ARC.Precredential(ciphersuite: ciphersuite, requestContext: requestContext, serverPublicKey: server.serverPublicKey)
|
||||
let request = precredential.credentialRequest
|
||||
let response = try server.respond(credentialRequest: request)
|
||||
|
||||
let responseData = response.serialize()
|
||||
let response2 = try ARC.CredentialResponse.deserialize(responseData: responseData)
|
||||
let responseData = response.serialize(ciphersuite: ciphersuite)
|
||||
let response2 = try ARC.CredentialResponse.deserialize(responseData: responseData, ciphersuite: ciphersuite)
|
||||
XCTAssert(response.U == response2.U)
|
||||
XCTAssert(response.encUPrime == response2.encUPrime)
|
||||
XCTAssert(response.X0Aux == response2.X0Aux)
|
||||
@@ -73,12 +83,17 @@ class ARCEncodingTests: XCTestCase {
|
||||
XCTAssert(response == response2.proof.responses[index])
|
||||
}
|
||||
|
||||
let responseData2 = response2.serialize()
|
||||
let responseData2 = response2.serialize(ciphersuite: ciphersuite)
|
||||
XCTAssertEqual(responseData, responseData2)
|
||||
}
|
||||
|
||||
func testCredentialEncoding() throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<ARCCurve>.self)
|
||||
func testResponseEncoding() throws {
|
||||
try responseEncoding(CurveType: P256.self)
|
||||
try responseEncoding(CurveType: P384.self)
|
||||
}
|
||||
|
||||
func credentialEncoding<Curve: SupportedCurveDetailsImpl>(CurveType _: Curve.Type) throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<Curve>.self)
|
||||
let server = ARC.Server(ciphersuite: ciphersuite)
|
||||
let requestContext = Data("test request context".utf8)
|
||||
let precredential = try ARC.Precredential(ciphersuite: ciphersuite, requestContext: requestContext, serverPublicKey: server.serverPublicKey)
|
||||
@@ -86,8 +101,8 @@ class ARCEncodingTests: XCTestCase {
|
||||
let response = try server.respond(credentialRequest: request)
|
||||
let credential = try precredential.makeCredential(credentialResponse: response)
|
||||
|
||||
let credentialData = try credential.serialize()
|
||||
let credential2 = try ARC.Credential.deserialize(credentialData: credentialData)
|
||||
let credentialData = try credential.serialize(ciphersuite: ciphersuite)
|
||||
let credential2 = try ARC.Credential.deserialize(credentialData: credentialData, ciphersuite: ciphersuite)
|
||||
XCTAssert(credential.m1 == credential2.m1)
|
||||
XCTAssert(credential.U == credential2.U)
|
||||
XCTAssert(credential.UPrime == credential2.UPrime)
|
||||
@@ -99,12 +114,17 @@ class ARCEncodingTests: XCTestCase {
|
||||
XCTAssertEqual(value.1, credential2.presentationState.state[key]?.1)
|
||||
}
|
||||
|
||||
let credentialData2 = try credential2.serialize()
|
||||
let credentialData2 = try credential2.serialize(ciphersuite: ciphersuite)
|
||||
XCTAssertEqual(credentialData, credentialData2)
|
||||
}
|
||||
|
||||
func testPresentationEncoding() throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<ARCCurve>.self)
|
||||
func testCredentialEncoding() throws {
|
||||
try credentialEncoding(CurveType: P256.self)
|
||||
try credentialEncoding(CurveType: P384.self)
|
||||
}
|
||||
|
||||
func presentationEncoding<Curve: SupportedCurveDetailsImpl>(CurveType _: Curve.Type) throws {
|
||||
let ciphersuite = ARC.Ciphersuite(HashToCurveImpl<Curve>.self)
|
||||
let server = ARC.Server(ciphersuite: ciphersuite)
|
||||
let requestContext = Data("test request context".utf8)
|
||||
let precredential = try ARC.Precredential(ciphersuite: ciphersuite, requestContext: requestContext, serverPublicKey: server.serverPublicKey)
|
||||
@@ -113,8 +133,8 @@ class ARCEncodingTests: XCTestCase {
|
||||
var credential = try precredential.makeCredential(credentialResponse: response)
|
||||
let (presentation, _) = try credential.makePresentation(presentationContext: Data("test presentation context".utf8), presentationLimit: 1)
|
||||
|
||||
let presentationData = presentation.serialize()
|
||||
let presentation2 = try ARC.Presentation.deserialize(presentationData: presentationData)
|
||||
let presentationData = presentation.serialize(ciphersuite: ciphersuite)
|
||||
let presentation2 = try ARC.Presentation.deserialize(presentationData: presentationData, ciphersuite: ciphersuite)
|
||||
XCTAssert(presentation.U == presentation2.U)
|
||||
XCTAssert(presentation.UPrimeCommit == presentation2.UPrimeCommit)
|
||||
XCTAssert(presentation.m1Commit == presentation2.m1Commit)
|
||||
@@ -124,10 +144,15 @@ class ARCEncodingTests: XCTestCase {
|
||||
XCTAssert(response == presentation2.proof.responses[index])
|
||||
}
|
||||
|
||||
let presentationData2 = presentation2.serialize()
|
||||
let presentationData2 = presentation2.serialize(ciphersuite: ciphersuite)
|
||||
XCTAssertEqual(presentationData, presentationData2)
|
||||
}
|
||||
|
||||
func testPresentationEncoding() throws {
|
||||
try presentationEncoding(CurveType: P256.self)
|
||||
try presentationEncoding(CurveType: P384.self)
|
||||
}
|
||||
|
||||
func testPresentationStateEncoding() throws {
|
||||
let emptyPresentationState = ARC.PresentationState()
|
||||
let smallPresentationState = ARC.PresentationState(state: [Data("context1".utf8): (4, [1, 2, 3]), Data("context2".utf8): (10, [4, 5, 6])])
|
||||
|
||||
@@ -20,7 +20,7 @@ final class ARCPublicAPITests: XCTestCase {
|
||||
|
||||
func testARCEndToEnd() throws {
|
||||
// [Issuer] Create the server secrets (other initializers will be available).
|
||||
let privateKey = P384._ARCV1.PrivateKey()
|
||||
let privateKey = P256._ARCV1.PrivateKey()
|
||||
|
||||
// [Issuer] Serialize public key to share with client (other serializations may be available).
|
||||
let publicKeyBytes = privateKey.publicKey.rawRepresentation
|
||||
@@ -35,7 +35,7 @@ final class ARCPublicAPITests: XCTestCase {
|
||||
_ = (publicKeyBytes, requestContext, presentationContext, presentationLimit)
|
||||
|
||||
// [Client] Obtain public key out of band (other serializations may be available).
|
||||
let publicKey = try P384._ARCV1.PublicKey(rawRepresentation: publicKeyBytes)
|
||||
let publicKey = try P256._ARCV1.PublicKey(rawRepresentation: publicKeyBytes)
|
||||
|
||||
// [Client] Prepare a credential request.
|
||||
let precredential = try publicKey.prepareCredentialRequest(requestContext: requestContext)
|
||||
@@ -44,7 +44,7 @@ final class ARCPublicAPITests: XCTestCase {
|
||||
let credentialRequestBytes = precredential.credentialRequest.rawRepresentation
|
||||
|
||||
// [Issuer] Receive the credential request.
|
||||
let credentialRequest = try P384._ARCV1.CredentialRequest(rawRepresentation: credentialRequestBytes)
|
||||
let credentialRequest = try P256._ARCV1.CredentialRequest(rawRepresentation: credentialRequestBytes)
|
||||
|
||||
// [Issuer] Generate a credential response.
|
||||
let credentialResponse = try privateKey.issue(credentialRequest)
|
||||
@@ -53,7 +53,7 @@ final class ARCPublicAPITests: XCTestCase {
|
||||
let credentialResponseBytes = credentialResponse.rawRepresentation
|
||||
|
||||
// [Client] Receive the credential response.
|
||||
let _ = try P384._ARCV1.CredentialResponse(rawRepresentation: credentialResponseBytes)
|
||||
let _ = try P256._ARCV1.CredentialResponse(rawRepresentation: credentialResponseBytes)
|
||||
|
||||
// [Client] Generate a credential.
|
||||
// NOTE: This is a var because it enforces the presentation limits for each presentation prefix.
|
||||
@@ -70,7 +70,7 @@ final class ARCPublicAPITests: XCTestCase {
|
||||
let presentationBytes = presentation.rawRepresentation
|
||||
|
||||
// [Verifier] Receive the presentation.
|
||||
let _ = try P384._ARCV1.Presentation(rawRepresentation: presentationBytes)
|
||||
let _ = try P256._ARCV1.Presentation(rawRepresentation: presentationBytes)
|
||||
|
||||
// [Verifier] Verify the presentation.
|
||||
let validPresentation = try privateKey.verify(
|
||||
@@ -87,7 +87,7 @@ final class ARCPublicAPITests: XCTestCase {
|
||||
}
|
||||
|
||||
func testCrendentialEnforcesPresentationLimitLocally() throws {
|
||||
let privateKey = P384._ARCV1.PrivateKey()
|
||||
let privateKey = P256._ARCV1.PrivateKey()
|
||||
let publicKey = privateKey.publicKey
|
||||
let requestContext = Data("shared request context".utf8)
|
||||
let presentationContext = Data("shared presentation context".utf8)
|
||||
|
||||
@@ -17,6 +17,68 @@ import XCTest
|
||||
|
||||
let ARCEncodedTestVector = """
|
||||
[
|
||||
{
|
||||
"Credential": {
|
||||
"U": "033ee1ebbcff622bc26b10932ed1eb147226d832048fb2337dc0ad7722cb07483d",
|
||||
"U_prime": "02637fe04cc143281ee607bd8f898e670293dce44a2840b9cbb9e0d1fc7a2b29b4",
|
||||
"X1": "03c413230a9bd956718aa46138a33f774f4c708d61c1d6400d404243049d4a31dc",
|
||||
"m1": "eedfe7939e2382934ab5b0f76aae44124955d2c5ebf9b41d88786259c34692d2"
|
||||
},
|
||||
"CredentialRequest": {
|
||||
"m1": "eedfe7939e2382934ab5b0f76aae44124955d2c5ebf9b41d88786259c34692d2",
|
||||
"m1_enc": "03b8f11506a5302424143573e087fa20195cb5e893a67ef354eae3a78e263c54e4",
|
||||
"m2": "911fb315257d9ae29d47ecb48c6fa27074dee6860a0489f8db6ac9a486be6a3e",
|
||||
"m2_enc": "03f1ae4d7b78ba8030bd63859d4f4a909395c52bda34716b6620a2fdd52b336fc9",
|
||||
"proof": "0f361327abbc724ff0d37db365065bc4bd60e18125842bb4c03a7e5a632a1e95e74dcc440fcb9fb39106922e0d2544e6c82ca710abf35e8b10bf5d61296c9adb7d683eaed9a76a755b73f2b4b6e763a7c7883ce4b5c21bd02cd96b9af18cfb227f1acb4ead77c85049d291ed7841405610843f163e9cc2f6a8869111582324cd32bf13000c129d274ccf5386cb90e839916d5dff7eade18e3eabec415f613911",
|
||||
"r1": "008035081690bfde3b1e68b91443c22cc791d244340fe957d5aa44d7313740df",
|
||||
"r2": "d59c5e6ff560cc597c2b8ca25256c720bceca2ab03921492c5e9e4ad3b558002",
|
||||
"request_context": "74657374207265717565737420636f6e74657874"
|
||||
},
|
||||
"CredentialResponse": {
|
||||
"H_aux": "03d3cd09eeb8d19716586a49260c69309c495a717a36cad3381f6c02ac80b70e64",
|
||||
"U": "033ee1ebbcff622bc26b10932ed1eb147226d832048fb2337dc0ad7722cb07483d",
|
||||
"X0_aux": "02d453c121324114367906bd11ffc3b6e6a77b75382497279b1a60ab8412c1dec6",
|
||||
"X1_aux": "03b0e4b1f376c6207bf34efda46ce54b132a20b90bc28b9152f3e441fe2b508b63",
|
||||
"X2_aux": "0327369efcb7577abaeb7b56940e6e042126900bdf8bd8944c0adbb7be3ad98e2a",
|
||||
"b": "e699140babbe599f7dd8f6e3e8f615e5f201d1c2b0bc2f821f19e80a0a0e1e7b",
|
||||
"enc_U_prime": "035b8e09ce8776f1a2c7ef8610c9a6a39936c5666ab8b28d6629d3685056716482",
|
||||
"proof": "dd4596175db0b4273fcdff330370d2b5e7a4bf92bf518141f4553af37ef0e1260cb8312affc2462800adba102117448b449985d1704d8afd0df9ac708231561dca56faae325cb56b0a9e8ad07bdc6ce90f6e7430090e970a7240e289218de7a17672bea9a66187d102ffef976fb01af69d8d3aa3156a5a4223dc6d08b8ce9f1d2639a2edc7052404bf1410adf6c41465bd687e3dfa5372ea71f804b56d947bae9482e5707f42dbe35f8b0e11b4a0d27a5a01e1b9a75b66d82b7945eb0b002ee400bebcdc4c3133f804b22bd2d771762058cc35a5033365d2e15150fe46d3b0e98e18ee55f0451b0b171420f73592292e4ff50603c1f0d7769dbd090936090f63"
|
||||
},
|
||||
"Presentation1": {
|
||||
"U": "032704f22133d2ec70f9e6f4bbf64c582220b666f2e2c1d37c3f8995a2a5568c7e",
|
||||
"U_prime_commit": "03533cf1b2fd53a0716e02425eb42e4c55835aa6b2992d364cba70810d0f8aeb51",
|
||||
"a": "b78e57df8f0a95d102ff12bbb97e15ed35c23e54f9b4483d30b76772ee60d886",
|
||||
"m1_commit": "03e412408579105213ed10b6447c85bcd672ba73ecae1e21c463d0df4ef7beb814",
|
||||
"nonce": "0x0",
|
||||
"presentation_context": "746573742070726573656e746174696f6e20636f6e74657874",
|
||||
"proof": "a558da5f17c04adcb0898827aaded14be1dc612dcd12b0579c11bb387ce9ae4b7dbcb3bbe413caaaf754d99e5a342abb7e0041458d670f4b58eda37e745a675295d7a7b86248141d6547b53d793e5c77896ec4dc8dd438ab66d9c8b43ef6b060938a1ca793057b154970ebc3c7ec3a23134e0852d0041f9098ce77311e5b5eca0000000000000000000000000000000000000000000000000000000000000004",
|
||||
"r": "42252210dd60ddbbf1a57e3b144e26dd693b7644a9626a8c36896ede53d12930",
|
||||
"tag": "031a774fd87a8f18f6420bea43cf5425e7426eec8ba7b8df5c13dc05f10ec652d9",
|
||||
"z": "f5a4bbcf14e55e357df9f5ccb5ded37b2b14bc2e1a68e31f86416f0606ee75d1"
|
||||
},
|
||||
"Presentation2": {
|
||||
"U": "035fd233dee2c147155c6008ea64941b6ff7b315aced12531468f2e27bf22e3ef0",
|
||||
"U_prime_commit": "02434af337b87fd21d1e3d950aebfc8033a3d2e9dd2bb8b9e7953488078754496d",
|
||||
"a": "95bcf45150a61f5c44a6cfbf343cd9e0f593f127b6f49bec0f9b20f0550504a2",
|
||||
"m1_commit": "02a578fd3a84eb5b657367b02de39b45fd48ab7781ef8f94efe601274a5ded2a07",
|
||||
"nonce": "0x1",
|
||||
"presentation_context": "746573742070726573656e746174696f6e20636f6e74657874",
|
||||
"proof": "050965cde906fc4723333b100ce0fd9f7b026315f1db16984d4cccb2bc4aa65eb7a17f5b8dfe4f14d40006506ee5fb323e829dd4cb9dc3c455b2e04dd691600aec3cc3f1939198a80acb78b7f90b3bff769cab890f33e4d69b7c302d21ad35ec457d048d3ed7d13ee82c3c0aac2129ad0c8375cf29cd8ea3948a16b9247b1cc5faf69a3116f903b9dcccc4eff31f026041e49797b53c87eca66cfe1040187ef7",
|
||||
"r": "d7ed72750b6d366ed0febdc539b52d89434f468a578c59d7ca9015b7da240ad6",
|
||||
"tag": "03084fe6fff0ecc7c33ef5c49b492dda38083f52e9a2b70b88f3d4b4ba7b50afba",
|
||||
"z": "91eedfb168c556ff5ca3b89d047f482c9279b47f584aab6c7f895f7674251771"
|
||||
},
|
||||
"ServerKey": {
|
||||
"X0": "0232b5e93dc2ff489c20a986a84757c5cc4512f057e1ea92011a26d3ad2c56288d",
|
||||
"X1": "03c413230a9bd956718aa46138a33f774f4c708d61c1d6400d404243049d4a31dc",
|
||||
"X2": "02db00f6f8e6d235786a120017bd356fe1c9d09069d3ac9352cc9be10ef1505a55",
|
||||
"x0": "3338fa65ec36e0290022b48eb562889d89dbfa691d1cde91517fa222ed7ad364",
|
||||
"x1": "f9db001266677f62c095021db018cd8cbb55941d4073698ce45c405d1348b7b1",
|
||||
"x2": "350e8040f828bf6ceca27405420cdf3d63cb3aef005f40ba51943c8026877963",
|
||||
"xb": "fd293126bb49a6d793cd77d7db960f5692fec3b7ec07602c60cd32aee595dffd"
|
||||
},
|
||||
"suite": "ARCV1-P256",
|
||||
},
|
||||
{
|
||||
"Credential": {
|
||||
"U": "02be890d43908e52ed43ae7bc7098f3a7694617fe44a88c33c6fa4eb9e942c0b2bb9d2fd56a44e1d6094fc7b9e8b949055",
|
||||
@@ -179,9 +241,9 @@ class ARCTestVectors: XCTestCase {
|
||||
|
||||
// Verify request proof, by creating a new request with the
|
||||
// tv.CredentialRequest.proof scalars and verifying it.
|
||||
let requestProof = try proofFromString(CurveType: Curve.self, value: tv.CredentialRequest.proof, scalarCount: ARC.CredentialRequest.scalarCount)
|
||||
let requestProof = try proofFromString(CurveType: Curve.self, value: tv.CredentialRequest.proof, scalarCount: ARC.CredentialRequest<HashToCurveImpl<Curve>>.getScalarCount())
|
||||
let newRequest = ARC.CredentialRequest(m1Enc: precredential.credentialRequest.m1Enc, m2Enc: precredential.credentialRequest.m2Enc, proof: requestProof)
|
||||
XCTAssert(try newRequest.verify(generatorG: precredential.generatorG, generatorH: precredential.generatorH))
|
||||
XCTAssert(try newRequest.verify(generatorG: precredential.generatorG, generatorH: precredential.generatorH, ciphersuite: ciphersuite))
|
||||
|
||||
// Make a credential response, passing in randomness b
|
||||
let b = try scalarFromString(CurveType: Curve.self, value: tv.CredentialResponse.b)
|
||||
@@ -195,9 +257,9 @@ class ARCTestVectors: XCTestCase {
|
||||
|
||||
// Verify response proof, by creating a new response with the
|
||||
// tv.CredentialResponse.proof scalars and verifying it.
|
||||
let responseProof = try proofFromString(CurveType: Curve.self, value: tv.CredentialResponse.proof, scalarCount: ARC.CredentialResponse.scalarCount)
|
||||
let responseProof = try proofFromString(CurveType: Curve.self, value: tv.CredentialResponse.proof, scalarCount: ARC.CredentialResponse<HashToCurveImpl<Curve>>.getScalarCount())
|
||||
let newResponse = ARC.CredentialResponse(U: response.U, encUPrime: response.encUPrime, X0Aux: response.X0Aux, X1Aux: response.X1Aux, X2Aux: response.X2Aux, HAux: response.HAux, proof: responseProof)
|
||||
XCTAssert(try newResponse.verify(request: precredential.credentialRequest, serverPublicKey: server.serverPublicKey, generatorG: server.generatorG, generatorH: server.generatorH))
|
||||
XCTAssert(try newResponse.verify(request: precredential.credentialRequest, serverPublicKey: server.serverPublicKey, generatorG: server.generatorG, generatorH: server.generatorH, ciphersuite: ciphersuite))
|
||||
|
||||
// Make a credential from the response
|
||||
var credential = try precredential.makeCredential(credentialResponse: response)
|
||||
@@ -221,9 +283,9 @@ class ARCTestVectors: XCTestCase {
|
||||
|
||||
// Verify presentation1 proof, by creating a new presentation with the
|
||||
// tv.Presentation1.proof scalars and verifying it.
|
||||
let presentation1Proof = try proofFromString(CurveType: Curve.self, value: tv.Presentation1.proof, scalarCount: ARC.Presentation.scalarCount)
|
||||
let presentation1Proof = try proofFromString(CurveType: Curve.self, value: tv.Presentation1.proof, scalarCount: ARC.Presentation<HashToCurveImpl<Curve>>.getScalarCount())
|
||||
let newPresentation1 = ARC.Presentation(U: presentation1.U, UPrimeCommit: presentation1.UPrimeCommit, m1Commit: presentation1.m1Commit, tag: presentation1.tag, proof: presentation1Proof)
|
||||
XCTAssert(try newPresentation1.verify(serverPrivateKey: server.serverPrivateKey, X1: server.serverPublicKey.X1, m2: m2, presentationContext: presentationContext1, presentationLimit: 2, nonce: nonce_1, generatorG: credential.generatorG, generatorH: credential.generatorH))
|
||||
XCTAssert(try newPresentation1.verify(serverPrivateKey: server.serverPrivateKey, X1: server.serverPublicKey.X1, m2: m2, presentationContext: presentationContext1, presentationLimit: 2, nonce: nonce_1, generatorG: credential.generatorG, generatorH: credential.generatorH, ciphersuite: ciphersuite))
|
||||
|
||||
// Make a second presentation from the credential, passing in randomness a, r, z
|
||||
let presentationContext2 = try Data(hexString: tv.Presentation2.presentation_context)
|
||||
@@ -240,9 +302,9 @@ class ARCTestVectors: XCTestCase {
|
||||
|
||||
// Verify presentation2 proof, by creating a new presentation with the
|
||||
// tv.Presentation2.proof scalars and verifying it.
|
||||
let presentation2Proof = try proofFromString(CurveType: Curve.self, value: tv.Presentation2.proof, scalarCount: ARC.Presentation.scalarCount)
|
||||
let presentation2Proof = try proofFromString(CurveType: Curve.self, value: tv.Presentation2.proof, scalarCount: ARC.Presentation<HashToCurveImpl<Curve>>.getScalarCount())
|
||||
let newPresentation2 = ARC.Presentation(U: presentation2.U, UPrimeCommit: presentation2.UPrimeCommit, m1Commit: presentation2.m1Commit, tag: presentation2.tag, proof: presentation2Proof)
|
||||
XCTAssert(try newPresentation2.verify(serverPrivateKey: server.serverPrivateKey, X1: server.serverPublicKey.X1, m2: m2, presentationContext: presentationContext2, presentationLimit: 2, nonce: nonce_2, generatorG: credential.generatorG, generatorH: credential.generatorH))
|
||||
XCTAssert(try newPresentation2.verify(serverPrivateKey: server.serverPrivateKey, X1: server.serverPublicKey.X1, m2: m2, presentationContext: presentationContext2, presentationLimit: 2, nonce: nonce_2, generatorG: credential.generatorG, generatorH: credential.generatorH, ciphersuite: ciphersuite))
|
||||
|
||||
// Verify both presentations
|
||||
XCTAssertTrue(try server.verify(presentation: presentation1, requestContext: requestContext, presentationContext: presentationContext1, presentationLimit: 2, nonce: nonce_1))
|
||||
@@ -251,7 +313,8 @@ class ARCTestVectors: XCTestCase {
|
||||
|
||||
func validateTestVector(_ tv: ARCTestVector) {
|
||||
switch tv.suite {
|
||||
case ARC.domain: XCTAssertNoThrow(try self.validate(curveType: P384.self, tv))
|
||||
case "ARCV1-P256": XCTAssertNoThrow(try self.validate(curveType: P256.self, tv))
|
||||
case "ARCV1-P384": XCTAssertNoThrow(try self.validate(curveType: P384.self, tv))
|
||||
default: XCTFail("Unsupported ciphersuite:" + tv.suite)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -47,7 +47,7 @@ class ARCTests: XCTestCase {
|
||||
XCTAssert(m1Decrypted == m1 * generatorG)
|
||||
let m2Decrypted = request.m2Enc - r2 * generatorH
|
||||
XCTAssert(m2Decrypted == precredential.clientSecrets.m2 * generatorG)
|
||||
XCTAssert(try request.verify(generatorG: generatorG, generatorH: generatorH))
|
||||
XCTAssert(try request.verify(generatorG: generatorG, generatorH: generatorH, ciphersuite: ciphersuite))
|
||||
|
||||
// Server receives the CredentialRequest, and makes an CredentialResponse with its server keys.
|
||||
let issuance = try server.respond(credentialRequest: request)
|
||||
@@ -84,7 +84,8 @@ class ARCTests: XCTestCase {
|
||||
presentationLimit: presentationLimit,
|
||||
nonce: nonce1,
|
||||
generatorG: generatorG,
|
||||
generatorH: generatorH))
|
||||
generatorH: generatorH,
|
||||
ciphersuite: ciphersuite))
|
||||
|
||||
// Server verifies Presentation2 with its server keys.
|
||||
XCTAssert(try server.verify(
|
||||
@@ -102,7 +103,8 @@ class ARCTests: XCTestCase {
|
||||
presentationLimit: presentationLimit,
|
||||
nonce: nonce2,
|
||||
generatorG: generatorG,
|
||||
generatorH: generatorH))
|
||||
generatorH: generatorH,
|
||||
ciphersuite: ciphersuite))
|
||||
|
||||
// Test that two presentations with the same presentationContext and privateAttribute,
|
||||
// but difference nonces, have different tag elements
|
||||
|
||||
Reference in new issue
Block a user