BlackHart
Go live
Hacks feed/Syscoin Bridge

Syscoin Bridge

June 7, 2026·Syscoin·Bridge Exploit
$10.0M
total loss
Statusrecovered

Why it happened

Attack class: Bridge exploit

A malformed burn was read differently by Syscoin Core and the bridge relay, which released 5 billion SYS that were never burned.

What would have stopped it

  • Make the relay reject any burn that is not in one canonical form.
  • Test both parsers against each other on malformed inputs.

Not scored before the exploit

BlackHart had not scored Syscoin Bridge before this exploit.

An attacker tricked the Syscoin bridge into releasing 5 billion SYS, valued at about $10 million on paper, without burning any real coins first. A malformed transaction on Syscoin's UTXO chain was read one way by Syscoin Core and another way by the bridge relay, which treated it as a burn of native SYS. The amount was far larger than Syscoin's circulating supply, so it could not have been sold anywhere near that value, and no user balances were taken. Syscoin paused the bridge and traced the coins, the attacker returned all 5 billion SYS three days later, and Syscoin burned them to restore the normal supply.

User SYS balancessafe(no user funds taken)
Syscoin cryptography and proofssafe(a parsing bug, not a broken proof)
SYS supplysafe(all 5 billion returned and burned)
UTXO to NEVM bridgedrained(5 billion SYS released; bridge still paused)
Exploit anatomy

A malformed burn on the UTXO chain was accepted by the NEVM relay, and the bridge vault released 5 billion SYS to the attacker's NEVM address, which moved them back to the UTXO chain before returning them all to the recovery address.

The attack in 3 steps. Step 1, Misread burn: Bridge vault on NEVM (bridge). Step 2, Bridge back: Attacker NEVM address (attacker), about $10M reached this step. Step 3, Returned: Syscoin recovery address (exit).

  1. Step 1: Misread burn

  2. Step 2: Bridge back

    • Attacker
      Attacker NEVM address
      5B SYS sent back to the UTXO chain
      split into 4B and 1B
      0x71b216BD...554769
  3. Step 3: Returned

    • Exit
      Syscoin recovery address
      all 5B SYS returned June 10
      burned June 15

Why each step worked

    • Core and relay parsed one burn two waysrelay treated a worthless token burn as native SYS
    • No cap on a single releasemissing controlone relay moved many times the circulating supply
    • Bridge paused and coins tracedexchanges and partners blocked the funds
    • Relay now rejects ambiguous burnsmatching Core change in progress
Full forensic detail

Step-by-step reconstruction, root cause, counterfactuals, remediation, and disclosure timeline.

Exploit anatomy

1.
Shortly after midnight UTC on June 7 the attacker created two worthless test tokens on Syscoin's EVM layer (NEVM) and bridged them to Syscoin's UTXO chain.
2.
At 07:03 UTC the attacker sent a malformed burn transaction on the UTXO chain. Syscoin Core and the NEVM relay read it differently, and the relay treated it as a burn of 5 billion native SYS.
3.
After a series of failed attempts, a relay transaction at 08:19 UTC was accepted and the bridge vault released 5,000,000,000 SYS on NEVM to the attacker's address.
0xd714E791...6D20f9relayTx(uint64,bytes,uint256,uint256[],bytes)tx:0x0021cc76...0a7868
4.
Four minutes later the attacker bridged the 5 billion SYS back to the UTXO chain and split it between two addresses holding about 4 billion and 1 billion SYS. Syscoin paused the bridge and worked with exchanges to block the coins.
5.
On June 10 the attacker returned all 5 billion SYS to Syscoin's official recovery address in two transactions, and on June 15 Syscoin burned the returned coins to an unspendable output, restoring the expected supply.

Root cause

Syscoin's bridge moves SYS between its Bitcoin-style UTXO chain and its EVM layer, NEVM. When a burn happens on one side, a relay contract on NEVM verifies proof of that burn and tells the vault to release the matching amount. Per Syscoin's technical post-mortem, the root cause was a cross-layer interpretation mismatch: Syscoin Core and the NEVM relay parsed the same malformed burn transaction differently. Core treated it as a burn of the attacker's worthless token, while the relay read it as a burn of native SYS, and the vault, which treats that asset as native SYS, released 5 billion coins that had never been burned. Halborn and Syscoin both stress that the cryptography and the proof format were not broken; the failure was in parsing, where two parts of one bridge must agree exactly on what a transaction says. The release dwarfed Syscoin's circulating supply, so the roughly $10 million figure is a notional market value rather than an amount the attacker could have sold. The relay now rejects ambiguous burns, and Syscoin Core is being updated to reject the same pattern consistently.

Prevention analysis

Make the relay reject any burn that is not in one canonical form.

The attack needed Core and the relay to read one transaction two ways. Rejecting ambiguous burns outright, which Syscoin has now deployed, removes the gap.

Test both parsers against each other on malformed inputs.

Differential testing of Core and the relay on deliberately odd transactions would have exposed that they disagreed long before an attacker did.

Cap how much the vault can release in one relay.

A single relay released 5 billion SYS, many times the circulating supply. A per-transaction and daily ceiling would have kept any mistake small.

Similar incidents

Verus-Ethereum Bridge (2026)

The Ethereum side of the Verus bridge read signed data differently from Verus nodes and paid out a transfer that never happened. Same root: two layers of one bridge disagreeing about the same data.

BNB Chain Token Hub (2022)

A flaw in how the bridge checked proofs let an attacker mint 2 million BNB from nothing. Same class: proof parsing, not cryptography, was the weak point.

Nomad Bridge (2022)

Nomad released funds for messages that were never sent. Same outcome: the destination side paid out without a real burn or lock behind it.

Remediation

1.Syscoin paused the bridge on June 7, traced the coins with exchanges and partners, and recovered all 5 billion SYS on June 10.
2.Syscoin burned the returned coins to an unspendable output on June 15, restoring the expected supply.
3.The relay now rejects ambiguous burns, including multi-asset burns with inconsistent data and duplicate asset assignments to one output; a matching Syscoin Core change is being released with fork handling.done
4.The bridge stays paused pending final review; exchanges may resume native SYS deposits where appropriate.pending

Timeline

2026-06-07Attacker begins deploying test tokens on NEVM.
2026-06-07First test token is bridged to the UTXO chain as a probe.
2026-06-07Malformed burn transaction is confirmed on the UTXO chain.
2026-06-07Relay accepts the burn and the vault releases 5 billion SYS on NEVM.
2026-06-07Attacker bridges the 5 billion SYS back to the UTXO chain.
2026-06-07Syscoin posts its incident notice; the bridge is paused.
2026-06-10Attacker returns 1 billion SYS to Syscoin's recovery address.
2026-06-10Attacker returns the remaining 4 billion SYS.
2026-06-15Syscoin burns the returned 5 billion SYS to an unspendable output.
2026-06-15Syscoin publishes its technical post-mortem.
Syscoin Core team (detection, recovery and post-mortem). Halborn (analysis). Exchanges and partners that helped trace and block the coins
Continuous adversarial monitoring

Get your protocol scored across 12 dimensions, or request ongoing coverage.