NdsImageManifestCapture.cs

using System.Security.Cryptography;
 
namespace NdsForge;

internal static class NdsImageManifestCapture
{
    public static async ValueTask<NdsImageManifest> CaptureAsync(
        NdsImage image,
        CancellationToken cancellationToken)
    {
        ArgumentNullException.ThrowIfNull(image);
        NdsManifestProgram[] programs = await CaptureProgramsAsync(image, cancellationToken).ConfigureAwait(false);
        var allocations = new List<NdsManifestAllocation>(image.FileSystem.Allocations.Count);
        var allocationHashes = new Dictionary<int, string>(image.FileSystem.Allocations.Count);
        foreach (NdsFileAllocation allocation in image.FileSystem.Allocations.OrderBy(static value => value.FileId))
        {
            string hash = await HashRegionAsync(image, allocation.Data, cancellationToken).ConfigureAwait(false);
            allocationHashes.Add(allocation.FileId, hash);
            allocations.Add(new()
            {
                FileId = allocation.FileId,
                Offset = allocation.Data.Offset,
                Length = allocation.Data.Length,
                Sha256 = hash,
            });
        }
 
        var files = new List<NdsManifestFile>(image.FileSystem.Files.Count);
        foreach (NdsFile file in image.FileSystem.Files.OrderBy(static value => value.FullPath, StringComparer.Ordinal))
        {
            cancellationToken.ThrowIfCancellationRequested();
            files.Add(new()
            {
                Path = file.FullPath,
                FileId = file.Id,
                Offset = file.Data.Offset,
                Length = file.Data.Length,
                Sha256 = allocationHashes[file.Id],
            });
        }
 
        var overlays = new List<NdsManifestOverlay>();
        foreach (NdsOverlay overlay in image.Arm9Overlays.Concat(image.Arm7Overlays)
            .OrderBy(static value => value.Processor).ThenBy(static value => value.Id))
        {
            cancellationToken.ThrowIfCancellationRequested();
            overlays.Add(new()
            {
                Processor = overlay.Processor,
                OverlayId = overlay.Id,
                FileId = overlay.FileId,
                FilePath = overlay.File?.FullPath,
                Offset = overlay.Data?.Offset,
                Length = overlay.Data?.Length,
                LoadAddress = overlay.LoadAddress,
                RamSize = overlay.RamSize,
                BssSize = overlay.BssSize,
                StaticInitializerStart = overlay.StaticInitializerStart,
                StaticInitializerEnd = overlay.StaticInitializerEnd,
                CompressedSize = overlay.CompressedSize,
                Flags = overlay.Flags,
                Sha256 = overlay.Data is not null
                    ? allocationHashes[checked((int)overlay.FileId)]
                    : null,
            });
        }
 
        NdsHeader header = image.Header;
        var manifest = new NdsImageManifest
        {
            PhysicalLength = image.Length,
            ImageSha256 = await HashRegionAsync(image, new(0, image.Length), cancellationToken).ConfigureAwait(false),
            Header = new()
            {
                Title = header.Title,
                GameCode = header.GameCode,
                MakerCode = header.MakerCode,
                Kind = header.Kind,
                Version = header.Version,
                RegionCode = header.RegionCode,
                AutoStart = header.AutoStart,
                UsedImageSize = header.UsedImageSize,
                DeviceCapacityBytes = header.DeviceCapacityBytes,
                NormalCardControl = header.NormalCardControl,
                SecureCardControl = header.SecureCardControl,
                Sha256 = HashMemory(header.RawData.Span),
            },
            Dsi = CaptureDsi(header.Dsi),
            Programs = programs,
            Directories = image.FileSystem.Directories
                .Select(static value => value.FullPath)
                .Order(StringComparer.Ordinal)
                .ToArray(),
            Files = files.AsReadOnly(),
            Allocations = allocations.AsReadOnly(),
            Overlays = overlays.AsReadOnly(),
            Banner = CaptureBanner(image),
        };
        manifest.Validate();
        return manifest;
    }

    private static async ValueTask<NdsManifestProgram[]> CaptureProgramsAsync(
        NdsImage image,
        CancellationToken cancellationToken)
    {
        NdsProgram[] programs = [image.Header.Arm9, image.Header.Arm7];
        IEnumerable<NdsProgram> all = programs.Concat(
            new[] { image.Header.Arm9i, image.Header.Arm7i }.OfType<NdsProgram>());
        var result = new List<NdsManifestProgram>();
        foreach (NdsProgram program in all.OrderBy(static value => value.Processor))
        {
            result.Add(new()
            {
                Processor = program.Processor,
                Offset = program.Data.Offset,
                Length = program.Data.Length,
                LoadAddress = program.LoadAddress,
                EntryAddress = program.EntryAddress,
                Sha256 = await HashRegionAsync(image, program.Data, cancellationToken).ConfigureAwait(false),
            });
        }
 
        return result.ToArray();
    }

    private static NdsManifestDsi? CaptureDsi(NdsDsiHeader? dsi) => dsi is null ? null : new()
    {
        TitleId = dsi.TitleId,
        TotalImageSize = dsi.TotalImageSize,
        RegionFlags = dsi.RegionFlags,
        AccessControl = dsi.AccessControl,
        HasModcryptAreas = dsi.HasModcryptAreas,
        UsesInsecureModcryptKey = dsi.UsesInsecureModcryptKey,
        ModcryptArea1 = CaptureRegion(dsi.ModcryptArea1),
        ModcryptArea2 = CaptureRegion(dsi.ModcryptArea2),
    };

    private static NdsManifestRegion CaptureRegion(NdsRegion region) => new()
    {
        Offset = region.Offset,
        Length = region.Length,
    };

    private static NdsManifestBanner? CaptureBanner(NdsImage image)
    {
        NdsBanner? banner = image.Banner;
        return banner is null ? null : new()
        {
            Offset = image.Header.BannerOffset,
            Length = banner.RawData.Length,
            Version = banner.Version,
            IsAnimated = banner.IsAnimated,
            Titles = banner.Titles.ToDictionary(
                static pair => pair.Key.ToString(),
                static pair => pair.Value,
                StringComparer.Ordinal),
            Sha256 = HashMemory(banner.RawData.Span),
        };
    }

    private static async ValueTask<string> HashRegionAsync(
        NdsImage image,
        NdsRegion region,
        CancellationToken cancellationToken)
    {
        using Stream stream = image.OpenRead(region);
        byte[] digest = await SHA256.HashDataAsync(stream, cancellationToken).ConfigureAwait(false);
        return Convert.ToHexStringLower(digest);
    }

    private static string HashMemory(ReadOnlySpan<byte> data) => Convert.ToHexStringLower(SHA256.HashData(data));
}