IBM API Connect 10.0.8.0 through 10.0.8.12 could allow a local attacker to obtain sensitive information due to the use of a cryptographically weak pseudo-random number generator.
IBM API Connect 10.0.8.0 through 10.0.8.12 could allow a remote attacker to gain full administrative control due to the use of a cryptographically weak pseudo-random number generator.
CallBackery versions prior to 0.62.0 for Perl use a cryptographically weak pseudo-random number generator (PRNG) to generate the signing secret for session cookies. The secret is derived from two calls to the built-in rand() function, which is seeded with only 32 bits, resulting in at most 2^32 possible secret values. An attacker who obtains a single signed session cookie can perform an offline brute-force attack to recover the secret and then forge session cookies for any user, including administrators. This vulnerability is fixed in version 0.62.0.
CVE-2026-102813 is an authentication vulnerability in the password-recovery feature of the TP-Link RE305 V3 device. The verification-code interface can be accessed by an unauthenticated attacker on the same local network, who can trigger generation of an administrator password-reset verification code. Due to the lack of an effective attempt counter or lockout mechanism and the use of a predictable verification-code generation process, an attacker may brute-force or obtain the code. Successful exploitation allows resetting the administrator password and gaining privileged device-management access.
The download link for files uploaded through a form relied on a token that could be predicted. The file name in the request was also not verified in a way that resisted guessing. An unauthenticated attacker could use this to access files uploaded by other visitors. In addition, the token was shown in plain text in the text version of the notification email.
Incorrect permission assignment in GlavSoft TightVNC Server for Windows before 2.8.88 allows a local authenticated user to read or overwrite the inter-process communication handles used between the TightVNC service and its desktop server process. The named shared memory segment in the Global\ namespace that carries the pipe HANDLE values is created with a NULL DACL, and its name is derived from a time-seeded srand(time(0)) value that is predictable to one-second granularity. A low-privileged local process can open the mapping and tamper with the IPC channel of a service running as SYSTEM, potentially leading to disclosure of session data, privilege escalation, or denial of service.
AsyncHttpClient versions prior to 3.0.12 and 2.16.1 use a cryptographically weak pseudo-random number generator (ThreadLocalRandom) to generate the HTTP Digest client nonce (cnonce). This weak randomness reduces the security of the authentication exchange by making the nonce more predictable. The issue is fixed in versions 3.0.12 and 2.16.1.
Fortra BoKS Server Agent contains a predictable password generation vulnerability in the adjoin utility. Machine-account passwords generated during Active Directory join or password renewal operations may have significantly less entropy than intended, making them more susceptible to prediction by an attacker who can estimate when the password was generated.
In deployments using BoKS keytab management, affected versions of boks_keytabmd generate Active Directory service-account passwords from a predictable pseudo-random sequence seeded with the current Unix timestamp. An attacker who knows the service principal and can estimate the password-change time can reproduce a limited candidate set and verify candidates offline.
Eclipse ThreadX NetX Duo versions 6.0 through 6.5.2.202603a use a cryptographically weak pseudo-random number generator (PRNG) for generating HelloVerifyRequest cookies in the DTLS server. The default NX_RAND() function relies on the standard C library rand() without a key or client binding. This weakness allows an attacker who can predict the PRNG output to spoof the cookie exchange and cause the server to send handshake data to a victim, effectively using the server as a traffic reflector.
Postiz-app versions before 2.4.0 generate security-sensitive credentials using a non-cryptographically secure pseudorandom number generator (Math.random()), exposing OAuth tokens and keys to compromise. An unauthenticated OAuth dynamic client registration endpoint leaks client credentials, enabling attackers to reconstruct the PRNG internal state and predict past and future credentials. This vulnerability has a critical severity with a CVSS score of 9.1.
The sm-crypto JavaScript library for Chinese cryptographic algorithms SM2, SM3, and SM4 has a critical vulnerability in versions prior to 0.5.0. The default key generation in Node.js uses a cryptographically weak pseudo-random number generator seeded from Math.random() and the current time, allowing attackers who can observe Math.random() outputs and estimate key generation time to recover private keys and forge signatures. This issue is fixed in version 0.5.0.
crypto-js is a JavaScript library of crypto standards. Versions of crypto-js prior to 4.0.0 generate randomness in CryptoJS.lib.WordArray.random() using a custom variation of the Multiply-With-Carry pseudorandom number generator, seeded from Math.random(), instead of a cryptographically secure source. This generator was introduced in version 3.1.2-4 and remained present in nearly every 3.x release. Nominal requests for 128 or 256 bits of entropy through this function produce effective search spaces of approximately 2 to the 39th and 2 to the 47th possibilities, small enough to enumerate on commodity hardware. Downstream wallet applications that used CryptoJS.lib.WordArray.random() as the entropy source for BIP39 recovery phrases are affected, and an attacker who enumerates the reduced output space can recover the resulting private keys and control the associated funds. This issue is fixed in version 4.0.0.
When enabling Spring Boot DevTools support for a remote application target (for example a Docker container or Cloud Foundry app) from the Spring Tools Boot Dashboard, Spring Tools generates a shared secret that authenticates DevTools remote-restart uploads to the deployed application. This secret was generated using a non-cryptographic pseudo-random number generator rather than a cryptographically secure source of randomness.
Affected Spring Products and Versions:
Spring Tools for Eclipse: 5.2.0 and earlier
Joomla Extension - regularlabs.com - Insecure login URL keys in IP login extension - Persistent URL login keys were also generated using a non-cryptographic random generator with insufficient entropy.
ExtremeXOS (EXOS) uses a challenge-response mechanism to authorize access to the privileged debug-mode function. The challenge value is generated using an insufficiently random source, which under certain conditions may allow an attacker to predict the expected response and activate debug-mode without authorization. Depending on device configuration and version, this may enable escalation to root-level access and persistent modification of the device software stack. Exploitation requires either a valid low-privilege account on the device (remote scenario) or physical serial console access (local scenario). This vulnerability is distinct from CVE-2017-14329, which addressed a different issue involving Python script privileges.
Extreme would like to thank Hadrien Barral (Université Gustave Eiffel) and Georges-Axel Jaloyan (French Ministry of the Interior) for responsible disclosure of their findings.
Dancer2 versions before 2.2.0 for Perl generate insecure session ids when required CSPRNG modules are unavailable.
Dancer2::Core::Role::SessionFactory::generate_id silently falls back to a built-in rand-derived session id unless both Math::Random::ISAAC::XS and Crypt::URandom are available.
The fallback session id is generated from a SHA-1 hash of a call to the built-in rand function, the absolute path of the Dancer2::Core::Role::SessionFactory module, an internal counter, the process id, the module instance memory address, and a shuffled string of characters (using the List::Util::shuffle function, which also uses the built-in rand function).
These are all low-entropy and easily guessed sources.
The built-in rand() function is seeded with 32-bits and considered unsuitable for security applications.
Predictable session ids could allow an attacker to gain access to systems.
Crypt::Password versions through 0.28 for Perl generate insecure random values for salts.
These versions use the built-in rand function, which is predictable and unsuitable for cryptography.
GD::SecurityImage versions through 1.75 for Perl use rand to generate secrets.
The random method creates the challenge text used for the CAPTCHA by sampling characters from an array using Perl's built-in rand function, and generates a (by default) six-character string.
The built-in rand function is unsuitable for security applications because it is predictable and reversible.