/

CVE-2026-28410

Severity:

HIGH RISK

(8.1)

Improper Access Control / Logic Error in Smart Contract

CVE-2026-28410

Analyzed

Vulnerability type

Category:

Improper Access Control / Logic Error in Smart Contract

CWE:

CWE-284, CWE-682

Impact:

Unauthorized Token Release / Financial Loss

Severity:

HIGH RISK

(8.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A flaw in The Graph's token vesting smart contracts allows certain users to access tokens that are supposed to remain locked under their vesting schedule.

Under specific on-chain conditions, beneficiaries can withdraw more tokens than intended or withdraw them earlier than permitted, breaking the expected vesting guarantees.

Affected context

This vulnerability occurs within The Graph's on-chain token vesting contracts that govern how and when locked tokens become claimable.

It is relevant wherever these vesting contracts are deployed to manage time-based token unlocks, such as team allocations, investor vesting, or ecosystem grants.

The issue manifests when the contract's vesting logic and access control checks do not correctly enforce the intended schedule, enabling premature or excess withdrawals under certain state and time conditions.

Exploit preconditions

  • Attack surface: On-chain interaction with the vesting smart contract via supported blockchain networks (e.g., Ethereum, Polygon).
  • Required access: A valid beneficiary or account with some vesting allocation; no special off-chain privileges are needed beyond the ability to submit transactions.
  • Trigger point: Invocation of vesting-related functions (e.g., claim/withdraw) where the contract fails to enforce the proper vesting schedule or amount.
  • Why exploitation is possible: The contract's logic and/or access control checks contain an incorrect implementation of the vesting rules, allowing users to claim tokens that should remain locked according to the intended schedule.

Why this happens

The root cause lies in a combination of improper access control (CWE-284) and incorrect calculation (CWE-682) within the vesting logic.

The contract does not strictly enforce the intended time-based or amount-based constraints for token release, either due to:

  • Misapplied or missing checks that should gate withdrawals until particular vesting milestones are reached, or
  • A flawed arithmetic or state transition that miscomputes how many tokens are vested at a given time.

Conceptually, the contract trusts its own logic to represent the vesting schedule but implements that logic incorrectly, allowing calls that should fail to succeed and resulting in premature or excessive token unlocking.

Potential impact

  • Beneficiaries may withdraw tokens earlier than their agreed vesting schedule allows.
  • Users could potentially claim more tokens than they are entitled to under the vesting plan.
  • Token supply assumptions may be broken, impacting governance, liquidity, or token price stability.
  • Downstream financial agreements or incentives based on vesting schedules can be undermined.
  • Loss of trust in the token's vesting guarantees and wider protocol governance commitments.

General mitigation guidance

Effective mitigation centers on enforcing precise, verifiable vesting rules and least-privilege access control within smart contracts:

  • Model vesting schedules explicitly and keep all calculations deterministic and reviewable (e.g., linear schedules using well-defined time units and caps).
  • Enforce strict access control on withdrawal functions so only intended beneficiaries or designated roles can trigger releases, and only within their allocation.
  • Implement clear invariants, such as "total claimed ≤ total vested ≤ total allocation," and enforce these at every state transition.
  • Prefer simple, auditable vesting formulas over complex branching logic that is harder to reason about and test.
  • Use defensive programming patterns like require/assert checks for time, amount, and beneficiary identity before transferring tokens.
  • Separate concerns where possible: maintain accounting (balances and schedules) independently from transfer execution to simplify reasoning and testing.

How teams detect issues like this

Detection typically involves a combination of code-level and behavior-level analysis:

  • Static analysis and formal verification: Use tools and property-based testing to assert that no sequence of valid calls permits claimed > vested or vested > allocation for any beneficiary.
  • Manual code review: Examine vesting-related functions for:
  • Direct transfers that bypass vesting checks.
  • Arithmetic that can cause rounding or off-by-one errors around time boundaries.
  • Conditional branches that skip critical validation in edge cases.
  • Invariant and simulation testing: Run simulations of vesting over time with different inputs (timestamps, beneficiaries, allocations) to ensure claims never exceed what the schedule allows.
  • Policy enforcement in CI/CD: Integrate automated checks for known risky patterns in smart contracts, such as unrestricted token transfer paths or unchecked state updates that affect vesting balances.

Sources

SourceLink
github.comgithub.com/graphprotocol/contracts/commit/91224ed83eeff3fc3afea01f5ed269373d9bf773
github.comgithub.com/graphprotocol/contracts/security/advisories/GHSA-qx35-rc5x-x39r

Frequently asked

questions

Yes. Any party that is a beneficiary under the affected vesting contracts can exploit the flaw by sending crafted transactions to the blockchain, because smart contracts are inherently remotely callable.

The attacker typically needs to be an address recognized by the vesting contract (for example, a beneficiary or account with a vesting allocation). They do not need privileged off-chain access; the only requirement is the ability to submit on-chain transactions.

Re-implement vesting logic with explicit, mathematically sound formulas and strict access control, enforce invariants around claimable amounts and timelines, and subject the contract to thorough security review and, where feasible, formal verification before deployment.

Adopt a secure development lifecycle for smart contracts, relying on well-reviewed vesting templates, comprehensive unit and property-based tests, independent audits, and automated checks for access control and arithmetic correctness before any contract is deployed or upgraded.

Find out what's already
exploitable in your codebase.