meck93/evote-crypto

// check if a given number is prime
export const isPrime = (num: number): boolean => {
  for (let i = 2; i <= Math.sqrt(num); i++) {
== should be ===
    if (Math.floor(num / i) == num / i) {
Missing semicolon
      return false
    }
  }
Missing semicolon
  return true
Missing semicolon
}
 
// get all primitive roots of a given number
// only works for prime numbers
TODO found
// TODO: implement for non-prime numbers
Function `getPrimitiveRoots` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
export const getPrimitiveRoots = (n: number): number[] => {
  if (!isPrime(n)) {
Missing semicolon
    return []
  }
 
  // source: https://asecuritysite.com/encryption/pickg
Missing semicolon
  const g: number[] = []
  for (let i = 1; i < n; i++) {
Missing semicolon
    let exp = 1
Missing semicolon
    let next = i % n
 
    while (next !== 1) {
Missing semicolon
      next = (next * i) % n
Missing semicolon
      exp += 1
    }
 
    if (exp === n - 1) {
Missing semicolon
      g.push(i)
    }
  }
 
Missing semicolon
  return g
Missing semicolon
}
 
// calculate q given p (for p < 2)
TODO found
// TODO: maybe check if p is actually prime
Missing semicolon
export const getQofP = (p: number): number => (p > 1 ? (p - 1) / 2 : -1)
 
// q is valid if it is prime
Missing semicolon
export const isQValid = (q: number): boolean => (q > 1 ? isPrime(q) : false)
 
// g is valid if:
// - g != 1
// - q != q
// - g^q mod p == 1
export const isGValid = (g: number, p: number): boolean => {
Missing semicolon
  return g !== 1 && g !== getQofP(p) && g ** getQofP(p) % p === 1
Missing semicolon
}
 
// get all primes that have a q = (p-1)/2 that is prime given a list of primes
export const getPCandidates = (primes: number[]): number[] =>
  primes.reduce((previous: number[], current: number) => {
Missing semicolon
    return isQValid(getQofP(current)) ? [...previous, current] : previous
Missing semicolon
  }, [])
 
// get all generators g of q given a prime p
export const getGCandidates = (p: number): number[] =>
  getPrimitiveRoots(getQofP(p)).reduce((previous: number[], current: number) => {
Missing semicolon
    return isGValid(current, p) ? [...previous, current] : previous
Missing semicolon
  }, [])