smg_comms_skeys_s...  -- Message reader & writers for SMG Communication Protocol
smg_comms_skeys_s...  -- S.MG, 2018
smg_comms_skeys_s... 
smg_comms_skeys_s... with Interfaces; use Interfaces;
smg_comms_skeys_s... with Serpent;
smg_comms_skeys_s... with System; use System;
smg_comms_files      with Ada.Assertions; use Ada.Assertions;
smg_comms_skeys_s... 
smg_comms_skeys_s... package body Messages is
smg_comms_skeys_s... 
smg_comms_keymgm       ----------------------
smg_comms_keymgm       -- Serpent Messages --
smg_comms_keymgm       ----------------------
smg_comms_keymgm     
smg_comms_skeys_s...   procedure Write_SKeys_SMsg( Keyset  : in Serpent_Keyset;
smg_comms_skeys_s...                               Counter : in Interfaces.Unsigned_16;
smg_comms_skeys_s...                               Msg     : out Raw_Types.Serpent_Msg) is
smg_comms_keymgm       begin
smg_comms_keymgm         -- call internal write on Octets with correct type id
smg_comms_keymgm         Write_SKeys( Keyset, Counter, SKeys_S_Type, Msg );
smg_comms_keymgm       end Write_SKeys_SMsg;
smg_comms_keymgm     
smg_comms_keymgm     
smg_comms_keymgm       -- Reads a Serpent keyset from given Serpent Message
smg_comms_keymgm       procedure Read_SKeys_SMsg( Msg     : in Raw_Types.Serpent_Msg;
smg_comms_keymgm                                  Counter : out Interfaces.Unsigned_16;
smg_comms_keymgm                                  Keyset  : out Serpent_Keyset) is
smg_comms_keymgm       begin
smg_comms_keymgm         -- check type id and call internal Read_SKeys if correct
smg_comms_keymgm         if Msg(Msg'First) /= SKeys_S_Type then
smg_comms_keymgm           raise Invalid_Msg;
smg_comms_keymgm         else
smg_comms_keymgm           Read_SKeys( Msg, Counter, Keyset );
smg_comms_keymgm         end if;
smg_comms_keymgm       end Read_SKeys_SMsg;
smg_comms_keymgm     
smg_comms_keymgm       -- writes given key mgm structure into a Serpent message
smg_comms_keymgm       procedure Write_KMgm_SMsg( KMgm    : in Keys_Mgm;
smg_comms_keymgm                                  Counter : in Interfaces.Unsigned_16;
smg_comms_keymgm                                  Msg     : out Raw_Types.Serpent_Msg) is
smg_comms_keymgm       begin
smg_comms_keymgm         -- call internal write of key mgm with correct type ID
smg_comms_keymgm         Write_KMgm( KMgm, Counter, Key_Mgm_S_Type, Msg );
smg_comms_keymgm       end Write_KMgm_SMsg;
smg_comms_keymgm     
smg_comms_keymgm       -- reads a key mgm structure from the given Serpent message
smg_comms_keymgm       procedure Read_KMgm_SMsg( Msg     : in Raw_Types.Serpent_Msg;
smg_comms_keymgm                                 Counter : out Interfaces.Unsigned_16;
smg_comms_keymgm                                 KMgm    : out Keys_Mgm) is
smg_comms_keymgm       begin
smg_comms_keymgm         -- check type id and call internal Read_KMgm if correct
smg_comms_keymgm         if Msg(Msg'First) /= Key_Mgm_S_Type then
smg_comms_keymgm           raise Invalid_Msg;
smg_comms_keymgm         else
smg_comms_keymgm           Read_KMgm( Msg, Counter, KMgm );
smg_comms_keymgm         end if;
smg_comms_keymgm       end Read_KMgm_SMsg;
smg_comms_keymgm     
smg_comms_files        ------ File Transfer ------
smg_comms_files        procedure Write_File_Transfer( Chunk   : in File_Chunk;
smg_comms_files                                       Msg     : out Raw_Types.Serpent_Msg) is
smg_comms_files          Pos: Integer := Msg'First;
smg_comms_files          U16: Interfaces.Unsigned_16;
smg_comms_files        begin
smg_comms_files          -- write type ID
smg_comms_files          Msg(Pos) := File_Transfer_S_Type;
smg_comms_files          Pos := Pos + 1;
smg_comms_files      
smg_comms_files          -- write filename as text field (size+2, text)
smg_comms_files          -- check against overflows
smg_comms_files          if Chunk.Name_Len > Text_Len'Last - 2 or
smg_comms_files             Pos + Integer(Chunk.Name_Len) + 2 > Msg'Last then
smg_comms_files            raise Invalid_Msg;
smg_comms_files          end if;
smg_comms_files      
smg_comms_files          -- write total size: filename size + 2 
smg_comms_files          U16 := Interfaces.Unsigned_16( Chunk.Name_Len + 2 );
smg_comms_files          Write_U16( Msg, Pos, U16 );
smg_comms_files      
smg_comms_files          -- write filename
smg_comms_files          String_To_Octets( Chunk.Filename, 
smg_comms_files                            Msg(Pos..Pos+Integer(Chunk.Name_Len)-1) );
smg_comms_files          Pos := Pos + Integer(Chunk.Name_Len);
smg_comms_files      
smg_comms_files          --write content
smg_comms_files          -- check against overflow, including the 2 octets for counter at the end
smg_comms_files          if Chunk.Len > Text_Len'Last - 2 or
smg_comms_files             Pos + Integer(Chunk.Len) + 4 > Msg'Last then
smg_comms_files            raise Invalid_Msg;
smg_comms_files          end if;
smg_comms_files      
smg_comms_files          -- write total size for this text field
smg_comms_files          U16 := Interfaces.Unsigned_16( Chunk.Len + 2 );
smg_comms_files          Write_U16( Msg, Pos, U16 );
smg_comms_files      
smg_comms_files          -- write actual content
smg_comms_files          Msg(Pos..Pos+Chunk.Content'Length-1) := Chunk.Content;
smg_comms_files          Pos := Pos + Chunk.Content'Length;
smg_comms_files      
smg_comms_files          -- write counter
smg_comms_files          Write_U16( Msg, Pos, Chunk.Count );
smg_comms_files      
smg_comms_files          -- write padding if needed
smg_comms_files          if Pos <= Msg'Last then
smg_comms_files            RNG.Get_Octets( Msg(Pos..Msg'Last) );
smg_comms_files          end if;
smg_comms_files      
smg_comms_files        end Write_File_Transfer;
smg_comms_files      
smg_comms_files        -- The opposite of Write_File_Transfer method above.
smg_comms_files        -- Counter will contain the message counter
smg_comms_files        -- Chunk will contain the chunk counter, filename and content
smg_comms_files        procedure Read_File_Transfer( Msg     : in Raw_Types.Serpent_Msg;
smg_comms_files                                      Chunk   : out File_Chunk) is
smg_comms_files          Pos: Integer := Msg'First;
smg_comms_files          U16: Interfaces.Unsigned_16;
smg_comms_files          S_Name, E_Name: Integer; --start/end for filename in Msg
smg_comms_files          S_Len: Text_Len; -- length of filename (needed as Text_Len anyway)
smg_comms_files          S_Content, E_Content: Integer; --start/end for content in Msg
smg_comms_files          Content_Len: text_Len; -- length of content (needed as Text_Len anyway)
smg_comms_files        begin
smg_comms_files          -- read and check type ID
smg_comms_files          if Msg(Pos) /= File_Transfer_S_Type then
smg_comms_files            raise Invalid_Msg;
smg_comms_files          end if;
smg_comms_files          Pos := Pos + 1;
smg_comms_files      
smg_comms_files          -- read filename size
smg_comms_files          Read_U16( Msg, Pos, U16 );
smg_comms_files      
smg_comms_files          -- check for overflow and underflow; filename size >= 1
smg_comms_files          if Pos + Integer(U16) - 2 > Msg'Last or
smg_comms_files             U16 < 3 then
smg_comms_files            raise Invalid_Msg;
smg_comms_files          end if;
smg_comms_files          U16 := U16 - 2;
smg_comms_files          S_Len := Text_Len(U16);
smg_comms_files      
smg_comms_files          -- set start + end for reading filename later, when ready
smg_comms_files          S_Name := Pos;
smg_comms_files          E_Name := Pos + Integer(U16)-1;
smg_comms_files          Pos := Pos + S_Len;
smg_comms_files      
smg_comms_files          -- read size of content
smg_comms_files          Read_U16( Msg, Pos, U16 );
smg_comms_files          -- check for overflow and underflow; content >=1; counter =2 octets
smg_comms_files          if Pos + Integer(U16) - 1 > Msg'Last or
smg_comms_files             U16 < 3 then
smg_comms_files            raise Invalid_msg;
smg_comms_files          end if;
smg_comms_files          U16 := U16 - 2;
smg_comms_files          Content_Len := Text_Len(U16);
smg_comms_files          -- set start and end for reading content later, when ready
smg_comms_files          S_Content := Pos;
smg_comms_files          E_Content := Pos + Integer(U16) - 1;
smg_comms_files          Pos := Pos + Content_Len;
smg_comms_files      
smg_comms_files          -- read counter
smg_comms_files          Read_U16( Msg, Pos, U16 );
smg_comms_files          -- check chunking validity i.e. if counter>0 then no padding
smg_comms_files          if U16 /= 0 and Pos /= Msg'Last then
smg_comms_files            raise Invalid_Msg;
smg_comms_files          end if;
smg_comms_files      
smg_comms_files          -- create File_Chunk structure and fill it with data from Msg
smg_comms_files          declare
smg_comms_files            FC : File_Chunk( Len      => Content_Len, 
smg_comms_files                             Count    => U16,
smg_comms_files                             Name_Len => S_Len);
smg_comms_files          begin
smg_comms_files            -- read from Msg
smg_comms_files            FC.Content  := Msg( S_Content..E_Content );
smg_comms_files            Octets_To_String( Msg( S_Name..E_Name ), FC.Filename);
smg_comms_files            -- copy to output var
smg_comms_files            Chunk := FC;
smg_comms_files          end;
smg_comms_files      
smg_comms_files        end Read_File_Transfer;
smg_comms_files      
smg_comms_files        ---- File Requests ----
smg_comms_files        procedure Write_File_Request( FR      : in Filenames;
smg_comms_files                                      Counter : in Interfaces.Unsigned_16;
smg_comms_files                                      Msg     : out Raw_Types.Serpent_Msg;
smg_comms_files                                      Written : out Natural) is
smg_comms_files          Pos    : Integer := Msg'First;
smg_comms_files          Max_Pos: Integer := Msg'Last - 2; -- 2 octets at end for counter
smg_comms_files          Text_Sz: Integer;
smg_comms_files          Max_Sz : Integer;
smg_comms_files        begin
smg_comms_files          -- write ID for File Request type
smg_comms_files          Msg( Pos ) := File_Req_S_Type;
smg_comms_files          Pos := Pos + 1;
smg_comms_files      
smg_comms_files          -- write Text size: filenames + separators
smg_comms_files          -- consider fewer filenames if they don't ALL fit
smg_comms_files          -- 2 octets are taken by size itself
smg_comms_files          Max_Sz := Max_Pos - Pos - 1;
smg_comms_files          Text_Sz := FR.Sz + FR.F_No - 1;
smg_comms_files          if Text_Sz > Max_Sz then
smg_comms_files            -- walk the array of filenames backwards and stop when they fit
smg_comms_files            Written := FR.F_No - 1;
smg_comms_files            -- calculate actual size written based on start of first discarded
smg_comms_files              -- filename and (Written -1) octets for needed separators
smg_comms_files            Text_Sz := Integer(FR.Starts(Written+1)) - FR.Starts'First + 
smg_comms_files                         (Written - 1);
smg_comms_files        
smg_comms_files            -- loop until either fits or nothing left
smg_comms_files            while Written > 0 and Text_Sz > Max_Sz loop
smg_comms_files              Written := Written - 1;
smg_comms_files              Text_Sz := Integer(FR.Starts(Written+1))- FR.Starts'First + 
smg_comms_files                           (Written - 1);
smg_comms_files            end loop;
smg_comms_files            -- check that there is what to write, since nothing -> invalid message
smg_comms_files            if Written = 0 then
smg_comms_files              raise Invalid_Msg;
smg_comms_files            end if;
smg_comms_files      
smg_comms_files          else --from if Text_Sz > Max_Sz
smg_comms_files            -- ALL are written
smg_comms_files            Written := FR.F_No;  
smg_comms_files          end if;
smg_comms_files      
smg_comms_files          -- write Text_Sz + 2 (i.e. TOTAL size)
smg_comms_files          if Text_Sz + 2 > Integer(Interfaces.Unsigned_16'Last) then
smg_comms_files            raise Invalid_Msg;
smg_comms_files          end if;
smg_comms_files      
smg_comms_files          Write_U16( Msg, Pos, Interfaces.Unsigned_16(Text_Sz+2) );
smg_comms_files      
smg_comms_files          -- write filenames separated by Sep
smg_comms_files          for I in 1..Written loop
smg_comms_files            declare
smg_comms_files              Start_Pos : Positive;
smg_comms_files              End_Pos   : Positive;
smg_comms_files              Len       : Positive;
smg_comms_files            begin
smg_comms_files              -- current start pos in FR.S
smg_comms_files              Start_Pos := Positive( FR.Starts( FR.Starts'First + I - 1));
smg_comms_files      
smg_comms_files              -- calculate end based on start of next name or last
smg_comms_files              if I < FR.F_No then
smg_comms_files                End_Pos := Positive( FR.Starts( FR.Starts'First + I)) - 1;
smg_comms_files              else
smg_comms_files                End_Pos := FR.S'Last;
smg_comms_files              end if;
smg_comms_files      
smg_comms_files              -- NB: this WILL fail if starting positions are not in order!
smg_comms_files              Len := End_Pos - Start_Pos + 1;
smg_comms_files              if Len <= 0 then
smg_comms_files                raise Invalid_Msg;
smg_comms_files              end if;
smg_comms_files        
smg_comms_files              --write the actual filename
smg_comms_files              String_To_Octets( FR.S( Start_Pos..End_Pos ), Msg(Pos..Pos+Len-1) );
smg_comms_files              Pos := Pos + Len;
smg_comms_files      
smg_comms_files              --if it's not the last one, write a separator
smg_comms_files              if I < Written then
smg_comms_files                Msg(Pos) := Sep;
smg_comms_files                Pos := Pos + 1;
smg_comms_files              end if;
smg_comms_files            end;
smg_comms_files          end loop;
smg_comms_files      
smg_comms_files          -- write the message counter in little endian at all times
smg_comms_files          Write_U16( Msg, Pos, Counter );
smg_comms_files      
smg_comms_files          -- write padding if needed
smg_comms_files          if Pos <= Msg'Last then
smg_comms_files            Rng.Get_Octets( Msg(Pos..Msg'Last) );
smg_comms_files          end if;
smg_comms_files        end Write_File_Request;
smg_comms_files        
smg_comms_files        -- Reads a request for files; the opposite of Write_File_Request above
smg_comms_files        procedure Read_File_Request( Msg      : in Raw_Types.Serpent_Msg;
smg_comms_files                                     Counter  : out Interfaces.Unsigned_16;
smg_comms_files                                     FR       : out Filenames) is
smg_comms_files          Pos       : Integer := Msg'First;
smg_comms_files          Max_Pos   : Integer := Msg'Last - 2; --at least 2 reserved for counter
smg_comms_files          Text_Sz   : Integer;
smg_comms_files          Max_Sz    : Integer := Max_Pos - Pos - 1; --text only i.e. w.o. size itself
smg_comms_files          F_No      : Integer;
smg_comms_files          U16       : Interfaces.Unsigned_16;
smg_comms_files        begin
smg_comms_files          -- read type ID and check
smg_comms_files          if Msg(Pos) /= File_Req_S_Type then
smg_comms_files            raise Invalid_Msg;
smg_comms_files          end if;
smg_comms_files          Pos := Pos + 1;
smg_comms_files      
smg_comms_files          -- read total size of filenames+separators
smg_comms_files          Read_U16( Msg, Pos, U16 );
smg_comms_files          Text_Sz := Integer(U16);
smg_comms_files          -- take away the 2 octets for size itself
smg_comms_files          Text_Sz := Text_Sz - 2;
smg_comms_files          
smg_comms_files          -- check that Text_Sz is not overflowing/underflowing
smg_comms_files          if Text_Sz < 1 or Text_Sz > Max_Sz then
smg_comms_files            raise Invalid_Msg;
smg_comms_files          end if;
smg_comms_files      
smg_comms_files          -- count first the separators to know how many filenames
smg_comms_files          -- NB: there is always at least 1 filename as Text_Sz > 0
smg_comms_files          F_No := 1;
smg_comms_files          for I in Pos .. Pos + Text_Sz - 1 loop
smg_comms_files            if Msg(I) = Sep then
smg_comms_files              F_No := F_No + 1;
smg_comms_files            end if;
smg_comms_files          end loop;
smg_comms_files      
smg_comms_files          -- create the output structure and discard separators
smg_comms_files          -- text without separators should be Text_Sz - F_No + 1 
smg_comms_files          -- (because ONLY one separator between 2 filenames allowed)
smg_comms_files          -- if it's not that => Invalid_Msg
smg_comms_files          -- F_No and Text_Sz are not overflow (earlier check + calc)
smg_comms_files          declare
smg_comms_files            F     : Filenames(Text_Len(F_No), Text_Len(Text_Sz-F_No+1)); 
smg_comms_files            S_Pos : Positive;
smg_comms_files            Index : Positive;
smg_comms_files          begin
smg_comms_files            S_Pos := F.S'First;
smg_comms_files            Index := F.Starts'First;
smg_comms_files            F.Starts(Index) := Interfaces.Unsigned_16(S_Pos);
smg_comms_files      
smg_comms_files            for I in Pos .. Pos + Text_Sz - 1 loop
smg_comms_files              -- copy over to F.S anything that is not separator
smg_comms_files              if Msg(I) /= Sep then
smg_comms_files                F.S( S_Pos ) := Character'Val(Msg(I));
smg_comms_files                S_Pos := S_Pos + 1;
smg_comms_files              else
smg_comms_files                -- if it's separator, check and if ok, add next as start
smg_comms_files                if I = Pos + Text_Sz or -- separator as last character is error
smg_comms_files                     Msg(I+1) = Sep or  -- 2 consecutive separators is error
smg_comms_files                     Index >= F.Starts'Last then -- too many separators is error
smg_comms_files                  raise Invalid_Msg;
smg_comms_files                else
smg_comms_files                  Index := Index + 1;
smg_comms_files                  F.Starts( Index ) := Interfaces.Unsigned_16(S_Pos);
smg_comms_files                end if;
smg_comms_files              end if;
smg_comms_files            end loop;
smg_comms_files      
smg_comms_files            -- copy the whole structure to output variable
smg_comms_files            FR := F;      
smg_comms_files          end;
smg_comms_files      
smg_comms_files          -- read message counter now
smg_comms_files          Pos := Pos + Text_Sz;
smg_comms_files          Read_U16( Msg, Pos, Counter );
smg_comms_files          
smg_comms_files        end Read_File_Request;
smg_comms_keymgm     
smg_comms_keymgm       ------------------
smg_comms_keymgm       -- RSA Messages --
smg_comms_keymgm       ------------------
smg_comms_keymgm     
smg_comms_keymgm       procedure Write_SKeys_RMsg( Keyset  : in Serpent_Keyset;
smg_comms_keymgm                                   Counter : in Interfaces.Unsigned_16;
smg_comms_keymgm                                   Msg     : out Raw_Types.RSA_Msg) is
smg_comms_keymgm       begin
smg_comms_keymgm         -- call internal write of Serpent keys with correct type ID
smg_comms_keymgm         Write_SKeys( Keyset, Counter, SKeys_R_Type, Msg );
smg_comms_keymgm       end Write_SKeys_RMsg;
smg_comms_keymgm     
smg_comms_keymgm       procedure Read_SKeys_RMsg( Msg     : in Raw_Types.RSA_Msg;
smg_comms_keymgm                                  Counter : out Interfaces.Unsigned_16;
smg_comms_keymgm                                  Keyset  : out Serpent_Keyset) is
smg_comms_keymgm       begin
smg_comms_keymgm         -- check type id and call internal Read_SKeys if correct
smg_comms_keymgm         if Msg(Msg'First) /= SKeys_R_Type then
smg_comms_keymgm           raise Invalid_Msg;
smg_comms_keymgm         else
smg_comms_keymgm           Read_SKeys( Msg, Counter, Keyset );
smg_comms_keymgm         end if;
smg_comms_keymgm       end Read_SKeys_RMsg;
smg_comms_keymgm     
smg_comms_keymgm       procedure Write_KMgm_RMsg( KMgm    : in Keys_Mgm;
smg_comms_keymgm                                  Counter : in Interfaces.Unsigned_16;
smg_comms_keymgm                                  Msg     : out Raw_Types.RSA_Msg) is
smg_comms_keymgm       begin
smg_comms_keymgm         -- call internal write of key mgm with correct type ID
smg_comms_keymgm         Write_KMgm( KMgm, Counter, Key_Mgm_R_Type, Msg );
smg_comms_keymgm       end Write_KMgm_RMsg;
smg_comms_keymgm     
smg_comms_keymgm       procedure Read_KMgm_RMsg( Msg     : in Raw_Types.RSA_Msg;
smg_comms_keymgm                                 Counter : out Interfaces.Unsigned_16;
smg_comms_keymgm                                 KMgm    : out Keys_Mgm) is
smg_comms_keymgm       begin
smg_comms_keymgm         -- check type id and call internal Read_KMgm if correct
smg_comms_keymgm         if Msg(Msg'First) /= Key_Mgm_R_Type then
smg_comms_keymgm           raise Invalid_Msg;
smg_comms_keymgm         else
smg_comms_keymgm           Read_KMgm( Msg, Counter, KMgm );
smg_comms_keymgm         end if;
smg_comms_keymgm       end Read_KMgm_RMsg;
smg_comms_keymgm     
smg_comms_files      
smg_comms_files        ----------Utilities ----------
smg_comms_files        -- String to Octets conversion
smg_comms_files        procedure String_To_Octets(Str: in String; O: out Raw_Types.Octets) is
smg_comms_files        begin
smg_comms_files          Assert( Str'Length = O'Length );
smg_comms_files          for I in 1..Str'Length loop
smg_comms_files            O( O'First+I-1 ) := Character'Pos(Str(Str'First + I - 1 ));
smg_comms_files          end loop;
smg_comms_files        end String_To_Octets;
smg_comms_files      
smg_comms_files        -- Octets to string conversion
smg_comms_files        -- NB: Str'Length has to be EQUAL to Octets'Length!
smg_comms_files        procedure Octets_To_String(O: in Raw_Types.Octets; Str: out String) is
smg_comms_files        begin
smg_comms_files          Assert( O'Length = Str'Length );
smg_comms_files          for I in 1..O'Length loop
smg_comms_files            Str( Str'First+I-1 ) := Character'Val(O(O'First + I - 1 ));
smg_comms_files          end loop;
smg_comms_files        end Octets_To_String;
smg_comms_files      
smg_comms_keymgm       ------------------
smg_comms_keymgm       -- private part --
smg_comms_keymgm       ------------------
smg_comms_keymgm       procedure Cast_LE( LE: in out Raw_Types.Octets ) is
smg_comms_keymgm       begin
smg_comms_keymgm         -- flip octets ONLY if native is big endian.
smg_comms_keymgm         if System.Default_Bit_Order = System.High_Order_First then
smg_comms_keymgm           declare
smg_comms_keymgm             BE: constant Raw_Types.Octets := LE;
smg_comms_keymgm           begin
smg_comms_keymgm             for I in 1..LE'Length loop
smg_comms_keymgm               LE(LE'First+I-1) := BE(BE'Last-I+1);
smg_comms_keymgm             end loop;
smg_comms_keymgm           end;
smg_comms_keymgm         end if;
smg_comms_keymgm         -- NOTHING to do for native little endian
smg_comms_keymgm       end Cast_LE;
smg_comms_keymgm     
smg_comms_keymgm       procedure Write_SKeys( Keyset  : in Serpent_Keyset;
smg_comms_keymgm                              Counter : in Interfaces.Unsigned_16;
smg_comms_keymgm                              Type_ID : in Interfaces.Unsigned_8;
smg_comms_keymgm                              Msg     : out Raw_Types.Octets) is
smg_comms_skeys_s...     Pos   : Integer := Msg'First;
smg_comms_skeys_s...     Check : CRC32.CRC32;
smg_comms_skeys_s...     K     : Serpent.Key;
smg_comms_skeys_s...   begin
smg_comms_skeys_s...     -- write Type ID
smg_comms_keymgm         Msg(Pos) := Type_ID;
smg_comms_skeys_s...     Pos := Pos + 1;
smg_comms_skeys_s... 
smg_comms_skeys_s...     -- write count of keys (NB: this IS 8 bits by definition)
smg_comms_skeys_s...     Msg(Pos) := Keyset.Keys'Length;
smg_comms_skeys_s...     Pos := Pos + 1;
smg_comms_skeys_s... 
smg_comms_skeys_s...     -- write keys
smg_comms_skeys_s...     for I in Keyset.Keys'Range loop
smg_comms_skeys_s...       -- retrieve Key to write
smg_comms_skeys_s...       K := Keyset.Keys( I );
smg_comms_skeys_s... 
smg_comms_skeys_s...       -- write key itself
smg_comms_skeys_s...       Msg(Pos..Pos+K'Length-1) := K;
smg_comms_skeys_s...       -- ensure little endian order in message
smg_comms_skeys_s...       Cast_LE(Msg(Pos..Pos+K'Length-1));
smg_comms_skeys_s...       Pos := Pos + K'Length;
smg_comms_skeys_s... 
smg_comms_skeys_s...       -- write CRC of key
smg_comms_skeys_s...       Check := CRC32.CRC( K );
smg_comms_skeys_s...       Msg(Pos..Pos+3) := Raw_Types.Cast(Check);
smg_comms_skeys_s...       Cast_LE(Msg(Pos..Pos+3));
smg_comms_skeys_s...       Pos := Pos + 4;
smg_comms_skeys_s...     end loop;
smg_comms_skeys_s... 
smg_comms_skeys_s...     -- write flag
smg_comms_skeys_s...     Msg(Pos) := Keyset.Flag;
smg_comms_skeys_s...     Pos := Pos + 1;
smg_comms_skeys_s... 
smg_comms_skeys_s...     -- write message counter
smg_comms_files          Write_U16( Msg, Pos, Counter );
smg_comms_skeys_s... 
smg_comms_skeys_s...     -- write padding as needed; endianness is irrelevant here
smg_comms_files          if Pos <= Msg'Last then
smg_comms_files            RNG.Get_Octets( Msg(Pos..Msg'Last) );
smg_comms_skeys_s...     end if;
smg_comms_skeys_s... 
smg_comms_keymgm       end Write_SKeys;
smg_comms_skeys_s... 
smg_comms_keymgm       procedure Read_SKeys( Msg     : in Raw_Types.Octets;
smg_comms_keymgm                             Counter : out Interfaces.Unsigned_16;
smg_comms_keymgm                             Keyset  : out Serpent_Keyset) is
smg_comms_skeys_s...     Pos: Integer := Msg'First;
smg_comms_skeys_s...   begin
smg_comms_skeys_s...     -- read type and check
smg_comms_keymgm         if Msg(Pos) = SKeys_S_Type or 
smg_comms_keymgm            Msg(Pos) = SKeys_R_Type then
smg_comms_skeys_s...       Pos := Pos + 1;
smg_comms_skeys_s...     else
smg_comms_skeys_s...       raise Invalid_Msg;
smg_comms_skeys_s...     end if;
smg_comms_skeys_s... 
smg_comms_skeys_s...     -- read count of keys and check
smg_comms_skeys_s...     if Msg(Pos) in Keys_Count'Range then
smg_comms_skeys_s...       declare
smg_comms_skeys_s...         N     : Keys_Count := Keys_Count(Msg(Pos));
smg_comms_skeys_s...         KS    : Serpent_Keyset(N);
smg_comms_skeys_s...         K     : Serpent.Key;
smg_comms_skeys_s...         Check : CRC32.CRC32;
smg_comms_skeys_s...         O4    : Raw_Types.Octets_4; 
smg_comms_skeys_s...       begin
smg_comms_skeys_s...         Pos := Pos + 1;
smg_comms_skeys_s...         --read keys and check crc for each
smg_comms_skeys_s...         for I in 1 .. N loop
smg_comms_skeys_s...           -- read key and advance pos
smg_comms_skeys_s...           K := Msg(Pos..Pos+K'Length-1);
smg_comms_skeys_s...           Cast_LE(K);
smg_comms_skeys_s...           Pos := Pos + K'Length;
smg_comms_skeys_s...           -- read crc and compare to crc32(key)
smg_comms_skeys_s...           O4 := Msg(Pos..Pos+3);
smg_comms_skeys_s...           Cast_LE(O4);
smg_comms_skeys_s...           Check   := Raw_Types.Cast(O4);
smg_comms_skeys_s...           Pos := Pos + 4;
smg_comms_skeys_s...           if Check /= CRC32.CRC(K) then
smg_comms_skeys_s...             raise Invalid_Msg;
smg_comms_skeys_s...           end if;
smg_comms_skeys_s...           -- if it got here, key is fine so add to set
smg_comms_skeys_s...           KS.Keys(KS.Keys'First + I -1) := K;
smg_comms_skeys_s...         end loop;
smg_comms_skeys_s...         -- read and set flag
smg_comms_skeys_s...         KS.Flag := Msg(Pos);
smg_comms_skeys_s...         Pos := Pos + 1;
smg_comms_skeys_s...         -- read and set message counter
smg_comms_files              Read_U16( Msg, Pos, Counter );
smg_comms_skeys_s...         -- rest of message is padding so it's ignored
smg_comms_skeys_s...         -- copy keyset to output variable
smg_comms_skeys_s...         Keyset := KS;
smg_comms_skeys_s...       end;
smg_comms_skeys_s...     else
smg_comms_skeys_s...       raise Invalid_Msg;
smg_comms_skeys_s...     end if;
smg_comms_keymgm       end Read_SKeys;
smg_comms_skeys_s... 
smg_comms_keymgm       -- writes given key management structure to the given octets array
smg_comms_keymgm       procedure Write_KMgm( KMgm    : in Keys_Mgm;
smg_comms_keymgm                             Counter : in Interfaces.Unsigned_16;
smg_comms_keymgm                             Type_ID : in Interfaces.Unsigned_8;
smg_comms_keymgm                             Msg     : out Raw_Types.Octets) is
smg_comms_keymgm         Pos   : Integer := Msg'First;
smg_comms_skeys_s...   begin
smg_comms_keymgm         -- write given type id
smg_comms_keymgm         Msg(Pos) := Type_ID;
smg_comms_keymgm         Pos := Pos + 1;
smg_comms_keymgm     
smg_comms_keymgm         -- write count of server keys requested
smg_comms_keymgm         Msg(Pos) := KMgm.N_Server;
smg_comms_keymgm         Pos := Pos + 1;
smg_comms_keymgm     
smg_comms_keymgm         -- write count of client keys requested
smg_comms_keymgm         Msg(Pos) := KMgm.N_Client;
smg_comms_keymgm         Pos := Pos + 1;
smg_comms_keymgm     
smg_comms_keymgm         -- write id of key preferred for further inbound Serpent messages
smg_comms_keymgm         Msg(Pos) := KMgm.Key_ID;
smg_comms_keymgm         Pos := Pos + 1;
smg_comms_keymgm     
smg_comms_keymgm         -- write count of burnt keys in this message
smg_comms_keymgm         Msg(Pos..Pos) := Cast( KMgm.N_Burnt );
smg_comms_keymgm         Pos := Pos + 1;
smg_comms_keymgm     
smg_comms_keymgm         -- if there are any burnt keys, write their ids
smg_comms_keymgm         if KMgm.N_Burnt > 0 then
smg_comms_keymgm           Msg( Pos .. Pos + KMgm.Burnt'Length - 1 ) := KMgm.Burnt;
smg_comms_keymgm           Pos := Pos + KMgm.Burnt'Length;
smg_comms_skeys_s...     end if;
smg_comms_keymgm     
smg_comms_keymgm         -- write the message count
smg_comms_files          Write_U16( Msg, Pos, Counter );
smg_comms_keymgm     
smg_comms_keymgm         -- pad with random octets until the end of Msg
smg_comms_files          if Pos <= Msg'Last then
smg_comms_files            RNG.Get_Octets( Msg(Pos..Msg'Last) );
smg_comms_files          end if;
smg_comms_keymgm     
smg_comms_keymgm       end Write_KMgm;
smg_comms_keymgm     
smg_comms_keymgm       -- attempts to read from the given array of octets a key management structure
smg_comms_keymgm       procedure Read_KMgm( Msg     : in Raw_Types.Octets;
smg_comms_keymgm                            Counter : out Interfaces.Unsigned_16;
smg_comms_keymgm                            KMgm    : out Keys_Mgm) is
smg_comms_keymgm         Pos       : Integer := Msg'First;
smg_comms_keymgm         Burnt_Pos : Integer := Msg'First + 4;
smg_comms_keymgm       begin
smg_comms_keymgm         -- read type and check
smg_comms_keymgm         if Msg(Pos) = Key_Mgm_S_Type or 
smg_comms_keymgm            Msg(Pos) = Key_Mgm_R_Type then
smg_comms_keymgm           Pos := Pos + 1;
smg_comms_keymgm         else
smg_comms_keymgm           raise Invalid_Msg;
smg_comms_keymgm         end if;
smg_comms_keymgm     
smg_comms_keymgm         -- read the count of burnt keys and check
smg_comms_keymgm         -- NB: Burnt_Pos IS in range of Counter_8bits since it's an octet
smg_comms_keymgm         declare
smg_comms_keymgm           N_Burnt : Counter_8bits := Counter_8bits(Msg(Burnt_Pos));
smg_comms_keymgm           Mgm     : Keys_Mgm(N_Burnt);
smg_comms_keymgm         begin
smg_comms_keymgm           -- read count of server keys requested
smg_comms_keymgm           Mgm.N_Server := Msg(Pos);
smg_comms_keymgm           Pos := Pos + 1;
smg_comms_keymgm     
smg_comms_keymgm           -- read count of client keys requested
smg_comms_keymgm           Mgm.N_Client := Msg(Pos);
smg_comms_keymgm           Pos := Pos + 1;
smg_comms_keymgm     
smg_comms_keymgm           -- read ID of Serpent key preferred for further inbound messages
smg_comms_keymgm           Mgm.Key_ID   := Msg(Pos);
smg_comms_keymgm           Pos := Pos + 2; --skip the count of burnt keys as it's read already
smg_comms_keymgm     
smg_comms_keymgm           -- read ids of burnt keys, if any
smg_comms_keymgm           if N_Burnt > 0 then
smg_comms_keymgm             Mgm.Burnt := Msg(Pos..Pos+N_Burnt-1);
smg_comms_keymgm             Pos := Pos + N_Burnt;
smg_comms_keymgm           end if;
smg_comms_keymgm     
smg_comms_keymgm           -- read and set message counter
smg_comms_files            Read_U16( Msg, Pos, Counter );
smg_comms_keymgm           -- rest of message is padding so it's ignored
smg_comms_keymgm           -- copy the keys mgm structure to output param
smg_comms_keymgm           KMgm := Mgm;
smg_comms_keymgm         end;
smg_comms_keymgm       end Read_KMgm;
smg_comms_keymgm     
smg_comms_files        -- Write a 16 bits value to Octets at Pos; Pos increases by 2.
smg_comms_files        procedure Write_U16( Msg: in out Raw_Types.Octets;
smg_comms_files                             Pos: in out Natural;
smg_comms_files                             U16: in Interfaces.Unsigned_16) is
smg_comms_files        begin
smg_comms_files          Msg(Pos..Pos+1) := Raw_Types.Cast(U16);
smg_comms_files          Cast_LE(Msg(Pos..Pos+1));
smg_comms_files          Pos := Pos + 2;
smg_comms_files        end Write_U16;
smg_comms_files      
smg_comms_files        -- Read a 16-bits values from Octets from Pos; Pos increases by 2.
smg_comms_files        procedure Read_U16( Msg: in Raw_Types.Octets;
smg_comms_files                            Pos: in out Natural;
smg_comms_files                            U16: out Interfaces.Unsigned_16) is
smg_comms_files          O2  : Raw_Types.Octets_2;
smg_comms_files        begin
smg_comms_files          O2  := Msg(Pos..Pos+1);
smg_comms_files          Cast_LE(O2);
smg_comms_files          U16 := Raw_Types.Cast(O2);
smg_comms_files          Pos := Pos + 2;
smg_comms_files        end Read_U16;
smg_comms_skeys_s... 
smg_comms_skeys_s... end Messages;