viem@2.23.2 security report

The RPC URL 'ttps://rpc.donatuz.com' is missing the leading 'h'. This could be a typo, but it also means the URL will be treated as a relative path or invalid protocol, potentially causing errors or unexpected behavior if the user relies on it for network requests.

The ccipRequest function performs outbound HTTP requests to URLs provided in the OffchainLookup error data. In a real Ethereum/CCIP context these URLs come from a smart contract, but the code does not validate or restrict URLs (e.g., no allowlist, no scheme check). This could potentially be abused (SSRF-like) if an attacker controls the contract or error data, and it introduces data exfiltration surface by sending {data}/{sender} payloads to arbitrary endpoints.

The fromRlp function creates a cursor with recursiveReadLimit set to Number.POSITIVE_INFINITY, disabling the library's built-in protection against deeply nested RLP structures. Combined with recursive list parsing in readList/fromRlpCursor, a maliciously crafted deeply-nested RLP payload could cause stack exhaustion (RangeError: Maximum call stack size exceeded) or excessive memory consumption, resulting in a denial-of-service condition for callers that process untrusted RLP data.

The isImageUri function performs fetch(uri, { method: 'HEAD' }) on a URI that may be attacker-controlled (e.g. from ENS avatar records or NFT tokenURI). This can be used to probe internal network services or metadata endpoints (e.g. 169.254.169.254) if the URI is not validated against private IP ranges. No URL scheme/host allowlist beyond what resolveAvatarUri does is applied before the fetch.

getMetadataAvatarUri fetches an arbitrary URI and parses JSON, then passes the returned image field through parseAvatarUri, which may itself perform further fetches. This creates a chain of attacker-controlled outbound requests and potential JSON-based resource loading.

extractMessages tracks only brace nesting and ignores string literals and escapes. JSON strings containing unmatched braces (e.g. '{"a":"}"}') will corrupt the nesting level, causing incorrect message splitting, dropped messages, or merged payloads. Depending on the caller, this can be used to smuggle or truncate messages across the IPC boundary.

getIpcRpcClient(path) forwards the caller-supplied path directly to node:net connect() as an IPC endpoint with no normalization, allowlisting, or scope restriction. If path is influenced by untrusted input, it could connect to arbitrary local sockets (e.g. privileged daemons) rather than an intended package-scoped endpoint.

The onData handler parses every complete JSON message received over the IPC socket with JSON.parse(). There is no validation, size limit, or schema check before parsing. A malicious or compromised peer can send arbitrarily large or deeply nested JSON, causing high CPU/memory usage (JSON bombs / DoS). The parsed object is then passed directly to onResponse().

The function receives private keys as parameters and uses them to sign hashes. While this is expected behavior for a multisig smart account utility, handling private keys in memory and passing them to a signing function introduces risk if the keys are logged, stored, or transmitted improperly. The code does not appear to exfiltrate keys, but the pattern warrants caution since private keys are highly sensitive credentials.

The factoryAddress is configurable by the caller (parameters.factoryAddress) and defaults to a hardcoded address. If a malicious factory is provided, it could deploy a backdoored smart account or perform arbitrary calls during account creation. This is a design risk inherent in account abstraction but should be clearly documented.

A default factory address '0x5d82735936c6Cd5DE57cC3c1A799f6B2E6F933Df' is hardcoded instead of being derived from the provided entryPoint. This could lead to unexpected account creation address if the factory is not intended for the given chain/entryPoint, potentially causing loss of funds or incorrect account deployment.

The owner account is parsed via parseAccount(parameters.owner) without verifying that it is a valid EOA or that the address matches the expected owner. If an attacker can influence the owner parameter, they could set themselves as owner and drain funds.

The ccipRequest function performs fetch() calls to URLs provided by the contract error data (urls array from on-chain OffchainLookup error). This is expected behavior for CCIP-read / EIP-3668 offchain lookup, but the URLs are fully attacker-controllable via the smart contract being called. This means a malicious contract could direct requests to any host, including localhost/internal services (SSRF), potentially leaking the request data (which includes sender address and callData) to arbitrary endpoints. Additionally, results from these URLs are trusted and passed back into an on-chain callback, forming a trust chain that relies entirely on user-supplied endpoints.

fetch URL construction uses string replacement of {sender} and {data} into the URL without validation that the resulting URL is a well-formed http(s) URL or that it does not target internal/private addresses. No allowlist, protocol restriction, or redirect handling is present. In a package-supplied utility this is normal for CCIP read implementations but is a security-sensitive pattern worth noting.

The createCursor call sets recursiveReadLimit to Number.POSITIVE_INFINITY, disabling the library's built-in recursion limit. A deeply nested or maliciously crafted RLP input can cause unbounded recursion in readList/fromRlpCursor, leading to a stack overflow and process crash (DoS).

The function 'isImageUri' performs a 'fetch' request to an arbitrary user-supplied URI without validating the protocol or target. This could allow an attacker to make requests to internal services or local files if the library is used in a server-side context.

The function 'getMetadataAvatarUri' fetches JSON from the provided 'uri' without validating the protocol or host. This could lead to SSRF or data exfiltration if the URI is controlled by an attacker.

The code references a destructured variable reconnect in the expression const { attempts = 5, delay = 2_000 } = typeof reconnect === 'object' ? reconnect : {}; but reconnect is never imported, declared, or passed into getSocketRpcClient. This will cause a ReferenceError at runtime and suggests the file is incomplete or was tampered with.

When paymaster is an object, the code directly assigns and later invokes getPaymasterStubData and getPaymasterData from that object without validation. The logic (getPaymasterData && getPaymasterStubData ? getPaymasterStubData : getPaymasterData) can cause a single function to be used for both stub and final paymaster data, potentially leaking data twice or executing unintended behavior if attacker-controlled.

The code dynamically invokes paymaster action functions (getPaymasterStubData, getPaymasterData) that are provided either by the bundler client or via the paymaster parameter. These calls can send the full UserOperation request (including sender address, callData, signature, and paymaster context) to external paymaster URLs. While this is a legitimate ERC-4337 paymaster pattern, if an attacker can supply or override the paymaster configuration (e.g., through bundler client decorators, configuration injection, or a compromised dependency), user operation data and possibly signatures can be exfiltrated to an untrusted endpoint.

The file exports a large number of test-only utilities (e.g., impersonateAccount, setBalance, setCode, setNonce, setStorageAt, setRpcUrl, mine, reset, revert, loadState, dumpState, increaseTime, setNextBlockTimestamp, etc.) from the main public entrypoint. These methods can manipulate blockchain state, impersonate accounts, and modify balances/nonces. If an application bundles these exports and an attacker can influence which action is called (e.g., via dynamic dispatch or exposed API), it could lead to unauthorized state manipulation. While these are explicitly test utilities, their presence in the primary barrel file increases attack surface.

The file contains three large hardcoded EVM bytecode blobs exported as string constants. These are compiled smart contract bytecodes intended for on-chain deployment and calls (a deployless call pattern). While not malicious on their own, embedded bytecode is opaque and cannot be easily audited in source form; it is a common vector for hiding logic such as signature validation, delegatecall proxies, or subtle address-rewriting behavior.

The universalSignatureValidatorByteCode contains embedded Solidity logic for validating ECDSA signatures, including the magic value 0x1626ba7e (ERC-1271 isValidSignature selector) and selective recovery logic. If this validator is used to verify wallet ownership (e.g., account abstraction), a flaw in the embedded bytecode could allow signature forgery or bypass of authorization checks.

Bytecode strings in hex are effectively obfuscated relative to their source. Without decompilation or a matching verified source, the exact behavior of these contracts cannot be confirmed from this TypeScript file alone. This is a supply-chain risk: a tampered bytecode string would silently alter on-chain behavior while looking like normal constants.

ccipRequest() performs fetch() to URLs that originate from on-chain OffchainLookup error data (urls array). The URL, sender, and data are interpolated directly into the request URL ({sender}/{data}) and POST body without allowlisting, scheme validation, or restriction to https. A malicious or compromised contract can supply attacker-controlled URLs, turning this utility into a generic fetch primitive from the host application.

url.replace('{sender}', sender).replace('{data}', data) blindly substitutes on-chain-provided values into the request URL. If a contract supplies a URL template with unexpected schemes (e.g., file:, gopher:, or internal hosts), the request target is fully attacker-influenced. No protocol/allowlist check exists.

The uid() function uses Math.random() to generate identifiers. Math.random() is not cryptographically secure and is predictable, which is unsuitable for security-sensitive uses such as tokens, session IDs, CSRF nonces, or password reset links. If this utility is used for such purposes, it could allow attackers to predict or brute-force generated values. This is a code-quality/security weakness rather than an active malicious pattern.