Google Git
Sign in
android / platform / external / epid-sdk / HEAD / . / epid / common / math / unittests / ffelement-test.cc
blob: 212e09e754c5466fd7c69c56085df7e2e7143f19 [file] [log] [blame]
/*############################################################################
# Copyright 2016-2017 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
############################################################################*/
/*!
* \file
* \brief FfElement unit tests.
*/
#include <algorithm>
#include <cstring>
#include <limits>
#include "epid/common-testhelper/epid_gtest-testhelper.h"
#include "gtest/gtest.h"
#include "epid/common-testhelper/bignum_wrapper-testhelper.h"
#include "epid/common-testhelper/errors-testhelper.h"
#include "epid/common-testhelper/ffelement_wrapper-testhelper.h"
#include "epid/common-testhelper/finite_field_wrapper-testhelper.h"
#include "epid/common-testhelper/octstr-testhelper.h"
#include "epid/common-testhelper/prng-testhelper.h"
extern "C" {
#include "epid/common/math/finitefield.h"
}
#include "epid/common/types.h"
#ifndef COUNT_OF
#define COUNT_OF(a) (sizeof(a) / sizeof((a)[0]))
#endif // COUNT_OF
/// compares BigNumStr values
bool operator==(BigNumStr const& lhs, BigNumStr const& rhs) {
return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
}
/// compares BigNumStr to FqElemStr values
bool operator==(BigNumStr const& lhs, FqElemStr const& rhs) {
return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
}
/// compares FqElemStr to BigNumStr values
bool operator==(FqElemStr const& lhs, BigNumStr const& rhs) {
return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
}
/// compares FqElemStr values
bool operator==(FqElemStr const& lhs, FqElemStr const& rhs) {
return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
}
/// compares Fq2ElemStr values
bool operator==(Fq2ElemStr const& lhs, Fq2ElemStr const& rhs) {
return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
}
/// compares Fq6ElemStr values
bool operator==(Fq6ElemStr const& lhs, Fq6ElemStr const& rhs) {
return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
}
/// compares Fq12ElemStr values
bool operator==(Fq12ElemStr const& lhs, Fq12ElemStr const& rhs) {
return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
}
/// compares FpElemStr values
bool operator==(FpElemStr const& lhs, FpElemStr const& rhs) {
return 0 == std::memcmp(&lhs, &rhs, sizeof(lhs));
}
/// compares FfElementObj values
bool operator==(FfElementObj const& lhs, FfElementObj const& rhs) {
auto lhs_data = lhs.data();
auto rhs_data = rhs.data();
return lhs_data.size() == rhs_data.size() &&
std::equal(lhs_data.begin(), lhs_data.end(), rhs_data.begin());
}
namespace {
class FfElementTest : public ::testing::Test {
public:
virtual void SetUp() {
fq = FiniteFieldObj(bn_q_str);
// construct Fq^2 finite field
FfElementObj neg_beta(&fq);
THROW_ON_EPIDERR(FfNeg(fq, FfElementObj(&fq, fq_qm1_str), neg_beta));
fq2 = FiniteFieldObj(fq, neg_beta, 2);
// construct Fq^6 finite field
FfElementObj neg_xi(&fq2);
THROW_ON_EPIDERR(FfNeg(fq2, FfElementObj(&fq2, this->fq2_2_1_str), neg_xi));
fq6 = FiniteFieldObj(fq2, neg_xi, 3);
// construct Fq^12 finite field
FfElementObj neg_v(&fq6);
THROW_ON_EPIDERR(
FfNeg(fq6, FfElementObj(&fq6, this->fq6_0_0_1_0_0_0_str), neg_v));
fq12 = FiniteFieldObj(fq6, neg_v, 2);
fq_0 = FfElementObj(&fq, &bn_0_str, sizeof(bn_0_str));
fq_2 = FfElementObj(&fq, &fq_2_str, sizeof(fq_2_str));
fq_qm2 = FfElementObj(&fq, &fq_qm2_str, sizeof(fq_qm2_str));
fq_3 = FfElementObj(&fq, &fq_3_str, sizeof(fq_3_str));
fq_4 = FfElementObj(&fq, &fq_4_str, sizeof(fq_4_str));
fq_5 = FfElementObj(&fq, &fq_5_str, sizeof(fq_5_str));
fq_a = FfElementObj(&fq, &bn_a_str, sizeof(bn_a_str));
// construct Intel(R) EPID 1.1 Fq finite field
epid11_fq = FiniteFieldObj(bn_epid11_bn_q_str);
// construct Intel(R) EPID 1.1 Fqd finite field
epid11_fqd = FiniteFieldObj(epid11_fq, bn_epid11_fq_coeffs,
COUNT_OF(bn_epid11_fq_coeffs));
// Fqk ground element is {-qnr, 0, 0}
FfElementObj epid11_neg_qnr(&epid11_fq);
THROW_ON_EPIDERR(FfNeg(
epid11_fq, FfElementObj(&epid11_fq, fq_epid11_fq_qnr), epid11_neg_qnr));
Fq3ElemStr epid11_ground_element_str = {0};
THROW_ON_EPIDERR(WriteFfElement(epid11_fq, epid11_neg_qnr,
&epid11_ground_element_str.a[0],
sizeof(epid11_ground_element_str.a[0])));
// construct Intel(R) EPID 1.1 Fqk finite field
epid11_GT = FiniteFieldObj(
epid11_fqd, FfElementObj(&epid11_fqd, epid11_ground_element_str), 2);
fq_0 = FfElementObj(&fq, &bn_0_str, sizeof((bn_0_str)));
fq_1 = FfElementObj(&fq, &bn_1_str, sizeof(bn_1_str));
fq_a = FfElementObj(&fq, &bn_a_str, sizeof(bn_a_str));
fq_b = FfElementObj(&fq, &bn_b_str, sizeof(bn_b_str));
fq_result = FfElementObj(&fq);
fq_sum_ab = FfElementObj(&fq, &fq_sum_ab_str, sizeof(fq_sum_ab_str));
fp = FiniteFieldObj(bn_p_str);
bn_0 = BigNumObj(bn_0_str);
bn_1 = BigNumObj(bn_1_str);
bn_a = BigNumObj(bn_a_str);
fq2_a = FfElementObj(&fq2, &fq2_a_str, sizeof(fq2_a_str));
fq2_result = FfElementObj(&fq2);
fq12_g = FfElementObj(&fq12, &fq12_g_str, sizeof(fq12_g_str));
fq12_h = FfElementObj(&fq12, &fq12_h_str, sizeof(fq12_h_str));
fq12_i = FfElementObj(&fq12, &fq12_i_str, sizeof(fq12_i_str));
fq12_j = FfElementObj(&fq12, &fq12_j_str, sizeof(fq12_j_str));
fq12_k = FfElementObj(&fq12, &fq12_k_str, sizeof(fq12_k_str));
fq12_result = FfElementObj(&fq12);
}
FiniteFieldObj fq;
FiniteFieldObj fq2;
FiniteFieldObj fq6;
FiniteFieldObj fq12;
FiniteFieldObj epid11_fq;
FiniteFieldObj epid11_fqd;
FiniteFieldObj epid11_GT;
FfElementObj fq_0;
FfElementObj fq_1;
FfElementObj fq_2;
FfElementObj fq_qm2; // Intel(R) EPID 2.0 parameter q - 2
FfElementObj fq_3;
FfElementObj fq_4;
FfElementObj fq_5;
FfElementObj fq_a;
FfElementObj fq_b;
FfElementObj fq_result;
FfElementObj fq_sum_ab;
FfElementObj fq2_a;
FfElementObj fq2_result;
FfElementObj fq12_g;
FfElementObj fq12_h;
FfElementObj fq12_i;
FfElementObj fq12_j;
FfElementObj fq12_k;
FfElementObj fq12_result;
FiniteFieldObj fp;
BigNumObj bn_0;
BigNumObj bn_1;
BigNumObj bn_a;
// Intel(R) EPID 2.0 parameter p
static const BigNumStr bn_p_str;
static const FpElemStr fp_p_str;
// Intel(R) EPID 2.0 parameter p - 1
static const BigNumStr fp_pm1_str;
// Intel(R) EPID 2.0 parameter q
static const BigNumStr bn_q_str;
// Intel(R) EPID 2.0 parameter q - 1
static const FqElemStr fq_qm1_str;
static const BigNumStr bn_qm1_str;
// Intel(R) EPID 2.0 parameter q - 2
static const FqElemStr fq_qm2_str;
// Intel(R) EPID 2.0 parameter q + 1
static const BigNumStr bn_qp1_str;
// Intel(R) EPID 2.0 parameter q - 0x3013
static const BigNumStr fq_qm0x3013_str;
// Intel(R) EPID 1.1 parameter q
static const BigNumStr bn_epid11_bn_q_str;
// Intel(R) EPID 1.1 parameter qnr
static const FqElemStr fq_epid11_fq_qnr;
// Intel(R) EPID 1.1 parameter coeff
static const BigNumStr bn_epid11_fq_coeffs[3];
// zero
static const BigNumStr bn_0_str;
static const FqElemStr fq_0_str;
// one
static const BigNumStr bn_1_str;
static const FqElemStr fq_1_str;
// two
static const BigNumStr bn_2_str;
static const FqElemStr fq_2_str;
// three
static const FqElemStr fq_3_str;
// four
static const FqElemStr fq_4_str;
// five
static const FqElemStr fq_5_str;
// 0x0000FFFF
static const BigNumStr bn_0xffff_str;
// Fq2 element containing {2, 1}
static const Fq2ElemStr fq2_2_1_str;
// Fq6 element containing {0, 0, 1, 0, 0, 0}
static const Fq6ElemStr fq6_0_0_1_0_0_0_str;
// arbitrary constant a (256 bit value)
static const BigNumStr bn_a_str;
static const FqElemStr fq_a_str;
static const Fq2ElemStr fq2_a_str;
// arbitrary constant b (256 bit value)
static const BigNumStr bn_b_str;
static const FqElemStr fq_b_str;
// a + b
static const FqElemStr fq_sum_ab_str;
static const Fq2ElemStr fq2_sum_ab_str;
static const Fq6ElemStr fq6_sum_ab_str;
static const Fq12ElemStr fq12_sum_ab_str;
// a * b
static const FqElemStr fq_mul_ab_str;
static const Fq2ElemStr fq2_mul_ab_str;
// 1/a
static const FqElemStr fq_inv_a_str;
// -a
static const FqElemStr fq_neg_a_str;
// pow(a, b), that is a raised to the power b
static const FqElemStr fq_exp_ab_str;
static const uint8_t sha_msg[3]; // predefined message for tests "abc"
static const FqElemStr fq_abc_sha256_str;
static const FqElemStr fq_abc_sha384_str;
static const FqElemStr fq_abc_sha512_str;
static const FqElemStr fq_abc_sha512256_str;
// arbitrary Fq12 constant a (unrelated to a above)
static const Fq12ElemStr fq12_g_str;
// arbitrary Fq12 constant b (unrelated to a above)
static const Fq12ElemStr fq12_h_str;
// arbitrary Fq12 constant c
static const Fq12ElemStr fq12_i_str;
// arbitrary Fq12 constant d
static const Fq12ElemStr fq12_j_str;
// arbitrary Fq12 constant e
static const Fq12ElemStr fq12_k_str;
// c * d
static const Fq12ElemStr fq12_mul_ij_str;
// e * b
static const Fq12ElemStr fq12_mul_gb_str;
// Fq Multi Exp Data
static const FqElemStr fq_multi_exp_base_1[1];
static const BigNumStr fq_multi_exp_exp_1[1];
static const FqElemStr fq_multi_exp_res_1;
static const std::vector<uint8_t> fq_multi_exp_exp_1_264;
static const FqElemStr fq_multi_exp_res_1_264;
static const FqElemStr fq_multi_exp_res_1_256_264;
static const FqElemStr fq_multi_exp_base_2[2];
static const BigNumStr fq_multi_exp_exp_2[2];
static const FqElemStr fq_multi_exp_res_2;
static const FqElemStr fq_multi_exp_base_3[3];
static const BigNumStr fq_multi_exp_exp_3[3];
static const FqElemStr fq_multi_exp_res_3;
static const FqElemStr fq_multi_exp_base_4[4];
static const BigNumStr fq_multi_exp_exp_4[4];
static const FqElemStr fq_multi_exp_res_4;
static const FqElemStr fq_multi_exp_base_5[5];
static const BigNumStr fq_multi_exp_exp_5[5];
static const FqElemStr fq_multi_exp_res_5;
static const FqElemStr fq_multi_exp_base_6[6];
static const BigNumStr fq_multi_exp_exp_6[6];
static const FqElemStr fq_multi_exp_res_6;
// Intel(R) EPID 1.1 GT Multi Exp Data
static const Fq6ElemStr epid11_GT_multi_exp_base_3[3];
static const std::vector<uint8_t> epid11_GT_multi_exp_exp_3[3];
static const Fq6ElemStr epid11_GT_multi_exp_res_3;
// Fq12 Multi Exp Data
static const Fq12ElemStr fq12_multi_exp_base_4[4];
static const BigNumStr fq12_multi_exp_exp_4[4];
static const Fq12ElemStr fq12_multi_exp_res_4;
};
const Fq2ElemStr FfElementTest::fq2_2_1_str = {
{{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}}}}};
const Fq6ElemStr FfElementTest::fq6_0_0_1_0_0_0_str = {
{{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}}}};
// Intel(R) EPID 2.0 parameter p
const BigNumStr FfElementTest::bn_p_str = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5, 0xF2,
0x5E, 0xEE, 0x71, 0xA4, 0x9E, 0x0C, 0xDC, 0x65, 0xFB, 0x12, 0x99,
0x92, 0x1A, 0xF6, 0x2D, 0x53, 0x6C, 0xD1, 0x0B, 0x50, 0x0D};
// Intel(R) EPID 2.0 parameter p - 0x0D
const FpElemStr FfElementTest::fp_p_str = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5, 0xF2,
0x5E, 0xEE, 0x71, 0xA4, 0x9E, 0x0C, 0xDC, 0x65, 0xFB, 0x12, 0x99,
0x92, 0x1A, 0xF6, 0x2D, 0x53, 0x6C, 0xD1, 0x0B, 0x50, 0x00};
// Intel(R) EPID 2.0 parameter p - 1
const BigNumStr FfElementTest::fp_pm1_str = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5, 0xF2,
0x5E, 0xEE, 0x71, 0xA4, 0x9E, 0x0C, 0xDC, 0x65, 0xFB, 0x12, 0x99,
0x92, 0x1A, 0xF6, 0x2D, 0x53, 0x6C, 0xD1, 0x0B, 0x50, 0x0C,
};
// Intel(R) EPID 2.0 parameter q
const BigNumStr FfElementTest::bn_q_str = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5, 0xF2,
0x5E, 0xEE, 0x71, 0xA4, 0x9F, 0x0C, 0xDC, 0x65, 0xFB, 0x12, 0x98,
0x0A, 0x82, 0xD3, 0x29, 0x2D, 0xDB, 0xAE, 0xD3, 0x30, 0x13};
// Intel(R) EPID 2.0 parameter q - 1
const FqElemStr FfElementTest::fq_qm1_str = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5, 0xF2,
0x5E, 0xEE, 0x71, 0xA4, 0x9F, 0x0C, 0xDC, 0x65, 0xFB, 0x12, 0x98,
0x0A, 0x82, 0xD3, 0x29, 0x2D, 0xDB, 0xAE, 0xD3, 0x30, 0x12};
const BigNumStr FfElementTest::bn_qm1_str = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5, 0xF2,
0x5E, 0xEE, 0x71, 0xA4, 0x9F, 0x0C, 0xDC, 0x65, 0xFB, 0x12, 0x98,
0x0A, 0x82, 0xD3, 0x29, 0x2D, 0xDB, 0xAE, 0xD3, 0x30, 0x12};
// Intel(R) EPID 2.0 parameter q - 2
const FqElemStr FfElementTest::fq_qm2_str = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5, 0xF2,
0x5E, 0xEE, 0x71, 0xA4, 0x9F, 0x0C, 0xDC, 0x65, 0xFB, 0x12, 0x98,
0x0A, 0x82, 0xD3, 0x29, 0x2D, 0xDB, 0xAE, 0xD3, 0x30, 0x11};
// Intel(R) EPID 2.0 parameter q + 1
const BigNumStr FfElementTest::bn_qp1_str = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5, 0xF2,
0x5E, 0xEE, 0x71, 0xA4, 0x9F, 0x0C, 0xDC, 0x65, 0xFB, 0x12, 0x98,
0x0A, 0x82, 0xD3, 0x29, 0x2D, 0xDB, 0xAE, 0xD3, 0x30, 0x14};
// Intel(R) EPID 2.0 parameter q - 0x3013
const BigNumStr FfElementTest::fq_qm0x3013_str = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5, 0xF2,
0x5E, 0xEE, 0x71, 0xA4, 0x9F, 0x0C, 0xDC, 0x65, 0xFB, 0x12, 0x98,
0x0A, 0x82, 0xD3, 0x29, 0x2D, 0xDB, 0xAE, 0xD3, 0x00, 0x00};
// Intel(R) EPID 1.1 parameter q
const BigNumStr FfElementTest::bn_epid11_bn_q_str = {
0x09, 0xF9, 0x24, 0xE5, 0xD9, 0xBC, 0x67, 0x7F, 0x81, 0x0D, 0xF0,
0x25, 0x58, 0xF7, 0x53, 0x13, 0xA9, 0x8A, 0xA6, 0x10, 0x47, 0x65,
0x5D, 0x73, 0x9E, 0xF1, 0x94, 0xEB, 0x05, 0xB1, 0xA7, 0x11};
// Intel(R) EPID 1.1 parameter qnr
const FqElemStr FfElementTest::fq_epid11_fq_qnr = {
{0x08, 0x66, 0xA7, 0x67, 0x36, 0x6E, 0x62, 0x71, 0xB7, 0xA6, 0x52,
0x94, 0x8F, 0xFB, 0x25, 0x9E, 0xE6, 0x4F, 0x25, 0xE5, 0x26, 0x9A,
0x2B, 0x6E, 0x7E, 0xF8, 0xA6, 0x39, 0xAE, 0x46, 0xAA, 0x24}};
// Intel(R) EPID 1.1 parameter coeff
const BigNumStr FfElementTest::bn_epid11_fq_coeffs[3] = {
{{{0x02, 0x16, 0x7A, 0x61, 0x53, 0xDD, 0xF6, 0xE2, 0x89, 0x15, 0xA0,
0x94, 0xF1, 0xB5, 0xDC, 0x65, 0x21, 0x15, 0x62, 0xE1, 0x7D, 0xC5,
0x43, 0x89, 0xEE, 0xB4, 0xEF, 0xC8, 0xA0, 0x8E, 0x34, 0x0F}}},
{{{0x04, 0x82, 0x27, 0xE1, 0xEB, 0x98, 0x64, 0xC2, 0x8D, 0x8F, 0xDD,
0x0E, 0x82, 0x40, 0xAE, 0xD4, 0x31, 0x63, 0xD6, 0x46, 0x32, 0x16,
0x85, 0x7A, 0xB7, 0x18, 0x68, 0xB8, 0x17, 0x02, 0x81, 0xA6}}},
{{{0x06, 0x20, 0x76, 0xE8, 0x54, 0x54, 0x53, 0xB4, 0xA9, 0xD8, 0x44,
0x4B, 0xAA, 0xFB, 0x1C, 0xFD, 0xAE, 0x15, 0xCA, 0x29, 0x79, 0xA6,
0x24, 0xA4, 0x0A, 0xF6, 0x1E, 0xAC, 0xED, 0xFB, 0x10, 0x41}}}};
// zero
const BigNumStr FfElementTest::bn_0_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
const FqElemStr FfElementTest::fq_0_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
// one
const BigNumStr FfElementTest::bn_1_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
const FqElemStr FfElementTest::fq_1_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
// two
const BigNumStr FfElementTest::bn_2_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
const FqElemStr FfElementTest::fq_2_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02};
// three
const FqElemStr FfElementTest::fq_3_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03};
// four
const FqElemStr FfElementTest::fq_4_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04};
// five
const FqElemStr FfElementTest::fq_5_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05};
const BigNumStr FfElementTest::bn_0xffff_str = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff};
// arbitrary constant a (256 bit value)
const BigNumStr FfElementTest::bn_a_str = {
0x12, 0xA6, 0x5B, 0xD6, 0x91, 0x8D, 0x50, 0xA7, 0x66, 0xEB, 0x7D,
0x52, 0xE3, 0x40, 0x17, 0x60, 0x7F, 0xDF, 0x6C, 0xA1, 0x2C, 0x1A,
0x37, 0xE0, 0x92, 0xC0, 0xF7, 0xB9, 0x76, 0xAB, 0xB1, 0x8A};
const FqElemStr FfElementTest::fq_a_str = {
0x12, 0xA6, 0x5B, 0xD6, 0x91, 0x8D, 0x50, 0xA7, 0x66, 0xEB, 0x7D,
0x52, 0xE3, 0x40, 0x17, 0x60, 0x7F, 0xDF, 0x6C, 0xA1, 0x2C, 0x1A,
0x37, 0xE0, 0x92, 0xC0, 0xF7, 0xB9, 0x76, 0xAB, 0xB1, 0x8A};
const Fq2ElemStr FfElementTest::fq2_a_str = {
{{{{0x12, 0xA6, 0x5B, 0xD6, 0x91, 0x8D, 0x50, 0xA7, 0x66, 0xEB, 0x7D,
0x52, 0xE3, 0x40, 0x17, 0x60, 0x7F, 0xDF, 0x6C, 0xA1, 0x2C, 0x1A,
0x37, 0xE0, 0x92, 0xC0, 0xF7, 0xB9, 0x76, 0xAB, 0xB1, 0x8A}}},
{{{0xDD, 0x2B, 0xE9, 0x59, 0x24, 0xA5, 0xB3, 0xFD, 0xEB, 0xE1, 0x3C,
0xC0, 0x73, 0x4E, 0x99, 0xEE, 0x36, 0xF6, 0xC0, 0x1A, 0x76, 0x01,
0x0A, 0xF0, 0xCB, 0xB4, 0x71, 0x88, 0x95, 0xCB, 0x35, 0xBA}}}}};
// arbitrary constant b (256 bit value)
const BigNumStr FfElementTest::bn_b_str = {
0xE6, 0x65, 0x23, 0x9B, 0xD4, 0x07, 0x16, 0x83, 0x38, 0x23, 0xB2,
0x67, 0x57, 0xEB, 0x0F, 0x23, 0x3A, 0xF4, 0x8E, 0xDA, 0x71, 0x5E,
0xD9, 0x98, 0x63, 0x98, 0x2B, 0xBC, 0x78, 0xD1, 0x94, 0xF2};
const FqElemStr FfElementTest::fq_b_str = {
0xE6, 0x65, 0x23, 0x9B, 0xD4, 0x07, 0x16, 0x83, 0x38, 0x23, 0xB2,
0x67, 0x57, 0xEB, 0x0F, 0x23, 0x3A, 0xF4, 0x8E, 0xDA, 0x71, 0x5E,
0xD9, 0x98, 0x63, 0x98, 0x2B, 0xBC, 0x78, 0xD1, 0x94, 0xF2};
// a + b
const FqElemStr FfElementTest::fq_sum_ab_str = {
0xF9, 0x0B, 0x7F, 0x72, 0x65, 0x94, 0x67, 0x2A, 0x9F, 0x0F, 0x2F,
0xBA, 0x3B, 0x2B, 0x26, 0x83, 0xBA, 0xD3, 0xFB, 0x7B, 0x9D, 0x79,
0x11, 0x78, 0xF6, 0x59, 0x23, 0x75, 0xEF, 0x7D, 0x46, 0x7C};
const Fq2ElemStr FfElementTest::fq2_sum_ab_str = {
{{{{0xF9, 0x0B, 0x7F, 0x72, 0x65, 0x94, 0x67, 0x2A, 0x9F, 0x0F, 0x2F,
0xBA, 0x3B, 0x2B, 0x26, 0x83, 0xBA, 0xD3, 0xFB, 0x7B, 0x9D, 0x79,
0x11, 0x78, 0xF6, 0x59, 0x23, 0x75, 0xEF, 0x7D, 0x46, 0x7C}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}}}};
const Fq6ElemStr FfElementTest::fq6_sum_ab_str = {
{{{{0xF9, 0x0B, 0x7F, 0x72, 0x65, 0x94, 0x67, 0x2A, 0x9F, 0x0F, 0x2F,
0xBA, 0x3B, 0x2B, 0x26, 0x83, 0xBA, 0xD3, 0xFB, 0x7B, 0x9D, 0x79,
0x11, 0x78, 0xF6, 0x59, 0x23, 0x75, 0xEF, 0x7D, 0x46, 0x7C},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}}}};
const Fq12ElemStr FfElementTest::fq12_sum_ab_str = {
{{{{{{0xF9, 0x0B, 0x7F, 0x72, 0x65, 0x94, 0x67, 0x2A, 0x9F, 0x0F, 0x2F,
0xBA, 0x3B, 0x2B, 0x26, 0x83, 0xBA, 0xD3, 0xFB, 0x7B, 0x9D, 0x79,
0x11, 0x78, 0xF6, 0x59, 0x23, 0x75, 0xEF, 0x7D, 0x46, 0x7C},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}}}},
{{{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
{{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}}}}}};
// a * b
const FqElemStr FfElementTest::fq_mul_ab_str = {
0xE4, 0xAB, 0xE3, 0xE4, 0x08, 0xC3, 0x8A, 0x00, 0x78, 0x50, 0x01,
0xA9, 0x4A, 0xFC, 0x43, 0x15, 0xA2, 0x99, 0x51, 0x20, 0x6B, 0x9C,
0x00, 0xCF, 0x82, 0x88, 0xBD, 0x39, 0x0B, 0xA2, 0x0B, 0x58};
const Fq2ElemStr FfElementTest::fq2_mul_ab_str = {
{{{{0xE4, 0xAB, 0xE3, 0xE4, 0x08, 0xC3, 0x8A, 0x00, 0x78, 0x50, 0x01,
0xA9, 0x4A, 0xFC, 0x43, 0x15, 0xA2, 0x99, 0x51, 0x20, 0x6B, 0x9C,
0x00, 0xCF, 0x82, 0x88, 0xBD, 0x39, 0x0B, 0xA2, 0x0B, 0x58}}},
{{{0xB4, 0xE4, 0x39, 0xEA, 0x70, 0xDE, 0x15, 0xC3, 0xC6, 0x91, 0xFD,
0x7F, 0xBE, 0x2B, 0xF5, 0xD2, 0xC0, 0xB7, 0x20, 0xFC, 0x1F, 0x02,
0x33, 0xC9, 0x39, 0x93, 0xB9, 0x5E, 0x55, 0x51, 0xB6, 0x46}}}}};
// 1/a
const FqElemStr FfElementTest::fq_inv_a_str = {
0x15, 0x17, 0x1A, 0x1E, 0x93, 0x71, 0x1B, 0x39, 0xC5, 0x97, 0xEF,
0x78, 0xA5, 0x51, 0x34, 0x62, 0x44, 0xAD, 0x8D, 0x51, 0xDF, 0x90,
0x7C, 0x6F, 0x56, 0xB6, 0xAB, 0x63, 0x5A, 0x68, 0x6D, 0xF6};
// -a
const FqElemStr FfElementTest::fq_neg_a_str = {
0xED, 0x59, 0xA4, 0x29, 0x6E, 0x6F, 0xA0, 0x25, 0xDF, 0xFA, 0x75,
0x0C, 0x0B, 0x31, 0x8D, 0x3E, 0x8C, 0xFC, 0xF9, 0x59, 0xE6, 0x7D,
0xD2, 0xA2, 0x40, 0x68, 0x36, 0x22, 0x38, 0x27, 0x7E, 0x89};
// pow(a, b)
const FqElemStr FfElementTest::fq_exp_ab_str = {
0x29, 0x65, 0x68, 0x0E, 0x56, 0xB9, 0x8F, 0xBA, 0xA6, 0xEA, 0x8F,
0xE1, 0x13, 0x44, 0x3B, 0x12, 0x5C, 0xB9, 0xF8, 0x76, 0x42, 0x12,
0xCB, 0xB2, 0xED, 0xC0, 0x23, 0xA3, 0x5C, 0xAD, 0x38, 0xD1};
const uint8_t FfElementTest::sha_msg[] = {'a', 'b', 'c'};
const FqElemStr FfElementTest::fq_abc_sha256_str = {
0xBA, 0x78, 0x16, 0xBF, 0x8F, 0x01, 0xCF, 0xEA, 0x41, 0x41, 0x40,
0xDE, 0x5D, 0xAE, 0x22, 0x23, 0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17,
0x7A, 0x9C, 0xB4, 0x10, 0xFF, 0x61, 0xF2, 0x00, 0x15, 0xAD,
};
const FqElemStr FfElementTest::fq_abc_sha384_str = {
0x10, 0xAC, 0xE4, 0xE8, 0x8F, 0xBB, 0x96, 0xBF, 0x53, 0xB6, 0xAF,
0xE4, 0x4E, 0x95, 0xDE, 0xA5, 0x98, 0x8F, 0x10, 0xBF, 0x59, 0xC4,
0x11, 0xFE, 0x1F, 0x7A, 0xA6, 0x1E, 0x57, 0x3E, 0xE3, 0x3C,
};
const FqElemStr FfElementTest::fq_abc_sha512_str = {
0x14, 0xB4, 0x28, 0x89, 0xD2, 0x86, 0xA4, 0x79, 0xE3, 0x5B, 0xC4,
0x50, 0xD1, 0x3B, 0xF2, 0x35, 0xF7, 0x97, 0x91, 0x05, 0x3D, 0x64,
0xC0, 0x06, 0x45, 0x9F, 0xEC, 0xD8, 0xDB, 0x53, 0x3E, 0xC3,
};
const FqElemStr FfElementTest::fq_abc_sha512256_str = {
0x53, 0x04, 0x8E, 0x26, 0x81, 0x94, 0x1E, 0xF9, 0x9B, 0x2E, 0x29,
0xB7, 0x6B, 0x4C, 0x7D, 0xAB, 0xE4, 0xC2, 0xD0, 0xC6, 0x34, 0xFC,
0x6D, 0x46, 0xE0, 0xE2, 0xF1, 0x31, 0x07, 0xE7, 0xAF, 0x23,
};
const Fq12ElemStr FfElementTest::fq12_g_str = {
{{{{{{0xBA, 0x10, 0x1F, 0xF6, 0x46, 0x8B, 0xE9, 0x32, 0x4F, 0xC0, 0xA5,
0x01, 0xAD, 0x5E, 0xE2, 0x31, 0x16, 0x29, 0x96, 0xED, 0xA7, 0xDE,
0x4C, 0xE1, 0xD2, 0x8D, 0x33, 0xCA, 0x50, 0xAB, 0x7B, 0xC6},
{0x15, 0xEB, 0x79, 0xF4, 0xEB, 0xDE, 0x30, 0xB6, 0xC4, 0x07, 0x7C,
0x42, 0xCB, 0x04, 0x54, 0xF2, 0x1F, 0x4D, 0x1F, 0xC0, 0xDF, 0xA2,
0x2B, 0x9E, 0x34, 0xC4, 0x4C, 0x84, 0x14, 0xD3, 0x62, 0x07}}},
{{{0xF1, 0x8B, 0x84, 0xD1, 0x46, 0x57, 0xB6, 0xE7, 0x80, 0xE1, 0x46,
0x49, 0x1C, 0x0D, 0xEF, 0x81, 0x31, 0xB0, 0xBE, 0x8C, 0xB9, 0x08,
0xD0, 0xD3, 0xC4, 0x56, 0xCA, 0xAD, 0xF9, 0x1D, 0x75, 0x19},
{0x3F, 0xEE, 0x7C, 0x43, 0xC1, 0xFA, 0x4E, 0x50, 0xB7, 0x19, 0x01,
0x00, 0x6F, 0xD5, 0x16, 0xB6, 0xF4, 0x85, 0xE0, 0xEB, 0x2E, 0x5F,
0x0A, 0x7E, 0xF8, 0xAC, 0xBC, 0x05, 0xEC, 0x73, 0xB5, 0x57}}},
{{{0xE3, 0xB3, 0x18, 0x29, 0xBB, 0xEF, 0x86, 0x50, 0x87, 0xCF, 0x70,
0xBA, 0x13, 0x8B, 0xB1, 0xB6, 0x2D, 0x6F, 0x65, 0x3D, 0xA1, 0x0B,
0xE3, 0x92, 0xC5, 0x72, 0x86, 0x6A, 0xB3, 0xEB, 0xE0, 0xE5},
{0xDA, 0x0E, 0x57, 0x87, 0xD5, 0xA9, 0x61, 0xA5, 0x1E, 0xCB, 0x04,
0x86, 0xCD, 0xC3, 0x18, 0x2A, 0x36, 0xA0, 0x81, 0x73, 0xE7, 0x13,
0x87, 0x80, 0x8D, 0x1A, 0xFE, 0x6E, 0x4B, 0xA3, 0x13, 0x03}}}}},
{{{{{0x66, 0x9E, 0x80, 0x4D, 0x8A, 0xAA, 0x00, 0x95, 0x72, 0xCE, 0xBB,
0x51, 0xE8, 0x01, 0x09, 0x41, 0xD3, 0x63, 0x28, 0x05, 0xA4, 0xBE,
0xD6, 0x41, 0xA6, 0x2F, 0x5F, 0xBF, 0x0B, 0x13, 0xB4, 0x54},
{0x5B, 0x50, 0x65, 0xDC, 0x6F, 0x29, 0xD6, 0xDA, 0xBF, 0xC2, 0x06,
0xEA, 0x3B, 0xB2, 0xF1, 0xD4, 0x26, 0x5C, 0x92, 0x6B, 0x95, 0x6D,
0x88, 0xAB, 0x8F, 0xC6, 0x9D, 0x31, 0xE4, 0x9B, 0x71, 0x49}}},
{{{0xE0, 0xCE, 0x97, 0x8F, 0xC9, 0x9F, 0xBC, 0xA8, 0x4A, 0xC6, 0xAA,
0x4A, 0xC8, 0x0D, 0x2A, 0x60, 0x1A, 0x43, 0x40, 0x03, 0xB3, 0x53,
0x30, 0x98, 0x1F, 0x3F, 0xDF, 0x5C, 0x0F, 0xF0, 0x84, 0x8E},
{0x5A, 0x5D, 0x41, 0xD2, 0x47, 0x78, 0x6D, 0x9F, 0x89, 0xCE, 0xF5,
0x8E, 0xB6, 0x54, 0xA2, 0x26, 0xE5, 0x40, 0x39, 0x5C, 0x59, 0x08,
0xB3, 0xDA, 0xF5, 0xF8, 0xA0, 0x18, 0x33, 0x57, 0xD1, 0x72}}},
{{{0xBB, 0xBA, 0x6C, 0xED, 0xE8, 0xA0, 0x5E, 0xC8, 0x81, 0xC5, 0xAC,
0x15, 0x1B, 0xD0, 0xE6, 0xC8, 0x92, 0xF9, 0x43, 0x03, 0x5A, 0x00,
0x42, 0xE3, 0x49, 0xA5, 0xF7, 0x19, 0x78, 0x8A, 0x39, 0x89},
{0x32, 0xAE, 0xBF, 0x4D, 0x4B, 0xB3, 0x33, 0x76, 0x16, 0xFD, 0x0B,
0xFE, 0x42, 0x1E, 0x17, 0x37, 0x2A, 0x04, 0xEA, 0x26, 0xBA, 0x6E,
0x2C, 0x36, 0xAF, 0x35, 0x1B, 0x75, 0x6D, 0x17, 0xDC, 0x8E}}}}}}};
const Fq12ElemStr FfElementTest::fq12_h_str = {
{{{{{{0x41, 0xFB, 0xBE, 0xD2, 0x20, 0x95, 0xE5, 0xBA, 0x87, 0x54, 0x23,
0xCC, 0x04, 0x97, 0x38, 0x4B, 0x69, 0x28, 0x18, 0x6D, 0xAE, 0x19,
0xE3, 0x3D, 0xFE, 0x39, 0xE2, 0x1C, 0xC2, 0x53, 0x17, 0xF6},
{0xEA, 0xA3, 0x0F, 0x62, 0x6E, 0xBF, 0x6F, 0x8F, 0xBC, 0xFA, 0x6E,
0x07, 0xD3, 0xD3, 0xAE, 0x5C, 0xAA, 0xB5, 0x9C, 0xD7, 0xB8, 0x5B,
0x1B, 0x69, 0x52, 0x93, 0xBF, 0xDB, 0x87, 0x5C, 0x19, 0x07}}},
{{{0x1B, 0x03, 0xE1, 0x79, 0x3C, 0x10, 0x0B, 0x65, 0xBF, 0xD7, 0xF3,
0x45, 0x1A, 0xD4, 0xDD, 0xB8, 0x67, 0x1A, 0x8F, 0x41, 0x1A, 0xD4,
0x04, 0x3C, 0xD2, 0xA4, 0x3B, 0x47, 0xFE, 0xBD, 0xEA, 0x87},
{0xDF, 0x7F, 0x94, 0x9C, 0xB8, 0x65, 0x54, 0x8D, 0xD7, 0x0B, 0x33,
0x26, 0x25, 0x89, 0xD4, 0x60, 0x0C, 0x89, 0x5F, 0x2C, 0x00, 0x7F,
0xAF, 0x89, 0x35, 0xE5, 0xB9, 0x23, 0x7F, 0x79, 0x1A, 0x86}}},
{{{0xCE, 0x01, 0x4F, 0x24, 0x3C, 0x3A, 0xC3, 0x61, 0x5B, 0xD9, 0x2D,
0x87, 0x94, 0xA3, 0xD2, 0x8B, 0x57, 0xC4, 0x07, 0xF8, 0x29, 0x5E,
0x09, 0x23, 0xCA, 0xE9, 0x85, 0xA1, 0xDB, 0xF2, 0x0C, 0x8F},
{0xC2, 0xFB, 0x9A, 0xCC, 0xD9, 0x82, 0x63, 0x28, 0x83, 0xB7, 0x4F,
0x99, 0x3A, 0x19, 0x11, 0xB0, 0xB4, 0xE7, 0x73, 0x94, 0x35, 0x19,
0x6B, 0xC2, 0x5D, 0x2E, 0x8C, 0x33, 0xFF, 0x13, 0xCD, 0xBE}}}}},
{{{{{0x29, 0x43, 0xF6, 0xA0, 0xE9, 0xDC, 0x27, 0x27, 0x9B, 0x0A, 0x33,
0xBC, 0x85, 0x6A, 0xBF, 0x8B, 0xC5, 0x89, 0x10, 0x92, 0xAE, 0x73,
0xC9, 0x32, 0x46, 0x8D, 0x24, 0x1F, 0x32, 0x96, 0xED, 0x0B},
{0x44, 0x8C, 0x6D, 0xF6, 0x1A, 0x2F, 0xCA, 0x18, 0x8E, 0x84, 0xFF,
0x5F, 0x5F, 0xAF, 0xC0, 0x52, 0x35, 0xA1, 0xB3, 0xA0, 0xDE, 0xEE,
0x97, 0xBF, 0xB8, 0xFA, 0x8B, 0x9E, 0x00, 0x13, 0xE7, 0x26}}},
{{{0xFB, 0x78, 0xA1, 0x6D, 0x41, 0x92, 0xA6, 0xC6, 0x7F, 0xAD, 0xB7,
0xFC, 0x4F, 0x5F, 0x48, 0x94, 0x7D, 0xB7, 0xF5, 0xCC, 0xB5, 0x7E,
0x08, 0xCD, 0xBF, 0x58, 0xC9, 0x30, 0xEB, 0xE4, 0xA0, 0xBF},
{0x0C, 0x6A, 0x89, 0x18, 0x97, 0x37, 0x54, 0x76, 0x79, 0x3E, 0x8E,
0xA6, 0x5B, 0x77, 0xCE, 0x4A, 0xCB, 0xD9, 0x8B, 0x7B, 0x32, 0x1A,
0x30, 0x40, 0x49, 0xFF, 0x84, 0xE7, 0xBE, 0xD8, 0xCF, 0xFD}}},
{{{0x2D, 0x23, 0x54, 0xB5, 0x2E, 0x29, 0xE9, 0xC7, 0x62, 0x1B, 0x03,
0x34, 0x3A, 0xEB, 0xC9, 0x69, 0x38, 0x9F, 0xD1, 0x2B, 0xDA, 0x8B,
0x07, 0x58, 0x30, 0xF8, 0x38, 0x08, 0x09, 0x07, 0xCA, 0x5B},
{0x3A, 0x13, 0xED, 0xF4, 0x5D, 0xC9, 0x23, 0x66, 0x85, 0x8C, 0x6A,
0x7D, 0xE9, 0x11, 0x17, 0xE6, 0x43, 0x2F, 0x12, 0xC5, 0x07, 0x63,
0x84, 0x98, 0xA0, 0x1C, 0xDC, 0xF3, 0x91, 0x91, 0x11, 0x55}}}}}}};
const Fq12ElemStr FfElementTest::fq12_i_str = {
{{{{{{0x0F, 0xD0, 0x1C, 0x59, 0x98, 0x52, 0x5A, 0x40, 0xFF, 0x26, 0x0A,
0xFD, 0x70, 0xEC, 0x23, 0x48, 0x1B, 0x4B, 0x70, 0xA0, 0x15, 0xC5,
0xB1, 0x8B, 0xA5, 0x75, 0xAC, 0xCE, 0xF3, 0x6C, 0xE8, 0xBA},
{0xA7, 0xFB, 0xF9, 0xEA, 0x18, 0x70, 0xD8, 0x9B, 0x3C, 0xC3, 0x66,
0x10, 0x38, 0xAC, 0x16, 0x32, 0xDC, 0x9D, 0xF0, 0xD4, 0x2C, 0xE7,
0xF6, 0x69, 0x47, 0x69, 0x84, 0xEE, 0x39, 0x5F, 0xD8, 0xCC}}},
{{{0x1B, 0xEF, 0x81, 0x13, 0x81, 0xB9, 0x56, 0xAE, 0xD0, 0xD4, 0xAE,
0xCB, 0x24, 0x7C, 0x7B, 0x7F, 0xC0, 0x41, 0x42, 0x0A, 0x9D, 0x90,
0x6B, 0x1E, 0x3A, 0xAD, 0x39, 0x7A, 0x1F, 0xEF, 0x56, 0x9E},
{0xBD, 0x84, 0x48, 0xAF, 0x65, 0x66, 0x33, 0xE5, 0x67, 0xF1, 0xC4,
0x48, 0xF0, 0xB6, 0x61, 0x06, 0xC7, 0x78, 0xB3, 0xC1, 0x12, 0xB8,
0x31, 0xD4, 0x69, 0x2E, 0x0E, 0xD3, 0xD4, 0x91, 0x81, 0x9A}}},
{{{0x23, 0x62, 0x9B, 0x83, 0x95, 0xF6, 0x7F, 0xF6, 0xCC, 0x6B, 0xEE,
0x84, 0xF0, 0x5B, 0x93, 0xA6, 0x90, 0x48, 0x1A, 0xA7, 0xA8, 0xE8,
0x10, 0xA5, 0x53, 0x7E, 0x4F, 0xD5, 0x0D, 0xB0, 0x86, 0xF7},
{0x1F, 0xB8, 0xB7, 0xD4, 0x2E, 0x41, 0x83, 0x2C, 0xFC, 0x62, 0x14,
0xB8, 0xC2, 0xF6, 0xC1, 0x5E, 0xC1, 0xC1, 0x40, 0x8B, 0x28, 0xB5,
0x1B, 0x85, 0xEE, 0x71, 0xC8, 0x14, 0x56, 0xB9, 0x3B, 0x90}}}}},
{{{{{0x4A, 0xFE, 0x73, 0xFA, 0xCF, 0x20, 0x67, 0x0E, 0x89, 0x1D, 0xCB,
0x05, 0x38, 0x27, 0x1C, 0xD5, 0x7A, 0x0C, 0xAC, 0x92, 0x17, 0x94,
0x7F, 0x10, 0x3E, 0xFF, 0x97, 0x23, 0x66, 0x8D, 0x70, 0xAE},
{0x80, 0x97, 0xFF, 0x88, 0xF8, 0x01, 0x2B, 0x99, 0x81, 0xEB, 0xF8,
0x19, 0xEF, 0xDA, 0xE3, 0xAE, 0xD9, 0x9B, 0x4C, 0x13, 0xFC, 0x9E,
0x18, 0xD6, 0xB0, 0xCF, 0x4E, 0x29, 0xA8, 0xCF, 0x01, 0xFA}}},
{{{0xDA, 0x22, 0x85, 0x18, 0x9A, 0x51, 0x17, 0xAC, 0x26, 0x57, 0xF6,
0x73, 0x59, 0x24, 0xD5, 0xC9, 0x4D, 0xAC, 0xB6, 0xE4, 0x51, 0xF7,
0x5E, 0x30, 0x5B, 0x25, 0x3D, 0x52, 0xA3, 0xE0, 0x4B, 0xA2},
{0xC3, 0x4C, 0x2F, 0x53, 0xD5, 0x92, 0x33, 0x7E, 0x8B, 0x66, 0x5F,
0x48, 0x48, 0xCA, 0xA8, 0x98, 0x0F, 0x73, 0xD3, 0x60, 0xAF, 0x25,
0x02, 0xEE, 0x64, 0xE7, 0x02, 0x89, 0x9A, 0xD2, 0x96, 0x45}}},
{{{0x04, 0xE1, 0x30, 0x9B, 0xD8, 0x85, 0xF0, 0x99, 0x7C, 0x01, 0xD5,
0x58, 0x5A, 0x74, 0x0B, 0xD4, 0xF2, 0xFA, 0xC7, 0x59, 0x36, 0xFD,
0x91, 0x07, 0x60, 0xF7, 0xDC, 0x11, 0x3E, 0x8A, 0xC6, 0x48},
{0x0D, 0x02, 0x30, 0x18, 0xD0, 0xB9, 0x6B, 0xD6, 0x39, 0x6A, 0x41,
0x82, 0xDD, 0xE3, 0xCE, 0xB8, 0xB6, 0xF5, 0x61, 0x80, 0x61, 0x16,
0xF4, 0x9A, 0xB8, 0x58, 0x1D, 0x3F, 0x4D, 0xC2, 0xCA, 0xCF}}}}}}};
const Fq12ElemStr FfElementTest::fq12_j_str = {
{{{{{{0x3A, 0x30, 0x33, 0xA2, 0x14, 0xDF, 0xDC, 0x70, 0x48, 0xF3, 0xBA,
0x3F, 0xCE, 0xFC, 0x69, 0x24, 0xAE, 0xA1, 0xF3, 0xCF, 0xD8, 0x77,
0x69, 0x38, 0x38, 0xF4, 0x8E, 0xFB, 0x51, 0xFB, 0x10, 0x7C},
{0x73, 0xB4, 0xEE, 0xF9, 0x76, 0xBB, 0x45, 0xEC, 0x07, 0x24, 0x23,
0xA3, 0x38, 0x64, 0x39, 0x4C, 0x03, 0x94, 0xF5, 0xEE, 0x5F, 0xC9,
0x83, 0x4F, 0xD1, 0xA6, 0x4A, 0x05, 0x25, 0x0C, 0x46, 0x33}}},
{{{0xD4, 0x40, 0x47, 0xAE, 0xEC, 0xDA, 0x30, 0xF9, 0xE1, 0x28, 0xFB,
0xB1, 0x4C, 0x62, 0xFB, 0x6C, 0x90, 0x0D, 0xB1, 0xEC, 0xAF, 0x2D,
0x95, 0x64, 0x11, 0x93, 0xDA, 0x8E, 0xB8, 0x7D, 0xE4, 0xA3},
{0x8E, 0xA6, 0x9B, 0xAA, 0x58, 0xD5, 0xDC, 0x59, 0x1A, 0x51, 0x53,
0x47, 0x30, 0x1C, 0x2B, 0xB0, 0xBB, 0x57, 0x57, 0x0A, 0x8C, 0x5F,
0x62, 0x9C, 0x52, 0x28, 0xC0, 0x25, 0x27, 0xAE, 0xCD, 0x36}}},
{{{0xBF, 0x2D, 0x03, 0xB1, 0x33, 0xFD, 0x24, 0x81, 0x3C, 0x91, 0x43,
0x90, 0x0C, 0x20, 0xC4, 0xE3, 0x69, 0x3F, 0xA9, 0xA2, 0x7C, 0xC2,
0x48, 0x28, 0x1B, 0xF0, 0x81, 0x1F, 0x2B, 0x8F, 0x8D, 0x43},
{0x38, 0x18, 0x12, 0xA3, 0x89, 0xF1, 0xD7, 0x60, 0x89, 0x68, 0x6A,
0xC4, 0xCC, 0x5D, 0xF4, 0xCE, 0x43, 0x95, 0x84, 0xCD, 0x01, 0x55,
0xB8, 0x5D, 0x24, 0x50, 0xCD, 0xE3, 0x68, 0x1C, 0xFF, 0x59}}}}},
{{{{{0x0D, 0xAC, 0xCB, 0xE7, 0x9D, 0x68, 0x0F, 0x4A, 0xAF, 0xEB, 0xB5,
0xFB, 0xF9, 0xB1, 0x58, 0x80, 0xD5, 0x71, 0x53, 0x26, 0x2E, 0x9C,
0xCE, 0x10, 0xAC, 0xD2, 0x0A, 0xEB, 0xB4, 0x5C, 0xC8, 0xD7},
{0x16, 0x26, 0x66, 0x71, 0xDD, 0x67, 0xBA, 0xDB, 0x35, 0x76, 0x64,
0xC6, 0x0B, 0x0B, 0x07, 0x4B, 0x65, 0xA2, 0xF7, 0x68, 0x9E, 0xFE,
0xE8, 0xE3, 0xA7, 0x09, 0x79, 0xC5, 0xDF, 0x5E, 0x9C, 0xEC}}},
{{{0xEE, 0x83, 0x59, 0xB5, 0x89, 0x81, 0xA2, 0x87, 0xD7, 0x75, 0x65,
0x90, 0xDE, 0x78, 0x37, 0x59, 0x04, 0x9B, 0x50, 0xC3, 0xBA, 0x90,
0x09, 0x15, 0xAB, 0x17, 0xC5, 0xBF, 0x5B, 0xB9, 0xE4, 0x6C},
{0xA9, 0xB1, 0x49, 0x76, 0x25, 0x74, 0x5D, 0x9C, 0x78, 0xC5, 0x09,
0xEE, 0xEB, 0xEB, 0x9D, 0x1C, 0x6C, 0xC0, 0x27, 0x9D, 0x66, 0xE6,
0x7F, 0x31, 0xCD, 0xB0, 0x8A, 0xE4, 0x9E, 0xBD, 0x70, 0x18}}},
{{{0x88, 0xA1, 0x08, 0x39, 0xA2, 0x48, 0xA5, 0x98, 0xB6, 0xAD, 0x10,
0x54, 0x07, 0xCD, 0xFC, 0x6D, 0xB1, 0x02, 0xFF, 0xE3, 0x92, 0xD7,
0x9D, 0x48, 0xFB, 0xCE, 0x88, 0x46, 0x92, 0x07, 0x02, 0xBA},
{0xEE, 0xEB, 0xAE, 0x88, 0xB1, 0x4E, 0xD0, 0xF2, 0xCE, 0xD7, 0x57,
0x07, 0xD4, 0x39, 0xD2, 0x7D, 0x1A, 0x0C, 0xEF, 0xF2, 0x84, 0x84,
0x22, 0x8A, 0xB1, 0x80, 0x0D, 0xDC, 0x64, 0x86, 0xFD, 0x70}}}}}}};
const Fq12ElemStr FfElementTest::fq12_mul_ij_str = {
{{{{{{0x4A, 0x0E, 0x83, 0x4F, 0x62, 0xCA, 0x56, 0x0B, 0x0F, 0x2E, 0xF3,
0x1A, 0xC6, 0xFC, 0x76, 0x4F, 0x4B, 0x85, 0x78, 0x6F, 0x9D, 0xB9,
0xBD, 0xC8, 0xBB, 0x7C, 0x73, 0x12, 0x28, 0xFF, 0xBC, 0x8F},
{0x18, 0x8E, 0x5E, 0x4B, 0x72, 0xA5, 0x4A, 0x99, 0xFC, 0xE7, 0x05,
0xE5, 0xD2, 0x2C, 0x06, 0x95, 0xF5, 0xE4, 0xA5, 0x87, 0xCB, 0x85,
0x25, 0xF8, 0xDA, 0x71, 0x7B, 0x9A, 0xF1, 0x52, 0xF9, 0x33}}},
{{{0x05, 0x5F, 0x15, 0x72, 0xA3, 0x61, 0xA6, 0x6C, 0xB8, 0x43, 0xBB,
0xCA, 0x33, 0xB2, 0xDB, 0x59, 0xCA, 0xAB, 0xAD, 0xA0, 0x4D, 0xE3,
0xB8, 0xF5, 0xC9, 0x8C, 0x06, 0x91, 0xE5, 0xE4, 0x5A, 0xAD},
{0xE7, 0x66, 0xCC, 0x2B, 0x2C, 0x11, 0x88, 0x29, 0xB1, 0x3C, 0x52,
0xFE, 0x50, 0xDF, 0x8F, 0x15, 0x6A, 0x6B, 0xB8, 0x32, 0x96, 0x90,
0x85, 0x03, 0x78, 0x88, 0x97, 0x7B, 0x5B, 0x50, 0x2E, 0xDE}}},
{{{0xE7, 0x53, 0x22, 0x11, 0xEB, 0xFF, 0x1B, 0x19, 0xAE, 0x5F, 0x58,
0x3A, 0x4F, 0x6F, 0x34, 0xFB, 0x2A, 0x49, 0xCA, 0x4B, 0x9C, 0x31,
0xFC, 0x74, 0x0F, 0x11, 0xCC, 0x45, 0xCD, 0xA2, 0x12, 0xCA},
{0xF4, 0x2F, 0x30, 0x9A, 0x6A, 0xCB, 0xEE, 0x88, 0x15, 0x56, 0x29,
0x2A, 0xBF, 0x33, 0x7B, 0xDB, 0x59, 0x74, 0x4D, 0xC0, 0x64, 0xF0,
0x0B, 0x9F, 0xF2, 0x65, 0xB7, 0x3A, 0xDA, 0xE2, 0xB5, 0x63}}}}},
{{{{{0x3A, 0x3E, 0x06, 0xEF, 0x73, 0xA3, 0xBC, 0xEA, 0xCC, 0x68, 0xD9,
0xF5, 0x6E, 0x94, 0x1C, 0x54, 0x47, 0xF1, 0x99, 0x2C, 0x44, 0x64,
0x45, 0x84, 0x50, 0x10, 0xFD, 0xC5, 0x16, 0x65, 0x89, 0xEC},
{0x72, 0xA6, 0x7E, 0x82, 0x7F, 0xE2, 0xE3, 0xEA, 0x82, 0xA3, 0x18,
0xF4, 0x9B, 0x93, 0x4D, 0x79, 0xA0, 0x2C, 0xBF, 0x90, 0x0E, 0xDB,
0x41, 0x09, 0x27, 0x44, 0x19, 0xD1, 0xB4, 0xE5, 0xC6, 0x8C}}},
{{{0xA5, 0xC7, 0x82, 0xBF, 0x00, 0x7B, 0x8D, 0x7A, 0x05, 0x7B, 0x7E,
0x33, 0x60, 0x28, 0x34, 0x9C, 0x86, 0x5A, 0x6B, 0xCE, 0xA5, 0xED,
0x26, 0x22, 0x63, 0x4A, 0xE9, 0x57, 0xCD, 0x55, 0xD2, 0xD3},
{0x0E, 0x73, 0x14, 0xE4, 0xEE, 0xE7, 0x3C, 0x43, 0xFC, 0xAE, 0x84,
0x59, 0x2F, 0xEA, 0x35, 0x84, 0xA5, 0x77, 0xCE, 0xA8, 0xC5, 0xAA,
0xB8, 0xDC, 0xB9, 0xD6, 0x71, 0x11, 0xE2, 0x95, 0x00, 0x97}}},
{{{0xBD, 0x50, 0xDA, 0x58, 0x1B, 0xDA, 0xB3, 0x25, 0x19, 0x2F, 0x9D,
0xFA, 0x2C, 0xFB, 0x96, 0x26, 0xBB, 0x4A, 0x41, 0x82, 0xA9, 0x45,
0x24, 0xEE, 0xEE, 0xEA, 0xD3, 0xC5, 0x94, 0xFC, 0x2A, 0x37},
{0x6A, 0x43, 0xB8, 0x6C, 0xBB, 0x98, 0xB7, 0x17, 0x03, 0xC0, 0x3D,
0x6D, 0x59, 0x56, 0x3D, 0x23, 0x42, 0x94, 0x25, 0x64, 0xB9, 0x62,
0xAD, 0x4D, 0x84, 0x9B, 0x3C, 0x05, 0x8C, 0xF0, 0xD3, 0xD3}}}}}},
};
const Fq12ElemStr FfElementTest::fq12_k_str = {
{{{{{{0xE4, 0xCA, 0x0B, 0xA8, 0x9C, 0x70, 0xE2, 0x20, 0x24, 0xD9, 0x8F,
0x09, 0x12, 0x79, 0x55, 0x44, 0x8C, 0x58, 0x42, 0x8F, 0x18, 0x97,
0x0A, 0xC3, 0x0A, 0x40, 0x68, 0x0E, 0x1E, 0x21, 0x7F, 0xB4},
{0x73, 0xCF, 0x8D, 0x54, 0x68, 0xAE, 0x1C, 0xC4, 0x95, 0x01, 0xE3,
0x52, 0x33, 0xFE, 0x69, 0xB5, 0x23, 0x45, 0xEF, 0xFF, 0x79, 0x14,
0xEF, 0x98, 0xA8, 0x4E, 0xB1, 0x2E, 0xE1, 0x15, 0x81, 0x0C}}},
{{{0x9F, 0x65, 0x90, 0x6A, 0x53, 0xD7, 0xF6, 0x73, 0x08, 0xDA, 0x45,
0x11, 0xDE, 0xCF, 0xED, 0x4C, 0x8C, 0x21, 0x02, 0xF5, 0x3F, 0x97,
0xB6, 0xB2, 0xF5, 0xC6, 0x58, 0xFC, 0x9A, 0xA6, 0xBB, 0xF9},
{0x3C, 0xD8, 0xFC, 0x86, 0x09, 0x1C, 0x16, 0xA4, 0x6F, 0x5E, 0x7A,
0x81, 0x01, 0xF9, 0x8A, 0x6D, 0x38, 0xB5, 0xC9, 0x5F, 0xE9, 0x7D,
0x6F, 0x46, 0x92, 0x49, 0x5B, 0xB8, 0x61, 0x03, 0x6F, 0x5E}}},
{{{0xDA, 0x53, 0xCB, 0x62, 0xCD, 0x82, 0x63, 0x96, 0xC7, 0xC0, 0x39,
0xA4, 0x31, 0xEE, 0x15, 0x26, 0x1C, 0xE6, 0x4E, 0xE4, 0xB4, 0x40,
0xFA, 0x65, 0xA3, 0xF4, 0x73, 0x03, 0x85, 0x84, 0x41, 0xF9},
{0x77, 0xF3, 0x90, 0xDC, 0x88, 0x26, 0xBD, 0x27, 0x9A, 0x9D, 0x37,
0xF0, 0x80, 0xEE, 0x02, 0x1D, 0x3E, 0x4F, 0x88, 0xED, 0x8F, 0x89,
0x90, 0xF1, 0x6D, 0x5D, 0x70, 0x49, 0x99, 0x07, 0x61, 0x22}}}}},
{{{{{0x43, 0x52, 0xBA, 0xEE, 0xA8, 0xE9, 0x8E, 0x2E, 0x83, 0x30, 0x41,
0x85, 0xE3, 0x51, 0xB0, 0x8C, 0x86, 0x31, 0xEC, 0x02, 0x76, 0xE8,
0x41, 0x1F, 0x88, 0xBC, 0x39, 0xA2, 0xE4, 0xC1, 0x34, 0xA7},
{0x1D, 0x5F, 0x8C, 0x23, 0x0F, 0xF0, 0xDC, 0xCD, 0xBA, 0x67, 0xD5,
0x78, 0xD6, 0x8D, 0x32, 0x6A, 0xC1, 0x7F, 0x6F, 0x97, 0xCF, 0x46,
0xF0, 0x04, 0x7B, 0xE3, 0x5A, 0xEE, 0x31, 0xC4, 0xC0, 0x79}}},
{{{0x96, 0xBC, 0x01, 0x78, 0x9F, 0xBE, 0x8B, 0xBA, 0x59, 0x22, 0xFB,
0x64, 0x1B, 0x37, 0x5C, 0x33, 0x57, 0xAF, 0x83, 0x5A, 0x96, 0xEA,
0x56, 0xAA, 0x6E, 0x9C, 0xFA, 0xE6, 0xF9, 0xDF, 0xD8, 0x44},
{0xBB, 0x4E, 0xBF, 0xA8, 0xEC, 0x0F, 0x16, 0xA8, 0x59, 0x1F, 0x49,
0xF4, 0x8C, 0x80, 0x6C, 0x52, 0x7F, 0x74, 0x94, 0xC2, 0xE3, 0x29,
0x34, 0x9C, 0x97, 0xB9, 0x5E, 0xED, 0xFD, 0x59, 0x9D, 0xD4}}},
{{{0x83, 0xFB, 0xC2, 0xAD, 0x72, 0xE8, 0xF3, 0x68, 0x43, 0xD0, 0xD4,
0xDC, 0xB2, 0x36, 0xC1, 0xDB, 0x03, 0x29, 0xEE, 0x8C, 0x1A, 0x10,
0xD7, 0xFB, 0xC2, 0xEA, 0xDA, 0xBA, 0x42, 0x18, 0xE6, 0xE4},
{0x63, 0x41, 0x6E, 0x8C, 0xB3, 0x14, 0x68, 0x9A, 0x0F, 0x64, 0x87,
0x16, 0x02, 0xA3, 0x59, 0xF4, 0x60, 0x80, 0x04, 0x2B, 0xA4, 0xE6,
0x10, 0x2D, 0x61, 0x59, 0x14, 0xFE, 0xAF, 0x84, 0xA0, 0x67}}}}}}};
const Fq12ElemStr FfElementTest::fq12_mul_gb_str = {
{{{{{{0xE4, 0xCA, 0x0B, 0xA8, 0x9C, 0x70, 0xE2, 0x20, 0x24, 0xD9, 0x8F,
0x09, 0x12, 0x79, 0x55, 0x44, 0x8C, 0x58, 0x42, 0x8F, 0x18, 0x97,
0x0A, 0xC3, 0x0A, 0x40, 0x68, 0x0E, 0x1E, 0x21, 0x7F, 0xB4},
{0x73, 0xCF, 0x8D, 0x54, 0x68, 0xAE, 0x1C, 0xC4, 0x95, 0x01, 0xE3,
0x52, 0x33, 0xFE, 0x69, 0xB5, 0x23, 0x45, 0xEF, 0xFF, 0x79, 0x14,
0xEF, 0x98, 0xA8, 0x4E, 0xB1, 0x2E, 0xE1, 0x15, 0x81, 0x0C}}},
{{{0x9F, 0x65, 0x90, 0x6A, 0x53, 0xD7, 0xF6, 0x73, 0x08, 0xDA, 0x45,
0x11, 0xDE, 0xCF, 0xED, 0x4C, 0x8C, 0x21, 0x02, 0xF5, 0x3F, 0x97,
0xB6, 0xB2, 0xF5, 0xC6, 0x58, 0xFC, 0x9A, 0xA6, 0xBB, 0xF9},
{0x3C, 0xD8, 0xFC, 0x86, 0x09, 0x1C, 0x16, 0xA4, 0x6F, 0x5E, 0x7A,
0x81, 0x01, 0xF9, 0x8A, 0x6D, 0x38, 0xB5, 0xC9, 0x5F, 0xE9, 0x7D,
0x6F, 0x46, 0x92, 0x49, 0x5B, 0xB8, 0x61, 0x03, 0x6F, 0x5E}}},
{{{0xDA, 0x53, 0xCB, 0x62, 0xCD, 0x82, 0x63, 0x96, 0xC7, 0xC0, 0x39,
0xA4, 0x31, 0xEE, 0x15, 0x26, 0x1C, 0xE6, 0x4E, 0xE4, 0xB4, 0x40,
0xFA, 0x65, 0xA3, 0xF4, 0x73, 0x03, 0x85, 0x84, 0x41, 0xF9},
{0x77, 0xF3, 0x90, 0xDC, 0x88, 0x26, 0xBD, 0x27, 0x9A, 0x9D, 0x37,
0xF0, 0x80, 0xEE, 0x02, 0x1D, 0x3E, 0x4F, 0x88, 0xED, 0x8F, 0x89,
0x90, 0xF1, 0x6D, 0x5D, 0x70, 0x49, 0x99, 0x07, 0x61, 0x22}}}}},
{{{{{0xBC, 0xAD, 0x45, 0x11, 0x57, 0x13, 0x62, 0x9E, 0xC3, 0xB5, 0xB0,
0xD9, 0x0B, 0x1F, 0xF4, 0x12, 0x86, 0xAA, 0x79, 0xF8, 0x9B, 0xAF,
0xC9, 0x63, 0x4A, 0x6C, 0xF4, 0x38, 0xCA, 0x11, 0xFB, 0x6C},
{0xE2, 0xA0, 0x73, 0xDC, 0xF0, 0x0C, 0x13, 0xFF, 0x8C, 0x7E, 0x1C,
0xE6, 0x17, 0xE4, 0x72, 0x34, 0x4B, 0x5C, 0xF6, 0x63, 0x43, 0x51,
0x1A, 0x7E, 0x57, 0x45, 0xD2, 0xED, 0x7D, 0x0E, 0x6F, 0x9A}}},
{{{0x69, 0x43, 0xFE, 0x87, 0x60, 0x3E, 0x65, 0x12, 0xED, 0xC2, 0xF6,
0xFA, 0xD3, 0x3A, 0x48, 0x6B, 0xB5, 0x2C, 0xE2, 0xA0, 0x7B, 0xAD,
0xB3, 0xD8, 0x64, 0x8C, 0x32, 0xF4, 0xB4, 0xF3, 0x57, 0xCF},
{0x44, 0xB1, 0x40, 0x57, 0x13, 0xED, 0xDA, 0x24, 0xED, 0xC6, 0xA8,
0x6A, 0x61, 0xF1, 0x38, 0x4C, 0x8D, 0x67, 0xD1, 0x38, 0x2F, 0x6E,
0xD5, 0xE6, 0x3B, 0x6F, 0xCE, 0xED, 0xB1, 0x79, 0x92, 0x3F}}},
{{{0x7C, 0x04, 0x3D, 0x52, 0x8D, 0x13, 0xFD, 0x65, 0x03, 0x15, 0x1D,
0x82, 0x3C, 0x3A, 0xE2, 0xC4, 0x09, 0xB2, 0x77, 0x6E, 0xF8, 0x87,
0x32, 0x87, 0x10, 0x3E, 0x53, 0x21, 0x6C, 0xBA, 0x49, 0x2F},
{0x9C, 0xBE, 0x91, 0x73, 0x4C, 0xE8, 0x88, 0x33, 0x37, 0x81, 0x6B,
0x48, 0xEB, 0xCE, 0x4A, 0xAA, 0xAC, 0x5C, 0x61, 0xCF, 0x6D, 0xB1,
0xFA, 0x55, 0x71, 0xD0, 0x18, 0xDC, 0xFF, 0x4E, 0x8F, 0xAC}}}}}},
};
const FqElemStr FfElementTest::fq_multi_exp_base_1[1] = {{
0x12, 0xA6, 0x5B, 0xD6, 0x91, 0x8D, 0x50, 0xA7, 0x66, 0xEB, 0x7D,
0x52, 0xE3, 0x40, 0x17, 0x60, 0x7F, 0xDF, 0x6C, 0xA1, 0x2C, 0x1A,
0x37, 0xE0, 0x92, 0xC0, 0xF7, 0xB9, 0x76, 0xAB, 0xB1, 0x8A,
}};
const BigNumStr FfElementTest::fq_multi_exp_exp_1[1] = {{
0xFF, 0xFB, 0x3E, 0x5D, 0xFF, 0x9A, 0xFF, 0x02, 0x00, 0xFF, 0xFF,
0xFF, 0xF2, 0xE1, 0x85, 0x81, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x81, 0xFF, 0xFD, 0xFF, 0xEB, 0xFF, 0x29, 0xA7, 0xFF,
}};
const FqElemStr FfElementTest::fq_multi_exp_res_1 = {
0x6A, 0x21, 0xEC, 0x89, 0xCC, 0x13, 0x2F, 0x6F, 0x29, 0x1B, 0x3A,
0x94, 0xF6, 0xE6, 0xA8, 0xBD, 0x98, 0x25, 0x43, 0x7A, 0xDC, 0xC1,
0x20, 0xBA, 0x30, 0xD8, 0x1C, 0x8E, 0x79, 0xFC, 0xDA, 0x67,
};
const std::vector<uint8_t> FfElementTest::fq_multi_exp_exp_1_264({
0x08, 0xFF, 0xFB, 0x3E, 0x5D, 0xFF, 0x9A, 0xFF, 0x02, 0x00, 0xFF,
0xFF, 0xFF, 0xF2, 0xE1, 0x85, 0x81, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x81, 0xFF, 0xFD, 0xFF, 0xEB, 0xFF, 0x29, 0xA7, 0xFF,
});
const FqElemStr FfElementTest::fq_multi_exp_res_1_264 = {
0x71, 0x41, 0xa1, 0xdb, 0xd1, 0xd1, 0x50, 0xc2, 0x73, 0x07, 0xc1,
0x93, 0xeb, 0xae, 0x89, 0x4c, 0x6e, 0x49, 0x74, 0xf7, 0x46, 0x23,
0x75, 0xca, 0xc8, 0x67, 0x82, 0xaf, 0xcf, 0x35, 0x34, 0x1c};
const FqElemStr FfElementTest::fq_multi_exp_res_1_256_264 = {
0x10, 0x2f, 0x3a, 0xe5, 0x6e, 0x95, 0x92, 0x8f, 0x98, 0x03, 0x67,
0x79, 0xec, 0x0c, 0xc9, 0x46, 0x07, 0xd9, 0xd9, 0x40, 0x46, 0x29,
0x99, 0xe9, 0x23, 0xf9, 0x6b, 0x10, 0x35, 0x7c, 0xf1, 0xa3};
const FqElemStr FfElementTest::fq_multi_exp_base_2[2] = {
{0xE6, 0x65, 0x23, 0x9B, 0xD4, 0x07, 0x16, 0x83, 0x38, 0x23, 0xB2,
0x67, 0x57, 0xEB, 0x0F, 0x23, 0x3A, 0xF4, 0x8E, 0xDA, 0x71, 0x5E,
0xD9, 0x98, 0x63, 0x98, 0x2B, 0xBC, 0x78, 0xD1, 0x94, 0xF2},
{0xDD, 0x2B, 0xE9, 0x59, 0x24, 0xA5, 0xB3, 0xFD, 0xEB, 0xE1, 0x3C,
0xC0, 0x73, 0x4E, 0x99, 0xEE, 0x36, 0xF6, 0xC0, 0x1A, 0x76, 0x01,
0x0A, 0xF0, 0xCB, 0xB4, 0x71, 0x88, 0x95, 0xCB, 0x35, 0xBA}};
const BigNumStr FfElementTest::fq_multi_exp_exp_2[2] = {
{0x11, 0xFF, 0xFF, 0xFF, 0x4F, 0x59, 0xB1, 0xD3, 0x6B, 0x08, 0xFF,
0xFF, 0x0B, 0xF3, 0xAF, 0x27, 0xFF, 0xB8, 0xFF, 0xFF, 0x98, 0xFF,
0xEB, 0xFF, 0xF2, 0x6A, 0xFF, 0xFF, 0xEA, 0x31, 0xFF, 0xFF},
{0xE2, 0xFF, 0x03, 0x1D, 0xFF, 0x19, 0x81, 0xCB, 0xFF, 0xFF, 0x6B,
0xD5, 0x3E, 0xFF, 0xFF, 0xFF, 0xFF, 0xBD, 0xFF, 0x5A, 0xFF, 0x5C,
0x7C, 0xFF, 0x84, 0xFF, 0xFF, 0x8C, 0x03, 0xB2, 0x26, 0xFF}};
const FqElemStr FfElementTest::fq_multi_exp_res_2 = {
0x8A, 0xF7, 0x96, 0x53, 0x9C, 0xC3, 0x57, 0x89, 0x50, 0xE3, 0xAB,
0x12, 0x62, 0xEA, 0x0C, 0xE4, 0x65, 0xA6, 0x91, 0x09, 0x93, 0x81,
0xFC, 0xBB, 0x0E, 0xFA, 0xC1, 0xC4, 0xDC, 0x3F, 0x0A, 0xD1,
};
const FqElemStr FfElementTest::fq_multi_exp_base_3[3] = {
{0x24, 0x9D, 0xDD, 0x1A, 0xC0, 0x07, 0x1F, 0x65, 0xDF, 0xBB, 0xC7,
0x39, 0x99, 0x44, 0x63, 0x8E, 0x7E, 0xB2, 0x85, 0x82, 0xC6, 0x4E,
0x2D, 0x39, 0xA8, 0x3F, 0x12, 0xB4, 0xE9, 0x9D, 0x67, 0x28},
{0x6B, 0x51, 0x6B, 0x33, 0x0B, 0x2E, 0x2A, 0x94, 0x34, 0xCC, 0x7E,
0x97, 0xFA, 0x85, 0x51, 0x44, 0x30, 0xE5, 0xF2, 0x68, 0x23, 0x31,
0x84, 0xFF, 0xBB, 0x95, 0x9A, 0xB2, 0x80, 0x95, 0xC4, 0x91},
{0x77, 0xED, 0xA2, 0x53, 0xA3, 0xBF, 0x6C, 0x58, 0x16, 0x7D, 0xEF,
0x8A, 0x7D, 0x38, 0x65, 0x3F, 0x92, 0xA6, 0x85, 0xD7, 0x9F, 0x80,
0xA4, 0xA1, 0x70, 0x02, 0xE5, 0x66, 0xF2, 0xD8, 0xD7, 0xD2}};
const BigNumStr FfElementTest::fq_multi_exp_exp_3[3] = {
{0xFF, 0xFF, 0xFF, 0xB4, 0x48, 0xFF, 0xFF, 0xFF, 0xA3, 0xFF, 0xE3,
0xFF, 0x61, 0xFF, 0xA2, 0x97, 0x9A, 0xFF, 0x6F, 0x04, 0xC6, 0xB9,
0xFF, 0x22, 0xFF, 0x20, 0x9E, 0xFF, 0x43, 0xFF, 0xFF, 0xFF},
{0xB1, 0x19, 0xBF, 0xFF, 0x74, 0x7F, 0xCC, 0x34, 0x1E, 0x30, 0x7D,
0xC5, 0xC4, 0xFF, 0xE7, 0xF8, 0xFF, 0x5F, 0xFF, 0x73, 0xFF, 0x58,
0xFF, 0xD6, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xEC, 0xFF, 0xFF},
{0xFF, 0xFF, 0x0D, 0xFF, 0xFF, 0xFF, 0xFF, 0x26, 0xA8, 0xFF, 0xFF,
0xFF, 0x3E, 0xFF, 0xFF, 0xFF, 0xE0, 0x4F, 0xFF, 0xE3, 0xFF, 0xFF,
0xEB, 0x04, 0x4B, 0xFF, 0x5D, 0x55, 0xFF, 0x2D, 0xFF, 0xFF}};
const FqElemStr FfElementTest::fq_multi_exp_res_3 = {
0x04, 0x22, 0x21, 0xE7, 0x9F, 0xE3, 0x07, 0x2F, 0xA4, 0xBB, 0x56,
0x84, 0xD5, 0x93, 0x4A, 0xDA, 0x5B, 0x89, 0x07, 0xBE, 0xC5, 0x5F,
0xE6, 0x5C, 0x18, 0xF0, 0xF8, 0x8E, 0x8E, 0x00, 0xB9, 0x87,
};
const FqElemStr FfElementTest::fq_multi_exp_base_4[4] = {
{0x81, 0xEE, 0x78, 0x31, 0x4C, 0xC0, 0x3C, 0xDD, 0x16, 0x52, 0xC6,
0x7E, 0x07, 0x4C, 0xFE, 0xC4, 0x50, 0x63, 0x5A, 0x40, 0xC8, 0xDF,
0x94, 0x23, 0x1A, 0x90, 0xDD, 0x24, 0x61, 0x23, 0xDD, 0x87},
{0x76, 0xBB, 0x2C, 0x1C, 0xB3, 0x78, 0x93, 0x7E, 0x10, 0x29, 0xC3,
0xEC, 0xBD, 0xA3, 0x75, 0x3A, 0xF1, 0x0B, 0xE1, 0xCA, 0xEE, 0x02,
0x58, 0x74, 0xC7, 0xDC, 0xB8, 0x4F, 0x3F, 0x7B, 0xA2, 0xFC},
{0x3A, 0xD3, 0x04, 0xAA, 0x9D, 0x2A, 0xDE, 0x86, 0x56, 0x84, 0x80,
0x42, 0xA5, 0x68, 0xD8, 0x6E, 0x65, 0xC4, 0x08, 0x07, 0x87, 0x4B,
0xC1, 0x92, 0xCB, 0x68, 0x52, 0x6C, 0x5A, 0x4F, 0x7C, 0xFB},
{0x56, 0xE7, 0xBD, 0x59, 0x54, 0xCC, 0x20, 0x16, 0xAE, 0x36, 0xD1,
0xB0, 0xE4, 0x82, 0x47, 0x27, 0x32, 0xD1, 0x38, 0x7C, 0x53, 0x7F,
0xDD, 0xF4, 0xDE, 0xFA, 0xF7, 0x0F, 0xDD, 0xDF, 0x48, 0xA9}};
const BigNumStr FfElementTest::fq_multi_exp_exp_4[4] = {
{0xFF, 0xA5, 0xC3, 0xFF, 0xFF, 0x09, 0x18, 0x18, 0x95, 0x40, 0xFF,
0xFF, 0xDB, 0xFF, 0xFF, 0xFF, 0xFF, 0x99, 0xFF, 0x25, 0xFF, 0xFF,
0x42, 0x07, 0xB5, 0xFF, 0x26, 0xE0, 0x4F, 0xB5, 0xB4, 0xFF},
{0x1F, 0xFF, 0xAA, 0xF1, 0xFF, 0xFF, 0x7E, 0xFF, 0xFF, 0xFF, 0x07,
0xFF, 0xE7, 0xDF, 0xFF, 0xEE, 0xFF, 0x57, 0xFF, 0xFF, 0xFF, 0xB8,
0xB3, 0x9C, 0xFF, 0x8A, 0x89, 0xFF, 0xFE, 0x32, 0xFF, 0xC1},
{0x9A, 0xFF, 0xFF, 0x9B, 0xFF, 0xAB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x36, 0xF0, 0xC5, 0xAE, 0x87, 0x41, 0xFF, 0x5C, 0xDD,
0xFF, 0xFF, 0xFF, 0xFF, 0x59, 0xC9, 0xFF, 0x44, 0x5C, 0x58},
{0x00, 0xFF, 0x95, 0xFF, 0x21, 0xFF, 0xFF, 0x1D, 0x1A, 0x06, 0xD3,
0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0xFF, 0xFF, 0xFF, 0xB0, 0x31, 0xFF,
0xFF, 0x1F, 0x61, 0x48, 0xFF, 0xFF, 0xFF, 0x17, 0xC9, 0x79}};
const FqElemStr FfElementTest::fq_multi_exp_res_4 = {
0x26, 0x2C, 0x23, 0x55, 0xD5, 0xBD, 0x7B, 0x67, 0x60, 0xFE, 0x06,
0x7B, 0xCC, 0xB8, 0x6B, 0xC9, 0x00, 0x81, 0xAE, 0xCB, 0xEC, 0x91,
0x6D, 0x1B, 0x9E, 0x1C, 0xD8, 0xC0, 0x8D, 0x3F, 0x1B, 0x20,
};
const Fq12ElemStr FfElementTest::fq12_multi_exp_base_4[4] = {
{
{{{{{{0x2C, 0x86, 0xEE, 0x80, 0x61, 0x45, 0x8F, 0xFD, 0x96, 0xC2, 0x81,
0x11, 0xE8, 0x96, 0xE2, 0xCA, 0x21, 0x78, 0xF7, 0xA3, 0x4B, 0xBA,
0xDC, 0x0D, 0x34, 0x8A, 0x56, 0x12, 0x67, 0x8D, 0x72, 0x37},
{0xA8, 0xEB, 0x5F, 0x1A, 0x1B, 0xF0, 0x5C, 0xC6, 0x6F, 0xC2, 0xC5,
0x03, 0xC4, 0x19, 0x85, 0xA6, 0xE0, 0x64, 0xFE, 0x71, 0x51, 0x46,
0xDF, 0xC2, 0xD6, 0xF9, 0xA0, 0xD6, 0x84, 0xC1, 0x4A, 0x11}}},
{{{0xE0, 0x33, 0xA3, 0x1C, 0x73, 0x71, 0x62, 0x17, 0x10, 0x4C, 0xD8,
0x3E, 0xEE, 0xA1, 0x38, 0x9F, 0xA5, 0xFB, 0x1D, 0xC4, 0x9D, 0x2F,
0x08, 0x4A, 0xD3, 0x61, 0x37, 0x79, 0xAB, 0xC1, 0x37, 0x7E},
{0x90, 0xFD, 0xA3, 0x9D, 0x0C, 0x81, 0x52, 0xF4, 0x58, 0x24, 0x89,
0xC4, 0xF4, 0xD4, 0x82, 0x33, 0xCA, 0x5D, 0xB4, 0x58, 0xA6, 0x1E,
0xE6, 0x2B, 0x86, 0xEF, 0x56, 0xC4, 0x4F, 0x9B, 0x27, 0x3C}}},
{{{0x96, 0x54, 0xDA, 0xB5, 0x32, 0x23, 0x8A, 0x93, 0xCC, 0xA5, 0x7D,
0x28, 0x4A, 0x97, 0xA4, 0x30, 0xA8, 0x11, 0xBC, 0x43, 0x22, 0x7F,
0x02, 0x73, 0x0E, 0x5C, 0x63, 0x52, 0x2F, 0x4B, 0x5F, 0x7D},
{0xC3, 0x1E, 0x30, 0xAE, 0xAC, 0x8C, 0xE8, 0x93, 0xD6, 0xCE, 0x05,
0x4B, 0x6B, 0x21, 0x01, 0x14, 0x4A, 0x1D, 0xD9, 0x08, 0x0C, 0xA1,
0x4C, 0x0B, 0x44, 0x28, 0x9C, 0xB6, 0xD1, 0x96, 0xBD, 0x07}}}}},
{{{{{0x8B, 0x3D, 0x77, 0x4E, 0xBD, 0x7B, 0x9F, 0x65, 0x20, 0xDB, 0xA0,
0x95, 0x25, 0x44, 0x44, 0x7A, 0xE3, 0xDC, 0xDD, 0x2F, 0xBA, 0x75,
0x16, 0x19, 0xCB, 0x90, 0x31, 0x79, 0x38, 0xB6, 0x1A, 0x82},
{0xBC, 0xB6, 0x85, 0xCD, 0xEB, 0xB9, 0x13, 0x43, 0xEA, 0xC2, 0x78,
0xBE, 0x25, 0x97, 0x1C, 0x6E, 0x18, 0x55, 0xFD, 0xCB, 0xE6, 0x7E,
0x1E, 0x92, 0xAD, 0x48, 0xE7, 0xA7, 0x02, 0x87, 0x0B, 0x8F}}},
{{{0x16, 0xD7, 0x8E, 0x95, 0x8E, 0x62, 0x0A, 0xAD, 0x20, 0x2D, 0x6A,
0x2B, 0x4E, 0x6F, 0xC1, 0xC2, 0x63, 0xBA, 0x82, 0xF3, 0x8C, 0xD0,
0xA2, 0x09, 0xD3, 0xE5, 0xBA, 0x1F, 0x65, 0x35, 0xD0, 0x1C},
{0x09, 0x98, 0x47, 0x65, 0xF2, 0x90, 0xD4, 0xE2, 0xD0, 0x6F, 0x9E,
0xDB, 0xA2, 0x14, 0x9B, 0x4B, 0x3D, 0xAA, 0x75, 0x25, 0x67, 0xF4,
0x7D, 0x77, 0xE9, 0x24, 0xED, 0xEE, 0x1B, 0x07, 0x7F, 0xE0}}},
{{{0x7A, 0x34, 0xB7, 0x3C, 0x36, 0x0D, 0xCE, 0xF9, 0xBF, 0xF9, 0xE5,
0x09, 0x86, 0xEB, 0xB9, 0xD8, 0xC4, 0x67, 0xC5, 0xCD, 0xD4, 0xBC,
0xEE, 0x45, 0xF7, 0x11, 0x68, 0xD9, 0x23, 0x6D, 0xD6, 0x24},
{0x6E, 0x97, 0x83, 0x13, 0x76, 0x9F, 0x35, 0xEA, 0xB8, 0x47, 0x57,
0x9B, 0x74, 0x47, 0x1F, 0x19, 0xE7, 0x97, 0x74, 0x1B, 0xB1, 0xA0,
0xF3, 0x92, 0xDC, 0x35, 0xFD, 0x7F, 0x4F, 0x07, 0x22, 0xAC}}}}}},
},
{{{{{{{0xFD, 0x05, 0x41, 0x27, 0x00, 0x7A, 0xAD, 0x17, 0xBC, 0xBF, 0x22,
0x5E, 0xDA, 0xEB, 0x7D, 0xAA, 0xB5, 0x2D, 0xC8, 0x61, 0xFE, 0x2C,
0xBA, 0x9E, 0x54, 0x43, 0x94, 0xDC, 0xFD, 0x0E, 0x6D, 0x6D},
{0xA1, 0x5E, 0x05, 0xA5, 0x05, 0x55, 0xE7, 0x2A, 0xF7, 0x53, 0x37,
0x2C, 0xEF, 0x44, 0x95, 0xCA, 0x2C, 0xE8, 0xEB, 0xAE, 0x61, 0x05,
0x33, 0xE7, 0x0F, 0x30, 0x67, 0xBE, 0xCD, 0xB2, 0x93, 0x44}}},
{{{0x44, 0x31, 0x96, 0x4D, 0x72, 0x61, 0xCD, 0x23, 0x1F, 0x7B, 0x57,
0x33, 0x39, 0xAC, 0x57, 0x53, 0x3D, 0x70, 0x57, 0xB3, 0x6D, 0xD5,
0x8A, 0x89, 0x30, 0xBC, 0xED, 0x29, 0x19, 0x39, 0x6E, 0x6A},
{0x80, 0x21, 0x1E, 0xB7, 0x84, 0xB1, 0x0A, 0xA4, 0xD0, 0xFF, 0x59,
0x31, 0xE9, 0xBA, 0x39, 0xF7, 0x81, 0xDF, 0x1B, 0x7B, 0xD9, 0xDB,
0x02, 0x17, 0xBE, 0x97, 0x63, 0xBD, 0x37, 0x14, 0xB8, 0x8B}}},
{{{0x6C, 0xCC, 0x5B, 0xA3, 0xEE, 0xC8, 0x0B, 0x7B, 0xF5, 0xDE, 0xBC,
0xB7, 0xA8, 0x25, 0x35, 0xAE, 0x0B, 0x30, 0x96, 0x33, 0x52, 0x13,
0xA3, 0x89, 0x3A, 0x2E, 0xA4, 0x7E, 0x5F, 0x4E, 0xB1, 0xF7},
{0x87, 0xBA, 0x08, 0xB0, 0xFB, 0xCB, 0x31, 0xA6, 0x2B, 0x3E, 0xE7,
0xC4, 0xCC, 0xA5, 0x14, 0x61, 0xC9, 0x18, 0xFC, 0x74, 0x59, 0x06,
0xF4, 0xAD, 0xFC, 0x2D, 0x0C, 0x7D, 0xDB, 0x2A, 0xEC, 0xD4}}}}},
{{{{{0xE9, 0x31, 0x31, 0x50, 0x25, 0xB7, 0x0C, 0x48, 0x30, 0xD5, 0x78,
0xB1, 0x10, 0xEA, 0x5D, 0xAA, 0xAA, 0x03, 0xEC, 0xE3, 0x0F, 0x36,
0xA6, 0xBC, 0x18, 0x3A, 0x76, 0x87, 0xA3, 0xE9, 0x33, 0xDA},
{0x48, 0x78, 0x93, 0x64, 0x72, 0x9B, 0x2A, 0x1E, 0x0D, 0x50, 0x9F,
0x6F, 0xBD, 0xA5, 0x18, 0xB1, 0xA8, 0x14, 0x9A, 0x1B, 0xB9, 0xB4,
0x2C, 0x1F, 0x46, 0xB8, 0x9B, 0x7A, 0xC7, 0x84, 0xAE, 0x27}}},
{{{0xD1, 0xEC, 0x1C, 0xEC, 0x69, 0xF0, 0x35, 0x40, 0x77, 0x7E, 0x27,
0x22, 0x36, 0x38, 0xDF, 0x15, 0xC2, 0xB3, 0xB8, 0x63, 0x4A, 0x6E,
0x68, 0x8C, 0xC1, 0x39, 0x3C, 0x02, 0x4C, 0x2A, 0x31, 0x18},
{0x2E, 0x35, 0xF5, 0xCA, 0xA2, 0xE9, 0x24, 0x92, 0xD5, 0xE5, 0x2E,
0x5D, 0x1C, 0x94, 0xD9, 0xC7, 0xF0, 0x22, 0x16, 0x20, 0xA8, 0x37,
0xDD, 0x0E, 0xAB, 0x1B, 0x5E, 0x8B, 0xEE, 0x81, 0xC6, 0x17}}},
{{{0xF1, 0x29, 0x5D, 0x1D, 0x6F, 0x53, 0x5A, 0xB2, 0x20, 0x88, 0x3D,
0xA4, 0x98, 0x81, 0xA4, 0xEF, 0x11, 0x1B, 0x64, 0x9E, 0x2C, 0x95,
0xDD, 0xD7, 0x57, 0xB3, 0x95, 0xCA, 0x40, 0xB9, 0x0D, 0x62},
{0xDC, 0x86, 0x8B, 0xE6, 0xD3, 0x7B, 0x33, 0xEA, 0x50, 0x25, 0xE2,
0x77, 0xE3, 0x0B, 0x5A, 0xC8, 0x81, 0xFC, 0xAE, 0x74, 0x38, 0x69,
0x07, 0xF8, 0x4E, 0xD7, 0x85, 0xA6, 0x2F, 0x13, 0xB7, 0x0A}}}}}}},
{{{{{{{0xF4, 0xDC, 0xAC, 0x02, 0xC0, 0x95, 0x07, 0xDC, 0x12, 0x4F, 0x3A,
0x01, 0xA9, 0xEE, 0xF3, 0x07, 0x46, 0x94, 0x47, 0x15, 0x63, 0xA6,
0x8E, 0x0A, 0xC4, 0xC4, 0xE4, 0x23, 0x85, 0x63, 0xE4, 0x4E},
{0x9A, 0x9E, 0x9F, 0xC1, 0xED, 0x4E, 0x94, 0x10, 0xFE, 0x7D, 0x90,
0xEF, 0x82, 0x21, 0xAC, 0x67, 0x24, 0x99, 0x86, 0xC6, 0x85, 0x8B,
0x19, 0x9A, 0x9B, 0x90, 0x0B, 0xA4, 0x90, 0x78, 0x34, 0x53}}},
{{{0xB1, 0x4C, 0xBA, 0xB8, 0xC6, 0x40, 0x71, 0xC2, 0x17, 0x51, 0x05,
0xC2, 0xC9, 0xBC, 0x03, 0x10, 0x4E, 0xFE, 0x2F, 0x94, 0xED, 0x13,
0x35, 0x7B, 0x20, 0xA6, 0x59, 0x44, 0x81, 0xD0, 0xEC, 0x12},
{0x74, 0xA2, 0x4A, 0xFB, 0xD7, 0x28, 0x70, 0xAD, 0xDE, 0x86, 0x2F,
0xEF, 0xF9, 0x50, 0x5D, 0x1E, 0x46, 0x3B, 0x82, 0x1C, 0x6A, 0xC9,
0x3F, 0x32, 0xAE, 0xCD, 0x93, 0x2C, 0xA5, 0x70, 0x45, 0x24}}},
{{{0x38, 0x19, 0x79, 0xBF, 0x35, 0xF5, 0xC1, 0x53, 0x06, 0x42, 0xAA,
0x6B, 0xF3, 0xB7, 0x8F, 0xFB, 0xFC, 0x28, 0x46, 0x9A, 0x65, 0x2A,
0x45, 0x3D, 0x4C, 0x3C, 0x6B, 0x9C, 0x44, 0xC5, 0x82, 0xB8},
{0x80, 0xF9, 0xB3, 0x44, 0x95, 0x17, 0x39, 0x01, 0x6B, 0xD6, 0x1D,
0x73, 0x22, 0x94, 0xFF, 0x6F, 0x7B, 0x4E, 0xB6, 0xA4, 0xE4, 0x6C,
0xA8, 0xDB, 0x38, 0x74, 0x0B, 0xDB, 0xFA, 0x14, 0x99, 0x39}}}}},
{{{{{0x28, 0xEE, 0xFC, 0x62, 0xE5, 0x33, 0x9C, 0x63, 0xD5, 0x7F, 0x2C,
0x4C, 0xF4, 0x76, 0x4C, 0xF7, 0x7B, 0x27, 0x2C, 0xA9, 0xB9, 0x01,
0x3C, 0x58, 0xF7, 0xCE, 0xAA, 0x0A, 0x21, 0xC0, 0xA3, 0xA7},
{0xA1, 0x85, 0xBC, 0xFE, 0x55, 0xFC, 0x3B, 0x9B, 0x3D, 0xEF, 0x14,
0x85, 0x8A, 0x4E, 0x5E, 0x1F, 0x4F, 0xC9, 0x86, 0xB8, 0xF2, 0xB2,
0xE3, 0xE7, 0x7E, 0x87, 0xE2, 0x20, 0xD7, 0x85, 0x2C, 0xD1}}},
{{{0x13, 0xCB, 0x46, 0xAD, 0xD7, 0xEC, 0x66, 0xD5, 0x2B, 0x6E, 0x87,
0x92, 0x13, 0xB2, 0x7D, 0x18, 0x69, 0x35, 0xCB, 0xF1, 0xBE, 0xC2,
0x9D, 0xEB, 0xF5, 0x00, 0x0B, 0x73, 0xA3, 0xFD, 0x51, 0xDC},
{0x91, 0x0E, 0xE4, 0x46, 0x41, 0x23, 0xDD, 0x85, 0x53, 0x0C, 0xAE,
0xF9, 0x74, 0xCF, 0x1C, 0x32, 0x22, 0xDA, 0x4A, 0x14, 0x80, 0x71,
0x51, 0x23, 0xC3, 0xAB, 0x7E, 0xEC, 0x77, 0xCC, 0x59, 0x12}}},
{{{0x1C, 0x0F, 0x65, 0x6B, 0xD8, 0x41, 0xE0, 0x1B, 0x51, 0x9C, 0x89,
0x26, 0xAB, 0x88, 0x63, 0x5D, 0xBB, 0x95, 0x92, 0x5B, 0x2C, 0x1D,
0xDE, 0xC1, 0x88, 0xD6, 0xF1, 0x02, 0x48, 0xE0, 0xE2, 0xD1},
{0x40, 0x7F, 0xF1, 0x23, 0x4A, 0xCF, 0x36, 0xD5, 0xCF, 0x76, 0x0D,
0x00, 0x2A, 0xF7, 0x5F, 0x31, 0xBB, 0xCC, 0x46, 0x84, 0x07, 0x04,
0x98, 0x9C, 0xB4, 0x31, 0x15, 0x2D, 0x91, 0xF6, 0x29, 0x33}}}}}}},
{{{{{{{0xA8, 0x8E, 0x9A, 0xF9, 0x25, 0x12, 0x98, 0xE2, 0xC3, 0x61, 0x2E,
0xE8, 0xD6, 0xA6, 0x77, 0x16, 0x49, 0x04, 0x75, 0x69, 0xD1, 0x83,
0x2D, 0x3F, 0x2A, 0x79, 0xB6, 0x9B, 0xC9, 0x1D, 0x03, 0x90},
{0x2A, 0xD8, 0x11, 0x9F, 0x26, 0x36, 0xE7, 0xE9, 0x3A, 0x05, 0x4C,
0x15, 0x49, 0x93, 0xDA, 0xE9, 0xD0, 0x5A, 0xE4, 0x8D, 0x8A, 0xFA,
0x04, 0xF1, 0x20, 0x84, 0x56, 0xEC, 0x3C, 0x27, 0x19, 0x5C}}},
{{{0xF1, 0xAF, 0xBF, 0xF6, 0x0E, 0x58, 0x84, 0x2D, 0x94, 0x11, 0xF4,
0xB5, 0xF4, 0x14, 0x51, 0xB0, 0x90, 0x46, 0x1A, 0x81, 0xED, 0xCF,
0x91, 0x66, 0x58, 0xA6, 0x36, 0x3A, 0x52, 0x18, 0x5A, 0xC1},
{0x08, 0x4C, 0x99, 0xD3, 0xDC, 0xCE, 0x7F, 0xCE, 0x78, 0xE0, 0x38,
0x87, 0x32, 0xF1, 0x80, 0x3C, 0x7B, 0x67, 0xAA, 0x6F, 0xDD, 0xE0,
0xFC, 0xCB, 0xD0, 0xB0, 0x3A, 0x59, 0x52, 0x2A, 0x84, 0xE4}}},
{{{0xF8, 0x4A, 0xFF, 0x50, 0xA0, 0x65, 0xC4, 0xEE, 0xF4, 0x9C, 0xAA,
0x34, 0x46, 0xF9, 0xD2, 0x6C, 0xA1, 0x61, 0x71, 0x49, 0x32, 0x25,
0x84, 0x54, 0x90, 0x44, 0xBE, 0xA4, 0x0B, 0xF7, 0xFE, 0x26},
{0x81, 0x63, 0x73, 0xF7, 0x2F, 0xF2, 0xFA, 0x24, 0x52, 0xA4, 0xD9,
0x4C, 0xC1, 0xA7, 0xA5, 0xC3, 0x03, 0x36, 0x13, 0x9B, 0x16, 0x45,
0x16, 0xCB, 0x4B, 0x99, 0x38, 0xF3, 0x6D, 0xC8, 0x7E, 0xAB}}}}},
{{{{{0xB3, 0x53, 0xDF, 0xB6, 0x82, 0x60, 0x12, 0x11, 0x36, 0x69, 0x0E,
0x05, 0x31, 0x8E, 0xCF, 0xD7, 0x3F, 0x32, 0xE7, 0x95, 0x84, 0x1D,
0xC8, 0xB5, 0xBE, 0x49, 0x17, 0x9D, 0xCF, 0xA9, 0x5A, 0x2A},
{0xC4, 0x11, 0x86, 0xE8, 0x6C, 0x02, 0x56, 0xB0, 0x25, 0x2F, 0xA0,
0x06, 0xB3, 0x62, 0xB2, 0x11, 0xAF, 0xBE, 0xA4, 0xE8, 0x61, 0x64,
0x85, 0xFB, 0xEB, 0x1C, 0xF1, 0xBC, 0x2C, 0xAE, 0x10, 0x51}}},
{{{0x16, 0xA6, 0xC0, 0xB3, 0x86, 0x8E, 0x6D, 0x79, 0xB6, 0xBD, 0xDE,
0x1E, 0x26, 0x06, 0x46, 0x65, 0x82, 0x84, 0x5A, 0x97, 0xD3, 0xB7,
0x93, 0x78, 0x6B, 0x9D, 0x14, 0x33, 0x94, 0x43, 0x34, 0x04},
{0x45, 0xD1, 0x47, 0xD4, 0x2F, 0x17, 0xCF, 0xF1, 0xDD, 0xEA, 0x11,
0x52, 0xAE, 0x01, 0x88, 0x3A, 0x10, 0xEE, 0x5C, 0x16, 0xCD, 0xB5,
0x48, 0xE9, 0x16, 0x2C, 0x70, 0xB4, 0x1E, 0x19, 0x38, 0xE0}}},
{{{0x18, 0xE9, 0xAE, 0xC5, 0xDA, 0x74, 0x41, 0x2D, 0x70, 0x07, 0x60,
0x37, 0x27, 0x66, 0xF7, 0x00, 0xBB, 0x79, 0x51, 0xF3, 0x7C, 0x8A,
0x2B, 0xB5, 0x69, 0x6E, 0x10, 0x1F, 0xE0, 0x0A, 0x5E, 0xBE},
{0xB4, 0x4E, 0x0E, 0x02, 0x59, 0xB5, 0xCB, 0x4A, 0x6A, 0x86, 0x8B,
0xCC, 0xA2, 0x13, 0xA0, 0xE9, 0xF2, 0x5C, 0xB0, 0x23, 0xB2, 0x15,
0xF9, 0xBB, 0x43, 0xC1, 0x54, 0xF4, 0xC8, 0xAB, 0x16, 0xA6}}}}}}},
};
const BigNumStr FfElementTest::fq12_multi_exp_exp_4[4] = {
{
0x14, 0x92, 0xD1, 0x1F, 0xAC, 0x90, 0x4D, 0xC3, 0x3E, 0xB8, 0xA7,
0xFE, 0x35, 0x98, 0xDA, 0x94, 0xD6, 0xF3, 0x27, 0x29, 0x4B, 0x70,
0xCF, 0x0F, 0xDA, 0x14, 0x97, 0xA1, 0x9B, 0x6B, 0x24, 0x08,
},
{
0x76, 0x8D, 0xE5, 0xC2, 0xAB, 0x78, 0xD9, 0x76, 0x98, 0xFF, 0x92,
0xEA, 0x95, 0x58, 0xC5, 0x0C, 0x6F, 0x1B, 0x35, 0xC4, 0xBF, 0x4A,
0x9E, 0xC2, 0x6A, 0xEC, 0xE2, 0xF6, 0xAF, 0xEB, 0xAC, 0x06,
},
{
0x50, 0x38, 0x60, 0x31, 0xAB, 0x05, 0xCC, 0xB1, 0xC2, 0x06, 0xA0,
0xD7, 0x92, 0x12, 0xBD, 0x17, 0x81, 0xB9, 0x7E, 0x07, 0x9B, 0xD4,
0x3B, 0x2D, 0x3C, 0x15, 0x3A, 0x5A, 0xF1, 0xC0, 0xC4, 0x75,
},
{
0xA1, 0x3F, 0xEA, 0x99, 0x7E, 0xC7, 0x65, 0xF5, 0x41, 0xA6, 0xD6,
0xD3, 0x77, 0xEC, 0x27, 0xF8, 0x6C, 0x18, 0x28, 0x69, 0x97, 0x08,
0x0E, 0x63, 0x5A, 0xDA, 0xFE, 0x9F, 0xD1, 0x4A, 0x61, 0x4F,
},
};
const Fq12ElemStr FfElementTest::fq12_multi_exp_res_4 = {
{{{{{{0x3A, 0x30, 0x33, 0xA2, 0x14, 0xDF, 0xDC, 0x70, 0x48, 0xF3, 0xBA,
0x3F, 0xCE, 0xFC, 0x69, 0x24, 0xAE, 0xA1, 0xF3, 0xCF, 0xD8, 0x77,
0x69, 0x38, 0x38, 0xF4, 0x8E, 0xFB, 0x51, 0xFB, 0x10, 0x7C},
{0x73, 0xB4, 0xEE, 0xF9, 0x76, 0xBB, 0x45, 0xEC, 0x07, 0x24, 0x23,
0xA3, 0x38, 0x64, 0x39, 0x4C, 0x03, 0x94, 0xF5, 0xEE, 0x5F, 0xC9,
0x83, 0x4F, 0xD1, 0xA6, 0x4A, 0x05, 0x25, 0x0C, 0x46, 0x33}}},
{{{0xD4, 0x40, 0x47, 0xAE, 0xEC, 0xDA, 0x30, 0xF9, 0xE1, 0x28, 0xFB,
0xB1, 0x4C, 0x62, 0xFB, 0x6C, 0x90, 0x0D, 0xB1, 0xEC, 0xAF, 0x2D,
0x95, 0x64, 0x11, 0x93, 0xDA, 0x8E, 0xB8, 0x7D, 0xE4, 0xA3},
{0x8E, 0xA6, 0x9B, 0xAA, 0x58, 0xD5, 0xDC, 0x59, 0x1A, 0x51, 0x53,
0x47, 0x30, 0x1C, 0x2B, 0xB0, 0xBB, 0x57, 0x57, 0x0A, 0x8C, 0x5F,
0x62, 0x9C, 0x52, 0x28, 0xC0, 0x25, 0x27, 0xAE, 0xCD, 0x36}}},
{{{0xBF, 0x2D, 0x03, 0xB1, 0x33, 0xFD, 0x24, 0x81, 0x3C, 0x91, 0x43,
0x90, 0x0C, 0x20, 0xC4, 0xE3, 0x69, 0x3F, 0xA9, 0xA2, 0x7C, 0xC2,
0x48, 0x28, 0x1B, 0xF0, 0x81, 0x1F, 0x2B, 0x8F, 0x8D, 0x43},
{0x38, 0x18, 0x12, 0xA3, 0x89, 0xF1, 0xD7, 0x60, 0x89, 0x68, 0x6A,
0xC4, 0xCC, 0x5D, 0xF4, 0xCE, 0x43, 0x95, 0x84, 0xCD, 0x01, 0x55,
0xB8, 0x5D, 0x24, 0x50, 0xCD, 0xE3, 0x68, 0x1C, 0xFF, 0x59}}}}},
{{{{{0x0D, 0xAC, 0xCB, 0xE7, 0x9D, 0x68, 0x0F, 0x4A, 0xAF, 0xEB, 0xB5,
0xFB, 0xF9, 0xB1, 0x58, 0x80, 0xD5, 0x71, 0x53, 0x26, 0x2E, 0x9C,
0xCE, 0x10, 0xAC, 0xD2, 0x0A, 0xEB, 0xB4, 0x5C, 0xC8, 0xD7},
{0x16, 0x26, 0x66, 0x71, 0xDD, 0x67, 0xBA, 0xDB, 0x35, 0x76, 0x64,
0xC6, 0x0B, 0x0B, 0x07, 0x4B, 0x65, 0xA2, 0xF7, 0x68, 0x9E, 0xFE,
0xE8, 0xE3, 0xA7, 0x09, 0x79, 0xC5, 0xDF, 0x5E, 0x9C, 0xEC}}},
{{{0xEE, 0x83, 0x59, 0xB5, 0x89, 0x81, 0xA2, 0x87, 0xD7, 0x75, 0x65,
0x90, 0xDE, 0x78, 0x37, 0x59, 0x04, 0x9B, 0x50, 0xC3, 0xBA, 0x90,
0x09, 0x15, 0xAB, 0x17, 0xC5, 0xBF, 0x5B, 0xB9, 0xE4, 0x6C},
{0xA9, 0xB1, 0x49, 0x76, 0x25, 0x74, 0x5D, 0x9C, 0x78, 0xC5, 0x09,
0xEE, 0xEB, 0xEB, 0x9D, 0x1C, 0x6C, 0xC0, 0x27, 0x9D, 0x66, 0xE6,
0x7F, 0x31, 0xCD, 0xB0, 0x8A, 0xE4, 0x9E, 0xBD, 0x70, 0x18}}},
{{{0x88, 0xA1, 0x08, 0x39, 0xA2, 0x48, 0xA5, 0x98, 0xB6, 0xAD, 0x10,
0x54, 0x07, 0xCD, 0xFC, 0x6D, 0xB1, 0x02, 0xFF, 0xE3, 0x92, 0xD7,
0x9D, 0x48, 0xFB, 0xCE, 0x88, 0x46, 0x92, 0x07, 0x02, 0xBA},
{0xEE, 0xEB, 0xAE, 0x88, 0xB1, 0x4E, 0xD0, 0xF2, 0xCE, 0xD7, 0x57,
0x07, 0xD4, 0x39, 0xD2, 0x7D, 0x1A, 0x0C, 0xEF, 0xF2, 0x84, 0x84,
0x22, 0x8A, 0xB1, 0x80, 0x0D, 0xDC, 0x64, 0x86, 0xFD, 0x70}}}}}}};
const FqElemStr FfElementTest::fq_multi_exp_base_5[5] = {
{0x7B, 0x26, 0x96, 0x84, 0x04, 0x0D, 0x6F, 0x10, 0xAA, 0x7F, 0xD0,
0x0C, 0x41, 0x3A, 0x68, 0x48, 0xBF, 0x3D, 0xB5, 0xCE, 0x3A, 0x9C,
0xA9, 0x10, 0xA4, 0x67, 0x7C, 0xC0, 0x41, 0x52, 0xCA, 0xE7},
{0x2E, 0xD9, 0xEF, 0x86, 0xB6, 0x32, 0x72, 0x89, 0x37, 0xCF, 0x16,
0xCE, 0x27, 0x15, 0x7A, 0x95, 0xCF, 0x94, 0x1B, 0xF3, 0xCE, 0x49,
0x20, 0x29, 0x9A, 0x61, 0x2E, 0x0A, 0xF5, 0xE1, 0xDC, 0x9F},
{0xE0, 0x19, 0x37, 0x44, 0xA7, 0x45, 0x49, 0x7E, 0x19, 0x02, 0x09,
0x78, 0xBE, 0xA4, 0x65, 0x60, 0x7A, 0xF5, 0xC8, 0xAF, 0x97, 0x5E,
0xDA, 0x3A, 0xB4, 0x16, 0x70, 0x31, 0xE3, 0xB4, 0x18, 0xA8},
{0xBC, 0x92, 0x29, 0x92, 0x14, 0xD3, 0x3F, 0xB8, 0xB8, 0x8C, 0x41,
0xDF, 0xC5, 0xA1, 0xCA, 0x77, 0xE5, 0x73, 0xFE, 0xA7, 0xAC, 0x81,
0x66, 0x11, 0x5A, 0x6D, 0x7D, 0x97, 0x13, 0x92, 0x8D, 0x1D},
{0xE1, 0xA0, 0x0D, 0xDC, 0x8F, 0x20, 0xF5, 0x2D, 0x1D, 0x1F, 0xBD,
0x24, 0x8C, 0xC2, 0x26, 0x06, 0x89, 0xE9, 0x46, 0xA9, 0xD2, 0x44,
0x8F, 0x1A, 0x8D, 0xAF, 0x20, 0x73, 0x60, 0x0B, 0x66, 0x9C}};
const BigNumStr FfElementTest::fq_multi_exp_exp_5[5] = {
{0x78, 0xE6, 0x3F, 0x42, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xD7,
0x6E, 0xE9, 0xFF, 0x4F, 0xFF, 0x23, 0xFF, 0x67, 0xB4, 0xED, 0xEE,
0xD7, 0xC6, 0xFF, 0x4B, 0x0B, 0x6F, 0x1F, 0xD6, 0xFD, 0x7F},
{0xA1, 0x87, 0xFF, 0x1B, 0xFF, 0x85, 0x68, 0xFF, 0x1C, 0xFF, 0xD5,
0xFF, 0x95, 0x73, 0xFF, 0xFF, 0xFF, 0x9E, 0x7E, 0xFF, 0xFF, 0xFF,
0xFF, 0x5E, 0x9E, 0x62, 0xFF, 0xFF, 0x97, 0xFF, 0xFF, 0xF3},
{0x2E, 0xE8, 0x1E, 0x35, 0xFF, 0x82, 0x0B, 0x99, 0xEC, 0x30, 0x2B,
0xCE, 0xEC, 0x83, 0x05, 0xFF, 0x9E, 0x3C, 0xFF, 0xFF, 0xA1, 0xFF,
0xFF, 0xFF, 0x57, 0x26, 0x5B, 0x6C, 0xFF, 0xE6, 0x94, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0x94, 0xFF, 0xFF, 0x79, 0xFC, 0xFF, 0x83,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA9, 0xFF, 0x2F, 0x6B, 0xD1, 0xE7,
0xFF, 0xFF, 0xFF, 0x7C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
{0x63, 0x53, 0x53, 0xFF, 0xFF, 0xFF, 0x4F, 0xFF, 0xFF, 0xFF, 0x09,
0xFF, 0xC0, 0xD8, 0x17, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0x45, 0xFF, 0x3A, 0xFF, 0xFF, 0xFF, 0xFF, 0x60, 0x06}};
const FqElemStr FfElementTest::fq_multi_exp_res_5 = {
0x8F, 0x6D, 0x54, 0xCA, 0x00, 0x85, 0xD8, 0x78, 0xA4, 0x45, 0x36,
0x7C, 0x23, 0xD0, 0x3C, 0x2D, 0x20, 0x78, 0xD9, 0xD7, 0xF1, 0xC3,
0x99, 0xD9, 0xD3, 0x0A, 0x0E, 0x86, 0x98, 0xC2, 0xA7, 0x97,
};
const FqElemStr FfElementTest::fq_multi_exp_base_6[6] = {
{0x75, 0x18, 0x6A, 0x3D, 0xCC, 0x76, 0x33, 0x92, 0xD0, 0x57, 0xDA,
0xE0, 0x37, 0x6F, 0x71, 0xD5, 0x9E, 0x7E, 0x65, 0xED, 0xD7, 0xFD,
0x82, 0xC0, 0x6C, 0x83, 0x60, 0x30, 0xC1, 0xD3, 0x3D, 0x4D},
{0xF5, 0x3A, 0x20, 0xAB, 0x22, 0x47, 0x07, 0xAE, 0x71, 0xC1, 0x91,
0x73, 0xEF, 0x1F, 0x1D, 0x76, 0x2E, 0xEE, 0x0D, 0xDE, 0xD9, 0xF8,
0x5C, 0x85, 0xC7, 0x5B, 0x93, 0x88, 0xF6, 0xFF, 0x4C, 0xA5},
{0x21, 0xB3, 0x5E, 0xE8, 0xD2, 0xDA, 0x14, 0x1C, 0xB5, 0x2C, 0xFC,
0x61, 0x9D, 0xEB, 0x65, 0x87, 0xBB, 0x5B, 0xBC, 0xFD, 0x37, 0x54,
0x6B, 0xDC, 0xD9, 0xFA, 0x7A, 0xCD, 0x18, 0x7E, 0x8B, 0x89},
{0x70, 0xB7, 0x19, 0x42, 0xB4, 0x41, 0x2C, 0x1B, 0xBD, 0x7B, 0x25,
0x06, 0xA2, 0x95, 0xB5, 0xB6, 0x70, 0xDF, 0x58, 0x71, 0xCA, 0x09,
0x12, 0x66, 0x5A, 0x7B, 0xF0, 0x5F, 0x43, 0x69, 0x32, 0xF6},
{0x3D, 0x57, 0xE8, 0x3F, 0x1E, 0x39, 0x2B, 0xE5, 0xD0, 0xCF, 0xA9,
0xC8, 0x72, 0x10, 0x7F, 0xC5, 0x4F, 0xAE, 0xE9, 0x73, 0x28, 0x4C,
0xFC, 0x3F, 0xD5, 0xFF, 0xE8, 0xCF, 0x2C, 0xEB, 0x33, 0xD3},
{0x51, 0x80, 0x15, 0x1C, 0xE6, 0x9C, 0x4B, 0x80, 0x40, 0xBA, 0x40,
0x29, 0x3A, 0x86, 0xA8, 0xB2, 0x66, 0x08, 0x97, 0x8D, 0xEB, 0x8B,
0xA7, 0x93, 0xE3, 0x49, 0xC6, 0xC0, 0x46, 0x93, 0xC1, 0x75}};
const BigNumStr FfElementTest::fq_multi_exp_exp_6[6] = {
{0xFF, 0xFF, 0xFF, 0x49, 0x50, 0xFF, 0x19, 0xFF, 0xEB, 0xFF, 0xFF,
0xFF, 0xFF, 0x28, 0x4A, 0x0E, 0xFF, 0x74, 0xFF, 0xC7, 0xFF, 0xD9,
0x81, 0xFF, 0xFF, 0xFF, 0xD5, 0x2C, 0xFF, 0xFF, 0xFF, 0xAE},
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x0C, 0x03, 0xFF, 0x95, 0xFF, 0x11, 0x9D, 0xFF, 0x9B,
0xFF, 0xFF, 0x68, 0x44, 0xFF, 0xC9, 0xFF, 0x10, 0xC7, 0xBF},
{0x64, 0xFF, 0x89, 0x4A, 0xFF, 0x20, 0xFF, 0xE7, 0xFF, 0x36, 0x23,
0xDD, 0xFF, 0xFF, 0xFC, 0xFF, 0x6B, 0xFF, 0xFF, 0xFF, 0xFF, 0x48,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x94, 0xD3, 0x59, 0xBE},
{0x0F, 0xFF, 0x76, 0xA5, 0x9E, 0x02, 0x9B, 0xFF, 0xA1, 0xFF, 0xC2,
0xFF, 0x9D, 0xFF, 0x23, 0xFF, 0xFF, 0xFF, 0xFF, 0x6B, 0x81, 0x2A,
0xFF, 0x98, 0xFF, 0xFF, 0xB9, 0xFF, 0xB7, 0x78, 0xE6, 0xFF},
{0xAF, 0xF3, 0xFF, 0x3C, 0xA8, 0xFF, 0xB9, 0x3A, 0xFF, 0xFF, 0xFF,
0x70, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x85, 0xFF,
0xFF, 0x52, 0xFF, 0x41, 0x10, 0x62, 0xFF, 0x51, 0x35, 0xFF},
{0xFF, 0xFF, 0xFF, 0xFF, 0xD3, 0xC3, 0xD9, 0xFF, 0xFF, 0x3A, 0x44,
0x88, 0x04, 0xFF, 0x0B, 0xFF, 0xFF, 0xFF, 0x64, 0xFF, 0xFF, 0x52,
0xFF, 0x7D, 0x6B, 0x24, 0x6E, 0xFF, 0xFF, 0xFF, 0xA7, 0x71}};
const FqElemStr FfElementTest::fq_multi_exp_res_6 = {
0xFB, 0x89, 0x4F, 0xBB, 0x91, 0xEE, 0xD6, 0x57, 0x2D, 0x34, 0xF9,
0x0B, 0xE3, 0xEB, 0x71, 0x1D, 0x63, 0x74, 0x96, 0x3B, 0xD4, 0x02,
0x2F, 0x08, 0xDB, 0x95, 0x6A, 0x40, 0x68, 0xD4, 0x55, 0x76,
};
const Fq6ElemStr FfElementTest::epid11_GT_multi_exp_base_3[3] = {
{0x02, 0x7C, 0xAC, 0xE1, 0x58, 0x08, 0x6A, 0x83, 0x50, 0xD8, 0xBA, 0xBA,
0x4B, 0x60, 0x6C, 0xEB, 0x51, 0xCE, 0x7E, 0x6D, 0x8E, 0xA8, 0x56, 0x41,
0x33, 0xF3, 0xB0, 0xA6, 0xFC, 0xCD, 0xC8, 0x41, 0x05, 0x9E, 0xCC, 0x4F,
0x51, 0x77, 0xD9, 0xEC, 0x57, 0x34, 0x48, 0x47, 0x22, 0x7A, 0x7C, 0xA1,
0x14, 0xB8, 0x2A, 0xC9, 0x16, 0x0A, 0xB4, 0xB3, 0x5D, 0x44, 0x28, 0x23,
0x80, 0x7A, 0x3E, 0xDA, 0x02, 0x6D, 0x03, 0x47, 0xCD, 0x2A, 0xAB, 0xA4,
0xCE, 0x63, 0x0B, 0x5E, 0x3A, 0xF2, 0x96, 0x86, 0xA9, 0x9F, 0x2A, 0x9A,
0xFF, 0x8F, 0x94, 0x91, 0xC8, 0x3C, 0xF2, 0x5A, 0xAA, 0xDA, 0x6B, 0x8E,
0x02, 0xFC, 0x42, 0x4B, 0xFE, 0xF3, 0x23, 0x0A, 0xF8, 0x1A, 0x5C, 0x9A,
0x5C, 0x0D, 0x71, 0xEF, 0x85, 0x64, 0xA6, 0x4D, 0x6A, 0x8B, 0x82, 0x58,
0x2E, 0xBC, 0xFB, 0xB9, 0xDF, 0xB8, 0xCE, 0x3D, 0x03, 0xF3, 0x07, 0x18,
0x4A, 0x13, 0x82, 0x8A, 0xEA, 0x24, 0x57, 0x72, 0xE2, 0x33, 0x9D, 0xB3,
0x0C, 0x57, 0xCF, 0xAB, 0xDD, 0xEE, 0xF8, 0xD7, 0x2A, 0x75, 0xF5, 0xD7,
0x28, 0xED, 0x0F, 0xB7, 0x02, 0xEC, 0x5F, 0xED, 0x50, 0xAE, 0x6B, 0xF3,
0x80, 0x29, 0x7B, 0xA2, 0x75, 0x61, 0xFD, 0x20, 0x01, 0x2B, 0xDF, 0x8B,
0x3C, 0x2A, 0xB9, 0x1D, 0x92, 0xED, 0x0F, 0xAD, 0x73, 0x74, 0x1E, 0xD8},
{0x06, 0xA6, 0x4A, 0x6B, 0x89, 0xD0, 0x07, 0x2A, 0xE6, 0x0B, 0x56, 0xD3,
0x48, 0x17, 0xF6, 0x99, 0x31, 0x41, 0x21, 0x99, 0x51, 0xF6, 0xB1, 0x6C,
0x02, 0xCD, 0x11, 0xE7, 0xCC, 0xD3, 0xC5, 0x6C, 0x06, 0xF4, 0x39, 0x62,
0x37, 0x88, 0x37, 0xAD, 0x1F, 0x36, 0x81, 0xFA, 0xD7, 0x4B, 0x9F, 0x57,
0x0F, 0x5B, 0xC3, 0x53, 0x14, 0x53, 0x41, 0x3A, 0x2B, 0xAB, 0x6E, 0xF4,
0xD8, 0x7F, 0xC5, 0x67, 0x08, 0x70, 0xD7, 0x9B, 0x59, 0xE1, 0xE0, 0x57,
0xE2, 0xF4, 0x04, 0x82, 0x06, 0x6A, 0xD5, 0xA2, 0x76, 0x64, 0x41, 0x7F,
0x3B, 0xE6, 0x33, 0xB9, 0x39, 0x68, 0xDA, 0x0D, 0x13, 0x03, 0x63, 0xC8,
0x07, 0x94, 0x70, 0xF9, 0xFB, 0xD8, 0x99, 0x31, 0xA1, 0x53, 0x1C, 0x20,
0x43, 0x12, 0xEB, 0xFF, 0xA4, 0x5D, 0x64, 0x7C, 0x24, 0x9E, 0xE0, 0x03,
0x80, 0x8E, 0xFB, 0xDC, 0xEE, 0xFD, 0x1F, 0xEF, 0x03, 0x43, 0x07, 0x44,
0xEF, 0xB3, 0x71, 0x39, 0x77, 0x61, 0x5C, 0xA9, 0x32, 0x54, 0x33, 0x98,
0xA2, 0x14, 0x6A, 0x13, 0x53, 0x22, 0x94, 0xA2, 0xCE, 0x15, 0xE7, 0xD0,
0x30, 0xF2, 0x6B, 0x07, 0x02, 0x56, 0x28, 0xC3, 0xB1, 0x39, 0xF9, 0xC7,
0xDA, 0xE2, 0xFD, 0xD0, 0xA8, 0x1B, 0xE8, 0xB2, 0xE3, 0x75, 0x02, 0xB8,
0x90, 0xA4, 0xA5, 0x8F, 0x23, 0xA1, 0xCD, 0x75, 0xE7, 0x51, 0x37, 0xE5},
{0x09, 0x27, 0x38, 0x30, 0x06, 0x44, 0x13, 0xEF, 0xFE, 0x70, 0x5C, 0x4A,
0x21, 0xFF, 0xF8, 0xF5, 0xBB, 0xC9, 0x6E, 0xA8, 0x7E, 0x00, 0xB1, 0xD7,
0x5E, 0x55, 0xCF, 0xC7, 0x34, 0x6B, 0x8D, 0xD5, 0x04, 0xCE, 0x6E, 0xCA,
0x11, 0x5A, 0xB3, 0x0C, 0x33, 0x79, 0x5F, 0xDE, 0xD9, 0xDB, 0x8C, 0xFA,
0x73, 0x4E, 0x1E, 0xFA, 0xA1, 0x21, 0x6D, 0xA3, 0x6D, 0xE8, 0x69, 0x02,
0x9E, 0xCC, 0x4D, 0x14, 0x09, 0xB5, 0x7C, 0xBA, 0x98, 0xC2, 0xE3, 0xAA,
0x82, 0x6A, 0x0F, 0x1E, 0x4C, 0x6C, 0x9E, 0xB8, 0xB6, 0xA3, 0x5D, 0x06,
0xFE, 0x99, 0x5C, 0x62, 0xA9, 0x19, 0x4E, 0x84, 0x61, 0xC7, 0xF9, 0x78,
0x04, 0x39, 0xDA, 0xB4, 0x79, 0x32, 0x63, 0x60, 0xA6, 0x69, 0x86, 0x5C,
0xFF, 0xB0, 0x71, 0xD0, 0xF5, 0x5E, 0x3C, 0xB2, 0x5D, 0x81, 0x4F, 0x9F,
0xE4, 0xF7, 0x3B, 0xC7, 0xC5, 0x80, 0x5E, 0x8E, 0x01, 0x23, 0xFA, 0xFC,
0x09, 0xAE, 0x12, 0x55, 0xF2, 0xD0, 0x50, 0x5C, 0xED, 0xC6, 0xD6, 0x81,
0x9A, 0xA7, 0x93, 0xA3, 0xF4, 0xAC, 0xE5, 0x3E, 0xDB, 0x5A, 0x05, 0xB7,
0x0B, 0x80, 0xAD, 0xA9, 0x08, 0xF1, 0x5A, 0xB5, 0x09, 0x23, 0x52, 0x65,
0x46, 0x64, 0x79, 0xF2, 0x47, 0x04, 0x72, 0x48, 0x4E, 0x01, 0x55, 0x4A,
0x67, 0x8D, 0x1E, 0x07, 0xC7, 0x46, 0x87, 0xF6, 0x50, 0xC3, 0xA6, 0x6B}};
const std::vector<uint8_t> FfElementTest::epid11_GT_multi_exp_exp_3[3] = {
{0x00, 0x00, 0xAF, 0x5B, 0x22, 0x71, 0x98, 0xB6, 0xEB, 0x67, 0x3D,
0x94, 0x4A, 0xB6, 0x5E, 0x99, 0x81, 0xC5, 0x96, 0x91, 0x55, 0xBA,
0x2F, 0x16, 0x01, 0x4E, 0xE1, 0x25, 0xAD, 0xCA, 0x94, 0x88, 0x60,
0x3B, 0xA2, 0x56, 0x0A, 0x94, 0x0B, 0x2C, 0x3E, 0xD0, 0x8F, 0x15,
0x07, 0x3D, 0xD5, 0xBE, 0x72, 0x3E, 0x2D, 0x06, 0x74, 0xFF, 0x06,
0xED, 0x47, 0x28, 0x08, 0x0C, 0xA0, 0x6F, 0xDB, 0x75, 0x55, 0x32,
0xDC, 0x97, 0x47, 0x60, 0x4E, 0x6F, 0xB4, 0x29, 0x89, 0x0C},
{0x00, 0x00, 0x01, 0xB8, 0x40, 0xBB, 0xE1, 0x1C, 0x84, 0x8E, 0x02,
0xC0, 0xEF, 0x69, 0x84, 0x90, 0xED, 0xEB, 0x99, 0x94, 0xBC, 0x79,
0x48, 0xC8, 0x08, 0x3C, 0x25, 0xDA, 0xAC, 0xFF, 0x3A, 0xDD},
{0x00, 0x00, 0x37, 0x1E, 0xCD, 0x0F, 0x66, 0x09, 0x7D, 0x33, 0x9A,
0xDC, 0x47, 0x28, 0xF7, 0x91, 0xF3, 0xC2, 0xBC, 0x3A, 0xA9, 0x05,
0x62, 0xFC, 0xDD, 0x8C, 0x65, 0xC2, 0xA8, 0x14, 0x55, 0x52},
};
const Fq6ElemStr FfElementTest::epid11_GT_multi_exp_res_3 = {
0x09, 0xCF, 0x1D, 0xB6, 0x97, 0x14, 0x58, 0xAA, 0x29, 0x7E, 0x03, 0x96,
0xD2, 0xDC, 0xD4, 0x2C, 0x1F, 0x2F, 0xB0, 0xC1, 0x5E, 0x71, 0xFB, 0x0C,
0x8D, 0xDB, 0xBD, 0x1D, 0x20, 0xD9, 0x9A, 0xA5, 0x02, 0x69, 0x62, 0x1C,
0x5C, 0xE8, 0x12, 0x11, 0xB1, 0x49, 0x93, 0x29, 0x23, 0xAF, 0xB4, 0xFF,
0x77, 0x1E, 0xC9, 0xA6, 0xA0, 0x6D, 0xD9, 0x38, 0x89, 0x1A, 0xC7, 0xB9,
0xF9, 0x66, 0x25, 0xD3, 0x00, 0x59, 0xE1, 0xAC, 0x0D, 0xDE, 0xCF, 0xC0,
0xCF, 0x50, 0x48, 0x6B, 0xCE, 0x32, 0x15, 0x79, 0x13, 0x71, 0x12, 0x9B,
0x63, 0x09, 0x4D, 0x20, 0xD9, 0x4A, 0xCD, 0x4F, 0x00, 0x7F, 0x8A, 0x19,
0x06, 0x3F, 0x0F, 0x3E, 0x83, 0xA3, 0xEE, 0x0F, 0xAB, 0x72, 0xC9, 0x9A,
0x5D, 0xD1, 0x67, 0xBF, 0xF1, 0x0E, 0xAB, 0x9C, 0xE8, 0x50, 0x04, 0xA7,
0x20, 0xAA, 0xF6, 0xB9, 0x8E, 0x2F, 0x69, 0x44, 0x02, 0x68, 0x7A, 0x2E,
0x70, 0xD4, 0x7E, 0x83, 0x8F, 0xAB, 0x58, 0x3E, 0xD2, 0x95, 0xA0, 0x1A,
0x61, 0xC8, 0x93, 0xA0, 0xCC, 0xA4, 0x90, 0xFB, 0x73, 0xC2, 0xD2, 0x91,
0x70, 0x34, 0x6A, 0x67, 0x03, 0x67, 0x49, 0x84, 0xEE, 0x3B, 0x9E, 0x8B,
0x6D, 0x47, 0x95, 0xBD, 0x0E, 0x47, 0x97, 0x9E, 0x0A, 0x87, 0x61, 0x83,
0x80, 0xEF, 0x4F, 0x91, 0xA8, 0xA6, 0xB7, 0xC0, 0x44, 0xE2, 0x21, 0x8D};
////////////////////////////////////////////////
// NewFfElement
TEST_F(FfElementTest, NewFailsGivenNullPointer) {
FfElement* ff_elem = nullptr;
EXPECT_EQ(kEpidBadArgErr, NewFfElement(nullptr, &ff_elem));
EXPECT_EQ(kEpidBadArgErr, NewFfElement(this->fq, nullptr));
DeleteFfElement(&ff_elem);
}
TEST_F(FfElementTest, NewSucceedsGiven256BitFiniteField) {
FfElement* ff_elem = nullptr;
EXPECT_EQ(kEpidNoErr, NewFfElement(this->fq, &ff_elem));
DeleteFfElement(&ff_elem);
}
TEST_F(FfElementTest, Default256BitElementIsZero) {
FfElement* ff_elem = nullptr;
THROW_ON_EPIDERR(NewFfElement(this->fq, &ff_elem));
FqElemStr ff_elem_str;
EpidStatus sts =
WriteFfElement(this->fq, ff_elem, &ff_elem_str, sizeof(ff_elem_str));
DeleteFfElement(&ff_elem);
THROW_ON_EPIDERR(sts);
FqElemStr fq_zero_str = {0};
EXPECT_EQ(fq_zero_str, ff_elem_str);
}
////////////////////////////////////////////////
// DeleteFfElement
TEST_F(FfElementTest, DeleteNullsPointer) {
FfElement* ff_elem = nullptr;
EpidStatus sts = NewFfElement(this->fq, &ff_elem);
DeleteFfElement(&ff_elem);
THROW_ON_EPIDERR(sts);
EXPECT_EQ(nullptr, ff_elem);
}
TEST_F(FfElementTest, DeleteWorksGivenNullPointer) {
EXPECT_NO_THROW(DeleteFfElement(nullptr));
FfElement* ff_elem = nullptr;
EXPECT_NO_THROW(DeleteFfElement(&ff_elem));
}
////////////////////////////////////////////////
// ReadFfElement
TEST_F(FfElementTest, ReadFailsGivenArgumentsMismatch) {
uint8_t buf[sizeof(Fq12ElemStr)] = {0};
EXPECT_EQ(kEpidBadArgErr,
ReadFfElement(this->fq12, buf, sizeof(Fq12ElemStr), this->fq_a));
EXPECT_EQ(kEpidBadArgErr,
ReadFfElement(this->fq, buf, sizeof(FqElemStr), this->fq12_result));
}
TEST_F(FfElementTest, ReadFailsGivenNullPointer) {
FqElemStr ff_elem_str;
EXPECT_EQ(kEpidBadArgErr, ReadFfElement(nullptr, &ff_elem_str,
sizeof(ff_elem_str), this->fq_a));
EXPECT_EQ(kEpidBadArgErr,
ReadFfElement(this->fq, nullptr, sizeof(ff_elem_str), this->fq_a));
EXPECT_EQ(kEpidBadArgErr, ReadFfElement(this->fq, &ff_elem_str,
sizeof(ff_elem_str), nullptr));
}
TEST_F(FfElementTest, ReadFailsGivenInvalidBufferSize) {
EXPECT_EQ(kEpidBadArgErr,
ReadFfElement(this->fq, &this->fq_qm1_str, 0, this->fq_a));
EXPECT_EQ(kEpidBadArgErr,
ReadFfElement(this->fq, &this->fq_qm1_str,
std::numeric_limits<size_t>::max(), this->fq_a));
}
TEST_F(FfElementTest, ReadFailsGivenElementDoesNotBelongToFF) {
// q does not belong to Fq
EXPECT_EQ(kEpidBadArgErr, ReadFfElement(this->fq, &this->bn_q_str,
sizeof(this->bn_q_str), this->fq_a));
}
TEST_F(FfElementTest, Read256BitElementCorrectly) {
// q-1 is valid element of Fq
ASSERT_EQ(kEpidNoErr, ReadFfElement(this->fq, &this->fq_qm1_str,
sizeof(this->fq_qm1_str), this->fq_a));
FqElemStr buf;
EXPECT_EQ(kEpidNoErr,
WriteFfElement(this->fq, this->fq_a, &buf, sizeof(buf)));
EXPECT_EQ(this->fq_qm1_str, buf);
}
TEST_F(FfElementTest, ReadIgnoreLeadingZerosForPrimeField) {
// q-1 is valid element of Fq
std::vector<uint8_t> ff_elem_str = {
0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF0, 0xCD, 0x46, 0xE5,
0xF2, 0x5E, 0xEE, 0x71, 0xA4, 0x9F, 0x0C, 0xDC, 0x65, 0xFB, 0x12,
0x98, 0x0A, 0x82, 0xD3, 0x29, 0x2D, 0xDB, 0xAE, 0xD3, 0x30, 0x12};
ASSERT_EQ(kEpidNoErr, ReadFfElement(this->fq, ff_elem_str.data(),
ff_elem_str.size(), this->fq_a));
FqElemStr buf;
EXPECT_EQ(kEpidNoErr,
WriteFfElement(this->fq, this->fq_a, &buf, sizeof(buf)));
EXPECT_EQ(this->fq_qm1_str, buf);
}
TEST_F(FfElementTest, ReadExpectExactSizeForFieldExtensions) {
uint8_t buf[sizeof(Fq2ElemStr) + 1] = {0};
EXPECT_EQ(kEpidBadArgErr,
ReadFfElement(this->fq2, buf, sizeof(buf), this->fq2_a));
}
///////////////////////////////////////////////////////////////////////
// InitFfElementFromBn
TEST_F(FfElementTest, InitFromBnFailsGivenNonPrimeField) {
BigNumStr str = {0x01};
FfElementObj ffe(&this->fq2);
BigNumObj bn(sizeof(str), str);
EXPECT_EQ(kEpidBadArgErr, InitFfElementFromBn(this->fq2, bn, ffe));
}
TEST_F(FfElementTest, InitFromBnFailsGivenNullPointer) {
BigNumStr str = {0x01};
FfElementObj ffe(&this->fq);
BigNumObj bn(sizeof(str), str);
EXPECT_EQ(kEpidBadArgErr, InitFfElementFromBn(nullptr, bn, ffe));
EXPECT_EQ(kEpidBadArgErr, InitFfElementFromBn(this->fq, nullptr, ffe));
EXPECT_EQ(kEpidBadArgErr, InitFfElementFromBn(this->fq, bn, nullptr));
}
TEST_F(FfElementTest, InitFromBnInFieldElementCorrectly) {
FfElementObj ffe(&this->fq);
BigNumObj qm1_bn(this->bn_qm1_str);
FqElemStr buf;
EXPECT_EQ(kEpidNoErr, InitFfElementFromBn(this->fq, qm1_bn, ffe));
EXPECT_EQ(kEpidNoErr, WriteFfElement(this->fq, ffe, &buf, sizeof(buf)));
EXPECT_EQ(this->fq_qm1_str, buf);
}
TEST_F(FfElementTest, InitFromBnOutOfFieldElementCorrectly) {
FfElementObj ffe(&this->fq);
BigNumObj q_bn(this->bn_q_str);
BigNumObj qp1_bn(this->bn_qp1_str);
FqElemStr buf;
EXPECT_EQ(kEpidNoErr, InitFfElementFromBn(this->fq, q_bn, ffe));
EXPECT_EQ(kEpidNoErr, WriteFfElement(this->fq, ffe, &buf, sizeof(buf)));
EXPECT_EQ(this->bn_0_str, buf);
EXPECT_EQ(kEpidNoErr, InitFfElementFromBn(this->fq, qp1_bn, ffe));
EXPECT_EQ(kEpidNoErr, WriteFfElement(this->fq, ffe, &buf, sizeof(buf)));
EXPECT_EQ(this->bn_1_str, buf);
}
///////////////////////////////////////////////////////////////////////
// FfIsEqual
TEST_F(FfElementTest, FfIsEqualFailsGivenArgumentsMismatch) {
bool result;
EXPECT_EQ(kEpidBadArgErr,
FfIsEqual(this->fq12, this->fq_a, this->fq_b, &result));
EXPECT_EQ(kEpidBadArgErr,
FfIsEqual(this->fq, this->fq12_g, this->fq_b, &result));
EXPECT_EQ(kEpidBadArgErr,
FfIsEqual(this->fq, this->fq_a, this->fq12_h, &result));
}
TEST_F(FfElementTest, FfIsEqualFailsGivenNullPointer) {
bool result;
EXPECT_EQ(kEpidBadArgErr,
FfIsEqual(nullptr, this->fq_a, this->fq_a, &result));
EXPECT_EQ(kEpidBadArgErr, FfIsEqual(this->fq, nullptr, this->fq_a, &result));
EXPECT_EQ(kEpidBadArgErr, FfIsEqual(this->fq, this->fq_a, nullptr, &result));
EXPECT_EQ(kEpidBadArgErr,
FfIsEqual(this->fq, this->fq_a, this->fq_a, nullptr));
}
TEST_F(FfElementTest, FfIsEqualCanCompareElementWithItself) {
bool result;
EXPECT_EQ(kEpidNoErr, FfIsEqual(this->fq, this->fq_a, this->fq_a, &result));
EXPECT_TRUE(result);
}
TEST_F(FfElementTest, Different256BitFiniteFieldElementsAreNotEqual) {
bool result;
EXPECT_EQ(kEpidNoErr, FfIsEqual(this->fq, this->fq_a, this->fq_b, &result));
EXPECT_FALSE(result);
}
TEST_F(FfElementTest, Same256BitFiniteFieldElementsAreEqual) {
FfElementObj fq_a_local(&this->fq, &this->fq_a_str, sizeof(this->fq_a_str));
bool result;
EXPECT_EQ(kEpidNoErr, FfIsEqual(this->fq, this->fq_a, fq_a_local, &result));
EXPECT_TRUE(result);
}
TEST_F(FfElementTest, DifferentFq12ElementsAreNotEqual) {
bool result;
EXPECT_EQ(kEpidNoErr,
FfIsEqual(this->fq12, this->fq12_g, this->fq12_h, &result));
EXPECT_FALSE(result);
}
TEST_F(FfElementTest, SameFq12ElementsAreEqual) {
FfElementObj fq12_g_local(&this->fq12, &this->fq12_g_str,
sizeof(this->fq12_g_str));
bool result;
EXPECT_EQ(kEpidNoErr,
FfIsEqual(this->fq12, this->fq12_g, fq12_g_local, &result));
EXPECT_TRUE(result);
}
////////////////////////////////////////////////
// WriteFfElement
TEST_F(FfElementTest, WriteFailsGivenArgumentsMismatch) {
uint8_t buf[sizeof(Fq12ElemStr)] = {0};
EXPECT_EQ(kEpidBadArgErr,
WriteFfElement(this->fq12, this->fq_a, buf, sizeof(Fq12ElemStr)));
EXPECT_EQ(kEpidBadArgErr,
WriteFfElement(this->fq, this->fq12_g, buf, sizeof(Fq12ElemStr)));
}
TEST_F(FfElementTest, WriteFailsGivenNullPointer) {
FqElemStr ff_elem_str;
EXPECT_EQ(kEpidBadArgErr, WriteFfElement(nullptr, this->fq_a, &ff_elem_str,
sizeof(ff_elem_str)));
EXPECT_EQ(kEpidBadArgErr, WriteFfElement(this->fq, nullptr, &ff_elem_str,
sizeof(ff_elem_str)));
EXPECT_EQ(kEpidBadArgErr,
WriteFfElement(this->fq, this->fq_a, nullptr, sizeof(ff_elem_str)));
}
TEST_F(FfElementTest, WriteFailsGivenInvalidBufferSize) {
FqElemStr ff_elem_str;
EXPECT_EQ(kEpidBadArgErr,
WriteFfElement(this->fq, this->fq_a, &ff_elem_str, 0));
EXPECT_EQ(kEpidBadArgErr, WriteFfElement(this->fq, this->fq_a, &ff_elem_str,
sizeof(ff_elem_str) - 1));
EXPECT_EQ(kEpidBadArgErr, WriteFfElement(this->fq, this->fq_a, &ff_elem_str,
std::numeric_limits<size_t>::max()));
}
TEST_F(FfElementTest, WriteWorksGiven256BitElement) {
FqElemStr ff_elem_str;
EXPECT_EQ(kEpidNoErr, WriteFfElement(this->fq, this->fq_a, &ff_elem_str,
sizeof(ff_elem_str)));
EXPECT_EQ(this->fq_a_str, ff_elem_str);
}
TEST_F(FfElementTest, WritePadPrimeFieldElement) {
FqElemStr ff_elem_str[2] = {0xcd};
EXPECT_EQ(kEpidNoErr, WriteFfElement(this->fq, this->fq_a, &ff_elem_str[0],
sizeof(ff_elem_str)));
EXPECT_EQ(this->fq_0_str, ff_elem_str[0]);
EXPECT_EQ(this->fq_a_str, ff_elem_str[1]);
}
TEST_F(FfElementTest, WriteExpectExactSizeForFieldExtensions) {
uint8_t buf[sizeof(Fq12ElemStr) + 1] = {0};
EXPECT_EQ(kEpidBadArgErr, WriteFfElement(this->fq12, this->fq12_g, buf,
sizeof(Fq12ElemStr) + 1));
EXPECT_EQ(kEpidBadArgErr, WriteFfElement(this->fq12, this->fq12_g, buf,
sizeof(Fq12ElemStr) - 1));
EXPECT_EQ(kEpidBadArgErr,
WriteFfElement(this->fq12, this->fq12_g, buf, sizeof(FqElemStr)));
}
///////////////////////////////////////////////////////////////////////
// FfNeg
TEST_F(FfElementTest, FfNegFailsGivenArgumentsMismatch) {
EXPECT_EQ(kEpidBadArgErr, FfNeg(this->fq12, this->fq_a, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfNeg(this->fq, this->fq12_g, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfNeg(this->fq, this->fq_a, this->fq12_result));
}
TEST_F(FfElementTest, FfNegFailsGivenNullPointer) {
EXPECT_EQ(kEpidBadArgErr, FfNeg(nullptr, this->fq_a, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfNeg(this->fq, nullptr, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfNeg(this->fq, this->fq_a, nullptr));
}
TEST_F(FfElementTest, FfNegSucceedsGivenElementZero) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr, FfNeg(this->fq, this->fq_0, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_0_str, fq_r_str)
<< "FfNeg: Negate element does not match to reference neg zero value";
}
TEST_F(FfElementTest, FfNegSucceedsGivenNonZeroElement) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr, FfNeg(this->fq, this->fq_a, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_neg_a_str, fq_r_str)
<< "FfNeg: Negate element does not match to reference neg value";
}
////////////////////////////////////////////////
// FfIsZero
TEST_F(FfElementTest, FfIsZeroFailsGivenNullPointer) {
bool result = false;
EXPECT_EQ(kEpidBadArgErr, FfIsZero(nullptr, this->fq_0, &result));
EXPECT_EQ(kEpidBadArgErr, FfIsZero(this->fq, nullptr, &result));
EXPECT_EQ(kEpidBadArgErr, FfIsZero(this->fq, this->fq_0, nullptr));
}
TEST_F(FfElementTest, FfIsZeroFailsGivenArgumentsMismatch) {
bool result;
EXPECT_EQ(kEpidBadArgErr, FfIsZero(this->fq12, this->fq_a, &result));
EXPECT_EQ(kEpidBadArgErr, FfIsZero(this->fq, this->fq12_g, &result));
}
TEST_F(FfElementTest, FfIsZeroSucceedsGivenZeroElement) {
bool result = false;
EXPECT_EQ(kEpidNoErr, FfIsZero(this->fq, this->fq_0, &result));
EXPECT_TRUE(result);
}
TEST_F(FfElementTest, FfIsZeroSucceedsGivenNonZeroElement) {
bool result = false;
EXPECT_EQ(kEpidNoErr, FfIsZero(this->fq, this->fq_1, &result));
EXPECT_FALSE(result);
}
////////////////////////////////////////////////
// FfMul
TEST_F(FfElementTest, FfMulFailsGivenNullPointer) {
EXPECT_EQ(kEpidBadArgErr,
FfMul(nullptr, this->fq_a, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMul(this->fq, nullptr, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMul(this->fq, this->fq_a, nullptr, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfMul(this->fq, this->fq_a, this->fq_b, nullptr));
}
TEST_F(FfElementTest, FfMulFailsGivenArgumentsMismatch) {
EXPECT_EQ(kEpidBadArgErr,
FfMul(this->fq12, this->fq_a, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMul(this->fq, this->fq12_g, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMul(this->fq, this->fq_a, this->fq12_h, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMul(this->fq, this->fq_a, this->fq_b, this->fq12_result));
EXPECT_EQ(kEpidBadArgErr,
FfMul(this->fq2, this->fq_a, this->fq2_a, this->fq2_result));
}
TEST_F(FfElementTest, FfMulSucceedsGivenElementZero) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr,
FfMul(this->fq, this->fq_0, this->fq_b, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_0_str, fq_r_str);
EXPECT_EQ(kEpidNoErr,
FfMul(this->fq, this->fq_a, this->fq_0, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_0_str, fq_r_str);
}
TEST_F(FfElementTest, FfMulSucceedsGivenElementOne) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr,
FfMul(this->fq, this->fq_1, this->fq_b, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_b_str, fq_r_str);
EXPECT_EQ(kEpidNoErr,
FfMul(this->fq, this->fq_a, this->fq_1, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_a_str, fq_a_str);
}
TEST_F(FfElementTest, FfMulSucceedsGivenTwoElements) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr,
FfMul(this->fq, this->fq_a, this->fq_b, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_mul_ab_str, fq_r_str);
Fq2ElemStr fq2_r_str;
THROW_ON_EPIDERR(
ReadFfElement(this->fq, &(fq_b_str), sizeof(fq_b_str), this->fq_b));
EXPECT_EQ(kEpidNoErr,
FfMul(this->fq2, this->fq2_a, this->fq_b, this->fq2_result));
THROW_ON_EPIDERR(WriteFfElement(this->fq2, this->fq2_result, &fq2_r_str,
sizeof(fq2_r_str)));
EXPECT_EQ(this->fq2_mul_ab_str, fq2_r_str);
Fq12ElemStr fq12_r_str;
THROW_ON_EPIDERR(ReadFfElement(this->fq12, &(this->fq12_i_str),
sizeof(this->fq12_i_str), this->fq12_i));
THROW_ON_EPIDERR(ReadFfElement(this->fq12, &(fq12_j_str), sizeof(fq12_j_str),
this->fq12_j));
EXPECT_EQ(kEpidNoErr,
FfMul(this->fq12, this->fq12_i, this->fq12_j, this->fq12_result));
THROW_ON_EPIDERR(WriteFfElement(this->fq12, this->fq12_result, &fq12_r_str,
sizeof(fq12_r_str)));
EXPECT_EQ(fq12_mul_ij_str, fq12_r_str);
}
////////////////////////////////////////////////
// FfSub
TEST_F(FfElementTest, FfSubFailsGivenArgumentsMismatch) {
EXPECT_EQ(kEpidBadArgErr,
FfSub(this->fq12, this->fq_a, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSub(this->fq, this->fq12_g, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSub(this->fq, this->fq_a, this->fq12_h, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSub(this->fq, this->fq_a, this->fq_b, this->fq12_result));
}
TEST_F(FfElementTest, FfSubFailsGivenNullPtr) {
EXPECT_EQ(kEpidBadArgErr,
FfSub(nullptr, this->fq_a, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSub(this->fq, nullptr, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSub(this->fq, this->fq_a, nullptr, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfSub(this->fq, this->fq_a, this->fq_b, nullptr));
}
TEST_F(FfElementTest, FfSubSucceedsGivenElementZero) {
FqElemStr fq_r_str = {0x0};
// additive identity
EXPECT_EQ(kEpidNoErr,
FfSub(this->fq, this->fq_a, this->fq_0, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_a_str, fq_r_str);
EXPECT_EQ(kEpidNoErr,
FfSub(this->fq, this->fq_0, this->fq_0, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_0_str, fq_r_str);
}
TEST_F(FfElementTest, FfSubSucceedsGivenTwoEqualElements) {
FqElemStr fq_r_str = {0x0};
EXPECT_EQ(kEpidNoErr,
FfSub(this->fq, this->fq_a, this->fq_a, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_0_str, fq_r_str);
}
TEST_F(FfElementTest, FfSubSucceedsGivenTwoElements) {
FqElemStr fq_r_str = {0x0};
EXPECT_EQ(kEpidNoErr,
FfSub(this->fq, this->fq_sum_ab, this->fq_b, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_a_str, fq_r_str);
}
TEST_F(FfElementTest, FfSubSucceedsGivenTwoElementsFq2) {
FfElementObj a(&this->fq2, &this->bn_a_str, sizeof(this->bn_a_str));
FfElementObj b(&this->fq2, &this->bn_b_str, sizeof(this->bn_b_str));
FfElementObj sum_ab(&this->fq2, this->fq2_sum_ab_str);
FfElementObj r(&this->fq2);
EXPECT_EQ(kEpidNoErr, FfSub(this->fq2, sum_ab, b, r));
EXPECT_EQ(a, r);
}
TEST_F(FfElementTest, FfSubSucceedsGivenTwoElementsFq6) {
FfElementObj a(&this->fq6, &this->bn_a_str, sizeof(this->bn_a_str));
FfElementObj b(&this->fq6, &this->bn_b_str, sizeof(this->bn_b_str));
FfElementObj sum_ab(&this->fq6, this->fq6_sum_ab_str);
FfElementObj r(&this->fq6);
EXPECT_EQ(kEpidNoErr, FfSub(this->fq6, sum_ab, b, r));
EXPECT_EQ(a, r);
}
TEST_F(FfElementTest, FfSubSucceedsGivenTwoElementsFq12) {
FfElementObj a(&this->fq12, &this->bn_a_str, sizeof(this->bn_a_str));
FfElementObj b(&this->fq12, &this->bn_b_str, sizeof(this->bn_b_str));
FfElementObj sum_ab(&this->fq12, this->fq12_sum_ab_str);
FfElementObj r(&this->fq12);
EXPECT_EQ(kEpidNoErr, FfSub(this->fq12, sum_ab, b, r));
EXPECT_EQ(a, r);
}
////////////////////////////////////////////////
// FfAdd
TEST_F(FfElementTest, FfAddFailsGivenArgumentsMismatch) {
EXPECT_EQ(kEpidBadArgErr,
FfAdd(this->fq12, this->fq_a, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfAdd(this->fq, this->fq12_g, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfAdd(this->fq, this->fq_a, this->fq12_h, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfAdd(this->fq, this->fq_a, this->fq_b, this->fq12_result));
}
TEST_F(FfElementTest, FfAddFailsGivenNullPtr) {
EXPECT_EQ(kEpidBadArgErr,
FfAdd(nullptr, this->fq_a, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfAdd(this->fq, nullptr, this->fq_b, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfAdd(this->fq, this->fq_a, nullptr, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfAdd(this->fq, this->fq_a, this->fq_b, nullptr));
}
TEST_F(FfElementTest, FfAddSucceedsGivenElementZero) {
FqElemStr fq_r_str = {0x0};
// additive identity
EXPECT_EQ(kEpidNoErr,
FfAdd(this->fq, this->fq_a, this->fq_0, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_a_str, fq_r_str);
EXPECT_EQ(kEpidNoErr,
FfAdd(this->fq, this->fq_0, this->fq_b, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_b_str, fq_r_str);
EXPECT_EQ(kEpidNoErr,
FfAdd(this->fq, this->fq_0, this->fq_0, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_0_str, fq_r_str);
}
TEST_F(FfElementTest, FfAddSucceedsGivenTwoElements) {
FqElemStr fq_r_str = {0x0};
EXPECT_EQ(kEpidNoErr,
FfAdd(this->fq, this->fq_a, this->fq_b, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_sum_ab_str, fq_r_str);
}
TEST_F(FfElementTest, FfAddSucceedsGivenTwoElementsFq2) {
FfElementObj a(&this->fq2, &this->bn_a_str, sizeof(this->bn_a_str));
FfElementObj b(&this->fq2, &this->bn_b_str, sizeof(this->bn_b_str));
FfElementObj r(&this->fq2);
EXPECT_EQ(kEpidNoErr, FfAdd(this->fq2, a, b, r));
EXPECT_EQ(FfElementObj(&this->fq2, this->fq2_sum_ab_str), r);
}
TEST_F(FfElementTest, FfAddSucceedsGivenTwoElementsFq6) {
FfElementObj a(&this->fq6, &this->bn_a_str, sizeof(this->bn_a_str));
FfElementObj b(&this->fq6, &this->bn_b_str, sizeof(this->bn_b_str));
FfElementObj r(&this->fq6);
EXPECT_EQ(kEpidNoErr, FfAdd(this->fq6, a, b, r));
EXPECT_EQ(FfElementObj(&this->fq6, this->fq6_sum_ab_str), r);
}
TEST_F(FfElementTest, FfAddSucceedsGivenTwoElementsFq12) {
FfElementObj a(&this->fq12, &this->bn_a_str, sizeof(this->bn_a_str));
FfElementObj b(&this->fq12, &this->bn_b_str, sizeof(this->bn_b_str));
FfElementObj r(&this->fq12);
EXPECT_EQ(kEpidNoErr, FfAdd(this->fq12, a, b, r));
EXPECT_EQ(FfElementObj(&this->fq12, this->fq12_sum_ab_str), r);
}
////////////////////////////////////////////////
// FfInv
TEST_F(FfElementTest, FfInvFailsGivenNullPointer) {
EXPECT_EQ(kEpidBadArgErr, FfInv(nullptr, (this->fq_a), this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfInv(this->fq, nullptr, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfInv(this->fq, this->fq_a, nullptr));
}
TEST_F(FfElementTest, FfInvFailsGivenArgumentsMismatch) {
EXPECT_EQ(kEpidBadArgErr, FfInv(this->fq12, this->fq_a, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfInv(this->fq, this->fq12_g, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfInv(this->fq, this->fq_a, this->fq12_result));
}
TEST_F(FfElementTest, FfInvFailsGivenElementZero) {
EXPECT_EQ(kEpidDivByZeroErr, FfInv(this->fq, this->fq_0, this->fq_result));
}
TEST_F(FfElementTest, FfInvSucceedsGivenElementOne) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr, FfInv(this->fq, this->fq_1, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_1_str, fq_r_str);
}
TEST_F(FfElementTest, FfInvSucceedsGivenAnElement) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr, FfInv(this->fq, this->fq_a, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_inv_a_str, fq_r_str);
}
////////////////////////////////////////////////
// FfExp
TEST_F(FfElementTest, FfExpFailsGivenNullPointer) {
EXPECT_EQ(kEpidBadArgErr,
FfExp(nullptr, this->fq_a, this->bn_a, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfExp(this->fq, nullptr, this->bn_a, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfExp(this->fq, this->fq_a, nullptr, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfExp(this->fq, this->fq_a, this->bn_a, nullptr));
}
TEST_F(FfElementTest, FfExpFailsGivenArgumentsMismatch) {
EXPECT_EQ(kEpidBadArgErr,
FfExp(this->fq12, this->fq_a, this->bn_0, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfExp(this->fq, this->fq12_g, this->bn_0, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfExp(this->fq, this->fq_a, this->bn_0, this->fq12_result));
}
TEST_F(FfElementTest, FfExpSucceedsGivenElementZero) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr,
FfExp(this->fq, this->fq_0, this->bn_a, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_0_str, fq_r_str);
}
TEST_F(FfElementTest, FfExpSucceedsGivenExponentZero) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr,
FfExp(this->fq, this->fq_a, this->bn_0, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_1_str, fq_r_str);
}
TEST_F(FfElementTest, FfExpSucceedsGivenElementOne) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr,
FfExp(this->fq, this->fq_1, this->bn_a, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_1_str, fq_r_str);
}
TEST_F(FfElementTest, FfExpSucceedsGivenExponentOne) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr,
FfExp(this->fq, this->fq_a, this->bn_1, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_a_str, fq_r_str);
}
TEST_F(FfElementTest, FfExpSucceedsGivenAnElement) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr,
FfExp(this->fq, this->fq_a, this->bn_a, this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_exp_ab_str, fq_r_str);
Fq12ElemStr fq12_r_str;
BigNumObj bn_pm1(sizeof(this->fp_pm1_str), this->fp_pm1_str);
EXPECT_EQ(kEpidNoErr,
FfExp(this->fq12, this->fq12_k, bn_pm1, this->fq12_result));
THROW_ON_EPIDERR(WriteFfElement(this->fq12, this->fq12_result, &fq12_r_str,
sizeof(fq12_r_str)));
EXPECT_EQ(this->fq12_mul_gb_str, fq12_r_str);
}
////////////////////////////////////////////////
// FfHash
TEST_F(FfElementTest, FfHashFailsGivenArgumentsMismatch) {
EXPECT_EQ(kEpidBadArgErr,
FfHash(this->fq12, this->sha_msg, sizeof(this->sha_msg), kSha256,
this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfHash(this->fq, this->sha_msg, sizeof(this->sha_msg), kSha256,
this->fq12_result));
}
TEST_F(FfElementTest, FfHashFailsGivenNullPointer) {
uint8_t const msg[] = {0};
EXPECT_EQ(kEpidBadArgErr,
FfHash(nullptr, msg, sizeof(msg), kSha256, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfHash(this->fq, nullptr, sizeof(msg), kSha256, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfHash(this->fq, msg, sizeof(msg), kSha256, nullptr));
}
TEST_F(FfElementTest, FfHashFailsGivenUnsupportedHashAlg) {
uint8_t const msg[] = {0};
EXPECT_EQ(kEpidHashAlgorithmNotSupported,
FfHash(this->fq, msg, sizeof(msg), kSha3_256, this->fq_result));
EXPECT_EQ(kEpidHashAlgorithmNotSupported,
FfHash(this->fq, msg, sizeof(msg), kSha3_384, this->fq_result));
EXPECT_EQ(kEpidHashAlgorithmNotSupported,
FfHash(this->fq, msg, sizeof(msg), kSha3_512, this->fq_result));
}
TEST_F(FfElementTest, FfHashFailsGivenIncorrectMsgLen) {
uint8_t const msg[] = {0};
size_t len_greater_int_max = (size_t)INT_MAX + 1;
EXPECT_EQ(kEpidBadArgErr, FfHash(this->fq, msg, 0, kSha256, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfHash(this->fq, msg, std::numeric_limits<size_t>::max(), kSha256,
this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfHash(this->fq, msg, len_greater_int_max, kSha256,
this->fq_result));
}
TEST_F(FfElementTest, FfHashWorksGivenSHA256HashAlg) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr, FfHash(this->fq, sha_msg, sizeof(sha_msg), kSha256,
this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_abc_sha256_str, fq_r_str)
<< "FfHash: Hash element does not match to reference value";
}
TEST_F(FfElementTest, FfHashWorksGivenSHA384HashAlg) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr, FfHash(this->fq, sha_msg, sizeof(sha_msg), kSha384,
this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_abc_sha384_str, fq_r_str)
<< "FfHash: Hash element does not match to reference value";
}
TEST_F(FfElementTest, FfHashWorksGivenSHA512HashAlg) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr, FfHash(this->fq, sha_msg, sizeof(sha_msg), kSha512,
this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_abc_sha512_str, fq_r_str)
<< "FfHash: Hash element does not match to reference value";
}
TEST_F(FfElementTest, FfHashWorksGivenSHA512256HashAlg) {
FqElemStr fq_r_str;
EXPECT_EQ(kEpidNoErr, FfHash(this->fq, sha_msg, sizeof(sha_msg), kSha512_256,
this->fq_result));
THROW_ON_EPIDERR(
WriteFfElement(this->fq, this->fq_result, &fq_r_str, sizeof(fq_r_str)));
EXPECT_EQ(this->fq_abc_sha512256_str, fq_r_str)
<< "FfHash: Hash element does not match to reference value";
}
////////////////////////////////////////////////
// FfMultiExp
TEST_F(FfElementTest, FfMultiExpFailsGivenArgumentsMismatch) {
FfElement const* p[] = {this->fq_a, this->fq_b};
FfElement const* p12[] = {this->fq12_g, this->fq12_h};
BigNumStr const* b[] = {&this->bn_0_str, &this->bn_0_str};
EXPECT_EQ(kEpidBadArgErr, FfMultiExp(this->fq12, p, b, 2, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfMultiExp(this->fq, p12, b, 2, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfMultiExp(this->fq, p, b, 2, this->fq12_result));
}
TEST_F(FfElementTest, FfMultiExpFailsGivenNullPointer) {
FfElement const* p[] = {this->fq_a, this->fq_b};
FfElement const* p_withnull[] = {nullptr, this->fq_b};
BigNumStr const* b[] = {&fq_multi_exp_exp_2[0], &this->fq_multi_exp_exp_2[1]};
BigNumStr const* b_withnull[] = {nullptr, &this->fq_multi_exp_exp_2[1]};
size_t m = 2;
EXPECT_EQ(kEpidBadArgErr, FfMultiExp(nullptr, p, b, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExp(this->fq, nullptr, b, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExp(this->fq, p, nullptr, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfMultiExp(this->fq, p, b, m, nullptr));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExp(this->fq, p_withnull, b, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExp(this->fq, p, b_withnull, m, this->fq_result));
}
TEST_F(FfElementTest, FfMultiExpFailsGivenIncorrectMLen) {
FfElement const* p[] = {this->fq_a, this->fq_b};
BigNumStr const* b[] = {&this->fq_multi_exp_exp_2[0],
&this->fq_multi_exp_exp_2[1]};
size_t len_greater_int_max = (size_t)INT_MAX + 1;
EXPECT_EQ(kEpidBadArgErr, FfMultiExp(this->fq, p, b, 0, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExp(this->fq, p, b, std::numeric_limits<size_t>::max(),
this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExp(this->fq, p, b, len_greater_int_max, this->fq_result));
}
TEST_F(FfElementTest, FfMultiExpWorksGivenOneExponent) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[1];
FfElement const* p[1];
BigNumStr const* b[1];
int m = 0;
// prepare data for test
for (m = 0; m < 1; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_1[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_1[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExp(this->fq, p, b, 1, r));
// verify calculation is correct
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_1), r)
<< "FfMultiExp: Finite field element does not match with reference value";
}
TEST_F(FfElementTest, FfMultiExpWorksGivenTwoExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[2];
FfElement const* p[2];
BigNumStr const* b[2];
int m = 0;
// prepare data for test
for (m = 0; m < 2; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_2[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_2[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExp(this->fq, p, b, 2, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_2), r)
<< "FfMultiExp: Finite field element does not match with reference value";
}
TEST_F(FfElementTest, FfMultiExpWorksGivenThreeExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[3];
FfElement const* p[3];
BigNumStr const* b[3];
int m = 0;
// prepare data for test
for (m = 0; m < 3; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_3[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_3[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExp(this->fq, p, b, 3, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_3), r)
<< "FfMultiExp: Finite field element does not match with reference value";
}
TEST_F(FfElementTest, FfMultiExpWorksGivenFourExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[4];
FfElement const* p[4];
BigNumStr const* b[4];
int m = 0;
// prepare data for test
for (m = 0; m < 4; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_4[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_4[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExp(this->fq, p, b, 4, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_4), r)
<< "FfMultiExp: Finite field element does not match with reference value";
}
TEST_F(FfElementTest, FfMultiExpWorksGivenFourFq12Exponents) {
FfElementObj r12(&this->fq12);
FfElementObj fq12_exp[4];
FfElement const* p[4];
BigNumStr const* b[4];
int m = 0;
// prepare data for test
for (m = 0; m < 4; m++) {
fq12_exp[m] = FfElementObj(&this->fq12, this->fq12_multi_exp_base_4[m]);
// initialize data for test
p[m] = fq12_exp[m];
b[m] = &this->fq12_multi_exp_exp_4[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExp(this->fq12, p, b, 4, r12));
EXPECT_EQ(FfElementObj(&this->fq12, this->fq12_multi_exp_res_4), r12)
<< "FfMultiExp: Finite field element does not match with reference value";
}
TEST_F(FfElementTest, FfMultiExpWorksGivenFiveExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[5];
FfElement const* p[5];
BigNumStr const* b[5];
int m = 0;
// prepare data for test
for (m = 0; m < 5; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_5[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_5[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExp(this->fq, p, b, 5, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_5), r)
<< "FfMultiExp: Finite field element does not match with reference value";
}
TEST_F(FfElementTest, FfMultiExpWorksGivenSixExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[6];
FfElement const* p[6];
BigNumStr const* b[6];
int m = 0;
// prepare data for test
for (m = 0; m < 6; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_6[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_6[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExp(this->fq, p, b, 6, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_6), r)
<< "FfMultiExp: Finite field element does not match with reference value";
}
///////////////////////////////////////////////////////////////////////
// FfMultiExpBn
TEST_F(FfElementTest, FfMultiExpBnFailsGivenArgumentsMismatch) {
FfElement const* p[] = {this->fq_a, this->fq_b};
FfElement const* p12[] = {this->fq12_g, this->fq12_h};
BigNum const* b[] = {bn_0, bn_0};
EXPECT_EQ(kEpidBadArgErr, FfMultiExpBn(this->fq12, p, b, 2, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfMultiExpBn(this->fq, p12, b, 2, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfMultiExpBn(this->fq, p, b, 2, this->fq12_result));
}
TEST_F(FfElementTest, FfMultiExpBnFailsGivenNullPointer) {
FfElement const* p[] = {this->fq_a, this->fq_b};
FfElement const* p_withnull[] = {nullptr, this->fq_b};
BigNumObj bn_exp_0(this->fq_multi_exp_exp_2[0]);
BigNumObj bn_exp_1(this->fq_multi_exp_exp_2[1]);
BigNum const* b[] = {bn_exp_0, bn_exp_1};
BigNum const* b_withnull[] = {nullptr, bn_exp_1};
size_t m = 2;
EXPECT_EQ(kEpidBadArgErr, FfMultiExpBn(nullptr, p, b, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExpBn(this->fq, nullptr, b, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExpBn(this->fq, p, nullptr, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfMultiExpBn(this->fq, p, b, m, nullptr));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExpBn(this->fq, p_withnull, b, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExpBn(this->fq, p, b_withnull, m, this->fq_result));
}
TEST_F(FfElementTest, FfMultiExpBnFailsGivenIncorrectMLen) {
FfElement const* p[] = {this->fq_a, this->fq_b};
BigNumObj bn_exp_0(this->fq_multi_exp_exp_2[0]);
BigNumObj bn_exp_1(this->fq_multi_exp_exp_2[1]);
BigNum const* b[] = {bn_exp_0, bn_exp_1};
size_t len_greater_int_max = (size_t)INT_MAX + 1;
EXPECT_EQ(kEpidBadArgErr, FfMultiExpBn(this->fq, p, b, 0, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExpBn(this->fq, p, b, std::numeric_limits<size_t>::max(),
this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfMultiExpBn(this->fq, p, b, len_greater_int_max, this->fq_result));
}
TEST_F(FfElementTest, FfMultiExpBnWorksGivenOneExponent) {
const int items = 1;
FfElementObj r(&this->fq);
FfElementObj fq_base[1];
BigNumObj bn_exp[1];
FfElement const* p[1];
BigNum const* b[1];
int m = 0;
// prepare data for test
for (m = 0; m < items; m++) {
fq_base[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_1[m]);
bn_exp[m] = BigNumObj(this->fq_multi_exp_exp_1[m]);
// initialize data for test
p[m] = fq_base[m];
b[m] = bn_exp[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExpBn(this->fq, p, b, items, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_1), r)
<< "FfMultiExpBn: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, FfMultiExpBnWorksGivenTwoExponents) {
const int items = 2;
FfElementObj r(&this->fq);
FfElementObj fq_base[2];
BigNumObj bn_exp[2];
FfElement const* p[2];
BigNum const* b[2];
int m = 0;
// prepare data for test
for (m = 0; m < items; m++) {
fq_base[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_2[m]);
bn_exp[m] = BigNumObj(this->fq_multi_exp_exp_2[m]);
// initialize data for test
p[m] = fq_base[m];
b[m] = bn_exp[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExpBn(this->fq, p, b, items, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_2), r)
<< "FfMultiExpBn: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, FfMultiExpBnWorksGivenThreeExponents) {
const int items = 3;
FfElementObj r(&this->fq);
FfElementObj fq_base[3];
BigNumObj bn_exp[3];
FfElement const* p[3];
BigNum const* b[3];
int m = 0;
// prepare data for test
for (m = 0; m < items; m++) {
fq_base[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_3[m]);
bn_exp[m] = BigNumObj(this->fq_multi_exp_exp_3[m]);
// initialize data for test
p[m] = fq_base[m];
b[m] = bn_exp[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExpBn(this->fq, p, b, items, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_3), r)
<< "FfMultiExpBn: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, FfMultiExpBnWorksGivenFourExponents) {
const int items = 4;
FfElementObj r(&this->fq);
FfElementObj fq_base[4];
BigNumObj bn_exp[4];
FfElement const* p[4];
BigNum const* b[4];
int m = 0;
// prepare data for test
for (m = 0; m < items; m++) {
fq_base[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_4[m]);
bn_exp[m] = BigNumObj(this->fq_multi_exp_exp_4[m]);
// initialize data for test
p[m] = fq_base[m];
b[m] = bn_exp[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExpBn(this->fq, p, b, items, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_4), r)
<< "FfMultiExpBn: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, DISABLED_FfMultiExpBnWorksGivenFourFq12Exponents) {
const int items = 4;
FfElementObj fq12_r(&this->fq12);
FfElementObj fq12_base[4];
BigNumObj fq12_bn_exp[4];
FfElement const* fq12_p[4];
BigNum const* fq12_b[4];
int m = 0;
// prepare data for test
for (m = 0; m < items; m++) {
fq12_base[m] = FfElementObj(&this->fq12, this->fq12_multi_exp_base_4[m]);
fq12_bn_exp[m] = BigNumObj(this->fq12_multi_exp_exp_4[m]);
// initialize data for test
fq12_p[m] = fq12_base[m];
fq12_b[m] = fq12_bn_exp[m];
}
// do test
EXPECT_EQ(kEpidNoErr,
FfMultiExpBn(this->fq12, fq12_p, fq12_b, items, fq12_r));
EXPECT_EQ(FfElementObj(&this->fq12, this->fq_multi_exp_res_4), fq12_r)
<< "FfMultiExpBn: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, FfMultiExpBnWorksGivenFiveExponents) {
const int items = 5;
FfElementObj r(&this->fq);
FfElementObj fq_base[5];
BigNumObj bn_exp[5];
FfElement const* p[5];
BigNum const* b[5];
int m = 0;
// prepare data for test
for (m = 0; m < items; m++) {
fq_base[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_5[m]);
bn_exp[m] = BigNumObj(this->fq_multi_exp_exp_5[m]);
// initialize data for test
p[m] = fq_base[m];
b[m] = bn_exp[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExpBn(this->fq, p, b, items, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_5), r)
<< "FfSscmMultiExp: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, FfMultiExpBnWorksGivenSixExponents) {
const int items = 6;
FfElementObj r(&this->fq);
FfElementObj fq_base[6];
BigNumObj bn_exp[6];
FfElement const* p[6];
BigNum const* b[6];
int m = 0;
// prepare data for test
for (m = 0; m < items; m++) {
fq_base[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_6[m]);
bn_exp[m] = BigNumObj(this->fq_multi_exp_exp_6[m]);
// initialize data for test
p[m] = fq_base[m];
b[m] = bn_exp[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExpBn(this->fq, p, b, items, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_6), r)
<< "FfSscmMultiExp: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, FfMultiExpBnWorksOverEpid11GT) {
const int items = 3;
FfElementObj r(&this->epid11_GT);
FfElementObj ff_base[3];
BigNumObj bn_exp[3];
FfElement const* p[3];
BigNum const* b[3];
int m = 0;
// prepare data for test
for (m = 0; m < items; m++) {
ff_base[m] =
FfElementObj(&this->epid11_GT, this->epid11_GT_multi_exp_base_3[m]);
bn_exp[m] = BigNumObj(this->epid11_GT_multi_exp_exp_3[m]);
// initialize data for test
p[m] = ff_base[m];
b[m] = bn_exp[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfMultiExpBn(this->epid11_GT, p, b, items, r));
EXPECT_EQ(FfElementObj(&this->epid11_GT, this->epid11_GT_multi_exp_res_3), r)
<< "FfSscmMultiExp: Finite field element does not "
"match with reference value";
}
///////////////////////////////////////////////////////////////////////
// FfSscmMultiExp
TEST_F(FfElementTest, SscmFfMultiExpFailsGivenArgumentsMismatch) {
FfElement const* p[] = {this->fq_a, this->fq_b};
FfElement const* p12[] = {this->fq12_g, this->fq12_h};
BigNumStr const* b[] = {&this->bn_0_str, &this->bn_0_str};
EXPECT_EQ(kEpidBadArgErr,
FfSscmMultiExp(this->fq12, p, b, 2, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSscmMultiExp(this->fq, p12, b, 2, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSscmMultiExp(this->fq, p, b, 2, this->fq12_result));
}
TEST_F(FfElementTest, SscmFfMultiExpFailsGivenNullPointer) {
FfElement const* p[] = {this->fq_a, this->fq_b};
FfElement const* p_withnull[] = {nullptr, this->fq_b};
BigNumStr const* b[] = {&this->fq_multi_exp_exp_2[0],
&this->fq_multi_exp_exp_2[1]};
BigNumStr const* b_withnull[] = {nullptr, &this->fq_multi_exp_exp_2[1]};
size_t m = 2;
EXPECT_EQ(kEpidBadArgErr, FfSscmMultiExp(nullptr, p, b, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSscmMultiExp(this->fq, nullptr, b, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSscmMultiExp(this->fq, p, nullptr, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfSscmMultiExp(this->fq, p, b, m, nullptr));
EXPECT_EQ(kEpidBadArgErr,
FfSscmMultiExp(this->fq, p_withnull, b, m, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSscmMultiExp(this->fq, p, b_withnull, m, this->fq_result));
}
TEST_F(FfElementTest, SscmFfMultiExpFailsGivenIncorrectMLen) {
FfElement const* p[] = {this->fq_a, this->fq_b};
BigNumStr const* b[] = {&this->fq_multi_exp_exp_2[0],
&this->fq_multi_exp_exp_2[1]};
size_t len_greater_int_max = (size_t)INT_MAX + 1;
EXPECT_EQ(kEpidBadArgErr, FfSscmMultiExp(this->fq, p, b, 0, this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfSscmMultiExp(this->fq, p, b, std::numeric_limits<size_t>::max(),
this->fq_result));
EXPECT_EQ(kEpidBadArgErr, FfSscmMultiExp(this->fq, p, b, len_greater_int_max,
this->fq_result));
}
TEST_F(FfElementTest, SscmFfMultiExpWorksGivenOneExponent) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[1];
FfElement const* p[1];
BigNumStr const* b[1];
int m = 0;
// prepare data for test
for (m = 0; m < 1; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_1[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_1[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfSscmMultiExp(this->fq, p, b, 1, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_1), r)
<< "FfSscmMultiExp: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, SscmFfMultiExpWorksGivenTwoExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[2];
FfElement const* p[2];
BigNumStr const* b[2];
int m = 0;
// prepare data for test
for (m = 0; m < 2; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_2[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_2[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfSscmMultiExp(this->fq, p, b, 2, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_2), r)
<< "FfSscmMultiExp: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, SscmFfMultiExpWorksGivenThreeExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[3];
FfElement const* p[3];
BigNumStr const* b[3];
int m = 0;
// prepare data for test
for (m = 0; m < 3; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_3[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_3[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfSscmMultiExp(this->fq, p, b, 3, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_3), r)
<< "FfSscmMultiExp: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, SscmFfMultiExpWorksGivenFourExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[4];
FfElement const* p[4];
BigNumStr const* b[4];
int m = 0;
// prepare data for test
for (m = 0; m < 4; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_4[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_4[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfSscmMultiExp(this->fq, p, b, 4, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_4), r)
<< "FfSscmMultiExp: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, SscmFfMultiExpWorksGivenFourFq12Exponents) {
FfElementObj r12(&this->fq12);
FfElementObj fq12_exp[4];
FfElement const* p[4];
BigNumStr const* b[4];
int m = 0;
// prepare data for test
for (m = 0; m < 4; m++) {
fq12_exp[m] = FfElementObj(&this->fq12, this->fq12_multi_exp_base_4[m]);
// initialize data for test
p[m] = fq12_exp[m];
b[m] = &this->fq12_multi_exp_exp_4[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfSscmMultiExp(this->fq12, p, b, 4, r12));
EXPECT_EQ(FfElementObj(&this->fq12, this->fq12_multi_exp_res_4), r12)
<< "FfSscmMultiExp: Finite field element does not match with reference "
"value";
}
TEST_F(FfElementTest, SscmFfMultiExpWorksGivenFiveExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[5];
FfElement const* p[5];
BigNumStr const* b[5];
int m = 0;
// prepare data for test
for (m = 0; m < 5; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_5[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_5[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfSscmMultiExp(this->fq, p, b, 5, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_5), r)
<< "FfSscmMultiExp: Finite field element does not "
"match with reference value";
}
TEST_F(FfElementTest, SscmFfMultiExpWorksGivenSixExponents) {
FfElementObj r(&this->fq);
FfElementObj fq_exp[6];
FfElement const* p[6];
BigNumStr const* b[6];
int m = 0;
// prepare data for test
for (m = 0; m < 6; m++) {
fq_exp[m] = FfElementObj(&this->fq, this->fq_multi_exp_base_6[m]);
// initialize data for test
p[m] = fq_exp[m];
b[m] = &this->fq_multi_exp_exp_6[m];
}
// do test
EXPECT_EQ(kEpidNoErr, FfSscmMultiExp(this->fq, p, b, 6, r));
EXPECT_EQ(FfElementObj(&this->fq, this->fq_multi_exp_res_6), r)
<< "FfSscmMultiExp: Finite field element does not "
"match with reference value";
}
////////////////////////////////////////////////
// FfGetRandom
TEST_F(FfElementTest, FfGetRandomFailsGivenArgumentsMismatch) {
Prng my_prng;
EXPECT_EQ(kEpidBadArgErr,
FfGetRandom(this->fq12, &this->bn_1_str, &Prng::Generate, &my_prng,
this->fq_result));
EXPECT_EQ(kEpidBadArgErr,
FfGetRandom(this->fq, &this->bn_1_str, &Prng::Generate, &my_prng,
this->fq12_result));
}
TEST_F(FfElementTest, FfGetRandomFailsGivenNullPtr) {
Prng my_prng;
FfElementObj r(&this->fq);
EXPECT_EQ(kEpidBadArgErr, FfGetRandom(nullptr, &this->bn_1_str,
&Prng::Generate, &my_prng, r));
EXPECT_EQ(kEpidBadArgErr,
FfGetRandom(this->fq, nullptr, &Prng::Generate, &my_prng, r));
EXPECT_EQ(kEpidBadArgErr,
FfGetRandom(this->fq, &this->bn_1_str, nullptr, &my_prng, r));
EXPECT_EQ(kEpidBadArgErr, FfGetRandom(this->fq, &this->bn_1_str,
&Prng::Generate, &my_prng, nullptr));
}
TEST_F(FfElementTest, FfGetRandomSucceedsGivenFq2) {
Prng my_prng;
FfElementObj r(&this->fq2);
EXPECT_EQ(kEpidNoErr, FfGetRandom(this->fq2, &this->bn_1_str, &Prng::Generate,
&my_prng, r));
}
TEST_F(FfElementTest, FfGetRandomSucceedsGivenFq6) {
Prng my_prng;
FfElementObj r(&this->fq6);
EXPECT_EQ(kEpidNoErr, FfGetRandom(this->fq6, &this->bn_1_str, &Prng::Generate,
&my_prng, r));
}
TEST_F(FfElementTest, FfGetRandomSucceedsGivenFq12) {
Prng my_prng;
FfElementObj r(&this->fq12);
EXPECT_EQ(kEpidNoErr, FfGetRandom(this->fq12, &this->bn_1_str,
&Prng::Generate, &my_prng, r));
}
TEST_F(FfElementTest, FfGetRandomSuccedsGivenLowBound) {
Prng my_prng;
FfElementObj r(&this->fq);
FqElemStr buf;
unsigned int result;
EXPECT_EQ(kEpidNoErr, FfGetRandom(this->fq, &this->bn_1_str, &Prng::Generate,
&my_prng, r));
THROW_ON_EPIDERR(WriteFfElement(this->fq, r, &buf, sizeof(buf)));
THROW_ON_EPIDERR(Cmp_OctStr256(&this->bn_1_str.data, &buf.data, &result));
EXPECT_EQ(result, (unsigned int)2);
EXPECT_EQ(kEpidNoErr, FfGetRandom(this->fq, &this->bn_2_str, &Prng::Generate,
&my_prng, r));
THROW_ON_EPIDERR(WriteFfElement(this->fq, r, &buf, sizeof(buf)));
THROW_ON_EPIDERR(Cmp_OctStr256(&this->bn_2_str.data, &buf.data, &result));
EXPECT_EQ(result, (unsigned int)2);
EXPECT_EQ(kEpidNoErr, FfGetRandom(this->fq, &this->bn_0xffff_str,
&Prng::Generate, &my_prng, r));
THROW_ON_EPIDERR(WriteFfElement(this->fq, r, &buf, sizeof(buf)));
THROW_ON_EPIDERR(
Cmp_OctStr256(&this->bn_0xffff_str.data, &buf.data, &result));
EXPECT_EQ(result, (unsigned int)2);
EXPECT_EQ(kEpidNoErr, FfGetRandom(this->fq, &this->bn_0xffff_str,
&Prng::Generate, &my_prng, r));
THROW_ON_EPIDERR(WriteFfElement(this->fq, r, &buf, sizeof(buf)));
THROW_ON_EPIDERR(
Cmp_OctStr256(&this->bn_0xffff_str.data, &buf.data, &result));
EXPECT_EQ(result, (unsigned int)2);
}
TEST_F(FfElementTest, FfGetRandomGeneratesDifferentNumbers) {
Prng my_prng;
FfElementObj r1(&this->fq);
FfElementObj r2(&this->fq);
bool result;
EXPECT_EQ(kEpidNoErr, FfGetRandom(this->fq, &this->bn_1_str, &Prng::Generate,
&my_prng, r1));
EXPECT_EQ(kEpidNoErr, FfGetRandom(this->fq, &this->bn_1_str, &Prng::Generate,
&my_prng, r2));
THROW_ON_EPIDERR(FfIsEqual(this->fq, r1, r2, &result));
EXPECT_FALSE(result);
}
TEST_F(FfElementTest, FfGetRandomFailsOnMaxIterGivenLargeLowBound) {
Prng my_prng;
FfElementObj r(&this->fq);
// FfGetRandom generates random data between [low_bound, modulus-1]
// modulus in this case is Intel(R) EPID 2.0 parameter q
// giving low_bound = modulus - {0x30, 0x13} should get kEpidRandMaxIterErr
EXPECT_EQ(kEpidRandMaxIterErr, FfGetRandom(this->fq, &this->fq_qm0x3013_str,
&Prng::Generate, &my_prng, r));
}
////////////////////////////////////////////////
// FfSqrt
TEST_F(FfElementTest, FfSqrtFailsGivenNullPtr) {
FfElementObj r(&this->fq);
EXPECT_EQ(kEpidBadArgErr, FfSqrt(nullptr, this->fq_4, r));
EXPECT_EQ(kEpidBadArgErr, FfSqrt(this->fq, nullptr, r));
EXPECT_EQ(kEpidBadArgErr, FfSqrt(this->fq, this->fq_4, nullptr));
}
TEST_F(FfElementTest, FfSqrtWorksForOne) {
FfElementObj r(&this->fq);
FfElementObj s(&this->fq);
EXPECT_EQ(kEpidNoErr, FfSqrt(this->fq, this->fq_1, r));
EXPECT_EQ(this->fq_1, r);
}
TEST_F(FfElementTest, FfSqrtFailsForTwo) {
FfElementObj r(&this->fq);
EXPECT_EQ(kEpidMathQuadraticNonResidueError, FfSqrt(this->fq, this->fq_2, r));
}
TEST_F(FfElementTest, FfSqrtFailsForThree) {
FfElementObj r(&this->fq);
EXPECT_EQ(kEpidMathQuadraticNonResidueError, FfSqrt(this->fq, this->fq_3, r));
}
TEST_F(FfElementTest, FfSqrtWorksForFour) {
FfElementObj r(&this->fq);
EXPECT_EQ(kEpidNoErr, FfSqrt(this->fq, this->fq_4, r));
EXPECT_EQ(this->fq_qm2, r);
}
TEST_F(FfElementTest, FfSqrtFailsForFive) {
FfElementObj r(&this->fq);
EXPECT_EQ(kEpidMathQuadraticNonResidueError, FfSqrt(this->fq, this->fq_5, r));
}
TEST_F(FfElementTest, FfSqrtWorksForEpid11Prime) {
// given b_str value ensure sqrt algorithm step 7 if clause is triggered
const BigNumStr b_str = {0x06, 0xc1, 0x26, 0xe8, 0xa5, 0xa5, 0x21, 0x19,
0x07, 0x42, 0x49, 0x77, 0x7c, 0x5c, 0x98, 0x7f,
0xd4, 0x0c, 0x42, 0xf5, 0x25, 0x2c, 0xac, 0xb9,
0x7e, 0x09, 0x70, 0xf0, 0x84, 0x3b, 0x81, 0x46};
FfElementObj b(&this->epid11_fq, &b_str, sizeof((b_str)));
FfElementObj r(&this->epid11_fq);
FfElementObj s(&this->epid11_fq);
FfElementObj r2(&this->epid11_fq);
EXPECT_EQ(kEpidNoErr, FfMul(this->epid11_fq, b, b, s));
EXPECT_EQ(kEpidNoErr, FfSqrt(this->epid11_fq, s, r));
EXPECT_EQ(kEpidNoErr, FfMul(this->epid11_fq, r, r, r2));
EXPECT_EQ(s, r2);
}
TEST_F(FfElementTest, FfSqrtReturnsARoot) {
Prng my_prng;
FfElementObj r(&this->fq);
FfElementObj b(&this->fq);
FfElementObj s(&this->fq);
FfElementObj r2(&this->fq);
unsigned int i;
for (i = 0; i < 1000; i++) {
ASSERT_EQ(kEpidNoErr, FfGetRandom(this->fq, &this->bn_2_str,
&Prng::Generate, &my_prng, b));
ASSERT_EQ(kEpidNoErr, FfMul(this->fq, b, b, s));
ASSERT_EQ(kEpidNoErr, FfSqrt(this->fq, s, r));
ASSERT_EQ(kEpidNoErr, FfMul(this->fq, r, r, r2));
ASSERT_EQ(s, r2);
}
}
TEST_F(FfElementTest, FfSqrtReturnsARootInEpid11) {
Prng my_prng;
FfElementObj r(&this->epid11_fq);
FfElementObj b(&this->epid11_fq);
FfElementObj s(&this->epid11_fq);
FfElementObj r2(&this->epid11_fq);
unsigned int i;
for (i = 0; i < 1000; i++) {
ASSERT_EQ(kEpidNoErr, FfGetRandom(this->epid11_fq, &this->bn_2_str,
&Prng::Generate, &my_prng, b));
ASSERT_EQ(kEpidNoErr, FfMul(this->epid11_fq, b, b, s));
ASSERT_EQ(kEpidNoErr, FfSqrt(this->epid11_fq, s, r));
ASSERT_EQ(kEpidNoErr, FfMul(this->epid11_fq, r, r, r2));
ASSERT_EQ(s, r2);
}
}
TEST_F(FfElementTest, FfSqrtReturnsARoot224Prime) {
const BigNumStr prime_224r1 = {
0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
FiniteFieldObj f_q(prime_224r1);
Prng my_prng;
FfElementObj r(&f_q);
FfElementObj b(&f_q);
FfElementObj s(&f_q);
FfElementObj r2(&f_q);
unsigned int i;
for (i = 0; i < 100; i++) {
EXPECT_EQ(kEpidNoErr,
FfGetRandom(f_q, &this->bn_2_str, &Prng::Generate, &my_prng, b));
EXPECT_EQ(kEpidNoErr, FfMul(f_q, b, b, s));
EXPECT_EQ(kEpidNoErr, FfSqrt(f_q, s, r));
EXPECT_EQ(kEpidNoErr, FfMul(f_q, r, r, r2));
EXPECT_EQ(s, r2);
}
}
} // namespace