Docjar: A Java Source and Docuemnt Enginecom.*    java.*    javax.*    org.*    all    new    plug-in

Quick Search    Search Deep

Class RC2  view RC2 download

  extended byjavax.crypto.CipherSpi
      extended bycryptix.jce.provider.cipher.BlockCipher
          extended bycryptix.jce.provider.cipher.RC2

public final class RC2
extends BlockCipher


The source code (C version) from which this port was done, and (most of) the programming notes, are by P. Gutmann ( -- as obtained from Usenet.

Eric Young ( implementation, also based on Gutmann's work, and included in Eric's colossal SSL library ver 0.6.6 14 Jan 1997, was also used for the initial key data and the computation of the session key schedule. Code to tailor the session key for a specified length in bits is included in this Java implementation but is crippled (commented out). The current code behaves as if the session key is fixed at 1024-bit.

The RC2 algorithm is word (16-bit entity) oriented, operating on a block of 64 bits (or 8 Java bytes) divided into four words, with a key table of 64 words.

RC2 (TM) was designed by Ron Rivest, and was previously a trade secret of RSA Data Security, Inc. The algorithm has since been published as an RFC [reference?]. The name "RC2" is a trademark of RSA Data Security, Inc.

$Revision: 1.5 $

Field Summary
static int BLOCK_SIZE
          The block size, in bytes, of this cipher.
private  boolean decrypt
private static int[] S_BOX
          RC2 uses a single 256-byte S-box derived from the ciphertext contents of Beale Cipher No.1 XOR'd with a one-time pad.
private  int[] sKey
          The session key.
Fields inherited from class cryptix.jce.provider.cipher.BlockCipher
Constructor Summary
Method Summary
private  void blockDecrypt(byte[] in, int inOff, byte[] out, int outOff)
          Decrypt a single block.
private  void blockEncrypt(byte[] in, int inOff, byte[] out, int outOff)
          Encrypt a single block.
protected  void coreCrypt(byte[] in, int inOffset, byte[] out, int outOffset)
          Encrypt a given buffer.
protected  void coreInit( key, boolean decrypt)
private  void makeKey( key)
          Expands a user key to a working RC2 key.
Methods inherited from class cryptix.jce.provider.cipher.BlockCipher
clone, coreGetBlockSize, engineDoFinal, engineDoFinal, engineGetBlockSize, engineGetIV, engineGetKeySize, engineGetOutputSize, engineGetParameters, engineInit, engineInit, engineInit, engineSetMode, engineSetPadding, engineUpdate, engineUpdate
Methods inherited from class javax.crypto.CipherSpi
engineDoFinal, engineUnwrap, engineUpdate, engineWrap
Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail


public static final int BLOCK_SIZE
The block size, in bytes, of this cipher.

See Also:
Constant Field Values


private static final int[] S_BOX
RC2 uses a single 256-byte S-box derived from the ciphertext contents of Beale Cipher No.1 XOR'd with a one-time pad. The Beale Ciphers predate modern cryptography by enough time that there should be no concerns about trapdoors hidden in the data. They have been published widely, and the S-box can be easily recreated from the one-time pad values and the Beale Cipher data taken from a standard source. To initialise the S-box:
   for i = 0 to 255 do
     sBox[ i ] = ( beale[ i ] mod 256 ) ^ pad[ i ];

The following table gives the computed values based on the above. Thanks Eric :))


private int[] sKey
The session key. We're using the lower 16 bits of each int only.


private boolean decrypt
Constructor Detail


public RC2()
Method Detail


protected void coreInit( key,
                        boolean decrypt)
Specified by:
coreInit in class BlockCipher


protected void coreCrypt(byte[] in,
                         int inOffset,
                         byte[] out,
                         int outOffset)
Description copied from class: BlockCipher
Encrypt a given buffer. in and out can point to the same buffer if (outOffset == inOffset) || (outOffset >= (inOffset+coreGetBlockSize)) That is: the buffers may not partially overlap...

Specified by:
coreCrypt in class BlockCipher


private void makeKey( key)
Expands a user key to a working RC2 key.

The secret key is first expanded to fill 128 bytes (64 words). The expansion consists of taking the sum of the first and last bytes in the user key, looking up the sum (modulo 256) in the S-box, and appending the result to the key. The operation is repeated with the second byte and new last byte of the key until all 128 bytes have been generated. Note that the following pseudocode treats the S array (the session key) as an array of 128 bytes rather than 64 words:

   for j = 0 to length-1 do
     S[ j ] = K[ j ];
   for j = length to 127 do
     S[ j ] = sBox[ ( S[ j-length ] + S[ j-1 ] ) mod 256 ];


private void blockEncrypt(byte[] in,
                          int inOff,
                          byte[] out,
                          int outOff)
Encrypt a single block. Input and output may overlap.

The cipher has 16 full rounds, each divided into 4 subrounds. In addition the fifth and eleventh rounds add the contents of the S-box indexed by one of the data words to another of the data words following the four subrounds.


private void blockDecrypt(byte[] in,
                          int inOff,
                          byte[] out,
                          int outOff)
Decrypt a single block. Input and output may overlap.