暗号化されたAppleiTunes iPhoneバックアップを復号化する方法は?


84

多くの不幸なiPhoneユーザーから、iTunesバックアップからデータを復元するのを手伝ってくれるように頼まれました。これは、暗号化されていない場合は簡単ですが、パスワードがわかっているかどうかに関係なく、暗号化されている場合は簡単ではありません。

そのため、暗号化されたときにmddataファイルとmdinfoファイルで使用される暗号化スキームを理解しようとしています。それ以外の場合はこれらのファイルを読み取るのに問題はなく、そのための堅牢なC#ライブラリをいくつか構築しました。(あなたが助けることができれば、私はあなたがどの言語を使うかは気にしません。それは私がここで求めている原則です!)

Appleの「iPhoneOSEnterprise展開ガイド」には、「iTunesのデバイス概要ペインで[iPhoneバックアップの暗号化]オプションを選択すると、デバイスのバックアップを暗号化された形式で保存できます。ファイルは256ビットキーのAES128を使用して暗号化されます。キーはiPhoneのキーチェーンに安全に保管されています。」

これはかなり良い手がかりです。iPhoneAES / Rijndaelの相互運用性に関するStackoverflowには、128のキーサイズとCBCモードを使用できることを示唆するいくつかの良い情報があります。

他の難読化とは別に、キーと初期化ベクトル(IV)/ソルトが必要です。

キーは、ユーザーがiTunesによって入力を求められ、CBCによって指示された方法で埋め込まれた「AppleMobileBackup.exe」に渡される「バックアップパスワード」の操作であると考える人もいるかもしれません。ただし、iPhoneキーチェーンへの参照を考えると、「バックアップパスワード」がX509証明書または対称秘密鍵のパスワードとして使用されないのではないか、証明書または秘密鍵自体が鍵として使用されるのではないかと思います。(AESとiTunesの暗号化/復号化プロセスは対称的です。)

IVは別の問題であり、それはいくつかのことかもしれません。おそらく、それはiTunesまたはデバイス自体にハードコードされたキーの1つです。

上記のAppleのコメントは、キーがデバイスのキーチェーンに存在することを示唆していますが、これはそれほど重要ではないと思います。暗号化されたバックアップを別のデバイスに復元できます。これは、復号化に関連するすべての情報がバックアップとiTunesの構成に存在し、デバイス上にあるものだけがこのコンテキストでは無関係で置き換え可能であることを示しています。では、鍵はどこにあるのでしょうか。

以下にWindowsマシンからのパスをリストしましたが、どのOSを使用する場合でもかなりの量になります。

「\ appdata \ Roaming \ AppleComputer \ iTunes \ itunesprefs.xml」には、「Keychain」dictエントリを含むPListが含まれています。「\ programdata \ apple \ Lockdown \ 09037027da8f4bdefdea97d706703ca034c88bab.plist」には、「DeviceCertificate」、「HostCertificate」、および「RootCertificate」を含むPListが含まれており、これらはすべて有効なX509証明書のようです。同じファイルには、非対称キー「RootPrivateKey」と「HostPrivateKey」も含まれているようです(私の読書では、これらはPKCS#7エンベロープである可能性があります)。また、各バックアップ内には、Manifest.plistファイルに「AuthSignature」と「AuthData」の値がありますが、これらは各ファイルが段階的にバックアップされるにつれてローテーションされているように見えますが、実際に何かがない限り、キーとしてはそれほど有用ではないことを示唆していますかなり関与しています。

暗号化されたバックアップからデータを取得するのが簡単であることを示唆する誤解を招くものがたくさんあります。そうではなく、私の知る限り、それは行われていません。バックアップ暗号化をバイパスまたは無効にすることはまったく別の問題であり、私がやろうとしていることではありません。

これは、iPhoneなどをハッキングすることではありません。私がここで求めているのは、暗号化されていないものと同じように、暗号化されたiTunesバックアップからデータ(写真、連絡先など)を抽出する手段だけです。上に書いた情報を使ってあらゆる種類の順列を試しましたが、どこにも行きませんでした。私が見逃したかもしれない考えやテクニックをいただければ幸いです。


3
3年後の更新:私はそれを理解し、自由に利用できる製品にまとめました。私は上の正しい軌道に乗っていましたが、それは大変でした。
エイダンフィッツパトリック

その製品へのリンクはありますか?
Thilo 2012年

1
あなたが尋ねたように、それはiPhoneバックアップエクストラクタです。プログラムには有料版がありますが、昔ながらの無料版では、暗号化されたファイルを一度に4つ取り出すことができます。
エイダンフィッツパトリック2012年

1
10.2バックアップを復号化できたようです。それをどのように達成したかを教えてください。
niki

@Niki iOS 10の回答を以下に更新しました
andrewdotn 2017年

回答:


105

セキュリティ研究者のジャン=バティストBédruneとジャンSigwaldはこれを行う方法を提示ハック・イン・ザ・ボックスアムステルダム2011

それ以来、Appleは キーとアルゴリズムの詳細を記載したiOSセキュリティホワイトペーパーをリリースしました。CharlieMilleretaliOS Hacker's Handbookをリリースしました。これは、ハウツー方式で同じ分野のいくつかをカバーしています。iOS 10が最初に登場したとき、Appleが最初に公表しなかったバックアップ形式への変更がありましたが、さまざまな人々が形式の変更をリバースエンジニアリングしました

暗号化されたバックアップは素晴らしいです

暗号化されたiPhoneバックアップの優れている点は、通常の暗号化されていないバックアップにはないWiFiパスワードなどが含まれていることです。iOSセキュリティホワイトペーパーで説明されているように、暗号化されたバックアップはより「安全」であると見なされるため、Appleはより機密性の高い情報をバックアップに含めても問題ないと考えています。

重要な警告:明らかに、iOSデバイスのバックアップを復号化すると暗号化が削除されます。プライバシーとセキュリティを保護するために、これらのスクリプトはフルディスク暗号化を備えたマシンでのみ実行する必要があります。それはのような関数使用することにより例えば、メモリ内のキーを保護し、書き込みソフトウェアにセキュリティの専門家のために可能ではあるがVirtualLock()、および SecureZeroMemory()他の多くのものの中に、これらのPythonスクリプトは、ガベージコレクトのPythonによるように、文字列であなたの暗号化キーとパスワードを格納します。これは、秘密鍵とパスワードがしばらくの間RAMに残り、そこからスワップファイルとディスクにリークし、攻撃者がそれらを回復できることを意味します。これは、暗号化されたバックアップを持つという点を完全に打ち負かします。

バックアップを復号化する方法:理論上

iOSのセキュリティホワイトペーパーでは、私ができるよりも、ファイルごとのキー、保護クラス、保護クラスキー、およびより良いkeybagsの基本的な概念を説明します。これらにまだ精通していない場合は、関連する部分を読むために数分かかります。

これで、iOSのすべてのファイルが独自のランダムなファイルごとの暗号化キーで暗号化され、保護クラスに属し、ファイルごとの暗号化キーがファイルシステムメタデータに保存され、保護クラスキーにラップされていることがわかりました。

復号化するには:

  1. BackupKeyBagエントリに 保存されているキーバッグをデコードしManifest.plistます。この構造の概要は、ホワイトペーパーに記載されています。iPhoneウィキは 4バイトの文字列型のフィールド、4バイトのビッグエンディアンの長さフィールド、およびその値自体:バイナリ形式について説明します。

    重要な値は、PBKDF2 ationsITERSALT、二重保護ソルトDPSLと反復回数DPIC、そして各保護CLSについて、WPKYラップされたキーです。

  2. バックアップパスワードを使用して、正しいPBKDF2ソルトと反復回数を使用して32バイトのキーを取得します。最初にDPSLDPICでSHA256ラウンドを使用し、次にとでSHA1ラウンドを使用ITERSALTます。

    RFC 3394に従って、ラップされた各キーをアンラップし ます

  3. から4バイトの保護クラスとより長いキーをプルManifestKeyManifest.plist、それをアンラップして、マニフェストデータベースを復号化します。これで、すべてのファイルメタデータを含むSQLiteデータベースができました。

  4. 関心の各ファイルについて、で見ることで、クラスで暗号化されたファイル単位の暗号化鍵と保護クラスコードを取得Files.file含むバイナリplistのためのデータベース列EncryptionKeyProtectionClassエントリー。EncryptionKey使用する前に、最初の4バイト長のタグを 削除します。

    次に、バックアップパスワードでラップ解除されたクラスキーでラップ解除して、最終的な復号化キーを取得します。次に、IVがゼロのCBCモードでAESを使用してファイルを復号化します。

バックアップを復号化する方法:実際には

まず、いくつかのライブラリの依存関係が必要になります。自作でインストールされたPython2.7または3.7を使用しているMacを使用している場合は、次の方法で依存関係をインストールできます。

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}

追加クレジット

iphone-dataprotectionコードを解読することができBédruneとSigwaldによって投稿キーチェーンを保存した無線LANやWebサイトのパスワードのような楽しいことを含め、バックアップから:

$ 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
私はそれを試しましたが、他のすべてのツールが失敗したところで機能しました。もう1つの不足しているPythonモジュールも追加する必要がありました: pip install --user pycrypto ありがとう!
ALoopingIcon 2012

2
素晴らしい!macportsを使用して、次の依存関係をインストールしました:py27-m2crypto py27-cryptography
hyperspasm

2
code.google.comのリンクは私にとって404でしたが、github.com / dinosec / iphone-dataprotectionでツールの更新バージョン(OS X 10.10用)を見つけました。OS X10.11.5で動作しました。
アーロンブレイガー2016

2
もしあなたがコードを更新するなら、あなたは私にとって神に近いでしょう!
Jonas Zaugg 2017

3
@JonasZaugg iOS10のサンプルコードを更新しました。お役に立てば幸いです。
andrewdotn 2017年

6

申し訳ありませんが、pbkdf2やそのバリエーションなど、さらに複雑になる可能性があります。WWDC 2010セッション#209を聞いてください。このセッションでは、主にiOS 4のセキュリティ対策について説明していますが、バックアップの個別の暗号化とそれらの関連についても簡単に説明しています。

パスワードを知らなければ、ブルートフォース攻撃であっても、パスワードを復号化する方法はありません。

パスワードを知っている人がバックアップのデータにアクセスできるようにしたいとします。

どのアルゴが採用されているかを理解するために、iTunesの実際のコードを見る方法がないのではないかと心配しています。

ニュートンの時代に、私はプログラムからデータを復号化する必要があり、そのアルゴリズムを理解する必要さえなく、その復号化関数を直接呼び出すことができました(もちろんパスワードを知っています)。残念ながら、もうそれほど簡単ではありません。

そのiTunesコードをリバースエンジニアリングできる熟練した人々が周りにいると確信しています-あなたは彼らに興味を持ってもらう必要があります。

理論的には、Appleのアルゴは、正確な暗号化方法を知っている攻撃者に対して、データを安全に(つまり、力ずくの方法で事実上破壊できないように)設計する必要があります。そして、WWDCセッション209で、彼らはこれを達成するために何をするかについてかなり深く掘り下げました。善意を伝えれば、Appleのセキュリティチームから直接回答を得ることができるかもしれません。結局のところ、難読化によるセキュリティは実際には効率的ではないことを知っておく必要があります。彼らのセキュリティメーリングリストを試してみてください。彼らが応答しなくても、リストに載っている他の誰かが助けを借りて応答するかもしれません。

幸運を!


1

まだ試していませんが、Elcomsoftは、フォレンジック目的でバックアップを復号化できると主張する製品をリリースしました。自分でソリューションを設計するほどクールではないかもしれませんが、もっと速いかもしれません。

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


1
ありがとう。これはバックアップ自体を復号化するのではなく、キーを解読するだけです。私はすでにそれを行う方法を知っています...そしてそれはあなたが鍵を手に入れたらバックアップを解読するよりもずっと簡単です。
エイダンフィッツパトリック2010

-3

Erica Sadunのmdhelperコマンドラインユーティリティ(OS Xバイナリソース)のコピーを入手する必要があります。アドレス帳やSMSデータベース、その他のアプリケーションのメタデータや設定など、iPhone / iPodTouchバックアップのコンテンツの一覧表示と抽出をサポートします。


1
これは単なるPListリーダーです。私はすでにそのようなことをネイティブに行うことができます。それは私が求めているものであり、そのユーティリティの範囲を超えている暗号化されたバックアップをサポートしていません。
エイダンフィッツパトリック

ユーティリティを試すのに時間をかけましたか?私のバックアップは暗号化されており、あなたがやろうとしていることを正確に実行します。
Nathan de Vries

10
はい、そして私もソースを読みました。暗号化されたバックアップを処理せず、暗号化されたバックアップに対するiTunesのサポートがリリースされる前に最後に変更されました。バックアップがエンコードされているか、iPhoneが暗号化されたファイルシステムを使用していることを意味しているのではないかと思います。これはまったく別の問題です。コードで暗号化がサポートされていないだけでなく、コマンドラインオプションでパスワードを渡すオプションがないことは明らかです。また、コードは証明書やキーチェーンを使用していません。私はこれについて間違っていると証明されたいのですが、私は本当にそうではないと思います!しかし、私はその提案に感謝します。
エイダンフィッツパトリック
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.