tmeissner
/
cryptocores
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
cryptography ip-cores in vhdl / verilog
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
184 Commits
1 Branch
1.7 MiB
Tree: c400d2ef1b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c400d2ef1b'
${ noResults }
cryptocores/aes/rtl/vhdl/aes_pkg.vhd

395 lines
17 KiB
Raw Normal View History

divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
Add PSL checkers, refactoring * Add some simple PSL checkers & coverage to aes_enc & aes_dec * Add generating of PSL coverage report * Add report outputs to testbench
5 years ago
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
Add PSL checkers, refactoring * Add some simple PSL checkers & coverage to aes_enc & aes_dec * Add generating of PSL coverage report * Add report outputs to testbench
5 years ago
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
​
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
beauty care
10 years ago
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
First working version of AES enc & dec * Split enc & dec in separate units aes_enc & aes_dec * Add component declarations to aes_pkg * Key schedule isn't implemented yet * Fixed round keys at the moment until key schedule is implemented * Simple test of enc & dec * New aes top level unit (empty at the moment) * Renamed makefile to Makefile
5 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
​
​
​
​
​
​
Add PSL checkers, refactoring * Add some simple PSL checkers & coverage to aes_enc & aes_dec * Add generating of PSL coverage report * Add report outputs to testbench
5 years ago
​
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
​
​
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
Fixed many incorrect implemented functions
5 years ago
Minor refactoring & bugfixing * Set VHDL standard to VHDL 2008 * Replace rcon() functuion by simple array constant * Correct loop range in addroundkey() function
5 years ago
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
merge last changes from amc mini repo
9 years ago
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
merge last changes from amc mini repo
9 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
Minor refactoring & bugfixing * Set VHDL standard to VHDL 2008 * Replace rcon() functuion by simple array constant * Correct loop range in addroundkey() function
5 years ago
​
​
​
​
​
​
​
​
​
​
​
Fixed many incorrect implemented functions
5 years ago
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
Fixed many incorrect implemented functions
5 years ago
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
merge last changes from amc mini repo
9 years ago
Fixed many incorrect implemented functions
5 years ago
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
​
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
​
​
​
​
​
Fixed many incorrect implemented functions
5 years ago
​
​
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
beauty care
10 years ago
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
Fixed many incorrect implemented functions
5 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
​
​
Fixed many incorrect implemented functions
5 years ago
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
Fixed many incorrect implemented functions
5 years ago
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
Fixed many incorrect implemented functions
5 years ago
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
​
​
​
​
​
​
​
Fixed many incorrect implemented functions
5 years ago
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
Fixed many incorrect implemented functions
5 years ago
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
Fixed many incorrect implemented functions
5 years ago
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
​
Fix gmul() & (inv)mixcolums() functions
5 years ago
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
Fix gmul() & (inv)mixcolums() functions
5 years ago
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
Fix gmul() & (inv)mixcolums() functions
5 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
​
Fixed many incorrect implemented functions
5 years ago
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
Fixed many incorrect implemented functions
5 years ago
​
​
​
​
add implementation of mixcolumns function
10 years ago
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
​
​
Fix gmul() & (inv)mixcolums() functions
5 years ago
Fixed many incorrect implemented functions
5 years ago
Fix gmul() & (inv)mixcolums() functions
5 years ago
​
Fixed many incorrect implemented functions
5 years ago
​
​
​
​
Fix gmul() & (inv)mixcolums() functions
5 years ago
​
​
​
​
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
​
​
​
Fixed many incorrect implemented functions
5 years ago
​
​
​
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
First working version of AES enc & dec * Split enc & dec in separate units aes_enc & aes_dec * Add component declarations to aes_pkg * Key schedule isn't implemented yet * Fixed round keys at the moment until key schedule is implemented * Simple test of enc & dec * New aes top level unit (empty at the moment) * Renamed makefile to Makefile
5 years ago
Add remaining AES functions * addroundkey() * subword() * rotword() * rcon()
9 years ago
​
​
Fixed many incorrect implemented functions
5 years ago
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
divide rtl directory in 2 sub-directories: vhdl & verilog move all rtl *.vhd files into the new vhdl directory in the rtl directory
12 years ago
 
  1. -- ======================================================================
  2. -- AES encryption/decryption
  3. -- Copyright (C) 2019 Torsten Meissner
  4. -------------------------------------------------------------------------
  5. -- This program is free software; you can redistribute it and/or modify
  6. -- it under the terms of the GNU General Public License as published by
  7. -- the Free Software Foundation; either version 2 of the License, or
  8. -- (at your option) any later version.
  9. 

  10. -- This program is distributed in the hope that it will be useful,
  11. -- but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. -- GNU General Public License for more details.
  14. 

  15. -- You should have received a copy of the GNU General Public License
  16. -- along with this program; if not, write to the Free Software
  17. -- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18. -- ======================================================================
  19. 

  20. 

  21. -- aes implementation
  22. -- key length: 128 bit -> Nk = 4
  23. -- data width: 128 bit -> Nb = 4
  24. -- round number Nr = 10
  25. 

  26. 

  27. library ieee;
  28.   use ieee.std_logic_1164.all;
  29.   use ieee.numeric_std.all;
  30. 

  31. 

  32. 

  33. package aes_pkg is
  34. 

  35. 

  36.   -- components
  37.   component aes_enc is
  38.     generic (
  39.       design_type : string := "ITER"
  40.     );
  41.     port (
  42.       reset_i     : in  std_logic;
  43.       clk_i       : in  std_logic;
  44.       key_i       : in  std_logic_vector(0 to 127);
  45.       data_i      : in  std_logic_vector(0 to 127);
  46.       valid_i     : in  std_logic;
  47.       accept_o    : out std_logic;
  48.       data_o      : out std_logic_vector(0 to 127);
  49.       valid_o     : out std_logic;
  50.       accept_i    : in  std_logic
  51.     );
  52.   end component aes_enc;
  53. 

  54. 

  55.   component aes_dec is
  56.     generic (
  57.       design_type : string := "ITER"
  58.     );
  59.     port (
  60.       reset_i     : in  std_logic;
  61.       clk_i       : in  std_logic;
  62.       key_i       : in  std_logic_vector(0 to 127);
  63.       data_i      : in  std_logic_vector(0 to 127);
  64.       valid_i     : in  std_logic;
  65.       accept_o    : out std_logic;
  66.       data_o      : out std_logic_vector(0 to 127);
  67.       valid_o     : out std_logic;
  68.       accept_i    : in  std_logic
  69.     );
  70.   end component aes_dec;
  71. 

  72. 

  73.   -- constants for AES128
  74.   constant c_nk : natural := 4;   -- key size
  75.   constant c_nb : natural := 4;   -- number of bytes
  76.   constant c_nr : natural := 10;  -- number of rounds
  77. 

  78.   subtype t_rounds is natural range 0 to c_nr + 1;
  79.   subtype t_key_rounds is natural range c_nk to c_nb * (c_nr + 1);
  80.   subtype t_enc_rounds is natural range t_rounds'low to t_rounds'high+1;
  81.   subtype t_dec_rounds is natural range t_rounds'low to t_rounds'high+1;
  82. 

  83.   type t_datatable1d is array (0 to 3) of std_logic_vector(7 downto 0);
  84.   type t_datatable2d is array (0 to 3) of t_datatable1d;
  85. 

  86.   type t_stable1d is array (0 to 15) of std_logic_vector(7 downto 0);
  87.   type t_stable2d is array (0 to 15) of t_stable1d;
  88. 

  89.   type t_key is array (0 to 3) of std_logic_vector(31 downto 0);
  90. 

  91.   type t_rcon is array (0 to 9) of t_datatable1d;
  92. 

  93.   constant c_sbox : t_stable2d := (
  94.     -- 0     1      2      3      4      5      6      7      8      9      A      B      C      D      E      F
  95.     (x"63", x"7c", x"77", x"7b", x"f2", x"6b", x"6f", x"c5", x"30", x"01", x"67", x"2b", x"fe", x"d7", x"ab", x"76"), -- 0
  96.     (x"ca", x"82", x"c9", x"7d", x"fa", x"59", x"47", x"f0", x"ad", x"d4", x"a2", x"af", x"9c", x"a4", x"72", x"c0"), -- 1
  97.     (x"b7", x"fd", x"93", x"26", x"36", x"3f", x"f7", x"cc", x"34", x"a5", x"e5", x"f1", x"71", x"d8", x"31", x"15"), -- 2
  98.     (x"04", x"c7", x"23", x"c3", x"18", x"96", x"05", x"9a", x"07", x"12", x"80", x"e2", x"eb", x"27", x"b2", x"75"), -- 3
  99.     (x"09", x"83", x"2c", x"1a", x"1b", x"6e", x"5a", x"a0", x"52", x"3b", x"d6", x"b3", x"29", x"e3", x"2f", x"84"), -- 4
  100.     (x"53", x"d1", x"00", x"ed", x"20", x"fc", x"b1", x"5b", x"6a", x"cb", x"be", x"39", x"4a", x"4c", x"58", x"cf"), -- 5
  101.     (x"d0", x"ef", x"aa", x"fb", x"43", x"4d", x"33", x"85", x"45", x"f9", x"02", x"7f", x"50", x"3c", x"9f", x"a8"), -- 6
  102.     (x"51", x"a3", x"40", x"8f", x"92", x"9d", x"38", x"f5", x"bc", x"b6", x"da", x"21", x"10", x"ff", x"f3", x"d2"), -- 7
  103.     (x"cd", x"0c", x"13", x"ec", x"5f", x"97", x"44", x"17", x"c4", x"a7", x"7e", x"3d", x"64", x"5d", x"19", x"73"), -- 8
  104.     (x"60", x"81", x"4f", x"dc", x"22", x"2a", x"90", x"88", x"46", x"ee", x"b8", x"14", x"de", x"5e", x"0b", x"db"), -- 9
  105.     (x"e0", x"32", x"3a", x"0a", x"49", x"06", x"24", x"5c", x"c2", x"d3", x"ac", x"62", x"91", x"95", x"e4", x"79"), -- A
  106.     (x"e7", x"c8", x"37", x"6d", x"8d", x"d5", x"4e", x"a9", x"6c", x"56", x"f4", x"ea", x"65", x"7a", x"ae", x"08"), -- B
  107.     (x"ba", x"78", x"25", x"2e", x"1c", x"a6", x"b4", x"c6", x"e8", x"dd", x"74", x"1f", x"4b", x"bd", x"8b", x"8a"), -- C
  108.     (x"70", x"3e", x"b5", x"66", x"48", x"03", x"f6", x"0e", x"61", x"35", x"57", x"b9", x"86", x"c1", x"1d", x"9e"), -- D
  109.     (x"e1", x"f8", x"98", x"11", x"69", x"d9", x"8e", x"94", x"9b", x"1e", x"87", x"e9", x"ce", x"55", x"28", x"df"), -- E
  110.     (x"8c", x"a1", x"89", x"0d", x"bf", x"e6", x"42", x"68", x"41", x"99", x"2d", x"0f", x"b0", x"54", x"bb", x"16")); -- F
  111. 

  112.   constant c_sbox_invers : t_stable2d := (
  113.     -- 0     1      2      3      4      5      6      7      8      9      A      B      C      D      E      F
  114.     (x"52", x"09", x"6a", x"d5", x"30", x"36", x"a5", x"38", x"bf", x"40", x"a3", x"9e", x"81", x"f3", x"d7", x"fb"), -- 0
  115.     (x"7c", x"e3", x"39", x"82", x"9b", x"2f", x"ff", x"87", x"34", x"8e", x"43", x"44", x"c4", x"de", x"e9", x"cb"), -- 1
  116.     (x"54", x"7b", x"94", x"32", x"a6", x"c2", x"23", x"3d", x"ee", x"4c", x"95", x"0b", x"42", x"fa", x"c3", x"4e"), -- 2
  117.     (x"08", x"2e", x"a1", x"66", x"28", x"d9", x"24", x"b2", x"76", x"5b", x"a2", x"49", x"6d", x"8b", x"d1", x"25"), -- 3
  118.     (x"72", x"f8", x"f6", x"64", x"86", x"68", x"98", x"16", x"d4", x"a4", x"5c", x"cc", x"5d", x"65", x"b6", x"92"), -- 4
  119.     (x"6c", x"70", x"48", x"50", x"fd", x"ed", x"b9", x"da", x"5e", x"15", x"46", x"57", x"a7", x"8d", x"9d", x"84"), -- 5
  120.     (x"90", x"d8", x"ab", x"00", x"8c", x"bc", x"d3", x"0a", x"f7", x"e4", x"58", x"05", x"b8", x"b3", x"45", x"06"), -- 6
  121.     (x"d0", x"2c", x"1e", x"8f", x"ca", x"3f", x"0f", x"02", x"c1", x"af", x"bd", x"03", x"01", x"13", x"8a", x"6b"), -- 7
  122.     (x"3a", x"91", x"11", x"41", x"4f", x"67", x"dc", x"ea", x"97", x"f2", x"cf", x"ce", x"f0", x"b4", x"e6", x"73"), -- 8
  123.     (x"96", x"ac", x"74", x"22", x"e7", x"ad", x"35", x"85", x"e2", x"f9", x"37", x"e8", x"1c", x"75", x"df", x"6e"), -- 9
  124.     (x"47", x"f1", x"1a", x"71", x"1d", x"29", x"c5", x"89", x"6f", x"b7", x"62", x"0e", x"aa", x"18", x"be", x"1b"), -- A
  125.     (x"fc", x"56", x"3e", x"4b", x"c6", x"d2", x"79", x"20", x"9a", x"db", x"c0", x"fe", x"78", x"cd", x"5a", x"f4"), -- B
  126.     (x"1f", x"dd", x"a8", x"33", x"88", x"07", x"c7", x"31", x"b1", x"12", x"10", x"59", x"27", x"80", x"ec", x"5f"), -- C
  127.     (x"60", x"51", x"7f", x"a9", x"19", x"b5", x"4a", x"0d", x"2d", x"e5", x"7a", x"9f", x"93", x"c9", x"9c", x"ef"), -- D
  128.     (x"a0", x"e0", x"3b", x"4d", x"ae", x"2a", x"f5", x"b0", x"c8", x"eb", x"bb", x"3c", x"83", x"53", x"99", x"61"), -- E
  129.     (x"17", x"2b", x"04", x"7e", x"ba", x"77", x"d6", x"26", x"e1", x"69", x"14", x"63", x"55", x"21", x"0c", x"7d"));-- F
  130. 

  131.   constant c_rcon : t_rcon := (
  132.     (x"01", x"00", x"00", x"00"),
  133.     (x"02", x"00", x"00", x"00"),
  134.     (x"04", x"00", x"00", x"00"),
  135.     (x"08", x"00", x"00", x"00"),
  136.     (x"10", x"00", x"00", x"00"),
  137.     (x"20", x"00", x"00", x"00"),
  138.     (x"40", x"00", x"00", x"00"),
  139.     (x"80", x"00", x"00", x"00"),
  140.     (x"1B", x"00", x"00", x"00"),
  141.     (x"36", x"00", x"00", x"00"));
  142. 

  143.   type t_mode is (ENCRYPT, DECRYPT);
  144. 

  145. 

  146.   function bytesub    (input : std_logic_vector(7 downto 0)) return std_logic_vector;
  147.   function invbytesub (input : std_logic_vector(7 downto 0)) return std_logic_vector;
  148. 

  149.   function subbytes (input : in t_datatable2d) return t_datatable2d;
  150.   function invsubbytes (input : in t_datatable2d) return t_datatable2d;
  151. 

  152.   function shiftrow    (input : t_datatable2d) return t_datatable2d;
  153.   function invshiftrow (input : t_datatable2d) return t_datatable2d;
  154. 

  155.   function mixcolumns (input : t_datatable2d) return t_datatable2d;
  156.   function invmixcolumns (input : t_datatable2d) return t_datatable2d;
  157. 

  158.   function sortdata (input : std_logic_vector(127 downto 0)) return t_datatable2d;
  159. 

  160.   function gmul (a : std_logic_vector(7 downto 0); b : std_logic_vector(7 downto 0)) return std_logic_vector;
  161. 

  162.   function addroundkey (input : in t_datatable2d; key : in t_key) return t_datatable2d;
  163. 

  164.   function subword (input : in t_datatable1d) return t_datatable1d;
  165. 

  166.   function rotword (input : in t_datatable1d) return t_datatable1d;
  167. 

  168.   function set_state (input : in std_logic_vector(0 to 127)) return t_datatable2d;
  169. 

  170.   function get_state (input : in t_datatable2d) return std_logic_vector;
  171. 

  172.   function to_string(input : t_datatable2d) return string;
  173. 

  174. 

  175. end package aes_pkg;
  176. 

  177. 

  178. 

  179. package body aes_pkg is
  180. 

  181. 

  182.   function sortdata (input : std_logic_vector(127 downto 0)) return t_datatable2d is
  183.     variable v_datamatrix : t_datatable2d;
  184.   begin
  185.     for outdex in 0 to 3 loop
  186.       for index in 0 to 3 loop
  187.         v_datamatrix(index)(outdex) := input(outdex*32+(index+1)*7 downto outdex*32+index*8);
  188.       end loop;
  189.     end loop;
  190.     return v_datamatrix;
  191.   end function sortdata;
  192. 

  193. 

  194.   function bytesub (input : std_logic_vector(7 downto 0)) return std_logic_vector is
  195.   begin
  196.     return(c_sbox(to_integer(unsigned(input(7 downto 4))))(to_integer(unsigned(input(3 downto 0)))));
  197.   end function bytesub;
  198. 

  199. 

  200.   function invbytesub (input : std_logic_vector(7 downto 0)) return std_logic_vector is
  201.   begin
  202.     return(c_sbox_invers(to_integer(unsigned(input(7 downto 4))))(to_integer(unsigned(input(3 downto 0)))));
  203.   end function invbytesub;
  204. 

  205. 

  206.   function subbytes (input : in t_datatable2d) return t_datatable2d is
  207.     variable v_data : t_datatable2d;
  208.   begin
  209.     for column in 0 to 3 loop
  210.       for row in 0 to 3 loop
  211.         v_data(row)(column) := c_sbox(to_integer(unsigned(input(row)(column)(7 downto 4))))(to_integer(unsigned(input(row)(column)(3 downto 0))));
  212.       end loop;
  213.     end loop;
  214.     return v_data;
  215.   end function subbytes;
  216. 

  217. 

  218.   function invsubbytes (input : in t_datatable2d) return t_datatable2d is
  219.     variable v_data : t_datatable2d;
  220.   begin
  221.     for column in 0 to 3 loop
  222.       for row in 0 to 3 loop
  223.         v_data(row)(column) := c_sbox_invers(to_integer(unsigned(input(row)(column)(7 downto 4))))(to_integer(unsigned(input(row)(column)(3 downto 0))));
  224.       end loop;
  225.     end loop;
  226.     return v_data;
  227.   end function invsubbytes;
  228. 

  229. 

  230.   function shiftrow (input : t_datatable2d) return t_datatable2d is
  231.     variable v_datamatrix : t_datatable2d;
  232.   begin
  233.     -- copy input in internal matrix
  234.     v_datamatrix := input;
  235.     -- 2nd row
  236.     v_datamatrix(1)(0) := input(1)(1);
  237.     v_datamatrix(1)(1) := input(1)(2);
  238.     v_datamatrix(1)(2) := input(1)(3);
  239.     v_datamatrix(1)(3) := input(1)(0);
  240.     -- 3rd row
  241.     v_datamatrix(2)(0) := input(2)(2);
  242.     v_datamatrix(2)(1) := input(2)(3);
  243.     v_datamatrix(2)(2) := input(2)(0);
  244.     v_datamatrix(2)(3) := input(2)(1);
  245.     -- 4rd row
  246.     v_datamatrix(3)(0) := input(3)(3);
  247.     v_datamatrix(3)(1) := input(3)(0);
  248.     v_datamatrix(3)(2) := input(3)(1);
  249.     v_datamatrix(3)(3) := input(3)(2);
  250.     -- return manipulated internal matrix
  251.     return v_datamatrix;
  252.   end function shiftrow;
  253. 

  254. 

  255.   function invshiftrow (input : t_datatable2d) return t_datatable2d is
  256.     variable v_datamatrix : t_datatable2d;
  257.   begin
  258.     -- copy input in internal matrix
  259.     v_datamatrix := input;
  260.     -- 2nd row
  261.     v_datamatrix(1)(0) := input(1)(3);
  262.     v_datamatrix(1)(1) := input(1)(0);
  263.     v_datamatrix(1)(2) := input(1)(1);
  264.     v_datamatrix(1)(3) := input(1)(2);
  265.     -- 3rd row
  266.     v_datamatrix(2)(0) := input(2)(2);
  267.     v_datamatrix(2)(1) := input(2)(3);
  268.     v_datamatrix(2)(2) := input(2)(0);
  269.     v_datamatrix(2)(3) := input(2)(1);
  270.     -- 4rd row
  271.     v_datamatrix(3)(0) := input(3)(1);
  272.     v_datamatrix(3)(1) := input(3)(2);
  273.     v_datamatrix(3)(2) := input(3)(3);
  274.     v_datamatrix(3)(3) := input(3)(0);
  275.     -- return manipulated internal matrix
  276.     return v_datamatrix;
  277.   end function invshiftrow;
  278. 

  279. 

  280.   -- trivial algorithmus to multiply two bytes in the GF(2^8) finite field defined
  281.   -- by the polynomial x^8 + x^4 + x^3 + x + 1
  282.   -- taken from http://www.codeplanet.eu/tutorials/cpp/51-advanced-encryption-standard.html
  283.   -- and ported to vhdl
  284.   function gmul (a : std_logic_vector(7 downto 0); b : std_logic_vector(7 downto 0)) return std_logic_vector is
  285.     variable v_a, v_b     : std_logic_vector(7 downto 0);
  286.     variable v_data       : std_logic_vector(7 downto 0) := (others => '0');
  287.     variable v_hi_bit_set : boolean;
  288.   begin
  289.     v_a := a;
  290.     v_b := b;
  291.     for index in 0 to 7 loop
  292.       if(v_b(0) = '1') then
  293.         v_data := v_data xor v_a;
  294.       end if;
  295.       v_hi_bit_set := v_a(7) = '1';
  296.       v_a          := v_a(6 downto 0) & '0';
  297.       if (v_hi_bit_set) then
  298.         v_a := v_a xor x"1B";
  299.       end if;
  300.       v_b := '0' & v_b(7 downto 1);
  301.     end loop;
  302.     return v_data;
  303.   end function gmul;
  304. 

  305. 

  306.   -- matrix columns manipulation
  307.   function mixcolumns (input : t_datatable2d) return t_datatable2d is
  308.     variable v_data : t_datatable2d;
  309.   begin
  310.     for column in 0 to 3 loop
  311.       v_data(0)(column) := gmul(x"02", input(0)(column)) xor gmul(x"03", input(1)(column)) xor input(2)(column) xor input(3)(column);
  312.       v_data(1)(column) := input(0)(column) xor gmul(x"02", input(1)(column)) xor gmul(x"03",input(2)(column))  xor input(3)(column);
  313.       v_data(2)(column) := input(0)(column) xor input(1)(column) xor gmul(x"02",input(2)(column))  xor gmul(x"03",input(3)(column));
  314.       v_data(3)(column) := gmul(x"03", input(0)(column)) xor input(1)(column) xor input(2)(column) xor gmul(x"02",input(3)(column));
  315.     end loop;
  316.     return v_data;
  317.   end function mixcolumns;
  318. 

  319. 

  320.   -- matrix columns manipulation
  321.   function invmixcolumns (input : t_datatable2d) return t_datatable2d is
  322.     variable v_data : t_datatable2d;
  323.   begin
  324.     for column in 0 to 3 loop
  325.       v_data(0)(column) := gmul(x"0E", input(0)(column)) xor gmul(x"0B", input(1)(column)) xor gmul(x"0D", input(2)(column)) xor gmul(x"09", input(3)(column));
  326.       v_data(1)(column) := gmul(x"09", input(0)(column)) xor gmul(x"0E", input(1)(column)) xor gmul(x"0B", input(2)(column)) xor gmul(x"0D", input(3)(column));
  327.       v_data(2)(column) := gmul(x"0D", input(0)(column)) xor gmul(x"09", input(1)(column)) xor gmul(x"0E", input(2)(column)) xor gmul(x"0B", input(3)(column));
  328.       v_data(3)(column) := gmul(x"0B", input(0)(column)) xor gmul(x"0D", input(1)(column)) xor gmul(x"09", input(2)(column)) xor gmul(x"0E", input(3)(column));
  329.     end loop;
  330.     return v_data;
  331.   end function invmixcolumns;
  332. 

  333. 

  334.   function addroundkey (input : in t_datatable2d; key : in t_key) return t_datatable2d is
  335.     variable v_data : t_datatable2d;
  336.     variable v_key  : t_datatable1d;
  337.   begin
  338.     for column in 0 to 3 loop
  339.       v_key := (key(column)(31 downto 24), key(column)(23 downto 16), key(column)(15 downto 8), key(column)(7 downto 0));
  340.       for row in 0 to 3 loop
  341.         v_data(row)(column) := input(row)(column) xor v_key(row);
  342.       end loop;
  343.     end loop;
  344.     return v_data;
  345.   end function addroundkey;
  346. 

  347. 

  348.   function subword (input : in t_datatable1d) return t_datatable1d is
  349.     variable v_data : t_datatable1d;
  350.   begin
  351.     for i in 0 to 3 loop
  352.       v_data(i) := c_sbox(to_integer(unsigned(input(i)(7 downto 4))))(to_integer(unsigned(input(i)(3 downto 0))));
  353.     end loop;
  354.     return v_data;
  355.   end function subword;
  356. 

  357. 

  358.   function rotword (input : in t_datatable1d) return t_datatable1d is
  359.   begin
  360.     return(input(1), input(2), input(3), input(0));
  361.   end function rotword;
  362. 

  363. 

  364.   function set_state (input : in std_logic_vector(0 to 127)) return t_datatable2d is
  365.     variable v_data : t_datatable2d;
  366.   begin
  367.     for column in 0 to 3 loop
  368.       for row in 0 to 3 loop
  369.         v_data(row)(column) := input(row*8+column*32 to row*8+column*32+7);
  370.       end loop;
  371.     end loop;
  372.     return v_data;
  373.   end function set_state;
  374. 

  375. 

  376.   function get_state (input : in t_datatable2d) return std_logic_vector is
  377.   begin
  378.     return input(0)(0) & input(1)(0) & input(2)(0) & input(3)(0) &
  379.            input(0)(1) & input(1)(1) & input(2)(1) & input(3)(1) &
  380.            input(0)(2) & input(1)(2) & input(2)(2) & input(3)(2) &
  381.            input(0)(3) & input(1)(3) & input(2)(3) & input(3)(3);
  382.   end function get_state;
  383. 

  384. 

  385.   function to_string(input : t_datatable2d) return string is
  386.   begin
  387.     return '(' & to_hstring(input(0)(0)) & ',' & to_hstring(input(0)(1)) & ',' & to_hstring(input(0)(2)) & ',' & to_hstring(input(0)(3)) & ')' & LF &
  388.            '(' & to_hstring(input(1)(0)) & ',' & to_hstring(input(1)(1)) & ',' & to_hstring(input(1)(2)) & ',' & to_hstring(input(1)(3)) & ')' & LF &
  389.            '(' & to_hstring(input(2)(0)) & ',' & to_hstring(input(2)(1)) & ',' & to_hstring(input(2)(2)) & ',' & to_hstring(input(2)(3)) & ')' & LF &
  390.            '(' & to_hstring(input(3)(0)) & ',' & to_hstring(input(3)(1)) & ',' & to_hstring(input(3)(2)) & ',' & to_hstring(input(3)(3)) & ')';
  391.   end function to_string;
  392. 

  393. 

  394. 

  395. end package body aes_pkg;