Full KES verification. This method checks that the signature itself checks out (as per verifySigKES), and also makes sure that it matches the provided VerKey.

totalPeriodsKES :: proxy v -> Word #

Return the total number of KES periods supported by this algorithm. The KES algorithm is assumed to support a fixed maximum number of periods, not a variable number.

Do note that this is the total number of periods not the total number of evolutions. The difference is off-by-one. For example if there are 2 periods (period 0 and 1) then there is only one evolution.

rawSerialiseVerKeyKES :: VerKeyKES v -> ByteString #

rawSerialiseSigKES :: SigKES v -> ByteString #

rawDeserialiseVerKeyKES :: ByteString -> Maybe (VerKeyKES v) #

rawDeserialiseSigKES :: ByteString -> Maybe (SigKES v) #

Instances

Instances details

KESAlgorithm NeverKES #
Instance details Defined in Cardano.Crypto.KES.NeverUsed Associated Types data VerKeyKES NeverKES # data SigKES NeverKES # type SeedSizeKES NeverKES :: Nat # type SizeVerKeyKES NeverKES :: Nat # type SizeSignKeyKES NeverKES :: Nat # type SizeSigKES NeverKES :: Nat # type ContextKES NeverKES # type Signable NeverKES :: Type -> Constraint # Methods algorithmNameKES :: proxy NeverKES -> String # hashVerKeyKES :: HashAlgorithm h => VerKeyKES NeverKES -> Hash h (VerKeyKES NeverKES) # verifyKES :: (Signable NeverKES a, HasCallStack) => ContextKES NeverKES -> VerKeyKES NeverKES -> Period -> a -> SigKES NeverKES -> Either String () # totalPeriodsKES :: proxy NeverKES -> Word # rawSerialiseVerKeyKES :: VerKeyKES NeverKES -> ByteString # rawSerialiseSigKES :: SigKES NeverKES -> ByteString # rawDeserialiseVerKeyKES :: ByteString -> Maybe (VerKeyKES NeverKES) # rawDeserialiseSigKES :: ByteString -> Maybe (SigKES NeverKES) #
(DSIGNMAlgorithmBase d, KnownNat (SizeSigDSIGNM d + SizeVerKeyDSIGNM d)) => KESAlgorithm (CompactSingleKES d) #
Instance details Defined in Cardano.Crypto.KES.CompactSingle Associated Types data VerKeyKES (CompactSingleKES d) # data SigKES (CompactSingleKES d) # type SeedSizeKES (CompactSingleKES d) :: Nat # type SizeVerKeyKES (CompactSingleKES d) :: Nat # type SizeSignKeyKES (CompactSingleKES d) :: Nat # type SizeSigKES (CompactSingleKES d) :: Nat # type ContextKES (CompactSingleKES d) # type Signable (CompactSingleKES d) :: Type -> Constraint # Methods algorithmNameKES :: proxy (CompactSingleKES d) -> String # hashVerKeyKES :: HashAlgorithm h => VerKeyKES (CompactSingleKES d) -> Hash h (VerKeyKES (CompactSingleKES d)) # verifyKES :: (Signable (CompactSingleKES d) a, HasCallStack) => ContextKES (CompactSingleKES d) -> VerKeyKES (CompactSingleKES d) -> Period -> a -> SigKES (CompactSingleKES d) -> Either String () # totalPeriodsKES :: proxy (CompactSingleKES d) -> Word # rawSerialiseVerKeyKES :: VerKeyKES (CompactSingleKES d) -> ByteString # rawSerialiseSigKES :: SigKES (CompactSingleKES d) -> ByteString # rawDeserialiseVerKeyKES :: ByteString -> Maybe (VerKeyKES (CompactSingleKES d)) # rawDeserialiseSigKES :: ByteString -> Maybe (SigKES (CompactSingleKES d)) #
KnownNat t => KESAlgorithm (MockKES t) #	Mock key evolving signatures. What is the difference between Mock KES and Simple KES (`Cardano.Crypto.KES.Simple`), you may ask? Simple KES satisfies the outward appearance of a KES scheme through assembling a pre-generated list of keys and iterating through them. Mock KES, on the other hand, pretends to be KES but in fact does no key evolution whatsoever. Simple KES is appropriate for testing, since it will for example reject old keys. Mock KES is more suitable for a basic testnet, since it doesn't suffer from the performance implications of shuffling a giant list of keys around
Instance details Defined in Cardano.Crypto.KES.Mock Associated Types data VerKeyKES (MockKES t) # data SigKES (MockKES t) # type SeedSizeKES (MockKES t) :: Nat # type SizeVerKeyKES (MockKES t) :: Nat # type SizeSignKeyKES (MockKES t) :: Nat # type SizeSigKES (MockKES t) :: Nat # type ContextKES (MockKES t) # type Signable (MockKES t) :: Type -> Constraint # Methods algorithmNameKES :: proxy (MockKES t) -> String # hashVerKeyKES :: HashAlgorithm h => VerKeyKES (MockKES t) -> Hash h (VerKeyKES (MockKES t)) # verifyKES :: (Signable (MockKES t) a, HasCallStack) => ContextKES (MockKES t) -> VerKeyKES (MockKES t) -> Period -> a -> SigKES (MockKES t) -> Either String () # totalPeriodsKES :: proxy (MockKES t) -> Word # rawSerialiseVerKeyKES :: VerKeyKES (MockKES t) -> ByteString # rawSerialiseSigKES :: SigKES (MockKES t) -> ByteString # rawDeserialiseVerKeyKES :: ByteString -> Maybe (VerKeyKES (MockKES t)) # rawDeserialiseSigKES :: ByteString -> Maybe (SigKES (MockKES t)) #
DSIGNMAlgorithmBase d => KESAlgorithm (SingleKES d) #
Instance details Defined in Cardano.Crypto.KES.Single Associated Types data VerKeyKES (SingleKES d) # data SigKES (SingleKES d) # type SeedSizeKES (SingleKES d) :: Nat # type SizeVerKeyKES (SingleKES d) :: Nat # type SizeSignKeyKES (SingleKES d) :: Nat # type SizeSigKES (SingleKES d) :: Nat # type ContextKES (SingleKES d) # type Signable (SingleKES d) :: Type -> Constraint # Methods algorithmNameKES :: proxy (SingleKES d) -> String # hashVerKeyKES :: HashAlgorithm h => VerKeyKES (SingleKES d) -> Hash h (VerKeyKES (SingleKES d)) # verifyKES :: (Signable (SingleKES d) a, HasCallStack) => ContextKES (SingleKES d) -> VerKeyKES (SingleKES d) -> Period -> a -> SigKES (SingleKES d) -> Either String () # totalPeriodsKES :: proxy (SingleKES d) -> Word # rawSerialiseVerKeyKES :: VerKeyKES (SingleKES d) -> ByteString # rawSerialiseSigKES :: SigKES (SingleKES d) -> ByteString # rawDeserialiseVerKeyKES :: ByteString -> Maybe (VerKeyKES (SingleKES d)) # rawDeserialiseSigKES :: ByteString -> Maybe (SigKES (SingleKES d)) #
(OptimizedKESAlgorithm d, SodiumHashAlgorithm h, SizeHash h ~ SeedSizeKES d, NoThunks (VerKeyKES (CompactSumKES h d)), KnownNat (SizeVerKeyKES (CompactSumKES h d)), KnownNat (SizeSignKeyKES (CompactSumKES h d)), KnownNat (SizeSigKES (CompactSumKES h d))) => KESAlgorithm (CompactSumKES h d) #
Instance details Defined in Cardano.Crypto.KES.CompactSum Associated Types data VerKeyKES (CompactSumKES h d) # data SigKES (CompactSumKES h d) # type SeedSizeKES (CompactSumKES h d) :: Nat # type SizeVerKeyKES (CompactSumKES h d) :: Nat # type SizeSignKeyKES (CompactSumKES h d) :: Nat # type SizeSigKES (CompactSumKES h d) :: Nat # type ContextKES (CompactSumKES h d) # type Signable (CompactSumKES h d) :: Type -> Constraint # Methods algorithmNameKES :: proxy (CompactSumKES h d) -> String # hashVerKeyKES :: HashAlgorithm h0 => VerKeyKES (CompactSumKES h d) -> Hash h0 (VerKeyKES (CompactSumKES h d)) # verifyKES :: (Signable (CompactSumKES h d) a, HasCallStack) => ContextKES (CompactSumKES h d) -> VerKeyKES (CompactSumKES h d) -> Period -> a -> SigKES (CompactSumKES h d) -> Either String () # totalPeriodsKES :: proxy (CompactSumKES h d) -> Word # rawSerialiseVerKeyKES :: VerKeyKES (CompactSumKES h d) -> ByteString # rawSerialiseSigKES :: SigKES (CompactSumKES h d) -> ByteString # rawDeserialiseVerKeyKES :: ByteString -> Maybe (VerKeyKES (CompactSumKES h d)) # rawDeserialiseSigKES :: ByteString -> Maybe (SigKES (CompactSumKES h d)) #
(DSIGNMAlgorithmBase d, KnownNat t, KnownNat (SeedSizeDSIGNM d * t), KnownNat (SizeVerKeyDSIGNM d * t), KnownNat (SizeSignKeyDSIGNM d * t)) => KESAlgorithm (SimpleKES d t) #
Instance details Defined in Cardano.Crypto.KES.Simple Associated Types data VerKeyKES (SimpleKES d t) # data SigKES (SimpleKES d t) # type SeedSizeKES (SimpleKES d t) :: Nat # type SizeVerKeyKES (SimpleKES d t) :: Nat # type SizeSignKeyKES (SimpleKES d t) :: Nat # type SizeSigKES (SimpleKES d t) :: Nat # type ContextKES (SimpleKES d t) # type Signable (SimpleKES d t) :: Type -> Constraint # Methods algorithmNameKES :: proxy (SimpleKES d t) -> String # hashVerKeyKES :: HashAlgorithm h => VerKeyKES (SimpleKES d t) -> Hash h (VerKeyKES (SimpleKES d t)) # verifyKES :: (Signable (SimpleKES d t) a, HasCallStack) => ContextKES (SimpleKES d t) -> VerKeyKES (SimpleKES d t) -> Period -> a -> SigKES (SimpleKES d t) -> Either String () # totalPeriodsKES :: proxy (SimpleKES d t) -> Word # rawSerialiseVerKeyKES :: VerKeyKES (SimpleKES d t) -> ByteString # rawSerialiseSigKES :: SigKES (SimpleKES d t) -> ByteString # rawDeserialiseVerKeyKES :: ByteString -> Maybe (VerKeyKES (SimpleKES d t)) # rawDeserialiseSigKES :: ByteString -> Maybe (SigKES (SimpleKES d t)) #
(KESAlgorithm d, SodiumHashAlgorithm h, SizeHash h ~ SeedSizeKES d, KnownNat ((SizeSignKeyKES d + SeedSizeKES d) + (2 * SizeVerKeyKES d)), KnownNat (SizeSigKES d + (SizeVerKeyKES d * 2))) => KESAlgorithm (SumKES h d) #
Instance details Defined in Cardano.Crypto.KES.Sum Associated Types data VerKeyKES (SumKES h d) # data SigKES (SumKES h d) # type SeedSizeKES (SumKES h d) :: Nat # type SizeVerKeyKES (SumKES h d) :: Nat # type SizeSignKeyKES (SumKES h d) :: Nat # type SizeSigKES (SumKES h d) :: Nat # type ContextKES (SumKES h d) # type Signable (SumKES h d) :: Type -> Constraint # Methods algorithmNameKES :: proxy (SumKES h d) -> String # hashVerKeyKES :: HashAlgorithm h0 => VerKeyKES (SumKES h d) -> Hash h0 (VerKeyKES (SumKES h d)) # verifyKES :: (Signable (SumKES h d) a, HasCallStack) => ContextKES (SumKES h d) -> VerKeyKES (SumKES h d) -> Period -> a -> SigKES (SumKES h d) -> Either String () # totalPeriodsKES :: proxy (SumKES h d) -> Word # rawSerialiseVerKeyKES :: VerKeyKES (SumKES h d) -> ByteString # rawSerialiseSigKES :: SigKES (SumKES h d) -> ByteString # rawDeserialiseVerKeyKES :: ByteString -> Maybe (VerKeyKES (SumKES h d)) # rawDeserialiseSigKES :: ByteString -> Maybe (SigKES (SumKES h d)) #

class (KESAlgorithm v, Monad m) => KESSignAlgorithm m v where #

Associated Types

data SignKeyKES v :: Type #

Methods

deriveVerKeyKES :: SignKeyKES v -> m (VerKeyKES v) #

signKES #

Arguments

:: forall a. (Signable v a, HasCallStack)
=> ContextKES v
-> Period	The current period for the key
-> a
-> SignKeyKES v
-> m (SigKES v)

updateKES #

Arguments

:: HasCallStack
=> ContextKES v
-> SignKeyKES v
-> Period	The current period for the key, not the target period.
-> m (Maybe (SignKeyKES v))

Update the KES signature key to the next period, given the current period.

It returns Nothing if the cannot be evolved any further.

The precondition (to get a Just result) is that the current KES period of the input key is not the last period. The given period must be the current KES period of the input key (not the next or target).

The postcondition is that in case a key is returned, its current KES period is incremented by one compared to before.

Note that you must track the current period separately, and to skip to a later period requires repeated use of this function, since it only increments one period at once.

genKeyKES :: MLockedSeed (SeedSizeKES v) -> m (SignKeyKES v) #

forgetSignKeyKES :: SignKeyKES v -> m () #

Forget a signing key synchronously, rather than waiting for GC. In some non-mock instances this provides a guarantee that the signing key is no longer in memory.

The precondition is that this key value will not be used again.

Instances

Instances details

Monad m => KESSignAlgorithm m NeverKES #
Instance details Defined in Cardano.Crypto.KES.NeverUsed Associated Types data SignKeyKES NeverKES # Methods deriveVerKeyKES :: SignKeyKES NeverKES -> m (VerKeyKES NeverKES) # signKES :: (Signable NeverKES a, HasCallStack) => ContextKES NeverKES -> Period -> a -> SignKeyKES NeverKES -> m (SigKES NeverKES) # updateKES :: ContextKES NeverKES -> SignKeyKES NeverKES -> Period -> m (Maybe (SignKeyKES NeverKES)) # genKeyKES :: MLockedSeed (SeedSizeKES NeverKES) -> m (SignKeyKES NeverKES) # forgetSignKeyKES :: SignKeyKES NeverKES -> m () #
(DSIGNMAlgorithm m d, KnownNat (SizeSigDSIGNM d + SizeVerKeyDSIGNM d)) => KESSignAlgorithm m (CompactSingleKES d) #
Instance details Defined in Cardano.Crypto.KES.CompactSingle Associated Types data SignKeyKES (CompactSingleKES d) # Methods deriveVerKeyKES :: SignKeyKES (CompactSingleKES d) -> m (VerKeyKES (CompactSingleKES d)) # signKES :: (Signable (CompactSingleKES d) a, HasCallStack) => ContextKES (CompactSingleKES d) -> Period -> a -> SignKeyKES (CompactSingleKES d) -> m (SigKES (CompactSingleKES d)) # updateKES :: ContextKES (CompactSingleKES d) -> SignKeyKES (CompactSingleKES d) -> Period -> m (Maybe (SignKeyKES (CompactSingleKES d))) # genKeyKES :: MLockedSeed (SeedSizeKES (CompactSingleKES d)) -> m (SignKeyKES (CompactSingleKES d)) # forgetSignKeyKES :: SignKeyKES (CompactSingleKES d) -> m () #
(Monad m, KnownNat t) => KESSignAlgorithm m (MockKES t) #
Instance details Defined in Cardano.Crypto.KES.Mock Associated Types data SignKeyKES (MockKES t) # Methods deriveVerKeyKES :: SignKeyKES (MockKES t) -> m (VerKeyKES (MockKES t)) # signKES :: (Signable (MockKES t) a, HasCallStack) => ContextKES (MockKES t) -> Period -> a -> SignKeyKES (MockKES t) -> m (SigKES (MockKES t)) # updateKES :: ContextKES (MockKES t) -> SignKeyKES (MockKES t) -> Period -> m (Maybe (SignKeyKES (MockKES t))) # genKeyKES :: MLockedSeed (SeedSizeKES (MockKES t)) -> m (SignKeyKES (MockKES t)) # forgetSignKeyKES :: SignKeyKES (MockKES t) -> m () #
DSIGNMAlgorithm m d => KESSignAlgorithm m (SingleKES d) #
Instance details Defined in Cardano.Crypto.KES.Single Associated Types data SignKeyKES (SingleKES d) # Methods deriveVerKeyKES :: SignKeyKES (SingleKES d) -> m (VerKeyKES (SingleKES d)) # signKES :: (Signable (SingleKES d) a, HasCallStack) => ContextKES (SingleKES d) -> Period -> a -> SignKeyKES (SingleKES d) -> m (SigKES (SingleKES d)) # updateKES :: ContextKES (SingleKES d) -> SignKeyKES (SingleKES d) -> Period -> m (Maybe (SignKeyKES (SingleKES d))) # genKeyKES :: MLockedSeed (SeedSizeKES (SingleKES d)) -> m (SignKeyKES (SingleKES d)) # forgetSignKeyKES :: SignKeyKES (SingleKES d) -> m () #
(OptimizedKESAlgorithm d, KESSignAlgorithm m d, SodiumHashAlgorithm h, SizeHash h ~ SeedSizeKES d, MonadSodium m, MonadST m, MonadThrow m, NoThunks (VerKeyKES (CompactSumKES h d)), KnownNat (SizeVerKeyKES (CompactSumKES h d)), KnownNat (SizeSignKeyKES (CompactSumKES h d)), KnownNat (SizeSigKES (CompactSumKES h d))) => KESSignAlgorithm m (CompactSumKES h d) #
Instance details Defined in Cardano.Crypto.KES.CompactSum Associated Types data SignKeyKES (CompactSumKES h d) # Methods deriveVerKeyKES :: SignKeyKES (CompactSumKES h d) -> m (VerKeyKES (CompactSumKES h d)) # signKES :: (Signable (CompactSumKES h d) a, HasCallStack) => ContextKES (CompactSumKES h d) -> Period -> a -> SignKeyKES (CompactSumKES h d) -> m (SigKES (CompactSumKES h d)) # updateKES :: ContextKES (CompactSumKES h d) -> SignKeyKES (CompactSumKES h d) -> Period -> m (Maybe (SignKeyKES (CompactSumKES h d))) # genKeyKES :: MLockedSeed (SeedSizeKES (CompactSumKES h d)) -> m (SignKeyKES (CompactSumKES h d)) # forgetSignKeyKES :: SignKeyKES (CompactSumKES h d) -> m () #
(KESAlgorithm (SimpleKES d t), DSIGNMAlgorithm m d, KnownNat t, KnownNat (SeedSizeDSIGNM d * t), MonadEvaluate m, MonadSodium m, MonadST m) => KESSignAlgorithm m (SimpleKES d t) #
Instance details Defined in Cardano.Crypto.KES.Simple Associated Types data SignKeyKES (SimpleKES d t) # Methods deriveVerKeyKES :: SignKeyKES (SimpleKES d t) -> m (VerKeyKES (SimpleKES d t)) # signKES :: (Signable (SimpleKES d t) a, HasCallStack) => ContextKES (SimpleKES d t) -> Period -> a -> SignKeyKES (SimpleKES d t) -> m (SigKES (SimpleKES d t)) # updateKES :: ContextKES (SimpleKES d t) -> SignKeyKES (SimpleKES d t) -> Period -> m (Maybe (SignKeyKES (SimpleKES d t))) # genKeyKES :: MLockedSeed (SeedSizeKES (SimpleKES d t)) -> m (SignKeyKES (SimpleKES d t)) # forgetSignKeyKES :: SignKeyKES (SimpleKES d t) -> m () #
(KESSignAlgorithm m d, SodiumHashAlgorithm h, SizeHash h ~ SeedSizeKES d, MonadSodium m, MonadST m, MonadThrow m, KnownNat ((SizeSignKeyKES d + SeedSizeKES d) + (2 * SizeVerKeyKES d)), KnownNat (SizeSigKES d + (SizeVerKeyKES d * 2))) => KESSignAlgorithm m (SumKES h d) #
Instance details Defined in Cardano.Crypto.KES.Sum Associated Types data SignKeyKES (SumKES h d) # Methods deriveVerKeyKES :: SignKeyKES (SumKES h d) -> m (VerKeyKES (SumKES h d)) # signKES :: (Signable (SumKES h d) a, HasCallStack) => ContextKES (SumKES h d) -> Period -> a -> SignKeyKES (SumKES h d) -> m (SigKES (SumKES h d)) # updateKES :: ContextKES (SumKES h d) -> SignKeyKES (SumKES h d) -> Period -> m (Maybe (SignKeyKES (SumKES h d))) # genKeyKES :: MLockedSeed (SeedSizeKES (SumKES h d)) -> m (SignKeyKES (SumKES h d)) # forgetSignKeyKES :: SignKeyKES (SumKES h d) -> m () #

type Period = Word #

The KES period. Periods are enumerated from zero.

Be careful of fencepost errors: if there are 2 periods (period 0 and 1) then there is only one key evolution.

class KESAlgorithm v => OptimizedKESAlgorithm v where #

Subclass for KES algorithms that embed a copy of the VerKey into the signature itself, rather than relying on the externally supplied VerKey alone. Some optimizations made in the CompactSingleKES and CompactSumKES implementations require this additional interface in order to avoid redundant computations.

Methods

verifySigKES #

Arguments

:: (Signable v a, HasCallStack)
=> ContextKES v
-> Period	The current period for the key
-> a
-> SigKES v
-> Either String ()

Partial verification: this method only verifies the signature itself, but it does not check it against any externally-provided VerKey. Use verifyKES for full KES verification.

verKeyFromSigKES :: ContextKES v -> Period -> SigKES v -> VerKeyKES v #

Extract a VerKey from a SigKES. Note that a VerKey embedded in or derived from a SigKES is effectively user-supplied, so it is not enough to validate a SigKES against this VerKey (like verifySigKES does); you must also compare the VerKey against an externally-provided key that you want to verify against (see verifyKES).

Instances

Instances details

(KESAlgorithm (CompactSingleKES d), DSIGNMAlgorithmBase d) => OptimizedKESAlgorithm (CompactSingleKES d) #
Instance details Defined in Cardano.Crypto.KES.CompactSingle Methods verifySigKES :: (Signable (CompactSingleKES d) a, HasCallStack) => ContextKES (CompactSingleKES d) -> Period -> a -> SigKES (CompactSingleKES d) -> Either String () # verKeyFromSigKES :: ContextKES (CompactSingleKES d) -> Period -> SigKES (CompactSingleKES d) -> VerKeyKES (CompactSingleKES d) #
(KESAlgorithm (CompactSumKES h d), OptimizedKESAlgorithm d, HashAlgorithm h) => OptimizedKESAlgorithm (CompactSumKES h d) #
Instance details Defined in Cardano.Crypto.KES.CompactSum Methods verifySigKES :: (Signable (CompactSumKES h d) a, HasCallStack) => ContextKES (CompactSumKES h d) -> Period -> a -> SigKES (CompactSumKES h d) -> Either String () # verKeyFromSigKES :: ContextKES (CompactSumKES h d) -> Period -> SigKES (CompactSumKES h d) -> VerKeyKES (CompactSumKES h d) #

verifyOptimizedKES :: (OptimizedKESAlgorithm v, Signable v a, HasCallStack) => ContextKES v -> VerKeyKES v -> Period -> a -> SigKES v -> Either String () #

`SignedKES` wrapper

newtype SignedKES v a #

Constructors

SignedKES
Fields getSig :: SigKES v

Instances

Instances details

Generic (SignedKES v a) #
Instance details Defined in Cardano.Crypto.KES.Class Associated Types type Rep (SignedKES v a) :: Type -> Type Source # Methods from :: SignedKES v a -> Rep (SignedKES v a) x Source # to :: Rep (SignedKES v a) x -> SignedKES v a Source #
KESAlgorithm v => Show (SignedKES v a) #
Instance details Defined in Cardano.Crypto.KES.Class Methods showsPrec :: Int -> SignedKES v a -> ShowS Source # show :: SignedKES v a -> String Source # showList :: [SignedKES v a] -> ShowS Source #
KESAlgorithm v => Eq (SignedKES v a) #
Instance details Defined in Cardano.Crypto.KES.Class Methods (==) :: SignedKES v a -> SignedKES v a -> Bool Source # (/=) :: SignedKES v a -> SignedKES v a -> Bool Source #
KESAlgorithm v => NoThunks (SignedKES v a) #
Instance details Defined in Cardano.Crypto.KES.Class Methods noThunks :: Context -> SignedKES v a -> IO (Maybe ThunkInfo) Source # wNoThunks :: Context -> SignedKES v a -> IO (Maybe ThunkInfo) Source # showTypeOf :: Proxy (SignedKES v a) -> String Source #
type Rep (SignedKES v a) #
Instance details Defined in Cardano.Crypto.KES.Class type Rep (SignedKES v a) = D1 ('MetaData "SignedKES" "Cardano.Crypto.KES.Class" "cardano-crypto-class-2.1.1.0-inplace" 'True) (C1 ('MetaCons "SignedKES" 'PrefixI 'True) (S1 ('MetaSel ('Just "getSig") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (SigKES v))))

signedKES :: (KESSignAlgorithm m v, Signable v a) => ContextKES v -> Period -> a -> SignKeyKES v -> m (SignedKES v a) #

verifySignedKES :: (KESAlgorithm v, Signable v a) => ContextKES v -> VerKeyKES v -> Period -> a -> SignedKES v a -> Either String () #

CBOR encoding and decoding

encodeVerKeyKES :: KESAlgorithm v => VerKeyKES v -> Encoding #

decodeVerKeyKES :: forall v s. KESAlgorithm v => Decoder s (VerKeyKES v) #

encodeSigKES :: KESAlgorithm v => SigKES v -> Encoding #

decodeSigKES :: forall v s. KESAlgorithm v => Decoder s (SigKES v) #

encodeSignedKES :: KESAlgorithm v => SignedKES v a -> Encoding #

decodeSignedKES :: KESAlgorithm v => Decoder s (SignedKES v a) #

Encoded `Size` expressions

encodedVerKeyKESSizeExpr :: forall v. KESAlgorithm v => Proxy (VerKeyKES v) -> Size #

Size expression for VerKeyKES which is using sizeVerKeyKES encoded as Size.

encodedSignKeyKESSizeExpr :: forall v. KESAlgorithm v => Proxy (SignKeyKES v) -> Size #

Size expression for SignKeyKES which is using sizeSignKeyKES encoded as Size.

encodedSigKESSizeExpr :: forall v. KESAlgorithm v => Proxy (SigKES v) -> Size #

Size expression for SigKES which is using sizeSigKES encoded as Size.

Raw sizes

sizeVerKeyKES :: forall v proxy. KESAlgorithm v => proxy v -> Word #

sizeSigKES :: forall v proxy. KESAlgorithm v => proxy v -> Word #

sizeSignKeyKES :: forall v proxy. KESAlgorithm v => proxy v -> Word #

seedSizeKES :: forall v proxy. KESAlgorithm v => proxy v -> Word #

The upper bound on the Seed size needed by genKeyKES

Unsound API

class KESSignAlgorithm m v => UnsoundKESSignAlgorithm m v where #

Unsound operations on KES sign keys. These operations violate secure forgetting constraints by leaking secrets to unprotected memory. Consider using the DirectSerialise / DirectDeserialise APIs instead.

Methods

rawDeserialiseSignKeyKES :: ByteString -> m (Maybe (SignKeyKES v)) #

rawSerialiseSignKeyKES :: SignKeyKES v -> m ByteString #

Instances

Instances details

Monad m => UnsoundKESSignAlgorithm m NeverKES #
Instance details Defined in Cardano.Crypto.KES.NeverUsed Methods rawDeserialiseSignKeyKES :: ByteString -> m (Maybe (SignKeyKES NeverKES)) # rawSerialiseSignKeyKES :: SignKeyKES NeverKES -> m ByteString #
(KESSignAlgorithm m (CompactSingleKES d), UnsoundDSIGNMAlgorithm m d) => UnsoundKESSignAlgorithm m (CompactSingleKES d) #
Instance details Defined in Cardano.Crypto.KES.CompactSingle Methods rawDeserialiseSignKeyKES :: ByteString -> m (Maybe (SignKeyKES (CompactSingleKES d))) # rawSerialiseSignKeyKES :: SignKeyKES (CompactSingleKES d) -> m ByteString #
(Monad m, KnownNat t) => UnsoundKESSignAlgorithm m (MockKES t) #
Instance details Defined in Cardano.Crypto.KES.Mock Methods rawDeserialiseSignKeyKES :: ByteString -> m (Maybe (SignKeyKES (MockKES t))) # rawSerialiseSignKeyKES :: SignKeyKES (MockKES t) -> m ByteString #
(KESSignAlgorithm m (SingleKES d), UnsoundDSIGNMAlgorithm m d) => UnsoundKESSignAlgorithm m (SingleKES d) #
Instance details Defined in Cardano.Crypto.KES.Single Methods rawDeserialiseSignKeyKES :: ByteString -> m (Maybe (SignKeyKES (SingleKES d))) # rawSerialiseSignKeyKES :: SignKeyKES (SingleKES d) -> m ByteString #
(KESSignAlgorithm m (CompactSumKES h d), UnsoundKESSignAlgorithm m d, MonadSodium m, MonadST m) => UnsoundKESSignAlgorithm m (CompactSumKES h d) #
Instance details Defined in Cardano.Crypto.KES.CompactSum Methods rawDeserialiseSignKeyKES :: ByteString -> m (Maybe (SignKeyKES (CompactSumKES h d))) # rawSerialiseSignKeyKES :: SignKeyKES (CompactSumKES h d) -> m ByteString #
(UnsoundDSIGNMAlgorithm m d, KnownNat t, KESSignAlgorithm m (SimpleKES d t)) => UnsoundKESSignAlgorithm m (SimpleKES d t) #
Instance details Defined in Cardano.Crypto.KES.Simple Methods rawDeserialiseSignKeyKES :: ByteString -> m (Maybe (SignKeyKES (SimpleKES d t))) # rawSerialiseSignKeyKES :: SignKeyKES (SimpleKES d t) -> m ByteString #
(KESSignAlgorithm m (SumKES h d), UnsoundKESSignAlgorithm m d, MonadSodium m, MonadST m) => UnsoundKESSignAlgorithm m (SumKES h d) #
Instance details Defined in Cardano.Crypto.KES.Sum Methods rawDeserialiseSignKeyKES :: ByteString -> m (Maybe (SignKeyKES (SumKES h d))) # rawSerialiseSignKeyKES :: SignKeyKES (SumKES h d) -> m ByteString #