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-71481

CVE-2026-71481: Cryptographic Signature Verification Bypass in ALTCHA PHP Library

Alon Barad
Alon Barad
Software Engineer

Nov 18, 2026·10 min read·4 visits

Executive Summary (TL;DR)

The altcha-org/altcha PHP library (versions 2.0.0 to 2.0.2) skips HMAC signature verification in verifySolution() if the client omits the signature field from the challenge payload. Attackers can remove the signature, supply arbitrary low-difficulty Proof-of-Work parameters, and bypass CAPTCHA verification completely. Upgrade to version 2.0.3 to resolve the issue.

CVE-2026-71481 (GHSA-82w8-65qw-gch6) is a cryptographic signature verification bypass (CWE-347) in the altcha-org/altcha PHP library affecting versions 2.0.0 through 2.0.2. Due to a flawed conditional check in the verifySolution method, omitting the signature field from a submitted challenge payload causes the server to skip HMAC verification entirely, even when a server-side HMAC secret is configured. Unauthenticated remote attackers can exploit this flaw to self-issue low-difficulty Proof-of-Work challenges, solve them with trivial effort, and bypass CAPTCHA controls.

Vulnerability Overview

ALTCHA PHP (altcha-org/altcha, hosted in the altcha-org/altcha-lib-php repository) is a server-side PHP library used for generating and verifying Proof-of-Work (PoW) CAPTCHA challenges. Unlike traditional visual CAPTCHAs, ALTCHA requires client applications to solve a computational puzzle before submitting protected forms or accessing rate-limited endpoints. Because the challenge generation and verification endpoints are exposed directly to unauthenticated users over HTTP/HTTPS, the verification logic represents a primary security boundary against automated bot traffic, credential stuffing, and spam.

In versions 2.0.0 through 2.0.2, the library contains an Improper Verification of Cryptographic Signature vulnerability (CWE-347) within the Altcha::verifySolution method in src/Altcha.php. When verifying a client submission, the server relies on a configured HMAC secret (hmacSignatureSecret) to ensure that the challenge parameters being solved were originally issued by the server and have not been altered by the client.

Due to a compound conditional statement in verifySolution, the library checks for both the existence of the server's HMAC secret and the presence of a non-null signature in the client's payload before executing the signature comparison. If a client submits a challenge payload where the signature field is omitted or set to null, the conditional expression evaluates to false, and the HMAC verification block is bypassed entirely.

Skipping the HMAC check causes the library to proceed directly to Proof-of-Work validation using the unverified parameters supplied in the request. An unauthenticated remote attacker can exploit this flaw by fabricating a challenge with minimal computational difficulty, computing a trivial solution locally, stripping the signature field, and submitting the payload. The server validates the trivial PoW solution against the attacker's parameters and returns a successful verification result, rendering the CAPTCHA protection ineffective.

Root Cause Analysis

To maintain stateless operation across HTTP requests, the ALTCHA architecture delegates storage of the challenge parameters to the client. During normal operation, the server invokes createChallenge() to generate parameters—such as the hashing algorithm (e.g., PBKDF2 or SHA-256), the difficulty cost, a random salt, and a target counter—and serializes these parameters into a canonical JSON representation. The server then computes an HMAC signature over this canonical JSON string using its private $this->hmacSignatureSecret property and sends both the parameters and the signature to the client.

When the client returns the solved puzzle, it submits a Payload object containing two sub-components: a Challenge object (which holds the challenge parameters and the signature) and a Solution object (which holds the computed answer). The security of this stateless model relies entirely on the server verifying the HMAC signature before trusting the challenge parameters inside Payload->challenge->parameters.

The root cause of CVE-2026-71481 is the coupling of a server configuration check (null !== $this->hmacSignatureSecret) with a client input check (null !== $payload->challenge->signature) using a logical && operator in src/Altcha.php:

if (null !== $payload->challenge->signature && null !== $this->hmacSignatureSecret)

In the data model of altcha-org/altcha v2, the Challenge class allows the $signature property to be nullable (?string). When the incoming payload omits the signature key or explicitly sets it to null, $payload->challenge->signature resolves to null. Consequently, the first operand (null !== $payload->challenge->signature) evaluates to false, causing PHP's short-circuit evaluation to bypass the entire if block without evaluating whether $this->hmacSignatureSecret is configured.

Because no else branch or preliminary assertion existed to handle the state where $this->hmacSignatureSecret is non-null while $payload->challenge->signature is null, execution fell through directly to the PoW verification step. The library treated the absence of a signature as equivalent to an deployment where signature verification was intentionally disabled by the administrator.

Code Analysis

The vulnerability resides in the verifySolution method of src/Altcha.php and was remediated in commit 8b02ad2c9b82998613bac4d093517d457061cbbe. Comparing the vulnerable implementation in versions 2.0.0–2.0.2 against the patched implementation in version 2.0.3 illustrates how the control flow was restructured to enforce signature presence.

In the vulnerable version of src/Altcha.php, lines 118–128 performed the signature check as follows:

// Vulnerable code in src/Altcha.php (v2.0.0 - v2.0.2)
// Verify challenge signature
if (null !== $payload->challenge->signature && null !== $this->hmacSignatureSecret) {
    // Only reached if the client voluntarily provides a non-null signature
    $expectedSignature = $this->hmacHex($params->toCanonicalJson(), $this->hmacSignatureSecret);
    if (!hash_equals($expectedSignature, $payload->challenge->signature)) {
        return new VerifySolutionResult(
            verified: false,
            invalidSignature: true,
            time: microtime(true) - $startTime,
        );
    }
}
// Execution continues here if $payload->challenge->signature is null

Commit 8b02ad2c9b82998613bac4d093517d457061cbbe modifies src/Altcha.php by separating the check for the server's HMAC secret from the validation of the client's signature field:

// Patched code in src/Altcha.php (v2.0.3)
// Verify challenge signature
if (null !== $this->hmacSignatureSecret) {
    // Server requires HMAC verification; explicitly reject missing signatures
    if (null === $payload->challenge->signature) {
        return new VerifySolutionResult(
            verified: false,
            invalidSignature: true,
            time: microtime(true) - $startTime,
        );
    }
    $expectedSignature = $this->hmacHex($params->toCanonicalJson(), $this->hmacSignatureSecret);
    if (!hash_equals($expectedSignature, $payload->challenge->signature)) {
        return new VerifySolutionResult(
            verified: false,
            invalidSignature: true,
            time: microtime(true) - $startTime,
        );
    }
}

The patch establishes $this->hmacSignatureSecret as the authoritative control variable. When a secret is configured on the Altcha instance, the code enters the verification block unconditionally. It then explicitly checks null === $payload->challenge->signature and immediately returns a failed VerifySolutionResult with verified: false and invalidSignature: true if the signature is missing. Only after confirming that $payload->challenge->signature is non-null does it compute $expectedSignature via $this->hmacHex() and compare the values using the constant-time hash_equals() function.

Assessing fix completeness: the remediation completely closes this bypass vector when hmacSignatureSecret is configured. Because PHP strict typing is enforced in the library, $payload->challenge->signature can only be a string or null. An empty string ("") passes the null === $payload->challenge->signature check and proceeds to hash_equals($expectedSignature, ""), which evaluates to false against a valid hex HMAC digest. Additionally, the patch added a dedicated regression test (testMissingSignatureIsRejected) in tests/AltchaTest.php to verify that a Challenge instantiated with a null signature returns verified: false and invalidSignature: true.

Exploitation

Exploiting CVE-2026-71481 requires no authentication, elevated privileges, or prior knowledge of the server's hmacSignatureSecret. The only prerequisite is that the target web application uses altcha-org/altcha versions 2.0.0, 2.0.1, or 2.0.2 to verify incoming CAPTCHA payloads. An attacker does not even need to interact with the server's challenge generation endpoint, as the entire payload can be synthesized offline.

To execute the bypass, the attacker first constructs a set of challenge parameters using the lowest possible difficulty settings supported by the server's configured PoW algorithm (for example, PBKDF2 or SHA-256). By setting the cost parameter to 1 and selecting a static, known salt and minimal keyPrefixLength, the computational work required to find a matching hash or counter is reduced to a single iteration, taking less than one millisecond on standard hardware.

Next, the attacker computes the valid PoW solution corresponding to these self-issued parameters and constructs the JSON payload with the signature field either omitted or set to null:

{
  "challenge": {
    "parameters": {
      "algorithm": "PBKDF2",
      "cost": 1,
      "salt": "attacker_controlled_salt"
    },
    "signature": null
  },
  "solution": {
    "number": 0
  }
}

The unit test testMissingSignatureIsRejected introduced in commit 8b02ad2c9b82998613bac4d093517d457061cbbe demonstrates the exact programmatic construction of the bypass payload within the library's object model:

// Strip signature from challenge
$strippedChallenge = new Challenge($challenge->parameters, null);
$payload = new Payload($strippedChallenge, $solution);
 
$result = $this->altcha->verifySolution(new VerifySolutionOptions(
    payload: $payload,
    algorithm: $this->pbkdf2,
));

When the attacker encodes the JSON structure (typically as a Base64-encoded string in the altcha form parameter) and sends it in an HTTP POST request to the target application, the vulnerable verifySolution() method skips the HMAC check, verifies that the trivial solution matches the attacker's cost: 1 parameters, and returns a VerifySolutionResult object with verified: true. Furthermore, because the signature check is skipped, an attacker can replay the exact same pre-computed payload across an unlimited number of requests without recalculating the solution, unless the target application implements separate state tracking over the payload.

Impact Assessment

CVE-2026-71481 is rated as a High severity vulnerability with a CVSS v3.1 base score of 7.5 (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N). The Attack Vector is Network (AV:N) and Attack Complexity is Low (AC:L), reflecting that any remote client capable of reaching the web application can exploit the flaw simply by modifying a JSON structure. No privileges (PR:N) or user interaction (UI:N) are required.

The primary impact is to Integrity (I:H), while Confidentiality (C:N) and Availability (A:N) are marked as None in the base CVSS vector. Within the security scope of the ALTCHA library itself, the vulnerability causes a total failure of the integrity verification mechanism: the library guarantees to the calling application that a challenge was authentically issued by the server and solved according to policy, when in fact the challenge was forged by the client.

In a production deployment, the downstream operational impact depends on the sensitive workflows protected by the ALTCHA control. Because the vulnerability affects deployments that explicitly configure hmacSignatureSecret—which is the standard configuration for production environments—all protected endpoints are exposed to automated abuse.

Attackers can leverage this bypass to defeat anti-automation barriers on authentication endpoints, enabling high-velocity credential stuffing and brute-force attacks (MITRE ATT&CK T1110). On registration, comment, password reset, or contact endpoints, the bypass allows automated mass account creation, SMS/email toll fraud, and database exhaustion without incurring the computational cost intended by the Proof-of-Work mechanism.

Remediation

The primary remediation is to upgrade the altcha-org/altcha Composer package to version 2.0.3 or later, which includes commit 8b02ad2c9b82998613bac4d093517d457061cbbe. Administrators and developers can apply the update via the Composer CLI:

composer require altcha-org/altcha:^2.0.3

After running the update command, inspect the project's composer.lock file to confirm that the installed version of altcha-org/altcha resolves to 2.0.3 or higher before redeploying the application.

> [!NOTE] > In addition to upgrading the package, developers should audit their Altcha class instantiation to ensure that hmacSignatureSecret is explicitly provided with a cryptographically strong, high-entropy secret key. If hmacSignatureSecret is left null, signature verification remains disabled by design.

For environments where an immediate Composer package upgrade cannot be deployed, engineering teams can implement an application-layer pre-validation check before passing user input to Altcha::verifySolution(). By inspecting the decoded payload and rejecting any request where the signature field is missing, empty, or non-string, the application forces the null !== $payload->challenge->signature condition in the vulnerable library to evaluate to true:

// Application-layer workaround prior to calling verifySolution()
$rawJson = base64_decode($submittedAltchaPayload, true);
if (false === $rawJson) {
    throw new \InvalidArgumentException('Malformed base64 payload.');
}
 
$decodedPayload = json_decode($rawJson, true);
if (!is_array($decodedPayload) 
    || empty($decodedPayload['challenge']['signature']) 
    || !is_string($decodedPayload['challenge']['signature'])
) {
    throw new \InvalidArgumentException('Missing or invalid challenge signature.');
}
 
// Safe to proceed to $altcha->verifySolution() as signature is guaranteed non-null

Security teams should also review HTTP access and application logs for anomalous spikes in requests to CAPTCHA-protected endpoints, or multiple requests submitting identical altcha payload strings, which may indicate automated exploitation prior to patching.

Official Patches

altcha-orgGitHub Commit 8b02ad2c9b82998613bac4d093517d457061cbbe
altcha-orgALTCHA PHP Library Release v2.0.3
GitHub Security AdvisoriesGitHub Security Advisory GHSA-82w8-65qw-gch6

Fix Analysis (1)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N

Affected Systems

altcha-org/altcha (Packagist / PHP Composer)altcha-org/altcha-lib-php

Affected Versions Detail

Product
Affected Versions
Fixed Version
altcha-org/altcha
altcha-org
>= 2.0.0, < 2.0.32.0.3
AttributeDetail
CVE / GHSA IDCVE-2026-71481 / GHSA-82w8-65qw-gch6
Weakness ClassCWE-347: Improper Verification of Cryptographic Signature
Affected Componentaltcha-org/altcha ( >= 2.0.0, < 2.0.3 ) - Altcha::verifySolution()
Attack VectorRemote, Unauthenticated via HTTP/HTTPS (AV:N/AC:L/PR:N/UI:N)
CVSS v3.1 Score7.5 High (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N)
Security ImpactComplete Proof-of-Work CAPTCHA Verification Bypass
Exploit StatusProof-of-Concept (Vendor unit test in commit 8b02ad2c9b82998613bac4d093517d457061cbbe)
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1562.001Impair Defenses: Disable or Modify Tools
Defense Evasion
T1110Brute Force
Credential Access
CWE-347
Improper Verification of Cryptographic Signature

The product does not verify, or incorrectly verifies, the cryptographic signature for data, allowing an attacker to modify the data or provide counterfeit data that is accepted as authentic.

Vulnerability Timeline

Fix commit 8b02ad2c9b82998613bac4d093517d457061cbbe authored and merged in altcha-org/altcha-lib-php
2026-07-02
CVE-2026-71481 and GHSA-82w8-65qw-gch6 published by GitHub Security Advisories
2026-11-18
NVD and OSV databases publish vulnerability records with CVSS v3.1 score of 7.5
2026-11-18

References & Sources

  • [1]GitHub Security Advisory GHSA-82w8-65qw-gch6
  • [2]Fix Commit 8b02ad2c9b82998613bac4d093517d457061cbbe
  • [3]ALTCHA PHP Library Release v2.0.3
  • [4]CVE-2026-71481 Record on CVE.org
  • [5]ALTCHA PHP Library GitHub Repository

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

•13 minutes ago•CVE-2026-69131
4.3

CVE-2026-69131: Missing Authorization in django-filer Bulk Deletion Admin Action

A missing authorization vulnerability exists in django-filer versions prior to 3.5.0 when the optional per-folder permission system (FILER_ENABLE_PERMISSIONS) is enabled. The bulk delete admin action (delete_files_or_folders) verifies global Django model-level deletion permissions but fails to enforce object-level FolderPermission edit checks. Consequently, an authenticated staff user holding model-level delete rights can delete files, folders, and directory trees from folders where their access has been explicitly restricted to read-only via FolderPermission.

Alon Barad
Alon Barad
1 views•9 min read
•about 1 hour ago•CVE-2026-75506
6.6

CVE-2026-75506: Second-Order OS Command Injection in OliveTin shellAfterCompleted Hook

CVE-2026-75506 (GHSA-vc6p-m6vx-6cwq) is a second-order OS command injection vulnerability in OliveTin affecting versions 3000.0.0 prior to 3000.18.1. The post-execution hook mechanism, shellAfterCompleted, interpolates runtime execution outputs and username variables directly into a shell command string passed to sh -c without validation. When an action emits untrusted output containing shell metacharacters, those metacharacters break out of the intended syntax and execute arbitrary OS commands under the context of the OliveTin service process.

Alon Barad
Alon Barad
3 views•10 min read
•about 5 hours ago•CVE-2026-61618
6.9

CVE-2026-61618: Improper Input Validation of KZG Accumulator Limbs in snark-verifier

CVE-2026-61618 (GHSA-265x-v3qf-ff6p) is an improper input validation vulnerability (CWE-20) in Axiom Crypto's snark-verifier library prior to version 0.2.5. The library decodes KZG accumulator public-instance limbs without enforcing canonical bit-width bounds prior to elliptic curve coordinate reconstruction. In the Ethereum Virtual Machine (EVM) loader path, the generated Yul bytecode validates that reconstructed affine coordinates lie on the elliptic curve, but fails to verify that the constituent limbs respect their allocated bit-widths, allowing non-canonical proof representations. In the native Rust execution path, accumulator decoding relies on unchecked assertions and unwraps, allowing malformed public instances to trigger an unhandled process panic.

Amit Schendel
Amit Schendel
4 views•12 min read
•about 6 hours ago•CVE-2026-63496
7.8

CVE-2026-63496: OS Command Injection in @augment-vir/node grep() Helper

An OS command injection vulnerability (CWE-78) exists in the @augment-vir/node package prior to version 31.73.5. The grep() utility function builds a shell command string by interpolating caller-supplied search patterns inside double quotes and executes the string through bash via runShellCommand(). Because bash evaluates command substitution expressions inside double-quoted strings, an attacker controlling the search pattern input can execute arbitrary OS commands with the privileges of the Node.js runtime.

Alon Barad
Alon Barad
4 views•8 min read
•about 18 hours 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
9 views•9 min read
•about 19 hours ago•CVE-2026-63634
6.9

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

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.

Amit Schendel
Amit Schendel
5 views•11 min read