{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE UndecidableInstances #-}
module Voting.Protocol.Trustee.Indispensable where
import Control.DeepSeq (NFData)
import Control.Monad (Monad(..), foldM, unless)
import Control.Monad.Trans.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.Tuple (fst)
import GHC.Generics (Generic)
import Text.Show (Show(..))
import qualified Control.Monad.Trans.State.Strict as S
import qualified Data.Aeson as JSON
import qualified Data.ByteString as BS
import qualified Data.List as List
import Voting.Protocol.Utils
import Voting.Protocol.FFC
import Voting.Protocol.Credential
import Voting.Protocol.Election
import Voting.Protocol.Tally
data TrusteePublicKey c = TrusteePublicKey
{ trustee_PublicKey :: !(PublicKey c)
, trustee_SecretKeyProof :: !(Proof c)
} deriving (Eq,Show,Generic,NFData)
instance ToJSON (TrusteePublicKey c) where
toJSON TrusteePublicKey{..} =
JSON.object
[ "pok" .= trustee_SecretKeyProof
, "public_key" .= trustee_PublicKey
]
toEncoding TrusteePublicKey{..} =
JSON.pairs
( "pok" .= trustee_SecretKeyProof
<> "public_key" .= trustee_PublicKey
)
instance Reifies c FFC => FromJSON (TrusteePublicKey c) where
parseJSON = JSON.withObject "TrusteePublicKey" $ \o -> do
trustee_PublicKey <- o .: "public_key"
trustee_SecretKeyProof <- o .: "pok"
return TrusteePublicKey{..}
data ErrorTrusteePublicKey
= ErrorTrusteePublicKey_WrongProof
deriving (Eq,Show)
proveIndispensableTrusteePublicKey ::
Reifies c FFC => Monad m => RandomGen r =>
SecretKey c -> S.StateT r m (TrusteePublicKey c)
proveIndispensableTrusteePublicKey trustSecKey = do
let trustee_PublicKey = publicKey trustSecKey
trustee_SecretKeyProof <-
prove trustSecKey [groupGen] $
hash (indispensableTrusteePublicKeyStatement trustee_PublicKey)
return TrusteePublicKey{..}
verifyIndispensableTrusteePublicKey ::
Reifies c FFC => Monad m =>
TrusteePublicKey c ->
ExceptT ErrorTrusteePublicKey m ()
verifyIndispensableTrusteePublicKey TrusteePublicKey{..} =
unless ((proof_challenge trustee_SecretKeyProof ==) $
hash
(indispensableTrusteePublicKeyStatement trustee_PublicKey)
[commit trustee_SecretKeyProof groupGen trustee_PublicKey]) $
throwE ErrorTrusteePublicKey_WrongProof
indispensableTrusteePublicKeyStatement :: PublicKey c -> BS.ByteString
indispensableTrusteePublicKeyStatement trustPubKey =
"pok|"<>bytesNat trustPubKey<>"|"
combineIndispensableTrusteePublicKeys ::
Reifies c FFC => [TrusteePublicKey c] -> PublicKey c
combineIndispensableTrusteePublicKeys =
List.foldr (\TrusteePublicKey{..} -> (trustee_PublicKey *)) one
verifyIndispensableDecryptionShareByTrustee ::
Reifies c FFC => Monad m =>
EncryptedTally c -> [PublicKey c] -> [DecryptionShare c] ->
ExceptT ErrorTally m ()
verifyIndispensableDecryptionShareByTrustee encByChoiceByQuest =
isoZipWithM_ (throwE $ ErrorTally_NumberOfTrustees)
(verifyDecryptionShare encByChoiceByQuest)
combineIndispensableDecryptionShares ::
Reifies c FFC => [PublicKey c] -> DecryptionShareCombinator c
combineIndispensableDecryptionShares
pubKeyByTrustee
encByChoiceByQuest
decByChoiceByQuestByTrustee = do
verifyIndispensableDecryptionShareByTrustee
encByChoiceByQuest
pubKeyByTrustee
decByChoiceByQuestByTrustee
(DecryptionShare dec0,decs) <-
maybe (throwE ErrorTally_NumberOfTrustees) return $
List.uncons decByChoiceByQuestByTrustee
foldM (isoZipWithM (throwE ErrorTally_NumberOfQuestions)
(maybe (throwE ErrorTally_NumberOfChoices) return `o2`
isoZipWith (\a (decFactor, _proof) -> a * decFactor)))
((fst <$>) <$> dec0) (unDecryptionShare <$> decs)