| package org.bouncycastle.crypto.macs; |
| |
| import org.bouncycastle.crypto.CipherParameters; |
| import org.bouncycastle.crypto.DataLengthException; |
| import org.bouncycastle.crypto.Mac; |
| import org.bouncycastle.crypto.params.KeyParameter; |
| import org.bouncycastle.crypto.params.ParametersWithSBox; |
| |
| /** |
| * implementation of GOST 28147-89 MAC |
| */ |
| public class GOST28147Mac |
| implements Mac |
| { |
| private int blockSize = 8; |
| private int macSize = 4; |
| private int bufOff; |
| private byte[] buf; |
| private byte[] mac; |
| private boolean firstStep = true; |
| private int[] workingKey = null; |
| |
| // |
| // This is default S-box - E_A. |
| private byte S[] = { |
| 0x9,0x6,0x3,0x2,0x8,0xB,0x1,0x7,0xA,0x4,0xE,0xF,0xC,0x0,0xD,0x5, |
| 0x3,0x7,0xE,0x9,0x8,0xA,0xF,0x0,0x5,0x2,0x6,0xC,0xB,0x4,0xD,0x1, |
| 0xE,0x4,0x6,0x2,0xB,0x3,0xD,0x8,0xC,0xF,0x5,0xA,0x0,0x7,0x1,0x9, |
| 0xE,0x7,0xA,0xC,0xD,0x1,0x3,0x9,0x0,0x2,0xB,0x4,0xF,0x8,0x5,0x6, |
| 0xB,0x5,0x1,0x9,0x8,0xD,0xF,0x0,0xE,0x4,0x2,0x3,0xC,0x7,0xA,0x6, |
| 0x3,0xA,0xD,0xC,0x1,0x2,0x0,0xB,0x7,0x5,0x9,0x4,0x8,0xF,0xE,0x6, |
| 0x1,0xD,0x2,0x9,0x7,0xA,0x6,0x0,0x8,0xC,0x4,0x5,0xF,0x3,0xB,0xE, |
| 0xB,0xA,0xF,0x5,0x0,0xC,0xE,0x8,0x6,0x2,0x3,0x9,0x1,0x7,0xD,0x4 |
| }; |
| |
| public GOST28147Mac() |
| { |
| mac = new byte[blockSize]; |
| |
| buf = new byte[blockSize]; |
| bufOff = 0; |
| } |
| |
| private int[] generateWorkingKey( |
| byte[] userKey) |
| { |
| if (userKey.length != 32) |
| { |
| throw new IllegalArgumentException("Key length invalid. Key needs to be 32 byte - 256 bit!!!"); |
| } |
| |
| int key[] = new int[8]; |
| for(int i=0; i!=8; i++) |
| { |
| key[i] = bytesToint(userKey,i*4); |
| } |
| |
| return key; |
| } |
| |
| public void init( |
| CipherParameters params) |
| throws IllegalArgumentException |
| { |
| reset(); |
| buf = new byte[blockSize]; |
| if (params instanceof ParametersWithSBox) |
| { |
| ParametersWithSBox param = (ParametersWithSBox)params; |
| |
| // |
| // Set the S-Box |
| // |
| System.arraycopy(param.getSBox(), 0, this.S, 0, param.getSBox().length); |
| |
| // |
| // set key if there is one |
| // |
| if (param.getParameters() != null) |
| { |
| workingKey = generateWorkingKey(((KeyParameter)param.getParameters()).getKey()); |
| } |
| } |
| else if (params instanceof KeyParameter) |
| { |
| workingKey = generateWorkingKey(((KeyParameter)params).getKey()); |
| } |
| else |
| { |
| throw new IllegalArgumentException("invalid parameter passed to GOST28147 init - " + params.getClass().getName()); |
| } |
| } |
| |
| public String getAlgorithmName() |
| { |
| return "GOST28147Mac"; |
| } |
| |
| public int getMacSize() |
| { |
| return macSize; |
| } |
| |
| private int gost28147_mainStep(int n1, int key) |
| { |
| int cm = (key + n1); // CM1 |
| |
| // S-box replacing |
| |
| int om = S[ 0 + ((cm >> (0 * 4)) & 0xF)] << (0 * 4); |
| om += S[ 16 + ((cm >> (1 * 4)) & 0xF)] << (1 * 4); |
| om += S[ 32 + ((cm >> (2 * 4)) & 0xF)] << (2 * 4); |
| om += S[ 48 + ((cm >> (3 * 4)) & 0xF)] << (3 * 4); |
| om += S[ 64 + ((cm >> (4 * 4)) & 0xF)] << (4 * 4); |
| om += S[ 80 + ((cm >> (5 * 4)) & 0xF)] << (5 * 4); |
| om += S[ 96 + ((cm >> (6 * 4)) & 0xF)] << (6 * 4); |
| om += S[112 + ((cm >> (7 * 4)) & 0xF)] << (7 * 4); |
| |
| return om << 11 | om >>> (32-11); // 11-leftshift |
| } |
| |
| private void gost28147MacFunc( |
| int[] workingKey, |
| byte[] in, |
| int inOff, |
| byte[] out, |
| int outOff) |
| { |
| int N1, N2, tmp; //tmp -> for saving N1 |
| N1 = bytesToint(in, inOff); |
| N2 = bytesToint(in, inOff + 4); |
| |
| for(int k = 0; k < 2; k++) // 1-16 steps |
| { |
| for(int j = 0; j < 8; j++) |
| { |
| tmp = N1; |
| N1 = N2 ^ gost28147_mainStep(N1, workingKey[j]); // CM2 |
| N2 = tmp; |
| } |
| } |
| |
| intTobytes(N1, out, outOff); |
| intTobytes(N2, out, outOff + 4); |
| } |
| |
| //array of bytes to type int |
| private int bytesToint( |
| byte[] in, |
| int inOff) |
| { |
| return ((in[inOff + 3] << 24) & 0xff000000) + ((in[inOff + 2] << 16) & 0xff0000) + |
| ((in[inOff + 1] << 8) & 0xff00) + (in[inOff] & 0xff); |
| } |
| |
| //int to array of bytes |
| private void intTobytes( |
| int num, |
| byte[] out, |
| int outOff) |
| { |
| out[outOff + 3] = (byte)(num >>> 24); |
| out[outOff + 2] = (byte)(num >>> 16); |
| out[outOff + 1] = (byte)(num >>> 8); |
| out[outOff] = (byte)num; |
| } |
| |
| private byte[] CM5func(byte[] buf, int bufOff, byte[] mac) |
| { |
| byte[] sum = new byte[buf.length - bufOff]; |
| |
| System.arraycopy(buf, bufOff, sum, 0, mac.length); |
| |
| for (int i = 0; i != mac.length; i++) |
| { |
| sum[i] = (byte)(sum[i] ^ mac[i]); |
| } |
| |
| return sum; |
| } |
| |
| public void update(byte in) |
| throws IllegalStateException |
| { |
| if (bufOff == buf.length) |
| { |
| byte[] sumbuf = new byte[buf.length]; |
| System.arraycopy(buf, 0, sumbuf, 0, mac.length); |
| |
| if (firstStep) |
| { |
| firstStep = false; |
| } |
| else |
| { |
| sumbuf = CM5func(buf, 0, mac); |
| } |
| |
| gost28147MacFunc(workingKey, sumbuf, 0, mac, 0); |
| bufOff = 0; |
| } |
| |
| buf[bufOff++] = in; |
| } |
| |
| public void update(byte[] in, int inOff, int len) |
| throws DataLengthException, IllegalStateException |
| { |
| if (len < 0) |
| { |
| throw new IllegalArgumentException("Can't have a negative input length!"); |
| } |
| |
| int gapLen = blockSize - bufOff; |
| |
| if (len > gapLen) |
| { |
| System.arraycopy(in, inOff, buf, bufOff, gapLen); |
| |
| byte[] sumbuf = new byte[buf.length]; |
| System.arraycopy(buf, 0, sumbuf, 0, mac.length); |
| |
| if (firstStep) |
| { |
| firstStep = false; |
| } |
| else |
| { |
| sumbuf = CM5func(buf, 0, mac); |
| } |
| |
| gost28147MacFunc(workingKey, sumbuf, 0, mac, 0); |
| |
| bufOff = 0; |
| len -= gapLen; |
| inOff += gapLen; |
| |
| while (len > blockSize) |
| { |
| sumbuf = CM5func(in, inOff, mac); |
| gost28147MacFunc(workingKey, sumbuf, 0, mac, 0); |
| |
| len -= blockSize; |
| inOff += blockSize; |
| } |
| } |
| |
| System.arraycopy(in, inOff, buf, bufOff, len); |
| |
| bufOff += len; |
| } |
| |
| public int doFinal(byte[] out, int outOff) |
| throws DataLengthException, IllegalStateException |
| { |
| //padding with zero |
| while (bufOff < blockSize) |
| { |
| buf[bufOff] = 0; |
| bufOff++; |
| } |
| |
| byte[] sumbuf = new byte[buf.length]; |
| System.arraycopy(buf, 0, sumbuf, 0, mac.length); |
| |
| if (firstStep) |
| { |
| firstStep = false; |
| } |
| else |
| { |
| sumbuf = CM5func(buf, 0, mac); |
| } |
| |
| gost28147MacFunc(workingKey, sumbuf, 0, mac, 0); |
| |
| System.arraycopy(mac, (mac.length/2)-macSize, out, outOff, macSize); |
| |
| reset(); |
| |
| return macSize; |
| } |
| |
| public void reset() |
| { |
| /* |
| * clean the buffer. |
| */ |
| for (int i = 0; i < buf.length; i++) |
| { |
| buf[i] = 0; |
| } |
| |
| bufOff = 0; |
| |
| firstStep = true; |
| } |
| } |