/vote/submitted: UI to begin MalwareCheck

pages/api/election/[election_id]/admin/decrypt-column.ts

@@ -1,7 +1,7 @@
 import { mapValues } from 'lodash-es'
 import { NextApiRequest, NextApiResponse } from 'next'
 import { pointToString, RP } from 'src/crypto/curve'
-import decrypt from 'src/crypto/decrypt'
+import { decrypt } from 'src/crypto/decrypt'
 import { CipherStrings } from 'src/crypto/stringify-shuffle'
 
 export default async (req: NextApiRequest, res: NextApiResponse) => {

pages/api/malware-check/confirm.ts

@@ -0,0 +1,53 @@
+import { NextApiRequest, NextApiResponse } from 'next'
+
+import { firebase, pushover } from '../_services'
+import { malwareCheckErrorGenerator } from './download'
+
+export default async (req: NextApiRequest, res: NextApiResponse) => {
+  const { auth_token, confirmed, election_id, issue_description, otp } = req.body
+
+  if (typeof election_id !== 'string') return res.status(400).json({ error: 'Missing election_id' })
+  if (typeof auth_token !== 'string') return res.status(400).json({ error: 'Missing auth_token' })
+  if (typeof confirmed !== 'boolean') return res.status(400).json({ error: 'Missing confirmed' })
+  if (typeof otp !== 'string') return res.status(400).json({ error: 'Missing otp' })
+
+  const electionDoc = firebase.firestore().collection('elections').doc(election_id)
+  const checkDoc = electionDoc.collection('malware-checks').doc(auth_token)
+
+  const check = await checkDoc.get()
+  const malwareCheckError = malwareCheckErrorGenerator('confirm', election_id, auth_token, otp, res)
+  if (!check.exists) return malwareCheckError('No malware check found')
+
+  const data = check.data()
+  if (!data || !data.checks || !Array.isArray(data.checks)) return malwareCheckError('Invalid check data')
+
+  // Find matching check entry by OTP
+  const checkEntry = data.checks.find((entry: { otp?: string }) => entry.otp === otp)
+  if (!checkEntry) return malwareCheckError('Invalid OTP', 401)
+
+  // Update the specific check entry - add confirmation
+  const updatedChecks = data.checks.map((entry: { confirmations?: unknown[]; otp?: string }) => {
+    if (entry.otp === otp) {
+      const confirmations = Array.isArray(entry.confirmations) ? [...entry.confirmations] : []
+      confirmations.push({
+        confirmed,
+        confirmed_at: new Date(),
+        issue_description: issue_description || null,
+        otp,
+      })
+      return { ...entry, confirmations }
+    }
+
+    return entry
+  })
+
+  await checkDoc.update({ checks: updatedChecks })
+
+  if (!confirmed)
+    await pushover(
+      'Malware check: Reported issue',
+      `${election_id}: ${auth_token} (OTP: ${otp})\n${issue_description ? `Issue: ${issue_description}` : ''}`,
+    )
+
+  return res.status(200).json({ success: true })
+}

pages/api/malware-check/decrypt-success.ts

@@ -0,0 +1,35 @@
+import { NextApiRequest, NextApiResponse } from 'next'
+
+import { firebase } from '../_services'
+import { malwareCheckErrorGenerator } from './download'
+
+export default async (req: NextApiRequest, res: NextApiResponse) => {
+  const { auth_token, election_id, otp } = req.body
+
+  if (typeof election_id !== 'string') return res.status(400).json({ error: 'Missing election_id' })
+  if (typeof auth_token !== 'string') return res.status(400).json({ error: 'Missing auth_token' })
+  if (typeof otp !== 'string') return res.status(400).json({ error: 'Missing otp' })
+
+  const electionDoc = firebase.firestore().collection('elections').doc(election_id)
+  const checkDoc = electionDoc.collection('malware-checks').doc(auth_token)
+
+  const malwareCheckError = malwareCheckErrorGenerator('decrypt-success', election_id, auth_token, otp, res)
+  const check = await checkDoc.get()
+  if (!check.exists) return malwareCheckError('No malware check found')
+
+  const data = check.data()
+  if (!data || !data.checks || !Array.isArray(data.checks)) return malwareCheckError('Invalid check data')
+
+  // Find matching check entry by OTP
+  const checkEntry = data.checks.find((entry: { otp?: string }) => entry.otp === otp)
+  if (!checkEntry) return malwareCheckError('Invalid OTP', 401)
+
+  // Update the specific check entry
+  const updatedChecks = data.checks.map((entry: { otp?: string }) => {
+    return entry.otp === otp ? { ...entry, decrypted_at: new Date() } : entry
+  })
+
+  await checkDoc.update({ checks: updatedChecks })
+
+  return res.status(200).json({ success: true })
+}

pages/api/malware-check/download.ts

@@ -0,0 +1,71 @@
+import { NextApiRequest, NextApiResponse } from 'next'
+
+import { firebase, pushover } from '../_services'
+
+export default async (req: NextApiRequest, res: NextApiResponse) => {
+  const { already_seen_device, auth_token, election_id, otp } = req.body
+
+  if (typeof election_id !== 'string') return res.status(400).json({ error: 'Missing election_id' })
+  if (typeof auth_token !== 'string') return res.status(400).json({ error: 'Missing auth_token' })
+  if (typeof otp !== 'string') return res.status(400).json({ error: 'Missing otp' })
+
+  const electionDoc = firebase.firestore().collection('elections').doc(election_id)
+  const checkDoc = electionDoc.collection('malware-checks').doc(auth_token)
+
+  const check = await checkDoc.get()
+
+  const malwareCheckError = malwareCheckErrorGenerator('download', election_id, auth_token, otp, res)
+  if (!check.exists) return malwareCheckError('No malware check found')
+
+  const data = check.data()
+  if (!data || !data.checks || !Array.isArray(data.checks)) return malwareCheckError('Invalid check data')
+
+  // Find matching check entry by OTP
+  const checkEntry = data.checks.find((entry: { otp?: string }) => entry.otp === otp)
+  if (!checkEntry) return malwareCheckError('Invalid OTP', 401)
+
+  // Check if already downloaded
+  if (checkEntry.downloaded_at) {
+    await pushover('Malware check: Already downloaded', `${election_id}: ${auth_token}\nOTP: ${otp}`)
+    return res.status(410).json({ error: 'Already downloaded. Restart from original device' })
+  }
+
+  // Fetch encrypted vote from database
+  const votes = await electionDoc.collection('votes').where('auth', '==', auth_token).get()
+  if (votes.empty) return res.status(404).json({ error: 'Vote not found' })
+  const storedVote = votes.docs[0].data()
+
+  // Update the specific check entry
+  const updatedChecks = data.checks.map((entry: { already_seen_device?: null | string; otp?: string }) => {
+    if (entry.otp === otp)
+      return {
+        ...entry,
+        already_seen_device: already_seen_device ?? null,
+        downloaded_at: new Date(),
+        downloaded_by_ip: req.headers['x-real-ip'] || null,
+        downloaded_by_user_agent: req.headers['user-agent'] || null,
+      }
+
+    return entry
+  })
+
+  await checkDoc.update({ checks: updatedChecks })
+
+  return res.status(200).json({
+    encrypted_randomizers: checkEntry.encrypted_randomizers,
+    encrypted_vote: storedVote.encrypted_vote,
+  })
+}
+
+export function malwareCheckErrorGenerator(
+  type: 'confirm' | 'decrypt-success' | 'download',
+  election_id: string,
+  auth_token: string,
+  otp: string,
+  res: NextApiResponse,
+) {
+  return async function (error: string, errorCode = 404) {
+    await pushover(`Malware check, ${type}: ${error}`, `${election_id}: ${auth_token}\nOTP: ${otp}`)
+    return res.status(errorCode).json({ error })
+  }
+}

pages/api/malware-check/init.ts

@@ -0,0 +1,29 @@
+import { firestore } from 'firebase-admin'
+import { NextApiRequest, NextApiResponse } from 'next'
+
+import { firebase } from '../_services'
+import { generateEmailLoginCode } from '../admin-login'
+
+export default async (req: NextApiRequest, res: NextApiResponse) => {
+  const { auth_token, election_id, encrypted_randomizers } = req.body
+
+  if (typeof election_id !== 'string') return res.status(400).json({ error: 'Missing election_id' })
+  if (typeof auth_token !== 'string') return res.status(400).json({ error: 'Missing auth_token' })
+  if (typeof encrypted_randomizers !== 'string') return res.status(400).json({ error: 'Missing encrypted_randomizers' })
+
+  const electionDoc = firebase.firestore().collection('elections').doc(election_id)
+
+  // Generate 6-digit OTP
+  const otp = generateEmailLoginCode()
+
+  // Create new check entry
+  const checkEntry = { created_at: new Date(), encrypted_randomizers, otp }
+
+  // Add new check entry to checks array
+  await electionDoc
+    .collection('malware-checks')
+    .doc(auth_token)
+    .set({ auth_token, checks: firestore.FieldValue.arrayUnion(checkEntry) }, { merge: true })
+
+  return res.status(200).json({ otp })
+}

pages/api/malware-check/malware-check-status.ts

@@ -0,0 +1,39 @@
+import { firebase } from 'api/_services'
+import { NextApiRequest, NextApiResponse } from 'next'
+
+export default async (req: NextApiRequest, res: NextApiResponse) => {
+  // Disabling endpoint for now, because we're not using it.
+  // It also could benefit from tighter auth, so not anyone can check statuses (and device user-agents) for other voters.
+  // And its understanding of the malware-check docs data structure is outdated.
+  const disabled = true
+  if (disabled) return res.status(400).json({ disabled })
+
+  const { auth, election_id } = req.query
+
+  if (typeof election_id !== 'string') return res.status(400).json({ error: 'Missing election_id' })
+  if (typeof auth !== 'string') return res.status(400).json({ error: 'Missing auth' })
+
+  const electionDoc = firebase.firestore().collection('elections').doc(election_id)
+
+  // Fetch malware checks for this auth token
+  const checks = await electionDoc.collection('malware-checks').where('auth', '==', auth).get()
+
+  const checkStatuses = checks.docs.map((doc) => {
+    const data = doc.data()
+    return {
+      confirmed: data.confirmed,
+      created_at: data.created_at?._seconds ? new Date(data.created_at._seconds * 1000).toISOString() : null,
+      device_info: data.device_info?.device_type || 'Unknown',
+      match: data.match,
+      user_agent: data.device_info?.user_agent || 'Unknown',
+    }
+  })
+
+  // Count confirmed checks
+  const confirmedCount = checkStatuses.filter((c) => c.confirmed === true).length
+
+  return res.status(200).json({
+    checks: checkStatuses,
+    verified_count: confirmedCount,
+  })
+}

pages/malware-check/[election_id]/[auth_token]/[otp].tsx

@@ -0,0 +1 @@
+export { MalwareCheckPage as default } from 'src/malware-check/MalwareCheckPage'

src/admin/Voters/useVoterInvites.ts

@@ -5,5 +5,9 @@ import { useData } from 'src/pusher-helper'
 export function useVoterInvites(): VoterInvites {
   const election_id = useRouter().query.election_id as string | undefined
 
-  return useData(`election/${election_id}/admin/find-voter-invites`, [`invite-voter-${election_id}`, 'delivery']) || {}
+  const { data } = useData(`election/${election_id}/admin/find-voter-invites`, [
+    `invite-voter-${election_id}`,
+    'delivery',
+  ])
+  return data || {}
 }

src/crypto/decrypt.ts

@@ -1,11 +1,30 @@
 import { RP } from './curve'
-import { Cipher } from './shuffle'
+import { Cipher, Public_Key } from './shuffle'
 
-export default function decrypt(secret_key: bigint, cipher: Cipher): RP {
+export function decrypt(secret_key: bigint, cipher: Cipher): RP {
   const { encrypted, lock } = cipher
 
   const shared_secret = lock.multiply(secret_key)
   const message = encrypted.subtract(shared_secret)
 
   return message
 }
+
+/**
+ * Decrypt a cipher using the randomizer and public key.
+ * This allows decryption without the secret key, useful for malware checks.
+ *
+ * Encryption: encrypted = message + (public_key * randomizer)
+ * Decryption: message = encrypted - (public_key * randomizer)
+ */
+export function decryptWithRandomizer(public_key: Public_Key, randomizer: bigint, cipher: Cipher): RP {
+  const { encrypted } = cipher
+
+  // Calculate shared_secret = public_key * randomizer (same as in encryption)
+  const shared_secret = public_key.multiply(randomizer)
+
+  // Decrypt: message = encrypted - shared_secret
+  const message = encrypted.subtract(shared_secret)
+
+  return message
+}

src/crypto/encrypt.ts

@@ -1,7 +1,7 @@
 import { G, RP } from './curve'
 import { Cipher, Public_Key } from './shuffle'
 
-export default function encrypt(public_key: Public_Key, randomizer: bigint, message: RP): Cipher {
+export function encrypt(public_key: Public_Key, randomizer: bigint, message: RP): Cipher {
   // Calculate our encrypted message
   const shared_secret = public_key.multiply(randomizer)
   const encrypted = message.add(shared_secret)

src/crypto/symmetric-encrypt.ts

@@ -0,0 +1,80 @@
+import { Crypto } from '@peculiar/webcrypto'
+
+const crypto = new Crypto()
+
+const AesAlgorithm = {
+  counter: new Uint8Array(16), // null ok bc key always unique
+  length: 64,
+  name: 'AES-CTR',
+}
+
+/** Decrypt a base64url-encoded ciphertext using AES-CTR with the given key.
+   Returns the decrypted string */
+export async function decryptSymmetric(key: CryptoKey, ciphertext: string): Promise<string> {
+  // Convert base64url to base64
+  let base64 = ciphertext.replace(/-/g, '+').replace(/_/g, '/')
+  const padding = base64.length % 4
+  if (padding) {
+    base64 += '='.repeat(4 - padding)
+  }
+
+  // Decode base64 to bytes
+  const cipherBytes =
+    typeof window !== 'undefined'
+      ? new Uint8Array(
+          atob(base64)
+            .split('')
+            .map((c) => c.charCodeAt(0)),
+        )
+      : new Uint8Array(Buffer.from(base64, 'base64'))
+
+  const decrypted = await crypto.subtle.decrypt(AesAlgorithm, key, cipherBytes)
+  return new TextDecoder().decode(decrypted)
+}
+
+/** Encrypt a string using AES-CTR with the given key.
+    Returns base64url-encoded ciphertext */
+export async function encryptSymmetric(key: CryptoKey, data: string): Promise<string> {
+  const encoded = new TextEncoder().encode(data)
+  const ciphertext = await crypto.subtle.encrypt(AesAlgorithm, key, encoded)
+
+  const bytes = new Uint8Array(ciphertext)
+  const base64 =
+    typeof window !== 'undefined' ? btoa(String.fromCharCode(...bytes)) : Buffer.from(bytes).toString('base64')
+
+  return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+}
+
+/** Export a CryptoKey to base64url string for storage in URL hash */
+export async function exportKeyToBase64URL(key: CryptoKey): Promise<string> {
+  const keyData = await crypto.subtle.exportKey('raw', key)
+  const bytes = new Uint8Array(keyData)
+  const base64 =
+    typeof window !== 'undefined' ? btoa(String.fromCharCode(...bytes)) : Buffer.from(bytes).toString('base64')
+  return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+}
+
+/** Generate a 128-bit symmetric encryption key */
+export async function generateSymmetricKey(): Promise<CryptoKey> {
+  return crypto.subtle.generateKey({ length: 128, name: 'AES-CTR' }, true, ['encrypt', 'decrypt'])
+}
+
+/** Import a base64url string back to a CryptoKey */
+export async function importKeyFromBase64URL(base64url: string): Promise<CryptoKey> {
+  // Convert base64url to base64
+  let base64 = base64url.replace(/-/g, '+').replace(/_/g, '/')
+  const padding = base64.length % 4
+  if (padding) base64 += '='.repeat(4 - padding)
+
+  // Decode base64 to bytes
+  const bytes =
+    typeof window !== 'undefined'
+      ? new Uint8Array(
+          atob(base64)
+            .split('')
+            .map((c) => c.charCodeAt(0)),
+        )
+      : new Uint8Array(Buffer.from(base64, 'base64'))
+
+  return crypto.subtle.importKey('raw', bytes, { length: 128, name: 'AES-CTR' }, false, ['encrypt', 'decrypt'])
+}

src/crypto/tests/shuffle.test.ts

@@ -3,8 +3,8 @@ import { expect, test } from 'bun:test'
 import { isEqual, range } from 'lodash'
 
 import { pointToString, random_bigint, stringToPoint } from '../curve'
-import decrypt from '../decrypt'
-import encrypt from '../encrypt'
+import { decrypt } from '../decrypt'
+import { encrypt } from '../encrypt'
 import { generate_key_pair } from '../generate-key-pair'
 import { rename_to_c1_and_2, shuffleWithProof } from '../shuffle'
 import { verify_shuffle_proof } from '../shuffle-proof'

src/crypto/tests/threshold-keygen.test.ts

@@ -2,8 +2,8 @@ import { expect, test } from 'bun:test'
 import { mapValues, noop } from 'lodash'
 
 import { CURVE, G, random_bigint, RP, stringToPoint } from '../curve'
-import decrypt from '../decrypt'
-import encrypt from '../encrypt'
+import { decrypt } from '../decrypt'
+import { encrypt } from '../encrypt'
 import {
   combine_partials,
   compute_keyshare,