1
/*
2
 * Copyright (c) 2018 naehrwert
3
 * Copyright (c) 2018-2024 CTCaer
4
 *
5
 * This program is free software; you can redistribute it and/or modify it
6
 * under the terms and conditions of the GNU General Public License,
7
 * version 2, as published by the Free Software Foundation.
8
 *
9
 * This program is distributed in the hope it will be useful, but WITHOUT
10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12
 * more details.
13
 *
14
 * You should have received a copy of the GNU General Public License
15
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16
 */
17

18
#include <string.h>
19

20
#include <bdk.h>
21

22
#include "pkg2.h"
23
#include "hos.h"
24

25
#include "../config.h"
26
#include <libs/fatfs/ff.h>
27
#include <libs/compr/blz.h>
28

29
extern hekate_config h_cfg;
30
extern const u8 package2_keyseed[];
31

32
u32 pkg2_newkern_ini1_start;
33
u32 pkg2_newkern_ini1_end;
34

35
/*#define DPRINTF(...) gfx_printf(__VA_ARGS__)
36
#define DEBUG_PRINTING*/
37
#define DPRINTF(...)
38

39
u32 pkg2_calc_kip1_size(pkg2_kip1_t *kip1)
40
{
41
	u32 size = sizeof(pkg2_kip1_t);
42
	for (u32 j = 0; j < KIP1_NUM_SECTIONS; j++)
43
		size += kip1->sections[j].size_comp;
44
	return size;
45
}
46

47
void pkg2_get_newkern_info(u8 *kern_data)
48
{
49
	u32 crt_start = 0;
50
	u32 pkg2_newkern_ini1_info = 0;
51
	pkg2_newkern_ini1_start    = 0;
52

53
	u32 first_op = *(u32 *)kern_data;
54
	if ((first_op & 0xFE000000) == 0x14000000)
55
		crt_start = (first_op & 0x1FFFFFF) << 2;
56

57
	// Find static OP offset that is close to INI1 offset.
58
	u32 counter_ops = 0x100;
59
	while (counter_ops)
60
	{
61
		if (*(u32 *)(kern_data + crt_start + 0x100 - counter_ops) == PKG2_NEWKERN_GET_INI1_HEURISTIC)
62
		{
63
			// OP found. Add 12 for the INI1 info offset.
64
			pkg2_newkern_ini1_info = crt_start + 0x100 - counter_ops + 12;
65

66
			// On v2 kernel with dynamic crt there's a NOP after heuristic. Offset one op.
67
			if (crt_start)
68
				pkg2_newkern_ini1_info += 4;
69
			break;
70
		}
71

72
		counter_ops -= 4;
73
	}
74

75
	// Offset not found?
76
	if (!counter_ops)
77
		return;
78

79
	u32 info_op = *(u32 *)(kern_data + pkg2_newkern_ini1_info);
80
	pkg2_newkern_ini1_info += ((info_op & 0xFFFF) >> 3); // Parse ADR and PC.
81

82
	pkg2_newkern_ini1_start = *(u32 *)(kern_data + pkg2_newkern_ini1_info);
83
	pkg2_newkern_ini1_end   = *(u32 *)(kern_data + pkg2_newkern_ini1_info + 0x8);
84

85
	// On v2 kernel with dynamic crt, values are relative to value address.
86
	if (crt_start)
87
	{
88
		pkg2_newkern_ini1_start += pkg2_newkern_ini1_info;
89
		pkg2_newkern_ini1_end   += pkg2_newkern_ini1_info + 0x8;
90
	}
91
}
92

93
//!TODO: Update on mkey changes.
94
static const u8 mkey_vector_7xx[HOS_KB_VERSION_MAX - HOS_KB_VERSION_810 + 1][SE_KEY_128_SIZE] =
95
{
96
	// Master key 7  encrypted with 8.  (7.0.0 with 8.1.0)
97
	{ 0xEA, 0x60, 0xB3, 0xEA, 0xCE, 0x8F, 0x24, 0x46, 0x7D, 0x33, 0x9C, 0xD1, 0xBC, 0x24, 0x98, 0x29 },
98
	// Master key 8  encrypted with 9.  (8.1.0 with 9.0.0)
99
	{ 0x4D, 0xD9, 0x98, 0x42, 0x45, 0x0D, 0xB1, 0x3C, 0x52, 0x0C, 0x9A, 0x44, 0xBB, 0xAD, 0xAF, 0x80 },
100
	// Master key 9  encrypted with 10. (9.0.0 with 9.1.0)
101
	{ 0xB8, 0x96, 0x9E, 0x4A, 0x00, 0x0D, 0xD6, 0x28, 0xB3, 0xD1, 0xDB, 0x68, 0x5F, 0xFB, 0xE1, 0x2A },
102
	// Master key 10 encrypted with 11. (9.1.0 with 12.1.0)
103
	{ 0xC1, 0x8D, 0x16, 0xBB, 0x2A, 0xE4, 0x1D, 0xD4, 0xC2, 0xC1, 0xB6, 0x40, 0x94, 0x35, 0x63, 0x98 },
104
	// Master key 11 encrypted with 12. (12.1.0 with 13.0.0)
105
	{ 0xA3, 0x24, 0x65, 0x75, 0xEA, 0xCC, 0x6E, 0x8D, 0xFB, 0x5A, 0x16, 0x50, 0x74, 0xD2, 0x15, 0x06 },
106
	// Master key 12 encrypted with 13. (13.0.0 with 14.0.0)
107
	{ 0x83, 0x67, 0xAF, 0x01, 0xCF, 0x93, 0xA1, 0xAB, 0x80, 0x45, 0xF7, 0x3F, 0x72, 0xFD, 0x3B, 0x38 },
108
	// Master key 13 encrypted with 14. (14.0.0 with 15.0.0)
109
	{ 0xB1, 0x81, 0xA6, 0x0D, 0x72, 0xC7, 0xEE, 0x15, 0x21, 0xF3, 0xC0, 0xB5, 0x6B, 0x61, 0x6D, 0xE7 },
110
	// Master key 14 encrypted with 15. (15.0.0 with 16.0.0)
111
	{ 0xAF, 0x11, 0x4C, 0x67, 0x17, 0x7A, 0x52, 0x43, 0xF7, 0x70, 0x2F, 0xC7, 0xEF, 0x81, 0x72, 0x16 },
112
	// Master key 15 encrypted with 16. (16.0.0 with 17.0.0)
113
	{ 0x25, 0x12, 0x8B, 0xCB, 0xB5, 0x46, 0xA1, 0xF8, 0xE0, 0x52, 0x15, 0xB7, 0x0B, 0x57, 0x00, 0xBD },
114
	// Master key 16 encrypted with 17. (17.0.0 with 18.0.0)
115
	{ 0x58, 0x15, 0xD2, 0xF6, 0x8A, 0xE8, 0x19, 0xAB, 0xFB, 0x2D, 0x52, 0x9D, 0xE7, 0x55, 0xF3, 0x93 },
116
	// Master key 17 encrypted with 18. (18.0.0 with 19.0.0)
117
	{ 0x4A, 0x01, 0x3B, 0xC7, 0x44, 0x6E, 0x45, 0xBD, 0xE6, 0x5E, 0x2B, 0xEC, 0x07, 0x37, 0x52, 0x86 },
118
	// Master key 18 encrypted with 19. (19.0.0 with 20.0.0)
119
	{ 0x97, 0xE4, 0x11, 0xAB, 0x22, 0x72, 0x1A, 0x1F, 0x70, 0x5C, 0x00, 0xB3, 0x96, 0x30, 0x05, 0x28 },
120
};
121

122
static bool _pkg2_key_unwrap_validate(pkg2_hdr_t *tmp_test, pkg2_hdr_t *hdr, u8 src_slot, u8 *mkey, const u8 *key_seed)
123
{
124
	// Decrypt older encrypted mkey.
125
	se_aes_crypt_ecb(src_slot, DECRYPT, mkey, SE_KEY_128_SIZE, key_seed, SE_KEY_128_SIZE);
126
	// Set and unwrap pkg2 key.
127
	se_aes_key_set(9, mkey, SE_KEY_128_SIZE);
128
	se_aes_unwrap_key(9, 9, package2_keyseed);
129

130
	// Decrypt header.
131
	se_aes_crypt_ctr(9, tmp_test, sizeof(pkg2_hdr_t), hdr, sizeof(pkg2_hdr_t), hdr);
132

133
	// Return if header is valid.
134
	return (tmp_test->magic == PKG2_MAGIC);
135
}
136

137
pkg2_hdr_t *pkg2_decrypt(void *data, u8 kb)
138
{
139
	pkg2_hdr_t mkey_test;
140
	u8 *pdata = (u8 *)data;
141
	u8 pkg2_keyslot = 8;
142

143
	// Skip signature.
144
	pdata += 0x100;
145

146
	pkg2_hdr_t *hdr = (pkg2_hdr_t *)pdata;
147

148
	// Skip header.
149
	pdata += sizeof(pkg2_hdr_t);
150

151
	// Check if we need to decrypt with newer mkeys. Valid for THK for 7.0.0 and up.
152
	se_aes_crypt_ctr(8, &mkey_test, sizeof(pkg2_hdr_t), hdr, sizeof(pkg2_hdr_t), hdr);
153

154
	if (mkey_test.magic == PKG2_MAGIC)
155
		goto key_found;
156

157
	// Decrypt older pkg2 via new mkeys.
158
	if ((kb >= HOS_KB_VERSION_700) && (kb < HOS_KB_VERSION_MAX))
159
	{
160
		u8 tmp_mkey[SE_KEY_128_SIZE];
161
		u8 decr_slot = 7; // THK mkey or T210B01 mkey.
162
		u8 mkey_seeds_cnt = sizeof(mkey_vector_7xx) / SE_KEY_128_SIZE;
163
		u8 mkey_seeds_idx = mkey_seeds_cnt; // Real index + 1.
164
		u8 mkey_seeds_min_idx = mkey_seeds_cnt - (HOS_KB_VERSION_MAX - kb);
165

166
		while (mkey_seeds_cnt)
167
		{
168
			// Decrypt and validate mkey.
169
			int res = _pkg2_key_unwrap_validate(&mkey_test, hdr, decr_slot,
170
				tmp_mkey, mkey_vector_7xx[mkey_seeds_idx - 1]);
171

172
			if (res)
173
			{
174
				pkg2_keyslot = 9;
175
				goto key_found;
176
			}
177
			else
178
			{
179
				// Set current mkey in order to decrypt a lower mkey.
180
				mkey_seeds_idx--;
181
				se_aes_key_set(9, tmp_mkey, SE_KEY_128_SIZE);
182

183
				decr_slot = 9; // Temp key.
184

185
				// Check if we tried last key for that pkg2 version.
186
				// And start with a lower mkey in case mkey is older.
187
				if (mkey_seeds_idx == mkey_seeds_min_idx)
188
				{
189
					mkey_seeds_cnt--;
190
					mkey_seeds_idx = mkey_seeds_cnt;
191
					decr_slot = 7; // THK mkey or T210B01 mkey.
192
				}
193
			}
194
		}
195
	}
196

197
key_found:
198
	// Decrypt header.
199
	se_aes_crypt_ctr(pkg2_keyslot, hdr, sizeof(pkg2_hdr_t), hdr, sizeof(pkg2_hdr_t), hdr);
200
	//gfx_hexdump((u32)hdr, hdr, 0x100);
201

202
	if (hdr->magic != PKG2_MAGIC)
203
		return NULL;
204

205
	for (u32 i = 0; i < 4; i++)
206
	{
207
DPRINTF("sec %d has size %08X\n", i, hdr->sec_size[i]);
208
		if (!hdr->sec_size[i])
209
			continue;
210

211
		se_aes_crypt_ctr(pkg2_keyslot, pdata, hdr->sec_size[i], pdata, hdr->sec_size[i], &hdr->sec_ctr[i * SE_AES_IV_SIZE]);
212
		//gfx_hexdump((u32)pdata, pdata, 0x100);
213

214
		pdata += hdr->sec_size[i];
215
	}
216

217
	return hdr;
218
}
219

220