Nyx: emuMMC Manage window, Tools UI, and misc updates

- Add gui_emu_tools: emuMMC Manage window with correct positioning (LV_PROTECT_PARENT + re-parent to win) - Tools: single SD button (tap = SD partition manager, 3s hold = eMMC) - Remove emuSD from Nyx UI (tabs, UMS, partition manager); keep bootloader emusd - Shorten Create emuMMC description text by one character - Storage/build/config and dependency updates Co-authored-by: Cursor <cursoragent@cursor.com>
2026-02-20 20:49:48 +01:00
parent 4eead2c14d
commit fed7f05831
81 changed files with 6932 additions and 3462 deletions
--- a/bootloader/hos/hos.c
+++ b/bootloader/hos/hos.c
@@ -2,7 +2,7 @@
 * Copyright (c) 2018 naehrwert
 * Copyright (c) 2018 st4rk
 * Copyright (c) 2018 Ced2911
- * Copyright (c) 2018-2026 CTCaer
+ * Copyright (c) 2018-2025 CTCaer
 * Copyright (c) 2018 balika011
 *
 * This program is free software; you can redistribute it and/or modify it
@@ -28,6 +28,8 @@
 #include "../frontend/fe_tools.h"
 #include "../config.h"
 #include "../storage/emummc.h"
+#include "../storage/emusd.h"
+#include <storage/boot_storage.h>

 //#define DPRINTF(...) gfx_printf(__VA_ARGS__)
 #define DPRINTF(...)
@@ -166,7 +168,7 @@ static void _hos_eks_get()

 		// Decrypt EKS blob.
 		hos_eks_mbr_t *eks = (hos_eks_mbr_t *)(mbr + 0x80);
-		se_aes_crypt_ecb(14, DECRYPT, eks, eks, sizeof(hos_eks_mbr_t));
+		se_aes_crypt_ecb(14, DECRYPT, eks, sizeof(hos_eks_mbr_t), eks, sizeof(hos_eks_mbr_t));

 		// Check if valid and for this unit.
 		if (eks->magic == HOS_EKS_MAGIC && eks->lot0 == FUSE(FUSE_OPT_LOT_CODE_0))
@@ -212,7 +214,7 @@ static void _hos_eks_save()

 		// Get keys.
 		u8 *keys = (u8 *)zalloc(SZ_8K);
-		se_aes_ctx_get_keys(keys + SZ_4K, keys, SE_KEY_128_SIZE);
+		se_get_aes_keys(keys + SZ_4K, keys, SE_KEY_128_SIZE);

 		// Set magic and personalized info.
 		h_cfg.eks->magic   = HOS_EKS_MAGIC;
@@ -227,7 +229,7 @@ static void _hos_eks_save()
 		// Encrypt EKS blob.
 		u8 *eks = malloc(sizeof(hos_eks_mbr_t));
 		memcpy(eks, h_cfg.eks, sizeof(hos_eks_mbr_t));
-		se_aes_crypt_ecb(14, ENCRYPT, eks, eks, sizeof(hos_eks_mbr_t));
+		se_aes_crypt_ecb(14, ENCRYPT, eks, sizeof(hos_eks_mbr_t), eks, sizeof(hos_eks_mbr_t));

 		// Write EKS blob to SD.
 		memcpy(mbr + 0x80, eks, sizeof(hos_eks_mbr_t));
@@ -262,7 +264,7 @@ static void _hos_eks_clear(u32 mkey)
 			// Encrypt EKS blob.
 			u8 *eks = malloc(sizeof(hos_eks_mbr_t));
 			memcpy(eks, h_cfg.eks, sizeof(hos_eks_mbr_t));
-			se_aes_crypt_ecb(14, ENCRYPT, eks, eks, sizeof(hos_eks_mbr_t));
+			se_aes_crypt_ecb(14, ENCRYPT, eks, sizeof(hos_eks_mbr_t), eks, sizeof(hos_eks_mbr_t));

 			// Write EKS blob to SD.
 			memcpy(mbr + 0x80, eks, sizeof(hos_eks_mbr_t));
@@ -350,7 +352,7 @@ static int _hos_keygen(pkg1_eks_t *eks, u32 mkey, tsec_ctxt_t *tsec_ctxt, bool s
 		 */

 		// Use custom TSEC Hovi Keygen firmware.
-		tsec_ctxt->fw = sd_file_read("bootloader/sys/thk.bin", NULL);
+		tsec_ctxt->fw = boot_storage_file_read("bootloader/sys/thk.bin", NULL);
 		if (!tsec_ctxt->fw)
 		{
 			_hos_crit_error("Failed to load thk.bin");
@@ -406,7 +408,7 @@ static int _hos_keygen(pkg1_eks_t *eks, u32 mkey, tsec_ctxt_t *tsec_ctxt, bool s
 		else
 		{
 			// Decrypt eks and set keyslots.
-			se_aes_crypt_ecb(12, DECRYPT, tsec_keys.tmp, eks_keyseeds[0], SE_KEY_128_SIZE);
+			se_aes_crypt_block_ecb(12, DECRYPT, tsec_keys.tmp, eks_keyseeds[0]);
 			se_aes_unwrap_key(15, 14, tsec_keys.tmp);

 			// Derive device keys.
@@ -442,7 +444,7 @@ static int _hos_keygen(pkg1_eks_t *eks, u32 mkey, tsec_ctxt_t *tsec_ctxt, bool s
 		else
 		{
 			// Decrypt eks and set keyslots for Exosphere 2.
-			se_aes_crypt_ecb(12, DECRYPT, tsec_keys.tmp, eks_keyseeds[0], SE_KEY_128_SIZE);
+			se_aes_crypt_block_ecb(12, DECRYPT, tsec_keys.tmp, eks_keyseeds[0]);
 			se_aes_unwrap_key(15, 14, tsec_keys.tmp);

 			// Derive device keys.
@@ -469,9 +471,9 @@ static int _hos_keygen(pkg1_eks_t *eks, u32 mkey, tsec_ctxt_t *tsec_ctxt, bool s
 		se_aes_key_set(13, tsec_keys.tsec, SE_KEY_128_SIZE);

 		// Derive eks keys from TSEC+SBK.
-		se_aes_crypt_ecb(13, DECRYPT, tsec_keys.tsec, eks_keyseeds[0], SE_KEY_128_SIZE);
+		se_aes_crypt_block_ecb(13, DECRYPT, tsec_keys.tsec, eks_keyseeds[0]);
 		se_aes_unwrap_key(15, 14, tsec_keys.tsec);
-		se_aes_crypt_ecb(13, DECRYPT, tsec_keys.tsec, eks_keyseeds[mkey], SE_KEY_128_SIZE);
+		se_aes_crypt_block_ecb(13, DECRYPT, tsec_keys.tsec, eks_keyseeds[mkey]);
 		se_aes_unwrap_key(13, 14, tsec_keys.tsec);

 		// Clear SBK.
@@ -481,21 +483,21 @@ static int _hos_keygen(pkg1_eks_t *eks, u32 mkey, tsec_ctxt_t *tsec_ctxt, bool s
 		// Verify eks CMAC.
 		u8 cmac[SE_KEY_128_SIZE];
 		se_aes_unwrap_key(11, 13, cmac_keyseed);
-		se_aes_hash_cmac(cmac, SE_KEY_128_SIZE, 11, (void *)eks->ctr, sizeof(eks->ctr) + sizeof(eks->keys));
+		se_aes_cmac(cmac, SE_KEY_128_SIZE, 11, (void *)eks->ctr, sizeof(eks->ctr) + sizeof(eks->keys));
 		if (!memcmp(eks->cmac, cmac, SE_KEY_128_SIZE))
 			return 0;
 */

-		se_aes_crypt_ecb(13, DECRYPT, tsec_keys.tsec, cmac_keyseed, SE_KEY_128_SIZE);
+		se_aes_crypt_block_ecb(13, DECRYPT, tsec_keys.tsec, cmac_keyseed);
 		se_aes_unwrap_key(11, 13, cmac_keyseed);

 		// Decrypt eks and set keyslots.
-		se_aes_crypt_ctr(13, &eks->keys, &eks->keys, sizeof(eks_keys_t), eks->ctr);
+		se_aes_crypt_ctr(13, &eks->keys, sizeof(eks_keys_t), &eks->keys, sizeof(eks_keys_t), eks->ctr);
 		se_aes_key_set(11, eks->keys.package1_key,   SE_KEY_128_SIZE);
 		se_aes_key_set(12, eks->keys.master_kekseed, SE_KEY_128_SIZE);
 		se_aes_key_set(13, eks->keys.master_kekseed, SE_KEY_128_SIZE);

-		se_aes_crypt_ecb(12, DECRYPT, tsec_keys.tsec, master_keyseed_retail, SE_KEY_128_SIZE);
+		se_aes_crypt_block_ecb(12, DECRYPT, tsec_keys.tsec, master_keyseed_retail);

 		if (!is_exo)
 		{
@@ -666,7 +668,7 @@ static bool _get_fs_exfat_compatible(link_t *info, u32 *hos_revision)
 		if (strcmp((char *)ki->kip1->name, "FS"))
 			continue;

-		if (!se_sha_hash_256_oneshot(sha_buf, ki->kip1, ki->size))
+		if (!se_calc_sha256_oneshot(sha_buf, ki->kip1, ki->size))
 			break;

 		pkg2_get_ids(&kip_ids, &fs_ids_cnt);
@@ -726,8 +728,14 @@ void hos_launch(ini_sec_t *cfg)
 		goto error;
 	}

+	if (emusd_storage_init_mmc() || !emusd_mount()) {
+		_hos_crit_error("error: Failed to init emuSD.");
+
+		goto error;
+	}
+
 	// Check if SD Card is GPT.
-	if (sd_is_gpt())
+	if (emusd_is_gpt())
 	{
 		_hos_crit_error("SD has GPT only! Run Fix Hybrid MBR!");
 		goto error;
@@ -746,6 +754,8 @@ void hos_launch(ini_sec_t *cfg)
 		// Check if stock is enabled and device can boot in OFW.
 		if (ctxt.stock && (h_cfg.t210b01 || !tools_autorcm_enabled()))
 		{
+			emusd_storage_end();
+			emummc_storage_end();
 			emmc_end();

 			WPRINTF("\nRebooting to OFW in 5s...");
@@ -758,7 +768,8 @@ void hos_launch(ini_sec_t *cfg)

 	mkey = ctxt.pkg1_id->mkey;

-	bool emummc_enabled = emu_cfg.enabled && !h_cfg.emummc_force_disable;
+	//  TODO: separate force_disable for emuSD?
+	bool emummc_enabled = (emu_cfg.enabled || emu_sd_cfg.enabled) && !h_cfg.emummc_force_disable;

 	// Enable emummc patching.
 	if (emummc_enabled)
@@ -839,7 +850,7 @@ void hos_launch(ini_sec_t *cfg)
 				if (h_cfg.t210b01)
 				{
 					u32 bek_vector[4] = {0};
-					se_aes_crypt_ecb(13, ENCRYPT, bek_vector, bek_vector, SE_KEY_128_SIZE);
+					se_aes_crypt_ecb(13, ENCRYPT, bek_vector, SE_KEY_128_SIZE, bek_vector, SE_KEY_128_SIZE);
 					if (bek_vector[0] == 0x59C14895) // Encrypted zeroes first 32bits.
 						EPRINTF("Pkg1 corrupt?");
 					else
@@ -947,9 +958,9 @@ void hos_launch(ini_sec_t *cfg)
 			// Hash only Kernel when it embeds INI1.
 			u8 kernel_hash[0x20];
 			if (!ctxt.new_pkg2)
-				se_sha_hash_256_oneshot(kernel_hash, ctxt.kernel, ctxt.kernel_size);
+				se_calc_sha256_oneshot(kernel_hash, ctxt.kernel, ctxt.kernel_size);
 			else
-				se_sha_hash_256_oneshot(kernel_hash, ctxt.kernel + PKG2_NEWKERN_START,
+				se_calc_sha256_oneshot(kernel_hash, ctxt.kernel + PKG2_NEWKERN_START,
 					pkg2_newkern_ini1_start - PKG2_NEWKERN_START);

 			ctxt.pkg2_kernel_id = pkg2_identify(kernel_hash);
@@ -989,12 +1000,12 @@ void hos_launch(ini_sec_t *cfg)
 	LIST_FOREACH_ENTRY(merge_kip_t, mki, &ctxt.kip1_list, link)
 		pkg2_merge_kip(&kip1_info, (pkg2_kip1_t *)mki->kip1);

-	// Check if FS is compatible with exFAT and if 5.1.0 or 10.2.0.
+	// Check if FS is compatible with exFAT and if 5.1.0.
 	if (!ctxt.stock && (sd_fs.fs_type == FS_EXFAT || mkey == HOS_MKEY_VER_500 || ctxt.pkg1_id->fuses == 13))
 	{
 		bool exfat_compat = _get_fs_exfat_compatible(&kip1_info, &ctxt.exo_ctx.hos_revision);

-		if (sd_fs.fs_type == FS_EXFAT && !exfat_compat)
+		if (emusd_get_fs_type() == FS_EXFAT && !exfat_compat)
 		{
 			_hos_crit_error("SD Card is exFAT but installed HOS driver\nonly supports FAT32!");

@@ -1008,14 +1019,14 @@ void hos_launch(ini_sec_t *cfg)
 	{
 		EHPRINTFARGS("Failed to apply '%s'!", failed_patch);

-		bool emu_patch_failed = !strcmp(failed_patch, "emummc");
-		if (!emu_patch_failed)
+		bool emmc_patch_failed = !strcmp(failed_patch, "emummc");
+		if (!emmc_patch_failed)
 		{
 			gfx_puts("\nPress POWER to continue.\nPress VOL to go to the menu.\n");
 			display_backlight_brightness(h_cfg.backlight, 1000);
 		}

-		if (emu_patch_failed || !(btn_wait() & BTN_POWER))
+		if (emmc_patch_failed || !(btn_wait() & BTN_POWER))
 			goto error; // MUST stop here, because if user requests 'nogc' but it's not applied, their GC controller gets updated!
 	}

@@ -1027,6 +1038,9 @@ void hos_launch(ini_sec_t *cfg)
 		config_exosphere(&ctxt, warmboot_base);

 	// Unmount SD card and eMMC.
+	emummc_storage_end();
+	emusd_storage_end();
+	boot_storage_end();
 	sd_end();
 	emmc_end();

@@ -1127,6 +1141,8 @@ void hos_launch(ini_sec_t *cfg)

 error:
 	_free_launch_components(&ctxt);
+	emummc_storage_end();
+	emusd_storage_end();
 	emmc_end();

 	EPRINTF("\nFailed to launch HOS!");
--- a/bootloader/hos/hos_config.c
+++ b/bootloader/hos/hos_config.c
@@ -15,6 +15,8 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

+#include <storage/boot_storage.h>
+#include "../storage/emusd.h"
 #include <string.h>

 #include <bdk.h>
@@ -29,7 +31,7 @@

 static int _config_warmboot(launch_ctxt_t *ctxt, const char *value)
 {
-	ctxt->warmboot = sd_file_read(value, &ctxt->warmboot_size);
+	ctxt->warmboot = emusd_file_read(value, &ctxt->warmboot_size);
 	if (!ctxt->warmboot)
 		return 0;

@@ -38,7 +40,7 @@ static int _config_warmboot(launch_ctxt_t *ctxt, const char *value)

 static int _config_secmon(launch_ctxt_t *ctxt, const char *value)
 {
-	ctxt->secmon = sd_file_read(value, &ctxt->secmon_size);
+	ctxt->secmon = emusd_file_read(value, &ctxt->secmon_size);
 	if (!ctxt->secmon)
 		return 0;

@@ -47,7 +49,7 @@ static int _config_secmon(launch_ctxt_t *ctxt, const char *value)

 static int _config_kernel(launch_ctxt_t *ctxt, const char *value)
 {
-	ctxt->kernel = sd_file_read(value, &ctxt->kernel_size);
+	ctxt->kernel = emusd_file_read(value, &ctxt->kernel_size);
 	if (!ctxt->kernel)
 		return 0;

@@ -61,11 +63,12 @@ static int _config_kip1(launch_ctxt_t *ctxt, const char *value)
 	if (value[strlen(value) - 1] == '*')
 	{
 		char *dir = (char *)malloc(256);
-		strcpy(dir, value);
+		strcpy(dir, "emusd:");
+		strcat(dir, value);

 		u32 dirlen = 0;
 		dir[strlen(dir) - 2] = 0;
-		dirlist_t *filelist = dirlist(dir, "*.kip*", 0);
+		dirlist_t *filelist = dirlist(dir, "*.kip*", false, false);

 		strcat(dir, "/");
 		dirlen = strlen(dir);
@@ -81,7 +84,7 @@ static int _config_kip1(launch_ctxt_t *ctxt, const char *value)
 				strcpy(dir + dirlen, filelist->name[i]);

 				merge_kip_t *mkip1 = (merge_kip_t *)malloc(sizeof(merge_kip_t));
-				mkip1->kip1 = sd_file_read(dir, &size);
+				mkip1->kip1 = emusd_file_read(dir + 6, &size);
 				if (!mkip1->kip1)
 				{
 					free(mkip1);
@@ -103,7 +106,7 @@ static int _config_kip1(launch_ctxt_t *ctxt, const char *value)
 	else
 	{
 		merge_kip_t *mkip1 = (merge_kip_t *)malloc(sizeof(merge_kip_t));
-		mkip1->kip1 = sd_file_read(value, &size);
+		mkip1->kip1 = emusd_file_read(value, &size);
 		if (!mkip1->kip1)
 		{
 			free(mkip1);
@@ -169,7 +172,7 @@ static int _config_stock(launch_ctxt_t *ctxt, const char *value)
 {
 	if (*value == '1')
 	{
-		DPRINTF("Enabled stock mode\n");
+		DPRINTF("Disabled all patching\n");
 		ctxt->stock = true;
 	}
 	return 1;
@@ -262,7 +265,7 @@ static int _config_pkg3(launch_ctxt_t *ctxt, const char *value)

 static int _config_exo_fatal_payload(launch_ctxt_t *ctxt, const char *value)
 {
-	ctxt->exofatal = sd_file_read(value, &ctxt->exofatal_size);
+	ctxt->exofatal = emusd_file_read(value, &ctxt->exofatal_size);
 	if (!ctxt->exofatal)
 		return 0;

--- a/bootloader/hos/pkg1.c
+++ b/bootloader/hos/pkg1.c
@@ -17,6 +17,8 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

+#include <storage/boot_storage.h>
+#include "../storage/emusd.h"
 #include <string.h>
 #include <stdlib.h>

@@ -205,7 +207,7 @@ int pkg1_decrypt(const pkg1_id_t *id, u8 *pkg1)
 		u8 *pkg11 = pkg1 + id->pkg11_off;
 		u32 pkg11_size = *(u32 *)pkg11;
 		hdr = (pk11_hdr_t *)(pkg11 + 0x20);
-		se_aes_crypt_ctr(11, hdr, hdr, pkg11_size, pkg11 + 0x10);
+		se_aes_crypt_ctr(11, hdr, pkg11_size, hdr, pkg11_size, pkg11 + 0x10);
 	}
 	else
 	{
@@ -216,7 +218,7 @@ int pkg1_decrypt(const pkg1_id_t *id, u8 *pkg1)
 		// Use BEK for T210B01.
 		// Additionally, skip 0x20 bytes from decryption to maintain the header.
 		se_aes_iv_clear(13);
-		se_aes_crypt_cbc(13, DECRYPT, pkg1 + 0x20, pkg1 + 0x20, oem_hdr->size - 0x20);
+		se_aes_crypt_cbc(13, DECRYPT, pkg1 + 0x20, oem_hdr->size - 0x20, pkg1 + 0x20, oem_hdr->size - 0x20);
 	}

 	// Return if header is valid.
--- a/bootloader/hos/pkg2.c
+++ b/bootloader/hos/pkg2.c
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2018 naehrwert
- * Copyright (c) 2018-2026 CTCaer
+ * Copyright (c) 2018-2025 CTCaer
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
@@ -15,6 +15,7 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

+#include <storage/boot_storage.h>
 #include <string.h>

 #include <bdk.h>
@@ -27,6 +28,7 @@
 #include <libs/compr/blz.h>
 #include <libs/fatfs/ff.h>
 #include "../storage/emummc.h"
+#include "../storage/emusd.h"

 //#define DPRINTF(...) gfx_printf(__VA_ARGS__)
 #define DPRINTF(...)
@@ -64,6 +66,7 @@ static void parse_external_kip_patches()
 		return;

 	LIST_INIT(ini_kip_sections);
+	// TODO: load frome emusd?
 	if (ini_patch_parse(&ini_kip_sections, "bootloader/patches.ini"))
 	{
 		// Copy ids into a new patchset.
@@ -374,7 +377,7 @@ static int _kipm_inject(const char *kipm_path, char *target_name, pkg2_kip1_info
 	if (!strcmp((char *)ki->kip1->name, target_name))
 	{
 		u32 size = 0;
-		u8 *kipm_data = (u8 *)sd_file_read(kipm_path, &size);
+		u8 *kipm_data = (u8 *)boot_storage_file_read(kipm_path, &size);
 		if (!kipm_data)
 			return 1;

@@ -544,7 +547,7 @@ const char *pkg2_patch_kips(link_t *info, char *patch_names)

 			// Check if current KIP not hashed and hash it.
 			if (kip_hash[0] == 0)
-				if (!se_sha_hash_256_oneshot(kip_hash, ki->kip1, ki->size))
+				if (!se_calc_sha256_oneshot(kip_hash, ki->kip1, ki->size))
 					memset(kip_hash, 0, sizeof(kip_hash));

 			// Check if kip is the expected version.
@@ -656,6 +659,8 @@ const char *pkg2_patch_kips(link_t *info, char *patch_names)
 				if (kip_id_idx > 17)
 					emu_cfg.fs_ver -= 2;

+				emu_sd_cfg.fs_ver = emu_cfg.fs_ver;
+
 				// Inject emuMMC code.
 				gfx_printf("Injecting emuMMC. FS ID: %d\n", emu_cfg.fs_ver);
 				if (_kipm_inject("bootloader/sys/emummc.kipm", "FS", ki))
@@ -708,7 +713,7 @@ pkg2_hdr_t *pkg2_decrypt(void *data, u8 mkey, bool is_exo)
 		u8 tmp_mkey[SE_KEY_128_SIZE];

 		// Decrypt 7.0.0 encrypted mkey.
-		se_aes_crypt_ecb(!is_exo ? 7 : 13, DECRYPT, tmp_mkey, mkey_vector_7xx, SE_KEY_128_SIZE);
+		se_aes_crypt_ecb(!is_exo ? 7 : 13, DECRYPT, tmp_mkey, SE_KEY_128_SIZE, mkey_vector_7xx, SE_KEY_128_SIZE);

 		// Set and unwrap pkg2 key.
 		se_aes_key_set(9, tmp_mkey, SE_KEY_128_SIZE);
@@ -718,7 +723,7 @@ pkg2_hdr_t *pkg2_decrypt(void *data, u8 mkey, bool is_exo)
 	}

 	// Decrypt header.
-	se_aes_crypt_ctr(pkg2_keyslot, hdr, hdr, sizeof(pkg2_hdr_t), hdr);
+	se_aes_crypt_ctr(pkg2_keyslot, hdr, sizeof(pkg2_hdr_t), hdr, sizeof(pkg2_hdr_t), hdr);

 	if (hdr->magic != PKG2_MAGIC)
 		return NULL;
@@ -730,7 +735,7 @@ DPRINTF("sec %d has size %08X\n", i, hdr->sec_size[i]);
 		if (!hdr->sec_size[i])
 			continue;

-		se_aes_crypt_ctr(pkg2_keyslot, pdata, pdata, hdr->sec_size[i], hdr->sec_ctr[i]);
+		se_aes_crypt_ctr(pkg2_keyslot, pdata, hdr->sec_size[i], pdata, hdr->sec_size[i], &hdr->sec_ctr[i * SE_AES_IV_SIZE]);

 		pdata += hdr->sec_size[i];
 	}
@@ -776,7 +781,7 @@ DPRINTF("adding kip1 '%s' @ %08X (%08X)\n", (char *)ki->kip1->name, (u32)ki->kip
 	{
 		hdr->sec_size[PKG2_SEC_INI1] = ini1_size;
 		hdr->sec_off[PKG2_SEC_INI1] = 0x14080000;
-		se_aes_crypt_ctr(8, ini1, ini1, ini1_size, hdr->sec_ctr[PKG2_SEC_INI1]);
+		se_aes_crypt_ctr(8, ini1, ini1_size, ini1, ini1_size, &hdr->sec_ctr[PKG2_SEC_INI1 * SE_AES_IV_SIZE]);
 	}
 	else
 	{
@@ -854,7 +859,7 @@ DPRINTF("%s @ %08X (%08X)\n", is_meso ? "Mesosphere": "kernel",(u32)ctxt->kernel
 		kernel_size += ini1_size;
 	}
 	hdr->sec_size[PKG2_SEC_KERNEL] = kernel_size;
-	se_aes_crypt_ctr(pkg2_keyslot, pdst, pdst, kernel_size, hdr->sec_ctr[PKG2_SEC_KERNEL]);
+	se_aes_crypt_ctr(pkg2_keyslot, pdst, kernel_size, pdst, kernel_size, &hdr->sec_ctr[PKG2_SEC_KERNEL * SE_AES_IV_SIZE]);
 	pdst += kernel_size;
 DPRINTF("kernel encrypted\n");

@@ -870,7 +875,7 @@ DPRINTF("INI1 encrypted\n");
 		u8 *pk2_hash_data = (u8 *)dst + 0x100 + sizeof(pkg2_hdr_t);
 		for (u32 i = PKG2_SEC_KERNEL; i <= PKG2_SEC_UNUSED; i++)
 		{
-			se_sha_hash_256_oneshot(hdr->sec_sha256[i], (void *)pk2_hash_data, hdr->sec_size[i]);
+			se_calc_sha256_oneshot(&hdr->sec_sha256[SE_SHA_256_SIZE * i], (void *)pk2_hash_data, hdr->sec_size[i]);
 			pk2_hash_data += hdr->sec_size[i];
 		}
 	}
@@ -878,7 +883,7 @@ DPRINTF("INI1 encrypted\n");
 	// Encrypt header.
 	*(u32 *)hdr->ctr = 0x100 + sizeof(pkg2_hdr_t) + kernel_size + ini1_size;
 	hdr->ctr[4] = key_ver;
-	se_aes_crypt_ctr(pkg2_keyslot, hdr, hdr, sizeof(pkg2_hdr_t), hdr);
+	se_aes_crypt_ctr(pkg2_keyslot, hdr, sizeof(pkg2_hdr_t), hdr, sizeof(pkg2_hdr_t), hdr);
 	memset(hdr->ctr, 0 , SE_AES_IV_SIZE);
 	*(u32 *)hdr->ctr = 0x100 + sizeof(pkg2_hdr_t) + kernel_size + ini1_size;
 	hdr->ctr[4] = key_ver;
--- a/bootloader/hos/pkg2.h
+++ b/bootloader/hos/pkg2.h
@@ -1,6 +1,6 @@
 /*
 * Copyright (c) 2018 naehrwert
- * Copyright (c) 2018-2026 CTCaer
+ * Copyright (c) 2018-2025 CTCaer
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
@@ -71,7 +71,7 @@ enum
 typedef struct _pkg2_hdr_t
 {
 /* 0x000 */	u8  ctr[0x10];
-/* 0x010 */	u8  sec_ctr[4][SE_AES_IV_SIZE];
+/* 0x010 */	u8  sec_ctr[0x40];
 /* 0x050 */	u32 magic;
 /* 0x054 */	u32 base;
 /* 0x058 */	u32 pad0;
@@ -80,7 +80,7 @@ typedef struct _pkg2_hdr_t
 /* 0x05E */	u16 pad1;
 /* 0x060 */	u32 sec_size[4];
 /* 0x070 */	u32 sec_off[4];
-/* 0x080 */	u8  sec_sha256[4][SE_SHA_256_SIZE];
+/* 0x080 */	u8  sec_sha256[0x80];
 /* 0x100 */	u8  data[];
 } pkg2_hdr_t;

--- a/bootloader/hos/pkg3.c
+++ b/bootloader/hos/pkg3.c
@@ -16,6 +16,8 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

+#include <storage/boot_storage.h>
+#include "../storage/emusd.h"
 #include <string.h>

 #include <bdk.h>
@@ -29,7 +31,7 @@
 //#define DPRINTF(...) gfx_printf(__VA_ARGS__)
 #define DPRINTF(...)

-extern bool is_ipl_updated(void *buf, u32 size, const char *path, bool force);
+extern bool is_ipl_updated(void *buf, const char *path, bool force);

 #define PKG3_KIP_SKIP_MAX 16

@@ -84,10 +86,9 @@ typedef struct _pkg3_content_t

 static void _pkg3_update_r2p()
 {
-	u32 size = 0;
-	u8 *r2p_payload = sd_file_read("atmosphere/reboot_payload.bin", &size);
+	u8 *r2p_payload = emusd_file_read("atmosphere/reboot_payload.bin", NULL);

-	is_ipl_updated(r2p_payload, size, "atmosphere/reboot_payload.bin", h_cfg.updater2p ? true : false);
+	is_ipl_updated(r2p_payload, "emusd:atmosphere/reboot_payload.bin", h_cfg.updater2p ? true : false);

 	free(r2p_payload);
 }
@@ -125,6 +126,10 @@ static int _pkg3_kip1_skip(char ***pkg3_kip1_skip, u32 *pkg3_kip1_skip_num, char

 int parse_pkg3(launch_ctxt_t *ctxt, const char *path)
 {
+	char *path1 = (char *)malloc(256);
+	strcpy(path1, "emusd:");
+	strcat(path1, path);
+
 	FIL fp;

 	char **pkg3_kip1_skip = NULL;
@@ -152,16 +157,25 @@ int parse_pkg3(launch_ctxt_t *ctxt, const char *path)
 	}

 #ifdef HOS_MARIKO_STOCK_SECMON
-	if (stock && emummc_disabled && (pkg1_old || h_cfg.t210b01))
+	if (stock && emummc_disabled && (pkg1_old || h_cfg.t210b01)) {
+		free(path1);
 		return 1;
+	}
+
 #else
-	if (stock && emummc_disabled && pkg1_old)
+	if (stock && emummc_disabled && pkg1_old) {
+		free(path1);
 		return 1;
+	}
+
 #endif

 	// Try to open PKG3.
-	if (f_open(&fp, path, FA_READ) != FR_OK)
+	if (f_open(&fp, path1, FA_READ) != FR_OK) {
+		free(path1);
 		return 0;
+	}
+

 	void *pkg3 = malloc(f_size(&fp));

@@ -267,6 +281,7 @@ int parse_pkg3(launch_ctxt_t *ctxt, const char *path)
 		_pkg3_update_r2p();

 		free(pkg3_kip1_skip);
+		free(path1);

 		return 1;
 	}
--- a/bootloader/hos/secmon_exo.c
+++ b/bootloader/hos/secmon_exo.c
@@ -24,12 +24,15 @@
 #include "../config.h"
 #include <libs/fatfs/ff.h>
 #include "../storage/emummc.h"
+#include "../storage/emusd.h"

 enum emuMMC_Type
 {
-	emuMMC_None = 0,
-	emuMMC_Partition,
-	emuMMC_File,
+	EmummcType_None           = 0,
+    EmummcType_Partition_Sd   = 1,
+    EmummcType_File_Sd        = 2,
+    EmummcType_Partition_Emmc = 3,
+    EmummcType_File_Emmc      = 4,
 	emuMMC_MAX
 };

@@ -64,6 +67,22 @@ typedef struct
 		emummc_file_config_t file_cfg;
 	};
 	char nintendo_path[EMUMMC_FILE_PATH_MAX];
+} emummc_emmc_config_t;
+
+typedef struct
+{
+	emummc_base_config_t base_cfg;
+	union 
+	{
+		emummc_partition_config_t partition_cfg;
+		emummc_file_config_t file_cfg;
+	};
+} emummc_sd_config_t;
+
+typedef struct
+{
+	emummc_emmc_config_t emmc_cfg;
+	emummc_sd_config_t sd_cfg;
 } exo_emummc_config_t;

 typedef struct _exo_cfg_t
@@ -75,7 +94,8 @@ typedef struct _exo_cfg_t
 	u8  uart_port;
 	u8  uart_invert;
 	u32 uart_baudrate;
-	u32 rsvd1[2];
+	u8  memory_mode_auto;
+	u8  rsvd1[7];
 	exo_emummc_config_t emummc_cfg;
 } exo_cfg_t;

@@ -206,7 +226,7 @@ void config_exosphere(launch_ctxt_t *ctxt, u32 warmboot_base)
 	if (!ctxt->stock)
 	{
 		LIST_INIT(ini_exo_sections);
-		if (ini_parse(&ini_exo_sections, "exosphere.ini", false))
+		if (ini_parse(&ini_exo_sections, "emusd:exosphere.ini", false))
 		{
 			LIST_FOREACH_ENTRY(ini_sec_t, ini_sec, &ini_exo_sections, link)
 			{
@@ -214,6 +234,7 @@ void config_exosphere(launch_ctxt_t *ctxt, u32 warmboot_base)
 				if (!(ini_sec->type == INI_CHOICE) || strcmp(ini_sec->name, "exosphere"))
 					continue;

+
 				LIST_FOREACH_ENTRY(ini_kv_t, kv, &ini_sec->kvs, link)
 				{
 					if (!strcmp("debugmode_user", kv->key))
@@ -224,12 +245,14 @@ void config_exosphere(launch_ctxt_t *ctxt, u32 warmboot_base)
 						exo_cfg->uart_invert = atoi(kv->val);
 					else if (!strcmp("log_baud_rate", kv->key))
 						exo_cfg->uart_baudrate = atoi(kv->val);
+					else if (!strcmp("memory_mode_auto", kv->key)) {
+						exo_cfg->memory_mode_auto = atoi(kv->val);
+					}
 					else if (emu_cfg.enabled && !h_cfg.emummc_force_disable)
 					{
 						if (!strcmp("blank_prodinfo_emummc", kv->key))
 							cal0_blanking = atoi(kv->val);
-					}
-					else
+					} else
 					{
 						if (!strcmp("blank_prodinfo_sysmmc", kv->key))
 							cal0_blanking = atoi(kv->val);
@@ -245,7 +268,7 @@ void config_exosphere(launch_ctxt_t *ctxt, u32 warmboot_base)
 		if (!ctxt->exo_ctx.usb3_force)
 		{
 			LIST_INIT(ini_sys_sections);
-			if (ini_parse(&ini_sys_sections, "atmosphere/config/system_settings.ini", false))
+			if (ini_parse(&ini_sys_sections, "emusd:atmosphere/config/system_settings.ini", false))
 			{
 				LIST_FOREACH_ENTRY(ini_sec_t, ini_sec, &ini_sys_sections, link)
 				{
@@ -314,22 +337,72 @@ void config_exosphere(launch_ctxt_t *ctxt, u32 warmboot_base)
 		pkg1_warmboot_rsa_mod(warmboot_base);
 	}

+	// By default, disable emuMMC
+	exo_cfg->emummc_cfg.emmc_cfg.base_cfg.magic = EMUMMC_MAGIC;
+	exo_cfg->emummc_cfg.emmc_cfg.base_cfg.type  = EmummcType_None;
 	if (emu_cfg.enabled && !h_cfg.emummc_force_disable)
 	{
-		exo_cfg->emummc_cfg.base_cfg.magic = EMUMMC_MAGIC;
-		exo_cfg->emummc_cfg.base_cfg.type = emu_cfg.sector ? emuMMC_Partition : emuMMC_File;
-		exo_cfg->emummc_cfg.base_cfg.fs_ver = emu_cfg.fs_ver;
-		exo_cfg->emummc_cfg.base_cfg.id = emu_cfg.id;
+		exo_cfg->emummc_cfg.emmc_cfg.base_cfg.fs_ver = emu_cfg.fs_ver;
+		exo_cfg->emummc_cfg.sd_cfg.base_cfg.fs_ver   = emu_sd_cfg.fs_ver;
+		
+		exo_cfg->emummc_cfg.emmc_cfg.base_cfg.id     = emu_cfg.id;
+		if (emu_cfg.enabled == 4 && emu_cfg.sector) {
+			// emmc partition based
+			exo_cfg->emummc_cfg.emmc_cfg.base_cfg.type = EmummcType_Partition_Emmc;
+		} else if (emu_cfg.enabled == 4 && !emu_cfg.sector) {
+			// emmc file based
+			exo_cfg->emummc_cfg.emmc_cfg.base_cfg.type = EmummcType_File_Emmc;
+		} else if (emu_cfg.enabled == 1 && emu_cfg.sector) {
+			// sd partition based
+			exo_cfg->emummc_cfg.emmc_cfg.base_cfg.type = EmummcType_Partition_Sd;
+		} else if (emu_cfg.enabled == 1 && !emu_cfg.sector) {
+			// sd file based
+			exo_cfg->emummc_cfg.emmc_cfg.base_cfg.type = EmummcType_File_Sd;
+		} else {
+			// disabled
+			exo_cfg->emummc_cfg.emmc_cfg.base_cfg.type = EmummcType_None;
+		}

 		if (emu_cfg.sector)
-			exo_cfg->emummc_cfg.partition_cfg.start_sector = emu_cfg.sector;
+			exo_cfg->emummc_cfg.emmc_cfg.partition_cfg.start_sector = emu_cfg.sector;
 		else
-			strcpy((char *)exo_cfg->emummc_cfg.file_cfg.path, emu_cfg.path);
+			strcpy((char *)exo_cfg->emummc_cfg.emmc_cfg.file_cfg.path, emu_cfg.path);

 		if (!ctxt->stock && emu_cfg.nintendo_path && emu_cfg.nintendo_path[0])
-			strcpy((char *)exo_cfg->emummc_cfg.nintendo_path, emu_cfg.nintendo_path);
+			strcpy((char *)exo_cfg->emummc_cfg.emmc_cfg.nintendo_path, emu_cfg.nintendo_path);
 		else
-			strcpy((char *)exo_cfg->emummc_cfg.nintendo_path, "Nintendo");
+			strcpy((char *)exo_cfg->emummc_cfg.emmc_cfg.nintendo_path, "Nintendo");
+	}
+
+	exo_cfg->emummc_cfg.sd_cfg.base_cfg.magic = EMUMMC_MAGIC;
+	exo_cfg->emummc_cfg.sd_cfg.base_cfg.type  = EmummcType_None;
+	if (emu_sd_cfg.enabled) 
+	{
+		exo_cfg->emummc_cfg.sd_cfg.base_cfg.fs_ver   = emu_sd_cfg.fs_ver;
+		exo_cfg->emummc_cfg.emmc_cfg.base_cfg.fs_ver = emu_sd_cfg.fs_ver;
+
+		exo_cfg->emummc_cfg.sd_cfg.base_cfg.id     = emu_sd_cfg.id;
+		if (emu_sd_cfg.enabled == 4 && emu_sd_cfg.sector) {
+			// emmc partition based
+			exo_cfg->emummc_cfg.sd_cfg.base_cfg.type = EmummcType_Partition_Emmc;
+		} else if (emu_sd_cfg.enabled == 4 && !emu_sd_cfg.sector) {
+			// emmc file based
+			exo_cfg->emummc_cfg.sd_cfg.base_cfg.type = EmummcType_File_Emmc;
+		} else if (emu_sd_cfg.enabled == 1 && emu_sd_cfg.sector) {
+			// sd partition based
+			exo_cfg->emummc_cfg.sd_cfg.base_cfg.type = EmummcType_Partition_Sd;
+		} else if (emu_sd_cfg.enabled == 1 && !emu_sd_cfg.sector) {
+			// sd file based
+			exo_cfg->emummc_cfg.sd_cfg.base_cfg.type = EmummcType_File_Sd;
+		} else {
+			// disabled
+			exo_cfg->emummc_cfg.sd_cfg.base_cfg.type = EmummcType_None;
+		}
+
+		if (emu_sd_cfg.sector)
+			exo_cfg->emummc_cfg.sd_cfg.partition_cfg.start_sector = emu_sd_cfg.sector;
+		else
+			strcpy((char *)exo_cfg->emummc_cfg.sd_cfg.file_cfg.path, emu_sd_cfg.path);
 	}

 	// Copy over exosphere fatal for Mariko.