Patent Publication Number: US-5841872-A

Title: Encryption enhancement system

Description:
FIELD OF THE INVENTION 
     The present invention relates to encryption and, more particularly, to enhancement of data the security provided by encryption systems. 
     BACKGROUND OF THE INVENTION 
     Conventional encryption systems commonly use a pseudo-random number generator to encrypt a stream of data. For example, many conventional encryption systems involve XOR&#39;ing (bitwise) a stream of (pseudo) random numbers with the input data stream. So long as the random number stream is not known, the resulting output data also looks like a stream of random numbers. The principal way to crack the code is to learn how to recreate the random number stream and then to XOR the encrypted data stream with this random number stream, thereby regenerating the original data. 
     One problem with many conventional encryption systems based on random number generators is that it is possible to gain an understanding of the meaning of a message without fully decrypting the message. The reason is that, if two documents are essentially identical except for a single bit or byte, the resulting encrypted messages generally will be nearly identical as well. The same is true for decryption; if a single bit or byte is different, the decrypted messages will look nearly the same. 
     A common attack on the security of such encryption systems also exists. With the aid of computers, analysts compare how small variations in input data affect the encrypted data. By making a sufficient number of comparisons, analysts often can determine the secret random number sequence. 
     Many less sophisticated cryptography systems do not use a random number generator as described above. Instead, they use a rotating key of a fixed length to encrypt the data stream. This type of encryption system is easily cracked using differential analysis techniques. 
     Accordingly, there is a need to enhance many conventional encryption systems. 
     SUMMARY OF THE INVENTION 
     The present invention provides an encryption enhancement system utilizing a process hereafter referred to as &#34;data spinning,&#34; which involves introducing data into the random number generation process such that the output is a function of the introduced data. The present invention makes it more difficult break the security of encryption systems, because a single mistake in the decryption processes causes the remaining data to become totally scrambled. Nevertheless, this invention permits decryption using a straightforward, albeit nonintuitive, reversal process. 
     Many additional advantages of the present invention will become apparent to those skilled in the art based on the present disclosure. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     A complete understanding of the present invention may be gained by considering the following detailed description in conjunction with the accompanying drawing, in which: 
     FIG. 1 shows an encryption enhancement system according to the present invention. 
    
    
     DETAILED DESCRIPTION OF PREFERRED EMBODIMENT(S) 
     Embodiments of the present invention utilize the concept of data spinning. Certain embodiments can be used to enhance any encryption system making the enhanced system much more difficult to analyze and decipher. Other embodiments are used as stand alone encryption systems. 
     The technique of introducing input data into a pseudo-random number generating process has been used in the field of signature analysis. Signature analysis involves the creation of a random number based on the series of patterns (i.e., a signature data stream) that is introduced into a pseudo-random number generator. Signature analysis makes it possible to distinguish one stream of data from another stream in a statistical process known as error analysis. In error analysis, only the final state of the variables is important. This technique has not generally been used in cryptography, however, because of the lack of knowledge it takes to extract the original data from the encrypted data. 
     FIG. 1 shows one embodiment of an encryption system according to the present invention. In FIG. 1, the original input data stream 1 is encrypted, transmitted across an insecure channel 6, and decrypted by external decryption system 7, ultimately ending up as output data stream 11, which should be exactly the same as the original data stream. 
     Encryption/decryption enhancement system 2 (also referred to as &#34;LEFT SPIN 2&#34;) uses &#34;data spinning&#34; to enhance the encryption process. Main modifier 3 uses a reversible function (such as XOR to XOR, subtract to add, rotate left to rotate right, or other such reversible operations) to modify data. In certain embodiments, incoming data is modified by state equations modifier 4 with a function of state variables. State equations modifier 4 includes a series of state equations that include the input data. This makes the next state of the state variables a function of the input data stream. The output of main modifier 3 is fed into external encryption system 5, which may be any encryption system currently available on the market. The data leaving system 5 is broadcast on an insecure channel, such as the Internet or other public network. This data stream is now much more difficult to decipher. 
     In order to unscramble the data, external decryption system 7 is first used; then encryption/decryption enhancement system 8 (also referred to as &#34;RIGHT SPIN 8&#34;) operates on the resulting data. Because data spinning is a non-linear operation, order of operations is important. If external encryption system 5 were to preceed the left spin 2, then right spin 8 must preceed external decryption system 7. In the preferred embodiment, external decryption system 7 removes the last applied operation performed by external encryption system 5. After this operation, the data is &#34;unspun&#34; or &#34;spun right&#34; by state equations 10 and inverse modifier 9. Inverse modifier 9 applies the inverse of the process that was performed by main modifier 3. State equations 10 is identical to state equations 4 except for the fact that the result of the reverse modifier which resembles the original data is used instead of the data stream originating from the external decryption system 7. In this way, the sequence of the state variables are matched producing the same result. In FIG. 1, left spin 2 and right spin 8 can be exchanged. 
     DATA SPINNING 
     Data spinning is defined as the process by which the actual data is introduced into a random sequence generator. The reverse process is different from the forward process. Each process is labeled RIGHT SPIN or LEFT SPIN. Either process may be used to encrypt so long as the opposite process is used to decrypt. Below is a generalized system of equations that can be used to spin data: 
     RIGHT SPIN: 
     Y=Din MMOD Fm(X0,X1, . . . Xn) 
     X0={X0} MOD Fs0(Din,X0,X1, . . . Xn) 
     X1={X1} MOD Fs1(Din,X0,X1, . . . Xn) 
     Xn={Xn} MOD Fsn(Din,X0,X1, . . . Xn) 
     Where &#34;Y&#34; is defined as the encrypted output data stream. This output may be used directly or may be the input to another encryption engine such as PGP. Any data size may be used. Most common is 8-bit or byte format. 
     &#34;Din&#34; is defined as the input data stream. 
     &#34;MMOD&#34; (or main modifier) is a reversible combination operator. The most common examples are the bit-wise XOR operator and the ADD operator. Virtually every computer has these two operators. The XOR operator is fully reversible. The reverse direction of &#34;ADD&#34; is &#34;SUB&#34; or subtract. 
     MOD is any operator including lossey operations such as AND, OR. 
     &#34;Fm(X0,X1, . . . Xn)&#34; is a Boolean bitwise expression consisting of one or more state variables. 
     &#34;Fsn(D,X0,X1, . . . Xn)&#34; is the n th  Boolean bitwise expression consisting of one or more state variables plus an optional input data equation. 
     LEFT SPIN: 
     Y=Din IMOD Fm(X0,X1, . . . Xn) 
     X0=X0MOD Fs0(Y,X0,X1, . . . Xn) 
     X1=X1MOD Fs1(Y,X0,X1, . . . Xn) 
     Xn=Xn MOD Fsn(Y,X0,X1, . . . Xn) 
     &#34;IMOD&#34; (or inverse modifier is the inverse operation of&#34;MMOD&#34; defined in the RIGHT SPIN main modifier; otherwise, this equation is identical in every way. The inverse operation only occurs during the main modifier. The bitwise XOR operator is fully reversible whereby the same function may be used for both &#34;MOD&#34; and &#34;IMOD&#34;. In the event an ADD, or ROTATE is used, the inverse operation is used during the LEFT SPIN. 
     Each of the state variables in the LEFT SPIN is identical to the state variables in the RIGHT SPIN. The only difference is the substitution of &#34;Din&#34; with &#34;Y&#34; in each of the state variables. Note that the MOD operators are not reversed during the calculation phase of the state variables. It is possible but ill-advised to use lossey operators in place of the basic MOD operators (AND, OR, etc.). This is not recommended because of the possibility that the state variables which constitute a random sequence generator may converge into a constant stream. The function on the right side of the &#34;MOD&#34; operator may be lossey without harming the pseudo-random generation process. 
     The state variables constitute a random number generator with a seed value defined as the initial conditions of the state variables. A good test to see if the sequence is random is to force a continuous series of zeros into the data stream. The resulting sequence should be very close to white noise. The more operators that are added, the better the whiteness becomes. Adding real data only helps to further randomize the state variables. 
     Note that in the &#34;LEFT SPIN&#34; direction, the output of the main modifier is used instead of the input data as was used the &#34;RIGHT SPIN&#34; direction. 
     It is also possible to create a series of state equations that reference other state variables, as in the following example: 
     RIGHT SPIN: 
     X0=X2 MOD Fs0(Din,X0,X1,X2) 
     X1=X3 MOD Fs1(Din, X0,X1,X2) 
     X2=X1 MOD Fs2(Din,X0,X1,X2) 
     The analogous LEFT SPIN model could use &#34;Y&#34; in place of Din. Other potential combinations include but are not limited to using both Din and Y in the state equations 4, 10. Each state equation, when going from right spin to left spin, would replace Din with Y and vice versa. Below is an example employing this teaching: 
     RIGHT SPIN: 
     X0=X0 MOD Fs0(Din, X0,X1,X2) 
     X1=X1 MOD Fs1(Y, X0,X1,X2) 
     X2=X2 MOD Fs2(Din, X0,X1,X2) 
     LEFT SPIN: 
     X0=X0 MOD Fs0(Y,X0,X1,X2) 
     X1=X1 MOD Fs1(Din, X0,X1,X2) 
     X2=X2 MOD Fs2(Y,X0,X1,X2) 
     PROGRAM EXAMPLE 
     This program example uses 8 data spinners operating on 8-bit data. The right side of the MOD operator (in this example XOR or ADD is used) uses a variety of bizarre Boolean expressions. This demonstrates the variety and flexibility of data spinning. Both the transmitting and receiving systems must be exactly related or chaos will result. The variety of state equations offers yet another level of protection. This program shows data spinning as a stand alone encryption system. Below is a typical example: 
     
         ______________________________________                                    
#include &lt;stdio.h&gt;                                                        
typedef unsigned char byte;                                               
// complex data spinning encryption class written in C++:                 
class DataSpin                                                            
public:                                                                   
DataSpin(byte s = 113, byte t = 121, byte u = 73 , byte                   
v = 91 ,                                                                  
byte w = 201, byte x = 7 , byte y = 111, byte                             
z = 101 );                                                                
byte SPIN.sub.-- RIGHT(byte);                                             
byte SPIN.sub.-- LEFT(byte);                                              
private:                                                                  
byte S,T,U,V,W,X,Y,Z;                                                     
};                                                                        
DataSpin::DataSpin(byte s, byte t, byte u, byte v,                        
        byte w, byte x, byte y, byte z )                                  
{                                                                         
S=s; T=t; U=u; V=v; W=w; X=x; Y=y; Z=z;                                   
}                                                                         
byte DataSpin::SPIN.sub.-- RIGHT(byte DATA.sub.-- IN)                     
{                                                                         
byte DATA.sub.-- OUT;                                                     
DATA.sub.-- OUT = DATA.sub.-- IN + ((T + U)   (Y + V)   (W + S));         
// forward MOD == ADD                                                     
S += DATA.sub.-- IN + (Z &lt;&lt; (DATA.sub.-- IN &amp; 3 ));                       
                            // State                                      
Variables                                                                 
T  = DATA.sub.-- IN + X;                                                  
U += Y   ((W + X) &lt;&lt; (Z &amp; 3));                                            
V  = (Z + X) &lt;&lt; 1;                                                        
W += Z   Y;                                                               
X  = Z &lt;&lt;1;                                                               
Y += Z;                                                                   
Z  = DATA.sub.-- IN;                                                      
return DATA.sub.-- OUT;                                                   
}                                                                         
byte DataSpin::SPIN.sub.-- LEFT(byte DATA.sub.-- IN)                      
{                                                                         
byte DATA.sub.-- OUT;                                                     
DATA.sub.-- OUT = DATA.sub.-- IN - ((T + U)   (Y + V)   (W + S));         
// inverse *MOD == SUB                                                    
S += DATA.sub.-- OUT + (Z &lt;&lt; (DATA.sub.-- OUT &amp; 3 ));                     
                              //                                          
State Variables                                                           
T  = DATA.sub.-- OUT + X;                                                 
U += Y   ((W + X) &lt;&lt; (Z &amp; 3));                                            
V  = (Z + X) &lt;&lt; 1;                                                        
W += Z   Y;                                                               
X  = Z &lt;&lt;1;                                                               
Y += Z;                                                                   
Z  = DATA.sub.-- OUT;                                                     
return DATA.sub.-- OUT;                                                   
}                                                                         
void main( )                                                              
{                                                                         
static DataSpin A,B,C; // initialize to default settings                  
char *W = &#34;This is a test to see if this silly thing works                
or not|  &#34;;                                                               
static char X 60!,Z 60!;                                                  
int i;                                                                    
// encrypt W into X . . .                                                 
for (i=0;i&lt;60;i++) X i! = A.SPIN.sub.-- RIGHT(W i!);                      
// decrypt X into Z . . .  {W =? Z }                                      
for (i=0;i&lt;60;i++) Z i! = B.SPIN.sub.-- LEFT(X i!);                       
X 59!=0; // terminate the string so printf will stop|                     
printf(&#34;\nBelow is the encrypted text:\n%s\n
&#34;,X);                                                                     
printf(&#34;\nBelow should be readable:\n%s\n&#34;,Z
);                                                                        
// create a 1-bit displacement and try again:                             
X 5!  = 1;                                                                
for (i=0;i&lt;60;i++) Z i! = C.SPIN.sub.-- LEFT(X i!);                       
X 59!=0; // terminate the string so printf will stop|                     
printf(&#34;\nOne bit displacement on the fifth character           
below:\n%s\n&#34;,Z);                                     
}                                                                         
______________________________________                                    
 
    
     
         ______________________________________                                    
PROGRAM OUTPUT                                                            
______________________________________                                    
Below is the encrypted text:                                              
å°N, u□M+*.sub.-- (+%++¤;Å+}+&gt;n°
¥e-1/4Å.linevert split. .linevert split.4□.sub.-- |    
|                                                                
.linevert split.OA.sub.-- }+ef@ &lt;.sub.-- @a                               
Below should be readable:                                                 
This is a test to see if this silly thing works or not|                   
One bit displacement on the fifth character below:                        
This j+n-%                                                                
x□.sub.---- oe+a.linevert split.□ai-.sub.--         
!-§oo.sub.--.k□Å.sub.-- N--+.sub.-- -.sub.-- E&amp;1      
□t.sub.-- §d+□  §&lt;&lt;□  §.En
glish Pound.□  §                                          
______________________________________                                    
 
    
     PROGRAM COMMENTARY 
     With a single bit error in the 5 th  position, the encrypted data stream is totally garbled. By contrast, conventional encryption systems &#34;heal&#34; themselves after such an event. In other words, only the &#34;t&#34; in &#34;test&#34; would have been affected. There is no limit on how many state variables there could be. In this example there are only 8. Eight variables is equivalent to a 64-bit private key in other encryption systems known in the art. 
     The method by which the random numbers are generated by virtue of the state variables family of equations may also be considered as part of the difficulty of analyzing the data packets. 
     The state variables used in this program example are identical for LEFT --  SPIN and RIGHT --  SPIN except for the exchange of input and output data. It is important to note that reverse operators are not used in the state variables, but only in the &#34;main modifier&#34;. 
     Another possibility is to reverse the order of spinning: SPIN --  LEFT first to encrypt, then SPIN --  RIGHT to decrypt. The resulting encrypted stream is completely different when &#34;spun&#34; in this manner. 
     The present invention encompasses all subject-matter within the scope of the following claims. In this regard, it will be appreciated by those skilled in the art that additional embodiments of the present invention beyond those explicitly discussed above may be made without departing from the teachings of the present invention. Such embodiments are intended to be within the scope of the claims. 
     For example, it will be apparent to those skilled in the art based on the present disclosure that a decryption process can be used to encrypt data, and vice versa. In other words, decryption can be used as a form of encryption. It will further be apparent based on the present disclosure that the present invention may be implemented in hardware or software. 
     It will further be apparent to those skilled in the art based on the present disclosure that the present invention may be used to encrypt and decrypt data sent over the Internet or any other insecure channel for purposes of private communication, digital commerce, banking, or any other application.