Talihsiz bir iPhone kullanıcı tarafından onlara kendi iTunes yedeklerden veri geri yardımcı olmam istendi. Bu şifre bilinen olup olmadığını şifreli şifresiz zaman zaman kolay, ama değil.

Gibi, şifreleme düzenini şifreli zaman mddata ve mdinfo dosya üzerinde kullanılan anlamaya çalışıyorum. Herhangi bir sorun yoksa bu dosyaları okuma ve sağlam yapılı C# bunu yapmak için kütüphaneler. Eğer yardım etmek mümkün değilse, kullandığınız umurumda değil. Buradayım sonra bir ilke meselesi!)

Apple OS Kurumsal Dağıtım Kılavuzu "Cihaz yedekleme Şifrelemek iPhone seçerek şifreli formatta saklanabilecek" devlet "iPhone Cihaz özet olarak yedekleme seçeneği iTunes bölmesi. Dosyaları 256-bit anahtar ile AES128 kullanarak şifrelenir. Anahtarı güvenli bir şekilde iPhone Anahtarlık saklanır."

Bu çok iyi bir ipucu, ve iPhone üzerinde burada Stackoverflow üzerinde bazı iyi bilgi AES/Rijndael interoperability 128 olanıdır düşündüren var ve CBC modunda kullanılabilir.

Başka bir şaşırtmaca dışında, ve (IV) tuşu başlatma vektör/bir tuz gereklidir.

Anahtarın bir manipülasyon olduğunu düşünebilirler bir "yedek şifre" kullanıcı girmek için iTunes tarafından istendiğinde ve geçirilen "AppleMobileBackup.exe", yastıklı bir moda CBC tarafından dikte. Ancak, belirli bir başvuru için iPhone Anahtarlık, ben merak edip "yedek şifre" olmayabilir kullanılan bir şifre üzerinde bir X 509 sertifika ya da simetrik özel anahtar ve sertifika ya da özel anahtarın olabilir kullanılan anahtar. (AES ve iTunes şifrelemek/şifresini işlemi simetriktir.)

IV başka bir konudur, ve bir kaç şey olabilir. Belki de anahtarları hard-coded devices themselves içine iTunes içine, ya da biri.

Apple'ın yorum yukarıda anahtarı cihazın Anahtarlık hediye olduğunu gösteriyor, ancak bu o kadar da önemli değil bence. Bir şifreli bir yedekleme geri yükleme . ben^>farklıtüm bilgiler şifre çözme ilgili akla getiriyor cihaz, yedekleme ve iTunes yapılandırması varsa, ve bu cihazda sadece alakasız ve bu bağlamda değiştirilebilir nitelikte. Anahtarı nereye kadar iyi olabilir?

Yolları aşağıda Windows bir makineden listeledim ama hangisi hemen hemen aynı çok.

"\Application Data\Apple Computer\iTunes\itunesprefs.xml" a",". dict giriş Anahtarlık ile bir PList içerir\Roaming "\Programdata\apple\Kilitleme\09037027da8f4bdefdea97d706703ca034c88bab."bir PList içeriyor"", "","", tüm bunlar geçerli bir X 509 sertifikaları gibi görünüyor. RootCertificate HostCertificate DeviceCertificate plist Aynı dosya da asimetrik anahtarlar içeren görünüyor "" ve "HostPrivateKey" (benim okuma bu #7-zarflı) AMAÇ olabileceğini gösteriyor. RootPrivateKey Ayrıca, her yedekleme içinde "" ve "AuthData" bildirimde değerleri.AuthSignature var bu her dosya aşamalı olarak düzenleniyor olarak döndürülmüş gibi görünse plist dosyası, bir şeyler gerçekten oldukça kapsamlı yapılır sürece bir anahtar olarak kullanışlı değiller önerdi.

Şeyler var şifreli yedeklerden alma Veri düşündüren kolaydır yanıltıcı bir sürü şey var. Değil, ve bildiğim kadarıyla hiç yapılmadı. Bypassing or disabling yedekleme şifreleme tamamen başka bir konudur, ve yapmak için arıyorum ne değildir.

Bu böyle ayrı iPhone ya da bir şey kesmek değil. Buradayım sonra tüm verileri (fotoğraflar, vb. kişiler) ayıklamak için bir araçtır olanlar şifresiz elimden geldiği şifreli iTunes yedekleme. Yukarıdaki indir olduğum bilgi ile permütasyon her türlü denedim ama hiçbir şey işe yaramadı. Herhangi bir düşünce veya atlamış olabilirim teknikleri sevinirim.

Güvenlik araştırmacıları, Jean-Baptiste ve Jean Bédrune Sigwald Hack-in-the-box Amsterdam 2011 33**.

O zamandan beri, Apple iOS Security Whitepaperyayımladı anahtarları ve algoritmaları hakkında daha ayrıntılı bilgi ve Charlie Miller ve ark. var bu aynı bazı kapsayan iOS Hacker’s Handbook serbest nasıl moda bir yer.

Neyse ki, Bédrune ve Sigwald kaynaklı açık var iphone-dataprotection code. Yedekleme şifresini çözmek bu kadar basit. backup_tool komut çalıştırma:

$ hg clone https://code.google.com/p/iphone-dataprotection/
$ python iphone-dataprotection/python_scripts/backup_tool.py \
    ~/Library/Application\ Support/MobileSync/Backup/long-hex-string \
    outdir
Device Name : My iPhone
Display Name : My iPhone
Last Backup Date : 2012-12-09 16:00:18
IMEI : 565988269232005
Serial Number : LN1G2AIND69G
Product Type : iPhone4,1
Product Version : 6.0.1
iTunes Version : 11.0
Extract backup to outdir ? (y/n)
y
Backup is encrypted
Enter backup password :
*******************
Writing Documents/products/97266p_bifold_3.jpg
...
...
...
Writing Media/DCIM/103APPLE/IMG_3874.JPG
You can decrypt the keychain using the following command :
python keychain_tool.py -d outdir/keychain-backup.plist outdir/Manifest.plist

Şifreli iPhone yedekleme konusunda büyük bir şey değildir WiFi şifreleri gibi normal şifresiz yedekleri değil. Olarak iOS Security Whitepaper şifreli yedekleri ele daha fazla“,” çok Elma ok daha fazla düşünür güvenli olarak kabul edilir onları hassas bilgiler. Ve, backup_tool tamamlandıktan sonra yapabiliriz şifre hassas bilgileri düz metin olarak geri almak için kullanın

$ # You’ll need to install the M2Crypto library before keychain_tool
$ # will work. These commands may be all you need:
$ brew install swig
...
$ pip install --user M2Crypto
...
$ echo | python iphone-dataprotection/python_scripts/keychain_tool.py \
    -d outdir/keychain-backup.plist outdir/Manifest.plist | less -S

If you have key835 for device 14b826ee48c5ea8b617f62fe12040c2d09af6b46 enter it (in hex)
--------------------------------------------------------------------------------------
|                              Passwords                                             |
-----------------------------------------------------------------------------------
|Service           |Account          |Data           |Access group  |Protection class|
--------------------------------------------------------------------------------------
|AirPort           |Ed’s Coffee Shop |<3FrenchRoast  |apple         |AfterFirstUnlock|
...

Önemli bir uyarı: açıkçası, iOS şifre çözme cihaz yedekleme kendi şifreleme kaldırır. Gizliliğinizi korumak için ve güvenlik,gerekir sadece tüm disk şifreleme ile bir makine üzerinde bu komut dosyalarını çalıştırın.Bunu yaparken bir güvenlik uzmanı anahtarları korur yazılım yazmak mümkün mü bellek, örneğin kullanarak fonksiyonları ile VirtualLock() SecureZeroMemory() birçok diğer şeyler arasında, bu Python komut dizeleri şifreleme anahtarları ve şifreleri sizin için saklar çöp toplama Python ile. Bu gizli anahtarlar ve şifreler demektir takas alanını içine sızıntı onlar nereden bir süre için RAM içinde yaşayacaktır. dosya ve bir düşman onları kurtarmak için nerede diske. Bu tamamen yendi şifreli bir yedekleme sahip nokta.

Şimdi Eğer istiyorsanız, ne açık kaynak yedekleme şifresini çözmek için kod, ama biliyorsun bu kodu nasıl çalıştığını bilmek, kendiniz yazabilirsiniz?

iOS Security Whitepaper temel kavramlarını açıklar başına dosya anahtarları, koruma sınıfları, koruma sınıfı anahtarları ve keybags benden daha iyi. Eğer zaten bu aşina iseniz, birkaç tane al dakika sayfa 6-12 okuyacak.

Şimdi iOS her dosya kendi rastgele şifreli olduğunu biliyorsun her dosya şifreleme anahtarının koruma sınıfına ait, ve her dosya şifreleme anahtarları dosya sistemi meta verileri, sarılı saklanır koruma sınıfı anahtarı.

Şifrelenmiş yedeklemeler, sadece dosya içeriğini şifrelenir. Dosya içindekiler şifresiz yedekleri aynı karma dosya altında saklanır meta şifresiz ve aynı biçimde tartışıldı How to parse the Manifest.mbdb file in an iOS 4.0 iTunes Backup. Koruma sınıfı anahtarları şifre şifreli keybag içinde olan Metadata.plist ve sınıf şifreli dosya başına şifreleme anahtarları meta saklanır.

Şifresini çözmek için:

1. Kod çözme keybag BackupKeyBag giriş içinde saklı Manifest.plist. Bu yapı üst düzey bir bakış verilmiş. whitepaper sayfa 19. iPhone Wiki açıklar ikili format: 4 baytlık bir dize türü alanında, 4 baytlık bir büyük-indian uzunluk alan ve değeri kendisi.

   Önemli değerleri PBKDF2 ITERtebrikler ** 15, ve sonra her bir koruma için CLS, WPKY anahtar tamamladı.

2. Örnek olarak aşağıda "test" yedekleme parola kullanarak, 32 baytlık bir anahtar türetmek doğru PBKDF2 tuz ve numarasını kullanarak yineleme. Aç her sarılmış anahtarına göre RFC 3394.

3. Görülmesi gereken her dosya için, sınıf şifreli başına dosya şifreleme olsun anahtar ve koruma sınıfı .mbdb dosyasındaki meta kodu. Şifreleme anahtarı dört bayt ilgili bitiminden sonra başlar .mbdb dosyasında karma ve koruma sınıfı numarası bayt. dosya uzunluğu sonunda.

   Sonra, son şifre çözme anahtarı türetmek ile açılması ile sınıf anahtar yedekleme parolası ile açtı. Bu decrypt sıfır bir IV ile CBC mod kullanarak AES dosya.

Çalıştırılabilir, kaynak kodu şeklinde, burada hesap şifresini çözmek için nasıl tercihler data/encrypted şifreli bir iPhone yedekleme ile dosya test şifre:

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

# default to True to avoid leaking secrets
ANONYMIZE_OUTPUT = True

import PBKDF2 # http://iphone-dataprotection.googlecode.com/hg-history/tip/python_scripts/crypto/PBKDF2.py
import bplist # https://github.com/farcaller/bplist-python/raw/master/bplist.py
import Crypto.Cipher.AES # https://www.dlitz.net/software/pycrypto/

import hashlib
import os.path
import pprint
import sys

BACKUP_DIR = "data/encrypted"

def main():
    with open(os.path.join(BACKUP_DIR, 'Manifest.plist'), 'rb') as infile:
        manifest_plist = bplist.BPlistReader.plistWithString(infile.read())
    keybag = Keybag(manifest_plist['BackupKeyBag'])
    # the actual keys are unknown, but the wrapped keys are known
    keybag.printClassKeys()
    if not keybag.unlockWithPasscode('test'):
        raise Exception('Could not unlock keybag; bad password?')
    # now the keys are known too
    keybag.printClassKeys()

    for item in process_mbdb_file(
            os.path.join(BACKUP_DIR, 'Manifest.mbdb')).values():
        filename = item['filename']
        if not filename.endswith('calculator.plist'):
            continue
        encryption_key = item['unknown1'][4:]
        protection_class = item['flag']
        backup_filename = os.path.join(
            BACKUP_DIR,
            hashlib.sha1(item['domain']   '-'   item['filename']).hexdigest())
        with open(backup_filename, 'rb') as infile:
            data = infile.read()
        print '== encrypted data:'
        print wrap(data)
        print

        key = keybag.unwrapKeyForClass(protection_class, encryption_key)
        # truncate to actual length, because encryption may introduce padding
        decrypted_data = AESdecryptCBC(data, key)[:item['filelen']]
        print '== decrypted data:'
        print wrap(decrypted_data)
        print

        print '== pretty-printed calculator preferences'
        pprint.pprint(bplist.BPlistReader.plistWithString(decrypted_data))

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

import struct

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):
        passcodekey = PBKDF2.PBKDF2(passcode, self.attrs["SALT"],
                                    iterations=self.attrs["ITER"]).read(32)
        for classkey in self.classKeys.values():
            if not classkey.has_key("WPKY"):
                continue
            k = classkey["WPKY"]
            if classkey["WRAP"] & WRAP_PASSCODE:
                k = AESUnwrap(passcodekey, 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 iterations: %d, iv=%s" % (
            self.attrs["ITER"], anonymize(self.attrs["SALT"].encode('hex')))
        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

##
# this .mbdb-parsing code is from http://stackoverflow.com/q/3085153/14558:

def getint(data, offset, intsize):
    """Retrieve an integer (big-endian) and new offset from the current offset"""
    value = 0
    while intsize > 0:
        value = (value<<8)   ord(data[offset])
        offset = offset   1
        intsize = intsize - 1
    return value, offset

def getstring(data, offset):
    """Retrieve a string and new offset from the current offset into the data"""
    if data[offset] == chr(0xFF) and data[offset 1] == chr(0xFF):
        return '', offset 2 # Blank string
    length, offset = getint(data, offset, 2) # 2-byte length
    value = data[offset:offset length]
    return value, (offset   length)

def process_mbdb_file(filename):
    mbdb = {} # Map offset of info in this file => file info
    data = open(filename).read()
    if data[0:4] != "mbdb": raise Exception("This does not look like an MBDB file")
    offset = 4
    offset = offset   2 # value x05 x00, not sure what this is
    while offset < len(data):
        fileinfo = {}
        fileinfo['start_offset'] = offset
        fileinfo['domain'], offset = getstring(data, offset)
        fileinfo['filename'], offset = getstring(data, offset)
        fileinfo['linktarget'], offset = getstring(data, offset)
        fileinfo['datahash'], offset = getstring(data, offset)
        fileinfo['unknown1'], offset = getstring(data, offset)
        fileinfo['mode'], offset = getint(data, offset, 2)
        fileinfo['unknown2'], offset = getint(data, offset, 4)
        fileinfo['unknown3'], offset = getint(data, offset, 4)
        fileinfo['userid'], offset = getint(data, offset, 4)
        fileinfo['groupid'], offset = getint(data, offset, 4)
        fileinfo['mtime'], offset = getint(data, offset, 4)
        fileinfo['atime'], offset = getint(data, offset, 4)
        fileinfo['ctime'], offset = getint(data, offset, 4)
        fileinfo['filelen'], offset = getint(data, offset, 8)
        fileinfo['flag'], offset = getint(data, offset, 1)
        fileinfo['numprops'], offset = getint(data, offset, 1)
        fileinfo['properties'] = {}
        for ii in range(fileinfo['numprops']):
            propname, offset = getstring(data, offset)
            propval, offset = getstring(data, offset)
            fileinfo['properties'][propname] = propval
        mbdb[fileinfo['start_offset']] = fileinfo
    return mbdb

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

if ANONYMIZE_OUTPUT:
    memo = {}
    def anonymize(s):
        global memo
        if s in memo:
            return memo[s]
        import random
        import string
        r = random.Random(0)
        possible_alphabets = [
            string.digits,
            string.digits   'abcdef',
            "".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([r.choice(alphabet) for i in range(len(s))])
        memo[s] = ret
        return ret
else:
    def anonymize(s): 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)

if __name__ == '__main__':
    main()

Sonra bu çıktı baskılar

== Keybag
Keybag type: Backup keybag (1)
Keybag version: 3
Keybag iterations: 10000, iv=dc6486c479e84c94efce4bea7169ef7d4c80b6da
Keybag UUID: dc6486c479e84c94efce4bea7169ef7d
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Class                                                WRAP Type       Key                                                              WPKY                                                             Public key
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
NSFileProtectionComplete                             2    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
NSFileProtectionCompleteUnlessOpen                   2    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
NSFileProtectionCompleteUntilFirstUserAuthentication 2    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
NSFileProtectionNone                                 2    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
NSFileProtectionRecovery?                            3    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed

kSecAttrAccessibleWhenUnlocked                       2    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleAfterFirstUnlock                   2    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleAlways                             2    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleWhenUnlockedThisDeviceOnly         3    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly     3    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleAlwaysThisDeviceOnly               3    AES                                                                         dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed

== Keybag
Keybag type: Backup keybag (1)
Keybag version: 3
Keybag iterations: 10000, iv=dc6486c479e84c94efce4bea7169ef7d4c80b6da
Keybag UUID: dc6486c479e84c94efce4bea7169ef7d
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Class                                                WRAP Type       Key                                                              WPKY                                                             Public key
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
NSFileProtectionComplete                             2    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
NSFileProtectionCompleteUnlessOpen                   2    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
NSFileProtectionCompleteUntilFirstUserAuthentication 2    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
NSFileProtectionNone                                 2    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
NSFileProtectionRecovery?                            3    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed

kSecAttrAccessibleWhenUnlocked                       2    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleAfterFirstUnlock                   2    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleAlways                             2    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleWhenUnlockedThisDeviceOnly         3    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly     3    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed
kSecAttrAccessibleAlwaysThisDeviceOnly               3    AES        dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9 dc6486c479e84c94efce4bea7169ef7d4c80b6da07d35d393fc7158e18b8d8f9979694329a71ceed

== encrypted data:
"\xcc\x95U\xbf\xbc\x03%\xff\xe3m\x9f\xdb=~}\xbb\xa1\x8cp\xf4\xe2\xa2\x81G8\xf7"
"\x8f\xc4\x8aI\xf4]\x0e\xca\xd4\xb8\xb6\xfb'\x07\x9e\xdc,\xfe\xf5\xd7a\ry\xd8B"
"\xe4(\xbb56\xbd\x82/1\x86\xaf\xe2\xeac\xccu\xc0\xa6\xac5\xfa\x1d\xf7\xbf#HVXq"
"\xe3\x99`nW\xbb \xc9\x9e\xf2\x1d\xbf\x87\x95\\\xfd\x1f oW\xcb\x0bE\x98\x02\x86"
"\x03\xfe\x90aL\xad(\xd0\x01D\xb5;\x86\x98\xcc\xf9\x0b\x9cLQ8\xaf\xac\xae\x04"
"\x1cSpF\x00'R\\\xd7\xcb\xefx\xa4`\xcc\xb6\xc7\x94\x98\x91\x11Z\xb1_\xda\xa1"
"\x8a\xce\xd1"

== decrypted data:
'bplist00\xd3\x01\x02\x03\x04\x05\x06_\x10\x14TrigonometricModeKey[MemoryValue'
'\\DisplayValue\x08_\x10(0.41666666666666666666666666666666666666U57.84\x08\x0f'
'&2?@k\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\x00q'

== pretty-printed calculator preferences
{'DisplayValue': '57.84',
 'MemoryValue': '0.41666666666666666666666666666666666666',
 'TrigonometricModeKey': False}

iphone-dataprotection source codebakın bu işlemez durumda, eliptik eğri anahtarları gibi. Unutmayın iphone-dataprotection sadece yedekleri daha, gibi işler cihaz üzerinde veri koruma çatlama ve özel ramdisks kullanarak.