Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.crypto.engines;
  
An RC6 engine.
 
 public class RC6Engine
     implements BlockCipher
 {
     private static final int wordSize = 32;
     private static final int bytesPerWord =  / 8;
 
     /*
      * the number of rounds to perform
      */
     private static final int _noRounds = 20;
 
     /*
      * the expanded key array of size 2*(rounds + 1)
      */
     private int _S[];
 
     /*
      * our "magic constants" for wordSize 32
      *
      * Pw = Odd((e-2) * 2^wordsize)
      * Qw = Odd((o-2) * 2^wordsize)
      *
      * where e is the base of natural logarithms (2.718281828...)
      * and o is the golden ratio (1.61803398...)
      */
     private static final int    P32 = 0xb7e15163;
     private static final int    Q32 = 0x9e3779b9;
 
     private static final int    LGW = 5;        // log2(32)
 
     private boolean forEncryption;

    
Create an instance of the RC6 encryption algorithm and set some defaults
 
     public RC6Engine()
     {
                     = null;
     }
 
     public String getAlgorithmName()
     {
         return "RC6";
     }
 
     public int getBlockSize()
     {
         return 4 * ;
     }

    
initialise a RC5-32 cipher.

Parameters:
forEncryption whether or not we are for encryption.
params the parameters required to set up the cipher.
Throws:
java.lang.IllegalArgumentException if the params argument is inappropriate.
 
     public void init(
         boolean             forEncryption,
         CipherParameters    params)
     {
         if (!(params instanceof KeyParameter))
         {
             throw new IllegalArgumentException("invalid parameter passed to RC6 init - " + params.getClass().getName());
         }
 
         KeyParameter       p = (KeyParameter)params;
         this. = forEncryption;
         setKey(p.getKey());
     }
 
     public int processBlock(
         byte[]  in,
         int     inOff,
         byte[]  out,
         int     outOff)
     {
         int blockSize = getBlockSize();
         if ( == null)
         {
             throw new IllegalStateException("RC6 engine not initialised");
         }
         if ((inOff + blockSize) > in.length)
         {
             throw new DataLengthException("input buffer too short");
         }
        if ((outOff + blockSize) > out.length)
        {
            throw new OutputLengthException("output buffer too short");
        }
        return ()
            ?   encryptBlock(ininOffoutoutOff
            :   decryptBlock(ininOffoutoutOff);
    }
    public void reset()
    {
    }

    
Re-key the cipher.

Parameters:
key the key to be used
    private void setKey(
        byte[]      key)
    {
        //
        // KEY EXPANSION:
        //
        // There are 3 phases to the key expansion.
        //
        // Phase 1:
        //   Copy the secret key K[0...b-1] into an array L[0..c-1] of
        //   c = ceil(b/u), where u = wordSize/8 in little-endian order.
        //   In other words, we fill up L using u consecutive key bytes
        //   of K. Any unfilled byte positions in L are zeroed. In the
        //   case that b = c = 0, set c = 1 and L[0] = 0.
        //
        // compute number of dwords
        int c = (key.length + ( - 1)) / ;
        if (c == 0)
        {
            c = 1;
        }
        int[]   L = new int[(key.length +  - 1) / ];
        // load all key bytes into array of key dwords
        for (int i = key.length - 1; i >= 0; i--)
        {
            L[i / ] = (L[i / ] << 8) + (key[i] & 0xff);
        }
        //
        // Phase 2:
        //   Key schedule is placed in a array of 2+2*ROUNDS+2 = 44 dwords.
        //   Initialize S to a particular fixed pseudo-random bit pattern
        //   using an arithmetic progression modulo 2^wordsize determined
        //   by the magic numbers, Pw & Qw.
        //
                    = new int[2+2*+2];
        [0] = ;
        for (int i=1; i < .i++)
        {
            [i] = ([i-1] + );
        }
        //
        // Phase 3:
        //   Mix in the user's secret key in 3 passes over the arrays S & L.
        //   The max of the arrays sizes is used as the loop control
        //
        int iter;
        if (L.length > .)
        {
            iter = 3 * L.length;
        }
        else
        {
            iter = 3 * .;
        }
        int A = 0;
        int B = 0;
        int i = 0, j = 0;
        for (int k = 0; k < iterk++)
        {
            A = [i] = rotateLeft([i] + A + B, 3);
            B =  L[j] = rotateLeft(L[j] + A + BA+B);
            i = (i+1) % .;
            j = (j+1) %  L.length;
        }
    }
    private int encryptBlock(
        byte[]  in,
        int     inOff,
        byte[]  out,
        int     outOff)
    {
        // load A,B,C and D registers from in.
        int A = bytesToWord(ininOff);
        int B = bytesToWord(ininOff + );
        int C = bytesToWord(ininOff + *2);
        int D = bytesToWord(ininOff + *3);
        
        // Do pseudo-round #0: pre-whitening of B and D
        B += [0];
        D += [1];
        // perform round #1,#2 ... #ROUNDS of encryption 
        for (int i = 1; i <= i++)
        {
            int t = 0,u = 0;
            
            t = B*(2*B+1);
            t = rotateLeft(t,5);
            
            u = D*(2*D+1);
            u = rotateLeft(u,5);
            
            A ^= t;
            A = rotateLeft(A,u);
            A += [2*i];
            
            C ^= u;
            C = rotateLeft(C,t);
            C += [2*i+1];
            
            int temp = A;
            A = B;
            B = C;
            C = D;
            D = temp;            
        }
        // do pseudo-round #(ROUNDS+1) : post-whitening of A and C
        A += [2*+2];
        C += [2*+3];
            
        // store A, B, C and D registers to out        
        wordToBytes(AoutoutOff);
        wordToBytes(BoutoutOff + );
        wordToBytes(CoutoutOff + *2);
        wordToBytes(DoutoutOff + *3);
        
        return 4 * ;
    }
    private int decryptBlock(
        byte[]  in,
        int     inOff,
        byte[]  out,
        int     outOff)
    {
        // load A,B,C and D registers from out.
        int A = bytesToWord(ininOff);
        int B = bytesToWord(ininOff + );
        int C = bytesToWord(ininOff + *2);
        int D = bytesToWord(ininOff + *3);
        // Undo pseudo-round #(ROUNDS+1) : post whitening of A and C 
        C -= [2*+3];
        A -= [2*+2];
        
        // Undo round #ROUNDS, .., #2,#1 of encryption 
        for (int i = i >= 1; i--)
        {
            int t=0,u = 0;
            
            int temp = D;
            D = C;
            C = B;
            B = A;
            A = temp;
            
            t = B*(2*B+1);
            t = rotateLeft(t);
            
            u = D*(2*D+1);
            u = rotateLeft(u);
            
            C -= [2*i+1];
            C = rotateRight(C,t);
            C ^= u;
            
            A -= [2*i];
            A = rotateRight(A,u);
            A ^= t;
            
        }
        // Undo pseudo-round #0: pre-whitening of B and D
        D -= [1];
        B -= [0];
        
        wordToBytes(AoutoutOff);
        wordToBytes(BoutoutOff + );
        wordToBytes(CoutoutOff + *2);
        wordToBytes(DoutoutOff + *3);
        
        return 4 * ;
    }
    
    //////////////////////////////////////////////////////////////
    //
    // PRIVATE Helper Methods
    //
    //////////////////////////////////////////////////////////////

    
Perform a left "spin" of the word. The rotation of the given word x is rotated left by y bits. Only the lg(wordSize) low-order bits of y are used to determine the rotation amount. Here it is assumed that the wordsize used is 32.

Parameters:
x word to rotate
y number of bits to rotate % wordSize
    private int rotateLeft(int xint y)
    {
        return (x << y) | (x >>> -y);
    }

    
Perform a right "spin" of the word. The rotation of the given word x is rotated left by y bits. Only the lg(wordSize) low-order bits of y are used to determine the rotation amount. Here it is assumed that the wordsize used is a power of 2.

Parameters:
x word to rotate
y number of bits to rotate % wordSize
    private int rotateRight(int xint y)
    {
        return (x >>> y) | (x << -y);
    }
    private int bytesToWord(
        byte[]  src,
        int     srcOff)
    {
        int    word = 0;
        for (int i =  - 1; i >= 0; i--)
        {
            word = (word << 8) + (src[i + srcOff] & 0xff);
        }
        return word;
    }
    private void wordToBytes(
        int    word,
        byte[]  dst,
        int     dstOff)
    {
        for (int i = 0; i < i++)
        {
            dst[i + dstOff] = (byte)word;
            word >>>= 8;
        }
    }
New to GrepCode? Check out our FAQ X