diff options
Diffstat (limited to 'src/crypto-types.adb')
| -rw-r--r-- | src/crypto-types.adb | 944 |
1 files changed, 944 insertions, 0 deletions
diff --git a/src/crypto-types.adb b/src/crypto-types.adb new file mode 100644 index 0000000..ac9afc2 --- /dev/null +++ b/src/crypto-types.adb @@ -0,0 +1,944 @@ +-- 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. + +with Ada.Unchecked_Conversion; + +--pragma Elaborate_All(Generic_Mod_Aux); + +package body Crypto.Types is + + package body Generic_Mod_Aux is + function "xor"(Left, Right : T_A) return T_A is + Result : T_A(0..Left'Length-1); + begin + if Left'Length /= Right'Length then + raise Constraint_Error; + end if; + for I in 0..Left'Length-1 loop + Result(I) := Left(Left'First+I) xor Right(Right'First+I); + end loop; + return Result; + end "xor"; + + ------------------------------------------------------------------------ + + function "xor"(Left : T_A; Right : T) return T_A is + Result : T_A := Left; + begin + Result(Result'Last) := Left(Result'Last) xor Right; + return Result; + end "xor"; + + ------------------------------------------------------------------------ + + function "xor"(Left : T; Right : T_A) return T_A is + begin + return Right xor Left; + end "xor"; + + + ------------------------------------------------------------------------ + + function "and"(Left, Right : T_A) return T_A is + Result : T_A(0..Left'Length-1); + begin + + if Left'Length /= Right'Length then + raise Constraint_Error; + end if; + for I in 0..Left'Length-1 loop + Result(I) := Left(Left'First+I) and Right(Right'First+I); + end loop; + return Result; + end "and"; + + ------------------------------------------------------------------------ + function "+"(Left : T_A; Right : T) return T_A is + Result: T_A(Left'Range) := Left; + begin + Result(Left'Last) := Left(Left'Last) + Right; + + -- overflow? + if Result(Left'Last) < Left(Left'Last) then + for I in reverse Left'First..Left'Last-1 loop + Result(I):=Result(I)+1; + if Result(I) /= 0 then + return Result; + end if; + end loop; + end if; + return Result; + end "+"; + + + ------------------------------------------------------------------------ + function "+"(Left : T; Right : T_A) return T_A is + begin + return Right + Left; + end "+"; + ------------------------------------------------------------------------ + + function Is_Zero(Item : T_A) return Boolean is + begin + for I in Item'Range loop + if Item(I) /= 0 then return False; + end if; + end loop; + return True; + end Is_Zero; + +------------------------------------------------------------------------ + + function Left_Part(Block : in T_A) return T_A is + Len : constant Natural := ((Block'Length+1)/2)-1; + Left : constant T_A(0..Len) := Block(Block'First..(Block'First+Len)); + begin + return Left; + end Left_Part; + + ------------------------------------------------------------------------ + + function Right_Part(Block : in T_A) return T_A is + Len : constant Natural := Block'Length/2; + Right : constant T_A(0..Len-1) := Block(Block'Last-Len+1..Block'Last); + begin + return Right; + end Right_Part; + + ------------------------------------------------------------------------ + + function Shift_Left(Value : T_A; Amount : Natural) return T_A is + Result : T_A(Value'Range) := (others => 0); + L : constant Natural := Amount mod T'Size; + M : constant Natural := Value'First+(Amount/T'Size); + begin + if Amount >= Value'Size then + return Result; + elsif Amount = 0 then + return Value; + end if; + Result(Value'Last-M) := Shift_Left(Value(Value'Last),L); + + for I in reverse Value'First..Value'Last-(M+1) loop + Result(I) := Shift_Left(Value(I),L) + xor Shift_Right(Value(I+1),T'Size-L); + end loop; + return Result; + end Shift_Left; + ------------------------------------------------------------------------- + function Shift_Right(Value : T_A; Amount : Natural) return T_A is + Result : T_A(Value'Range) := (others => 0); + L : constant Natural := Amount mod T'Size; + M : constant Natural := Value'First+(Amount/T'Size); + begin + if Amount >= Value'Size then + return Result; + elsif Amount = 0 then + return Value; + end if; + Result(Value'Last-M) := Shift_Right(Value(Value'Last),L); + + for I in reverse Value'First..Value'Last-(M+1) loop + Result(I) := Shift_Right(Value(I),L) + xor Shift_Left(Value(I+1),T'Size-L); + end loop; + return Result; + end Shift_Right; + + end Generic_Mod_Aux; + + + function Cast is new Ada.Unchecked_Conversion (Byte_Word, Word); + function Cast is new Ada.Unchecked_Conversion (Word, Byte_Word); + function DCast is new Ada.Unchecked_Conversion (Byte_DWord, DWord); + function DCast is new Ada.Unchecked_Conversion (DWord, Byte_DWord); + pragma Inline (Cast, DCast); + + + package Aux_Byte is new Generic_Mod_Aux(Byte,Bytes); + package Aux_Word is new Generic_Mod_Aux(Word,Words); + package Aux_DWord is new Generic_Mod_Aux(Dword,DWords); + + --------------------------------------------------------------------------- + + function To_Word(A,B,C,D : Character) return Word is + begin + return Cast((Byte(Character'Pos(D)), Byte(Character'Pos(C)), + Byte(Character'Pos(B)), Byte(Character'Pos(A)))); + end To_Word; + + --------------------------------------------------------------------------- + + function To_Word(A,B,C,D : Byte) return Word is + begin + return Cast((D, C, B, A)); + end To_Word; + + --------------------------------------------------------------------------- + + function To_Word (X : Byte_Word) return Word is + begin + return Cast((X(3), X(2), X(1), X(0))); + end To_Word; + + --------------------------------------------------------------------------- + + function R_To_Word (X : Byte_Word) return Word is + begin + return Cast(X); + end R_To_Word; + + --------------------------------------------------------------------------- + + function To_Bytes (X : Word) return Byte_Word is + begin + return (Cast(X)(3), Cast(X)(2), Cast(X)(1), Cast(X)(0)); + end To_Bytes; + + --------------------------------------------------------------------------- + + function R_To_Bytes (X : Word) return Byte_Word is + begin + return Cast(X); + end R_To_Bytes; + + --------------------------------------------------------------------------- + + function Byte0 (W : Word) return Byte is + begin + return Cast(W)(3); + end Byte0; + + --------------------------------------------------------------------------- + + function Byte1 (W : Word) return Byte is + begin + return Cast(W)(2); + end Byte1; + + --------------------------------------------------------------------------- + + function Byte2 (W : Word) return Byte is + begin + return Cast(W)(1); + end Byte2; + + --------------------------------------------------------------------------- + + function Byte3 (W : Word) return Byte is + begin + return Cast(W)(0); + end Byte3; + + --------------------------------------------------------------------------- + + function To_DWord (X : Byte_DWord) return DWord is + begin + return DCast((X(7), X(6), X(5), X(4), X(3), X(2), X(1), X(0))); + end To_DWord; + + --------------------------------------------------------------------------- + + function R_To_DWord (X : Byte_DWord) return DWord is + begin + return DCast(X); + end R_To_DWord; + + --------------------------------------------------------------------------- + + function To_Bytes (X : DWord) return Byte_DWord is + begin + return (DCast(X)(7), DCast(X)(6), DCast(X)(5), DCast(X)(4), + DCast(X)(3), DCast(X)(2), DCast(X)(1), DCast(X)(0)); + + end To_Bytes; + + --------------------------------------------------------------------------- + + function R_To_Bytes (X : DWord) return Byte_DWord is + begin + return DCast(X); + end R_To_Bytes; + + --------------------------------------------------------------------------- + + function Byte0 (D : DWord) return Byte is + begin + return DCast(D)(7); + end Byte0; + + --------------------------------------------------------------------------- + function Byte1 (D : DWord) return Byte is + begin + return DCast(D)(6); + end Byte1; + + --------------------------------------------------------------------------- + + function Byte2 (D : DWord) return Byte is + begin + return DCast(D)(5); + end Byte2; + + --------------------------------------------------------------------------- + + function Byte3 (D : DWord) return Byte is + begin + return DCast(D)(4); + end Byte3; + + --------------------------------------------------------------------------- + + function Byte4 (D : DWord) return Byte is + begin + return DCast(D)(3); + end Byte4; + + --------------------------------------------------------------------------- + + function Byte5 (D : DWord) return Byte is + begin + return DCast(D)(2); + end Byte5; + + --------------------------------------------------------------------------- + + function Byte6 (D : DWord) return Byte is + begin + return DCast(D)(1); + end Byte6; + + --------------------------------------------------------------------------- + + function Byte7 (D : DWord) return Byte is + begin + return DCast(D)(0); + end Byte7; + + --------------------------------------------------------------------------- + + + function "xor"(Left, Right : Bytes) return Bytes is + begin + return Aux_Byte."xor"(Left,Right); + end "xor"; + + --------------------------------------------------------------------------- + + function "xor"(Left : Bytes; Right : Byte) return Bytes is + begin + return Aux_Byte."xor"(Left,Right); + end "xor"; + + --------------------------------------------------------------------------- + + function "+"(Left : Bytes; Right : Byte) return Bytes is + begin + return Aux_Byte."+"(Left,Right); + end "+"; + + --------------------------------------------------------------------------- + + function "+"(Left : Byte; Right : Bytes) return Bytes is + begin + return Right + Left; + end "+"; + + --------------------------------------------------------------------------- + + function "and"(Left, Right : Bytes) return Bytes is + begin + return Aux_Byte."and"(Left,Right); + end "and"; + + --------------------------------------------------------------------------- + --------------------------------------------------------------------------- + + function "xor"(Left, Right : Words) return Words is + begin + return Aux_Word."xor"(Left,Right); + end "xor"; + + --------------------------------------------------------------------------- + + function "+"(Left : Words; Right : Word) return Words is + + begin + return Aux_Word."+"(Left,Right); + end "+"; + + --------------------------------------------------------------------------- + + function "+"(Left : Word; Right : Words) return Words is + begin + return Right + Left; + end "+"; + + --------------------------------------------------------------------------- + + function "+"(Left : Words; Right : Byte) return Words is + Result: Words(Left'Range) := Left; + begin + Result(Left'Last) := Left(Left'Last) + Word(Right); + + -- overflow? + if Result(Left'Last) < Left(Left'Last) then + for I in reverse Left'First..Left'Last-1 loop + Result(I):=Result(I)+1; + if Result(I) /= 0 then + return Result; + end if; + end loop; + end if; + return Result; + end "+"; + + --------------------------------------------------------------------------- + --------------------------------------------------------------------------- + + function "xor"(Left, Right : DWords) return DWords is + begin + return Aux_DWord."xor"(Left,Right); + end "xor"; + + --------------------------------------------------------------------------- + + function "+"(Left : DWords; Right : DWord) return DWords is + begin + return Aux_DWord."+"(Left,Right); + end "+"; + + --------------------------------------------------------------------------- + + function "+"(Left : DWord; Right : DWords) return DWords is + begin + return Right + Left; + end "+"; + + --------------------------------------------------------------------------- + + function "+"(Left : DWords; Right : Byte) return DWords is + Result: DWords(Left'Range) := Left; + begin + Result(Left'Last) := Left(Left'Last) + DWord(Right); + + -- overflow? + if Result(Left'Last) < Left(Left'Last) then + for I in reverse Left'First..Left'Last-1 loop + Result(I):=Result(I)+1; + if Result(I) /= 0 then + return Result; + end if; + end loop; + end if; + return Result; + end "+"; + + --------------------------------------------------------------------------- + + function To_Words(Byte_Array : Bytes) return Words is + L : constant Natural := + Natural(Float'Ceiling(Float(Byte_Array'Length)/4.0))-1; + W : Words(0..L) := (others => 0); + N : Integer := Byte_Array'First; + S : Natural :=24; + begin + + for I in 0..(Byte_Array'Length/4)-1 loop + W(I) := To_Word(Byte_Array(N..N+3)); + N := N+4; + end loop; + + for I in 1..(Byte_Array'Length mod 4) loop + W(L):= W(L) or Shift_Left(Word(Byte_Array(N)),S); + N := N+1; + S := S-8; + end loop; + + return W; + end To_Words; + + --------------------------------------------------------------------------- + + function To_Bytes(Word_Array : Words) return Bytes is + B : Bytes(1..Word_Array'Length*4); + C : Natural := 1; + begin + for I in Word_Array'Range loop + B(C..C+3) := To_Bytes(Word_Array(I)); + C:=C+4; + end loop; + return B; + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_DWords(Byte_Array : Bytes) return DWords is + L : constant Natural := + Natural(Float'Ceiling(Float(Byte_Array'Length)/8.0))-1; + W : DWords(0..L):=(others => 0); + N : Natural := Byte_Array'First; + S : Natural := 56; + begin + + for I in 0..(Byte_Array'Length/8)-1 loop + W(I) := To_DWord(Byte_Array(N..N+7)); + N := N+8; + end loop; + + for I in 1..(Byte_Array'Length mod 8) loop + W(L):= W(L) or Shift_Left(DWord(Byte_Array(N)),S); + N := N+1; + S := S-8; + end loop; + + return W; + end To_DWords; + + --------------------------------------------------------------------------- + + + function To_Bytes(DWord_Array : DWords) return Bytes is + B : Bytes(1..DWord_Array'Length*8); + C : Natural := 1; + begin + for I in DWord_Array'Range loop + B(C..C+7) := To_Bytes(DWord_Array(I)); + C:=C+8; + end loop; + return B; + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Hex(B : Byte) return Hex_Byte is + S : constant String := "0123456789ABCDEF"; + H : Hex_Byte; + begin + H(2) := S(Natural(B and 15)+1); + H(1) := S(Natural(Shift_Right(B,4)+1)); + return H; + end To_Hex; + + --------------------------------------------------------------------------- + + function To_Hex(W : Word) return Hex_Word is + S : constant String := "0123456789ABCDEF"; + H : Hex_Word; + T : Word := W; + begin + for I in reverse H'Range loop + H(I) := S(Natural(T and 15)+1); + T := Shift_Right(T,4); + end loop; + return H; + end To_Hex; + + --------------------------------------------------------------------------- + + + function To_Hex(D : DWord) return Hex_DWord is + S : constant String := "0123456789ABCDEF"; + H : Hex_DWord; + T : DWord := D; + begin + for I in reverse H'Range loop + H(I) := S(Natural(T and 15)+1); + T := Shift_Right(T,4); + end loop; + + return H; + end To_Hex; + + + function Hex_To_Bytes(Hex : String) return Bytes is + Return_Bytes : Bytes(0..Hex'Length/2 -1); + begin + for I in Return_Bytes'Range loop + case Hex(Hex'First + 2*i) is + when '0' => Return_Bytes(i):=16#00#; + when '1' => Return_Bytes(i):=16#01#; + when '2' => Return_Bytes(i):=16#02#; + when '3' => Return_Bytes(i):=16#03#; + when '4' => Return_Bytes(i):=16#04#; + when '5' => Return_Bytes(i):=16#05#; + when '6' => Return_Bytes(i):=16#06#; + when '7' => Return_Bytes(i):=16#07#; + when '8' => Return_Bytes(i):=16#08#; + when '9' => Return_Bytes(i):=16#09#; + when 'A' => Return_Bytes(i):=16#0A#; + when 'B' => Return_Bytes(i):=16#0B#; + when 'C' => Return_Bytes(i):=16#0C#; + when 'D' => Return_Bytes(i):=16#0D#; + when 'E' => Return_Bytes(i):=16#0E#; + when 'F' => Return_Bytes(i):=16#0F#; + when others => null; + end case; + + case Hex(Hex'First + 2*i + 1) is + when '0' => Return_Bytes(i):= Return_Bytes(i) + 16#00#; + when '1' => Return_Bytes(i):= Return_Bytes(i) + 16#10#; + when '2' => Return_Bytes(i):= Return_Bytes(i) + 16#20#; + when '3' => Return_Bytes(i):= Return_Bytes(i) + 16#30#; + when '4' => Return_Bytes(i):= Return_Bytes(i) + 16#40#; + when '5' => Return_Bytes(i):= Return_Bytes(i) + 16#50#; + when '6' => Return_Bytes(i):= Return_Bytes(i) + 16#60#; + when '7' => Return_Bytes(i):= Return_Bytes(i) + 16#70#; + when '8' => Return_Bytes(i):= Return_Bytes(i) + 16#80#; + when '9' => Return_Bytes(i):= Return_Bytes(i) + 16#90#; + when 'A' => Return_Bytes(i):= Return_Bytes(i) + 16#A0#; + when 'B' => Return_Bytes(i):= Return_Bytes(i) + 16#B0#; + when 'C' => Return_Bytes(i):= Return_Bytes(i) + 16#C0#; + when 'D' => Return_Bytes(i):= Return_Bytes(i) + 16#D0#; + when 'E' => Return_Bytes(i):= Return_Bytes(i) + 16#E0#; + when 'F' => Return_Bytes(i):= Return_Bytes(i) + 16#F0#; + when others => null; + end case; + + end loop; + return Return_Bytes; + end Hex_To_Bytes; + + --------------------------------------------------------------------------- + + function Is_Zero(Byte_Array : Bytes) return Boolean is + begin + return Aux_Byte.Is_Zero(Byte_Array); + end Is_Zero; + + --------------------------------------------------------------------------- + + + function Is_Zero(Word_Array : Words) return Boolean is + begin + return Aux_Word.Is_Zero(Word_Array); + end Is_Zero; + + --------------------------------------------------------------------------- + + function Is_Zero(DWord_Array : Dwords) return Boolean is + begin + return Aux_DWord.Is_Zero(DWord_Array); + end Is_Zero; + + --------------------------------------------------------------------------- + --------------------------------------------------------------------------- + --------------------------------------------------------------------------- + + function To_Bytes(Message : String) return Bytes is + B : Bytes(Message'Range); + begin + for I in Message'Range loop + B(I) := Character'Pos(Message(I)); + end loop; + return B; + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_String(ASCII : Bytes) return String is + S : String(1..ASCII'Length); + J : Integer:=1; + begin + for I in ASCII'Range loop + S(J) := Character'Val(ASCII(I)); + J:=J+1; + end loop; + return S; + end To_String; + + --------------------------------------------------------------------------- + + function Left_Part(Block : in Bytes) return Bytes is + begin + return Aux_Byte.Left_Part(Block); + end Left_Part; + + --------------------------------------------------------------------------- + + function Right_Part(Block : in Bytes) return Bytes is + begin + return Aux_Byte.Right_Part(Block); + end Right_Part; + + --------------------------------------------------------------------------- + + function To_Bytes(B : B_Block64) return Bytes is + begin + return Bytes(B); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(B : B_Block128) return Bytes is + begin + return Bytes(B); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(B : B_Block192) return Bytes is + + begin + return Bytes(B); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(B : B_Block256) return Bytes is + begin + return Bytes(B); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(W : W_Block160) return Bytes is + begin + return To_Bytes(Words(W)); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(W : W_Block256) return Bytes is + begin + return To_Bytes(Words(W)); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(W : W_Block512) return Bytes is + begin + return To_Bytes(Words(W)); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(D : DW_Block256) return Bytes is + begin + return To_Bytes(DWords(D)); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(D : DW_Block384) return Bytes is + begin + return To_Bytes(DWords(D)); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(D : DW_Block512) return Bytes is + begin + return To_Bytes(DWords(D)); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(D : DW_Block1024) return Bytes is + begin + return To_Bytes(DWords(D)); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_Bytes(D : DW_Block8192) return Bytes is + begin + return To_Bytes(DWords(D)); + end To_Bytes; + + --------------------------------------------------------------------------- + + function To_B_Block64(B : Bytes) return B_Block64 is + begin + return B_Block64(B); + end To_B_Block64; + + --------------------------------------------------------------------------- + + function To_B_Block128(B : Bytes) return B_Block128 is + begin + return B_Block128(B); + end To_B_Block128; + + --------------------------------------------------------------------------- + + function To_B_Block192(B : Bytes) return B_Block192 is + begin + return B_Block192(B); + end To_B_Block192; + + --------------------------------------------------------------------------- + + function To_B_Block256(B : Bytes) return B_Block256 is + begin + return B_Block256(B); + end To_B_Block256; + + --------------------------------------------------------------------------- + + function To_W_Block160(B : Bytes) return W_Block160 is + begin + return W_Block160(To_Words(B)); + end To_W_Block160; + + --------------------------------------------------------------------------- + + function To_W_Block256(B : Bytes) return W_Block256 is + begin + return W_Block256(To_Words(B)); + end To_W_Block256; + + --------------------------------------------------------------------------- + + function To_W_Block512(B : Bytes) return W_Block512 is + begin + return W_Block512(To_Words(B)); + end To_W_Block512; + + --------------------------------------------------------------------------- + + function To_DW_Block256(B : Bytes) return DW_Block256 is + begin + return DW_Block256(To_DWords(B)); + end To_DW_Block256; + + --------------------------------------------------------------------------- + + function To_DW_Block384(B : Bytes) return DW_Block384 is + begin + return DW_Block384(To_DWords(B)); + end To_DW_Block384; + + --------------------------------------------------------------------------- + + function To_DW_Block512(B : Bytes) return DW_Block512 is + begin + return DW_Block512(To_DWords(B)); + end To_DW_Block512; + + --------------------------------------------------------------------------- + + function To_DW_Block1024(B : Bytes) return DW_Block1024 is + begin + return DW_Block1024(To_DWords(B)); + end To_DW_Block1024; + + --------------------------------------------------------------------------- + + function To_DW_Block8192(B : Bytes) return DW_Block8192 is + begin + return DW_Block8192(To_DWords(B)); + end To_DW_Block8192; + + --------------------------------------------------------------------------- + + function "xor"(Left, Right : W_Block160) return W_Block160 is + begin + return W_Block160(Words(Left) xor Words(Right)); + end "xor"; + --------------------------------------------------------------------------- + + function "xor"(Left, Right : W_Block256) return W_Block256 is + begin + return W_Block256(Words(Left) xor Words(Right)); + end "xor"; + --------------------------------------------------------------------------- + + function "xor"(Left, Right : W_Block512) return W_Block512 is + begin + return W_Block512(Words(Left) xor Words(Right)); + end "xor"; + + --------------------------------------------------------------------------- + + function "xor"(Left, Right : DW_Block512) return DW_Block512 is + begin + return DW_Block512(DWords(Left) xor DWords(Right)); + end "xor"; + + --------------------------------------------------------------------------- + + function "xor"(Left, Right : DW_Block1024) return DW_Block1024 is + begin + return DW_Block1024(DWords(Left) xor DWords(Right)); + end "xor"; + + --------------------------------------------------------------------------- + + function "xor"(Left, Right : DW_Block8192) return DW_Block8192 is + begin + return DW_Block8192(DWords(Left) xor DWords(Right)); + end "xor"; + + --------------------------------------------------------------------------- + + function "xor"(Left, Right : B_Block128) return B_Block128 is + begin + return B_Block128(Bytes(Left) xor Bytes(Right)); + end "xor"; + + --------------------------------------------------------------------------- + + function "xor"(Left, Right : B_Block64) return B_Block64 is + begin + return B_Block64(Bytes(Left) xor Bytes(Right)); + end "xor"; + + --------------------------------------------------------------------------- + + function "+"(Left : B_Block128; Right : Byte) return B_Block128 is + begin + return B_Block128(Bytes(Left) + Right); + end "+"; + + --------------------------------------------------------------------------- + + function Shift_Left(Value : Bytes; Amount : Natural) return Bytes is + begin + return Aux_Byte.Shift_Left(Value,Amount); + end Shift_Left; + + --------------------------------------------------------------------------- + + function Shift_Left(Value : B_Block128; Amount :Natural) return B_Block128 is + begin + return B_Block128(Aux_Byte.Shift_Left(Bytes(Value),Amount)); + end Shift_Left; + + ---------------------------------------------------------------------------- + + function Shift_Right(Value : Bytes; Amount : Natural) return Bytes is + begin + return Aux_Byte.Shift_Right(Value,Amount); + end Shift_Right; + + --------------------------------------------------------------------------- + + function Shift_Right(Value : B_Block128; Amount :Natural)return B_Block128 is + begin + return B_Block128(Aux_Byte.Shift_Right(Bytes(Value),Amount)); + end Shift_Right; + + + + + end Crypto.Types; |