-- Errors.hs: centralized error types for hOpenPGP
-- Copyright © 2012-2026  Clint Adams
-- This software is released under the terms of the Expat license.
-- (See the LICENSE file).
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}

module Codec.Encryption.OpenPGP.Types.Internal.Errors
    ( -- * Low-level cryptographic errors
      CipherError (..)
    , renderCipherError
    , EncodedSessionKeyError (..)
    , renderEncodedSessionKeyError
    , MDCFailure (..)
    , renderMDCFailure
    , CurveConversionError (..)
    , renderCurveConversionError
    , ECPointError (..)
    , renderECPointError
    , X25519OctetError (..)
    , renderX25519OctetError
    , ECDHOctetError (..)
    , renderECDHOctetError
    , KeyPktCoercionError (..)
    , renderKeyPktCoercionError
    , PacketCoercionError (..)
    , KeyringChunkParseError (..)
    , renderChunkParseError
    , KeyIdError (..)
    , renderKeyIdError
    , KeyInfoError (..)
    , KeySelectionError (..)
    , TKConversionError (..)
    , renderTKConversionError

      -- * Mid-level errors
    , S2KError (..)
    , renderS2KError
    , SecretKeyError (..)
    , renderSecretKeyError
    , SigningError (..)
    , renderSigningError
    , SignError (..)
    , renderSignError
    , VerificationError (..)
    , CriticalPacketError (..)
    , renderCriticalPacketError
    , renderVerificationError
    , OPSBuildError (..)
    , renderOPSBuildError
    , RecipientCapabilityError (..)
    , renderRecipientCapabilityError
    , PKESKEncryptError (..)
    , renderPKESKEncryptError
    , CompressionError (..)
    , renderCompressionError
    , PktParseErrorReason (..)
    , renderPktParseReason
    , PktValidationError (..)
    , renderPktValidationError
    , SKeyError (..)
    , renderSKeyError
    , PktParseError (..)
    , renderPktParseError
    , SerializeError (..)
    , renderSerializeError

      -- * AEAD / SEIPDv2 unified auth failures
    , AEADAuthFailure (..)
    , renderAEADAuthFailure
    , SEIPDv2Failure (..)
    , renderSEIPDv2Failure

      -- * Message-level errors
    , MessageParseFailure (..)
    , renderMessageParseFailure
    , MessageDecryptFailure (..)
    , renderMessageDecryptFailure
    , MessageEncryptFailure (..)
    , renderMessageEncryptFailure
    , PayloadDecryptFailure (..)
    , renderPayloadDecryptFailure

      -- * Decrypt-level errors
    , DecryptStructureError (..)
    , renderDecryptStructureError
    , DecryptOutcome (..)
    , renderDecryptOutcome
    , DecryptSessionKeyResolutionReport (..)
    , renderDecryptSessionKeyResolutionReport
    , DecryptReport (..)
    , renderDecryptReport
    , SKESKSessionKeyResolutionError (..)
    , renderSKESKSessionKeyResolutionError
    , PKESKX25519V3UnwrapError (..)
    , renderPKESKX25519V3UnwrapError
    , PKESKAttemptFailureKind (..)
    , PKESKAttemptFailure (..)
    , PKESKResolverAttemptAction (..)
    , PKESKResolverAttempt (..)
    , DecryptSessionKeyResolutionPath (..)

      -- * Top-level message error
    , MessageError (..)
    , renderMessageError
    ) where

import qualified Crypto.Error as CE
import qualified Crypto.PubKey.RSA.Types as RSA
import Data.ByteString (ByteString)
import Data.Containers.ListUtils (nubOrd)
import Data.Int (Int64)
import Data.List (intercalate)
import qualified Data.Set as Set
import Data.Text (Text)
import Data.Word (Word8)

import Codec.Encryption.OpenPGP.Types.Internal.Base
    ( AEADAlgorithm (..)
    , CompressionAlgorithm (..)
    , EightOctetKeyId (..)
    , Fingerprint (..)
    , HashAlgorithm (..)
    , KeyFlag (..)
    , KeyVersion (..)
    , PubKeyAlgorithm (..)
    , SigType (..)
    , SymmetricAlgorithm (..)
    )
import Codec.Encryption.OpenPGP.Types.Internal.PKITypes

-------------------------------------------------------------------------------
-- Low-level cryptographic errors
-------------------------------------------------------------------------------

-- | Errors that can arise from block-cipher operations in this library.
data CipherError
    = -- | The algorithm is not supported or not implemented.
      UnsupportedAlgorithm !SymmetricAlgorithm
    | -- | Cipher initialization failed (bad key material).
      CipherInitFailed !SymmetricAlgorithm !String
    | -- | A CFB or other block-cipher operation failed.
      CipherOperationFailed !String
    deriving (CipherError -> CipherError -> Bool
(CipherError -> CipherError -> Bool)
-> (CipherError -> CipherError -> Bool) -> Eq CipherError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CipherError -> CipherError -> Bool
== :: CipherError -> CipherError -> Bool
$c/= :: CipherError -> CipherError -> Bool
/= :: CipherError -> CipherError -> Bool
Eq, Int -> CipherError -> ShowS
[CipherError] -> ShowS
CipherError -> [Char]
(Int -> CipherError -> ShowS)
-> (CipherError -> [Char])
-> ([CipherError] -> ShowS)
-> Show CipherError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CipherError -> ShowS
showsPrec :: Int -> CipherError -> ShowS
$cshow :: CipherError -> [Char]
show :: CipherError -> [Char]
$cshowList :: [CipherError] -> ShowS
showList :: [CipherError] -> ShowS
Show)

renderCipherError :: CipherError -> String
renderCipherError :: CipherError -> [Char]
renderCipherError (UnsupportedAlgorithm SymmetricAlgorithm
sa) =
    [Char]
"unsupported symmetric algorithm: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
sa
renderCipherError (CipherInitFailed SymmetricAlgorithm
sa [Char]
err) =
    [Char]
"could not initialize cipher for " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
sa [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
err
renderCipherError (CipherOperationFailed [Char]
err) = [Char]
err

-------------------------------------------------------------------------------

data EncodedSessionKeyError
    = EncodedSessionKeyTooShort
    | EncodedSessionKeyUnsupportedAlgorithm !SymmetricAlgorithm
    | EncodedSessionKeyLengthMismatch !SymmetricAlgorithm !Int !Int
    | EncodedSessionKeyChecksumMismatch
    deriving (EncodedSessionKeyError -> EncodedSessionKeyError -> Bool
(EncodedSessionKeyError -> EncodedSessionKeyError -> Bool)
-> (EncodedSessionKeyError -> EncodedSessionKeyError -> Bool)
-> Eq EncodedSessionKeyError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EncodedSessionKeyError -> EncodedSessionKeyError -> Bool
== :: EncodedSessionKeyError -> EncodedSessionKeyError -> Bool
$c/= :: EncodedSessionKeyError -> EncodedSessionKeyError -> Bool
/= :: EncodedSessionKeyError -> EncodedSessionKeyError -> Bool
Eq, Int -> EncodedSessionKeyError -> ShowS
[EncodedSessionKeyError] -> ShowS
EncodedSessionKeyError -> [Char]
(Int -> EncodedSessionKeyError -> ShowS)
-> (EncodedSessionKeyError -> [Char])
-> ([EncodedSessionKeyError] -> ShowS)
-> Show EncodedSessionKeyError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EncodedSessionKeyError -> ShowS
showsPrec :: Int -> EncodedSessionKeyError -> ShowS
$cshow :: EncodedSessionKeyError -> [Char]
show :: EncodedSessionKeyError -> [Char]
$cshowList :: [EncodedSessionKeyError] -> ShowS
showList :: [EncodedSessionKeyError] -> ShowS
Show)

renderEncodedSessionKeyError :: EncodedSessionKeyError -> String
renderEncodedSessionKeyError :: EncodedSessionKeyError -> [Char]
renderEncodedSessionKeyError EncodedSessionKeyError
EncodedSessionKeyTooShort =
    [Char]
"encoded session key is too short"
renderEncodedSessionKeyError (EncodedSessionKeyUnsupportedAlgorithm SymmetricAlgorithm
sa) =
    [Char]
"unsupported algorithm in encoded session key: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
sa
renderEncodedSessionKeyError (EncodedSessionKeyLengthMismatch SymmetricAlgorithm
sa Int
expected Int
actual) =
    [Char]
"invalid session key length for "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
sa
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": expected "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
expected
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
", got "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
actual
renderEncodedSessionKeyError EncodedSessionKeyError
EncodedSessionKeyChecksumMismatch =
    [Char]
"encoded session key checksum mismatch"

-------------------------------------------------------------------------------

data MDCFailure
    = MDCTrailerMissing
    | MDCTrailerCorrupted
    | MDCDigestMismatch
    deriving (MDCFailure -> MDCFailure -> Bool
(MDCFailure -> MDCFailure -> Bool)
-> (MDCFailure -> MDCFailure -> Bool) -> Eq MDCFailure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MDCFailure -> MDCFailure -> Bool
== :: MDCFailure -> MDCFailure -> Bool
$c/= :: MDCFailure -> MDCFailure -> Bool
/= :: MDCFailure -> MDCFailure -> Bool
Eq, Int -> MDCFailure -> ShowS
[MDCFailure] -> ShowS
MDCFailure -> [Char]
(Int -> MDCFailure -> ShowS)
-> (MDCFailure -> [Char])
-> ([MDCFailure] -> ShowS)
-> Show MDCFailure
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MDCFailure -> ShowS
showsPrec :: Int -> MDCFailure -> ShowS
$cshow :: MDCFailure -> [Char]
show :: MDCFailure -> [Char]
$cshowList :: [MDCFailure] -> ShowS
showList :: [MDCFailure] -> ShowS
Show)

renderMDCFailure :: MDCFailure -> String
renderMDCFailure :: MDCFailure -> [Char]
renderMDCFailure MDCFailure
MDCTrailerMissing = [Char]
"MDC trailer missing"
renderMDCFailure MDCFailure
MDCTrailerCorrupted = [Char]
"MDC trailer corrupted"
renderMDCFailure MDCFailure
MDCDigestMismatch = [Char]
"MDC digest mismatch"

-------------------------------------------------------------------------------

-- | EC point encoding errors
data ECPointError
    = ECPointErrorReasonEmpty
    | ECPointErrorReasonUnknownType
        { ECPointError -> Word8
ecPointFirstOctet :: Word8
        }
    | ECPointErrorReasonOddCoordinateLength
    deriving (ECPointError -> ECPointError -> Bool
(ECPointError -> ECPointError -> Bool)
-> (ECPointError -> ECPointError -> Bool) -> Eq ECPointError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ECPointError -> ECPointError -> Bool
== :: ECPointError -> ECPointError -> Bool
$c/= :: ECPointError -> ECPointError -> Bool
/= :: ECPointError -> ECPointError -> Bool
Eq, Int -> ECPointError -> ShowS
[ECPointError] -> ShowS
ECPointError -> [Char]
(Int -> ECPointError -> ShowS)
-> (ECPointError -> [Char])
-> ([ECPointError] -> ShowS)
-> Show ECPointError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ECPointError -> ShowS
showsPrec :: Int -> ECPointError -> ShowS
$cshow :: ECPointError -> [Char]
show :: ECPointError -> [Char]
$cshowList :: [ECPointError] -> ShowS
showList :: [ECPointError] -> ShowS
Show)

renderECPointError :: ECPointError -> String
renderECPointError :: ECPointError -> [Char]
renderECPointError ECPointError
ECPointErrorReasonEmpty = [Char]
"empty EC point encoding"
renderECPointError (ECPointErrorReasonUnknownType Word8
firstOctet) =
    [Char]
"unknown type of point: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
firstOctet
renderECPointError ECPointError
ECPointErrorReasonOddCoordinateLength =
    [Char]
"malformed EC point encoding: odd coordinate payload length"

-- | X25519 v3 octet layout errors
data X25519OctetError
    = X25519OctetErrorReasonTooShort
    | X25519OctetErrorReasonInconsistentESKLength
    | X25519OctetErrorReasonMissingSymmetricAlgorithm
    | X25519OctetErrorReasonUnsupportedSymmetricAlgorithm
        { X25519OctetError -> Word8
x25519SymmetricAlgorithmOctet :: Word8
        }
    deriving (X25519OctetError -> X25519OctetError -> Bool
(X25519OctetError -> X25519OctetError -> Bool)
-> (X25519OctetError -> X25519OctetError -> Bool)
-> Eq X25519OctetError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: X25519OctetError -> X25519OctetError -> Bool
== :: X25519OctetError -> X25519OctetError -> Bool
$c/= :: X25519OctetError -> X25519OctetError -> Bool
/= :: X25519OctetError -> X25519OctetError -> Bool
Eq, Int -> X25519OctetError -> ShowS
[X25519OctetError] -> ShowS
X25519OctetError -> [Char]
(Int -> X25519OctetError -> ShowS)
-> (X25519OctetError -> [Char])
-> ([X25519OctetError] -> ShowS)
-> Show X25519OctetError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> X25519OctetError -> ShowS
showsPrec :: Int -> X25519OctetError -> ShowS
$cshow :: X25519OctetError -> [Char]
show :: X25519OctetError -> [Char]
$cshowList :: [X25519OctetError] -> ShowS
showList :: [X25519OctetError] -> ShowS
Show)

renderX25519OctetError :: X25519OctetError -> String
renderX25519OctetError :: X25519OctetError -> [Char]
renderX25519OctetError X25519OctetError
X25519OctetErrorReasonTooShort =
    [Char]
"X25519 v3 PKESK octet layout is too short"
renderX25519OctetError X25519OctetError
X25519OctetErrorReasonInconsistentESKLength =
    [Char]
"X25519 v3 PKESK octet layout has inconsistent ESK length"
renderX25519OctetError X25519OctetError
X25519OctetErrorReasonMissingSymmetricAlgorithm =
    [Char]
"X25519 v3 PKESK octet layout must include a symmetric algorithm octet"
renderX25519OctetError (X25519OctetErrorReasonUnsupportedSymmetricAlgorithm Word8
algo) =
    [Char]
"X25519 v3 PKESK octet layout has unsupported symmetric algorithm octet "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
algo

-- | ECDH RFC6637 octet layout errors
data ECDHOctetError
    = ECDHOctetErrorReasonMissingWrappedKeyLength
    | ECDHOctetErrorReasonWrappedKeyLengthMismatch
        { ECDHOctetError -> Int
ecdhDeclaredLength :: Int
        , ECDHOctetError -> Int
ecdhActualLength :: Int
        }
    | ECDHOctetErrorReasonInvalidWrappedKeySize
        { ECDHOctetError -> Int
ecdhWrappedKeySize :: Int
        }
    deriving (ECDHOctetError -> ECDHOctetError -> Bool
(ECDHOctetError -> ECDHOctetError -> Bool)
-> (ECDHOctetError -> ECDHOctetError -> Bool) -> Eq ECDHOctetError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ECDHOctetError -> ECDHOctetError -> Bool
== :: ECDHOctetError -> ECDHOctetError -> Bool
$c/= :: ECDHOctetError -> ECDHOctetError -> Bool
/= :: ECDHOctetError -> ECDHOctetError -> Bool
Eq, Int -> ECDHOctetError -> ShowS
[ECDHOctetError] -> ShowS
ECDHOctetError -> [Char]
(Int -> ECDHOctetError -> ShowS)
-> (ECDHOctetError -> [Char])
-> ([ECDHOctetError] -> ShowS)
-> Show ECDHOctetError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ECDHOctetError -> ShowS
showsPrec :: Int -> ECDHOctetError -> ShowS
$cshow :: ECDHOctetError -> [Char]
show :: ECDHOctetError -> [Char]
$cshowList :: [ECDHOctetError] -> ShowS
showList :: [ECDHOctetError] -> ShowS
Show)

renderECDHOctetError :: ECDHOctetError -> String
renderECDHOctetError :: ECDHOctetError -> [Char]
renderECDHOctetError ECDHOctetError
ECDHOctetErrorReasonMissingWrappedKeyLength =
    [Char]
"ECDH v3 PKESK RFC6637 octet layout: missing wrapped-key length octet after ephemeral MPI"
renderECDHOctetError (ECDHOctetErrorReasonWrappedKeyLengthMismatch Int
declared Int
actual) =
    [Char]
"ECDH v3 PKESK RFC6637 octet layout: wrapped key length field "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
declared
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" does not match body length "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
actual
renderECDHOctetError (ECDHOctetErrorReasonInvalidWrappedKeySize Int
sz) =
    [Char]
"ECDH v3 PKESK RFC6637 octet layout: wrapped key length "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
sz
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" is not a valid RFC 3394 wrapped key size"

-------------------------------------------------------------------------------

data KeyPktCoercionError pkt
    = NotAKeyPacket pkt
    | ExpectedPublicKeyPacket pkt
    | ExpectedSecretKeyPacket pkt
    deriving (KeyPktCoercionError pkt -> KeyPktCoercionError pkt -> Bool
(KeyPktCoercionError pkt -> KeyPktCoercionError pkt -> Bool)
-> (KeyPktCoercionError pkt -> KeyPktCoercionError pkt -> Bool)
-> Eq (KeyPktCoercionError pkt)
forall pkt.
Eq pkt =>
KeyPktCoercionError pkt -> KeyPktCoercionError pkt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall pkt.
Eq pkt =>
KeyPktCoercionError pkt -> KeyPktCoercionError pkt -> Bool
== :: KeyPktCoercionError pkt -> KeyPktCoercionError pkt -> Bool
$c/= :: forall pkt.
Eq pkt =>
KeyPktCoercionError pkt -> KeyPktCoercionError pkt -> Bool
/= :: KeyPktCoercionError pkt -> KeyPktCoercionError pkt -> Bool
Eq, Int -> KeyPktCoercionError pkt -> ShowS
[KeyPktCoercionError pkt] -> ShowS
KeyPktCoercionError pkt -> [Char]
(Int -> KeyPktCoercionError pkt -> ShowS)
-> (KeyPktCoercionError pkt -> [Char])
-> ([KeyPktCoercionError pkt] -> ShowS)
-> Show (KeyPktCoercionError pkt)
forall pkt. Show pkt => Int -> KeyPktCoercionError pkt -> ShowS
forall pkt. Show pkt => [KeyPktCoercionError pkt] -> ShowS
forall pkt. Show pkt => KeyPktCoercionError pkt -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall pkt. Show pkt => Int -> KeyPktCoercionError pkt -> ShowS
showsPrec :: Int -> KeyPktCoercionError pkt -> ShowS
$cshow :: forall pkt. Show pkt => KeyPktCoercionError pkt -> [Char]
show :: KeyPktCoercionError pkt -> [Char]
$cshowList :: forall pkt. Show pkt => [KeyPktCoercionError pkt] -> ShowS
showList :: [KeyPktCoercionError pkt] -> ShowS
Show)

renderKeyPktCoercionError
    :: Show pkt => KeyPktCoercionError pkt -> String
renderKeyPktCoercionError :: forall pkt. Show pkt => KeyPktCoercionError pkt -> [Char]
renderKeyPktCoercionError (NotAKeyPacket pkt
pkt) =
    [Char]
"not a key packet: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ pkt -> [Char]
forall a. Show a => a -> [Char]
show pkt
pkt
renderKeyPktCoercionError (ExpectedPublicKeyPacket pkt
pkt) =
    [Char]
"expected a public key packet, got: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ pkt -> [Char]
forall a. Show a => a -> [Char]
show pkt
pkt
renderKeyPktCoercionError (ExpectedSecretKeyPacket pkt
pkt) =
    [Char]
"expected a secret key packet, got: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ pkt -> [Char]
forall a. Show a => a -> [Char]
show pkt
pkt

-------------------------------------------------------------------------------

data PacketCoercionError
    = PacketCoercionError
    { PacketCoercionError -> [Char]
pceExpected :: !String
    , PacketCoercionError -> Word8
pceActualTag :: !Word8
    }
    deriving (PacketCoercionError -> PacketCoercionError -> Bool
(PacketCoercionError -> PacketCoercionError -> Bool)
-> (PacketCoercionError -> PacketCoercionError -> Bool)
-> Eq PacketCoercionError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PacketCoercionError -> PacketCoercionError -> Bool
== :: PacketCoercionError -> PacketCoercionError -> Bool
$c/= :: PacketCoercionError -> PacketCoercionError -> Bool
/= :: PacketCoercionError -> PacketCoercionError -> Bool
Eq, Int -> PacketCoercionError -> ShowS
[PacketCoercionError] -> ShowS
PacketCoercionError -> [Char]
(Int -> PacketCoercionError -> ShowS)
-> (PacketCoercionError -> [Char])
-> ([PacketCoercionError] -> ShowS)
-> Show PacketCoercionError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PacketCoercionError -> ShowS
showsPrec :: Int -> PacketCoercionError -> ShowS
$cshow :: PacketCoercionError -> [Char]
show :: PacketCoercionError -> [Char]
$cshowList :: [PacketCoercionError] -> ShowS
showList :: [PacketCoercionError] -> ShowS
Show)

-------------------------------------------------------------------------------

data KeyringChunkParseError
    = ChunkFailureBeforeInput !String
    | ChunkUnexpectedFinalizationFailure
    | ChunkParserFailure !String
    deriving (KeyringChunkParseError -> KeyringChunkParseError -> Bool
(KeyringChunkParseError -> KeyringChunkParseError -> Bool)
-> (KeyringChunkParseError -> KeyringChunkParseError -> Bool)
-> Eq KeyringChunkParseError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyringChunkParseError -> KeyringChunkParseError -> Bool
== :: KeyringChunkParseError -> KeyringChunkParseError -> Bool
$c/= :: KeyringChunkParseError -> KeyringChunkParseError -> Bool
/= :: KeyringChunkParseError -> KeyringChunkParseError -> Bool
Eq, Int -> KeyringChunkParseError -> ShowS
[KeyringChunkParseError] -> ShowS
KeyringChunkParseError -> [Char]
(Int -> KeyringChunkParseError -> ShowS)
-> (KeyringChunkParseError -> [Char])
-> ([KeyringChunkParseError] -> ShowS)
-> Show KeyringChunkParseError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyringChunkParseError -> ShowS
showsPrec :: Int -> KeyringChunkParseError -> ShowS
$cshow :: KeyringChunkParseError -> [Char]
show :: KeyringChunkParseError -> [Char]
$cshowList :: [KeyringChunkParseError] -> ShowS
showList :: [KeyringChunkParseError] -> ShowS
Show)

renderChunkParseError :: KeyringChunkParseError -> String
renderChunkParseError :: KeyringChunkParseError -> [Char]
renderChunkParseError (ChunkFailureBeforeInput [Char]
err) = [Char]
err
renderChunkParseError KeyringChunkParseError
ChunkUnexpectedFinalizationFailure =
    [Char]
"unexpected finalization of keyring chunk"
renderChunkParseError (ChunkParserFailure [Char]
err) = [Char]
err

-------------------------------------------------------------------------------

data KeyIdError
    = KeyIdUnsupportedNonRSAV3
    | KeyIdFingerprintLengthMismatch !Int
    deriving (KeyIdError -> KeyIdError -> Bool
(KeyIdError -> KeyIdError -> Bool)
-> (KeyIdError -> KeyIdError -> Bool) -> Eq KeyIdError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyIdError -> KeyIdError -> Bool
== :: KeyIdError -> KeyIdError -> Bool
$c/= :: KeyIdError -> KeyIdError -> Bool
/= :: KeyIdError -> KeyIdError -> Bool
Eq, Int -> KeyIdError -> ShowS
[KeyIdError] -> ShowS
KeyIdError -> [Char]
(Int -> KeyIdError -> ShowS)
-> (KeyIdError -> [Char])
-> ([KeyIdError] -> ShowS)
-> Show KeyIdError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyIdError -> ShowS
showsPrec :: Int -> KeyIdError -> ShowS
$cshow :: KeyIdError -> [Char]
show :: KeyIdError -> [Char]
$cshowList :: [KeyIdError] -> ShowS
showList :: [KeyIdError] -> ShowS
Show)

renderKeyIdError :: KeyIdError -> String
renderKeyIdError :: KeyIdError -> [Char]
renderKeyIdError KeyIdError
KeyIdUnsupportedNonRSAV3 =
    [Char]
"unsupported non-RSA v3 public key algorithm for eight-octet key ID"
renderKeyIdError (KeyIdFingerprintLengthMismatch Int
fpLen) =
    [Char]
"cannot derive an eight-octet key ID from a "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
fpLen
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"-octet fingerprint (expected 20)"

-------------------------------------------------------------------------------

data KeyInfoError
    = KeyInfoUnsupportedAlgorithm !PKey
    deriving (KeyInfoError -> KeyInfoError -> Bool
(KeyInfoError -> KeyInfoError -> Bool)
-> (KeyInfoError -> KeyInfoError -> Bool) -> Eq KeyInfoError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyInfoError -> KeyInfoError -> Bool
== :: KeyInfoError -> KeyInfoError -> Bool
$c/= :: KeyInfoError -> KeyInfoError -> Bool
/= :: KeyInfoError -> KeyInfoError -> Bool
Eq, Int -> KeyInfoError -> ShowS
[KeyInfoError] -> ShowS
KeyInfoError -> [Char]
(Int -> KeyInfoError -> ShowS)
-> (KeyInfoError -> [Char])
-> ([KeyInfoError] -> ShowS)
-> Show KeyInfoError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyInfoError -> ShowS
showsPrec :: Int -> KeyInfoError -> ShowS
$cshow :: KeyInfoError -> [Char]
show :: KeyInfoError -> [Char]
$cshowList :: [KeyInfoError] -> ShowS
showList :: [KeyInfoError] -> ShowS
Show)

-------------------------------------------------------------------------------

data KeySelectionError
    = KeySelectionParseError !Text
    deriving (KeySelectionError -> KeySelectionError -> Bool
(KeySelectionError -> KeySelectionError -> Bool)
-> (KeySelectionError -> KeySelectionError -> Bool)
-> Eq KeySelectionError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeySelectionError -> KeySelectionError -> Bool
== :: KeySelectionError -> KeySelectionError -> Bool
$c/= :: KeySelectionError -> KeySelectionError -> Bool
/= :: KeySelectionError -> KeySelectionError -> Bool
Eq, Int -> KeySelectionError -> ShowS
[KeySelectionError] -> ShowS
KeySelectionError -> [Char]
(Int -> KeySelectionError -> ShowS)
-> (KeySelectionError -> [Char])
-> ([KeySelectionError] -> ShowS)
-> Show KeySelectionError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeySelectionError -> ShowS
showsPrec :: Int -> KeySelectionError -> ShowS
$cshow :: KeySelectionError -> [Char]
show :: KeySelectionError -> [Char]
$cshowList :: [KeySelectionError] -> ShowS
showList :: [KeySelectionError] -> ShowS
Show)

-------------------------------------------------------------------------------

data TKConversionError
    = PublicSubkeyHasPrimaryRole
    | SecretSubkeyHasPrimaryRole
    | ExpectedPublicSubkeyPacket !Word8
    | ExpectedSecretSubkeyPacket !Word8
    | ExpectedPublicPrimaryKeyPacket !Word8
    | ExpectedSecretPrimaryKeyPacket !Word8
    deriving (TKConversionError -> TKConversionError -> Bool
(TKConversionError -> TKConversionError -> Bool)
-> (TKConversionError -> TKConversionError -> Bool)
-> Eq TKConversionError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TKConversionError -> TKConversionError -> Bool
== :: TKConversionError -> TKConversionError -> Bool
$c/= :: TKConversionError -> TKConversionError -> Bool
/= :: TKConversionError -> TKConversionError -> Bool
Eq, Int -> TKConversionError -> ShowS
[TKConversionError] -> ShowS
TKConversionError -> [Char]
(Int -> TKConversionError -> ShowS)
-> (TKConversionError -> [Char])
-> ([TKConversionError] -> ShowS)
-> Show TKConversionError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TKConversionError -> ShowS
showsPrec :: Int -> TKConversionError -> ShowS
$cshow :: TKConversionError -> [Char]
show :: TKConversionError -> [Char]
$cshowList :: [TKConversionError] -> ShowS
showList :: [TKConversionError] -> ShowS
Show)

renderTKConversionError :: TKConversionError -> String
renderTKConversionError :: TKConversionError -> [Char]
renderTKConversionError TKConversionError
PublicSubkeyHasPrimaryRole =
    [Char]
"expected subkey, got primary key"
renderTKConversionError TKConversionError
SecretSubkeyHasPrimaryRole =
    [Char]
"expected subkey, got primary key"
renderTKConversionError (ExpectedPublicSubkeyPacket Word8
tag) =
    [Char]
"expected public subkey packet (tag " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
tag [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderTKConversionError (ExpectedSecretSubkeyPacket Word8
tag) =
    [Char]
"expected secret subkey packet (tag " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
tag [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderTKConversionError (ExpectedPublicPrimaryKeyPacket Word8
tag) =
    [Char]
"expected public primary key packet (tag " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
tag [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderTKConversionError (ExpectedSecretPrimaryKeyPacket Word8
tag) =
    [Char]
"expected secret primary key packet (tag " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
tag [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"

-------------------------------------------------------------------------------
-- Mid-level errors
-------------------------------------------------------------------------------

data S2KError
    = S2KUnsupportedAlgorithm !CipherError
    | S2KUnsupportedSpecifier !Word8
    | S2KUnsupportedHashAlgorithm !HashAlgorithm
    | S2KArgon2ParamError !String
    | S2KArgon2Failed !String
    | S2KEncryptedSessionKeyCipherError !CipherError
    | S2KEncryptedSessionKeyDecodeError !EncodedSessionKeyError
    deriving (S2KError -> S2KError -> Bool
(S2KError -> S2KError -> Bool)
-> (S2KError -> S2KError -> Bool) -> Eq S2KError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: S2KError -> S2KError -> Bool
== :: S2KError -> S2KError -> Bool
$c/= :: S2KError -> S2KError -> Bool
/= :: S2KError -> S2KError -> Bool
Eq, Int -> S2KError -> ShowS
[S2KError] -> ShowS
S2KError -> [Char]
(Int -> S2KError -> ShowS)
-> (S2KError -> [Char]) -> ([S2KError] -> ShowS) -> Show S2KError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> S2KError -> ShowS
showsPrec :: Int -> S2KError -> ShowS
$cshow :: S2KError -> [Char]
show :: S2KError -> [Char]
$cshowList :: [S2KError] -> ShowS
showList :: [S2KError] -> ShowS
Show)

renderS2KError :: S2KError -> String
renderS2KError :: S2KError -> [Char]
renderS2KError (S2KUnsupportedAlgorithm CipherError
err) = [Char]
"S2K: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CipherError -> [Char]
renderCipherError CipherError
err
renderS2KError (S2KUnsupportedSpecifier Word8
t) =
    [Char]
"S2K: unsupported S2K type " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
t
renderS2KError (S2KUnsupportedHashAlgorithm HashAlgorithm
ha) =
    [Char]
"S2K: unsupported hash algorithm for S2K: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ HashAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show HashAlgorithm
ha
renderS2KError (S2KArgon2ParamError [Char]
msg) =
    [Char]
"S2K: Argon2 parameter error: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
msg
renderS2KError (S2KArgon2Failed [Char]
msg) =
    [Char]
"S2K: Argon2 KDF failed: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
msg
renderS2KError (S2KEncryptedSessionKeyCipherError CipherError
err) =
    [Char]
"S2K: encrypted session key decrypt failed: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CipherError -> [Char]
renderCipherError CipherError
err
renderS2KError (S2KEncryptedSessionKeyDecodeError EncodedSessionKeyError
err) =
    [Char]
"S2K: encrypted session key decode failed: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ EncodedSessionKeyError -> [Char]
renderEncodedSessionKeyError EncodedSessionKeyError
err

-------------------------------------------------------------------------------

data SecretKeyError
    = SecretKeyDecryptNotUnencrypted
    | SecretKeyEncryptOptionsInconsistent
    | SecretKeyDecryptCipherError !CipherError
    | SecretKeyEncryptCipherError !CipherError
    | SecretKeyDecryptAddendumError !SKAddendumKeyVersionError
    | SecretKeyEncryptAddendumError !SKAddendumKeyVersionError
    | SecretKeyPolicyCipherError !CipherError
    | SecretKeyPolicySaltLengthMismatch !Int !Int
    | SecretKeyPolicyNonceLengthMismatch !Int !Int
    | SecretKeyUnsupportedLegacyProtection
    | SecretKeyDecodeError !String
    | SecretKeyChecksumError !String
    | SecretKeyAEADError !String
    | SecretKeyAuthError !String
    | SecretKeyInvalidS2KMode !S2KError
    | SecretKeyAEADModeCrypto !CE.CryptoError
    | SecretKeyAEADModeUnsupportedAlgo !AEADAlgorithm
    | SecretKeyAEADModeUnsupportedCipher !SymmetricAlgorithm
    | SecretKeyInvalidNonceSize !String
    | SecretKeyPayloadTooShort !String
    | SecretKeyTrailingBytes !String
    | SecretKeyRSAInverseError
    | SecretKeyEncodeError !SerializeError
    deriving (SecretKeyError -> SecretKeyError -> Bool
(SecretKeyError -> SecretKeyError -> Bool)
-> (SecretKeyError -> SecretKeyError -> Bool) -> Eq SecretKeyError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SecretKeyError -> SecretKeyError -> Bool
== :: SecretKeyError -> SecretKeyError -> Bool
$c/= :: SecretKeyError -> SecretKeyError -> Bool
/= :: SecretKeyError -> SecretKeyError -> Bool
Eq, Int -> SecretKeyError -> ShowS
[SecretKeyError] -> ShowS
SecretKeyError -> [Char]
(Int -> SecretKeyError -> ShowS)
-> (SecretKeyError -> [Char])
-> ([SecretKeyError] -> ShowS)
-> Show SecretKeyError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SecretKeyError -> ShowS
showsPrec :: Int -> SecretKeyError -> ShowS
$cshow :: SecretKeyError -> [Char]
show :: SecretKeyError -> [Char]
$cshowList :: [SecretKeyError] -> ShowS
showList :: [SecretKeyError] -> ShowS
Show)

renderSecretKeyError :: SecretKeyError -> String
renderSecretKeyError :: SecretKeyError -> [Char]
renderSecretKeyError SecretKeyError
SecretKeyDecryptNotUnencrypted =
    [Char]
"decrypted secret key material was not in unencrypted form"
renderSecretKeyError SecretKeyError
SecretKeyEncryptOptionsInconsistent =
    [Char]
"skeoGenerateSaltAndIV is False but skeoSalt or skeoIV are Nothing"
renderSecretKeyError (SecretKeyDecryptCipherError CipherError
err) = CipherError -> [Char]
renderCipherError CipherError
err
renderSecretKeyError (SecretKeyEncryptCipherError CipherError
err) = CipherError -> [Char]
renderCipherError CipherError
err
renderSecretKeyError (SecretKeyDecryptAddendumError SKAddendumKeyVersionError
err) =
    SKAddendumKeyVersionError -> [Char]
renderSKAddendumKeyVersionError SKAddendumKeyVersionError
err
renderSecretKeyError (SecretKeyEncryptAddendumError SKAddendumKeyVersionError
err) =
    SKAddendumKeyVersionError -> [Char]
renderSKAddendumKeyVersionError SKAddendumKeyVersionError
err
renderSecretKeyError (SecretKeyPolicyCipherError CipherError
err) = CipherError -> [Char]
renderCipherError CipherError
err
renderSecretKeyError (SecretKeyPolicySaltLengthMismatch Int
expected Int
_actual) =
    [Char]
"secret key S2K salt must be " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
expected [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" octets"
renderSecretKeyError (SecretKeyPolicyNonceLengthMismatch Int
expected Int
_actual) =
    [Char]
"v6 secret key AEAD nonce must be " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
expected [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" octets"
renderSecretKeyError SecretKeyError
SecretKeyUnsupportedLegacyProtection =
    [Char]
"unsupported legacy secret key protection"
renderSecretKeyError (SecretKeyDecodeError [Char]
err) = [Char]
err
renderSecretKeyError (SecretKeyChecksumError [Char]
err) = [Char]
err
renderSecretKeyError (SecretKeyAEADError [Char]
err) = [Char]
err
renderSecretKeyError (SecretKeyAuthError [Char]
err) = [Char]
err
renderSecretKeyError (SecretKeyInvalidS2KMode S2KError
err) = S2KError -> [Char]
renderS2KError S2KError
err
renderSecretKeyError (SecretKeyAEADModeCrypto CryptoError
err) = CryptoError -> [Char]
forall a. Show a => a -> [Char]
show CryptoError
err
renderSecretKeyError (SecretKeyAEADModeUnsupportedAlgo AEADAlgorithm
aa) =
    [Char]
"unsupported AEAD mode: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ AEADAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show AEADAlgorithm
aa
renderSecretKeyError (SecretKeyAEADModeUnsupportedCipher SymmetricAlgorithm
sa) =
    [Char]
"unsupported secret-key AEAD symmetric algorithm: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
sa
renderSecretKeyError (SecretKeyInvalidNonceSize [Char]
err) = [Char]
err
renderSecretKeyError (SecretKeyPayloadTooShort [Char]
err) = [Char]
err
renderSecretKeyError (SecretKeyTrailingBytes [Char]
err) = [Char]
err
renderSecretKeyError SecretKeyError
SecretKeyRSAInverseError =
    [Char]
"could not derive RSA multiplicative inverse while encrypting secret key"
renderSecretKeyError (SecretKeyEncodeError SerializeError
err) = SerializeError -> [Char]
renderSerializeError SerializeError
err

-------------------------------------------------------------------------------

data SigningError
    = SigningSignError !SignError
    | SigningNoSignersAvailable
    | SigningInvalidTarget !ByteString
    | SigningKeyNotSigningCapable !ByteString
    | SigningKeyExpired !ByteString
    | SigningKeyNotYetValid !ByteString
    deriving (SigningError -> SigningError -> Bool
(SigningError -> SigningError -> Bool)
-> (SigningError -> SigningError -> Bool) -> Eq SigningError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SigningError -> SigningError -> Bool
== :: SigningError -> SigningError -> Bool
$c/= :: SigningError -> SigningError -> Bool
/= :: SigningError -> SigningError -> Bool
Eq, Int -> SigningError -> ShowS
[SigningError] -> ShowS
SigningError -> [Char]
(Int -> SigningError -> ShowS)
-> (SigningError -> [Char])
-> ([SigningError] -> ShowS)
-> Show SigningError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SigningError -> ShowS
showsPrec :: Int -> SigningError -> ShowS
$cshow :: SigningError -> [Char]
show :: SigningError -> [Char]
$cshowList :: [SigningError] -> ShowS
showList :: [SigningError] -> ShowS
Show)

renderSigningError :: SigningError -> String
renderSigningError :: SigningError -> [Char]
renderSigningError (SigningSignError SignError
e) = SignError -> [Char]
renderSignError SignError
e
renderSigningError SigningError
SigningNoSignersAvailable =
    [Char]
"no signing-capable keys available"
renderSigningError (SigningInvalidTarget ByteString
target) =
    [Char]
"invalid signing target: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> [Char]
forall a. Show a => a -> [Char]
show ByteString
target
renderSigningError (SigningKeyNotSigningCapable ByteString
keyId) =
    [Char]
"key is not signing-capable: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> [Char]
forall a. Show a => a -> [Char]
show ByteString
keyId
renderSigningError (SigningKeyExpired ByteString
keyId) =
    [Char]
"key has expired: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> [Char]
forall a. Show a => a -> [Char]
show ByteString
keyId
renderSigningError (SigningKeyNotYetValid ByteString
keyId) =
    [Char]
"key is not yet valid: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> [Char]
forall a. Show a => a -> [Char]
show ByteString
keyId

-------------------------------------------------------------------------------

data SignError
    = SignBackendErrorRSA !RSA.Error
    | SignBackendErrorCrypto !CE.CryptoError
    | SignBackendErrorUnsupportedHash !HashAlgorithm
    | SignBackendErrorHashTooShort
    | SignBackendErrorNoV6SaltSize !HashAlgorithm
    | SignBackendErrorUnsupportedKeyTypeV4 !PubKeyAlgorithm
    | SignBackendErrorUnsupportedKeyTypeV6 !PubKeyAlgorithm
    | SignBackendErrorOPSBuild !OPSBuildError
    | SignBackendErrorKeyId !KeyIdError
    | SignUnsupportedCertificationType !SigType
    | SignUnsupportedKeySignatureType !SigType
    | SignV6SaltSizeMismatch !HashAlgorithm !Word8 !Int
    | SignProducedWrongLength !String !Int !Int
    deriving (SignError -> SignError -> Bool
(SignError -> SignError -> Bool)
-> (SignError -> SignError -> Bool) -> Eq SignError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SignError -> SignError -> Bool
== :: SignError -> SignError -> Bool
$c/= :: SignError -> SignError -> Bool
/= :: SignError -> SignError -> Bool
Eq, Int -> SignError -> ShowS
[SignError] -> ShowS
SignError -> [Char]
(Int -> SignError -> ShowS)
-> (SignError -> [Char])
-> ([SignError] -> ShowS)
-> Show SignError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SignError -> ShowS
showsPrec :: Int -> SignError -> ShowS
$cshow :: SignError -> [Char]
show :: SignError -> [Char]
$cshowList :: [SignError] -> ShowS
showList :: [SignError] -> ShowS
Show)

renderSignError :: SignError -> String
renderSignError :: SignError -> [Char]
renderSignError (SignBackendErrorRSA Error
err) =
    [Char]
"signing backend error: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Error -> [Char]
forall a. Show a => a -> [Char]
show Error
err
renderSignError (SignBackendErrorCrypto CryptoError
err) =
    [Char]
"signing backend error: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CryptoError -> [Char]
forall a. Show a => a -> [Char]
show CryptoError
err
renderSignError (SignBackendErrorUnsupportedHash HashAlgorithm
ha) =
    [Char]
"signing backend error: unsupported hash algorithm for left16 derivation: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ HashAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show HashAlgorithm
ha
renderSignError SignError
SignBackendErrorHashTooShort =
    [Char]
"signing backend error: hash output too short to derive left16"
renderSignError (SignBackendErrorNoV6SaltSize HashAlgorithm
ha) =
    [Char]
"signing backend error: signature hash algorithm does not define a V6 salt size: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ HashAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show HashAlgorithm
ha
renderSignError (SignBackendErrorUnsupportedKeyTypeV4 PubKeyAlgorithm
pka) =
    [Char]
"signing backend error: unsupported signing key type for V4 ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderSignError (SignBackendErrorUnsupportedKeyTypeV6 PubKeyAlgorithm
pka) =
    [Char]
"signing backend error: unsupported signing key type for V6 ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderSignError (SignBackendErrorOPSBuild OPSBuildError
err) =
    [Char]
"signing backend error: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ OPSBuildError -> [Char]
renderOPSBuildError OPSBuildError
err
renderSignError (SignBackendErrorKeyId KeyIdError
err) =
    [Char]
"signing backend error: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ KeyIdError -> [Char]
renderKeyIdError KeyIdError
err
renderSignError (SignUnsupportedCertificationType SigType
t) =
    [Char]
"unsupported certification signature type: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SigType -> [Char]
forall a. Show a => a -> [Char]
show SigType
t
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" (expected one of GenericCert/PersonaCert/CasualCert/PositiveCert)"
renderSignError (SignUnsupportedKeySignatureType SigType
t) =
    [Char]
"unsupported key signature type: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SigType -> [Char]
forall a. Show a => a -> [Char]
show SigType
t
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" (expected DirectKeySignature or KeyRevocationSig)"
renderSignError (SignV6SaltSizeMismatch HashAlgorithm
ha Word8
expected Int
actual) =
    [Char]
"v6 signature salt size mismatch for "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ HashAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show HashAlgorithm
ha
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": expected "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
expected
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
", got "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
actual
renderSignError (SignProducedWrongLength [Char]
algo Int
expected Int
actual) =
    [Char]
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" produced a non-"
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
expected
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"-byte signature (got "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
actual
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"

-------------------------------------------------------------------------------

data CriticalPacketError
    = UnknownCriticalPacket !Word8
    | BrokenCriticalPacket !Word8 !String
    deriving (CriticalPacketError -> CriticalPacketError -> Bool
(CriticalPacketError -> CriticalPacketError -> Bool)
-> (CriticalPacketError -> CriticalPacketError -> Bool)
-> Eq CriticalPacketError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CriticalPacketError -> CriticalPacketError -> Bool
== :: CriticalPacketError -> CriticalPacketError -> Bool
$c/= :: CriticalPacketError -> CriticalPacketError -> Bool
/= :: CriticalPacketError -> CriticalPacketError -> Bool
Eq, Int -> CriticalPacketError -> ShowS
[CriticalPacketError] -> ShowS
CriticalPacketError -> [Char]
(Int -> CriticalPacketError -> ShowS)
-> (CriticalPacketError -> [Char])
-> ([CriticalPacketError] -> ShowS)
-> Show CriticalPacketError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CriticalPacketError -> ShowS
showsPrec :: Int -> CriticalPacketError -> ShowS
$cshow :: CriticalPacketError -> [Char]
show :: CriticalPacketError -> [Char]
$cshowList :: [CriticalPacketError] -> ShowS
showList :: [CriticalPacketError] -> ShowS
Show)

renderCriticalPacketError :: CriticalPacketError -> String
renderCriticalPacketError :: CriticalPacketError -> [Char]
renderCriticalPacketError (UnknownCriticalPacket Word8
t) =
    [Char]
"unknown critical packet type (" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
t [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderCriticalPacketError (BrokenCriticalPacket Word8
t [Char]
err) =
    [Char]
"broken critical packet type " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
t [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
err

-------------------------------------------------------------------------------

data VerificationError
    = IssuerSubpacketMismatch
    | IssuerSubpacketUncheckable !KeyIdError
    | IssuerKeyIdProhibitedInV6Signature
    | IssuerFingerprintSubpacketMismatch
    | UnsupportedCriticalSubpacket !SigType
    | VerificationCriticalPacketError !CriticalPacketError
    | NonSignaturePacket
    | UnexpectedSignaturePayloadShape
    | MissingHashAlgorithm
    | HashComputationUnsupportedAlgorithm !HashAlgorithm
    | HashComputationOutputTooShort
    | UnexpectedKeyVersion
    | SignatureHashUnsupportedByAlgorithm
        !HashAlgorithm
        !PubKeyAlgorithm
    | KeyRevoked
    | SigningKeyUnavailableAtSignatureTime
    | MissingIssuer
    | SigningKeyNotFound (Maybe EightOctetKeyId) (Maybe Fingerprint)
    | MultipleVerificationSuccesses !Int
    | UnsupportedKeyType !PubKeyAlgorithm
    | SignatureMismatch !PubKeyAlgorithm !Fingerprint
    | SignatureShapeMismatch !PubKeyAlgorithm
    | SignatureEncodingInvalidCrypto !PubKeyAlgorithm !CE.CryptoError
    | SignatureEncodingInvalidBadPrefix !PubKeyAlgorithm
    | SignatureEncodingInvalidLength !PubKeyAlgorithm !String !Int !Int
    | SignaturePolicyHashUnsupported !HashAlgorithm
    | SignaturePolicyPKAMismatch !PubKeyAlgorithm !PubKeyAlgorithm
    | SignatureExpired
    | CandidateKeyFailures [VerificationError]
    | InvalidSubkeyBackSignature !VerificationError
    deriving (VerificationError -> VerificationError -> Bool
(VerificationError -> VerificationError -> Bool)
-> (VerificationError -> VerificationError -> Bool)
-> Eq VerificationError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: VerificationError -> VerificationError -> Bool
== :: VerificationError -> VerificationError -> Bool
$c/= :: VerificationError -> VerificationError -> Bool
/= :: VerificationError -> VerificationError -> Bool
Eq, Int -> VerificationError -> ShowS
[VerificationError] -> ShowS
VerificationError -> [Char]
(Int -> VerificationError -> ShowS)
-> (VerificationError -> [Char])
-> ([VerificationError] -> ShowS)
-> Show VerificationError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> VerificationError -> ShowS
showsPrec :: Int -> VerificationError -> ShowS
$cshow :: VerificationError -> [Char]
show :: VerificationError -> [Char]
$cshowList :: [VerificationError] -> ShowS
showList :: [VerificationError] -> ShowS
Show)

renderVerificationError :: VerificationError -> String
renderVerificationError :: VerificationError -> [Char]
renderVerificationError VerificationError
IssuerSubpacketMismatch =
    [Char]
"verification failed: issuer subpacket does not match the actual signer"
renderVerificationError (IssuerSubpacketUncheckable KeyIdError
err) =
    [Char]
"verification failed: issuer subpacket cannot be checked ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ KeyIdError -> [Char]
renderKeyIdError KeyIdError
err
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderVerificationError VerificationError
IssuerKeyIdProhibitedInV6Signature =
    [Char]
"verification failed: Issuer Key ID subpacket is prohibited in v6 signatures"
renderVerificationError VerificationError
IssuerFingerprintSubpacketMismatch =
    [Char]
"verification failed: issuer fingerprint subpacket does not match the actual signer"
renderVerificationError (UnsupportedCriticalSubpacket SigType
sigType) =
    [Char]
"verification failed: unsupported critical hashed subpacket in "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SigType -> [Char]
forall a. Show a => a -> [Char]
show SigType
sigType
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" signature"
renderVerificationError (VerificationCriticalPacketError CriticalPacketError
err) =
    [Char]
"verification failed: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CriticalPacketError -> [Char]
renderCriticalPacketError CriticalPacketError
err
renderVerificationError VerificationError
NonSignaturePacket =
    [Char]
"verification failed: non-signature packet encountered where signature was expected"
renderVerificationError VerificationError
UnexpectedSignaturePayloadShape =
    [Char]
"verification failed: unexpected signature payload shape"
renderVerificationError VerificationError
MissingHashAlgorithm =
    [Char]
"verification failed: signature payload is missing hash algorithm"
renderVerificationError (HashComputationUnsupportedAlgorithm HashAlgorithm
ha) =
    [Char]
"verification failed: hash computation error (unsupported hash algorithm for left16 derivation: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ HashAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show HashAlgorithm
ha
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderVerificationError VerificationError
HashComputationOutputTooShort =
    [Char]
"verification failed: hash computation error (hash output too short to derive left16)"
renderVerificationError VerificationError
UnexpectedKeyVersion =
    [Char]
"verification failed: signing key has unexpected version (only v4 and v6 are supported)"
renderVerificationError (SignatureHashUnsupportedByAlgorithm HashAlgorithm
ha PubKeyAlgorithm
pka) =
    [Char]
"verification failed: hash algorithm "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ HashAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show HashAlgorithm
ha
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" is not supported by "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" signing backend"
renderVerificationError VerificationError
KeyRevoked =
    [Char]
"verification failed: signing key is revoked"
renderVerificationError VerificationError
SigningKeyUnavailableAtSignatureTime =
    [Char]
"verification failed: signing key was not valid at the signature creation time"
renderVerificationError VerificationError
MissingIssuer =
    [Char]
"verification failed: signature is missing issuer information"
renderVerificationError (SigningKeyNotFound Maybe EightOctetKeyId
meoki Maybe Fingerprint
mfp) =
    [Char]
"verification failed: signing key not found in keyring"
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Maybe EightOctetKeyId -> Maybe Fingerprint -> [Char]
issuerContext Maybe EightOctetKeyId
meoki Maybe Fingerprint
mfp
renderVerificationError (MultipleVerificationSuccesses Int
n) =
    [Char]
"verification failed: multiple successful key matches ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderVerificationError (UnsupportedKeyType PubKeyAlgorithm
pka) =
    [Char]
"verification failed: unsupported public key algorithm for verification ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderVerificationError (SignatureMismatch PubKeyAlgorithm
pka Fingerprint
fpr) =
    [Char]
"verification failed: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" signature mismatch (signer "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Fingerprint -> [Char]
forall a. Show a => a -> [Char]
show Fingerprint
fpr
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderVerificationError (SignatureShapeMismatch PubKeyAlgorithm
pka) =
    [Char]
"verification failed: malformed "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" signature encoding"
renderVerificationError (SignatureEncodingInvalidCrypto PubKeyAlgorithm
pka CryptoError
err) =
    [Char]
"verification failed: invalid "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" key/signature encoding ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CryptoError -> [Char]
forall a. Show a => a -> [Char]
show CryptoError
err
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderVerificationError (SignatureEncodingInvalidBadPrefix PubKeyAlgorithm
pka) =
    [Char]
"verification failed: invalid "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" key/signature encoding (prefixed-native EdDSA public key is missing the 0x40 prefix)"
renderVerificationError (SignatureEncodingInvalidLength PubKeyAlgorithm
pka [Char]
label Int
expected Int
actual) =
    [Char]
"verification failed: invalid "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" key/signature encoding (invalid "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
label
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" EdDSA public key length: expected "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
expected
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" octets, got "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
actual
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderVerificationError (SignaturePolicyHashUnsupported HashAlgorithm
ha) =
    [Char]
"verification failed: unsupported signature hash policy ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ HashAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show HashAlgorithm
ha
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderVerificationError (SignaturePolicyPKAMismatch PubKeyAlgorithm
sigPka PubKeyAlgorithm
keyPka) =
    [Char]
"verification failed: signature public-key algorithm "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
sigPka
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" does not match key algorithm "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
keyPka
renderVerificationError VerificationError
SignatureExpired =
    [Char]
"verification failed: signature expired"
renderVerificationError (CandidateKeyFailures [VerificationError]
errs) =
    [Char]
"verification failed: no candidate key validated the signature ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"; " ([[Char]] -> [[Char]]
forall a. Ord a => [a] -> [a]
nubOrd ([[Char]] -> [[Char]]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ (VerificationError -> [Char]) -> [VerificationError] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map VerificationError -> [Char]
renderVerificationError [VerificationError]
errs)
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
renderVerificationError (InvalidSubkeyBackSignature VerificationError
err) =
    [Char]
"verification failed: embedded primary-key back-signature verification failed: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ VerificationError -> [Char]
renderVerificationError VerificationError
err

issuerContext
    :: Maybe EightOctetKeyId -> Maybe Fingerprint -> String
issuerContext :: Maybe EightOctetKeyId -> Maybe Fingerprint -> [Char]
issuerContext Maybe EightOctetKeyId
meoki Maybe Fingerprint
mfp =
    case (Maybe EightOctetKeyId
meoki, Maybe Fingerprint
mfp) of
        (Maybe EightOctetKeyId
Nothing, Maybe Fingerprint
Nothing) -> [Char]
""
        (Maybe EightOctetKeyId, Maybe Fingerprint)
_ ->
            [Char]
" (issuer-keyid="
                [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
-> (EightOctetKeyId -> [Char]) -> Maybe EightOctetKeyId -> [Char]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [Char]
"unknown" EightOctetKeyId -> [Char]
forall a. Show a => a -> [Char]
show Maybe EightOctetKeyId
meoki
                [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
", issuer-fingerprint="
                [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char] -> (Fingerprint -> [Char]) -> Maybe Fingerprint -> [Char]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [Char]
"unknown" Fingerprint -> [Char]
forall a. Show a => a -> [Char]
show Maybe Fingerprint
mfp
                [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"

-------------------------------------------------------------------------------

data OPSBuildError
    = OPSBuildMissingIssuerKeyId
    | OPSBuildMissingIssuerFingerprint
    | OPSBuildFingerprintWrongLength !Int64
    | OPSBuildUnsupportedSigVersion !Word8
    | OPSBuildIssuerKeyIdProhibitedInV6
    deriving (OPSBuildError -> OPSBuildError -> Bool
(OPSBuildError -> OPSBuildError -> Bool)
-> (OPSBuildError -> OPSBuildError -> Bool) -> Eq OPSBuildError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OPSBuildError -> OPSBuildError -> Bool
== :: OPSBuildError -> OPSBuildError -> Bool
$c/= :: OPSBuildError -> OPSBuildError -> Bool
/= :: OPSBuildError -> OPSBuildError -> Bool
Eq, Int -> OPSBuildError -> ShowS
[OPSBuildError] -> ShowS
OPSBuildError -> [Char]
(Int -> OPSBuildError -> ShowS)
-> (OPSBuildError -> [Char])
-> ([OPSBuildError] -> ShowS)
-> Show OPSBuildError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OPSBuildError -> ShowS
showsPrec :: Int -> OPSBuildError -> ShowS
$cshow :: OPSBuildError -> [Char]
show :: OPSBuildError -> [Char]
$cshowList :: [OPSBuildError] -> ShowS
showList :: [OPSBuildError] -> ShowS
Show)

renderOPSBuildError :: OPSBuildError -> String
renderOPSBuildError :: OPSBuildError -> [Char]
renderOPSBuildError OPSBuildError
OPSBuildMissingIssuerKeyId =
    [Char]
"cannot build OPS3 packet from v4 signature without issuer metadata"
renderOPSBuildError OPSBuildError
OPSBuildMissingIssuerFingerprint =
    [Char]
"cannot build OPS6 packet from v6 signature without issuer fingerprint"
renderOPSBuildError (OPSBuildFingerprintWrongLength Int64
fpLen) =
    [Char]
"cannot build OPS6 packet: issuer fingerprint must be 32 octets, got "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int64 -> [Char]
forall a. Show a => a -> [Char]
show Int64
fpLen
renderOPSBuildError (OPSBuildUnsupportedSigVersion Word8
v) =
    [Char]
"cannot build one-pass signature packet for unsupported signature version "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
v
renderOPSBuildError OPSBuildError
OPSBuildIssuerKeyIdProhibitedInV6 =
    [Char]
"cannot build OPS3 packet: Issuer Key ID subpacket is prohibited in v6 signatures"

-------------------------------------------------------------------------------

data RecipientCapabilityError
    = RecipientCapabilityMissingEncryptionFlags
        !SomePKPayload
        !(Set.Set KeyFlag)
    | RecipientCapabilityNoEncryptableKeyMaterialInTK
    | RecipientCapabilityMissingSEIPDv1Support ![SomePKPayload]
    | RecipientCapabilityMissingSEIPDv2Support ![SomePKPayload]
    | RecipientCapabilityNoCommonSymmetricAlgorithms
        ![SymmetricAlgorithm]
    | RecipientCapabilityNoCommonAEADAlgorithms ![AEADAlgorithm]
    deriving (RecipientCapabilityError -> RecipientCapabilityError -> Bool
(RecipientCapabilityError -> RecipientCapabilityError -> Bool)
-> (RecipientCapabilityError -> RecipientCapabilityError -> Bool)
-> Eq RecipientCapabilityError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RecipientCapabilityError -> RecipientCapabilityError -> Bool
== :: RecipientCapabilityError -> RecipientCapabilityError -> Bool
$c/= :: RecipientCapabilityError -> RecipientCapabilityError -> Bool
/= :: RecipientCapabilityError -> RecipientCapabilityError -> Bool
Eq, Int -> RecipientCapabilityError -> ShowS
[RecipientCapabilityError] -> ShowS
RecipientCapabilityError -> [Char]
(Int -> RecipientCapabilityError -> ShowS)
-> (RecipientCapabilityError -> [Char])
-> ([RecipientCapabilityError] -> ShowS)
-> Show RecipientCapabilityError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RecipientCapabilityError -> ShowS
showsPrec :: Int -> RecipientCapabilityError -> ShowS
$cshow :: RecipientCapabilityError -> [Char]
show :: RecipientCapabilityError -> [Char]
$cshowList :: [RecipientCapabilityError] -> ShowS
showList :: [RecipientCapabilityError] -> ShowS
Show)

renderRecipientCapabilityError
    :: RecipientCapabilityError -> String
renderRecipientCapabilityError :: RecipientCapabilityError -> [Char]
renderRecipientCapabilityError (RecipientCapabilityMissingEncryptionFlags SomePKPayload
_ Set KeyFlag
flags) =
    [Char]
"key material missing required encryption flags: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Set KeyFlag -> [Char]
forall a. Show a => a -> [Char]
show Set KeyFlag
flags
renderRecipientCapabilityError RecipientCapabilityError
RecipientCapabilityNoEncryptableKeyMaterialInTK =
    [Char]
"no encryptable key material in target key"
renderRecipientCapabilityError (RecipientCapabilityMissingSEIPDv1Support [SomePKPayload]
_) =
    [Char]
"no recipient supports SEIPDv1"
renderRecipientCapabilityError (RecipientCapabilityMissingSEIPDv2Support [SomePKPayload]
_) =
    [Char]
"no recipient supports SEIPDv2"
renderRecipientCapabilityError (RecipientCapabilityNoCommonSymmetricAlgorithms [SymmetricAlgorithm]
algos) =
    [Char]
"no common symmetric algorithms: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [SymmetricAlgorithm] -> [Char]
forall a. Show a => a -> [Char]
show [SymmetricAlgorithm]
algos
renderRecipientCapabilityError (RecipientCapabilityNoCommonAEADAlgorithms [AEADAlgorithm]
algos) =
    [Char]
"no common AEAD algorithms: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [AEADAlgorithm] -> [Char]
forall a. Show a => a -> [Char]
show [AEADAlgorithm]
algos

-------------------------------------------------------------------------------

data PKESKEncryptError
    = UnsupportedSessionKeyAlgorithm !SymmetricAlgorithm !CipherError
    | InvalidSessionKeyLength !SymmetricAlgorithm !Int !Int
    | UnsupportedRecipientAlgorithm !PubKeyAlgorithm
    | InvalidRecipientKeyMaterial !PubKeyAlgorithm !String
    | InvalidRecipientKeyMaterialKeyId !PubKeyAlgorithm !KeyIdError
    | RecipientKdfFailure !PubKeyAlgorithm !String
    | RecipientKeyWrapFailure !PubKeyAlgorithm !String
    | RecipientKeyWrapFailureCipher !PubKeyAlgorithm !CipherError
    | RecipientKeyWrapFailureRSA !PubKeyAlgorithm !RSA.Error
    | RecipientKeyWrapFailureCrypto !PubKeyAlgorithm !CE.CryptoError
    | RecipientCapabilitySelectionFailure !RecipientCapabilityError
    | PayloadBuildFailureCipher !CipherError
    | PayloadBuildFailureS2K !S2KError
    | PayloadBuildFailureOPSBuild !OPSBuildError
    | PayloadBuildFailureSEIPDv2 !SEIPDv2Failure
    | NoRecipientsProvided
    deriving (PKESKEncryptError -> PKESKEncryptError -> Bool
(PKESKEncryptError -> PKESKEncryptError -> Bool)
-> (PKESKEncryptError -> PKESKEncryptError -> Bool)
-> Eq PKESKEncryptError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PKESKEncryptError -> PKESKEncryptError -> Bool
== :: PKESKEncryptError -> PKESKEncryptError -> Bool
$c/= :: PKESKEncryptError -> PKESKEncryptError -> Bool
/= :: PKESKEncryptError -> PKESKEncryptError -> Bool
Eq, Int -> PKESKEncryptError -> ShowS
[PKESKEncryptError] -> ShowS
PKESKEncryptError -> [Char]
(Int -> PKESKEncryptError -> ShowS)
-> (PKESKEncryptError -> [Char])
-> ([PKESKEncryptError] -> ShowS)
-> Show PKESKEncryptError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PKESKEncryptError -> ShowS
showsPrec :: Int -> PKESKEncryptError -> ShowS
$cshow :: PKESKEncryptError -> [Char]
show :: PKESKEncryptError -> [Char]
$cshowList :: [PKESKEncryptError] -> ShowS
showList :: [PKESKEncryptError] -> ShowS
Show)

renderPKESKEncryptError :: PKESKEncryptError -> String
renderPKESKEncryptError :: PKESKEncryptError -> [Char]
renderPKESKEncryptError (UnsupportedSessionKeyAlgorithm SymmetricAlgorithm
algo CipherError
reason) =
    [Char]
"unsupported session key algorithm "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CipherError -> [Char]
renderCipherError CipherError
reason
renderPKESKEncryptError (InvalidSessionKeyLength SymmetricAlgorithm
algo Int
expected Int
actual) =
    [Char]
"invalid session key length for "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": expected "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
expected
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
", got "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
actual
renderPKESKEncryptError (UnsupportedRecipientAlgorithm PubKeyAlgorithm
algo) =
    [Char]
"unsupported recipient public-key algorithm: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
algo
renderPKESKEncryptError (InvalidRecipientKeyMaterial PubKeyAlgorithm
algo [Char]
reason) =
    [Char]
"invalid recipient key material for "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
reason
renderPKESKEncryptError (InvalidRecipientKeyMaterialKeyId PubKeyAlgorithm
algo KeyIdError
err) =
    [Char]
"invalid recipient key material for "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": failed to derive PKESKv3 recipient key ID: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ KeyIdError -> [Char]
renderKeyIdError KeyIdError
err
renderPKESKEncryptError (RecipientKdfFailure PubKeyAlgorithm
algo [Char]
reason) =
    [Char]
"KDF failure for recipient algorithm "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
reason
renderPKESKEncryptError (RecipientKeyWrapFailure PubKeyAlgorithm
algo [Char]
reason) =
    [Char]
"key wrap failure for recipient algorithm "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
reason
renderPKESKEncryptError (RecipientKeyWrapFailureCipher PubKeyAlgorithm
algo CipherError
err) =
    [Char]
"key wrap failure for recipient algorithm "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CipherError -> [Char]
renderCipherError CipherError
err
renderPKESKEncryptError (RecipientKeyWrapFailureRSA PubKeyAlgorithm
algo Error
err) =
    [Char]
"key wrap failure for recipient algorithm "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Error -> [Char]
forall a. Show a => a -> [Char]
show Error
err
renderPKESKEncryptError (RecipientKeyWrapFailureCrypto PubKeyAlgorithm
algo CryptoError
err) =
    [Char]
"key wrap failure for recipient algorithm "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CryptoError -> [Char]
forall a. Show a => a -> [Char]
show CryptoError
err
renderPKESKEncryptError (RecipientCapabilitySelectionFailure RecipientCapabilityError
err) =
    RecipientCapabilityError -> [Char]
renderRecipientCapabilityError RecipientCapabilityError
err
renderPKESKEncryptError (PayloadBuildFailureCipher CipherError
err) =
    [Char]
"payload build failure: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CipherError -> [Char]
renderCipherError CipherError
err
renderPKESKEncryptError (PayloadBuildFailureS2K S2KError
err) =
    [Char]
"payload build failure: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ S2KError -> [Char]
renderS2KError S2KError
err
renderPKESKEncryptError (PayloadBuildFailureOPSBuild OPSBuildError
err) =
    [Char]
"payload build failure: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ OPSBuildError -> [Char]
renderOPSBuildError OPSBuildError
err
renderPKESKEncryptError (PayloadBuildFailureSEIPDv2 SEIPDv2Failure
err) =
    [Char]
"payload build failure: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SEIPDv2Failure -> [Char]
renderSEIPDv2Failure SEIPDv2Failure
err
renderPKESKEncryptError PKESKEncryptError
NoRecipientsProvided =
    [Char]
"no recipients provided"

-------------------------------------------------------------------------------

data CompressionError
    = EmptyCompressedPayload !CompressionAlgorithm
    | InnerPacketParseFailed !CompressionAlgorithm !String
    | ZeroLengthDecompressedPayload !CompressionAlgorithm
    | MarkerOnlyPayload !CompressionAlgorithm
    deriving (CompressionError -> CompressionError -> Bool
(CompressionError -> CompressionError -> Bool)
-> (CompressionError -> CompressionError -> Bool)
-> Eq CompressionError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CompressionError -> CompressionError -> Bool
== :: CompressionError -> CompressionError -> Bool
$c/= :: CompressionError -> CompressionError -> Bool
/= :: CompressionError -> CompressionError -> Bool
Eq, Int -> CompressionError -> ShowS
[CompressionError] -> ShowS
CompressionError -> [Char]
(Int -> CompressionError -> ShowS)
-> (CompressionError -> [Char])
-> ([CompressionError] -> ShowS)
-> Show CompressionError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CompressionError -> ShowS
showsPrec :: Int -> CompressionError -> ShowS
$cshow :: CompressionError -> [Char]
show :: CompressionError -> [Char]
$cshowList :: [CompressionError] -> ShowS
showList :: [CompressionError] -> ShowS
Show)

renderCompressionError :: CompressionError -> String
renderCompressionError :: CompressionError -> [Char]
renderCompressionError (EmptyCompressedPayload CompressionAlgorithm
algo) =
    [Char]
"Compressed Data packet ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CompressionAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show CompressionAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"): empty compressed payload"
renderCompressionError (InnerPacketParseFailed CompressionAlgorithm
algo [Char]
err) =
    [Char]
"Compressed Data packet ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CompressionAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show CompressionAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"): inner packet parse failed: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
err
renderCompressionError (ZeroLengthDecompressedPayload CompressionAlgorithm
algo) =
    [Char]
"Compressed Data packet ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CompressionAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show CompressionAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"): zero-length decompressed payload"
renderCompressionError (MarkerOnlyPayload CompressionAlgorithm
algo) =
    [Char]
"Compressed Data packet ("
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CompressionAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show CompressionAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"): decompressed content contains only Marker packets"

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

-- | Packet validation errors
data PktValidationError
    = PktValidationErrorReasonPKESKv6RecipientKeyIdentifierTooLong
    | PktValidationErrorReasonHashAlgorithmNoV6SaltSize HashAlgorithm
    | PktValidationErrorReasonOPSv6SaltSizeMismatch
        { PktValidationError -> Word8
saltSizeExpected :: Word8
        , PktValidationError -> Word8
saltSizeActual :: Word8
        }
    | PktValidationErrorReasonOPSv6SignerFingerprintWrongLength
    | PktValidationErrorReasonSEIPDv2SaltWrongLength
    | PktValidationErrorReasonSEIPDv2ChunkSizeTooLarge
    | PktValidationErrorReasonSEIPDv2SymmetricAlgorithmUnknown
    | PktValidationErrorReasonSEIPDv2SymmetricAlgorithmPlaintext
    | PktValidationErrorReasonSEIPDv2AEADAlgorithmUnknown
    | PktValidationErrorReasonOtherPacketTagTooLarge
        { PktValidationError -> Word8
otherPacketTag :: Word8
        }
    deriving (PktValidationError -> PktValidationError -> Bool
(PktValidationError -> PktValidationError -> Bool)
-> (PktValidationError -> PktValidationError -> Bool)
-> Eq PktValidationError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PktValidationError -> PktValidationError -> Bool
== :: PktValidationError -> PktValidationError -> Bool
$c/= :: PktValidationError -> PktValidationError -> Bool
/= :: PktValidationError -> PktValidationError -> Bool
Eq, Int -> PktValidationError -> ShowS
[PktValidationError] -> ShowS
PktValidationError -> [Char]
(Int -> PktValidationError -> ShowS)
-> (PktValidationError -> [Char])
-> ([PktValidationError] -> ShowS)
-> Show PktValidationError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PktValidationError -> ShowS
showsPrec :: Int -> PktValidationError -> ShowS
$cshow :: PktValidationError -> [Char]
show :: PktValidationError -> [Char]
$cshowList :: [PktValidationError] -> ShowS
showList :: [PktValidationError] -> ShowS
Show)

renderPktValidationError :: PktValidationError -> String
renderPktValidationError :: PktValidationError -> [Char]
renderPktValidationError PktValidationError
PktValidationErrorReasonPKESKv6RecipientKeyIdentifierTooLong =
    [Char]
"PKESK v6 recipient key identifier must fit in one octet (max 255 bytes)"
renderPktValidationError (PktValidationErrorReasonHashAlgorithmNoV6SaltSize HashAlgorithm
ha) =
    [Char]
"signature hash algorithm does not define a V6 salt size: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ HashAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show HashAlgorithm
ha
renderPktValidationError (PktValidationErrorReasonOPSv6SaltSizeMismatch Word8
expected Word8
actual) =
    [Char]
"OPS v6 salt size mismatch: expected "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
expected
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
", got "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
actual
renderPktValidationError PktValidationError
PktValidationErrorReasonOPSv6SignerFingerprintWrongLength =
    [Char]
"OPS v6 signer fingerprint must be exactly 32 octets"
renderPktValidationError PktValidationError
PktValidationErrorReasonSEIPDv2SaltWrongLength =
    [Char]
"SEIPD v2 salt must be exactly 32 octets"
renderPktValidationError PktValidationError
PktValidationErrorReasonSEIPDv2ChunkSizeTooLarge =
    [Char]
"SEIPD v2 chunk size octet must be between 0 and 16"
renderPktValidationError PktValidationError
PktValidationErrorReasonSEIPDv2SymmetricAlgorithmUnknown =
    [Char]
"SEIPD v2 requires a known symmetric algorithm"
renderPktValidationError PktValidationError
PktValidationErrorReasonSEIPDv2SymmetricAlgorithmPlaintext =
    [Char]
"SEIPD v2 cannot use plaintext cipher"
renderPktValidationError PktValidationError
PktValidationErrorReasonSEIPDv2AEADAlgorithmUnknown =
    [Char]
"SEIPD v2 requires a known AEAD algorithm"
renderPktValidationError (PktValidationErrorReasonOtherPacketTagTooLarge Word8
tag) =
    [Char]
"cannot serialize OtherPacket packet tag > 63: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
tag

-------------------------------------------------------------------------------

-- | Secret key errors
data SKeyError
    = SKeyErrorReasonInvalidRSAKey
    deriving (SKeyError -> SKeyError -> Bool
(SKeyError -> SKeyError -> Bool)
-> (SKeyError -> SKeyError -> Bool) -> Eq SKeyError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SKeyError -> SKeyError -> Bool
== :: SKeyError -> SKeyError -> Bool
$c/= :: SKeyError -> SKeyError -> Bool
/= :: SKeyError -> SKeyError -> Bool
Eq, Int -> SKeyError -> ShowS
[SKeyError] -> ShowS
SKeyError -> [Char]
(Int -> SKeyError -> ShowS)
-> (SKeyError -> [Char])
-> ([SKeyError] -> ShowS)
-> Show SKeyError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SKeyError -> ShowS
showsPrec :: Int -> SKeyError -> ShowS
$cshow :: SKeyError -> [Char]
show :: SKeyError -> [Char]
$cshowList :: [SKeyError] -> ShowS
showList :: [SKeyError] -> ShowS
Show)

renderSKeyError :: SKeyError -> String
renderSKeyError :: SKeyError -> [Char]
renderSKeyError SKeyError
SKeyErrorReasonInvalidRSAKey =
    [Char]
"putSKey: invalid RSA key - q has no multiplicative inverse mod p (key is mathematically broken)"

-------------------------------------------------------------------------------

-------------------------------------------------------------------------------

data SerializeError
    = SerializeErrorReasonValidation !PktValidationError
    | SerializeErrorReasonPutSKey !SKeyError
    | SerializeErrorReasonSymEncBlockSize !SymmetricAlgorithm
    | SerializeErrorReasonECPoint !ECPointError
    deriving (SerializeError -> SerializeError -> Bool
(SerializeError -> SerializeError -> Bool)
-> (SerializeError -> SerializeError -> Bool) -> Eq SerializeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SerializeError -> SerializeError -> Bool
== :: SerializeError -> SerializeError -> Bool
$c/= :: SerializeError -> SerializeError -> Bool
/= :: SerializeError -> SerializeError -> Bool
Eq, Int -> SerializeError -> ShowS
[SerializeError] -> ShowS
SerializeError -> [Char]
(Int -> SerializeError -> ShowS)
-> (SerializeError -> [Char])
-> ([SerializeError] -> ShowS)
-> Show SerializeError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SerializeError -> ShowS
showsPrec :: Int -> SerializeError -> ShowS
$cshow :: SerializeError -> [Char]
show :: SerializeError -> [Char]
$cshowList :: [SerializeError] -> ShowS
showList :: [SerializeError] -> ShowS
Show)

renderSerializeError :: SerializeError -> String
renderSerializeError :: SerializeError -> [Char]
renderSerializeError (SerializeErrorReasonValidation PktValidationError
e) = PktValidationError -> [Char]
renderPktValidationError PktValidationError
e
renderSerializeError (SerializeErrorReasonPutSKey SKeyError
e) = SKeyError -> [Char]
renderSKeyError SKeyError
e
renderSerializeError (SerializeErrorReasonSymEncBlockSize SymmetricAlgorithm
sa) =
    [Char]
"unsupported symmetric algorithm for secret-key IV sizing: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
sa
renderSerializeError (SerializeErrorReasonECPoint ECPointError
e) = ECPointError -> [Char]
renderECPointError ECPointError
e

-------------------------------------------------------------------------------
-- AEAD / SEIPDv2 unified auth failures
-------------------------------------------------------------------------------

-- | Unified AEAD authentication failures shared between legacy AEAD and SEIPDv2.
data AEADAuthFailure
    = AEADChunkAuthFailed !AEADAlgorithm !Int
    | AEADFinalTagFailed !AEADAlgorithm
    | AEADInitFailed !CipherError
    deriving (AEADAuthFailure -> AEADAuthFailure -> Bool
(AEADAuthFailure -> AEADAuthFailure -> Bool)
-> (AEADAuthFailure -> AEADAuthFailure -> Bool)
-> Eq AEADAuthFailure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AEADAuthFailure -> AEADAuthFailure -> Bool
== :: AEADAuthFailure -> AEADAuthFailure -> Bool
$c/= :: AEADAuthFailure -> AEADAuthFailure -> Bool
/= :: AEADAuthFailure -> AEADAuthFailure -> Bool
Eq, Int -> AEADAuthFailure -> ShowS
[AEADAuthFailure] -> ShowS
AEADAuthFailure -> [Char]
(Int -> AEADAuthFailure -> ShowS)
-> (AEADAuthFailure -> [Char])
-> ([AEADAuthFailure] -> ShowS)
-> Show AEADAuthFailure
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AEADAuthFailure -> ShowS
showsPrec :: Int -> AEADAuthFailure -> ShowS
$cshow :: AEADAuthFailure -> [Char]
show :: AEADAuthFailure -> [Char]
$cshowList :: [AEADAuthFailure] -> ShowS
showList :: [AEADAuthFailure] -> ShowS
Show)

renderAEADAuthFailure :: AEADAuthFailure -> String
renderAEADAuthFailure :: AEADAuthFailure -> [Char]
renderAEADAuthFailure (AEADChunkAuthFailed AEADAlgorithm
algo Int
chunk) =
    [Char]
"AEAD chunk authentication failed for "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ AEADAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show AEADAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" at chunk "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
chunk
renderAEADAuthFailure (AEADFinalTagFailed AEADAlgorithm
algo) =
    [Char]
"AEAD final tag verification failed for " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ AEADAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show AEADAlgorithm
algo
renderAEADAuthFailure (AEADInitFailed CipherError
err) =
    [Char]
"AEAD initialization failed: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CipherError -> [Char]
renderCipherError CipherError
err

-------------------------------------------------------------------------------

data SEIPDv2Failure
    = SEIPDv2UnsupportedAEADAlgorithm !AEADAlgorithm
    | SEIPDv2UnsupportedSymmetricAlgorithm !SymmetricAlgorithm
    | SEIPDv2InvalidSaltLength
    | SEIPDv2InvalidIVLength
    | SEIPDv2InvalidChunkSize
    | SEIPDv2CiphertextTooShort
    | SEIPDv2MalformedChunkLengths
    | SEIPDv2MissingFinalTag
    | SEIPDv2AuthFailure !AEADAuthFailure
    | SEIPDv2AuthFailed
    | SEIPDv2CipherFailed !CipherError
    | SEIPDv2SessionKeyError !S2KError
    deriving (SEIPDv2Failure -> SEIPDv2Failure -> Bool
(SEIPDv2Failure -> SEIPDv2Failure -> Bool)
-> (SEIPDv2Failure -> SEIPDv2Failure -> Bool) -> Eq SEIPDv2Failure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SEIPDv2Failure -> SEIPDv2Failure -> Bool
== :: SEIPDv2Failure -> SEIPDv2Failure -> Bool
$c/= :: SEIPDv2Failure -> SEIPDv2Failure -> Bool
/= :: SEIPDv2Failure -> SEIPDv2Failure -> Bool
Eq, Int -> SEIPDv2Failure -> ShowS
[SEIPDv2Failure] -> ShowS
SEIPDv2Failure -> [Char]
(Int -> SEIPDv2Failure -> ShowS)
-> (SEIPDv2Failure -> [Char])
-> ([SEIPDv2Failure] -> ShowS)
-> Show SEIPDv2Failure
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SEIPDv2Failure -> ShowS
showsPrec :: Int -> SEIPDv2Failure -> ShowS
$cshow :: SEIPDv2Failure -> [Char]
show :: SEIPDv2Failure -> [Char]
$cshowList :: [SEIPDv2Failure] -> ShowS
showList :: [SEIPDv2Failure] -> ShowS
Show)

renderSEIPDv2Failure :: SEIPDv2Failure -> String
renderSEIPDv2Failure :: SEIPDv2Failure -> [Char]
renderSEIPDv2Failure (SEIPDv2UnsupportedAEADAlgorithm AEADAlgorithm
EAX) =
    [Char]
"EAX is currently unsupported by the crypton AEAD backend"
renderSEIPDv2Failure (SEIPDv2UnsupportedAEADAlgorithm AEADAlgorithm
alg) =
    [Char]
"unsupported AEAD algorithm: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ AEADAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show AEADAlgorithm
alg
renderSEIPDv2Failure (SEIPDv2UnsupportedSymmetricAlgorithm SymmetricAlgorithm
_) =
    [Char]
"SEIPD v2 encrypt currently supports AES-128/192/256 only"
renderSEIPDv2Failure SEIPDv2Failure
SEIPDv2InvalidSaltLength =
    [Char]
"SEIPD v2 salt must be exactly 32 octets"
renderSEIPDv2Failure SEIPDv2Failure
SEIPDv2InvalidIVLength =
    [Char]
"SKESK v6 IV length does not match AEAD algorithm"
renderSEIPDv2Failure SEIPDv2Failure
SEIPDv2InvalidChunkSize =
    [Char]
"SEIPD v2 chunk size octet must be between 0 and 16"
renderSEIPDv2Failure SEIPDv2Failure
SEIPDv2CiphertextTooShort =
    [Char]
"SEIPD v2 ciphertext must include at least one chunk tag and a final tag"
renderSEIPDv2Failure SEIPDv2Failure
SEIPDv2MalformedChunkLengths =
    [Char]
"SEIPD v2 malformed chunk lengths"
renderSEIPDv2Failure SEIPDv2Failure
SEIPDv2MissingFinalTag =
    [Char]
"SEIPD v2 missing final authentication tag"
renderSEIPDv2Failure (SEIPDv2AuthFailure AEADAuthFailure
auth) = AEADAuthFailure -> [Char]
renderAEADAuthFailure AEADAuthFailure
auth
renderSEIPDv2Failure SEIPDv2Failure
SEIPDv2AuthFailed =
    [Char]
"AEAD authentication failed"
renderSEIPDv2Failure (SEIPDv2CipherFailed CipherError
err) =
    [Char]
"AEAD/cipher operation failed: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ CipherError -> [Char]
renderCipherError CipherError
err
renderSEIPDv2Failure (SEIPDv2SessionKeyError S2KError
err) = S2KError -> [Char]
renderS2KError S2KError
err

-------------------------------------------------------------------------------
-- Message-level errors
-------------------------------------------------------------------------------

data MessageParseFailure
    = MissingEncryptedMessage
    | ExpectedSKESKThenEncryptedData
    | SKESKSEIPDAlgorithmMismatch
    | UnsupportedEncryptedSKESK
    | MissingLiteralDataPacket
    | MessageParseCriticalPacketError !CriticalPacketError
    deriving (MessageParseFailure -> MessageParseFailure -> Bool
(MessageParseFailure -> MessageParseFailure -> Bool)
-> (MessageParseFailure -> MessageParseFailure -> Bool)
-> Eq MessageParseFailure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MessageParseFailure -> MessageParseFailure -> Bool
== :: MessageParseFailure -> MessageParseFailure -> Bool
$c/= :: MessageParseFailure -> MessageParseFailure -> Bool
/= :: MessageParseFailure -> MessageParseFailure -> Bool
Eq, Int -> MessageParseFailure -> ShowS
[MessageParseFailure] -> ShowS
MessageParseFailure -> [Char]
(Int -> MessageParseFailure -> ShowS)
-> (MessageParseFailure -> [Char])
-> ([MessageParseFailure] -> ShowS)
-> Show MessageParseFailure
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MessageParseFailure -> ShowS
showsPrec :: Int -> MessageParseFailure -> ShowS
$cshow :: MessageParseFailure -> [Char]
show :: MessageParseFailure -> [Char]
$cshowList :: [MessageParseFailure] -> ShowS
showList :: [MessageParseFailure] -> ShowS
Show)

renderMessageParseFailure :: MessageParseFailure -> String
renderMessageParseFailure :: MessageParseFailure -> [Char]
renderMessageParseFailure MessageParseFailure
MissingEncryptedMessage =
    [Char]
"Could not parse encrypted OpenPGP message"
renderMessageParseFailure MessageParseFailure
ExpectedSKESKThenEncryptedData =
    [Char]
"Expected an SKESK packet followed by symmetrically encrypted data or SEIPD v2 data"
renderMessageParseFailure MessageParseFailure
SKESKSEIPDAlgorithmMismatch =
    [Char]
"SKESK and SEIPD v2 algorithms do not match"
renderMessageParseFailure MessageParseFailure
UnsupportedEncryptedSKESK =
    [Char]
"Cannot decrypt SKESK packets with encrypted session keys"
renderMessageParseFailure MessageParseFailure
MissingLiteralDataPacket =
    [Char]
"Decrypted message does not contain a literal data packet"
renderMessageParseFailure (MessageParseCriticalPacketError CriticalPacketError
err) =
    CriticalPacketError -> [Char]
renderCriticalPacketError CriticalPacketError
err

-------------------------------------------------------------------------------

data MessageDecryptFailure
    = SessionMaterialDerivationFailed !S2KError
    | PayloadDecryptFailed !PayloadDecryptFailure
    deriving (MessageDecryptFailure -> MessageDecryptFailure -> Bool
(MessageDecryptFailure -> MessageDecryptFailure -> Bool)
-> (MessageDecryptFailure -> MessageDecryptFailure -> Bool)
-> Eq MessageDecryptFailure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MessageDecryptFailure -> MessageDecryptFailure -> Bool
== :: MessageDecryptFailure -> MessageDecryptFailure -> Bool
$c/= :: MessageDecryptFailure -> MessageDecryptFailure -> Bool
/= :: MessageDecryptFailure -> MessageDecryptFailure -> Bool
Eq, Int -> MessageDecryptFailure -> ShowS
[MessageDecryptFailure] -> ShowS
MessageDecryptFailure -> [Char]
(Int -> MessageDecryptFailure -> ShowS)
-> (MessageDecryptFailure -> [Char])
-> ([MessageDecryptFailure] -> ShowS)
-> Show MessageDecryptFailure
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MessageDecryptFailure -> ShowS
showsPrec :: Int -> MessageDecryptFailure -> ShowS
$cshow :: MessageDecryptFailure -> [Char]
show :: MessageDecryptFailure -> [Char]
$cshowList :: [MessageDecryptFailure] -> ShowS
showList :: [MessageDecryptFailure] -> ShowS
Show)

renderMessageDecryptFailure :: MessageDecryptFailure -> String
renderMessageDecryptFailure :: MessageDecryptFailure -> [Char]
renderMessageDecryptFailure (SessionMaterialDerivationFailed S2KError
err) = S2KError -> [Char]
renderS2KError S2KError
err
renderMessageDecryptFailure (PayloadDecryptFailed PayloadDecryptFailure
err) = PayloadDecryptFailure -> [Char]
renderPayloadDecryptFailure PayloadDecryptFailure
err

-------------------------------------------------------------------------------

data MessageEncryptFailure
    = MessageEncryptSEIPDv2Failed !SEIPDv2Failure
    | MessageEncryptCipherFailed !CipherError
    | MessageEncryptS2KFailed !S2KError
    | MessageEncryptDeprecatedS2KHash !HashAlgorithm
    | MessageEncryptUnsupportedSymmetricAlgorithm !SymmetricAlgorithm
    deriving (MessageEncryptFailure -> MessageEncryptFailure -> Bool
(MessageEncryptFailure -> MessageEncryptFailure -> Bool)
-> (MessageEncryptFailure -> MessageEncryptFailure -> Bool)
-> Eq MessageEncryptFailure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MessageEncryptFailure -> MessageEncryptFailure -> Bool
== :: MessageEncryptFailure -> MessageEncryptFailure -> Bool
$c/= :: MessageEncryptFailure -> MessageEncryptFailure -> Bool
/= :: MessageEncryptFailure -> MessageEncryptFailure -> Bool
Eq, Int -> MessageEncryptFailure -> ShowS
[MessageEncryptFailure] -> ShowS
MessageEncryptFailure -> [Char]
(Int -> MessageEncryptFailure -> ShowS)
-> (MessageEncryptFailure -> [Char])
-> ([MessageEncryptFailure] -> ShowS)
-> Show MessageEncryptFailure
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MessageEncryptFailure -> ShowS
showsPrec :: Int -> MessageEncryptFailure -> ShowS
$cshow :: MessageEncryptFailure -> [Char]
show :: MessageEncryptFailure -> [Char]
$cshowList :: [MessageEncryptFailure] -> ShowS
showList :: [MessageEncryptFailure] -> ShowS
Show)

renderMessageEncryptFailure :: MessageEncryptFailure -> String
renderMessageEncryptFailure :: MessageEncryptFailure -> [Char]
renderMessageEncryptFailure (MessageEncryptSEIPDv2Failed SEIPDv2Failure
err) = SEIPDv2Failure -> [Char]
renderSEIPDv2Failure SEIPDv2Failure
err
renderMessageEncryptFailure (MessageEncryptCipherFailed CipherError
err) = CipherError -> [Char]
renderCipherError CipherError
err
renderMessageEncryptFailure (MessageEncryptS2KFailed S2KError
err) = S2KError -> [Char]
renderS2KError S2KError
err
renderMessageEncryptFailure (MessageEncryptDeprecatedS2KHash HashAlgorithm
ha) =
    [Char]
"deprecated hash algorithm disallowed for modern message generation: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ HashAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show HashAlgorithm
ha
renderMessageEncryptFailure (MessageEncryptUnsupportedSymmetricAlgorithm SymmetricAlgorithm
sa) =
    [Char]
"symmetric algorithm disallowed for RFC9580 message generation: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
sa

-------------------------------------------------------------------------------

data PayloadDecryptFailure
    = PayloadDecryptCipherFailed !CipherError
    | PayloadDecryptMDCFailed !MDCFailure
    | PayloadDecryptAEADFailed !AEADAuthFailure
    | PayloadDecryptSEIPDv2Failed !SEIPDv2Failure
    deriving (PayloadDecryptFailure -> PayloadDecryptFailure -> Bool
(PayloadDecryptFailure -> PayloadDecryptFailure -> Bool)
-> (PayloadDecryptFailure -> PayloadDecryptFailure -> Bool)
-> Eq PayloadDecryptFailure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PayloadDecryptFailure -> PayloadDecryptFailure -> Bool
== :: PayloadDecryptFailure -> PayloadDecryptFailure -> Bool
$c/= :: PayloadDecryptFailure -> PayloadDecryptFailure -> Bool
/= :: PayloadDecryptFailure -> PayloadDecryptFailure -> Bool
Eq, Int -> PayloadDecryptFailure -> ShowS
[PayloadDecryptFailure] -> ShowS
PayloadDecryptFailure -> [Char]
(Int -> PayloadDecryptFailure -> ShowS)
-> (PayloadDecryptFailure -> [Char])
-> ([PayloadDecryptFailure] -> ShowS)
-> Show PayloadDecryptFailure
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PayloadDecryptFailure -> ShowS
showsPrec :: Int -> PayloadDecryptFailure -> ShowS
$cshow :: PayloadDecryptFailure -> [Char]
show :: PayloadDecryptFailure -> [Char]
$cshowList :: [PayloadDecryptFailure] -> ShowS
showList :: [PayloadDecryptFailure] -> ShowS
Show)

renderPayloadDecryptFailure :: PayloadDecryptFailure -> String
renderPayloadDecryptFailure :: PayloadDecryptFailure -> [Char]
renderPayloadDecryptFailure (PayloadDecryptCipherFailed CipherError
err) = CipherError -> [Char]
renderCipherError CipherError
err
renderPayloadDecryptFailure (PayloadDecryptMDCFailed MDCFailure
err) = MDCFailure -> [Char]
renderMDCFailure MDCFailure
err
renderPayloadDecryptFailure (PayloadDecryptAEADFailed AEADAuthFailure
err) = AEADAuthFailure -> [Char]
renderAEADAuthFailure AEADAuthFailure
err
renderPayloadDecryptFailure (PayloadDecryptSEIPDv2Failed SEIPDv2Failure
err) = SEIPDv2Failure -> [Char]
renderSEIPDv2Failure SEIPDv2Failure
err

-------------------------------------------------------------------------------
-- Decrypt-level errors
-------------------------------------------------------------------------------

data DecryptStructureError
    = DecryptStructureESKSEIPDMismatch
    | DecryptStructureESKOrder
    | DecryptStructureTrailingData
    deriving (DecryptStructureError -> DecryptStructureError -> Bool
(DecryptStructureError -> DecryptStructureError -> Bool)
-> (DecryptStructureError -> DecryptStructureError -> Bool)
-> Eq DecryptStructureError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DecryptStructureError -> DecryptStructureError -> Bool
== :: DecryptStructureError -> DecryptStructureError -> Bool
$c/= :: DecryptStructureError -> DecryptStructureError -> Bool
/= :: DecryptStructureError -> DecryptStructureError -> Bool
Eq, Int -> DecryptStructureError -> ShowS
[DecryptStructureError] -> ShowS
DecryptStructureError -> [Char]
(Int -> DecryptStructureError -> ShowS)
-> (DecryptStructureError -> [Char])
-> ([DecryptStructureError] -> ShowS)
-> Show DecryptStructureError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DecryptStructureError -> ShowS
showsPrec :: Int -> DecryptStructureError -> ShowS
$cshow :: DecryptStructureError -> [Char]
show :: DecryptStructureError -> [Char]
$cshowList :: [DecryptStructureError] -> ShowS
showList :: [DecryptStructureError] -> ShowS
Show)

renderDecryptStructureError :: DecryptStructureError -> String
renderDecryptStructureError :: DecryptStructureError -> [Char]
renderDecryptStructureError DecryptStructureError
DecryptStructureESKSEIPDMismatch =
    [Char]
"expected exactly one SKESK packet and exactly one SEIPDv2 packet"
renderDecryptStructureError DecryptStructureError
DecryptStructureESKOrder =
    [Char]
"expected the SKESK packet to precede the SEIPDv2 packet"
renderDecryptStructureError DecryptStructureError
DecryptStructureTrailingData =
    [Char]
"trailing data after SEIPDv2 payload"

-------------------------------------------------------------------------------

data DecryptOutcome
    = DecryptClean
    | DecryptTruncated
    | DecryptTrailingData
    | DecryptMalformedStructure !DecryptStructureError
    deriving (DecryptOutcome -> DecryptOutcome -> Bool
(DecryptOutcome -> DecryptOutcome -> Bool)
-> (DecryptOutcome -> DecryptOutcome -> Bool) -> Eq DecryptOutcome
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DecryptOutcome -> DecryptOutcome -> Bool
== :: DecryptOutcome -> DecryptOutcome -> Bool
$c/= :: DecryptOutcome -> DecryptOutcome -> Bool
/= :: DecryptOutcome -> DecryptOutcome -> Bool
Eq, Int -> DecryptOutcome -> ShowS
[DecryptOutcome] -> ShowS
DecryptOutcome -> [Char]
(Int -> DecryptOutcome -> ShowS)
-> (DecryptOutcome -> [Char])
-> ([DecryptOutcome] -> ShowS)
-> Show DecryptOutcome
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DecryptOutcome -> ShowS
showsPrec :: Int -> DecryptOutcome -> ShowS
$cshow :: DecryptOutcome -> [Char]
show :: DecryptOutcome -> [Char]
$cshowList :: [DecryptOutcome] -> ShowS
showList :: [DecryptOutcome] -> ShowS
Show)

renderDecryptOutcome :: DecryptOutcome -> String
renderDecryptOutcome :: DecryptOutcome -> [Char]
renderDecryptOutcome DecryptOutcome
DecryptClean = [Char]
"clean"
renderDecryptOutcome DecryptOutcome
DecryptTruncated = [Char]
"truncated"
renderDecryptOutcome DecryptOutcome
DecryptTrailingData = [Char]
"trailing data"
renderDecryptOutcome (DecryptMalformedStructure DecryptStructureError
err) =
    [Char]
"malformed structure: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ DecryptStructureError -> [Char]
renderDecryptStructureError DecryptStructureError
err

-------------------------------------------------------------------------------

data DecryptSessionKeyResolutionPath
    = DecryptResolvedViaSKESK
    | DecryptResolvedViaPKESK
    | DecryptResolvedViaManualPKESKInput
    deriving (DecryptSessionKeyResolutionPath
-> DecryptSessionKeyResolutionPath -> Bool
(DecryptSessionKeyResolutionPath
 -> DecryptSessionKeyResolutionPath -> Bool)
-> (DecryptSessionKeyResolutionPath
    -> DecryptSessionKeyResolutionPath -> Bool)
-> Eq DecryptSessionKeyResolutionPath
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DecryptSessionKeyResolutionPath
-> DecryptSessionKeyResolutionPath -> Bool
== :: DecryptSessionKeyResolutionPath
-> DecryptSessionKeyResolutionPath -> Bool
$c/= :: DecryptSessionKeyResolutionPath
-> DecryptSessionKeyResolutionPath -> Bool
/= :: DecryptSessionKeyResolutionPath
-> DecryptSessionKeyResolutionPath -> Bool
Eq, Int -> DecryptSessionKeyResolutionPath -> ShowS
[DecryptSessionKeyResolutionPath] -> ShowS
DecryptSessionKeyResolutionPath -> [Char]
(Int -> DecryptSessionKeyResolutionPath -> ShowS)
-> (DecryptSessionKeyResolutionPath -> [Char])
-> ([DecryptSessionKeyResolutionPath] -> ShowS)
-> Show DecryptSessionKeyResolutionPath
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DecryptSessionKeyResolutionPath -> ShowS
showsPrec :: Int -> DecryptSessionKeyResolutionPath -> ShowS
$cshow :: DecryptSessionKeyResolutionPath -> [Char]
show :: DecryptSessionKeyResolutionPath -> [Char]
$cshowList :: [DecryptSessionKeyResolutionPath] -> ShowS
showList :: [DecryptSessionKeyResolutionPath] -> ShowS
Show)

-------------------------------------------------------------------------------

data PKESKResolverAttemptAction
    = ResolverAttemptResolveWith (Maybe (KeyVersion, PubKeyAlgorithm))
    | ResolverAttemptSkip
    | ResolverAttemptExhausted
    deriving (PKESKResolverAttemptAction -> PKESKResolverAttemptAction -> Bool
(PKESKResolverAttemptAction -> PKESKResolverAttemptAction -> Bool)
-> (PKESKResolverAttemptAction
    -> PKESKResolverAttemptAction -> Bool)
-> Eq PKESKResolverAttemptAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PKESKResolverAttemptAction -> PKESKResolverAttemptAction -> Bool
== :: PKESKResolverAttemptAction -> PKESKResolverAttemptAction -> Bool
$c/= :: PKESKResolverAttemptAction -> PKESKResolverAttemptAction -> Bool
/= :: PKESKResolverAttemptAction -> PKESKResolverAttemptAction -> Bool
Eq, Int -> PKESKResolverAttemptAction -> ShowS
[PKESKResolverAttemptAction] -> ShowS
PKESKResolverAttemptAction -> [Char]
(Int -> PKESKResolverAttemptAction -> ShowS)
-> (PKESKResolverAttemptAction -> [Char])
-> ([PKESKResolverAttemptAction] -> ShowS)
-> Show PKESKResolverAttemptAction
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PKESKResolverAttemptAction -> ShowS
showsPrec :: Int -> PKESKResolverAttemptAction -> ShowS
$cshow :: PKESKResolverAttemptAction -> [Char]
show :: PKESKResolverAttemptAction -> [Char]
$cshowList :: [PKESKResolverAttemptAction] -> ShowS
showList :: [PKESKResolverAttemptAction] -> ShowS
Show)

-------------------------------------------------------------------------------

data PKESKResolverAttempt
    = PKESKResolverAttempt
    { PKESKResolverAttempt -> [PKESKAttemptFailure]
pkeskResolverAttemptPreviousFailures :: [PKESKAttemptFailure]
    , PKESKResolverAttempt -> PKESKResolverAttemptAction
pkeskResolverAttemptAction :: PKESKResolverAttemptAction
    }
    deriving (PKESKResolverAttempt -> PKESKResolverAttempt -> Bool
(PKESKResolverAttempt -> PKESKResolverAttempt -> Bool)
-> (PKESKResolverAttempt -> PKESKResolverAttempt -> Bool)
-> Eq PKESKResolverAttempt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PKESKResolverAttempt -> PKESKResolverAttempt -> Bool
== :: PKESKResolverAttempt -> PKESKResolverAttempt -> Bool
$c/= :: PKESKResolverAttempt -> PKESKResolverAttempt -> Bool
/= :: PKESKResolverAttempt -> PKESKResolverAttempt -> Bool
Eq, Int -> PKESKResolverAttempt -> ShowS
[PKESKResolverAttempt] -> ShowS
PKESKResolverAttempt -> [Char]
(Int -> PKESKResolverAttempt -> ShowS)
-> (PKESKResolverAttempt -> [Char])
-> ([PKESKResolverAttempt] -> ShowS)
-> Show PKESKResolverAttempt
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PKESKResolverAttempt -> ShowS
showsPrec :: Int -> PKESKResolverAttempt -> ShowS
$cshow :: PKESKResolverAttempt -> [Char]
show :: PKESKResolverAttempt -> [Char]
$cshowList :: [PKESKResolverAttempt] -> ShowS
showList :: [PKESKResolverAttempt] -> ShowS
Show)

-------------------------------------------------------------------------------

data DecryptSessionKeyResolutionReport
    = DecryptSessionKeyResolutionReport
    { DecryptSessionKeyResolutionReport
-> DecryptSessionKeyResolutionPath
decryptSessionResolutionPath :: DecryptSessionKeyResolutionPath
    , DecryptSessionKeyResolutionReport
-> [SKESKSessionKeyResolutionError]
decryptSessionResolutionSKESKErrors
        :: [SKESKSessionKeyResolutionError]
    , DecryptSessionKeyResolutionReport -> [PKESKAttemptFailure]
decryptSessionResolutionPKESKErrors :: [PKESKAttemptFailure]
    , DecryptSessionKeyResolutionReport -> [PKESKResolverAttempt]
decryptSessionResolutionResolverAttempts
        :: [PKESKResolverAttempt]
    }
    deriving (DecryptSessionKeyResolutionReport
-> DecryptSessionKeyResolutionReport -> Bool
(DecryptSessionKeyResolutionReport
 -> DecryptSessionKeyResolutionReport -> Bool)
-> (DecryptSessionKeyResolutionReport
    -> DecryptSessionKeyResolutionReport -> Bool)
-> Eq DecryptSessionKeyResolutionReport
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DecryptSessionKeyResolutionReport
-> DecryptSessionKeyResolutionReport -> Bool
== :: DecryptSessionKeyResolutionReport
-> DecryptSessionKeyResolutionReport -> Bool
$c/= :: DecryptSessionKeyResolutionReport
-> DecryptSessionKeyResolutionReport -> Bool
/= :: DecryptSessionKeyResolutionReport
-> DecryptSessionKeyResolutionReport -> Bool
Eq, Int -> DecryptSessionKeyResolutionReport -> ShowS
[DecryptSessionKeyResolutionReport] -> ShowS
DecryptSessionKeyResolutionReport -> [Char]
(Int -> DecryptSessionKeyResolutionReport -> ShowS)
-> (DecryptSessionKeyResolutionReport -> [Char])
-> ([DecryptSessionKeyResolutionReport] -> ShowS)
-> Show DecryptSessionKeyResolutionReport
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DecryptSessionKeyResolutionReport -> ShowS
showsPrec :: Int -> DecryptSessionKeyResolutionReport -> ShowS
$cshow :: DecryptSessionKeyResolutionReport -> [Char]
show :: DecryptSessionKeyResolutionReport -> [Char]
$cshowList :: [DecryptSessionKeyResolutionReport] -> ShowS
showList :: [DecryptSessionKeyResolutionReport] -> ShowS
Show)

-------------------------------------------------------------------------------

data DecryptReport
    = DecryptReport
    { DecryptReport -> DecryptOutcome
decryptReportOutcome :: DecryptOutcome
    , DecryptReport -> [DecryptSessionKeyResolutionReport]
decryptReportSessionKeyResolutions
        :: [DecryptSessionKeyResolutionReport]
    }
    deriving (DecryptReport -> DecryptReport -> Bool
(DecryptReport -> DecryptReport -> Bool)
-> (DecryptReport -> DecryptReport -> Bool) -> Eq DecryptReport
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DecryptReport -> DecryptReport -> Bool
== :: DecryptReport -> DecryptReport -> Bool
$c/= :: DecryptReport -> DecryptReport -> Bool
/= :: DecryptReport -> DecryptReport -> Bool
Eq, Int -> DecryptReport -> ShowS
[DecryptReport] -> ShowS
DecryptReport -> [Char]
(Int -> DecryptReport -> ShowS)
-> (DecryptReport -> [Char])
-> ([DecryptReport] -> ShowS)
-> Show DecryptReport
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DecryptReport -> ShowS
showsPrec :: Int -> DecryptReport -> ShowS
$cshow :: DecryptReport -> [Char]
show :: DecryptReport -> [Char]
$cshowList :: [DecryptReport] -> ShowS
showList :: [DecryptReport] -> ShowS
Show)

-- FIXME: this is suboptimal
renderDecryptSessionKeyResolutionReport
    :: DecryptSessionKeyResolutionReport -> String
renderDecryptSessionKeyResolutionReport :: DecryptSessionKeyResolutionReport -> [Char]
renderDecryptSessionKeyResolutionReport
    ( DecryptSessionKeyResolutionReport
            DecryptSessionKeyResolutionPath
_path
            [SKESKSessionKeyResolutionError]
_skeskErrors
            [PKESKAttemptFailure]
_pkeskErrors
            [PKESKResolverAttempt]
_resolverAttempts
        ) =
        [Char]
"decrypt session key resolution report"

renderDecryptReport :: DecryptReport -> String
renderDecryptReport :: DecryptReport -> [Char]
renderDecryptReport (DecryptReport DecryptOutcome
outcome [DecryptSessionKeyResolutionReport]
resolutions) =
    [Char]
"decrypt report: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ DecryptOutcome -> [Char]
forall a. Show a => a -> [Char]
show DecryptOutcome
outcome
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
", "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show ([DecryptSessionKeyResolutionReport] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [DecryptSessionKeyResolutionReport]
resolutions)
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" resolutions"

-------------------------------------------------------------------------------

data SKESKSessionKeyResolutionError
    = SKESKSessionKeyS2KError !S2KError
    | SKESKSessionKeySEIPDv2Error !SEIPDv2Failure
    | SKESKSessionKeyOtherError !String
    deriving (SKESKSessionKeyResolutionError
-> SKESKSessionKeyResolutionError -> Bool
(SKESKSessionKeyResolutionError
 -> SKESKSessionKeyResolutionError -> Bool)
-> (SKESKSessionKeyResolutionError
    -> SKESKSessionKeyResolutionError -> Bool)
-> Eq SKESKSessionKeyResolutionError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SKESKSessionKeyResolutionError
-> SKESKSessionKeyResolutionError -> Bool
== :: SKESKSessionKeyResolutionError
-> SKESKSessionKeyResolutionError -> Bool
$c/= :: SKESKSessionKeyResolutionError
-> SKESKSessionKeyResolutionError -> Bool
/= :: SKESKSessionKeyResolutionError
-> SKESKSessionKeyResolutionError -> Bool
Eq, Int -> SKESKSessionKeyResolutionError -> ShowS
[SKESKSessionKeyResolutionError] -> ShowS
SKESKSessionKeyResolutionError -> [Char]
(Int -> SKESKSessionKeyResolutionError -> ShowS)
-> (SKESKSessionKeyResolutionError -> [Char])
-> ([SKESKSessionKeyResolutionError] -> ShowS)
-> Show SKESKSessionKeyResolutionError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SKESKSessionKeyResolutionError -> ShowS
showsPrec :: Int -> SKESKSessionKeyResolutionError -> ShowS
$cshow :: SKESKSessionKeyResolutionError -> [Char]
show :: SKESKSessionKeyResolutionError -> [Char]
$cshowList :: [SKESKSessionKeyResolutionError] -> ShowS
showList :: [SKESKSessionKeyResolutionError] -> ShowS
Show)

renderSKESKSessionKeyResolutionError
    :: SKESKSessionKeyResolutionError -> String
renderSKESKSessionKeyResolutionError :: SKESKSessionKeyResolutionError -> [Char]
renderSKESKSessionKeyResolutionError (SKESKSessionKeyS2KError S2KError
err) = S2KError -> [Char]
renderS2KError S2KError
err
renderSKESKSessionKeyResolutionError (SKESKSessionKeySEIPDv2Error SEIPDv2Failure
err) =
    SEIPDv2Failure -> [Char]
renderSEIPDv2Failure SEIPDv2Failure
err
renderSKESKSessionKeyResolutionError (SKESKSessionKeyOtherError [Char]
err) = [Char]
err

-------------------------------------------------------------------------------

data PKESKX25519V3UnwrapError
    = PKESKX25519V3ParseError !String
    | PKESKX25519V3CipherError !CipherError
    | PKESKX25519V3KeySizeError !CipherError
    | PKESKX25519V3KeyLengthMismatch !SymmetricAlgorithm !Int !Int
    deriving (PKESKX25519V3UnwrapError -> PKESKX25519V3UnwrapError -> Bool
(PKESKX25519V3UnwrapError -> PKESKX25519V3UnwrapError -> Bool)
-> (PKESKX25519V3UnwrapError -> PKESKX25519V3UnwrapError -> Bool)
-> Eq PKESKX25519V3UnwrapError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PKESKX25519V3UnwrapError -> PKESKX25519V3UnwrapError -> Bool
== :: PKESKX25519V3UnwrapError -> PKESKX25519V3UnwrapError -> Bool
$c/= :: PKESKX25519V3UnwrapError -> PKESKX25519V3UnwrapError -> Bool
/= :: PKESKX25519V3UnwrapError -> PKESKX25519V3UnwrapError -> Bool
Eq, Int -> PKESKX25519V3UnwrapError -> ShowS
[PKESKX25519V3UnwrapError] -> ShowS
PKESKX25519V3UnwrapError -> [Char]
(Int -> PKESKX25519V3UnwrapError -> ShowS)
-> (PKESKX25519V3UnwrapError -> [Char])
-> ([PKESKX25519V3UnwrapError] -> ShowS)
-> Show PKESKX25519V3UnwrapError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PKESKX25519V3UnwrapError -> ShowS
showsPrec :: Int -> PKESKX25519V3UnwrapError -> ShowS
$cshow :: PKESKX25519V3UnwrapError -> [Char]
show :: PKESKX25519V3UnwrapError -> [Char]
$cshowList :: [PKESKX25519V3UnwrapError] -> ShowS
showList :: [PKESKX25519V3UnwrapError] -> ShowS
Show)

renderPKESKX25519V3UnwrapError
    :: PKESKX25519V3UnwrapError -> String
renderPKESKX25519V3UnwrapError :: PKESKX25519V3UnwrapError -> [Char]
renderPKESKX25519V3UnwrapError (PKESKX25519V3ParseError [Char]
err) = [Char]
err
renderPKESKX25519V3UnwrapError (PKESKX25519V3CipherError CipherError
err) = CipherError -> [Char]
renderCipherError CipherError
err
renderPKESKX25519V3UnwrapError (PKESKX25519V3KeySizeError CipherError
err) = CipherError -> [Char]
renderCipherError CipherError
err
renderPKESKX25519V3UnwrapError (PKESKX25519V3KeyLengthMismatch SymmetricAlgorithm
algo Int
expected Int
actual) =
    [Char]
"X25519 PKESKv3 unwrapped session key length mismatch for "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SymmetricAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show SymmetricAlgorithm
algo
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": expected "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
expected
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
", got "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
actual

-------------------------------------------------------------------------------
-- Top-level message error
-------------------------------------------------------------------------------

data MessageError
    = MessageEncryptFailureError !MessageEncryptFailure
    | MessageSignError !SignError
    | MessageParseFailureError !MessageParseFailure
    | MessageDecryptFailureError !MessageDecryptFailure
    deriving (MessageError -> MessageError -> Bool
(MessageError -> MessageError -> Bool)
-> (MessageError -> MessageError -> Bool) -> Eq MessageError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MessageError -> MessageError -> Bool
== :: MessageError -> MessageError -> Bool
$c/= :: MessageError -> MessageError -> Bool
/= :: MessageError -> MessageError -> Bool
Eq, Int -> MessageError -> ShowS
[MessageError] -> ShowS
MessageError -> [Char]
(Int -> MessageError -> ShowS)
-> (MessageError -> [Char])
-> ([MessageError] -> ShowS)
-> Show MessageError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MessageError -> ShowS
showsPrec :: Int -> MessageError -> ShowS
$cshow :: MessageError -> [Char]
show :: MessageError -> [Char]
$cshowList :: [MessageError] -> ShowS
showList :: [MessageError] -> ShowS
Show)

renderMessageError :: MessageError -> String
renderMessageError :: MessageError -> [Char]
renderMessageError (MessageEncryptFailureError MessageEncryptFailure
err) = MessageEncryptFailure -> [Char]
renderMessageEncryptFailure MessageEncryptFailure
err
renderMessageError (MessageSignError SignError
err) = SignError -> [Char]
renderSignError SignError
err
renderMessageError (MessageParseFailureError MessageParseFailure
err) = MessageParseFailure -> [Char]
renderMessageParseFailure MessageParseFailure
err
renderMessageError (MessageDecryptFailureError MessageDecryptFailure
err) = MessageDecryptFailure -> [Char]
renderMessageDecryptFailure MessageDecryptFailure
err

-------------------------------------------------------------------------------
-- PKESK / packet-parse errors (parameterized by pkt)
-------------------------------------------------------------------------------

data CurveConversionError
    = CurveConversionUnsupportedCurve !ByteString
    | CurveConversionUnsupportedEdCurve !ByteString
    deriving (CurveConversionError -> CurveConversionError -> Bool
(CurveConversionError -> CurveConversionError -> Bool)
-> (CurveConversionError -> CurveConversionError -> Bool)
-> Eq CurveConversionError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CurveConversionError -> CurveConversionError -> Bool
== :: CurveConversionError -> CurveConversionError -> Bool
$c/= :: CurveConversionError -> CurveConversionError -> Bool
/= :: CurveConversionError -> CurveConversionError -> Bool
Eq, Int -> CurveConversionError -> ShowS
[CurveConversionError] -> ShowS
CurveConversionError -> [Char]
(Int -> CurveConversionError -> ShowS)
-> (CurveConversionError -> [Char])
-> ([CurveConversionError] -> ShowS)
-> Show CurveConversionError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CurveConversionError -> ShowS
showsPrec :: Int -> CurveConversionError -> ShowS
$cshow :: CurveConversionError -> [Char]
show :: CurveConversionError -> [Char]
$cshowList :: [CurveConversionError] -> ShowS
showList :: [CurveConversionError] -> ShowS
Show)

renderCurveConversionError :: CurveConversionError -> String
renderCurveConversionError :: CurveConversionError -> [Char]
renderCurveConversionError (CurveConversionUnsupportedCurve ByteString
bs) =
    [Char]
"unsupported curve OID: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> [Char]
forall a. Show a => a -> [Char]
show ByteString
bs
renderCurveConversionError (CurveConversionUnsupportedEdCurve ByteString
bs) =
    [Char]
"unsupported Ed signing curve OID: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> [Char]
forall a. Show a => a -> [Char]
show ByteString
bs

-- | Reasons for packet parse errors
data PktParseErrorReason
    = PktParseErrorReasonPKESKv6RecipientIdentifierInvalid
        { PktParseErrorReason -> Int
pkeskRecipientIdLength :: Int
        }
    | PktParseErrorReasonPKESKv6KeyVersionInvalid
        { PktParseErrorReason -> Word8
pkeskKeyVersion :: Word8
        }
    | PktParseErrorReasonPKESKv6FingerprintLengthMismatch
        { pkeskKeyVersion :: Word8
        , PktParseErrorReason -> Int
pkeskExpectedFingerprintLength :: Int
        , PktParseErrorReason -> Int
pkeskActualFingerprintLength :: Int
        }
    | PktParseErrorReasonUnexpectedTrailingPKESKData
        { PktParseErrorReason -> PubKeyAlgorithm
pkeskAlgorithm :: PubKeyAlgorithm
        }
    | PktParseErrorReasonX25519V3OctetLayoutInvalid X25519OctetError
    | PktParseErrorReasonECDHOctetLayoutInvalid ECDHOctetError
    | PktParseErrorReasonCurveConversionFailed CurveConversionError
    | PktParseErrorReasonInvalidECPoint ECPointError
    | PktParseErrorReasonGeneric String
    deriving (PktParseErrorReason -> PktParseErrorReason -> Bool
(PktParseErrorReason -> PktParseErrorReason -> Bool)
-> (PktParseErrorReason -> PktParseErrorReason -> Bool)
-> Eq PktParseErrorReason
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PktParseErrorReason -> PktParseErrorReason -> Bool
== :: PktParseErrorReason -> PktParseErrorReason -> Bool
$c/= :: PktParseErrorReason -> PktParseErrorReason -> Bool
/= :: PktParseErrorReason -> PktParseErrorReason -> Bool
Eq, Int -> PktParseErrorReason -> ShowS
[PktParseErrorReason] -> ShowS
PktParseErrorReason -> [Char]
(Int -> PktParseErrorReason -> ShowS)
-> (PktParseErrorReason -> [Char])
-> ([PktParseErrorReason] -> ShowS)
-> Show PktParseErrorReason
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PktParseErrorReason -> ShowS
showsPrec :: Int -> PktParseErrorReason -> ShowS
$cshow :: PktParseErrorReason -> [Char]
show :: PktParseErrorReason -> [Char]
$cshowList :: [PktParseErrorReason] -> ShowS
showList :: [PktParseErrorReason] -> ShowS
Show)

renderPktParseReason :: PktParseErrorReason -> String
renderPktParseReason :: PktParseErrorReason -> [Char]
renderPktParseReason (PktParseErrorReasonPKESKv6RecipientIdentifierInvalid Int
len) =
    [Char]
"invalid PKESK v6 recipient identifier length: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
len
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" (expected 0, 20, 21, 32, or 33)"
renderPktParseReason (PktParseErrorReasonPKESKv6KeyVersionInvalid Word8
ver) =
    [Char]
"invalid PKESK v6 recipient key version: "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
ver
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" (expected 4 or 6)"
renderPktParseReason
    ( PktParseErrorReasonPKESKv6FingerprintLengthMismatch
            Word8
ver
            Int
expected
            Int
got
        ) =
        [Char]
"PKESK v6 recipient identifier length/version mismatch: key version "
            [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
ver
            [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" requires fingerprint length "
            [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
expected
            [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
", got "
            [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
got
renderPktParseReason (PktParseErrorReasonUnexpectedTrailingPKESKData PubKeyAlgorithm
pka) =
    [Char]
"unexpected trailing PKESK MPI data for algorithm " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PubKeyAlgorithm -> [Char]
forall a. Show a => a -> [Char]
show PubKeyAlgorithm
pka
renderPktParseReason (PktParseErrorReasonX25519V3OctetLayoutInvalid X25519OctetError
e) =
    X25519OctetError -> [Char]
renderX25519OctetError X25519OctetError
e
renderPktParseReason (PktParseErrorReasonECDHOctetLayoutInvalid ECDHOctetError
e) =
    ECDHOctetError -> [Char]
renderECDHOctetError ECDHOctetError
e
renderPktParseReason (PktParseErrorReasonCurveConversionFailed CurveConversionError
e) =
    CurveConversionError -> [Char]
renderCurveConversionError CurveConversionError
e
renderPktParseReason (PktParseErrorReasonInvalidECPoint ECPointError
e) =
    ECPointError -> [Char]
renderECPointError ECPointError
e
renderPktParseReason (PktParseErrorReasonGeneric [Char]
msg) = [Char]
msg

-- | Packet parse errors with typed reason
data PktParseError
    = PktParseError
    { PktParseError -> Int64
pktParseErrorOffset :: Int64
    , PktParseError -> PktParseErrorReason
pktParseErrorReason :: PktParseErrorReason
    }
    deriving (PktParseError -> PktParseError -> Bool
(PktParseError -> PktParseError -> Bool)
-> (PktParseError -> PktParseError -> Bool) -> Eq PktParseError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PktParseError -> PktParseError -> Bool
== :: PktParseError -> PktParseError -> Bool
$c/= :: PktParseError -> PktParseError -> Bool
/= :: PktParseError -> PktParseError -> Bool
Eq, Int -> PktParseError -> ShowS
[PktParseError] -> ShowS
PktParseError -> [Char]
(Int -> PktParseError -> ShowS)
-> (PktParseError -> [Char])
-> ([PktParseError] -> ShowS)
-> Show PktParseError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PktParseError -> ShowS
showsPrec :: Int -> PktParseError -> ShowS
$cshow :: PktParseError -> [Char]
show :: PktParseError -> [Char]
$cshowList :: [PktParseError] -> ShowS
showList :: [PktParseError] -> ShowS
Show)

renderPktParseError :: PktParseError -> String
renderPktParseError :: PktParseError -> [Char]
renderPktParseError (PktParseError Int64
off PktParseErrorReason
reason) =
    [Char]
"parse error at offset "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Int64 -> [Char]
forall a. Show a => a -> [Char]
show Int64
off
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
": "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PktParseErrorReason -> [Char]
renderPktParseReason PktParseErrorReason
reason

data PKESKAttemptFailureKind
    = PKESKAttemptUnwrapFailed
    | PKESKAttemptSessionMaterialDecodeFailed
    deriving (PKESKAttemptFailureKind -> PKESKAttemptFailureKind -> Bool
(PKESKAttemptFailureKind -> PKESKAttemptFailureKind -> Bool)
-> (PKESKAttemptFailureKind -> PKESKAttemptFailureKind -> Bool)
-> Eq PKESKAttemptFailureKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PKESKAttemptFailureKind -> PKESKAttemptFailureKind -> Bool
== :: PKESKAttemptFailureKind -> PKESKAttemptFailureKind -> Bool
$c/= :: PKESKAttemptFailureKind -> PKESKAttemptFailureKind -> Bool
/= :: PKESKAttemptFailureKind -> PKESKAttemptFailureKind -> Bool
Eq, Int -> PKESKAttemptFailureKind -> ShowS
[PKESKAttemptFailureKind] -> ShowS
PKESKAttemptFailureKind -> [Char]
(Int -> PKESKAttemptFailureKind -> ShowS)
-> (PKESKAttemptFailureKind -> [Char])
-> ([PKESKAttemptFailureKind] -> ShowS)
-> Show PKESKAttemptFailureKind
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PKESKAttemptFailureKind -> ShowS
showsPrec :: Int -> PKESKAttemptFailureKind -> ShowS
$cshow :: PKESKAttemptFailureKind -> [Char]
show :: PKESKAttemptFailureKind -> [Char]
$cshowList :: [PKESKAttemptFailureKind] -> ShowS
showList :: [PKESKAttemptFailureKind] -> ShowS
Show)

data PKESKAttemptFailure
    = PKESKAttemptFailure
    { PKESKAttemptFailure -> Maybe (KeyVersion, PubKeyAlgorithm)
pkeskAttemptFailureKeyContext
        :: Maybe (KeyVersion, PubKeyAlgorithm)
    , PKESKAttemptFailure -> PKESKAttemptFailureKind
pkeskAttemptFailureKind :: PKESKAttemptFailureKind
    , PKESKAttemptFailure -> [Char]
pkeskAttemptFailureReason :: String
    }
    deriving (PKESKAttemptFailure -> PKESKAttemptFailure -> Bool
(PKESKAttemptFailure -> PKESKAttemptFailure -> Bool)
-> (PKESKAttemptFailure -> PKESKAttemptFailure -> Bool)
-> Eq PKESKAttemptFailure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PKESKAttemptFailure -> PKESKAttemptFailure -> Bool
== :: PKESKAttemptFailure -> PKESKAttemptFailure -> Bool
$c/= :: PKESKAttemptFailure -> PKESKAttemptFailure -> Bool
/= :: PKESKAttemptFailure -> PKESKAttemptFailure -> Bool
Eq, Int -> PKESKAttemptFailure -> ShowS
[PKESKAttemptFailure] -> ShowS
PKESKAttemptFailure -> [Char]
(Int -> PKESKAttemptFailure -> ShowS)
-> (PKESKAttemptFailure -> [Char])
-> ([PKESKAttemptFailure] -> ShowS)
-> Show PKESKAttemptFailure
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PKESKAttemptFailure -> ShowS
showsPrec :: Int -> PKESKAttemptFailure -> ShowS
$cshow :: PKESKAttemptFailure -> [Char]
show :: PKESKAttemptFailure -> [Char]
$cshowList :: [PKESKAttemptFailure] -> ShowS
showList :: [PKESKAttemptFailure] -> ShowS
Show)