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
|
package org.bouncycastle.pqc.crypto.mceliece;
import org.bouncycastle.pqc.math.linearalgebra.GF2Matrix;
import org.bouncycastle.pqc.math.linearalgebra.GF2mField;
import org.bouncycastle.pqc.math.linearalgebra.Permutation;
import org.bouncycastle.pqc.math.linearalgebra.PolynomialGF2mSmallM;
public class McEliecePrivateKeyParameters
extends McElieceKeyParameters
{
// the OID of the algorithm
private String oid;
// the length of the code
private int n;
// the dimension of the code, where <tt>k >= n - mt</tt>
private int k;
// the underlying finite field
private GF2mField field;
// the irreducible Goppa polynomial
private PolynomialGF2mSmallM goppaPoly;
// a k x k random binary non-singular matrix
private GF2Matrix sInv;
// the permutation used to generate the systematic check matrix
private Permutation p1;
// the permutation used to compute the public generator matrix
private Permutation p2;
// the canonical check matrix of the code
private GF2Matrix h;
// the matrix used to compute square roots in <tt>(GF(2^m))^t</tt>
private PolynomialGF2mSmallM[] qInv;
/**
* Constructor.
*
* @param oid
* @param n the length of the code
* @param k the dimension of the code
* @param field the field polynomial defining the finite field
* <tt>GF(2<sup>m</sup>)</tt>
* @param goppaPoly the irreducible Goppa polynomial
* @param sInv the matrix <tt>S<sup>-1</sup></tt>
* @param p1 the permutation used to generate the systematic check
* matrix
* @param p2 the permutation used to compute the public generator
* matrix
* @param h the canonical check matrix
* @param qInv the matrix used to compute square roots in
* <tt>(GF(2<sup>m</sup>))<sup>t</sup></tt>
* @param params McElieceParameters
*/
public McEliecePrivateKeyParameters(String oid, int n, int k, GF2mField field,
PolynomialGF2mSmallM goppaPoly, GF2Matrix sInv, Permutation p1,
Permutation p2, GF2Matrix h, PolynomialGF2mSmallM[] qInv, McElieceParameters params)
{
super(true, params);
this.oid = oid;
this.k = k;
this.n = n;
this.field = field;
this.goppaPoly = goppaPoly;
this.sInv = sInv;
this.p1 = p1;
this.p2 = p2;
this.h = h;
this.qInv = qInv;
}
/**
* Constructor (used by the {@link McElieceKeyFactory}).
*
* @param oid
* @param n the length of the code
* @param k the dimension of the code
* @param encField the encoded field polynomial defining the finite field
* <tt>GF(2<sup>m</sup>)</tt>
* @param encGoppaPoly the encoded irreducible Goppa polynomial
* @param encSInv the encoded matrix <tt>S<sup>-1</sup></tt>
* @param encP1 the encoded permutation used to generate the systematic
* check matrix
* @param encP2 the encoded permutation used to compute the public
* generator matrix
* @param encH the encoded canonical check matrix
* @param encQInv the encoded matrix used to compute square roots in
* <tt>(GF(2<sup>m</sup>))<sup>t</sup></tt>
* @param params McElieceParameters
*/
public McEliecePrivateKeyParameters(String oid, int n, int k, byte[] encField,
byte[] encGoppaPoly, byte[] encSInv, byte[] encP1, byte[] encP2,
byte[] encH, byte[][] encQInv, McElieceParameters params)
{
super(true, params);
this.oid = oid;
this.n = n;
this.k = k;
field = new GF2mField(encField);
goppaPoly = new PolynomialGF2mSmallM(field, encGoppaPoly);
sInv = new GF2Matrix(encSInv);
p1 = new Permutation(encP1);
p2 = new Permutation(encP2);
h = new GF2Matrix(encH);
qInv = new PolynomialGF2mSmallM[encQInv.length];
for (int i = 0; i < encQInv.length; i++)
{
qInv[i] = new PolynomialGF2mSmallM(field, encQInv[i]);
}
}
/**
* @return the length of the code
*/
public int getN()
{
return n;
}
/**
* @return the dimension of the code
*/
public int getK()
{
return k;
}
/**
* @return the finite field <tt>GF(2<sup>m</sup>)</tt>
*/
public GF2mField getField()
{
return field;
}
/**
* @return the irreducible Goppa polynomial
*/
public PolynomialGF2mSmallM getGoppaPoly()
{
return goppaPoly;
}
/**
* @return the k x k random binary non-singular matrix S^-1
*/
public GF2Matrix getSInv()
{
return sInv;
}
/**
* @return the permutation used to generate the systematic check matrix
*/
public Permutation getP1()
{
return p1;
}
/**
* @return the permutation used to compute the public generator matrix
*/
public Permutation getP2()
{
return p2;
}
/**
* @return the canonical check matrix H
*/
public GF2Matrix getH()
{
return h;
}
/**
* @return the matrix used to compute square roots in
* <tt>(GF(2<sup>m</sup>))<sup>t</sup></tt>
*/
public PolynomialGF2mSmallM[] getQInv()
{
return qInv;
}
public String getOIDString()
{
return oid;
}
}
|
