Browse Prior Art Database

Intelligent Zero-Compress and High-Speed Encryption Process for Data Buffers

IP.com Disclosure Number: IPCOM000118925D
Original Publication Date: 1997-Sep-01
Included in the Prior Art Database: 2005-Apr-01
Document File: 6 page(s) / 196K

Publishing Venue

IBM

Related People

Lambert, H: AUTHOR

Abstract

In most network environments, there is a requirement to be able to send data as fast as possible and as securely as possible.

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 47% of the total text.

Intelligent Zero-Compress and High-Speed Encryption Process for Data
Buffers

      In most 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

      The 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
       format.
  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).

      In most 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.

      The Figure represents the data flow from the source application
to the compression and encryption process and finally out over the
network.

      The examples 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

      The starting 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.

      The register "ebx" contains a count of the number of DWORDs
that are zero in the updated new buffer.

      Using this 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.

Zero...