-- SPDX-FileCopyrightText: 2026 Alexandra de Wit
--
-- SPDX-License-Identifier: MIT

{- | Read one synced advisory artifact through a pinned lookup capability.
Package keys are canonical per ecosystem.
-}
module Ecluse.Core.Cve (
    -- * The opened artifact
    CveDb (..),
    CveDbRejected (..),

    -- * The consumer view
    CveLookup (..),
    AdvisoryRange (..),
    CveQueryFault (..),

    -- * Pure range matching
    PackageAdvisories,
    packageAdvisories,
    keepAdvisories,
    hasAdvisories,
    affecting,
    hasFixes,
    fixedAt,
    advisoryIdsOf,
    MissingScorePolicy (..),
    scoreAtLeast,
) where

import Data.Map.Strict qualified as Map
import Data.Set qualified as Set

import Ecluse.Core.Cve.Internal (AdvisoryRange (..), CveDb (..), CveDbRejected (..), CveLookup (..), CveQueryFault (..))
import Ecluse.Core.Ecosystem (Ecosystem)
import Ecluse.Core.Osv.Types (UpperBound (..))
import Ecluse.Core.Version (Version, VersionKey, parseVersionKey, renderVersion, renderVersionKey, versionKeyIn)

-- | One package's advisory segments, each with its bounds parsed once under the package's ecosystem.
data PackageAdvisories = PackageAdvisories
    { PackageAdvisories -> Ecosystem
paEcosystem :: Ecosystem
    , PackageAdvisories -> [Segment]
paSegments :: [Segment]
    , -- Lazy: only the remediation rule reads it, so a deny rule's filtered copy never builds it.
      PackageAdvisories -> Map Text [AdvisoryRange]
paFixes :: ~(Map Text [AdvisoryRange])
    , -- Missing parsed fixes disable rejection because a parsed probe can render to their raw text.
      PackageAdvisories -> Maybe (Set VersionKey)
paFixCandidates :: ~(Maybe (Set VersionKey))
    }

-- One advisory row and the bounds matching reads from it.
data Segment = Segment
    { Segment -> AdvisoryRange
segRange :: AdvisoryRange
    , -- Lazy: parsed when a version is first matched, so a request that matches none parses nothing.
      Segment -> SegmentBounds
segBounds :: ~SegmentBounds
    }

-- A bound the grammar cannot parse is no bound, so no version can be shown to be outside it.
data SegmentBounds
    = -- A point whose one string the grammar rejects, matched as text.
      OnlyText Text
    | -- The inclusive lower bound and the upper bound.
      Ordered (Maybe VersionKey) UpperKey

data UpperKey = Below VersionKey | AtMost VersionKey | NoUpper

-- | Parse every segment's bounds at most once, under the package's ecosystem.
packageAdvisories :: Ecosystem -> [AdvisoryRange] -> PackageAdvisories
packageAdvisories :: Ecosystem -> [AdvisoryRange] -> PackageAdvisories
packageAdvisories Ecosystem
eco = Ecosystem -> [Segment] -> PackageAdvisories
fromSegments Ecosystem
eco ([Segment] -> PackageAdvisories)
-> ([AdvisoryRange] -> [Segment])
-> [AdvisoryRange]
-> PackageAdvisories
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AdvisoryRange -> Segment) -> [AdvisoryRange] -> [Segment]
forall a b. (a -> b) -> [a] -> [b]
map (\AdvisoryRange
ar -> AdvisoryRange -> SegmentBounds -> Segment
Segment AdvisoryRange
ar (Ecosystem -> AdvisoryRange -> SegmentBounds
segmentBounds Ecosystem
eco AdvisoryRange
ar))

-- | Keep only the segments whose row passes the test.
keepAdvisories :: (AdvisoryRange -> Bool) -> PackageAdvisories -> PackageAdvisories
keepAdvisories :: (AdvisoryRange -> Bool) -> PackageAdvisories -> PackageAdvisories
keepAdvisories AdvisoryRange -> Bool
keep PackageAdvisories
advisories = Ecosystem -> [Segment] -> PackageAdvisories
fromSegments (PackageAdvisories -> Ecosystem
paEcosystem PackageAdvisories
advisories) ((Segment -> Bool) -> [Segment] -> [Segment]
forall a. (a -> Bool) -> [a] -> [a]
filter (AdvisoryRange -> Bool
keep (AdvisoryRange -> Bool)
-> (Segment -> AdvisoryRange) -> Segment -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Segment -> AdvisoryRange
segRange) (PackageAdvisories -> [Segment]
paSegments PackageAdvisories
advisories))

-- | Whether any segment remains. Without one, 'affecting' holds no row for any version.
hasAdvisories :: PackageAdvisories -> Bool
hasAdvisories :: PackageAdvisories -> Bool
hasAdvisories = Bool -> Bool
not (Bool -> Bool)
-> (PackageAdvisories -> Bool) -> PackageAdvisories -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Segment] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([Segment] -> Bool)
-> (PackageAdvisories -> [Segment]) -> PackageAdvisories -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageAdvisories -> [Segment]
paSegments

-- | Whether any row names a fix. Without one, 'fixedAt' holds no row for any version.
hasFixes :: PackageAdvisories -> Bool
hasFixes :: PackageAdvisories -> Bool
hasFixes = Bool -> Bool
not (Bool -> Bool)
-> (PackageAdvisories -> Bool) -> PackageAdvisories -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Text [AdvisoryRange] -> Bool
forall k a. Map k a -> Bool
Map.null (Map Text [AdvisoryRange] -> Bool)
-> (PackageAdvisories -> Map Text [AdvisoryRange])
-> PackageAdvisories
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PackageAdvisories -> Map Text [AdvisoryRange]
paFixes

-- The fixes index keeps row order within each fixed version.
fromSegments :: Ecosystem -> [Segment] -> PackageAdvisories
fromSegments :: Ecosystem -> [Segment] -> PackageAdvisories
fromSegments Ecosystem
eco [Segment]
segments =
    PackageAdvisories
        { paEcosystem :: Ecosystem
paEcosystem = Ecosystem
eco
        , paSegments :: [Segment]
paSegments = [Segment]
segments
        , paFixes :: Map Text [AdvisoryRange]
paFixes = ([AdvisoryRange] -> [AdvisoryRange] -> [AdvisoryRange])
-> [(Text, [AdvisoryRange])] -> Map Text [AdvisoryRange]
forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith (([AdvisoryRange] -> [AdvisoryRange] -> [AdvisoryRange])
-> [AdvisoryRange] -> [AdvisoryRange] -> [AdvisoryRange]
forall a b c. (a -> b -> c) -> b -> a -> c
flip [AdvisoryRange] -> [AdvisoryRange] -> [AdvisoryRange]
forall a. Semigroup a => a -> a -> a
(<>)) [(Segment -> Text -> Text
fixedIdentity Segment
s Text
fixed, [Segment -> AdvisoryRange
segRange Segment
s]) | (Segment
s, Text
fixed) <- [(Segment, Text)]
fixedSegments]
        , paFixCandidates :: Maybe (Set VersionKey)
paFixCandidates = [VersionKey] -> Set VersionKey
forall a. Ord a => [a] -> Set a
Set.fromList ([VersionKey] -> Set VersionKey)
-> Maybe [VersionKey] -> Maybe (Set VersionKey)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Segment, Text) -> Maybe VersionKey)
-> [(Segment, Text)] -> Maybe [VersionKey]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (Segment -> Maybe VersionKey
fixedKey (Segment -> Maybe VersionKey)
-> ((Segment, Text) -> Segment)
-> (Segment, Text)
-> Maybe VersionKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Segment, Text) -> Segment
forall a b. (a, b) -> a
fst) [(Segment, Text)]
fixedSegments
        }
  where
    fixedSegments :: [(Segment, Text)]
fixedSegments = [(Segment
s, Text
fixed) | Segment
s <- [Segment]
segments, FixedBefore Text
fixed <- [AdvisoryRange -> UpperBound
arUpperBound (Segment -> AdvisoryRange
segRange Segment
s)]]

-- Reuse the parsed upper bound. An unorderable fix retains its literal identity.
fixedIdentity :: Segment -> Text -> Text
fixedIdentity :: Segment -> Text -> Text
fixedIdentity Segment
segment Text
raw = Text -> (VersionKey -> Text) -> Maybe VersionKey -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
raw VersionKey -> Text
renderVersionKey (Segment -> Maybe VersionKey
fixedKey Segment
segment)

fixedKey :: Segment -> Maybe VersionKey
fixedKey :: Segment -> Maybe VersionKey
fixedKey Segment
segment = case Segment -> SegmentBounds
segBounds Segment
segment of
    Ordered Maybe VersionKey
_ (Below VersionKey
key) -> VersionKey -> Maybe VersionKey
forall a. a -> Maybe a
Just VersionKey
key
    SegmentBounds
_ -> Maybe VersionKey
forall a. Maybe a
Nothing

-- | Rows with this ecosystem's canonical exact fix identity, retaining order and duplicates.
fixedAt :: PackageAdvisories -> Version -> [AdvisoryRange]
fixedAt :: PackageAdvisories -> Version -> [AdvisoryRange]
fixedAt PackageAdvisories
advisories Version
version
    | Map Text [AdvisoryRange] -> Bool
forall k a. Map k a -> Bool
Map.null Map Text [AdvisoryRange]
fixes = []
    | Just VersionKey
key <- Maybe VersionKey
probeKey
    , Just Set VersionKey
candidates <- PackageAdvisories -> Maybe (Set VersionKey)
paFixCandidates PackageAdvisories
advisories
    , VersionKey -> Set VersionKey -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.notMember VersionKey
key Set VersionKey
candidates =
        []
    | Bool
otherwise = [AdvisoryRange]
-> Text -> Map Text [AdvisoryRange] -> [AdvisoryRange]
forall k a. Ord k => a -> k -> Map k a -> a
Map.findWithDefault [] Text
probeIdentity Map Text [AdvisoryRange]
fixes
  where
    fixes :: Map Text [AdvisoryRange]
fixes = PackageAdvisories -> Map Text [AdvisoryRange]
paFixes PackageAdvisories
advisories
    probeKey :: Maybe VersionKey
probeKey = Ecosystem -> Version -> Maybe VersionKey
versionKeyIn (PackageAdvisories -> Ecosystem
paEcosystem PackageAdvisories
advisories) Version
version
    probeIdentity :: Text
probeIdentity = Text -> (VersionKey -> Text) -> Maybe VersionKey -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Version -> Text
renderVersion Version
version) VersionKey -> Text
renderVersionKey Maybe VersionKey
probeKey

-- | The rows whose interval holds the version, in row order. __Fail-closed:__ an unprovable comparison counts as inside, bar an unorderable point.
affecting :: PackageAdvisories -> Version -> [AdvisoryRange]
affecting :: PackageAdvisories -> Version -> [AdvisoryRange]
affecting PackageAdvisories
advisories Version
version = [Segment -> AdvisoryRange
segRange Segment
s | Segment
s <- PackageAdvisories -> [Segment]
paSegments PackageAdvisories
advisories, SegmentBounds -> Bool
holds (Segment -> SegmentBounds
segBounds Segment
s)]
  where
    key :: Maybe VersionKey
key = Ecosystem -> Version -> Maybe VersionKey
versionKeyIn (PackageAdvisories -> Ecosystem
paEcosystem PackageAdvisories
advisories) Version
version
    holds :: SegmentBounds -> Bool
holds = \case
        OnlyText Text
only -> Version -> Text
renderVersion Version
version Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
only
        Ordered Maybe VersionKey
lower UpperKey
upper -> Bool -> (VersionKey -> Bool) -> Maybe VersionKey -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (\VersionKey
k -> VersionKey -> Maybe VersionKey -> Bool
atOrAbove VersionKey
k Maybe VersionKey
lower Bool -> Bool -> Bool
&& VersionKey -> UpperKey -> Bool
withinUpper VersionKey
k UpperKey
upper) Maybe VersionKey
key

atOrAbove :: VersionKey -> Maybe VersionKey -> Bool
atOrAbove :: VersionKey -> Maybe VersionKey -> Bool
atOrAbove VersionKey
k = Bool -> (VersionKey -> Bool) -> Maybe VersionKey -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (VersionKey
k VersionKey -> VersionKey -> Bool
forall a. Ord a => a -> a -> Bool
>=)

-- A fix is an exclusive upper bound and last_affected an inclusive one.
withinUpper :: VersionKey -> UpperKey -> Bool
withinUpper :: VersionKey -> UpperKey -> Bool
withinUpper VersionKey
k = \case
    Below VersionKey
fixed -> VersionKey
k VersionKey -> VersionKey -> Bool
forall a. Ord a => a -> a -> Bool
< VersionKey
fixed
    AtMost VersionKey
lastAffected -> VersionKey
k VersionKey -> VersionKey -> Bool
forall a. Ord a => a -> a -> Bool
<= VersionKey
lastAffected
    UpperKey
NoUpper -> Bool
True

-- | The distinct advisory identifiers of these rows, in the order they first appear.
advisoryIdsOf :: [AdvisoryRange] -> [Text]
advisoryIdsOf :: [AdvisoryRange] -> [Text]
advisoryIdsOf = [Text] -> [Text]
forall a. Ord a => [a] -> [a]
ordNub ([Text] -> [Text])
-> ([AdvisoryRange] -> [Text]) -> [AdvisoryRange] -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AdvisoryRange -> Text) -> [AdvisoryRange] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map AdvisoryRange -> Text
arCveId

{- OSV writes an enumerated version as introduced == last_affected. When the grammar rejects that
string, the segment names it literally, since nothing can order it against anything. -}
segmentBounds :: Ecosystem -> AdvisoryRange -> SegmentBounds
segmentBounds :: Ecosystem -> AdvisoryRange -> SegmentBounds
segmentBounds Ecosystem
eco AdvisoryRange
ar = case (AdvisoryRange -> Maybe Text
arIntroduced AdvisoryRange
ar, AdvisoryRange -> UpperBound
arUpperBound AdvisoryRange
ar) of
    (Just Text
introduced, LastAffected Text
lastAffected)
        | Text
introduced Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
lastAffected -> SegmentBounds
-> (VersionKey -> SegmentBounds)
-> Maybe VersionKey
-> SegmentBounds
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Text -> SegmentBounds
OnlyText Text
introduced) (\VersionKey
k -> Maybe VersionKey -> UpperKey -> SegmentBounds
Ordered (VersionKey -> Maybe VersionKey
forall a. a -> Maybe a
Just VersionKey
k) (VersionKey -> UpperKey
AtMost VersionKey
k)) Maybe VersionKey
introducedKey
    (Maybe Text
_, UpperBound
upper) -> Maybe VersionKey -> UpperKey -> SegmentBounds
Ordered Maybe VersionKey
introducedKey (UpperBound -> UpperKey
upperKey UpperBound
upper)
  where
    keyOf :: Text -> Maybe VersionKey
keyOf = Either VersionError VersionKey -> Maybe VersionKey
forall l r. Either l r -> Maybe r
rightToMaybe (Either VersionError VersionKey -> Maybe VersionKey)
-> (Text -> Either VersionError VersionKey)
-> Text
-> Maybe VersionKey
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ecosystem -> Text -> Either VersionError VersionKey
parseVersionKey Ecosystem
eco
    introducedKey :: Maybe VersionKey
introducedKey = Text -> Maybe VersionKey
keyOf (Text -> Maybe VersionKey) -> Maybe Text -> Maybe VersionKey
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< AdvisoryRange -> Maybe Text
arIntroduced AdvisoryRange
ar
    upperKey :: UpperBound -> UpperKey
upperKey = \case
        FixedBefore Text
fixed -> UpperKey
-> (VersionKey -> UpperKey) -> Maybe VersionKey -> UpperKey
forall b a. b -> (a -> b) -> Maybe a -> b
maybe UpperKey
NoUpper VersionKey -> UpperKey
Below (Text -> Maybe VersionKey
keyOf Text
fixed)
        LastAffected Text
lastAffected -> UpperKey
-> (VersionKey -> UpperKey) -> Maybe VersionKey -> UpperKey
forall b a. b -> (a -> b) -> Maybe a -> b
maybe UpperKey
NoUpper VersionKey -> UpperKey
AtMost (Text -> Maybe VersionKey
keyOf Text
lastAffected)
        UpperBound
Unbounded -> UpperKey
NoUpper

-- | Whether an individual absent score supplies threshold evidence.
data MissingScorePolicy
    = -- | CVSS keeps its denial for unscored advisories, including malware.
      DenyMissingScore
    | -- | EPSS requires a known score to supply a denial.
      AbstainMissingScore

-- | Compare a score with the deny threshold using the metric's missing-score policy.
scoreAtLeast :: MissingScorePolicy -> Double -> Maybe Double -> Bool
scoreAtLeast :: MissingScorePolicy -> Double -> Maybe Double -> Bool
scoreAtLeast MissingScorePolicy
missing Double
threshold = Bool -> (Double -> Bool) -> Maybe Double -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
absent (Double -> Double -> Bool
forall a. Ord a => a -> a -> Bool
>= Double
threshold)
  where
    absent :: Bool
absent = case MissingScorePolicy
missing of
        MissingScorePolicy
DenyMissingScore -> Bool
True
        MissingScorePolicy
AbstainMissingScore -> Bool
False