Subversion Repositories xtea

//////////////////////////////////////////////////////////////////////

////                                                              ////

////  XTEA IP Core                                                ////

////                                                              ////

////  This file is part of the xtea project                       ////

////  http://www.opencores.org/projects.cgi/web/xtea/overview     ////

////                                                              ////

////  Test-bench for the XTEA encryption algorithm.               ////

////                                                              ////

////  TODO:                                                       ////

////    * Update for new combined encipher/decipher module        ////

////    * Tidy                                                    ////

////    * Add interconnections                                    ////

////                                                              ////

////  Author: David Johnson, dj@david-web.co.uk                   ////

////                                                              ////

//////////////////////////////////////////////////////////////////////

////                                                              ////

//// Copyright (C) 2006 David Johnson                             ////

////                                                              ////

//// This source file is free software; you can redistribute it   ////

//// and/or modify it under the terms of the GNU Lesser General   ////

//// Public License as published by the Free Software Foundation; ////

//// either version 2.1 of the License, or (at your option) any   ////

//// later version.                                               ////

////                                                              ////

//// This source is distributed in the hope that it will be       ////

//// useful, but WITHOUT ANY WARRANTY; without even the implied   ////

//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ////

//// PURPOSE.  See the GNU Lesser General Public License for more ////

//// details.                                                     ////

////                                                              ////

//// You should have received a copy of the GNU Lesser General    ////

//// Public License along with this source; if not, write to the  ////

//// Free Software Foundation, Inc., 51 Franklin Street, Fifth    ////

//// Floor, Boston, MA  02110-1301  USA                           ////

////                                                              ////

//////////////////////////////////////////////////////////////////////

//

// CVS Revision History

//

// $Log: not supported by cvs2svn $

//

module cipher_testbench (clock, reset, all_done_encipher, all_done_decipher, data_out_encipher1, data_out_encipher2, data_out_decipher1, data_out_decipher2, data_in_encipher1, data_in_encipher2, data_in_decipher1, data_in_decipher2, key_out, result, reset_out);

input clock, reset, all_done_encipher, all_done_decipher;

input[31:0] data_in_encipher1, data_in_encipher2, data_in_decipher1, data_in_decipher2;

output result, reset_out;

output[31:0] data_out_encipher1, data_out_encipher2, data_out_decipher1, data_out_decipher2;

output[127:0] key_out;

reg result, reset_out, test_ciphertext, test_plaintext;

reg[7:0] state;

reg[31:0] data_out_encipher1, data_out_encipher2, data_out_decipher1, data_out_decipher2, tempdata1, tempdata2;

reg[127:0] key_out;

parameter s0 = 0, s1 = 1, s2 = 2, s3 = 3, s4 = 4, s5 = 5, s6 = 6, s7 = 7, s8 = 8, s9 = 9,

        s10 = 10, s11 = 11, s12 = 12, s13 = 13, s14 = 14, s15 = 15, s16 = 16, s17 = 17, s18 = 18, s19 = 19,

        s20 = 20, s21 = 21, s22 = 22, s23 = 23, s24 = 24, s25 = 25, s26 = 26, s27 = 27, s28 = 28, s29 = 29,

        s30 = 30, s31 = 31, s32 = 32, s33 = 33, s34 = 34, s35 = 35, s36 = 36, s37 = 37, s38 = 38, s39 = 39,

        s40 = 40, s41 = 41, s42 = 42, s43 = 43, s44 = 44, s45 = 45, s46 = 46, s47 = 47, s48 = 48, s49 = 49;

always @(posedge clock or posedge reset)

begin

        if (reset)

                state = s0;

        else

        begin

                case (state)

                        s0: state = s1;

                        s1: state = s2;

                        s2: state = all_done_encipher ? s3 : s2;

                        s3: state = s4;

                        s4: state = s5;

                        s5: state = all_done_decipher ? s6 : s5;

                        s6: state = s7;

                        s7: state = s8;

                        s8: state = s9;

                        s9: state = all_done_encipher ? s10 : s9;

                        s10: state = s11;

                        s11: state = s12;

                        s12: state = all_done_decipher ? s13 : s12;

                        s13: state = s14;

                        s14: state = s15;

                        s15: state = s16;

                        s16: state = all_done_encipher ? s17 : s16;

                        s17: state = s18;

                        s18: state = s19;

                        s19: state = all_done_decipher ? s20 : s19;

                        s20: state = s21;

                        s21: state = s22;

                        s22: state = s23;

                        s23: state = all_done_encipher ? s24 : s23;

                        s24: state = s25;

                        s25: state = s26;

                        s26: state = all_done_decipher ? s27 : s26;

                        s27: state = s28;

                        s28: state = s29;

                        s29: state = s30;

                        s30: state = all_done_encipher ? s31 : s30;

                        s31: state = s32;

                        s32: state = s33;

                        s33: state = all_done_decipher ? s34 : s33;

                        s34: state = s35;

                        s35: state = s36;

                        s36: state = s37;

                        s37: state = all_done_encipher ? s38 : s37;

                        s38: state = s39;

                        s39: state = s40;

                        s40: state = all_done_decipher ? s41 : s40;

                        s41: state = s42;

                        s42: state = s43;

                        s43: state = s44;

                        s44: state = all_done_encipher ? s45 : s44;

                        s45: state = s46;

                        s46: state = s47;

                        s47: state = all_done_decipher ? s48 : s47;

                        s48: state = s49;

                        s49: state = s49;

                        default: state = 1'bz;

                endcase

        end

end

always @(posedge clock or posedge reset)

begin

        if (reset)

        begin

                result = 1'b0;

                reset_out = 1'b0;

                test_ciphertext = 1'b0;

                test_plaintext = 1'b0;

                data_out_encipher1 = 32'bxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx;

                data_out_encipher2 = 32'bxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx;

                data_out_decipher1 = 32'bxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx;

                data_out_decipher2 = 32'bxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx;

                key_out = 128'bxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx;

        end

        else begin

                case (state)

                        //Test 1

                        s1: begin

                            reset_out = 1'b1;

                            data_out_encipher1 = 32'h00000000;

                            data_out_encipher2 = 32'h00000000;

                            key_out = 128'h00000000000000000000000000000000;

                            end

                        s2: reset_out = 1'b0;

                        s3: begin

                        test_ciphertext = ((data_in_encipher1 == 32'hdee9d4d8) && (data_in_encipher2 == 32'hf7131ed9));

                        tempdata1 = data_in_encipher1;

                        tempdata2 = data_in_encipher2;

                        end

                        s4: begin

                        reset_out = 1'b1;

                        data_out_decipher1 = tempdata1;

                        data_out_decipher2 = tempdata2;

                        end

                        s5: reset_out = 1'b0;

                        s6: test_plaintext = ((data_in_decipher1 == 32'h00000000) && (data_in_decipher2 == 32'h00000000));

                        s7: result = (test_ciphertext && test_plaintext);

                        //Test 2

                        s8: begin

                            result = 1'b0;

                            reset_out = 1'b1;

                            data_out_encipher1 = 32'h00000000;

                            data_out_encipher2 = 32'h00000000;

                            key_out = 128'h11111111222222223333333344444444;

                            end

                        s9: reset_out = 1'b0;

                        s10: begin

                        test_ciphertext = ((data_in_encipher1 == 32'hf07ac290) && (data_in_encipher2 == 32'h23c92672));

                        tempdata1 = data_in_encipher1;

                        tempdata2 = data_in_encipher2;

                        end

                        s11: begin

                        reset_out = 1'b1;

                        data_out_decipher1 = tempdata1;

                        data_out_decipher2 = tempdata2;

                        end

                        s12: reset_out = 1'b0;

                        s13: test_plaintext = ((data_in_decipher1 == 32'h00000000) && (data_in_decipher2 == 32'h00000000));

                        s14: result = (test_ciphertext && test_plaintext);

                        //Test 3

                        s15: begin

                            result = 1'b0;

                            reset_out = 1'b1;

                            data_out_encipher1 = 32'h12345678;

                            data_out_encipher2 = 32'h9abcdeff;

                            key_out = 128'h6a1d78c88c86d67f2a65bfbeb4bd6e46;

                            end

                        s16: reset_out = 1'b0;

                        s17: begin

                        test_ciphertext = ((data_in_encipher1 == 32'h99bbb92b) && (data_in_encipher2 == 32'h3ebd1644));

                        tempdata1 = data_in_encipher1;

                        tempdata2 = data_in_encipher2;

                        end

                        s18: begin

                        reset_out = 1'b1;

                        data_out_decipher1 = tempdata1;

                        data_out_decipher2 = tempdata2;

                        end

                        s19: reset_out = 1'b0;

                        s20: test_plaintext = ((data_in_decipher1 == 32'h12345678) && (data_in_decipher2 == 32'h9abcdeff));

                        s21: result = (test_ciphertext && test_plaintext);

                        //Test 4

                        s22: begin

                            result = 1'b0;

                            reset_out = 1'b1;

                            data_out_encipher1 = 32'h00000001;

                            data_out_encipher2 = 32'h00000001;

                            key_out = 128'h62ee209f69b7afce376a8936cdc9e923;

                            end

                        s23: reset_out = 1'b0;

                        s24: begin

                        test_ciphertext = ((data_in_encipher1 == 32'he57220dd) && (data_in_encipher2 == 32'h2622745b));

                        tempdata1 = data_in_encipher1;

                        tempdata2 = data_in_encipher2;

                        end

                        s25: begin

                        reset_out = 1'b1;

                        data_out_decipher1 = tempdata1;

                        data_out_decipher2 = tempdata2;

                        end

                        s26: reset_out = 1'b0;

                        s27: test_plaintext = ((data_in_decipher1 == 32'h00000001) && (data_in_decipher2 == 32'h00000001));

                        s28: result = (test_ciphertext && test_plaintext);

                        //Test 5

                        s29: begin

                            result = 1'b0;

                            reset_out = 1'b1;

                            data_out_encipher1 = 32'h77777777;

                            data_out_encipher2 = 32'h98765432;

                            key_out = 128'hbc3a7de2845846cf2794a1276b8ea8b8;

                            end

                        s30: reset_out = 1'b0;

                        s31: begin

                        test_ciphertext = ((data_in_encipher1 == 32'hda6b0b0a) && (data_in_encipher2 == 32'ha15e9758));

                        tempdata1 = data_in_encipher1;

                        tempdata2 = data_in_encipher2;

                        end

                        s32: begin

                        reset_out = 1'b1;

                        data_out_decipher1 = tempdata1;

                        data_out_decipher2 = tempdata2;

                        end

                        s33: reset_out = 1'b0;

                        s34: test_plaintext = ((data_in_decipher1 == 32'h77777777) && (data_in_decipher2 == 32'h98765432));

                        s35: result = (test_ciphertext && test_plaintext);

                        //Test 6

                        s36: begin

                            result = 1'b0;

                            reset_out = 1'b1;

                            data_out_encipher1 = 32'hffffffff;

                            data_out_encipher2 = 32'hffffffff;

                            key_out = 128'h6a1d78c88c86d6712a65bfbeb4bd6e46;

                            end

                        s37: reset_out = 1'b0;

                        s38: begin

                        test_ciphertext = ((data_in_encipher1 == 32'h674e0539) && (data_in_encipher2 == 32'h5ad31ab8));

                        tempdata1 = data_in_encipher1;

                        tempdata2 = data_in_encipher2;

                        end

                        s39: begin

                        reset_out = 1'b1;

                        data_out_decipher1 = tempdata1;

                        data_out_decipher2 = tempdata2;

                        end

                        s40: reset_out = 1'b0;

                        s41: test_plaintext = ((data_in_decipher1 == 32'hffffffff) && (data_in_decipher2 == 32'hffffffff));

                        s42: result = (test_ciphertext && test_plaintext);

                        //Test 7

                        s43: begin

                            result = 1'b0;

                            reset_out = 1'b1;

                            data_out_encipher1 = 32'hffffffff;

                            data_out_encipher2 = 32'hffffffff;

                            key_out = 128'hffffffffffffffffffffffffffffffff;

                            end

                        s44: reset_out = 1'b0;

                        s45: begin

                        test_ciphertext = ((data_in_encipher1 == 32'h28fc2891) && (data_in_encipher2 == 32'he623566a));

                        tempdata1 = data_in_encipher1;

                        tempdata2 = data_in_encipher2;

                        end

                        s46: begin

                        reset_out = 1'b1;

                        data_out_decipher1 = tempdata1;

                        data_out_decipher2 = tempdata2;

                        end

                        s47: reset_out = 1'b0;

                        s48: test_plaintext = ((data_in_decipher1 == 32'hffffffff) && (data_in_decipher2 == 32'hffffffff));

                        s49: result = (test_ciphertext && test_plaintext);

                        //End tests

                        default: begin

                        reset_out = 1'b1;

                        data_out_encipher1 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;

                        data_out_encipher2 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;

                        data_out_decipher1 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;

                        data_out_decipher2 = 32'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;

                        key_out = 128'bzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;

                        result = 1'bz;

                        end

                endcase

        end

end

endmodule