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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
package org.bouncycastle.pqc.jcajce.provider.mceliece;
import java.io.IOException;
import java.security.PublicKey;
import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import org.bouncycastle.asn1.ASN1Primitive;
import org.bouncycastle.asn1.DERNull;
import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
import org.bouncycastle.crypto.CipherParameters;
import org.bouncycastle.pqc.asn1.McEliecePublicKey;
import org.bouncycastle.pqc.crypto.mceliece.McElieceKeyPairGenerator;
import org.bouncycastle.pqc.crypto.mceliece.McElieceParameters;
import org.bouncycastle.pqc.crypto.mceliece.McEliecePublicKeyParameters;
import org.bouncycastle.pqc.jcajce.spec.McEliecePublicKeySpec;
import org.bouncycastle.pqc.math.linearalgebra.GF2Matrix;
/**
* This class implements a McEliece public key and is usually instantiated by
* the {@link McElieceKeyPairGenerator} or {@link McElieceKeyFactorySpi}.
*/
public class BCMcEliecePublicKey
implements CipherParameters, PublicKey
{
/**
*
*/
private static final long serialVersionUID = 1L;
// the OID of the algorithm
private String oid;
/**
* the length of the code
*/
private int n;
/**
* the error correction capability of the code
*/
private int t;
/**
* the generator matrix
*/
private GF2Matrix g;
private McElieceParameters McElieceParams;
/**
* Constructor (used by the {@link McElieceKeyPairGenerator}).
*
* @param oid
* @param n the length of the code
* @param t the error correction capability of the code
* @param g the generator matrix
*/
public BCMcEliecePublicKey(String oid, int n, int t, GF2Matrix g)
{
this.oid = oid;
this.n = n;
this.t = t;
this.g = g;
}
/**
* Constructor (used by the {@link McElieceKeyFactorySpi}).
*
* @param keySpec a {@link McEliecePublicKeySpec}
*/
public BCMcEliecePublicKey(McEliecePublicKeySpec keySpec)
{
this(keySpec.getOIDString(), keySpec.getN(), keySpec.getT(), keySpec.getG());
}
public BCMcEliecePublicKey(McEliecePublicKeyParameters params)
{
this(params.getOIDString(), params.getN(), params.getT(), params.getG());
this.McElieceParams = params.getParameters();
}
/**
* Return the name of the algorithm.
*
* @return "McEliece"
*/
public String getAlgorithm()
{
return "McEliece";
}
/**
* @return the length of the code
*/
public int getN()
{
return n;
}
/**
* @return the dimension of the code
*/
public int getK()
{
return g.getNumRows();
}
/**
* @return the error correction capability of the code
*/
public int getT()
{
return t;
}
/**
* @return the generator matrix
*/
public GF2Matrix getG()
{
return g;
}
/**
* @return a human readable form of the key
*/
public String toString()
{
String result = "McEliecePublicKey:\n";
result += " length of the code : " + n + "\n";
result += " error correction capability: " + t + "\n";
result += " generator matrix : " + g.toString();
return result;
}
/**
* Compare this key with another object.
*
* @param other the other object
* @return the result of the comparison
*/
public boolean equals(Object other)
{
if (!(other instanceof BCMcEliecePublicKey))
{
return false;
}
BCMcEliecePublicKey otherKey = (BCMcEliecePublicKey)other;
return (n == otherKey.n) && (t == otherKey.t) && g.equals(otherKey.g);
}
/**
* @return the hash code of this key
*/
public int hashCode()
{
return n + t + g.hashCode();
}
/**
* @return the OID of the algorithm
*/
public String getOIDString()
{
return oid;
}
/**
* @return the OID to encode in the SubjectPublicKeyInfo structure
*/
protected ASN1ObjectIdentifier getOID()
{
return new ASN1ObjectIdentifier(McElieceKeyFactorySpi.OID);
}
/**
* @return the algorithm parameters to encode in the SubjectPublicKeyInfo
* structure
*/
protected ASN1Primitive getAlgParams()
{
return null; // FIXME: needed at all?
}
/**
* Return the keyData to encode in the SubjectPublicKeyInfo structure.
* <p>
* The ASN.1 definition of the key structure is
* <pre>
* McEliecePublicKey ::= SEQUENCE {
* n Integer -- length of the code
* t Integer -- error correcting capability
* matrixG OctetString -- generator matrix as octet string
* }
* </pre>
* </p>
* @return the keyData to encode in the SubjectPublicKeyInfo structure
*/
public byte[] getEncoded()
{
McEliecePublicKey key = new McEliecePublicKey(new ASN1ObjectIdentifier(oid), n, t, g);
AlgorithmIdentifier algorithmIdentifier = new AlgorithmIdentifier(this.getOID(), DERNull.INSTANCE);
try
{
SubjectPublicKeyInfo subjectPublicKeyInfo = new SubjectPublicKeyInfo(algorithmIdentifier, key);
return subjectPublicKeyInfo.getEncoded();
}
catch (IOException e)
{
return null;
}
}
public String getFormat()
{
return null;
}
public McElieceParameters getMcElieceParameters()
{
return McElieceParams;
}
}
|
