Skip to content

v0.3.0

Choose a tag to compare

@github-actions github-actions released this 21 Aug 06:00
· 101 commits to main since this release
40138c0

Added

  • A recorded collection session, and the gate that replays it. A provider
    descriptor declares endpoints; nothing proved the collector emits them, which is
    the exact shape of the inline-EIM incident (right rule, data that never arrived, no
    Rego test able to see it). mise run trace now records a real --live collection
    through an intercepting proxy, against a local emulator and with no cloud
    credential
    , and the recording is committed to
    internal/genprovider/testdata/transcripts/. Two gates replay it on every build:
    TestTheRecordedCollectionStillHappens (fewer calls than the recording saw means a
    datum stopped arriving; more means an endpoint declared but never measured) and
    TestEveryDeclaredEndpointIsObservedOrDeclaredUnobserved (the non_observes ledger
    is exact in both directions). The replay serves the recorded responses, never
    responses derived from the spec under test: a harness answering "what the spec
    expects" would measure its own copy of the spec and stay green on a wrong items:.
    Measured on the first run: no declared endpoint stays silent, except three Outscale
    child joins and one Exoscale child join whose parent list is not served by the
    emulator or came back empty — each now written down with its reason. New guide:
    Tracing real API calls. No line of Pépin
    changed, so no collection endpoint became overridable and no exfiltration surface
    was created.

  • A veracity contract, and a debt counter rather than a green matrix. For each
    control × provider × source path, internal/veracity derives the verdicts that
    path can actually reach — three where it can conclude, one where it cannot lift
    the pass lock, one where the provider contract declares it not applicable — and
    compares them to committed scenarios that run against the binary, over the
    whole chain: canned API responses served to the descriptor's real collection spec,
    or a minimal Terraform plan passed to its real mapper. What is not proven is
    recorded in internal/veracity/testdata/debt.txt, a gate in both directions: an
    unproven obligation missing from the ledger fails the build, so a control added
    without its scenarios cannot land
    , and a line no longer owed fails it too. The
    counts are published in docs/known-limitations.md. Today: 178 paths, 5 fully
    proven, 458 obligations, 445 outstanding. A matrix of seven hundred
    template-generated cases would be green and would prove nothing.

  • A degradation suite with one guarantee: never a pass. A refused endpoint, a
    refused child join, a partial response, an unavailable service, an unreadable
    response, a Terraform attribute still unknown at plan time — each produced for
    real against a live server or a real plan, and checked on every control that
    reads the affected type rather than on a chosen witness.

  • A Terraform finding carries its origin: file, line, module. --format json
    gains labels.tf_file, labels.tf_line and labels.tf_module; the SARIF result
    gains a physicalLocation with a region, which is what makes a forge annotate the
    guilty resource block instead of the plan file. The module is read off the resource
    address; the file and the line are measured in the .tf sources beside the plan,
    because terraform show -json carries neither — verified in Terraform's own source,
    where a resource's configuration representation holds address, type, name and
    expressions and nothing about the document. When the sources are absent, the module
    is remote, or the same block header appears twice, the origin is simply absent: a
    wrong line sends someone to fix the wrong place, and it is believed. On a live
    collection the notion does not exist and no label is set.

  • Minimum permissions are declared in the descriptor, not only in prose. Each
    provider descriptor now carries a permissions: block, one entry per collection
    unit: the grant in the provider's native vocabulary, the official source that
    states it, and whether it is confirmed or still to verify. The provider
    pages render that block, so the table a reader follows and the grant the scan names
    in a not-evaluated reason cannot diverge. Four gates refuse a silent omission: a
    collection unit with no declared grant, an orphan entry, a missing state or source,
    and an unverified grant with no written reservation. Nothing here is confirmed by a
    scan run with a deliberately reduced role — this repository holds no cloud
    credentials — and every page says so.

  • Collection completeness is recorded, and it moves the verdict. Every collector
    — the declarative engine, the object-storage collector, the inline EIM policy chain
    and the managed-Kubernetes one — now records, unit by unit, whether it read
    everything the API had to return. A refused endpoint no longer stops the scan and no
    longer disappears into a warning: the inventory carries a collection block
    (attempted, complete, a stable error class, the provider's own detail), it is
    sealed in the evidence bundle, and it is published in --format json. Every
    control that reads a resource type fed by an incomplete unit becomes
    not-evaluated
    with that unit named as its reason — the assessment decides, never
    a rule — and the scan returns 3, never 0. The transition is strictly
    directional: a pass is withdrawn, a fail is kept (an observed deviation stays
    observed), a not-applicable is kept (it comes from the contract, not from the
    collection). A verdict can now move on an unchanged tenant: a scan whose credentials
    cannot read part of the scope used to return 0, and returns 3 from now on.

  • A capability report, printed before any verdict. A live scan announces what it
    could and could not observe, unit by unit, with the class of each failure and the
    number of controls it costs — the count coming from the same function that degrades
    the assessment, so the report cannot promise what the report does not hold. Outside
    live scans it appears only when there is something to say. Resource types a Terraform
    plan carries and no spec projects are listed too: they are not incompleteness — no
    control reads them, so no verdict depends on them, and they do not gate — but they
    are no longer silent.

  • exempted: a fifth, first-class assessment status, and dated exemptions.
    scan --exceptions <file.yaml> reads a versioned exemption policy — control,
    justification, expires_at, owner, approved_by, all five mandatory and all
    validated at load time. A fail covered by a valid entry becomes exempted, never
    pass: the finding stays in --format json, in the SARIF and in the severity
    counts, summary.conforme stays false, and the verdict reads NON-COMPLIANT under waiver. A new exit code, 4, means "every remaining critical/high deviation is
    covered by a dated, attributed exemption" — non-zero, so nothing passes in silence,
    and distinct, so a pipeline that accepts it has to write the number down. An expired
    exemption stops applying and says so; one naming a control or subject that does not
    exist is reported as an orphan; both fail a --strict gate. The bundle seals
    exemptions.json, so the dossier digest depends on what it set aside, and
    verify --re-derive replays the sealed policy at the sealed instant.
    A status and an exit code are both surfaces a pipeline must know how to read.

  • Every attribute of the normalized inventory carries its provenance. Beside
    attributes, a parallel provenance index says, for each attribute, where the
    value came from — api with the request actually served, terraform-plan with
    the plan resource type, or derived for a descriptor literal or a locally computed
    value — and whether the source really carried the field. It is a parallel index and
    not a wrapper around each value: the 59 Rego rules read attributes.<name>
    unchanged, so no verdict can move (measured on nine fixtures × two formats × two
    languages: identical findings, statuses and exit codes). --format assessment now
    exposes, for every control with a deciding attribute, that attribute and its
    attestation in evidence.attribute / evidence.source. This makes visible, without
    changing it, that two controls cross their attribute gate thanks to a descriptor
    constant rather than a measurement.

  • The normalized inventory is a versioned internal contract.
    pepin-inventory/v1, frozen in cmd/testdata/frozen/inventory.json with its
    envelope, its resource shape and the full vocabulary of resource types and common
    attributes derived from the descriptors and collectors. The version travels with
    every evidence bundle (manifest.inventory_schema), and a new reference page states
    what is guaranteed and what is not. Bundle format /v2 (manifest carries the
    inventory schema and the exemption summary), CLI surface v3 (--exceptions,
    exit code 4).

  • Wave 3 of the documentation: the control catalogue is generated, and the
    project explains itself.
    One generated page per control under docs/controls/
    (what it concludes, from which source, with which reason when it cannot), a
    remediation guide that shows the same control moving from fail to pass on the
    repository's own example plans, an architecture page that argues the central choice
    — one common rule set, the source is what changes per cloud — and two contribution
    guides, adding a control and adding a provider, each ending in a checklist usable as
    is. A public ROADMAP.md replaces the internal working document that used to sit in
    the product documentation.

  • Exoscale is the first provider with a complete set of deployable remediation
    proofs
    : 26 of 26, bringing the repository from 4 to 26 out of 95. Twenty
    self-contained Terraform modules, checked with terraform init -backend=false and
    terraform validate against the real provider schema, plus two documented notes
    where Terraform cannot express the fix (provider sovereignty, account MFA).
    TestExoscaleRemediationCoverageStaysComplete now fails the build when an exoscale
    control lands without its proof; the other providers stay outside that guard until
    they reach 100 %.

  • Wave 2 of the product documentation: ten pages, generated where they can be.
    A CLI reference built from the frozen surface and from real --help runs, the
    exit-code contract shown as six executions with the code each one returned, the
    five output formats with a real document each, plan-versus-live with two
    reproducible divergences, the evidence-bundle lifecycle (seal, verify,
    re-derive, tamper, redact) captured end to end, GitHub Actions and GitLab CI
    integrations whose complete pipelines are injected from examples/, and one
    page per sovereign cloud with its API calls and its minimal read-only
    permissions. TestEveryPublicCLIFlagIsDocumented now fails when a public flag
    is missing from the CLI reference, in either language.

  • The published CI examples pin v0.2.0 and every action by commit SHA. The
    action of v0.1.0 and v0.1.1 could not install anything (gh attestation verify
    without a token), so those tags should not be pinned by anyone.

  • Controls become configurable, and a relaxed setting cannot keep its badge. Four
    controls now read a policy file — the mandatory tagging profile, the snapshot
    freshness window and accepted states, the secret-detection threshold. Every setting
    is a handle that can manufacture green, so each normative mapping in the reference
    carries the constraints under which it holds (config_requise, with four
    interpretable senses: au_plus_le_defaut, superset_du_defaut,
    sous_ensemble_du_defaut, au_moins_aussi_strict_que_le_defaut). A configuration that falls outside a constraint makes the
    control lose its references in the assessment — it stops claiming CIS,
    ISO or SecNumCloud — and the relaxation appears in five places at once: the terminal
    (RELAXED CONFIGURATION), the assessment labels and evidence, --format json
    (config.relaxations), the verdict banner, and the sealed bundle (config.json
    plus a config entry in the manifest, both covered by checksums.txt). Tightening a
    setting is not a relaxation and is reported nowhere. mise run validate refuses a
    constraint naming a setting the policy engine cannot evaluate. See
    docs/guides/control-configuration.md.

  • One policy file: scan --policy. It carries controls: (the settings) and
    exceptions: (the exemptions, unchanged format). --exceptions remains as the
    historic name of the same file and reads the same schema, so an existing invocation
    and an existing file keep working; the two flags are mutually exclusive, because
    two policy files are two files that will drift. CLI surface v4.

  • Secret detection carries a confidence level. Every finding of
    compute_instance_no_secrets_in_user_data publishes labels.confidence: high for a
    PEM private-key block, medium for a recognized prefix in the expected format
    (ghp_, AKIA, SCW, EXO, glpat-, JWT), low for a generic heuristic
    (password=…, api_key=…). The default reporting threshold is low — everything is
    reported, exactly as before. The detected value still never appears, at any level, and
    that property is now tested at all three levels, on the message and the remediation,
    in both languages.

  • The evaluated inventory carries its configuration. The envelope gains config,
    the effective control configuration, next to evaluated_at — so a sealed bundle's
    input.json replays under the settings of its own day, and verify --re-derive stays
    faithful without being handed the policy file. --format json publishes
    config.policy_digest and config.effective on every scan, default included: a
    reader must be able to check that a scan ran under the expected settings, not merely
    observe that it said nothing. Bundle format v3.

Changed

  • network_documented now checks what it announces. The rule promised owner, project
    and environment, and evaluated count(tags) > 0: a single foo=bar was enough to
    declare a network documented — a compliance asserted without being measured. It now
    requires the tags that actually document (default Owner, Project, Env, configurable),
    and it stays silent when the tags attribute was not collected, where it used to report
    a deviation. The code is unchanged: it travels in SARIF ruleIds, archived
    assessments and exemption files, where a rename would turn a valid exemption into an
    orphan overnight and bring back the deviation it covered. Title and description are
    rewritten in both languages.

  • The mandatory tagging policy is configurable, and the comparison is
    convention-agnostic.
    governance_resource_required_tags no longer demands four frozen
    literals. The comparison ignores case and separators (cost-center = CostCenter), and
    aliases widen each logical name (team for Owner, environment for Env), so an
    organisation writing cost-center, application, environment, team is no longer reported
    as ungoverned. The targeted resource types are explicit and justified, and four billable
    types join the scope — blockstorage_snapshot, compute_image, managed_database,
    kubernetes_cluster — which closes a false-negative on paid services that were outside
    it. The shipped profile is documented as a recommendation, not a standard.

  • The snapshot freshness control says what it measures, and what it does not prove.
    blockstorage_volume_snapshots_exist now checks the snapshot's native state as well
    as its date: a snapshot in error, pending or creating no longer counts as a backup.
    The window is configurable (7 days by default). The title becomes "No recent, completed
    snapshot", and the description states plainly what the control does not prove —
    restorability, application completeness, retention, the existence of a backup policy.
    The code is unchanged, for the same reason as above. Anchored on Outscale
    Snapshot.State and Exoscale block-storage-snapshot.state, both projected by the
    collectors from this version on. The normalized inventory therefore gains an attribute,
    which is a contract change: inventory schema v4, whose note also records the config
    envelope key added above.

  • --strict also refuses a dropped normative mapping. It already refused zero
    coverage, remaining medium/low deviations and a stale exemptions file; it now returns
    3 when a relaxed setting cost a control its mapping. No new exit code: incompleteness
    and relaxation say the same thing — do not read this scan as a green light — and both
    already sit where 3 sits.