Back to skill

Security audit

sentry-ai

Security checks for vulnerabilities and agentic risk

Overview

This skill does not show theft or persistence, but it overstates crypto audit and safety capabilities and may label tokens as safe using weak checks.

Review this before installing if you might rely on it for financial decisions. Treat its outputs as market-data hints only, not as an anti-rug audit or trading recommendation, and do not connect wallets or automate trades based on this package without independent security checks.

Vulnerability Patterns
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/scan.py:55
Finding
Unsupported “SAFE” Classification Based Only on Market Metrics<![CDATA[ ## Vulnerability Details **File Location**: `scripts/scan.py`, lines 55–97 **Vulnerability Type**: Insecure financial risk-scoring logic **Risk Level**: High ### Complete Code Snippet ```python def calculate_risk_score(token_data): """ Calculate risk score based on multiple factors Returns 0-100 score """ score = 50 # Base score # Liquidity factor liquidity = token_data.get('liquidity', 0) if liquidity > 100000: score += 20 elif liquidity > 50000: score += 10 # Volume factor volume = token_data.get('volume24h', 0) if volume > 100000: score += 15 elif volume > 50000: score += 10 # Risk adjustments if liquidity < 10000: score -= 30 if volume < 1000: score -= 20 return max(0, min(100, score)) if __name__ == "__main__": print("[SENTRY-AI] Starting scan...") results = scan_all() print(f"Found {len(results)} pools") for token in results: risk = calculate_risk_score(token) status = "SAFE" if risk >= 70 else "RISKY" print(f"[{status}] {token['symbol']} - Risk Score: {risk}/100") print(f" Liquidity: ${token['liquidity']:,.0f}") print(f" URL: {token['url']}") print() ``` ### Technical Analysis The scanner assigns an initial score of 50 and adjusts it using only reported liquidity and 24-hour trading volume. A score of 70 or higher is then presented as `SAFE`. These metrics do not establish smart-contract safety. The implementation does not examine: - Mint or freeze authorities - Owner or administrator privileges - Transfer restrictions or honeypot behavior - Upgradeability and proxy administration - Holder concentration - Liquidity ownership or lock status - Sellability and fee manipulation - Contract source code or bytecode - Token supply manipulation - Wash trading or artificially generated volume Liquidity and volume can be su ...[truncated 1471 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace `SAFE` with a narrowly scoped description such as `HIGH LIQUIDITY/ACTIVITY` until contract-level checks are implemented. 2. Do not produce a positive security verdict when required evidence is unavailable. Use an `UNKNOWN` or `INSUFFICIENT DATA` state. 3. Separate market-quality scoring from contract-security scoring. 4. Add chain-specific checks, including: - Solana mint and freeze authority status - EVM ownership, access-control, proxy, and upgradeability analysis - Transfer simulation and honeypot detection - Buy and sell fee analysis - Holder concentration - Liquidity lock and ownership verification - Source-code or bytecode inspection 5. Treat third-party API data as untrusted and potentially manipulable. 6. Require multiple independent indicators before issuing any favorable assessment. 7. Include the evidence used for each conclusion and clearly document scoring limitations. 8. Add test cases for tokens with high liquidity and volume but dangerous contract permissions. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/audit.py:25
Finding
Address Length Check Misrepresented as Solana and Base Address Validation<![CDATA[ ## Vulnerability Details **File Location**: `scripts/audit.py`, lines 25–33 **Vulnerability Type**: Improper input validation **Risk Level**: Medium ### Complete Code Snippet ```python # Check 1: Basic format validation if len(address) >= 32 and len(address) <= 44: audit_result['checks'].append({ 'name': 'Address Format', 'status': 'PASS', 'details': 'Valid Solana/Base address format' }) audit_result['risk_score'] += 20 else: audit_result['checks'].append({ 'name': 'Address Format', 'status': 'FAIL', 'details': 'Invalid address format' }) ``` ### Technical Analysis The implementation treats every string between 32 and 44 characters as a valid Solana or Base address. It does not validate the character set, binary representation, chain, prefix, checksum, or required decoded length. Solana addresses are Base58-encoded public keys that must decode to the expected byte length. Base addresses use the EVM address format: a `0x` prefix followed by exactly 40 hexadecimal characters, with checksum validation applicable to mixed-case addresses. A string containing arbitrary or invalid characters can pass this check, receive a `PASS` result, and increase the score by 20 points. The report therefore makes a false chain-format assertion based only on input length. ### Attack Path 1. An attacker supplies an arbitrary string between 32 and 44 characters that is neither a valid Solana public key nor a valid Base/EVM address. 2. The length condition evaluates to true. 3. The audit records `Address Format` as `PASS`. 4. The report states that the string has a valid Solana/Base address format. 5. The risk score is increased by 20 points despite the identifier being invalid. 6. A user or downstream process may treat the malformed identifier and resulting audit report as legitimate. ### Impact Assessment This issue does not provide local code execution, elevated system permissions, or access to ...[truncated 272 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require the caller to identify the target chain or determine it using strict, unambiguous validation. 2. For Solana: - Reject characters outside the Base58 alphabet. - Base58-decode the complete value. - Verify that the result has the required public-key byte length. - Use a maintained Solana SDK public-key constructor where available. 3. For Base/EVM: - Require a `0x` prefix. - Require exactly 40 hexadecimal characters after the prefix. - Validate mixed-case addresses using the applicable checksum algorithm. - Use a maintained EVM address-validation library. 4. Do not award security-score points merely because an address is syntactically valid. 5. Return an explicit validation error before conducting an audit when the address is malformed or the chain is ambiguous. 6. Add unit tests covering invalid alphabets, incorrect decoded lengths, malformed prefixes, non-hexadecimal characters, checksum failures, and valid addresses for each supported chain. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (11)

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The README materially overstates the skill's auditing and anti-rug abilities, claiming multi-chain scanning, dynamic monitoring, and meaningful risk analysis while the implementation is reportedly a minimal mock with placeholder checks. In a financial and trading context, this can mislead users into making investment or automated execution decisions based on nonexistent security analysis, creating a substantial risk of loss.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The README advertises automated scanning/auditing and especially 'one-click execute' with stop-loss/take-profit and gas optimization, but it does not clearly warn that these features may trigger real network activity, automated trades, wallet interactions, or financial loss. In a crypto trading skill, this omission is materially risky because users may treat the tool as passive analysis software when it may initiate consequential on-chain actions.

Lp3

Medium
Category
MCP Least Privilege
Confidence
84% confidence
Finding
The skill advertises network-driven scanning capabilities such as DexScreener/Raydium monitoring, but it does not declare any explicit tool scope or permissions. In agent ecosystems, undeclared network capability is dangerous because it obscures the trust boundary and can enable unexpected outbound requests, data exfiltration, or live interaction with third-party services without user awareness.

Natural-Language Policy Violations

Medium
Confidence
93% confidence
Finding
The skill README switches into Chinese and presents the core description and usage context in that language, with no indication that users can choose another language or that the skill is intentionally limited to a Chinese-speaking audience. This is a natural-language policy concern because it imposes a locale/language preference without opt-in or documented justification.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The skill promotes one-click execution, take-profit/stop-loss logic, and gas optimization without any warning about financial risk, irreversible on-chain actions, or the need for explicit user confirmation. In a crypto-trading context, this lowers user caution and can facilitate accidental or poorly informed transactions with real monetary consequences.

Description-Behavior Mismatch

Medium
Confidence
96% confidence
Finding
The file presents itself as a multi-chain anti-rug auditor, but it only checks address length and labels critical checks like liquidity and holder distribution as UNKNOWN. In a security-oriented trading context, this can mislead users into relying on a fake sense of safety, causing unsafe trading decisions against malicious tokens.

Intent-Code Divergence

Medium
Confidence
94% confidence
Finding
The documentation claims the function audits token contracts for risk, but the implementation performs only minimal length validation and mock checks. This mismatch is dangerous because downstream users or agents may treat the output as a substantive security assessment when it is not.

External Transmission

Medium
Category
Data Exfiltration
Content
import json

CHAINS = {
    'solana': 'https://api.dexscreener.com/latest/dex/tokens/solana',
    'base': 'https://api.dexscreener.com/latest/dex/tokens/base'
}
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

External Transmission

Medium
Category
Data Exfiltration
Content
import json

CHAINS = {
    'solana': 'https://api.dexscreener.com/latest/dex/tokens/solana',
    'base': 'https://api.dexscreener.com/latest/dex/tokens/base'
}
Confidence
60% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Natural-Language Policy Violations

Low
Confidence
95% confidence
Finding
Nearly all instructional content and headings after the title are presented only in Chinese, with no indication that the skill is region-specific or that alternative languages are available. This can violate language/locale policy when users are not given an explicit language choice or opt-in.

Missing User Warnings

Low
Confidence
93% confidence
Finding
This code performs an HTTP request to a third-party API, which is a safety-relevant network operation for code files. Although errors and scan progress are printed, there is no disclosure near the request or in the module description that the skill contacts an external service to retrieve token data.

Static analysis

No suspicious patterns detected.