Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.crypto.engines;
  
An TEA engine.
 
 public class TEAEngine
     implements BlockCipher
 {
     private static final int rounds     = 32,
                              block_size = 8,
 //                             key_size   = 16,
                              delta      = 0x9E3779B9,
                              d_sum      = 0xC6EF3720; // sum on decrypt
     /*
      * the expanded key array of 4 subkeys
      */
     private int _a_b_c_d;
     private boolean _initialised;
     private boolean _forEncryption;

    
Create an instance of the TEA encryption algorithm and set some defaults
 
     public TEAEngine()
     {
          = false;
     }
 
     public String getAlgorithmName()
     {
         return "TEA";
     }
 
     public int getBlockSize()
     {
         return ;
     }

    
initialise

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 TEA init - " + params.getClass().getName());
         }
 
          = forEncryption;
          = true;
 
         KeyParameter       p = (KeyParameter)params;
 
         setKey(p.getKey());
     }
 
     public int processBlock(
         byte[]  in,
         int     inOff,
         byte[]  out,
         int     outOff)
     {
         if (!)
         {
             throw new IllegalStateException(getAlgorithmName()+" not initialised");
         }
         
         if ((inOff + ) > in.length)
         {
             throw new DataLengthException("input buffer too short");
         }
         
         if ((outOff + ) > 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)
    {
        if (key.length != 16) 
        {
            throw new IllegalArgumentException("Key size must be 128 bits.");
        }
         = bytesToInt(key, 0);
         = bytesToInt(key, 4);
         = bytesToInt(key, 8);
         = bytesToInt(key, 12);
    }
    private int encryptBlock(
        byte[]  in,
        int     inOff,
        byte[]  out,
        int     outOff)
    {
        // Pack bytes into integers
        int v0 = bytesToInt(ininOff);
        int v1 = bytesToInt(ininOff + 4);
        
        int sum = 0;
        
        for (int i = 0; i != i++)
        {
            sum += ;
            v0  += ((v1 << 4) + ) ^ (v1 + sum) ^ ((v1 >>> 5) + );
            v1  += ((v0 << 4) + ) ^ (v0 + sum) ^ ((v0 >>> 5) + );
        }
        unpackInt(v0outoutOff);
        unpackInt(v1outoutOff + 4);
        
        return ;
    }
    private int decryptBlock(
        byte[]  in,
        int     inOff,
        byte[]  out,
        int     outOff)
    {
        // Pack bytes into integers
        int v0 = bytesToInt(ininOff);
        int v1 = bytesToInt(ininOff + 4);
        
        int sum = ;
        
        for (int i = 0; i != i++)
        {
            v1  -= ((v0 << 4) + ) ^ (v0 + sum) ^ ((v0 >>> 5) + );
            v0  -= ((v1 << 4) + ) ^ (v1 + sum) ^ ((v1 >>> 5) + );
            sum -= ;
        }
        
        unpackInt(v0outoutOff);
        unpackInt(v1outoutOff + 4);
        
        return ;
    }
    private int bytesToInt(byte[] inint inOff)
    {
        return ((in[inOff++]) << 24) |
                 ((in[inOff++] & 255) << 16) |
                 ((in[inOff++] & 255) <<  8) |
                 ((in[inOff] & 255));
    }
    private void unpackInt(int vbyte[] outint outOff)
    {
        out[outOff++] = (byte)(v >>> 24);
        out[outOff++] = (byte)(v >>> 16);
        out[outOff++] = (byte)(v >>>  8);
        out[outOff  ] = (byte)v;
    }
New to GrepCode? Check out our FAQ X