Back to Intelligence

Cosmos EVM Balance-Handling Flaw (GHSA-7g4w-cg88-2cq2) Exploited Across Six Blockchains — Defender's Response Guide

SA
Security Arsenal Team
August 29, 2026
12 min read

Cosmos Labs has disclosed that a critical balance-handling vulnerability in the shared Cosmos EVM module — tracked as GHSA-7g4w-cg88-2cq2 — was actively exploited to drain funds from six blockchains between August 20 and August 25, 2026. This is not a theoretical exercise. Real value was stolen from production chains, and the flaw lived in a shared module, meaning every chain that consumed the vulnerable Cosmos EVM package inherited the same exposure simultaneously.

What makes this disclosure especially significant from a defensive standpoint is the supply-chain dimension: the vulnerable code was not written by any single chain team. It was a dependency. Chain operators who ran routine security reviews of their own application logic but treated upstream modules as trusted black boxes were exposed with no visibility into the risk. The advisory was published without a CVE identifier, a CWE classification, or a CVSS score — which means automated vulnerability scanners and CVE-driven tooling almost certainly missed it. If your exposure management pipeline keys exclusively off CVE feeds, this advisory never hit your queue.

If you operate a validator, run an EVM-compatible Cosmos chain, custody assets on one, or integrate with one via bridges, treat this as an incident, not a patch Tuesday item.

Technical Analysis

Affected Products and Versions

  • Component: Cosmos EVM module (the shared EVM compatibility layer used by Cosmos SDK chains)
  • Affected versions: All versions prior to 0.6.2 (per the truncated advisory data, operators should verify against the full GitHub Security Advisory for any additional affected ranges in the 0.6.x line)
  • Fixed version: 0.6.2 and later
  • Advisory identifier: GHSA-7g4w-cg88-2cq2 (GitHub Security Advisory — no CVE assigned, no CVSS score published, rated Critical by Cosmos Labs)
  • Impact window: Confirmed exploitation draining funds from six blockchains, August 20–25, 2026

How the Vulnerability Works

The flaw is a balance-handling logic error in the EVM module's accounting of token state. Balance-handling bugs in EVM implementations are a well-understood failure class: when the module that reconciles EVM-side state (gas accounting, value transfers, contract balance updates) with the underlying Cosmos SDK bank module state mishandles an edge case, an attacker can cause the two ledgers to diverge. The practical result is value that can be withdrawn or credited without a corresponding debit — effectively minting or siphoning funds at the protocol layer rather than through any smart contract flaw.

From a defender's perspective, the key characteristics are:

  • Exploitation is on-chain. There is no phish, no credential theft, no endpoint malware. The attack surface is the chain's transaction mempool and block processing itself. Anyone who can submit transactions to a vulnerable chain can attempt exploitation.
  • No smart contract interaction is required to be vulnerable — but contract calls are the likely vector. Flaws in balance handling during EVM message execution (value transfers, internal transactions, or gas refund paths) are typically triggered through crafted contract calls or unusual transaction structures.
  • Blast radius is dependency-driven. Six chains were drained in a five-day window because all six consumed the same module. Exploit knowledge transfers perfectly between them — same code, same bug, same exploit primitive, different chain ID.

Exploitation Status

  • Confirmed active exploitation in the wild. This is not a proof-of-concept scenario — funds were drained from six production blockchains.
  • No CISA KEV listing (KEV coverage for blockchain infrastructure modules is effectively nonexistent — do not wait for KEV as your tripwire here).
  • No CVE assigned. GHSA-only. If your vulnerability management tooling ingests only NVD/CVE feeds, you have a blind spot — GHSA ingestion is mandatory for blockchain and open-source dependency coverage.

Detection & Response

Detection for on-chain exploitation differs from traditional endpoint detection. Your highest-fidelity signals are: (1) validator and node telemetry (process crashes, state-sync anomalies, unexpected restarts during the exploitation window), (2) transaction-level anomalies (sudden large balance movements, withdrawal bursts, contract calls that result in unbalanced state transitions), and (3) version posture (any production node still running Cosmos EVM < 0.6.2).

The rules below target the observable behaviors defenders can realistically hunt: node process anomalies on validator infrastructure (Linux), suspicious transaction/withdrawal patterns in node logs, and post-exploitation attempts to move or obscure drained funds through operator-controlled infrastructure.

Sigma Rules

YAML
---
title: Cosmos Validator Node Unexpected Restart or Crash Loop
id: 3f9a1c47-2b8e-4d6a-9c15-7e2f8b4a1d93
status: experimental
description: Detects unexpected restarts or crash loops of Cosmos SDK-based chain daemon processes on validator infrastructure, which may indicate exploitation attempts against consensus or EVM module state handling, or instability caused by a malformed transaction triggering the balance-handling flaw.
references:
  - https://thehackernews.com/2026/08/cosmos-evm-flaw-exploited-after-cosmos.html
  - https://github.com/advisories/GHSA-7g4w-cg88-2cq2
author: Security Arsenal
date: 2026/08/28
tags:
  - attack.impact
  - attack.t1499
logsource:
  category: process_creation
  product: linux
detection:
  selection_binary:
    Image|endswith:
      - '/simd'
      - '/evmosd'
      - '/cosmosd'
      - '/ethermintd'
      - '/seid'
      - '/injectived'
      - '/dymd'
  selection_args:
    CommandLine|contains:
      - 'start'
  condition: selection_binary and selection_args
falsepositives:
  - Planned upgrades and routine validator restarts
  - Scheduled maintenance windows
level: medium
---
title: Suspicious Withdrawal or Balance Query Pattern in Chain Node Logs
id: 8c2d5e91-4f3a-4b7c-a1e6-9d3b7f2c5e84
status: experimental
description: Detects log patterns on Cosmos validator or RPC nodes indicating mass withdrawal operations, failed bank-module state transitions, or EVM-to-bank module reconciliation errors consistent with balance-handling exploitation (GHSA-7g4w-cg88-2cq2).
references:
  - https://thehackernews.com/2026/08/cosmos-evm-flaw-exploited-after-cosmos.html
  - https://github.com/advisories/GHSA-7g4w-cg88-2cq2
author: Security Arsenal
date: 2026/08/28
tags:
  - attack.impact
  - attack.t1657
logsource:
  product: linux
  service: syslog
detection:
  selection:
    - 'evm':
        - 'insufficient funds for transfer'
        - 'balance mismatch'
        - 'state transition error'
        - 'failed to commit state'
        - 'panic'
        - 'negative balance'
        - 'withdrawal'
    - 'x/bank':
        - 'send coins'
        - 'multi-send'
        - 'burn'
        - 'mint'
  condition: selection
falsepositives:
  - Normal user withdrawal activity on high-traffic chains (tune with volume baselining and threshold aggregation)
  - Integration testing on public testnets
level: high
---
title: Outbound Transfer of Drained Assets to Exchange or Bridge Endpoints
id: b7e4a2d8-1c9f-4e5b-8a3d-6f1c9e2b7a45
status: experimental
description: Detects network connections from validator or node infrastructure to known bridge, mixer, or exchange API endpoints during or shortly after an exploitation window — a common pattern for laundering drained on-chain assets. Tune the endpoint list to your threat model.
references:
  - https://thehackernews.com/2026/08/cosmos-evm-flaw-exploited-after-cosmos.html
author: Security Arsenal
date: 2026/08/28
tags:
  - attack.exfiltration
  - attack.t1567
logsource:
  category: network_connection
  product: linux
detection:
  selection:
    DestinationHostname|contains:
      - 'bridge.'
      - '.bridge.'
      - 'mixer'
      - 'tornado'
      - 'swap.'
    Image|contains:
      - 'curl'
      - 'wget'
      - 'node'
      - 'python'
  condition: selection
falsepositives:
  - Legitimate operator tooling querying bridge or DEX APIs for monitoring
  - Market-making infrastructure on trading firm validators
level: medium

KQL — Microsoft Sentinel / Defender Hunt Queries

Validator infrastructure, node logs, and chain telemetry should be ingested into Sentinel via Syslog/CEF. The following queries hunt for (1) exploitation-window anomalies and (2) hosts running vulnerable versions based on software inventory or process command lines.

KQL — Microsoft Sentinel / Defender
// Hunt 1: Cosmos chain daemon restarts and panic/crash events during the exploitation window (Aug 20-25, 2026)
// Extend the window if your chain ingested the module later or your review is retrospective
let ExploitWindowStart = datetime(2026-08-20);
let ExploitWindowEnd = datetime(2026-08-26);
Syslog
| where TimeGenerated between (ExploitWindowStart .. ExploitWindowEnd)
| where ProcessName has_any ("simd", "evmosd", "cosmosd", "ethermintd", "seid", "injectived")
   or SyslogMessage has_any ("panic", "balance mismatch", "state transition error",
                              "insufficient funds for transfer", "failed to commit state",
                              "negative balance", "x/evm", "x/bank")
| summarize EventCount = count(), SampleMessages = make_set(SyslogMessage, 5)
   by Computer, ProcessName, bin(TimeGenerated, 1h)
| where EventCount > 20   // tune threshold to your baseline block-production log volume
| sort by EventCount desc;

// Hunt 2: Identify hosts with vulnerable Cosmos EVM module versions via process command line / inventory
// Devices where the chain binary reports a version below 0.6.2
DeviceProcessEvents
| where TimeGenerated > ago(30d)
| where FileName has_any ("simd", "evmosd", "cosmosd", "ethermintd", "seid", "injectived")
   and ProcessCommandLine has_any ("version", "start")
| extend CmdLine = tostring(ProcessCommandLine)
| extend VersionMatch = extract(@"(0\.6\.[01]\b|0\.[0-5]\.\d+)", 0, CmdLine)
| where isnotempty(VersionMatch)
| summarize LastSeen = max(TimeGenerated), Versions = make_set(VersionMatch) by DeviceName, FileName
| sort by LastSeen desc;

// Hunt 3: Sudden spike in withdrawal/transfer transactions in node RPC logs (post-exploitation fund movement)
CommonSecurityLog
| where TimeGenerated > ago(14d)
| where Message has_any ("withdraw", "MsgSend", "MsgMultiSend", "MsgWithdrawDelegatorReward",
                          "MsgWithdrawValidatorCommission", "MsgEthereumTx")
| summarize TxCount = count() by DeviceHostName, bin(TimeGenerated, 15m)
| where TxCount > 100   // baseline against normal chain throughput per host
| sort by TxCount desc;

Velociraptor VQL — Validator Host Triage

If you suspect a validator host was touched during the exploitation window (e.g., an operator attempted an emergency rollback, or an intruder leveraged host access alongside the on-chain exploit), this artifact triages running chain processes, their versions, and recent connections.

VQL — Velociraptor
-- Triage Cosmos validator hosts: enumerate chain daemon processes, binaries, and network peers
SELECT Pid,
       Name,
       Exe,
       CommandLine,
       Username,
       CreateTime
FROM pslist()
WHERE Name =~ '(simd|evmosd|cosmosd|ethermintd|seid|injectived|dymd)$'
   OR CommandLine =~ '(x/evm|cosmos-evm|ethermint)'

-- Correlate with live network connections from those processes (peer/bridge endpoints)
SELECT Pid,
       Name,
       Status,
       Laddr,
       Raddr,
       Raddr.IP AS RemoteIP,
       Raddr.Port AS RemotePort
FROM netstat()
WHERE Name =~ '(simd|evmosd|cosmosd|ethermintd|seid|injectived|dymd)$'
   AND Status =~ 'ESTABLISHED'

-- Check for recently modified chain data directories or emergency binary swaps during the exploit window
SELECT FullPath,
       Size,
       Mtime,
       Ctime
FROM glob(globs=['/home/*/.*d/data/*.json',
                 '/root/.*d/config/app.toml',
                 '/root/.*d/config/config.toml',
                 '/usr/local/bin/*d',
                 '/home/*/go/bin/*d'])
WHERE Mtime > '2026-08-20' AND Mtime < '2026-08-26'
ORDER BY Mtime DESC

Remediation & Verification Script

The following Bash script audits validator hosts for vulnerable Cosmos EVM versions, checks the binary's module version, and verifies chain state integrity indicators. Run it on every validator, RPC node, and archive node — including standby/sentry infrastructure, which teams routinely forget.

Bash / Shell
#!/usr/bin/env bash
# Cosmos EVM GHSA-7g4w-cg88-2cq2 — vulnerability audit and remediation verification
# Run on every validator, RPC, archive, and sentry node. Requires the chain daemon binary in PATH or provided as $1.

set -euo pipefail

BINARY="${1:-}"
if [[ -z "$BINARY" ]]; then
  # Attempt to auto-detect the running chain daemon
  BINARY=$(ps -eo comm,args | grep -E '(simd|evmosd|cosmosd|ethermintd|seid|injectived|dymd)' | grep -v grep | awk '{print $2}' | head -n1 || true)
fi

if [[ -z "$BINARY" ]]; then
  echo "[!] No chain daemon detected. Provide the binary path as argument: $0 /path/to/<chain>d"
  exit 2
fi

echo "[*] Auditing binary: $BINARY"

# 1. Report daemon version and module dependency versions
"$BINARY" version --long 2>/dev/null | grep -Ei 'version|commit|cosmos-evm|ethermint' || "$BINARY" version

# 2. Check go.mod / build info for cosmos-evm module version (go binaries embed module versions)
echo "[*] Checking embedded module versions via 'go version -m'..."
if command -v go >/dev/null 2>&1; then
  go version -m "$BINARY" | grep -Ei 'cosmos-evm|evm|ethermint' || echo "[-] No EVM module version found in build info — verify manually against go.mod"
else
  echo "[-] 'go' toolchain not present; extract module versions from your build pipeline SBOM instead"
fi

# 3. Flag vulnerable versions (< 0.6.2)
EVM_VER=$( (go version -m "$BINARY" 2>/dev/null || true) | grep -Eo 'cosmos-evm[^ ]*v?0\.[0-9]+\.[0-9]+' | grep -Eo '0\.[0-9]+\.[0-9]+' | head -n1 || true)
if [[ -n "$EVM_VER" ]]; then
  MAJ=$(echo "$EVM_VER" | cut -d. -f1); MIN=$(echo "$EVM_VER" | cut -d. -f2); PAT=$(echo "$EVM_VER" | cut -d. -f3)
  if [[ "$MAJ" -eq 0 ]] && { [[ "$MIN" -lt 6 ]] || { [[ "$MIN" -eq 6 ]] && [[ "$PAT" -lt 2 ]]; }; }; then
    echo "[CRITICAL] Vulnerable cosmos-evm module $EVM_VER detected (< 0.6.2). UPGRADE IMMEDIATELY."
    exit 1
  else
    echo "[OK] cosmos-evm module $EVM_VER is at or above 0.6.2"
  fi
else
  echo "[WARN] Could not parse EVM module version automatically. Cross-check go.mod and rebuild from source at >= 0.6.2."
fi

# 4. Verify service is running the patched binary after upgrade (restart check)
systemctl list-units --type=service --state=running | grep -Ei 'simd|evmosd|cosmosd|ethermintd|seid|injectived' || echo "[-] No chain service found via systemd — verify your process supervisor"

# 5. Baseline: capture recent withdrawal volume for anomaly review (requires local RPC on :26657)
echo "[*] Tip: pull recent block txs and diff withdrawal volume against your 30-day baseline:"
echo "    curl -s localhost:26657/block_results?height=<H> | jq '.result.txs_results' "

echo "[*] Audit complete. Record results in your change-management / IR tracker."

Remediation

This is a Critical, actively exploited flaw with confirmed theft from six chains. Treat it as incident response, not routine patching.

  1. Upgrade the Cosmos EVM module to 0.6.2 or later immediately. Coordinate a governance-driven or emergency chain upgrade per your chain's established procedures. For application developers, bump the dependency in go.mod, rebuild from source (do not trust cached binaries), and redeploy. Verify the running binary's embedded module version with go version -m as shown in the script above.
  2. Audit balances and state reconciliation retroactively. Compare EVM-module state against x/bank module state for the August 20–25, 2026 window (and earlier if your chain ingested the module before then). Balance-handling exploits often leave a state divergence fingerprint: addresses whose spendable balance exceeds what transaction history supports. If you find divergence, you may already have been drained without noticing.
  3. Do not rely on CVE feeds for this advisory. GHSA-7g4w-cg88-2cq2 has no CVE, no CVSS, and no CWE. Add GitHub Security Advisory (GHSA) ingestion to your vulnerability management pipeline — for blockchain dependencies, GHSA is frequently the only channel. Any scanner keyed solely on NVD was blind to this.
  4. Inventory every chain and environment that consumes the module. Include testnets, devnets, sentry nodes, and standby validators. Shared-module flaws do not respect environment boundaries — testnet exploits are rehearsal for mainnet exploits.
  5. If you were among the affected chains: engage on-chain forensics (trace fund flows to bridges/exchanges and file freeze requests early — exchange cooperation windows close fast), preserve node logs and block data before log rotation destroys them, and notify delegators/token holders per your disclosure obligations.
  6. Review the full advisory: GitHub Security Advisory GHSA-7g4w-cg88-2cq2 (github.com/advisories/GHSA-7g4w-cg88-2cq2) and Cosmos Labs' official channels for the complete affected-version ranges — the public reporting truncated the version data, so confirm your exact exposure against the source advisory.
  7. Longer term: treat upstream chain modules as attack surface. Include them in SBOM generation, pin and review dependency upgrades, and establish an emergency-upgrade runbook before the next shared-module critical advisory — because there will be one.

Related Resources

Security Arsenal Managed SOC Services AlertMonitor Platform Book a SOC Assessment soc-mdr Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.