camelliaengine.java

bouncycastle 是一个JAVA安全提供者

package org.bouncycastle.crypto.engines;

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

/**
 * Camellia - based on RFC 3713.
 */
public class CamelliaEngine implements BlockCipher
{
    private boolean _keyIs128;
    
    private static final int  BLOCK_SIZE = 16;
    
    private static final long MASK8 = 0xff;
    private static final long MASK32 = 0xffffffffL;
    
    private static final long SIGMA1 = 0xA09E667F3BCC908BL;
    private static final long SIGMA2 = 0xB67AE8584CAA73B2L;
    private static final long SIGMA3 = 0xC6EF372FE94F82BEL;
    private static final long SIGMA4 = 0x54FF53A5F1D36F1CL;
    private static final long SIGMA5 = 0x10E527FADE682D1DL;
    private static final long SIGMA6 = 0xB05688C2B3E6C1FDL;
    
    private long   _kw1, _kw2, _kw3, _kw4;
    private long   _k1, _k2, _k3, _k4, _k5, _k6, _k7, _k8, _k9, _k10, _k11, _k12,
                   _k13, _k14, _k15, _k16, _k17, _k18, _k19, _k20, _k21, _k22, _k23, _k24;
    private long   _ke1, _ke2, _ke3, _ke4, _ke5, _ke6;
    
    private final byte[] SBOX1 = {
            (byte)112, (byte)130,  (byte)44,  (byte)236,  (byte)179 ,  (byte)39,  (byte)192,  (byte)229,  (byte)228,  (byte)133 ,  (byte)87 ,  (byte)53,  (byte)234 ,  (byte)12,  (byte)174 , (byte)65,
             (byte)35, (byte)239,  (byte)107,  (byte)147 ,  (byte)69 ,  (byte)25,  (byte)165 ,  (byte)33,  (byte)237 ,  (byte)14 ,  (byte)79 ,  (byte)78 ,  (byte)29,  (byte)101,  (byte)146,  (byte)189,
            (byte)134, (byte)184,   (byte)175,  (byte)143,  (byte)124,  (byte)235 ,  (byte)31,  (byte)206 ,  (byte)62 ,  (byte)48,  (byte)220 ,  (byte)95 ,  (byte)94,  (byte)197 ,  (byte)11 ,  (byte)26,
            (byte)166, (byte)225,  (byte)57,  (byte)202,  (byte)213 ,  (byte)71 ,  (byte)93 ,  (byte)61,  (byte)217  ,  (byte)1 ,  (byte)90,  (byte)214 ,  (byte)81 ,  (byte)86,  (byte)108 ,  (byte)77,
            (byte)139, (byte)13,  (byte)154,  (byte)102,  (byte)251,  (byte)204,  (byte)176 ,  (byte)45,  (byte)116 ,  (byte)18 ,  (byte)43 ,  (byte)32,  (byte)240,  (byte)177,  (byte)132,  (byte)153,
            (byte)223, (byte)76,  (byte)203,  (byte)194 ,  (byte)52,  (byte)126,  (byte)118  ,  (byte)5,  (byte)109,  (byte)183,  (byte)169 ,  (byte)49,  (byte)209 ,  (byte)23  ,  (byte)4,  (byte)215,
             (byte)20, (byte)88,  (byte)58,  (byte)97,  (byte)222 ,  (byte)27 ,  (byte)17 ,  (byte)28 ,  (byte)50 ,  (byte)15,  (byte)156 ,  (byte)22 ,  (byte)83 ,  (byte)24,  (byte)242 ,  (byte)34,
            (byte)254, (byte)68,  (byte)207,  (byte)178,  (byte)195,  (byte)181,  (byte)122,  (byte)145 ,  (byte)36  ,  (byte)8,  (byte)232,  (byte)168 ,  (byte)96,  (byte)252,  (byte)105 ,  (byte)80,
            (byte)170, (byte)208,  (byte)160,  (byte)125,  (byte)161,  (byte)137 ,  (byte)98,  (byte)151 ,  (byte)84 ,  (byte)91 ,  (byte)30,  (byte)149,  (byte)224,  (byte)255,  (byte)100,  (byte)210,
             (byte)16, (byte)196,  (byte)0,  (byte)72,  (byte)163,  (byte)247,  (byte)117,  (byte)219,  (byte)138  ,  (byte)3,  (byte)230,  (byte)218  ,  (byte)9 ,  (byte)63,  (byte)221,  (byte)148,
            (byte)135, (byte)92,  (byte)131,  (byte)2,  (byte)205 ,  (byte)74,  (byte)144 ,  (byte)51,  (byte)115,  (byte)103,  (byte)246,  (byte)243,  (byte)157,  (byte)127,  (byte)191,  (byte)226,
             (byte)82, (byte)155,  (byte)216 ,  (byte)38,  (byte)200 ,  (byte)55,  (byte)198 ,  (byte)59,  (byte)129,  (byte)150,  (byte)111 ,  (byte)75 ,  (byte)19,  (byte)190 ,  (byte)99 ,  (byte)46,
            (byte)233, (byte)121,  (byte)167,  (byte)140,  (byte)159,  (byte)110,  (byte)188,  (byte)142 ,  (byte)41,  (byte)245,  (byte)249,  (byte)182 ,  (byte)47,  (byte)253,  (byte)180 ,  (byte)89,
            (byte)120, (byte)152,  (byte)6,  (byte)106,  (byte)231 ,  (byte)70,  (byte)113,  (byte)186,  (byte)212 ,  (byte)37,  (byte)171 ,  (byte)66,  (byte)136,  (byte)162,  (byte)141,  (byte)250,
            (byte)114, (byte)7,  (byte)185 ,  (byte)85,  (byte)248,  (byte)238,  (byte)172 ,  (byte)10 ,  (byte)54 ,  (byte)73 ,  (byte)42,  (byte)104 ,  (byte)60 ,  (byte)56,  (byte)241,  (byte)164,
             (byte)64, (byte)40,  (byte)211,  (byte)123,  (byte)187,  (byte)201 ,  (byte)67,  (byte)193 ,  (byte)21,  (byte)227,  (byte)173,  (byte)244,  (byte)119,  (byte)199,  (byte)128,  (byte)158
        };
    
    private final byte[] SBOX2 = new byte[256];
    private final byte[] SBOX3 = new byte[256];
    private final byte[] SBOX4 = new byte[256];

    
    public CamelliaEngine()
    {
        for (int x = 0; x != 256; x++)
        {
            SBOX2[x] = lRot8(SBOX1[x], 1);
            SBOX3[x] = lRot8(SBOX1[x], 7);
            SBOX4[x] = SBOX1[lRot8((byte)x, 1) & 0xff];
        }
    }
         
    private void setKey(
        boolean forEncryption,
        byte[]  key)
    {
        long klA, klB;
        long krA, krB;
        
        switch (key.length)
        {
        case 16:
            _keyIs128 = true;
            klA = bytesToWord(key, 0);
            klB = bytesToWord(key, 8);
            krA = 0;
            krB = 0;
            break;
        case 24:
            klA = bytesToWord(key, 0);
            klB = bytesToWord(key, 8);
            krA = bytesToWord(key, 16);
            krB = ~bytesToWord(key, 16);
            _keyIs128 = false;
            break;
        case 32:
            klA = bytesToWord(key, 0);
            klB = bytesToWord(key, 8);
            krA = bytesToWord(key, 16);
            krB = bytesToWord(key, 24);
            _keyIs128 = false;
            break;
        default:
            throw new IllegalArgumentException("only a key sizes of 128/192/256 are acceptable.");
        }
        
        long d1 = klA ^ krA;
        long d2 = klB ^ krB;
        
        d2 = d2 ^ f(d1, SIGMA1);
        d1 = d1 ^ f(d2, SIGMA2);
        d1 = d1 ^ klA;
        d2 = d2 ^ klB;
        d2 = d2 ^ f(d1, SIGMA3);
        d1 = d1 ^ f(d2, SIGMA4);
        
        long kaA = d1;
        long kaB = d2;

        if (_keyIs128)
        {
            if (forEncryption)
            {
                _kw1 = klA;
                _kw2 = klB;
                _kw3 = lRot128high(kaA, kaB, 111);
                _kw4 = lRot128low(kaA, kaB, 111);
                _k1  = kaA;
                _k2  = kaB;
                _k3  = lRot128high(klA, klB, 15);
                _k4  = lRot128low(klA, klB, 15);
                _k5  = lRot128high(kaA, kaB, 15);
                _k6  = lRot128low(kaA, kaB, 15);
                _k7  = lRot128high(klA, klB, 45);
                _k8  = lRot128low(klA, klB, 45);
                _k9  = lRot128high(kaA, kaB, 45);
                _k10 = lRot128low(klA, klB,  60);
                _k11 = lRot128high(kaA, kaB, 60);
                _k12 = lRot128low(kaA, kaB, 60);
                _k13 = lRot128high(klA, klB, 94);
                _k14 = lRot128low(klA, klB, 94);
                _k15 = lRot128high(kaA, kaB, 94);
                _k16 = lRot128low(kaA, kaB, 94);
                _k17 = lRot128high(klA, klB, 111);
                _k18 = lRot128low(klA, klB, 111);
                _ke1 = lRot128high(kaA, kaB, 30);
                _ke2 = lRot128low(kaA, kaB, 30);
                _ke3 = lRot128high(klA, klB, 77);
                _ke4 = lRot128low(klA, klB, 77);
            }
            else
            {
                _kw3 = klA;
                _kw4 = klB;
                _kw1 = lRot128high(kaA, kaB, 111);
                _kw2 = lRot128low(kaA, kaB, 111);
                _k18 = kaA;
                _k17 = kaB;
                _k16 = lRot128high(klA, klB, 15);
                _k15 = lRot128low(klA, klB, 15);
                _k14 = lRot128high(kaA, kaB, 15);
                _k13 = lRot128low(kaA, kaB, 15);
                _k12 = lRot128high(klA, klB, 45);
                _k11 = lRot128low(klA, klB, 45);
                _k10 = lRot128high(kaA, kaB, 45);
                _k9  = lRot128low(klA, klB,  60);
                _k8  = lRot128high(kaA, kaB, 60);
                _k7  = lRot128low(kaA, kaB, 60);
                _k6  = lRot128high(klA, klB, 94);
                _k5  = lRot128low(klA, klB, 94);
                _k4  = lRot128high(kaA, kaB, 94);
                _k3  = lRot128low(kaA, kaB, 94);
                _k2  = lRot128high(klA, klB, 111);
                _k1  = lRot128low(klA, klB, 111);
                _ke4 = lRot128high(kaA, kaB, 30);
                _ke3 = lRot128low(kaA, kaB, 30);
                _ke2 = lRot128high(klA, klB, 77);
                _ke1 = lRot128low(klA, klB, 77);
            }
        }
        else
        {
            d1 = kaA ^ krA;
            d2 = kaB ^ krB;
            d2 = d2 ^ f(d1, SIGMA5);
            d1 = d1 ^ f(d2, SIGMA6);
            
            long kbA = d1;
            long kbB = d2;
            
            if (forEncryption)
            {
                _kw1 = klA;
                _kw2 = klB;
                _k1  = kbA;
                _k2  = kbB;
                _k3  = lRot128high(krA, krB, 15);
                _k4  = lRot128low(krA, krB, 15);
                _k5  = lRot128high(kaA, kaB, 15);
                _k6  = lRot128low(kaA, kaB, 15);
                _ke1 = lRot128high(krA, krB, 30);
                _ke2 = lRot128low(krA, krB, 30);
                _k7  = lRot128high(kbA, kbB, 30);
                _k8  = lRot128low(kbA, kbB, 30);
                _k9  = lRot128high(klA, klB, 45);
                _k10 = lRot128low(klA, klB, 45);
                _k11 = lRot128high(kaA, kaB, 45);
                _k12 = lRot128low(kaA, kaB, 45);
                _ke3 = lRot128high(klA, klB, 60);
                _ke4 = lRot128low(klA, klB, 60);
                _k13 = lRot128high(krA, krB, 60);
                _k14 = lRot128low(krA, krB, 60);
                _k15 = lRot128high(kbA, kbB, 60);
                _k16 = lRot128low(kbA, kbB, 60);
                _k17 = lRot128high(klA, klB, 77);
                _k18 = lRot128low(klA, klB, 77);
                _ke5 = lRot128high(kaA, kaB, 77);
                _ke6 = lRot128low(kaA, kaB, 77);
                _k19 = lRot128high(krA, krB, 94);
                _k20 = lRot128low(krA, krB, 94);
                _k21 = lRot128high(kaA, kaB, 94);
                _k22 = lRot128low(kaA, kaB, 94);
                _k23 = lRot128high(klA, klB, 111);
                _k24 = lRot128low(klA, klB, 111);
                _kw3 = lRot128high(kbA, kbB, 111);
                _kw4 = lRot128low(kbA, kbB, 111);
            }
            else
            {
                _kw3 = klA;
                _kw4 = klB;
                _kw1 = lRot128high(kbA, kbB, 111);
                _kw2 = lRot128low(kbA, kbB, 111);
                _k24 = kbA;
                _k23 = kbB;
                _k22 = lRot128high(krA, krB, 15);
                _k21 = lRot128low(krA, krB, 15);
                _k20 = lRot128high(kaA, kaB, 15);
                _k19 = lRot128low(kaA, kaB, 15);
                _k18 = lRot128high(kbA, kbB, 30);
                _k17 = lRot128low(kbA, kbB, 30);
                _k16 = lRot128high(klA, klB, 45);
                _k15 = lRot128low(klA, klB, 45);
                _k14 = lRot128high(kaA, kaB, 45);
                _k13 = lRot128low(kaA, kaB, 45);
                _k12 = lRot128high(krA, krB, 60);
                _k11 = lRot128low(krA, krB, 60);
                _k10 = lRot128high(kbA, kbB, 60);
                _k9  = lRot128low(kbA, kbB, 60);
                _k8  = lRot128high(klA, klB, 77);
                _k7  = lRot128low(klA, klB, 77);
                _k6  = lRot128high(krA, krB, 94);
                _k5  = lRot128low(krA, krB, 94);
                _k4  = lRot128high(kaA, kaB, 94);
                _k3  = lRot128low(kaA, kaB, 94);
                _k2  = lRot128high(klA, klB, 111);
                _k1  = lRot128low(klA, klB, 111); 
                _ke6 = lRot128high(krA, krB, 30);
                _ke5 = lRot128low(krA, krB, 30);
                _ke4 = lRot128high(klA, klB, 60);
                _ke3 = lRot128low(klA, klB, 60);
                _ke2 = lRot128high(kaA, kaB, 77);
                _ke1 = lRot128low(kaA, kaB, 77);
            }
        }
    }
    
    public void init(boolean forEncryption, CipherParameters params)
            throws IllegalArgumentException
    {
        if (!(params instanceof KeyParameter))
        {
            throw new IllegalArgumentException("only simple KeyParameter expected.");
        }
        
        setKey(forEncryption, ((KeyParameter)params).getKey());
    }

    public String getAlgorithmName()
    {
        return "Camellia";
    }

    public int getBlockSize()