Difference between revisions of "KBAG"

From The iPhone Wiki
Jump to: navigation, search
m
m (dd skips and counts vary depending on the file; next paragraph explains how also)
 
(20 intermediate revisions by 7 users not shown)
Line 1: Line 1:
  +
Apple's [[IMG3 File Format|IMG3]] and [[IMG4 File Format|IMG4]] security scheme uses a data format called a '''KBAG'''. At the bottom of a firmware file, you will see something that will, on the ASCII side of your hex editor, say "GABK", which, as ARM is [[wikipedia:little-endian|little-endian]] based, is "KBAG" flipped. Look on the hex side and you will see the KBAG according to this format:
==Explanation==
 
  +
In Apple's new [[IMG3 File Format|IMG3]] security scheme, they have used something called a KBAG. At the bottom of a firmware file, you will see something that will, on the ASCII side of your hex editor, see "GABK", which is "KBAG" flipped. Look on the hex side and you will the KBAG according to this format:
 
  +
== How it works ==
  +
It boils down to using the [[GID Key]] to decrypt <code>encIV</code> and <code>encKey</code>, then using that key and IV to decrypt the DATA section of the file (the code itself).
  +
  +
Because of the circumstances with the [[IMG3 File Format]], the kernel never needs to even touch the [[GID Key]] anymore, as its job is to just flash the image to the [[NOR]] as is, with container and all.
  +
  +
To grab the KBAG for img3 files, you'd run <code>xpwntool /path/to/img3/ /dev/null</code>.
  +
  +
This is different with img4 files. For these, you can use [https://github.com/xerub/img4lib img4lib] and run the following command: <code>img4 -i /path/to/image.im4p -b</code>.
   
 
==KBAG Format==
 
==KBAG Format==
 
===KBAG128===
 
===KBAG128===
  +
typedef struct Unparsed_KBAG_AES128 {
<pre>
 
  +
uint32_t magic; // string with bytes flipped ("KBAG" in little endian)
typedef struct Unparsed_KBAG_128 {
 
int magic; // string with bits flipped = "KBAG" (magic = 0x4741424B)
+
uint32_t fullSize; // size of KBAG from beyond that point to the end of it
int tagFullSize; // size of KBAG from beyond that point to the end of it
+
uint32_t tagDataSize; // size of KBAG without this 0xC header
int tagDataSize; // size of KBAG without this 0xC header
+
uint32_t cryptState; // 1 if the key and IV in the KBAG are encrypted with the [[GID Key]]
int cryptState; // 1 if the key and IV in the KBAG are encrypted with the [[GID-Key]]
+
// 2 if the key and IV are encrypted with the Development [[GID Key]], used when the [[Security Fusings|processor is demoted.]]
// 2 is used with a second KBAG for the [[S5L8920]], use is unknown.
+
uint32_t aesType; // 0x80 = aes128 / 0xc0 = aes192 / 0x100 = aes256
int aesType; // 0x80 = aes128 / 0xc0 = aes192 / 0x100 = aes256
+
uint8_t encIV[16]; // IV for the firmware file, encrypted with the [[GID Key]]
char EncIV[16]; // IV for the firmware file, encrypted with the [[GID-Key]]
+
uint8_t encKey[16]; // Key for the firmware file, encrypted with the [[GID Key]]
  +
} UnparsedKbagAes128_t;
char EncKey[16]; // Key for the firmware file, encrypted with the [[GID-Key]]
 
} Unparsed_KBAG_AES128;
 
</pre>
 
   
 
===KBAG192===
 
===KBAG192===
  +
typedef struct Unparsed_KBAG_AES192 {
<pre>
 
  +
uint32_t magic; // string with bytes flipped ("KBAG" in little endian)
typedef struct Unparsed_KBAG_AES192 {
 
int magic; // string with bits flipped = "KBAG" (magic = 0x4741424B)
+
uint32_t fullSize; // size of KBAG from beyond that point to the end of it
int fullSize; // size of KBAG from beyond that point to the end of it
+
uint32_t tagDataSize; // size of KBAG without this 0xC header
int tagDataSize; // size of KBAG without this 0xC header
+
uint32_t cryptState; // 1 if the key and IV in the KBAG are encrypted with the [[GID Key]]
int cryptState; // 1 if the key and IV in the KBAG are encrypted with the [[GID-Key]]
+
// 2 if the key and IV are encrypted with the Development [[GID Key]], used when the [[Security Fusings|processor is demoted.]]
// 2 is used with a second KBAG for the [[S5L8920]], use is unknown.
+
uint32_t aesType; // 0x80 = aes128 / 0xc0 = aes192 / 0x100 = aes256
int aesType; // 0x80 = aes128 / 0xc0 = aes192 / 0x100 = aes256
+
uint8_t encIV[16]; // IV for the firmware file, encrypted with the [[GID Key]]
char EncIV[16]; // IV for the firmware file, encrypted with the [[GID-Key]]
+
uint8_t encKey[24]; // Key for the firmware file, encrypted with the [[GID Key]]
  +
} UnparsedKbagAes192_t;
char EncKey[24]; // Key for the firmware file, encrypted with the [[GID-Key]]
 
} Unparsed_KBAG_AES192;
 
</pre>
 
   
 
===KBAG256===
 
===KBAG256===
  +
typedef struct Unparsed_KBAG_256 {
<pre>
 
  +
uint32_t magic; // string with bytes flipped ("KBAG" in little endian)
typedef struct Unparsed_KBAG_256 {
 
int magic; // string with bits flipped = "KBAG" (magic = 0x4741424B)
+
uint32_t fullSize; // size of KBAG from beyond that point to the end of it
int fullSize; // size of KBAG from beyond that point to the end of it
+
uint32_t tagDataSize; // size of KBAG without this 0xC header
int tagDataSize; // size of KBAG without this 0xC header
+
uint32_t cryptState; // 1 if the key and IV in the KBAG are encrypted with the [[GID Key]]
int cryptState; // 1 if the key and IV in the KBAG are encrypted with the [[GID-Key]]
+
// 2 if the key and IV are encrypted with the Development [[GID Key]], used when the [[Security Fusings|processor is demoted.]]
// 2 is used with a second KBAG for the [[S5L8920]], use is unknown.
+
uint32_t aesType; // 0x80 = aes128 / 0xc0 = aes192 / 0x100 = aes256
  +
uint8_t encIV[16]; // IV for the firmware file, encrypted with the [[GID Key]]
int aesType; // 0x80 = aes-128, 0xc0 = aes-192, 0x100 = aes256
 
  +
} UnparsedKbagAes256_t;
char EncKey[32]; // Key for the firmware file, encrypted with the [[GID-Key]]
 
char EncIV[16]; // IV for the firmware file, encrypted with the [[GID-Key]]
+
uint8_t encKey[32]; // Key for the firmware file, encrypted with the [[GID Key]]
} Unparsed_KBAG_AES256;
 
</pre>
 
 
==How it works==
 
Basically, it just boils down to using the [[GID-key]] to decrypt Enc_IV and Enc_Key, then using that key and IV to decrypt the DATA section of the file (the code itself).
 
 
As an interesting side note, because of the circumstances with the [[IMG3 File Format]], the kernel never needs to even touch the [[GID-key]] anymore, as it's job is to just flash the image to the [[NOR]] as is, with container and all.
 
   
in order to decrypt the [[KBAG]] you need to remove them from [[IMG3 File Format|IMG3]] using this command <code>dd if=IMG3_FILE bs=1 skip=4741424B count=0x70</code>
 
   
 
[[Category:Firmware Tags]]
 
[[Category:Firmware Tags]]
[[Category:Firmware Parsing]]
 

Latest revision as of 18:55, 29 March 2022

Apple's IMG3 and IMG4 security scheme uses a data format called a KBAG. At the bottom of a firmware file, you will see something that will, on the ASCII side of your hex editor, say "GABK", which, as ARM is little-endian based, is "KBAG" flipped. Look on the hex side and you will see the KBAG according to this format:

How it works

It boils down to using the GID Key to decrypt encIV and encKey, then using that key and IV to decrypt the DATA section of the file (the code itself).

Because of the circumstances with the IMG3 File Format, the kernel never needs to even touch the GID Key anymore, as its job is to just flash the image to the NOR as is, with container and all.

To grab the KBAG for img3 files, you'd run xpwntool /path/to/img3/ /dev/null.

This is different with img4 files. For these, you can use img4lib and run the following command: img4 -i /path/to/image.im4p -b.

KBAG Format

KBAG128

typedef struct Unparsed_KBAG_AES128 {
     uint32_t magic;       // string with bytes flipped ("KBAG" in little endian)
     uint32_t fullSize;    // size of KBAG from beyond that point to the end of it
     uint32_t tagDataSize; // size of KBAG without this 0xC header
     uint32_t cryptState;  // 1 if the key and IV in the KBAG are encrypted with the GID Key
                           // 2 if the key and IV are encrypted with the Development GID Key, used when the processor is demoted.
     uint32_t aesType;     // 0x80 = aes128 / 0xc0 = aes192 / 0x100 = aes256
     uint8_t encIV[16];    // IV for the firmware file, encrypted with the GID Key
     uint8_t encKey[16];   // Key for the firmware file, encrypted with the GID Key
} UnparsedKbagAes128_t;

KBAG192

typedef struct Unparsed_KBAG_AES192 {
     uint32_t magic;       // string with bytes flipped ("KBAG" in little endian)
     uint32_t fullSize;    // size of KBAG from beyond that point to the end of it
     uint32_t tagDataSize; // size of KBAG without this 0xC header
     uint32_t cryptState;  // 1 if the key and IV in the KBAG are encrypted with the GID Key
                           // 2 if the key and IV are encrypted with the Development GID Key, used when the processor is demoted.
     uint32_t aesType;     // 0x80 = aes128 / 0xc0 = aes192 / 0x100 = aes256
     uint8_t encIV[16];    // IV for the firmware file, encrypted with the GID Key
     uint8_t encKey[24];   // Key for the firmware file, encrypted with the GID Key
} UnparsedKbagAes192_t;

KBAG256

typedef struct Unparsed_KBAG_256 {
     uint32_t magic;       // string with bytes flipped ("KBAG" in little endian)
     uint32_t fullSize;    // size of KBAG from beyond that point to the end of it
     uint32_t tagDataSize; // size of KBAG without this 0xC header
     uint32_t cryptState;  // 1 if the key and IV in the KBAG are encrypted with the GID Key
                           // 2 if the key and IV are encrypted with the Development GID Key, used when the processor is demoted.
     uint32_t aesType;     // 0x80 = aes128 / 0xc0 = aes192 / 0x100 = aes256
     uint8_t encIV[16];    // IV for the firmware file, encrypted with the GID Key
     uint8_t encKey[32];   // Key for the firmware file, encrypted with the GID Key
} UnparsedKbagAes256_t;