Cosmos Vulnerability Scanner

// VULNERABLE: String concatenation without length-prefix encoding (Finding 16)
func VaultUserKey(vaultID uint64, user string) []byte {
    return []byte(fmt.Sprintf("%d%s", vaultID, user))
}
// vaultId=1, user="2a" → key "12a"
// vaultId=12, user="a" → key "12a"  ← COLLISION!

// Even with separators, string fields containing the separator collide:
// vaultId=1, user="a|", position="b" → "1|a||b"
// vaultId=1, user="a", position="|b" → "1|a||b"  ← COLLISION!

// VULNERABLE: Pool IDs serialized as strings in KV store keys (Finding 31)
func PositionKey(poolID uint64, posID uint64) []byte {
    return []byte(fmt.Sprintf("position/%d/%d", poolID, posID))
}
// poolID=42 shares byte prefix [52 50] with poolID=421
// HasAnyAtPrefix("position/42") matches "position/421/..."
// Attacker creates positions with carefully chosen pool IDs
// that prefix-collide with victim positions

// VULNERABLE: Attacker can increment pool IDs by creating empty pools
store.Iterator(PositionPrefix(poolID), nil)  // Includes poolID * 10 + N

// VULNERABLE: Unbonding period bypass via redelegation (Finding 14)
// If a user redelegates to a validator outside the active set
// (e.g., bonded stake rank 102), then unbonds, the 21-day
// unbonding period is skipped — the state key lookup for the
// unbonding entry doesn't account for out-of-set validators.
// Attacker who steals tokens can instantly exit staking.

// SECURE: Use length-prefixed encoding
func VaultUserKey(vaultID uint64, user string) []byte {
    key := make([]byte, 8+1+len(user))
    binary.BigEndian.PutUint64(key[:8], vaultID)  // Fixed-width
    key[8] = byte(len(user))                       // Length prefix
    copy(key[9:], user)
    return key
}

// SECURE: Use cosmossdk.io/collections key codecs
var PositionsMap = collections.NewMap(
    sb, PositionsPrefix,
    collections.PairKeyCodec(collections.Uint64Key, collections.Uint64Key),
    codec.CollValue[Position](cdc),
)

// VULNERABLE: PrepareProposal validates signatures but skips
// VerifyVoteExtension rules (Finding 15, SEDA Chain)
func (h *Handler) PrepareProposal(ctx sdk.Context, req *abci.PrepareProposalRequest) (*abci.PrepareProposalResponse, error) {
    for _, vote := range req.LocalLastCommit.Votes {
        // Only checks vote signature — does NOT re-run VerifyVoteExtension!
        if !verifySignature(vote) { continue }
        // CometBFT accepts late precommits without full verification
        // Byzantine validator smuggles malicious vote extension into proposal
        extensions = append(extensions, vote.VoteExtension)
    }
    // Leader unknowingly includes forged oracle data in block
}

// VULNERABLE: Any module trusting ctx.BlockTime() for security-critical decisions
// CometBFT "Tachyon" (Finding 21, CSA-2026-001): inconsistency between how
// commit signatures are verified and how block time is derived breaks BFT Time
// guarantee. A faulty process CAN arbitrarily increase block time.

// These are all exploitable if block time can be manipulated:
deadline := proposal.SubmitTime.Add(votingPeriod)
if ctx.BlockTime().After(deadline) { ... }  // Governance deadlines

vestingEnd := account.EndTime
if ctx.BlockTime().After(vestingEnd) { ... }  // Vesting unlocks

price := oracle.GetTWAP(ctx, pair, window)  // Time-weighted prices

// VULNERABLE: Creating vesting accounts on blocked addresses (Finding 29, ASA-2024-003)
func (ms msgServer) CreatePeriodicVestingAccount(ctx context.Context, msg *types.MsgCreatePeriodicVestingAccount) error {
    toAddr := sdk.AccAddressFromBech32(msg.ToAddress)
    // Missing: check if toAddress is a blocked address or module account
    // Funds deposited to module accounts via vesting become permanently inaccessible
    // Could also enable unintended interactions with module accounts
}

// VULNERABLE: Circuit breaker reset does not verify per-type authorization
// Account authorized to break MsgSend can reset MsgDelegate
func (ms msgServer) ResetCircuitBreaker(ctx context.Context, msg *types.MsgResetCircuitBreaker) error {
    // Checks: is the sender an authorized circuit breaker account? YES
    // Missing: does the sender have authority over THIS SPECIFIC message type?
    // Result: any circuit breaker account can re-enable any disabled message type
}

// VULNERABLE: ICS-23 spec allowed proofs to carry their own spec parameters
// (Finding 3a, Dragonberry — all IBC chains, all versions)
// Validation only required input leaf prefix to CONTAIN the standard spec's
// prefix as a substring — not match exactly.
// Attacker forges absence proof to "prove" packet commitment doesn't exist
// on counterparty chain (even though it does), then triggers IBC timeout refunds
// for packets that were successfully delivered.
// Iterative drainage of ALL ICS-20 escrow accounts across ALL Cosmos networks.

// VULNERABLE: Same class as Dragonberry in IAVL RangeProof system
// (Finding 30, Dragonfruit — $566M BNB bridge exploit used related flaw)
// Missing validation checks on leaf/inner-node prefix/suffix length
// allowed forging proofs against the IAVL Merkle tree.

// VULNERABLE: Cosmos-side ECDSA verification accepts non-canonical s-values
// (Finding 13, Gravity Bridge)
func EthAddressFromSignature(hash []byte, sig []byte) (common.Address, error) {
    // Missing: canonical s-value validation
    // ECDSA has two valid s values per signature (elliptic curve symmetry)
    // Ethereum enforces s < secp256k1.N/2, Cosmos side does not
    // Malicious orchestrator submits non-canonical signature:
    //   Cosmos accepts → Ethereum rejects → bridge enters crash loop
    //   Selectively block validator set updates and transaction batches
}