Subversion Repositories threeaesc

-- Copyright (c) 2011 Antonio de la Piedra

-- This program is free software: you can redistribute it and/or modify

-- it under the terms of the GNU General Public License as published by

-- the Free Software Foundation, either version 3 of the License, or

-- (at your option) any later version.

-- This program 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 General Public License for more details.

-- You should have received a copy of the GNU General Public License

-- along with this program.  If not, see <http://www.gnu.org/licenses/>.

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.std_logic_ARITH.ALL;

use IEEE.std_logic_UNSIGNED.ALL;

use ieee.numeric_std.all;

use work.aes_lib.all;

entity aes_fsm_enc is

        port(     clk: in std_logic;

                  rst : in std_logic;

                  block_in : in std_logic_vector(127 downto 0);

                  key : in std_logic_vector(127 downto 0);

                  enc : in std_logic;

                  block_out : out std_logic_vector(127 downto 0);

                  block_ready : out std_logic);

        end aes_fsm_enc;

architecture Behavioral of aes_fsm_enc is

  type state_type is (idle, n_round_1, n_round_2, n_round_3, n_round_4, n_round_5, n_round_6, last_round_1,

                      last_round_2, last_round_3, last_round_4, last_round_5, last_round_6, pre);

  signal state, next_state: state_type ;

  signal block_in_s :  std_logic_vector(127 downto 0);

  signal sub_key_s :  std_logic_vector(127 downto 0);

  signal load_s :  std_logic;

  signal enc_s :  std_logic;

  signal last_s, rst_cnt :  std_logic;

  signal block_out_s :  std_logic_vector(127 downto 0);

  signal count: natural range 0 to 10;

  signal en_cnt : std_logic;

  signal key_addr_1, key_addr_2 : std_logic_vector(3 downto 0);

  signal key_data_1, key_data_delay_1, key_data_2, key_data_delay_2 : std_logic_vector(127 downto 0);

begin

  process1: process (clk,rst)

  begin

    if (rst ='1') then

      state <= idle;

    elsif rising_edge(clk) then

      state <= next_state;

    end if;

  end process process1;

  process2 : process (state, enc, block_in, key, block_out_s)

    variable block_reg_v : std_logic_vector(127 downto 0);

  begin

    next_state <= state;

    block_reg_v := (others => '0');

    block_in_s <= (others => '0');

   sub_key_s <= (others => '0');

   enc_s <= '0';

   load_s <= '0';

   last_s <= '0';

   block_ready <= '0';

    case state is

          when idle =>

            if enc ='1' then

              next_state <= pre;

            else

              next_state <= idle;

            end if;

          when pre =>

            rst_cnt <= '0';

            for i in 0 to 127 loop

              block_reg_v(i) := block_in(i) xor key(i);

            end loop;

            load_s <= '1';

            enc_s <= '0';

            sub_key_s <= key_data_1;

            block_in_s <= block_reg_v;

            next_state <= n_round_1;

          when n_round_1 =>

            enc_s <= '1';

            load_s <= '0';

            next_state <= n_round_2;

          when n_round_2 =>

            enc_s <= '1';

            load_s <= '0';

            next_state <= n_round_3;

          when n_round_3 =>

            enc_s <= '1';

            load_s <= '0';

            next_state <= n_round_4;

          when n_round_4 =>

            enc_s <= '1';

            load_s <= '0';

            next_state <= n_round_5;

          when n_round_5 =>

            enc_s <= '1';

            load_s <= '0';

            next_state <= n_round_6;

          when n_round_6 =>

            enc_s <= '1';

            load_s <= '1';

            sub_key_s <=  key_data_1;

            block_in_s <= block_out_s;

            if count = 9 then

              next_state <= last_round_1;

            else

              next_state <= n_round_1;

            end if;

          when last_round_1 =>

            enc_s <= '1';

            load_s <= '0';

            last_s <= '1';

            next_state <= last_round_2;

          when last_round_2 =>

            enc_s <= '1';

            load_s <= '0';

            last_s <= '1';

            next_state <= last_round_3;

          when last_round_3 =>

            enc_s <= '1';

            load_s <= '0';

            last_s <= '1';

            next_state <= last_round_4;

          when last_round_4 =>

            enc_s <= '1';

            load_s <= '0';

            last_s <= '1';

            next_state <= last_round_5;

          when last_round_5 =>

            enc_s <= '1';

            load_s <= '0';

            last_s <= '1';

            rst_cnt <= '1';

            next_state <= last_round_6;

          when last_round_6 =>

            enc_s <= '1';

            load_s <= '0';

            last_s <= '1';

            block_ready <= '1';

            rst_cnt <= '0';

            next_state <= idle;

    end case;

  end process process2;

  mod_10_cnt : process(clk, rst_cnt)

  begin

    if rising_edge(clk) then

      if (rst_cnt = '1') then

        count <= 0;

      elsif(en_cnt = '1' and state = n_round_1) then

        if (count = 9) then

          count <= 0;

        else

          count <= count + 1;

        end if;

      end if;

     end if;

  end process mod_10_cnt;

  en_cnt <= '1';

  AES_ROUND_N : entity work.aes_enc(Behavioral) port map (clk,

                                                          rst,

                                                          block_in_s,

                                                          sub_key_s,

                                                          load_s,

                                                          enc_s,

                                                          last_s,

                                                          block_out_s);

  SUB_KEYS_DRAM : entity work.dual_mem(rtl) generic map (4, 128, 10)

                                            port map (clk,

                                                      '0',

                                                      key_addr_1,

                                                      key_addr_2,

                                                      (others => '0'),

                                                      key_data_1,

                                                      key_data_2);

  key_addr_1 <= std_logic_vector(to_unsigned(count, key_addr_1'length));

  key_addr_2 <= std_logic_vector(to_unsigned(count, key_addr_2'length));

 block_out <= block_out_s;

end Behavioral;