Pregunta ¿Cómo descifrar una copia de seguridad de Apple iTunes iPhone encriptada?


Algunos desafortunados usuarios de iPhone me han pedido que los ayude a restaurar los datos de sus copias de seguridad de iTunes. Esto es fácil cuando no están encriptados, pero no cuando están encriptados, se sepa o no la contraseña.

Como tal, estoy tratando de descubrir el esquema de encriptación utilizado en los archivos mddata y mdinfo cuando está encriptado. No tengo problemas para leer estos archivos de lo contrario, y he construido algunas robustas bibliotecas C # para hacerlo. (Si puede ayudar, no me importa qué idioma use. ¡Es el principio que busco aquí!)

La "Guía de implementación de Apple OS iPhone Enterprise" indica que "las copias de seguridad de los dispositivos se pueden almacenar en formato cifrado seleccionando Encrypt iPhone Opción de copia de seguridad en el panel de resumen del dispositivo de iTunes. Los archivos se cifran utilizando AES128 con una clave de 256 bits. La clave se almacena de forma segura en el llavero de iPhone ".

Esa es una buena pista, y hay buena información aquí en Stackoverflow en iPhone Interoperabilidad AES / Rijndael sugiriendo que se puede utilizar un tamaño de clave de 128 y el modo CBC.

Aparte de cualquier otra ofuscación, se requiere una clave y un vector de inicialización (IV) / sal.

Uno podría suponer que la clave es una manipulación de la "contraseña de respaldo" que los usuarios deben ingresar por iTunes y pasar a "AppleMobileBackup.exe", rellenado de una manera dictada por CBC. Sin embargo, dada la referencia al llavero iPhone, me pregunto si la" contraseña de copia de seguridad "podría no utilizarse como una contraseña en un certificado X509 o clave privada simétrica, y que el certificado o privado la clave misma se podría usar como la clave. (AES y el proceso de cifrado / descifrado de iTunes es simétrico).

El IV es otro asunto, y podría ser algunas cosas. Quizás es una de las claves codificado en iTunes, o en el dispositivos mismos.

Aunque el comentario de Apple anterior sugiere que la clave está presente en el llavero del dispositivo, creo que esto no es tan importante. Uno puede restaurar una copia de seguridad encriptada a un diferente dispositivo, que sugiere que toda la información relevante para el descifrado está presente en la copia de seguridad y en la configuración de iTunes, y que cualquier elemento únicamente en el dispositivo es irrelevante y reemplazable en este contexto. Entonces, ¿dónde podría estar la llave?

He enumerado las rutas a continuación desde una máquina con Windows, pero es mucho más que cualquier sistema operativo que usemos.

El "\ appdata \ Roaming \ Apple Computer \ iTunes \ itunesprefs.xml" contiene un PList con una entrada dict "Keychain" en él. El "\ programdata \ apple \ Lockdown \ 09037027da8f4bdefdea97d706703ca034c88bab.plist" contiene un PList con "DeviceCertificate", "HostCertificate" y "RootCertificate", todos los cuales parecen ser certificados X509 válidos. El mismo archivo también parece contener claves asimétricas "RootPrivateKey" y "HostPrivateKey" (mi lectura sugiere que estos pueden ser PKCS # 7-envueltos). Además, dentro de cada copia de seguridad hay valores de "AuthSignature" y "AuthData" en el archivo Manifest.plist, aunque estos parecen rotarse ya que cada archivo recibe una copia de seguridad incremental, sugirieron que no son tan útiles como clave, a menos que haya algo realmente bastante complicado está siendo hecho.

Hay muchas cosas engañosas que sugieren que obtener datos de copias de seguridad encriptadas es fácil. No lo es, y que yo sepa, no se ha hecho. Anulando o deshabilitando el cifrado de la copia de seguridad es otro asunto completamente diferente, y no es lo que estoy buscando hacer.

Esto no se trata de piratear el iPhone o algo por el estilo. Todo lo que busco aquí es un medio para extraer datos (fotos, contactos, etc.) de las copias de seguridad cifradas de iTunes, ya que puedo descifrarlas. He intentado todo tipo de permutaciones con la información que he presentado anteriormente, pero no conseguí nada. Apreciaría cualquier pensamiento o técnica que podría haber perdido.


76
2017-09-30 14:07


origen


Respuestas:


Los investigadores de seguridad Jean-Baptiste Bédrune y Jean Sigwald presentado cómo para hacer esto a Hack-in-the-box Amsterdam 2011.

Desde entonces, Apple ha lanzado un Libro blanco de seguridad de iOS con más detalles sobre claves y algoritmos, y Charlie Miller et al. tener lanzado el Manual del hacker de iOS, que cubre algunos de los mismos suelo de una manera práctica. Cuando iOS 10 apareció por primera vez hubo cambios al formato de copia de seguridad que Apple no publicó al principio, pero varios gente ingeniería inversa de los cambios de formato.

Las copias de seguridad cifradas son geniales

Lo mejor de las copias de seguridad de iPhone encriptadas es que contienen cosas como contraseñas WiFi que no están en copias de seguridad no encriptadas regulares. Como discutido en el Libro blanco de seguridad de iOS, copias de seguridad encriptadas se consideran más "seguros", por lo que Apple considera que está bien incluir más información sensible en ellos.

Una advertencia importante: obviamente, descifrar la copia de seguridad de su dispositivo iOS elimina su cifrado. Para proteger su privacidad y seguridad, debieras solo ejecute estos scripts en una máquina con encriptación de disco completo. Mientras es posible que un experto en seguridad escriba software que proteja las claves en memoria, p. mediante el uso de funciones como VirtualLock() y SecureZeroMemory() entre muchas otras cosas, estos Los scripts de Python almacenarán sus claves de cifrado y contraseñas en cadenas para ser recogido por basura por Python. Esto significa tus claves secretas y contraseñas vivirá en RAM por un tiempo, de donde se filtrará en su intercambio archivo y en su disco, donde un adversario puede recuperarlos. Esta derrota por completo el punto de tener una copia de seguridad encriptada.

Cómo descifrar copias de seguridad: en teoría

los Libro blanco de seguridad de iOS explica los conceptos fundamentales de claves por archivo, clases de protección, claves de clase de protección y bolsas de teclado mejor que yo. Si aún no está familiarizado con estos, tome algunos minutos para leer las partes relevantes.

Ahora sabes que cada archivo en iOS está encriptado con su propio código aleatorio clave de cifrado por archivo, pertenece a una clase de protección, y el archivo por archivo las claves de cifrado se almacenan en los metadatos del sistema de archivos, envueltos en clave de clase de protección.

Para descifrar:

  1. Decodifica la bolsa de claves almacenada en el BackupKeyBag entrada de Manifest.plist. Una descripción general de alto nivel de esta estructura se da en el papel blanco. los iPhone Wiki describe el formato binario: un campo de tipo de cadena de 4 bytes, un 4-byte campo de longitud de big-endian, y luego el valor en sí mismo.

    Los valores importantes son el PBKDF2 ITERaciones y SALT, el doble sal de protección DPSL y cuenta de iteración DPICy luego para cada proteccion CLS, el WPKY llave envuelta.

  2. Con la contraseña de respaldo, obtenga una clave de 32 bytes con el PBKDF2 correcto sal y número de iteraciones. Primero use una ronda SHA256 con DPSL y DPIC, luego una ronda SHA1 con ITER y SALT.

    Desenvuelva cada llave envuelta de acuerdo a RFC 3394.

  3. Descifre la base de datos de manifiesto tirando de la clase de protección de 4 bytes y la clave más larga del ManifestKey en Manifest.plisty desenvolverlo. Ahora tienes un Base de datos SQLite con todos los metadatos de archivos.

  4. Para cada archivo de interés, obtenga el cifrado por archivo cifrado por clase clave y código de clase de protección mirando en el Files.file base de datos columna para un plist binario que contiene EncryptionKey y ProtectionClass entradas. Pele la etiqueta inicial de cuatro bytes de longitud EncryptionKey antes de usar.

    Luego, obtenga la clave de descifrado final desenvuélvala con la clase clave que se desenvolvió con la contraseña de respaldo. Luego descifra el archivo usando AES en modo CBC con un cero IV.

Cómo descifrar copias de seguridad: en la práctica

En forma de código fuente ejecutable, aquí está cómo descifrar la calculadora archivo de preferencias de una copia de seguridad de iPhone encriptada:

#!/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()

Que luego imprime esta salida:

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}

Crédito adicional

los código de protección de datos de iphone publicado por Bédrune y Sigwald puede descifrar el llavero desde una copia de seguridad, incluyendo cosas divertidas como wifi guardado y contraseñas del sitio 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|
...

Ese código ya no funciona en las copias de seguridad de los teléfonos con el último iOS, pero no todo ha cambiado mucho ... deja un comentario si quieres que lo haga actualice el código anterior para volcar también las contraseñas guardadas; P


84
2017-12-09 23:34



Lo sentimos, pero podría ser incluso más complicado, involucrando pbkdf2, o incluso una variación de este. Escuche la sesión # 209 de la WWDC 2010, que habla principalmente sobre las medidas de seguridad en iOS 4, pero también menciona brevemente el cifrado por separado de las copias de seguridad y cómo están relacionadas.

Puede estar bastante seguro de que, sin conocer la contraseña, no hay forma de que pueda descifrarla, incluso mediante la fuerza bruta.

Supongamos que desea intentar habilitar a las personas que CONOZCAN la contraseña para acceder a los datos de sus copias de seguridad.

Me temo que no hay forma de evitar mirar el código real en iTunes para descubrir qué algos se emplean.

En los días de Newton, tuve que desencriptar los datos de un programa y pude llamar su función de descifrado directamente (conociendo la contraseña, por supuesto) sin la necesidad de descifrar su algoritmo. Ya no es tan fácil, desafortunadamente.

Estoy seguro de que hay gente capacitada que podría aplicar ingeniería inversa al código de iTunes, solo tienes que interesarlos.

En teoría, los algos de Apple deberían diseñarse de forma que los datos permanezcan seguros (es decir, prácticamente irrompibles con los métodos de fuerza bruta) para cualquier atacante que conozca el método de cifrado exacto. Y en la sesión 209 de WWDC, profundizaron en los detalles sobre lo que hacen para lograr esto. Quizás puedas obtener respuestas directamente del equipo de seguridad de Apple si les dices tus buenas intenciones. Después de todo, incluso ellos deberían saber que la seguridad por ofuscación no es realmente eficiente. Prueba su lista de correo de seguridad. Incluso si no responden, tal vez alguien más en silencio en la lista responderá con algo de ayuda.

¡Buena suerte!


5
2017-09-26 18:09



No lo he probado, pero Elcomsoft lanzó un producto que según ellos es capaz de descifrar copias de seguridad, para fines forenses. Tal vez no sea tan genial como diseñar una solución, pero podría ser más rápido.

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


1
2017-09-24 13:21



Debes obtener una copia de la utilidad de línea de comandos mdhelper de Erica Sadun (OS X binario & fuente) Admite la inclusión y extracción de los contenidos de las copias de seguridad de iPhone / iPod Touch, incluidas las libretas de direcciones y SMS, y otros metadatos y configuraciones de la aplicación.


-3
2017-10-01 13:13