void Evaluator::preencrypt(const uint64_t *plain, int plain_coeff_count, int plain_coeff_uint64_count, uint64_t *destination)
{
// Extract encryption parameters.
int coeff_count = poly_modulus_.coeff_count();
int coeff_bit_count = poly_modulus_.coeff_bit_count();
int coeff_uint64_count = divide_round_up(coeff_bit_count, bits_per_uint64);
// Only care about coefficients up till coeff_count.
if (plain_coeff_count > coeff_count)
{
plain_coeff_count = coeff_count;
}
// Multiply plain by scalar coeff_div_plaintext and reposition if in upper-half.
if (plain == destination)
{
// If plain and destination are same poly, then need another storage for multiply output.
Pointer temp(allocate_uint(coeff_uint64_count, pool_));
for (int i = 0; i < plain_coeff_count; ++i)
{
multiply_uint_uint(plain, plain_coeff_uint64_count, coeff_div_plain_modulus_.pointer(), coeff_uint64_count, coeff_uint64_count, temp.get());
bool is_upper_half = is_greater_than_or_equal_uint_uint(temp.get(), upper_half_threshold_.pointer(), coeff_uint64_count);
if (is_upper_half)
{
add_uint_uint(temp.get(), upper_half_increment_.pointer(), coeff_uint64_count, destination);
}
else
{
set_uint_uint(temp.get(), coeff_uint64_count, destination);
}
plain += plain_coeff_uint64_count;
destination += coeff_uint64_count;
}
}
else
{
for (int i = 0; i < plain_coeff_count; ++i)
{
multiply_uint_uint(plain, plain_coeff_uint64_count, coeff_div_plain_modulus_.pointer(), coeff_uint64_count, coeff_uint64_count, destination);
bool is_upper_half = is_greater_than_or_equal_uint_uint(destination, upper_half_threshold_.pointer(), coeff_uint64_count);
if (is_upper_half)
{
add_uint_uint(destination, upper_half_increment_.pointer(), coeff_uint64_count, destination);
}
plain += plain_coeff_uint64_count;
destination += coeff_uint64_count;
}
}
// Zero any remaining coefficients.
for (int i = plain_coeff_count; i < coeff_count; ++i)
{
set_zero_uint(coeff_uint64_count, destination);
destination += coeff_uint64_count;
}
}
void poly_eval_poly(const uint64_t *poly_to_eval,
int poly_to_eval_coeff_count,
int poly_to_eval_coeff_uint64_count,
const uint64_t *value, int value_coeff_count,
int value_coeff_uint64_count, int result_coeff_count,
int result_coeff_uint64_count, uint64_t *result, MemoryPool &pool)
{
#ifdef SEAL_DEBUG
if (poly_to_eval == nullptr)
{
throw invalid_argument("poly_to_eval");
}
if (value == nullptr)
{
throw invalid_argument("value");
}
if (result == nullptr)
{
throw invalid_argument("result");
}
if (poly_to_eval_coeff_count <= 0)
{
throw invalid_argument("poly_to_eval_coeff_count");
}
if (poly_to_eval_coeff_uint64_count <= 0)
{
throw invalid_argument("poly_to_eval_coeff_uint64_count");
}
if (value_coeff_count <= 0)
{
throw invalid_argument("value_coeff_count");
}
if (value_coeff_uint64_count <= 0)
{
throw invalid_argument("value_coeff_uint64_count");
}
if (result_coeff_count <= 0)
{
throw invalid_argument("result_coeff_count");
}
if (result_coeff_uint64_count <= 0)
{
throw invalid_argument("result_coeff_uint64_count");
}
#endif
// Evaluate poly at value using Horner's method
Pointer temp1(allocate_poly(result_coeff_count, result_coeff_uint64_count, pool));
Pointer temp2(allocate_zero_poly(result_coeff_count, result_coeff_uint64_count, pool));
uint64_t *productptr = temp1.get();
uint64_t *intermediateptr = temp2.get();
for (int coeff_index = poly_to_eval_coeff_count - 1; coeff_index >= 0; coeff_index--)
{
multiply_poly_poly(intermediateptr, result_coeff_count, result_coeff_uint64_count, value, value_coeff_count, value_coeff_uint64_count, result_coeff_count, result_coeff_uint64_count, productptr, pool);
const uint64_t *curr_coeff = get_poly_coeff(poly_to_eval, coeff_index, poly_to_eval_coeff_uint64_count);
add_uint_uint(productptr, result_coeff_uint64_count, curr_coeff, poly_to_eval_coeff_uint64_count, false, result_coeff_uint64_count, productptr);
swap(productptr, intermediateptr);
}
set_poly_poly(intermediateptr, result_coeff_count, result_coeff_uint64_count, result);
}
ChooserPoly ChooserEvaluator::add_many(const std::vector<ChooserPoly> &operands)
{
if (operands.empty())
{
throw invalid_argument("operands vector can not be empty");
}
int sum_max_coeff_count = operands[0].max_coeff_count_;
vector<ChooserPoly>::size_type largest_abs_value_index = 0;
for (vector<ChooserPoly>::size_type i = 0; i < operands.size(); ++i)
{
// Throw if any of the operands is not initialized correctly
if (operands[i].max_coeff_count_ <= 0 || operands[i].comp_ == nullptr)
{
throw invalid_argument("input operand is not correctly initialized");
}
if (operands[i].max_coeff_count_ > sum_max_coeff_count)
{
sum_max_coeff_count = operands[i].max_coeff_count_;
}
if (compare_uint_uint(operands[i].max_abs_value_.pointer(), operands[i].max_abs_value_.uint64_count(), operands[largest_abs_value_index].max_abs_value_.pointer(), operands[largest_abs_value_index].max_abs_value_.uint64_count() > 0))
{
largest_abs_value_index = i;
}
}
int sum_max_abs_value_bit_count = operands[largest_abs_value_index].max_abs_value_.significant_bit_count() + get_significant_bit_count(operands.size());
int sum_max_abs_value_uint64_count = divide_round_up(sum_max_abs_value_bit_count, bits_per_uint64);
Pointer sum_max_abs_value(allocate_zero_uint(sum_max_abs_value_uint64_count, pool_));
vector<Computation*> comps;
for (vector<ChooserPoly>::size_type i = 0; i < operands.size(); ++i)
{
add_uint_uint(operands[i].max_abs_value_.pointer(), operands[i].max_abs_value_.uint64_count(), sum_max_abs_value.get(), sum_max_abs_value_uint64_count, false, sum_max_abs_value_uint64_count, sum_max_abs_value.get());
comps.push_back(operands[i].comp_);
}
return ChooserPoly(sum_max_coeff_count, BigUInt(sum_max_abs_value_bit_count, sum_max_abs_value.get()), new AddManyComputation(comps));
}
void multiply_poly_poly(const uint64_t *operand1,
int operand1_coeff_count, int operand1_coeff_uint64_count,
const uint64_t *operand2, int operand2_coeff_count,
int operand2_coeff_uint64_count, int result_coeff_count,
int result_coeff_uint64_count, uint64_t *result, MemoryPool &pool)
{
#ifdef SEAL_DEBUG
if (operand1 == nullptr && operand1_coeff_count > 0 &&
operand1_coeff_uint64_count > 0)
{
throw invalid_argument("operand1");
}
if (operand1_coeff_count < 0)
{
throw invalid_argument("operand1_coeff_count");
}
if (operand1_coeff_uint64_count < 0)
{
throw invalid_argument("operand1_coeff_uint64_count");
}
if (operand2 == nullptr && operand2_coeff_count > 0 &&
operand2_coeff_uint64_count > 0)
{
throw invalid_argument("operand2");
}
if (operand2_coeff_count < 0)
{
throw invalid_argument("operand2_coeff_count");
}
if (operand2_coeff_uint64_count < 0)
{
throw invalid_argument("operand2_coeff_uint64_count");
}
if (result_coeff_count < 0)
{
throw invalid_argument("result_coeff_count");
}
if (result_coeff_uint64_count < 0)
{
throw invalid_argument("result_coeff_uint64_count");
}
if (result == nullptr && result_coeff_count > 0 &&
result_coeff_uint64_count > 0)
{
throw invalid_argument("result");
}
if (result != nullptr &&
(operand1 == result || operand2 == result))
{
throw invalid_argument("result cannot point to the same value as operand1 or operand2");
}
#endif
Pointer intermediate(allocate_uint(result_coeff_uint64_count, pool));
// Clear product.
set_zero_poly(result_coeff_count, result_coeff_uint64_count, result);
operand1_coeff_count = get_significant_coeff_count_poly(
operand1, operand1_coeff_count, operand1_coeff_uint64_count);
operand2_coeff_count = get_significant_coeff_count_poly(
operand2, operand2_coeff_count, operand2_coeff_uint64_count);
for (int operand1_index = 0; operand1_index < operand1_coeff_count; operand1_index++)
{
const uint64_t *operand1_coeff = get_poly_coeff(
operand1, operand1_index, operand1_coeff_uint64_count);
for (int operand2_index = 0; operand2_index < operand2_coeff_count; operand2_index++)
{
int product_coeff_index = operand1_index + operand2_index;
if (product_coeff_index >= result_coeff_count)
{
break;
}
const uint64_t *operand2_coeff = get_poly_coeff(
operand2, operand2_index, operand2_coeff_uint64_count);
multiply_uint_uint(operand1_coeff, operand1_coeff_uint64_count,
operand2_coeff, operand2_coeff_uint64_count, result_coeff_uint64_count, intermediate.get());
uint64_t *result_coeff = get_poly_coeff(
result, product_coeff_index, result_coeff_uint64_count);
add_uint_uint(result_coeff, intermediate.get(), result_coeff_uint64_count, result_coeff);
}
}
}
void Evaluator::multiply(const uint64_t *encrypted1, const uint64_t *encrypted2, uint64_t *destination)
{
// Extract encryption parameters.
int coeff_count = poly_modulus_.coeff_count();
int coeff_bit_count = poly_modulus_.coeff_bit_count();
int coeff_uint64_count = divide_round_up(coeff_bit_count, bits_per_uint64);
// Clear destatintion.
set_zero_poly(coeff_count, coeff_uint64_count, destination);
// Determine if FFT can be used.
bool use_fft = polymod_.coeff_count_power_of_two() >= 0 && polymod_.is_one_zero_one();
if (use_fft)
{
// Use FFT to multiply polynomials.
// Allocate polynomial to store product of two polynomials, with poly but no coeff modulo yet (and signed).
int product_coeff_bit_count = coeff_bit_count + coeff_bit_count + get_significant_bit_count(static_cast<uint64_t>(coeff_count)) + 2;
int product_coeff_uint64_count = divide_round_up(product_coeff_bit_count, bits_per_uint64);
Pointer product(allocate_poly(coeff_count, product_coeff_uint64_count, pool_));
// Use FFT to multiply polynomials.
set_zero_uint(product_coeff_uint64_count, get_poly_coeff(product.get(), coeff_count - 1, product_coeff_uint64_count));
fftmultiply_poly_poly_polymod(encrypted1, encrypted2, polymod_.coeff_count_power_of_two(), coeff_uint64_count, product_coeff_uint64_count, product.get(), pool_);
// For each coefficient in product, multiply by plain_modulus and divide by coeff_modulus and then modulo by coeff_modulus.
int plain_modulus_bit_count = plain_modulus_.significant_bit_count();
int plain_modulus_uint64_count = divide_round_up(plain_modulus_bit_count, bits_per_uint64);
int intermediate_bit_count = product_coeff_bit_count + plain_modulus_bit_count - 1;
int intermediate_uint64_count = divide_round_up(intermediate_bit_count, bits_per_uint64);
Pointer intermediate(allocate_uint(intermediate_uint64_count, pool_));
Pointer quotient(allocate_uint(intermediate_uint64_count, pool_));
for (int coeff_index = 0; coeff_index < coeff_count; ++coeff_index)
{
uint64_t *product_coeff = get_poly_coeff(product.get(), coeff_index, product_coeff_uint64_count);
bool coeff_is_negative = is_high_bit_set_uint(product_coeff, product_coeff_uint64_count);
if (coeff_is_negative)
{
negate_uint(product_coeff, product_coeff_uint64_count, product_coeff);
}
multiply_uint_uint(product_coeff, product_coeff_uint64_count, plain_modulus_.pointer(), plain_modulus_uint64_count, intermediate_uint64_count, intermediate.get());
add_uint_uint(intermediate.get(), wide_coeff_modulus_div_two_.pointer(), intermediate_uint64_count, intermediate.get());
divide_uint_uint_inplace(intermediate.get(), wide_coeff_modulus_.pointer(), intermediate_uint64_count, quotient.get(), pool_);
modulo_uint_inplace(quotient.get(), intermediate_uint64_count, mod_, pool_);
uint64_t *dest_coeff = get_poly_coeff(destination, coeff_index, coeff_uint64_count);
if (coeff_is_negative)
{
negate_uint_mod(quotient.get(), coeff_modulus_.pointer(), coeff_uint64_count, dest_coeff);
}
else
{
set_uint_uint(quotient.get(), coeff_uint64_count, dest_coeff);
}
}
}
else
{
// Use normal multiplication to multiply polynomials.
// Allocate polynomial to store product of two polynomials, with no poly or coeff modulo yet.
int product_coeff_count = coeff_count + coeff_count - 1;
int product_coeff_bit_count = coeff_bit_count + coeff_bit_count + get_significant_bit_count(static_cast<uint64_t>(coeff_count));
int product_coeff_uint64_count = divide_round_up(product_coeff_bit_count, bits_per_uint64);
Pointer product(allocate_poly(product_coeff_count, product_coeff_uint64_count, pool_));
// Multiply polynomials.
multiply_poly_poly(encrypted1, coeff_count, coeff_uint64_count, encrypted2, coeff_count, coeff_uint64_count, product_coeff_count, product_coeff_uint64_count, product.get(), pool_);
// For each coefficient in product, multiply by plain_modulus and divide by coeff_modulus and then modulo by coeff_modulus.
int plain_modulus_bit_count = plain_modulus_.significant_bit_count();
int plain_modulus_uint64_count = divide_round_up(plain_modulus_bit_count, bits_per_uint64);
int intermediate_bit_count = product_coeff_bit_count + plain_modulus_bit_count;
int intermediate_uint64_count = divide_round_up(intermediate_bit_count, bits_per_uint64);
Pointer intermediate(allocate_uint(intermediate_uint64_count, pool_));
Pointer quotient(allocate_uint(intermediate_uint64_count, pool_));
Pointer productmoded(allocate_poly(product_coeff_count, coeff_uint64_count, pool_));
for (int coeff_index = 0; coeff_index < product_coeff_count; ++coeff_index)
{
const uint64_t *product_coeff = get_poly_coeff(product.get(), coeff_index, product_coeff_uint64_count);
multiply_uint_uint(product_coeff, product_coeff_uint64_count, plain_modulus_.pointer(), plain_modulus_uint64_count, intermediate_uint64_count, intermediate.get());
add_uint_uint(intermediate.get(), wide_coeff_modulus_div_two_.pointer(), intermediate_uint64_count, intermediate.get());
divide_uint_uint_inplace(intermediate.get(), wide_coeff_modulus_.pointer(), intermediate_uint64_count, quotient.get(), pool_);
modulo_uint_inplace(quotient.get(), intermediate_uint64_count, mod_, pool_);
uint64_t *productmoded_coeff = get_poly_coeff(productmoded.get(), coeff_index, coeff_uint64_count);
set_uint_uint(quotient.get(), coeff_uint64_count, productmoded_coeff);
}
// Perform polynomial modulo.
modulo_poly_inplace(productmoded.get(), product_coeff_count, polymod_, mod_, pool_);
// Copy to destination.
set_poly_poly(productmoded.get(), coeff_count, coeff_uint64_count, destination);
}
}
void Evaluator::multiply_plain(const BigPoly &encrypted1, const BigPoly &plain2, BigPoly &destination)
{
// Extract encryption parameters.
int coeff_count = poly_modulus_.coeff_count();
int coeff_bit_count = poly_modulus_.coeff_bit_count();
int coeff_uint64_count = divide_round_up(coeff_bit_count, bits_per_uint64);
// Verify parameters.
if (encrypted1.coeff_count() != coeff_count || encrypted1.coeff_bit_count() != coeff_bit_count)
{
throw invalid_argument("encrypted1 is not valid for encryption parameters");
}
#ifdef _DEBUG
if (encrypted1.significant_coeff_count() == coeff_count || !are_poly_coefficients_less_than(encrypted1, coeff_modulus_))
{
throw invalid_argument("encrypted1 is not valid for encryption parameters");
}
if (plain2.significant_coeff_count() >= coeff_count || !are_poly_coefficients_less_than(plain2, plain_modulus_))
{
throw invalid_argument("plain2 is too large to be represented by encryption parameters");
}
#endif
if (destination.coeff_count() != coeff_count || destination.coeff_bit_count() != coeff_bit_count)
{
destination.resize(coeff_count, coeff_bit_count);
}
// Get pointer to inputs (duplicated if needed).
ConstPointer encrypted1ptr = duplicate_poly_if_needed(encrypted1, encrypted1.pointer() == destination.pointer(), pool_);
// Handle test-mode case.
if (mode_ == TEST_MODE)
{
// Get pointer to inputs (duplicated and resized if needed).
ConstPointer plain2ptr = duplicate_poly_if_needed(plain2, coeff_count, coeff_uint64_count, plain2.pointer() == destination.pointer(), pool_);
// Resize second operand if needed.
multiply_poly_poly_polymod_coeffmod(encrypted1ptr.get(), plain2ptr.get(), polymod_, mod_, destination.pointer(), pool_);
return;
}
// Reposition coefficients.
Pointer moved2ptr(allocate_poly(coeff_count, coeff_uint64_count, pool_));
int plain_coeff_count = min(plain2.significant_coeff_count(), coeff_count);
int plain2_coeff_uint64_count = plain2.coeff_uint64_count();
const uint64_t *plain2_coeff = plain2.pointer();
uint64_t *moved2_coeff = moved2ptr.get();
for (int i = 0; i < plain_coeff_count; ++i)
{
set_uint_uint(plain2_coeff, plain2_coeff_uint64_count, coeff_uint64_count, moved2_coeff);
bool is_upper_half = is_greater_than_or_equal_uint_uint(moved2_coeff, plain_upper_half_threshold_.pointer(), coeff_uint64_count);
if (is_upper_half)
{
add_uint_uint(moved2_coeff, plain_upper_half_increment_.pointer(), coeff_uint64_count, moved2_coeff);
}
moved2_coeff += coeff_uint64_count;
plain2_coeff += plain2_coeff_uint64_count;
}
for (int i = plain_coeff_count; i < coeff_count; ++i)
{
set_zero_uint(coeff_uint64_count, moved2_coeff);
moved2_coeff += coeff_uint64_count;
}
// Use normal polynomial multiplication.
multiply_poly_poly_polymod_coeffmod(encrypted1ptr.get(), moved2ptr.get(), polymod_, mod_, destination.pointer(), pool_);
}
