module Signet.Unstable.Type.VerifierTest where

import qualified Data.ByteString.Char8 as Ascii
import qualified Signet.Unstable.Exception.InvalidVerifier as InvalidVerifier
import qualified Signet.Unstable.Exception.VerificationException as VerificationException
import qualified Signet.Unstable.Extra.Either as Either
import qualified Signet.Unstable.Extra.Tasty as Tasty
import qualified Signet.Unstable.Type.AsymmetricSignature as AsymmetricSignature
import qualified Signet.Unstable.Type.Message as Message
import qualified Signet.Unstable.Type.PublicKey as PublicKey
import qualified Signet.Unstable.Type.Secret as Secret
import qualified Signet.Unstable.Type.Signature as Signature
import qualified Signet.Unstable.Type.Signatures as Signatures
import qualified Signet.Unstable.Type.SymmetricSignature as SymmetricSignature
import qualified Signet.Unstable.Type.Verifier as Verifier
import Test.Tasty.HUnit ((@?=))

spec :: Tasty.Spec
spec :: Spec
spec = TestName -> Spec -> Spec
Tasty.describe TestName
"Signet.Unstable.Type.Verifier" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
  TestName -> Spec -> Spec
Tasty.describe TestName
"parse" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    TestName -> Assertion -> Spec
Tasty.it TestName
"succeeds with a valid public key" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = TestName -> ByteString
Ascii.pack TestName
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      let actual :: Either InvalidVerifier Verifier
actual = ByteString -> Either InvalidVerifier Verifier
Verifier.parse ByteString
byteString
      PublicKey
publicKey <- Either InvalidPublicKey PublicKey -> IO PublicKey
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidPublicKey PublicKey -> IO PublicKey)
-> Either InvalidPublicKey PublicKey -> IO PublicKey
forall a b. (a -> b) -> a -> b
$ ByteString -> Either InvalidPublicKey PublicKey
PublicKey.parse ByteString
byteString
      Either InvalidVerifier Verifier
actual Either InvalidVerifier Verifier
-> Either InvalidVerifier Verifier -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= Verifier -> Either InvalidVerifier Verifier
forall a b. b -> Either a b
Right (PublicKey -> Verifier
Verifier.Asymmetric PublicKey
publicKey)

    TestName -> Assertion -> Spec
Tasty.it TestName
"succeeds with a valid secret" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = TestName -> ByteString
Ascii.pack TestName
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      let actual :: Either InvalidVerifier Verifier
actual = ByteString -> Either InvalidVerifier Verifier
Verifier.parse ByteString
byteString
      Secret
secret <- Either InvalidSecret Secret -> IO Secret
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSecret Secret -> IO Secret)
-> Either InvalidSecret Secret -> IO Secret
forall a b. (a -> b) -> a -> b
$ ByteString -> Either InvalidSecret Secret
Secret.parse ByteString
byteString
      Either InvalidVerifier Verifier
actual Either InvalidVerifier Verifier
-> Either InvalidVerifier Verifier -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= Verifier -> Either InvalidVerifier Verifier
forall a b. b -> Either a b
Right (Secret -> Verifier
Verifier.Symmetric Secret
secret)

    TestName -> Assertion -> Spec
Tasty.it TestName
"fails with invalid input" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = TestName -> ByteString
Ascii.pack TestName
"invalid"
      let actual :: Either InvalidVerifier Verifier
actual = ByteString -> Either InvalidVerifier Verifier
Verifier.parse ByteString
byteString
      Either InvalidVerifier Verifier
actual Either InvalidVerifier Verifier
-> Either InvalidVerifier Verifier -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= InvalidVerifier -> Either InvalidVerifier Verifier
forall a b. a -> Either a b
Left (ByteString -> InvalidVerifier
InvalidVerifier.MkInvalidVerifier ByteString
byteString)

  TestName -> Spec -> Spec
Tasty.describe TestName
"render" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    TestName -> Assertion -> Spec
Tasty.it TestName
"works with a public key" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = TestName -> ByteString
Ascii.pack TestName
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      PublicKey
publicKey <- Either InvalidPublicKey PublicKey -> IO PublicKey
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidPublicKey PublicKey -> IO PublicKey)
-> (ByteString -> Either InvalidPublicKey PublicKey)
-> ByteString
-> IO PublicKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidPublicKey PublicKey
PublicKey.parse (ByteString -> IO PublicKey) -> ByteString -> IO PublicKey
forall a b. (a -> b) -> a -> b
$ ByteString
byteString
      Verifier -> ByteString
Verifier.render (PublicKey -> Verifier
Verifier.Asymmetric PublicKey
publicKey) ByteString -> ByteString -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= ByteString
byteString

    TestName -> Assertion -> Spec
Tasty.it TestName
"works with a secret" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      let byteString :: ByteString
byteString = TestName -> ByteString
Ascii.pack TestName
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Secret
secret <- Either InvalidSecret Secret -> IO Secret
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSecret Secret -> IO Secret)
-> (ByteString -> Either InvalidSecret Secret)
-> ByteString
-> IO Secret
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidSecret Secret
Secret.parse (ByteString -> IO Secret) -> ByteString -> IO Secret
forall a b. (a -> b) -> a -> b
$ ByteString
byteString
      Verifier -> ByteString
Verifier.render (Secret -> Verifier
Verifier.Symmetric Secret
secret) ByteString -> ByteString -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= ByteString
byteString

  TestName -> Spec -> Spec
Tasty.describe TestName
"verify" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    TestName -> Assertion -> Spec
Tasty.it TestName
"succeeds with a valid asymmetric signature" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      Verifier
verifier <- Either InvalidVerifier Verifier -> IO Verifier
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidVerifier Verifier -> IO Verifier)
-> (ByteString -> Either InvalidVerifier Verifier)
-> ByteString
-> IO Verifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidVerifier Verifier
Verifier.parse (ByteString -> IO Verifier) -> ByteString -> IO Verifier
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      Message
message <- Either InvalidMessage Message -> IO Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> IO Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> IO Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> IO Message) -> ByteString -> IO Message
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> IO ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> IO ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> IO ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> IO ([UnknownSignature], Signatures))
-> ByteString -> IO ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1a,CV1O+PvrwXM42OMUX+tmm6bA3cS0tgLp0qo3YKuu0MGmBrsUhA0MHXF11HsEUJtPfTKs80WE7WUKVt9TueLDCQ=="
      let actual :: Either VerificationException Signature
actual = Verifier
-> Message -> Signatures -> Either VerificationException Signature
Verifier.verify Verifier
verifier Message
message Signatures
signatures
      Right Signature
signature <- Either InvalidSignature (Either UnknownSignature Signature)
-> IO (Either UnknownSignature Signature)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature (Either UnknownSignature Signature)
 -> IO (Either UnknownSignature Signature))
-> (ByteString
    -> Either InvalidSignature (Either UnknownSignature Signature))
-> ByteString
-> IO (Either UnknownSignature Signature)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature (Either UnknownSignature Signature)
Signature.parse (ByteString -> IO (Either UnknownSignature Signature))
-> ByteString -> IO (Either UnknownSignature Signature)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1a,CV1O+PvrwXM42OMUX+tmm6bA3cS0tgLp0qo3YKuu0MGmBrsUhA0MHXF11HsEUJtPfTKs80WE7WUKVt9TueLDCQ=="
      Either VerificationException Signature
actual Either VerificationException Signature
-> Either VerificationException Signature -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= Signature -> Either VerificationException Signature
forall a b. b -> Either a b
Right Signature
signature

    TestName -> Assertion -> Spec
Tasty.it TestName
"fails with an invalid asymmetric signature" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      Verifier
verifier <- Either InvalidVerifier Verifier -> IO Verifier
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidVerifier Verifier -> IO Verifier)
-> (ByteString -> Either InvalidVerifier Verifier)
-> ByteString
-> IO Verifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidVerifier Verifier
Verifier.parse (ByteString -> IO Verifier) -> ByteString -> IO Verifier
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      Message
message <- Either InvalidMessage Message -> IO Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> IO Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> IO Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> IO Message) -> ByteString -> IO Message
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> IO ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> IO ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> IO ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> IO ([UnknownSignature], Signatures))
-> ByteString -> IO ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1a,00000000000000000000000000000000000000000000000000000000000000000000000000000000000000=="
      let actual :: Either VerificationException Signature
actual = Verifier
-> Message -> Signatures -> Either VerificationException Signature
Verifier.verify Verifier
verifier Message
message Signatures
signatures
      Either VerificationException Signature
actual Either VerificationException Signature
-> Either VerificationException Signature -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= VerificationException -> Either VerificationException Signature
forall a b. a -> Either a b
Left (Id -> VerificationException
VerificationException.MkVerificationException (Id -> VerificationException) -> Id -> VerificationException
forall a b. (a -> b) -> a -> b
$ Message -> Id
Message.id_ Message
message)

    TestName -> Assertion -> Spec
Tasty.it TestName
"succeeds with a valid symmetric signature" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      Verifier
verifier <- Either InvalidVerifier Verifier -> IO Verifier
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidVerifier Verifier -> IO Verifier)
-> (ByteString -> Either InvalidVerifier Verifier)
-> ByteString
-> IO Verifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidVerifier Verifier
Verifier.parse (ByteString -> IO Verifier) -> ByteString -> IO Verifier
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Message
message <- Either InvalidMessage Message -> IO Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> IO Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> IO Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> IO Message) -> ByteString -> IO Message
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> IO ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> IO ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> IO ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> IO ([UnknownSignature], Signatures))
-> ByteString -> IO ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1,IywpE5NXy+JdAScgR7j5Pt59GjmazD7iJuVsQoRZFyw="
      let actual :: Either VerificationException Signature
actual = Verifier
-> Message -> Signatures -> Either VerificationException Signature
Verifier.verify Verifier
verifier Message
message Signatures
signatures
      Right Signature
signature <- Either InvalidSignature (Either UnknownSignature Signature)
-> IO (Either UnknownSignature Signature)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature (Either UnknownSignature Signature)
 -> IO (Either UnknownSignature Signature))
-> (ByteString
    -> Either InvalidSignature (Either UnknownSignature Signature))
-> ByteString
-> IO (Either UnknownSignature Signature)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature (Either UnknownSignature Signature)
Signature.parse (ByteString -> IO (Either UnknownSignature Signature))
-> ByteString -> IO (Either UnknownSignature Signature)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1,IywpE5NXy+JdAScgR7j5Pt59GjmazD7iJuVsQoRZFyw="
      Either VerificationException Signature
actual Either VerificationException Signature
-> Either VerificationException Signature -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= Signature -> Either VerificationException Signature
forall a b. b -> Either a b
Right Signature
signature

    TestName -> Assertion -> Spec
Tasty.it TestName
"fails with an invalid symmetric signature" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      Verifier
verifier <- Either InvalidVerifier Verifier -> IO Verifier
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidVerifier Verifier -> IO Verifier)
-> (ByteString -> Either InvalidVerifier Verifier)
-> ByteString
-> IO Verifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidVerifier Verifier
Verifier.parse (ByteString -> IO Verifier) -> ByteString -> IO Verifier
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Message
message <- Either InvalidMessage Message -> IO Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> IO Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> IO Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> IO Message) -> ByteString -> IO Message
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> IO ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> IO ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> IO ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> IO ([UnknownSignature], Signatures))
-> ByteString -> IO ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1,0000000000000000000000000000000000000000000="
      let actual :: Either VerificationException Signature
actual = Verifier
-> Message -> Signatures -> Either VerificationException Signature
Verifier.verify Verifier
verifier Message
message Signatures
signatures
      Either VerificationException Signature
actual Either VerificationException Signature
-> Either VerificationException Signature -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= VerificationException -> Either VerificationException Signature
forall a b. a -> Either a b
Left (Id -> VerificationException
VerificationException.MkVerificationException (Id -> VerificationException) -> Id -> VerificationException
forall a b. (a -> b) -> a -> b
$ Message -> Id
Message.id_ Message
message)

  TestName -> Spec -> Spec
Tasty.describe TestName
"asymmetric" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    TestName -> Assertion -> Spec
Tasty.it TestName
"succeeds with a valid signature" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      PublicKey
publicKey <- Either InvalidPublicKey PublicKey -> IO PublicKey
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidPublicKey PublicKey -> IO PublicKey)
-> (ByteString -> Either InvalidPublicKey PublicKey)
-> ByteString
-> IO PublicKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidPublicKey PublicKey
PublicKey.parse (ByteString -> IO PublicKey) -> ByteString -> IO PublicKey
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      Message
message <- Either InvalidMessage Message -> IO Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> IO Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> IO Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> IO Message) -> ByteString -> IO Message
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> IO ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> IO ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> IO ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> IO ([UnknownSignature], Signatures))
-> ByteString -> IO ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1a,CV1O+PvrwXM42OMUX+tmm6bA3cS0tgLp0qo3YKuu0MGmBrsUhA0MHXF11HsEUJtPfTKs80WE7WUKVt9TueLDCQ=="
      let actual :: Either VerificationException AsymmetricSignature
actual = PublicKey
-> Message
-> Signatures
-> Either VerificationException AsymmetricSignature
Verifier.asymmetric PublicKey
publicKey Message
message Signatures
signatures
      AsymmetricSignature
asymmetricSignature <- Either InvalidAsymmetricSignature AsymmetricSignature
-> IO AsymmetricSignature
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidAsymmetricSignature AsymmetricSignature
 -> IO AsymmetricSignature)
-> (ByteString
    -> Either InvalidAsymmetricSignature AsymmetricSignature)
-> ByteString
-> IO AsymmetricSignature
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidAsymmetricSignature AsymmetricSignature
AsymmetricSignature.parse (ByteString -> IO AsymmetricSignature)
-> ByteString -> IO AsymmetricSignature
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"CV1O+PvrwXM42OMUX+tmm6bA3cS0tgLp0qo3YKuu0MGmBrsUhA0MHXF11HsEUJtPfTKs80WE7WUKVt9TueLDCQ=="
      Either VerificationException AsymmetricSignature
actual Either VerificationException AsymmetricSignature
-> Either VerificationException AsymmetricSignature -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= AsymmetricSignature
-> Either VerificationException AsymmetricSignature
forall a b. b -> Either a b
Right AsymmetricSignature
asymmetricSignature

    TestName -> Assertion -> Spec
Tasty.it TestName
"fails with an invalid signature" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      PublicKey
publicKey <- Either InvalidPublicKey PublicKey -> IO PublicKey
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidPublicKey PublicKey -> IO PublicKey)
-> (ByteString -> Either InvalidPublicKey PublicKey)
-> ByteString
-> IO PublicKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidPublicKey PublicKey
PublicKey.parse (ByteString -> IO PublicKey) -> ByteString -> IO PublicKey
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"whpk_wuzPrKxPfWpJSsXgyg/MEoMGvjs5SjDO4ad6X4ZYqqg="
      Message
message <- Either InvalidMessage Message -> IO Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> IO Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> IO Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> IO Message) -> ByteString -> IO Message
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> IO ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> IO ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> IO ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> IO ([UnknownSignature], Signatures))
-> ByteString -> IO ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1a,00000000000000000000000000000000000000000000000000000000000000000000000000000000000000=="
      let actual :: Either VerificationException AsymmetricSignature
actual = PublicKey
-> Message
-> Signatures
-> Either VerificationException AsymmetricSignature
Verifier.asymmetric PublicKey
publicKey Message
message Signatures
signatures
      Either VerificationException AsymmetricSignature
actual Either VerificationException AsymmetricSignature
-> Either VerificationException AsymmetricSignature -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= VerificationException
-> Either VerificationException AsymmetricSignature
forall a b. a -> Either a b
Left (Id -> VerificationException
VerificationException.MkVerificationException (Id -> VerificationException) -> Id -> VerificationException
forall a b. (a -> b) -> a -> b
$ Message -> Id
Message.id_ Message
message)

  TestName -> Spec -> Spec
Tasty.describe TestName
"symmetric" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    TestName -> Assertion -> Spec
Tasty.it TestName
"succeeds with a valid signature" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      Secret
secret <- Either InvalidSecret Secret -> IO Secret
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSecret Secret -> IO Secret)
-> (ByteString -> Either InvalidSecret Secret)
-> ByteString
-> IO Secret
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidSecret Secret
Secret.parse (ByteString -> IO Secret) -> ByteString -> IO Secret
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Message
message <- Either InvalidMessage Message -> IO Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> IO Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> IO Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> IO Message) -> ByteString -> IO Message
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> IO ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> IO ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> IO ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> IO ([UnknownSignature], Signatures))
-> ByteString -> IO ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1,IywpE5NXy+JdAScgR7j5Pt59GjmazD7iJuVsQoRZFyw="
      let actual :: Either VerificationException SymmetricSignature
actual = Secret
-> Message
-> Signatures
-> Either VerificationException SymmetricSignature
Verifier.symmetric Secret
secret Message
message Signatures
signatures
      SymmetricSignature
symmetricSignature <- Either InvalidSymmetricSignature SymmetricSignature
-> IO SymmetricSignature
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSymmetricSignature SymmetricSignature
 -> IO SymmetricSignature)
-> (ByteString
    -> Either InvalidSymmetricSignature SymmetricSignature)
-> ByteString
-> IO SymmetricSignature
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidSymmetricSignature SymmetricSignature
SymmetricSignature.parse (ByteString -> IO SymmetricSignature)
-> ByteString -> IO SymmetricSignature
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"IywpE5NXy+JdAScgR7j5Pt59GjmazD7iJuVsQoRZFyw="
      Either VerificationException SymmetricSignature
actual Either VerificationException SymmetricSignature
-> Either VerificationException SymmetricSignature -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= SymmetricSignature
-> Either VerificationException SymmetricSignature
forall a b. b -> Either a b
Right SymmetricSignature
symmetricSignature

    TestName -> Assertion -> Spec
Tasty.it TestName
"fails with an invalid signature" (Assertion -> Spec) -> Assertion -> Spec
forall a b. (a -> b) -> a -> b
$ do
      Secret
secret <- Either InvalidSecret Secret -> IO Secret
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSecret Secret -> IO Secret)
-> (ByteString -> Either InvalidSecret Secret)
-> ByteString
-> IO Secret
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidSecret Secret
Secret.parse (ByteString -> IO Secret) -> ByteString -> IO Secret
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"whsec_bXlzZWNyZXRrZXkxMjM0NQ=="
      Message
message <- Either InvalidMessage Message -> IO Message
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidMessage Message -> IO Message)
-> (ByteString -> Either InvalidMessage Message)
-> ByteString
-> IO Message
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Either InvalidMessage Message
Message.parse (ByteString -> IO Message) -> ByteString -> IO Message
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"i.0.Hello, world!"
      ([UnknownSignature]
_, Signatures
signatures) <- Either InvalidSignature ([UnknownSignature], Signatures)
-> IO ([UnknownSignature], Signatures)
forall e (m :: * -> *) a.
(Exception e, MonadThrow m) =>
Either e a -> m a
Either.throw (Either InvalidSignature ([UnknownSignature], Signatures)
 -> IO ([UnknownSignature], Signatures))
-> (ByteString
    -> Either InvalidSignature ([UnknownSignature], Signatures))
-> ByteString
-> IO ([UnknownSignature], Signatures)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString
-> Either InvalidSignature ([UnknownSignature], Signatures)
Signatures.parse (ByteString -> IO ([UnknownSignature], Signatures))
-> ByteString -> IO ([UnknownSignature], Signatures)
forall a b. (a -> b) -> a -> b
$ TestName -> ByteString
Ascii.pack TestName
"v1,0000000000000000000000000000000000000000000="
      let actual :: Either VerificationException SymmetricSignature
actual = Secret
-> Message
-> Signatures
-> Either VerificationException SymmetricSignature
Verifier.symmetric Secret
secret Message
message Signatures
signatures
      Either VerificationException SymmetricSignature
actual Either VerificationException SymmetricSignature
-> Either VerificationException SymmetricSignature -> Assertion
forall a. (Eq a, Show a, HasCallStack) => a -> a -> Assertion
@?= VerificationException
-> Either VerificationException SymmetricSignature
forall a b. a -> Either a b
Left (Id -> VerificationException
VerificationException.MkVerificationException (Id -> VerificationException) -> Id -> VerificationException
forall a b. (a -> b) -> a -> b
$ Message -> Id
Message.id_ Message
message)