Patent Publication Number: US-8971526-B2

Title: Method of counter-measuring against side-channel attacks

Description:
FIELD 
     The present invention concerns a method of counter-measuring against side-channel attacks for block-ciphers, and in particular, but not exclusively, to a method of counter-measuring which uses a match-in-place function. 
     DESCRIPTION OF RELATED ART 
     Many existing encryption algorithms in use today, such as the most widely used encryption algorithm ‘Advanced Encryption Standard (AES)’ are vulnerable to Differential Power Analysis (DPA). DPA is a side-channel attack that consists in first measuring a microprocessor&#39;s power consumption when executing a cryptographic algorithm and then performing statistical analysis in order to recover secret-keys used in the cryptographic algorithm for encryption. Once the secret-keys have been determined it is possible to decrypt encrypted information. 
     A microprocessor&#39;s electromagnetic emanations can also be measured and exploited to determine secret-keys used in a cryptographic algorithm for encryption. 
     A common technique to protect secret-key algorithms against DPA consists of masking every intermediate variable with a random mask. The masked data and the random mask are then processed separately and eventually recombined at the end of the algorithm. An attacker trying to analyze the power consumption of a microprocessor at a single point will obtain random values (random data values and random mask values); therefore, such masking will be secure against first-order DPA. 
     A masking counter-measure is characterized by the number of random masks used to protect a given sensitive variable; a masking with d random masks is called a d-th order masking. A d-th order masking can only be broken by a (d+1) th  order side-channel analysis, i.e. an attack that requires the processing of d+1 variables simultaneously. The number of executions required to break a counter-measure grows exponentially with the order d. Therefore, the order d is a good security criterion. However, in practice the most efficient counter-measures are of order d=1 only 
     It has been shown that a second-order DPA attacks to decrypt masked data is possible. Therefore, better counter-measures are needed in order to obtain fully secure encryption of data. 
     Further developments in counter-measures have been made; one of the most recent counter-measures against side-channel attacks is a counter-measure with order d=2. 
     For any masking counter-measure the main difficulty is to protect the non-linear parts of the algorithm; for Advanced Encryption Standard (AES) the non-linear parts of the algorithm are essentially SBOX functions. The technique used consists of iterating over the entire SBOX function for every SBOX look-up, using a comparison algorithm that is implemented as a subroutine. The comparison algorithm being called for every SBOX input, it is possible to show that the counter-measure can resist any second-order side-channel attack. 
     However such masking counter-measures are grossly inefficient as it requires many operations during execution and also utilises much of the microprocessors memory during execution. 
     It is an aim of the present invention to obviate, or mitigate, at least some of the afore-mentioned disadvantages. 
     SUMMARY 
     According to the invention, these aims are achieved by means of a method of counter-measuring against side channel attacks, the method comprising executing a block-cipher algorithm to mask intermediate variables, wherein the block-cipher algorithm comprises one or more non-linear functions, characterised in that at least one of the non-linear functions is implemented using a match-in-place function. 
     The method of the present invention makes use of a match-in-place function to improve the efficiency of the method. Using a match-in-place function reduces the number of operations which are required to provide an effective counter-measuring against side channel attacks. Furthermore, less memory is required to implement the method of the present invention compared to know methods. 
     The match-in-place function may be a bit-randomized match-in place function (MIP I  (data; adr,b)). 
     The bit-randomized match-in place function may be defined as: 
                 MIP   I     ⁡     (       data   ;       b   ⁢           ⁢   if   ⁢           ⁢   read   ⁢           ⁢     (   adr   )       =   adr       ,   b     )       =     {         data             b   ⁢           ⁢   otherwise                   
wherein adr is an address in a memory, data is a variable which can be stored at an address in a memory, and b is a value which is returned if the data variable is equal to actual data which is present at the address adr in memory; otherwise the complement of b is returned. b may be a bit value.
 
     The following relationship may exist:
 
MIP I (data;adr; b )=MIP(data;adr)⊕ b  
 
wherein b is the complement of b.
 
     The at least one of the non-linear function may comprise a compare b  function, defined by: 
                   compare   b     ⁡     (     x   ;   y     )       ⁢   b   ⁢           ⁢   if   ⁢           ⁢   x     =     y   =     {           b   ⁢           ⁢   if   ⁢           ⁢   x               ≠   y                     
wherein x is the first input variable of the compare b  function and y is the second input variable of the compare b  function, and b is a value which is returned if x is equal to y, such that the compare b  function can be implemented by: writing the variable x to an address adr in memory; executing the bit-randomized match-in place function defined as:
 
     
       
         
           
             
               
                 MIP 
                 I 
               
               ⁡ 
               
                 ( 
                 
                   
                     y 
                     ; 
                     adr 
                   
                   , 
                   b 
                 
                 ) 
               
             
             = 
             
               
                 b 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 if 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 read 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   ( 
                   adr 
                   ) 
                 
               
               = 
               
                 { 
                 
                   
                     
                       
                         
                           y 
                         
                       
                       
                         
                           
                             b 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             otherwise 
                           
                         
                       
                     
                     ⁢ 
                     
                       
 
                     
                     ⁢ 
                     and 
                   
                   , 
                   
                     returning 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         
                           MIP 
                           I 
                         
                         ⁡ 
                         
                           ( 
                           
                             
                               y 
                               ; 
                               adr 
                             
                             , 
                             b 
                           
                           ) 
                         
                       
                       . 
                     
                   
                 
               
             
           
         
       
     
     The non-linear function may be comprised in a SubByte operation. The non-linear function may be comprised in a SubByte operation of an AES algorithm. 
     The block-cipher algorithm may further comprise one or more linear functions. At least one of the one or more linear functions may be masked by XORing variables of the function. 
     The block-cipher algorithm may be an Advanced Encryption Standard (AES) algorithm. 
     According to a further aspect of the present invention there is provided a computer readable medium comprising a computer program which is configured to implement a method according to any one of the afore mentioned methods. 
     According to a further aspect of the present invention there is provided a method of computing a second order masked Sbox function from a second order masked input, comprising the steps of: 
     
       
         
           
             
               
                 ( 
                 i 
                 ) 
               
               ⁢ 
               b 
             
             ← 
             
               rand 
               ⁡ 
               
                 ( 
                 1 
                 ) 
               
             
           
         
       
       
         
           
             
               
                 ( 
                 ii 
                 ) 
               
               ⁢ 
               
                   
               
               ⁢ 
               for 
               ⁢ 
               
                   
               
               ⁢ 
               a 
             
             = 
             
               
                 0 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 to 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   2 
                   n 
                 
               
               - 
               
                 1 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   do 
                   ⁢ 
                   
                     
 
                   
                   ( 
                   a 
                   ) 
                 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 write 
                 ⁢ 
                 
                     
                 
                 ⁢ 
                 
                   ( 
                   
                     
                       
                         r 
                         1 
                       
                       ⊕ 
                       a 
                     
                     ; 
                     adr 
                   
                   ) 
                 
               
             
           
         
       
       
         
           
             
               
                 ( 
                 b 
                 ) 
               
               ⁢ 
               cmp 
             
             ← 
             
               
                 MIP 
                 I 
               
               ⁡ 
               
                 ( 
                 
                   
                     r 
                     2 
                   
                   ; 
                   adr 
                   ; 
                   b 
                 
                 ) 
               
             
           
         
       
       
         
           
             
               
                 ( 
                 c 
                 ) 
               
               ⁢ 
               
                 R 
                 cmp 
               
             
             ← 
             
               
                 ( 
                 
                   
                     S 
                     ⁡ 
                     
                       ( 
                       
                         x 
                         ⊕ 
                         a 
                       
                       ) 
                     
                   
                   ⊕ 
                   
                     s 
                     1 
                   
                 
                 ) 
               
               ⊕ 
               
                 s 
                 2 
               
             
           
         
       
     
     (iii) Return R b    
     wherein, b is a variable which represents a random bit which indexes a register, and a is a variable which represents an index which defines the number of times steps (a)-(c) should be carried out, r 1 , r 2  is a pair of input masks, x is a masked value wherein x=x⊕r 1 ⊕r 2 ⊕εF n   2 , and s 1 , s 2  are a pair of output masks, and adr is a free memory address, cmp is a bit variable which indexes a register and is an output of the function MIP I  (r 2 ; adr; b), R cmp  is a register address of a register of a micro-processor. Typically, at least two registers R 0  and R 1  in the micro-processor are used (i.e. cmp can be 0 or 1; a first register R 0  is indexed/addressed if cmp=0, and a second register R 1  is indexed/addressed if cmp=1). R b  is a register address of a register of a micro-processor. Typically at least two registers R 0  and R 1  in the micro-processor are used (i.e. b can be 0 or 1; register R 0  is indexed/addressed if b=0, and register R 1  is indexed/addressed if b=1). MIP I  (r 2 ; adr; b) is a bit-randomized match-in place function defined as: 
     
       
         
           
             
               
                 MIP 
                 I 
               
               ⁡ 
               
                 ( 
                 
                   
                     data 
                     ; 
                     
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         if 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         read 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           ( 
                           adr 
                           ) 
                         
                       
                       = 
                       adr 
                     
                   
                   , 
                   b 
                 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     data 
                   
                 
                 
                   
                     
                       b 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       otherwise 
                     
                   
                 
               
             
           
         
       
     
     According to a further aspect of the present invention there is provided a computer readable medium comprising a computer program which is configured to carry out the afore-mentioned method of computing a second order masked Sbox function. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The invention will be better understood with the aid of the description of an embodiment given by way of example and illustrated by the figures, in which: 
         FIG. 1  shows Pseudo-code for AES encryption; 
         FIG. 2  shows Pseudo-code for AES decryption; 
         FIG. 3  shows a table comprising the number of memory transfers (pre-processing phase), number of XORs and memory transfers (main phase) and memory required for the original implementation of a compare b  function and the implementation of the compare b  function according to the present invention; 
         FIG. 4  shows a table comprising number of XORs, number of memory transfers and memory required for a full second Rivain-Dottax-Prouff (RDP2) algorithm implementation which uses the method of the present invention to implementation a compare b  function. 
     
    
    
     DETAILED DESCRIPTION OF POSSIBLE EMBODIMENTS 
     The use of the method of the present invention in an AES encryption algorithm will be described in detail. However, it should be understood that the method of the present invention is not limited to use with an AES encryption algorithm; the method of the present invention could be used in any block-cipher algorithm. 
     The AES Encryption Algorithm operates on a 4×4 array of bytes s i,j , termed the ‘state’. For encryption, each subpart of the AES Encryption Algorithm (except a last subpart) comprises the following four stages:
         1. AddRoundKey: each byte of the state is xored with the round key
           k i,j , derived from the key schedule:
 
 s   i,j   ←s   i,j   ⊕k   i,j  
   
           2. SubBytes: each byte of the state is updated using an 8-bit S-box function:
 
 s   i,j   ←S ( s   i,j )
           The S-box function is defined as:
 
 S ( x )=Aff(Inv( x ))
   where Aff is an affine function over GF(2 8 ) and
 
Inv( x )= x   254  
   is the inverse function over GF(2 8 ) (with 0→0)   
           3. ShiftRows: the bytes of the state are cyclically shifted in each row
           by a certain offset; the first row is left unchanged.   
           4. MixColumns: the bytes of the state are modified column by column as follows:
 
 s   I   0,c ←(02 ·s   0,c )⊕(03 ·s   1,c )⊕ s   2,c   ⊕s   3,c  
 
 s   I   1,c   ←s   0,c ⊕(02 ·s   1,c )⊕(03 ·s   2,c )⊕ s   3,c  
 
 s   I   2,c   ←s   0,c   ⊕s   1,c ⊕(02 ·s   2,c )⊕(03 ·s   3,c )
 
 s   I   3,c ←903 ·s   0,c )⊕ s   1,c   ⊕s   2,c ⊕(02 ·s   3,c )
       

     The pseudo-code for AES encryption with a 128-bit key is given in  FIG. 1 . The word array ‘w’ contains round keys (k i,j ) which are generated by a key-schedule algorithm. 
     For decryption, every round (except the last) comprises the following operations:
         1. InvShiftRows: is the inverse of the ShiftRows operation (stage 3 of encryption). The bytes of the state (a set of intermediate variables used in AES encryption, as defined in paragraph [0025]) are cyclically shifted in each row by a certain offset; the first row of bytes is left unchanged.   2. InvSubBytes: is the inverse of the SubBytes operation (stage 2 of encryption). The inverse S-box (S − ) is applied on each byte of the state, with:
 
 S   −1 ( x )=Inv(Aff −1 ( x ))
   3. AddRoundKey: the operation is equal to its own inverse.   4. InvMixColumns: is the inverse of the MixColumns operation (stage 4 of the encryption). The bytes of the state are modified column by column as follows:
 
 s   I   0,c ←(0 e·s   0,c )⊕(0 b·s   1,c )⊕(0 d·s   2,c )⊕(09 ·s   3,c )
 
 s   I   1,c ←(09 ·s   0,c )⊕(0 e·s   1,c )⊕(0 b·s   2,c )⊕(0 d·s   3,c )
 
 s   I   2,c ←(0 d·s   0,c )⊕(09 ·s   1,c )⊕(0 e·s   2,c )⊕(0 b·s   3,c )
 
 s   I   3,c ←(0 b·s   0,c )⊕(0 d·s   1,c )⊕(09 ·s   2,c )⊕(0 e·s   3,c )
 
The pseudo-code for the inverse cipher is given in  FIG. 2 .
       

     Finally, the round key-schedule (k i,j ) is based on the following operations:
         1. SubWord: takes a four-byte input word and applies the S-box (S(x)) to each of the four bytes.   2. RotWord: takes a word [a 0 ; a 1 ; a 2 ; a 3 ] as input and performs a cyclic permutation to return [a 1 ; a 2 ; a 3 ; a 0 ]   3. Xor with Rcon: takes as input a 32-bits word and xor it with the round constant word array Rcon[i]=[(02) i−1 ; 00; 00; 00], for round 1≦i≦10. We refer to [5] for a full description of the key-schedule.       

     As discussed in the introduction, the principle of the masking counter-measure is to mask every intermediate variable with one or more random masks. In case of the masking counter-measure with order d=2, two masks are used, which gives a total of three shares. More precisely, any state variable p (represented as a byte in AES) is shared into three shares (p 0 ; p 1 ; p 2 ) with:
 
 p=p   0   ⊕p   1   ⊕p   2  
 
where the shares p 1  and p 2  are called the masks.
 
     The three shares p 0 , p 1  and p 2  must be processed in such a way that the previous relation is preserved throughout the execution of the encryption algorithm. Note that similarly every byte k of the round key must be shared into three shares (k 0 ; k 1 ; k 2 ) such that k=k 0 ⊕k 1 ⊕k 2 . 
     The linear parts of the block-cipher are easy to process. A function f is said to be linear when the following holds:
 
 f ( x⊕y )= f ( x )⊕ f ( y )  Equation (1)
 
     Then for such linear function when given as input the three shares (p 0 ; p 1 ; p 2 ) such that:
 
 p=p   0   ⊕p   1   ⊕p   2  
 
it suffices to compute f(p 0 ), f(p 1 ) and f(p 2 ) separately and forming Equation (1) one obtains:
 
 f ( p )= f ( p   0 )⊕ f ( p   1 )⊕ f ( p   2 )
 
Therefore, the three output shares f(p 0 ), f(p 1 ) and f(p 2 ) are a valid sharing of the output f(p). For AES encryption, the AddRoundKey, ShiftRows and MixColumns operation are linear functions and can therefore be processed in this manner. However, the SubBytes operation (such as the S-box function in the case of AES) is non-linear and must be processed differently.
 
     To process non-linear operations such as the S-box function in the case of AES an algorithm can be defined as follows:
 
 S:{ 0;1} n →{0;1} m  
 
Note that for AES n=m=8. The algorithm preferably comprises a masked function compare b  defined as follows:
 
                   compare   b     ⁡     (     x   ;   y     )       ⁢   b   ⁢           ⁢   if   ⁢           ⁢   x     =     y   =     {           b   ⁢           ⁢   if   ⁢           ⁢   x               ≠   y                     
where the x and y are the input variables of the compare b  function.
 
     Computation of a second-order masked S-box function from a second-order masked input may be carried out as follows:
         Input: A masked value x=x⊕r 1 ⊕r 2 εF n   2 , wherein r 1 ; r 2  is a pair of input masks, and s 1 ; s 2 εF m   2  is a pair of output masks.   Output: The masked S-box function output S(x)⊕s 1 ⊕s 2 .   1. b←rand(1)   2. for a=0 to 2n−1 do
           (a) cmp←compare b  (r 1 ⊕a; r 2 )   (b) Rcmp←(S(x⊕a)⊕s 1 )⊕s 2      
           3. Return R b          

     Wherein r 1 ⊕a; r 2  are input variables of the compare b  function, a=r 1 ⊕r 2  then cmp=compare b  (r 1 ⊕a, r 2 )=compare b  (r 2 ; r 2 )=b which gives R b =(S(x⊕r 1 ⊕r 2 ) ⊕s 1 )⊕s 2 =S(x)⊕s 1 ⊕s 2  as required. 
     In this particular embodiment, care should be taken when implementing the compare b  function. Namely the compare b  (x; y) function preferably should not be implemented by computing x⊕y directly, since in the above algorithm this would amount to computing (r 1 ⊕r 2 ⊕a) which combined with x would give a second-order leakage. 
     The method implementing of the compare b  function to prevent any first order side-channel leakage on x⊕y will now be described: 
     Recall that the function compare b  is defined as: 
     
       
         
           
             
               
                 
                   compare 
                   b 
                 
                 ⁡ 
                 
                   ( 
                   
                     x 
                     ; 
                     y 
                   
                   ) 
                 
               
               ⁢ 
               b 
               ⁢ 
               
                   
               
               ⁢ 
               if 
               ⁢ 
               
                   
               
               ⁢ 
               x 
             
             = 
             
               y 
               = 
               
                 { 
                 
                   
                     
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         if 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         x 
                       
                     
                   
                   
                     
                       
                         ≠ 
                         y 
                       
                     
                   
                 
               
             
           
         
       
     
     The method of implementing requires a table T of 2 n  bits in RAM. The table T is pre-processed as follows:
         1. r 3 ←{0; 1} n      2. For i=0 to 2 n −1 do T[i]←b   3. T[r 3 ]←b
 
This completes the pre-processing step.
       

     At the end of this pre-processing step, the table T satisfies: 
               b   ⁢           ⁢   if   ⁢           ⁢   x     =       T   ⁡     [   x   ]       =     {           r   3             b           otherwise                   
Then the compare b  function is implemented as:
 
return  T [( x⊕r   3 )⊕ y] 
 
In this case all intermediate variables in the computation are independent of x⊕y; this prevents any first-order side-channel leakage on x⊕y.
 
     The above-mentioned implementation of the compare b  is known in the art. Disadvantageously, the above-mentioned implementation of the compare b  is inefficient; the compare b  algorithm requires 2 n  bits of RAM; in practice however it may be more convenient to use 2 n  bytes of RAM since otherwise bit-access techniques must be used which might be cumbersome to implement securely. Pre-processing requires 2 n +1 memory transfers; such pre-processing must be done before every call to the RDP2 algorithm. Every call to compare b  then requires two XOR operations and one memory transfer. For AES with n=8, the compare b  function therefore requires 256 bytes of RAM and 257 memory transfers during pre-processing. In total, the RDP2 algorithm then requires 6·2 n  XOR operations, 3·2 n +1 memory transfers and the generation of n+1 random bits. 
     The method according to the present invention is based on a different implementation of the compare b  function, and in particular an implementation which uses match-in-place function. 
     Any processor has the usual instructions data←read(adr) and write(data; adr) that read and write some data at some address adr in memory. In match-in-place technology the processor has an additional function MIP(data; adr) that works as follows: 
     
       
         
           
             
               
                 MIP 
                 ⁡ 
                 
                   ( 
                   
                     data 
                     ; 
                     adr 
                   
                   ) 
                 
               
               ⁢ 
               1 
               ⁢ 
               
                   
               
               ⁢ 
               if 
               ⁢ 
               
                   
               
               ⁢ 
               read 
               ⁢ 
               
                   
               
               ⁢ 
               
                 ( 
                 adr 
                 ) 
               
             
             == 
             
               { 
               
                 
                   
                     data 
                   
                 
                 
                   
                     
                       0 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       otherwise 
                     
                   
                 
               
             
           
         
       
     
     In other words, data is matched at the memory location adr and the value at address adr never leaves the memory. 
     In the present invention there is provided additional function MIP I  which is a bit-randomized version of the MIP function, defined as follows: 
     
       
         
           
             
               
                 MIP 
                 I 
               
               ⁡ 
               
                 ( 
                 
                   
                     data 
                     ; 
                     
                       
                         b 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         if 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         read 
                         ⁢ 
                         
                             
                         
                         ⁢ 
                         
                           ( 
                           adr 
                           ) 
                         
                       
                       == 
                       adr 
                     
                   
                   , 
                   b 
                 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     data 
                   
                 
                 
                   
                     
                       b 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       otherwise 
                     
                   
                 
               
             
           
         
       
     
     Preferably there exists the following relationship:
 
MIP I (data;adr; b )=MIP(data;adr)⊕ b  
 
     Using the MIP I  function, the compare b  function can be simply implemented as follows, where adr is a free address in memory.
         compare b  (x; y):
           1. Write (x; adr)   2. Return MIP I  (y; adr; b)
 
Once x has been written at address adr in memory, the MIP I (y; adr; b) function returns b if x=y and b otherwise, as required by the compare b  function.
   
               

     Using the MIP I  function the computation of a second-order masked S-box function from a second-order masked input becomes as follows:
         Input: A masked value x=x⊕r 1 ⊕r 2 ⊕εF n   2 , a pair of output masks s 1 ; s 2 εF n 2, a free memory address adr.   Output: The masked S-box function output S(x)⊕s 1 ⊕s 2  
           1. b←rand(1)   2. for a=0 to 2 n −1 do
               (a) write (r 1 ⊕a; adr)   (b) cmp←MIP I  (r 2 ; adr; b)   (c) Rcmp←(S(x⊕a)⊕s 1 )⊕s 2      
               3. Return R b      
               

     The implementation of the compare b  function based on the MIP I  function, satisfies the same property as the original compare b  function implementation; namely all intermediate variables are independent of x⊕y. 
     Note that the randomized function MIP I (y; adr; b) is preferable. If the function MIP(y; adr) is used instead (by first computing MIP(y; adr) and then returning MIP(y; adr) ⊕b) then the implementation would be insecure, as the intermediate variable MIP(y; adr) is not independent from x⊕y. 
       FIG. 3  shows a table which compares the efficiency of the original implementation of compare b  function and the implementation of the compare b  function according to the present invention (i.e. using the MIP I  function). It is clear that fewer operations and less RAM is required to implement the compare b  function according to the present invention. 
       FIG. 4  shows a table which compares the efficiency of a masking algorithm originally implemented and a masking algorithm implemented according to the present invention (i.e. using the MIP I  function). For AES with n=8, the present invention requires 1 byte of RAM (instead of 2n), 1024 XORs (instead of 1536) and 512 memory transfers (instead of 769). If XORs and memory transfers have the same cost, the present invention variant is 33% faster the original implementation. Thus, for the same level of security, the present invention provides a faster counter-measure which requires less RAM. 
     Various modifications and variations to the described embodiments of the invention will be apparent to those skilled in the art without departing from the scope of the invention as defined in the appended claims. Although the invention has been described in connection with specific preferred embodiments, it should be understood that the invention as claimed should not be unduly limited to such specific embodiment.