#include "../lib/lib.h" #include <cstdint> #include <iterator> #define BysIdx(VarA,…
- User
#include "../lib/lib.h" #include #include
#define BysIdx(VarA, BaseB) VarA[BaseB64] #define VecIdx(VarA, BaseB) VarA[BaseB16]
void FrodoDecaps_Hard(string cin_file, string skin_file, string ssout_file) {
#pragma comment (user, "parameter definations")
uint32_t SHAKE_128 = 0; uint32_t SHAKE_256 = 1; // FrodoKEM-640 uint32_t D = 15; uint32_t q = 32768; uint32_t n = 640; uint32_t n_bar = 8; uint32_t B = 2; uint32_t len_A = 128/8; // in bytes uint32_t len_sec = 128/8; uint32_t SHAKE = SHAKE_128; uint32_t len_SE = 256/8; uint32_t len_salt = 256/8; // if eFrodoKEM, use these uint32_t elen_SE = 128/8; uint32_t elen_salt = 0; uint32_t A_tmp_len = 0; // for VectorIR use uint32_t len_matrix_n_nbar = n*n_bar; uint32_t len_matrix_nbar_nbar = n_bar*n_bar; // for ByteStringIR use, all len* are in bytes //uint32_t len_u1 = B*n_bar*n_bar/8; //uint32_t len_seed_SE1_k1 = len_sec + len_u1 + len_salt; // below takes up more than one line //uint32_t len_b = D*n*n_bar/8; // 150 lines //uint32_t len_c1 = D*n*n_bar/8; // 150 lines //uint32_t len_c2 = D*n_bar*n_bar/8; // 2 lines //uint32_t len_S_T_string = len_matrix_n_nbar*16/8; // 640*8*16/512 = 160 lines //uint32_t len_sk = len_sec+len_A+len_b+len_S_T_string+len_sec; // 311 lines uint32_t lines_sk = 311; uint32_t lines_c = 153; uint32_t lines_c1 = 150; uint32_t lines_c2 = 2;#pragma message ("offline execution: prepare consts")
#pragma message ("online execution")
Config_ALUon(); Config_ALUconst(1,1); Config_ALU2_ADD(); // 0. extract from ciphertext c and sk MByteStringIR Msk;#pragma comment(user, "Msk:0") Msk.Initial_FromFile(skin_file, lines_sk);
ByteStringIR sk;#pragma comment(user, "sk:693") sk.Initial_FromMByteStringIR(&Msk, lines_sk);
ByteStringIR seed_A;#pragma comment(user, "seed_A:1017") VectorIR seed_A_vec; #pragma comment(user, "seed_A_vec:1017") // now seed_A has s||seed_A seed_A = Hard_ByteStringIRFromByteStringIR(&sk, 1);
ByteStringIR s;#pragma comment(user, "s:1018") VectorIR s_vec; #pragma comment(user, "s_vec:1018") s = Hard_ByteStringIRFromByteStringIR(&sk, 1);
// extract seed_A seed_A_vec = Hard_CoeffShiftCoeffs(&seed_A_vec, 1, 0, 1, 1, 128); // clean s, leave least 128 bits only s_vec = Hard_CoeffShiftCoeffs(&s_vec, 1, 0, 1, 0, 512-128); s_vec = Hard_CoeffShiftCoeffs(&s_vec, 1, 0, 1, 1, 512-128); ByteStringIR b;#pragma comment(user, "b:693") VectorIR b_vec; #pragma comment(user, "b_vec:693")
ByteStringIR b_string_part_0_0;#pragma comment(user, "b_string_part_0_0:693") ByteStringIR b_string_part_0_1; #pragma comment(user, "b_string_part_0_1:723") ByteStringIR b_string_part_1_0; #pragma comment(user, "b_string_part_1_0:730") ByteStringIR b_string_part_1_1; #pragma comment(user, "b_string_part_1_1:760") ByteStringIR b_string_part_2_0; #pragma comment(user, "b_string_part_2_0:768") ByteStringIR b_string_part_2_1; #pragma comment(user, "b_string_part_2_1:798") ByteStringIR b_string_part_3_0; #pragma comment(user, "b_string_part_3_0:805") ByteStringIR b_string_part_3_1; #pragma comment(user, "b_string_part_3_1:835")
VectorIR b_vec_part_0_0;#pragma comment(user, "b_vec_part_0_0:693") VectorIR b_vec_part_0_1; #pragma comment(user, "b_vec_part_0_1:723") VectorIR b_vec_part_1_0; #pragma comment(user, "b_vec_part_1_0:730") VectorIR b_vec_part_1_1; #pragma comment(user, "b_vec_part_1_1:760") VectorIR b_vec_part_2_0; #pragma comment(user, "b_vec_part_2_0:768") VectorIR b_vec_part_2_1; #pragma comment(user, "b_vec_part_2_1:798") VectorIR b_vec_part_3_0; #pragma comment(user, "b_vec_part_3_0:805") VectorIR b_vec_part_3_1; #pragma comment(user, "b_vec_part_3_1:835")
// shift b and ST_string b_vec = Hard_CoeffShiftCoeffs(&b_vec, lines_sk, 0, 1, 1, 256); ByteStringIR pkh;#pragma comment(user, "pkh:1019") ByteStringIR pkh_sk; #pragma comment(user, "pkh_sk:1003") // copy pkh from sk pkh = Hard_ByteStringIRFromByteStringIR(&pkh_sk, 1);
MByteStringIR Mc;#pragma comment(user, "Mc:400") Mc.Initial_FromFile(cin_file, lines_c);
ByteStringIR c;#pragma comment(user, "c:512") c.Initial_FromMByteStringIR(&Mc, lines_c);
ByteStringIR salt;#pragma comment(user, "salt:1020") VectorIR salt_vec; #pragma comment(user, "salt_vec:1020") // salt in string c ByteStringIR salt_c; #pragma comment(user, "salt_c:663") // copy salt from c salt = Hard_ByteStringIRFromByteStringIR(&salt_c, 2); // clean salt salt_vec = Hard_CoeffShiftCoeffs(&salt_vec, 2, 0, 1, 1, 512-64);
// Bp = Unpack(c1) VectorIR c1_vec; // first 150 lines of c#pragma comment(user, "c1_vec:512")
// the first step of Unpack c1_vec = Hard_CoeffReverse(&c1_vec, lines_c1, 0, 0, 1, 1); // c1 is divided into 2 blocks: 75+75 lines ByteStringIR c1_string_block_0;#pragma comment(user, "c1_string_block_0:512") ByteStringIR c1_string_block_1; #pragma comment(user, "c1_string_block_1:587") VectorIR Bp_vec; #pragma comment(user, "Bp_vec:0")
// ST_string is divided into 2 blocks: 80+80 lines ByteStringIR ST_string_block_0;#pragma comment(user, "ST_string_block_0:843") ByteStringIR ST_string_block_1; #pragma comment(user, "ST_string_block_1:923") VectorIR ST_vec; #pragma comment(user, "ST_vec:256")
// calculate Bp*S VectorIR BpS_vec;#pragma comment(user, "BpS_vec:192")
ControlScalarIR k_cs;#pragma comment(user, "k_cs:2") ControlScalarIR k_low_cs; #pragma comment(user, "k_low_cs:3") ControlScalarIR k_high_cs; #pragma comment(user, "k_high_cs:4") ControlScalarIR Bp_vec_index_cs; #pragma comment(user, "Bp_vec_index_cs:5") ControlScalarIR ST_vec_index_cs; #pragma comment(user, "ST_vec_index_cs:6") ControlScalarIR BpS_vec_index_cs; #pragma comment(user, "BpS_vec_index_cs:7") IVectorIR no_use; #pragma comment(user, "no_use:0")
// the first loop // remaining steps of Ubpack#pragma comment(user, "CLUSTER:0") Bp_vec = Hard_VectorIRFromByteStringIR_Dir(&c1_string_block_0, 75, 160, 15, 32, 0, 51275, 512160); Bp_vec = Hard_CoeffReverse(&Bp_vec, 160, 0, 0, 0, 1); #pragma comment(user, "CLUSTER:0") Bp_vec = Hard_Vec_Shift(&Bp_vec, 160, 17, 1);
// parallel execution to Unpack#pragma comment(user, "CLUSTER:1") ST_vec = Hard_VectorIRFromByteStringIR_Dir(&ST_string_block_0, 80, 160, 16, 32, 0, 51280, 512160);
for (k_cs.scalar_data = 0; k_cs.scalar_data < 160; k_cs.scalar_data = k_cs.scalar_data + 1) { k_low_cs.scalar_data = k_cs.scalar_data & 3; k_high_cs.scalar_data = k_cs.scalar_data >> 2; Bp_vec_index_cs.scalar_data = k_low_cs.scalar_data * 20; ST_vec_index_cs.scalar_data = k_high_cs.scalar_data * 20; BpS_vec_index_cs.scalar_data = k_high_cs.scalar_data << 3; BpS_vec_index_cs.scalar_data = BpS_vec_index_cs.scalar_data ^ k_low_cs.scalar_data; VecIdx(BpS_vec,BpS_vec_index_cs.scalar_data) = Hard_VecMulVec(VecIdx(Bp_vec,Bp_vec_index_cs.scalar_data), VecIdx(ST_vec,ST_vec_index_cs.scalar_data), 160, 0,0,0,0,0,0,0,no_use,0,0,0,0); } // the second loop // remaining steps of Ubpack#pragma comment(user, "CLUSTER:0") Bp_vec = Hard_VectorIRFromByteStringIR_Dir(&c1_string_block_1, 75, 160, 15, 32, 0, 51275, 512160); Bp_vec = Hard_CoeffReverse(&Bp_vec, 160, 0, 0, 0, 1); #pragma comment(user, "CLUSTER:0") Bp_vec = Hard_Vec_Shift(&Bp_vec, 160, 17, 1);
// parallel execution to Unpack#pragma comment(user, "CLUSTER:1") ST_vec = Hard_VectorIRFromByteStringIR_Dir(&ST_string_block_1, 80, 160, 16, 32, 0, 51280, 512160);
for (k_cs.scalar_data = 0; k_cs.scalar_data < 160; k_cs.scalar_data = k_cs.scalar_data + 1) { k_low_cs.scalar_data = k_cs.scalar_data & 3; k_high_cs.scalar_data = k_cs.scalar_data >> 2; Bp_vec_index_cs.scalar_data = k_low_cs.scalar_data * 20; ST_vec_index_cs.scalar_data = k_high_cs.scalar_data * 20; BpS_vec_index_cs.scalar_data = k_high_cs.scalar_data << 3; BpS_vec_index_cs.scalar_data = BpS_vec_index_cs.scalar_data ^ k_low_cs.scalar_data; BpS_vec_index_cs.scalar_data = BpS_vec_index_cs.scalar_data ^ 4; VecIdx(BpS_vec,BpS_vec_index_cs.scalar_data) = Hard_VecMulVec(VecIdx(Bp_vec,Bp_vec_index_cs.scalar_data), VecIdx(ST_vec,ST_vec_index_cs.scalar_data), 160, 0,0,0,0,0,0,0,no_use,0,0,0,0); } // form vector#pragma comment(user, "CLUSTER:1") BpS_vec = Hard_VectorIRFromVectorIR_Dir(&BpS_vec, 64, 4, 32, 32, 0, 32, 4*512);
// 2. C = Unpack(c2) // no need to form matrix, since BpS is vector now ByteStringIR c2;#pragma comment(user, "c2:662") VectorIR C_vec; #pragma comment(user, "C_vec:0")
#pragma comment(user, "CLUSTER:0") C_vec = Hard_VectorIRFromByteStringIR_Dir(&c2, 2, 4, 15, 32, 0, 960, 4*512);
// 3. M = C-Bp*S VectorIR M;#pragma comment(user, "M:0")
#pragma comment(user, "CLUSTER:0") M = Hard_Vec_Sub(&C_vec, &BpS_vec, 4);
// 4. u_p = Decode(M) ByteStringIR u_p;#pragma comment(user, "u_p:1021")
#pragma comment(user, "CLUSTER:0") M = Hard_Vec_AndConst(&M, 4, 0, 32767); #pragma comment(user, "CLUSTER:0") M = Hard_Vec_AddConst(&M, 4, 12); // D-B-1 = 12 #pragma comment(user, "CLUSTER:0") M = Hard_Vec_Shift(&M, 4, D-B, 1); #pragma comment(user, "CLUSTER:0") u_p = Hard_ByteStringIRFromVectorIR_Dir(&M, 4, 1, B, 8, 0, 128, 128);
////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// // 5. gen seed_SE_p and k_p salt_vec = Hard_CoeffShiftCoeffs(&salt_vec, 1, 0, 1, 0, 256); VectorIR u_p_vec;#pragma comment(user, "u_p_vec:1021")
u_p_vec = Hard_CoeffShiftCoeffs(&u_p_vec, 1, 0, 1, 1, 128); VectorIR seed5_vec;#pragma comment(user, "seed5_vec:1019") ByteStringIR seed5; #pragma comment(user, "seed5:1019")
#pragma comment(user, "CLUSTER:0") seed5_vec = Hard_Vec_Xor(&seed5_vec, &salt_vec, 1, 0); #pragma comment(user, "CLUSTER:0") seed5_vec = Hard_Vec_Xor(&seed5_vec, &u_p_vec, 1, 0);
// now seed5 has pkh||u'||salt // seedSE'||k' ByteStringIR seed_SE_p_k_p;#pragma comment(user, "seed_SE_p_k_p:1022") seed_SE_p_k_p = Hard_Shake3_Static(&seed5, 1, 1, SHAKE, 0,0,0,0,48);
// 6. gen seed_r; use DGW to gen Sp, Ep, Epp later // shift seedSE'||k' to from 0x96||seedSE'||k' VectorIR seed_SE_p_k_p_vec;#pragma comment(user, "seed_SE_p_k_p_vec:1022") seed_SE_p_k_p_vec = Hard_CoeffShiftCoeffs(&seed_SE_p_k_p_vec, 1, 0, 1, 0, 8); #pragma comment(user, "CLUSTER:0") seed_SE_p_k_p_vec = Hard_Vec_XorConst(&seed_SE_p_k_p_vec, 1, 0, 150); // 0x96 = 150(dec)
ByteStringIR seed_r; // seed_r is 0x96||seedSE'#pragma comment(user, "seed_r:1022")
// 7. sample Sp // type VectorIR, for Gauss Sample use only VectorIR Sp_string_initial_vec;#pragma comment(user, "Sp_string_initial_vec:856") // TODO out_coeff #pragma comment(user, "CLUSTER:0") Sp_string_initial_vec = Hard_PRNG_Gauss_Sample(&seed_r, 160, 1, 0, 0, 16, 0, 1, 13, 0, 0, SHAKE, len_SE+1, 0);
ByteStringIR Sp_string_block_0_0;#pragma comment(user, "Sp_string_block_0_0:856") ByteStringIR Sp_string_block_0_1; #pragma comment(user, "Sp_string_block_0_1:861") ByteStringIR Sp_string_block_0_2; #pragma comment(user, "Sp_string_block_0_2:866") ByteStringIR Sp_string_block_0_3; #pragma comment(user, "Sp_string_block_0_3:871") ByteStringIR Sp_string_block_0_4; #pragma comment(user, "Sp_string_block_0_4:876") ByteStringIR Sp_string_block_0_5; #pragma comment(user, "Sp_string_block_0_5:881") ByteStringIR Sp_string_block_0_6; #pragma comment(user, "Sp_string_block_0_6:886") ByteStringIR Sp_string_block_0_7; #pragma comment(user, "Sp_string_block_0_7:891")
ByteStringIR Sp_string_block_1_0;#pragma comment(user, "Sp_string_block_1_0:896") ByteStringIR Sp_string_block_1_1; #pragma comment(user, "Sp_string_block_1_1:901") ByteStringIR Sp_string_block_1_2; #pragma comment(user, "Sp_string_block_1_2:906") ByteStringIR Sp_string_block_1_3; #pragma comment(user, "Sp_string_block_1_3:911") ByteStringIR Sp_string_block_1_4; #pragma comment(user, "Sp_string_block_1_4:916") ByteStringIR Sp_string_block_1_5; #pragma comment(user, "Sp_string_block_1_5:921") ByteStringIR Sp_string_block_1_6; #pragma comment(user, "Sp_string_block_1_6:926") ByteStringIR Sp_string_block_1_7; #pragma comment(user, "Sp_string_block_1_7:931")
ByteStringIR Sp_string_block_2_0;#pragma comment(user, "Sp_string_block_2_0:936") ByteStringIR Sp_string_block_2_1; #pragma comment(user, "Sp_string_block_2_1:941") ByteStringIR Sp_string_block_2_2; #pragma comment(user, "Sp_string_block_2_2:946") ByteStringIR Sp_string_block_2_3; #pragma comment(user, "Sp_string_block_2_3:951") ByteStringIR Sp_string_block_2_4; #pragma comment(user, "Sp_string_block_2_4:956") ByteStringIR Sp_string_block_2_5; #pragma comment(user, "Sp_string_block_2_5:961") ByteStringIR Sp_string_block_2_6; #pragma comment(user, "Sp_string_block_2_6:966") ByteStringIR Sp_string_block_2_7; #pragma comment(user, "Sp_string_block_2_7:971")
ByteStringIR Sp_string_block_3_0;#pragma comment(user, "Sp_string_block_3_0:976") ByteStringIR Sp_string_block_3_1; #pragma comment(user, "Sp_string_block_3_1:981") ByteStringIR Sp_string_block_3_2; #pragma comment(user, "Sp_string_block_3_2:986") ByteStringIR Sp_string_block_3_3; #pragma comment(user, "Sp_string_block_3_3:991") ByteStringIR Sp_string_block_3_4; #pragma comment(user, "Sp_string_block_3_4:996") ByteStringIR Sp_string_block_3_5; #pragma comment(user, "Sp_string_block_3_5:1001") ByteStringIR Sp_string_block_3_6; #pragma comment(user, "Sp_string_block_3_6:1006") ByteStringIR Sp_string_block_3_7; #pragma comment(user, "Sp_string_block_3_7:1011")
// 12-13: Unpack(b) and calculate Sp*B on-the-fly // first step of Unpack b_vec = Hard_CoeffReverse(&b_vec, 150, 0, 0, 1, 1); // Sp_col is a 8*160 block of Sp // here is the 8 lines of the block VectorIR Sp_col_0_vec;#pragma comment(user, "Sp_col_0_vec:0") VectorIR Sp_col_1_vec; #pragma comment(user, "Sp_col_1_vec:10") VectorIR Sp_col_2_vec; #pragma comment(user, "Sp_col_2_vec:20") VectorIR Sp_col_3_vec; #pragma comment(user, "Sp_col_3_vec:30") VectorIR Sp_col_4_vec; #pragma comment(user, "Sp_col_4_vec:40") VectorIR Sp_col_5_vec; #pragma comment(user, "Sp_col_5_vec:50") VectorIR Sp_col_6_vec; #pragma comment(user, "Sp_col_6_vec:60") VectorIR Sp_col_7_vec; #pragma comment(user, "Sp_col_7_vec:70")
// indicate the whole 8*160 Sp_col block, used in matmat-mul VectorIR Sp_col_vec;#pragma comment(user, "Sp_col_vec:0")
// matrix B has 2 parts: 128+32 lines VectorIR B_row_vec_part_0_tmp;#pragma comment(user, "B_row_vec_part_0_tmp:384") VectorIR B_row_vec_part_1_tmp; #pragma comment(user, "B_row_vec_part_1_tmp:623") VectorIR B_row_vec_part_0; #pragma comment(user, "B_row_vec_part_0:256") VectorIR B_row_vec_part_1; #pragma comment(user, "B_row_vec_part_1:512")
// intermediate results for matmat-mul VectorIR SpB_mat_tmp;#pragma comment(user, "SpB_mat_tmp:120") // results for matmat-mul VectorIR SpB_mat; #pragma comment(user, "SpB_mat:545")
////////////////////////////////////////////////////// // matmat-mul: // Sp = [Sp0, Sp1, Sp2, Sp3] // B = [B0, B1, B2, B3]^T // thus Sp*B = Sp0*B0 + Sp2*B2 + Sp1*B1 + Sp3*B3 ////////////////////////////////////////////////////// ////////////////////////////////////////////////////// // Sp0*B0 ////////////////////////////////////////////////////// // extract Sp // 2 parallel reads#pragma comment(user, "CLUSTER:0") Sp_col_0_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_0_0, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:1") Sp_col_2_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_1_0, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:0") Sp_col_1_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_0_4, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:1") Sp_col_3_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_1_4, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_4_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_2_0, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_5_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_2_4, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_6_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_3_0, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_7_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_3_4, 5, 10, 16, 32, 0, 256, 512);
// form matrix Sp, use CLUSTER3 to allow parallel execution with Unpack(b)#pragma comment(user, "CLUSTER:3") Sp_col_vec = Hard_BankTransform(&Sp_col_vec, 80, 0, 1, 0, 0, 0);
// Unpack(b) and from matrix B // CLUSTER0 - Unpack part 0: 30 rows of b -> 128 rows of B_row // CLUSTER1 - Unpack part 1: 7.5 rows of b -> 32 rows of B_row, put in bank4 to form matrix // TODO parallel write (?)#pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_VectorIRFromByteStringIR_Dir(&b_string_part_0_1, 8, 16, 15, 32, 0, 1564, 3264); #pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_VectorIRFromByteStringIR_Dir(&b_string_part_0_0, 30, 64, 15, 32, 0, 1564, 3264); // reverse/shift in vector, then form matrix B, to half the cycles cost //#pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_CoeffReverse(&B_row_vec_part_0_tmp, 64, 0, 0, 0, 1); //#pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_CoeffReverse(&B_row_vec_part_1_tmp, 16, 0, 0, 0, 1); #pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_Vec_Shift(&B_row_vec_part_0_tmp, 32, 17, 1); #pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_Vec_Shift(&B_row_vec_part_1_tmp, 16, 17, 1); // form matrix B from VectorIR #pragma comment(user, "CLUSTER:0") B_row_vec_part_0 = Hard_VectorIRFromVectorIR_Dir(&B_row_vec_part_0_tmp, 64, 128, 32, 32, 0, 3216, 1616); #pragma comment(user, "CLUSTER:1") B_row_vec_part_1 = Hard_VectorIRFromVectorIR_Dir(&B_row_vec_part_1_tmp, 16, 32, 32, 32, 0, 3216, 1616);
// matmat-mul SpB_mat = Hard_MatmatMul(&Sp_col_vec, &B_row_vec_part_0, 160, 0, 0, 16, 8, 160, 160, 8, 0); ////////////////////////////////////////////////////// // Sp1*B1 ////////////////////////////////////////////////////// // extract Sp#pragma comment(user, "CLUSTER:0") Sp_col_0_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_0_1, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:1") Sp_col_2_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_1_1, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:0") Sp_col_1_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_0_5, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:1") Sp_col_3_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_1_5, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_4_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_2_1, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_5_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_2_5, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_6_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_3_1, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_7_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_3_5, 5, 10, 16, 32, 0, 256, 512);
// form matrix Sp#pragma comment(user, "CLUSTER:3") Sp_col_vec = Hard_BankTransform(&Sp_col_vec, 80, 0, 1, 0, 0, 0);
// Unpack(b) and from matrix B // shift 0.5+37 lines of b b_vec_part_1_0 = Hard_CoeffShiftCoeffs(&b_vec_part_1_0, 38, 0, 1, 1, 256);#pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_VectorIRFromByteStringIR_Dir(&b_string_part_1_1, 8, 16, 15, 32, 0, 1564, 3264); #pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_VectorIRFromByteStringIR_Dir(&b_string_part_1_0, 30, 64, 15, 32, 0, 1564, 3264); // reverse/shift in vector, then form matrix B //#pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_CoeffReverse(&B_row_vec_part_0_tmp, 64, 0, 0, 0, 1); //#pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_CoeffReverse(&B_row_vec_part_1_tmp, 16, 0, 0, 0, 1); #pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_Vec_Shift(&B_row_vec_part_0_tmp, 32, 17, 1); #pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_Vec_Shift(&B_row_vec_part_1_tmp, 16, 17, 1); // form matrix B from VectorIR #pragma comment(user, "CLUSTER:0") B_row_vec_part_0 = Hard_VectorIRFromVectorIR_Dir(&B_row_vec_part_0_tmp, 64, 128, 32, 32, 0, 3216, 1616); #pragma comment(user, "CLUSTER:1") B_row_vec_part_1 = Hard_VectorIRFromVectorIR_Dir(&B_row_vec_part_1_tmp, 16, 32, 32, 32, 0, 3216, 1616);
// matmat-mul SpB_mat_tmp = Hard_MatmatMul(&Sp_col_vec, &B_row_vec_part_0, 160, 0, 0, 16, 8, 160, 160, 8, 0); // add tmp result to SpB_mat#pragma comment(user, "CLUSTER:3") SpB_mat = Hard_Vec_Add(&SpB_mat, &SpB_mat_tmp, 8);
////////////////////////////////////////////////////// // Sp2*B2 ////////////////////////////////////////////////////// // extract Sp#pragma comment(user, "CLUSTER:0") Sp_col_0_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_0_2, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:1") Sp_col_2_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_1_2, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:0") Sp_col_1_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_0_6, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:1") Sp_col_3_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_1_6, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_4_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_2_2, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_5_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_2_6, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_6_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_3_2, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_7_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_3_6, 5, 10, 16, 32, 0, 256, 512);
// form matrix#pragma comment(user, "CLUSTER:3") Sp_col_vec = Hard_BankTransform(&Sp_col_vec, 80, 0, 1, 0, 0, 0);
// Unpack(b) and from matrix B#pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_VectorIRFromByteStringIR_Dir(&b_string_part_2_1, 8, 16, 15, 32, 0, 1564, 3264); #pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_VectorIRFromByteStringIR_Dir(&b_string_part_2_0, 30, 64, 15, 32, 0, 1564, 3264); // reverse/shift in vector, then form matrix B //#pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_CoeffReverse(&B_row_vec_part_0_tmp, 64, 0, 0, 0, 1); //#pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_CoeffReverse(&B_row_vec_part_1_tmp, 16, 0, 0, 0, 1); #pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_Vec_Shift(&B_row_vec_part_0_tmp, 32, 17, 1); #pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_Vec_Shift(&B_row_vec_part_1_tmp, 16, 17, 1); // form matrix B from VectorIR #pragma comment(user, "CLUSTER:0") B_row_vec_part_0 = Hard_VectorIRFromVectorIR_Dir(&B_row_vec_part_0_tmp, 64, 128, 32, 32, 0, 3216, 1616); #pragma comment(user, "CLUSTER:1") B_row_vec_part_1 = Hard_VectorIRFromVectorIR_Dir(&B_row_vec_part_1_tmp, 16, 32, 32, 32, 0, 3216, 1616);
// matmat-mul SpB_mat_tmp = Hard_MatmatMul(&Sp_col_vec, &B_row_vec_part_0, 160, 0, 0, 16, 8, 160, 160, 8, 0); // add tmp result to SpB_mat#pragma comment(user, "CLUSTER:3") SpB_mat = Hard_Vec_Add(&SpB_mat, &SpB_mat_tmp, 8);
////////////////////////////////////////////////////// // Sp3*B3 ////////////////////////////////////////////////////// // extract Sp#pragma comment(user, "CLUSTER:0") Sp_col_0_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_0_3, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:1") Sp_col_2_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_1_3, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:0") Sp_col_1_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_0_7, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:1") Sp_col_3_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_1_7, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_4_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_2_3, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_5_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_2_7, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_6_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_3_3, 5, 10, 16, 32, 0, 256, 512); #pragma comment(user, "CLUSTER:2") Sp_col_7_vec = Hard_VectorIRFromByteStringIR_Dir(&Sp_string_block_3_7, 5, 10, 16, 32, 0, 256, 512);
// form matrix#pragma comment(user, "CLUSTER:3") Sp_col_vec = Hard_BankTransform(&Sp_col_vec, 80, 0, 1, 0, 0, 0);
// Unpack(b) and from matrix B // shift 0.5+37 lines of b b_vec_part_3_0 = Hard_CoeffShiftCoeffs(&b_vec_part_3_0, 38, 0, 1, 1, 256);#pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_VectorIRFromByteStringIR_Dir(&b_string_part_3_1, 8, 16, 15, 32, 0, 1564, 3264); #pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_VectorIRFromByteStringIR_Dir(&b_string_part_3_0, 30, 64, 15, 32, 0, 1564, 3264); // reverse/shift in vector, then form matrix B //#pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_CoeffReverse(&B_row_vec_part_0_tmp, 64, 0, 0, 0, 1); //#pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_CoeffReverse(&B_row_vec_part_1_tmp, 16, 0, 0, 0, 1); #pragma comment(user, "CLUSTER:0") B_row_vec_part_0_tmp = Hard_Vec_Shift(&B_row_vec_part_0_tmp, 32, 17, 1); #pragma comment(user, "CLUSTER:1") B_row_vec_part_1_tmp = Hard_Vec_Shift(&B_row_vec_part_1_tmp, 16, 17, 1); // form matrix B from VectorIR #pragma comment(user, "CLUSTER:0") B_row_vec_part_0 = Hard_VectorIRFromVectorIR_Dir(&B_row_vec_part_0_tmp, 64, 128, 32, 32, 0, 3216, 1616); #pragma comment(user, "CLUSTER:1") B_row_vec_part_1 = Hard_VectorIRFromVectorIR_Dir(&B_row_vec_part_1_tmp, 16, 32, 32, 32, 0, 3216, 1616);
// matmat-mul SpB_mat_tmp = Hard_MatmatMul(&Sp_col_vec, &B_row_vec_part_0, 160, 0, 0, 16, 8, 160, 160, 8, 0); // add tmp result to SpB_mat#pragma comment(user, "CLUSTER:3") SpB_mat = Hard_Vec_Add(&SpB_mat, &SpB_mat_tmp, 8);
// transfer SpB_mat to VectorIR VectorIR SpB_vec;#pragma comment(user, "SpB_vec:508") #pragma comment(user, "CLUSTER:2") SpB_vec = Hard_VectorIRFromVectorIR_Dir(&SpB_mat, 8, 4, 32, 32, 0, 328, 3216);
// 9-10. Gen(A) on-the-fly, and calculate Sp*A // move Sp_string_block_1_* to bank 6 to make room for Sp*A ByteStringIR Sp_string_block_1_0_new;#pragma comment(user, "Sp_string_block_1_0_new:816") ByteStringIR Sp_string_block_1_4_new; #pragma comment(user, "Sp_string_block_1_4_new:836")
Sp_string_block_1_0_new = Hard_ByteStringIRFromByteStringIR(&Sp_string_block_3_0, 40); // type VectorIR, for shift op use only VectorIR Sp_string_block_0_0_vec; VectorIR Sp_string_block_0_4_vec; VectorIR Sp_string_block_1_0_new_vec; VectorIR Sp_string_block_1_4_new_vec; VectorIR Sp_string_block_2_0_vec; VectorIR Sp_string_block_2_4_vec; VectorIR Sp_string_block_3_0_vec; VectorIR Sp_string_block_3_4_vec;#pragma comment(user, "Sp_string_block_0_0_vec:856") #pragma comment(user, "Sp_string_block_0_4_vec:876") #pragma comment(user, "Sp_string_block_1_0_new_vec:816") #pragma comment(user, "Sp_string_block_1_4_new_vec:836") #pragma comment(user, "Sp_string_block_2_0_vec:936") #pragma comment(user, "Sp_string_block_2_4_vec:956") #pragma comment(user, "Sp_string_block_3_0_vec:976") #pragma comment(user, "Sp_string_block_3_4_vec:996")
// seedA is in bank7; // now prepare i||seedA in 4 different banks (i=0,1,2,3) for the first round of loop VectorIR seed_A_0_vec;#pragma comment(user, "seed_A_0_vec:379") VectorIR seed_A_1_vec; #pragma comment(user, "seed_A_1_vec:507") VectorIR seed_A_2_vec; #pragma comment(user, "seed_A_2_vec:815") VectorIR seed_A_3_vec; #pragma comment(user, "seed_A_3_vec:1017")
//#pragma comment(user, "CLUSTER:0") seed_A_0_vec = Hard_CoeffShiftCoeffs(&seed_A_3_vec, 1, 0, 1, 0, 16); #pragma comment(user, "CLUSTER:0") seed_A_1_vec = Hard_Vec_AddConst(&seed_A_0_vec, 1, 1); #pragma comment(user, "CLUSTER:0") seed_A_2_vec = Hard_Vec_AddConst(&seed_A_0_vec, 1, 2); #pragma comment(user, "CLUSTER:1") seed_A_3_vec = Hard_Vec_AddConst(&seed_A_1_vec, 1, 2);
ByteStringIR seed_A_0_string;#pragma comment(user, "seed_A_0_string:379") ByteStringIR seed_A_1_string; #pragma comment(user, "seed_A_1_string:507") ByteStringIR seed_A_2_string; #pragma comment(user, "seed_A_2_string:815") ByteStringIR seed_A_3_string; #pragma comment(user, "seed_A_3_string:1017")
// output data A_row_string_* from SHAKE are put in 4 different banks ByteStringIR A_row_string_0;#pragma comment(user, "A_row_string_0:288") ByteStringIR A_row_string_1; #pragma comment(user, "A_row_string_1:416") ByteStringIR A_row_string_2; #pragma comment(user, "A_row_string_2:512") ByteStringIR A_row_string_3; #pragma comment(user, "A_row_string_3:640")
// A_row_vec_* from A_row_string_* are also put in 4 different banks VectorIR A_row_vec_0;#pragma comment(user, "A_row_vec_0:532") VectorIR A_row_vec_1; #pragma comment(user, "A_row_vec_1:660") VectorIR A_row_vec_2; #pragma comment(user, "A_row_vec_2:768") VectorIR A_row_vec_3; #pragma comment(user, "A_row_vec_3:896")
// matrix A_row VectorIR A_row_mat_0;#pragma comment(user, "A_row_mat_0:288") VectorIR A_row_mat_1; #pragma comment(user, "A_row_mat_1:308") VectorIR A_row_mat_2; #pragma comment(user, "A_row_mat_2:328") VectorIR A_row_mat_3; #pragma comment(user, "A_row_mat_3:348")
// matrix Sp_col_new (append _new because the name Sp_col has been used) // a 8*4 block of Sp VectorIR Sp_col_mat_new;#pragma comment(user, "Sp_col_mat_new:800") // 8 lines of Sp_col_mat_new; VectorIR Sp_col_0_vec_new; VectorIR Sp_col_1_vec_new; VectorIR Sp_col_2_vec_new; VectorIR Sp_col_3_vec_new; VectorIR Sp_col_4_vec_new; VectorIR Sp_col_5_vec_new; VectorIR Sp_col_6_vec_new; VectorIR Sp_col_7_vec_new; #pragma comment(user, "Sp_col_0_vec_new:800") #pragma comment(user, "Sp_col_1_vec_new:801") #pragma comment(user, "Sp_col_2_vec_new:802") #pragma comment(user, "Sp_col_3_vec_new:803") #pragma comment(user, "Sp_col_4_vec_new:804") #pragma comment(user, "Sp_col_5_vec_new:805") #pragma comment(user, "Sp_col_6_vec_new:806") #pragma comment(user, "Sp_col_7_vec_new:807")
// result of Sp*A VectorIR SpA_mat;#pragma comment(user, "SpA_mat:0") // store intermediate results of SpA VectorIR SpA_mat_tmp; #pragma comment(user, "SpA_mat_tmp:512") // to add SpA intermediate results VectorIR SpA_mat_0_0; VectorIR SpA_mat_0_1; VectorIR SpA_mat_1_0; VectorIR SpA_mat_1_1; #pragma comment(user, "SpA_mat_0_0:0") #pragma comment(user, "SpA_mat_0_1:128") #pragma comment(user, "SpA_mat_1_0:256") #pragma comment(user, "SpA_mat_1_1:384") VectorIR SpA_mat_tmp_0_0; VectorIR SpA_mat_tmp_0_1; VectorIR SpA_mat_tmp_1_0; VectorIR SpA_mat_tmp_1_1; #pragma comment(user, "SpA_mat_tmp_0_0:512") #pragma comment(user, "SpA_mat_tmp_0_1:640") #pragma comment(user, "SpA_mat_tmp_1_0:768") #pragma comment(user, "SpA_mat_tmp_1_1:896")
// before loop, clean SpA_mat#pragma comment(user, "CLUSTER:0") SpA_mat_0_0 = Hard_Vec_AndConst(&SpA_mat_0_0, 128, 0, 0); #pragma comment(user, "CLUSTER:1") SpA_mat_0_1 = Hard_Vec_AndConst(&SpA_mat_0_0, 128, 0, 0); #pragma comment(user, "CLUSTER:2") SpA_mat_1_0 = Hard_Vec_AndConst(&SpA_mat_0_0, 32, 0, 0); #pragma comment(user, "CLUSTER:3") SpA_mat_1_1 = Hard_Vec_AndConst(&SpA_mat_0_0, 32, 0, 0);
// for loop ControlScalarIR i_cs;#pragma comment(user, "i_cs:0")
// line offset of Sp_string_block_* ControlScalarIR j_cs;#pragma comment(user, "j_cs:1")
for (i_cs.scalar_data = 0; i_cs.scalar_data < 160; i_cs.scalar_data = i_cs.scalar_data + 1) { // input i||seedA has 34 bytes; output 1280 bytes A_row_string_0 = Hard_Shake3_Static(&seed_A_0_string, 20, 1, SHAKE, 0,0,0,0, 34); A_row_string_1 = Hard_Shake3_Static(&seed_A_1_string, 20, 1, SHAKE, 0,0,0,0, 34); A_row_string_2 = Hard_Shake3_Static(&seed_A_2_string, 20, 1, SHAKE, 0,0,0,0, 34); A_row_string_3 = Hard_Shake3_Static(&seed_A_3_string, 20, 1, SHAKE, 0,0,0,0, 34); // refresh i||seedA for the next round // parallel execution of LOW#pragma comment(user, "CLUSTER:0") seed_A_0_vec = Hard_Vec_AddConst(&seed_A_0_vec, 1, 4); #pragma comment(user, "CLUSTER:1") seed_A_1_vec = Hard_Vec_AddConst(&seed_A_1_vec, 1, 4); #pragma comment(user, "CLUSTER:2") seed_A_2_vec = Hard_Vec_AddConst(&seed_A_2_vec, 1, 4); #pragma comment(user, "CLUSTER:3") seed_A_3_vec = Hard_Vec_AddConst(&seed_A_3_vec, 1, 4);
// parallel execution of ADW#pragma comment(user, "CLUSTER:0") A_row_vec_0 = Hard_VectorIRFromByteStringIR_Dir(&A_row_string_0, 20, 40, 16, 32, 0, 20512, 40512); #pragma comment(user, "CLUSTER:1") A_row_vec_1 = Hard_VectorIRFromByteStringIR_Dir(&A_row_string_1, 20, 40, 16, 32, 0, 20512, 40512); #pragma comment(user, "CLUSTER:2") A_row_vec_2 = Hard_VectorIRFromByteStringIR_Dir(&A_row_string_2, 20, 40, 16, 32, 0, 20512, 40512); #pragma comment(user, "CLUSTER:3") A_row_vec_3 = Hard_VectorIRFromByteStringIR_Dir(&A_row_string_3, 20, 40, 16, 32, 0, 20512, 40512);
// form matrix A_row#pragma comment(user, "CLUSTER:0") A_row_mat_0 = Hard_BankTransform(&A_row_vec_0, 40, 0, 1, 0, 0, 0); #pragma comment(user, "CLUSTER:1") A_row_mat_1 = Hard_BankTransform(&A_row_vec_1, 40, 0, 1, 0, 0, 0); #pragma comment(user, "CLUSTER:2") A_row_mat_2 = Hard_BankTransform(&A_row_vec_2, 40, 0, 1, 0, 0, 0); #pragma comment(user, "CLUSTER:3") A_row_mat_3 = Hard_BankTransform(&A_row_vec_3, 40, 0, 1, 0, 0, 0);
// i_cs = [0,7]: j_cs = 0 // i_cs = [8,15]: j_cs = 1 // ... j_cs.scalar_data = i_cs.scalar_data >> 3; // form matrix Sp_col_mat_new // parallel read#pragma comment(user, "CLUSTER:0") Sp_col_0_vec_new = Hard_VectorIRFromByteStringIR_Dir(BysIdx(Sp_string_block_0_0,j_cs.scalar_data), 1, 1, 16, 32, 0, 164, 324); #pragma comment(user, "CLUSTER:1") Sp_col_4_vec_new = Hard_VectorIRFromByteStringIR_Dir(BysIdx(Sp_string_block_2_0,j_cs.scalar_data), 1, 1, 16, 32, 0, 164, 324); #pragma comment(user, "CLUSTER:0") Sp_col_1_vec_new = Hard_VectorIRFromByteStringIR_Dir(BysIdx(Sp_string_block_0_4,j_cs.scalar_data), 1, 1, 16, 32, 0, 164, 324); #pragma comment(user, "CLUSTER:1") Sp_col_5_vec_new = Hard_VectorIRFromByteStringIR_Dir(BysIdx(Sp_string_block_2_4,j_cs.scalar_data), 1, 1, 16, 32, 0, 164, 324); #pragma comment(user, "CLUSTER:0") Sp_col_2_vec_new = Hard_VectorIRFromByteStringIR_Dir(BysIdx(Sp_string_block_1_0_new,j_cs.scalar_data), 1, 1, 16, 32, 0, 164, 324); #pragma comment(user, "CLUSTER:1") Sp_col_6_vec_new = Hard_VectorIRFromByteStringIR_Dir(BysIdx(Sp_string_block_3_0,j_cs.scalar_data), 1, 1, 16, 32, 0, 164, 324); #pragma comment(user, "CLUSTER:0") Sp_col_3_vec_new = Hard_VectorIRFromByteStringIR_Dir(BysIdx(Sp_string_block_1_4_new,j_cs.scalar_data), 1, 1, 16, 32, 0, 164, 324); #pragma comment(user, "CLUSTER:1") Sp_col_7_vec_new = Hard_VectorIRFromByteStringIR_Dir(BysIdx(Sp_string_block_3_4,j_cs.scalar_data), 1, 1, 16, 32, 0, 164, 324);
// mat-mat mul SpA_mat_tmp = Hard_MatmatMul(&Sp_col_mat_new, &A_row_mat_0, 80, 0, 0, 16, 8, 4, 4, 640, 0); // the chosen line right shift 4 bits // do not allocate buffer address Sp_string_block_0_0_vec = Hard_CoeffShiftCoeffs(BysIdx(Sp_string_block_0_0,j_cs.scalar_data), 1, 0, 1, 1, 16*4); Sp_string_block_0_4_vec = Hard_CoeffShiftCoeffs(BysIdx(Sp_string_block_0_4,j_cs.scalar_data), 1, 0, 1, 1, 16*4); Sp_string_block_1_0_new_vec = Hard_CoeffShiftCoeffs(BysIdx(Sp_string_block_1_0_new,j_cs.scalar_data), 1, 0, 1, 1, 16*4); Sp_string_block_1_4_new_vec = Hard_CoeffShiftCoeffs(BysIdx(Sp_string_block_1_4_new,j_cs.scalar_data), 1, 0, 1, 1, 16*4); Sp_string_block_2_0_vec = Hard_CoeffShiftCoeffs(BysIdx(Sp_string_block_2_0,j_cs.scalar_data), 1, 0, 1, 1, 16*4); Sp_string_block_2_4_vec = Hard_CoeffShiftCoeffs(BysIdx(Sp_string_block_2_4,j_cs.scalar_data), 1, 0, 1, 1, 16*4); Sp_string_block_3_0_vec = Hard_CoeffShiftCoeffs(BysIdx(Sp_string_block_3_0,j_cs.scalar_data), 1, 0, 1, 1, 16*4); Sp_string_block_3_4_vec = Hard_CoeffShiftCoeffs(BysIdx(Sp_string_block_3_4,j_cs.scalar_data), 1, 0, 1, 1, 16*4); // parallel execution#pragma comment(user, "CLUSTER:0") SpA_mat_0_0 = Hard_Vec_Add(&SpA_mat_0_0, &SpA_mat_tmp_0_0, 128); #pragma comment(user, "CLUSTER:1") SpA_mat_0_1 = Hard_Vec_Add(&SpA_mat_0_1, &SpA_mat_tmp_0_1, 128); #pragma comment(user, "CLUSTER:0") SpA_mat_1_0 = Hard_Vec_Add(&SpA_mat_1_0, &SpA_mat_tmp_1_0, 32); #pragma comment(user, "CLUSTER:1") SpA_mat_1_1 = Hard_Vec_Add(&SpA_mat_1_1, &SpA_mat_tmp_1_1, 32);
} // matrix Sp*A -> vector // DVectorIR refers to SpA_mat_tmp DVectorIR SpA_mat_Dvec;#pragma comment(user, "SpA_mat_Dvec:0") VectorIR SpA_vec; #pragma comment(user, "SpA_vec:512")
#pragma comment(user, "CLUSTER:0") SpA_vec.Initial_FromDVectorIR(&SpA_mat_Dvec, 160);
// 8,11. Sample again to generate Ep and Epp // Ep_string is divided into 64+64+32 lines ByteStringIR Ep_string_block_0;#pragma comment(user, "Ep_string_block_0:320") ByteStringIR Ep_string_block_1; #pragma comment(user, "Ep_string_block_1:384") ByteStringIR Ep_string_block_2; #pragma comment(user, "Ep_string_block_2:448")
ByteStringIR Epp_string;#pragma comment(user, "Epp_string:450")
// type VectorIR, for Gauss Sample use only VectorIR Ep_string_initial_vec;#pragma comment(user, "Ep_string_initial_vec:320")
// set seed_flag = 1 to continue the previous output // TODO out_coeff?#pragma comment(user, "CLUSTER:0") Ep_string_initial_vec = Hard_PRNG_Gauss_Sample(&seed_r, 162, 1, 0, 1, 16, 0, 1, 13, 0, 0, SHAKE, 33, 0);
// 10. Bpp = Sp*A + Ep // 13. V = Sp*B + Epp VectorIR Ep_vec_0;#pragma comment(user, "Ep_vec_0:0") VectorIR Ep_vec_1; #pragma comment(user, "Ep_vec_1:128") VectorIR Ep_vec_2; #pragma comment(user, "Ep_vec_2:896")
VectorIR Epp_vec;#pragma comment(user, "Epp_vec:256")
// for vecadd use only VectorIR SpA_vec_0;#pragma comment(user, "SpA_vec_0:512") VectorIR SpA_vec_1; #pragma comment(user, "SpA_vec_1:640") VectorIR SpA_vec_2; #pragma comment(user, "SpA_vec_2:768")
// for vecadd use only VectorIR Bpp_vec_0;#pragma comment(user, "Bpp_vec_0:512") VectorIR Bpp_vec_1; #pragma comment(user, "Bpp_vec_1:640") VectorIR Bpp_vec_2; #pragma comment(user, "Bpp_vec_2:768")
VectorIR V_vec;#pragma comment(user, "V_vec:508")
// parallel execution#pragma comment(user, "CLUSTER:0") Ep_vec_0 = Hard_VectorIRFromByteStringIR_Dir(&Ep_string_block_0, 64, 128, 16, 32, 0, 51264, 512128); #pragma comment(user, "CLUSTER:1") Ep_vec_1 = Hard_VectorIRFromByteStringIR_Dir(&Ep_string_block_1, 64, 128, 16, 32, 0, 51264, 512128);
// parallel execution#pragma comment(user, "CLUSTER:0") SpA_vec_0 = Hard_Vec_Add(&SpA_vec_0, &Ep_vec_0, 128); #pragma comment(user, "CLUSTER:1") SpA_vec_1 = Hard_Vec_Add(&SpA_vec_1, &Ep_vec_1, 128);
#pragma comment(user, "CLUSTER:2") Ep_vec_2 = Hard_VectorIRFromByteStringIR_Dir(&Ep_string_block_2, 32, 64, 16, 32, 0, 51232, 51264);
#pragma comment(user, "CLUSTER:2") SpA_vec_2 = Hard_Vec_Add(&SpA_vec_2, &Ep_vec_2, 64);
#pragma comment(user, "CLUSTER:3") Epp_vec = Hard_VectorIRFromByteStringIR_Dir(&Epp_string, 2, 4, 16, 32, 0, 5122, 5124); #pragma comment(user, "CLUSTER:3") V_vec = Hard_Vec_Add(&SpB_vec, &Epp_vec, 4);
// 14. Cp = V+Encode(u_p) VectorIR u_p_encoded_vec;#pragma comment(user, "u_p_encoded_vec:1000") VectorIR Cp_vec; #pragma comment(user, "Cp_vec:508")
// u_p_vec has 128'b0||u // do not allocate CLUSTER u_p_vec = Hard_CoeffShiftCoeffs(&u_p_vec, 1, 0, 1, 1, 128);#pragma comment(user, "CLUSTER:3") u_p_encoded_vec = Hard_VectorIRFromByteStringIR_Dir(&u_p_vec, 1, 4, 2, 32, 0, 128, 4*512);
#pragma comment(user, "CLUSTER:3") u_p_encoded_vec = Hard_Vec_Shift(&u_p_encoded_vec, 4, D-B, 1);
#pragma comment(user, "CLUSTER:3") Cp_vec = Hard_Vec_Add(&u_p_encoded_vec, &V_vec, 4);
////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////// // 15. constant time comparison // read c again from XMEM ByteStringIR c1_new;#pragma comment(user, "c1_new:328") VectorIR c1_vec_new; #pragma comment(user, "c1_vec_new:328") ByteStringIR c2_new; #pragma comment(user, "c2_new:478") VectorIR c2_vec_new; #pragma comment(user, "c2_vec_new:478")
c1_new.Initial_FromMByteStringIR(&Mc, lines_c-1); // no need to read salt // B' = Unpack(c1) // C = Unpack(c2) // Bp is divided into 3 blocks for parallel execution // _new indicates this is the second time that c is loaded into buffer VectorIR Bp_vec_new_0;#pragma comment(user, "Bp_vec_new_0:0") VectorIR Bp_vec_new_1; #pragma comment(user, "Bp_vec_new_1:128") VectorIR Bp_vec_new_2; #pragma comment(user, "Bp_vec_new_2:256") VectorIR C_vec_new; #pragma comment(user, "C_vec_new:320")
c1_vec_new = Hard_CoeffReverse(&c1_vec_new, lines_c1+lines_c2, 0, 0, 1, 1);#pragma comment(user, "CLUSTER:0") Bp_vec_new_0 = Hard_VectorIRFromByteStringIR_Dir(&c1_new, lines_c1+lines_c2, 168, 15, 32, 0, 77760, 512*324); Bp_vec_new_0 = Hard_CoeffReverse(&Bp_vec_new_0, 324, 0, 0, 0, 1); // parallel execution #pragma comment(user, "CLUSTER:0") Bp_vec_new_0 = Hard_Vec_Shift(&Bp_vec_new_0, 128, 17, 1); #pragma comment(user, "CLUSTER:1") Bp_vec_new_1 = Hard_Vec_Shift(&Bp_vec_new_1, 128, 17, 1); #pragma comment(user, "CLUSTER:2") Bp_vec_new_2 = Hard_Vec_Shift(&Bp_vec_new_2, 72, 17, 1);
// compare results VectorIR B_cmp_0;#pragma comment(user, "B_cmp_0:0") VectorIR B_cmp_1; #pragma comment(user, "B_cmp_1:128") VectorIR B_cmp_2; #pragma comment(user, "B_cmp_2:256") VectorIR C_cmp; #pragma comment(user, "C_cmp:320")
// Bpp and Cp should mod q before comparison // parallel execution#pragma comment(user, "CLUSTER:0") Bpp_vec_0 = Hard_Vec_AndConst(&Bpp_vec_0, 128, 0, 32767); #pragma comment(user, "CLUSTER:1") Bpp_vec_1 = Hard_Vec_AndConst(&Bpp_vec_1, 128, 0, 32767); #pragma comment(user, "CLUSTER:2") Bpp_vec_2 = Hard_Vec_AndConst(&Bpp_vec_2, 64, 0, 32767); #pragma comment(user, "CLUSTER:3") Cp_vec = Hard_Vec_AndConst(&Cp_vec, 4, 0, 32767);
// parallel execution#pragma comment(user, "CLUSTER:0") B_cmp_0 = Hard_Vec_Comp(&Bp_vec_new_0, &Bpp_vec_0, 128, 2); #pragma comment(user, "CLUSTER:1") B_cmp_1 = Hard_Vec_Comp(&Bp_vec_new_1, &Bpp_vec_1, 128, 2); #pragma comment(user, "CLUSTER:2") B_cmp_2 = Hard_Vec_Comp(&Bp_vec_new_2, &Bpp_vec_2, 64, 2); #pragma comment(user, "CLUSTER:2") C_cmp = Hard_Vec_Comp(&C_vec_new, &Cp_vec, 4, 2);
// FIXME VectorIR selector;#pragma comment(user, "selector:896") selector = Hard_EleVecAccumulate(&B_cmp_0, 324, 0, 1, 0); selector = Hard_EleVecExpand(&selector, 1, 0, 1);
// 16. compute ss // read c again from XMEM c1_new.Initial_FromMByteStringIR(&Mc, lines_c); VectorIR selector_kp;#pragma comment(user, "selector_kp:897") VectorIR selector_s; #pragma comment(user, "selector_s:898") ByteStringIR k_bar; #pragma comment(user, "k_bar:899") VectorIR k_bar_vec; #pragma comment(user, "k_bar_vec:899")
// shift 0x96||seedSE'||k' to obtain k' seed_SE_p_k_p_vec = Hard_CoeffShiftCoeffs(&seed_SE_p_k_p_vec, 1, 0, 1, 1, 264); // k_bar = (selector & k_bar) | (~selector & s)#pragma comment(user, "CLUSTER:0") selector_kp = Hard_Vec_And(&selector, &seed_SE_p_k_p_vec, 1, 0); #pragma comment(user, "CLUSTER:0") selector = Hard_Vec_Not(&selector, 1, 0); #pragma comment(user, "CLUSTER:0") selector_s = Hard_Vec_And(&selector, &s_vec, 1, 0); #pragma comment(user, "CLUSTER:0") k_bar_vec = Hard_Vec_Or(&selector_kp, &selector_s, 1, 0);
k_bar_vec = Hard_CoeffShiftCoeffs(&k_bar_vec, 1, 0, 1, 0, 192); // append k_bar to c VectorIR c_end;#pragma comment(user, "c_end:481") #pragma comment(user, "CLUSTER:0") c_end = Hard_Vec_Xor(&c_end, &k_bar_vec, 1, 0);
ByteStringIR ss;#pragma comment(user, "ss:900") ss = Hard_Shake3_Static(&c1_new, 1, 153, SHAKE, 0, 0, 0, 0, 40);
MByteStringIR Mss;#pragma comment(user, "Mss:1000") Mss.Initial_FromByteStringIR(&ss, 1);
} 快速解释这段代码,先进行整体粗略概括功能,然后逐行详细解释
- Assistant
整体功能概括
这段代码实现的是 FrodoKEM(一种基于格密码的后量子密钥封装机制)的 解封装过程(Decapsulation),且代码中使用了硬件加速的函数(如
Hard_XXX系列函数)。其核心功能是:- 从密文
c和私钥sk中解封装出共享密钥ss。 - 包括密文解码、矩阵运算、高斯采样、哈希计算等关键步骤,涉及复杂的数学运算和位操作。
逐行详细解释
1. 头文件与宏定义
#include "../lib/lib.h" #include <cstdint> #include <iterator> #define BysIdx(VarA, BaseB) VarA[BaseB*64] #define VecIdx(VarA, BaseB) VarA[BaseB*16]- 作用:包含必要的头文件,定义宏用于数组索引操作。
BysIdx和VecIdx是简化数组访问的宏,用于按固定步长(64 或 16)访问数组元素。
2. 函数定义与参数
void FrodoDecaps_Hard(string cin_file, string skin_file, string ssout_file)- 功能:定义解封装函数,输入为密文文件
cin_file、私钥文件skin_file,输出为共享密钥文件ssout_file。
3. 常量与参数定义
uint32_t SHAKE_128 = 0; uint32_t SHAKE_256 = 1; uint32_t D = 15; // 量化参数 uint32_t q = 32768; // 模数 uint32_t n = 640; // 向量维度 uint32_t n_bar = 8; // 子块大小 uint32_t B = 2; // 编码位数 // 其他长度参数(如哈希长度、盐值长度等)- 功能:定义 FrodoKEM-640 的参数,如模数
q、维度n、子块大小n_bar等。
4. 初始化配置
Config_ALUon(); Config_ALUconst(1,1); Config_ALU2_ADD();- 功能:配置硬件加速单元(ALU),启用常数加载和加法功能。
5. 加载私钥与密文
MByteStringIR Msk; Msk.Initial_FromFile(skin_file, lines_sk); // 从文件加载私钥 ByteStringIR sk = Hard_ByteStringIRFromByteStringIR(&Msk, lines_sk);- 功能:从文件读取私钥
sk,并初始化为ByteStringIR类型(可能表示字节字符串)。
6. 提取种子与密钥
seed_A = Hard_CoeffShiftCoeffs(&seed_A_vec, 1, 0, 1, 1, 128); // 提取 seed_A s_vec = Hard_CoeffShiftCoeffs(&s_vec, 1, 0, 1, 1, 512-128); // 提取 s 的低 128 位- 功能:从私钥中提取种子
seed_A和随机数s,并通过位移操作截取有效位数。
7. 解包密文 c1
c1_vec = Hard_CoeffReverse(&c1_vec, lines_c1, 0, 0, 1, 1); // 反转字节顺序 Bp_vec = Hard_VectorIRFromByteStringIR_Dir(&c1_string_block_0, 75, 160, 15, 32, 0, 512*75, 512*160);- 功能:将密文
c1解包为矩阵Bp,涉及字节顺序反转和向量转换。
8. 计算 Bp*S
for (k_cs.scalar_data = 0; k_cs.scalar_data < 160; k_cs.scalar_data++) { // 索引计算 + 向量点积 VecIdx(BpS_vec,BpS_vec_index_cs.scalar_data) = Hard_VecMulVec(...); }- 功能:计算矩阵
Bp与私钥矩阵S的乘积,结果存入BpS_vec。
9. 解码 M
M = Hard_Vec_Sub(&C_vec, &BpS_vec, 4); // M = C - Bp*S M = Hard_Vec_AndConst(&M, 4, 0, 32767); // 取模 q M = Hard_Vec_Shift(&M, 4, D-B, 1); // 移位解码 u_p = Hard_ByteStringIRFromVectorIR_Dir(&M, 4, 1, B, 8, 0, 128, 128); // 转换为字节字符串- 功能:解码向量
M,得到明文u_p。
10. 生成 seed_SE_p 和 k_p
seed5_vec = Hard_Vec_Xor(&seed5_vec, &salt_vec, 1, 0); // seed5 = pkh || u' || salt seed_SE_p_k_p = Hard_Shake3_Static(&seed5, 1, 1, SHAKE, 0,0,0,0,48); // 哈希生成 seed_SE_p 和 k_p- 功能:通过哈希函数(SHAKE)生成派生密钥
seed_SE_p和k_p。
11. 高斯采样生成 Sp
Sp_string_initial_vec = Hard_PRNG_Gauss_Sample(&seed_r, 160, 1, 0, 0, 16, 0, 1, 13, 0, 0, SHAKE, len_SE+1, 0);- 功能:基于种子
seed_r进行高斯采样,生成矩阵Sp。
12. 矩阵乘法 SpB 和 SpA
SpB_mat = Hard_MatmatMul(&Sp_col_vec, &B_row_vec_part_0, 160, 0, 0, 16, 8, 160, 160, 8, 0); SpA_mat = Hard_MatmatMul(&Sp_col_mat_new, &A_row_mat_0, 80, 0, 0, 16, 8, 4, 4, 640, 0);- 功能:执行矩阵乘法
Sp*B和Sp*A,用于后续验证。
13. 生成 Ep 和 Epp
Ep_string_initial_vec = Hard_PRNG_Gauss_Sample(&seed_r, 162, 1, 0, 1, 16, 0, 1, 13, 0, 0, SHAKE, 33, 0);- 功能:再次采样生成噪声向量
Ep和Epp。
14. 计算 Bpp 和 V
Bpp_vec = Hard_Vec_Add(&SpA_vec, &Ep_vec, 128); // Bpp = Sp*A + Ep V_vec = Hard_Vec_Add(&SpB_vec, &Epp_vec, 4); // V = Sp*B + Epp- 功能:计算候选值
Bpp和V,用于后续验证。
15. 常数时间比较
B_cmp = Hard_Vec_Comp(&Bp_vec_new, &Bpp_vec, 128, 2); // 比较 Bp 和 Bpp C_cmp = Hard_Vec_Comp(&C_vec_new, &Cp_vec, 4, 2); // 比较 Cp 和 C- 功能:常数时间比较,防止时序攻击,确保安全性。
16. 生成共享密钥 ss
k_bar_vec = Hard_Vec_Or(&selector_kp, &selector_s, 1, 0); // 根据选择器选择 k' 或 s ss = Hard_Shake3_Static(&c1_new, 1, 153, SHAKE, 0, 0, 0, 0, 40); // 哈希生成最终共享密钥- 功能:根据比较结果选择输出密钥,并通过哈希计算生成最终共享密钥
ss。
总结
这段代码是 FrodoKEM 解封装过程的硬件加速实现,核心包括:
- 密文解码与矩阵运算(解包
c1/c2,计算Bp*S)。 - 高斯采样与噪声生成(生成
Sp, Ep, Epp)。 - 常数时间比较(防止时序攻击)。
- 密钥派生(通过哈希生成最终共享密钥)。
代码中大量使用硬件加速函数(如
Hard_XXX),表明其目标平台可能是 FPGA 或 ASIC 等专用硬件。 - 从密文
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.