This release is a pre-release and may not be stable for production use.
TBA WIMSE interop tests
This interoperability project contains the WIMSE scenario definitions, peer execution plans, and rules for counting combinations.
See the interop guide for the full 161,370-ID inventory, hosted results, and current peer qualification.
| File | Purpose |
|---|---|
| Coverage workbook | Factor levels, raw Cartesian matrix, and planned runs |
| Scenario matrix | Scenario variants, expected decisions, and observable effects |
| Execution matrix | Candidate peers, versions, roles, and directions |
| Factor catalog | Factor levels and required pairings, bundled in the wheel |
| Exclusions | Incompatible combinations, bundled in the wheel |
| Scenario catalog | Named hops, variants, expected event order, decisions, and effects |
| Peer catalog | Endpoint capabilities by implementation, role, profile, and identifier scheme |
| All-TbA baseline plan | Native role readiness, package work, and matrix changes for TbA-only flows |
| Full runtime closure plan | Counted delivery tranches and evidence required for the 142,844-ID inventory |
| Per-ID blocker report | Runtime and published IDs, historical evidence, and binding gaps |
| External peer access | Public artifacts and sandbox dependencies for proposed peers |
| RICH and nine-hop candidate inventory | The 161,370-ID additive matrix |
| Nine-hop qualification | Generation command and contracts for running the named success case |
From this package directory, run uv run tba-tests-interop-wimse. After installing the wheel, run tba-tests-interop-wimse or python -m tba_tests_interop_wimse. The command loads the TOML files from the installed package.
The bundled catalogs declare their schema with the SemVer string schema_version = "1.0.0". The loader accepts that exact version. Advance the schema version when the catalog format changes, and update the loader to support it.
Give each factor a stable key under [factors.<key>], a display name, and a list of levels. Each rule has an id, a basis, and a when predicate. When it matches, the requires predicate must hold or the excludes predicate must be false. Predicates can test a factor's level with { factor = "tls", in = ["WIC mutual TLS"] } or combine predicates using all, any, and not. Keep expected denials in the scenario matrix when a request can occur and the verifier is expected to reject it.
The default command reports scenario families, endpoint capabilities, structural scenarios, and pending and qualified execution rows. Use --json to export the generated data and --legacy-count to reproduce the flat workbook count. The workbook's Generated Scenarios, Generated Executions, and Peer Capabilities sheets reflect the scoped model. Its Cartesian Matrix and Planned Runs sheets preserve the earlier flat model.
The generator expands authentication settings and issuer modes on each named hop. A terminating or chained call joins the receiving implementation on one hop to the calling implementation on the next. Its scenario variants define the fault target and ordered events. In the bearer fixture, a denied provider call stays in scope when the expected trace has no release. If a structurally valid scenario lacks a matching peer chain, it remains in Generated Scenarios without an execution row.
Qualify a peer capability by entering an exact version and evidence. A capability covers one profile, one role, and one identifier scheme. To qualify issuer or other support roles, add an entry under qualified_support in peers.toml keyed by the role reported in the execution output. Each entry must include its implementation, version, and evidence. Both endpoint capabilities and all support roles must qualify before an execution row qualifies.
Qualification also requires a configuration pin on each capability and support role, and a passing [[baselines]] record for each ordered caller/receiver pair. Each baseline has outcome = "pass", an evidence reference, and caller and receiver tables with implementation, version, configuration, profile, and identifier scheme.
Each hop profile declares application_proof in factors.toml with one of three levels: None, WPT, or HTTP Message Signatures. Generated scenario hops expose the same field and the execution workbook displays it as Application proof per hop. The generated proof field retains the earlier combined credential and proof labels for existing consumers.
The hop catalog defines five interaction types and the rules for composing them. Run tba-tests-interop-wimse --hop-matrix to reproduce the 155-row hop sequence matrix. Add --json for the type definitions and composition rules.
The matrix enumerates all ordered type sequences of length one through three. Mapped rows already link to structural scenarios. Proposed rows have a concrete example awaiting a modeled scenario and execution support. Unreviewed rows still need an applicability decision. The binding gaps on unmapped rows describe the roles and inputs that must be declared. A zero candidate count on an unmapped row measures the current catalog and leaves its applicability undecided.
Supply --peer-snapshot PATH to count qualified runs in a lab snapshot. To verify which runs actually passed, audit the matching JUnit report with --audit-peer-junit.
The peer catalog records external integration candidates under [implementations]. Add --include-candidates to the hop plan to expand proposed endpoint profiles and explicitly modeled support operations. The expanded hop and peer matrix counts them by sequence. The proposal overlay preserves existing qualified bindings. Proposed endpoints and support roles require their own runtime evidence.
Run tba-tests-interop-wimse --expand-hops --peer-snapshot PATH for the constrained execution plan. The planner evaluates every sequence against the lab operations in hops.toml. A flow needs a declared initial input, allowed operation transitions, and a complete final operation. Compatible workload pairs use the snapshot's profile and issuer options. A workload role keeps the same endpoint pin throughout its flow. Support operations use the declared lab roles and can require the TbA implementation or a specific profile on the next call.
Each admitted assignment gets a success control and one case per applicable refusal. A refusal stops the flow at its decision hop with zero effects. For this lab plan, operations that can commit an effect wait for the final authorization before doing so. The planner reuses the existing scenario catalog for bare one- and two-call flows. Add --json to export every new planned execution ID, its ordered hop bindings, and its oracle. Planned IDs need runtime adapters and outcome evidence. A sequence excluded by these lab contracts can become eligible when new contracts are added.
From this package directory, export every workload and typed-hop ID against the same qualification snapshot you will use for pytest.
$env:TBA_WIMSE_PEER_SNAPSHOT = (Resolve-Path path/to/qualification.json).Path
$env:TBA_WIMSE_EXPANDED = "1"
tba-tests-interop-wimse --expand-hops --include-candidates --peer-snapshot $env:TBA_WIMSE_PEER_SNAPSHOT --json > matrix/expanded-executions.json
python -m pytest -o junit_family=xunit1 tests/peer/test_candidate_executions.py --junitxml=matrix/expanded-results.xml
tba-tests-interop-wimse --expand-hops --include-candidates --peer-snapshot $env:TBA_WIMSE_PEER_SNAPSHOT --audit-peer-junit matrix/expanded-results.xml
Set TBA_WIMSE_EXECUTION_ID to a full ID from workload_executions or planned_executions to run one case. The full suite uses the peer lab prerequisites below for qualified workload runs. Typed adapters register under their ordered operation path and must match the assigned bindings before returning observed reached hops, decision hop, result, and effects. The included local adapters cover stand-alone status and delegation. Missing bindings produce a per-ID blocked result. The JUnit audit requires individual pass evidence for the entire plan and returns a nonzero exit code when any ID is blocked, failed, or missing.
Set TBA_WIMSE_HOP_PATH=call,call,call with expanded collection enabled to select the three-workload-call flow. The chain uses the pinned peer lab and requires a qualified directional baseline and issuer for every call. A single request starts the chain, and authenticated intermediate receivers forward it. The final workload owns the only write. The report includes the HTTP decision at each reached hop and the observed ledger count.
Add --include-native to the expanded export or audit and set TBA_WIMSE_INCLUDE_NATIVE=1 for pytest to include the all-TbA runs. With the Cred qualification snapshot and --include-candidates, the combined manifest contains 142,844 distinct IDs. The sequence counts include native workload and typed runs. Set TBA_WIMSE_FROZEN_MANIFEST to the combined manifest to require the runner to reproduce every frozen ID from the selected snapshot before collection. The plan counts a shared local-only scenario once. Native X.509-SVID and WIT-SVID issuer names and the TbA replacements for external support services denote planned bindings.
The native three-workload-call adapter uses separately configured TbA endpoints with baseline issuers. Its runtime snapshot must carry the digest of the current TbA fixture source. Generate a fresh snapshot after changes to those sources and use the same snapshot to generate IDs, run pytest, and audit JUnit. New issuer and support-role adapters need independent runtime evidence before their IDs can pass.
With the peer lab dependencies loaded, python tests/run_three_call_batch.py --help shows how to run the remaining existing-peer three-call cases from the frozen snapshot and prior pilot report. The driver records its selected IDs, writes each observed result to attempts.jsonl as it runs, and writes JUnit on completion. Use python tests/expanded_blockers.py --help to refresh the per-ID blocker export from the published manifest, pinned snapshots and runtime reports, and the live attempt log.
The native WIT-SVID controls exercise TbA issuance and presentation across six proof and transport profiles. They are component evidence for the issuer integration and are kept separate from candidate execution results.
After refreshing the pinned peer snapshot, collect JUnit evidence from the native WIT-SVID issuer controls for that runtime, using -o junit_family=xunit1. Pass the resulting XML and snapshot to python tests/run_native_wit_svid_batch.py --help for the arguments to run the 16,710 native WIT-SVID-only cases. The driver checks the six issuer controls, records the runtime snapshot and selected IDs, and audits the one-, two-, and three-hop results against that snapshot. Set TBA_WIMSE_NATIVE_WIT_ONLY=1 with expanded native collection enabled to select the same scope from pytest.
For the 6,261 X.509-SVID-only cases, collect the native X.509-SVID issuer control JUnit report and pass it with the pinned snapshot to the same driver with --issuer tba-x509-svid. The runtime uses freshly minted TbA X.509-SVIDs on the selected SPIFFE mTLS hops, with the baseline application-proof issuer where applicable. TBA_WIMSE_NATIVE_ISSUER=tba-x509-svid selects this scope from pytest.
For the 23,878 cases using both native issuers, collect the combined issuer controls and both component control reports against the same fixture version. Pass the combined JUnit report as --controls, the two component reports as --wit-controls and --x509-controls, and select --issuer combined. The scope includes both credentials on the same request and credentials used on separate hops in the same flow. TBA_WIMSE_NATIVE_ISSUER=combined selects this scope from pytest.
Use python tests/run_typed_service_batch.py --help for the 21,140 typed service cases. Run with --qualify first to check each operation path and outcome with its assigned native or existing peer bindings. Pass the resulting JUnit file as --qualification-results to run the entire slice against the same pinned snapshot. The suite uses the local status, delegation, exchange, and bearer services and the pinned SPIRE Agent Workload API. The agent returns the workload certificate, key, and bundle used by the next call. The results record reached hops, stop reasons, and resource effects per ID.
Use the same runner with --native-acquisition for the 627 native credential-acquisition executions. Install grpcio==1.85.1 and protobuf==7.36.2 in the test environment alongside the TbA workspace packages. The TbA fixture implements FetchX509SVID over a loopback gRPC stream. It derives workload selectors from mutually authenticated fixture certificates. This setup qualifies the X.509 acquisition flow on Windows without depending on platform-specific process attestation. The workload uses the returned certificate, key, and bundle for the next mTLS call. The evidence records both the SHA-256 fingerprint returned by the Workload API and the fingerprint observed by the receiver.
Use --specialized-acquisition for the 105 native executions where that mTLS call depends on a terminal policy decision. The local services cover issuer and holder revocation, revocation before commit, delegation status, and approval display verification. The workload receiver writes to its ledger only after an allow decision. The same --qualify and --qualification-results steps apply to this tranche.
To run the 728 short native workload cases with baseline credentials, capture JUnit evidence from the native baseline workload controls using -o junit_family=xunit1. Pass that evidence as --controls to tests/run_native_baseline_workload_batch.py with --snapshot pointing to the current pinned peer snapshot and --output to a new result directory. These cases exercise the existing scenario oracles for the enforcing hop, event order, writes, and releases.
Use tests/run_native_baseline_policy_batch.py for the 2,396 specialized flows with baseline credentials. Supply the baseline profile JUnit file as --profile-controls and the current peer snapshot as --snapshot. Run --qualify first, then supply its JUnit report as --qualification-results for the full tranche. The loopback services run transaction-token issuance, delegation receipt verification, and terminal policy checks with the existing workload fixtures.
Add --svids, --wit-controls, --x509-controls, and --combined-controls to the same runner for the 8,775 specialized flows that use native SVIDs. Supply the WIT-SVID, X.509-SVID, and combined issuer JUnit reports for the pinned runtime. The per-ID runtime trace includes the fingerprint and verification outcome for each native SVID seen by a receiver.
Use tests/run_go_spiffe_batch.py for the external SPIFFE workload cases. Build the pinned module in tests/support/go_spiffe_bridge/ for the host and for Linux. The Linux binary checks credential acquisition directly against the local SPIRE Agent. The host binary independently verifies the presented X.509-SVID and SPIFFE ID in the shared mTLS fixture. Install the locked dependencies for tests/support/defakto_bridge/ with npm ci --ignore-scripts, then pass its verify.mjs as --defakto-bridge to qualify Defakto's SDK verification and select Defakto-only and mixed go-spiffe cases. The optional external support services remain separate qualification dependencies.
Install the locked dependencies in tests/support/emilia_bridge/ with npm ci --ignore-scripts and pass check.mjs as --emilia-bridge to select the 64 go-spiffe and Defakto workloads that require the EMILIA service. The runner qualifies Gate's provider-entry allow and refusal behavior before it runs the workload cases.
Generated scenarios and peer runs expose hop_count and hop_sequence_id for the workload calls explicitly modeled by that row. A status lookup or provider call handled inside a current fixture does not become an extra hop in this report until modeled as an explicit arrow. The existing peer join expands mapped scenarios into executions. The flat catalog's second_hop factor still describes an authentication profile and has no role in multiplying hop type sequences into peer runs.
Verification
Dispatch full-matrix.yml for the 161,370-ID inventory on GitHub-hosted
Ubuntu. It runs the 142,844 baseline and 12,288 named nine-hop executions in
parallel. The aggregate artifact full-wimse-matrix-results reconciles every
published ID. The 6,238 generic RICH cases run in the baseline shards after
four live directional controls qualify the pinned Research and Coordinator
proof adapters. The report records unavailable companion endpoints and
support operations with their assigned roles and hop sequences.
Use the frozen manifest to check the 142,844-ID inventory, including native TbA-to-TbA and external peer cases. Run peer components and matrix executions against pinned endpoints. Keep qualification controls separate from per-ID execution results.
The following paragraph records the original spreadsheet snapshot and its qualification status. Current results and blockers are in the hosted run summary.
The 3,148 structural keys are exhaustive for the options declared by the current templates. The 20 flat axes are retained for comparison and are not all active independent axes in the templates. Runtime adapters and qualifying evidence for the remaining profiles and families are pending. No external peer pair is qualified. The spreadsheet is a snapshot of the current candidate inventory.
Candidate peer runs
Run either side of the WIC/mTLS fixture
Install the package with the wic extra using the selected TbA wheels. For
example, with a fixture wheelhouse use
pip install --no-index --find-links ./wheelhouse "tba-tests-interop-wimse[wic]==0.4.0.dev2".
The Python API exposes WicCaller, WicReceiver, and WorkloadVerifier from
tba_tests_interop_wimse.wic. WorkloadVerifier accepts a certificate status
provider. WicReceiver accepts a resource implementing commit(identity)
and snapshot() and defaults to an in-memory ledger.
Give each role a JSON configuration with its own leaf and key, the TLS trust anchor, its expected peer URI, and explicitly approved peer leaf certificates. The fixture currently accepts direct issuance by the configured domain anchor. Example caller configuration:
{
"tls": {
"certificate": "caller.pem",
"private_key": "caller.key",
"trust_anchor": "test-ca.pem"
},
"expected_peer": "wimse://example.org/receiver",
"domain_anchors": {"example.org": "test-ca.pem"},
"good_certificates": ["receiver.pem"],
"host": "127.0.0.1",
"port": 8443,
"dns_name": "receiver.example.org"
}
For the receiver configuration, supply its leaf and key, the expected caller
URI, and the caller certificate under good_certificates. Match the server
leaf's DNS SAN to the caller's dns_name. Run:
tba-wimse-wic-fixture receive receiver.json
tba-wimse-wic-fixture call caller.json
tba-wimse-wic-fixture readback caller.json
The receiver listens on loopback and prints its port as JSON. Use "port": 0
to allocate one automatically. A partner caller can use its own mTLS client to
send POST /writes and GET /effects. A partner receiver can implement those
same endpoints for the TbA caller. An allowed write returns HTTP 201 and the
authenticated workload URI. Readback returns HTTP 200 and the committed
identities. A workload identity refusal after a TLS handshake returns HTTP 403
from the receiver, or a server-identity denial from the TbA caller. If a
partner receiver provides a different contract, use its own resource readback.
Run either side of the WIT/WPT fixture
Install tba-tests-interop-wimse[wpt] from the selected wheelhouse. Import
WptCaller or WptReceiver from tba_tests_interop_wimse.wpt, or use
tba-wimse-wpt-fixture receive receiver.json, call caller.json, and
readback caller.json. The receiver binds loopback. Both roles share the
WIC fixture's protected write and readback routes. HTTPS authenticates the
server by its DNS name. TbA authenticates the caller using WIT/WPT.
Receiver JSON takes certificate, private_key, dns_name, optional
port (zero selects a port), and trust_by_domain (a map from trust domain
to trusted issuer JWKs). Caller JSON takes host (defaults to loopback),
port, dns_name, trust_anchor, wit_file, and private_key (the PEM
proof key bound to the WIT). TLS file paths and key files are supplied by the
operator. The receiver checks the audience against its configured DNS name,
listening port, and the requested fixture route.
The native interoperability baseline uses TbA for both endpoints with separate TLS, issuer, and proof keys. It exercises all five profiles and all eight profile/scheme configurations in the baseline inventory. The 52 structural rows include positive writes and readback, applicable identity and proof refusals, replay, and the combined-profile identity equality policy. The replay case verifies one committed write and no additional effect from the duplicate.
For WIT/HTTP signatures, use SignatureCaller and SignatureReceiver from
tba_tests_interop_wimse.httpsig. This is the Ed25519, single-signature,
bodyless GET/POST subset of the WIMSE HTTP signature draft -08.
It does not implement signed responses, CONNECT, or the general signature
grammar. For a composition, use CombinedCaller with a WIC verifier and
the selected application caller. Supply both transport credentials and a
client verifier to the receiver. It requires the identities to be equal or
to match an exact configured pair. Use the spiffe-wic extra alongside
wic for SpiffeWicVerifier. The mixed SPIFFE setup keeps the WIT in the
native WIMSE namespace and configures the corresponding pair explicitly.
The SPIFFE client authenticates the expected workload URI after TLS chain
validation. The native WIMSE fixture also validates the TLS DNS name.
Run the candidate inventory
Run tba-tests-interop-wimse --coverage for a JSON inventory of every
structural scenario and peer execution ID. Add --attempts attempts.json
to reconcile peer results. The file is a JSON array with an execution_id,
positive integer attempt, and status per entry. Component tests are
evidence for the behavior they exercise and do not populate this file as
complete execution attempts.
The first component slices are opt-in:
- Set
TBA_WIMSEY_CHECKOUTto a checkout of56b070582f3e380c5006630698fb4ca808c08b04built withcargo build --locked -p wimsey-cli. Runtests/peer/test_wimsey_wic_component.pywith the WIC dependencies and workload certificate fixture available. This pairs the wimsey WIC verifier with TbA's verifier over the shared TLS fixture, recording which engine made the decision at the checked endpoint.tests/peer/test_wimsey_http_signature.pyverifies request signatures in both directions against the same pinned CLI with synthetic inputs. - Set
CRED_SDK_CHECKOUTto the built revision described in the Cred testkit README and make that testkit and its WIT/WPT dependencies available. Runtests/peer/test_baselines.py. This exercises the pinned Cred verifier over loopback HTTP and checks the protected read response for the control, proof refusals, and duplicate presentation.
These checks belong to the external interop evidence track. The fixture manifest identifies them as component bindings. Complete candidate runs still require the pinned endpoint configuration and directional baseline defined in the peer catalog.
From the repository root, run:
python -m pytest pkgs/tba-tests-interop-wimse/tests/peer --collect-only -q
python -m pytest pkgs/tba-tests-interop-wimse/tests/peer -o junit_family=xunit1 --junitxml=peer-runs.xml
For full-inventory validation, report only the candidate execution tests and audit their results against the current catalog:
python -m pytest pkgs/tba-tests-interop-wimse/tests/peer/test_candidate_executions.py -o junit_family=xunit1 --junitxml=candidates.xml
tba-tests-interop-wimse --audit-peer-junit candidates.xml
The audit exits 1 for an incomplete inventory. Use --json with the audit
to include each execution's status and observations.
For a local peer lab run, put the package's src and tests directories
on the Python path and configure TBA_WIMSEY_CHECKOUT and
TBA_WIMSE_PEER_SNAPSHOT (an output JSON path). Run
python -m support.qualification_overlay before pytest. This runs four
positive controls for the native WIMSE and SPIFFE WIC configurations,
in both directions, and captures the exact fixture source and wimsey
binary digests. It also records qualification of the ephemeral direct
test CA for that WIC configuration. The peer suite consumes the snapshot
through the same environment variable. Pass its path to the auditor
with --peer-snapshot so evidence is matched to the pinned execution IDs.
These results describe the pinned local lab configuration.
The direct WIC lab adapter also runs scenarios 09, 10, 11, 13, and 16 with baseline CA trust in both TbA/wimsey directions and both identifier schemes. Peer verifiers run over mutual TLS. The shared test resource owns the application policies, including synthetic delegation status, protected operations, child grants, and tool and build claim checks. The harness checks the rejection reason and reads back the resource ledger over HTTPS after each policy request.
The same lab snapshot qualifies the shared support fixtures for gateway origin handling, token exchange, revocation before effect, shared accounting, approval display, and bearer release. Qualification executes issuer controls in both directions and exercises every supported policy variant before recording a role. The approval fixture verifies the published V5 and R2 vectors from OASNT draft -02 Appendix A against its enrolled test key and fixed clock.
Set TBA_WIMSE_SPIRE=1 when building the snapshot to include the
SPIRE issuer. The lab uses the pinned local SPIRE 1.16.0 server image in a
disposable container with no external network. It exercises server-minted
X.509-SVIDs and their trust bundle. For malformed SAN and foreign domain
cases, it injects a separate fixture leaf into the peer input while keeping
the receiver's SPIRE workload trust pin. The issuer role covers the
server-mint path. Agent attestation and Workload API delivery are outside
that qualification. Cross-domain application issuers, budget and status
authorities, and the bearer provider are local test fixtures.
Set TBA_WIMSE_COMBINED_SIGNATURE=1 to fill the combined-signature
candidate slot for the SPIFFE profile in the lab snapshot. In each direction
the control sends a signed write and independently reads the ledger over
mutual TLS. The wimsey side uses its pinned WIC verifier and HTTP signature
CLI. The shared fixture supplies the HTTPS resource, replay state, and
the mapping between the authenticated SPIFFE identity and the WIMSE WIT.
The controls cover the lab CA and, when enabled, SPIRE server-minted
X.509-SVIDs. Set TBA_WIMSE_SPIRE_WIT=1 alongside
TBA_WIMSE_SPIRE=1 to qualify the separate SPIRE WIT-SVID issuer. The
SPIRE server mints ES256 WIT-SVIDs with SPIFFE subjects, and the fixture
loads the matching WIT authority from the SPIFFE bundle. Separate
ephemeral SPIRE servers provide wrong-anchor and foreign-domain
credentials for denial cases. These controls exercise the SPIRE server
mint interface. Workload API delivery requires its own qualification.
Set TBA_WIMSE_COMBINED_SIGNATURE_WIMSE=1 to qualify the WIMSE URI
variant in both directions. A lab CA issues the WIMSE transport
certificates. The application identity is either a lab-issued WIMSE
WIT or a server-minted SPIFFE WIT-SVID. The latter uses an explicit
mapping from the WIMSE transport identity to the SPIFFE subject.
When the other combined profiles are enabled, the support controls
exercise both orders of the eligible mixed-profile and mixed-identifier
chains.
The combined adapter also covers gateway origin handling, transaction binding, delegated authority, proxy rewrites, cross-domain exchange, revocation before effect, and gateway identity mapping. Its two-hop controls exercise the supported arrangements of WIC-only and combined-signature endpoints. The cross-domain token issuers, status authority, effect store, and proxy handoff use local test fixtures.
Set TBA_WIMSE_COMBINED_WPT=1 to also qualify the SPIFFE combined WPT
candidate slot with wimsey. This builds a small offline command-line
bridge against the pinned wimsey WIT and WPT crates. The bridge receives
the request's Txn-Token and destination access token and uses wimsey's
WPT binding APIs. The suite pins the bridge binary digest in the
qualification snapshot. Both directions exercise the four baseline
and SPIRE issuer combinations. The support controls also cover
chains with WPT, WIC-only, and HTTP-signature hops. The lab harness
provides HTTPS, replay state, the local support services, and ES256
proof signing on the TbA side for SPIRE-minted WIT-SVIDs.
Set TBA_WIMSE_COMBINED_WPT_WIMSE=1 to qualify the WIMSE transport URI
variant in both directions using the same bridge. The lab CA issues
the transport certificates. The application proof uses a lab-issued WIMSE
WIT or a SPIRE server-minted WIT-SVID with a mapped SPIFFE subject.
With the other combined profiles enabled, qualification also exercises
WIMSE and SPIFFE hops together and both orders of the eligible mixed
WPT and HTTP-signature chains.
Set TBA_WIMSE_COFIDE_BRIDGE to the path of the compiled
tests/support/cofide_bridge.go executable to qualify Cofide in the
shared HTTPS lab. Build it in a temporary Go module using the pinned
Cofide checkout at 7984a60105002dc65b31e9cd08572cd5d10ed9d6 as the
replacement for github.com/cofide/wimse-s2s-httpsig-poc. Seed the
temporary module with the checkout's go.mod and go.sum, change its
module name, add a requirement on the replaced module, and build the
bridge with Go 1.25.3. The qualification snapshot pins the resulting
binary digest.
The bridge uses the prototype's Go signing function and its pinned P-256 verification library. The lab profile signs the method, request target, destination authority, WIT, and any applicable authorization or transaction token headers. TbA checks the WIT issuer, freshness, and replay state. The lab uses its own HTTPS endpoints and support services. This qualification covers request signatures with a lab-issued WIT or SPIRE server-minted WIT-SVID.
Set TBA_WIMSE_CRED_CHECKOUT to a clean Cred SDK checkout at
586e1a76f487c2376e0ba0a4687bb2de8d3eb588 with its pinned dependencies
installed. Qualification builds Cred's identity modules and exposes its
demo client's signing function in a temporary adapter beside the snapshot.
The snapshot pins the generated modules and bridge. The adapter uses
Cred's WIT and WPT verification, with the lab supplying HTTPS, replay
state, token issuance and resource effects. Its caller signs the WPT for
the lab request URI and binds any transaction or destination access token.
The same checkout qualifies Cred independently as a second WIT + HTTP
Message Signatures peer alongside Cofide. For draft-08 requests, both
TbA → Cred and Cred → TbA exercise a baseline request, a request with a
valid signed transaction JWT, and a request with a second valid
transaction JWT substituted after signing. Each valid request records
one write. Each substitution fails signature verification and records
zero writes. These controls use direct HTTPS with a lab-issued WIT and
bodyless requests. To run them without building the other peers, run
python -m pytest tests/peer/test_cred_http_signature.py from the
package directory with TBA_WIMSE_CRED_CHECKOUT set.
After the candidate run, use
python -m support.blocker_report snapshot.json candidates.xml to count
remaining blockers. It reports the overlap between missing runtime
adapters, directional baselines, and issuer or support roles, so one row
can appear in several categories. Trust isolation is exercised by
holding the TLS CA fixed and varying the workload identity or its
configured workload anchor.
The native adapter registry is separate from the peer lab registry. The expanded inventory includes native cases with TBA_WIMSE_INCLUDE_NATIVE=1. Rows without a runtime binding appear as skipped.
Pytest collects one item per generated execution ID. A single test function joins each row to its scenario and calls the same runner used by the pilot. The report retains the full execution ID, scenario ID, and runner result. Blocked items are reported as skipped with their reason. A skipped item provides no runtime evidence.
Register real peer bindings in the peer_adapters fixture. An adapter can cover
multiple variants and families. The runner checks qualification, checks adapter
support, reuses setup controls within each worker, and opens an isolated context
for each row. Its setup key must include every setting that affects the control,
including ordered peer and issuer pins, configuration, and topology. Local
reference adapters are separate from the peer lab bindings.
The 31 flat rules remain available for comparison through --legacy-count. In the scoped model, hop layout handles the topology rules. Profile expansion handles WIC URI and issuer applicability. Variant definitions handle transaction, authority, accounting, and event ordering. The peer join handles role and profile matching. The broker trace exclusion stays explicit in exclusions.toml.
| Flat rule IDs | Scoped owner |
|---|---|
chain-hops, direct-hops, gateway-hops, missing-origin-identity |
Named hop lists and gateway variants |
wic-uri-required, wic-uri-inapplicable, issuer-wit, issuer-wic |
Per-hop profile and issuer expansion |
wic-faults, application-faults, identity-comparison, signature-rewrite, token-binding |
Target hop, verification layer, and family profile list |
token-domain, child-grant, human-display, human-effect, protected-read-attempt, read-only-write |
Typed scenario topology and named variants |
shared-accounting, shared-counter |
Shared budget variants and explicit accounting and schedule levels |
bearer-release, post-release, denied-broker-no-release, fail-closed-broker-visible-revocation |
Ordered provider events and the broker trace exclusion |
peer-profile-1 through peer-profile-6 |
Capability matching by profile, scheme, version, and role |
Metadata
Release files for tba-tests-interop-wimse 0.4.0.dev3
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| tba_tests_interop_wimse-0.4.0.dev3.tar.gz | 88.2 kB | With provenance | Details for tba_tests_interop_wimse-0.4.0.dev3.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| tba_tests_interop_wimse-0.4.0.dev3-py3-none-any.whl | Python 3 | none | any | Details for tba_tests_interop_wimse-0.4.0.dev3-py3-none-any.whl |
Total release size: 162.3 kB
Release files / tba_tests_interop_wimse-0.4.0.dev3.tar.gz
| Download URL | tba_tests_interop_wimse-0.4.0.dev3.tar.gz |
|---|---|
| Size | 88.2 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
a33a0278232c99f883142bbedd38562d96ba72ada4901b52f4b4c3d8819387db
|
|
BLAKE2b-256 checksum How to use checksums |
09abd163d6a66bf47e41c4e228d826d6cf5f7644ff5e643670043dd5f0255b8d
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logRelease files / tba_tests_interop_wimse-0.4.0.dev3-py3-none-any.whl
| Download URL | tba_tests_interop_wimse-0.4.0.dev3-py3-none-any.whl |
|---|---|
| Size | 74.1 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
7fe377bf6831c64e2179e06326c287595813cdc5235ec2d2109a416da5d2c45c
|
|
BLAKE2b-256 checksum How to use checksums |
db6fe08a44239b25fd9b389e53674f85b364efaa7c1d3c39a798751164ef78d5
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logSecurity for tba-tests-interop-wimse 0.4.0.dev3
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for tba_tests_interop_wimse-0.4.0.dev3.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.