9807497631

Committed 05 Jul 2024 10:48AM UTC coverage: 41.758% (+0.2%) from 41.529%

Build # 9807497631

Build Type

push

github

Committed by

goncalo-frade-iohk

Commit Message

feat(agent): add new agent derivation path

Signed-off-by: goncalo-frade-iohk <goncalo.frade@iohk.io>

Run Details

105 of 138 new or added lines in 13 files covered. (76.09%)

13 existing lines in 4 files now uncovered.

4874 of 11672 relevant lines covered (41.76%)

96.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

56.86

/EdgeAgentSDK/Apollo/Sources/Model/X25519Key.swift

import ApolloLibrary
import Domain
import Foundation

struct X25519PrivateKey: PrivateKey {
    private let internalKey: ApolloLibrary.KMMX25519PrivateKey
    let keyType: String = "EC"
    let keySpecifications: [String : String]
    let derivationPath: Domain.DerivationPath?
    var identifier:String
    var size: Int { raw.count }
    var raw: Data { internalKey.raw.toData() }

    init(
        identifier: String = UUID().uuidString,
        internalKey: ApolloLibrary.KMMX25519PrivateKey,
        derivationPath: Domain.DerivationPath? = nil
    ) {
        self.identifier = identifier
        self.internalKey = internalKey
        var keySpecifications = ["curve" : "x25519"]
        derivationPath.map { keySpecifications[KeyProperties.derivationPath.rawValue] = $0.keyPathString() }
        self.keySpecifications = keySpecifications
        self.derivationPath = derivationPath
    }

    func publicKey() -> PublicKey {
        guard let publicKey = try? internalKey.publicKey() else {
            // TODO: This should never happen, but now we need to confirm if the Apollo domain needs to handle throwing or the library needs to remove it
            fatalError("This should never happen. PrivateKeys should always build a public")
        }
        return X25519PublicKey(internalKey: publicKey)
        
    }
}

extension X25519PrivateKey: KeychainStorableKey {
    var restorationIdentifier: String { "x25519+priv" }
    var storableData: Data { raw }
    var index: Int? { nil }
    var queryDerivationPath: String? { derivationPath?.keyPathString() }
    var type: Domain.KeychainStorableKeyProperties.KeyAlgorithm { .rawKey }
    var keyClass: Domain.KeychainStorableKeyProperties.KeyType { .privateKey }
    var accessiblity: Domain.KeychainStorableKeyProperties.Accessability? { .firstUnlock(deviceOnly: true) }
    var synchronizable: Bool { false }
}

struct X25519PublicKey: PublicKey {
    private let internalKey: ApolloLibrary.KMMX25519PublicKey
    let keyType: String = "EC"
    let keySpecifications: [String : String] = [
        "curve" : "x25519"
    ]
    var identifier: String
    var size: Int { raw.count }
    var raw: Data { internalKey.raw.toData() }

    init(
        identifier: String = UUID().uuidString,
        internalKey: ApolloLibrary.KMMX25519PublicKey
    ) {
        self.identifier = identifier
        self.internalKey = internalKey
    }

    init(raw: Data) {
        self.init(internalKey: .init(raw: raw.toKotlinByteArray()))
    }

    func verify(data: Data, signature: Data) throws -> Bool {
        throw ApolloError.keyAgreementDoesNotSupportVerification
    }
}

extension X25519PublicKey: KeychainStorableKey {
    var restorationIdentifier: String { "x25519+pub" }
    var storableData: Data { raw }
    var index: Int? { nil }
    var queryDerivationPath: String? { nil }
    var type: Domain.KeychainStorableKeyProperties.KeyAlgorithm { .rawKey }
    var keyClass: Domain.KeychainStorableKeyProperties.KeyType { .publicKey }
    var accessiblity: Domain.KeychainStorableKeyProperties.Accessability? { .firstUnlock(deviceOnly: true) }
    var synchronizable: Bool { false }
}

1	import ApolloLibrary
2	import Domain
3	import Foundation
4
5	struct X25519PrivateKey: PrivateKey {
6	private let internalKey: ApolloLibrary.KMMX25519PrivateKey
7	let keyType: String = "EC"	21✔
8	let keySpecifications: [String : String]
9	let derivationPath: Domain.DerivationPath?
10	var identifier:String
11	var size: Int { raw.count }	×
12	var raw: Data { internalKey.raw.toData() }	18✔
13
14	init(
15	identifier: String = UUID().uuidString,
16	internalKey: ApolloLibrary.KMMX25519PrivateKey,
17	derivationPath: Domain.DerivationPath? = nil
18	) {	21✔
19	self.identifier = identifier	21✔
20	self.internalKey = internalKey	21✔
21	var keySpecifications = ["curve" : "x25519"]	21✔
22	derivationPath.map { keySpecifications[KeyProperties.derivationPath.rawValue] = $0.keyPathString() }	21✔
23	self.keySpecifications = keySpecifications	21✔
24	self.derivationPath = derivationPath	21✔
25	}	21✔
26
27	func publicKey() -> PublicKey {	18✔
28	guard let publicKey = try? internalKey.publicKey() else {	18✔
29	// TODO: This should never happen, but now we need to confirm if the Apollo domain needs to handle throwing or the library needs to remove it	×
30	fatalError("This should never happen. PrivateKeys should always build a public")	×
31	}	18✔
32	return X25519PublicKey(internalKey: publicKey)	18✔
33		18✔
34	}	18✔
35	}
36
37	extension X25519PrivateKey: KeychainStorableKey {
38	var restorationIdentifier: String { "x25519+priv" }	6✔
39	var storableData: Data { raw }	3✔
40	var index: Int? { nil }	6✔
41	var queryDerivationPath: String? { derivationPath?.keyPathString() }	3✔
42	var type: Domain.KeychainStorableKeyProperties.KeyAlgorithm { .rawKey }	×
43	var keyClass: Domain.KeychainStorableKeyProperties.KeyType { .privateKey }	×
44	var accessiblity: Domain.KeychainStorableKeyProperties.Accessability? { .firstUnlock(deviceOnly: true) }	×
45	var synchronizable: Bool { false }	×
46	}
47
48	struct X25519PublicKey: PublicKey {
49	private let internalKey: ApolloLibrary.KMMX25519PublicKey
50	let keyType: String = "EC"	18✔
51	let keySpecifications: [String : String] = [	18✔
52	"curve" : "x25519"	18✔
53	]	18✔
54	var identifier: String
55	var size: Int { raw.count }	×
56	var raw: Data { internalKey.raw.toData() }	18✔
57
58	init(
59	identifier: String = UUID().uuidString,
60	internalKey: ApolloLibrary.KMMX25519PublicKey
61	) {	18✔
62	self.identifier = identifier	18✔
63	self.internalKey = internalKey	18✔
64	}	18✔
65
66	init(raw: Data) {	×
67	self.init(internalKey: .init(raw: raw.toKotlinByteArray()))	×
68	}	×
69
70	func verify(data: Data, signature: Data) throws -> Bool {	×
71	throw ApolloError.keyAgreementDoesNotSupportVerification	×
72	}	×
73	}
74
75	extension X25519PublicKey: KeychainStorableKey {
76	var restorationIdentifier: String { "x25519+pub" }	×
77	var storableData: Data { raw }	×
78	var index: Int? { nil }	×
NEW 79	var queryDerivationPath: String? { nil }	×
80	var type: Domain.KeychainStorableKeyProperties.KeyAlgorithm { .rawKey }	×
81	var keyClass: Domain.KeychainStorableKeyProperties.KeyType { .publicKey }	×
82	var accessiblity: Domain.KeychainStorableKeyProperties.Accessability? { .firstUnlock(deviceOnly: true) }	×
83	var synchronizable: Bool { false }	×
84	}

hyperledger / identus-edge-agent-sdk-swift / 9807497631

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous