NdsSecureArea.cs

using System.Buffers.Binary;
using System.Text;
 
namespace NdsForge;

public static class NdsSecureArea
{
    public const int Offset = 0x4000;
    public const int ByteLength = 0x4000;

    public static NdsSecureAreaInspection Inspect(NdsImage image, NdsKey1KeyTable? keyTable = null)
    {
        ArgumentNullException.ThrowIfNull(image);
        if (image.Header.Arm9.Data.Offset < Offset)
        {
            return new(NdsSecureAreaState.Absent, default, image.Header.SecureAreaCrc, null);
        }
 
        var region = new NdsRegion(Offset, ByteLength);
        if (image.Length < region.End)
        {
            return new(NdsSecureAreaState.Malformed, region, image.Header.SecureAreaCrc, null);
        }
 
        var data = new byte[ByteLength];
        using Stream stream = image.OpenRead(region);
        stream.ReadExactly(data);
        return Inspect(data, image.Header.GameCode, image.Header.SecureAreaCrc, keyTable);
    }

    public static NdsSecureAreaInspection Inspect(
        ReadOnlySpan<byte> area,
        string gameCode,
        ushort storedCrc,
        NdsKey1KeyTable? keyTable = null)
    {
        ValidateArea(area);
        uint first = BinaryPrimitives.ReadUInt32LittleEndian(area);
        uint second = BinaryPrimitives.ReadUInt32LittleEndian(area[4..]);
        var region = new NdsRegion(Offset, ByteLength);
        if (first == 0 && second == 0)
        {
            return new(NdsSecureAreaState.Multiboot, region, storedCrc, NdsChecksums.ComputeCrc16(area));
        }
 
        if (first == NdsKey1Cipher.DestroyedId && second == NdsKey1Cipher.DestroyedId)
        {
            ushort? calculated = keyTable is null
                ? null
                : NdsChecksums.ComputeCrc16(NdsKey1Cipher.Encrypt(area, ParseGameCode(gameCode), keyTable));
            return new(NdsSecureAreaState.Decrypted, region, storedCrc, calculated);
        }
 
        if (keyTable is not null)
        {
            try
            {
                _ = NdsKey1Cipher.Decrypt(area, ParseGameCode(gameCode), keyTable);
                return new(
                    NdsSecureAreaState.Encrypted,
                    region,
                    storedCrc,
                    NdsChecksums.ComputeCrc16(area));
            }
            catch (InvalidDataException)
            {
                // Failed identifier recovery is an inspection result rather than an exceptional control path.
            }
        }
 
        return new(
            NdsSecureAreaState.Unrecognized,
            region,
            storedCrc,
            keyTable is null ? null : NdsChecksums.ComputeCrc16(area));
    }

    public static byte[] Encrypt(ReadOnlySpan<byte> area, string gameCode, NdsKey1KeyTable keyTable)
    {
        ArgumentNullException.ThrowIfNull(keyTable);
        return NdsKey1Cipher.Encrypt(area, ParseGameCode(gameCode), keyTable);
    }

    public static byte[] Decrypt(ReadOnlySpan<byte> area, string gameCode, NdsKey1KeyTable keyTable)
    {
        ArgumentNullException.ThrowIfNull(keyTable);
        return NdsKey1Cipher.Decrypt(area, ParseGameCode(gameCode), keyTable);
    }

    public static ValueTask EncryptAsync(
        Stream source,
        Stream destination,
        string gameCode,
        NdsKey1KeyTable keyTable,
        CancellationToken cancellationToken = default) =>
        TransformAsync(source, destination, gameCode, keyTable, encrypt: true, cancellationToken);

    public static ValueTask DecryptAsync(
        Stream source,
        Stream destination,
        string gameCode,
        NdsKey1KeyTable keyTable,
        CancellationToken cancellationToken = default) =>
        TransformAsync(source, destination, gameCode, keyTable, encrypt: false, cancellationToken);

    private static async ValueTask TransformAsync(
        Stream source,
        Stream destination,
        string gameCode,
        NdsKey1KeyTable keyTable,
        bool encrypt,
        CancellationToken cancellationToken)
    {
        ArgumentNullException.ThrowIfNull(source);
        ArgumentNullException.ThrowIfNull(destination);
        if (!source.CanRead)
        {
            throw new ArgumentException("The secure-area source must be readable.", nameof(source));
        }
 
        if (!destination.CanWrite)
        {
            throw new ArgumentException("The secure-area destination must be writable.", nameof(destination));
        }
 
        var input = new byte[ByteLength];
        await source.ReadExactlyAsync(input, cancellationToken).ConfigureAwait(false);
        byte[] output = encrypt
            ? Encrypt(input, gameCode, keyTable)
            : Decrypt(input, gameCode, keyTable);
        await destination.WriteAsync(output, cancellationToken).ConfigureAwait(false);
    }

    private static uint ParseGameCode(string gameCode)
    {
        ArgumentNullException.ThrowIfNull(gameCode);
        if (gameCode.Length != 4 || gameCode.Any(static value => value is < ' ' or > '~'))
        {
            throw new ArgumentException("A KEY1 game code must contain exactly four printable ASCII characters.", nameof(gameCode));
        }
 
        Span<byte> bytes = stackalloc byte[4];
        Encoding.ASCII.GetBytes(gameCode, bytes);
        return BinaryPrimitives.ReadUInt32LittleEndian(bytes);
    }

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