From 4c6356122422f59f831db86ae4ec3c5e4a5ce766 Mon Sep 17 00:00:00 2001 From: Michael Scire Date: Fri, 19 May 2017 08:34:50 -0700 Subject: [PATCH] ctrtool: Add support for inline decryption --- ctrtool/aes_keygen.c | 127 ++++++++++++++++++++++++++++++++++ ctrtool/aes_keygen.h | 8 +++ ctrtool/cia.c | 4 +- ctrtool/exefs.c | 34 ++++------ ctrtool/exefs.h | 3 +- ctrtool/exheader.c | 18 ----- ctrtool/exheader.h | 1 - ctrtool/keyset.cpp | 141 +++++++++++++++++++++++++++----------- ctrtool/keyset.h | 22 +++--- ctrtool/main.c | 28 ++++++-- ctrtool/ncch.c | 157 ++++++++++++++++++++++++++++++++++++------- ctrtool/ncch.h | 15 +++++ ctrtool/settings.c | 57 ++++++++++------ ctrtool/settings.h | 8 ++- ctrtool/tik.c | 24 +++++-- ctrtool/tik.h | 2 +- ctrtool/types.h | 1 + 17 files changed, 502 insertions(+), 148 deletions(-) create mode 100644 ctrtool/aes_keygen.c create mode 100644 ctrtool/aes_keygen.h diff --git a/ctrtool/aes_keygen.c b/ctrtool/aes_keygen.c new file mode 100644 index 0000000..d8bda85 --- /dev/null +++ b/ctrtool/aes_keygen.c @@ -0,0 +1,127 @@ +#include "aes_keygen.h" + +// 128bit wrap-around math +int32_t wrap_index(int32_t i) +{ + return i < 0 ? ((i % 16) + 16) % 16 : (i > 15 ? i % 16 : i); +} + +void n128_rrot(const uint8_t *in, uint32_t rot, uint8_t *out) +{ + uint32_t bit_shift, byte_shift; + + rot = rot % 128; + byte_shift = rot / 8; + bit_shift = rot % 8; + + for (int32_t i = 0; i < 16; i++) { + out[i] = (in[wrap_index(i - byte_shift)] >> bit_shift) | (in[wrap_index(i - byte_shift - 1)] << (8 - bit_shift)); + } + +} + +void n128_lrot(const uint8_t *in, uint32_t rot, uint8_t *out) +{ + uint32_t bit_shift, byte_shift; + + rot = rot % 128; + byte_shift = rot / 8; + bit_shift = rot % 8; + + for (int32_t i = 0; i < 16; i++) { + out[i] = (in[wrap_index(i + byte_shift)] << bit_shift) | (in[wrap_index(i + byte_shift + 1)] >> (8 - bit_shift)); + } +} + +/* out = a + b +*/ +void n128_add(const uint8_t *a, const uint8_t *b, uint8_t *out) +{ + uint8_t carry = 0; + uint32_t sum = 0; + + for (int i = 15; i >= 0; i--) { + sum = a[i] + b[i] + carry; + carry = sum >> 8; + out[i] = sum & 0xff; + } + + while (carry != 0) { + for (int i = 15; i >= 0; i--) { + sum = out[i] + carry; + carry = sum >> 8; + out[i] = sum & 0xff; + } + } +} + +/* out = a - b +*/ +void n128_sub(const uint8_t *a, const uint8_t *b, uint8_t *out) +{ + uint8_t carry = 0; + uint32_t sum = 0; + + for (int i = 15; i >= 0; i--) { + sum = a[i] - (b[i] + carry); + + // check to see if anything was borrowed from next byte + if (a[i] < (b[i] + carry)) { + sum += 0x100; + carry = 1; + } + else { + carry = 0; + } + + // set value + out[i] = sum & 0xff; + } + + + while (carry != 0) { + for (int i = 15; i >= 0; i--) { + sum = out[i] - carry; + + // check to see if anything was borrowed from next byte + if (out[i] < carry) { + sum += 0x100; + carry = 1; + } + else { + carry = 0; + } + + out[i] = sum & 0xff; + } + } + +} + +void n128_xor(const uint8_t *a, const uint8_t *b, uint8_t *out) +{ + for (int i = 0; i < 16; i++) { + out[i] = a[i] ^ b[i]; + } +} + +// keygen algorithm +void ctr_aes_keygen(const uint8_t *x, const uint8_t *y, uint8_t *key) +{ + static const uint8_t KEYGEN_CONST[16] = { 0x1F, 0xF9, 0xE9, 0xAA, 0xC5, 0xFE, 0x04, 0x08, 0x02, 0x45, 0x91, 0xDC, 0x5D, 0x52, 0x76, 0x8A }; + + // overall algo: + // key = (((x <<< 2) ^ y) + KEYGEN_CONST) >>> 41 + uint8_t x_rot[16], key_xy[16], key_xyc[16]; + + // x_rot = x <<< 2 + n128_lrot(x, 2, x_rot); + + // key_xy = x_rot ^ y + n128_xor(x_rot, y, key_xy); + + // key_xyc = key_xy + KEYGEN_CONST + n128_add(key_xy, KEYGEN_CONST, key_xyc); + + n128_rrot(key_xyc, 41, key); +} \ No newline at end of file diff --git a/ctrtool/aes_keygen.h b/ctrtool/aes_keygen.h new file mode 100644 index 0000000..dae87a3 --- /dev/null +++ b/ctrtool/aes_keygen.h @@ -0,0 +1,8 @@ +#pragma once +#include + +/* + AES Key generator for the Nintendo 3DS (CTR) Consoles +*/ + +void ctr_aes_keygen(const uint8_t *x, const uint8_t *y, uint8_t *key); diff --git a/ctrtool/cia.c b/ctrtool/cia.c index bf75755..4723c70 100644 --- a/ctrtool/cia.c +++ b/ctrtool/cia.c @@ -214,8 +214,8 @@ void cia_process(cia_context* ctx, u32 actions) - if (settings_get_common_key(ctx->usersettings)) - tik_get_decrypted_titlekey(&ctx->tik, ctx->titlekey); + if (settings_get_common_keyX(ctx->usersettings)) + tik_get_titlekey(&ctx->tik, ctx->titlekey); else if(settings_get_title_key(ctx->usersettings)) memcpy(ctx->titlekey, settings_get_title_key(ctx->usersettings), 16); diff --git a/ctrtool/exefs.c b/ctrtool/exefs.c index e732e4c..150a405 100644 --- a/ctrtool/exefs.c +++ b/ctrtool/exefs.c @@ -48,9 +48,10 @@ void exefs_set_encrypted(exefs_context* ctx, u32 encrypted) ctx->encrypted = encrypted; } -void exefs_set_key(exefs_context* ctx, u8 key[16]) +void exefs_set_keys(exefs_context* ctx, u8 key[16], u8 special_key[16]) { memcpy(ctx->key, key, 16); + memcpy(ctx->special_key, special_key, 16); } void exefs_set_counter(exefs_context* ctx, u8 counter[16]) @@ -58,22 +59,6 @@ void exefs_set_counter(exefs_context* ctx, u8 counter[16]) memcpy(ctx->counter, counter, 16); } -void exefs_determine_key(exefs_context* ctx, u32 actions) -{ - u8* key = settings_get_ncch_key(ctx->usersettings); - - if (actions & PlainFlag) - ctx->encrypted = 0; - else - { - if (key) - { - ctx->encrypted = 1; - memcpy(ctx->key, key, 0x10); - } - } -} - void exefs_save(exefs_context* ctx, u32 index, u32 flags) { exefs_sectionheader* section = (exefs_sectionheader*)(ctx->header.section + index); @@ -146,8 +131,14 @@ void exefs_save(exefs_context* ctx, u32 index, u32 flags) goto clean; } - if (ctx->encrypted) + if (ctx->encrypted) { + // .code and .firm use a special key on 7.0+ + if (ctx->encrypted & NCCHCRYPTO_SPECIAL_FSES) + ctr_init_key(&ctx->aes, ctx->special_key); ctr_crypt_counter(&ctx->aes, compressedbuffer, compressedbuffer, compressedsize); + if (ctx->encrypted & NCCHCRYPTO_SPECIAL_FSES) + ctr_init_key(&ctx->aes, ctx->key); + } decompressedsize = lzss_get_decompressed_size(compressedbuffer, compressedsize); @@ -228,8 +219,6 @@ void exefs_process(exefs_context* ctx, u32 actions) { u32 i; - exefs_determine_key(ctx, actions); - exefs_read_header(ctx, actions); if (actions & VerifyFlag) @@ -272,7 +261,10 @@ int exefs_verify(exefs_context* ctx, u32 index, u32 flags) return 0; fseeko64(ctx->file, ctx->offset + offset, SEEK_SET); - ctr_init_key(&ctx->aes, ctx->key); + if (index == 0 && (ctx->encrypted & NCCHCRYPTO_SPECIAL_FSES)) + ctr_init_key(&ctx->aes, ctx->special_key); + else + ctr_init_key(&ctx->aes, ctx->key); ctr_init_counter(&ctx->aes, ctx->counter); ctr_add_counter(&ctx->aes, offset / 0x10); diff --git a/ctrtool/exefs.h b/ctrtool/exefs.h index 28afffb..16e6152 100644 --- a/ctrtool/exefs.h +++ b/ctrtool/exefs.h @@ -30,6 +30,7 @@ typedef struct u8 partitionid[8]; u8 counter[16]; u8 key[16]; + u8 special_key[16]; u64 offset; u64 size; exefs_header header; @@ -48,7 +49,7 @@ void exefs_set_usersettings(exefs_context* ctx, settings* usersettings); void exefs_set_partitionid(exefs_context* ctx, u8 partitionid[8]); void exefs_set_counter(exefs_context* ctx, u8 counter[16]); void exefs_set_compressedflag(exefs_context* ctx, int compressedflag); -void exefs_set_key(exefs_context* ctx, u8 key[16]); +void exefs_set_keys(exefs_context* ctx, u8 key[16], u8 special_key[16]); void exefs_set_encrypted(exefs_context* ctx, u32 encrypted); void exefs_read_header(exefs_context* ctx, u32 flags); void exefs_calculate_hash(exefs_context* ctx, u8 hash[32]); diff --git a/ctrtool/exheader.c b/ctrtool/exheader.c index 4a96f0f..21473de 100644 --- a/ctrtool/exheader.c +++ b/ctrtool/exheader.c @@ -70,22 +70,6 @@ void exheader_set_key(exheader_context* ctx, u8 key[16]) } -void exheader_determine_key(exheader_context* ctx, u32 actions) -{ - u8* key = settings_get_ncch_key(ctx->usersettings); - - if (actions & PlainFlag) - ctx->encrypted = 0; - else - { - if (key) - { - ctx->encrypted = 1; - memcpy(ctx->key, key, 0x10); - } - } -} - void exheader_read(exheader_context* ctx, u32 actions) { if (ctx->haveread == 0) @@ -183,8 +167,6 @@ void exheader_deserialise_arm11localcaps_permissions(exheader_arm11systemlocalca int exheader_process(exheader_context* ctx, u32 actions) { - exheader_determine_key(ctx, actions); - exheader_read(ctx, actions); if (ctx->header.codesetinfo.flags.flag & 1) diff --git a/ctrtool/exheader.h b/ctrtool/exheader.h index 9ac656f..09f751e 100644 --- a/ctrtool/exheader.h +++ b/ctrtool/exheader.h @@ -198,6 +198,5 @@ void exheader_print(exheader_context* ctx, u32 actions); void exheader_verify(exheader_context* ctx); int exheader_hash_valid(exheader_context* ctx); int exheader_programid_valid(exheader_context* ctx); -void exheader_determine_key(exheader_context* ctx, u32 actions); #endif // _EXHEADER_H_ diff --git a/ctrtool/keyset.cpp b/ctrtool/keyset.cpp index f11e185..0341cbe 100644 --- a/ctrtool/keyset.cpp +++ b/ctrtool/keyset.cpp @@ -33,9 +33,57 @@ static unsigned char hextobin(char c) return 0; } -void keyset_init(keyset* keys) +void keyset_init(keyset* keys, u32 actions) { + const key128 defaultkeys_retail[] = { + // common keyX + {{0x61, 0x70, 0x85, 0x71, 0x9b, 0x7c, 0xfb, 0x31, 0x6d, 0xf4, 0xdf, 0x2e, 0x83, 0x62, 0xc6, 0xe2}, 1}, + // fixed system key - unknown if used/correct? + {{0x52, 0x7c, 0xe6, 0x30, 0xa9, 0xca, 0x30, 0x5f, 0x36, 0x96, 0xf3, 0xcd, 0xe9, 0x54, 0x19, 0x4b}, 1}, + // NCCH 0x2c keyX + {{0xb9, 0x8e, 0x95, 0xce, 0xca, 0x3e, 0x4d, 0x17, 0x1f, 0x76, 0xa9, 0x4d, 0xe9, 0x34, 0xc0, 0x53}, 1}, + // NCCH 0x25 keyX 7.x + {{0xce, 0xe7, 0xd8, 0xab, 0x30, 0xc0, 0x0d, 0xae, 0x85, 0x0e, 0xf5, 0xe3, 0x82, 0xac, 0x5a, 0xf3}, 1}, + // NCCH 0x18 keyX N9.3 + {{0x82, 0xe9, 0xc9, 0xbe, 0xbf, 0xb8, 0xbd, 0xb8, 0x75, 0xec, 0xc0, 0xa0, 0x7d, 0x47, 0x43, 0x74}, 1}, + // NCCH 0x1B keyX N9.6 + {{0x45, 0xad, 0x04, 0x95, 0x39, 0x92, 0xc7, 0xc8, 0x93, 0x72, 0x4a, 0x9a, 0x7b, 0xce, 0x61, 0x82}, 1} + }; + const key128 defaultkeys_dev[] = { + // common keyX + {{0xbd, 0x4f, 0xe7, 0xe7, 0x33, 0xc7, 0x55, 0xfc, 0xe7, 0x54, 0x0e, 0xab, 0xbd, 0x8a, 0xc3, 0x0d}, 1}, + // fixed system key + {{0x52, 0x7c, 0xe6, 0x30, 0xa9, 0xca, 0x30, 0x5f, 0x36, 0x96, 0xf3, 0xcd, 0xe9, 0x54, 0x19, 0x4b}, 1}, + // NCCH 0x2c keyX + {{0x51, 0x02, 0x07, 0x51, 0x55, 0x07, 0xcb, 0xb1, 0x8e, 0x24, 0x3d, 0xcb, 0x85, 0xe2, 0x3a, 0x1d}, 1}, + // NCCH 0x25 keyX 7.x + {{0x81, 0x90, 0x7a, 0x4b, 0x6f, 0x1b, 0x47, 0x32, 0x3a, 0x67, 0x79, 0x74, 0xce, 0x4a, 0xd7, 0x1b}, 1}, + // NCCH 0x18 keyX N9.3 + {{0x30, 0x4b, 0xf1, 0x46, 0x83, 0x72, 0xee, 0x64, 0x11, 0x5e, 0xbd, 0x40, 0x93, 0xd8, 0x42, 0x76}, 1}, + // NCCH 0x1B keyX N9.6 + {{0x6c, 0x8b, 0x29, 0x44, 0xa0, 0x72, 0x60, 0x35, 0xf9, 0x41, 0xdf, 0xc0, 0x18, 0x52, 0x4f, 0xb6}, 1} + }; + memset(keys, 0, sizeof(keyset)); + + if (actions & PlainFlag) + return; + + if (!(actions & DevFlag)) { + memcpy(&keys->commonkeyX, &defaultkeys_retail[0], sizeof(key128)); + memcpy(&keys->ncchfixedsystemkey, &defaultkeys_retail[1], sizeof(key128)); + memcpy(&keys->ncchkeyX_old, &defaultkeys_retail[2], sizeof(key128)); + memcpy(&keys->ncchkeyX_seven, &defaultkeys_retail[3], sizeof(key128)); + memcpy(&keys->ncchkeyX_ninethree, &defaultkeys_retail[4], sizeof(key128)); + memcpy(&keys->ncchkeyX_ninesix, &defaultkeys_retail[5], sizeof(key128)); + } else { + memcpy(&keys->commonkeyX, &defaultkeys_dev[0], sizeof(key128)); + memcpy(&keys->ncchfixedsystemkey, &defaultkeys_dev[1], sizeof(key128)); + memcpy(&keys->ncchkeyX_old, &defaultkeys_dev[2], sizeof(key128)); + memcpy(&keys->ncchkeyX_seven, &defaultkeys_dev[3], sizeof(key128)); + memcpy(&keys->ncchkeyX_ninethree, &defaultkeys_dev[4], sizeof(key128)); + memcpy(&keys->ncchkeyX_ninesix, &defaultkeys_dev[5], sizeof(key128)); + } } int keyset_load_key(TiXmlHandle node, unsigned char* key, unsigned int size, int* valid) @@ -158,9 +206,12 @@ int keyset_load(keyset* keys, const char* fname, int verbose) keyset_load_rsakey2048(root.FirstChild("ncchrsakey"), &keys->ncchrsakey); keyset_load_rsakey2048(root.FirstChild("ncchdescrsakey"), &keys->ncchdescrsakey); keyset_load_rsakey2048(root.FirstChild("firmrsakey"), &keys->firmrsakey); - keyset_load_key128(root.FirstChild("commonkey"), &keys->commonkey); - keyset_load_key128(root.FirstChild("ncchkey"), &keys->ncchkey); + keyset_load_key128(root.FirstChild("commonkeyx"), &keys->commonkeyX); keyset_load_key128(root.FirstChild("ncchfixedsystemkey"), &keys->ncchfixedsystemkey); + keyset_load_key128(root.FirstChild("ncchkeyxold"), &keys->ncchkeyX_old); + keyset_load_key128(root.FirstChild("ncchkeyxseven"), &keys->ncchkeyX_seven); + keyset_load_key128(root.FirstChild("ncchkeyxninethree"), &keys->ncchkeyX_ninethree); + keyset_load_key128(root.FirstChild("ncchkeyxninesix"), &keys->ncchkeyX_ninesix); return 1; @@ -169,14 +220,21 @@ int keyset_load(keyset* keys, const char* fname, int verbose) void keyset_merge(keyset* keys, keyset* src) { - if (src->ncchkey.valid) - keyset_set_key128(&keys->ncchkey, src->ncchkey.data); - if (src->ncchfixedsystemkey.valid) - keyset_set_key128(&keys->ncchfixedsystemkey, src->ncchfixedsystemkey.data); - if (src->commonkey.valid) - keyset_set_key128(&keys->commonkey, src->commonkey.data); - if (src->titlekey.valid) - keyset_set_key128(&keys->titlekey, src->titlekey.data); +#define COPY_IF_VALID(v) do {\ + if (src->v.valid && !keys->v.valid)\ + keyset_set_key128(&keys->v, src->v.data);\ +} while (0) + + COPY_IF_VALID(titlekey); + COPY_IF_VALID(commonkeyX); + COPY_IF_VALID(ncchfixedsystemkey); + COPY_IF_VALID(ncchkeyX_old); + COPY_IF_VALID(ncchkeyX_seven); + COPY_IF_VALID(ncchkeyX_ninethree); + COPY_IF_VALID(ncchkeyX_ninesix); + COPY_IF_VALID(seed); + +#undef COPY_IF_VALID } void keyset_set_key128(key128* key, unsigned char* keydata) @@ -190,19 +248,9 @@ void keyset_parse_key128(key128* key, char* keytext, int keylen) keyset_parse_key(keytext, keylen, key->data, 16, &key->valid); } -void keyset_set_commonkey(keyset* keys, unsigned char* keydata) +void keyset_parse_commonkeyX(keyset* keys, char* keytext, int keylen) { - keyset_set_key128(&keys->commonkey, keydata); -} - -void keyset_parse_commonkey(keyset* keys, char* keytext, int keylen) -{ - keyset_parse_key128(&keys->commonkey, keytext, keylen); -} - -void keyset_set_titlekey(keyset* keys, unsigned char* keydata) -{ - keyset_set_key128(&keys->titlekey, keydata); + keyset_parse_key128(&keys->commonkeyX, keytext, keylen); } void keyset_parse_titlekey(keyset* keys, char* keytext, int keylen) @@ -210,19 +258,9 @@ void keyset_parse_titlekey(keyset* keys, char* keytext, int keylen) keyset_parse_key128(&keys->titlekey, keytext, keylen); } -void keyset_set_ncchkey(keyset* keys, unsigned char* keydata) +void keyset_parse_ncchkeyX_old(keyset* keys, char* keytext, int keylen) { - keyset_set_key128(&keys->ncchkey, keydata); -} - -void keyset_parse_ncchkey(keyset* keys, char* keytext, int keylen) -{ - keyset_parse_key128(&keys->ncchkey, keytext, keylen); -} - -void keyset_set_ncchfixedsystemkey(keyset* keys, unsigned char* keydata) -{ - keyset_set_key128(&keys->ncchfixedsystemkey, keydata); + keyset_parse_key128(&keys->ncchkeyX_old, keytext, keylen); } void keyset_parse_ncchfixedsystemkey(keyset* keys, char* keytext, int keylen) @@ -230,6 +268,26 @@ void keyset_parse_ncchfixedsystemkey(keyset* keys, char* keytext, int keylen) keyset_parse_key128(&keys->ncchfixedsystemkey, keytext, keylen); } +void keyset_parse_ncchkeyX_seven(keyset* keys, char* keytext, int keylen) +{ + keyset_parse_key128(&keys->ncchkeyX_seven, keytext, keylen); +} + +void keyset_parse_ncchkeyX_ninethree(keyset* keys, char* keytext, int keylen) +{ + keyset_parse_key128(&keys->ncchkeyX_ninethree, keytext, keylen); +} + +void keyset_parse_ncchkeyX_ninesix(keyset* keys, char* keytext, int keylen) +{ + keyset_parse_key128(&keys->ncchkeyX_ninesix, keytext, keylen); +} + +void keyset_parse_seed(keyset* keys, char* keytext, int keylen) +{ + keyset_parse_key128(&keys->seed, keytext, keylen); +} + void keyset_dump_rsakey(rsakey2048* key, const char* keytitle) { if (key->keytype == RSAKEY_INVALID) @@ -261,10 +319,17 @@ void keyset_dump_key128(key128* key, const char* keytitle) void keyset_dump(keyset* keys) { +#define DUMP_KEY(n, s) do {\ + keyset_dump_key128(&keys->n, (s));\ +} while(0) fprintf(stdout, "Current keyset: \n"); - keyset_dump_key128(&keys->ncchkey, "NCCH KEY"); - keyset_dump_key128(&keys->ncchfixedsystemkey, "NCCH FIXEDSYSTEMKEY"); - keyset_dump_key128(&keys->commonkey, "COMMON KEY"); + DUMP_KEY(ncchkeyX_old, "NCCH OLD KEYX"); + DUMP_KEY(ncchkeyX_seven, "NCCH 7.0 KEYX"); + DUMP_KEY(ncchkeyX_ninethree, "NCCH N9.3 KEYX"); + DUMP_KEY(ncchkeyX_ninesix, "NCCH N9.6 KEYX"); + DUMP_KEY(ncchfixedsystemkey, "NCCH FIXEDSYSTEMKEY"); + DUMP_KEY(commonkeyX, "COMMON KEYX"); +#undef DUMP_KEY keyset_dump_rsakey(&keys->ncsdrsakey, "NCSD RSA KEY"); keyset_dump_rsakey(&keys->ncchdescrsakey, "NCCH DESC RSA KEY"); diff --git a/ctrtool/keyset.h b/ctrtool/keyset.h index 2cf2866..5f71d90 100644 --- a/ctrtool/keyset.h +++ b/ctrtool/keyset.h @@ -42,27 +42,31 @@ typedef struct typedef struct { - key128 commonkey; key128 titlekey; - key128 ncchkey; + key128 seed; + key128 commonkeyX; key128 ncchfixedsystemkey; + key128 ncchkeyX_old; + key128 ncchkeyX_seven; + key128 ncchkeyX_ninethree; + key128 ncchkeyX_ninesix; rsakey2048 ncsdrsakey; rsakey2048 ncchrsakey; rsakey2048 ncchdescrsakey; rsakey2048 firmrsakey; } keyset; -void keyset_init(keyset* keys); +void keyset_init(keyset* keys, u32 actions); int keyset_load(keyset* keys, const char* fname, int verbose); void keyset_merge(keyset* keys, keyset* src); -void keyset_set_commonkey(keyset* keys, unsigned char* keydata); -void keyset_parse_commonkey(keyset* keys, char* keytext, int keylen); -void keyset_set_titlekey(keyset* keys, unsigned char* keydata); +void keyset_parse_commonkeyX(keyset* keys, char* keytext, int keylen); void keyset_parse_titlekey(keyset* keys, char* keytext, int keylen); -void keyset_set_ncchkey(keyset* keys, unsigned char* keydata); -void keyset_parse_ncchkey(keyset* keys, char* keytext, int keylen); -void keyset_set_ncchfixedsystemkey(keyset* keys, unsigned char* keydata); +void keyset_parse_ncchkeyX_old(keyset* keys, char* keytext, int keylen); void keyset_parse_ncchfixedsystemkey(keyset* keys, char* keytext, int keylen); +void keyset_parse_ncchkeyX_seven(keyset* keys, char* keytext, int keylen); +void keyset_parse_ncchkeyX_ninethree(keyset* keys, char* keytext, int keylen); +void keyset_parse_ncchkeyX_ninesix(keyset* keys, char* keytext, int keylen); +void keyset_parse_seed(keyset* keys, char* keytext, int keylen); void keyset_dump(keyset* keys); #ifdef __cplusplus diff --git a/ctrtool/main.c b/ctrtool/main.c index dd8ef88..393d272 100644 --- a/ctrtool/main.c +++ b/ctrtool/main.c @@ -52,11 +52,13 @@ static void usage(const char *argv0) " -k, --keyset=file Specify keyset file.\n" " -v, --verbose Give verbose output.\n" " -y, --verify Verify hashes and signatures.\n" + " -d, --dev Decrypt with development keys instead of retail.\n" " --unitsize=size Set media unit size (default 0x200).\n" " --commonkey=key Set common key.\n" " --titlekey=key Set tik title key.\n" " --ncchkey=key Set ncch key.\n" " --ncchsyskey=key Set ncch fixed system key.\n" + " --seed=key Set seed for ncch seed crypto.\n" " --showkeys Show the keys being used.\n" " --showsyscalls Show system call names instead of numbers.\n" " -t, --intype=type Specify input file type [ncsd, ncch, exheader, cia, tmd, lzss,\n" @@ -109,8 +111,7 @@ int main(int argc, char* argv[]) ctx.filetype = FILETYPE_UNKNOWN; settings_init(&ctx.usersettings); - keyset_init(&ctx.usersettings.keys); - keyset_init(&tmpkeys); + keyset_init(&tmpkeys, 0); while (1) @@ -137,8 +138,8 @@ int main(int argc, char* argv[]) {"raw", 0, NULL, 'r'}, {"unitsize", 1, NULL, 9}, {"showkeys", 0, NULL, 10}, - {"commonkey", 1, NULL, 11}, - {"ncchkey", 1, NULL, 12}, + {"commonkeyx", 1, NULL, 11}, + {"ncchkeyxold", 1, NULL, 12}, {"intype", 1, NULL, 't'}, {"lzssout", 1, NULL, 13}, {"firmdir", 1, NULL, 14}, @@ -152,10 +153,14 @@ int main(int argc, char* argv[]) {"titlekey", 1, NULL, 22}, {"plainrgn", 1, NULL, 23}, {"showsyscalls", 0, NULL, 24}, + {"ncchkeyxseven", 1, NULL, 25}, + {"ncchkeyxninethree", 1, NULL, 26}, + {"ncchkeyxninesix", 1, NULL, 27}, + {"seed", 1, NULL, 28}, {NULL}, }; - c = getopt_long(argc, argv, "ryxivpk:n:t:", long_options, &option_index); + c = getopt_long(argc, argv, "dryxivpk:n:t:", long_options, &option_index); if (c == -1) break; @@ -173,6 +178,10 @@ int main(int argc, char* argv[]) ctx.actions |= VerifyFlag; break; + case 'd': + ctx.actions |= DevFlag; + break; + case 'p': ctx.actions |= PlainFlag; break; @@ -228,8 +237,8 @@ int main(int argc, char* argv[]) case 8: settings_set_exefs_dir_path(&ctx.usersettings, optarg); break; case 9: settings_set_mediaunit_size(&ctx.usersettings, strtoul(optarg, 0, 0)); break; case 10: ctx.actions |= ShowKeysFlag; break; - case 11: keyset_parse_commonkey(&tmpkeys, optarg, strlen(optarg)); break; - case 12: keyset_parse_ncchkey(&tmpkeys, optarg, strlen(optarg)); break; + case 11: keyset_parse_commonkeyX(&tmpkeys, optarg, strlen(optarg)); break; + case 12: keyset_parse_ncchkeyX_old(&tmpkeys, optarg, strlen(optarg)); break; case 13: settings_set_lzss_path(&ctx.usersettings, optarg); break; case 14: settings_set_firm_dir_path(&ctx.usersettings, optarg); break; case 15: keyset_parse_ncchfixedsystemkey(&tmpkeys, optarg, strlen(optarg)); break; @@ -242,6 +251,10 @@ int main(int argc, char* argv[]) case 22: keyset_parse_titlekey(&tmpkeys, optarg, strlen(optarg)); break; case 23: settings_set_plainrgn_path(&ctx.usersettings, optarg); break; case 24: ctx.actions |= ShowSyscallsFlag; break; + case 25: keyset_parse_ncchkeyX_seven(&tmpkeys, optarg, strlen(optarg)); break; + case 26: keyset_parse_ncchkeyX_ninethree(&tmpkeys, optarg, strlen(optarg)); break; + case 27: keyset_parse_ncchkeyX_ninesix(&tmpkeys, optarg, strlen(optarg)); break; + case 28: keyset_parse_seed(&tmpkeys, optarg, strlen(optarg)); break; default: usage(argv[0]); @@ -259,6 +272,7 @@ int main(int argc, char* argv[]) usage(argv[0]); } + keyset_init(&ctx.usersettings.keys, ctx.actions); keyset_load(&ctx.usersettings.keys, keysetfname, (ctx.actions & VerboseFlag) | checkkeysetfile); keyset_merge(&ctx.usersettings.keys, &tmpkeys); if (ctx.actions & ShowKeysFlag) diff --git a/ctrtool/ncch.c b/ctrtool/ncch.c index b553b60..1c9f9ee 100644 --- a/ctrtool/ncch.c +++ b/ctrtool/ncch.c @@ -6,6 +6,7 @@ #include "utils.h" #include "ctr.h" #include "settings.h" +#include "aes_keygen.h" #include static int programid_is_system(u8 programid[8]) @@ -333,6 +334,14 @@ void ncch_process(ncch_context* ctx, u32 actions) ncch_get_counter(ctx, exefscounter, NCCHTYPE_EXEFS); ncch_get_counter(ctx, romfscounter, NCCHTYPE_ROMFS); + if (actions & ShowKeysFlag) + { + fprintf(stdout, "Counter(s):\n"); + memdump(stdout, " exheader: ", exheadercounter, 0x10); + memdump(stdout, " ExeFS: ", exefscounter, 0x10); + memdump(stdout, " RomFS: ", romfscounter, 0x10); + } + exheader_set_file(&ctx->exheader, ctx->file); exheader_set_offset(&ctx->exheader, ncch_get_exheader_offset(ctx) ); @@ -351,7 +360,7 @@ void ncch_process(ncch_context* ctx, u32 actions) exefs_set_partitionid(&ctx->exefs, ctx->header.partitionid); exefs_set_usersettings(&ctx->exefs, ctx->usersettings); exefs_set_counter(&ctx->exefs, exefscounter); - exefs_set_key(&ctx->exefs, ctx->key); + exefs_set_keys(&ctx->exefs, ctx->key, ctx->special_key); exefs_set_encrypted(&ctx->exefs, ctx->encrypted); romfs_set_file(&ctx->romfs, ctx->file); @@ -359,7 +368,10 @@ void ncch_process(ncch_context* ctx, u32 actions) romfs_set_size(&ctx->romfs, ncch_get_romfs_size(ctx)); romfs_set_usersettings(&ctx->romfs, ctx->usersettings); romfs_set_counter(&ctx->romfs, romfscounter); - romfs_set_key(&ctx->romfs, ctx->key); + if (ctx->encrypted & NCCHCRYPTO_SPECIAL_FSES) + romfs_set_key(&ctx->romfs, ctx->special_key); + else + romfs_set_key(&ctx->romfs, ctx->key); romfs_set_encrypted(&ctx->romfs, ctx->encrypted); exheader_read(&ctx->exheader, actions); @@ -371,6 +383,23 @@ void ncch_process(ncch_context* ctx, u32 actions) if (actions & InfoFlag) ncch_print(ctx); + if (ctx->encrypted == NCCHCRYPTO_BROKEN) + { + fprintf(stderr, "Error, NCCH encryption broken.\n"); + return; + } + + if ((actions & ShowKeysFlag) && ctx->encrypted) + { + fprintf(stdout, "Using key(s):\n"); + memdump(stdout, " 0x2C: ", ctx->key, 0x10); + if (ctx->encrypted & NCCHCRYPTO_SPECIAL_FSES) + { + fprintf(stdout, " special (%02x): ", ctx->header.flags[3]); + memdump(stdout, "", ctx->special_key, 0x10); + } + } + if (actions & ExtractFlag) { ncch_save(ctx, NCCHTYPE_EXEFS, actions); @@ -482,8 +511,12 @@ u64 ncch_get_mediaunit_size(ncch_context* ctx) void ncch_determine_key(ncch_context* ctx, u32 actions) { exheader_header exheader; - u8* key = settings_get_ncch_key(ctx->usersettings); + u8* key; + u8* seed; ctr_ncchheader* header = &ctx->header; + u8 seedbuf[0x20]; + u8 seedhash[0x20]; + u8 keyX[0x10], keyY[0x10], seedKeyY[0x10]; ctx->encrypted = 0; memset(ctx->key, 0, 0x10); @@ -492,17 +525,58 @@ void ncch_determine_key(ncch_context* ctx, u32 actions) { ctx->encrypted = 0; } - else if (key != 0) - { - ctx->encrypted = 1; - memcpy(ctx->key, key, 0x10); - } else { // No explicit NCCH key defined, so we try to decide - + // In almost all of these scenarios, the normal 0x2C NCCH keyX will be the default, + // except for the old fixedkey crypto, where we'll override it anyway, so let's just + // set the 0x2C keyX first. + key = settings_get_ncchkeyX_old(ctx->usersettings); + if (key) + memcpy(keyX, key, 0x10); + else + fprintf(stderr, "Warning, could not read NCCH base key. Decryption will likely fail.\n"); - // Firstly, check if the NCCH is already decrypted, by reading the programid in the exheader + // The keyY is normally the beginning of the NCCH header signature. In case seed crypto + // changes that, we'll override it below. + memcpy(keyY, header->signature, 0x10); + memcpy(seedKeyY, keyY, 0x10); + + // 0x2c crypto is normally used; we override it where necessary + ctr_aes_keygen(keyX, keyY, ctx->key); + + // Seed crypto can be used alongside any other crypto type, so we'll need to figure this out early. + if (header->flags[7] & 0x20) + { + ctx->encrypted = NCCHCRYPTO_SEED; + seed = settings_get_seed(ctx->usersettings); + if (!seed) + { + fprintf(stderr, "This title uses seed crypto, but no seed is set, unable to decrypt.\n" + "Use -p to avoid decryption or use --seed=SEEDHERE to provide the seed.\n"); + ctx->encrypted = NCCHCRYPTO_BROKEN; + return; + } + + memcpy(seedbuf, seed, 0x10); + // Assumes running on little endian + memcpy(seedbuf + 0x10, header->programid, sizeof(header->programid)); + ctr_sha_256(seedbuf, 0x18, seedhash); + if (memcmp(seedhash, header->seedcheck, sizeof(header->seedcheck))) { + fprintf(stderr, "Seed check mismatch. (Got: %02x%02x%02x%02x, expected: %02x%02x%02x%02x)\n", + seedhash[0], seedhash[1], seedhash[2], seedhash[3], + header->seedcheck[0], header->seedcheck[1], header->seedcheck[2], header->seedcheck[3]); + ctx->encrypted = NCCHCRYPTO_BROKEN; + return; + } + + memcpy(seedbuf, header->signature, 0x10); + memcpy(seedbuf + 0x10, seed, 0x10); + ctr_sha_256(seedbuf, 0x20, seedhash); + memcpy(seedKeyY, seedhash, 0x10); + } + + // Check if the NCCH is already decrypted, by reading the programid in the exheader // Otherwise, use determination rules fseeko64(ctx->file, ncch_get_exheader_offset(ctx), SEEK_SET); memset(&exheader, 0, sizeof(exheader)); @@ -511,37 +585,74 @@ void ncch_determine_key(ncch_context* ctx, u32 actions) if (!memcmp(exheader.arm11systemlocalcaps.programid, ctx->header.programid, 8)) { // program id's match, so it's probably not encrypted - ctx->encrypted = 0; + ctx->encrypted = NCCHCRYPTO_NONE; + if (!(header->flags[7] & 4)) + fprintf(stderr, "Warning, exheader seems decrypted but the NCCH says it isn't.\n" + "This NCCH will likely break on console.\n"); } - else if (header->flags[7] & 4) + else if (header->flags[7] & 4) // no crypto { - ctx->encrypted = 0; // not encrypted + ctx->encrypted = NCCHCRYPTO_NONE; } - else if (header->flags[7] & 1) + else if (header->flags[7] & 1) // fixed key crypto { + ctx->encrypted = NCCHCRYPTO_FIXED; if (programid_is_system(header->programid)) { // fixed system key - ctx->encrypted = 1; key = settings_get_ncch_fixedsystemkey(ctx->usersettings); - if (!key) - fprintf(stdout, "Warning, could not read system fixed key.\n"); - else + if (!key) { + fprintf(stderr, "Error, could not read system fixed key.\n"); + ctx->encrypted = NCCHCRYPTO_BROKEN; + } else { memcpy(ctx->key, key, 0x10); + } } else { // null key - ctx->encrypted = 1; memset(ctx->key, 0, 0x10); } } + else if (header->flags[3] == 0x01) // 7.0 crypto + { + ctx->encrypted = NCCHCRYPTO_SEVEN; + key = settings_get_ncchkeyX_seven(ctx->usersettings); + if (!key) { + fprintf(stderr, "Error, could not read NCCH 7.0 keyX.\n"); + return; + } + ctr_aes_keygen(key, seedKeyY, ctx->special_key); + } + else if (header->flags[3] == 0x0A) // N9.3 crypto + { + ctx->encrypted = NCCHCRYPTO_NINETHREE; + key = settings_get_ncchkeyX_ninethree(ctx->usersettings); + if (!key) { + fprintf(stderr, "Error, could not read NCCH 9.3 keyX.\n"); + return; + } + ctr_aes_keygen(key, seedKeyY, ctx->special_key); + } + else if (header->flags[3] == 0x0B) // N9.6 crypto + { + ctx->encrypted = NCCHCRYPTO_NINESIX; + key = settings_get_ncchkeyX_ninesix(ctx->usersettings); + if (!key) { + fprintf(stderr, "Error, could not read NCCH 9.6 keyX.\n"); + return; + } + ctr_aes_keygen(key, seedKeyY, ctx->special_key); + } + else if (header->flags[3] != 0) // unknown special crypto + { + fprintf(stderr, "Warning, unknown NCCH crypto method.\n"); + ctx->encrypted = NCCHCRYPTO_BROKEN; + } else { - // secure key (cannot decrypt!) - fprintf(stdout, "Warning, could not read secure key.\n"); - ctx->encrypted = 1; - memset(ctx->key, 0, 0x10); + // old/normal NCCH crypto + ctx->encrypted = NCCHCRYPTO_OLD; } } } diff --git a/ctrtool/ncch.h b/ctrtool/ncch.h index 64dc490..79f8957 100644 --- a/ctrtool/ncch.h +++ b/ctrtool/ncch.h @@ -20,6 +20,19 @@ typedef enum NCCHTYPE_PLAINRGN = 5, } ctr_ncchtypes; +typedef enum +{ + NCCHCRYPTO_NONE = 0, //< already decrypted + NCCHCRYPTO_FIXED = 1, //< fixed key crypto, used for SDK-made application titles and very very old system titles + NCCHCRYPTO_OLD = (1<<1), //< crypto used before 7.0 + NCCHCRYPTO_SEVEN = (1<<2), //< crypto used starting with 7.0 + NCCHCRYPTO_NINETHREE = (1<<3), //< crypto used on N3DS starting with 9.3 + NCCHCRYPTO_NINESIX = (1<<4), //< crypto used on N3DS starting with 9.6 + NCCHCRYPTO_SEED = (1<<5), //< crypto used starting with 9.6 for preloading titles + NCCHCRYPTO_SPECIAL_FSES = NCCHCRYPTO_SEVEN | NCCHCRYPTO_NINETHREE | NCCHCRYPTO_NINESIX | NCCHCRYPTO_SEED, //< ExeFS and RomFS need new keys + NCCHCRYPTO_BROKEN = 0xFF //< Internal: seed crypto required but no seed set +} ctr_ncchcryptotype; + typedef struct { u8 signature[0x100]; @@ -58,6 +71,8 @@ typedef struct { FILE* file; u8 key[16]; + u8 special_key[16]; // used with the 7.x+ crypto methods + u8 seed[16]; u32 encrypted; u64 offset; u64 size; diff --git a/ctrtool/settings.c b/ctrtool/settings.c index ddbf51b..95f7dbd 100644 --- a/ctrtool/settings.c +++ b/ctrtool/settings.c @@ -136,38 +136,55 @@ unsigned int settings_get_mediaunit_size(settings* usersettings) return 0; } -unsigned char* settings_get_ncch_key(settings* usersettings) -{ - if (usersettings && usersettings->keys.ncchkey.valid) - return usersettings->keys.ncchkey.data; - else - return 0; -} +#define GETKEY(s, k) do {\ + if ((s) && (s)->keys.k.valid)\ + return (s)->keys.k.data;\ + else\ + return NULL;\ +} while (0) unsigned char* settings_get_ncch_fixedsystemkey(settings* usersettings) { - if (usersettings && usersettings->keys.ncchfixedsystemkey.valid) - return usersettings->keys.ncchfixedsystemkey.data; - else - return 0; + GETKEY(usersettings, ncchfixedsystemkey); } -unsigned char* settings_get_common_key(settings* usersettings) +unsigned char* settings_get_ncchkeyX_old(settings* usersettings) { - if (usersettings && usersettings->keys.commonkey.valid) - return usersettings->keys.commonkey.data; - else - return 0; + GETKEY(usersettings, ncchkeyX_old); +} + +unsigned char* settings_get_ncchkeyX_seven(settings* usersettings) +{ + GETKEY(usersettings, ncchkeyX_seven); +} + +unsigned char* settings_get_ncchkeyX_ninethree(settings* usersettings) +{ + GETKEY(usersettings, ncchkeyX_ninethree); +} + +unsigned char* settings_get_ncchkeyX_ninesix(settings* usersettings) +{ + GETKEY(usersettings, ncchkeyX_ninesix); +} + +unsigned char* settings_get_common_keyX(settings* usersettings) +{ + GETKEY(usersettings, commonkeyX); +} + +unsigned char* settings_get_seed(settings* usersettings) +{ + GETKEY(usersettings, seed); } unsigned char* settings_get_title_key(settings* usersettings) { - if (usersettings && usersettings->keys.titlekey.valid) - return usersettings->keys.titlekey.data; - else - return 0; + GETKEY(usersettings, titlekey); } +#undef GETKEY + int settings_get_ignore_programid(settings* usersettings) { if (usersettings) diff --git a/ctrtool/settings.h b/ctrtool/settings.h index 2822b93..c3f819f 100644 --- a/ctrtool/settings.h +++ b/ctrtool/settings.h @@ -46,9 +46,13 @@ filepath* settings_get_firm_dir_path(settings* usersettings); filepath* settings_get_wav_path(settings* usersettings); filepath* settings_get_plainrgn_path(settings* usersettings); unsigned int settings_get_mediaunit_size(settings* usersettings); -unsigned char* settings_get_ncch_key(settings* usersettings); unsigned char* settings_get_ncch_fixedsystemkey(settings* usersettings); -unsigned char* settings_get_common_key(settings* usersettings); +unsigned char* settings_get_ncchkeyX_old(settings* usersettings); +unsigned char* settings_get_ncchkeyX_seven(settings* usersettings); +unsigned char* settings_get_ncchkeyX_ninethree(settings* usersettings); +unsigned char* settings_get_ncchkeyX_ninesix(settings* usersettings); +unsigned char* settings_get_common_keyX(settings* usersettings); +unsigned char* settings_get_seed(settings* usersettings); unsigned char* settings_get_title_key(settings* usersettings); int settings_get_ignore_programid(settings* usersettings); int settings_get_list_romfs_files(settings* usersettings); diff --git a/ctrtool/tik.c b/ctrtool/tik.c index ce582c3..c9a1e5b 100644 --- a/ctrtool/tik.c +++ b/ctrtool/tik.c @@ -2,6 +2,7 @@ #include #include +#include "aes_keygen.h" #include "tik.h" #include "ctr.h" #include "utils.h" @@ -31,9 +32,9 @@ void tik_set_usersettings(tik_context* ctx, settings* usersettings) ctx->usersettings = usersettings; } -void tik_get_decrypted_titlekey(tik_context* ctx, u8 decryptedkey[0x10]) +void tik_get_titlekey(tik_context* ctx, u8 key[0x10]) { - memcpy(decryptedkey, ctx->titlekey, 16); + memcpy(ctx->titlekey, key, 16); } void tik_get_titleid(tik_context* ctx, u8 titleid[8]) @@ -50,16 +51,29 @@ void tik_get_iv(tik_context* ctx, u8 iv[16]) void tik_decrypt_titlekey(tik_context* ctx, u8 decryptedkey[0x10]) { u8 iv[16]; - u8* key = settings_get_common_key(ctx->usersettings); + u8* keyX = settings_get_common_keyX(ctx->usersettings); + const u8 keyYs[6][16] = { + // application titles (eShop titles) + {0xd0, 0x7b, 0x33, 0x7f, 0x9c, 0xa4, 0x38, 0x59, 0x32, 0xa2, 0xe2, 0x57, 0x23, 0x23, 0x2e, 0xb9}, + // system titles + {0x0c, 0x76, 0x72, 0x30, 0xf0, 0x99, 0x8f, 0x1c, 0x46, 0x82, 0x82, 0x02, 0xfa, 0xac, 0xbe, 0x4c}, + // these are unused + {0xc4, 0x75, 0xcb, 0x3a, 0xb8, 0xc7, 0x88, 0xbb, 0x57, 0x5e, 0x12, 0xa1, 0x09, 0x07, 0xb8, 0xa4}, + {0xe4, 0x86, 0xee, 0xe3, 0xd0, 0xc0, 0x9c, 0x90, 0x2f, 0x66, 0x86, 0xd4, 0xc0, 0x6f, 0x64, 0x9f}, + {0xed, 0x31, 0xba, 0x9c, 0x04, 0xb0, 0x67, 0x50, 0x6c, 0x44, 0x97, 0xa3, 0x5b, 0x78, 0x04, 0xfc}, + {0x5e, 0x66, 0x99, 0x8a, 0xb4, 0xe8, 0x93, 0x16, 0x06, 0x85, 0x0f, 0xd7, 0xa1, 0x6d, 0xd7, 0x55}, + }; + u8 key[16]; memset(decryptedkey, 0, 0x10); - if (!key) + if (!keyX) { fprintf(stdout, "Warning, could not read common key.\n"); } else { + ctr_aes_keygen(keyX, keyYs[(ctx->tik.title_id[3] & 0x10) ? 1 : 0], key); memset(iv, 0, 0x10); memcpy(iv, ctx->tik.title_id, 8); @@ -108,7 +122,7 @@ void tik_print(tik_context* ctx) memdump(stdout, "Encrypted Titlekey: ", tik->encrypted_title_key, 0x10); - if (settings_get_common_key(ctx->usersettings)) + if (settings_get_common_keyX(ctx->usersettings)) memdump(stdout, "Decrypted Titlekey: ", ctx->titlekey, 0x10); memdump(stdout, "Ticket ID: ", tik->ticket_id, 0x08); diff --git a/ctrtool/tik.h b/ctrtool/tik.h index edd72c5..1aa0596 100644 --- a/ctrtool/tik.h +++ b/ctrtool/tik.h @@ -54,7 +54,7 @@ void tik_set_file(tik_context* ctx, FILE* file); void tik_set_offset(tik_context* ctx, u64 offset); void tik_set_size(tik_context* ctx, u32 size); void tik_set_usersettings(tik_context* ctx, settings* usersettings); -void tik_get_decrypted_titlekey(tik_context* ctx, u8 decryptedkey[0x10]); +void tik_get_titlekey(tik_context* ctx, u8 key[0x10]); void tik_get_titleid(tik_context* ctx, u8 titleid[8]); void tik_get_iv(tik_context* ctx, u8 iv[0x10]); void tik_decrypt_titlekey(tik_context* ctx, u8 decryptedkey[0x10]); diff --git a/ctrtool/types.h b/ctrtool/types.h index 5904a08..c35e2ba 100644 --- a/ctrtool/types.h +++ b/ctrtool/types.h @@ -25,6 +25,7 @@ enum flags ShowKeysFlag = (1<<6), DecompressCodeFlag = (1<<7), ShowSyscallsFlag = (1<<8), + DevFlag = (1<<9), }; enum validstate