LibHac/tests/LibHac.Tests/CryptoTests/AesCbcTests.cs

using LibHac.Crypto;
using Xunit;

namespace LibHac.Tests.CryptoTests;

public class AesCbcTests
{
    public static EncryptionTestVector[] EncryptTestVectors =
        RspReader.ReadEncryptionTestVectorsArray(true, "CBCVarKey128.rsp", "CBCVarTxt128.rsp", "CBCKeySbox128.rsp", "CBCGFSbox128.rsp");

    public static EncryptionTestVector[] DecryptTestVectors =
        RspReader.ReadEncryptionTestVectorsArray(false, "CBCVarKey128.rsp", "CBCVarTxt128.rsp", "CBCKeySbox128.rsp", "CBCGFSbox128.rsp");

    public static EncryptionTestVector[] EncryptMultiTestVectors =
        RspReader.ReadEncryptionTestVectorsArray(true, "CBCMMT128.rsp");

    public static EncryptionTestVector[] DecryptMultiTestVectors =
        RspReader.ReadEncryptionTestVectorsArray(false, "CBCMMT128.rsp");

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

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

    [Fact]
    public static void EncryptMulti()
    {
        Common.EncryptCipherTest(EncryptMultiTestVectors, (key, iv) => Aes.CreateCbcEncryptor(key, iv, true));
    }

    [Fact]
    public static void DecryptMulti()
    {
        Common.DecryptCipherTest(DecryptMultiTestVectors, (key, iv) => Aes.CreateCbcDecryptor(key, iv, true));
    }

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

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

    [AesIntrinsicsRequiredFact]
    public static void EncryptMultiIntrinsics()
    {
        Common.EncryptCipherTest(EncryptMultiTestVectors, (key, iv) => Aes.CreateCbcEncryptor(key, iv));
    }

    [AesIntrinsicsRequiredFact]
    public static void DecryptMultiIntrinsics()
    {
        Common.DecryptCipherTest(DecryptMultiTestVectors, (key, iv) => Aes.CreateCbcDecryptor(key, 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 =
        RspReader.ReadEncryptionTestVectors(true, "CBCVarKey128.rsp", "CBCVarTxt128.rsp", "CBCKeySbox128.rsp", "CBCGFSbox128.rsp");

    public static TheoryData<EncryptionTestVector> DecryptTestVectors_Individual =
        RspReader.ReadEncryptionTestVectors(false, "CBCVarKey128.rsp", "CBCVarTxt128.rsp", "CBCKeySbox128.rsp", "CBCGFSbox128.rsp");

    public static TheoryData<EncryptionTestVector> EncryptMultiTestVectors_Individual =
        RspReader.ReadEncryptionTestVectors(true, "CBCMMT128.rsp");

    public static TheoryData<EncryptionTestVector> DecryptMultiTestVectors_Individual =
        RspReader.ReadEncryptionTestVectors(false, "CBCMMT128.rsp");

    //[Theory, MemberData(nameof(EncryptTestVectors_Individual))]
    public static void Encrypt_Individual(EncryptionTestVector tv)
    {
        Common.CipherTestCore(tv.PlainText, tv.CipherText, Aes.CreateCbcEncryptor(tv.Key, tv.Iv, true));
    }

    //[Theory, MemberData(nameof(DecryptTestVectors_Individual))]
    public static void Decrypt_Individual(EncryptionTestVector tv)
    {
        Common.CipherTestCore(tv.CipherText, tv.PlainText, Aes.CreateCbcDecryptor(tv.Key, tv.Iv, true));
    }

    //[Theory, MemberData(nameof(EncryptMultiTestVectors_Individual))]
    public static void EncryptMulti_Individual(EncryptionTestVector tv)
    {
        Common.CipherTestCore(tv.PlainText, tv.CipherText, Aes.CreateCbcEncryptor(tv.Key, tv.Iv, true));
    }

    //[Theory, MemberData(nameof(DecryptMultiTestVectors_Individual))]
    public static void DecryptMulti_Individual(EncryptionTestVector tv)
    {
        Common.CipherTestCore(tv.CipherText, tv.PlainText, Aes.CreateCbcDecryptor(tv.Key, tv.Iv, true));
    }

    //[AesIntrinsicsRequiredTheory, MemberData(nameof(EncryptTestVectors_Individual))]
    public static void EncryptIntrinsics_Individual(EncryptionTestVector tv)
    {
        Common.CipherTestCore(tv.PlainText, tv.CipherText, Aes.CreateCbcEncryptor(tv.Key, tv.Iv));
    }

    //[AesIntrinsicsRequiredTheory, MemberData(nameof(DecryptTestVectors_Individual))]
    public static void DecryptIntrinsics_Individual(EncryptionTestVector tv)
    {
        Common.CipherTestCore(tv.CipherText, tv.PlainText, Aes.CreateCbcDecryptor(tv.Key, tv.Iv));
    }

    //[AesIntrinsicsRequiredTheory, MemberData(nameof(EncryptMultiTestVectors_Individual))]
    public static void EncryptMultiIntrinsics_Individual(EncryptionTestVector tv)
    {
        Common.CipherTestCore(tv.PlainText, tv.CipherText, Aes.CreateCbcEncryptor(tv.Key, tv.Iv));
    }

    //[AesIntrinsicsRequiredTheory, MemberData(nameof(DecryptMultiTestVectors_Individual))]
    public static void DecryptMultiIntrinsics_Individual(EncryptionTestVector tv)
    {
        Common.CipherTestCore(tv.CipherText, tv.PlainText, Aes.CreateCbcDecryptor(tv.Key, tv.Iv));
    }
}