/* * Copyright (c) Atmosphère-NX * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include <exosphere.hpp> #include <exosphere/secmon/secmon_monitor_context.hpp> #include "fusee_key_derivation.hpp" #include "fusee_external_package.hpp" #include "fusee_setup_horizon.hpp" #include "fusee_ini.hpp" #include "fusee_emummc.hpp" #include "fusee_mmc.hpp" #include "fusee_cpu.hpp" #include "fusee_fatal.hpp" #include "fusee_package2.hpp" #include "fusee_malloc.hpp" #include "fusee_secmon_sync.hpp" #include "fusee_stratosphere.hpp" #include "fs/fusee_fs_api.hpp" namespace ams::nxboot { namespace { constexpr inline const uintptr_t CLKRST = secmon::MemoryRegionPhysicalDeviceClkRst.GetAddress(); constexpr inline const uintptr_t PMC = secmon::MemoryRegionPhysicalDevicePmc.GetAddress(); constexpr inline const uintptr_t MC = secmon::MemoryRegionPhysicalDeviceMemoryController.GetAddress(); constinit secmon::EmummcConfiguration g_emummc_cfg = {}; void DeriveAllKeys(const fuse::SocType soc_type) { /* If on erista, run the TSEC keygen firmware. */ if (soc_type == fuse::SocType_Erista) { clkrst::SetBpmpClockRate(clkrst::BpmpClockRate_408MHz); if (!tsec::RunTsecFirmware(GetExternalPackage().tsec_keygen, sizeof(GetExternalPackage().tsec_keygen))) { ShowFatalError("Failed to run tsec_keygen firmware!\n"); } clkrst::SetBpmpClockRate(clkrst::BpmpClockRate_576MHz); } /* Derive master/device keys. */ if (soc_type == fuse::SocType_Erista) { DeriveKeysErista(); } else /* if (soc_type == fuse::SocType_Mariko) */ { DeriveKeysMariko(); } } bool ParseIniSafe(IniSectionList &out_sections, const char *ini_path) { const auto result = ParseIniFile(out_sections, ini_path); if (result == ParseIniResult_Success) { return true; } else if (result == ParseIniResult_NoFile) { return false; } else { ShowFatalError("Failed to parse %s!\n", ini_path); } } u32 ParseHexInteger(const char *s) { u32 x = 0; if (s[0] == '0' && s[1] == 'x') { s += 2; } while (true) { const char c = *(s++); if (c == '\x00') { return x; } else { x <<= 4; if ('0' <= c && c <= '9') { x |= (c - '0'); } else if ('a' <= c && c <= 'f') { x |= (c - 'a') + 10; } else if ('A' <= c && c <= 'F') { x |= (c - 'A') + 10; } } } } u32 ParseDecimalInteger(const char *s) { u32 x = 0; while (true) { const char c = *(s++); if (c == '\x00') { return x; } else { x *= 10; if ('0' <= c && c <= '9') { x += c - '0'; } } } } bool IsDirectoryExist(const char *path) { fs::DirectoryEntryType entry_type; bool archive; return R_SUCCEEDED(fs::GetEntryType(std::addressof(entry_type), std::addressof(archive), path)) && entry_type == fs::DirectoryEntryType_Directory; } bool IsFileExist(const char *path) { fs::DirectoryEntryType entry_type; bool archive; return R_SUCCEEDED(fs::GetEntryType(std::addressof(entry_type), std::addressof(archive), path)) && entry_type == fs::DirectoryEntryType_File; } bool ConfigureEmummc() { /* Set magic. */ g_emummc_cfg.base_cfg.magic = secmon::EmummcBaseConfiguration::Magic; /* Parse ini. */ bool enabled = false; u32 id = 0; u32 sector = 0; const char *path = ""; const char *n_path = ""; { IniSectionList sections; if (ParseIniSafe(sections, "sdmc:/emummc/emummc.ini")) { for (const auto §ion : sections) { /* We only care about the [emummc] section. */ if (std::strcmp(section.name, "emummc")) { continue; } /* Handle individual fields. */ for (const auto &entry : section.kv_list) { if (std::strcmp(entry.key, "enabled") == 0) { enabled = entry.value[0] != '0'; } else if (std::strcmp(entry.key, "id") == 0) { id = ParseHexInteger(entry.value); } else if (std::strcmp(entry.key, "sector") == 0) { sector = ParseHexInteger(entry.value); } else if (std::strcmp(entry.key, "path") == 0) { path = entry.value; } else if (std::strcmp(entry.key, "nintendo_path") == 0) { n_path = entry.value; } } } } } /* Set values parsed from config. */ g_emummc_cfg.base_cfg.id = id; std::strncpy(g_emummc_cfg.emu_dir_path.str, n_path, sizeof(g_emummc_cfg.emu_dir_path.str)); g_emummc_cfg.emu_dir_path.str[sizeof(g_emummc_cfg.emu_dir_path.str) - 1] = '\x00'; if (enabled) { if (sector > 0) { g_emummc_cfg.base_cfg.type = secmon::EmummcType_Partition; g_emummc_cfg.partition_cfg.start_sector = sector; } else if (path[0] != '\x00' && IsDirectoryExist(path)) { g_emummc_cfg.base_cfg.type = secmon::EmummcType_File; std::strncpy(g_emummc_cfg.file_cfg.path.str, path, sizeof(g_emummc_cfg.file_cfg.path.str)); g_emummc_cfg.file_cfg.path.str[sizeof(g_emummc_cfg.file_cfg.path.str) - 1] = '\x00'; } else { ShowFatalError("Invalid emummc setting!\n"); } } return enabled; } u8 *LoadPackage1(fuse::SocType soc_type) { u8 *package1 = static_cast<u8 *>(AllocateAligned(0x40000, 0x1000)); const Result result = ReadBoot0(0x100000, package1, 0x40000); if (R_FAILED(result)) { ShowFatalError("Failed to read boot0: 0x%08" PRIx32 "!\n", result.GetValue()); } if (soc_type == fuse::SocType_Mariko) { package1 += 0x170; se::DecryptAes128Cbc(package1 + 0x20, 0x40000 - (0x20 + 0x170), pkg1::AesKeySlot_MarikoBek, package1 + 0x20, 0x40000 - (0x20 + 0x170), package1 + 0x10, se::AesBlockSize); hw::InvalidateDataCache(package1 + 0x20, 0x40000 - (0x20 + 0x170)); if (std::memcmp(package1, package1 + 0x20, 0x20) != 0) { ShowFatalError("Package1 seems corrupt!\n"); } } return package1; } ams::TargetFirmware GetApproximateTargetFirmware(const u8 *package1) { /* Get an approximation of the target firmware. */ switch (package1[0x1F]) { case 0x01: return ams::TargetFirmware_1_0_0; case 0x02: return ams::TargetFirmware_2_0_0; case 0x04: return ams::TargetFirmware_3_0_0; case 0x07: return ams::TargetFirmware_4_0_0; case 0x0B: return ams::TargetFirmware_5_0_0; case 0x0E: if (std::memcmp(package1 + 0x10, "20180802", 8) == 0) { return ams::TargetFirmware_6_0_0; } else if (std::memcmp(package1 + 0x10, "20181107", 8) == 0) { return ams::TargetFirmware_6_2_0; } break; case 0x0F: return ams::TargetFirmware_7_0_0; case 0x10: if (std::memcmp(package1 + 0x10, "20190314", 8) == 0) { return ams::TargetFirmware_8_0_0; } else if (std::memcmp(package1 + 0x10, "20190531", 8) == 0) { return ams::TargetFirmware_8_1_0; } else if (std::memcmp(package1 + 0x10, "20190809", 8) == 0) { return ams::TargetFirmware_9_0_0; } else if (std::memcmp(package1 + 0x10, "20191021", 8) == 0) { return ams::TargetFirmware_9_1_0; } else if (std::memcmp(package1 + 0x10, "20200303", 8) == 0) { return ams::TargetFirmware_10_0_0; } else if (std::memcmp(package1 + 0x10, "20201030", 8) == 0) { return ams::TargetFirmware_11_0_0; } else if (std::memcmp(package1 + 0x10, "20210129", 8) == 0) { return ams::TargetFirmware_12_0_0; } else if (std::memcmp(package1 + 0x10, "20210422", 8) == 0) { return ams::TargetFirmware_12_0_2; } else if (std::memcmp(package1 + 0x10, "20210607", 8) == 0) { return ams::TargetFirmware_12_1_0; } else if (std::memcmp(package1 + 0x10, "20210805", 8) == 0) { return ams::TargetFirmware_13_0_0; } else if (std::memcmp(package1 + 0x10, "20220105", 8) == 0) { return ams::TargetFirmware_13_2_1; } else if (std::memcmp(package1 + 0x10, "20220209", 8) == 0) { return ams::TargetFirmware_14_0_0; } else if (std::memcmp(package1 + 0x10, "20220801", 8) == 0) { return ams::TargetFirmware_15_0_0; } else if (std::memcmp(package1 + 0x10, "20230111", 8) == 0) { return ams::TargetFirmware_16_0_0; } else if (std::memcmp(package1 + 0x10, "20230906", 8) == 0) { return ams::TargetFirmware_17_0_0; } else if (std::memcmp(package1 + 0x10, "20240207", 8) == 0) { return ams::TargetFirmware_18_0_0; } else if (std::memcmp(package1 + 0x10, "20240808", 8) == 0) { return ams::TargetFirmware_19_0_0; } break; default: break; } ShowFatalError("Unable to identify package1!\n"); } u8 *LoadBootConfigAndPackage2() { Result result; /* Load boot config. */ if (R_FAILED((result = ReadPackage2(0, secmon::MemoryRegionPhysicalIramBootConfig.GetPointer<void>(), secmon::MemoryRegionPhysicalIramBootConfig.GetSize())))) { ShowFatalError("Failed to read boot config: 0x%08" PRIx32 "!\n", result.GetValue()); } /* Read package2 header. */ u8 *package2; size_t package2_size; { constexpr s64 Package2Offset = AMS_OFFSETOF(pkg2::StorageLayout, package2_header); pkg2::Package2Header header; if (R_FAILED((result = ReadPackage2(Package2Offset, std::addressof(header), sizeof(header))))) { ShowFatalError("Failed to read package2 header: 0x%08" PRIx32 "!\n", result.GetValue()); } package2_size = header.meta.GetSize(); package2 = static_cast<u8 *>(AllocateAligned(util::AlignUp(package2_size, 0x4000), 0x4000)); if (R_FAILED((result = ReadPackage2(Package2Offset, package2, util::AlignUp(package2_size, 0x4000))))) { ShowFatalError("Failed to read package2: 0x%08" PRIx32 "!\n", result.GetValue()); } } /* Decrypt package2. */ DecryptPackage2(package2); return package2; } constexpr inline const u8 PkcModulusErista[0x100] = { 0xF7, 0x86, 0x47, 0xAB, 0x71, 0x89, 0x81, 0xB5, 0xCF, 0x0C, 0xB0, 0xE8, 0x48, 0xA7, 0xFD, 0xAD, 0xCB, 0x4E, 0x4A, 0x52, 0x0B, 0x1A, 0x8E, 0xDE, 0x41, 0x87, 0x6F, 0xB7, 0x31, 0x05, 0x5F, 0xAA, 0xEA, 0x97, 0x76, 0x21, 0x20, 0x2B, 0x40, 0x48, 0x76, 0x55, 0x35, 0x03, 0xFE, 0x7F, 0x67, 0x62, 0xFD, 0x4E, 0xE1, 0x22, 0xF8, 0xF0, 0x97, 0x39, 0xEF, 0xEA, 0x47, 0x89, 0x3C, 0xDB, 0xF0, 0x02, 0xAD, 0x0C, 0x96, 0xCA, 0x82, 0xAB, 0xB3, 0xCB, 0x98, 0xC8, 0xDC, 0xC6, 0xAC, 0x5C, 0x93, 0x3B, 0x84, 0x3D, 0x51, 0x91, 0x9E, 0xC1, 0x29, 0x22, 0x95, 0xF0, 0xA1, 0x51, 0xBA, 0xAF, 0x5D, 0xC3, 0xAB, 0x04, 0x1B, 0x43, 0x61, 0x7D, 0xEA, 0x65, 0x95, 0x24, 0x3C, 0x51, 0x3E, 0x8F, 0xDB, 0xDB, 0xC1, 0xC4, 0x2D, 0x04, 0x29, 0x5A, 0xD7, 0x34, 0x6B, 0xCC, 0xF1, 0x06, 0xF9, 0xC9, 0xE1, 0xF9, 0x61, 0x52, 0xE2, 0x05, 0x51, 0xB1, 0x3D, 0x88, 0xF9, 0xA9, 0x27, 0xA5, 0x6F, 0x4D, 0xE7, 0x22, 0x48, 0xA5, 0xF8, 0x12, 0xA2, 0xC2, 0x5A, 0xA0, 0xBF, 0xC8, 0x76, 0x4B, 0x66, 0xFE, 0x1C, 0x73, 0x00, 0x29, 0x26, 0xCD, 0x18, 0x4F, 0xC2, 0xB0, 0x51, 0x77, 0x2E, 0x91, 0x09, 0x1B, 0x41, 0x5D, 0x89, 0x5E, 0xEE, 0x24, 0x22, 0x47, 0xE5, 0xE5, 0xF1, 0x86, 0x99, 0x67, 0x08, 0x28, 0x42, 0xF0, 0x58, 0x62, 0x54, 0xC6, 0x5B, 0xDC, 0xE6, 0x80, 0x85, 0x6F, 0xE2, 0x72, 0xB9, 0x7E, 0x36, 0x64, 0x48, 0x85, 0x10, 0xA4, 0x75, 0x38, 0x79, 0x76, 0x8B, 0x51, 0xD5, 0x87, 0xC3, 0x02, 0xC9, 0x1B, 0x93, 0x22, 0x49, 0xEA, 0xAB, 0xA0, 0xB5, 0xB1, 0x3C, 0x10, 0xC4, 0x71, 0xF0, 0xF1, 0x81, 0x1A, 0x3A, 0x9C, 0xFC, 0x51, 0x61, 0xB1, 0x4B, 0x18, 0xB2, 0x3D, 0xAA, 0xD6, 0xAC, 0x72, 0x26, 0xB7 }; constexpr inline const u8 PkcModulusDevelopmentErista[0x100] = { 0x37, 0x84, 0x14, 0xB3, 0x78, 0xA4, 0x7F, 0xD8, 0x71, 0x45, 0xCD, 0x90, 0x51, 0x51, 0xBF, 0x2C, 0x27, 0x03, 0x30, 0x46, 0xBE, 0x8F, 0x99, 0x3E, 0x9F, 0x36, 0x4D, 0xEB, 0xF7, 0x0E, 0x81, 0x7F, 0xE4, 0x6B, 0xA8, 0x42, 0x8A, 0xA5, 0x4F, 0x76, 0xCC, 0xCB, 0xC5, 0x31, 0xA8, 0x5A, 0x70, 0x51, 0x34, 0xBF, 0x1E, 0x8D, 0x6E, 0xCF, 0x05, 0x84, 0xCF, 0x8B, 0xE5, 0x9C, 0x3A, 0xA5, 0xCD, 0x1A, 0x9C, 0xAC, 0x59, 0x30, 0x09, 0x21, 0x3C, 0xBE, 0x07, 0x5C, 0x8D, 0x1C, 0xD1, 0xA3, 0xC9, 0x8F, 0x26, 0xE2, 0x99, 0xB2, 0x3C, 0x28, 0xAD, 0x63, 0x0F, 0xF5, 0xA0, 0x1C, 0xA2, 0x34, 0xC4, 0x0E, 0xDB, 0xD7, 0xE1, 0xA9, 0x5E, 0xE9, 0xA5, 0xA8, 0x64, 0x3A, 0xFC, 0x48, 0xB5, 0x97, 0xDF, 0x55, 0x7C, 0x9A, 0xD2, 0x8C, 0x32, 0x36, 0x1D, 0xC5, 0xA0, 0xC5, 0x66, 0xDF, 0x8A, 0xAD, 0x76, 0x18, 0x46, 0x3E, 0xDF, 0xD8, 0xEF, 0xB9, 0xE5, 0xDC, 0xCD, 0x08, 0x59, 0xBC, 0x36, 0x68, 0xD6, 0xFC, 0x3F, 0xFA, 0x11, 0x00, 0x0D, 0x50, 0xE0, 0x69, 0x0F, 0x70, 0x78, 0x7E, 0xD1, 0xA5, 0x85, 0xCD, 0x13, 0xBC, 0x42, 0x74, 0x33, 0x0C, 0x11, 0x24, 0x1E, 0x33, 0xD5, 0x31, 0xB7, 0x3E, 0x48, 0x94, 0xCC, 0x81, 0x29, 0x1E, 0xB1, 0xCF, 0x4C, 0x36, 0x7F, 0xE1, 0x1C, 0x15, 0xD4, 0x3F, 0xFB, 0x12, 0xC2, 0x73, 0x22, 0x16, 0x52, 0xE0, 0x5C, 0x4C, 0x94, 0xE0, 0x87, 0x47, 0xEA, 0xD0, 0x9F, 0x42, 0x9B, 0xAC, 0xB6, 0xB5, 0xB6, 0x34, 0xE4, 0x55, 0x49, 0xD7, 0xC0, 0xAE, 0xD4, 0x22, 0xB3, 0x5C, 0x87, 0x64, 0x42, 0xEC, 0x11, 0x6D, 0xBC, 0x09, 0xC0, 0x80, 0x07, 0xD0, 0xBD, 0xBA, 0x45, 0xFE, 0xD5, 0x52, 0xDA, 0xEC, 0x41, 0xA4, 0xAD, 0x7B, 0x36, 0x86, 0x18, 0xB4, 0x5B, 0xD1, 0x30, 0xBB }; void LoadWarmbootFirmware(fuse::SocType soc_type, ams::TargetFirmware target_firmware, const u8 *package1) { u8 *warmboot_dst = secmon::MemoryRegionPhysicalIramWarmbootBin.GetPointer<u8>(); size_t warmboot_size = std::min(sizeof(GetExternalPackage().warmboot), secmon::MemoryRegionPhysicalIramWarmbootBin.GetSize()); if (soc_type == fuse::SocType_Erista) { /* Copy the ams warmboot binary. */ std::memcpy(warmboot_dst, GetExternalPackage().warmboot, warmboot_size); /* Set the rsa modulus. */ if (fuse::GetHardwareState() == fuse::HardwareState_Production) { std::memcpy(warmboot_dst + 0x10, PkcModulusErista, sizeof(PkcModulusErista)); } else { std::memcpy(warmboot_dst + 0x10, PkcModulusDevelopmentErista, sizeof(PkcModulusDevelopmentErista)); } /* Set the target firmware. */ std::memcpy(warmboot_dst + 0x248, std::addressof(target_firmware), sizeof(target_firmware)); } else /* if (soc_type == fuse::SocType_Mariko) */ { /* Declare path for mariko warmboot files. */ char warmboot_path[0x80] = "sdmc:/warmboot_mariko/wb_xx.bin"; auto UpdateWarmbootPath = [&warmboot_path](u8 fuses) { warmboot_path[0x19] = "0123456789abcdef"[(fuses >> 4) & 0xF]; warmboot_path[0x1A] = "0123456789abcdef"[(fuses >> 0) & 0xF]; }; /* Get expected/burnt fuse counts. */ const u32 expected_fuses = fuse::GetExpectedFuseVersion(target_firmware); const u32 burnt_fuses = fuse::GetFuseVersion(); u32 used_fuses = expected_fuses; /* Get warmboot from package1. */ const u8 *warmboot_src = nullptr; size_t warmboot_src_size = 0; { const u32 *package1_pk11 = reinterpret_cast<const u32 *>(package1 + (target_firmware >= ams::TargetFirmware_6_2_0 ? 0x7000 : 0x4000)); if (std::memcmp(package1_pk11, "PK11", 4) != 0) { ShowFatalError("Invalid package1 magic!\n"); } const u32 *package1_pk11_data = reinterpret_cast<const u32 *>(package1_pk11 + (0x20 / sizeof(u32))); for (size_t i = 0; i < 3; ++i) { switch (*package1_pk11_data) { case 0xD5034FDF: package1_pk11_data += package1_pk11[6] / sizeof(u32); break; case 0xE328F0C0: case 0xF0C0A7F0: package1_pk11_data += package1_pk11[4] / sizeof(u32); break; default: warmboot_src = reinterpret_cast<const u8 *>(package1_pk11_data); i = 3; break; } } warmboot_src_size = *package1_pk11_data; if (!(0x800 <= warmboot_src_size && warmboot_src_size < 0x1000)) { ShowFatalError("Package1 warmboot firmware seems invalid!\n"); } /* If we should, save the current warmboot firmware. */ UpdateWarmbootPath(expected_fuses); if (!IsFileExist(warmboot_path)) { fs::CreateDirectory("sdmc:/warmboot_mariko"); fs::CreateFile(warmboot_path, warmboot_src_size); Result result; fs::FileHandle file; if (R_FAILED((result = fs::OpenFile(std::addressof(file), warmboot_path, fs::OpenMode_ReadWrite)))) { ShowFatalError("Failed to save %s!\n", warmboot_path); } ON_SCOPE_EXIT { fs::CloseFile(file); }; if (R_FAILED((result = fs::WriteFile(file, 0, warmboot_src, warmboot_src_size, fs::WriteOption::Flush)))) { ShowFatalError("Failed to save %s!\n", warmboot_path); } } /* If we need to, find a cached warmboot firmware that we can use. */ if (burnt_fuses > expected_fuses) { warmboot_src = nullptr; warmboot_src_size = 0; for (u32 attempt = burnt_fuses; attempt <= 32; ++attempt) { /* Open the current cache file. */ UpdateWarmbootPath(attempt); fs::FileHandle file; if (R_FAILED(fs::OpenFile(std::addressof(file), warmboot_path, fs::OpenMode_Read))) { continue; } ON_SCOPE_EXIT { fs::CloseFile(file); }; /* Get the size. */ s64 size; if (R_FAILED(fs::GetFileSize(std::addressof(size), file)) || !(0x800 <= size && size < 0x1000)) { continue; } /* Allocate memory. */ warmboot_src_size = static_cast<size_t>(size); void *tmp = AllocateAligned(warmboot_src_size, 0x10); /* Read the file. */ if (R_FAILED(fs::ReadFile(file, 0, tmp, warmboot_src_size))) { continue; } /* Use the cached file. */ used_fuses = attempt; warmboot_src = static_cast<const u8 *>(tmp); break; } } /* Check that we found a firmware. */ if (warmboot_src == nullptr) { ShowFatalError("Failed to locate warmboot firmware!\n"); } /* Copy the warmboot firmware. */ std::memcpy(warmboot_dst, warmboot_src, std::min(warmboot_size, warmboot_src_size)); /* Set the warmboot firmware magic. */ switch (used_fuses) { case 7: reg::Write(PMC + APBDEV_PMC_SECURE_SCRATCH32, 0x87); case 8: reg::Write(PMC + APBDEV_PMC_SECURE_SCRATCH32, 0xA8); default: reg::Write(PMC + APBDEV_PMC_SECURE_SCRATCH32, (0x108 + 0x21 * (used_fuses - 8))); break; } reg::SetBits(PMC + APBDEV_PMC_SEC_DISABLE3, (1 << 16)); } } } void ConfigureExosphere(fuse::SocType soc_type, ams::TargetFirmware target_firmware, bool emummc_enabled, u32 fs_version) { /* Get monitor configuration. */ auto &storage_ctx = *secmon::MemoryRegionPhysicalDramMonitorConfiguration.GetPointer<secmon::SecureMonitorStorageConfiguration>(); std::memset(std::addressof(storage_ctx), 0, sizeof(storage_ctx)); /* Set magic. */ storage_ctx.magic = secmon::SecureMonitorStorageConfiguration::Magic; /* Set some defaults. */ storage_ctx.target_firmware = target_firmware; storage_ctx.lcd_vendor = GetDisplayLcdVendor(); storage_ctx.emummc_cfg = g_emummc_cfg; storage_ctx.flags[0] = secmon::SecureMonitorConfigurationFlag_Default; storage_ctx.flags[1] = secmon::SecureMonitorConfigurationFlag_None; storage_ctx.log_port = uart::Port_ReservedDebug; storage_ctx.log_baud_rate = 115200; /* Set the fs version. */ storage_ctx.emummc_cfg.base_cfg.fs_version = fs_version; /* Parse fields from exosphere.ini */ { IniSectionList sections; if (ParseIniSafe(sections, "sdmc:/exosphere.ini")) { for (const auto §ion : sections) { /* We only care about the [exosphere] section. */ if (std::strcmp(section.name, "exosphere")) { continue; } /* Handle individual fields. */ for (const auto &entry : section.kv_list) { if (std::strcmp(entry.key, "debugmode") == 0) { if (entry.value[0] == '1') { storage_ctx.flags[0] |= secmon::SecureMonitorConfigurationFlag_IsDevelopmentFunctionEnabledForKernel; } else { storage_ctx.flags[0] &= ~secmon::SecureMonitorConfigurationFlag_IsDevelopmentFunctionEnabledForKernel; } } else if (std::strcmp(entry.key, "debugmode_user") == 0) { if (entry.value[0] == '1') { storage_ctx.flags[0] |= secmon::SecureMonitorConfigurationFlag_IsDevelopmentFunctionEnabledForUser; } else { storage_ctx.flags[0] &= ~secmon::SecureMonitorConfigurationFlag_IsDevelopmentFunctionEnabledForUser; } } else if (std::strcmp(entry.key, "disable_user_exception_handlers") == 0) { if (entry.value[0] == '1') { storage_ctx.flags[0] |= secmon::SecureMonitorConfigurationFlag_DisableUserModeExceptionHandlers; } else { storage_ctx.flags[0] &= ~secmon::SecureMonitorConfigurationFlag_DisableUserModeExceptionHandlers; } } else if (std::strcmp(entry.key, "enable_user_pmu_access") == 0) { if (entry.value[0] == '1') { storage_ctx.flags[0] |= secmon::SecureMonitorConfigurationFlag_EnableUserModePerformanceCounterAccess; } else { storage_ctx.flags[0] &= ~secmon::SecureMonitorConfigurationFlag_EnableUserModePerformanceCounterAccess; } } else if (std::strcmp(entry.key, "blank_prodinfo_sysmmc") == 0) { if (!emummc_enabled) { if (entry.value[0] == '1') { storage_ctx.flags[0] |= secmon::SecureMonitorConfigurationFlag_ShouldUseBlankCalibrationBinary; } else { storage_ctx.flags[0] &= ~secmon::SecureMonitorConfigurationFlag_ShouldUseBlankCalibrationBinary; } } } else if (std::strcmp(entry.key, "blank_prodinfo_emummc") == 0) { if (emummc_enabled) { if (entry.value[0] == '1') { storage_ctx.flags[0] |= secmon::SecureMonitorConfigurationFlag_ShouldUseBlankCalibrationBinary; } else { storage_ctx.flags[0] &= ~secmon::SecureMonitorConfigurationFlag_ShouldUseBlankCalibrationBinary; } } } else if (std::strcmp(entry.key, "allow_writing_to_cal_sysmmc") == 0) { if (entry.value[0] == '1') { storage_ctx.flags[0] |= secmon::SecureMonitorConfigurationFlag_AllowWritingToCalibrationBinarySysmmc; } else { storage_ctx.flags[0] &= ~secmon::SecureMonitorConfigurationFlag_AllowWritingToCalibrationBinarySysmmc; } } else if (std::strcmp(entry.key, "log_port") == 0) { const u32 log_port = ParseDecimalInteger(entry.value); if (0 <= log_port && log_port < 4) { storage_ctx.log_port = log_port; } } else if (std::strcmp(entry.key, "log_baud_rate") == 0) { storage_ctx.log_baud_rate = ParseDecimalInteger(entry.value); } else if (std::strcmp(entry.key, "log_inverted") == 0) { if (entry.value[0] == '1') { storage_ctx.log_flags |= uart::Flag_Inverted; } } } } } } /* Parse usb setting from system_settings.ini */ { IniSectionList sections; if (ParseIniSafe(sections, "sdmc:/atmosphere/config/system_settings.ini")) { for (const auto §ion : sections) { /* We only care about the [usb] section. */ if (std::strcmp(section.name, "usb")) { continue; } /* Handle individual fields. */ for (const auto &entry : section.kv_list) { if (std::strcmp(entry.key, "usb30_force_enabled") == 0) { if (std::strcmp(entry.value, "u8!0x1") == 0) { storage_ctx.flags[0] |= secmon::SecureMonitorConfigurationFlag_ForceEnableUsb30; } } } } } } /* Copy exosphere. */ void *exosphere_dst = reinterpret_cast<void *>(0x40030000); bool use_sd_exo = false; { /* Try to use an sd card file, if present. */ fs::FileHandle exo_file; if (R_SUCCEEDED(fs::OpenFile(std::addressof(exo_file), "sdmc:/atmosphere/exosphere.bin", fs::OpenMode_Read))) { ON_SCOPE_EXIT { fs::CloseFile(exo_file); }; /* Note that we're using sd_exo. */ use_sd_exo = true; Result result; /* Get the size. */ s64 size; if (R_FAILED((result = fs::GetFileSize(std::addressof(size), exo_file))) || size > sizeof(GetExternalPackage().exosphere)) { ShowFatalError("Invalid SD exosphere size: 0x%08" PRIx32 ", %" PRIx64 "!\n", result.GetValue(), static_cast<u64>(size)); } /* Read the file. */ if (R_FAILED((result = fs::ReadFile(exo_file, 0, exosphere_dst, size)))) { ShowFatalError("Failed to read SD exosphere: 0x%08" PRIx32 "!\n", result.GetValue()); } } } if (!use_sd_exo) { std::memcpy(exosphere_dst, GetExternalPackage().exosphere, sizeof(GetExternalPackage().exosphere)); } /* Copy mariko fatal. */ if (soc_type == fuse::SocType_Mariko) { u8 *mariko_fatal_dst = secmon::MemoryRegionPhysicalMarikoProgramImage.GetPointer<u8>(); bool use_sd_mariko_fatal = false; { /* Try to use an sd card file, if present. */ fs::FileHandle mariko_program_file; if (R_SUCCEEDED(fs::OpenFile(std::addressof(mariko_program_file), "sdmc:/atmosphere/mariko_fatal.bin", fs::OpenMode_Read))) { ON_SCOPE_EXIT { fs::CloseFile(mariko_program_file); }; /* Note that we're using sd mariko fatal. */ use_sd_mariko_fatal = true; Result result; /* Get the size. */ s64 size; if (R_FAILED((result = fs::GetFileSize(std::addressof(size), mariko_program_file))) || size > sizeof(GetExternalPackage().mariko_fatal)) { ShowFatalError("Invalid SD mariko_fatal size: 0x%08" PRIx32 ", %" PRIx64 "!\n", result.GetValue(), static_cast<u64>(size)); } /* Read the file. */ if (R_FAILED((result = fs::ReadFile(mariko_program_file, 0, mariko_fatal_dst, size)))) { ShowFatalError("Failed to read SD mariko_fatal: 0x%08" PRIx32 "!\n", result.GetValue()); } /* Clear the remainder. */ std::memset(mariko_fatal_dst + size, 0, sizeof(GetExternalPackage().mariko_fatal) - size); } } if (!use_sd_mariko_fatal) { std::memcpy(mariko_fatal_dst, GetExternalPackage().mariko_fatal, sizeof(GetExternalPackage().mariko_fatal)); } } /* Setup the CPU to boot exosphere. */ SetupCpu(reinterpret_cast<uintptr_t>(exosphere_dst)); /* Initialize bootloader parameters. */ InitializeSecureMonitorMailbox(); /* Set our bootloader state. */ SetBootloaderState(pkg1::BootloaderState_LoadedBootConfig); /* Ensure that the CPU will see consistent data. */ hw::FlushEntireDataCache(); } bool IsNogcEnabled(ams::TargetFirmware target_firmware) { /* First parse from ini. */ { IniSectionList sections; if (ParseIniSafe(sections, "sdmc:/atmosphere/config/stratosphere.ini")) { for (const auto §ion : sections) { /* We only care about the [stratosphere] section. */ if (std::strcmp(section.name, "stratosphere")) { continue; } /* Handle individual fields. */ for (const auto &entry : section.kv_list) { if (std::strcmp(entry.key, "nogc") == 0) { return entry.value[0] == '1'; } } } } } /* That failed, so try to decide automatically. */ const auto fuse_version = fuse::GetFuseVersion(); if (target_firmware >= ams::TargetFirmware_12_0_2 && fuse_version < fuse::GetExpectedFuseVersion(ams::TargetFirmware_12_0_2)) { return true; } if (target_firmware >= ams::TargetFirmware_11_0_0 && fuse_version < fuse::GetExpectedFuseVersion(ams::TargetFirmware_11_0_0)) { return true; } if (target_firmware >= ams::TargetFirmware_9_0_0 && fuse_version < fuse::GetExpectedFuseVersion(ams::TargetFirmware_9_0_0)) { return true; } if (target_firmware >= ams::TargetFirmware_4_0_0 && fuse_version < fuse::GetExpectedFuseVersion(ams::TargetFirmware_4_0_0)) { return true; } return false; } } void SetupAndStartHorizon() { /* Get soc type. */ const auto soc_type = fuse::GetSocType(); /* Derive all keys. */ DeriveAllKeys(soc_type); /* Determine whether we're using emummc. */ const bool emummc_enabled = ConfigureEmummc(); /* Initialize emummc. */ /* NOTE: SYSTEM:/ accessible past this point. */ InitializeEmummc(emummc_enabled, g_emummc_cfg); /* Read bootloader. */ const u8 * const package1 = LoadPackage1(soc_type); /* Get target firmware. */ const auto target_firmware = GetApproximateTargetFirmware(package1); /* Read/decrypt package2. */ u8 * const package2 = LoadBootConfigAndPackage2(); /* Setup warmboot firmware. */ LoadWarmbootFirmware(soc_type, target_firmware, package1); /* Decide whether to use nogc patches. */ const bool nogc_enabled = IsNogcEnabled(target_firmware); /* Decide what KIPs/patches we're loading. */ const auto fs_version = ConfigureStratosphere(package2, target_firmware, emummc_enabled, nogc_enabled); /* Setup exosphere. */ ConfigureExosphere(soc_type, target_firmware, emummc_enabled, fs_version); /* Start CPU. */ StartCpu(); /* Build modified package2. */ RebuildPackage2(target_firmware, emummc_enabled); /* Wait for confirmation that exosphere is ready. */ WaitSecureMonitorState(pkg1::SecureMonitorState_Initialized); } }