NdsModcryptContext.cs

namespace NdsForge;

public sealed class NdsModcryptContext
{
    private readonly byte[] _key;
    private readonly byte[] _area1Counter;
    private readonly byte[] _area2Counter;

    public NdsModcryptContext(
        ReadOnlySpan<byte> key,
        ReadOnlySpan<byte> area1Counter,
        ReadOnlySpan<byte> area2Counter,
        NdsModcryptKeyMode keyMode = NdsModcryptKeyMode.SecureNormalKey)
    {
        ValidateBlock(key, nameof(key));
        ValidateBlock(area1Counter, nameof(area1Counter));
        ValidateBlock(area2Counter, nameof(area2Counter));
        if (!Enum.IsDefined(keyMode))
        {
            throw new ArgumentOutOfRangeException(nameof(keyMode), keyMode, "Unknown modcrypt key provenance.");
        }
 
        _key = key.ToArray();
        _area1Counter = area1Counter.ToArray();
        _area2Counter = area2Counter.ToArray();
        KeyMode = keyMode;
    }

    public NdsModcryptKeyMode KeyMode { get; }

    public ReadOnlyMemory<byte> ExportKey() => _key.ToArray();

    public ReadOnlyMemory<byte> ExportCounter(NdsModcryptArea area) => GetCounter(area).ToArray();

    public static NdsModcryptContext FromHeader(NdsHeader header)
    {
        ArgumentNullException.ThrowIfNull(header);
        NdsDsiHeader dsi = header.Dsi ??
            throw new ArgumentException("Modcrypt requires a DSi-enhanced or DSi-exclusive header.", nameof(header));
        if (dsi.UsesInsecureModcryptKey)
        {
            return new(
                header.RawData.Span[..16],
                dsi.Arm9Hmac.Span[..16],
                dsi.Arm7Hmac.Span[..16],
                NdsModcryptKeyMode.InsecureHeaderKey);
        }
 
        return new(
            NdsDsiKeyScrambler.DeriveModcryptNormalKey(header),
            dsi.Arm9Hmac.Span[..16],
            dsi.Arm7Hmac.Span[..16],
            NdsModcryptKeyMode.SecureNormalKey);
    }

    public static NdsModcryptContext FromHeader(NdsHeader header, ReadOnlySpan<byte> secureNormalKey)
    {
        ArgumentNullException.ThrowIfNull(header);
        NdsDsiHeader dsi = header.Dsi ??
            throw new ArgumentException("Modcrypt requires a DSi-enhanced or DSi-exclusive header.", nameof(header));
        if (dsi.UsesInsecureModcryptKey)
        {
            throw new ArgumentException(
                "A header selecting its public modcrypt key cannot accept a secure-key override.",
                nameof(header));
        }
 
        ValidateBlock(secureNormalKey, nameof(secureNormalKey));
        return new(
            secureNormalKey,
            dsi.Arm9Hmac.Span[..16],
            dsi.Arm7Hmac.Span[..16],
            NdsModcryptKeyMode.SecureNormalKey);
    }

    internal ReadOnlyMemory<byte> Key => _key;

    internal ReadOnlyMemory<byte> GetCounter(NdsModcryptArea area) => area switch
    {
        NdsModcryptArea.First => _area1Counter,
        NdsModcryptArea.Second => _area2Counter,
        _ => throw new ArgumentOutOfRangeException(nameof(area), area, "Unknown modcrypt area."),
    };

    private static void ValidateBlock(ReadOnlySpan<byte> value, string parameterName)
    {
        if (value.Length != NdsModcrypt.BlockSize)
        {
            throw new ArgumentException("A modcrypt key or counter must contain exactly sixteen bytes.", parameterName);
        }
    }
}