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(resetReason: CuttlefishResetReason, test: XCTestCase) -> Error? {
  25         let expectation = XCTestExpectation(description: "reset replied")
  26         var reterr: Error?
  27         self.reset(resetReason: resetReason) { 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 preflightVouchWithBottleSync(test: XCTestCase, bottleID: String) -> (String?, Error?) {
 130         let expectation = XCTestExpectation(description: "preflightVouchWithBottle replied")
 131         var reta: String?, reterr: Error?
 132         self.preflightVouchWithBottle(bottleID: bottleID) { a, err in
 133             reta = a
 134             reterr = err
 135             expectation.fulfill()
 136         }
 137         test.wait(for: [expectation], timeout: 10.0)
 138         return (reta, reterr)
 139     }
 140
 141     func vouchWithBottleSync(test: XCTestCase, b: String, entropy: Data, bottleSalt: String, tlkShares: [CKKSTLKShare]) -> (Data?, Data?, Error?) {
 142         let expectation = XCTestExpectation(description: "vouchWithBottle replied")
 143         var reta: Data?, retb: Data?, reterr: Error?
 144         self.vouchWithBottle(bottleID: b, entropy: entropy, bottleSalt: bottleSalt, tlkShares: tlkShares) { a, b, err in
 145             reta = a
 146             retb = b
 147             reterr = err
 148             expectation.fulfill()
 149         }
 150         test.wait(for: [expectation], timeout: 10.0)
 151         return (reta, retb, reterr)
 152     }
 153
 154     func joinSync(test: XCTestCase,
 155                   voucherData: Data,
 156                   voucherSig: Data,
 157                   ckksKeys: [CKKSKeychainBackedKeySet],
 158                   tlkShares: [CKKSTLKShare],
 159                   preapprovedKeys: [Data]? = nil) -> (String?, [CKRecord]?, Error?) {
 160         let expectation = XCTestExpectation(description: "join replied")
 161         var reta: String?, retkhr: [CKRecord]?, reterr: Error?
 162         self.join(voucherData: voucherData,
 163                   voucherSig: voucherSig,
 164                   ckksKeys: ckksKeys,
 165                   tlkShares: tlkShares,
 166                   preapprovedKeys: preapprovedKeys) { a, khr, err in
 167                     reta = a
 168                     retkhr = khr
 169                     reterr = err
 170                     expectation.fulfill()
 171         }
 172         test.wait(for: [expectation], timeout: 10.0)
 173         return (reta, retkhr, reterr)
 174     }
 175
 176     func preapprovedJoinSync(test: XCTestCase,
 177                              ckksKeys: [CKKSKeychainBackedKeySet],
 178                              tlkShares: [CKKSTLKShare],
 179                              preapprovedKeys: [Data]? = nil) -> (String?, [CKRecord]?, Error?) {
 180         let expectation = XCTestExpectation(description: "preapprovedjoin replied")
 181         var reta: String?
 182         var retkhr: [CKRecord]?
 183         var reterr: Error?
 184         self.preapprovedJoin(ckksKeys: ckksKeys,
 185                              tlkShares: tlkShares,
 186                              preapprovedKeys: preapprovedKeys) { a, khr, err in
 187                                 reta = a
 188                                 retkhr = khr
 189                                 reterr = err
 190                                 expectation.fulfill()
 191         }
 192         test.wait(for: [expectation], timeout: 10.0)
 193         return (reta, retkhr, reterr)
 194     }
 195
 196     func updateSync(test: XCTestCase,
 197                     deviceName: String? = nil,
 198                     serialNumner: String? = nil,
 199                     osVersion: String? = nil,
 200                     policyVersion: UInt64? = nil,
 201                     policySecrets: [String: Data]? = nil) -> (TrustedPeersHelperPeerState?, Error?) {
 202         let expectation = XCTestExpectation(description: "update replied")
 203         var reterr: Error?
 204         var retstate: TrustedPeersHelperPeerState?
 205         self.update(deviceName: deviceName,
 206                     serialNumber: serialNumner,
 207                     osVersion: osVersion,
 208                     policyVersion: policyVersion,
 209                     policySecrets: policySecrets) { state, err in
 210                         retstate = state
 211                         reterr = err
 212                         expectation.fulfill()
 213         }
 214         test.wait(for: [expectation], timeout: 10.0)
 215         return (retstate, reterr)
 216     }
 217
 218     func setAllowedMachineIDsSync(test: XCTestCase, allowedMachineIDs: Set<String>, listDifference: Bool = true) -> (Error?) {
 219         let expectation = XCTestExpectation(description: "setAllowedMachineIDs replied")
 220         var reterr: Error?
 221         self.setAllowedMachineIDs(allowedMachineIDs) { differences, err in
 222             XCTAssertEqual(differences, listDifference, "Reported list difference should match expectation")
 223             reterr = err
 224             expectation.fulfill()
 225         }
 226         test.wait(for: [expectation], timeout: 10.0)
 227         return reterr
 228     }
 229
 230     func addAllowedMachineIDsSync(test: XCTestCase, machineIDs: [String]) -> Error? {
 231         let expectation = XCTestExpectation(description: "addAllow replied")
 232         var reterr: Error?
 233         self.addAllow(machineIDs) { err in
 234             reterr = err
 235             expectation.fulfill()
 236         }
 237         test.wait(for: [expectation], timeout: 10.0)
 238         return reterr
 239     }
 240
 241     func removeAllowedMachineIDsSync(test: XCTestCase, machineIDs: [String]) -> Error? {
 242         let expectation = XCTestExpectation(description: "removeAllow replied")
 243         var reterr: Error?
 244         self.removeAllow(machineIDs) { err in
 245             reterr = err
 246             expectation.fulfill()
 247         }
 248         test.wait(for: [expectation], timeout: 10.0)
 249         return reterr
 250     }
 251
 252     func departByDistrustingSelfSync(test: XCTestCase) -> Error? {
 253         let expectation = XCTestExpectation(description: "departByDistrustingSelf replied")
 254         var reterr: Error?
 255         self.departByDistrustingSelf { error in
 256             reterr = error
 257             expectation.fulfill()
 258         }
 259         test.wait(for: [expectation], timeout: 10.0)
 260         return reterr
 261     }
 262
 263     func distrustSync(test: XCTestCase, peerIDs: Set<String>) -> Error? {
 264         let expectation = XCTestExpectation(description: "distrustSync replied")
 265         var reterr: Error?
 266         self.distrust(peerIDs: peerIDs) { error in
 267             reterr = error
 268             expectation.fulfill()
 269         }
 270         test.wait(for: [expectation], timeout: 10.0)
 271         return reterr
 272     }
 273
 274     func getStateSync(test: XCTestCase) -> ContainerState {
 275         let expectation = XCTestExpectation(description: "getState replied")
 276         var retstate: ContainerState?
 277         self.getState { state in
 278             retstate = state
 279             expectation.fulfill()
 280         }
 281         test.wait(for: [expectation], timeout: 10.0)
 282         return retstate!
 283     }
 284
 285     func loadSecretSync(test: XCTestCase,
 286                         label: String) -> (Data?) {
 287         var secret: Data?
 288         do {
 289             secret = try loadSecret(label: label)
 290         } catch {
 291
 292         }
 293         return secret
 294     }
 295
 296     func setRecoveryKeySync(test: XCTestCase, recoveryKey: String, recoverySalt: String, ckksKeys: [CKKSKeychainBackedKeySet]) -> (Error?) {
 297         let expectation = XCTestExpectation(description: "setRecoveryKey replied")
 298         var reterr: Error?
 299
 300         self.setRecoveryKey(recoveryKey: recoveryKey, salt: recoverySalt, ckksKeys: ckksKeys) { error in
 301             reterr = error
 302             expectation.fulfill()
 303         }
 304         test.wait(for: [expectation], timeout: 10.0)
 305         return (reterr)
 306     }
 307
 308     func fetchViableBottlesSync(test: XCTestCase) -> ([String]?, [String]?, Error?) {
 309         let expectation = XCTestExpectation(description: "fetchViableBottles replied")
 310         var retescrowRecordIDs: [String]?
 311         var retpartialEscrowRecordIDs: [String]?
 312         var reterror: Error?
 313         self.fetchViableBottles { escrowRecordIDs, partialEscrowRecordIDs, error in
 314             retescrowRecordIDs = escrowRecordIDs
 315             retpartialEscrowRecordIDs = partialEscrowRecordIDs
 316             reterror = error
 317             expectation.fulfill()
 318         }
 319         test.wait(for: [expectation], timeout: 10.0)
 320         return (retescrowRecordIDs, retpartialEscrowRecordIDs, reterror)
 321     }
 322
 323     func trustStatusSync(test: XCTestCase) -> (TrustedPeersHelperEgoPeerStatus, Error?) {
 324         let expectation = XCTestExpectation(description: "trustStatus replied")
 325         var retEgoStatus = TrustedPeersHelperEgoPeerStatus(egoPeerID: nil, status: .unknown, viablePeerCountsByModelID: [:], isExcluded: false, isLocked: false)
 326         var reterror: Error?
 327         self.trustStatus { egoStatus, error in
 328             retEgoStatus = egoStatus
 329             reterror = error
 330             expectation.fulfill()
 331         }
 332         test.wait(for: [expectation], timeout: 10.0)
 333         return (retEgoStatus, reterror)
 334     }
 335
 336     func fetchPolicyDocumentsSync(test: XCTestCase,
 337                                   keys: [NSNumber: String]) -> ([NSNumber: [String]]?, Error?) {
 338         let expectation = XCTestExpectation(description: "fetchPolicyDocuments replied")
 339         var reta: [NSNumber: [String]]?, reterr: Error?
 340         self.fetchPolicyDocuments(keys: keys) { a, err in
 341             reta = a
 342             reterr = err
 343             expectation.fulfill()
 344         }
 345         test.wait(for: [expectation], timeout: 10.0)
 346         return (reta, reterr)
 347     }
 348
 349     func fetchEscrowContentsSync(test: XCTestCase) -> (Data?, String?, Data?, Error?) {
 350         let expectation = XCTestExpectation(description: "fetchEscrowContents replied")
 351         var retentropy: Data?
 352         var retbottleID: String?
 353         var retspki: Data?
 354         var reterror: Error?
 355
 356         self.fetchEscrowContents { entropy, bottleID, spki, error in
 357             retentropy = entropy
 358             retbottleID = bottleID
 359             retspki = spki
 360             reterror = error
 361
 362             expectation.fulfill()
 363         }
 364         test.wait(for: [expectation], timeout: 10.0)
 365         return (retentropy, retbottleID, retspki, reterror)
 366     }
 367
 368     func requestHealthCheckSync(requiresEscrowCheck: Bool, test: XCTestCase) -> (Bool, Bool, Bool, Error?) {
 369         let expectation = XCTestExpectation(description: "requestHealthCheck replied")
 370         var retrepairaccount: Bool = false
 371         var retrepairescrow: Bool = false
 372         var retresetoctagon: Bool = false
 373         var reterror: Error?
 374
 375         self.requestHealthCheck(requiresEscrowCheck: requiresEscrowCheck) { repairAccount, repairEscrow, resetOctagon, error in
 376             retrepairaccount = repairAccount
 377             retrepairescrow = repairEscrow
 378             retresetoctagon = resetOctagon
 379             reterror = error
 380
 381             expectation.fulfill()
 382         }
 383         test.wait(for: [expectation], timeout: 10.0)
 384         return (retrepairaccount, retrepairescrow, retresetoctagon, reterror)
 385     }
 386 }