Skip to content

Commit 1bb0a76

Browse files
author
gefeili
committed
Try to refactor MapGroup1.
1 parent 494e40b commit 1bb0a76

File tree

4 files changed

+158
-86
lines changed

4 files changed

+158
-86
lines changed

‎core/src/main/java/org/bouncycastle/pqc/crypto/snova/MapGroup1.java‎

Lines changed: 98 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
package org.bouncycastle.pqc.crypto.snova;
22

3+
import org.bouncycastle.util.GF16;
4+
35
class MapGroup1
46
{
57
public final byte[][][][] p11; // [m][v][v]
@@ -26,6 +28,102 @@ public MapGroup1(SnovaParameters params)
2628
qAlpha2 = new byte[m][alpha][lsq];
2729
}
2830

31+
public void decode(byte[] input, SnovaParameters params, int len)
32+
{
33+
// int m = params.getM();
34+
// int v = params.getV();
35+
// int o = params.getO();
36+
// int alpha = params.getAlpha();
37+
int lsq = params.getLsq();
38+
if ((lsq & 1) == 0)
39+
{
40+
int inOff = decodeP(input, 0, p11, len);
41+
inOff += decodeP(input, inOff, p12, len - inOff);
42+
inOff += decodeP(input, inOff, p21, len - inOff);
43+
inOff += decodeAlpha(input, inOff, aAlpha, len - inOff);
44+
inOff += decodeAlpha(input, inOff, bAlpha, len - inOff);
45+
inOff += decodeAlpha(input, inOff, qAlpha1, len - inOff);
46+
decodeAlpha(input, inOff, qAlpha2, len - inOff);
47+
}
48+
// else
49+
// {
50+
//
51+
// }
52+
}
53+
54+
// public boolean decodeArrayLsqOdd(byte[] input, int inOff, boolean isLower, byte[] output, int lsqHalf)
55+
// {
56+
// int outOff = 0;
57+
// if (isLower)
58+
// {
59+
// for (int i = 0; i < lsqHalf; ++i)
60+
// {
61+
// output[outOff++] = (byte)(input[inOff] & 0x0F);
62+
// output[outOff++] = (byte)((input[inOff++] >>> 4) & 0x0F);
63+
// }
64+
// output[outOff] = (byte)(input[inOff] & 0x0F);
65+
// return false;
66+
// }
67+
// else
68+
// {
69+
// for (int i = 0; i < lsqHalf; ++i)
70+
// {
71+
// output[outOff++] = (byte)((input[inOff++] >>> 4) & 0x0F);
72+
// output[outOff++] = (byte)(input[inOff] & 0x0F);
73+
// }
74+
// output[outOff] = (byte)((input[inOff] >>> 4) & 0x0F);
75+
// return true;
76+
// }
77+
// }
78+
79+
private int decodeP(byte[] input, int inOff, byte[][][][] p, int len)
80+
{
81+
int rlt = 0;
82+
for (int i = 0; i < p.length; ++i)
83+
{
84+
rlt += decodeAlpha(input, inOff + rlt, p[i], len);
85+
}
86+
return rlt;
87+
}
88+
89+
private static int decodeAlpha(byte[] input, int inOff, byte[][][] alpha, int len)
90+
{
91+
int rlt = 0;
92+
for (int i = 0; i < alpha.length; ++i)
93+
{
94+
for (int j = 0; j < alpha[i].length; ++j)
95+
{
96+
int tmp = Math.min(alpha[i][j].length, len << 1);
97+
GF16.decode(input, inOff + rlt, alpha[i][j], 0, tmp);
98+
rlt += (tmp + 1) >> 1;
99+
len -= (tmp + 1) >> 1;
100+
}
101+
}
102+
return rlt;
103+
}
104+
105+
// private int decodeP(byte[] input, int inOff, boolean isLower,byte[][][][] p, int lsqHalf)
106+
// {
107+
// for (int i = 0; i < p.length; ++i)
108+
// {
109+
// inOff = decodeAlpha(input, inOff, p[i]);
110+
// }
111+
// return inOff;
112+
// }
113+
114+
// private boolean decodeAlpha(byte[] input, int inOff, boolean isLower, byte[][][] alpha, int lsqHalf)
115+
// {
116+
// for (int i = 0; i < alpha.length; ++i)
117+
// {
118+
// for (int j = 0; j < alpha[i].length; ++j)
119+
// {
120+
// isLower = decodeArrayLsqOdd(input, inOff, isLower, alpha[i][j], lsqHalf);
121+
// inOff += lsqHalf + (isLower ? 1 : 0);
122+
// }
123+
// }
124+
// return isLower;
125+
// }
126+
29127
public void fill(byte[] input)
30128
{
31129
int inOff = fillP(input, 0, p11, input.length);
@@ -61,20 +159,4 @@ static int fillAlpha(byte[] input, int inOff, byte[][][] alpha, int len)
61159
}
62160
return rlt;
63161
}
64-
65-
static void copyTo(byte[][][][] alpha, byte[] output)
66-
{
67-
int outOff = 0;
68-
for (int i = 0; i < alpha.length; ++i)
69-
{
70-
for (int j = 0; j < alpha[i].length; ++j)
71-
{
72-
for (int k = 0; k < alpha[i][j].length; ++k)
73-
{
74-
System.arraycopy(alpha[i][j][k], 0, output, outOff, alpha[i][j][k].length);
75-
outOff += alpha[i][j][k].length;
76-
}
77-
}
78-
}
79-
}
80162
}

‎core/src/main/java/org/bouncycastle/pqc/crypto/snova/SnovaEngine.java‎

Lines changed: 13 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@
1111
import org.bouncycastle.util.GF16;
1212
import org.bouncycastle.util.Pack;
1313

14-
public class SnovaEngine
14+
class SnovaEngine
1515
{
1616
private final SnovaParameters params;
1717
private final int l;
@@ -517,38 +517,32 @@ void genABQP(MapGroup1 map1, byte[] pkSeed, byte[] fixedAbq)
517517
System.arraycopy(blockOut, 0, prngOutput, offset, remaining);
518518
}
519519
}
520+
// if ((lsq & 1) == 0)
521+
// {
522+
// map1.decode(prngOutput, params, (gf16sPrngPublic - qTemp.length) >> 1);
523+
// }
524+
// else
525+
// {
520526
byte[] temp = new byte[gf16sPrngPublic - qTemp.length];
521527
GF16.decode(prngOutput, temp, temp.length);
522528
map1.fill(temp);
529+
// }
523530
if (l >= 4)
524531
{
525-
GF16.decode(prngOutput, temp.length >> 1, qTemp, 0, qTemp.length);
526-
532+
GF16.decode(prngOutput, (gf16sPrngPublic - qTemp.length) >> 1, qTemp, 0, qTemp.length);
533+
int ptArray = 0;
527534
// Post-processing for invertible matrices
535+
int offset = m * alpha * l;
528536
for (int pi = 0; pi < m; ++pi)
529537
{
530538
for (int a = 0; a < alpha; ++a)
531539
{
532540
makeInvertibleByAddingAS(map1.aAlpha[pi][a], 0);
533541
makeInvertibleByAddingAS(map1.bAlpha[pi][a], 0);
534-
}
535-
}
536-
537-
int ptArray = 0;
538-
for (int pi = 0; pi < m; ++pi)
539-
{
540-
for (int a = 0; a < alpha; ++a)
541-
{
542542
genAFqS(qTemp, ptArray, map1.qAlpha1[pi][a], 0);
543543
ptArray += l;
544-
}
545-
}
546-
for (int pi = 0; pi < m; ++pi)
547-
{
548-
for (int a = 0; a < alpha; ++a)
549-
{
550-
genAFqS(qTemp, ptArray, map1.qAlpha2[pi][a], 0);
551-
ptArray += l;
544+
genAFqS(qTemp, offset, map1.qAlpha2[pi][a], 0);
545+
offset += l;
552546
}
553547
}
554548
}

‎core/src/main/java/org/bouncycastle/pqc/crypto/snova/SnovaSigner.java‎

Lines changed: 21 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -134,21 +134,23 @@ public void signDigestCore(byte[] ptSignature, byte[] digest, byte[] arraySalt,
134134
final int v = params.getV();
135135
final int o = params.getO();
136136
final int n = params.getN();
137-
final int bytesHash = (o * lsq + 1) >>> 1;
137+
final int mxlsq = m * lsq;
138+
final int oxlsq = o * lsq;
139+
final int bytesHash = (oxlsq + 1) >>> 1;
138140
final int bytesSalt = 16;
139141

140142
// Initialize matrices and arrays
141-
byte[][] Gauss = new byte[m * lsq][m * lsq + 1];
143+
byte[][] Gauss = new byte[mxlsq][mxlsq + 1];
142144
byte[][] Temp = new byte[lsq][lsq];
143-
byte[] solution = new byte[m * lsq];
145+
byte[] solution = new byte[mxlsq];
144146

145147
byte[][][][] Left = new byte[m][alpha][v][lsq];
146148
byte[][][][] Right = new byte[m][alpha][v][lsq];
147149
byte[] leftXTmp = new byte[lsq];
148150
byte[] rightXtmp = new byte[lsq];
149151
byte[][] XInGF16Matrix = new byte[v][lsq];
150152
byte[][] FvvGF16Matrix = new byte[m][lsq];
151-
byte[] hashInGF16 = new byte[m * lsq];
153+
byte[] hashInGF16 = new byte[mxlsq];
152154

153155
byte[] signedHash = new byte[bytesHash];
154156
byte[] vinegarBytes = new byte[(v * lsq + 1) / 2];
@@ -174,9 +176,9 @@ public void signDigestCore(byte[] ptSignature, byte[] digest, byte[] arraySalt,
174176
numSign++;
175177

176178
// Fill last column of Gauss matrix
177-
for (int i = 0; i < m * lsq; i++)
179+
for (int i = 0; i < mxlsq; i++)
178180
{
179-
Gauss[i][m * lsq] = hashInGF16[i];
181+
Gauss[i][mxlsq] = hashInGF16[i];
180182
}
181183

182184
// Generate vinegar values
@@ -227,24 +229,22 @@ public void signDigestCore(byte[] ptSignature, byte[] digest, byte[] arraySalt,
227229
}
228230
}
229231

230-
int idx2 = m * lsq;
231232
// Gaussian elimination setup
232-
for (int i = 0; i < m; i++)
233+
for (int i = 0, ixlsq = 0; i < m; i++, ixlsq += lsq)
233234
{
234-
for (int j = 0; j < l; j++)
235+
for (int j = 0, jxl = 0; j < l; j++, jxl += l)
235236
{
236-
for (int k = 0; k < l; k++)
237+
for (int k = 0, jxl_k = jxl; k < l; k++, jxl_k++)
237238
{
238-
int idx1 = i * lsq + j * l + k;
239-
Gauss[idx1][idx2] ^= FvvGF16Matrix[i][j * l + k];
239+
Gauss[ixlsq + jxl_k][mxlsq] ^= FvvGF16Matrix[i][jxl_k];
240240
}
241241
}
242242
}
243243

244244
// Compute the coefficients of Xo and put into Gauss matrix and compute the coefficients of Xo^t and add into Gauss matrix
245-
for (int mi = 0; mi < m; ++mi)
245+
for (int mi = 0, mixlsq = 0; mi < m; ++mi, mixlsq += lsq)
246246
{
247-
for (int index = 0; index < o; ++index)
247+
for (int index = 0, idxlsq = 0; index < o; ++index, idxlsq += lsq)
248248
{
249249
for (int a = 0; a < alpha; ++a)
250250
{
@@ -297,32 +297,30 @@ public void signDigestCore(byte[] ptSignature, byte[] digest, byte[] arraySalt,
297297
{
298298
for (int tj = 0; tj < lsq; ++tj)
299299
{
300-
int gaussRow = mi * lsq + ti;
301-
int gaussCol = index * lsq + tj;
302-
Gauss[gaussRow][gaussCol] ^= Temp[ti][tj];
300+
Gauss[mixlsq + ti][idxlsq + tj] ^= Temp[ti][tj];
303301
}
304302
}
305303
}
306304
}
307305
}
308306
// Gaussian elimination implementation
309-
flagRedo = performGaussianElimination(Gauss, solution, m * lsq);
307+
flagRedo = performGaussianElimination(Gauss, solution, mxlsq);
310308
}
311309
while (flagRedo != 0);
312310

313311
// Copy vinegar variables
314312
byte[] tmp = new byte[n * lsq];
315-
for (int idx = 0; idx < v; idx++)
313+
for (int idx = 0, idxlsq = 0; idx < v; idx++, idxlsq += lsq)
316314
{
317-
System.arraycopy(XInGF16Matrix[idx], 0, tmp, idx * lsq, lsq);
318-
for (int i = 0; i < o; i++)
315+
System.arraycopy(XInGF16Matrix[idx], 0, tmp, idxlsq, lsq);
316+
for (int i = 0, ixlsq = 0; i < o; i++, ixlsq += lsq)
319317
{
320-
GF16Utils.gf16mMulTo(T12[idx][i], solution, i * lsq, tmp, idx * lsq, l);
318+
GF16Utils.gf16mMulTo(T12[idx][i], solution, ixlsq, tmp, idxlsq, l);
321319
}
322320
}
323321

324322
// Copy remaining oil variables
325-
System.arraycopy(solution, 0, tmp, v * lsq, lsq * o);
323+
System.arraycopy(solution, 0, tmp, v * lsq, oxlsq);
326324
GF16.encode(tmp, ptSignature, tmp.length);
327325

328326
System.arraycopy(arraySalt, 0, ptSignature, ptSignature.length - bytesSalt, bytesSalt);

0 commit comments

Comments
 (0)