Repository navigation
Releases
v0.5.1
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 --pubkeyenforces 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
pflagto 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.1identity and GitHub OIDC issuer. Its authenticated Rekor entry useshashedrekordAPI format0.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
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 diffcompares 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:
usepepin verify --pubkeywhen signer authenticity is required. -
Scaleway: the organisation's API-key expiry policy is read (issue #196).
iam_apiaccesspolicy_max_key_expirationwas 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
carriesmax_api_key_expiration_duration, verified against the live API on 2026-09-11.
The control is now active for Scaleway and concludespasson 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_listenerscame backnot-evaluatedon 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 afail, 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_eudropped frompasstonot-evaluatedon the first
attempt.access_logis deliberately not mapped: it lives on a separate resource this
plan does not carry, soloadbalancer_logging_enabledhonestly stays unevaluated. -
Outscale plans now judge API access rules (issue #203).
iam_apiaccessrule_no_public_cidrcame backnot-evaluatedon the Terraform source
while the plan carriedip_ranges— a required argument of
outscale_api_access_rulewhen no other criterion is given, so always written in the
HCL. Pépin could not conclude about a0.0.0.0/0written in plain sight. Measured on
the qualification tenant's real plan and confirmed by a--plan-onlyrun, GO, with
nothing created. -
Outscale plans can now judge deletion protection (issue #203).
compute_instance_deletion_protectioncame backnot-evaluatedon the Terraform
source while the plan carried the answer:outscale_vm.deletion_protectionis 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-onlyqualification run, GO, with
nothing created and nothing billed. -
Outscale plans now evaluate access-key expiry and account ownership (issue #203).
iam_accesskey_expiration_setandiam_no_root_access_keywere unevaluated even
though the plan carriesexpiration_dateand distinguishes an account key from an
EIM user's key:user_nameis null only for the former. The mapping derives
root_ownedfrom 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— severityhigh— could not conclude on either source. The
data was in the API-key listing the collector already calls:user_id, and
application_idfor 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'stype, literallyowner, 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 typeowner, 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 formatv11, a pure addition. -
Scaleway live: a security group's default policy is now collected (issue #195).
network_securitygroup_default_deny— severityhigh— came backnot-evaluatedon
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_policyall 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 tov10: a pure addition, the new
security_grouptype. -
Four guards around Terraform default declarations (issue #243, ADR-0024).
The existingdefault: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
computedattribute 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
requiredattribute is refused: it can never fire. Four such
declarations existed onaction, written from documentation and never checked against
the schema — a misleading no-op, now removed. - Every default declaration in
mapping_terraformcites its provider source,
checked mechanically. A wrong declaration does not look wrong: it produces a plausible
verdict. TestNoSpecFabricatesAnAttributeFromNothingnow covers the Terraform mapping, which
it never did — the projection path the issue was about was outside the gate.
Also:
TestProviderMappingsMatchSchemasilently 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 newto_booltransform keeps a boolean a boolean
whichever source it comes from, rather thanfalselive and"false"from a plan.
Provenance also distinguishes an explicitfalsefrom a value derived fromnull,
while an unknown or unmapped attribute remains distinguishable from both. - A default on a
Fixed
-
An invalid S3 success response is no longer reported as an empty bucket list.
A successful HTTP status must contain a readableListAllMyBucketsResult;
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 duringverify --re-derive. -
A finding's documentation link points at the page the publication serves, not at a
redirect. Every finding printedblog.stephane-robert.info/…, which answers301
towardswww.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_enabledreturnednot-evaluatedon every Scaleway plan
that leavesencryption_at_restunwritten — while the plan proves the database will be
created unencrypted. Measured end to end on theducklakereference 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 inplanned_valueswith the valuenull; 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 anoptionalattribute that is notcomputed, 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...
v0.4.0
Fixed
- The release gate blocked a tag on the absence of an artefact that tag would create.
Stage 2 runs the container commands extracted fromdocs/install.md, and that page
pins the version being released —TestTheInstallPagePinsTheLatestReleaserequires
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-checkand 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*.mdorexamples/predates the minimum
references/release/pinning.yamldeclares 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.yamlthat 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 writesrelease-gate/stageN.jsonand the run ends
withrelease-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--skipis refused;
and the gate must be able to go red —mise run gate:selftestbreaks each rule and
demands a refusal, and runs insideprepush. -
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, thecosign verify
anddocker runofdocs/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'sbefore_scriptin thealpine:3.21it 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 enterchecksums.txtanyway, 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 fileNON 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'sextra
hook, applied and destroyed on a real account — the two-NIC machine, the root access
key, theiam_policy_*family, snapshots, a public OMI, load balancers; the runner
now appliespre_destroy_varsbefore 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 throughterraform_only_resources) plus 3 SOS buckets created by the
extrahook (one of them with Object Lock, through the S3 API), applied, scanned
--livein five formats, sealed, destroyed and proven destroyed across two zones
(15 API families + buckets, before/after delta). The expected organisation comes
fromPEPIN_QUAL_EXO_ORGand is confirmed byGET /api-key/{key}→org-id
before any apply. What the live pass found, pinned as measured and filed: SOS
acceptsPutBucketTaggingand 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: {}andaudit_enabledis derived fromaudit.endpoint);regionis
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_groupfires with an impossible remediation); every
SKS cluster creates ansks-ccm-*IAM role that fails twoiam_role_*controls
(#213). The two rule changes of #206 are pinned:…_all_portsisnot-applicable
on Exoscale,network_securitygroup_unrestricted_egressfails ontcp 1-65535. -
A qualification tenant, applied and destroyed on a real account (issue #178,
stage 3).PEPIN_GATE_LIVE=1 mise run qualifyapplies the Terraform stack committed
underreferences/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--livein 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 committedexpected.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.usernameis mapped
fromemailat both Scaleway and Exoscale, so an MFA finding's subject was an e-mail
address — and it travelled verbatim intoassessment.json, the OSCAL, the SARIF and
the sealedinput.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, athigh, 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. verifyno longer accepts a bundle that contradicts itself. Rewriting four
failresults intopassand recomputing the digest of the file touched produced a
bundle reported as "internally consistent", exit 0 — while its ownmanifest.json
still announced"fail": 4. The bundle already carried the inform...
v0.3.0
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 tracenow records a real--livecollection
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(thenon_observesledger
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 wrongitems:.
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/veracityderives the verdicts that
path can actually reach — three where it can conclude, one where it cannot lift
thepasslock, 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 ininternal/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 indocs/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
gainslabels.tf_file,labels.tf_lineandlabels.tf_module; the SARIF result
gains aphysicalLocationwith aregion, which is what makes a forge annotate the
guiltyresourceblock instead of the plan file. The module is read off the resource
address; the file and the line are measured in the.tfsources beside the plan,
becauseterraform show -jsoncarries neither — verified in Terraform's own source,
where a resource's configuration representation holdsaddress,type,nameand
expressionsand 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 apermissions: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 anot-evaluatedreason 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 acollectionblock
(attempted,complete, a stableerrorclass, the provider's owndetail), 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-evaluatedwith that unit named as its reason — the assessment decides, never
a rule — and the scan returns3, never0. The transition is strictly
directional: apassis withdrawn, afailis kept (an observed deviation stays
observed), anot-applicableis 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 return0, and returns3from 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. Afailcovered by a valid entry becomesexempted, never
pass: the finding stays in--format json, in the SARIF and in the severity
counts,summary.conformestays false, and the verdict readsNON-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--strictgate. The bundle seals
exemptions.json, so the dossier digest depends on what it set aside, and
verify --re-derivereplays 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 parallelprovenanceindex says, for each attribute, where the
value came from —apiwith the request actually served,terraform-planwith
the plan resource type, orderivedfor 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 readattributes.<name>
unchanged, so no verdict can move (measured on nine fixtures × two formats × two
languages: identical findings, statuses and exit codes).--format assessmentnow
exposes, for every control with a deciding attribute, that attribute and its
attestation inevidence.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 incmd/testdata/frozen/inventory.jsonwith 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 underdocs/controls/
(what it concludes, from which source, with which reason when it cannot), a
remediation guide that shows the same control moving fromfailtopasson 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 publicROADMAP.mdreplaces 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...
v0.2.0
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→ fallbacken; 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 indocs/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-derivereplays 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
--langflag is added. Pure addition —
no verb, no other flag and no exit code moved. -
docs/doc-cache-brief.mdmoves 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 toreferences/docs/README.md, beside thesources.yamlit 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
calledgh attestation verifywithout a token;ghrefuses to run in a
workflow withoutGH_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 suppliesgithub.tokenitself: 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.shover 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
Fixed
-
A Scaleway instance whose security group is created by the same plan is no
longer reportedCRITICAL"VM without a security group". At plan time
security_group_idis unknown after apply, so it is absent from
planned_values; thelisttransform 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
tonot-evaluatedon 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
./pepinalready 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 —
FuzzParsePlanandFuzzInventoryWalk,
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.mdnow links its private reporting channel instead of only
describing it.
v0.1.0
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,CookieandWWW-Authenticateacross domains — not
X-Auth-Token(the Scaleway secret key) norAccessKey/SecretKey
(Outscale). One 302 toward a controlled host handed them over. The collection
client no longer follows redirects. pepin verifyno longer reads outside its bundle. Artifact names came
from the manifest, supplied by the audited third party, so../secretturned
verification into an existence-and-content oracle. Names must be plain
basenames.--seal --redactno longer ships the tenant's keys. Redaction covered
free-form documents only, whileaccess_keyis a first-class attribute of the
normalized model andpassword/certificatecome 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
andchecksums.txtcome from the same origin, so whoever can replace release
assets replaces both.install.shnow 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
code3now says so without requiring--strict. - Fourteen controls no longer report
passwithout the deciding data. The
capability gate gained thirteen entries, and an empty collection no longer
counts as collected — the IAM collector always setsstatements, at[]when
a document fails to parse, so four critical/high controls concluded
"compliant" over zero information. authenticated-readandAuthenticatedUsersare 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
aclonscaleway_object_bucketis
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== falseis simply false for
"false"; 25 comparisons across 16 rules now go throughtruthy(). - 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,anyand 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-2severities aligned onhighacross 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 jsonfindings 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
/vNsuffix offormatinmanifest.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-driftcompares the
liveframework-scslindex against a baseline committed in
referentiel/scsl-baseline.jsonand 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 frompepin 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.Zreplays offline everything that must
hold: clean tree onmain, 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.ymlbuildslinux/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 whosepepin versionis not the tag or whose exit codes moved
throughdocker 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 fromenv:. 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.