keychain/TrustedPeersHelperUnitTests/ContainerSync.swift

   1 //
   2 //  SessionSync.swift
   3 //  Security_ios
   4 //
   5 //  Created by Ben Williamson on 6/8/18.
   6 //
   7
   8 import XCTest
   9
  10 extension Container {
  11
  12     func dumpSync(test: XCTestCase) -> ([AnyHashable: Any]?, Error?) {
  13         let expectation = XCTestExpectation(description: "dump replied")
  14         var reta: [AnyHashable: Any]?, reterr: Error?
  15         self.dump { a, err in
  16             reta = a
  17             reterr = err
  18             expectation.fulfill()
  19         }
  20         test.wait(for: [expectation], timeout: 10.0)
  21         return (reta, reterr)
  22     }
  23
  24     func resetSync(test: XCTestCase) -> Error? {
  25         let expectation = XCTestExpectation(description: "reset replied")
  26         var reterr: Error?
  27         self.reset { error in
  28             reterr = error
  29             expectation.fulfill()
  30         }
  31         test.wait(for: [expectation], timeout: 10.0)
  32         return reterr
  33     }
  34
  35     func localResetSync(test: XCTestCase) -> Error? {
  36         let expectation = XCTestExpectation(description: "reset replied")
  37         var reterr: Error?
  38         self.localReset { error in
  39             reterr = error
  40             expectation.fulfill()
  41         }
  42         test.wait(for: [expectation], timeout: 10.0)
  43         return reterr
  44     }
  45
  46     func prepareSync(test: XCTestCase,
  47                      epoch: UInt64,
  48                      machineID: String,
  49                      bottleSalt: String,
  50                      bottleID: String,
  51                      modelID: String,
  52                      deviceName: String = "test device name",
  53                      serialNumber: String = "456",
  54                      osVersion: String = "123",
  55                      policyVersion: UInt64? = nil,
  56                      policySecrets: [String: Data]? = nil,
  57                      signingPrivateKeyPersistentRef: Data? = nil,
  58                      encryptionPrivateKeyPersistentRef: Data? = nil
  59         ) -> (String?, Data?, Data?, Data?, Data?, Error?) {
  60         let expectation = XCTestExpectation(description: "prepare replied")
  61         var reta: String?, retb: Data?, retc: Data?, retd: Data?, rete: Data?, reterr: Error?
  62         self.prepare(epoch: epoch,
  63                      machineID: machineID,
  64                      bottleSalt: bottleSalt,
  65                      bottleID: bottleID,
  66                      modelID: modelID,
  67                      deviceName: deviceName,
  68                      serialNumber: serialNumber,
  69                      osVersion: osVersion,
  70                      policyVersion: policyVersion,
  71                      policySecrets: policySecrets,
  72                      signingPrivateKeyPersistentRef: signingPrivateKeyPersistentRef,
  73                      encryptionPrivateKeyPersistentRef: encryptionPrivateKeyPersistentRef
  74         ) { a, b, c, d, e, err in
  75             reta = a
  76             retb = b
  77             retc = c
  78             retd = d
  79             rete = e
  80             reterr = err
  81             expectation.fulfill()
  82         }
  83         test.wait(for: [expectation], timeout: 10.0)
  84         return (reta, retb, retc, retd, rete, reterr)
  85     }
  86
  87     func establishSync(test: XCTestCase,
  88                        ckksKeys: [CKKSKeychainBackedKeySet],
  89                        tlkShares: [CKKSTLKShare],
  90                        preapprovedKeys: [Data]?) -> (String?, [CKRecord], Error?) {
  91         let expectation = XCTestExpectation(description: "prepare replied")
  92         var reta: String?, retkhr: [CKRecord]?, reterr: Error?
  93         self.establish(ckksKeys: ckksKeys,
  94                        tlkShares: tlkShares,
  95                        preapprovedKeys: preapprovedKeys) { a, khr, err in
  96                         reta = a
  97                         retkhr = khr
  98                         reterr = err
  99                         expectation.fulfill()
 100         }
 101         test.wait(for: [expectation], timeout: 10.0)
 102         return (reta, retkhr!, reterr)
 103     }
 104
 105     func vouchSync(test: XCTestCase,
 106                    peerID: String,
 107                    permanentInfo: Data,
 108                    permanentInfoSig: Data,
 109                    stableInfo: Data,
 110                    stableInfoSig: Data,
 111                    ckksKeys: [CKKSKeychainBackedKeySet]) -> (Data?, Data?, Error?) {
 112         let expectation = XCTestExpectation(description: "vouch replied")
 113         var reta: Data?, retb: Data?, reterr: Error?
 114         self.vouch(peerID: peerID,
 115                    permanentInfo: permanentInfo,
 116                    permanentInfoSig: permanentInfoSig,
 117                    stableInfo: stableInfo,
 118                    stableInfoSig: stableInfoSig,
 119                    ckksKeys: ckksKeys) { a, b, err in
 120                     reta = a
 121                     retb = b
 122                     reterr = err
 123                     expectation.fulfill()
 124         }
 125         test.wait(for: [expectation], timeout: 10.0)
 126         return (reta, retb, reterr)
 127     }
 128
 129     func vouchWithBottleSync(test: XCTestCase, b: String, entropy: Data, bottleSalt: String, tlkShares: [CKKSTLKShare]) -> (Data?, Data?, Error?) {
 130         let expectation = XCTestExpectation(description: "vouchWithBottle replied")
 131         var reta: Data?, retb: Data?, reterr: Error?
 132         self.vouchWithBottle(bottleID: b, entropy: entropy, bottleSalt: bottleSalt, tlkShares: tlkShares) { a, b, err in
 133             reta = a
 134             retb = b
 135             reterr = err
 136             expectation.fulfill()
 137         }
 138         test.wait(for: [expectation], timeout: 10.0)
 139         return (reta, retb, reterr)
 140     }
 141
 142     func joinSync(test: XCTestCase,
 143                   voucherData: Data,
 144                   voucherSig: Data,
 145                   ckksKeys: [CKKSKeychainBackedKeySet],
 146                   tlkShares: [CKKSTLKShare],
 147                   preapprovedKeys: [Data]? = nil) -> (String?, [CKRecord]?, Error?) {
 148         let expectation = XCTestExpectation(description: "join replied")
 149         var reta: String?, retkhr: [CKRecord]?, reterr: Error?
 150         self.join(voucherData: voucherData,
 151                   voucherSig: voucherSig,
 152                   ckksKeys: ckksKeys,
 153                   tlkShares: tlkShares,
 154                   preapprovedKeys: preapprovedKeys) { a, khr, err in
 155                     reta = a
 156                     retkhr = khr
 157                     reterr = err
 158                     expectation.fulfill()
 159         }
 160         test.wait(for: [expectation], timeout: 10.0)
 161         return (reta, retkhr, reterr)
 162     }
 163
 164     func preapprovedJoinSync(test: XCTestCase,
 165                              ckksKeys: [CKKSKeychainBackedKeySet],
 166                              tlkShares: [CKKSTLKShare],
 167                              preapprovedKeys: [Data]? = nil) -> (String?, [CKRecord]?, Error?) {
 168         let expectation = XCTestExpectation(description: "preapprovedjoin replied")
 169         var reta: String?
 170         var retkhr: [CKRecord]?
 171         var reterr: Error?
 172         self.preapprovedJoin(ckksKeys: ckksKeys,
 173                              tlkShares: tlkShares,
 174                              preapprovedKeys: preapprovedKeys) { a, khr, err in
 175                                 reta = a
 176                                 retkhr = khr
 177                                 reterr = err
 178                                 expectation.fulfill()
 179         }
 180         test.wait(for: [expectation], timeout: 10.0)
 181         return (reta, retkhr, reterr)
 182     }
 183
 184     func updateSync(test: XCTestCase,
 185                     deviceName: String? = nil,
 186                     serialNumner: String? = nil,
 187                     osVersion: String? = nil,
 188                     policyVersion: UInt64? = nil,
 189                     policySecrets: [String: Data]? = nil) -> (TrustedPeersHelperPeerState?, Error?) {
 190         let expectation = XCTestExpectation(description: "update replied")
 191         var reterr: Error?
 192         var retstate: TrustedPeersHelperPeerState?
 193         self.update(deviceName: deviceName,
 194                     serialNumber: serialNumner,
 195                     osVersion: osVersion,
 196                     policyVersion: policyVersion,
 197                     policySecrets: policySecrets) { state, err in
 198                         retstate = state
 199                         reterr = err
 200                         expectation.fulfill()
 201         }
 202         test.wait(for: [expectation], timeout: 10.0)
 203         return (retstate, reterr)
 204     }
 205
 206     func setAllowedMachineIDsSync(test: XCTestCase, allowedMachineIDs: Set<String>, listDifference: Bool = true) -> (Error?) {
 207         let expectation = XCTestExpectation(description: "setAllowedMachineIDs replied")
 208         var reterr: Error?
 209         self.setAllowedMachineIDs(allowedMachineIDs) { differences, err in
 210             XCTAssertEqual(differences, listDifference, "Reported list difference should match expectation")
 211             reterr = err
 212             expectation.fulfill()
 213         }
 214         test.wait(for: [expectation], timeout: 10.0)
 215         return reterr
 216     }
 217
 218     func addAllowedMachineIDsSync(test: XCTestCase, machineIDs: [String]) -> Error? {
 219         let expectation = XCTestExpectation(description: "addAllow replied")
 220         var reterr: Error?
 221         self.addAllow(machineIDs) { err in
 222             reterr = err
 223             expectation.fulfill()
 224         }
 225         test.wait(for: [expectation], timeout: 10.0)
 226         return reterr
 227     }
 228
 229     func removeAllowedMachineIDsSync(test: XCTestCase, machineIDs: [String]) -> Error? {
 230         let expectation = XCTestExpectation(description: "removeAllow replied")
 231         var reterr: Error?
 232         self.removeAllow(machineIDs) { err in
 233             reterr = err
 234             expectation.fulfill()
 235         }
 236         test.wait(for: [expectation], timeout: 10.0)
 237         return reterr
 238     }
 239
 240     func departByDistrustingSelfSync(test: XCTestCase) -> Error? {
 241         let expectation = XCTestExpectation(description: "departByDistrustingSelf replied")
 242         var reterr: Error?
 243         self.departByDistrustingSelf { error in
 244             reterr = error
 245             expectation.fulfill()
 246         }
 247         test.wait(for: [expectation], timeout: 10.0)
 248         return reterr
 249     }
 250
 251     func distrustSync(test: XCTestCase, peerIDs: Set<String>) -> Error? {
 252         let expectation = XCTestExpectation(description: "distrustSync replied")
 253         var reterr: Error?
 254         self.distrust(peerIDs: peerIDs) { error in
 255             reterr = error
 256             expectation.fulfill()
 257         }
 258         test.wait(for: [expectation], timeout: 10.0)
 259         return reterr
 260     }
 261
 262     func getStateSync(test: XCTestCase) -> ContainerState {
 263         let expectation = XCTestExpectation(description: "getState replied")
 264         var retstate: ContainerState?
 265         self.getState { state in
 266             retstate = state
 267             expectation.fulfill()
 268         }
 269         test.wait(for: [expectation], timeout: 10.0)
 270         return retstate!
 271     }
 272
 273     func loadSecretSync(test: XCTestCase,
 274                         label: String) -> (Data?) {
 275         var secret: Data?
 276         do {
 277             secret = try loadSecret(label: label)
 278         } catch {
 279
 280         }
 281         return secret
 282     }
 283
 284     func setRecoveryKeySync(test: XCTestCase, recoveryKey: String, recoverySalt: String, ckksKeys: [CKKSKeychainBackedKeySet]) -> (Error?) {
 285         let expectation = XCTestExpectation(description: "setRecoveryKey replied")
 286         var reterr: Error?
 287
 288         self.setRecoveryKey(recoveryKey: recoveryKey, salt: recoverySalt, ckksKeys: ckksKeys) { error in
 289             reterr = error
 290             expectation.fulfill()
 291         }
 292         test.wait(for: [expectation], timeout: 10.0)
 293         return (reterr)
 294     }
 295
 296     func fetchViableBottlesSync(test: XCTestCase) -> ([String]?, [String]?, Error?) {
 297         let expectation = XCTestExpectation(description: "fetchViableBottles replied")
 298         var retescrowRecordIDs: [String]?
 299         var retpartialEscrowRecordIDs: [String]?
 300         var reterror: Error?
 301         self.fetchViableBottles { escrowRecordIDs, partialEscrowRecordIDs, error in
 302             retescrowRecordIDs = escrowRecordIDs
 303             retpartialEscrowRecordIDs = partialEscrowRecordIDs
 304             reterror = error
 305             expectation.fulfill()
 306         }
 307         test.wait(for: [expectation], timeout: 10.0)
 308         return (retescrowRecordIDs, retpartialEscrowRecordIDs, reterror)
 309     }
 310
 311     func trustStatusSync(test: XCTestCase) -> (TrustedPeersHelperEgoPeerStatus, Error?) {
 312         let expectation = XCTestExpectation(description: "trustStatus replied")
 313         var retEgoStatus = TrustedPeersHelperEgoPeerStatus(egoPeerID: nil, status: .unknown, peerCountsByModelID: [:], isExcluded: false, isLocked: false)
 314         var reterror: Error?
 315         self.trustStatus { egoStatus, error in
 316             retEgoStatus = egoStatus
 317             reterror = error
 318             expectation.fulfill()
 319         }
 320         test.wait(for: [expectation], timeout: 10.0)
 321         return (retEgoStatus, reterror)
 322     }
 323
 324     func fetchPolicyDocumentsSync(test: XCTestCase,
 325                                   keys: [NSNumber: String]) -> ([NSNumber: [String]]?, Error?) {
 326         let expectation = XCTestExpectation(description: "fetchPolicyDocuments replied")
 327         var reta: [NSNumber: [String]]?, reterr: Error?
 328         self.fetchPolicyDocuments(keys: keys) { a, err in
 329             reta = a
 330             reterr = err
 331             expectation.fulfill()
 332         }
 333         test.wait(for: [expectation], timeout: 10.0)
 334         return (reta, reterr)
 335     }
 336
 337     func fetchEscrowContentsSync(test: XCTestCase) -> (Data?, String?, Data?, Error?) {
 338         let expectation = XCTestExpectation(description: "fetchEscrowContents replied")
 339         var retentropy: Data?
 340         var retbottleID: String?
 341         var retspki: Data?
 342         var reterror: Error?
 343
 344         self.fetchEscrowContents { entropy, bottleID, spki, error in
 345             retentropy = entropy
 346             retbottleID = bottleID
 347             retspki = spki
 348             reterror = error
 349
 350             expectation.fulfill()
 351         }
 352         test.wait(for: [expectation], timeout: 10.0)
 353         return (retentropy, retbottleID, retspki, reterror)
 354     }
 355
 356     func requestHealthCheckSync(requiresEscrowCheck: Bool, test: XCTestCase) -> (Bool, Bool, Bool, Error?) {
 357         let expectation = XCTestExpectation(description: "requestHealthCheck replied")
 358         var retrepairaccount: Bool = false
 359         var retrepairescrow: Bool = false
 360         var retresetoctagon: Bool = false
 361         var reterror: Error?
 362
 363         self.requestHealthCheck(requiresEscrowCheck: requiresEscrowCheck) { repairAccount, repairEscrow, resetOctagon, error in
 364             retrepairaccount = repairAccount
 365             retrepairescrow = repairEscrow
 366             retresetoctagon = resetOctagon
 367             reterror = error
 368
 369             expectation.fulfill()
 370         }
 371         test.wait(for: [expectation], timeout: 10.0)
 372         return (retrepairaccount, retrepairescrow, retresetoctagon, reterror)
 373     }
 374 }