Frage Wie entschlüsselt man ein verschlüsseltes Apple iTunes iPhone Backup?


Ich wurde von einigen unglücklichen iPhone-Nutzern gebeten, ihnen bei der Wiederherstellung von Daten aus ihren iTunes-Backups zu helfen. Dies ist einfach, wenn sie unverschlüsselt sind, aber nicht, wenn sie verschlüsselt sind, unabhängig davon, ob das Passwort bekannt ist oder nicht.

Als solches versuche ich herauszufinden, welches Verschlüsselungsschema bei der Verschlüsselung von mddata und mdinfo verwendet wird. Ich habe keine Probleme, diese Dateien anders zu lesen, und habe dafür einige robuste C # -Bibliotheken erstellt. (Wenn du helfen kannst, ist mir egal, welche Sprache du benutzt. Das ist der Grundsatz, nach dem ich hier bin!)

Das "iPhone OS Enterprise Deployment Guide" von Apple besagt, dass "Gerätesicherungen im verschlüsselten Format gespeichert werden können, indem Sie das iPhone verschlüsseln auswählen Sicherungsoption im Gerätezusammenfassungsbereich von iTunes. Dateien werden mit AES128 mit einem 256-Bit-Schlüssel verschlüsselt. Der Schlüssel ist sicher im iPhone-Schlüsselbund aufbewahrt. "

Das ist ein ziemlich guter Anhaltspunkt, und es gibt einige gute Informationen hier auf Stackoverflow auf dem iPhone AES / Rijndael-Interoperabilität Vorschlagen einer Schlüsselgröße von 128 und CBC-Modus kann verwendet werden.

Abgesehen von jeder anderen Verschleierung sind ein Schlüssel und ein Initialisierungsvektor (IV) / Salz erforderlich.

Man könnte annehmen, dass der Schlüssel eine Manipulation des "Sicherungskennworts" ist, zu dem Benutzer aufgefordert werden, durch iTunes einzugeben und an "AppleMobileBackup.exe", gepolstert in einer Art und Weise diktiert von CBC. Allerdings, angesichts der Verweis auf den iPhone Schlüsselbund, frage ich mich, ob das" backup password "möglicherweise nicht als ein Passwort auf einem X509-Zertifikat oder symmetrischen privaten Schlüssel verwendet werden, und das Zertifikat oder privat Schlüssel selbst könnte als Schlüssel verwendet werden. (AES und der iTunes Verschlüsselungs- / Entschlüsselungsprozess ist symmetrisch.)

Die IV ist eine andere Sache, und es könnte ein paar Dinge sein. Vielleicht ist es einer der Schlüssel hart codiert in iTunes oder in die Geräte selbst.

Obwohl Apples Kommentar darauf hindeutet, dass der Schlüssel auf dem Schlüsselbund des Geräts vorhanden ist, halte ich das für nicht so wichtig. Man kann eine verschlüsselte Sicherung auf einem wiederherstellen anders Gerät, das darauf hinweist, dass alle für die Entschlüsselung relevanten Informationen in der Backup- und iTunes-Konfiguration vorhanden sind, und dass alles nur auf dem Gerät in diesem Zusammenhang irrelevant und austauschbar ist. Also, wo könnte der Schlüssel sein?

Ich habe unten die Pfade von einem Windows-Rechner aufgelistet, aber es ist ein großer Vorteil, welches Betriebssystem wir auch verwenden.

Die "\ appdata \ Roaming \ Apple Computer \ iTunes \ itunesprefs.xml" enthält einen PList mit einem "Keychain" dict-Eintrag darin. Die "\ programdata \ apple \ Lockdown \ 09037027da8f4bdefdea97d706703ca034c88bab.plist" enthält einen PList mit "DeviceCertificate", "HostCertificate" und "RootCertificate", von denen alle als gültige X509-Zertifikate zu gelten scheinen. Die gleiche Datei scheint auch die asymmetrischen Schlüssel "RootPrivateKey" und "HostPrivateKey" zu enthalten (nach meiner Lesart könnte dies PKCS # 7-hüllend sein). Außerdem gibt es in jeder Sicherung "AuthSignature" und "AuthData" -Werte in der Manifest.plist-Datei, obwohl diese gedreht zu sein scheinen, da jede Datei inkrementell gesichert wird, was bedeutet, dass sie nicht als Schlüssel nützlich sind, es sei denn, wirklich etwas ziemlich involviert ist getan.

Es gibt eine Menge irreführender Dinge, die darauf hindeuten, dass Daten aus verschlüsselten Backups leicht zu bekommen sind. Es ist nicht, und meines Wissens ist es nicht getan worden. Umgehen oder deaktivieren Die Backup-Verschlüsselung ist eine ganz andere Sache, und das ist nicht das, was ich tun möchte.

Es geht nicht darum, das iPhone oder ähnliches zu zerhacken. Alles, was ich hier möchte, ist ein Mittel, um Daten (Fotos, Kontakte, etc.) aus verschlüsselten iTunes-Backups zu extrahieren, wie ich unverschlüsselte. Ich habe alle möglichen Permutationen mit den Informationen, die ich oben angegeben habe, ausprobiert, aber ich habe nichts erreicht. Ich würde mich über alle Gedanken oder Techniken freuen, die ich verpasst haben könnte.


76
2017-09-30 14:07


Ursprung


Antworten:


Sicherheitsforscher Jean-Baptiste Bédrune und Jean Sigwald präsentiert wie um dies zu tun beim Hack-in-the-box Amsterdam 2011.

Seitdem hat Apple ein iOS-Sicherheits-Whitepaper mit mehr Details über Schlüssel und Algorithmen, und Charlie Miller et al. haben veröffentlicht die iOS Hacker Handbuch, die einige der gleichen abdeckt in einer How-To-Mode geschliffen. Als iOS 10 zum ersten Mal veröffentlicht wurde, gab es Änderungen zu dem Backup-Format, das Apple zunächst nicht veröffentlicht hat, aber verschiedene Menschen Reverse-Engineering der Formatänderungen.

Verschlüsselte Backups sind großartig

Das Tolle an verschlüsselten iPhone-Backups ist, dass sie Dinge enthalten wie WiFi-Passwörter, die nicht in regulären unverschlüsselten Backups enthalten sind. Wie diskutiert in der iOS-Sicherheits-Whitepaper, verschlüsselte Backups werden als "sicherer" betrachtet, daher hält es Apple für ok, mehr hinzuzufügen sensible Informationen in ihnen.

Eine wichtige Warnung: Entschlüsseln Sie das Backup Ihres iOS-Geräts Entfernt seine Verschlüsselung. Um Ihre Privatsphäre und Sicherheit zu schützen, Du solltest Führen Sie diese Skripts nur auf einem Computer mit vollständiger Festplattenverschlüsselung aus. Während es Für einen Sicherheitsexperten ist es möglich, Software zu schreiben, die Schlüssel schützt Speicher, z.B. mit Funktionen wie VirtualLock() und SecureZeroMemory() unter vielen anderen Dingen, diese Python-Skripte speichern Ihre Verschlüsselungsschlüssel und Kennwörter in Strings Müll von Python gesammelt werden. Dies bedeutet Ihre geheimen Schlüssel und Passwörter wird für eine Weile im RAM leben, von wo aus sie in deinen Swap eindringen werden Datei und auf Ihre Festplatte, wo ein Gegner sie wiederherstellen kann. Dies schließt den Punkt der verschlüsselten Sicherung komplett aus.

So entschlüsseln Sie Backups: theoretisch

Das iOS-Sicherheits-Whitepaper erklärt die grundlegenden Konzepte von Schlüsseln pro Datei, Schutzklassen, Schlüsseln für Schutzklassen und Schlüsseltaschen besser als ich kann. Wenn Sie diese nicht bereits kennen, nehmen Sie ein paar Minuten, um die relevanten Teile zu lesen.

Jetzt wissen Sie, dass jede Datei in iOS mit einer eigenen Zufallszahl verschlüsselt ist Pro-Datei-Verschlüsselungsschlüssel, gehört zu einer Schutzklasse, und die pro-Datei Verschlüsselungsschlüssel werden in den Metadaten des Dateisystems gespeichert und in die Schutzklassenschlüssel.

Entschlüsseln:

  1. Dekodieren Sie den in der BackupKeyBag Eintrag von Manifest.plist. Ein Überblick dieser Struktur auf hoher Ebene ist in das weißes Papier. Das iPhone Wiki beschreibt das Binärformat: ein 4-Byte-String-Typ-Feld, ein 4-Byte Big-Endian-Längenfeld und dann der Wert selbst.

    Die wichtigen Werte sind die PBKDF2 ITERationen und SALT, der Doppelgänger Schutzsalz DPSL und Iterationszählung DPICund dann für jeden Schutz CLS, das WPKY eingepackter Schlüssel.

  2. Verwenden Sie das Sicherungskennwort, um einen 32-Byte-Schlüssel mit dem korrekten PBKDF2 abzuleiten Salz und Anzahl der Iterationen. Verwenden Sie zuerst eine SHA256 Runde mit DPSL und DPIC, dann eine SHA1 Runde mit ITER und SALT.

    Wickeln Sie jeden eingepackten Schlüssel entsprechend ab RFC 3394.

  3. Entschlüsseln Sie die Manifestdatenbank, indem Sie die 4-Byte-Schutzklasse und den längeren Schlüssel von der ManifestKey im Manifest.plistund es auspacken. Du hast jetzt ein SQLite-Datenbank mit allen Dateimetadaten.

  4. Erhalten Sie für jede Datei von Interesse die klassenverschlüsselte Verschlüsselung pro Datei Schlüssel und Schutzklassencode durch Blick in die Files.file Datenbank Spalte für eine Binärdatei, die enthält EncryptionKey und ProtectionClass Einträge. Entferne das anfängliche Vier-Byte-Längen-Tag von EncryptionKey vor Gebrauch.

    Dann leiten Sie den endgültigen Entschlüsselungsschlüssel ab, indem Sie ihn mit der Klasse auspacken Schlüssel, der mit dem Sicherungskennwort ausgepackt wurde. Entschlüsseln Sie die Datei Verwenden von AES im CBC-Modus mit einer Null IV.

So entschlüsseln Sie Backups: in der Praxis

In runnable Quellcodeform, hier ist, wie man den Rechner entschlüsselt Voreinstellungsdatei von einem verschlüsselten iPhone-Backup:

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

import argparse
import base64
import getpass
import hashlib
import os.path
import pprint
import random
import shutil
import sqlite3
import stat
import string
import struct
import sys
import tempfile

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

def main():
    ## Parse options
    parser = argparse.ArgumentParser()
    parser.add_argument('--backup-directory', dest='backup_directory',
                      default='data/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')
    parser.add_argument('--base64-passcode-key-pipe', dest='passcode_key_pipe',
                        help="""\
Provide a previously derived passcode key to save time doing PBDKF2 when
developing""")
    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)
    else:
        password = getpass.getpass('Backup password: ')

    if args.passcode_key_pipe:
        passcode_key = base64.decodestring(readpipe(args.passcode_key_pipe))
    else:
        passcode_key = None

    ## Unlock keybag with password
    if not keybag.unlockWithPasscode(password, passcode_key):
        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'), 'r') 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, 'w') as db_file:
            db_file.write(decrypted_data)
        conn = sqlite3.connect(db_filename)
        c = conn.cursor()
        c.execute("""
            SELECT fileID, domain, relativePath, file
            FROM Files
            WHERE relativePath LIKE '%/Preferences/com.apple.calculator.plist'
            ORDER BY 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 calculator preferences'
        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 = ["CLAS","WRAP","WPKY", "KTYP", "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 == "TYPE":
                self.type = data
                if self.type > 3:
                    print "FAIL: keybag type > 3 : %d" % self.type
            elif tag == "UUID" and self.uuid is None:
                self.uuid = data
            elif tag == "WRAP" and self.wrap is None:
                self.wrap = data
            elif tag == "UUID":
                if currentClassKey:
                    self.classKeys[currentClassKey["CLAS"]] = currentClassKey
                currentClassKey = {"UUID": data}
            elif tag in CLASSKEY_TAGS:
                currentClassKey[tag] = data
            else:
                self.attrs[tag] = data
        if currentClassKey:
            self.classKeys[currentClassKey["CLAS"]] = currentClassKey

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

    def unwrapKeyForClass(self, protection_class, persistent_key):
        ck = self.classKeys[protection_class]["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["VERS"]
        print "Keybag UUID: %s" % anonymize(self.uuid.encode("hex"))
        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("WRAP","")).ljust(5),
                 KEY_TYPES[ck.get("KTYP",0)].ljust(11),
                 anonymize(ck.get("KEY", "").encode("hex")).ljust(65),
                 anonymize(ck.get("WPKY", "").encode("hex")).ljust(65),
                 ck.get("PBKY", "").encode("hex")])
        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 xrange(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 xrange(1,n+1):
        R[i] = C[i]

    for j in reversed(xrange(0,6)):
        for i in reversed(xrange(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 = "".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):
    global anon_random, memo
    if ANONYMIZE_OUTPUT:
        if s in memo:
            return memo[s]
        possible_alphabets = [
            string.digits,
            string.digits + 'abcdef',
            string.letters,
            "".join(chr(x) for x in range(0, 256)),
        ]
        for a in possible_alphabets:
            if all(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()

Welches druckt dann diese Ausgabe:

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
VNfSPwXOK8mvKxTtmZ51JppAzrsG7gkWSiY8W7xnRX4=

== 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:
'bplist00\xd3\x01\x02\x03\x04\x05\x06\\DisplayValue[MemoryValue_\x10\x14Trigono'
'metricModeKey_\x10%3.14159265358979323846264338327950288_\x10#2.71828182845904'
'5235360287471352662\x08\x08\x0f\x1c(?g\x8d\x00\x00\x00\x00\x00\x00\x01\x01\x00'
'\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
'\x00\x00\x00\x8e'

== pretty-printed calculator preferences
{'DisplayValue': '3.14159265358979323846264338327950288',
 'MemoryValue': '2.718281828459045235360287471352662',
 'TrigonometricModeKey': False}

Extra-Kredit

Das iPhone-Datenschutzcode geposted von Bédrune und Sigwald kann entschlüsseln die Schlüsselanhänger von einem Backup, einschließlich Spaß Dinge wie gespeicherte Wifi und Website-Passwörter:

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

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

Dieser Code funktioniert nicht mehr bei Backups von Telefonen mit dem neuesten iOS, aber nicht viel hat sich geändert ... lass einen Kommentar, wenn du willst, dass ich es tue den obigen Code aktualisieren, um gespeicherte Passwörter auszugeben;


84
2017-12-09 23:34



Tut mir leid, aber es könnte sogar komplizierter sein, mit pbkdf2, oder sogar eine Variation davon. Hören Sie sich die WWDC 2010-Sitzung # 209 an, die hauptsächlich über die Sicherheitsmaßnahmen in iOS 4 berichtet, aber auch kurz die separate Verschlüsselung von Backups und ihre Beziehung erwähnt.

Sie können sich ziemlich sicher sein, dass Sie das Passwort nicht einmal mit roher Gewalt entschlüsseln können.

Nehmen wir an, Sie möchten versuchen, Personen, die das Passwort kennen, zu ermöglichen, zu den Daten ihrer Backups zu gelangen.

Ich fürchte, es gibt keinen Weg, den eigentlichen Code in iTunes zu betrachten, um herauszufinden, welche Algos verwendet werden.

In den Newton-Tagen musste ich Daten von einem Programm entschlüsseln und konnte seine Entschlüsselungsfunktion direkt aufrufen (natürlich unter Kenntnis des Passworts), ohne seinen Algorithmus sogar unterlaufen zu müssen. Es ist leider nicht mehr so ​​einfach.

Ich bin mir sicher, dass es fähige Leute gibt, die den iTunes-Code zurückentwickeln können - Sie müssen nur Interesse wecken.

Theoretisch sollten Apples Algos so entworfen werden, dass die Daten immer noch sicher (d. H. Praktisch unzerbrechlich durch Brute-Force-Methoden) für jeden Angreifer sind, der die genaue Verschlüsselungsmethode kennt. Und in der WWDC-Sitzung 209 gingen sie ziemlich detailliert in die Details darüber, was sie tun, um dies zu erreichen. Vielleicht können Sie die Antworten direkt vom Sicherheitsteam von Apple erhalten, wenn Sie ihnen Ihre guten Absichten mitteilen. Schließlich sollten auch sie wissen, dass die Sicherheit durch Verschleierung nicht wirklich effizient ist. Versuchen Sie ihre Sicherheitsmailingliste. Selbst wenn sie nicht antworten, wird vielleicht jemand anderes, der stillschweigend auf der Liste steht, mit etwas Hilfe antworten.

Viel Glück!


5
2017-09-26 18:09



Ich habe es noch nicht ausprobiert, aber Elcomsoft hat ein Produkt veröffentlicht, von dem behauptet wird, dass es in der Lage ist, Backups für forensische Zwecke zu entschlüsseln. Vielleicht nicht so cool wie selbst eine Lösung zu entwickeln, aber es könnte schneller sein.

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


1
2017-09-24 13:21



Sie sollten sich eine Kopie von Erica Saduns mdhelper-Kommandozeilenprogramm (OS X binär & Quelle). Es unterstützt das Auflisten und Extrahieren der Inhalte von iPhone / iPod Touch-Backups, einschließlich Adressbuch- und SMS-Datenbanken und anderer Anwendungsmetadaten und -einstellungen.


-3
2017-10-01 13:13