LibHac/tests/LibHac.Tests/CryptoTests/AesXtsTests.cs

using System;
using System.Collections.Generic;
using System.Linq;
using LibHac.Crypto;
using Xunit;

namespace LibHac.Tests.CryptoTests
{
    public class AesXtsTests
    {
        public static EncryptionTestVector[] EncryptTestVectors =
            RemovePartialByteTests(RspReader.ReadEncryptionTestVectorsArray(true, "XTSGenAES128.rsp"));

        public static EncryptionTestVector[] DecryptTestVectors =
            RemovePartialByteTests(RspReader.ReadEncryptionTestVectorsArray(false, "XTSGenAES128.rsp"));

        // The XTS implementation only supports multiples of whole bytes
        private static EncryptionTestVector[] RemovePartialByteTests(EncryptionTestVector[] input)
        {
            IEnumerable<EncryptionTestVector> filteredTestVectors = input
                .Where(x => x.DataUnitLength % 8 == 0);

            var output = new List<EncryptionTestVector>();

            foreach (EncryptionTestVector item in filteredTestVectors)
            {
                output.Add(item);
            }

            return output.ToArray();
        }

        [Fact]
        public static void Encrypt()
        {
            Common.EncryptCipherTest(EncryptTestVectors,
                (key, iv) => Aes.CreateXtsEncryptor(key.AsSpan(0, 0x10), key.AsSpan(0x10, 0x10), iv, true));
        }

        [Fact]
        public static void Decrypt()
        {
            Common.DecryptCipherTest(DecryptTestVectors,
                (key, iv) => Aes.CreateXtsDecryptor(key.AsSpan(0, 0x10), key.AsSpan(0x10, 0x10), iv, true));
        }

        [AesIntrinsicsRequiredFact]
        public static void EncryptIntrinsics()
        {
            Common.EncryptCipherTest(EncryptTestVectors,
                (key, iv) => Aes.CreateXtsEncryptor(key.AsSpan(0, 0x10), key.AsSpan(0x10, 0x10), iv));
        }

        [AesIntrinsicsRequiredFact]
        public static void DecryptIntrinsics()
        {
            Common.DecryptCipherTest(DecryptTestVectors,
                (key, iv) => Aes.CreateXtsDecryptor(key.AsSpan(0, 0x10), key.AsSpan(0x10, 0x10), iv));
        }


        // The above tests run all the test vectors in a single test to avoid having thousands of tests.
        // Use the below tests if running each test vector as an individual test is needed.

        // ReSharper disable InconsistentNaming

#pragma warning disable xUnit1013 // Public method should be marked as test

        public static TheoryData<EncryptionTestVector> EncryptTestVectors_Individual =
            RemovePartialByteTests(RspReader.ReadEncryptionTestVectors(true, "XTSGenAES128.rsp"));

        public static TheoryData<EncryptionTestVector> DecryptTestVectors_Individual =
            RemovePartialByteTests(RspReader.ReadEncryptionTestVectors(false, "XTSGenAES128.rsp"));

        private static TheoryData<EncryptionTestVector> RemovePartialByteTests(TheoryData<EncryptionTestVector> input)
        {
            IEnumerable<EncryptionTestVector> filteredTestVectors = input
                .Select(x => x[0])
                .Cast<EncryptionTestVector>()
                .Where(x => x.DataUnitLength % 8 == 0);

            var output = new TheoryData<EncryptionTestVector>();

            foreach (EncryptionTestVector item in filteredTestVectors)
            {
                output.Add(item);
            }

            return output;
        }

        //[Theory, MemberData(nameof(EncryptTestVectors_Individual))]
        public static void Encrypt_Individual(EncryptionTestVector tv)
        {
            Span<byte> key1 = tv.Key.AsSpan(0, 0x10);
            Span<byte> key2 = tv.Key.AsSpan(0x10, 0x10);

            Common.CipherTestCore(tv.PlainText, tv.CipherText, Aes.CreateXtsEncryptor(key1, key2, tv.Iv, true));
        }

        //[Theory, MemberData(nameof(DecryptTestVectors_Individual))]
        public static void Decrypt_Individual(EncryptionTestVector tv)
        {
            Span<byte> key1 = tv.Key.AsSpan(0, 0x10);
            Span<byte> key2 = tv.Key.AsSpan(0x10, 0x10);

            Common.CipherTestCore(tv.CipherText, tv.PlainText, Aes.CreateXtsDecryptor(key1, key2, tv.Iv, true));
        }

        //[AesIntrinsicsRequiredTheory, MemberData(nameof(EncryptTestVectors_Individual))]
        public static void EncryptIntrinsics_Individual(EncryptionTestVector tv)
        {
            Span<byte> key1 = tv.Key.AsSpan(0, 0x10);
            Span<byte> key2 = tv.Key.AsSpan(0x10, 0x10);

            Common.CipherTestCore(tv.PlainText, tv.CipherText, Aes.CreateXtsEncryptor(key1, key2, tv.Iv));
        }

        //[AesIntrinsicsRequiredTheory, MemberData(nameof(DecryptTestVectors_Individual))]
        public static void DecryptIntrinsics_Individual(EncryptionTestVector tv)
        {
            Span<byte> key1 = tv.Key.AsSpan(0, 0x10);
            Span<byte> key2 = tv.Key.AsSpan(0x10, 0x10);

            Common.CipherTestCore(tv.CipherText, tv.PlainText, Aes.CreateXtsDecryptor(key1, key2, tv.Iv));
        }
    }
}