hackage-security-0.5.2.2: Hackage security library

Safe Haskell | None
Language | Haskell2010

Hackage.Security.Server

Contents

- Re-exports
- Key types
- Types abstracting over key types
- Key types in isolation
- Hiding key types
- Operations on keys
- Key IDs
- Signing
- Types
- Utility
  - Re-exports
  - Utility
- Cache layout
- Repository layout
  - Utility
- Repository layout
- TUF types
  - Utility
- Repository
- Index
- Cache
- Datatypes
- TUF types
- Construction and verification
- JSON aids
- Avoid interpreting signatures
  - Utility
- TUF types
  - Util

Description

Main entry point into the Hackage Security framework for clients

Synopsis

- module Hackage.Security.JSON
- data Ed25519
- data Key a where
  - KeyEd25519 :: PublicKey -> SecretKey -> Key Ed25519
- data PublicKey a where
  - PublicKeyEd25519 :: PublicKey -> PublicKey Ed25519
- data PrivateKey a where
  - PrivateKeyEd25519 :: SecretKey -> PrivateKey Ed25519
- data KeyType typ where
  - KeyTypeEd25519 :: KeyType Ed25519
- somePublicKey :: Some Key -> Some PublicKey
- somePublicKeyType :: Some PublicKey -> Some KeyType
- someKeyId :: HasKeyId key => Some key -> KeyId
- publicKey :: Key a -> PublicKey a
- privateKey :: Key a -> PrivateKey a
- createKey :: KeyType key -> IO (Key key)
- createKey' :: KeyType key -> IO (Some Key)
- newtype KeyId = KeyId {
  - keyIdString :: String
  }
- class HasKeyId key where
- sign :: PrivateKey typ -> ByteString -> ByteString
- verify :: PublicKey typ -> ByteString -> ByteString -> Bool
- newtype FileLength = FileLength {
  - fileLength :: Int54
  }
- newtype Hash = Hash String
- newtype KeyThreshold = KeyThreshold Int54
- data FileInfo = FileInfo {
  - fileInfoLength :: FileLength
  - fileInfoHashes :: Map HashFn Hash
  }
- data HashFn
  - = HashFnSHA256
  - | HashFnMD5
- newtype Hash = Hash String
- fileInfo :: ByteString -> FileInfo
- computeFileInfo :: FsRoot root => Path root -> IO FileInfo
- compareTrustedFileInfo :: FileInfo -> FileInfo -> Bool
- knownFileInfoEqual :: FileInfo -> FileInfo -> Bool
- fileInfoSHA256 :: FileInfo -> Maybe Hash
- data Int54
- module Hackage.Security.TUF.FileMap
- class HasHeader a where
- newtype FileVersion = FileVersion Int54
- newtype FileExpires = FileExpires (Maybe UTCTime)
- data Header = Header {
  - headerExpires :: FileExpires
  - headerVersion :: FileVersion
  }
- expiresInDays :: UTCTime -> Integer -> FileExpires
- expiresNever :: FileExpires
- isExpired :: UTCTime -> FileExpires -> Bool
- versionInitial :: FileVersion
- versionIncrement :: FileVersion -> FileVersion
- data CacheLayout = CacheLayout {
  - cacheLayoutRoot :: CachePath
  - cacheLayoutTimestamp :: CachePath
  - cacheLayoutSnapshot :: CachePath
  - cacheLayoutMirrors :: CachePath
  - cacheLayoutIndexTar :: CachePath
  - cacheLayoutIndexIdx :: CachePath
  - cacheLayoutIndexTarGz :: CachePath
  }
- cabalCacheLayout :: CacheLayout
- data IndexLayout = IndexLayout {
  - indexFileToPath :: forall dec. IndexFile dec -> IndexPath
  - indexFileFromPath :: IndexPath -> Maybe (Some IndexFile)
  }
- data IndexFile :: * -> * where
  - IndexPkgMetadata :: PackageIdentifier -> IndexFile (Signed Targets)
  - IndexPkgCabal :: PackageIdentifier -> IndexFile ()
  - IndexPkgPrefs :: PackageName -> IndexFile ()
- hackageIndexLayout :: IndexLayout
- indexLayoutPkgMetadata :: IndexLayout -> PackageIdentifier -> IndexPath
- indexLayoutPkgCabal :: IndexLayout -> PackageIdentifier -> IndexPath
- indexLayoutPkgPrefs :: IndexLayout -> PackageName -> IndexPath
- data RepoLayout = RepoLayout {
  - repoLayoutRoot :: RepoPath
  - repoLayoutTimestamp :: RepoPath
  - repoLayoutSnapshot :: RepoPath
  - repoLayoutMirrors :: RepoPath
  - repoLayoutIndexTarGz :: RepoPath
  - repoLayoutIndexTar :: RepoPath
  - repoLayoutPkgTarGz :: PackageIdentifier -> RepoPath
  }
- hackageRepoLayout :: RepoLayout
- cabalLocalRepoLayout :: RepoLayout
- data Mirrors = Mirrors {
  - mirrorsVersion :: FileVersion
  - mirrorsExpires :: FileExpires
  - mirrorsMirrors :: [Mirror]
  }
- data Mirror = Mirror {
  - mirrorUrlBase :: URI
  - mirrorContent :: MirrorContent
  }
- data MirrorContent = MirrorFull
- type MirrorDescription = String
- describeMirror :: Mirror -> MirrorDescription
- data RepoRoot
- type RepoPath = Path RepoRoot
- anchorRepoPathLocally :: Path root -> RepoPath -> Path root
- anchorRepoPathRemotely :: Path Web -> RepoPath -> Path Web
- data IndexRoot
- type IndexPath = Path IndexRoot
- data CacheRoot
- type CachePath = Path CacheRoot
- anchorCachePath :: Path root -> CachePath -> Path root
- data Root = Root {
  - rootVersion :: FileVersion
  - rootExpires :: FileExpires
  - rootKeys :: KeyEnv
  - rootRoles :: RootRoles
  }
- data RootRoles = RootRoles {
  - rootRolesRoot :: RoleSpec Root
  - rootRolesSnapshot :: RoleSpec Snapshot
  - rootRolesTargets :: RoleSpec Targets
  - rootRolesTimestamp :: RoleSpec Timestamp
  - rootRolesMirrors :: RoleSpec Mirrors
  }
- data RoleSpec a = RoleSpec {
  - roleSpecKeys :: [Some PublicKey]
  - roleSpecThreshold :: KeyThreshold
  }
- data Signed a = Signed {
  - signed :: a
  - signatures :: Signatures
  }
- newtype Signatures = Signatures [Signature]
- data Signature = Signature {
  - signature :: ByteString
  - signatureKey :: Some PublicKey
  }
- unsigned :: a -> Signed a
- withSignatures :: ToJSON WriteJSON a => RepoLayout -> [Some Key] -> a -> Signed a
- withSignatures' :: ToJSON Identity a => [Some Key] -> a -> Signed a
- signRendered :: [Some Key] -> ByteString -> Signatures
- verifySignature :: ByteString -> Signature -> Bool
- signedFromJSON :: (MonadKeys m, FromJSON m a) => JSValue -> m (Signed a)
- verifySignatures :: JSValue -> Signatures -> Bool
- data UninterpretedSignatures a = UninterpretedSignatures {
  - uninterpretedSigned :: a
  - uninterpretedSignatures :: [PreSignature]
  }
- data PreSignature = PreSignature {
  - presignature :: ByteString
  - presigMethod :: Some KeyType
  - presigKeyId :: KeyId
  }
- fromPreSignature :: MonadKeys m => PreSignature -> m Signature
- fromPreSignatures :: MonadKeys m => [PreSignature] -> m Signatures
- toPreSignature :: Signature -> PreSignature
- toPreSignatures :: Signatures -> [PreSignature]
- data Snapshot = Snapshot {
  - snapshotVersion :: FileVersion
  - snapshotExpires :: FileExpires
  - snapshotInfoRoot :: FileInfo
  - snapshotInfoMirrors :: FileInfo
  - snapshotInfoTarGz :: FileInfo
  - snapshotInfoTar :: Maybe FileInfo
  }
- data Targets = Targets {
  - targetsVersion :: FileVersion
  - targetsExpires :: FileExpires
  - targetsTargets :: FileMap
  - targetsDelegations :: Maybe Delegations
  }
- data Delegations = Delegations {
  - delegationsKeys :: KeyEnv
  - delegationsRoles :: [DelegationSpec]
  }
- data DelegationSpec = DelegationSpec {
  - delegationSpecKeys :: [Some PublicKey]
  - delegationSpecThreshold :: KeyThreshold
  - delegation :: Delegation
  }
- data Delegation = Delegation (Pattern a) (Replacement a)
- targetsLookup :: TargetPath -> Targets -> Maybe FileInfo
- data Timestamp = Timestamp {
  - timestampVersion :: FileVersion
  - timestampExpires :: FileExpires
  - timestampInfoSnapshot :: FileInfo
  }

# Re-exports

module Hackage.Security.JSON

# Key types

data Ed25519 #

# Types abstracting over key types

data Key a where #

Constructors

KeyEd25519 :: PublicKey -> SecretKey -> Key Ed25519 |

Instances

SomeShow Key # |
Methods someShow :: DictShow (Key a) #
SomeEq Key # |
Methods someEq :: DictEq (Key a) #
HasKeyId Key # |
Methods keyId :: Key typ -> KeyId #
ReportSchemaErrors m => FromJSON m (Some Key) # |
Methods fromJSON :: JSValue -> m (Some Key) #
Monad m => ToJSON m (Some Key) # |
Methods toJSON :: Some Key -> m JSValue #
Monad m => ToJSON m (Key typ) # |
Methods toJSON :: Key typ -> m JSValue #
Eq (Key typ) # |
Methods (==) :: Key typ -> Key typ -> Bool # (/=) :: Key typ -> Key typ -> Bool #
Show (Key typ) # |
Methods showsPrec :: Int -> Key typ -> ShowS # show :: Key typ -> String # showList :: [Key typ] -> ShowS #

data PublicKey a where #

Constructors

PublicKeyEd25519 :: PublicKey -> PublicKey Ed25519 |

Instances

SomeShow PublicKey # |
Methods someShow :: DictShow (PublicKey a) #
SomeEq PublicKey # |
Methods someEq :: DictEq (PublicKey a) #
HasKeyId PublicKey # |
Methods keyId :: PublicKey typ -> KeyId #
ReportSchemaErrors m => FromJSON m (Some PublicKey) # |
Methods fromJSON :: JSValue -> m (Some PublicKey) #
Monad m => ToJSON m (Some PublicKey) # |
Methods toJSON :: Some PublicKey -> m JSValue #
Monad m => ToJSON m (PublicKey typ) # |
Methods toJSON :: PublicKey typ -> m JSValue #
Eq (PublicKey typ) # |
Methods (==) :: PublicKey typ -> PublicKey typ -> Bool # (/=) :: PublicKey typ -> PublicKey typ -> Bool #
Show (PublicKey typ) # |
Methods showsPrec :: Int -> PublicKey typ -> ShowS # show :: PublicKey typ -> String # showList :: [PublicKey typ] -> ShowS #

data PrivateKey a where #

Constructors

PrivateKeyEd25519 :: SecretKey -> PrivateKey Ed25519 |

Instances

SomeShow PrivateKey # |
Methods someShow :: DictShow (PrivateKey a) #
SomeEq PrivateKey # |
Methods someEq :: DictEq (PrivateKey a) #
Eq (PrivateKey typ) # |
Methods (==) :: PrivateKey typ -> PrivateKey typ -> Bool # (/=) :: PrivateKey typ -> PrivateKey typ -> Bool #
Show (PrivateKey typ) # |
Methods showsPrec :: Int -> PrivateKey typ -> ShowS # show :: PrivateKey typ -> String # showList :: [PrivateKey typ] -> ShowS #

# Key types in isolation

data KeyType typ where #

Constructors

KeyTypeEd25519 :: KeyType Ed25519 |

Instances

SomeShow KeyType # |
Methods someShow :: DictShow (KeyType a) #
SomeEq KeyType # |
Methods someEq :: DictEq (KeyType a) #
ReportSchemaErrors m => FromJSON m (Some KeyType) # |
Methods fromJSON :: JSValue -> m (Some KeyType) #
Monad m => ToJSON m (KeyType typ) # |
Methods toJSON :: KeyType typ -> m JSValue #
Monad m => ToJSON m (Some KeyType) # |
Methods toJSON :: Some KeyType -> m JSValue #
Eq (KeyType typ) # |
Methods (==) :: KeyType typ -> KeyType typ -> Bool # (/=) :: KeyType typ -> KeyType typ -> Bool #
Show (KeyType typ) # |
Methods showsPrec :: Int -> KeyType typ -> ShowS # show :: KeyType typ -> String # showList :: [KeyType typ] -> ShowS #

# Hiding key types

somePublicKey :: Some Key -> Some PublicKey #

somePublicKeyType :: Some PublicKey -> Some KeyType #

someKeyId :: HasKeyId key => Some key -> KeyId #

# Operations on keys

publicKey :: Key a -> PublicKey a #

privateKey :: Key a -> PrivateKey a #

createKey :: KeyType key -> IO (Key key) #

createKey' :: KeyType key -> IO (Some Key) #

# Key IDs

newtype KeyId #

The key ID of a key, by definition, is the hexdigest of the SHA-256 hash of the canonical JSON form of the key where the private object key is excluded.

NOTE: The FromJSON and ToJSON instances for KeyId are ntentially omitted. Use writeKeyAsId instead.

Constructors

KeyId |
Fields keyIdString :: String

Instances

Eq KeyId # |
Methods (==) :: KeyId -> KeyId -> Bool # (/=) :: KeyId -> KeyId -> Bool #
Ord KeyId # |
Methods compare :: KeyId -> KeyId -> Ordering # (<) :: KeyId -> KeyId -> Bool # (<=) :: KeyId -> KeyId -> Bool # (>) :: KeyId -> KeyId -> Bool # (>=) :: KeyId -> KeyId -> Bool # max :: KeyId -> KeyId -> KeyId # min :: KeyId -> KeyId -> KeyId #
Show KeyId # |
Methods showsPrec :: Int -> KeyId -> ShowS # show :: KeyId -> String # showList :: [KeyId] -> ShowS #
Monad m => FromObjectKey m KeyId # |
Methods fromObjectKey :: String -> m (Maybe KeyId) #
Monad m => ToObjectKey m KeyId # |
Methods toObjectKey :: KeyId -> m String #

class HasKeyId key where #

Compute the key ID of a key

Minimal complete definition

keyId

Methods

keyId :: key typ -> KeyId #

Instances

HasKeyId PublicKey # |
Methods keyId :: PublicKey typ -> KeyId #
HasKeyId Key # |
Methods keyId :: Key typ -> KeyId #

# Signing

sign :: PrivateKey typ -> ByteString -> ByteString #

Sign a bytestring and return the signature

TODO: It is unfortunate that we have to convert to a strict bytestring for ed25519

verify :: PublicKey typ -> ByteString -> ByteString -> Bool #

# Types

newtype FileLength #

File length

Having verified file length information means we can protect against endless data attacks and similar.

Constructors

FileLength |
Fields fileLength :: Int54

Instances

Eq FileLength # |
Methods (==) :: FileLength -> FileLength -> Bool # (/=) :: FileLength -> FileLength -> Bool #
Ord FileLength # |
Methods compare :: FileLength -> FileLength -> Ordering # (<) :: FileLength -> FileLength -> Bool # (<=) :: FileLength -> FileLength -> Bool # (>) :: FileLength -> FileLength -> Bool # (>=) :: FileLength -> FileLength -> Bool # max :: FileLength -> FileLength -> FileLength # min :: FileLength -> FileLength -> FileLength #
Show FileLength # |
Methods showsPrec :: Int -> FileLength -> ShowS # show :: FileLength -> String # showList :: [FileLength] -> ShowS #
ReportSchemaErrors m => FromJSON m FileLength # |
Methods fromJSON :: JSValue -> m FileLength #
Monad m => ToJSON m FileLength # |
Methods toJSON :: FileLength -> m JSValue #

newtype Hash #

File hash

Constructors

Hash String |

Instances

Eq Hash # |
Methods (==) :: Hash -> Hash -> Bool # (/=) :: Hash -> Hash -> Bool #
Ord Hash # |
Methods compare :: Hash -> Hash -> Ordering # (<) :: Hash -> Hash -> Bool # (<=) :: Hash -> Hash -> Bool # (>) :: Hash -> Hash -> Bool # (>=) :: Hash -> Hash -> Bool # max :: Hash -> Hash -> Hash # min :: Hash -> Hash -> Hash #
Show Hash # |
Methods showsPrec :: Int -> Hash -> ShowS # show :: Hash -> String # showList :: [Hash] -> ShowS #
ReportSchemaErrors m => FromJSON m Hash # |
Methods fromJSON :: JSValue -> m Hash #
Monad m => ToJSON m Hash # |
Methods toJSON :: Hash -> m JSValue #

newtype KeyThreshold #

Key threshold

The key threshold is the minimum number of keys a document must be signed with. Key thresholds are specified in `RoleSpec` or `DelegationsSpec`.

Constructors

KeyThreshold Int54 |

Instances

Eq KeyThreshold # |
Methods (==) :: KeyThreshold -> KeyThreshold -> Bool # (/=) :: KeyThreshold -> KeyThreshold -> Bool #
Ord KeyThreshold # |
Methods compare :: KeyThreshold -> KeyThreshold -> Ordering # (<) :: KeyThreshold -> KeyThreshold -> Bool # (<=) :: KeyThreshold -> KeyThreshold -> Bool # (>) :: KeyThreshold -> KeyThreshold -> Bool # (>=) :: KeyThreshold -> KeyThreshold -> Bool # max :: KeyThreshold -> KeyThreshold -> KeyThreshold # min :: KeyThreshold -> KeyThreshold -> KeyThreshold #
Show KeyThreshold # |
Methods showsPrec :: Int -> KeyThreshold -> ShowS # show :: KeyThreshold -> String # showList :: [KeyThreshold] -> ShowS #
ReportSchemaErrors m => FromJSON m KeyThreshold # |
Methods fromJSON :: JSValue -> m KeyThreshold #
Monad m => ToJSON m KeyThreshold # |
Methods toJSON :: KeyThreshold -> m JSValue #

data FileInfo #

File information

This intentionally does not have an `Eq` instance; see `knownFileInfoEqual` and `verifyFileInfo` instead.

NOTE: Throughout we compute file information always over the raw bytes. For example, when `timestamp.json` lists the hash of `snapshot.json`, this hash is computed over the actual `snapshot.json` file (as opposed to the canonical form of the embedded JSON). This brings it in line with the hash computed over target files, where that is the only choice available.

Constructors

FileInfo |
Fields fileInfoLength :: FileLength fileInfoHashes :: Map HashFn Hash

Instances

Show FileInfo # |
Methods showsPrec :: Int -> FileInfo -> ShowS # show :: FileInfo -> String # showList :: [FileInfo] -> ShowS #
ReportSchemaErrors m => FromJSON m FileInfo # |
Methods fromJSON :: JSValue -> m FileInfo #
Monad m => ToJSON m FileInfo # |
Methods toJSON :: FileInfo -> m JSValue #

data HashFn #

Constructors

HashFnSHA256 |
HashFnMD5 |

Instances

Eq HashFn # |
Methods (==) :: HashFn -> HashFn -> Bool # (/=) :: HashFn -> HashFn -> Bool #
Ord HashFn # |
Methods compare :: HashFn -> HashFn -> Ordering # (<) :: HashFn -> HashFn -> Bool # (<=) :: HashFn -> HashFn -> Bool # (>) :: HashFn -> HashFn -> Bool # (>=) :: HashFn -> HashFn -> Bool # max :: HashFn -> HashFn -> HashFn # min :: HashFn -> HashFn -> HashFn #
Show HashFn # |
Methods showsPrec :: Int -> HashFn -> ShowS # show :: HashFn -> String # showList :: [HashFn] -> ShowS #
ReportSchemaErrors m => FromObjectKey m HashFn # |
Methods fromObjectKey :: String -> m (Maybe HashFn) #
Monad m => ToObjectKey m HashFn # |
Methods toObjectKey :: HashFn -> m String #

newtype Hash #

File hash

Constructors

Hash String |

Instances

Eq Hash # |
Methods (==) :: Hash -> Hash -> Bool # (/=) :: Hash -> Hash -> Bool #
Ord Hash # |
Methods compare :: Hash -> Hash -> Ordering # (<) :: Hash -> Hash -> Bool # (<=) :: Hash -> Hash -> Bool # (>) :: Hash -> Hash -> Bool # (>=) :: Hash -> Hash -> Bool # max :: Hash -> Hash -> Hash # min :: Hash -> Hash -> Hash #
Show Hash # |
Methods showsPrec :: Int -> Hash -> ShowS # show :: Hash -> String # showList :: [Hash] -> ShowS #
ReportSchemaErrors m => FromJSON m Hash # |
Methods fromJSON :: JSValue -> m Hash #
Monad m => ToJSON m Hash # |
Methods toJSON :: Hash -> m JSValue #

# Utility

fileInfo :: ByteString -> FileInfo #

Compute `FileInfo`

TODO: Currently this will load the entire input bytestring into memory. We need to make this incremental, by computing the length and all hashes in a single traversal over the input.

computeFileInfo :: FsRoot root => Path root -> IO FileInfo #

Compute `FileInfo`

compareTrustedFileInfo #

Arguments

:: FileInfo | expected (from trusted TUF files)
-> FileInfo | actual (from `fileInfo` on target file)
-> Bool |

Compare the expected trusted file info against the actual file info of a target file.

This should be used only when the `FileInfo` is already known. If we want to compare known `FileInfo` against a file on disk we should delay until we have confirmed that the file lengths match (see `downloadedVerify`).

knownFileInfoEqual :: FileInfo -> FileInfo -> Bool #

fileInfoSHA256 :: FileInfo -> Maybe Hash #

Extract SHA256 hash from `FileInfo` (if present)

## Re-exports

data Int54 #

54-bit integer values

JavaScript can only safely represent numbers between `-(2^53 - 1)` and `2^53 - 1`.

TODO: Although we introduce the type here, we don't actually do any bounds checking and just inherit all type class instance from Int64. We should probably define `fromInteger` to do bounds checking, give different instances for type classes such as `Bounded` and `FiniteBits`, etc.

Instances

Bounded Int54 # |
Methods minBound :: Int54 # maxBound :: Int54 #
Enum Int54 # |
Methods succ :: Int54 -> Int54 # pred :: Int54 -> Int54 # toEnum :: Int -> Int54 # fromEnum :: Int54 -> Int # enumFrom :: Int54 -> [Int54] # enumFromThen :: Int54 -> Int54 -> [Int54] # enumFromTo :: Int54 -> Int54 -> [Int54] # enumFromThenTo :: Int54 -> Int54 -> Int54 -> [Int54] #
Eq Int54 # |
Methods (==) :: Int54 -> Int54 -> Bool # (/=) :: Int54 -> Int54 -> Bool #
Integral Int54 # |
Methods quot :: Int54 -> Int54 -> Int54 # rem :: Int54 -> Int54 -> Int54 # div :: Int54 -> Int54 -> Int54 # mod :: Int54 -> Int54 -> Int54 # quotRem :: Int54 -> Int54 -> (Int54, Int54) # divMod :: Int54 -> Int54 -> (Int54, Int54) # toInteger :: Int54 -> Integer #
Data Int54 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int54 -> c Int54 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int54 # toConstr :: Int54 -> Constr # dataTypeOf :: Int54 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int54) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int54) # gmapT :: (forall b. Data b => b -> b) -> Int54 -> Int54 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int54 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int54 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int54 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int54 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int54 -> m Int54 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int54 -> m Int54 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int54 -> m Int54 #
Num Int54 # |
Methods (+) :: Int54 -> Int54 -> Int54 # (-) :: Int54 -> Int54 -> Int54 # (*) :: Int54 -> Int54 -> Int54 # negate :: Int54 -> Int54 # abs :: Int54 -> Int54 # signum :: Int54 -> Int54 # fromInteger :: Integer -> Int54 #
Ord Int54 # |
Methods compare :: Int54 -> Int54 -> Ordering # (<) :: Int54 -> Int54 -> Bool # (<=) :: Int54 -> Int54 -> Bool # (>) :: Int54 -> Int54 -> Bool # (>=) :: Int54 -> Int54 -> Bool # max :: Int54 -> Int54 -> Int54 # min :: Int54 -> Int54 -> Int54 #
Read Int54 # |
Methods readsPrec :: Int -> ReadS Int54 # readList :: ReadS [Int54] # readPrec :: ReadPrec Int54 # readListPrec :: ReadPrec [Int54] #
Real Int54 # |
Methods toRational :: Int54 -> Rational #
Show Int54 # |
Methods showsPrec :: Int -> Int54 -> ShowS # show :: Int54 -> String # showList :: [Int54] -> ShowS #
Ix Int54 # |
Methods range :: (Int54, Int54) -> [Int54] # index :: (Int54, Int54) -> Int54 -> Int # unsafeIndex :: (Int54, Int54) -> Int54 -> Int inRange :: (Int54, Int54) -> Int54 -> Bool # rangeSize :: (Int54, Int54) -> Int # unsafeRangeSize :: (Int54, Int54) -> Int
PrintfArg Int54 # |
Methods formatArg :: Int54 -> FieldFormatter # parseFormat :: Int54 -> ModifierParser #
Storable Int54 # |
Methods sizeOf :: Int54 -> Int # alignment :: Int54 -> Int # peekElemOff :: Ptr Int54 -> Int -> IO Int54 # pokeElemOff :: Ptr Int54 -> Int -> Int54 -> IO () # peekByteOff :: Ptr b -> Int -> IO Int54 # pokeByteOff :: Ptr b -> Int -> Int54 -> IO () # peek :: Ptr Int54 -> IO Int54 # poke :: Ptr Int54 -> Int54 -> IO () #
Bits Int54 # |
Methods (.&.) :: Int54 -> Int54 -> Int54 # (.|.) :: Int54 -> Int54 -> Int54 # xor :: Int54 -> Int54 -> Int54 # complement :: Int54 -> Int54 # shift :: Int54 -> Int -> Int54 # rotate :: Int54 -> Int -> Int54 # zeroBits :: Int54 # bit :: Int -> Int54 # setBit :: Int54 -> Int -> Int54 # clearBit :: Int54 -> Int -> Int54 # complementBit :: Int54 -> Int -> Int54 # testBit :: Int54 -> Int -> Bool # bitSizeMaybe :: Int54 -> Maybe Int # bitSize :: Int54 -> Int # isSigned :: Int54 -> Bool # shiftL :: Int54 -> Int -> Int54 # unsafeShiftL :: Int54 -> Int -> Int54 # shiftR :: Int54 -> Int -> Int54 # unsafeShiftR :: Int54 -> Int -> Int54 # rotateL :: Int54 -> Int -> Int54 # rotateR :: Int54 -> Int -> Int54 # popCount :: Int54 -> Int #
FiniteBits Int54 # |
Methods finiteBitSize :: Int54 -> Int # countLeadingZeros :: Int54 -> Int # countTrailingZeros :: Int54 -> Int #
ReportSchemaErrors m => FromJSON m Int54 # |
Methods fromJSON :: JSValue -> m Int54 #
Monad m => ToJSON m Int54 # |
Methods toJSON :: Int54 -> m JSValue #

module Hackage.Security.TUF.FileMap

class HasHeader a where #

Minimal complete definition

fileExpires, fileVersion

Methods

fileExpires :: Lens' a FileExpires #

File expiry date

fileVersion :: Lens' a FileVersion #

File version (monotonically increasing counter)

Instances

HasHeader Header # |
Methods fileExpires :: Lens' Header FileExpires # fileVersion :: Lens' Header FileVersion #
HasHeader Mirrors # |
Methods fileExpires :: Lens' Mirrors FileExpires # fileVersion :: Lens' Mirrors FileVersion #
HasHeader Snapshot # |
Methods fileExpires :: Lens' Snapshot FileExpires # fileVersion :: Lens' Snapshot FileVersion #
HasHeader Timestamp # |
Methods fileExpires :: Lens' Timestamp FileExpires # fileVersion :: Lens' Timestamp FileVersion #
HasHeader Targets # |
Methods fileExpires :: Lens' Targets FileExpires # fileVersion :: Lens' Targets FileVersion #
HasHeader Root # |
Methods fileExpires :: Lens' Root FileExpires # fileVersion :: Lens' Root FileVersion #

newtype FileVersion #

File version

The file version is a flat integer which must monotonically increase on every file update.

`Show` and `Read` instance are defined in terms of the underlying `Int` (this is use for example by hackage during the backup process).

Constructors

FileVersion Int54 |

Instances

Eq FileVersion # |
Methods (==) :: FileVersion -> FileVersion -> Bool # (/=) :: FileVersion -> FileVersion -> Bool #
Ord FileVersion # |
Methods compare :: FileVersion -> FileVersion -> Ordering # (<) :: FileVersion -> FileVersion -> Bool # (<=) :: FileVersion -> FileVersion -> Bool # (>) :: FileVersion -> FileVersion -> Bool # (>=) :: FileVersion -> FileVersion -> Bool # max :: FileVersion -> FileVersion -> FileVersion # min :: FileVersion -> FileVersion -> FileVersion #
Read FileVersion # |
Methods readsPrec :: Int -> ReadS FileVersion # readList :: ReadS [FileVersion] # readPrec :: ReadPrec FileVersion # readListPrec :: ReadPrec [FileVersion] #
Show FileVersion # |
Methods showsPrec :: Int -> FileVersion -> ShowS # show :: FileVersion -> String # showList :: [FileVersion] -> ShowS #
ReportSchemaErrors m => FromJSON m FileVersion # |
Methods fromJSON :: JSValue -> m FileVersion #
Monad m => ToJSON m FileVersion # |
Methods toJSON :: FileVersion -> m JSValue #

newtype FileExpires #

File expiry date

A `Nothing` value here means no expiry. That makes it possible to set some files to never expire. (Note that not having the Maybe in the type here still allows that, because you could set an expiry date 2000 years into the future. By having the Maybe here we avoid the _need_ for such encoding issues.)

Constructors

FileExpires (Maybe UTCTime) |

Instances

Eq FileExpires # |
Methods (==) :: FileExpires -> FileExpires -> Bool # (/=) :: FileExpires -> FileExpires -> Bool #
Ord FileExpires # |
Methods compare :: FileExpires -> FileExpires -> Ordering # (<) :: FileExpires -> FileExpires -> Bool # (<=) :: FileExpires -> FileExpires -> Bool # (>) :: FileExpires -> FileExpires -> Bool # (>=) :: FileExpires -> FileExpires -> Bool # max :: FileExpires -> FileExpires -> FileExpires # min :: FileExpires -> FileExpires -> FileExpires #
Show FileExpires # |
Methods showsPrec :: Int -> FileExpires -> ShowS # show :: FileExpires -> String # showList :: [FileExpires] -> ShowS #
ReportSchemaErrors m => FromJSON m FileExpires # |
Methods fromJSON :: JSValue -> m FileExpires #
Monad m => ToJSON m FileExpires # |
Methods toJSON :: FileExpires -> m JSValue #

data Header #

Occassionally it is useful to read only a header from a file.

`HeaderOnly` intentionally only has a `FromJSON` instance (no `ToJSON`).

Constructors

Header |
Fields headerExpires :: FileExpires headerVersion :: FileVersion

Instances

HasHeader Header # |
Methods fileExpires :: Lens' Header FileExpires # fileVersion :: Lens' Header FileVersion #
ReportSchemaErrors m => FromJSON m Header # |
Methods fromJSON :: JSValue -> m Header #

## Utility

expiresInDays :: UTCTime -> Integer -> FileExpires #

expiresNever :: FileExpires #

isExpired :: UTCTime -> FileExpires -> Bool #

versionInitial :: FileVersion #

versionIncrement :: FileVersion -> FileVersion #

# Cache layout

data CacheLayout #

Location of the various files we cache

Although the generic TUF algorithms do not care how we organize the cache, we nonetheless specity this here because as long as there are tools which access files in the cache directly we need to define the cache layout. See also comments for `defaultCacheLayout`.

Constructors

CacheLayout |
Fields cacheLayoutRoot :: CachePath TUF root metadata cacheLayoutTimestamp :: CachePath TUF timestamp cacheLayoutSnapshot :: CachePath TUF snapshot cacheLayoutMirrors :: CachePath TUF mirrors list cacheLayoutIndexTar :: CachePath Uncompressed index tarball cacheLayoutIndexIdx :: CachePath Index to the uncompressed index tarball cacheLayoutIndexTarGz :: CachePath Compressed index tarball We cache both the compressed and the uncompressed tarballs, because incremental updates happen through the compressed tarball, but reads happen through the uncompressed one (with the help of the tarball index).

cabalCacheLayout :: CacheLayout #

The cache layout cabal-install uses

We cache the index as `cache/00-index.tar`; this is important because `cabal-install` expects to find it there (and does not currently go through the hackage-security library to get files from the index).

# Repository layout

data IndexLayout #

Layout of the files within the index tarball

Constructors

IndexLayout |
Fields indexFileToPath :: forall dec. IndexFile dec -> IndexPath Translate an `IndexFile` to a path indexFileFromPath :: IndexPath -> Maybe (Some IndexFile) Parse an `FilePath`

data IndexFile :: * -> * where #

Files that we might request from the index

The type index tells us the type of the decoded file, if any. For files for which the library does not support decoding this will be `()`. NOTE: Clients should NOT rely on this type index being `()`, or they might break if we add support for parsing additional file formats in the future.

TODO: If we wanted to support legacy Hackage, we should also have a case for the global preferred-versions file. But supporting legacy Hackage will probably require more work anyway..

Constructors

IndexPkgMetadata :: PackageIdentifier -> IndexFile (Signed Targets) |
IndexPkgCabal :: PackageIdentifier -> IndexFile () |
IndexPkgPrefs :: PackageName -> IndexFile () |

Instances

SomePretty IndexFile # |
Methods somePretty :: DictPretty (IndexFile a) #
SomeShow IndexFile # |
Methods someShow :: DictShow (IndexFile a) #
Show (IndexFile dec) # |
Methods showsPrec :: Int -> IndexFile dec -> ShowS # show :: IndexFile dec -> String # showList :: [IndexFile dec] -> ShowS #
Pretty (IndexFile dec) # |
Methods pretty :: IndexFile dec -> String #

hackageIndexLayout :: IndexLayout #

The layout of the index as maintained on Hackage

## Utility

indexLayoutPkgMetadata :: IndexLayout -> PackageIdentifier -> IndexPath #

indexLayoutPkgCabal :: IndexLayout -> PackageIdentifier -> IndexPath #

indexLayoutPkgPrefs :: IndexLayout -> PackageName -> IndexPath #

# Repository layout

data RepoLayout #

Layout of a repository

Constructors

RepoLayout |
Fields repoLayoutRoot :: RepoPath TUF root metadata repoLayoutTimestamp :: RepoPath TUF timestamp repoLayoutSnapshot :: RepoPath TUF snapshot repoLayoutMirrors :: RepoPath TUF mirrors list repoLayoutIndexTarGz :: RepoPath Compressed index tarball repoLayoutIndexTar :: RepoPath Uncompressed index tarball repoLayoutPkgTarGz :: PackageIdentifier -> RepoPath Path to the package tarball

Instances

MonadReader RepoLayout WriteJSON # |
Methods ask :: WriteJSON RepoLayout # local :: (RepoLayout -> RepoLayout) -> WriteJSON a -> WriteJSON a # reader :: (RepoLayout -> a) -> WriteJSON a #
MonadReader RepoLayout ReadJSON_Keys_Layout # |
Methods ask :: ReadJSON_Keys_Layout RepoLayout # local :: (RepoLayout -> RepoLayout) -> ReadJSON_Keys_Layout a -> ReadJSON_Keys_Layout a # reader :: (RepoLayout -> a) -> ReadJSON_Keys_Layout a #

hackageRepoLayout :: RepoLayout #

The layout used on Hackage

cabalLocalRepoLayout :: RepoLayout #

Layout used by cabal for ("legacy") local repos

Obviously, such repos do not normally contain any of the TUF files, so their location is more or less arbitrary here.

# TUF types

data Mirrors #

Constructors

Mirrors |
Fields mirrorsVersion :: FileVersion mirrorsExpires :: FileExpires mirrorsMirrors :: [Mirror]

Instances

HasHeader Mirrors # |
Methods fileExpires :: Lens' Mirrors FileExpires # fileVersion :: Lens' Mirrors FileVersion #
VerifyRole Mirrors # |
Methods verifyRole :: Trusted Root -> TargetPath -> Maybe FileVersion -> Maybe UTCTime -> Signed Mirrors -> Either VerificationError (SignaturesVerified Mirrors) #
(MonadError DeserializationError m, ReportSchemaErrors m) => FromJSON m Mirrors # |
Methods fromJSON :: JSValue -> m Mirrors #
Monad m => ToJSON m Mirrors # |
Methods toJSON :: Mirrors -> m JSValue #
MonadKeys m => FromJSON m (Signed Mirrors) # |
Methods fromJSON :: JSValue -> m (Signed Mirrors) #

data Mirror #

Definition of a mirror

NOTE: Unlike the TUF specification, we require that all mirrors must have the same format. That is, we omit `metapath` and `targetspath`.

Constructors

Mirror |
Fields mirrorUrlBase :: URI mirrorContent :: MirrorContent

Instances

Show Mirror # |
Methods showsPrec :: Int -> Mirror -> ShowS # show :: Mirror -> String # showList :: [Mirror] -> ShowS #
ReportSchemaErrors m => FromJSON m Mirror # |
Methods fromJSON :: JSValue -> m Mirror #
Monad m => ToJSON m Mirror # |
Methods toJSON :: Mirror -> m JSValue #

data MirrorContent #

Full versus partial mirrors

The TUF spec explicitly allows for partial mirrors, with the mirrors file specifying (through patterns) what is available from partial mirrors.

For now we only support full mirrors; if we wanted to add partial mirrors, we would add a second `MirrorPartial` constructor here with arguments corresponding to TUF's `metacontent` and `targetscontent` fields.

Constructors

MirrorFull |

Instances

Show MirrorContent # |
Methods showsPrec :: Int -> MirrorContent -> ShowS # show :: MirrorContent -> String # showList :: [MirrorContent] -> ShowS #

## Utility

type MirrorDescription = String #

describeMirror :: Mirror -> MirrorDescription #

Give a human-readable description of a particular mirror

(for use in error messages)

# Repository

data RepoRoot #

The root of the repository

Repository roots can be anchored at a remote URL or a local directory.

Note that even for remote repos `RepoRoot` is (potentially) different from `Web` -- for a repository located at, say, `http://hackage.haskell.org` they happen to coincide, but for one location at `http://example.com/some/subdirectory` they do not.

Instances

Pretty (Path RepoRoot) # |
Methods pretty :: Path RepoRoot -> String #

type RepoPath = Path RepoRoot #

Paths relative to the root of the repository

anchorRepoPathLocally :: Path root -> RepoPath -> Path root #

anchorRepoPathRemotely :: Path Web -> RepoPath -> Path Web #

# Index

data IndexRoot #

The root of the index tarball

Instances

Pretty (Path IndexRoot) # |
Methods pretty :: Path IndexRoot -> String #

type IndexPath = Path IndexRoot #

Paths relative to the root of the index tarball

# Cache

data CacheRoot #

The cache directory

Instances

Pretty (Path CacheRoot) # |
Methods pretty :: Path CacheRoot -> String #

type CachePath = Path CacheRoot #

anchorCachePath :: Path root -> CachePath -> Path root #

Anchor a cache path to the location of the cache

# Datatypes

data Root #

The root metadata

NOTE: We must have the invariant that ALL keys (apart from delegation keys) must be listed in `rootKeys`. (Delegation keys satisfy a similar invariant, see Targets.)

Constructors

Root |
Fields rootVersion :: FileVersion rootExpires :: FileExpires rootKeys :: KeyEnv rootRoles :: RootRoles

Instances

HasHeader Root # |
Methods fileExpires :: Lens' Root FileExpires # fileVersion :: Lens' Root FileVersion #
VerifyRole Root # |
Methods verifyRole :: Trusted Root -> TargetPath -> Maybe FileVersion -> Maybe UTCTime -> Signed Root -> Either VerificationError (SignaturesVerified Root) #
Monad m => ToJSON m Root # |
Methods toJSON :: Root -> m JSValue #
MonadKeys m => FromJSON m (Signed Root) # | We give an instance for Signed Root rather than Root because the key environment from the root data is necessary to resolve the explicit sharing in the signatures.
Methods fromJSON :: JSValue -> m (Signed Root) #

data RootRoles #

Constructors

RootRoles |
Fields rootRolesRoot :: RoleSpec Root rootRolesSnapshot :: RoleSpec Snapshot rootRolesTargets :: RoleSpec Targets rootRolesTimestamp :: RoleSpec Timestamp rootRolesMirrors :: RoleSpec Mirrors

Instances

MonadKeys m => FromJSON m RootRoles # |
Methods fromJSON :: JSValue -> m RootRoles #
Monad m => ToJSON m RootRoles # |
Methods toJSON :: RootRoles -> m JSValue #

data RoleSpec a #

Role specification

The phantom type indicates what kind of type this role is meant to verify.

Constructors

RoleSpec |
Fields roleSpecKeys :: [Some PublicKey] roleSpecThreshold :: KeyThreshold

Instances

MonadKeys m => FromJSON m (RoleSpec a) # |
Methods fromJSON :: JSValue -> m (RoleSpec a) #
Monad m => ToJSON m (RoleSpec a) # |
Methods toJSON :: RoleSpec a -> m JSValue #
Show (RoleSpec a) # |
Methods showsPrec :: Int -> RoleSpec a -> ShowS # show :: RoleSpec a -> String # showList :: [RoleSpec a] -> ShowS #

# TUF types

data Signed a #

Constructors

Signed |
Fields signed :: a signatures :: Signatures

Instances

MonadKeys m => FromJSON m (Signed Mirrors) # |
Methods fromJSON :: JSValue -> m (Signed Mirrors) #
(MonadKeys m, MonadReader RepoLayout m) => FromJSON m (Signed Snapshot) # |
Methods fromJSON :: JSValue -> m (Signed Snapshot) #
(MonadKeys m, MonadReader RepoLayout m) => FromJSON m (Signed Timestamp) # |
Methods fromJSON :: JSValue -> m (Signed Timestamp) #
MonadKeys m => FromJSON m (Signed Targets) # |
Methods fromJSON :: JSValue -> m (Signed Targets) #
MonadKeys m => FromJSON m (Signed Root) # | We give an instance for Signed Root rather than Root because the key environment from the root data is necessary to resolve the explicit sharing in the signatures.
Methods fromJSON :: JSValue -> m (Signed Root) #
(Monad m, ToJSON m a) => ToJSON m (Signed a) # |
Methods toJSON :: Signed a -> m JSValue #

newtype Signatures #

A list of signatures

Invariant: each signature must be made with a different key. We enforce this invariant for incoming untrusted data (`fromPreSignatures`) but not for lists of signatures that we create in code.

Constructors

Signatures [Signature] |

Instances

MonadKeys m => FromJSON m Signatures # |
Methods fromJSON :: JSValue -> m Signatures #
Monad m => ToJSON m Signatures # |
Methods toJSON :: Signatures -> m JSValue #

data Signature #

Constructors

Signature |
Fields signature :: ByteString signatureKey :: Some PublicKey

# Construction and verification

unsigned :: a -> Signed a #

Create a new document without any signatures

withSignatures :: ToJSON WriteJSON a => RepoLayout -> [Some Key] -> a -> Signed a #

Sign a document

withSignatures' :: ToJSON Identity a => [Some Key] -> a -> Signed a #

Variation on `withSignatures` that doesn't need the repo layout

signRendered :: [Some Key] -> ByteString -> Signatures #

Construct signatures for already rendered value

verifySignature :: ByteString -> Signature -> Bool #

# JSON aids

signedFromJSON :: (MonadKeys m, FromJSON m a) => JSValue -> m (Signed a) #

General FromJSON instance for signed datatypes

We don't give a general FromJSON instance for Signed because for some datatypes we need to do something special (datatypes where we need to read key environments); for instance, see the "Signed Root" instance.

verifySignatures :: JSValue -> Signatures -> Bool #

Signature verification

NOTES: 1. By definition, the signature must be verified against the canonical JSON format. This means we _must_ parse and then pretty print (as we do here) because the document as stored may or may not be in canonical format. 2. However, it is important that we NOT translate from the JSValue to whatever internal datatype we are using and then back to JSValue, because that may not roundtrip: we must allow for additional fields in the JSValue that we ignore (and would therefore lose when we attempt to roundtrip). 3. We verify that all signatures are valid, but we cannot verify (here) that these signatures are signed with the right key, or that we have a sufficient number of signatures. This will be the responsibility of the calling code.

# Avoid interpreting signatures

data UninterpretedSignatures a #

File with uninterpreted signatures

Sometimes we want to be able to read a file without interpreting the signatures (that is, resolving the key IDs) or doing any kind of checks on them. One advantage of this is that this allows us to read many file types without any key environment at all, which is sometimes useful.

Constructors

UninterpretedSignatures |
Fields uninterpretedSigned :: a uninterpretedSignatures :: [PreSignature]

Instances

(ReportSchemaErrors m, FromJSON m a) => FromJSON m (UninterpretedSignatures a) # |
Methods fromJSON :: JSValue -> m (UninterpretedSignatures a) #
(Monad m, ToJSON m a) => ToJSON m (UninterpretedSignatures a) # |
Methods toJSON :: UninterpretedSignatures a -> m JSValue #
Show a => Show (UninterpretedSignatures a) # |
Methods showsPrec :: Int -> UninterpretedSignatures a -> ShowS # show :: UninterpretedSignatures a -> String # showList :: [UninterpretedSignatures a] -> ShowS #

data PreSignature #

A signature with a key ID (rather than an actual key)

This corresponds precisely to the TUF representation of a signature.

Constructors

PreSignature |
Fields presignature :: ByteString presigMethod :: Some KeyType presigKeyId :: KeyId

Instances

Show PreSignature # |
Methods showsPrec :: Int -> PreSignature -> ShowS # show :: PreSignature -> String # showList :: [PreSignature] -> ShowS #
ReportSchemaErrors m => FromJSON m PreSignature # |
Methods fromJSON :: JSValue -> m PreSignature #
Monad m => ToJSON m PreSignature # |
Methods toJSON :: PreSignature -> m JSValue #

## Utility

fromPreSignature :: MonadKeys m => PreSignature -> m Signature #

Convert a pre-signature to a signature

Verifies that the key type matches the advertised method.

fromPreSignatures :: MonadKeys m => [PreSignature] -> m Signatures #

Convert a list of `PreSignature`s to a list of `Signature`s

This verifies the invariant that all signatures are made with different keys. We do this on the presignatures rather than the signatures so that we can do the check on key IDs, rather than keys (the latter don't have an Ord instance).

toPreSignature :: Signature -> PreSignature #

Convert signature to pre-signature

toPreSignatures :: Signatures -> [PreSignature] #

Convert list of pre-signatures to a list of signatures

data Snapshot #

Constructors

Snapshot |
Fields snapshotVersion :: FileVersion snapshotExpires :: FileExpires snapshotInfoRoot :: FileInfo File info for the root metadata We list this explicitly in the snapshot so that we can check if we need to update the root metadata without first having to download the entire index tarball. snapshotInfoMirrors :: FileInfo File info for the mirror metadata snapshotInfoTarGz :: FileInfo Compressed index tarball snapshotInfoTar :: Maybe FileInfo Uncompressed index tarball Repositories are not required to provide this.

Instances

HasHeader Snapshot # |
Methods fileExpires :: Lens' Snapshot FileExpires # fileVersion :: Lens' Snapshot FileVersion #
VerifyRole Snapshot # |
Methods verifyRole :: Trusted Root -> TargetPath -> Maybe FileVersion -> Maybe UTCTime -> Signed Snapshot -> Either VerificationError (SignaturesVerified Snapshot) #
(MonadReader RepoLayout m, MonadError DeserializationError m, ReportSchemaErrors m) => FromJSON m Snapshot # |
Methods fromJSON :: JSValue -> m Snapshot #
MonadReader RepoLayout m => ToJSON m Snapshot # |
Methods toJSON :: Snapshot -> m JSValue #
(MonadKeys m, MonadReader RepoLayout m) => FromJSON m (Signed Snapshot) # |
Methods fromJSON :: JSValue -> m (Signed Snapshot) #

# TUF types

data Targets #

Target metadata

Most target files do not need expiry dates because they are not subject to change (and hence attacks like freeze attacks are not a concern).

Constructors

Targets |
Fields targetsVersion :: FileVersion targetsExpires :: FileExpires targetsTargets :: FileMap targetsDelegations :: Maybe Delegations

Instances

Show Targets # |
Methods showsPrec :: Int -> Targets -> ShowS # show :: Targets -> String # showList :: [Targets] -> ShowS #
HasHeader Targets # |
Methods fileExpires :: Lens' Targets FileExpires # fileVersion :: Lens' Targets FileVersion #
MonadKeys m => FromJSON m Targets # |
Methods fromJSON :: JSValue -> m Targets #
Monad m => ToJSON m Targets # |
Methods toJSON :: Targets -> m JSValue #
MonadKeys m => FromJSON m (Signed Targets) # |
Methods fromJSON :: JSValue -> m (Signed Targets) #

data Delegations #

Delegations

Much like the Root datatype, this must have an invariant that ALL used keys (apart from the global keys, which are in the root key environment) must be listed in `delegationsKeys`.

Constructors

Delegations |
Fields delegationsKeys :: KeyEnv delegationsRoles :: [DelegationSpec]

Instances

Show Delegations # |
Methods showsPrec :: Int -> Delegations -> ShowS # show :: Delegations -> String # showList :: [Delegations] -> ShowS #
MonadKeys m => FromJSON m Delegations # |
Methods fromJSON :: JSValue -> m Delegations #
Monad m => ToJSON m Delegations # |
Methods toJSON :: Delegations -> m JSValue #

data DelegationSpec #

Delegation specification

NOTE: This is a close analogue of `RoleSpec`.

Constructors

DelegationSpec |
Fields delegationSpecKeys :: [Some PublicKey] delegationSpecThreshold :: KeyThreshold delegation :: Delegation

Instances

Show DelegationSpec # |
Methods showsPrec :: Int -> DelegationSpec -> ShowS # show :: DelegationSpec -> String # showList :: [DelegationSpec] -> ShowS #
MonadKeys m => FromJSON m DelegationSpec # |
Methods fromJSON :: JSValue -> m DelegationSpec #
Monad m => ToJSON m DelegationSpec # |
Methods toJSON :: DelegationSpec -> m JSValue #

data Delegation #

A delegation

A delegation is a pair of a pattern and a replacement.

See `match` for an example.

Constructors

Delegation (Pattern a) (Replacement a) |

Instances

Show Delegation # |
Methods showsPrec :: Int -> Delegation -> ShowS # show :: Delegation -> String # showList :: [Delegation] -> ShowS #
Lift Delegation # |
Methods lift :: Delegation -> Q Exp #

## Util

targetsLookup :: TargetPath -> Targets -> Maybe FileInfo #

data Timestamp #

Constructors

Timestamp |
Fields timestampVersion :: FileVersion timestampExpires :: FileExpires timestampInfoSnapshot :: FileInfo

Instances

HasHeader Timestamp # |
Methods fileExpires :: Lens' Timestamp FileExpires # fileVersion :: Lens' Timestamp FileVersion #
VerifyRole Timestamp # |
Methods verifyRole :: Trusted Root -> TargetPath -> Maybe FileVersion -> Maybe UTCTime -> Signed Timestamp -> Either VerificationError (SignaturesVerified Timestamp) #
(MonadReader RepoLayout m, MonadError DeserializationError m, ReportSchemaErrors m) => FromJSON m Timestamp # |
Methods fromJSON :: JSValue -> m Timestamp #
MonadReader RepoLayout m => ToJSON m Timestamp # |
Methods toJSON :: Timestamp -> m JSValue #
(MonadKeys m, MonadReader RepoLayout m) => FromJSON m (Signed Timestamp) # |
Methods fromJSON :: JSValue -> m (Signed Timestamp) #