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:
Si BeaumontandCory Benfield authored and GitHub committed 2025-07-02 20:31:02 +00:00
1 parent 9fb2fd8d3c
commit 93a2ebfad7
15 files changed
+923 -200

No files matched your search

+59
View File
@@ -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(
+394 -8
View File
@@ -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.
///
+11 -6
View File
@@ -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
}
+105 -98
View File
@@ -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")
+4 -4
View File
@@ -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")
+5 -5
View File
@@ -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")
+6 -4
View File
@@ -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
)
}
}
+196 -20
View File
@@ -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)
}
}
+5 -3
View File
@@ -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