Description

YesWiki is a wiki system written in PHP. From version 4.6.2 to before version 4.6.6, HttpSignatureService::verifySignature() checks the result of PHP's openssl_verify() with a loose boolean negation - if (!openssl_verify(...)) { throw ... }. PHP's openssl_verify has four possible return values: 1, 0, -1, and "false". The -1 row is the bypass: PHP's truthiness rules make -1 a truthy value, so !(-1) === false, the throw is skipped, and the controller proceeds to processActivity(). Any condition that makes OpenSSL's EVP_VerifyFinal() return -1 triggers the bypass. The reachable consequence is the controller silently treats a failed verification as success and processes the attacker's payload. This issue has been patched in version 4.6.6.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "8.2",
  "pubDate": "2026-09-05T00:17:19.540Z",
  "pubdate": "2026-09-05T00:17:19.540Z",
  "executiveSummary": "YesWiki versions 4.6.2 through 4.6.5 contain a critical authentication bypass vulnerability within the HttpSignatureService component. The flaw arises from an incorrect implementation of the openssl_verify() function's return value check. By failing to account for the -1 return value—which signifies an error during the verification process—the application incorrectly treats verification failures as successful authentication attempts.\nThis vulnerability allows an attacker to bypass cryptographic signature validation, effectively permitting the processing of arbitrary, unauthenticated activity payloads. An attacker can leverage this to inject malicious requests into the system, potentially leading to unauthorized data modification or administrative actions. The risk is considered high due to the ease of exploitation and the bypass of fundamental security controls. Users are urged to upgrade to version 4.6.6 to fully remediate this flaw.",
  "technicalDetails": "The vulnerability resides in the HttpSignatureService::verifySignature() method within YesWiki. In PHP, the openssl_verify() function returns 1 for a correct signature, 0 for an incorrect signature, and -1 if an error occurs (such as an invalid public key or malformed signature data).\nThe root cause is a type-juggling error in the application's verification logic: if (!openssl_verify(...)) { throw ... }. In PHP's loose comparison and boolean evaluation, both 0 (false) and false (on failure) evaluate to false, causing the exception to be thrown correctly for these cases. However, -1 is treated as a truthy value. Therefore, when openssl_verify() returns -1, the expression !(-1) evaluates to false, the exception block is bypassed, and the application execution continues as if the signature were valid.\nThe attack flow proceeds as follows: An attacker sends a crafted request containing a malicious payload and a malformed signature that intentionally triggers an error in the underlying OpenSSL EVP_VerifyFinal() function. Because the error condition -1 does not trigger the exception, the HttpSignatureService mistakenly signals that verification was successful. Control is then passed to the processActivity() function, which proceeds to execute the logic associated with the payload without ever having verified its authenticity or integrity.\nThis vulnerability effectively nullifies signature-based authentication mechanisms within the impacted versions. Because the failure condition is skipped, the application becomes susceptible to the processing of unauthenticated or tampered requests. Depending on the exposed functionality of processActivity(), an attacker could potentially achieve unauthorized state changes or interact with system components that rely on HttpSignatureService for security validation. Exploitation requires the attacker to be able to submit requests that utilize the signature verification flow, but it does not require prior valid credentials, as the bypass occurs during the authentication phase itself."
}