Find the boundary.
Make it fail.

00 / THE OBJECTIVE

Turn a suspicious path
into a reproducible finding.

I work backward from a consequence: a foreign event becomes trusted, an unsigned range wraps into a valid-looking span, or an approved operation changes between authorization and use. The research starts by writing down the exact invariant the implementation must preserve.

Then I isolate the attacker's control, map each transition, and construct a counterexample. A useful report shows the input, the decision the system made, the consequence inside the tested component, and the evidence another engineer needs to repeat it.

Completed work

Original local binary, parser and authorization studies

Evidence

Source, deterministic fixtures, recorded results, native hashes

Next research

Teleoperation command integrity ↗

01 / THE METHOD

Seven questions.
One chain of evidence.

1. 01

   What outcome matters?

   Define the asset and failure in observable terms. “A foreign emitter creates an admitted research row” is testable. “The protocol is insecure” is too broad to be a finding.

2. 02

   What can the attacker control?

   Name the initial foothold: a supplied byte, a nested event, a proposal argument, a replayed envelope. Keep preconditions explicit. Distinguish a test harness's powers from a real entry point.

3. 03

   Where does data acquire trust?

   Trace parse → normalize → attribute → authorize → commit. Record the exact field, function and state transition that promote the input. Test the value before and after that boundary.

4. 04

   What is the smallest useful primitive?

   Reduce the witness until removing another byte or event changes the result. Keep a valid control beside it. A malformed boolean and a foreign emitter are separate primitives with separate causes.

5. 05

   Can the primitives compose?

   Combine the conditions in the same fixture. Test ordering, retries, stale state, partial failure and restart. Record which precondition enables the next transition; two isolated failures do not prove a chain.

6. 06

   What proves the consequence?

   Capture admitted rows, return values, state diffs or persisted decisions. Preserve source revision, tool version, seed and input hash. A response code alone rarely proves the operation happened.

7. 07

   Does the repair survive the witness?

   Run the same counterexample against the change, then its boundary neighbors and benign controls. Challenge restarts and concurrent use where state matters. Preserve the failed hypothesis as carefully as the successful one.

02 / INPUT → ATTRIBUTION → ADMISSION

Valid-looking bytes.
Wrong authority.

In my event recorder, a noncanonical Borsh boolean became a buy through int(bool(byte)). Separately, matching event bytes could be decoded without identifying the active emitting program. The subscription's transaction-level mention was being asked to prove a property of an individual event.

The public lab isolates these defects in 22 shared vectors. The compound path above is a hypothesis assembled from those primitives; a deployed end-to-end exploit would require its own entry-point and consequence evidence. The existing source review concerns my recorder.

Recorded artifacts: shared vectors · standalone reproduction · model contract.

03 / SOURCE → INSTRUCTIONS → NATIVE RESULT

Prove the arithmetic
beneath the decompiler.

Faultline contrasts two range predicates in original C fixtures, compiled at O0 and O2. With total = 16, offset = 0xffffffff, and count = 2, a wrapping 32-bit sum becomes 1. A permissive predicate accepts the span; the mathematical span exceeds the buffer.

offset + count <= total
+---------------------+
| 0xffffffff + 2 = 1  |  uint32 wrap
+---------------------+

Bounded predicate:
offset <= total && count <= total - offset

Each recorded build evaluates all 256 byte values and 21,728 range triples. The legacy functions show 254 boolean disagreements and 6,855 false range accepts; the corrected functions show zero disagreements on that corpus. Native results are tied to the exact fixture hashes and compared with recovered Ghidra output.

The demonstrated primitive is a false range acceptance. An actual out-of-bounds access would require a caller that uses the accepted span; these pure fixtures stop at the predicate. That separation tells a reviewer exactly which part of a future chain still needs proof.

04 / CHECK → STATE → COMMIT

An allowed tool name
is only the beginning.

Sealbreak tests whether a proposal preserves the exact approved actor, audience, tool, target, complete arguments, validity window and nonce. The attacker controls the proposal and can change one binding, replay a previous envelope, or race repeated attempts.

The recorded local corpus contains 29 scenarios. Its deliberately weak tool-name baseline admits 25 unauthorized proposals; the bound approval gate admits none of those 25 and retains all three benign controls. The remaining case is an unavailable-tool control. A separate 56-test run includes thread and process races, restart, nested-argument changes and time advancing before commit.

The decisive observation is the durable nonce insertion: concurrent attempts sharing a nonce produce one accepted decision. A future executor would still need to bind that decision to the immutable operation and reconcile crashes after acceptance.

05 / CHALLENGE THE RESULT

Give the hypothesis
a way to lose.

A useful experiment includes a condition that disproves it. Repair a parser without rejecting its valid inputs. Change one field while keeping the remaining packet identical. Run the optimized binary against the same independent reference as the debug build. Distinguish an expected rejection from a crash or a test that never reached the boundary.

Separate discovery inputs from evaluation inputs. Publish the seed and the selected edge values. Count exclusions, timeouts and unknown observations. A curated adversarial corpus demonstrates behavior on that corpus; it does not estimate an attacker's success rate in the field.

For statistical search, the same discipline applies. With 3,000 bootstrap draws and a two-sided 0.05 / 729 tail allocation, the expected count is about 0.103 draws per tail. More decimal places cannot supply the missing resolution. The Deflated Sharpe Ratio and Probability of Backtest Overfitting address selection questions; a separate temporal test must establish what the system knew at decision time.

06 / TIMING AS AN INPUT

Break the assumption
between two observations.

A standing stop at 95 does not make 95 executable when the next observation opens below it. Move the opening price to expose how an apparently small model shortcut changes the result.

The observable is the result at the boundary. Spread, intrabar ordering, costs and source timestamps remain independent inputs to a real evaluator. Follow the execution-gap investigation ↗

07 / MISSING STATE

A complete formula
can still miss the constraint.

This local fixture compares a virtual-curve output with available real reserves. Remove observation coverage and the result becomes incomplete even when the arithmetic still works.

The expression is x × q / (y + q). Real reserves cap the displayed bound; an actual transaction can fail rather than partially fill. The fee constants are illustrative inputs, not a current venue quote. The transferable question is simple: which external state can invalidate a numerically correct decision?

08 / SOURCE RECORD

Inspect the machinery.

1. Event trust: model contract and reproduction.

   Canonical boolean, invocation attribution, shared vectors and exact evidence boundary.

2. Faultline: native fixture and Ghidra export.

   Build commands, independent reference, optimization comparison and provenance.

3. Sealbreak: bound authorization and durable replay state.

   Recorded local outcomes, process tests, trusted-host assumptions and integration work.

4. Borsh specification.

   Canonical wire representation for the parser review.

5. Solana logsSubscribe.

   Transaction-level mention filtering and notification fields.

6. Next study: command integrity for teleoperated machines.

   An original proposal and executable local state-machine fixture.

Existing result counts above come from the linked dated artifacts. This October 2026 edition changes the research presentation; it does not turn a recorded local experiment into a new external finding.