Intelligent Zero-Compress and High-Speed Encryption Process for Data Buffers
Original Publication Date: 1997-Sep-01
Included in the Prior Art Database: 2005-Apr-01
In most network environments, there is a requirement to be able to send data as fast as possible and as securely as possible.
Intelligent Zero-Compress and High-Speed Encryption
Process for Data
network environments, there is a requirement to be able
to send data as fast as possible and as securely as possible.
The process described here addresses this problem by:
o defining a very fast encryption algorithm based on a
variable number of bit rotations
o applying the rotations on a variable number of bytes
o encrypting the buffer after an XOR with a history buffer
and compressing out the resulting zero bytes
combination of all of the above results in a secure,
fast, and small encryption system, in particular, where with
following conditions can be assumed:
1. Most data sent from a given application is of a similar
2. If the current data buffer is XOR'd with the previous
data. Buffer, there is a significant percentage of zeros
in the resulting buffer (this is unlikely to be true for
voice or video data).
networks, the most time taken is in the transmission of
the data, and any reduction in the amount of data gives the most time
improvement. Zero compression is simple and fast, and the additional
overhead of using this encryption algorithm is not significant.
represents the data flow from the source application
to the compression and encryption process and finally out over the
described below are based on an Intel 486 (or
better) processor architecture; hence, the number of bits handled in
any single operation is 32 bits. Other processor architectures allow
more bits to be handled at a time. Alternatively, the code
complexity could be increased to handle more than 32 bits.
XOR and Copy Algorithm
condition is that the "previous buffer" is
initialized to "0", the effect of this being that the first time
through the XOR has no effect. At the same time, the data from the
new buffer is copied to the saved buffer. The next time through, the
XOR will be using the data from the first buffer. While performing
the XOR, the condition code is checked to see if the result is zero,
if it is a counter that is incremented. This way, the count of zeros
in the buffer can be checked with the size of the buffer to see if it
is worth compressing.
As a result
of the preceding code, the new data is XOR'd with
the old and an un-XOR'd copy replaces the data in the old buffer.
"ebx" contains a count of the number of DWORDs
that are zero in the updated new buffer.
count and comparing with the length of the buffer,
it can be seen if it is worth performing a run length compress.
Note: The above
code snippet assumes that the buffers are multiples
of DwORDs and that the old buffer is the same length as the new. The
code snippet would need modifying to handle different lengths.