import com.dd.plist.NSData; //导入依赖的package包/类
private PairSetupPin1Response doPairSetupPin1(Socket socket) throws Exception {
    byte[] pairSetupPinRequestData = AuthUtils.createPList(new HashMap<String, String>() {{
        put("method", "pin");
        put("user", clientId);
    }});

    byte[] pairSetupPin1ResponseBytes = AuthUtils.postData(socket, "/pair-setup-pin", "application/x-apple-binary-plist", pairSetupPinRequestData);

    NSDictionary pairSetupPin1Response = (NSDictionary) PropertyListParser.parse(pairSetupPin1ResponseBytes);
    if (pairSetupPin1Response.containsKey("pk") && pairSetupPin1Response.containsKey("salt")) {
        byte[] pk = ((NSData) pairSetupPin1Response.get("pk")).bytes();
        byte[] salt = ((NSData) pairSetupPin1Response.get("salt")).bytes();
        return new PairSetupPin1Response(pk, salt);
    }
    throw new Exception();
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
public static Optional<InflatableData> from(byte[] bs) {
    InflatableData data;
    try {
        NSDictionary parse = (NSDictionary) PropertyListParser.parse(bs);
        byte[] escrowedKeys = ((NSData) parse.get("escrowedKeys")).bytes();
        UUID deviceUuid = UUID.fromString(((NSString) parse.get("deviceUuid")).getContent());
        String deviceHardWareId = ((NSString) parse.get("deviceHardWareId")).getContent();
        data = new InflatableData(escrowedKeys, deviceUuid, deviceHardWareId);

    } catch (ClassCastException | IllegalArgumentException | IOException | NullPointerException
            | PropertyListFormatException | ParseException | ParserConfigurationException | SAXException ex) {
        logger.warn("-- from() - exception: ", ex);
        data = null;
    }
    return Optional.ofNullable(data);
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
private PairSetupPin2Response doPairSetupPin2(Socket socket, final byte[] publicClientValueA, final byte[] clientEvidenceMessageM1) throws Exception {
    byte[] pairSetupPinRequestData = AuthUtils.createPList(new HashMap<String, byte[]>() {{
        put("pk", publicClientValueA);
        put("proof", clientEvidenceMessageM1);
    }});

    byte[] pairSetupPin2ResponseBytes = AuthUtils.postData(socket, "/pair-setup-pin", "application/x-apple-binary-plist", pairSetupPinRequestData);

    NSDictionary pairSetupPin2Response = (NSDictionary) PropertyListParser.parse(pairSetupPin2ResponseBytes);
    if (pairSetupPin2Response.containsKey("proof")) {
        byte[] proof = ((NSData) pairSetupPin2Response.get("proof")).bytes();
        return new PairSetupPin2Response(proof);
    }
    throw new Exception();
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
private PairSetupPin3Response doPairSetupPin3(Socket socket, final byte[] sessionKeyHashK) throws Exception {

        MessageDigest sha512Digest = MessageDigest.getInstance("SHA-512");
        sha512Digest.update("Pair-Setup-AES-Key".getBytes(StandardCharsets.UTF_8));
        sha512Digest.update(sessionKeyHashK);
        byte[] aesKey = Arrays.copyOfRange(sha512Digest.digest(), 0, 16);

        sha512Digest.update("Pair-Setup-AES-IV".getBytes(StandardCharsets.UTF_8));
        sha512Digest.update(sessionKeyHashK);
        byte[] aesIV = Arrays.copyOfRange(sha512Digest.digest(), 0, 16);

        int lengthB;
        int lengthA = lengthB = aesIV.length - 1;
        for (; lengthB >= 0 && 256 == ++aesIV[lengthA]; lengthA = lengthB += -1) ;

        Cipher aesGcm128Encrypt = Cipher.getInstance("AES/GCM/NoPadding");
        SecretKeySpec secretKey = new SecretKeySpec(aesKey, "AES");
        aesGcm128Encrypt.init(Cipher.ENCRYPT_MODE, secretKey, new GCMParameterSpec(128, aesIV));
        final byte[] aesGcm128ClientLTPK = aesGcm128Encrypt.doFinal(authKey.getAbyte());

        byte[] pairSetupPinRequestData = AuthUtils.createPList(new HashMap<String, byte[]>() {{
            put("epk", Arrays.copyOfRange(aesGcm128ClientLTPK, 0, aesGcm128ClientLTPK.length - 16));
            put("authTag", Arrays.copyOfRange(aesGcm128ClientLTPK, aesGcm128ClientLTPK.length - 16, aesGcm128ClientLTPK.length));
        }});

        byte[] pairSetupPin3ResponseBytes = AuthUtils.postData(socket, "/pair-setup-pin", "application/x-apple-binary-plist", pairSetupPinRequestData);

        NSDictionary pairSetupPin3Response = (NSDictionary) PropertyListParser.parse(pairSetupPin3ResponseBytes);

        if (pairSetupPin3Response.containsKey("epk") && pairSetupPin3Response.containsKey("authTag")) {
            byte[] epk = ((NSData) pairSetupPin3Response.get("epk")).bytes();
            byte[] authTag = ((NSData) pairSetupPin3Response.get("authTag")).bytes();

            return new PairSetupPin3Response(epk, authTag);
        }
        throw new Exception();
    }
 

import com.dd.plist.NSData; //导入依赖的package包/类
/** Installs a profile to set up an HTTPS certificate on the device. */
static void installCertProfile(RealDevice device, String certName, String certContentBase64)
    throws IosDeviceException {
  NSDictionary replacementDict = new NSDictionary();
  replacementDict.put("PayloadCertificateFileName", certName + ".cer");
  try {
    replacementDict.put("PayloadContent", new NSData(certContentBase64));
  } catch (IOException e) {
    throw new IosDeviceException(device, e);
  }
  replacementDict.put("PayloadDisplayName", certName);
  ConfigProfiles.installProfile(device, CERT_PROFILE_PATH, replacementDict);
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
@Test
public void testIssue31_FalsePositiveForGZipInsideDataElement() throws Exception {
    File plistFile = new File("test-files/github-issue31.plist");

    NSDictionary dict = (NSDictionary)PropertyListParser.parse(plistFile);
    NSDictionary files = (NSDictionary)dict.get("files2");
    NSData hash = (NSData)((NSDictionary)files.get("Base.lproj/Main.storyboardc/MainController.nib")).get("hash");
    assertEquals("1f8b2ef69414fa70ff578a697cfc0919235c8eff", HexConverter.toHex(hash.bytes()));
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
static byte[] kPCSMetadataEscrowedKeys(NSDictionary metadata) {
    NSDictionary clientMetadata = PListsLegacy.getAs(metadata, "ClientMetadata", NSDictionary.class);

    NSDictionary secureBackupiCloudDataProtection
            = PListsLegacy.getAs(clientMetadata, "SecureBackupiCloudDataProtection", NSDictionary.class);

    return PListsLegacy.getAs(secureBackupiCloudDataProtection, "kPCSMetadataEscrowedKeys", NSData.class).bytes();
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
static void diagnostic(byte[] metadata) {
    NSDictionary dictionary = PListsLegacy.parseDictionary(metadata);
    logger.debug("-- diagnostic() - dictionary: {}", dictionary.toXMLPropertyList());

    byte[] backupKeybagDigest = PListsLegacy.getAs(dictionary, "BackupKeybagDigest", NSData.class).bytes();
    logger.debug("-- diagnostic() - BackupKeybagDigest: 0x{}", Hex.toHexString(backupKeybagDigest));

    Optional<NSString> timestamp = PListsLegacy.optionalAs(dictionary, "com.apple.securebackup.timestamp", NSString.class);
    logger.debug("-- diagnostic() - com.apple.securebackup.timestamp: {}",
            timestamp.map(NSString::getContent));

    NSDictionary clientMetadata = PListsLegacy.getAs(dictionary, "ClientMetadata", NSDictionary.class);

    NSDictionary secureBackupiCloudDataProtection
            = PListsLegacy.getAs(clientMetadata, "SecureBackupiCloudDataProtection", NSDictionary.class);

    byte[] secureBackupiCloudIdentityPublicData
            = PListsLegacy.getAs(clientMetadata, "SecureBackupiCloudIdentityPublicData", NSData.class).bytes();

    Optional<PublicKeyInfo> optionalPublicKeyInfo
            = DERUtils.parse(secureBackupiCloudIdentityPublicData, PublicKeyInfo::new);
    logger.debug("-- diagnostic() - publicKeyInfo: {}", optionalPublicKeyInfo);

    byte[] kPCSMetadataEscrowedKeys
            = PListsLegacy.getAs(secureBackupiCloudDataProtection, "kPCSMetadataEscrowedKeys", NSData.class).bytes();
    logger.debug("-- diagnostic() - kPCSMetadataEscrowedKeys: 0x{}", Hex.toHexString(kPCSMetadataEscrowedKeys));
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
public byte[] encoded() {
    try {
        NSDictionary dict = new NSDictionary();
        dict.put("escrowedKeys", new NSData(escrowedKeys));
        dict.put("deviceUuid", new NSString(deviceUuid.toString()));
        dict.put("deviceHardWareId", new NSString(deviceHardWareId));
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PropertyListParser.saveAsBinary(dict, baos);
        return baos.toByteArray();
    } catch (IOException ex) {
        throw new IllegalStateException(ex);
    }
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
protected void verify(final NSDictionary dictionary, final String publicKey) throws InvalidLicenseException {
    if(null == dictionary) {
        throw new InvalidLicenseException();
    }
    final NSData signature = (NSData) dictionary.objectForKey("Signature");
    if(null == signature) {
        log.warn(String.format("Missing key 'Signature' in dictionary %s", dictionary));
        throw new InvalidLicenseException();
    }
    // Append all values
    StringBuilder values = new StringBuilder();
    final ArrayList<String> keys = new ArrayList<>(dictionary.keySet());
    // Sort lexicographically by key
    Collections.sort(keys, new NaturalOrderComparator());
    for(String key : keys) {
        if("Signature".equals(key)) {
            continue;
        }
        values.append(dictionary.objectForKey(key).toString());
    }
    byte[] signaturebytes = signature.bytes();
    byte[] plainbytes = values.toString().getBytes(Charset.forName("UTF-8"));
    try {
        final BigInteger modulus = new BigInteger(StringUtils.removeStart(publicKey, "0x"), 16);
        final BigInteger exponent = new BigInteger(Base64.decodeBase64("Aw=="));
        final KeySpec spec = new RSAPublicKeySpec(modulus, exponent);

        final PublicKey rsa = KeyFactory.getInstance("RSA").generatePublic(spec);
        final Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        rsaCipher.init(Cipher.DECRYPT_MODE, rsa);
        final MessageDigest sha1Digest = MessageDigest.getInstance("SHA1");
        if(!Arrays.equals(rsaCipher.doFinal(signaturebytes), sha1Digest.digest(plainbytes))) {
            throw new InvalidLicenseException();
        }
    }
    catch(NoSuchPaddingException
            | BadPaddingException
            | IllegalBlockSizeException
            | InvalidKeyException
            | InvalidKeySpecException
            | NoSuchAlgorithmException e) {
        log.warn(String.format("Signature verification failure for key %s", file));
        throw new InvalidLicenseException();
    }
    if(log.isInfoEnabled()) {
        log.info(String.format("Valid key in %s", file));
    }
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
public static AssetEncryptedAttributes fromDictionary(NSDictionary data, String domain) {
    logger.trace("<< fromDictionary() - data:{} domain: {}", data.toXMLPropertyList(), domain);
    NSDictionaries.as(data, "domain", NSString.class)
            .map(NSString::getContent)
            .filter(u -> !u.equals(domain))
            .ifPresent(u -> logger.warn("-- fromDictionary() - domain mismatch: {} != {}", u, domain));
    Optional<String> relativePath = NSDictionaries.as(data, "relativePath", NSString.class)
            .map(NSString::getContent);
    Optional<Instant> modified = NSDictionaries.as(data, "modified", NSDate.class)
            .map(NSDate::getDate)
            .map(Date::toInstant);
    Optional<Instant> birth = NSDictionaries.as(data, "birth", NSDate.class)
            .map(NSDate::getDate)
            .map(Date::toInstant);
    Optional<Instant> statusChanged = NSDictionaries.as(data, "statusChanged", NSDate.class)
            .map(NSDate::getDate)
            .map(Date::toInstant);
    Optional<Integer> userID = NSDictionaries.as(data, "userID", NSNumber.class)
            .map(NSNumber::intValue);
    Optional<Integer> groupID = NSDictionaries.as(data, "groupID", NSNumber.class)
            .map(NSNumber::intValue);
    Optional<Integer> mode = NSDictionaries.as(data, "mode", NSNumber.class)
            .map(NSNumber::intValue);
    Optional<Long> size = NSDictionaries.as(data, "size", NSNumber.class)
            .map(NSNumber::longValue);
    Optional<byte[]> encryptionKey = NSDictionaries.as(data, "encryptionKey", NSData.class)
            .map(NSData::bytes);
    Optional<byte[]> checksum = Optional.empty();   // not present
    Optional<Long> sizeBeforeCopy = Optional.empty();   // not present
    Optional<Integer> contentEncodingMethod = Optional.empty();   // not present
    Optional<Integer> contentCompressionMethod = Optional.empty();   // not present

    AssetEncryptedAttributes attributes = new AssetEncryptedAttributes(
            Optional.of(domain),
            relativePath,
            modified,
            birth,
            statusChanged,
            userID,
            groupID,
            mode,
            size,
            encryptionKey,
            checksum,
            sizeBeforeCopy,
            contentEncodingMethod,
            contentCompressionMethod);
    logger.trace(">> fromDictionary() - encrypted attributes: {}", attributes);
    return attributes;
}
 

import com.dd.plist.NSData; //导入依赖的package包/类
public static PropertyListResponseHandler<NSData> data() {
    return DATA;
}