1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
package org.bouncycastle.crypto.engines;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.DataLengthException;
import org.bouncycastle.crypto.OutputLengthException;
import org.bouncycastle.crypto.params.KeyParameter;
/**
* a class that provides a basic DESede (or Triple DES) engine.
*/
public class DESedeEngine
extends DESEngine
{
protected static final int BLOCK_SIZE = 8;
private int[] workingKey1 = null;
private int[] workingKey2 = null;
private int[] workingKey3 = null;
private boolean forEncryption;
/**
* standard constructor.
*/
public DESedeEngine()
{
}
/**
* initialise a DESede cipher.
*
* @param encrypting 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 encrypting,
CipherParameters params)
{
if (!(params instanceof KeyParameter))
{
throw new IllegalArgumentException("invalid parameter passed to DESede init - " + params.getClass().getName());
}
byte[] keyMaster = ((KeyParameter)params).getKey();
if (keyMaster.length != 24 && keyMaster.length != 16)
{
throw new IllegalArgumentException("key size must be 16 or 24 bytes.");
}
this.forEncryption = encrypting;
byte[] key1 = new byte[8];
System.arraycopy(keyMaster, 0, key1, 0, key1.length);
workingKey1 = generateWorkingKey(encrypting, key1);
byte[] key2 = new byte[8];
System.arraycopy(keyMaster, 8, key2, 0, key2.length);
workingKey2 = generateWorkingKey(!encrypting, key2);
if (keyMaster.length == 24)
{
byte[] key3 = new byte[8];
System.arraycopy(keyMaster, 16, key3, 0, key3.length);
workingKey3 = generateWorkingKey(encrypting, key3);
}
else // 16 byte key
{
workingKey3 = workingKey1;
}
}
public String getAlgorithmName()
{
return "DESede";
}
public int getBlockSize()
{
return BLOCK_SIZE;
}
public int processBlock(
byte[] in,
int inOff,
byte[] out,
int outOff)
{
if (workingKey1 == null)
{
throw new IllegalStateException("DESede engine not initialised");
}
if ((inOff + BLOCK_SIZE) > in.length)
{
throw new DataLengthException("input buffer too short");
}
if ((outOff + BLOCK_SIZE) > out.length)
{
throw new OutputLengthException("output buffer too short");
}
byte[] temp = new byte[BLOCK_SIZE];
if (forEncryption)
{
desFunc(workingKey1, in, inOff, temp, 0);
desFunc(workingKey2, temp, 0, temp, 0);
desFunc(workingKey3, temp, 0, out, outOff);
}
else
{
desFunc(workingKey3, in, inOff, temp, 0);
desFunc(workingKey2, temp, 0, temp, 0);
desFunc(workingKey1, temp, 0, out, outOff);
}
return BLOCK_SIZE;
}
public void reset()
{
}
}
|
