Homomorphic Encryption — for Web Apps 🧐 (Part 2)

// Pseudocode
const cipher = encrypt(5)
typeof cipher // 'bigint'

// Pseudocode
const plain = encode(5)
typeof plain // ?
const cipher = encrypt(plain)
typeof cipher // ?

// import paillier in node.js
const paillier = require('paillier-bigint.js')
// import paillier in native JS
import * as paillier from 'paillier-bigint'
(async () => {
// Create keys
  const { publicKey, privateKey } = await paillier.generateRandomKeys(3072)
// Encrypt the plainText integer
  const cipher = publicKey.encrypt(5n)
// Decrypt the cipherText
  const decypted = privateKey.decrypt(cipher)
  // decrypted === 5n
})()

// Pick one for your environment
// npm install node-seal
// yarn add node-seal
//
// ES6 or CommonJS
// import { Seal } from 'node-seal'
const { Seal } = require('node-seal')
(async () => {
    // Wait for the web assembly to fully initialize
    const Morfix = await Seal()
    
    ////////////////////////
    // Encryption Parameters
    ////////////////////////
    
    // Create a new EncryptionParameters
    const schemeType = Morfix.SchemeType.BFV
    const polyModulusDegree = 4096
    const bitSizes = [36,36,37]
    const bitSize = 20
    
    const encParms = Morfix.EncryptionParameters(schemeType)
    // Assign Poly Modulus Degree
    encParms.setPolyModulusDegree(polyModulusDegree)
    
    // Create a suitable set of CoeffModulus primes
    const coeffModulus = Morfix.CoeffModulus.Create(
      polyModulusDegree,
      Int32Array.from(bitSizes)
    )
    encParms.setCoeffModulus(coeffModulus)
    // Assign a PlainModulus (only for BFV scheme type)
    const plainModulus = Morfix.PlainModulus.Batching(polyModulusDegree, bitSize)
    encParms.setPlainModulus(plainModulus)
    ////////////////////////
    // Context
    ////////////////////////
    
    // Create a new Context
    const context = Morfix.Context(encParms, true)
    // Helper to check if the Context was created successfully
    if (!context.parametersSet) {
      throw new Error('Could not set the parameters in the given context. Please try different encryption parameters.')
    }
    ////////////////////////
    // Keys
    ////////////////////////
    
    const keyGenerator = Morfix.KeyGenerator(context)
    const secretKey = keyGenerator.getSecretKey()
    const publicKey = keyGenerator.getPublicKey()
    ////////////////////////
    // Instances
    ////////////////////////
    
    const evaluator = Morfix.Evaluator(context)
    // Create a BatchEncoder (only BFV SchemeType)
    const batchEncoder = Morfix.BatchEncoder(context)
    const encryptor = Morfix.Encryptor(context, publicKey)
    const decryptor = Morfix.Decryptor(context, secretKey)
    ////////////////////////
    // Homomorphic Functions
    ////////////////////////
    
    // Create an array of 4096 values
    const array = Int32Array
      .from({length: 4096})
      .map((_, i) => i)
    // Encode data to a PlainText
    const plain = batchEncoder.encode(array)
    
    // Encrypt a PlainText
    const cipher = encryptor.encrypt(plain)    
    
    // Decrypt a CipherText
    const decryptedPlainText = decryptor.decrypt(cipher)    
    
    // Decode data from a PlainText
    const decodedPlainText = batchEncoder.decode(decryptedPlainText)
    // decodedPlainText === array    
})()

// Generate and save
const genKeyPair = async keySize => {
  const keys = paillier.generateRandomKeys(keySize)
  privateKey = keys.privateKey
  publicKey = keys.publicKey
  // BigInt's do not serialize natively.
  // We're going to implement out own naïve serializer method 
  // which just saves to a string of numbers.
  BigInt.prototype.toJSON = function () {
    return `${this.toString()}`
  }
  fs.writeFileSync(
    'paillier_private_key', 
    JSON.stringify(privateKey),
    'utf8'
  )
  fs.writeFileSync(
    'paillier_public_key',
    JSON.stringify(publicKey),
    'utf8'
  )
}
// Load and instantiate
const loadKeys = async () => {
  const rawPrivateKey = fs.readFileSync(
    'paillier_private_key',
    'utf8'
  )
  const rawPublicKey = fs.readFileSync(
    'paillier_public_key',
    'utf8'
  )
const privateKeyObject = JSON.parse(rawPrivateKey)
  const publicKeyObject = JSON.parse(rawPublicKey)
  const publicKey = new paillier.PublicKey(
    BigInt(publicKeyObject.n),
    BigInt(publicKeyObject.g)
  )
  const privateKey = new paillier.PrivateKey(
    BigInt(privateKeyObject.lambda),
    BigInt(privateKeyObject.mu),
    publicKey,
    BigInt(privateKeyObject.p),
    BigInt(privateKeyObject.q)
  )
  return { privateKey, publicKey }
}

// Generate and save
const genKeyPair = async context => {
  const keyGenerator = Morfix.keyGenerator(context)
  const privateKey = keys.getSecretKey()
  const publicKey = keys.getPublicKey()
  fs.writeFileSync('seal_private_key', privateKey.save(), 'utf8')
  fs.writeFileSync('seal_public_key', publicKey.save(), 'utf8')
}
// Load and instantiate
const loadKeys = async context => {
  const sKey = Morfix.SecretKey()
  const pKey = Morfix.PublicKey()
  sKey.load(context, fs.readFileSync(secretKeyName, 'utf8'))
  pKey.load(context, fs.readFileSync(publicKeyName, 'utf8'))
  return { privateKey: sKey, publicKey: pKey }
}

const saved = encrypted.save()
console.log(Buffer.byteLength(saved, 'base64'))
// 91213 bytes

Generating private/public keys: Done [2285233 microseconds]
Running tests .................................................. Done
Average encrypt: 232081 microseconds
Average decrypt: 229535 microseconds
Average add: 55 microseconds
Average multiply plain: 1409 microseconds

/
| Encryption parameters :
|   scheme: BFV
|   poly_modulus_degree: 4096
|   coeff_modulus size: 109 (36 + 36 + 37) bits
|   plain_modulus: 786433
\
Generating secret/public keys: Done [5428 microseconds]
Running tests .................................................. Done
Average batch: 269 microseconds
Average unbatch: 352 microseconds
Average encrypt: 6438 microseconds
Average decrypt: 1844 microseconds
Average add: 118 microseconds
Average multiply: 18647 microseconds
Average multiply plain: 2535 microseconds