/

CVE-2026-33488

Severity:

HIGH RISK

(7.4)

Insufficient Cryptographic Strength in WWBN AVideo PGP 2FA

CVE-2026-33488

Analyzed

Vulnerability type

Category:

Insufficient Cryptographic Strength

CWE:

CWE-326

Impact:

Two-Factor Authentication Bypass and Resource Exhaustion

Severity:

HIGH RISK

(7.4)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

WWBN AVideo's LoginControl plugin uses 512-bit RSA keys for its PGP-based two-factor authentication, a key size that is trivially factorable with modern hardware.

An attacker who captures a user's public key can derive the corresponding private key, decrypt 2FA challenges, and effectively bypass the second factor; additionally, unauthenticated endpoints expose CPU-intensive cryptographic operations to anonymous users.

Affected context

This issue arises in WWBN AVideo deployments that:

  • Enable the LoginControl plugin's PGP-based two-factor authentication system, and
  • Rely on the plugin's createKeys() function to generate user keys, and
  • Expose the generateKeys.json.php and encryptMessage.json.php endpoints over the network.

Under these conditions, the system may appear to offer strong cryptographic protection for 2FA, but in practice uses obsolete key sizes and unauthenticated endpoints, weakening the actual security guarantees.

Exploit preconditions

  • Attack surface (2FA bypass):
  • Network-accessible AVideo instance with PGP 2FA enabled for target users.
  • Target user's public PGP key must be obtainable (e.g., from the application, logs, or other exposure paths).
  • Attack surface (resource exhaustion):
  • generateKeys.json.php and encryptMessage.json.php accessible without authentication.
  • Required access:
  • For 2FA bypass: Ability to observe or retrieve the victim's public key and interact with the login/2FA flow.
  • For resource exhaustion: Any network access to the affected endpoints (anonymous/unauthenticated).
  • Trigger point:
  • 2FA bypass occurs when the system encrypts a challenge to the user's PGP key, which the attacker can decrypt using the factored private key.
  • Resource exhaustion occurs when an attacker repeatedly calls cryptographic endpoints to force key generation or encryption operations.
  • Why exploitation is possible:
  • 512-bit RSA moduli are within practical factoring range for commodity hardware.
  • The design assumes that small key sizes still provide meaningful security and that cryptographic endpoints do not require prior authentication or rate limiting.

Why this happens

The core issue maps to CWE-326: Inadequate Encryption Strength. The LoginControl plugin's createKeys() function generates 512-bit RSA key pairs, which are far below modern minimum recommendations and have been publicly known to be factorable at low cost for decades.

Instead of enforcing strong, policy-driven key sizes and validating cryptographic parameters against contemporary standards, the implementation hard-codes or permits use of legacy key lengths. This results in cryptographic artifacts that can be efficiently broken, undermining the confidentiality and authenticity assumptions of PGP-based 2FA.

A secondary design flaw is the exposure of cryptographically heavy operations via generateKeys.json.php and encryptMessage.json.php without any authentication or throttling. This creates a denial-of-service vector where attackers can drive disproportionate CPU usage by repeatedly invoking these endpoints.

Potential impact

  • Attackers may factor a user's 512-bit RSA public key and compute the corresponding private key.
  • Two-factor authentication challenges can be decrypted and solved by attackers, allowing full 2FA bypass.
  • User accounts that rely on PGP 2FA can be compromised even if the user's password remains secret.
  • Automated attacks can abuse unauthenticated key generation/encryption endpoints to cause CPU exhaustion and degrade service availability.
  • Overall trust in the platform's authentication assurances may be reduced due to cryptographic weakness.

General mitigation guidance

Mitigations should focus on raising cryptographic strength and hardening access to crypto endpoints:

  • Enforce modern key sizes for RSA (e.g., 2048 bits or higher) as a non-configurable minimum within the plugin, and validate any existing keys against this policy.
  • Centralize cryptographic parameter definitions and prohibit use of deprecated algorithms or key lengths through configuration and code-level constants.
  • Require authentication and appropriate authorization for any endpoints that perform key generation or message encryption, and apply rate limiting or quotas to control computational load.
  • Introduce server-side checks that reject or flag keys below a defined security threshold, and guide users to regenerate keys when weak keys are detected.
  • Apply least-privilege and defense-in-depth around authentication components so that even if cryptographic protections degrade, additional controls can limit account takeover.

How teams detect issues like this

Useful detection approaches include:

  • Static analysis and code review:
  • Identify calls to cryptographic libraries where RSA key sizes are specified, and flag values below organizational policy (e.g., <2048 bits).
  • Look for hard-coded cryptographic parameters (key lengths, algorithms) and lack of configuration or policy validation.
  • Detect HTTP endpoints that trigger cryptographic operations but lack authentication checks or rate limiting.
  • Runtime and configuration auditing:
  • Periodically scan stored keys and certificates to detect weak key sizes or legacy algorithms in use.
  • Monitor logs for unusually high invocation rates of key generation or encryption endpoints, indicating potential abuse.
  • Security policy enforcement:
  • Integrate security linters or SAST tools into CI to enforce cryptographic standards.
  • Use WAF or API gateways to enforce authentication and rate limits on sensitive cryptographic endpoints, even if application code is misconfigured.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/00d979d87f8182095c8150609153a43f834e351e
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-6m5f-j7w2-w953

Frequently asked

questions

The 2FA bypass is broadly exploitable wherever the LoginControl PGP 2FA is enabled and an attacker can obtain a user's public key; factoring 512-bit RSA is within reach of modest hardware. The resource exhaustion aspect is exploitable by any unauthenticated party with network access to the affected endpoints.

For 2FA bypass, an attacker needs network access to the login interface and a way to obtain the victim's PGP public key. For CPU exhaustion, only unauthenticated HTTP access to the generateKeys.json.php and encryptMessage.json.php endpoints is required.

Enforce strong, standards-aligned cryptographic parameters (e.g., RSA ≥ 2048 bits) in the code, invalidate or migrate weak keys, and require authentication plus rate limiting for any endpoints that perform heavyweight cryptographic operations.

Adopt organization-wide cryptographic guidelines, use vetted libraries with secure defaults, add automated checks in CI to flag weak crypto configurations, and ensure that any security-sensitive endpoints are protected by authentication, authorization, and abuse-prevention mechanisms.

Find out what's already
exploitable in your codebase.