~ This is a work in progress towards an Ada implementation of Eulora's communication protocol. Start with Chapter 1.~
This chapter uses the raw types of the protocol as defined in the previous chapter and adds two methods that are still at layer 0 of the protocol: one method for packing Serpent messages into corresponding Serpent packets and one method for unpacking such Serpent packets to extract their contained Serpent message. It is a single small step forward but the corresponding .vpatch is still quite large as it contains the Serpent code in addition to the packing/unpacking methods. The packing is effectively an encryption with a given Serpent key while the unpacking is the corresponding decryption. Nevertheless, there are a few bits that are specific to this implementation as they reflect the requirements of Eulora's protocol:
- Packing receives as input a Serpent_Msg and produced as output a Serpent_Pkt. Symmetrically, unpacking receives as input a Serpent_Pkt and produces a Serpent_Msg. Both Serpent_Pkt and Serpent_Msg are arrays of octets but of fixed, pre-defined size: 1472 octets and nothing else.
- Both packing and unpacking will split their input into blocks of the size that Serpent can handle, encrypt/decrypt them and then glue together the results to produce the output. So there are effectively 921 encrypting / decrypting operations with the same, given Serpent key, for one single pack / unpack call.
I've adapted the Serpent implementation that I previously published as part of EuCrypt, effectively integrating it into SMG Comms and stripping away anything that isn't directly needed by SMG Comms:
- Serpent is now simply a package like all the others rather than a stand-alone library. While it is true that any changes to the original will have to be manually ported to this one as well, that was always going to be the case anyway. So I don't really see much point in carrying about all the glue and additional files to make a library out of only 2 files. Hence, Serpent in SMG Comms has 2 files and nothing more: serpent.ads and serpent.adb. Short and clear.
- Since this is production use already, testing parts such as the "Selftest" method don't really have any business in the code itself. I've moved this method where it belongs, namely with the tests for all the code, in the tests directory (test_serpent.ads/.adb)
- Since Serpent here becomes part of SMG Comms it follows that it should also use the raw types of the protocol - it will anyway be called to use variables of those types rather than anything else. There is no point in forcing back and forth conversions between SMG Comms' "Octets" and Serpent's "Bytes" types that are both arrays of octets anyway. So I've changed the definition of the "Bytes" type in Serpent so that it is here simply a subtype of the "Octets" type. This has the advantage that it allows smooth calls to Serpent from SMG Comms while being a small, easily-reversible change that also maintains otherwise the clarity of Serpent's code as it is. Basically SMG Comms gets to call Serpent without having to do explicit conversions between types that are anyway the same thing and Serpent gets to keep calling arrays of octets Bytes internally as it does in its stand-alone lib version.
In addition to the above, the .vpatch for this chapter also adds tests for the packing/unpacking methods2. I've also made a small change to raw_types.ads so that there is now only one variable for Serpent length: SERPENT_OCTETS. This reflects better the fact that there really is only one length for Serpent and it still allows to keep code clear by having the two array types Serpent_Pkt and Serpent_Msg - they just use the same length. Clarity of code is a tricky choice, what more can I say. Here's the updated code in raw_types:
-- constants from SMG.COMMS standard specification
-- size of a serpent-encrypted packet and message, in octets
-- note that this corresponds to 1472/16 = 92 Serpent blocks
-- NB: lengths are the same!
SERPENT_OCTETS : constant Positive := 1472;
-- size of a RSA-encrypted packet and message in octets and bits
RSA_PKT_OCTETS : constant Positive := 1470;
RSA_MSG_OCTETS : constant Positive := 234;
RSA_MSG_BITS : constant Positive := RSA_MSG_OCTETS * 8; --1872
-- raw, low-level types
-- all messages and packets are simply arrays of octets at low level/raw
type Octets is array( Natural range <> ) of Interfaces.Unsigned_8;
-- raw representations of basic types (with fixed, well-defined sizes)
subtype Octets_1 is Octets( 1 .. 1 );
subtype Octets_2 is Octets( 1 .. 2 );
subtype Octets_4 is Octets( 1 .. 4 );
subtype Octets_8 is Octets( 1 .. 8 );
-- RSA packets and contained raw messages
subtype RSA_Pkt is Octets( 1 .. RSA_PKT_OCTETS );
subtype RSA_Msg is Octets( 1 .. RSA_MSG_OCTETS );
-- Serpent packets and contained raw messages
-- NB: length is the same but the distinction makes the code clearer
subtype Serpent_Pkt is Octets( 1 .. SERPENT_OCTETS );
subtype Serpent_Msg is Octets( 1 .. SERPENT_OCTETS );
And the new code in packing.ads:
-- Packing/unpacking for Eulora's communication protocol:
-- Serpent Message to/from Serpent Packet
-- RSA Message to/from RSA Packet
-- S.MG, 2018
with Raw_Types;
with Serpent;
package Packing is
-- no side effects or internal state
Pragma Pure(Packing);
-- Packing a Serpent message into Serpent package, using the given key
function Pack( Msg : in Raw_Types.Serpent_Msg;
K : in Serpent.Key )
return Raw_Types.Serpent_Pkt;
-- Unpacking a Serpent packet into contained message, using the given key
function Unpack( Pkt : in Raw_Types.Serpent_Pkt;
K : in Serpent.Key)
return Raw_Types.Serpent_Msg;
-- internals of this package, NOT for outside use
private
-- length of 1 Serpent block
Block_Len: constant Natural := Serpent.Block'Length;
-- number of Serpent blocks in one single Serpent message/packet
S_Blocks : constant Natural := Raw_Types.SERPENT_OCTETS / Block_Len;
end Packing;
The new code in packing.adb:
-- Packing/unpacking for Eulora's communication protocol:
-- Serpent Message to/from Serpent Packet
-- RSA Message to/from RSA Packet
-- S.MG, 2018
package body Packing is
-- Packing a Serpent message into Serpent package, using the given key
function Pack( Msg : in Raw_Types.Serpent_Msg;
K : in Serpent.Key )
return Raw_Types.Serpent_Pkt is
-- single Serpent blocks containing plain / encrypted data
Plain : Serpent.Block;
Encr : Serpent.Block;
-- Serpent Key Schedule - needed for direct encr/decr calls
KS : Serpent.Key_Schedule;
-- final resulting Serpent package
Pkt : Raw_Types.Serpent_Pkt := (others => 0);
begin
-- prepare the Serpent key schedule based on given key
Serpent.Prepare_Key( K, KS );
-- encrypt message block by block and copy result in packet
for I in 1 .. S_Blocks loop
-- get current block to encrypt
Plain := Msg( Msg'First + (I-1) * Block_Len ..
Msg'First + I * Block_Len - 1 );
-- encrypt with Serpent
Serpent.Encrypt( KS, Plain, Encr );
-- copy result to output packet
Pkt( Pkt'First + (I-1) * Block_Len ..
Pkt'First + I * Block_Len - 1 )
:= Encr;
end loop;
-- return result
return Pkt;
end Pack;
-- Unpacking a Serpent packet into contained message, using the given key
function Unpack( Pkt : in Raw_Types.Serpent_Pkt;
K : in Serpent.Key)
return Raw_Types.Serpent_Msg is
-- single Serpent blocks containing plain / encrypted data
Plain : Serpent.Block;
Encr : Serpent.Block;
-- Serpent Key Schedule - needed for direct encr/decr calls
KS : Serpent.Key_Schedule;
-- the message extracted from the given packet
Msg : Raw_Types.Serpent_Msg := (others => 0);
begin
-- prepare the Serpent key for use
Serpent.Prepare_Key( K, KS );
-- decrypt the Serpent packet block by block
for I in 1 .. S_Blocks loop
-- get current block from input and decrypt
Encr := Pkt( Pkt'First + (I-1) * Block_Len ..
Pkt'First + I * Block_Len - 1 );
Serpent.Decrypt( KS, Encr, Plain );
-- copy result to its correct position in final output
Msg( Msg'First + (I-1) * Block_Len ..
Msg'First + I * Block_Len - 1 )
:= Plain;
end loop;
-- return the result - the message content of given package
return Msg;
end Unpack;
end Packing;
The .vpatch and my signature for it are as usual on my Reference Code Shelf as well as linked here for your convenience:
1472 / 16 = 92 ↩
And needed they were too for they actually caught an error that had survived somehow several re-readings of the code to the point that I was totally surprised when the tests first...failed. Never underestimate your own capacity of introducing idiotic errors in the simplest of things! ↩
Comments feed: RSS 2.0