All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.bouncycastle.crypto.engines.NoekeonEngine Maven / Gradle / Ivy

Go to download

The Bouncy Castle Crypto package is a Java implementation of cryptographic algorithms. This jar contains JCE provider and lightweight API for the Bouncy Castle Cryptography APIs for JDK 1.5 to JDK 1.8 with debug enabled.

There is a newer version: 1.70
Show newest version
package org.bouncycastle.crypto.engines;

import org.bouncycastle.crypto.BlockCipher;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.DataLengthException;
import org.bouncycastle.crypto.OutputLengthException;
import org.bouncycastle.crypto.params.KeyParameter;

/**
 * A Noekeon engine, using direct-key mode.
 */

public class NoekeonEngine
    implements BlockCipher
{
    private static final int genericSize = 16; // Block and key size, as well as the amount of rounds.
    
    private static final int[] nullVector = 
                               {
                                    0x00, 0x00, 0x00, 0x00 // Used in decryption
                               },
        
                               roundConstants = 
                               {
                                    0x80, 0x1b, 0x36, 0x6c,
                                    0xd8, 0xab, 0x4d, 0x9a,
                                    0x2f, 0x5e, 0xbc, 0x63,
                                    0xc6, 0x97, 0x35, 0x6a,
                                    0xd4
                               };
    
    private int[] state   = new int[4], // a
                  subKeys = new int[4], // k
                  decryptKeys = new int[4];
    
    private boolean _initialised,
                    _forEncryption;
    
    /**
     * Create an instance of the Noekeon encryption algorithm
     * and set some defaults
     */
    public NoekeonEngine()
    {
        _initialised = false;
    }
    
    public String getAlgorithmName()
    {
        return "Noekeon";
    }
    
    public int getBlockSize()
    {
        return genericSize;
    }
    
    /**
     * initialise
     *
     * @param forEncryption whether or not we are for encryption.
     * @param params the parameters required to set up the cipher.
     * @exception 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 Noekeon init - " + params.getClass().getName());
        }
        
        _forEncryption = forEncryption;
        _initialised = true;
        
        KeyParameter       p = (KeyParameter)params;
        
        setKey(p.getKey());
    }
    
    public int processBlock(
                            byte[]  in,
                            int     inOff,
                            byte[]  out,
                            int     outOff)
    {
        if (!_initialised)
        {
            throw new IllegalStateException(getAlgorithmName()+" not initialised");
        }
        
        if ((inOff + genericSize) > in.length)
        {
            throw new DataLengthException("input buffer too short");
        }
        
        if ((outOff + genericSize) > out.length)
        {
            throw new OutputLengthException("output buffer too short");
        }
        
        return (_forEncryption) ? encryptBlock(in, inOff, out, outOff)
                                : decryptBlock(in, inOff, out, outOff);
    }
    
    public void reset()
    {
    }
    
    /**
     * Re-key the cipher.
     * 

* @param key the key to be used */ private void setKey( byte[] key) { subKeys[0] = bytesToIntBig(key, 0); subKeys[1] = bytesToIntBig(key, 4); subKeys[2] = bytesToIntBig(key, 8); subKeys[3] = bytesToIntBig(key, 12); } private int encryptBlock( byte[] in, int inOff, byte[] out, int outOff) { state[0] = bytesToIntBig(in, inOff); state[1] = bytesToIntBig(in, inOff+4); state[2] = bytesToIntBig(in, inOff+8); state[3] = bytesToIntBig(in, inOff+12); int i; for (i = 0; i < genericSize; i++) { state[0] ^= roundConstants[i]; theta(state, subKeys); pi1(state); gamma(state); pi2(state); } state[0] ^= roundConstants[i]; theta(state, subKeys); intToBytesBig(state[0], out, outOff); intToBytesBig(state[1], out, outOff+4); intToBytesBig(state[2], out, outOff+8); intToBytesBig(state[3], out, outOff+12); return genericSize; } private int decryptBlock( byte[] in, int inOff, byte[] out, int outOff) { state[0] = bytesToIntBig(in, inOff); state[1] = bytesToIntBig(in, inOff+4); state[2] = bytesToIntBig(in, inOff+8); state[3] = bytesToIntBig(in, inOff+12); System.arraycopy(subKeys, 0, decryptKeys, 0, subKeys.length); theta(decryptKeys, nullVector); int i; for (i = genericSize; i > 0; i--) { theta(state, decryptKeys); state[0] ^= roundConstants[i]; pi1(state); gamma(state); pi2(state); } theta(state, decryptKeys); state[0] ^= roundConstants[i]; intToBytesBig(state[0], out, outOff); intToBytesBig(state[1], out, outOff+4); intToBytesBig(state[2], out, outOff+8); intToBytesBig(state[3], out, outOff+12); return genericSize; } private void gamma(int[] a) { a[1] ^= ~a[3] & ~a[2]; a[0] ^= a[2] & a[1]; int tmp = a[3]; a[3] = a[0]; a[0] = tmp; a[2] ^= a[0]^a[1]^a[3]; a[1] ^= ~a[3] & ~a[2]; a[0] ^= a[2] & a[1]; } private void theta(int[] a, int[] k) { int tmp; tmp = a[0]^a[2]; tmp ^= rotl(tmp,8)^rotl(tmp,24); a[1] ^= tmp; a[3] ^= tmp; for (int i = 0; i < 4; i++) { a[i] ^= k[i]; } tmp = a[1]^a[3]; tmp ^= rotl(tmp,8)^rotl(tmp,24); a[0] ^= tmp; a[2] ^= tmp; } private void pi1(int[] a) { a[1] = rotl(a[1], 1); a[2] = rotl(a[2], 5); a[3] = rotl(a[3], 2); } private void pi2(int[] a) { a[1] = rotl(a[1], 31); a[2] = rotl(a[2], 27); a[3] = rotl(a[3], 30); } // Helpers private int bytesToIntBig(byte[] in, int off) { return ((in[off++]) << 24) | ((in[off++] & 0xff) << 16) | ((in[off++] & 0xff) << 8) | (in[off ] & 0xff); } private void intToBytesBig(int x, byte[] out, int off) { out[off++] = (byte)(x >>> 24); out[off++] = (byte)(x >>> 16); out[off++] = (byte)(x >>> 8); out[off ] = (byte)x; } private int rotl(int x, int y) { return (x << y) | (x >>> (32-y)); } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy