LibHac/tests/LibHac.Tests/CryptoTests/RspReader.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using LibHac.Util;
using Xunit;

namespace LibHac.Tests.CryptoTests
{
    public class RspReader
    {
        private StreamReader Reader { get; }

        public RspReader(Stream stream)
        {
            Reader = new StreamReader(stream);
        }

        public IEnumerable<EncryptionTestVector> GetEncryptionTestVectors()
        {
            string line;
            bool isEncryptType = false;

            var testVector = new EncryptionTestVector();
            bool canOutputVector = false;

            while ((line = Reader.ReadLine()?.Trim()) != null)
            {
                if (line.Length == 0)
                {
                    if (canOutputVector)
                    {
                        testVector.Encrypt = isEncryptType;

                        yield return testVector;

                        testVector = new EncryptionTestVector();
                        canOutputVector = false;
                    }

                    continue;
                }

                if (line[0] == '#') continue;

                if (line[0] == '[')
                {
                    if (line == "[ENCRYPT]") isEncryptType = true;
                    if (line == "[DECRYPT]") isEncryptType = false;

                    continue;
                }

                string[] kvp = line.Split(new[] { " = " }, StringSplitOptions.None);
                if (kvp.Length != 2) throw new InvalidDataException();

                canOutputVector = true;

                switch (kvp[0].ToUpperInvariant())
                {
                    case "COUNT":
                        testVector.Count = int.Parse(kvp[1]);
                        break;
                    case "DATAUNITLEN":
                        testVector.DataUnitLength = int.Parse(kvp[1]);
                        break;
                    case "KEY":
                        testVector.Key = kvp[1].ToBytes();
                        break;
                    case "IV":
                    case "I":
                        testVector.Iv = kvp[1].ToBytes();
                        break;
                    case "PLAINTEXT":
                    case "PT":
                        testVector.PlainText = kvp[1].ToBytes();
                        break;
                    case "CIPHERTEXT":
                    case "CT":
                        testVector.CipherText = kvp[1].ToBytes();
                        break;
                }
            }
        }

        public static TheoryData<EncryptionTestVector> ReadEncryptionTestVectors(bool getEncryptTests, params string[] filenames)
        {
            EncryptionTestVector[] vectorArray = ReadEncryptionTestVectorsArray(getEncryptTests, filenames);
            var testVectors = new TheoryData<EncryptionTestVector>();

            foreach (EncryptionTestVector test in vectorArray)
            {
                testVectors.Add(test);
            }

            return testVectors;
        }

        public static EncryptionTestVector[] ReadEncryptionTestVectorsArray(bool getEncryptTests, params string[] filenames)
        {
            IEnumerable<string> resourcePaths = filenames.Select(x => $"LibHac.Tests.CryptoTests.TestVectors.{x}");
            var testVectors = new List<EncryptionTestVector>();

            foreach (string path in resourcePaths)
            {
                using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(path))
                {
                    var reader = new RspReader(stream);

                    foreach (EncryptionTestVector tv in reader.GetEncryptionTestVectors().Where(x => x.Encrypt == getEncryptTests))
                    {
                        testVectors.Add(tv);
                    }
                }
            }

            return testVectors.ToArray();
        }

        public IEnumerable<HashTestVector> GetHashTestVectors()
        {
            string line;

            var testVector = new HashTestVector();
            bool canOutputVector = false;

            while ((line = Reader.ReadLine()?.Trim()) != null)
            {
                if (line.Length == 0)
                {
                    if (canOutputVector)
                    {
                        yield return testVector;

                        testVector = new HashTestVector();
                        canOutputVector = false;
                    }

                    continue;
                }

                if (line[0] == '#') continue;
                if (line[0] == '[') continue;

                string[] kvp = line.Split(new[] { " = " }, StringSplitOptions.None);
                if (kvp.Length != 2) throw new InvalidDataException();

                canOutputVector = true;

                switch (kvp[0].ToUpperInvariant())
                {
                    case "LEN":
                        testVector.LengthBits = int.Parse(kvp[1]);
                        testVector.LengthBytes = testVector.LengthBits / 8;
                        break;
                    case "MSG":
                        testVector.Message = kvp[1].ToBytes();
                        break;
                    case "MD":
                        testVector.Digest = kvp[1].ToBytes();
                        break;
                }
            }
        }

        public static TheoryData<HashTestVector> ReadHashTestVectors(params string[] filenames)
        {
            HashTestVector[] vectorArray = ReadHashTestVectorsArray(filenames);
            var testVectors = new TheoryData<HashTestVector>();

            foreach (HashTestVector test in vectorArray)
            {
                testVectors.Add(test);
            }

            return testVectors;
        }

        public static HashTestVector[] ReadHashTestVectorsArray(params string[] filenames)
        {
            IEnumerable<string> resourcePaths = filenames.Select(x => $"LibHac.Tests.CryptoTests.TestVectors.{x}");
            var testVectors = new List<HashTestVector>();

            foreach (string path in resourcePaths)
            {
                using (Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(path))
                {
                    var reader = new RspReader(stream);

                    foreach (HashTestVector tv in reader.GetHashTestVectors())
                    {
                        testVectors.Add(tv);
                    }
                }
            }

            return testVectors.ToArray();
        }
    }

    public class EncryptionTestVector
    {
        public bool Encrypt { get; set; }
        public int Count { get; set; }
        public int DataUnitLength { get; set; }
        public byte[] Key { get; set; }
        public byte[] Iv { get; set; }
        public byte[] PlainText { get; set; }
        public byte[] CipherText { get; set; }
    }

    public class HashTestVector
    {
        public int LengthBits { get; set; }
        public int LengthBytes { get; set; }
        public byte[] Message { get; set; }
        public byte[] Digest { get; set; }
    }
}