path: root/src/crypto-types.ads

-- 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 2 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, write to the Free Software
-- Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-- 02111-1307, USA.

-- As a special exception, if other files instantiate generics from
-- this unit, or you link this unit with other files to produce an
-- executable, this unit does not by itself cause the resulting
-- executable to be covered by the GNU General Public License. This
-- exception does not however invalidate any other reasons why the
-- executable file might be covered by the GNU Public License.

package Crypto.Types is

   ---------------------------------------------------------------------------
   ---------------------------TYPES-------------------------------------------
   ---------------------------------------------------------------------------

   -- primary types;

   type Bit is mod 2;
   for Bit'Size use 1;

   type Byte  is mod 2 ** 8;
   for Byte'Size use 8;

   type DByte  is mod 2 ** 16;
   for DByte'Size use 16;

   type TByte is mod 2 ** 24 with Size => 24;

   type Word is mod 2 ** 32;
   for Word'Size use 32;

   type DWord is mod 2 ** 64;
   for DWord'Size use 64;

   --package BIO is new Ada.Text_Io.Modular_IO (Byte);
   --package WIO is new Ada.Text_Io.Modular_IO (Word);
   --package DIO is new Ada.Text_Io.Modular_IO (DWord);

   -- Arrays of primary types
   type Bits   is array (Integer range <>) of Bit;
   type Bytes  is array (Integer range <>) of Byte;
   type DBytes is array (Integer range <>) of DByte;
   type Words  is array (Integer range <>) of Word;
   type DWords is array (Integer range <>) of DWord;

   subtype Byte_Word_Range  is Natural range 0..3;
   subtype Byte_DWord_Range is Natural range 0..7;

   subtype Byte_Word  is Bytes (Byte_Word_Range);
   subtype Byte_DWord is Bytes (Byte_DWord_Range);

   -- N :  #bits
   -- byte-blocks (B_BlockN): array of N/8 bytes
   subtype B_Block32_Range  is Natural range 0..3;
   subtype B_Block48_Range  is Natural range 0..5;
   subtype B_Block56_Range  is Natural range 0..6;
   subtype B_Block64_Range  is Natural range 0..7;
   subtype B_Block128_Range is Natural range 0..15;
   subtype B_Block160_Range is Natural range 0..19;
   subtype B_Block192_Range is Natural range 0..23;
   subtype B_Block256_Range is Natural range 0..31;

   type B_Block32  is array(B_Block32_Range)  of Byte;
   type B_Block48  is array(B_Block48_Range)  of Byte;
   type B_Block56  is array(B_Block56_Range)  of Byte;
   type B_Block64  is array(B_Block64_Range)  of Byte;
   type B_Block128 is array(B_Block128_Range) of Byte;
   type B_Block160 is array(B_Block160_Range) of Byte;
   type B_Block192 is array(B_Block192_Range) of Byte;
   type B_Block256 is array(B_Block256_Range) of Byte;


   -- word blocks (W_BlockN): array of N/32 Words
   subtype W_Block128_Range is Natural range 0..3;
   subtype W_Block160_Range is Natural range 0..4;
   subtype W_Block192_Range is Natural range 0..5;
   subtype W_Block256_Range is Natural range 0..7;
   subtype W_Block512_Range is Natural range 0..15;

   type W_Block128 is array(W_Block128_Range) of Word;
   type W_Block160 is array(W_Block160_Range) of Word;
   type W_Block192 is array(W_Block192_Range) of Word;
   type W_Block256 is array(W_Block256_Range) of Word;
   type W_Block512 is array(W_Block512_Range) of Word;


   -- double wordblocks (DW_BlockN): array of N/64 Words
   subtype DW_Block128_Range  is Natural range 0..1;
   subtype DW_Block256_Range  is Natural range 0..3;
   subtype DW_Block384_Range  is Natural range 0..5;
   subtype DW_Block512_Range  is Natural range 0..7;
   subtype DW_Block1024_Range is Natural range 0..15;
   subtype DW_Block8192_Range is Natural range 0..127;

   type DW_Block128   is array(DW_Block128_Range) of DWord;
   type DW_Block256   is array(DW_Block256_Range)  of DWord;
   type DW_Block384   is array(DW_Block384_Range)  of DWord;
   type DW_Block512   is array(DW_Block512_Range)  of DWord;
   type DW_Block1024  is array(DW_Block1024_Range) of DWord;
   type DW_Block8192  is array(DW_Block8192_Range) of DWord;


   subtype Hex_Byte_Range   is Natural range 1..2;
   subtype Hex_Word_Range   is Natural range 1..8;
   subtype Hex_DWord_Range  is Natural range 1..16;


   subtype Hex_Byte  is String (Hex_Byte_Range);
   subtype Hex_Word  is String (Hex_Word_Range);
   subtype Hex_DWord is String (Hex_DWord_Range);

   subtype Message_Block_Length256  is Natural range 0 ..  32;
   subtype Message_Block_Length512  is Natural range 0 ..  64;
   subtype Message_Block_Length1024 is Natural range 0 .. 128;







   ---------------------------------------------------------------------------
   ---------------------------FUNCTIONS---------------------------------------
   ---------------------------------------------------------------------------

   function Shift_Left   (Value : Byte; Amount : Natural) return Byte;
   function Shift_Right  (Value : Byte; Amount : Natural) return Byte;
   function Rotate_Left  (Value : Byte; Amount : Natural) return Byte;
   function Rotate_Right (Value : Byte; Amount : Natural) return Byte;

   function Shift_Left   (Value : DByte; Amount : Natural) return DByte;
   function Shift_Right  (Value : DByte; Amount : Natural) return DByte;
   function Rotate_Left  (Value : DByte; Amount : Natural) return DByte;
   function Rotate_Right (Value : DByte; Amount : Natural) return DByte;

   function Shift_Left   (Value : Word; Amount : Natural) return Word;
   function Shift_Right  (Value : Word; Amount : Natural) return Word;
   function Rotate_Left  (Value : Word; Amount : Natural) return Word;
   function Rotate_Right (Value : Word; Amount : Natural) return Word;

   function Shift_Left   (Value : DWord; Amount : Natural) return DWord;
   function Shift_Right  (Value : DWord; Amount : Natural) return DWord;
   function Rotate_Left  (Value : DWord; Amount : Natural) return DWord;
   function Rotate_Right (Value : DWord; Amount : Natural) return DWord;

   pragma Import (Intrinsic, Shift_Left);
   pragma Import (Intrinsic, Shift_Right);

   function Shift_Left (Value : Bytes; Amount : Natural) return Bytes;
   function Shift_Left (Value : B_Block128; Amount : Natural) return B_Block128;
   function Shift_Right(Value : Bytes; Amount : Natural) return Bytes;
   function Shift_Right(Value : B_Block128; Amount : Natural) return B_Block128;

   --Operations for Bytes
   function "xor"(Left, Right : Bytes)        return Bytes;
   function "xor"(Left : Bytes; Right : Byte) return Bytes;
   function "+"(Left : Bytes; Right : Byte)   return Bytes;
   function "+"(Left : Byte; Right  : Bytes)  return Bytes;
   function "and"(Left, Right : Bytes)        return Bytes;


   -- Operations for Words
   function "xor"(Left, Right : Words)       return Words;
   function "+"(Left : Words; Right : Word)  return Words;
   function "+"(Left : Word; Right  : Words) return Words;
   function "+"(Left : Words; Right : Byte)  return Words;


   -- Operations for DWords
   function "xor"(Left, Right : DWords)        return DWords;
   function "+"(Left : DWords; Right : DWord)  return DWords;
   function "+"(Left : DWord;  Right : DWords) return DWords;
   function "+"(Left : DWords; Right : Byte)   return DWords;

   -- Bytes to Word
   function To_Word (A,B,C,D : Byte) return Word;
   function To_Word   (X : Byte_Word) return Word;
   function R_To_Word (X : Byte_Word) return Word; -- reverse
   function To_Words(Byte_Array : Bytes) return Words;

   -- Word to Bytes
   function To_Bytes (X : Word) return Byte_Word;
   function R_To_Bytes (X : Word) return Byte_Word; --reverse
   function To_Bytes(Word_Array : Words) return Bytes;

   --Word = b_0 b_1 b2 b_3
   -- ByteX returns b_n
   function Byte0 (W : Word) return Byte;
   function Byte1 (W : Word) return Byte;
   function Byte2 (W : Word) return Byte;
   function Byte3 (W : Word) return Byte;

   -- Bytes to DWord
   function To_DWord    (X : Byte_DWord) return DWord;
   function R_To_DWord  (X : Byte_DWord) return DWord;
   function To_DWords   (Byte_Array : Bytes) return DWords;

   -- DWord to Bytes
   function To_Bytes   (X : DWord)            return Byte_DWord;
   function R_To_Bytes (X : DWord)            return Byte_DWord;
   function To_Bytes   (DWord_Array : DWords) return Bytes;


   --DWord = b_0 b_1 b2 b_3 b_4 b_5 b_6 b_7
   -- ByteX returns b_n
   function Byte0 (D : DWord) return Byte;
   function Byte1 (D : DWord) return Byte;
   function Byte2 (D : DWord) return Byte;
   function Byte3 (D : DWord) return Byte;
   function Byte4 (D : DWord) return Byte;
   function Byte5 (D : DWord) return Byte;
   function Byte6 (D : DWord) return Byte;
   function Byte7 (D : DWord) return Byte;

   -- To_Word
   function To_Word (A,B,C,D : Character) return Word;

   -- String to Bytes
   function To_Bytes(Message : String) return Bytes;

   -- Bytes to String
   function To_String(ASCII : Bytes) return String;


   -- To_Hex
   function To_Hex(B : Byte)  return Hex_Byte;
   function To_Hex(W : Word)  return Hex_Word;
   function To_Hex(D : DWord) return Hex_DWord;   

   -- To_Bytes
   function Hex_To_Bytes(Hex : String) return Bytes;

   -- Is_Zero
   -- returns only true if the "input array"  X = (others => 0)
   function Is_Zero(Byte_Array  : Bytes)   return Boolean;
   function Is_Zero(Word_Array  : Words)   return Boolean;
   function Is_Zero(DWord_Array : DWords) return Boolean;


   -- Byte Blocks To Bytes.
   -- Needed for generic packages to convert a specific byte block.
   function To_Bytes(B : B_Block64)  return Bytes;
   function To_Bytes(B : B_Block128) return Bytes;
   function To_Bytes(B : B_Block192) return Bytes;
   function To_Bytes(B : B_Block256) return Bytes;
   function To_Bytes(W : W_Block160) return Bytes;
   function To_Bytes(W : W_Block256) return Bytes;
   function To_Bytes(W : W_Block512) return Bytes;
   function To_Bytes(D : DW_Block256) return Bytes;
   function To_Bytes(D : DW_Block384) return Bytes;
   function To_Bytes(D : DW_Block512) return Bytes;
   function To_Bytes(D : DW_Block1024) return Bytes;
   function To_Bytes(D : DW_Block8192) return Bytes;


   -- Bytes To block of Bytes.
   -- Needed for generic packages to convert a specific byte block.
   function To_B_Block64(B : Bytes) return B_Block64;
   function To_B_Block128(B : Bytes) return B_Block128;
   function To_B_Block192(B : Bytes) return B_Block192;
   function To_B_Block256(B : Bytes) return B_Block256;


   -- Bytes To block of words.
   -- Needed for generic packages to convert a specific byte block.
   function To_W_Block160(B : Bytes) return W_Block160;
   function To_W_Block256(B : Bytes) return W_Block256;
   function To_W_Block512(B : Bytes) return W_Block512;


   -- Bytes To block of double words.
   -- Needed for generic packages to convert a specific byte block.
   function To_DW_Block256(B : Bytes) return DW_Block256;
   function To_DW_Block384(B : Bytes) return DW_Block384;
   function To_DW_Block512(B : Bytes) return DW_Block512;
   function To_DW_Block1024(B : Bytes) return DW_Block1024;
   function To_DW_Block8192(B : Bytes) return DW_Block8192;

   -- Needed for generic packages to convert a specific byte block.
   function "xor"(Left, Right : B_Block64)    return   B_Block64;
   function "xor"(Left, Right : B_Block128)   return   B_Block128;
   function "xor"(Left, Right : W_Block160)   return   W_Block160;
   function "xor"(Left, Right : W_Block256)   return   W_Block256;
   function "xor"(Left, Right : W_Block512)   return   W_Block512;
   function "xor"(Left, Right : DW_Block512)  return  DW_Block512;
   function "xor"(Left, Right : DW_Block1024) return  DW_Block1024;
   function "xor"(Left, Right : DW_Block8192) return  DW_Block8192;

   function "+"(Left : B_Block128; Right : Byte) return B_Block128;


   -- Splits  byte array of length n into a left part of length
   -- ceiling(n/2) and a right part of length floor(n/2).
   function Left_Part(Block : in Bytes)  return Bytes;
   function Right_Part(Block : in Bytes) return Bytes;



   -- Nested generic package
   generic
      type T is mod <>;
      type T_A is array (Integer range <>) of T;
      with function Shift_Left  (Value : T; Amount : Natural) return T is <>;
      with function Shift_Right (Value : T; Amount : Natural) return T is <>;

   package Generic_Mod_Aux is
      function "xor"(Left, Right : T_A)      return T_A;
      function "xor"(Left : T_A; Right  : T) return T_A;
      function "xor"(Left : T; Right : T_A)  return T_A;

      function "and"(Left, Right : T_A)      return T_A;

      function "+"(Left : T_A; Right : T) return T_A;
      function "+"(Left : T; Right : T_A) return T_A;

      function Is_Zero(Item : T_A) return Boolean;

      function Left_Part (Block : in T_A) return T_A;
      function Right_Part(Block : in T_A) return T_A;

      function Shift_Left(Value : T_A;  Amount : Natural) return T_A;
      function Shift_Right(Value : T_A;  Amount : Natural) return T_A;
   end Generic_Mod_Aux;



   ---------------------------------------------------------------------------
   -------------------------------PRIVATE-------------------------------------
   ---------------------------------------------------------------------------

private
   pragma Inline (To_B_Block128,To_B_Block192,To_B_Block256);
   pragma Inline ("xor","+");
   pragma Inline (R_To_Bytes, To_Bytes);
   pragma Inline (To_Word, Byte0, Byte1, Byte2, Byte3);
   pragma Inline (Byte4, Byte5, Byte6, Byte7);
   pragma Inline (To_DWord, R_To_DWord);
   pragma Inline (Is_Zero);
   pragma Inline (Left_Part, Right_Part);
   pragma Import (Intrinsic, Rotate_Left);
   pragma Import (Intrinsic, Rotate_Right);

   pragma Optimize(Time);
end Crypto.Types;