SealPIR/src/pir_client.cpp

#include "pir_client.hpp"

using namespace std;
using namespace seal;
using namespace seal::util;

PIRClient::PIRClient(const EncryptionParameters &enc_params,
                     const PirParams &pir_params)
    : enc_params_(enc_params), pir_params_(pir_params) {

  context_ = make_shared<SEALContext>(enc_params, true);

  keygen_ = make_unique<KeyGenerator>(*context_);

  PublicKey public_key;
  keygen_->create_public_key(public_key);
  SecretKey secret_key = keygen_->secret_key();

  if (pir_params_.enable_symmetric) {
    encryptor_ = make_unique<Encryptor>(*context_, secret_key);
  } else {
    encryptor_ = make_unique<Encryptor>(*context_, public_key);
  }

  decryptor_ = make_unique<Decryptor>(*context_, secret_key);
  evaluator_ = make_unique<Evaluator>(*context_);
  encoder_ = make_unique<BatchEncoder>(*context_);
}

int PIRClient::generate_serialized_query(uint64_t desiredIndex,
                                         std::stringstream &stream) {

  int N = enc_params_.poly_modulus_degree();
  int output_size = 0;
  indices_ = compute_indices(desiredIndex, pir_params_.nvec);
  Plaintext pt(enc_params_.poly_modulus_degree());

  for (uint32_t i = 0; i < indices_.size(); i++) {
    uint32_t num_ptxts = ceil((pir_params_.nvec[i] + 0.0) / N);
    // initialize result.
    cout << "Client: index " << i + 1 << "/ " << indices_.size() << " = "
         << indices_[i] << endl;
    cout << "Client: number of ctxts needed for query = " << num_ptxts << endl;

    for (uint32_t j = 0; j < num_ptxts; j++) {
      pt.set_zero();
      if (indices_[i] >= N * j && indices_[i] <= N * (j + 1)) {
        uint64_t real_index = indices_[i] - N * j;
        uint64_t n_i = pir_params_.nvec[i];
        uint64_t total = N;
        if (j == num_ptxts - 1) {
          total = n_i % N;
        }
        uint64_t log_total = ceil(log2(total));

        cout << "Client: Inverting " << pow(2, log_total) << endl;
        pt[real_index] =
            invert_mod(pow(2, log_total), enc_params_.plain_modulus());
      }

      if (pir_params_.enable_symmetric) {
        output_size += encryptor_->encrypt_symmetric(pt).save(stream);
      } else {
        output_size += encryptor_->encrypt(pt).save(stream);
      }
    }
  }

  return output_size;
}

PirQuery PIRClient::generate_query(uint64_t desiredIndex) {

  indices_ = compute_indices(desiredIndex, pir_params_.nvec);

  PirQuery result(pir_params_.d);
  int N = enc_params_.poly_modulus_degree();

  Plaintext pt(enc_params_.poly_modulus_degree());
  for (uint32_t i = 0; i < indices_.size(); i++) {
    uint32_t num_ptxts = ceil((pir_params_.nvec[i] + 0.0) / N);
    // initialize result.
    cout << "Client: index " << i + 1 << "/ " << indices_.size() << " = "
         << indices_[i] << endl;
    cout << "Client: number of ctxts needed for query = " << num_ptxts << endl;

    for (uint32_t j = 0; j < num_ptxts; j++) {
      pt.set_zero();
      if (indices_[i] >= N * j && indices_[i] <= N * (j + 1)) {
        uint64_t real_index = indices_[i] - N * j;
        uint64_t n_i = pir_params_.nvec[i];
        uint64_t total = N;
        if (j == num_ptxts - 1) {
          total = n_i % N;
        }
        uint64_t log_total = ceil(log2(total));

        cout << "Client: Inverting " << pow(2, log_total) << endl;
        pt[real_index] =
            invert_mod(pow(2, log_total), enc_params_.plain_modulus());
      }
      Ciphertext dest;
      if (pir_params_.enable_symmetric) {
        encryptor_->encrypt_symmetric(pt, dest);
      } else {
        encryptor_->encrypt(pt, dest);
      }
      result[i].push_back(dest);
    }
  }

  return result;
}

uint64_t PIRClient::get_fv_index(uint64_t element_index) {
  return static_cast<uint64_t>(element_index /
                               pir_params_.elements_per_plaintext);
}

uint64_t PIRClient::get_fv_offset(uint64_t element_index) {
  return element_index % pir_params_.elements_per_plaintext;
}

Plaintext PIRClient::decrypt(Ciphertext ct) {
  Plaintext pt;
  decryptor_->decrypt(ct, pt);
  return pt;
}

vector<uint8_t> PIRClient::decode_reply(PirReply &reply, uint64_t offset) {
  Plaintext result = decode_reply(reply);
  return extract_bytes(result, offset);
}

vector<uint64_t> PIRClient::extract_coeffs(Plaintext pt) {
  vector<uint64_t> coeffs;
  encoder_->decode(pt, coeffs);
  return coeffs;
}

std::vector<uint64_t> PIRClient::extract_coeffs(seal::Plaintext pt,
                                                uint64_t offset) {
  vector<uint64_t> coeffs;
  encoder_->decode(pt, coeffs);

  uint32_t logt = floor(log2(enc_params_.plain_modulus().value()));

  uint64_t coeffs_per_element =
      coefficients_per_element(logt, pir_params_.ele_size);

  return std::vector<uint64_t>(coeffs.begin() + offset * coeffs_per_element,
                               coeffs.begin() +
                                   (offset + 1) * coeffs_per_element);
}

std::vector<uint8_t> PIRClient::extract_bytes(seal::Plaintext pt,
                                              uint64_t offset) {
  uint32_t N = enc_params_.poly_modulus_degree();
  uint32_t logt = floor(log2(enc_params_.plain_modulus().value()));
  uint32_t bytes_per_ptxt =
      pir_params_.elements_per_plaintext * pir_params_.ele_size;

  // Convert from FV plaintext (polynomial) to database element at the client
  vector<uint8_t> elems(bytes_per_ptxt);
  vector<uint64_t> coeffs;
  encoder_->decode(pt, coeffs);
  coeffs_to_bytes(logt, coeffs, elems.data(), bytes_per_ptxt,
                  pir_params_.ele_size);
  return std::vector<uint8_t>(elems.begin() + offset * pir_params_.ele_size,
                              elems.begin() +
                                  (offset + 1) * pir_params_.ele_size);
}

Plaintext PIRClient::decode_reply(PirReply &reply) {
  EncryptionParameters parms;
  parms_id_type parms_id;
  if (pir_params_.enable_mswitching) {
    parms = context_->last_context_data()->parms();
    parms_id = context_->last_parms_id();
  } else {
    parms = context_->first_context_data()->parms();
    parms_id = context_->first_parms_id();
  }
  uint32_t exp_ratio = compute_expansion_ratio(parms);
  uint32_t recursion_level = pir_params_.d;

  vector<Ciphertext> temp = reply;
  uint32_t ciphertext_size = temp[0].size();

  uint64_t t = enc_params_.plain_modulus().value();

  for (uint32_t i = 0; i < recursion_level; i++) {
    cout << "Client: " << i + 1 << "/ " << recursion_level
         << "-th decryption layer started." << endl;
    vector<Ciphertext> newtemp;
    vector<Plaintext> tempplain;

    for (uint32_t j = 0; j < temp.size(); j++) {
      Plaintext ptxt;
      decryptor_->decrypt(temp[j], ptxt);
#ifdef DEBUG
      cout << "Client: reply noise budget = "
           << decryptor_->invariant_noise_budget(temp[j]) << endl;
#endif

      // cout << "decoded (and scaled) plaintext = " << ptxt.to_string() <<
      // endl;
      tempplain.push_back(ptxt);

#ifdef DEBUG
      cout << "recursion level : " << i << " noise budget :  ";
      cout << decryptor_->invariant_noise_budget(temp[j]) << endl;
#endif

      if ((j + 1) % (exp_ratio * ciphertext_size) == 0 && j > 0) {
        // Combine into one ciphertext.
        Ciphertext combined(*context_, parms_id);
        compose_to_ciphertext(parms, tempplain, combined);
        newtemp.push_back(combined);
        tempplain.clear();
        // cout << "Client: const term of ciphertext = " << combined[0] << endl;
      }
    }
    cout << "Client: done." << endl;
    cout << endl;
    if (i == recursion_level - 1) {
      assert(temp.size() == 1);
      return tempplain[0];
    } else {
      tempplain.clear();
      temp = newtemp;
    }
  }

  // This should never be called
  assert(0);
  Plaintext fail;
  return fail;
}

GaloisKeys PIRClient::generate_galois_keys() {
  // Generate the Galois keys needed for coeff_select.
  vector<uint32_t> galois_elts;
  int N = enc_params_.poly_modulus_degree();
  int logN = get_power_of_two(N);

  // cout << "printing galois elements...";
  for (int i = 0; i < logN; i++) {
    galois_elts.push_back((N + exponentiate_uint(2, i)) /
                          exponentiate_uint(2, i));
    //#ifdef DEBUG
    // cout << galois_elts.back() << ", ";
    //#endif
  }
  GaloisKeys gal_keys;
  keygen_->create_galois_keys(galois_elts, gal_keys);
  return gal_keys;
}

Plaintext PIRClient::replace_element(Plaintext pt, vector<uint64_t> new_element,
                                     uint64_t offset) {
  vector<uint64_t> coeffs = extract_coeffs(pt);

  uint32_t logt = floor(log2(enc_params_.plain_modulus().value()));
  uint64_t coeffs_per_element =
      coefficients_per_element(logt, pir_params_.ele_size);

  assert(new_element.size() == coeffs_per_element);

  for (uint64_t i = 0; i < coeffs_per_element; i++) {
    coeffs[i + offset * coeffs_per_element] = new_element[i];
  }

  Plaintext new_pt;

  encoder_->encode(coeffs, new_pt);
  return new_pt;
}

Ciphertext PIRClient::get_one() {
  Plaintext pt("1");
  Ciphertext ct;
  if (pir_params_.enable_symmetric) {
    encryptor_->encrypt_symmetric(pt, ct);
  } else {
    encryptor_->encrypt(pt, ct);
  }
  return ct;
}