commit 5bf74b29d2d4aee47cd52483b475f90defad5e1d
Author: bg <bg@nerilex.org>
Date:   Wed Apr 22 02:05:50 2015 +0200

    initial commit - types seem to work to some degree

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..9b116d5
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,37 @@
+# You may edit this makefile as long as you keep these original 
+# target names defined.  You can change the recipes and/or add new targets.
+
+# Not intended for manual invocation.
+# Invoked if automatic builds are enabled.
+# Analyzes only on those sources that have changed.
+# Does not build executables.
+autobuild:
+	$(GNATMAKE) -gnatc -c -k  -d -P "$(GPRPATH)"
+
+# Clean the root project of all build products.
+clean:
+	$(GNATCLEAN) -P "$(GPRPATH)"
+
+# Clean root project and all imported projects too.
+clean_tree:
+	$(GNATCLEAN) -P "$(GPRPATH)" -r
+
+# Check project sources for errors.
+# Does not build executables.
+analyze:
+	$(GNATMAKE) -d  -gnatc -c -k  -P "$(GPRPATH)"
+
+# Build executables for all mains defined by the project.
+build:
+	$(GNATMAKE) -d -P "$(GPRPATH)"
+
+# Clean, then build executables for all mains defined by the project.
+rebuild: clean build
+
+# Compile individual file.
+compile_file:
+	$(GNATMAKE) -d -ws -c -u -P "$(GPRPATH)" "$(FILE)"
+
+# Analyze individual file (no object code generated).
+analyze_file:
+	$(GNATMAKE) -d -q -c -gnatc -u -P "$(GPRPATH)" "$(FILE)"
diff --git a/src/block_cipher/aes/aes.adb b/src/block_cipher/aes/aes.adb
new file mode 100644
index 0000000..a5cbdca
--- /dev/null
+++ b/src/block_cipher/aes/aes.adb
@@ -0,0 +1,21 @@
+package body AES is
+
+   function gf256mul(a, b : u8) return u8 is
+      r : u8 := 0;
+      t1 : u8 := a;
+      t2 : u8 := b;
+   begin
+      for i in 1 .. 8 loop
+         if (t1 and 1) = 1 then
+            r := r xor t2;
+         end if;
+         t1 := Shift_Right(t1, 1);
+         if (t2 and 16#80#) = 16#80# then
+            t2 := t2 xor polynom;
+         end if;
+         t2 := Shift_Left(t2, 1);
+      end loop;
+      return r;
+   end gf256mul;
+
+end AES;
diff --git a/src/block_cipher/aes/aes.ads b/src/block_cipher/aes/aes.ads
new file mode 100644
index 0000000..c23d3f6
--- /dev/null
+++ b/src/block_cipher/aes/aes.ads
@@ -0,0 +1,8 @@
+with Crypto_Types; use Crypto_Types;
+
+package AES is
+
+private
+   polynom : constant u8 := 16#1B#;
+   function gf256mul(a, b : u8) return u8;
+end AES;
diff --git a/src/crypto_core_types.ads b/src/crypto_core_types.ads
new file mode 100644
index 0000000..ff7295a
--- /dev/null
+++ b/src/crypto_core_types.ads
@@ -0,0 +1,27 @@
+with Interfaces; use Interfaces;
+
+package Crypto_Core_Types is
+
+   type u8  is new Unsigned_8;
+   for u8'Size use 8;
+
+   type u16 is new Unsigned_16;
+   for u16'Size use 16;
+
+   type u32 is new Unsigned_32;
+   for u32'Size use 32;
+
+   type u64 is new Unsigned_64;
+   for u64'Size use 64;
+
+   type u8_Array  is Array (Integer range <>) of u8;
+   type u16_Array is Array (Integer range <>) of u16;
+   type u32_Array is Array (Integer range <>) of u32;
+   type u64_Array is Array (Integer range <>) of u64;
+
+   type u8_Array_Access  is access u8_Array;
+   type u16_Array_Access is access u16_Array;
+   type u32_Array_Access is access u32_Array;
+   type u64_Array_Access is access u64_Array;
+
+end Crypto_Core_Types;
diff --git a/src/crypto_generic_types.adb b/src/crypto_generic_types.adb
new file mode 100644
index 0000000..357b18a
--- /dev/null
+++ b/src/crypto_generic_types.adb
@@ -0,0 +1,482 @@
+with Crypto_Core_Types; use Crypto_Core_Types;
+
+-- --------------------------
+-- - Generic Functions / Procedures -
+-- --------------------------
+
+-- --------------------------
+-- - Functions / Procedures -
+-- --------------------------
+package body Crypto_Generic_Types is
+
+   -- xor each element on the left with the corresponding element on the right
+   function "xor"(Left, Right : T_Array ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      if Left'Length /= Right'Length then
+         raise Constraint_Error;
+      end if;
+      for i in r'Range loop
+         r(i) := Left(i) xor Right(Right'First - Left'First + i);
+      end loop;
+      return r;
+   end "xor";
+
+   -- xor the left element with each element on the right
+   function "xor"(Left : T;  Right : T_Array ) return T is
+      r : T := Left;
+   begin
+      for i in Right'Range loop
+         r := r xor Right(i);
+      end loop;
+      return r;
+   end "xor";
+
+   -- xor each element on the left with the element on the right
+   function "xor"(Left : T_Array;  Right : T ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      for i in r'Range loop
+         r(i) := Left(i) xor Right;
+      end loop;
+      return r;
+   end "xor";
+
+   -- and each element on the left with the corresponding element on the right
+   function "and"(Left, Right : T_Array ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      if Left'Length /= Right'Length then
+         raise Constraint_Error;
+      end if;
+      for i in r'Range loop
+         r(i) := Left(i) and Right(Right'First - Left'First + i);
+      end loop;
+      return r;
+   end "and";
+
+   -- and the left element with each element on the right
+   function "and"(Left : T;  Right : T_Array ) return T is
+      r : T := Left;
+   begin
+      for i in Right'Range loop
+         r := r and Right(i);
+      end loop;
+      return r;
+   end "and";
+
+   -- and each element on the left with the element on the right
+   function "and"(Left : T_Array;  Right : T ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      for i in r'Range loop
+         r(i) := Left(i) and Right;
+      end loop;
+      return r;
+   end "and";
+
+   -- or each element on the left with the corresponding element on the right
+   function "or"(Left, Right : T_Array ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      if Left'Length /= Right'Length then
+         raise Constraint_Error;
+      end if;
+      for i in r'Range loop
+         r(i) := Left(i) or Right(Right'First - Left'First + i);
+      end loop;
+      return r;
+   end "or";
+
+   -- or the left element with each element on the right
+   function "or"(Left : T;  Right : T_Array ) return T is
+      r : T := Left;
+   begin
+      for i in Right'Range loop
+         r := r or Right(i);
+      end loop;
+      return r;
+   end "or";
+
+   -- or each element on the left with the element on the right
+   function "or"(Left : T_Array;  Right : T ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      for i in r'Range loop
+         r(i) := Left(i) or Right;
+      end loop;
+      return r;
+   end "or";
+
+   -- add each element on the left with the corresponding element on the right
+   function "+"(Left, Right : T_Array ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      if Left'Length /= Right'Length then
+         raise Constraint_Error;
+      end if;
+      for i in r'Range loop
+         r(i) := Left(i) + Right(Right'First - Left'First + i);
+      end loop;
+      return r;
+   end "+";
+
+   -- add the left element with each element on the right
+   function "+"(Left : T;  Right : T_Array ) return T is
+      r : T := Left;
+   begin
+      for i in Right'Range loop
+         r := r + Right(i);
+      end loop;
+      return r;
+   end "+";
+
+   -- add each element on the left with the element on the right
+   function "+"(Left : T_Array;  Right : T ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      for i in r'Range loop
+         r(i) := Left(i) + Right;
+      end loop;
+      return r;
+   end "+";
+
+   -- subtract from each element on the left the corresponding element on the right
+   function "-"(Left, Right : T_Array ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      if Left'Length /= Right'Length then
+         raise Constraint_Error;
+      end if;
+      for i in r'Range loop
+         r(i) := Left(i) - Right(Right'First - Left'First + i);
+      end loop;
+      return r;
+   end "-";
+
+   -- subtract from the left element each element on the right
+   function "-"(Left : T;  Right : T_Array ) return T is
+      r : T := Left;
+   begin
+      for i in Right'Range loop
+         r := r - Right(i);
+      end loop;
+      return r;
+   end "-";
+
+   -- subtract from each element on the left the element on the right
+   function "-"(Left : T_Array;  Right : T ) return T_Array is
+      r : T_Array(Left'Range);
+   begin
+      for i in r'Range loop
+         r(i) := Left(i) - Right;
+      end loop;
+      return r;
+   end "-";
+
+   function Rotate_Array_Left(A : T_Array; Amount : Natural) return T_Array is
+      r : T_Array(A'Range);
+      x : Integer;
+   begin
+      x := Amount mod r'Length;
+      if A'Length < 1 then
+         raise Constraint_Error;
+      end if;
+      r(r'First .. r'Last - x) := A(A'First + x .. A'Last);
+      r(r'Last - x + 1 .. r'Last) := A(A'First .. A'First + x - 1);
+      return r;
+   end Rotate_Array_Left;
+
+   function Rotate_Array_Right(A : T_Array; Amount : Natural) return T_Array is
+      r : T_Array(A'Range);
+      x : Integer;
+   begin
+      x := Amount mod r'Length;
+      if A'Length < 1 then
+         raise Constraint_Error;
+      end if;
+      r(r'First + x .. r'Last) := A(A'First .. A'Last - x);
+      r(r'First .. r'First + x - 1) := A(A'Last - x + 1 .. A'Last);
+      return r;
+   end Rotate_Array_Right;
+
+   function Shift_Array_Left(A : T_Array; Amount : Natural) return T_Array is
+      r : T_Array(A'Range);
+      x : Integer;
+   begin
+      x := Amount mod r'Length;
+      if A'Length < 1 then
+         raise Constraint_Error;
+      end if;
+      r(r'First .. r'Last - x) := A(A'First + x .. A'Last);
+      for i in (r'Last - x + 1) .. r'Last loop
+         r(i) := 0;
+      end loop;
+      return r;
+   end Shift_Array_Left;
+
+   function Shift_Array_Right(A : T_Array; Amount : Natural) return T_Array is
+      r : T_Array(A'Range);
+      x : Integer;
+   begin
+      x := Amount mod r'Length;
+      if A'Length < 1 then
+         raise Constraint_Error;
+      end if;
+      r(r'First + x .. r'Last) := A(A'First .. A'Last - x);
+      for i in r'First .. (r'First + x - 1) loop
+         r(i) := 0;
+      end loop;
+      return r;
+   end Shift_Array_Right;
+
+   -- rotate the whole Array as continues big-endian integer; positive Amount rotates left (towards lower address)
+   function Rotate_be(A : T_Array;  Amount : Integer) return T_Array is
+      r : T_Array(A'Range);
+      c1, c2, tmp : T;
+      x : Integer;
+      word_rot : Integer;
+      bit_rot : Integer;
+      reverse_bit_rot : Integer;
+   begin
+      x := Amount mod (A'Length * T'Size);
+      word_rot := x / T'Size;
+      bit_rot := x mod T'Size;
+      if word_rot > 0 then
+         r := Rotate_Array_Left(A => A, Amount => Natural(abs word_rot));
+      else
+         r := Rotate_Array_Right(A => A, Amount => Natural(word_rot));
+      end if;
+      -- if bit rotation goes to the left
+      if bit_rot > 0 then
+         reverse_bit_rot := T'Size - bit_rot;
+         c1 := Shift_Right(r(r'First), reverse_bit_rot);
+         for i in reverse r'Range loop
+            c2 := Shift_Right(r(i), reverse_bit_rot);
+            tmp := Shift_Left(r(i), bit_rot);
+            r(i) := tmp or c1;
+            c1 := c2;
+         end loop;
+      end if;
+      -- if bit rotation goes to the right
+      if bit_rot < 0 then
+         bit_rot := -bit_rot;
+         reverse_bit_rot := T'Size - bit_rot;
+         c1 := Shift_Left(r(r'Last), reverse_bit_rot);
+         for i in r'Range loop
+            c2 := Shift_Left(r(i), reverse_bit_rot);
+            tmp := Shift_Right(r(i), bit_rot);
+            r(i) := tmp or c1;
+            c1 := c2;
+         end loop;
+      end if;
+      return r;
+   end Rotate_be;
+
+   -- rotate the whole Array as continues little-endian integer; positive Amount rotates left (towards higher address)
+   function Rotate_le(A : T_Array;  Amount : Integer) return T_Array is
+      r : T_Array(A'Range);
+      c1, c2, tmp : T;
+      x : Integer;
+      word_rot : Integer;
+      bit_rot : Integer;
+      reverse_bit_rot : Integer;
+   begin
+      x := Amount mod (A'Length * T'Size);
+      word_rot := x / T'Size;
+      bit_rot := x mod T'Size;
+      if word_rot < 0 then
+         r := Rotate_Array_Left(A => A, Amount => Natural(abs word_rot));
+      else
+         r := Rotate_Array_Right(A => A, Amount => Natural(word_rot));
+      end if;
+      -- if bit rotation goes to the left
+      if bit_rot > 0 then
+         reverse_bit_rot := T'Size - bit_rot;
+         c1 := Shift_Right(r(r'Last), reverse_bit_rot);
+         for i in r'Range loop
+            c2 := Shift_Right(r(i), reverse_bit_rot);
+            tmp := Shift_Left(r(i), bit_rot);
+            r(i) := tmp or c1;
+            c1 := c2;
+         end loop;
+      end if;
+      -- if bit rotation goes to the right
+      if bit_rot < 0 then
+         bit_rot := -bit_rot;
+         reverse_bit_rot := T'Size - bit_rot;
+         c1 := Shift_Left(r(r'First), reverse_bit_rot);
+         for i in reverse r'Range loop
+            c2 := Shift_Left(r(i), reverse_bit_rot);
+            tmp := Shift_Right(r(i), bit_rot);
+            r(i) := tmp or c1;
+            c1 := c2;
+         end loop;
+      end if;
+      return r;
+   end Rotate_le;
+
+   -- rotate each element by Amount to the left; negative values for Amount rotate to the right
+   function Rotate_each(A : T_Array;  Amount : Integer) return T_Array is
+      r : T_Array(A'Range);
+   begin
+      if Amount > 0 then
+         for i in r'Range loop
+            r(i) := Rotate_Left(A(i), Natural(Amount));
+         end loop;
+      end if;
+      if Amount < 0 then
+         for i in r'Range loop
+            r(i) := Rotate_Right(A(i), Natural(-Amount));
+         end loop;
+      end if;
+      if Amount = 0 then
+         r := A;
+      end if;
+      return r;
+   end Rotate_each;
+
+
+   -- shift the whole Array as continues big-endian integer; positive Amount shifts left (towards lower address)
+   function Shift_be(A : T_Array;  Amount : Integer) return T_Array is
+      r : T_Array(A'Range);
+      word_shift : Integer;
+      bit_shift : Integer;
+      reverse_bit_shift : Integer;
+      c1, c2 : T := 0;
+   begin
+      -- left shift
+      if Amount > 0 then
+         word_shift := Amount / T'Size;
+         bit_shift := Amount mod T'Size;
+         reverse_bit_shift := T'Size - bit_shift;
+         r := Shift_Array_Left(A => A, Amount => word_shift);
+         for i in reverse r'Range loop
+            c2 := Shift_Right(Value => r(i), Amount => reverse_bit_shift);
+            r(i) := Shift_Left(Value => r(i), Amount => bit_shift) or c1;
+            c1 := c2;
+         end loop;
+      end if;
+      -- right shift
+      if Amount < 0 then
+         word_shift := (-Amount) / T'Size;
+         bit_shift := (-Amount) mod T'Size;
+         reverse_bit_shift := T'Size - bit_shift;
+         r := Shift_Array_Right(A => A, Amount => word_shift);
+         for i in r'Range loop
+            c2 := Shift_Left(Value => r(i), Amount => reverse_bit_shift);
+            r(i) := Shift_Right(Value => r(i), Amount => bit_shift) or c1;
+            c1 := c2;
+         end loop;
+      end if;
+      if Amount = 0 then
+         r := A;
+      end if;
+      return r;
+   end Shift_be;
+
+
+   -- Shift the whole Array as continues little-endian integer; positive Amount shifts left (towards higher address)
+   function Shift_le(A : T_Array;  Amount : Integer) return T_Array is
+      r : T_Array(A'Range);
+      word_shift : Integer;
+      bit_shift : Integer;
+      reverse_bit_shift : Integer;
+      c1, c2 : T := 0;
+   begin
+      -- left shift
+      if Amount > 0 then
+         word_shift := Amount / T'Size;
+         bit_shift := Amount mod T'Size;
+         reverse_bit_shift := T'Size - bit_shift;
+         r := Shift_Array_Right(A => A, Amount => word_shift);
+         for i in r'Range loop
+            c2 := Shift_Right(Value => r(i), Amount => reverse_bit_shift);
+            r(i) := Shift_Left(Value => r(i), Amount => bit_shift) or c1;
+            c1 := c2;
+         end loop;
+      end if;
+      -- right shift
+      if Amount < 0 then
+         word_shift := (-Amount) / T'Size;
+         bit_shift := (-Amount) mod T'Size;
+         reverse_bit_shift := T'Size - bit_shift;
+         r := Shift_Array_Left(A => A, Amount => word_shift);
+         for i in reverse r'Range loop
+            c2 := Shift_Left(Value => r(i), Amount => reverse_bit_shift);
+            r(i) := Shift_Right(Value => r(i), Amount => bit_shift) or c1;
+            c1 := c2;
+         end loop;
+      end if;
+      if Amount = 0 then
+         r := A;
+      end if;
+      return r;
+   end Shift_le;
+
+   -- shift each element by Amount to the left; negative values for Amount shift to the right
+   function Shift_each(A : T_Array;  Amount : Integer) return T_Array is
+      r : T_Array(A'Range);
+   begin
+      if Amount > 0 then
+         for i in r'Range loop
+            r(i) := Shift_Left(A(i), Natural(Amount));
+         end loop;
+      end if;
+      if Amount < 0 then
+         for i in r'Range loop
+            r(i) := Shift_Right(A(i), Natural(-Amount));
+         end loop;
+      end if;
+      if Amount = 0 then
+         r := A;
+      end if;
+      return r;
+   end Shift_each;
+
+   -- load a value which is stored big-endian in byte Array
+   function Load_be(A : u8_Array) return T is
+      r : T := 0;
+   begin
+      for i in 0 .. (T'Size / 8 - 1) loop
+         r := Shift_left(r, 8) or T(A(A'First + i));
+      end loop;
+      return r;
+   end Load_be;
+
+   -- load a value which is stored little-endian in byte Array
+   function Load_le (A : u8_Array) return T is
+      r : T := 0;
+   begin
+      for i in reverse 0 .. (T'Size / 8 - 1) loop
+         r := Shift_left(r, 8) or T(A(A'First + i));
+      end loop;
+      return r;
+   end Load_le;
+
+   -- store a value in big-endian format in a byte Array
+   procedure Store_be(A : out u8_Array; value : in T) is
+      x : T := value;
+      b : u8;
+   begin
+      for i in reverse 0 .. (T'Size / 8 - 1) loop
+         b := u8(x and 16#FF#);
+         A(A'FIrst + i) := b;
+         x := Shift_Right(x, 8);
+      end loop;
+   end Store_be;
+
+   -- store a value in little-endian format in a byte Array
+   procedure Store_le(A : out u8_Array; value : in T) is
+      x : T := value;
+      b : u8;
+   begin
+      for i in 0 .. (T'Size / 8 - 1) loop
+         b := u8(x and 16#FF#);
+         A(A'FIrst + i) := b;
+         x := Shift_Right(x, 8);
+      end loop;
+   end Store_le;
+
+end Crypto_Generic_Types;
+
diff --git a/src/crypto_generic_types.ads b/src/crypto_generic_types.ads
new file mode 100644
index 0000000..80f9e09
--- /dev/null
+++ b/src/crypto_generic_types.ads
@@ -0,0 +1,85 @@
+with Crypto_Core_Types; use Crypto_Core_Types;
+
+-- --------------------------
+-- - Generic Functions / Procedures -
+-- --------------------------
+
+generic
+   type T  is mod <>;
+
+   with    function Shift_Left
+     (Value  : T;
+      Amount : Natural) return T is <>;
+
+   with function Shift_Right
+     (Value  : T;
+      Amount : Natural) return T is <>;
+
+   with function Rotate_Left
+     (Value  : T;
+      Amount : Natural) return T is <>;
+
+   with function Rotate_Right
+     (Value  : T;
+      Amount : Natural) return T is <>;
+
+   type T_Array  is Array (Integer range <>) of T;
+
+   type T_Array_Access  is access T_Array;
+
+   -- --------------------------
+   -- - Functions / Procedures -
+   -- --------------------------
+package Crypto_Generic_Types is
+
+   -- xor each element on the left with the corresponding element on the right
+   function "xor"(Left, Right : T_Array ) return T_Array;
+   -- xor the left element with each element on the right
+   function "xor"(Left : T;  Right : T_Array ) return T;
+   -- xor each element on the left with the element on the right
+   function "xor"(Left : T_Array;  Right : T ) return T_Array;
+   -- and each element on the left with the corresponding element on the right
+   function "and"(Left, Right : T_Array ) return T_Array;
+   -- and the left element with each element on the right
+   function "and"(Left : T;  Right : T_Array ) return T;
+   -- and each element on the left with the element on the right
+   function "and"(Left : T_Array;  Right : T ) return T_Array;
+   -- or each element on the left with the corresponding element on the right
+   function "or"(Left, Right : T_Array ) return T_Array;
+   -- or the left element with each element on the right
+   function "or"(Left : T;  Right : T_Array ) return T;
+   -- or each element on the left with the element on the right
+   function "or"(Left : T_Array;  Right : T ) return T_Array;
+   -- add each element on the left with the corresponding element on the right
+   function "+"(Left, Right : T_Array ) return T_Array;
+   -- add the left element with each element on the right
+   function "+"(Left : T;  Right : T_Array ) return T;
+   -- add each element on the left with the element on the right
+   function "+"(Left : T_Array;  Right : T ) return T_Array;
+   -- subtract from each element on the left the corresponding element on the right
+   function "-"(Left, Right : T_Array ) return T_Array;
+   -- subtract from the left element each element on the right
+   function "-"(Left : T;  Right : T_Array ) return T;
+   -- subtract from each element on the left the element on the right
+   function "-"(Left : T_Array;  Right : T ) return T_Array;
+   -- rotate the whole Array as continues big-endian integer; positive Amount rotates left (towards lower address)
+   function Rotate_be(A : T_Array;  Amount : Integer) return T_Array;
+   -- rotate the whole Array as continues little-endian integer; positive Amount rotates left (towards higher address)
+   function Rotate_le(A : T_Array;  Amount : Integer) return T_Array;
+   -- rotate each element by Amount to the left; negative values for Amount rotate to the right
+   function Rotate_each(A : T_Array;  Amount : Integer) return T_Array;
+   -- shift the whole Array as continues big-endian integer; positive Amount shifts left (towards lower address)
+   function Shift_be(A : T_Array;  Amount : Integer) return T_Array;
+   -- Shift the whole Array as continues little-endian integer; positive Amount shifts left (towards higher address)
+   function Shift_le(A : T_Array;  Amount : Integer) return T_Array;
+   -- shift each element by Amount to the left; negative values for Amount shift to the right
+   function Shift_each(A : T_Array;  Amount : Integer) return T_Array;
+   -- load a value which is stored big-endian in byte Array
+   function Load_be (A : u8_Array) return T;
+   -- load a value which is stored little-endian in byte Array
+   function Load_le(A : u8_Array) return T;
+   -- store a value in big-endian format in a byte Array
+   procedure Store_be(A : out u8_Array; value : in T);
+   -- store a value in little-endian format in a byte Array
+   procedure Store_le(A : out u8_Array; value : in T);
+end Crypto_Generic_Types;
diff --git a/src/crypto_types.ads b/src/crypto_types.ads
new file mode 100644
index 0000000..913a111
--- /dev/null
+++ b/src/crypto_types.ads
@@ -0,0 +1,18 @@
+with Crypto_Generic_Types;
+with Crypto_Core_Types; use Crypto_Core_Types;
+
+package Crypto_Types is
+
+   package Crypto_Types_u8 is new  Crypto_Generic_Types(T => u8,  T_Array => u8_Array,  T_Array_Access => u8_Array_Access);
+   package Crypto_Types_u16 is new Crypto_Generic_Types(T => u16, T_Array => u16_Array, T_Array_Access => u16_Array_Access);
+   package Crypto_Types_u32 is new Crypto_Generic_Types(T => u32, T_Array => u32_Array, T_Array_Access => u32_Array_Access);
+   package Crypto_Types_u64 is new Crypto_Generic_Types(T => u64, T_Array => u64_Array, T_Array_Access => u64_Array_Access);
+
+--   use Crypto_Core_Types;
+--   use Crypto_Types_u8;
+--   use Crypto_Types_u16;
+--   use Crypto_Types_u32;
+--   use Crypto_Types_u64;
+
+
+end Crypto_Types;
diff --git a/src/main.adb b/src/main.adb
new file mode 100644
index 0000000..298380c
--- /dev/null
+++ b/src/main.adb
@@ -0,0 +1,64 @@
+with Ada.Text_IO; use Ada.Text_IO;
+with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
+with Crypto_Types; use Crypto_Types;
+with Crypto_Core_Types; use Crypto_Core_Types;
+
+use Crypto_Types.Crypto_Types_u8;
+
+
+procedure main is
+
+   procedure print_hex(value : in u8) is
+      hex_table : constant array (0 .. 15) of Character :=
+        ( '0', '1', '2', '3',
+       '4', '5', '6', '7',
+       '8', '9', 'A', 'B',
+       'C', 'D', 'E', 'F');
+   begin
+      Put(hex_table(Integer(Shift_Right(value, 4))));
+      Put(hex_table(Integer(value and 16#F#)));
+   end;
+
+   procedure print_array_hex(A : in u8_Array) is
+   begin
+      for i in A'Range loop
+         print_hex(A(i));
+         Put(' ');
+      end loop;
+   end;
+
+   a, b : u8_Array(0 .. 255);
+begin
+   for i in a'Range loop
+      a(i) := u8(i);
+      b(i) := u8(i);
+   end loop;
+
+   print_array_hex(a);
+   New_Line;
+   print_array_hex(b);
+   New_Line;
+   New_Line;
+
+   for i in 1 .. a'Length * u8'Size loop
+      a := Rotate_be(A => a, Amount => 1);
+      Put("a:  ");
+      print_array_hex(a);
+      New_Line;
+      b := Rotate_be(A => b, Amount => i);
+      Put("b:  ");
+      print_array_hex(b);
+      New_Line;
+      if (a /= b) then
+         Put("Error @ i=");
+         Put(i);
+         New_Line;
+      end if;
+      b := Rotate_be(A => b, Amount => -i);
+      Put("b': ");
+      print_array_hex(b);
+      New_Line;
+   end loop;
+
+   New_Line;
+end main;
diff --git a/src/tmp.txt b/src/tmp.txt
new file mode 100644
index 0000000..ffe8a51
--- /dev/null
+++ b/src/tmp.txt
@@ -0,0 +1,351 @@
+   function "xor"(Left, Right : u16_Array) return u16_Array;
+   function "xor"(Left, Right : u32_Array) return u32_Array;
+   function "xor"(Left, Right : u64_Array) return u64_Array;
+
+   -- xor the left element with each element on the right
+   function "xor"(Left : u8;  Right : u8_Array ) return u8;
+   function "xor"(Left : u16; Right : u16_Array) return u16;
+   function "xor"(Left : u32; Right : u32_Array) return u32;
+   function "xor"(Left : u64; Right : u64_Array) return u64;
+
+   -- xor each element on the left with the element on the right
+   function "xor"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "xor"(Left : u16_Array; Right : u16) return u16_Array;
+   function "xor"(Left : u32_Array; Right : u32) return u32_Array;
+   function "xor"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- and each element on the left with the corresponding element on the right
+   function "and"(Left, Right : u8_Array ) return u8_Array;
+   function "and"(Left, Right : u16_Array) return u16_Array;
+   function "and"(Left, Right : u32_Array) return u32_Array;
+   function "and"(Left, Right : u64_Array) return u64_Array;
+
+   -- and the left element with each element on the right
+   function "and"(Left : u8;  Right : u8_Array ) return u8;
+   function "and"(Left : u16; Right : u16_Array) return u16;
+   function "and"(Left : u32; Right : u32_Array) return u32;
+   function "and"(Left : u64; Right : u64_Array) return u64;
+
+   -- and each element on the left with the element on the right
+   function "and"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "and"(Left : u16_Array; Right : u16) return u16_Array;
+   function "and"(Left : u32_Array; Right : u32) return u32_Array;
+   function "and"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- or each element on the left with the corresponding element on the right
+   function "or"(Left, Right : u8_Array ) return u8_Array;
+   function "or"(Left, Right : u16_Array) return u16_Array;
+   function "or"(Left, Right : u32_Array) return u32_Array;
+   function "or"(Left, Right : u64_Array) return u64_Array;
+
+   -- or the left element with each element on the right
+   function "or"(Left : u8;  Right : u8_Array ) return u8;
+   function "or"(Left : u16; Right : u16_Array) return u16;
+   function "or"(Left : u32; Right : u32_Array) return u32;
+   function "or"(Left : u64; Right : u64_Array) return u64;
+
+   -- or each element on the left with the element on the right
+   function "or"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "or"(Left : u16_Array; Right : u16) return u16_Array;
+   function "or"(Left : u32_Array; Right : u32) return u32_Array;
+   function "or"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- add each element on the left with the corresponding element on the right
+   function "+"(Left, Right : u8_Array ) return u8_Array;
+   function "+"(Left, Right : u16_Array) return u16_Array;
+   function "+"(Left, Right : u32_Array) return u32_Array;
+   function "+"(Left, Right : u64_Array) return u64_Array;
+
+   -- add the left element with each element on the right
+   function "+"(Left : u8;  Right : u8_Array ) return u8;
+   function "+"(Left : u16; Right : u16_Array) return u16;
+   function "+"(Left : u32; Right : u32_Array) return u32;
+   function "+"(Left : u64; Right : u64_Array) return u64;
+
+   -- add each element on the left with the element on the right
+   function "+"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "+"(Left : u16_Array; Right : u16) return u16_Array;
+   function "+"(Left : u32_Array; Right : u32) return u32_Array;
+   function "+"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- subtract from each element on the left the corresponding element on the right
+   function "-"(Left, Right : u8_Array ) return u8_Array;
+   function "-"(Left, Right : u16_Array) return u16_Array;
+   function "-"(Left, Right : u32_Array) return u32_Array;
+   function "-"(Left, Right : u64_Array) return u64_Array;
+
+   -- subtract from the left element each element on the right
+   function "-"(Left : u8;  Right : u8_Array ) return u8;
+   function "-"(Left : u16; Right : u16_Array) return u16;
+   function "-"(Left : u32; Right : u32_Array) return u32;
+   function "-"(Left : u64; Right : u64_Array) return u64;
+
+   -- subtract from each element on the left the element on the right
+   function "-"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "-"(Left : u16_Array; Right : u16) return u16_Array;
+   function "-"(Left : u32_Array; Right : u32) return u32_Array;
+   function "-"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- rotate the whole Array as continues big-endian integer; positive Amount rotates left (towards lower address)
+   function Rotate_be is new Rotate_be(u8, u8_Array, u8_Array_Access);
+
+
+   --function Rotate_be(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Rotate_be(A : u16_Array; Amount : Integer) return u16_Array;
+   function Rotate_be(A : u32_Array; Amount : Integer) return u32_Array;
+   function Rotate_be(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- rotate the whole Array as continues little-endian integer; positive Amount rotates left (towards higher address)
+   function Rotate_le(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Rotate_le(A : u16_Array; Amount : Integer) return u16_Array;
+   function Rotate_le(A : u32_Array; Amount : Integer) return u32_Array;
+   function Rotate_le(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- rotate each element by Amount to the left; negative values for Amount rotate to the right
+   function Rotate_each(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Rotate_each(A : u16_Array; Amount : Integer) return u16_Array;
+   function Rotate_each(A : u32_Array; Amount : Integer) return u32_Array;
+   function Rotate_each(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- -----
+
+   -- shift the whole Array as continues big-endian integer; positive Amount shifts left (towards lower address)
+   function Shift_be(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Shift_be(A : u16_Array; Amount : Integer) return u16_Array;
+   function Shift_be(A : u32_Array; Amount : Integer) return u32_Array;
+   function Shift_be(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- -----
+
+   -- Shift the whole Array as continues little-endian integer; positive Amount shifts left (towards higher address)
+   function Shift_le(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Shift_le(A : u16_Array; Amount : Integer) return u16_Array;
+   function Shift_le(A : u32_Array; Amount : Integer) return u32_Array;
+   function Shift_le(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- -----
+
+   -- shift each element by Amount to the left; negative values for Amount shift to the right
+   function Shift_each(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Shift_each(A : u16_Array; Amount : Integer) return u16_Array;
+   function Shift_each(A : u32_Array; Amount : Integer) return u32_Array;
+   function Shift_each(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- -----
+
+   -- load a value which is stored big-endian in byte Array
+   function Load_be(a : u8_Array) return u8;
+   function Load_be(a : u8_Array) return u16;
+   function Load_be(a : u8_Array) return u32;
+   function Load_be(a : u8_Array) return u64;
+
+   -- load a value which is stored little-endian in byte Array
+   function Load_le(a : u8_Array) return u8;
+   function Load_le(a : u8_Array) return u16;
+   function Load_le(a : u8_Array) return u32;
+   function Load_le(a : u8_Array) return u64;
+
+   -- -----
+
+   -- store a value in big-endian format in a byte Array
+   procedure Store_be(a : in out u8_Array; value : in u8);
+   procedure Store_be(a : in out u8_Array; value : in u16);
+   procedure Store_be(a : in out u8_Array; value : in u32);
+   procedure Store_be(a : in out u8_Array; value : in u64);
+
+   -- store a value in little-endian format in a byte Array
+   procedure Store_le(a : in out u8_Array; value : in u8);
+   procedure Store_le(a : in out u8_Array; value : in u16);
+   procedure Store_le(a : in out u8_Array; value : in u32);
+   procedure Store_le(a : in out u8_Array; value : in u64);
+   
+   #################################################################################################################################
+   #################################################################################################################################
+   #################################################################################################################################
+   #################################################################################################################################
+   #################################################################################################################################
+   
+      -- --------------------------
+   -- - Functions / Procedures -
+   -- --------------------------
+
+   -- xor each element on the left with the corresponding element on the right
+   function "xor"(Left, Right : u8_Array ) return u8_Array;
+   function "xor"(Left, Right : u16_Array) return u16_Array;
+   function "xor"(Left, Right : u32_Array) return u32_Array;
+   function "xor"(Left, Right : u64_Array) return u64_Array;
+
+   -- xor the left element with each element on the right
+   function "xor"(Left : u8;  Right : u8_Array ) return u8;
+   function "xor"(Left : u16; Right : u16_Array) return u16;
+   function "xor"(Left : u32; Right : u32_Array) return u32;
+   function "xor"(Left : u64; Right : u64_Array) return u64;
+
+   -- xor each element on the left with the element on the right
+   function "xor"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "xor"(Left : u16_Array; Right : u16) return u16_Array;
+   function "xor"(Left : u32_Array; Right : u32) return u32_Array;
+   function "xor"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- and each element on the left with the corresponding element on the right
+   function "and"(Left, Right : u8_Array ) return u8_Array;
+   function "and"(Left, Right : u16_Array) return u16_Array;
+   function "and"(Left, Right : u32_Array) return u32_Array;
+   function "and"(Left, Right : u64_Array) return u64_Array;
+
+   -- and the left element with each element on the right
+   function "and"(Left : u8;  Right : u8_Array ) return u8;
+   function "and"(Left : u16; Right : u16_Array) return u16;
+   function "and"(Left : u32; Right : u32_Array) return u32;
+   function "and"(Left : u64; Right : u64_Array) return u64;
+
+   -- and each element on the left with the element on the right
+   function "and"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "and"(Left : u16_Array; Right : u16) return u16_Array;
+   function "and"(Left : u32_Array; Right : u32) return u32_Array;
+   function "and"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- or each element on the left with the corresponding element on the right
+   function "or"(Left, Right : u8_Array ) return u8_Array;
+   function "or"(Left, Right : u16_Array) return u16_Array;
+   function "or"(Left, Right : u32_Array) return u32_Array;
+   function "or"(Left, Right : u64_Array) return u64_Array;
+
+   -- or the left element with each element on the right
+   function "or"(Left : u8;  Right : u8_Array ) return u8;
+   function "or"(Left : u16; Right : u16_Array) return u16;
+   function "or"(Left : u32; Right : u32_Array) return u32;
+   function "or"(Left : u64; Right : u64_Array) return u64;
+
+   -- or each element on the left with the element on the right
+   function "or"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "or"(Left : u16_Array; Right : u16) return u16_Array;
+   function "or"(Left : u32_Array; Right : u32) return u32_Array;
+   function "or"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- add each element on the left with the corresponding element on the right
+   function "+"(Left, Right : u8_Array ) return u8_Array;
+   function "+"(Left, Right : u16_Array) return u16_Array;
+   function "+"(Left, Right : u32_Array) return u32_Array;
+   function "+"(Left, Right : u64_Array) return u64_Array;
+
+   -- add the left element with each element on the right
+   function "+"(Left : u8;  Right : u8_Array ) return u8;
+   function "+"(Left : u16; Right : u16_Array) return u16;
+   function "+"(Left : u32; Right : u32_Array) return u32;
+   function "+"(Left : u64; Right : u64_Array) return u64;
+
+   -- add each element on the left with the element on the right
+   function "+"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "+"(Left : u16_Array; Right : u16) return u16_Array;
+   function "+"(Left : u32_Array; Right : u32) return u32_Array;
+   function "+"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- subtract from each element on the left the corresponding element on the right
+   function "-"(Left, Right : u8_Array ) return u8_Array;
+   function "-"(Left, Right : u16_Array) return u16_Array;
+   function "-"(Left, Right : u32_Array) return u32_Array;
+   function "-"(Left, Right : u64_Array) return u64_Array;
+
+   -- subtract from the left element each element on the right
+   function "-"(Left : u8;  Right : u8_Array ) return u8;
+   function "-"(Left : u16; Right : u16_Array) return u16;
+   function "-"(Left : u32; Right : u32_Array) return u32;
+   function "-"(Left : u64; Right : u64_Array) return u64;
+
+   -- subtract from each element on the left the element on the right
+   function "-"(Left : u8_Array;  Right : u8 ) return u8_Array;
+   function "-"(Left : u16_Array; Right : u16) return u16_Array;
+   function "-"(Left : u32_Array; Right : u32) return u32_Array;
+   function "-"(Left : u64_Array; Right : u64) return u64_Array;
+
+   -- -----
+
+   -- rotate the whole Array as continues big-endian integer; positive Amount rotates left (towards lower address)
+   function Rotate_be(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Rotate_be(A : u16_Array; Amount : Integer) return u16_Array;
+   function Rotate_be(A : u32_Array; Amount : Integer) return u32_Array;
+   function Rotate_be(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- rotate the whole Array as continues little-endian integer; positive Amount rotates left (towards higher address)
+   function Rotate_le(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Rotate_le(A : u16_Array; Amount : Integer) return u16_Array;
+   function Rotate_le(A : u32_Array; Amount : Integer) return u32_Array;
+   function Rotate_le(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- rotate each element by Amount to the left; negative values for Amount rotate to the right
+   function Rotate_each(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Rotate_each(A : u16_Array; Amount : Integer) return u16_Array;
+   function Rotate_each(A : u32_Array; Amount : Integer) return u32_Array;
+   function Rotate_each(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- -----
+
+   -- shift the whole Array as continues big-endian integer; positive Amount shifts left (towards lower address)
+   function Shift_be(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Shift_be(A : u16_Array; Amount : Integer) return u16_Array;
+   function Shift_be(A : u32_Array; Amount : Integer) return u32_Array;
+   function Shift_be(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- -----
+
+   -- Shift the whole Array as continues little-endian integer; positive Amount shifts left (towards higher address)
+   function Shift_le(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Shift_le(A : u16_Array; Amount : Integer) return u16_Array;
+   function Shift_le(A : u32_Array; Amount : Integer) return u32_Array;
+   function Shift_le(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- -----
+
+   -- shift each element by Amount to the left; negative values for Amount shift to the right
+   function Shift_each(A : u8_Array;  Amount : Integer) return u8_Array;
+   function Shift_each(A : u16_Array; Amount : Integer) return u16_Array;
+   function Shift_each(A : u32_Array; Amount : Integer) return u32_Array;
+   function Shift_each(A : u64_Array; Amount : Integer) return u64_Array;
+
+   -- -----
+
+   -- load a value which is stored big-endian in byte Array
+   function Load_be(a : u8_Array) return u8;
+   function Load_be(a : u8_Array) return u16;
+   function Load_be(a : u8_Array) return u32;
+   function Load_be(a : u8_Array) return u64;
+
+   -- load a value which is stored little-endian in byte Array
+   function Load_le(a : u8_Array) return u8;
+   function Load_le(a : u8_Array) return u16;
+   function Load_le(a : u8_Array) return u32;
+   function Load_le(a : u8_Array) return u64;
+
+   -- -----
+
+   -- store a value in big-endian format in a byte Array
+   procedure Store_be(a : in out u8_Array; value : in u8);
+   procedure Store_be(a : in out u8_Array; value : in u16);
+   procedure Store_be(a : in out u8_Array; value : in u32);
+   procedure Store_be(a : in out u8_Array; value : in u64);
+
+   -- store a value in little-endian format in a byte Array
+   procedure Store_le(a : in out u8_Array; value : in u8);
+   procedure Store_le(a : in out u8_Array; value : in u16);
+   procedure Store_le(a : in out u8_Array; value : in u32);
+   procedure Store_le(a : in out u8_Array; value : in u64);
+   
\ No newline at end of file
diff --git a/steelcrypt.gpr b/steelcrypt.gpr
new file mode 100644
index 0000000..edc5868
--- /dev/null
+++ b/steelcrypt.gpr
@@ -0,0 +1,45 @@
+project Steelcrypt is
+
+   type Build_Modes is
+      ("Release", "Debug");
+   Mode : Build_Modes := external ("BUILD", "Debug");
+   for Main use ("main.adb");
+   for Source_Dirs use ("src/**");
+
+   case Mode is
+
+      when "Debug" =>
+         for Object_Dir use "obj_debug";
+
+      when "Release" =>
+         for Object_Dir use "obj_release";
+   end case;
+
+   package Compiler is
+
+      case Mode is
+
+         when "Debug" =>
+            for Default_Switches ("ada") use ("-g", "-gnato", "-gnatwa", "-gnatQ", "-gnat05");
+
+         when "Release" =>
+            for Default_Switches ("ada") use ("-gnatQ", "-gnatn", "-O2", "-gnat05");
+      end case;
+   end Compiler;
+
+   package Builder is
+
+      case Mode is
+
+         when "Debug" =>
+            for Default_Switches ("ada") use ("-g");
+
+         when "Release" =>
+            for Default_Switches ("ada") use ();
+      end case;
+   end Builder;
+
+   package Ide is
+   end Ide;
+
+end Steelcrypt;