Livt.Crypto

tests/aes/AesCtr256Test.lvt

namespace Livt.Crypto.Tests.Aes
using Livt.Crypto.Aes



@Test
component AesCtr256Test
{
    ctr: Ctr256

    new()
    {
        this.ctr = new Ctr256()
    }

    // -----------------------------------------------------------------------
    // Common test data (NIST SP 800-38A Appendix F.5.5, AES-256 CTR)
    // Key:         603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4
    // Counter[1]:  f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff
    // PT[1]:       6bc1bee22e409f96e93d7e117393172a  CT[1]: 601ec313775789a5b7a7f504bbf3d228
    // Counter[2]:  f0f1f2f3f4f5f6f7f8f9fafbfcfdff00
    // PT[2]:       ae2d8a571e03ac9c9eb76fac45af8e51  CT[2]: f443e3ca4d62b59aca84e990cacaf5c5
    // -----------------------------------------------------------------------

    // NIST SP 800-38A F.5.5 CTR-AES256 — Block 1 encryption.
    @Test
    fn TestNistSp80038ABlock1()
    {
        var key: byte[32] = [
            0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
            0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
            0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
            0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4]

        var counter: byte[16] = [
            0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
            0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]

        var pt: byte[16] = [
            0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
            0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a]

        this.ctr.SetKey(key)
        this.ctr.SetCounter(counter)
        this.ctr.LoadBlock(pt)
        this.ctr.CryptBlock()

        var ct: byte[16] = this.ctr.GetBlock()
        assert ct[0]  == 0x60
        assert ct[1]  == 0x1e
        assert ct[2]  == 0xc3
        assert ct[3]  == 0x13
        assert ct[4]  == 0x77
        assert ct[5]  == 0x57
        assert ct[6]  == 0x89
        assert ct[7]  == 0xa5
        assert ct[8]  == 0xb7
        assert ct[9]  == 0xa7
        assert ct[10] == 0xf5
        assert ct[11] == 0x04
        assert ct[12] == 0xbb
        assert ct[13] == 0xf3
        assert ct[14] == 0xd2
        assert ct[15] == 0x28
    }

    // NIST SP 800-38A F.5.5 CTR-AES256 — Blocks 1 and 2 (tests counter increment).
    // After Block 1, counter must auto-increment from fcfdfeff to fcfdff00.
    @Test
    fn TestNistSp80038ABlock2()
    {
        var key: byte[32] = [
            0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
            0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
            0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
            0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4]

        var counter: byte[16] = [
            0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
            0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]

        var pt1: byte[16] = [
            0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
            0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a]

        var pt2: byte[16] = [
            0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c,
            0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51]

        this.ctr.SetKey(key)
        this.ctr.SetCounter(counter)

        this.ctr.LoadBlock(pt1)
        this.ctr.CryptBlock()

        this.ctr.LoadBlock(pt2)
        this.ctr.CryptBlock()

        var ct2: byte[16] = this.ctr.GetBlock()
        assert ct2[0]  == 0xf4
        assert ct2[1]  == 0x43
        assert ct2[2]  == 0xe3
        assert ct2[3]  == 0xca
        assert ct2[4]  == 0x4d
        assert ct2[5]  == 0x62
        assert ct2[6]  == 0xb5
        assert ct2[7]  == 0x9a
        assert ct2[8]  == 0xca
        assert ct2[9]  == 0x84
        assert ct2[10] == 0xe9
        assert ct2[11] == 0x90
        assert ct2[12] == 0xca
        assert ct2[13] == 0xca
        assert ct2[14] == 0xf5
        assert ct2[15] == 0xc5
    }

    // CTR decrypt is the same operation as encrypt — apply CryptBlock to ciphertext
    // using the same key and initial counter to recover the original plaintext.
    @Test
    fn TestDecryptRoundtrip()
    {
        var key: byte[32] = [
            0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe,
            0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
            0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7,
            0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4]

        var counter: byte[16] = [
            0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
            0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff]

        var pt: byte[16] = [
            0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96,
            0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a]

        // Encrypt.
        this.ctr.SetKey(key)
        this.ctr.SetCounter(counter)
        this.ctr.LoadBlock(pt)
        this.ctr.CryptBlock()
        var ct: byte[16] = this.ctr.GetBlock()

        // Decrypt (reset counter to the same initial value).
        this.ctr.SetCounter(counter)
        this.ctr.LoadBlock(ct)
        this.ctr.CryptBlock()

        var recovered: byte[16] = this.ctr.GetBlock()
        assert recovered[0]  == 0x6b
        assert recovered[1]  == 0xc1
        assert recovered[2]  == 0xbe
        assert recovered[3]  == 0xe2
        assert recovered[4]  == 0x2e
        assert recovered[5]  == 0x40
        assert recovered[6]  == 0x9f
        assert recovered[7]  == 0x96
        assert recovered[8]  == 0xe9
        assert recovered[9]  == 0x3d
        assert recovered[10] == 0x7e
        assert recovered[11] == 0x11
        assert recovered[12] == 0x73
        assert recovered[13] == 0x93
        assert recovered[14] == 0x17
        assert recovered[15] == 0x2a
    }
}