Skip to content

Releases

v0.5.1

Choose a tag to compare

@github-actions github-actions released this 07 Nov 16:26
9c141d1

Security

  • Kubernetes, REST and S3 share a TLS 1.2+ policy: RSA keys below 2048 bits
    and EC keys below 224 bits are refused in client and verified server chains.
    TLS 1.2 allows only AEAD/ECDHE suites. Weak private clusters must rotate keys;
    HTTP endpoints remain supported without TLS protection.
    S3 retains SDK custom CA bundles and proxy settings.
  • HMAC authentication (EXO2, SigV4 and S3) refuses secrets shorter than 14 actual
    input bytes (112 bits). Existing short local S3 secrets must be replaced.
    verify --pubkey enforces the same public-key sizes as TLS and requires a local
    PEM public key; export remote/KMS keys first. Cosign verifies a validated
    temporary snapshot to prevent replacement of the input key after validation.
    Key-size enforcement is not an entropy estimate. The OpenSSF key-length
    proposal now covers all cryptographic paths and includes native signature tests.
    Cancellation or deadlines after Cosign starts retain their context error
    rather than being reported as an invalid signature.

Changed

  • Move release signing and native signature witnesses to Rekor v2 using
    Cosign 3.1.3 and TUF-authenticated configuration, without v1 fallback.
    Checksum and image signatures are verified before creating the GitHub Release.
    Verification commands remain unchanged; older v1 signatures remain supported.
  • Update the AWS SDK S3 dependencies. Upgrade pflag to 1.1.0; the bilingual
    CLI reference reflects the updated flag help.
  • Align main's single-maintainer merge policy with Feint: PRs and CI remain
    required, but formal approval and blocking CODEOWNER review are not required.
    Plumber follows the same policy without disabling branch-protection checks.

Fixed

  • The release gate allows the README to name the prepared tag while verifying
    its procedure against the previous published release, with explicit evidence.

Removed

  • Remove the SecNumCloud badge from both READMEs; normative mappings remain
    documented without claiming certification.

Porte de release — v0.5.1

Verdict : GO · commit 9c141d1 · 2026-11-07

Étape 1 — hors ligne : le dépôt, et ce que sa documentation affirme : GO

  • ✔ release-check : tout ce qui doit être vrai avant un tag
  • ✔ mise run audit (vet + lint + gosec + govulncheck + osv)
  • ✔ mise run adr-drift
  • ✔ mise run falsify:all : chaque porte a été vue rouge
  • ✔ campagne de fuzzing bornée
  • ✔ les blocs générés de la documentation sont à jour
  • ✔ les versions épinglées valent au moins le minimum déclaré sûr
  • ✔ tout lien relatif de la documentation résout
  • ✔ la description racine nomme les fournisseurs enregistrés
  • · couverture de remédiation (indicatif)

Étape 2 — réseau : les artefacts tels qu'un utilisateur les reçoit : GO

  • ✔ les binaires se construisent, portent le tag et gardent leurs codes
  • ✔ le bloc de vérification du README vérifie la chaîne publiée
  • ✔ le bloc de vérification du README épingle le tag de release
  • ✔ l'image publiée se vérifie et scanne un plan, avec les commandes documentées
  • ✔ l'installeur de l'action accepte le binaire publié et refuse le même altéré
  • ✔ le template GitLab installe pepin dans l'image qu'il déclare

Étape 4 — surfaces et notes : ce qu'un changement de verdict doit avoir écrit : GO

  • ✔ les surfaces gelées correspondent à leur fixture
  • ✔ un verdict qui bouge à sa ligne au CHANGELOG

Le rapport détaillé reste local : il porte des chemins de la machine qui a lancé la porte, et les identifiants de ressources du tenant de qualification.

Published artifact verification

Verified after publication, not only against locally built binaries:

  • Release workflow: all jobs succeeded, including keyless image/checksum signing, exact workflow-identity verification and the published action's exit-code contract.
  • Final source commit: 9c141d1aa63746e1f4c9d8b5bb22c491abb97ccc. Its main CI passed and the actual Plumber job scored 100/100.
  • The downloaded checksum signature passed Cosign verification against the exact release.yml@refs/tags/v0.5.1 identity and GitHub OIDC issuer. Its authenticated Rekor entry uses hashedrekord API format 0.0.2.
  • SHA-256 checks passed for all four downloaded binaries and the SBOM. Build provenance for each binary verified against the release workflow and exact source commit.
  • The downloaded Linux amd64 binary reports pepin v0.5.1. Its real native signature witness passed RSA2048/P256, rejected RSA1024 and rejected signature tampering while unsigned bundle integrity remained valid.
  • The published image signature and provenance verified against the exact workflow and source commit, by digest: sha256:8f141210ef6d81a780ab15edaeef9e8768e1bc6fff631498563a058156706339.
  • All six stage-2 consumer checks were rerun against published v0.5.1 and passed, including the documented verification chain, image scan, installer positive/tamper-negative and GitLab template.

The pre-tag gate's remediation-coverage check remains advisory: it reports 72 missing remediation proofs, not a release-blocking failure. No claim of complete remediation coverage is made.

v0.5.0

Choose a tag to compare

@github-actions github-actions released this 06 Nov 19:27
fcead90

Added

  • The quality map counts authenticated live verdicts per control and
    provider
    , from verified anonymized records. It distinguishes historical
    Scaleway and Exoscale evidence from unauthenticated canaries and preserves the
    version of the binary actually run. Evidence expires after 90 days and does
    not alter the veracity ledger.

  • pepin diff compares two evidence bundles after checking their internal
    checksums. It separates fixes, regressions, and lost or restored visibility,
    compares resource inventories, and reports provenance changes; JSON output is
    available with --format json. It does not authenticate detached signatures:
    use pepin verify --pubkey when signer authenticity is required.

  • Scaleway: the organisation's API-key expiry policy is read (issue #196).
    iam_apiaccesspolicy_max_key_expiration was active for Outscale only. Scaleway has the
    equivalent, at organisation level, and enforces it — the qualification tenant found
    it by being refused: "organization security settings require an expiration date for API
    keys"
    . The refusal was the measurement. GET /iam/v1alpha1/organizations/{id}/security-settings
    carries max_api_key_expiration_duration, verified against the live API on 2026-09-11.
    The control is now active for Scaleway and concludes pass on an organisation enforcing
    365 days. This is a preventive control: listing keys says what is true today, this
    setting says what the organisation will refuse tomorrow — the distinction SecNumCloud 9.5
    and CIS 5.4 both draw. One rule, unchanged, on normalised data (ADR-0001).

  • Outscale plans now judge load-balancer listeners (issue #203).
    loadbalancer_ssl_listeners came back not-evaluated on the Terraform source while the
    plan wrote the listeners in clear — protocol and port. An internet-facing load balancer
    listening only in HTTP is now a fail, and a TCP 443 one stays inconclusive with its
    subject, as it does live. The type's region is projected too, and that is not a
    detail: the sovereignty control judges the intersection across every type, so adding a
    type without a region removes coverage instead of adding it —
    governance_resource_region_in_eu dropped from pass to not-evaluated on the first
    attempt. access_log is deliberately not mapped: it lives on a separate resource this
    plan does not carry, so loadbalancer_logging_enabled honestly stays unevaluated.

  • Outscale plans now judge API access rules (issue #203).
    iam_apiaccessrule_no_public_cidr came back not-evaluated on the Terraform source
    while the plan carried ip_ranges — a required argument of
    outscale_api_access_rule when no other criterion is given, so always written in the
    HCL. Pépin could not conclude about a 0.0.0.0/0 written in plain sight. Measured on
    the qualification tenant's real plan and confirmed by a --plan-only run, GO, with
    nothing created.

  • Outscale plans can now judge deletion protection (issue #203).
    compute_instance_deletion_protection came back not-evaluated on the Terraform
    source while the plan carried the answer: outscale_vm.deletion_protection is an
    optional argument, so it is written in clear when the author wrote it. The mapping
    did not project it. Measured on the qualification tenant's real plan — the control now
    fails on the deliberately unprotected VM and stays inconclusive on the one with no
    readable environment — and confirmed by a --plan-only qualification run, GO, with
    nothing created and nothing billed.

  • Outscale plans now evaluate access-key expiry and account ownership (issue #203).
    iam_accesskey_expiration_set and iam_no_root_access_key were unevaluated even
    though the plan carries expiration_date and distinguishes an account key from an
    EIM user's key: user_name is null only for the former. The mapping derives
    root_owned from that explicit null, so an ordinary user's key is not mislabeled.
    The checked-in qualification plan now pins the missing-expiry key and the root key
    separately, with the other keys as counterexamples.

  • Scaleway live: a root-owned API key is now found (issue #195).
    iam_no_root_access_key — severity high — could not conclude on either source. The
    data was in the API-key listing the collector already calls: user_id, and
    application_id for a service identity. The naive derivation the issue sketched —
    "a user key is a root key" — would have flagged every member's own key, one false
    positive per person. The real marker is the user's type, literally owner, verified
    against the live API on 2026-09-11; account_root_user_id, carried by the same record,
    designates something else and differs from the owner's id. So the rule joins the key's
    owner to the user of type owner, which is what its contract already said. Both
    ownership fields are projected together: a key belongs to a user or to an
    application, and projecting only the first would silence the control on application
    keys whose ownership is perfectly observed. Confirmed on a real account — where it
    finds a genuine deviation — and by a qualification run, GO with destruction proven.
    Inventory format v11, a pure addition.

  • Scaleway live: a security group's default policy is now collected (issue #195).
    network_securitygroup_default_deny — severity high — came back not-evaluated on
    the live source while the same fault was found on the plan. The gap was not a missing
    API: the collector already paginates /instance/v1/zones/{zone}/security_groups
    to join rules to their group, and that response has carried
    inbound_default_policy all along. Nobody projected it. The contract was verified
    against the real API on 2026-09-11 before a line was written, and the control now
    concludes on both sources — confirmed by a qualification run on a real account, GO with
    its destruction proven. The inventory format moves to v10: a pure addition, the new
    security_group type.

  • Four guards around Terraform default declarations (issue #243, ADR-0024).
    The existing default: transform was already used by security-group rules feeding a
    CRITICAL control, undocumented and unsourced. It also replaces empty strings, so the new
    default_null: transform handles a present null without changing existing mappings.

    • A default on a computed attribute is refused: its silence goes to
      after_unknown, so the plan does not know it, and declaring it would fabricate an
      absent datum (ADR-0014).
    • A default on a required attribute is refused: it can never fire. Four such
      declarations existed on action, written from documentation and never checked against
      the schema — a misleading no-op, now removed.
    • Every default declaration in mapping_terraform cites its provider source,
      checked mechanically. A wrong declaration does not look wrong: it produces a plausible
      verdict.
    • TestNoSpecFabricatesAnAttributeFromNothing now covers the Terraform mapping, which
      it never did — the projection path the issue was about was outside the gate.

    Also: TestProviderMappingsMatchSchema silently skipped any provider whose example
    directory was not initialized, so the Outscale mapping was anchored on no schema at
    all
    , and said nothing. Skips are now named locally, and CI requires a schema for every
    provider with a Terraform mapping. A new to_bool transform keeps a boolean a boolean
    whichever source it comes from, rather than false live and "false" from a plan.
    Provenance also distinguishes an explicit false from a value derived from null,
    while an unknown or unmapped attribute remains distinguishable from both.

Fixed

  • An invalid S3 success response is no longer reported as an empty bucket list.
    A successful HTTP status must contain a readable ListAllMyBucketsResult;
    otherwise the evidence is classified as unreadable, not as a clean account. Bucket
    names and continuation pages are checked, partial observations are retained, and
    cross-resource tagging follows the configured resource types. Sealed assessments
    with a custom policy now replay its relaxations during verify --re-derive.

  • A finding's documentation link points at the page the publication serves, not at a
    redirect
    . Every finding printed blog.stephane-robert.info/…, which answers 301
    towards www.stephane-robert.info/… (measured on 2026-10-30). A reader following the
    link still arrived, but an archived report carried a host nobody controls any more, and
    a redirect that disappears takes the evidence of an audited control with it. The base
    URL is now the served host.

  • A Terraform plan that writes the answer by its silence is now read (issue #243).
    database_encryption_at_rest_enabled returned not-evaluated on every Scaleway plan
    that leaves encryption_at_rest unwritten — while the plan proves the database will be
    created unencrypted. Measured end to end on the ducklake reference tenant:

    before : not-evaluated — "attribut « encryption_at_rest » non collecté (garde de capacité)"
    after  : fail          — "Base de données managée « ducklake » sans chiffrement au repos."
    

    Terraform distinguishes two silences and Pépin conflated them. An optional argument the
    author did not write appears in planned_values with the value null; a value known
    only after apply is absent from that block entirely. Measured across the repository's
    complete plans, cross-checked attribute by attribute against the providers' schemas: 62
    null values, every one of them on an optional attribute that is not computed, zero
    counterexamples
    .

    What a null means is not in the plan — it is what the provider sends to the API when
    the argument is omitted, and that is read in its code. For this one:
    `internal/services/r...

Read more

v0.4.0

Choose a tag to compare

@github-actions github-actions released this 10 Sep 14:42
bccb19b

Fixed

  • The release gate blocked a tag on the absence of an artefact that tag would create.
    Stage 2 runs the container commands extracted from docs/install.md, and that page
    pins the version being released — TestTheInstallPagePinsTheLatestRelease requires
    it, rightly: an install page is the first thing anyone copies, and it must not offer a
    version the repository no longer publishes. But that image does not exist on ghcr.io
    while the gate runs, since the tag is what creates it. Found on the gate's first real
    use, cutting v0.4.0. Stage 2 now verifies the last published tag — which is what it
    actually measures, that the documented procedure works against a real release — and
    writes the substitution into its evidence: a documented command silently rewritten
    no longer proves what the page says.

Added

  • mise run release-gate -- vX.Y.Z — one verdict before a tag, GO or NO-GO, with its
    report
    (issue #178, stages 1 and 4). release-check and the canary each did what
    they said; what the repository had no way to produce was a single verdict, read
    from what a user actually experiences. A one-day external audit found by hand five
    defects that no gate was looking at, and three of them were claims the
    documentation made. So beyond running what already existed as one — preflight,
    audit, adr-drift, falsify:all, a bounded fuzzing campaign, the generated doc
    blocks — stage 1 now measures those claims: no Pépin version pinned in
    docs/install*.md or examples/ predates the minimum
    references/release/pinning.yaml declares safe (and both install pages cite it);
    every relative link in the documentation resolves, anchor included; and the
    binary's opening sentence names exactly the registered providers, measured by
    running it. Stage 4 adds the rule the CHANGELOG header already promised: an
    expected.yaml that moved since the previous tag obliges a CHANGELOG that moved
    too — a verdict changing on an unchanged tenant is what its reader will have to
    explain to an auditor. Each stage writes release-gate/stageN.json and the run ends
    with release-gate/REPORT.md, meant to be attached to the release. Three
    non-negotiable rules: nothing says GO while a stage is red; a skipped stage carries
    a written reason that appears in the report, and a silent --skip is refused;
    and the gate must be able to go red — mise run gate:selftest breaks each rule and
    demands a refusal, and runs inside prepush.

  • Release gate, stage 2 — the artefacts as a user gets them (issue #178). CI proves
    the mechanisms work, on artefacts it builds itself and serves over a loopback. It
    says nothing about the published chain — the signature living at Sigstore, the
    attestation at GitHub, the image on ghcr.io — which can stop verifying without a line
    of this repository moving. Stage 2 rebuilds the binaries with the workflow's own build
    line (they must carry their tag and keep their exit codes), then, against the previous
    tag's real assets: the README's "Verify what you downloaded" block, the cosign verify
    and docker run of docs/install.md, the action's installer — which must accept the
    published binary and refuse the same binary with one byte changed — and the GitLab
    template's before_script in the alpine:3.21 it declares. Those commands are
    extracted from the documentation, never copied into the gate: copying would prove
    the copy works, extracting proves the page works, which is the invariant of ADR-0016. A
    reorganised page turns the gate red instead of passing silently. Each check skips with
    a written reason when its tool is missing — and a stage whose measuring checks were
    all skipped is reported SKIPPED, never GO, because a green that measured nothing is
    the defect this product holds against others.

    The gate also writes release-gate/SUMMARY.md: the verdict alone — check names,
    their verdicts, the date, the commit — meant for the body of the GitHub Release.
    The detailed report is deliberately not published: it carries the maintainer's paths,
    raw tool output and, at stage 3, resource identifiers from a real account, and it
    could not enter checksums.txt anyway, since it is produced locally before the tag
    while the checksums are generated in CI (ADR-0016). A release body is not an artefact
    — it is the same register as the notes it extends, a human claim, unsigned — so the
    verdict adds no new trust promise there. And the gate proves the summary is safe to
    publish: it refuses to call it publishable when it names a path on this machine, says
    so on screen, and stamps the file NON PUBLIABLE.

  • Qualification tenants for Outscale and Exoscale (issue #198). Outscale: 79 Terraform
    resources plus 6 OOS buckets and an inline EIM policy created by the tenant's extra
    hook, applied and destroyed on a real account — the two-NIC machine, the root access
    key, the iam_policy_* family, snapshots, a public OMI, load balancers; the runner
    now applies pre_destroy_vars before destroying (a protected VM does not destroy,
    provider #88) and re-lists until deletions settle. Exoscale: plan-only, 37 resources,
    no account — the Terraform source is pinned, the live half waits for an account.

  • Exoscale qualification tenant, live half (issue #198): 40 resources in the full
    plan, 39 applied (the organisation's quota is four instances; the Swiss instance is
    plan-only through terraform_only_resources) plus 3 SOS buckets created by the
    extra hook (one of them with Object Lock, through the S3 API), applied, scanned
    --live in five formats, sealed, destroyed and proven destroyed across two zones
    (15 API families + buckets, before/after delta). The expected organisation comes
    from PEPIN_QUAL_EXO_ORG and is confirmed by GET /api-key/{key} → org-id
    before any apply. What the live pass found, pinned as measured and filed: SOS
    accepts PutBucketTagging and persists nothing (#208, every SOS bucket fails
    governance_resource_required_tags); kubernetes_cluster_audit_logging_enabled
    passes live on a cluster whose audit is disabled (#209, false green: the API returns
    audit: {} and audit_enabled is derived from audit.endpoint); region is
    projected on no live resource (#210, governance_resource_region_in_eu
    not-evaluated); instance labels are not collected live (#211, an untagged instance
    passes); a private instance carries no security group by construction (#212,
    compute_instance_has_security_group fires with an impossible remediation); every
    SKS cluster creates an sks-ccm-* IAM role that fails two iam_role_* controls
    (#213). The two rule changes of #206 are pinned: …_all_ports is not-applicable
    on Exoscale, network_securitygroup_unrestricted_egress fails on tcp 1-65535.

  • A qualification tenant, applied and destroyed on a real account (issue #178,
    stage 3). PEPIN_GATE_LIVE=1 mise run qualify applies the Terraform stack committed
    under references/qualification/scaleway/ — 40 resources in the plan, 29 of them
    applied: the five types a live scan collects; managed databases, private networks
    and IAM policies exist only in the plan, because no live scan would see them —,
    one fault per resource, one counterexample per control, scans it with --live in every format, seals and
    verifies the bundle, scans the same plan with --terraform, destroys it, proves the
    destruction (a listing per family on the tenant's tag, plus a before/after diff of
    the account), and compares both assessments with the committed expected.yaml
    (control × source × subject → status). The runner refuses to start on an account
    other than the one pinned there, and breaks one of its own expectations at the end
    of every run to prove it can say NO-GO. A maintainer's gesture with native
    credentials only, never CI.

Security

  • A shared evidence bundle no longer names a person. iam_user.username is mapped
    from email at both Scaleway and Exoscale, so an MFA finding's subject was an e-mail
    address — and it travelled verbatim into assessment.json, the OSCAL, the SARIF and
    the sealed input.json. A bundle is meant to be handed to a third party: the tool
    was putting personal data in it without anyone deciding to. --redact, already the
    "for a third party" switch, now substitutes those subjects with the user's stable
    identifier
    , in the inventory, in the sealed assessment and in the evidence line that
    quotes them. The address is not dropped — an operator fixing an MFA needs to know who —
    the local report is unchanged; only what leaves the perimeter is. Which attribute
    names a person is declared in the provider descriptor with its source, never a
    hard-coded list in the CLI.
  • A collector no longer reads back a request it has just put a secret into. CodeQL
    reported, at high, a secret key reaching a published report: a collector set its
    credential as a header, then rebuilt the call signature from that same request object
    to record it as provenance. The alert is a false positive — only method, scheme,
    host and path are read, never a header or a query — but the analysis is right in
    principle, and a string built before the credential is attached cannot become wrong
    later. The signature is now computed before authentication is applied, in one
    shared helper used by the three collectors that record it. Provenance still never names
    a call that did not happen: the string is computed early and used only after a response.
  • verify no longer accepts a bundle that contradicts itself. Rewriting four
    fail results into pass and recomputing the digest of the file touched produced a
    bundle reported as "internally consistent", exit 0 — while its own manifest.json
    still announced "fail": 4. The bundle already carried the inform...
Read more

v0.3.0

Choose a tag to compare

@github-actions github-actions released this 21 Aug 06:00
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 modul...

Read more

v0.2.0

Choose a tag to compare

@github-actions github-actions released this 19 Aug 14:53
a02e42d

Added

  • Pépin is bilingual, and detects the language. Reports, verdict, help,
    errors and the parsable formats (json, sarif, oscal, assessment) come
    out in French or in English. Resolution order:
    --lang=fr|en → PEPIN_LANG → LC_ALL → LANG → fallback en; the first
    non-empty source decides, and an unknown locale falls back to English without
    an error. Until now the skeleton was English and the content French, so a
    reader got a report in two languages within one sentence.
    French remains the reference language of the normative content: the reference
    and the rules are written in French first, and where a legal reading is at
    stake it is the French wording of a control that governs.

  • The project has a mark. docs/assets/brand/ holds the icon and the
    lockups in SVG and PNG, light, dark and monochrome, with the generators that
    produce them (scripts/generer-marque.py, scripts/generer-png-marque.py)
    and the usage rules in docs/brand.md. Both READMEs open on it.

Changed

  • A finding's prose changes with the language, its keys do not. Codes
    (CLD-*), check identifiers, severities, statuses, subjects and exit codes are
    identical in both languages; titles, messages, remediations and evidence are
    translated. A pipeline that diffs report text between runs should pin
    PEPIN_LANG. A pipeline keyed on codes and statuses is unaffected.

  • A sealed bundle carries the language of the scan that produced it.
    verify --re-derive replays the rules in both languages and accepts either
    match, so verifying a French bundle from an English shell is not reported as a
    falsification. Note that the bundle digest does depend on the language, since
    the assessment's prose is part of what is sealed.

  • CLI surface v1 → v2: the persistent --lang flag is added. Pure addition —
    no verb, no other flag and no exit code moved.

  • docs/doc-cache-brief.md moves out of the product documentation. It was a
    maintainer's memo addressing a machine ("already downloaded on this machine"),
    describing a cache a clone cannot have, linked from nowhere, and carrying six
    absolute paths into a home directory. What it held that was worth keeping
    moves to references/docs/README.md, beside the sources.yaml it describes --
    including the trap that matters most: the documentation is not the contract.

Fixed

  • The published action installs again. The provenance check added in 0.1.0
    called gh attestation verify without a token; gh refuses to run in a
    workflow without GH_TOKEN, so the installer treated every binary as
    unverifiable and refused it -- for every consumer, on both 0.1.0 and 0.1.1.
    The action now supplies github.token itself: nobody should have to wire up a
    token to install a binary.

    The gap that let it ship is worth naming. The pull-request job served
    install.sh over a loopback with the attestation check skipped, so the public
    path was never exercised until the post-publication job ran -- after the tag
    existed. A job now calls the action against an already-published version on
    every pull request.

v0.1.1

Choose a tag to compare

@github-actions github-actions released this 19 Aug 12:47
983cbb8

Fixed

  • A Scaleway instance whose security group is created by the same plan is no
    longer reported CRITICAL "VM without a security group".
    At plan time
    security_group_id is unknown after apply, so it is absent from
    planned_values; the list transform then fabricated an empty collection,
    which satisfied the rule's capability guard — the guard that exists precisely
    to prevent this. A collection transform now only runs when the source key
    actually exists. Absent means the source does not expose the information;
    present-and-empty is information.

    This changes a verdict on an unchanged tenant: the control moves from fail
    to not-evaluated on a Terraform plan. On a plan, an instance genuinely
    without a security group is indistinguishable from one whose group is not yet
    known, so Pépin now says so instead of guessing. The live path benefits too,
    where an API omitting a key produced the same fabricated [].

    Found by replaying fifteen third-party Terraform stacks against the binary.

  • The documentation drift gate now compiles what it measures. It reused a
    ./pepin already present at the repository root, so a stale binary could
    validate stale pages — it did, reporting "up to date" while the docs still
    advertised the finding above.

Added

  • Product documentation, generated rather than transcribed. Six pages in
    English with synchronised French counterparts: a five-minute quickstart that
    needs no cloud account, the assessment model (pass / fail /
    not-applicable / not-evaluated), the provider × control coverage matrix,
    known limitations, a commented walkthrough of a real scan, and the exact scope
    and non-goals. Every command output is captured from a real run of the binary,
    the coverage matrix is computed from the reference and the provider
    descriptors, and a CI gate fails when either drifts.

  • Fuzzing over untrusted inputs — FuzzParsePlan and FuzzInventoryWalk,
    covering the Terraform plan and inventory export paths. It immediately found a
    resource with an empty type entering the model, now rejected and kept as a
    regression.

Security

  • SECURITY.md now links its private reporting channel instead of only
    describing it.

v0.1.0

Choose a tag to compare

@github-actions github-actions released this 19 Aug 10:09

Security

  • Policies loaded at runtime no longer get network access. --policy-dir
    compiled third-party Rego with OPA's default capabilities, http.send
    included, so an eight-line rule could POST the evaluated inventory — instance
    user-data, IAM policy documents, bucket policies — to an arbitrary host, or
    reach the runner's internal network from inside the scanner. Fixed upstream in
    scankit v0.2.2; a policy calling one of those builtins now fails to compile.
    Policy evaluation also gets a five-minute deadline.
  • Provider credentials no longer survive an HTTP redirect. Go strips only
    Authorization, Cookie and WWW-Authenticate across domains — not
    X-Auth-Token (the Scaleway secret key) nor AccessKey/SecretKey
    (Outscale). One 302 toward a controlled host handed them over. The collection
    client no longer follows redirects.
  • pepin verify no longer reads outside its bundle. Artifact names came
    from the manifest, supplied by the audited third party, so ../secret turned
    verification into an existence-and-content oracle. Names must be plain
    basenames.
  • --seal --redact no longer ships the tenant's keys. Redaction covered
    free-form documents only, while access_key is a first-class attribute of the
    normalized model and password/certificate come from managed databases.
  • Toolchain moved to Go 1.26.6, which resolves five standard-library
    advisories reachable from this code (net/url, crypto/tls, encoding/xml,
    encoding/asn1, net/http).
  • The published action verifies authenticity, not just integrity. The binary
    and checksums.txt come from the same origin, so whoever can replace release
    assets replaces both. install.sh now verifies build provenance via
    gh attestation verify.

Fixed

Every item below can change a verdict on an unchanged tenant.

  • A scan that measured nothing no longer exits 0. Expired credentials,
    insufficient rights or a truncated inventory produced the same empty result as
    a clean tenant, and the CI gate went green on a scope never looked at. Exit
    code 3 now says so without requiring --strict.
  • Fourteen controls no longer report pass without the deciding data. The
    capability gate gained thirteen entries, and an empty collection no longer
    counts as collected — the IAM collector always sets statements, at [] when
    a document fails to parse, so four critical/high controls concluded
    "compliant" over zero information.
  • authenticated-read and AuthenticatedUsers are detected as public
    exposure: both grant read access to every authenticated user of the platform,
    which is cross-tenant.
  • A bucket made public by an inline acl on scaleway_object_bucket is
    collected at last; it previously produced zero findings and a "compliant"
    verdict.
  • Booleans arriving as strings are honoured. A Terraform plan renders some
    schema attributes as "true"/"false", and == false is simply false for
    "false"; 25 comparisons across 16 rules now go through truthy().
  • An uncatalogued region is reported instead of silently passing: the
    classification tables are allow-lists, so their silence read as "in the EU".
  • Network normalization: -1, any and an empty protocol all mean "every
    protocol", and a scalar where the model expects a list no longer makes the
    rule undefined — an export carrying "cidrs": "0.0.0.0/0" went unreported.
  • CLD-CHF-2 severities aligned on high across its three controls;
    severity drives the CI gate, and the split was unjustified.

Added

  • The public surface is frozen by tests, not by prose. The CLI's verbs,
    flags and exit codes, the --format json findings document, the assessment
    document and the evidence-bundle layout each have a committed fixture under
    cmd/testdata/frozen/ — the field tree, never a value. A shape that moves
    without its fixture fails CI; a fixture regenerated without its declared
    version moving fails CI too. The bundle's version travels on the wire as the
    /vN suffix of format in manifest.json; a verifier that meets a version
    it does not know should stop rather than guess.
  • The SCSL index is watched for drift. mise run scsl-drift compares the
    live framework-scsl index against a baseline committed in
    referentiel/scsl-baseline.json and exits 2 when a CLD requirement was
    added, removed or rewritten upstream without a human retriaging the
    mappings. Note the tooling exit convention (0 ok, 1 error, 2 drift)
    is deliberately distinct from pepin scan's (where 2 is a technical error).
  • A release is refused before the tag, not regretted after it.
    mise run release-check -- vX.Y.Z replays offline everything that must
    hold: clean tree on main, a free tag, tests and referential coherence,
    zero SCSL drift, the exit codes answered by the built binary rather than
    read from a constant, a sealed bundle that verifies, re-derives and
    refuses itself once tampered with
    , the version the Conventional Commits
    imply (.cz.toml), and both CHANGELOGs carrying the section the release
    body is read from.
  • A tag builds, attests and signs the release.
    .github/workflows/release.yml builds linux/darwin × amd64/arm64
    binaries with the tag stamped in, generates SHA-256 checksums and a
    CycloneDX SBOM, records SLSA build provenance, signs the checksums with
    keyless Cosign, and publishes the GitHub Release with this file's matching
    section as its body.
  • A container image (ghcr.io/stephrobert/pepin, one tag per release, no
    latest): the released linux binaries on a distroless base pinned by
    digest — CA roots for --live's TLS, user 65532, no shell. Nothing is
    compiled in the Dockerfile, so the release's checksums, SBOM and provenance
    describe the image's content too; the image carries its own SLSA
    provenance, SBOM attestation and keyless signature, and the release refuses
    an image whose pepin version is not the tag or whose exit codes moved
    through docker run.
  • A composite GitHub action (.github/actions/pepin-scan) that verifies
    the downloaded binary's SHA-256 against the release's checksum list before
    running it, scans a Terraform plan, an inventory or the live API, and turns
    the exit codes into a gate: fail-on-nonconformity: 'false' downgrades a
    non-compliant verdict (1, or 3 under strict) to a warning, and never
    downgrades a technical error (2). Credentials are never action inputs; the
    provider's native variables come from env:. CI corrupts one byte of the
    download and requires the refusal (entrypoints.yml), and every release
    replays the action against its own published artefacts.
  • A GitLab CI template and CI examples
    (examples/gitlab-ci/, examples/github-actions/): same verified
    download, same exit-code contract, report-only via
    allow_failure: exit_codes: [1, 3] — never 2. Installation and
    verification for all four entry points are documented in
    docs/install.md / docs/install.fr.md.