mirror of
https://github.com/zama-ai/concrete.git
synced 2026-02-09 12:15:09 -05:00
refactor: Integrate concrete-cpu and remove concrete-core
Co-authored-by: Mayeul@Zama <mayeul.debellabre@zama.ai>
This commit is contained in:
Quentin Bourgerie
@@ -6,269 +6,142 @@
|
||||
#include "concretelang/ClientLib/KeySet.h"
|
||||
#include "concretelang/ClientLib/CRT.h"
|
||||
#include "concretelang/Common/Error.h"
|
||||
#include "concretelang/Runtime/seeder.h"
|
||||
#include "concretelang/Support/Error.h"
|
||||
|
||||
#define CAPI_ERR_TO_STRINGERROR(instr, msg) \
|
||||
{ \
|
||||
int err; \
|
||||
instr; \
|
||||
if (err != 0) { \
|
||||
return concretelang::error::StringError(msg); \
|
||||
} \
|
||||
}
|
||||
|
||||
int clone_transform_lwe_secret_key_to_glwe_secret_key_u64(
|
||||
DefaultEngine *default_engine, LweSecretKey64 *output_lwe_sk,
|
||||
size_t poly_size, GlweSecretKey64 **output_glwe_sk) {
|
||||
LweSecretKey64 *output_lwe_sk_clone = NULL;
|
||||
int lwe_out_sk_clone_ok =
|
||||
clone_lwe_secret_key_u64(output_lwe_sk, &output_lwe_sk_clone);
|
||||
if (lwe_out_sk_clone_ok != 0) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
int glwe_sk_ok =
|
||||
default_engine_transform_lwe_secret_key_to_glwe_secret_key_u64(
|
||||
default_engine, &output_lwe_sk_clone, poly_size, output_glwe_sk);
|
||||
if (glwe_sk_ok != 0) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (output_lwe_sk_clone != NULL) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
namespace concretelang {
|
||||
namespace clientlib {
|
||||
|
||||
KeySet::KeySet() {
|
||||
|
||||
CAPI_ASSERT_ERROR(new_default_engine(best_seeder, &engine));
|
||||
|
||||
CAPI_ASSERT_ERROR(new_default_parallel_engine(best_seeder, &par_engine));
|
||||
}
|
||||
|
||||
KeySet::~KeySet() {
|
||||
for (auto it : secretKeys) {
|
||||
CAPI_ASSERT_ERROR(destroy_lwe_secret_key_u64(it.second.second));
|
||||
}
|
||||
|
||||
CAPI_ASSERT_ERROR(destroy_default_engine(engine));
|
||||
CAPI_ASSERT_ERROR(destroy_default_parallel_engine(par_engine));
|
||||
}
|
||||
|
||||
outcome::checked<std::unique_ptr<KeySet>, StringError>
|
||||
KeySet::generate(ClientParameters ¶ms, uint64_t seed_msb,
|
||||
uint64_t seed_lsb) {
|
||||
auto keySet = std::make_unique<KeySet>();
|
||||
OUTCOME_TRYV(keySet->generateKeysFromParams(params, seed_msb, seed_lsb));
|
||||
OUTCOME_TRYV(keySet->setupEncryptionMaterial(params, seed_msb, seed_lsb));
|
||||
KeySet::generate(ClientParameters clientParameters, CSPRNG &&csprng) {
|
||||
auto keySet = std::make_unique<KeySet>(clientParameters, std::move(csprng));
|
||||
OUTCOME_TRYV(keySet->generateKeysFromParams());
|
||||
OUTCOME_TRYV(keySet->setupEncryptionMaterial());
|
||||
return std::move(keySet);
|
||||
}
|
||||
|
||||
outcome::checked<void, StringError>
|
||||
KeySet::setupEncryptionMaterial(ClientParameters ¶ms, uint64_t seed_msb,
|
||||
uint64_t seed_lsb) {
|
||||
_clientParameters = params;
|
||||
outcome::checked<std::unique_ptr<KeySet>, StringError> KeySet::fromKeys(
|
||||
ClientParameters clientParameters, std::vector<LweSecretKey> secretKeys,
|
||||
std::vector<LweBootstrapKey> bootstrapKeys,
|
||||
std::vector<LweKeyswitchKey> keyswitchKeys,
|
||||
std::vector<PackingKeyswitchKey> packingKeyswitchKeys, CSPRNG &&csprng) {
|
||||
|
||||
// Set inputs and outputs LWE secret keys
|
||||
{
|
||||
for (auto param : params.inputs) {
|
||||
LweSecretKeyParam secretKeyParam = {0};
|
||||
LweSecretKey64 *secretKey = nullptr;
|
||||
if (param.encryption.hasValue()) {
|
||||
auto inputSk = this->secretKeys.find(param.encryption->secretKeyID);
|
||||
if (inputSk == this->secretKeys.end()) {
|
||||
return StringError("input encryption secret key (")
|
||||
<< param.encryption->secretKeyID << ") does not exist ";
|
||||
}
|
||||
secretKeyParam = inputSk->second.first;
|
||||
secretKey = inputSk->second.second;
|
||||
}
|
||||
std::tuple<CircuitGate, LweSecretKeyParam, LweSecretKey64 *> input = {
|
||||
param, secretKeyParam, secretKey};
|
||||
this->inputs.push_back(input);
|
||||
}
|
||||
for (auto param : params.outputs) {
|
||||
LweSecretKeyParam secretKeyParam = {0};
|
||||
LweSecretKey64 *secretKey = nullptr;
|
||||
if (param.encryption.hasValue()) {
|
||||
auto outputSk = this->secretKeys.find(param.encryption->secretKeyID);
|
||||
if (outputSk == this->secretKeys.end()) {
|
||||
return StringError(
|
||||
"cannot find output key to generate bootstrap key");
|
||||
}
|
||||
secretKeyParam = outputSk->second.first;
|
||||
secretKey = outputSk->second.second;
|
||||
}
|
||||
std::tuple<CircuitGate, LweSecretKeyParam, LweSecretKey64 *> output = {
|
||||
param, secretKeyParam, secretKey};
|
||||
this->outputs.push_back(output);
|
||||
auto keySet = std::make_unique<KeySet>(clientParameters, std::move(csprng));
|
||||
keySet->secretKeys = secretKeys;
|
||||
keySet->bootstrapKeys = bootstrapKeys;
|
||||
keySet->keyswitchKeys = keyswitchKeys;
|
||||
keySet->packingKeyswitchKeys = packingKeyswitchKeys;
|
||||
OUTCOME_TRYV(keySet->setupEncryptionMaterial());
|
||||
return std::move(keySet);
|
||||
}
|
||||
|
||||
EvaluationKeys KeySet::evaluationKeys() {
|
||||
return EvaluationKeys(keyswitchKeys, bootstrapKeys, packingKeyswitchKeys);
|
||||
}
|
||||
|
||||
outcome::checked<KeySet::SecretKeyGateMapping, StringError>
|
||||
KeySet::mapCircuitGateLweSecretKey(std::vector<CircuitGate> gates) {
|
||||
SecretKeyGateMapping mapping;
|
||||
for (auto gate : gates) {
|
||||
if (gate.encryption.hasValue()) {
|
||||
assert(gate.encryption->secretKeyID < this->secretKeys.size());
|
||||
auto skIt = this->secretKeys[gate.encryption->secretKeyID];
|
||||
|
||||
std::pair<CircuitGate, llvm::Optional<LweSecretKey>> input = {gate, skIt};
|
||||
mapping.push_back(input);
|
||||
} else {
|
||||
std::pair<CircuitGate, llvm::Optional<LweSecretKey>> input = {gate,
|
||||
llvm::None};
|
||||
mapping.push_back(input);
|
||||
}
|
||||
}
|
||||
return mapping;
|
||||
}
|
||||
|
||||
outcome::checked<void, StringError> KeySet::setupEncryptionMaterial() {
|
||||
OUTCOME_TRY(this->inputs,
|
||||
mapCircuitGateLweSecretKey(_clientParameters.inputs));
|
||||
OUTCOME_TRY(this->outputs,
|
||||
mapCircuitGateLweSecretKey(_clientParameters.outputs));
|
||||
return outcome::success();
|
||||
}
|
||||
|
||||
outcome::checked<void, StringError>
|
||||
KeySet::generateKeysFromParams(ClientParameters ¶ms, uint64_t seed_msb,
|
||||
uint64_t seed_lsb) {
|
||||
outcome::checked<void, StringError> KeySet::generateKeysFromParams() {
|
||||
|
||||
{
|
||||
// Generate LWE secret keys
|
||||
for (auto secretKeyParam : params.secretKeys) {
|
||||
OUTCOME_TRYV(
|
||||
this->generateSecretKey(secretKeyParam.first, secretKeyParam.second));
|
||||
}
|
||||
// Generate LWE secret keys
|
||||
for (auto secretKeyParam : _clientParameters.secretKeys) {
|
||||
OUTCOME_TRYV(this->generateSecretKey(secretKeyParam));
|
||||
}
|
||||
// Generate bootstrap, keyswitch and packing keyswitch keys
|
||||
{
|
||||
for (auto bootstrapKeyParam : params.bootstrapKeys) {
|
||||
OUTCOME_TRYV(this->generateBootstrapKey(bootstrapKeyParam.first,
|
||||
bootstrapKeyParam.second));
|
||||
}
|
||||
for (auto keyswitchParam : params.keyswitchKeys) {
|
||||
OUTCOME_TRYV(this->generateKeyswitchKey(keyswitchParam.first,
|
||||
keyswitchParam.second));
|
||||
}
|
||||
for (auto packingParam : params.packingKeys) {
|
||||
OUTCOME_TRYV(
|
||||
this->generatePackingKey(packingParam.first, packingParam.second));
|
||||
}
|
||||
// Generate bootstrap keys
|
||||
for (auto bootstrapKeyParam : _clientParameters.bootstrapKeys) {
|
||||
OUTCOME_TRYV(this->generateBootstrapKey(bootstrapKeyParam));
|
||||
}
|
||||
// Generate keyswitch key
|
||||
for (auto keyswitchParam : _clientParameters.keyswitchKeys) {
|
||||
OUTCOME_TRYV(this->generateKeyswitchKey(keyswitchParam));
|
||||
}
|
||||
// Generate packing keyswitch key
|
||||
for (auto packingKeyswitchKeyParam : _clientParameters.packingKeyswitchKeys) {
|
||||
OUTCOME_TRYV(this->generatePackingKeyswitchKey(packingKeyswitchKeyParam));
|
||||
}
|
||||
return outcome::success();
|
||||
}
|
||||
|
||||
void KeySet::setKeys(
|
||||
std::map<LweSecretKeyID, std::pair<LweSecretKeyParam, LweSecretKey64 *>>
|
||||
secretKeys,
|
||||
std::map<LweSecretKeyID,
|
||||
std::pair<BootstrapKeyParam, std::shared_ptr<LweBootstrapKey>>>
|
||||
bootstrapKeys,
|
||||
std::map<LweSecretKeyID,
|
||||
std::pair<KeyswitchKeyParam, std::shared_ptr<LweKeyswitchKey>>>
|
||||
keyswitchKeys,
|
||||
std::map<LweSecretKeyID, std::pair<PackingKeySwitchParam,
|
||||
std::shared_ptr<PackingKeyswitchKey>>>
|
||||
packingKeys) {
|
||||
this->secretKeys = secretKeys;
|
||||
this->bootstrapKeys = bootstrapKeys;
|
||||
this->keyswitchKeys = keyswitchKeys;
|
||||
this->packingKeys = packingKeys;
|
||||
}
|
||||
|
||||
outcome::checked<void, StringError>
|
||||
KeySet::generateSecretKey(LweSecretKeyID id, LweSecretKeyParam param) {
|
||||
LweSecretKey64 *sk;
|
||||
CAPI_ASSERT_ERROR(default_engine_generate_new_lwe_secret_key_u64(
|
||||
engine, param.dimension, &sk));
|
||||
|
||||
secretKeys[id] = {param, sk};
|
||||
|
||||
KeySet::generateSecretKey(LweSecretKeyParam param) {
|
||||
// Init the lwe secret key
|
||||
LweSecretKey sk(param, csprng);
|
||||
// Store the lwe secret key
|
||||
secretKeys.push_back(sk);
|
||||
return outcome::success();
|
||||
}
|
||||
|
||||
outcome::checked<LweSecretKey, StringError>
|
||||
KeySet::findLweSecretKey(LweSecretKeyID keyID) {
|
||||
assert(keyID < secretKeys.size());
|
||||
auto secretKey = secretKeys[keyID];
|
||||
|
||||
return secretKey;
|
||||
}
|
||||
|
||||
outcome::checked<void, StringError>
|
||||
KeySet::generateBootstrapKey(BootstrapKeyID id, BootstrapKeyParam param) {
|
||||
KeySet::generateBootstrapKey(BootstrapKeyParam param) {
|
||||
// Finding input and output secretKeys
|
||||
auto inputSk = secretKeys.find(param.inputSecretKeyID);
|
||||
if (inputSk == secretKeys.end()) {
|
||||
return StringError("cannot find input key to generate bootstrap key");
|
||||
}
|
||||
auto outputSk = secretKeys.find(param.outputSecretKeyID);
|
||||
if (outputSk == secretKeys.end()) {
|
||||
return StringError("cannot find output key to generate bootstrap key");
|
||||
}
|
||||
// Allocate the bootstrap key
|
||||
LweBootstrapKey64 *bsk;
|
||||
|
||||
uint64_t total_dimension = outputSk->second.first.dimension;
|
||||
|
||||
assert(total_dimension % param.glweDimension == 0);
|
||||
|
||||
uint64_t polynomialSize = total_dimension / param.glweDimension;
|
||||
|
||||
GlweSecretKey64 *output_glwe_sk = nullptr;
|
||||
|
||||
// This is not part of the C FFI but rather is a C util exposed for
|
||||
// convenience in tests.
|
||||
CAPI_ASSERT_ERROR(clone_transform_lwe_secret_key_to_glwe_secret_key_u64(
|
||||
engine, outputSk->second.second, polynomialSize, &output_glwe_sk));
|
||||
|
||||
CAPI_ASSERT_ERROR(default_parallel_engine_generate_new_lwe_bootstrap_key_u64(
|
||||
par_engine, inputSk->second.second, output_glwe_sk, param.baseLog,
|
||||
param.level, param.variance, &bsk));
|
||||
|
||||
CAPI_ASSERT_ERROR(destroy_glwe_secret_key_u64(output_glwe_sk));
|
||||
|
||||
OUTCOME_TRY(auto inputKey, findLweSecretKey(param.inputSecretKeyID));
|
||||
OUTCOME_TRY(auto outputKey, findLweSecretKey(param.outputSecretKeyID));
|
||||
// Initialize the bootstrap key
|
||||
LweBootstrapKey bootstrapKey(param, inputKey, outputKey, csprng);
|
||||
// Store the bootstrap key
|
||||
bootstrapKeys[id] = {param, std::make_shared<LweBootstrapKey>(bsk)};
|
||||
|
||||
bootstrapKeys.push_back(std::move(bootstrapKey));
|
||||
return outcome::success();
|
||||
}
|
||||
|
||||
outcome::checked<void, StringError>
|
||||
KeySet::generateKeyswitchKey(KeyswitchKeyID id, KeyswitchKeyParam param) {
|
||||
KeySet::generateKeyswitchKey(KeyswitchKeyParam param) {
|
||||
// Finding input and output secretKeys
|
||||
auto inputSk = secretKeys.find(param.inputSecretKeyID);
|
||||
if (inputSk == secretKeys.end()) {
|
||||
return StringError("cannot find input key to generate keyswitch key");
|
||||
}
|
||||
auto outputSk = secretKeys.find(param.outputSecretKeyID);
|
||||
if (outputSk == secretKeys.end()) {
|
||||
return StringError("cannot find output key to generate keyswitch key");
|
||||
}
|
||||
// Allocate the keyswitch key
|
||||
LweKeyswitchKey64 *ksk;
|
||||
|
||||
CAPI_ASSERT_ERROR(default_engine_generate_new_lwe_keyswitch_key_u64(
|
||||
engine, inputSk->second.second, outputSk->second.second, param.level,
|
||||
param.baseLog, param.variance, &ksk));
|
||||
|
||||
OUTCOME_TRY(auto inputKey, findLweSecretKey(param.inputSecretKeyID));
|
||||
OUTCOME_TRY(auto outputKey, findLweSecretKey(param.outputSecretKeyID));
|
||||
// Initialize the bootstrap key
|
||||
LweKeyswitchKey keyswitchKey(param, inputKey, outputKey, csprng);
|
||||
// Store the keyswitch key
|
||||
keyswitchKeys[id] = {param, std::make_shared<LweKeyswitchKey>(ksk)};
|
||||
|
||||
keyswitchKeys.push_back(keyswitchKey);
|
||||
return outcome::success();
|
||||
}
|
||||
|
||||
outcome::checked<void, StringError>
|
||||
KeySet::generatePackingKey(PackingKeySwitchID id, PackingKeySwitchParam param) {
|
||||
KeySet::generatePackingKeyswitchKey(PackingKeyswitchKeyParam param) {
|
||||
// Finding input secretKeys
|
||||
auto inputSk = secretKeys.find(param.inputSecretKeyID);
|
||||
if (inputSk == secretKeys.end()) {
|
||||
return StringError(
|
||||
"cannot find input key to generate packing keyswitch key");
|
||||
}
|
||||
auto bsk = bootstrapKeys.find(param.bootstrapKeyID);
|
||||
if (bsk == bootstrapKeys.end()) {
|
||||
return StringError(
|
||||
"cannot find input key to generate packing keyswitch key");
|
||||
}
|
||||
assert(param.inputSecretKeyID < secretKeys.size());
|
||||
auto inputSk = secretKeys[param.inputSecretKeyID];
|
||||
|
||||
// This is not part of the C FFI but rather is a C util exposed for
|
||||
// convenience in tests.
|
||||
GlweSecretKey64 *output_glwe_sk = nullptr;
|
||||
|
||||
auto lweDimension =
|
||||
inputSk->second.first.lweDimension() / bsk->second.first.glweDimension;
|
||||
|
||||
CAPI_ASSERT_ERROR(clone_transform_lwe_secret_key_to_glwe_secret_key_u64(
|
||||
engine, inputSk->second.second, lweDimension, &output_glwe_sk));
|
||||
|
||||
// Allocate the packing keyswitch key
|
||||
LweCircuitBootstrapPrivateFunctionalPackingKeyswitchKeys64 *fpksk;
|
||||
CAPI_ASSERT_ERROR(
|
||||
default_parallel_engine_generate_new_lwe_circuit_bootstrap_private_functional_packing_keyswitch_keys_unchecked_u64(
|
||||
par_engine, inputSk->second.second, output_glwe_sk, param.baseLog,
|
||||
param.level, param.variance, &fpksk));
|
||||
assert(param.outputSecretKeyID < secretKeys.size());
|
||||
auto outputSk = secretKeys[param.outputSecretKeyID];
|
||||
|
||||
PackingKeyswitchKey packingKeyswitchKey(param, inputSk, outputSk, csprng);
|
||||
// Store the keyswitch key
|
||||
packingKeys[id] = {param, std::make_shared<PackingKeyswitchKey>(fpksk)};
|
||||
|
||||
packingKeyswitchKeys.push_back(packingKeyswitchKey);
|
||||
return outcome::success();
|
||||
}
|
||||
|
||||
@@ -285,8 +158,9 @@ KeySet::allocate_lwe(size_t argPos, uint64_t **ciphertext, uint64_t &size) {
|
||||
}
|
||||
auto numBlocks =
|
||||
encryption->encoding.crt.empty() ? 1 : encryption->encoding.crt.size();
|
||||
assert(inputSk.second.has_value());
|
||||
|
||||
size = std::get<1>(inputSk).lweSize();
|
||||
size = inputSk.second->parameters().lweSize();
|
||||
*ciphertext = (uint64_t *)malloc(sizeof(uint64_t) * size * numBlocks);
|
||||
return outcome::success();
|
||||
}
|
||||
@@ -315,8 +189,9 @@ KeySet::encrypt_lwe(size_t argPos, uint64_t *ciphertext, uint64_t input) {
|
||||
return StringError("encrypt_lwe the positional argument is not encrypted");
|
||||
}
|
||||
auto encoding = encryption->encoding;
|
||||
auto lweSecretKeyParam = std::get<1>(inputSk);
|
||||
auto lweSecretKey = std::get<2>(inputSk);
|
||||
assert(inputSk.second.has_value());
|
||||
auto lweSecretKey = *inputSk.second;
|
||||
auto lweSecretKeyParam = lweSecretKey.parameters();
|
||||
// CRT encoding - N blocks with crt encoding
|
||||
auto crt = encryption->encoding.crt;
|
||||
if (!crt.empty()) {
|
||||
@@ -324,11 +199,7 @@ KeySet::encrypt_lwe(size_t argPos, uint64_t *ciphertext, uint64_t input) {
|
||||
auto product = crt::productOfModuli(crt);
|
||||
for (auto modulus : crt) {
|
||||
auto plaintext = crt::encode(input, modulus, product);
|
||||
CAPI_ASSERT_ERROR(
|
||||
default_engine_discard_encrypt_lwe_ciphertext_u64_raw_ptr_buffers(
|
||||
engine, lweSecretKey, ciphertext, plaintext,
|
||||
encryption->variance));
|
||||
|
||||
lweSecretKey.encrypt(ciphertext, plaintext, encryption->variance, csprng);
|
||||
ciphertext = ciphertext + lweSecretKeyParam.lweSize();
|
||||
}
|
||||
return outcome::success();
|
||||
@@ -336,10 +207,7 @@ KeySet::encrypt_lwe(size_t argPos, uint64_t *ciphertext, uint64_t input) {
|
||||
// Simple TFHE integers - 1 blocks with one padding bits
|
||||
// TODO we could check if the input value is in the right range
|
||||
uint64_t plaintext = input << (64 - (encryption->encoding.precision + 1));
|
||||
CAPI_ASSERT_ERROR(
|
||||
default_engine_discard_encrypt_lwe_ciphertext_u64_raw_ptr_buffers(
|
||||
engine, lweSecretKey, ciphertext, plaintext, encryption->variance));
|
||||
|
||||
lweSecretKey.encrypt(ciphertext, plaintext, encryption->variance, csprng);
|
||||
return outcome::success();
|
||||
}
|
||||
|
||||
@@ -349,8 +217,9 @@ KeySet::decrypt_lwe(size_t argPos, uint64_t *ciphertext, uint64_t &output) {
|
||||
return StringError("decrypt_lwe: position of argument is too high");
|
||||
}
|
||||
auto outputSk = outputs[argPos];
|
||||
auto lweSecretKey = std::get<2>(outputSk);
|
||||
auto lweSecretKeyParam = std::get<1>(outputSk);
|
||||
assert(outputSk.second.has_value());
|
||||
auto lweSecretKey = *outputSk.second;
|
||||
auto lweSecretKeyParam = lweSecretKey.parameters();
|
||||
auto encryption = std::get<0>(outputSk).encryption;
|
||||
if (!encryption.hasValue()) {
|
||||
return StringError("decrypt_lwe: the positional argument is not encrypted");
|
||||
@@ -358,15 +227,15 @@ KeySet::decrypt_lwe(size_t argPos, uint64_t *ciphertext, uint64_t &output) {
|
||||
|
||||
auto crt = encryption->encoding.crt;
|
||||
|
||||
if (!crt.empty()) { // The ciphertext used the crt strategy.
|
||||
if (!crt.empty()) {
|
||||
// CRT encoded TFHE integers
|
||||
|
||||
// Decrypt and decode remainders
|
||||
std::vector<int64_t> remainders;
|
||||
for (auto modulus : crt) {
|
||||
uint64_t decrypted;
|
||||
CAPI_ASSERT_ERROR(
|
||||
default_engine_decrypt_lwe_ciphertext_u64_raw_ptr_buffers(
|
||||
engine, lweSecretKey, ciphertext, &decrypted));
|
||||
uint64_t decrypted = 0;
|
||||
lweSecretKey.decrypt(ciphertext, decrypted);
|
||||
|
||||
auto plaintext = crt::decode(decrypted, modulus);
|
||||
remainders.push_back(plaintext);
|
||||
ciphertext = ciphertext + lweSecretKeyParam.lweSize();
|
||||
@@ -386,12 +255,10 @@ KeySet::decrypt_lwe(size_t argPos, uint64_t *ciphertext, uint64_t &output) {
|
||||
output -= maxPos * 2;
|
||||
}
|
||||
}
|
||||
} else { // The ciphertext used the scalar strategy
|
||||
|
||||
// Decrypt
|
||||
uint64_t plaintext;
|
||||
CAPI_ASSERT_ERROR(default_engine_decrypt_lwe_ciphertext_u64_raw_ptr_buffers(
|
||||
engine, lweSecretKey, ciphertext, &plaintext));
|
||||
} else {
|
||||
// Native encoded TFHE integers - 1 blocks with one padding bits
|
||||
uint64_t plaintext = 0;
|
||||
lweSecretKey.decrypt(ciphertext, plaintext);
|
||||
|
||||
// Decode unsigned integer
|
||||
uint64_t precision = encryption->encoding.precision;
|
||||
@@ -415,27 +282,18 @@ KeySet::decrypt_lwe(size_t argPos, uint64_t *ciphertext, uint64_t &output) {
|
||||
return outcome::success();
|
||||
}
|
||||
|
||||
const std::map<LweSecretKeyID, std::pair<LweSecretKeyParam, LweSecretKey64 *>> &
|
||||
KeySet::getSecretKeys() {
|
||||
return secretKeys;
|
||||
}
|
||||
const std::vector<LweSecretKey> &KeySet::getSecretKeys() { return secretKeys; }
|
||||
|
||||
const std::map<LweSecretKeyID,
|
||||
std::pair<BootstrapKeyParam, std::shared_ptr<LweBootstrapKey>>> &
|
||||
KeySet::getBootstrapKeys() {
|
||||
const std::vector<LweBootstrapKey> &KeySet::getBootstrapKeys() {
|
||||
return bootstrapKeys;
|
||||
}
|
||||
|
||||
const std::map<LweSecretKeyID,
|
||||
std::pair<KeyswitchKeyParam, std::shared_ptr<LweKeyswitchKey>>> &
|
||||
KeySet::getKeyswitchKeys() {
|
||||
const std::vector<LweKeyswitchKey> &KeySet::getKeyswitchKeys() {
|
||||
return keyswitchKeys;
|
||||
}
|
||||
|
||||
const std::map<LweSecretKeyID, std::pair<PackingKeySwitchParam,
|
||||
std::shared_ptr<PackingKeyswitchKey>>>
|
||||
&KeySet::getPackingKeys() {
|
||||
return packingKeys;
|
||||
const std::vector<PackingKeyswitchKey> &KeySet::getPackingKeyswitchKeys() {
|
||||
return packingKeyswitchKeys;
|
||||
}
|
||||
|
||||
} // namespace clientlib
|
||||
|
||||
Reference in New Issue
Block a user