Skip to content
This repository has been archived by the owner. It is now read-only.
Python C++ HTML Makefile
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
he
lib/he
tests
.gitignore
.travis.yml
BV.i
Dockerfile
LICENSE.md
Makefile
README.md
TODO.md
index.html
init.py
requirements.txt
setup.py

README.md

PyBV

❗ This library has been deprecated due to changes in strategy and roadmap. To actively contribute based on our current roadmap, checkout OpenMined, PySyft, or join our slack

A Python Implementation of the BV Homomorphic Encryption Scheme

The scheme was proposed by Lauter et al. in Can Homomorphic Encryption be Practical? which was a variant of a homomorphic encryption scheme given by Brakerski et al. in Fully Homomorphic Encryption from Ring-LWE and Security for Key Dependent Messages.

The API can be imported using the command "import BV". It currently supports the following functions and classes:

Running

  1. Install Docker

    • If you're on macOS and use Homebrew, run brew cask install docker; open -a docker
  2. Run these commands:

make build
make run

Development

  1. Install Docker

    • If you're on macOS and use Homebrew, run brew cask install docker; open -a docker
  2. Run make build

  3. Edit source code as you wish

  4. Run make dev

API

Functions:

pari_init(pari_size, max_prime)

pari_init() is the function that needs to be called before dealing with this API. On importing the module, the module executes this statement automatically. pari_size defines the size of stack we'll be using, and max_prime defines the pre-computed prime table. By default, pari_size is set to 2000000000, and max_prime is set to 2.

Arguments: pari_size (int), max_prime (int)

pari_close()

pari_close() function has to be called at the end of each program to clear the memory used.

Classes:

pari_GEN

This class abstracts the GEN variable in C++, making it available through a Python interface. The class is compatible with +, *, /, -, __getitem__ , %, and print.

  • Class Data:

    1. value (GEN)
  • __init__(self, x)

    The constructor converts x to a GEN variable.

    Arguments: x(int)

parameters

  • Class Data:
    1. n, Q, sigma (ints)
    2. q, t, F (pari_GEN)

secret_key

  • Class Data:

    1. sk (pari_GEN)
    2. params (parameters)
  • __init__(self, sk = None, parmas = None) The constructor initiates class data.

    Arguments: sk (pari_GEN), params (parameters)

  • decrypt(self, ct)
    decrypt() method returns the plaintext (pari_GEN) encrypted in ciphertext ct.

    Arguments: ct (pari_GEN)

  • serialize(self)
    TO BE IMPLEMENTED

public_key

  • Class Data:

    1. pk (pari_GEN)
    2. params (parameters*)
  • __init__(self, pk = None, params = None)
    The constructor initiates the class data.

    Arguments: pk (pari_GEN), params (parameters*)

  • encrypt(self, pt)
    encrypt() method returns the ciphertext (pari_GEN) which encrypts plaintext pt.

    Arguments: pt (pari_GEN)

  • serialize(self)
    TO BE IMPLEMENTED

key_pair

  • Class Data:
    1. sk (secret_key)
    2. pk (public_key)

key_gen

  • generate_key(self, n, Q, T, sigma)

    generate_key() method returns the keys, which is of type key_pair.

    Arguments: n (int), Q (int), T (int), sigma (int)

  • deserialize(self)
    TO BE IMPLEMENTED

ciphertext

The class is compatible with '+', '*', and '-' operators. It also supports multiplication with plaintext (int) and batching.

  • Class Data:

    1. value (pari_GEN)
    2. pk (public_key*)
  • __init__(self, plaintext = None, pk)

    The plaintext variable is either an int variable, or it is an int_list variable. The size of list has to be less than the degree of polynomials (paramter n) in the polynomial ring.

    Arguments: plaintext (int or int_list), pk (public_key*)

  • decrypt(self, sk)

    decrypt() method returns the decrypted ciphertext which is pari_GEN variable.

    Arguments: sk (secret_key*)


You can’t perform that action at this time.