diff options
Diffstat (limited to 'src/crypto-types.ads')
| -rw-r--r-- | src/crypto-types.ads | 357 |
1 files changed, 357 insertions, 0 deletions
diff --git a/src/crypto-types.ads b/src/crypto-types.ads new file mode 100644 index 0000000..ebcd6dc --- /dev/null +++ b/src/crypto-types.ads @@ -0,0 +1,357 @@ +-- 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; |