NdsKey1Cipher.cs

using System.Buffers.Binary;
 
namespace NdsForge;

internal static class NdsKey1Cipher
{
    public const uint DestroyedId = 0xE7FFDEFF;
    private const uint SecureId0 = 0x72636E65;
    private const uint SecureId1 = 0x6A624F79;

    public static byte[] Encrypt(ReadOnlySpan<byte> area, uint gameCode, NdsKey1KeyTable keyTable)
    {
        ValidateArea(area);
        if (ReadWord(area, 0) != DestroyedId || ReadWord(area, 4) != DestroyedId)
        {
            throw new InvalidDataException("Decrypted secure-area bytes must begin with two 0xE7FFDEFF marker words.");
        }
 
        byte[] output = area.ToArray();
        (uint[] words, uint[] argument) = InitializeLevel1(keyTable, gameCode);
        argument[1] = unchecked(argument[1] << 1);
        argument[2] >>= 1;
        InitializeLevel2(words, argument);
        for (int offset = 8; offset < 0x800; offset += 8)
        {
            EncryptStoredBlock(words, output, offset);
        }
 
        WriteWord(output, 0, SecureId0);
        WriteWord(output, 4, SecureId1);
        EncryptStoredBlock(words, output, 0);
        (words, _) = InitializeLevel1(keyTable, gameCode);
        EncryptStoredBlock(words, output, 0);
        return output;
    }

    public static byte[] Decrypt(ReadOnlySpan<byte> area, uint gameCode, NdsKey1KeyTable keyTable)
    {
        ValidateArea(area);
        byte[] output = area.ToArray();
        (uint[] words, uint[] argument) = InitializeLevel1(keyTable, gameCode);
        DecryptStoredBlock(words, output, 0);
        argument[1] = unchecked(argument[1] << 1);
        argument[2] >>= 1;
        InitializeLevel2(words, argument);
        DecryptStoredBlock(words, output, 0);
        if (ReadWord(output, 0) != SecureId0 || ReadWord(output, 4) != SecureId1)
        {
            throw new InvalidDataException("The supplied KEY1 table and game code do not recover a secure-area identifier.");
        }
 
        WriteWord(output, 0, DestroyedId);
        WriteWord(output, 4, DestroyedId);
        for (int offset = 8; offset < 0x800; offset += 8)
        {
            DecryptStoredBlock(words, output, offset);
        }
 
        return output;
    }

    private static (uint[] Words, uint[] Argument) InitializeLevel1(NdsKey1KeyTable keyTable, uint gameCode)
    {
        uint[] words = keyTable.CreateWorkingWords();
        uint[] argument = [gameCode, gameCode >> 1, unchecked(gameCode << 1)];
        InitializeLevel2(words, argument);
        InitializeLevel2(words, argument);
        return (words, argument);
    }

    private static void InitializeLevel2(uint[] words, uint[] argument)
    {
        EncryptBlock(words, ref argument[2], ref argument[1]);
        EncryptBlock(words, ref argument[1], ref argument[0]);
        UpdateSchedule(words, argument);
    }

    private static void UpdateSchedule(uint[] words, uint[] argument)
    {
        Span<byte> argumentBytes = stackalloc byte[12];
        for (int index = 0; index < argument.Length; index++)
        {
            BinaryPrimitives.WriteUInt32LittleEndian(argumentBytes[(index * 4)..], argument[index]);
        }
 
        for (int round = 0; round < 18; round++)
        {
            uint value = 0;
            for (int index = 0; index < 4; index++)
            {
                value = unchecked((value << 8) | argumentBytes[((round * 4) + index) & 7]);
            }
 
            words[round] ^= value;
        }
 
        uint first = 0;
        uint second = 0;
        for (int index = 0; index < words.Length; index += 2)
        {
            EncryptBlock(words, ref first, ref second);
            words[index] = first;
            words[index + 1] = second;
        }
    }

    private static void EncryptBlock(uint[] words, ref uint first, ref uint second)
    {
        uint a = first;
        uint b = second;
        for (int round = 0; round < 16; round++)
        {
            uint c = words[round] ^ a;
            a = b ^ Lookup(words, c);
            b = c;
        }
 
        second = a ^ words[16];
        first = b ^ words[17];
    }

    private static void DecryptBlock(uint[] words, ref uint first, ref uint second)
    {
        uint a = first;
        uint b = second;
        for (int round = 17; round > 1; round--)
        {
            uint c = words[round] ^ a;
            a = b ^ Lookup(words, c);
            b = c;
        }
 
        first = b ^ words[0];
        second = a ^ words[1];
    }

    private static uint Lookup(uint[] words, uint value)
    {
        uint a = words[18 + (value >> 24)];
        uint b = words[18 + 256 + ((value >> 16) & 0xFF)];
        uint c = words[18 + 512 + ((value >> 8) & 0xFF)];
        uint d = words[18 + 768 + (value & 0xFF)];
        return unchecked(d + (c ^ (b + a)));
    }

    private static void EncryptStoredBlock(uint[] words, Span<byte> data, int offset)
    {
        uint first = ReadWord(data, offset + 4);
        uint second = ReadWord(data, offset);
        EncryptBlock(words, ref first, ref second);
        WriteWord(data, offset + 4, first);
        WriteWord(data, offset, second);
    }

    private static void DecryptStoredBlock(uint[] words, Span<byte> data, int offset)
    {
        uint first = ReadWord(data, offset + 4);
        uint second = ReadWord(data, offset);
        DecryptBlock(words, ref first, ref second);
        WriteWord(data, offset + 4, first);
        WriteWord(data, offset, second);
    }

    private static uint ReadWord(ReadOnlySpan<byte> data, int offset) =>
        BinaryPrimitives.ReadUInt32LittleEndian(data[offset..]);

    private static void WriteWord(Span<byte> data, int offset, uint value) =>
        BinaryPrimitives.WriteUInt32LittleEndian(data[offset..], value);

    private static void ValidateArea(ReadOnlySpan<byte> area)
    {
        if (area.Length != NdsSecureArea.ByteLength)
        {
            throw new ArgumentException($"A secure area must contain exactly 0x{NdsSecureArea.ByteLength:X} bytes.", nameof(area));
        }
    }
}