EIP-7657 Sync committee slashing conditions (Sync committee slashings)
No call decision · Consensus & staking · EIP status Stagnant · created 2024-03-21
Newly defines rules for slashing (revoking eligibility of) sync committee validators used for light client sync when they engage in malicious behavior such as signing fake block roots.
Why it is needed
Ethereum's light client sync protocol lets applications such as wallets, new beacon nodes, and trust-minimized bridges confirm the latest state without downloading the full chain. This verification relies on trusting the signatures of a 512-member sync committee, but currently there is no rule to punish a sync committee majority that is bribed into signing a fake (non-canonical) finalized header. As a result, an attacker who merely pays the bribery cost can trick light clients into believing an incorrect checkpoint, which can be used to drain bridge funds or manipulate token distribution. Without economic punishment for bribery, the light client protocol was only safe for small-value uses.
What changes
Today
- No punishment rule exists even if a sync committee majority is bribed into signing a fake finalized header
- Light client based bridges and wallets risk losing assets by being fooled by fake updates
- No way to distinguish honest validators who were deceived into following a wrong checkpoint from validators who are actually malicious
After EIP-7657
- Signing different attested_headers at the same slot, different next_sync_committees in the same period, or a non-linear finalized history makes a validator subject to slashing
- An attack requires staking up to SYNC_COMMITTEE_SIZE x MAX_EFFECTIVE_BALANCE (512 x 32 ETH = 16384 ETH on mainnet) worth of stake
- Only simultaneous conflicting signatures are punished, not simply having been secretly bribed into following one side, which protects honest validators who were deceived into syncing to a non-canonical checkpoint
Who is affected
- Developers of light client based bridges and token distribution apps: With economic punishment attached to signature bribery, the light client protocol can be used to protect larger amounts of value.
- Validators selected for the sync committee: Signing conflicting messages twice within the same period or slot can result in slashing, requiring more care in signature management.
- Client and infrastructure teams: Need to separately build a slashing protection DB, validator API, a libp2p mesh for propagating evidence, a Slasher, a Beacon API, and so on.
- Wallet and light client users: Higher trust in the sync protocol allows for more secure state verification.
In depth
Three slashing conditions
process_sync_committee_slashing treats three cases as subject to slashing. First, signing different attested_headers at the same slot. Second, within the same sync committee period, where both attested_header and finalized_header belong to that period, finalizing different next_sync_committees. Third, signing a finalized_header that, based on recent_finalized_block_root, does not match the actual finalized history (a linear chain). Simply signing an alternative but internally consistent history is not subject to slashing; only 'non-linear' signatures, where two different chains are each signed once without internal contradiction, are punished.
Structure of the evidence container
SyncCommitteeSlashingEvidence consists of the attested_header and the next_sync_committee contained in its state (plus its merkle path), the finalized_header (plus finality_branch), the sync_aggregate and sync_committee_pubkeys representing the bitmap and public key list of participants in the signature, the signature_slot at which the signature was made, and actual_finalized_block_root and actual_finalized_branch, the actual finalized block root based on recent_finalized_block_root and its merkle path. SyncCommitteeSlashing contains two such pieces of evidence (evidence_1, evidence_2), a list of validator indices subject to slashing, and the reference recent_finalized_block_root and recent_finalized_slot.
Only the current and previous period are subject to punishment
evidence_1_attested_period must be at most 1 period greater than evidence_2_attested_period. In other words, only conflicts between the current and immediately preceding sync committee periods are subject to slashing; conflicts with older periods are not considered. This is because the sync committee sometimes signs blocks from the previous period at the start of a new period, and it also leaves a path for a validator who was bribed and synced to a non-canonical checkpoint to honestly participate again in a later period.
Limits on the value that can be protected
Even with slashing, this mechanism alone is not sufficient to protect value exceeding SYNC_COMMITTEE_SIZE (512) x MAX_EFFECTIVE_BALANCE (32 ETH) = 16384 ETH on mainnet. The source states that such larger-scale uses may require combining with existing approaches like multisig, or requiring additional collateral to be staked in order to be eligible to submit updates. It also explicitly notes that slashing, in any mechanism, can only be applied after the fact, once an attack has already occurred.
Evidence verification logic
is_valid_sync_committee_slashing_evidence checks that the number of participants in sync_aggregate is at least MIN_SYNC_COMMITTEE_PARTICIPANTS, verifies via finality_branch that finalized_header matches the finalized checkpoint in the attested_header's state, and verifies via next_sync_committee_branch with a merkle proof that next_sync_committee is actually the value stored in the attested_header's state. It also checks via actual_finalized_branch, depending on distance, through either state.block_roots or historical_roots, whether actual_finalized_block_root matches the block root at the position of finalized_header.slot based on recent_finalized_block_root, and finally verifies the signature itself using BLS FastAggregateVerify against the participating public keys.
Required follow-up infrastructure
This EIP introduces new consensus validation rules and therefore requires a hard fork. Once the consensus rules are in place, additional supporting infrastructure is needed separately, including slashing protection DB updates (so honest validators are not slashed upon reorganization), validator client/remote signer APIs, a libp2p mesh for beacon nodes to exchange slashing evidence, a Slasher that constructs evidence, and a Beacon API for submitting and querying evidence.
Current status
This EIP is in Stagnant status, and its Test Cases, Reference Implementation, and Security Considerations sections all remain TBD (unwritten). The call records available contain no decision on whether this EIP will be included in a fork.