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
128
129
130
131
|
package org.bouncycastle.crypto.engines;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.crypto.DataLengthException;
// BEGIN android-added
import org.bouncycastle.crypto.OutputLengthException;
// END android-added
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)
{
// BEGIN android-changed
throw new OutputLengthException("output buffer too short");
// END android-changed
}
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()
{
}
}
|
