Skip to content

v0.5.0

Choose a tag to compare

@github-actions github-actions released this 06 Nov 19:27
· 5 commits to main since this release
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/rdb/instance.go declares encryption_at_rest as TypeBool, Optional
    with no Default, and create always sends
    Encryption: &rdb.EncryptionAtRest{Enabled: d.Get(...)} — so an omitted argument sends
    false explicitly.

  • A throttled object-storage scan no longer reads as an outage, and an unknown key no longer
    as a missing right
    (issue #96). Classify recognizes third-party SDK errors through two
    anonymous interfaces, HTTPStatusCode() and ErrorCode(). It read the status first — and an
    SDK error always exposes its status, so the first branch always returned a class and the
    second was never reached
    . The error code was dead code.

    Measured by driving the S3 specification's error XML through the real AWS SDK client, which
    no test had ever done — the emulator serves no object-storage surface, so the only response
    that branch had ever seen was a 404 carrying no code at all:

    Real S3 response Classified as Should have been
    403 · InvalidAccessKeyId permission_denied unauthenticated
    403 · SignatureDoesNotMatch permission_denied unauthenticated
    503 · SlowDown unavailable rate_limited

    The third is the costliest in practice: a scan the API is merely throttling told the operator
    the service was down, so they waited for an outage that was not happening. The first two sent
    them to widen a policy for a key the provider does not recognize — and they had been doing so
    since the previous release, because the fix that moved those two codes to unauthenticated
    landed in a branch nothing reached.

    The code is now read before the status: the rule ADR-0023 sets for HTTP bodies, applied to the
    SDK path for the same reason. A published contract outranks a convention each provider applies
    its own way. A code the table does not know still falls back to the status, so nothing that
    worked stops working.

    internal/objectstorage/classify_s3_test.go now reaches every class through a real S3 error,
    end to end — SDK decoding, interface recognition, classification. What it does not establish
    is written down: that a given sovereign provider emits a given code in a given case is still
    owed to a real scan.

    No verdict moves on an unchanged tenant — every one of these classes already degraded a
    control to not-evaluated. What changes is which mistake the operator is sent to fix.

  • Scaleway: an unknown credential is no longer reported as a missing right (issue #250).
    Scaleway answers 401 when it does not recognize a key, and a bare 401 was filed
    permission_denied — "insufficient privilege on the scanning account". The canary record
    carried that on six of its seven Scaleway endpoints, while the canary holds no key at
    all. The sentence sent the operator to widen a policy attached to an identity the API does
    not know: the defect #91 fixed for Outscale, one provider along.

    The contract is the official SDK. scw/errors.go demultiplexes the response's type field
    into a Go error type, and it gives the two cases two distinct ones — so this is a compiled
    table, not prose:

    Situation of the scanning account HTTP type Class
    Key unknown, malformed or expired 401 denied_authentication unauthenticated
    Valid key, missing right 403 permissions_denied permission_denied

    The first row is measured (2026-09-21, GET /iam/v1alpha1/users, synthetic key, no account
    involved); the second is the SDK's. Both are mapped, including the one whose status already
    classified it correctly — ADR-0023 holds that the class derives from the documented code
    when one exists, and anchoring half a pair to the contract and half to a convention would
    make the distinction depend on a status that can move while the contract does not.

    Exoscale is deliberately left to its status. Measured the same day, it answers 403
    with {"message":"Invalid key or request signature"} — no type, no code, no structured
    field. The only discriminator would be the message text, which ADR-0023 refuses: a string
    match breaks the first time the wording changes. Its refusal stays broadly and truly
    classified rather than narrowly and brittly. A counterexample guards that decision.

    No verdict moves on an unchanged tenant — a refusal degraded a control to
    not-evaluated before and still does. What changes is which mistake the operator is sent
    to fix.

  • A refusal is no longer reported as an outage, and an unknown key is no longer reported
    as a missing right
    (issue #91). Outscale answers 400 where Scaleway answers 401 and
    Exoscale 403; a 4xx that no finer class claimed fell through to unavailable, so the
    canary record filed all eighteen Outscale endpoints under "service unavailable" —
    every one of which had answered. An operator reading that goes to check a status page
    while the control plane works perfectly.

    The distinction the issue left open — is a 400 a bad signature or a missing right? —
    could not be settled with synthetic credentials, which only ever produce the first. It
    was measured on 2026-09-12 against eu-west-2, with an EIM identity created for the
    measurement carrying only api:ReadVms, then destroyed; an authorized call was played
    first as a witness, so that a refusal could not come from the signature:

    Situation of the scanning account HTTP Type · Code Class
    Access key does not exist 400 InvalidParameterValue · 4120 unauthenticated
    Key exists, invalid signature 401 AccessDenied · 1 unauthenticated
    Valid key, missing right 403 AccessDenied · 4 permission_denied

    Two classes are added to the collection state — unauthenticated (the API did not
    recognize the credentials) and rejected (the API answered and refused the request) —
    and a 4xx is never unavailable again. The status alone cannot carry this: Outscale
    documents its authentication error at 400 and its authorization error at 401
    (official table), so classifying by status
    gets both wrong, in both directions. The error code settles it, and only codes that
    table documents are mapped — the measured 403 · 4 is not among them and is left to its
    status. InvalidAccessKeyId and SignatureDoesNotMatch on the object-storage path move
    to unauthenticated for the same reason: widening a policy does not make an unknown key
    known. No verdict moves on an unchanged tenant — a refusal degraded a control to
    not-evaluated before and still does; what changes is the sentence the operator reads,
    and which mistake it sends them to fix.

    pepin-inventory goes to v14: the schema is unchanged, but the set of values error
    can take is not, and a consumer enumerating them must be told (ADR-0003).

  • Exoscale live now writes the zone it scanned (issue #210).
    governance_resource_region_in_eu returned not-evaluated on every Exoscale
    organisation: no resource carried a region, so the control could never conclude about
    where anything lived. The collector knew the zone all along — it is the --region it
    was given and the host it talks to — but the engine read the variable region where
    Exoscale declares zone (region_key), so every resource came out with an empty
    region. The region now follows the declared key, for every provider. Writing the
    scanned zone asserts nothing unobserved: Exoscale's API is zone-scoped by its host,
    so a scan of de-fra-1 returns only de-fra-1 resources — it is the zone whose API
    answered, not a value inferred. Confirmed by a qualification run on a real account,
    GO, with the control now pass over instances, volumes, snapshots and clusters.

  • The Scaleway qualification tenant refuses to run in the default project (issue
    #240). It applies deliberately exposed resources, and its proof of destruction relies
    on a before/after delta for what carries no tag — which a third-party resource
    moving during the run falsifies, in either direction. At Scaleway the default project
    carries the Organization's ID, cannot be deleted or transferred, and is where
    everything lands when nobody chose. Measured on 2026-09-10: it held a VM from other
    work, started two hours earlier; the run could only proceed after emptying the whole
    account, which is not a procedure. The identity hook now refuses, and says which
    three commands fix it. The project is emptied, never recreated: a reused project
    keeps its consumption history, spends the 25-project quota once, and needs its VPC
    created once (a project created since 13 May 2025 no longer receives a default one).

  • The absent/empty rule is now a gate, not a habit (issue #227, second half). One
    rule governs every attribute a provider spec maps — a key absent from the source
    projects nothing, a key present and empty projects the empty value — and
    TestNoSpecFabricatesAnAttributeFromNothing holds it by pushing an empty item
    through every resource of every descriptor: a single attribute coming out fails the
    build. Its counterexample matters as much: a source that says "none" must still
    project it, or "never fabricate" would be satisfied by projecting nothing ever. Written
    once, mechanically enforced, rather than annotated across 138 attributes nobody
    re-reads — and it applies to providers not written yet. The rule is also stated where
    someone adding a provider will meet it, in both languages.

  • A resource with nothing no longer silences the control looking for it (issue #227).
    The Exoscale qualification tenant contains, deliberately, an instance with no
    security group at all
    — the very deviation compute_instance_has_security_group
    exists to catch. The scan answered not-evaluated: the sealed inventory carried
    security_group_ids: [], but an observed empty list counted as not collected, and
    the per-type intersection then removed the attribute from every instance. The faulty
    resource blinded its own control, and its neighbours with it.

    The fix is not teaching the capability lock to tolerate empty values — that would
    have re-opened ADR-0006's founding incident, because IAMPolicyStatements returned
    [] both for "this document could not be parsed" and for "this policy grants
    nothing"
    . The placeholder is removed at the source: the parser now returns nothing
    when it could not read, the collectors omit the attribute rather than posting an empty
    one, and only then does the lock answer on presence. An observed empty list is a
    complete enumeration that counts zero; nil still establishes nothing.

    Measured: one verdict moves — compute_instance_has_security_group on Exoscale live,
    not-evaluated → pass, and that pass is proven: all four instances carry the
    attribute, and the only empty one is private (#212). Confirmed end to end by two real
    qualification runs, Exoscale and Outscale, both GO.

  • The roadmap announced a version the project had left behind. ROADMAP.md still
    said "Where Pépin stands, v0.2.0" two releases later. For most projects that is a
    detail; for one whose whole claim is that no assertion is worth more than what was
    measured, a page wrong about its own version undermines the rest. The heading is now
    derived from the CHANGELOG — the same source as
    TestTheInstallPagePinsTheLatestRelease, because two sources of truth for one
    question end up disagreeing — and a version that cannot be read leaves the heading
    without a number rather than inventing one (ADR-0014).

Security

  • Toolchain moved to Go 1.26.10, which resolves ten standard-library
    advisories reachable from this code: GO-2026-6809 (crypto/x509, compromised
    intermediate certificates no longer trusted) and GO-2026-6617 (net/http,
    HTTP/2 server crash on an HPACK encoder race), among the ten traces
    govulncheck reported on 1.26.6. The gate was red on main, so nothing was
    committable without it. mise.toml follows go.mod, which is where CI reads
    its own version from, and osv-scanner.toml says which version its exception
    was measured under.

  • Credential-file secrets stay out of normalized inventories. A regression
    test exercises Scaleway and Outscale credential files, authenticates against
    a local API, and verifies that neither the credential value nor an unprojected
    secret field in the response enters the normalized inventory.