如何解密加密的Apple iTunes iPhone备份?


84

许多不幸的iPhone用户曾要求我帮助他们从iTunes备份中还原数据。当未加密时,这很容易,但是无论是否知道密码,都不容易。

因此,我试图找出加密时用于mddata和mdinfo文件的加密方案。否则,我可以毫无疑问地读取这些文件,并且为此构建了一些健壮的C#库。(如果您能提供帮助,我不在乎您使用哪种语言。这是我在这里遵循的原则!)

苹果公司的《 iPhone OS企业部署指南》指出:“可以通过在iTunes的设备摘要窗格中选择“加密iPhone备份”选项,以加密格式存储设备备份。文件使用256位密钥的AES128进行加密。安全地存储在iPhone钥匙串中。”

这是一个很好的线索,并且在iPhone AES / Rijndael互操作性上的Stackoverflow上有一些很好的信息,建议使用128的密钥大小和CBC模式。

除了其他混淆之外,还需要密钥和初始化向量(IV)/盐。

人们可能会认为该密钥是对“备份密码”的一种操纵,iTunes会提示用户输入该密码,并将其传递给“ AppleMobileBackup.exe ”,并以CBC规定的方式进行填充。但是,考虑到iPhone钥匙串,我想知道“备份密码”是否可能不用作X509证书或对称私钥上的密码,以及该证书或私钥本身是否可以用作密钥。(AES和iTunes的加密/解密过程是对称的。)

IV是另一回事,可能是几件事。也许它是硬编码到iTunes或设备本身的密钥之一。

尽管Apple的上述评论暗示密钥存在于设备的钥匙串中,但我认为这并不那么重要。可以将加密的备份还原到另一台设备,这表明备份和iTunes配置中存在与解密相关的所有信息,并且在这种情况下,仅设备上的任何内容都是不相关且可替换的。那么关键可能在哪里?

我在下面列出了Windows机器上的路径,但是无论我们使用哪种操作系统,它在很大程度上都是很大的。

“ \ appdata \ Roaming \ Apple Computer \ iTunes \ itunesprefs.xml”包含一个带有“ Keychain”字典条目的PList。“ \ programdata \ apple \ Lockdown \ 09037027da8f4bdefdea97d706703ca034c88bab.plist”包含带有“ DeviceCertificate”,“ HostCertificate”和“ RootCertificate”的PList,它们似乎都是有效的X509证书。同一文件似乎还包含非对称密钥“ RootPrivateKey”和“ HostPrivateKey”(我的阅读显示,这些密钥可能被PKCS#7包围)。另外,在每个备份中,Manifest.plist文件中都有“ AuthSignature”和“ AuthData”值,尽管随着每个文件的增量备份它们似乎会轮换,但建议它们作为键不是那么有用,除非真正相当复杂的工作正在完成。

有很多误导性的内容表明从加密备份中获取数据很容易。并非如此,据我所知,这还没有完成。完全绕过或禁用备份加密是另一回事,而不是我要执行的操作。

这与破解iPhone或类似的东西无关。我要做的只是从未加密的iTunes备份中提取数据(照片,联系人等)的一种方法。我已经使用上面提供的信息尝试了各种排列,但没有结果。我会很想念我可能错过的任何想法或技巧。


3
三年后的更新:我想出了办法,并将其推出了可免费获得的产品。我在上面的正确路线上,但是很难。
艾丹·菲茨帕特里克

您有该产品的链接吗?
Thilo 2012年

1
如您所问,它是iPhone Backup Extractor。尽管您会看到该程序的付费版本,但普通的旧免费版本允许您一次获取4个加密文件。
艾丹·菲茨帕特里克

1
我看到您设法解密了10.2备份。您能否分享您的成就?
Niki

@Niki我为iOS 10更新了以下答案
andrewdotn

Answers:


105

安全研究人员让-巴蒂斯特Bédrune和Jean Sigwald介绍如何做到这一点砍在现成2011阿姆斯特丹

从那时起,Apple发布了iOS安全白皮书, 其中包含有关密钥和算法的更多详细信息,以及Charlie Miller等人。已发布了《iOS Hacker's Handbook》,其中以操作指南的方式涵盖了一些相同的领域。当iOS 10首次发布时,备份格式发生了变化,Apple最初并未公开该备份格式,但是各种人对格式更改进行了反向工程

加密备份很棒

加密的iPhone备份的妙处在于,它们包含诸如WiFi密码之类的内容,这些内容不在常规的未加密备份中。如iOS安全白皮书中所述,加密备份被认为更“安全”,因此Apple认为可以在其中包含更多敏感信息。

重要警告:显然,解密iOS设备的备份会删除其加密。为了保护您的隐私和安全,您应该仅在具有全盘加密的计算机上运行这些脚本。虽然它是可能的安全专家编写软件,通过使用类似功能的保护在内存中,如钥匙VirtualLock()SecureZeroMemory()在许多其他事情,这些Python脚本将存储在您的字符串加密密钥和密码进行垃圾收集的被Python。这意味着您的秘密密钥和密码将在RAM中保留一段时间,从那时起它们就会泄漏到交换文件和磁盘中,而对手可以在其中恢复它们。这完全消除了具有加密备份的观点。

如何解密备份:理论上

iOS的安全性白皮书介绍了每个文件的密钥,防护等级,防护等级键和密钥包更好的基本概念比我的。如果您还不熟悉这些内容,请花几分钟阅读相关部分。

现在您知道iOS中的每个文件都使用其自己的随机的按文件加密密钥进行加密,属于保护类,并且按文件的加密密钥存储在文件系统元数据中,并包装在保护类密钥中。

解密:

  1. 解码存储在该密钥包BackupKeyBag进入 Manifest.plist白皮书对此结构进行了高级概述。的iPhone维基 描述了二进制格式:一个4字节串类型字段,4字节大端长度字段,然后将该值本身。

    重要的值是PBKDF2ationITERSALT,双重保护盐DPSL和迭代次数DPIC,然后是每个保护CLSWPKY包装密钥。

  2. 使用备份密码使用正确的PBKDF2盐和迭代次数派生32字节的密钥。首先使用SHA256轮DPSLDPIC,然后SHA1轮ITERSALT

    根据RFC 3394解开每个包装的密钥 。

  3. 通过从ManifestKeyin中拉出4字节的保护类和更长的密钥Manifest.plist并对其进行解包来解密清单数据库。现在,您将拥有一个包含所有文件元数据的SQLite数据库。

  4. 对于每个感兴趣的文件,请在Files.file数据库列中查找包含EncryptionKeyProtectionClass条目的二进制plist ,以获取按类加密的按文件加密密钥和保护类代码。使用之前,请剥离初始的四字节长度标签 EncryptionKey

    然后,通过使用与备用密码一起解开的类密钥来解开最终的解密密钥,来得出最终解密密钥。然后在CBC模式下使用IV为零的AES解密文件。

如何解密备份:实践中

首先,您需要一些库依赖项。如果您使用的是Mac OS上安装的本地安装的Python 2.7或3.7,则可以通过以下方式安装依赖项:

CFLAGS="-I$(brew --prefix)/opt/openssl/include" \
LDFLAGS="-L$(brew --prefix)/opt/openssl/lib" \    
    pip install biplist fastpbkdf2 pycrypto

以可运行的源代码格式,这是如何从加密的iPhone备份中解密单个首选项文件:

#!/usr/bin/env python3.7
# coding: UTF-8

from __future__ import print_function
from __future__ import division

import argparse
import getpass
import os.path
import pprint
import random
import shutil
import sqlite3
import string
import struct
import tempfile
from binascii import hexlify

import Crypto.Cipher.AES # https://www.dlitz.net/software/pycrypto/
import biplist
import fastpbkdf2
from biplist import InvalidPlistException


def main():
    ## Parse options
    parser = argparse.ArgumentParser()
    parser.add_argument('--backup-directory', dest='backup_directory',
                    default='testdata/encrypted')
    parser.add_argument('--password-pipe', dest='password_pipe',
                        help="""\
Keeps password from being visible in system process list.
Typical use: --password-pipe=<(echo -n foo)
""")
    parser.add_argument('--no-anonymize-output', dest='anonymize',
                        action='store_false')
    args = parser.parse_args()
    global ANONYMIZE_OUTPUT
    ANONYMIZE_OUTPUT = args.anonymize
    if ANONYMIZE_OUTPUT:
        print('Warning: All output keys are FAKE to protect your privacy')

    manifest_file = os.path.join(args.backup_directory, 'Manifest.plist')
    with open(manifest_file, 'rb') as infile:
        manifest_plist = biplist.readPlist(infile)
    keybag = Keybag(manifest_plist['BackupKeyBag'])
    # the actual keys are unknown, but the wrapped keys are known
    keybag.printClassKeys()

    if args.password_pipe:
        password = readpipe(args.password_pipe)
        if password.endswith(b'\n'):
            password = password[:-1]
    else:
        password = getpass.getpass('Backup password: ').encode('utf-8')

    ## Unlock keybag with password
    if not keybag.unlockWithPasscode(password):
        raise Exception('Could not unlock keybag; bad password?')
    # now the keys are known too
    keybag.printClassKeys()

    ## Decrypt metadata DB
    manifest_key = manifest_plist['ManifestKey'][4:]
    with open(os.path.join(args.backup_directory, 'Manifest.db'), 'rb') as db:
        encrypted_db = db.read()

    manifest_class = struct.unpack('<l', manifest_plist['ManifestKey'][:4])[0]
    key = keybag.unwrapKeyForClass(manifest_class, manifest_key)
    decrypted_data = AESdecryptCBC(encrypted_db, key)

    temp_dir = tempfile.mkdtemp()
    try:
        # Does anyone know how to get Python’s SQLite module to open some
        # bytes in memory as a database?
        db_filename = os.path.join(temp_dir, 'db.sqlite3')
        with open(db_filename, 'wb') as db_file:
            db_file.write(decrypted_data)
        conn = sqlite3.connect(db_filename)
        conn.row_factory = sqlite3.Row
        c = conn.cursor()
        # c.execute("select * from Files limit 1");
        # r = c.fetchone()
        c.execute("""
            SELECT fileID, domain, relativePath, file
            FROM Files
            WHERE relativePath LIKE 'Media/PhotoData/MISC/DCIM_APPLE.plist'
            ORDER BY domain, relativePath""")
        results = c.fetchall()
    finally:
        shutil.rmtree(temp_dir)

    for item in results:
        fileID, domain, relativePath, file_bplist = item

        plist = biplist.readPlistFromString(file_bplist)
        file_data = plist['$objects'][plist['$top']['root'].integer]
        size = file_data['Size']

        protection_class = file_data['ProtectionClass']
        encryption_key = plist['$objects'][
            file_data['EncryptionKey'].integer]['NS.data'][4:]

        backup_filename = os.path.join(args.backup_directory,
                                    fileID[:2], fileID)
        with open(backup_filename, 'rb') as infile:
            data = infile.read()
            key = keybag.unwrapKeyForClass(protection_class, encryption_key)
            # truncate to actual length, as encryption may introduce padding
            decrypted_data = AESdecryptCBC(data, key)[:size]

        print('== decrypted data:')
        print(wrap(decrypted_data))
        print()

        print('== pretty-printed plist')
        pprint.pprint(biplist.readPlistFromString(decrypted_data))

##
# this section is mostly copied from parts of iphone-dataprotection
# http://code.google.com/p/iphone-dataprotection/

CLASSKEY_TAGS = [b"CLAS",b"WRAP",b"WPKY", b"KTYP", b"PBKY"]  #UUID
KEYBAG_TYPES = ["System", "Backup", "Escrow", "OTA (icloud)"]
KEY_TYPES = ["AES", "Curve25519"]
PROTECTION_CLASSES={
    1:"NSFileProtectionComplete",
    2:"NSFileProtectionCompleteUnlessOpen",
    3:"NSFileProtectionCompleteUntilFirstUserAuthentication",
    4:"NSFileProtectionNone",
    5:"NSFileProtectionRecovery?",

    6: "kSecAttrAccessibleWhenUnlocked",
    7: "kSecAttrAccessibleAfterFirstUnlock",
    8: "kSecAttrAccessibleAlways",
    9: "kSecAttrAccessibleWhenUnlockedThisDeviceOnly",
    10: "kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly",
    11: "kSecAttrAccessibleAlwaysThisDeviceOnly"
}
WRAP_DEVICE = 1
WRAP_PASSCODE = 2

class Keybag(object):
    def __init__(self, data):
        self.type = None
        self.uuid = None
        self.wrap = None
        self.deviceKey = None
        self.attrs = {}
        self.classKeys = {}
        self.KeyBagKeys = None #DATASIGN blob
        self.parseBinaryBlob(data)

    def parseBinaryBlob(self, data):
        currentClassKey = None

        for tag, data in loopTLVBlocks(data):
            if len(data) == 4:
                data = struct.unpack(">L", data)[0]
            if tag == b"TYPE":
                self.type = data
                if self.type > 3:
                    print("FAIL: keybag type > 3 : %d" % self.type)
            elif tag == b"UUID" and self.uuid is None:
                self.uuid = data
            elif tag == b"WRAP" and self.wrap is None:
                self.wrap = data
            elif tag == b"UUID":
                if currentClassKey:
                    self.classKeys[currentClassKey[b"CLAS"]] = currentClassKey
                currentClassKey = {b"UUID": data}
            elif tag in CLASSKEY_TAGS:
                currentClassKey[tag] = data
            else:
                self.attrs[tag] = data
        if currentClassKey:
            self.classKeys[currentClassKey[b"CLAS"]] = currentClassKey

    def unlockWithPasscode(self, passcode):
        passcode1 = fastpbkdf2.pbkdf2_hmac('sha256', passcode,
                                        self.attrs[b"DPSL"],
                                        self.attrs[b"DPIC"], 32)
        passcode_key = fastpbkdf2.pbkdf2_hmac('sha1', passcode1,
                                            self.attrs[b"SALT"],
                                            self.attrs[b"ITER"], 32)
        print('== Passcode key')
        print(anonymize(hexlify(passcode_key)))
        for classkey in self.classKeys.values():
            if b"WPKY" not in classkey:
                continue
            k = classkey[b"WPKY"]
            if classkey[b"WRAP"] & WRAP_PASSCODE:
                k = AESUnwrap(passcode_key, classkey[b"WPKY"])
                if not k:
                    return False
                classkey[b"KEY"] = k
        return True

    def unwrapKeyForClass(self, protection_class, persistent_key):
        ck = self.classKeys[protection_class][b"KEY"]
        if len(persistent_key) != 0x28:
            raise Exception("Invalid key length")
        return AESUnwrap(ck, persistent_key)

    def printClassKeys(self):
        print("== Keybag")
        print("Keybag type: %s keybag (%d)" % (KEYBAG_TYPES[self.type], self.type))
        print("Keybag version: %d" % self.attrs[b"VERS"])
        print("Keybag UUID: %s" % anonymize(hexlify(self.uuid)))
        print("-"*209)
        print("".join(["Class".ljust(53),
                    "WRAP".ljust(5),
                    "Type".ljust(11),
                    "Key".ljust(65),
                    "WPKY".ljust(65),
                    "Public key"]))
        print("-"*208)
        for k, ck in self.classKeys.items():
            if k == 6:print("")

            print("".join(
                [PROTECTION_CLASSES.get(k).ljust(53),
                str(ck.get(b"WRAP","")).ljust(5),
                KEY_TYPES[ck.get(b"KTYP",0)].ljust(11),
                anonymize(hexlify(ck.get(b"KEY", b""))).ljust(65),
                anonymize(hexlify(ck.get(b"WPKY", b""))).ljust(65),
            ]))
        print()

def loopTLVBlocks(blob):
    i = 0
    while i + 8 <= len(blob):
        tag = blob[i:i+4]
        length = struct.unpack(">L",blob[i+4:i+8])[0]
        data = blob[i+8:i+8+length]
        yield (tag,data)
        i += 8 + length

def unpack64bit(s):
    return struct.unpack(">Q",s)[0]
def pack64bit(s):
    return struct.pack(">Q",s)

def AESUnwrap(kek, wrapped):
    C = []
    for i in range(len(wrapped)//8):
        C.append(unpack64bit(wrapped[i*8:i*8+8]))
    n = len(C) - 1
    R = [0] * (n+1)
    A = C[0]

    for i in range(1,n+1):
        R[i] = C[i]

    for j in reversed(range(0,6)):
        for i in reversed(range(1,n+1)):
            todec = pack64bit(A ^ (n*j+i))
            todec += pack64bit(R[i])
            B = Crypto.Cipher.AES.new(kek).decrypt(todec)
            A = unpack64bit(B[:8])
            R[i] = unpack64bit(B[8:])

    if A != 0xa6a6a6a6a6a6a6a6:
        return None
    res = b"".join(map(pack64bit, R[1:]))
    return res

ZEROIV = "\x00"*16
def AESdecryptCBC(data, key, iv=ZEROIV, padding=False):
    if len(data) % 16:
        print("AESdecryptCBC: data length not /16, truncating")
        data = data[0:(len(data)/16) * 16]
    data = Crypto.Cipher.AES.new(key, Crypto.Cipher.AES.MODE_CBC, iv).decrypt(data)
    if padding:
        return removePadding(16, data)
    return data

##
# here are some utility functions, one making sure I don’t leak my
# secret keys when posting the output on Stack Exchange

anon_random = random.Random(0)
memo = {}
def anonymize(s):
    if type(s) == str:
        s = s.encode('utf-8')
    global anon_random, memo
    if ANONYMIZE_OUTPUT:
        if s in memo:
            return memo[s]
        possible_alphabets = [
            string.digits,
            string.digits + 'abcdef',
            string.ascii_letters,
            "".join(chr(x) for x in range(0, 256)),
        ]
        for a in possible_alphabets:
            if all((chr(c) if type(c) == int else c) in a for c in s):
                alphabet = a
                break
        ret = "".join([anon_random.choice(alphabet) for i in range(len(s))])
        memo[s] = ret
        return ret
    else:
        return s

def wrap(s, width=78):
    "Return a width-wrapped repr(s)-like string without breaking on \’s"
    s = repr(s)
    quote = s[0]
    s = s[1:-1]
    ret = []
    while len(s):
        i = s.rfind('\\', 0, width)
        if i <= width - 4: # "\x??" is four characters
            i = width
        ret.append(s[:i])
        s = s[i:]
    return '\n'.join("%s%s%s" % (quote, line ,quote) for line in ret)

def readpipe(path):
    if stat.S_ISFIFO(os.stat(path).st_mode):
        with open(path, 'rb') as pipe:
            return pipe.read()
    else:
        raise Exception("Not a pipe: {!r}".format(path))

if __name__ == '__main__':
    main()

然后打印此输出:

Warning: All output keys are FAKE to protect your privacy
== Keybag
Keybag type: Backup keybag (1)
Keybag version: 3
Keybag UUID: dc6486c479e84c94efce4bea7169ef7d
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Class                                                WRAP Type       Key                                                              WPKY                                                             Public key
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
NSFileProtectionComplete                             2    AES                                                                         4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceedee86b4cde9f97afec197ad3b13c5d12b
NSFileProtectionCompleteUnlessOpen                   2    AES                                                                         09e8a0a9965f00f213ce06143a52801f35bde2af0ad54972769845d480b5043f545fa9b66a0353a6
NSFileProtectionCompleteUntilFirstUserAuthentication 2    AES                                                                         e966b6a0742878ce747cec3fa1bf6a53b0d811ad4f1d6147cd28a5d400a8ffe0bbabea5839025cb5
NSFileProtectionNone                                 2    AES                                                                         902f46847302816561e7df57b64beea6fa11b0068779a65f4c651dbe7a1630f323682ff26ae7e577
NSFileProtectionRecovery?                            3    AES                                                                         a3935fed024cd9bc11d0300d522af8e89accfbe389d7c69dca02841df46c0a24d0067dba2f696072

kSecAttrAccessibleWhenUnlocked                       2    AES                                                                         09a1856c7e97a51a9c2ecedac8c3c7c7c10e7efa931decb64169ee61cb07a0efb115050fd1e33af1
kSecAttrAccessibleAfterFirstUnlock                   2    AES                                                                         0509d215f2f574efa2f192efc53c460201168b26a175f066b5347fc48bc76c637e27a730b904ca82
kSecAttrAccessibleAlways                             2    AES                                                                         b7ac3c4f1e04896144ce90c4583e26489a86a6cc45a2b692a5767b5a04b0907e081daba009fdbb3c
kSecAttrAccessibleWhenUnlockedThisDeviceOnly         3    AES                                                                         417526e67b82e7c6c633f9063120a299b84e57a8ffee97b34020a2caf6e751ec5750053833ab4d45
kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly     3    AES                                                                         b0e17b0cf7111c6e716cd0272de5684834798431c1b34bab8d1a1b5aba3d38a3a42c859026f81ccc
kSecAttrAccessibleAlwaysThisDeviceOnly               3    AES                                                                         9b3bdc59ae1d85703aa7f75d49bdc600bf57ba4a458b20a003a10f6e36525fb6648ba70e6602d8b2

== Passcode key
ee34f5bb635830d698074b1e3e268059c590973b0f1138f1954a2a4e1069e612

== Keybag
Keybag type: Backup keybag (1)
Keybag version: 3
Keybag UUID: dc6486c479e84c94efce4bea7169ef7d
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Class                                                WRAP Type       Key                                                              WPKY                                                             Public key
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
NSFileProtectionComplete                             2    AES        64e8fc94a7b670b0a9c4a385ff395fe9ba5ee5b0d9f5a5c9f0202ef7fdcb386f 4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceedee86b4cde9f97afec197ad3b13c5d12b
NSFileProtectionCompleteUnlessOpen                   2    AES        22a218c9c446fbf88f3ccdc2ae95f869c308faaa7b3e4fe17b78cbf2eeaf4ec9 09e8a0a9965f00f213ce06143a52801f35bde2af0ad54972769845d480b5043f545fa9b66a0353a6
NSFileProtectionCompleteUntilFirstUserAuthentication 2    AES        1004c6ca6e07d2b507809503180edf5efc4a9640227ac0d08baf5918d34b44ef e966b6a0742878ce747cec3fa1bf6a53b0d811ad4f1d6147cd28a5d400a8ffe0bbabea5839025cb5
NSFileProtectionNone                                 2    AES        2e809a0cd1a73725a788d5d1657d8fd150b0e360460cb5d105eca9c60c365152 902f46847302816561e7df57b64beea6fa11b0068779a65f4c651dbe7a1630f323682ff26ae7e577
NSFileProtectionRecovery?                            3    AES        9a078d710dcd4a1d5f70ea4062822ea3e9f7ea034233e7e290e06cf0d80c19ca a3935fed024cd9bc11d0300d522af8e89accfbe389d7c69dca02841df46c0a24d0067dba2f696072

kSecAttrAccessibleWhenUnlocked                       2    AES        606e5328816af66736a69dfe5097305cf1e0b06d6eb92569f48e5acac3f294a4 09a1856c7e97a51a9c2ecedac8c3c7c7c10e7efa931decb64169ee61cb07a0efb115050fd1e33af1
kSecAttrAccessibleAfterFirstUnlock                   2    AES        6a4b5292661bac882338d5ebb51fd6de585befb4ef5f8ffda209be8ba3af1b96 0509d215f2f574efa2f192efc53c460201168b26a175f066b5347fc48bc76c637e27a730b904ca82
kSecAttrAccessibleAlways                             2    AES        c0ed717947ce8d1de2dde893b6026e9ee1958771d7a7282dd2116f84312c2dd2 b7ac3c4f1e04896144ce90c4583e26489a86a6cc45a2b692a5767b5a04b0907e081daba009fdbb3c
kSecAttrAccessibleWhenUnlockedThisDeviceOnly         3    AES        80d8c7be8d5103d437f8519356c3eb7e562c687a5e656cfd747532f71668ff99 417526e67b82e7c6c633f9063120a299b84e57a8ffee97b34020a2caf6e751ec5750053833ab4d45
kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly     3    AES        a875a15e3ff901351c5306019e3b30ed123e6c66c949bdaa91fb4b9a69a3811e b0e17b0cf7111c6e716cd0272de5684834798431c1b34bab8d1a1b5aba3d38a3a42c859026f81ccc
kSecAttrAccessibleAlwaysThisDeviceOnly               3    AES        1e7756695d337e0b06c764734a9ef8148af20dcc7a636ccfea8b2eb96a9e9373 9b3bdc59ae1d85703aa7f75d49bdc600bf57ba4a458b20a003a10f6e36525fb6648ba70e6602d8b2

== decrypted data:
'<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD '
'PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist versi'
'on="1.0">\n<dict>\n\t<key>DCIMLastDirectoryNumber</key>\n\t<integer>100</integ'
'er>\n\t<key>DCIMLastFileNumber</key>\n\t<integer>3</integer>\n</dict>\n</plist'
'>\n'

== pretty-printed plist
{'DCIMLastDirectoryNumber': 100, 'DCIMLastFileNumber': 3}

额外信用

Bédrune和Sigwald发布的iphone数据保护代码可以解密备份中的钥匙串,包括有趣的东西,例如保存的wifi和网站密码:

$ python iphone-dataprotection/python_scripts/keychain_tool.py ...

--------------------------------------------------------------------------------------
|                              Passwords                                             |
--------------------------------------------------------------------------------------
|Service           |Account          |Data           |Access group  |Protection class|
--------------------------------------------------------------------------------------
|AirPort           |Ed’s Coffee Shop |<3FrenchRoast  |apple         |AfterFirstUnlock|
...

该代码不再适用于使用最新iOS的手机备份,但是其中一些golang 端口已保持最新状态,以允许访问钥匙串


2
我尝试了一下,并且在所有其他工具都失败的情况下起作用。我还必须添加另一个缺少的python模块: pip install --user pycrypto 谢谢!
ALoopingIcon 2012年

2
精彩!使用macports,我安装了以下依赖项:py27-m2crypto py27-cryptography
hyperspasm

2
在code.google.com链接被404ing我,但我在发现工具的更新版本(OS X 10.10)github.com/dinosec/iphone-dataprotection。它适用于OS X 10.11.5。
亚伦·布拉格

2
如果您要更新代码,对我来说您将接近神灵!
Jonas Zaugg

3
@JonasZaugg我已经更新了iOS 10的示例代码。希望您发现它有用。
Andrewdotn

6

抱歉,它甚至可能更复杂,涉及到pbkdf2或它的一个变体。听WWDC 2010会话#209,该会话主要讨论iOS 4中的安全措施,还简要提及备份的单独加密及其相关性。

您可以确定,即使不知道密码,也无法解密,即使是蛮力破解。

让我们假设您想尝试使知道密码的人能够访问其备份数据。

我担心无法查看iTunes中的实际代码来确定采用了哪种算法。

在牛顿时代,我不得不从程序解密数据,并且能够直接调用其解密功能(当然知道密码),而无需了解其算法。不幸的是,这不再那么容易了。

我敢肯定,周围有技术人员可以对iTunes代码进行逆向工程-您只需使他们感兴趣。

从理论上讲,Apple的算法应采用某种方式设计,以使知道确切加密方法的任何攻击者仍可以安全地使用数据(即,几乎无法通过蛮力方法破坏)。在WWDC第209期中,他们深入了解了有关如何完成此操作的详细信息。如果您告诉他们您的良好意愿,也许您实际上可以直接从Apple的安全团队获得答案。毕竟,即使他们也应该知道,混淆带来的安全性并不是真正有效的。试试他们的安全邮件列表。即使他们没有回应,也许名单上的其他人默默地回应也会有所帮助。

祝好运!


1

还没有尝试过,但是Elcomsoft发布了他们声称能够解密备份以进行取证的产品。也许不如自己设计解决方案那么酷,但是可能更快。

http://www.elcomsoft.com/eppb.html


1
谢谢。这不会像这样解密备份:只会破解密钥。我已经知道该怎么做了……这比拥有密钥后解密备份要简单得多。
艾丹·菲茨帕特里克

-3

您应该获取Erica Sadun的mdhelper命令行实用程序(OS X二进制源代码)的副本。它支持列出和提取iPhone / iPod Touch备份的内容,包括地址簿和SMS数据库,以及其他应用程序元数据和设置。


1
那只是一个PList读者:我已经可以本地完成这些工作。它不支持加密备份,这是我需要的,并且超出了该实用程序的范围。
艾丹·菲茨帕特里克

您是否花时间尝试该实用程序?我的备份已加密,并且完全符合您要执行的操作。
内森·德弗里斯

10
是的,我也阅读了源代码。它不处理加密备份,并且在iTunes对加密备份的支持发布之前进行了最后修改。我怀疑您的意思是备份已编码或iPhone使用加密的文件系统,这完全是另一回事。除了代码中不支持加密外,更明显的是,没有任何选项可以在命令行选项中输入密码。而且代码不使用任何证书或钥匙串。我很乐意被证明是错误的,但是我真的不认为自己是错的!不过,我很感谢这个建议。
艾丹·菲茨帕特里克
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.