{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE UndecidableInstances #-}
module Voting.Protocol.Tally where
import Control.DeepSeq (NFData)
import Control.Monad (Monad(..), mapM, unless)
import Control.Monad.Trans.Except (Except, ExceptT, throwE)
import Data.Aeson (ToJSON(..),FromJSON(..),(.:),(.=))
import Data.Eq (Eq(..))
import Data.Function (($), (.))
import Data.Functor ((<$>))
import Data.Maybe (maybe)
import Data.Semigroup (Semigroup(..))
import Data.Reflection (Reifies(..))
import Data.Tuple (fst, snd)
import GHC.Generics (Generic)
import Numeric.Natural (Natural)
import System.Random (RandomGen)
import Text.Show (Show(..))
import qualified Data.Aeson as JSON
import qualified Data.Aeson.Types as JSON
import qualified Data.Aeson.Encoding as JSON
import qualified Control.Monad.Trans.State.Strict as S
import qualified Data.ByteString as BS
import qualified Data.List as List
import qualified Data.Map.Strict as Map
import Voting.Protocol.Utils
import Voting.Protocol.Arith
import Voting.Protocol.Credential
import Voting.Protocol.Election
data Tally crypto v c = Tally
{ tally_countMax :: !Natural
, tally_encByChoiceByQuest :: !(EncryptedTally crypto v c)
, tally_decShareByTrustee :: ![DecryptionShare crypto v c]
, tally_countByChoiceByQuest :: ![[Natural]]
} deriving (Generic)
deriving instance Eq (G crypto c) => Eq (Tally crypto v c)
deriving instance (Show (G crypto c), Show (G crypto c)) => Show (Tally crypto v c)
deriving instance NFData (G crypto c) => NFData (Tally crypto v c)
instance
( Reifies v Version
, GroupParams crypto c
) => ToJSON (Tally crypto v c) where
toJSON Tally{..} =
JSON.object
[ "num_tallied" .= tally_countMax
, "encrypted_tally" .= tally_encByChoiceByQuest
, "partial_decryptions" .= tally_decShareByTrustee
, "result" .= tally_countByChoiceByQuest
]
toEncoding Tally{..} =
JSON.pairs
( "num_tallied" .= tally_countMax
<> "encrypted_tally" .= tally_encByChoiceByQuest
<> "partial_decryptions" .= tally_decShareByTrustee
<> "result" .= tally_countByChoiceByQuest
)
instance
( Reifies v Version
, GroupParams crypto c
) => FromJSON (Tally crypto v c) where
parseJSON = JSON.withObject "Tally" $ \o -> do
tally_countMax <- o .: "num_tallied"
tally_encByChoiceByQuest <- o .: "encrypted_tally"
tally_decShareByTrustee <- o .: "partial_decryptions"
tally_countByChoiceByQuest <- o .: "result"
return Tally{..}
type EncryptedTally crypto v c = [[Encryption crypto v c]]
encryptedTally ::
GroupParams crypto c =>
[Ballot crypto v c] -> (EncryptedTally crypto v c, Natural)
encryptedTally = List.foldr insertEncryptedTally emptyEncryptedTally
emptyEncryptedTally ::
GroupParams crypto c =>
(EncryptedTally crypto v c, Natural)
emptyEncryptedTally = (List.repeat (List.repeat zero), 0)
insertEncryptedTally ::
GroupParams crypto c =>
Ballot crypto v c ->
(EncryptedTally crypto v c, Natural) ->
(EncryptedTally crypto v c, Natural)
insertEncryptedTally Ballot{..} (encTally, numBallots) =
( List.zipWith
(\Answer{..} -> List.zipWith (+) (fst <$> answer_opinions))
ballot_answers
encTally
, numBallots+1
)
type DecryptionShareCombinator crypto v c =
EncryptedTally crypto v c ->
[DecryptionShare crypto v c] ->
Except ErrorTally [[DecryptionFactor crypto c]]
proveTally ::
GroupParams crypto c =>
(EncryptedTally crypto v c, Natural) -> [DecryptionShare crypto v c] ->
DecryptionShareCombinator crypto v c -> Except ErrorTally (Tally crypto v c)
proveTally
(tally_encByChoiceByQuest, tally_countMax)
tally_decShareByTrustee
decShareCombinator = do
decFactorByChoiceByQuest <-
decShareCombinator
tally_encByChoiceByQuest
tally_decShareByTrustee
dec <- isoZipWithM (throwE ErrorTally_NumberOfQuestions)
(maybe (throwE ErrorTally_NumberOfChoices) return `o2`
isoZipWith (\Encryption{..} decFactor -> encryption_vault / decFactor))
tally_encByChoiceByQuest
decFactorByChoiceByQuest
let logMap = Map.fromList $ List.zip groupGenPowers [0..tally_countMax]
let log x =
maybe (throwE ErrorTally_CannotDecryptCount) return $
Map.lookup x logMap
tally_countByChoiceByQuest <- (log `mapM`)`mapM`dec
return Tally{..}
verifyTally ::
GroupParams crypto c =>
Tally crypto v c ->
DecryptionShareCombinator crypto v c ->
Except ErrorTally ()
verifyTally Tally{..} decShareCombinator = do
decFactorByChoiceByQuest <- decShareCombinator tally_encByChoiceByQuest tally_decShareByTrustee
isoZipWith3M_ (throwE ErrorTally_NumberOfQuestions)
(isoZipWith3M_ (throwE ErrorTally_NumberOfChoices)
(\Encryption{..} decFactor count -> do
let groupGenPowCount = encryption_vault / decFactor
unless (groupGenPowCount == groupGen ^ fromNatural count) $
throwE ErrorTally_WrongProof))
tally_encByChoiceByQuest
decFactorByChoiceByQuest
tally_countByChoiceByQuest
newtype DecryptionShare crypto v c = DecryptionShare
{ unDecryptionShare :: [[(DecryptionFactor crypto c, Proof crypto v c)]] }
deriving (Generic)
deriving instance Eq (G crypto c) => Eq (DecryptionShare crypto v c)
deriving instance Show (G crypto c) => Show (DecryptionShare crypto v c)
deriving newtype instance NFData (G crypto c) => NFData (DecryptionShare crypto v c)
instance ToJSON (G crypto c) => ToJSON (DecryptionShare crypto v c) where
toJSON (DecryptionShare decByChoiceByQuest) =
JSON.object
[ "decryption_factors" .=
toJSONList (((toJSON . fst) <$>) <$> decByChoiceByQuest)
, "decryption_proofs" .=
toJSONList (((toJSON . snd) <$>) <$> decByChoiceByQuest)
]
toEncoding (DecryptionShare decByChoiceByQuest) =
JSON.pairs $
JSON.pair "decryption_factors"
(JSON.list (JSON.list (toEncoding . fst)) decByChoiceByQuest) <>
JSON.pair "decryption_proofs"
(JSON.list (JSON.list (toEncoding . snd)) decByChoiceByQuest)
instance GroupParams crypto c => FromJSON (DecryptionShare crypto v c) where
parseJSON = JSON.withObject "DecryptionShare" $ \o -> do
decFactors <- o .: "decryption_factors"
decProofs <- o .: "decryption_proofs"
let err msg = JSON.typeMismatch ("DecryptionShare: "<>msg) (JSON.Object o)
DecryptionShare
<$> isoZipWithM (err "inconsistent number of questions")
(isoZipWithM (err "inconsistent number of choices")
(\a b -> return (a, b)))
decFactors decProofs
type DecryptionFactor = G
proveDecryptionShare ::
Reifies v Version =>
GroupParams crypto c =>
Key crypto =>
Monad m => RandomGen r =>
EncryptedTally crypto v c -> SecretKey crypto c -> S.StateT r m (DecryptionShare crypto v c)
proveDecryptionShare encByChoiceByQuest trusteeSecKey =
(DecryptionShare <$>) $
(proveDecryptionFactor trusteeSecKey `mapM`) `mapM` encByChoiceByQuest
proveDecryptionFactor ::
Reifies v Version =>
GroupParams crypto c =>
Key crypto =>
Monad m => RandomGen r =>
SecretKey crypto c -> Encryption crypto v c -> S.StateT r m (DecryptionFactor crypto c, Proof crypto v c)
proveDecryptionFactor trusteeSecKey Encryption{..} = do
proof <- prove trusteeSecKey [groupGen, encryption_nonce] (hash zkp)
return (encryption_nonce^trusteeSecKey, proof)
where zkp = decryptionShareStatement (publicKey trusteeSecKey)
decryptionShareStatement :: GroupParams crypto c => PublicKey crypto c -> BS.ByteString
decryptionShareStatement pubKey =
"decrypt|"<>bytesNat pubKey<>"|"
data ErrorTally
= ErrorTally_NumberOfQuestions
| ErrorTally_NumberOfChoices
| ErrorTally_NumberOfTrustees
| ErrorTally_WrongProof
| ErrorTally_CannotDecryptCount
deriving (Eq,Show,Generic,NFData)
verifyDecryptionShare ::
Reifies v Version =>
GroupParams crypto c =>
Monad m =>
EncryptedTally crypto v c -> PublicKey crypto c -> DecryptionShare crypto v c ->
ExceptT ErrorTally m ()
verifyDecryptionShare encByChoiceByQuest trusteePubKey (DecryptionShare decShare) =
let zkp = decryptionShareStatement trusteePubKey in
isoZipWithM_ (throwE ErrorTally_NumberOfQuestions)
(isoZipWithM_ (throwE ErrorTally_NumberOfChoices) $
\Encryption{..} (decFactor, proof) ->
unless (proof_challenge proof == hash zkp
[ commit proof groupGen trusteePubKey
, commit proof encryption_nonce decFactor
]) $ throwE ErrorTally_WrongProof)
encByChoiceByQuest
decShare
verifyDecryptionShareByTrustee ::
Reifies v Version =>
GroupParams crypto c =>
Monad m =>
EncryptedTally crypto v c -> [PublicKey crypto c] -> [DecryptionShare crypto v c] ->
ExceptT ErrorTally m ()
verifyDecryptionShareByTrustee encTally =
isoZipWithM_ (throwE ErrorTally_NumberOfTrustees)
(verifyDecryptionShare encTally)