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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
package javax.crypto.spec;
import java.security.spec.AlgorithmParameterSpec;
/**
* This class specifies the parameters used with the
* <a href="http://www.rsa.com/rsalabs/newfaq/q75.html"><i>RC2</i></a>
* algorithm.
* <p>
* The parameters consist of an effective key size and optionally
* an 8-byte initialization vector (IV) (only in feedback mode).
* <p>
* This class can be used to initialize a <code>Cipher</code> object that
* implements the <i>RC2</i> algorithm.
*/
public class RC2ParameterSpec
implements AlgorithmParameterSpec
{
private int effectiveKeyBits;
private byte[] iv = new byte[8];
/**
* Constructs a parameter set for RC2 from the given effective key size
* (in bits).
*
* @param effectiveKeyBits the effective key size in bits.
*/
public RC2ParameterSpec(
int effectiveKeyBits)
{
this.effectiveKeyBits = effectiveKeyBits;
}
/**
* Constructs a parameter set for RC2 from the given effective key size
* (in bits) and an 8-byte IV.
* <p>
* The bytes that constitute the IV are those between
* <code>iv[0]</code> and <code>iv[7]</code> inclusive.
*
* @param effectiveKeyBits the effective key size in bits.
* @param iv the buffer with the 8-byte IV.
*/
public RC2ParameterSpec(
int effectiveKeyBits,
byte[] iv)
{
this(effectiveKeyBits, iv, 0);
}
/**
* Constructs a parameter set for RC2 from the given effective key size
* (in bits) and IV.
* <p>
* The IV is taken from <code>iv</code>, starting at
* <code>offset</code> inclusive.
* The bytes that constitute the IV are those between
* <code>iv[offset]</code> and <code>iv[offset+7]</code> inclusive.
*
* @param effectiveKeyBits the effective key size in bits.
* @param iv the buffer with the IV.
* @param offset the offset in <code>iv</code> where the 8-byte IV starts.
*/
public RC2ParameterSpec(
int effectiveKeyBits,
byte[] iv,
int offset)
{
this.effectiveKeyBits = effectiveKeyBits;
this.iv = new byte[8];
System.arraycopy(iv, offset, this.iv, 0, this.iv.length);
}
/**
* Returns the effective key size in bits.
*
* @return the effective key size in bits.
*/
public int getEffectiveKeyBits()
{
return effectiveKeyBits;
}
/**
* Returns the IV or null if this parameter set does not contain an IV.
*
* @return the IV or null if this parameter set does not contain an IV.
*/
public byte[] getIV()
{
if (iv == null)
{
return null;
}
byte[] tmp = new byte[iv.length];
System.arraycopy(iv, 0, tmp, 0, tmp.length);
return tmp;
}
/**
* Tests for equality between the specified object and this
* object. Two RC2ParameterSpec objects are considered equal if their
* effective key sizes and IVs are equal.
* (Two IV references are considered equal if both are <tt>null</tt>.)
*
* @param obj the object to test for equality with this object.
* @return true if the objects are considered equal, false otherwise.
* @override equals in class java.lang.Object
*/
public boolean equals(
Object obj)
{
if ((obj == null) || !(obj instanceof RC2ParameterSpec))
{
return false;
}
RC2ParameterSpec spec = (RC2ParameterSpec)obj;
if (this.effectiveKeyBits != spec.effectiveKeyBits)
{
return false;
}
if (iv != null)
{
if (spec.iv == null)
{
return false;
}
for (int i = 0; i != iv.length; i++)
{
if (iv[i] != spec.iv[i])
{
return false;
}
}
}
else if (spec.iv != null)
{
return false;
}
return true;
}
/**
* Calculates a hash code value for the object.
* Objects that are equal will also have the same hashcode.
*
* @override hashCode in class java.lang.Object
*/
public int hashCode()
{
throw new RuntimeException("Not yet implemented");
}
}
|
