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.phpandencryptMessage.json.phpendpoints 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.phpandencryptMessage.json.phpaccessible 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.

