NdsModcrypt.cs

using System.Buffers;
 
namespace NdsForge;

public static class NdsModcrypt
{
    public const int BlockSize = 16;
    private const int StreamBufferSize = 64 * 1024;

    public static byte[] Transform(
        ReadOnlySpan<byte> data,
        NdsModcryptContext context,
        NdsModcryptArea area,
        long byteOffset = 0)
    {
        ArgumentNullException.ThrowIfNull(context);
        return Transform(data, context.Key.Span, context.GetCounter(area).Span, byteOffset);
    }

    public static byte[] Transform(
        ReadOnlySpan<byte> data,
        ReadOnlySpan<byte> key,
        ReadOnlySpan<byte> initialCounter,
        long byteOffset = 0)
    {
        ValidateArguments(key, initialCounter, byteOffset);
        byte[] output = new byte[data.Length];
        using var transform = new NdsModcryptTransform(key, initialCounter, byteOffset);
        transform.Transform(data, output);
        return output;
    }

    public static async ValueTask TransformAsync(
        Stream source,
        Stream destination,
        long length,
        NdsModcryptContext context,
        NdsModcryptArea area,
        long byteOffset = 0,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(context);
        await TransformAsync(
            source,
            destination,
            length,
            context.Key,
            context.GetCounter(area),
            byteOffset,
            cancellationToken).ConfigureAwait(false);
    }

    public static async ValueTask TransformAsync(
        Stream source,
        Stream destination,
        long length,
        ReadOnlyMemory<byte> key,
        ReadOnlyMemory<byte> initialCounter,
        long byteOffset = 0,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(source);
        ArgumentNullException.ThrowIfNull(destination);
        if (!source.CanRead)
        {
            throw new ArgumentException("The modcrypt source must be readable.", nameof(source));
        }
 
        if (!destination.CanWrite)
        {
            throw new ArgumentException("The modcrypt destination must be writable.", nameof(destination));
        }
 
        if (ReferenceEquals(source, destination))
        {
            throw new ArgumentException("Streaming modcrypt requires distinct source and destination streams.", nameof(destination));
        }
 
        if (length < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(length), "The transform length cannot be negative.");
        }
 
        ValidateArguments(key.Span, initialCounter.Span, byteOffset);
        byte[] buffer = ArrayPool<byte>.Shared.Rent(StreamBufferSize);
        try
        {
            using var transform = new NdsModcryptTransform(key.Span, initialCounter.Span, byteOffset);
            long remaining = length;
            while (remaining != 0)
            {
                cancellationToken.ThrowIfCancellationRequested();
                int count = (int)Math.Min(remaining, StreamBufferSize);
                await source.ReadExactlyAsync(buffer.AsMemory(0, count), cancellationToken).ConfigureAwait(false);
                transform.Transform(buffer.AsSpan(0, count), buffer.AsSpan(0, count));
                await destination.WriteAsync(buffer.AsMemory(0, count), cancellationToken).ConfigureAwait(false);
                remaining -= count;
            }
        }
        finally
        {
            ArrayPool<byte>.Shared.Return(buffer, clearArray: true);
        }
    }

    private static void ValidateArguments(ReadOnlySpan<byte> key, ReadOnlySpan<byte> initialCounter, long byteOffset)
    {
        if (key.Length != BlockSize)
        {
            throw new ArgumentException("A modcrypt AES key must contain exactly sixteen bytes.", nameof(key));
        }
 
        if (initialCounter.Length != BlockSize)
        {
            throw new ArgumentException("A modcrypt initial counter must contain exactly sixteen bytes.", nameof(initialCounter));
        }
 
        if (byteOffset < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(byteOffset), "A modcrypt slice offset cannot be negative.");
        }
    }
}