From a8f5d880b27b80a50598f258c2900d9509303455 Mon Sep 17 00:00:00 2001 From: Mow <32942550+taxicat1@users.noreply.github.com> Date: Wed, 3 Dec 2025 10:22:06 -0500 Subject: [PATCH] Improved DSProtect patches --- .../DSProtectOverlayPatch.cpp | 730 +++++++++--------- .../DSProtectPatches/DSProtectOverlayPatch.h | 5 +- .../DSProtectOverlayPatchAsm.h | 14 + .../DSProtectOverlayPatchAsm.s | 89 +++ .../DSProtectOverlayPatchv1Asm.h | 27 - .../DSProtectOverlayPatchv1Asm.s | 168 ---- .../DSProtectOverlayPatchv2Asm.h | 17 - .../DSProtectOverlayPatchv2Asm.s | 93 --- .../DSProtectOverlayPatchv2sAsm.h | 12 - .../DSProtectOverlayPatchv2sAsm.s | 64 -- common/ApList.cpp | 1 + common/DSProtectVersion.h | 3 +- data/aplist.csv | 7 + .../ApList/ApListFactory.cs | 2 + .../ApList/DSProtectVersion.cs | 3 +- 15 files changed, 503 insertions(+), 732 deletions(-) create mode 100644 arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchAsm.h create mode 100644 arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchAsm.s delete mode 100644 arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv1Asm.h delete mode 100644 arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv1Asm.s delete mode 100644 arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2Asm.h delete mode 100644 arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2Asm.s delete mode 100644 arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2sAsm.h delete mode 100644 arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2sAsm.s diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatch.cpp b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatch.cpp index 4899b24..97494ef 100644 --- a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatch.cpp +++ b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatch.cpp @@ -2,417 +2,457 @@ #include "../../../PatchContext.h" #include "thumbInstructions.h" #include "gameCode.h" -#include "DSProtectOverlayPatchv1Asm.h" -#include "DSProtectOverlayPatchv2Asm.h" -#include "DSProtectOverlayPatchv2sAsm.h" +#include "DSProtectOverlayPatchAsm.h" #include "DSProtectOverlayPatch.h" +#define FUNCMASK_A1 (0b000001) +#define FUNCMASK_NOTA1 (0b000010) +#define FUNCMASK_A2 (0b000100) +#define FUNCMASK_NOTA2 (0b001000) +#define FUNCMASK_A3 (0b010000) +#define FUNCMASK_NOTA3 (0b100000) + +#define PATCH_WRITE_WORD (0) +#define PATCH_COPY_NEXT (1) + +#define MAGIC_100_102 (0xFFFFFE70) +#define MAGIC_105_123 (0xFFFFFCE0) +#define MAGIC_200s_205s (0x00000000) + +#define OFFSET_INVALID (0x80000000) + const void* DSProtectOverlayPatch::InsertPatch(PatchContext& patchContext) { - if (_version <= DSProtectVersion::v1_28) - { - return InsertPatchV1(patchContext); - } - else if (_version <= DSProtectVersion::v2_05) - { - return InsertPatchV2(patchContext); - } - else if (_version <= DSProtectVersion::v2_05s) - { - return InsertPatchV2s(patchContext); - } - else - { - LOG_WARNING("Unsupported DSProtect version\n"); - return next ? (const void*)next->InsertPatch(patchContext) : nullptr; - } + ConfigurePatch(patchContext); + + u32 patchSize = SECTION_SIZE(dsprotectpatch); + void* patchAddress = patchContext.GetPatchHeap().Alloc(patchSize); + u32 entryAddress = (u32)&dsprotectpatch_entry - (u32)SECTION_START(dsprotectpatch) + (u32)patchAddress; + memcpy(patchAddress, SECTION_START(dsprotectpatch), patchSize); + + return (const void*)entryAddress; } -void DSProtectOverlayPatch::SetOldV1Offsets(const u16* offsets) const +void DSProtectOverlayPatch::ConfigurePatch(PatchContext& patchContext) const { - int offsetIdx = 0; + // Next patch and target overlay ID + dsprotectpatch_nextAddress = next ? (const void*)next->InsertPatch(patchContext) : nullptr; + dsprotectpatch_overlayId = _overlayId; - if (_functionMask & 0b000001) - dsprotectpatchv1_stub_protectb1_offset = offsets[offsetIdx++]; - else - dsprotectpatchv1_stub_protectb1_offset = 0; // does not exist + u32 regionOffset = _overlayOffset; - if (_functionMask & 0b000010) - dsprotectpatchv1_stub_notprotectb1_offset = offsets[offsetIdx++]; - else - dsprotectpatchv1_stub_notprotectb1_offset = 0; // does not exist - - if (_functionMask & 0b000100) - dsprotectpatchv1_stub_protectb2_offset = offsets[offsetIdx++]; - else - dsprotectpatchv1_stub_protectb2_offset = 0; // does not exist - - if (_functionMask & 0b001000) - dsprotectpatchv1_stub_notprotectb2_offset = offsets[offsetIdx++]; - else - dsprotectpatchv1_stub_notprotectb2_offset = 0; // does not exist - - if (_functionMask & 0b010000) - dsprotectpatchv1_stub_protectb3_offset = offsets[offsetIdx++]; - else - dsprotectpatchv1_stub_protectb3_offset = 0; // does not exist - - if (_functionMask & 0b100000) - dsprotectpatchv1_stub_notprotectb3_offset = offsets[offsetIdx++]; - else - dsprotectpatchv1_stub_notprotectb3_offset = 0; // does not exist -} - -const void* DSProtectOverlayPatch::InsertPatchV1(PatchContext& patchContext) const -{ - const void* nextPatch = next ? (const void*)next->InsertPatch(patchContext) : nullptr; - - dsprotectpatchv1_overlay_id = _overlayId; - dsprotectpatchv1_base_offset = _overlayOffset; + // Default invalid, enable below + dsprotectpatch_offsetA1 = OFFSET_INVALID; + dsprotectpatch_offsetNotA1 = OFFSET_INVALID; switch (_version) { + case DSProtectVersion::v1_00_2: + { + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_100_102; + + if (_functionMask & FUNCMASK_A1) + { + dsprotectpatch_offsetA1 = regionOffset + 0xD8; + regionOffset += 0xDC; // __DSprot_DetectFlashcart + } + + if (_functionMask & FUNCMASK_NOTA1) + { + dsprotectpatch_offsetNotA1 = regionOffset + 0xD8; + regionOffset += 0xDC; // __DSprot_DetectNotFlashcart + } + + break; + } case DSProtectVersion::v1_05: { - static u16 v105Offsets[] = { 0x858, 0x934, 0xA10, 0xAEC, 0xBC8, 0xC94 }; - SetOldV1Offsets(v105Offsets); + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_105_123; + + regionOffset += 0x24; // setCacheDisabled + regionOffset += 0xB4; // Encryptor_StartRange + regionOffset += 0xD4; // Encryptor_EndRange + regionOffset += 0x74; // RC4_Init + regionOffset += 0x4C; // RC4_Byte + regionOffset += 0x24; // RC4_InitSBox + regionOffset += 0x9C; // RC4_EncryptInstructions + regionOffset += 0xC; // RC4_DecryptInstructions + regionOffset += 0x58; // RC4_InitAndEncryptInstructions + regionOffset += 0x58; // RC4_InitAndDecryptInstructions + + if (_functionMask & (FUNCMASK_A2 | FUNCMASK_NOTA2)) + { + regionOffset += 0x120; // MACOwner_IsBad + } + + if (_functionMask & (FUNCMASK_A1 | FUNCMASK_NOTA1)) + { + regionOffset += 0x19C; // ROMUtil_Read + regionOffset += 0xA4; // ROMUtil_CRC32 + regionOffset += 0x110; // ROMTest_IsBad + } + + if (_functionMask & FUNCMASK_A1) + { + dsprotectpatch_offsetA1 = regionOffset + 0xD8; + regionOffset += 0xDC; // __DSProt_DetectFlashcart + } + + if (_functionMask & FUNCMASK_NOTA1) + { + dsprotectpatch_offsetNotA1 = regionOffset + 0xD8; + regionOffset += 0xDC; // __DSprot_DetectNotFlashcart + } - dsprotectpatchv1_nitro_static_init_offset = 0; // does not exist - dsprotectpatchv1_protectb1_return_value = 0; - dsprotectpatchv1_protectb2_return_value = 0; - dsprotectpatchv1_protectb3_return_value = 0; - dsprotectpatchv1_notprotectb1_return_value = 1; - dsprotectpatchv1_notprotectb2_return_value = 1; - dsprotectpatchv1_notprotectb3_return_value = 1; - // Remove xor 0x320 from the callback pointer - dsprotectpatchv1_moveCallback = 0xE230EE32; // eors lr, r0, #0x320 break; } case DSProtectVersion::v1_06: { - static u16 v106Offsets[] = { 0x860, 0x938, 0xA10, 0xAE8, 0xBC0, 0xC88 }; - SetOldV1Offsets(v106Offsets); + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_105_123; + + regionOffset += 0x24; // setCacheDisabled + regionOffset += 0xB4; // Encryptor_StartRange + regionOffset += 0xD4; // Encryptor_EndRange + regionOffset += 0x74; // RC4_Init + regionOffset += 0x4C; // RC4_Byte + regionOffset += 0x24; // RC4_InitSBox + regionOffset += 0x9C; // RC4_EncryptInstructions + regionOffset += 0xC; // RC4_DecryptInstructions + regionOffset += 0x58; // RC4_InitAndEncryptInstructions + regionOffset += 0x58; // RC4_InitAndDecryptInstructions + + if (_functionMask & (FUNCMASK_A2 | FUNCMASK_NOTA2)) + { + regionOffset += 0x120; // MACOwner_IsBad + } + + if (_functionMask & (FUNCMASK_A1 | FUNCMASK_NOTA1)) + { + regionOffset += 0x1A4; // ROMUtil_Read + regionOffset += 0xA4; // ROMUtil_CRC32 + regionOffset += 0x110; // ROMTest_IsBad + } + + if (_functionMask & FUNCMASK_A1) + { + dsprotectpatch_offsetA1 = regionOffset + 0xD4; + regionOffset += 0xD8; // DSProt_DetectFlashcart + } + + if (_functionMask & FUNCMASK_NOTA1) + { + dsprotectpatch_offsetNotA1 = regionOffset + 0xD4; + regionOffset += 0xD8; // DSProt_DetectNotFlashcart + } - dsprotectpatchv1_nitro_static_init_offset = 0; // does not exist - dsprotectpatchv1_protectb1_return_value = 0; - dsprotectpatchv1_protectb2_return_value = 0; - dsprotectpatchv1_protectb3_return_value = 0; - dsprotectpatchv1_notprotectb1_return_value = 1; - dsprotectpatchv1_notprotectb2_return_value = 1; - dsprotectpatchv1_notprotectb3_return_value = 1; break; } case DSProtectVersion::v1_08: { - static u16 v108Offsets[] = { 0x858, 0x930, 0xA08, 0xAE0, 0xBB8, 0xC94 }; - SetOldV1Offsets(v108Offsets); + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_105_123; + + regionOffset += 0x24; // setCacheDisabled + regionOffset += 0xB4; // Encryptor_StartRange + regionOffset += 0xD4; // Encryptor_EndRange + regionOffset += 0x74; // RC4_Init + regionOffset += 0x4C; // RC4_Byte + regionOffset += 0x24; // RC4_InitSBox + regionOffset += 0x9C; // RC4_EncryptInstructions + regionOffset += 0xC; // RC4_DecryptInstructions + regionOffset += 0x58; // RC4_InitAndEncryptInstructions + regionOffset += 0x58; // RC4_InitAndDecryptInstructions + + if (_functionMask & (FUNCMASK_A2 | FUNCMASK_NOTA2)) + { + regionOffset += 0x120; // MACOwner_IsBad + } + + if (_functionMask & (FUNCMASK_A1 | FUNCMASK_NOTA1)) + { + regionOffset += 0x19C; // ROMUtil_Read + regionOffset += 0xA4; // ROMUtil_CRC32 + regionOffset += 0x110; // ROMTest_IsBad + } + + if (_functionMask & FUNCMASK_A1) + { + dsprotectpatch_offsetA1 = regionOffset + 0xD4; + regionOffset += 0xD8; // DSProt_DetectFlashcart + } + + if (_functionMask & FUNCMASK_NOTA1) + { + dsprotectpatch_offsetNotA1 = regionOffset + 0xD4; + regionOffset += 0xD8; // DSProt_DetectNotFlashcart + } - dsprotectpatchv1_nitro_static_init_offset = 0; // does not exist - dsprotectpatchv1_protectb1_return_value = 0; - dsprotectpatchv1_protectb2_return_value = 0; - dsprotectpatchv1_protectb3_return_value = 0; - dsprotectpatchv1_notprotectb1_return_value = 1; - dsprotectpatchv1_notprotectb2_return_value = 1; - dsprotectpatchv1_notprotectb3_return_value = 1; break; } case DSProtectVersion::v1_10: { - static u16 v110Offsets[] = { 0x860, 0x940, 0xA20, 0xB00, 0xBE0, 0xCB0 }; - SetOldV1Offsets(v110Offsets); + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_105_123; + + regionOffset += 0xCC; // Encryptor_StartRange + regionOffset += 0xE8; // Encryptor_EndRange + regionOffset += 0x74; // RC4_Init + regionOffset += 0x4C; // RC4_Byte + regionOffset += 0x24; // RC4_InitSBox + regionOffset += 0x9C; // RC4_EncryptInstructions + regionOffset += 0xC; // RC4_DecryptInstructions + regionOffset += 0x58; // RC4_InitAndEncryptInstructions + regionOffset += 0x58; // RC4_InitAndDecryptInstructions + + if (_functionMask & (FUNCMASK_A2 | FUNCMASK_NOTA2)) + { + regionOffset += 0x120; // MACOwner_IsBad + } + + if (_functionMask & (FUNCMASK_A1 | FUNCMASK_NOTA1)) + { + regionOffset += 0x19C; // ROMUtil_Read + regionOffset += 0xA4; // ROMUtil_CRC32 + regionOffset += 0x110; // ROMTest_IsBad + } + + if (_functionMask & FUNCMASK_A1) + { + dsprotectpatch_offsetA1 = regionOffset + 0xD8; + regionOffset += 0xE0; // DSProt_DetectFlashcart + } + + if (_functionMask & FUNCMASK_NOTA1) + { + dsprotectpatch_offsetNotA1 = regionOffset + 0xD8; + regionOffset += 0xE0; // DSProt_DetectNotFlashcart + } - dsprotectpatchv1_nitro_static_init_offset = 0; // does not exist - dsprotectpatchv1_protectb1_return_value = 0; - dsprotectpatchv1_protectb2_return_value = 0; - dsprotectpatchv1_protectb3_return_value = 0; - dsprotectpatchv1_notprotectb1_return_value = 1; - dsprotectpatchv1_notprotectb2_return_value = 1; - dsprotectpatchv1_notprotectb3_return_value = 1; break; } case DSProtectVersion::v1_20: { - switch (_functionMask) + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_105_123; + + regionOffset += 0xC8; // Encryptor_StartRange + regionOffset += 0xE4; // Encryptor_EndRange + + if (_functionMask & FUNCMASK_A2) { - case 0b001111: - dsprotectpatchv1_stub_protectb1_offset = 0x864; - dsprotectpatchv1_stub_notprotectb1_offset = 0x94C; - dsprotectpatchv1_stub_protectb2_offset = 0xA34; - dsprotectpatchv1_stub_notprotectb2_offset = 0xB1C; - dsprotectpatchv1_stub_protectb3_offset = 0; // does not exist - dsprotectpatchv1_stub_notprotectb3_offset = 0; // does not exist - break; - - case 0b010101: - dsprotectpatchv1_stub_protectb1_offset = 0x644; - dsprotectpatchv1_stub_notprotectb1_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb2_offset = 0x72C; - dsprotectpatchv1_stub_notprotectb2_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb3_offset = 0x814; - dsprotectpatchv1_stub_notprotectb3_offset = 0; // does not exist - break; - - case 0b010110: - dsprotectpatchv1_stub_protectb1_offset = 0; // does not exist - dsprotectpatchv1_stub_notprotectb1_offset = 0x644; - dsprotectpatchv1_stub_protectb2_offset = 0x72C; - dsprotectpatchv1_stub_notprotectb2_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb3_offset = 0x814; - dsprotectpatchv1_stub_notprotectb3_offset = 0; // does not exist - break; - - case 0b011001: - dsprotectpatchv1_stub_protectb1_offset = 0x644; - dsprotectpatchv1_stub_notprotectb1_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb2_offset = 0; - dsprotectpatchv1_stub_notprotectb2_offset = 0x72C; - dsprotectpatchv1_stub_protectb3_offset = 0x814; - dsprotectpatchv1_stub_notprotectb3_offset = 0; // does not exist - break; - - case 0b110101: - dsprotectpatchv1_stub_protectb1_offset = 0x644; - dsprotectpatchv1_stub_notprotectb1_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb2_offset = 0x72C; - dsprotectpatchv1_stub_notprotectb2_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb3_offset = 0x814; - dsprotectpatchv1_stub_notprotectb3_offset = 0x8DC; - break; - - case 0b111111: - dsprotectpatchv1_stub_protectb1_offset = 0x864; - dsprotectpatchv1_stub_notprotectb1_offset = 0x94C; - dsprotectpatchv1_stub_protectb2_offset = 0xA34; - dsprotectpatchv1_stub_notprotectb2_offset = 0xB1C; - dsprotectpatchv1_stub_protectb3_offset = 0xC04; - dsprotectpatchv1_stub_notprotectb3_offset = 0xCCC; - break; - - default: - LOG_WARNING("Unsupported DSProtect function mask\n"); - return nextPatch; + regionOffset += 0x118; // MACOwner_IsBad } - dsprotectpatchv1_nitro_static_init_offset = 0; // does not exist - dsprotectpatchv1_protectb1_return_value = 0; - dsprotectpatchv1_protectb2_return_value = 0; - dsprotectpatchv1_protectb3_return_value = 0; - dsprotectpatchv1_notprotectb1_return_value = 1; - dsprotectpatchv1_notprotectb2_return_value = 1; - dsprotectpatchv1_notprotectb3_return_value = 1; + + if (_functionMask & FUNCMASK_NOTA2) + { + regionOffset += 0x118; // MACOwner_IsGood + } + + if (_functionMask & (FUNCMASK_A1 | FUNCMASK_NOTA1)) + { + regionOffset += 0x1D4; // ROMUtil_Read + regionOffset += 0xA4; // ROMUtil_CRC32 + } + + if (_functionMask & FUNCMASK_A1) + { + regionOffset += 0x108; // ROMTest_IsBad + } + + if (_functionMask & FUNCMASK_NOTA1) + { + regionOffset += 0x108; // ROMTest_IsGood + } + + if (_functionMask & FUNCMASK_A1) + { + dsprotectpatch_offsetA1 = regionOffset + 0xE0; + regionOffset += 0xE8; // DSProt_DetectFlashcart + } + + if (_functionMask & FUNCMASK_NOTA1) + { + dsprotectpatch_offsetNotA1 = regionOffset + 0xE0; + regionOffset += 0xE8; // DSProt_DetectNotFlashcart + } + break; } case DSProtectVersion::v1_22: { - switch (_functionMask) + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_105_123; + + regionOffset += 0xC8; // Encryptor_StartRange + regionOffset += 0xE4; // Encryptor_EndRange + + if (_functionMask & FUNCMASK_A2) { - case 0b010101: - dsprotectpatchv1_stub_protectb1_offset = 0x64C; - dsprotectpatchv1_stub_notprotectb1_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb2_offset = 0x734; - dsprotectpatchv1_stub_notprotectb2_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb3_offset = 0x81C; - dsprotectpatchv1_stub_notprotectb3_offset = 0; // does not exist - break; - - case 0b010110: - dsprotectpatchv1_stub_protectb1_offset = 0; // does not exist - dsprotectpatchv1_stub_notprotectb1_offset = 0x64C; - dsprotectpatchv1_stub_protectb2_offset = 0x734; - dsprotectpatchv1_stub_notprotectb2_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb3_offset = 0x81C; - dsprotectpatchv1_stub_notprotectb3_offset = 0; // does not exist - break; - - case 0b010111: - dsprotectpatchv1_stub_protectb1_offset = 0x754; - dsprotectpatchv1_stub_notprotectb1_offset = 0x83C; - dsprotectpatchv1_stub_protectb2_offset = 0x924; - dsprotectpatchv1_stub_notprotectb2_offset = 0; // does not exist - dsprotectpatchv1_stub_protectb3_offset = 0xA0C; - dsprotectpatchv1_stub_notprotectb3_offset = 0; // does not exist - break; - - case 0b011111: - dsprotectpatchv1_stub_protectb1_offset = 0x874; - dsprotectpatchv1_stub_notprotectb1_offset = 0x95C; - dsprotectpatchv1_stub_protectb2_offset = 0xA44; - dsprotectpatchv1_stub_notprotectb2_offset = 0xB2C; - dsprotectpatchv1_stub_protectb3_offset = 0xC14; - dsprotectpatchv1_stub_notprotectb3_offset = 0; // does not exist - break; - - case 0b111111: - dsprotectpatchv1_stub_protectb1_offset = 0x874; - dsprotectpatchv1_stub_notprotectb1_offset = 0x95C; - dsprotectpatchv1_stub_protectb2_offset = 0xA44; - dsprotectpatchv1_stub_notprotectb2_offset = 0xB2C; - dsprotectpatchv1_stub_protectb3_offset = 0xC14; - dsprotectpatchv1_stub_notprotectb3_offset = 0xCDC; - break; - - default: - LOG_WARNING("Unsupported DSProtect function mask\n"); - return nextPatch; + regionOffset += 0x120; // MACOwner_IsBad + } + + if (_functionMask & FUNCMASK_NOTA2) + { + regionOffset += 0x120; // MACOwner_IsGood + } + + if (_functionMask & (FUNCMASK_A1 | FUNCMASK_NOTA1)) + { + regionOffset += 0x1D4; // ROMUtil_Read + regionOffset += 0xA4; // ROMUtil_CRC32 + } + + if (_functionMask & FUNCMASK_A1) + { + regionOffset += 0x108; // ROMTest_IsBad + } + + if (_functionMask & FUNCMASK_NOTA1) + { + regionOffset += 0x108; // ROMTest_IsGood + } + + if (_functionMask & FUNCMASK_A1) + { + dsprotectpatch_offsetA1 = regionOffset + 0xE0; + regionOffset += 0xE8; // DSProt_DetectFlashcart + } + + if (_functionMask & FUNCMASK_NOTA1) + { + dsprotectpatch_offsetNotA1 = regionOffset + 0xE0; + regionOffset += 0xE8; // DSProt_DetectNotFlashcart } - dsprotectpatchv1_nitro_static_init_offset = 0; // does not exist - dsprotectpatchv1_protectb1_return_value = 0; - dsprotectpatchv1_protectb2_return_value = 0; - dsprotectpatchv1_protectb3_return_value = 0; - dsprotectpatchv1_notprotectb1_return_value = 1; - dsprotectpatchv1_notprotectb2_return_value = 1; - dsprotectpatchv1_notprotectb3_return_value = 1; break; } case DSProtectVersion::v1_23: case DSProtectVersion::v1_23Z: { - dsprotectpatchv1_stub_protectb1_offset = 0x410; - dsprotectpatchv1_stub_protectb2_offset = 0x500; - dsprotectpatchv1_stub_protectb3_offset = 0x5F0; - dsprotectpatchv1_stub_notprotectb1_offset = 0x488; - dsprotectpatchv1_stub_notprotectb2_offset = 0x578; - dsprotectpatchv1_stub_notprotectb3_offset = 0x668; - // this seems to be a decrypt function that is called from 5 static init functions - dsprotectpatchv1_nitro_static_init_offset = 0xD78; - dsprotectpatchv1_protectb1_return_value = 0; - dsprotectpatchv1_protectb2_return_value = 0; - dsprotectpatchv1_protectb3_return_value = 0; - dsprotectpatchv1_notprotectb1_return_value = 1; - dsprotectpatchv1_notprotectb2_return_value = 1; - dsprotectpatchv1_notprotectb3_return_value = 1; + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_105_123; + + dsprotectpatch_offsetA1 = regionOffset + 0x0 + 0xAC; + dsprotectpatch_offsetNotA1 = regionOffset + 0xB8 + 0xAC; + break; } case DSProtectVersion::v1_25: + { + dsprotectpatch_patchType = PATCH_COPY_NEXT; + + dsprotectpatch_offsetA1 = regionOffset + 0x0 + 0x90; + dsprotectpatch_offsetNotA1 = regionOffset + 0xA4 +0x9C; + + break; + } case DSProtectVersion::v1_26: { - dsprotectpatchv1_stub_protectb1_offset = 0x3DC; - dsprotectpatchv1_stub_protectb2_offset = 0x4CC; - dsprotectpatchv1_stub_protectb3_offset = 0x5BC; - dsprotectpatchv1_stub_notprotectb1_offset = 0x454; - dsprotectpatchv1_stub_notprotectb2_offset = 0x544; - dsprotectpatchv1_stub_notprotectb3_offset = 0x634; - dsprotectpatchv1_nitro_static_init_offset = 0x6AC; + dsprotectpatch_patchType = PATCH_COPY_NEXT; + + dsprotectpatch_offsetA1 = regionOffset + 0x0 + 0x90; + dsprotectpatch_offsetNotA1 = regionOffset + 0xA4 + 0x9C; + break; } case DSProtectVersion::v1_27: { - dsprotectpatchv1_stub_protectb1_offset = 0x3A0; - dsprotectpatchv1_stub_protectb2_offset = 0x418; - dsprotectpatchv1_stub_protectb3_offset = 0x490; - dsprotectpatchv1_stub_notprotectb1_offset = 0x3DC; - dsprotectpatchv1_stub_notprotectb2_offset = 0x454; - dsprotectpatchv1_stub_notprotectb3_offset = 0x4CC; - dsprotectpatchv1_nitro_static_init_offset = 0x508; - dsprotectpatchv1_loadReturnValue = 0; // Return the return value of the callback + dsprotectpatch_patchType = PATCH_COPY_NEXT; + + dsprotectpatch_offsetA1 = regionOffset + 0x0 + 0x8C; + dsprotectpatch_offsetNotA1 = regionOffset + 0xA0 + 0x8C; + break; } case DSProtectVersion::v1_28: { - dsprotectpatchv1_stub_protectb1_offset = 0x3A0; - dsprotectpatchv1_stub_protectb2_offset = 0x418; - dsprotectpatchv1_stub_protectb3_offset = 0x490; - dsprotectpatchv1_stub_notprotectb1_offset = 0x3DC; - dsprotectpatchv1_stub_notprotectb2_offset = 0x454; - dsprotectpatchv1_stub_notprotectb3_offset = 0x4CC; - dsprotectpatchv1_nitro_static_init_offset = 0x508; - dsprotectpatchv1_loadReturnValue = 0; // Return the return value of the callback + dsprotectpatch_patchType = PATCH_COPY_NEXT; + + dsprotectpatch_offsetA1 = regionOffset + 0x0 + 0x8C; + dsprotectpatch_offsetNotA1 = regionOffset + 0xA0 + 0x8C; + + break; + } + case DSProtectVersion::v2_00: + { + dsprotectpatch_patchType = PATCH_COPY_NEXT; + + dsprotectpatch_offsetA1 = regionOffset + 0x0 + 0x188; + dsprotectpatch_offsetNotA1 = regionOffset + 0x19C + 0x188; + + break; + } + case DSProtectVersion::v2_01: + { + dsprotectpatch_patchType = PATCH_COPY_NEXT; + + dsprotectpatch_offsetA1 = regionOffset + 0xAB0 + 0x188; + dsprotectpatch_offsetNotA1 = regionOffset + 0xC4C + 0x188; + + break; + } + case DSProtectVersion::v2_03: + { + dsprotectpatch_patchType = PATCH_COPY_NEXT; + + dsprotectpatch_offsetA1 = regionOffset + 0xC1C + 0x18C; + dsprotectpatch_offsetNotA1 = regionOffset + 0xDBC + 0x18C; + + break; + } + case DSProtectVersion::v2_05: + { + dsprotectpatch_patchType = PATCH_COPY_NEXT; + + dsprotectpatch_offsetA1 = regionOffset + 0xCAC + 0x18C; + dsprotectpatch_offsetNotA1 = regionOffset + 0xE4C + 0x18C; + + break; + } + // Instant versions + case DSProtectVersion::v2_00s: + { + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_200s_205s; + + dsprotectpatch_offsetA1 = regionOffset + 0x94 + 0x118; + + break; + } + case DSProtectVersion::v2_01s: + { + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_200s_205s; + + dsprotectpatch_offsetA1 = regionOffset + 0x94 + 0x118; + + break; + } + case DSProtectVersion::v2_03s: + { + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_200s_205s; + + dsprotectpatch_offsetA1 = regionOffset + 0xE0 + 0x118; + + break; + } + case DSProtectVersion::v2_05s: + { + dsprotectpatch_patchType = PATCH_WRITE_WORD; + dsprotectpatch_writeWord = MAGIC_200s_205s; + + dsprotectpatch_offsetA1 = regionOffset + 0x104 + 0x118; + break; } default: { LOG_WARNING("Unsupported DSProtect version\n"); - return nextPatch; + break; } } - dsprotectpatchv1_nextAddress = (u32)nextPatch; - - u32 patch1Size = SECTION_SIZE(dsprotectpatchv1_part1); - void* patch1Address = patchContext.GetPatchHeap().Alloc(patch1Size); - u32 patch2Size = SECTION_SIZE(dsprotectpatchv1_part2); - void* patch2Address = patchContext.GetPatchHeap().Alloc(patch2Size); - - dsprotectpatchv1_part2_address = (u32)&dsprotectpatchv1_entry2 - (u32)SECTION_START(dsprotectpatchv1_part2) + (u32)patch2Address; - - u32 entryAddress1 = (u32)&dsprotectpatchv1_entry1 - (u32)SECTION_START(dsprotectpatchv1_part1) + (u32)patch1Address; - memcpy(patch1Address, SECTION_START(dsprotectpatchv1_part1), patch1Size); - memcpy(patch2Address, SECTION_START(dsprotectpatchv1_part2), patch2Size); - - return (const void*)entryAddress1; } - -struct ds_protect_v2_patch_t -{ - u32 checksumFix; - u16 stubProtectb1Offset; - u16 stubProtectb2Offset; - u16 stubProtectb3Offset; - u16 stubProtectb4Offset; - u16 amInitOffset; - u16 storeChecksumFix; -}; - -static const ds_protect_v2_patch_t sDSProtectV2Patches[] = -{ - { 0x7CDBA8BD, 0x670, 0x6AC, 0x6E8, 0x724, 0x760, THUMB_STR_IMM(THUMB_R7, THUMB_R0, 0) }, // v2.00 - { 0xA6FD7CE1, 0x1120, 0x115C, 0x1198, 0x11D4, 0x1210, THUMB_STR_IMM(THUMB_R7, THUMB_R0, 0) }, // v2.01 - { 0x45C535B6, 0x129C, 0x1324, 0x13AC, 0x1434, 0x14BC, THUMB_STR_IMM(THUMB_R7, THUMB_R0, 0) }, // v2.03 - { 0x32E120D5, 0x132C, 0x13D8, 0x1484, 0x1530, 0x15DC, THUMB_STR_IMM(THUMB_R7, THUMB_R0, 8) }, // v2.05 -}; - -const void* DSProtectOverlayPatch::InsertPatchV2(PatchContext& patchContext) const -{ - dsprotectpatchv2_nextAddress = next ? (u32)next->InsertPatch(patchContext) : 0u; - dsprotectpatchv2_overlay_id = _overlayId; - dsprotectpatchv2_base_offset = _overlayOffset; - - const auto& patch = sDSProtectV2Patches[(u32)_version - (u32)DSProtectVersion::v2_00]; - dsprotectpatchv2_checksum_fix = patch.checksumFix; - dsprotectpatchv2_stub_protectb1_offset = patch.stubProtectb1Offset; - dsprotectpatchv2_stub_protectb2_offset = patch.stubProtectb2Offset; - dsprotectpatchv2_stub_protectb3_offset = patch.stubProtectb3Offset; - dsprotectpatchv2_stub_protectb4_offset = patch.stubProtectb4Offset; - dsprotectpatchv2_am_init_offset = patch.amInitOffset; - dsprotectpatchv2_store_checksum_fix = patch.storeChecksumFix; - - u32 patchSize = SECTION_SIZE(dsprotectpatchv2); - void* patchAddress = patchContext.GetPatchHeap().Alloc(patchSize); - - u32 entryAddress = (u32)&dsprotectpatchv2_entry - (u32)SECTION_START(dsprotectpatchv2) + (u32)patchAddress; - memcpy(patchAddress, SECTION_START(dsprotectpatchv2), patchSize); - - return (const void*)entryAddress; -} - -struct ds_protect_v2s_patch_t -{ - u32 checksumFix; - u16 instantDetectOffset; - u16 storeChecksumFix; -}; - -static const ds_protect_v2s_patch_t sDSProtectV2sPatches[] = -{ - { 0xEDEA7F01, 0x1BC, THUMB_STR_IMM(THUMB_R7, THUMB_R0, 0) }, // v2.00s - { 0xEDEA7F1F, 0x1BC, THUMB_STR_IMM(THUMB_R7, THUMB_R0, 0) }, // v2.01s - { 0x167325AA, 0x20C, THUMB_STR_IMM(THUMB_R7, THUMB_R0, 0) }, // v2.03s - { 0x32E120D5, 0x230, THUMB_STR_IMM(THUMB_R7, THUMB_R0, 4) } // v2.05s -}; - -const void* DSProtectOverlayPatch::InsertPatchV2s(PatchContext& patchContext) const -{ - dsprotectpatchv2s_nextAddress = next ? (u32)next->InsertPatch(patchContext) : 0u; - dsprotectpatchv2s_overlay_id = _overlayId; - - const auto& patch = sDSProtectV2sPatches[(u32)_version - (u32)DSProtectVersion::v2_00s]; - dsprotectpatchv2s_checksum_fix = patch.checksumFix; - dsprotectpatchv2s_stub_instantdetect_offset = patch.instantDetectOffset + _overlayOffset; - dsprotectpatchv2s_store_checksum_fix = patch.storeChecksumFix; - - u32 patchSize = SECTION_SIZE(dsprotectpatchv2s); - void* patchAddress = patchContext.GetPatchHeap().Alloc(patchSize); - u32 entryAddress = (u32)&dsprotectpatchv2s_entry - (u32)SECTION_START(dsprotectpatchv2s) + (u32)patchAddress; - memcpy(patchAddress, SECTION_START(dsprotectpatchv2s), patchSize); - - return (const void*)entryAddress; -} \ No newline at end of file diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatch.h b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatch.h index 0b76e9d..8c27437 100644 --- a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatch.h +++ b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatch.h @@ -17,8 +17,5 @@ private: DSProtectVersion _version; u32 _functionMask; - void SetOldV1Offsets(const u16* offsets) const; - const void* InsertPatchV1(PatchContext& patchContext) const; - const void* InsertPatchV2(PatchContext& patchContext) const; - const void* InsertPatchV2s(PatchContext& patchContext) const; + void ConfigurePatch(PatchContext& patchContext) const; }; diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchAsm.h b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchAsm.h new file mode 100644 index 0000000..4bc749a --- /dev/null +++ b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchAsm.h @@ -0,0 +1,14 @@ +#pragma once +#include "sections.h" + +DEFINE_SECTION_SYMBOLS(dsprotectpatch); + +extern "C" void dsprotectpatch_entry(); + +extern u32 dsprotectpatch_patchType; // 0=write dsprotectpatch_writeWord, 1=copy subsequent word +extern u32 dsprotectpatch_writeWord; // Word to write if dsprotectpatch_patchType=0 +extern u32 dsprotectpatch_offsetA1; // Target offset for A1 (0xFFFFFFFF=invalid) +extern u32 dsprotectpatch_offsetNotA1; // Target offset for NotA1 (0xFFFFFFFF=invalid) + +extern u32 dsprotectpatch_overlayId; // Target overlay ID +extern const void* dsprotectpatch_nextAddress; // Next patch address diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchAsm.s b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchAsm.s new file mode 100644 index 0000000..d90231e --- /dev/null +++ b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchAsm.s @@ -0,0 +1,89 @@ +.cpu arm946e-s +.syntax unified +.section "dsprotectpatch", "ax" +.thumb + +.global dsprotectpatch_entry +.type dsprotectpatch_entry, %function +dsprotectpatch_entry: + push {r4-r7, lr} + + // r5 is overlay table entry-- load { ovy_id, ram_start } + ldmia r5!, {r6, r7} + + // Bail if this is the wrong overlay + ldr r4, dsprotectpatch_overlayId + cmp r4, r6 + bne continue_to_next + + // Try to patch A1 + ldr r0, dsprotectpatch_offsetA1 + adds r0, r7 + bl try_apply_patch + + // Try to patch NotA1 + ldr r0, dsprotectpatch_offsetNotA1 + adds r0, r7 + bl try_apply_patch + +continue_to_next: + // Return next patch address + ldr r0, dsprotectpatch_nextAddress + pop {r4-r7, pc} + +.local try_apply_patch +.type try_apply_patch, %function +try_apply_patch: + // If the high bit is set, this is invalid and we skip it + cmp r0, #0x0 + blt offset_invalid + + // Check what patch type to use + ldr r1, dsprotectpatch_patchType + cmp r1, #0x0 + beq load_literal + + // Load next word (+4) + ldr r2, [r0, #0x4] + b load_done + +load_literal: + // Load literal value + ldr r2, dsprotectpatch_writeWord + +load_done: + // Write to patch location + str r2, [r0] + +offset_invalid: + bx lr + +.balign 4 + +.global dsprotectpatch_writeWord +dsprotectpatch_writeWord: + .word 0 + +.global dsprotectpatch_patchType +dsprotectpatch_patchType: + .word 0 + +.global dsprotectpatch_offsetA1 +dsprotectpatch_offsetA1: + .word 0 + +.global dsprotectpatch_offsetNotA1 +dsprotectpatch_offsetNotA1: + .word 0 + +.global dsprotectpatch_overlayId +dsprotectpatch_overlayId: + .word 0 + +.global dsprotectpatch_nextAddress +dsprotectpatch_nextAddress: + .word 0 + +.pool + +.end diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv1Asm.h b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv1Asm.h deleted file mode 100644 index b4a79ca..0000000 --- a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv1Asm.h +++ /dev/null @@ -1,27 +0,0 @@ -#pragma once -#include "sections.h" - -DEFINE_SECTION_SYMBOLS(dsprotectpatchv1_part1); -extern "C" void dsprotectpatchv1_entry1(); -extern u16 dsprotectpatchv1_stub_protectb1_offset; -extern u16 dsprotectpatchv1_stub_protectb2_offset; -extern u16 dsprotectpatchv1_stub_protectb3_offset; -extern u16 dsprotectpatchv1_nitro_static_init_offset; -extern u16 dsprotectpatchv1_overlay_id; -extern u32 dsprotectpatchv1_base_offset; -extern u32 dsprotectpatchv1_part2_address; -extern u32 dsprotectpatchv1_protectb1_return_value; -extern u32 dsprotectpatchv1_protectb2_return_value; -extern u32 dsprotectpatchv1_protectb3_return_value; - -DEFINE_SECTION_SYMBOLS(dsprotectpatchv1_part2); -extern "C" void dsprotectpatchv1_entry2(); -extern u16 dsprotectpatchv1_stub_notprotectb1_offset; -extern u16 dsprotectpatchv1_stub_notprotectb2_offset; -extern u16 dsprotectpatchv1_stub_notprotectb3_offset; -extern u32 dsprotectpatchv1_nextAddress; -extern u32 dsprotectpatchv1_notprotectb1_return_value; -extern u32 dsprotectpatchv1_notprotectb2_return_value; -extern u32 dsprotectpatchv1_notprotectb3_return_value; -extern u32 dsprotectpatchv1_loadReturnValue; -extern u32 dsprotectpatchv1_moveCallback; diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv1Asm.s b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv1Asm.s deleted file mode 100644 index 1b75d72..0000000 --- a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv1Asm.s +++ /dev/null @@ -1,168 +0,0 @@ -.cpu arm946e-s -.syntax unified -.section "dsprotectpatchv1_part1", "ax" - -.thumb - -.global dsprotectpatchv1_entry1 -.type dsprotectpatchv1_entry1, %function -dsprotectpatchv1_entry1: - push {r4-r7,lr} - adr r0, dsprotectpatchv1_stub_protectb1_offset - ldrh r4, [r0, #(dsprotectpatchv1_overlay_id - dsprotectpatchv1_stub_protectb1_offset)] - ldmia r5!, {r1, r2} // id, ram address - cmp r1, r4 - bne continue_to_next - - ldr r4, dsprotectpatchv1_base_offset - adds r2, r4 // add base offset to overlay address - - ldrh r4, [r0, #(dsprotectpatchv1_nitro_static_init_offset - dsprotectpatchv1_stub_protectb1_offset)] - ldr r3,= 0xE12FFF1E // bx lr - str r3, [r4, r2] - - adr r4, protectbX_patch - ldmia r4!, {r5,r6} - - adds r3, r0, #(dsprotectpatchv1_nitro_static_init_offset - dsprotectpatchv1_stub_protectb1_offset) -1: - ldmia r4!, {r7} - ldrh r1, [r0] - adds r1, r2 - stmia r1!, {r5,r6,r7} - adds r0, #2 - cmp r0, r3 - bne 1b - - ldr r7, dsprotectpatchv1_part2_address - bx r7 - -continue_to_next: - ldr r7, dsprotectpatchv1_part2_address - adds r7, #(dsprotectpatchv1_continue_to_next - dsprotectpatchv1_entry2) - bx r7 - -.global dsprotectpatchv1_stub_protectb1_offset -dsprotectpatchv1_stub_protectb1_offset: - .short 0 - -.global dsprotectpatchv1_stub_protectb2_offset -dsprotectpatchv1_stub_protectb2_offset: - .short 0 - -.global dsprotectpatchv1_stub_protectb3_offset -dsprotectpatchv1_stub_protectb3_offset: - .short 0 - -.global dsprotectpatchv1_nitro_static_init_offset -dsprotectpatchv1_nitro_static_init_offset: - .short 0 - -.global dsprotectpatchv1_overlay_id -dsprotectpatchv1_overlay_id: - .short 0 - -.balign 4 - -.global dsprotectpatchv1_base_offset -dsprotectpatchv1_base_offset: - .word 0 - -.global dsprotectpatchv1_part2_address -dsprotectpatchv1_part2_address: - .word 0 - -.pool - -.arm -protectbX_patch: - ldr r0, dsprotectpatchv1_protectb1_return_value - bx lr -.global dsprotectpatchv1_protectb1_return_value -dsprotectpatchv1_protectb1_return_value: - .word 1830601 -.global dsprotectpatchv1_protectb2_return_value -dsprotectpatchv1_protectb2_return_value: - .word 1830203 -.global dsprotectpatchv1_protectb3_return_value -dsprotectpatchv1_protectb3_return_value: - .word 1828014 - -.section "dsprotectpatchv1_part2", "ax" - -.thumb - -.global dsprotectpatchv1_entry2 -.type dsprotectpatchv1_entry2, %function -dsprotectpatchv1_entry2: - adr r0, dsprotectpatchv1_stub_notprotectb1_offset - adds r1, r0, #(dsprotectpatchv1_stub_notprotectb3_offset - dsprotectpatchv1_stub_notprotectb1_offset + 2) - mov lr, r1 -2: - ldrh r1, [r0] - adds r1, r2 - adr r3, notprotectbX_patch - ldmia r3!, {r4,r5,r6,r7} - stmia r1!, {r4,r5,r6,r7} - ldmia r3!, {r4,r5,r6} - stmia r1!, {r4,r5,r6} - adds r0, #2 - cmp r0, lr - bne 2b - - ldmia r3!, {r6,r7} - - adds r2, #0x18 - adr r0, dsprotectpatchv1_stub_notprotectb1_offset - ldrh r1, [r0, #(dsprotectpatchv1_stub_notprotectb2_offset - dsprotectpatchv1_stub_notprotectb1_offset)] - str r6, [r1, r2] - ldrh r1, [r0, #(dsprotectpatchv1_stub_notprotectb3_offset - dsprotectpatchv1_stub_notprotectb1_offset)] - str r7, [r1, r2] - -dsprotectpatchv1_continue_to_next: - ldr r0, dsprotectpatchv1_nextAddress - pop {r4-r7,pc} - -.global dsprotectpatchv1_stub_notprotectb1_offset -dsprotectpatchv1_stub_notprotectb1_offset: - .short 0 - -.global dsprotectpatchv1_stub_notprotectb2_offset -dsprotectpatchv1_stub_notprotectb2_offset: - .short 0 - -.global dsprotectpatchv1_stub_notprotectb3_offset -dsprotectpatchv1_stub_notprotectb3_offset: - .short 0 - -.balign 4 - -.global dsprotectpatchv1_nextAddress -dsprotectpatchv1_nextAddress: - .word 0 - -.pool - -.arm -notprotectbX_patch: - push {lr} -.global dsprotectpatchv1_moveCallback -dsprotectpatchv1_moveCallback: - movs lr, r0 - movne r0, r1 - blxne lr -.global dsprotectpatchv1_loadReturnValue -dsprotectpatchv1_loadReturnValue: - ldr r0, dsprotectpatchv1_notprotectb1_return_value - pop {pc} -.global dsprotectpatchv1_notprotectb1_return_value -dsprotectpatchv1_notprotectb1_return_value: - .word 1831551 -.global dsprotectpatchv1_notprotectb2_return_value -dsprotectpatchv1_notprotectb2_return_value: - .word 1830859 -.global dsprotectpatchv1_notprotectb3_return_value -dsprotectpatchv1_notprotectb3_return_value: - .word 1829648 - -.end \ No newline at end of file diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2Asm.h b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2Asm.h deleted file mode 100644 index bc2dbeb..0000000 --- a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2Asm.h +++ /dev/null @@ -1,17 +0,0 @@ -#pragma once -#include "sections.h" - -DEFINE_SECTION_SYMBOLS(dsprotectpatchv2); - -extern "C" void dsprotectpatchv2_entry(); -extern u16 dsprotectpatchv2_stub_protectb1_offset; -extern u16 dsprotectpatchv2_stub_protectb2_offset; -extern u16 dsprotectpatchv2_stub_protectb3_offset; -extern u16 dsprotectpatchv2_stub_protectb4_offset; -extern u16 dsprotectpatchv2_am_init_offset; -extern u16 dsprotectpatchv2_overlay_id; -extern u32 dsprotectpatchv2_nextAddress; -extern u32 dsprotectpatchv2_checksum_fix; -extern u32 dsprotectpatchv2_base_offset; - -extern u16 dsprotectpatchv2_store_checksum_fix; diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2Asm.s b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2Asm.s deleted file mode 100644 index 04cdbb0..0000000 --- a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2Asm.s +++ /dev/null @@ -1,93 +0,0 @@ -.cpu arm946e-s -.section "dsprotectpatchv2", "ax" -.syntax unified -.thumb - -.global dsprotectpatchv2_entry -.type dsprotectpatchv2_entry, %function -dsprotectpatchv2_entry: - push {r4-r7,lr} - - ldmia r5!, {r0,r1,r2} - adds r3, r2, r1 // bss address - - adr r2, dsprotectpatchv2_stub_protectb1_offset - ldrh r7, [r2, #(dsprotectpatchv2_overlay_id - dsprotectpatchv2_stub_protectb1_offset)] - cmp r0, r7 - bne continue_to_next - - ldr r7, [r2, #(dsprotectpatchv2_base_offset - dsprotectpatchv2_stub_protectb1_offset)] - adds r1, r7 // add base offset to overlay address - - ldrh r0, [r2, #(dsprotectpatchv2_am_init_offset - dsprotectpatchv2_stub_protectb1_offset)] - ldr r7,= 0xE12FFF1E // bx lr - str r7, [r1, r0] - - adr r0, stub_patch_code - ldmia r0!, {r4,r5,r6,r7} - - subs r1, #4 // write from 4 bytes before the actual function address - adds r0, r2, #(dsprotectpatchv2_stub_protectb4_offset - dsprotectpatchv2_stub_protectb1_offset) - mov lr, r0 -patch_loop: - ldrh r0, [r2] - adds r2, #2 - adds r0, r1 - stmia r0!, {r3,r4,r5,r6} // bss address + code -.global dsprotectpatchv2_store_checksum_fix -dsprotectpatchv2_store_checksum_fix: - str r7, [r0, #0] // checksum fix - cmp r2, lr - ble patch_loop - -continue_to_next: - ldr r0, dsprotectpatchv2_nextAddress - pop {r4-r7,pc} - -.balign 4 - -.global dsprotectpatchv2_stub_protectb1_offset -dsprotectpatchv2_stub_protectb1_offset: - .short 0 - -.global dsprotectpatchv2_stub_protectb2_offset -dsprotectpatchv2_stub_protectb2_offset: - .short 0 - -.global dsprotectpatchv2_stub_protectb3_offset -dsprotectpatchv2_stub_protectb3_offset: - .short 0 - -.global dsprotectpatchv2_stub_protectb4_offset -dsprotectpatchv2_stub_protectb4_offset: - .short 0 - -.global dsprotectpatchv2_am_init_offset -dsprotectpatchv2_am_init_offset: - .short 0 - -.global dsprotectpatchv2_overlay_id -dsprotectpatchv2_overlay_id: - .short 0 - -.global dsprotectpatchv2_base_offset -dsprotectpatchv2_base_offset: - .word 0 - -.global dsprotectpatchv2_nextAddress -dsprotectpatchv2_nextAddress: - .word 0 - -.pool - -.arm -stub_patch_code: - ldr r12, (. - 4) - ldr r2, [r12], #4 - ldr pc, [r12, r2, lsl #2] - -.global dsprotectpatchv2_checksum_fix -dsprotectpatchv2_checksum_fix: - .word 0 - -.end \ No newline at end of file diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2sAsm.h b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2sAsm.h deleted file mode 100644 index dd9d352..0000000 --- a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2sAsm.h +++ /dev/null @@ -1,12 +0,0 @@ -#pragma once -#include "sections.h" - -DEFINE_SECTION_SYMBOLS(dsprotectpatchv2s); - -extern "C" void dsprotectpatchv2s_entry(); -extern u32 dsprotectpatchv2s_stub_instantdetect_offset; -extern u32 dsprotectpatchv2s_overlay_id; -extern u32 dsprotectpatchv2s_nextAddress; -extern u32 dsprotectpatchv2s_checksum_fix; - -extern u16 dsprotectpatchv2s_store_checksum_fix; diff --git a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2sAsm.s b/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2sAsm.s deleted file mode 100644 index e07a7bf..0000000 --- a/arm9/source/patches/arm9/OverlayPatches/DSProtectPatches/DSProtectOverlayPatchv2sAsm.s +++ /dev/null @@ -1,64 +0,0 @@ -.cpu arm946e-s -.section "dsprotectpatchv2s", "ax" -.syntax unified -.thumb - -.global dsprotectpatchv2s_entry -.type dsprotectpatchv2s_entry, %function -dsprotectpatchv2s_entry: - push {r4-r7,lr} - - ldmia r5!, {r0,r1,r2,r3,r4} - - ldr r7, dsprotectpatchv2s_overlay_id - cmp r0, r7 - bne continue_to_next - - movs r3, #0 - movs r7, #0 - stmia r4!, {r3,r7} - stmia r4!, {r3,r7} - str r3, [r4] - - adr r0, stub_patch_code - ldmia r0!, {r3,r4,r5,r6,r7} - - ldr r0, dsprotectpatchv2s_stub_instantdetect_offset - adds r0, r1 - stmia r0!, {r3,r4,r5,r6} // code -.global dsprotectpatchv2s_store_checksum_fix -dsprotectpatchv2s_store_checksum_fix: - str r7, [r0, #0] // checksum fix - -continue_to_next: - ldr r0, dsprotectpatchv2s_nextAddress - pop {r4-r7,pc} - -.balign 4 - -.global dsprotectpatchv2s_stub_instantdetect_offset -dsprotectpatchv2s_stub_instantdetect_offset: - .word 0 - -.global dsprotectpatchv2s_overlay_id -dsprotectpatchv2s_overlay_id: - .word 0 - -.global dsprotectpatchv2s_nextAddress -dsprotectpatchv2s_nextAddress: - .word 0 - -.pool - -.arm -stub_patch_code: - movs r3, r0 - pusheq {r0,r1,lr} - pushne {r1,r2,r3} - pop {r0,r1,pc} - -.global dsprotectpatchv2s_checksum_fix -dsprotectpatchv2s_checksum_fix: - .word 0 - -.end \ No newline at end of file diff --git a/common/ApList.cpp b/common/ApList.cpp index 3eabef8..b283d4c 100644 --- a/common/ApList.cpp +++ b/common/ApList.cpp @@ -30,6 +30,7 @@ void ApListEntry::Dump() const const char* dsProtectVersionString; switch (GetDSProtectVersion()) { + case DSProtectVersion::v1_00_2: dsProtectVersionString = "v1.00_2"; break; case DSProtectVersion::v1_05: dsProtectVersionString = "v1.05"; break; case DSProtectVersion::v1_06: dsProtectVersionString = "v1.06"; break; case DSProtectVersion::v1_08: dsProtectVersionString = "v1.08"; break; diff --git a/common/DSProtectVersion.h b/common/DSProtectVersion.h index fe107d2..9d4db25 100644 --- a/common/DSProtectVersion.h +++ b/common/DSProtectVersion.h @@ -22,5 +22,6 @@ enum class DSProtectVersion : u32 v2_00s, v2_01s, v2_03s, - v2_05s + v2_05s, + v1_00_2 }; diff --git a/data/aplist.csv b/data/aplist.csv index f62c76e..2f45985 100644 --- a/data/aplist.csv +++ b/data/aplist.csv @@ -2,6 +2,7 @@ gameCode;gameVersion;dsprotVersion;dsprotFuncMask;regularOvlId;regularOffset;sOv A3PJ;0;1.10;10101;-2;0x28f34;-1;0x0 A3YK;0;1.08;111111;6;0x39c;-1;0x0 AEYK;0;1.06;10101;-2;0x5ccdc;-1;0x0 +ANMK;0;1.00_2;110011;-2;0x105d80;-1;0x0 ARFK;0;1.23;111111;2;0x0;-1;0x0 ARMK;0;1.23;111111;28;0x0;-1;0x0 AWIK;0;1.06;10101;-2;0xc9074;-1;0x0 @@ -519,6 +520,8 @@ YEEI;0;1.28;111111;90;0x0;-1;0x0 YEEP;0;1.28;111111;90;0x0;-1;0x0 YEES;0;1.28;111111;90;0x0;-1;0x0 YEOK;0;1.20;10101;-2;0x8a820;-1;0x0 +YFTK;0;1.00_2;110011;-2;0x69d40;-1;0x0 +YFYK;0;1.00_2;110011;-2;0x69d40;-1;0x0 YG4K;0;1.08;10101;2;0x0;-1;0x0 YKGE;0;1.10;111111;28;0x0;-1;0x0 YKGJ;0;1.08;111111;28;0x0;-1;0x0 @@ -537,7 +540,11 @@ YR4J;0;1.23;111111;1;0xcca0;-1;0x0 YRBK;0;1.08;10111;64;0x0;-1;0x0 YRCK;0;1.20;111111;0;0x0;-1;0x0 YROK;0;1.26;111111;0;0x0;-1;0x0 +YV5E;0;1.00_2;000001;-2;0x7e74;-1;0x0 +YV5J;0;1.00_2;000001;-2;0x7e74;-1;0x0 +YV5P;0;1.00_2;000001;-2;0x7e74;-1;0x0 YVIE;0;1.28;111111;47;0x0;-1;0x0 YVIJ;0;1.22;10111;47;0x0;-1;0x0 YVIP;0;1.28;111111;47;0x0;-1;0x0 +YVKK;0;1.00_2;010001;-2;0xf7064;-1;0x0 YW4K;0;1.06;111111;0;0x0;-1;0x0 diff --git a/tools/PicoLoaderConverter/PicoLoaderConverter/ApList/ApListFactory.cs b/tools/PicoLoaderConverter/PicoLoaderConverter/ApList/ApListFactory.cs index b2f310d..6bffebe 100644 --- a/tools/PicoLoaderConverter/PicoLoaderConverter/ApList/ApListFactory.cs +++ b/tools/PicoLoaderConverter/PicoLoaderConverter/ApList/ApListFactory.cs @@ -152,6 +152,7 @@ sealed class ApListFactory { return dsProtectVersion switch { + "1.00_2" => DSProtectVersion.V1_00_2, "1.05" => DSProtectVersion.V1_05, "1.06" => DSProtectVersion.V1_06, "1.08" => DSProtectVersion.V1_08, @@ -181,6 +182,7 @@ sealed class ApListFactory { return dsProtectVersion switch { + DSProtectVersion.V1_00_2 => "1.00_2", DSProtectVersion.V1_05 => "1.05", DSProtectVersion.V1_06 => "1.06", DSProtectVersion.V1_08 => "1.08", diff --git a/tools/PicoLoaderConverter/PicoLoaderConverter/ApList/DSProtectVersion.cs b/tools/PicoLoaderConverter/PicoLoaderConverter/ApList/DSProtectVersion.cs index c9b7806..82ada24 100644 --- a/tools/PicoLoaderConverter/PicoLoaderConverter/ApList/DSProtectVersion.cs +++ b/tools/PicoLoaderConverter/PicoLoaderConverter/ApList/DSProtectVersion.cs @@ -21,5 +21,6 @@ enum DSProtectVersion V2_00s, V2_01s, V2_03s, - V2_05s + V2_05s, + V1_00_2 }