Subversion Repositories aes_decrypt_fpga

`timescale 1ns/1ps

// Uncomment the following line if you're targeting Xilinx FPGA

//`define XILINX 1

// generic_muxfx.v defines a generic 2-to-1 MUX. This file is used to provide

// a generic definition of MUXF7 and MUXF8 in case you are not targetting Xilinx.

// When targetting Xilinx, skip this file to allow the simulator to locate the

// MUXF7 and MUXF8 in the Xilinx unisim library.

`ifndef XILINX

`include "generic/generic_muxfx.v"

`endif

`include "InvSbox.sv"

`include "InvSubBytes.sv"

`include "InvShiftRows.sv"

`include "InvAddRoundKey.sv"

`include "gfmul.sv"

`include "InvMixCol_slice.sv"

`include "InvMixColumns.sv"

`include "decrypt.sv"

`include "KschBuffer.sv"

`include "Sbox.sv"

`include "SubWord.sv"

`include "RotWord.sv"

`include "KeyExpand256.sv"

`include "aes_decrypt256.sv"

`include "aes_beh_model.sv"

`define PERIOD 10

`define T (`PERIOD/2)

`define Tcko 1

`define WAIT_N_CLK(num_of_clk) repeat(num_of_clk) @(posedge clk); #(`Tcko)

module aes_decrypt256_tb;

        logic   [0:127] ct;

        logic   ct_vld;

        wire    ct_rdy;

        logic   [0:255] kt;

        logic   kt_vld;

        wire    kt_rdy;

        wire    [0:127] pt;

        wire    pt_vld;

        logic   clk;

        logic   rst;

        int     sample_vec_failed = 0;

        int     back_to_back_failed = 0;

        int     RandVec_256_failed = 0;

        int     failed = 0;

        aes256_decrypt_t ref_model;

        logic   [0:255] tmp_kt;

        logic   [0:127] tmp_ct;

        `include "decrypt_vec.sv"

        task set_kt(input [0:255] x);

                kt = x;

                kt_vld = 1;

                `WAIT_N_CLK(1);

                kt_vld = 0;

                `WAIT_N_CLK(1);

        endtask

        task set_ct(input [0:127] x);

                ct = x;

                ct_vld = 1;

                `WAIT_N_CLK(1);

                ct_vld = 0;

                `WAIT_N_CLK(1);

        endtask

        function logic [0:127] rand128;

                rand128 = {$random, $random, $random, $random};

        endfunction

        function logic [0:255] rand256;

                rand256 = {$random, $random, $random, $random, $random, $random, $random, $random};

        endfunction

        always

        begin

                clk <= 1;

                #(`T);

                clk <= 0;

                #(`T);

        end

        aes_decrypt256 uut(.*);

        initial begin

                ref_model = new;

                rst = 1;

                kt_vld = 0;

                ct_vld = 0;

                `WAIT_N_CLK(3);

                rst = 0;

                `WAIT_N_CLK(1);

                // FIPS-197 sample vector test. FIPS-197 appendix C.3.

                $display("FIPS-197 sample vector test");

                $display("kt=000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f ct=8ea2b7ca516745bfeafc49904b496089");

                wait (kt_rdy);

                set_kt(256'h000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f);

                wait (ct_rdy);

                set_ct(128'h8ea2b7ca516745bfeafc49904b496089);

                wait (pt_vld);

                $display("pt=%h expected=00112233445566778899aabbccddeeff",pt);

                if (pt != 128'h00112233445566778899aabbccddeeff)

                begin

                        $display("***Mismatch");

                        sample_vec_failed = 1;

                        failed = 1;

                end

                $display("FIPS-197 sample vector test finished : %s", (sample_vec_failed)? "FAILED" : "PASSED");

                `WAIT_N_CLK(2);

                // Back-to-back ciphertext test.

                // Two ciphertext are applied back-to-back with no dead cycle in between.

                $display("\nBack-to-back ciphertext test");

                tmp_ct = rand128();

                tmp_kt = rand256();

                ref_model.KeyExpand(tmp_kt);

                ref_model.LoadCt(tmp_ct);

                ref_model.run(0);

                wait (kt_rdy);

                set_kt(tmp_kt);

                wait (ct_rdy);

                set_ct(tmp_ct);

                wait (pt_vld);

                $display("kt=%h ct=%h pt=%h expected=%h",tmp_kt,tmp_ct,pt,ref_model.GetState());

                if (pt != ref_model.GetState())

                begin

                        $display("***Mismatch");

                        back_to_back_failed = 1;

                        failed = 1;

                end

                tmp_ct = rand128();

                ref_model.LoadCt(tmp_ct);

                ref_model.run(0);

                wait (ct_rdy);

                set_ct(tmp_ct);

                wait (pt_vld);

                $display("kt=%h ct=%h pt=%h expected=%h",tmp_kt,tmp_ct,pt,ref_model.GetState());

                if (pt != ref_model.GetState())

                begin

                        $display("***Mismatch");

                        back_to_back_failed = 1;

                        failed = 1;

                end

                $display("Back-to-back ciphertext test finished : %s", (back_to_back_failed)? "FAILED" : "PASSED");

                `WAIT_N_CLK(2);

                // ECB-AES256.Decrypt sample vector test. SP800-38a appendix F.1.6

                $display("\nECB-AES256.Decrypt sample vector test");

                for (int k=0; k<`ECB_DECRYPT_256_VEC_SIZE; k++)

                begin

                        set_kt(ECBDecrypt_256_kt);

                        wait(ct_rdy);

                        set_ct(ECBDecrypt_256_ct[k]);

                        wait(pt_vld);

                        $display("kt=%h ct=%h pt=%h expected=%h",ECBDecrypt_256_kt,ECBDecrypt_256_ct[k],pt,ECBDecrypt_256_pt[k]);

                        if (pt != ECBDecrypt_256_pt[k])

                        begin

                                $display("***Mismatch");

                                ECBDecrypt_256_failed = 1;

                        end

                end

                $display("ECB-AES192.Decrypt sample vector test finished : %s", (ECBDecrypt_256_failed)? "FAILED" : "PASSED");

                `WAIT_N_CLK(2);

                // GFSbox Known Answer Test. AESAVS appendix B.3.

                $display("\nGFSbox Known Answer Test");

                for (int k=0; k<`GFSbox_256_VEC_SIZE; k++)

                begin

                        set_kt(GFSbox_256_kt);

                        wait(ct_rdy);

                        set_ct(GFSbox_256_ct[k]);

                        wait(pt_vld);

                        $display("kt=%h ct=%h pt=%h expected=%h",GFSbox_256_kt,GFSbox_256_ct[k],pt,GFSbox_256_pt[k]);

                        if (pt != GFSbox_256_pt[k])

                        begin

                                $display("***Mismatch");

                                GFSbox_256_failed = 1;

                        end

                end

                $display("GFSbox test finished : %s", (GFSbox_256_failed)? "FAILED" : "PASSED");

                `WAIT_N_CLK(2);

                // KeySbox Known Answer Test. AESAVS appendix C.3.

                $display("\nKeySbox Known Answer Test");

                for (int k=0; k<`KEYSBOX_256_VEC_SIZE; k++)

                begin

                        set_kt(KeySbox_256_kt[k]);

                        wait(ct_rdy);

                        set_ct(KeySbox_256_ct[k]);

                        wait(pt_vld);

                        $display("kt=%h ct=%h pt=%h expected=%h",KeySbox_256_kt[k],KeySbox_256_ct[k],pt,KeySbox_256_pt);

                        if (pt != KeySbox_256_pt[k])

                        begin

                                $display("***Mismatch");

                                KeySbox_256_failed = 1;

                        end

                end

                $display("KeySbox test finished : %s", (KeySbox_256_failed)? "FAILED" : "PASSED");

                `WAIT_N_CLK(2);

                // VarTxt Known Answer Test. AESAVS appendix D.3.

                $display("\nVarTxt Known Answer Test");

                for (int k=0; k<`VARTXT_256_VEC_SIZE; k++)

                begin

                        set_kt(VarTxt_256_kt);

                        wait(ct_rdy);

                        set_ct(VarTxt_256_ct[k]);

                        wait(pt_vld);

                        $display("kt=%h ct=%h pt=%h expected=%h",VarTxt_256_kt,VarTxt_256_ct[k],pt,VarTxt_256_pt[k]);

                        if (pt != VarTxt_256_pt[k])

                        begin

                                $display("***Mismatch");

                                VarTxt_256_failed = 1;

                        end

                end

                $display("VarTxt Known Answer Test finished : %s", (VarTxt_256_failed)? "FAILED" : "PASSED");

                `WAIT_N_CLK(2);

                // VarKey Known Answer Test. AESAVS appendix E.3.

                $display("\nVarKey Known Answer Test");

                for (int k=0; k<`VARKEY_256_VEC_SIZE; k++)

                begin

                        set_kt(VarKey_256_kt[k]);

                        wait(ct_rdy);

                        set_ct(VarKey_256_ct[k]);

                        wait(pt_vld);

                        $display("kt=%h ct=%h pt=%h expected=%h",VarKey_256_kt[k],VarKey_256_ct[k],pt,VarKey_256_pt);

                        if (pt != VarKey_256_pt)

                        begin

                                $display("***Mismatch");

                                VarKey_256_failed = 1;

                        end

                end

                $display("VarKey Known Answer Test finished : %s", (VarKey_256_failed)? "FAILED" : "PASSED");

                `WAIT_N_CLK(2);

                // Random vector test against golden model.

                $display("\nRandom Vector Test");

                for (int k=0; k<1000; k++)

                begin

                        tmp_ct = rand128();

                        tmp_kt = rand256();

                        ref_model.KeyExpand(tmp_kt);

                        ref_model.LoadCt(tmp_ct);

                        ref_model.run(0);

                        wait (kt_rdy);

                        set_kt(tmp_kt);

                        wait (ct_rdy);

                        set_ct(tmp_ct);

                        wait (pt_vld);

                        $display("kt=%h ct=%h pt=%h expected=%h",tmp_kt,tmp_ct,pt,ref_model.GetState());

                        if (pt != ref_model.GetState())

                        begin

                                $display("***Mismatch");

                                RandVec_256_failed = 1;

                        failed = 1;

                        end

                end

                $display("Random Vector Test finished : %s", (RandVec_256_failed)? "FAILED" : "PASSED");

                `WAIT_N_CLK(2);

                $display("\nAll tests finished : %s", (failed)? "FAILED" : "OK");

                $stop;

        end

endmodule