meck93/evote-crypto

/**
 * System Setup
 *
 * - generate system parameters p,q,g
 * - generate key pairs h,sk
 * - combine public/private key shares
 */
 
Missing semicolon
import BN = require('bn.js')
Missing semicolon
import { GlobalHelper } from '../index'
Missing semicolon
import { Helper, KeyPair, SystemParameters, isSystemParameters } from './index'
 
// generate system parameters p,q,g given p,g
export const generateSystemParameters = (p: number, g: number): SystemParameters => {
  return {
    p: GlobalHelper.newBN(p),
    q: GlobalHelper.newBN(Helper.getQofP(p)),
    g: GlobalHelper.newBN(g),
Missing semicolon
  }
Missing semicolon
}
 
// randomly generate a key pair h,sk given the system parameters p,q,g
export const generateKeyPair = (sp: SystemParameters): KeyPair => {
Missing semicolon
  isSystemParameters(sp)
Missing semicolon
  const sk = GlobalHelper.getSecureRandomValue(sp.q) // pick a random value in Z_q
Missing semicolon
  const h = GlobalHelper.powBN(sp.g, sk, sp.p) // compute public key h: g^sk mod p
Missing semicolon
  return { h, sk }
Missing semicolon
}
 
// generate system parameters p,q,g and a key pair h,sk given p,g
export const generateSystemParametersAndKeys = (
  p: number,
  g: number
): [SystemParameters, KeyPair] => {
Missing semicolon
  const sysParams = generateSystemParameters(p, g)
Missing semicolon
  const keyPair = generateKeyPair(sysParams)
Missing semicolon
  return [sysParams, keyPair]
Missing semicolon
}
 
// generate system parameters p,q,g and a key pair h,sk given p,g
// these parameters can be used for zero-knowledge proofs
export const generateSystemParametersAndKeysZKP = (
  p: number,
  g: number
): [SystemParameters, KeyPair] => {
Missing semicolon
  const sysParams = generateSystemParameters(p, g)
Missing semicolon
  const keyPair = generateKeyPair(sysParams)
 
  // verify that g^q mod p == 1 (this means: gcd(q,p) == 1)
Missing semicolon
  const test1 = GlobalHelper.powBN(sysParams.g, sysParams.q, sysParams.p)
Similar blocks of code found in 2 locations. Consider refactoring.
  if (!test1.eq(GlobalHelper.newBN(1))) {
    throw new Error(
      `g^q mod p != 1 (== ${test1.toNumber()}. for p: ${p}, q: ${sysParams.q.toNumber()} and g: ${g}`
Missing semicolon
    )
  }
 
  // verify that h^q mod p == 1 (this means: gcd(h,p) == 1)
Missing semicolon
  const test2 = GlobalHelper.powBN(keyPair.h, sysParams.q, sysParams.p)
Similar blocks of code found in 2 locations. Consider refactoring.
  if (!test2.eq(GlobalHelper.newBN(1))) {
    throw new Error(
      `h^q mod p != 1 (== ${test2.toNumber()}. for p: ${p}, q: ${sysParams.q.toNumber()} and g: ${g}`
Missing semicolon
    )
  }
 
  // verify that the public key h is not 1
Missing semicolon
  const test3 = keyPair.h.mod(sysParams.p)
  if (test3.eq(GlobalHelper.newBN(1))) {
Missing semicolon
    throw new Error(`h mod p == 1. for p: ${p}, q: ${sysParams.q.toNumber()} and g: ${g}`)
  }
 
Missing semicolon
  return [sysParams, keyPair]
Missing semicolon
}
 
// combines multiple public key shares to one public key
Similar blocks of code found in 2 locations. Consider refactoring.
export const combinePublicKeys = (params: SystemParameters, publicKeyShares: BN[]): BN => {
Missing semicolon
  isSystemParameters(params)
Missing semicolon
  return publicKeyShares.reduce((product, share) => GlobalHelper.mulBN(product, share, params.p))
Missing semicolon
}
 
// combines multiple private key shares to one private key
// NOTE: this should not be used as the distributed secret keys will become "useless"
//       it is only used for testing purpose
Similar blocks of code found in 2 locations. Consider refactoring.
export const combinePrivateKeys = (params: SystemParameters, privateKeyShares: BN[]): BN => {
Missing semicolon
  isSystemParameters(params)
Missing semicolon
  return privateKeyShares.reduce((sum, share) => GlobalHelper.addBN(sum, share, params.q))
Missing semicolon
}