Amazon::Credentials versions through 1.2.0 for Perl uses rand to generate encryption keys.
Amazon::Credentials stores credentials in an obfuscated form to prevent access to the secrets from a data dump of the object.
Before version 1.3.0, the secrets were encrypted using a 64-bit key that was generated using the built-in rand function, which is predictable and unsuitable for cryptography.
WebDyne::Session versions before 3.003_704 for Perl generate the session id insecurely.
The session handler generates the session id from an MD5 hash seeded with a call to the built-in rand() function. The rand function is passed a maximum value based on the process id, the epoch time and the reference address of the object, but this information will have no effect on the overall quality of the seed of the message digest.
The rand function is seeded by 32-bits and is predictable. It is considered unsuitable for cryptographic purposes.
Predictable session ids could allow an attacker to gain access to systems.
Note that WebDyne::Session versions 1.042 and earlier appear to be in separate distributions from WebDyne.
Crypt::PasswdMD5 versions through 1.42 for Perl use the built-in rand function to generate salts, which is cryptographically weak and predictable. This vulnerability (CVE-2026-6659) results in insecure random values for salts, weakening the cryptographic strength of password hashing. The issue is classified under CWE-338 for use of a weak pseudo-random number generator. No official patch or remediation has been indicated yet.
RELATE is a web-based courseware package. Prior to commit 2f68e16, RELATE is vulnerable to predictable token generation in auth.py's make_sign_in_key() function and exam.py's gen_ticket_code() function. This issue has been patched via commit 2f68e16.
Dancer::Session::Abstract versions through 1.3522 for Perl generates session ids insecurely.
The session id is generated from summing the character codepoints of the absolute pathname with the process id, the epoch time and calls to the built-in rand() function to return a number between 0 and 999-billion, and concatenating that result three times.
The path name might be known or guessed by an attacker, especially for applications known to be written using Dancer with standard installation locations.
The epoch time can be guessed by an attacker, and may be leaked in the HTTP header.
The process id comes from a small set of numbers, and workers may have sequential process ids.
The built-in rand() function is seeded with 32-bits and is considered unsuitable for security applications.
Predictable session ids could allow an attacker to gain access to systems.
SmarterTools SmarterMail builds prior to 9610 contain a cryptographic weakness in the file and email sharing endpoints that use DES-CBC encryption with keys and initialization vectors derived from System.Random seeded with insufficient entropy, reducing the seed space to approximately 19,000 possible values. An unauthenticated attacker can use the attachment download endpoint as an oracle to determine the seed in use and derive encryption keys and initialization vectors to forge sharing tokens for arbitrary emails, attachments, or file storage contents without prior access to the targeted content.
CryptX versions before 0.088 for Perl contain a vulnerability where the Crypt::PK pseudo-random number generator (PRNG) state is not reseeded after a process fork. This causes child processes to share identical PRNG states, leading to identical outputs in cryptographic operations such as key generation and signing. Specifically, ECDSA or DSA signatures generated by different processes can leak the private key due to nonce reuse. This affects preforking services like the Starman web server that load Crypt::PK::* objects before forking. The vulnerability has a high severity with a CVSS score of 7.5.
Apache::API::Password versions through 0.5.2 for Perl can generate insecure random values for salts.
The _make_salt and _make_salt_bcrypt methods will attept to load Crypt::URandom and then Bytes::Random::Secure to generate random bytes for the salt. If those modules are unavailable, it will simply return 16 bytes generated with Perl's built-in rand function.
The rand function is unsuitable for cryptographic use.
These salts are used for password hashing.
Solstice::Session versions through 1440 for Perl generates session ids insecurely.
The _generateSessionID method returns an MD5 digest seeded by the epoch time, a random hash reference, a call to the built-in rand() function and the process id.
The same method is used in the _generateID method in Solstice::Subsession, which is part of the same distribution.
The epoch time may be guessed, if it is not leaked in the HTTP Date header. Stringified hash refences will contain predictable content. The built-in rand() function is seeded by 16-bits and is unsuitable for security purposes. The process id comes from a small set of numbers.
Predictable session ids could allow an attacker to gain access to systems.
CVE-2026-5083 affects Ado::Sessions versions through 0.935 for Perl by generating insecure, predictable session IDs. The session IDs are created using a SHA-1 hash seeded with the built-in rand function, epoch time, and process ID (PID). Because the PID is from a small set and the epoch time can be guessed or leaked, the session IDs are predictable. This vulnerability could allow attackers to guess session IDs and potentially gain unauthorized access. The Ado::Sessions project is no longer maintained and has been removed from the CPAN index, though it remains available on BackPAN. No official patch or remediation is currently available.
CVE-2026-5082 affects Amon2::Plugin::Web::CSRFDefender versions 7.00 through 7.03 for Perl, where the module generates insecure session IDs. The vulnerability arises because if /dev/urandom is unavailable, the session ID generation falls back to a SHA-1 hash seeded with the built-in rand() function, process ID, and epoch time, which are predictable or guessable values. This weak randomness can lead to predictable session identifiers. The module has been deprecated by its author. No official patch or remediation is currently documented.
PAGI::Middleware::Session::Store::Cookie versions through 0.001003 for Perl generates random bytes insecurely.
PAGI::Middleware::Session::Store::Cookie attempts to read bytes from the /dev/urandom device directly. If that fails (for example, on systems without the device, such as Windows), then it will emit a warning that recommends the user install Crypt::URandom, and then return a string of random bytes generated by the built-in rand function, which is unsuitable for cryptographic applications.
This modules does not use the Crypt::URandom module, and installing it will not fix the problem.
The random bytes are used for generating an initialisation vector (IV) to encrypt the cookie.
A predictable IV may make it easier for malicious users to decrypt and tamper with the session data that is stored in the cookie.
Business::OnlinePayment::StoredTransaction versions through 0.01 for Perl uses an insecure secret key.
Business::OnlinePayment::StoredTransaction generates a secret key by using a MD5 hash of a single call to the built-in rand function, which is unsuitable for cryptographic use.
This key is intended for encrypting credit card transaction data.
HTTP::Session versions before 0.54 for Perl defaults to using insecurely generated session ids.
HTTP::Session defaults to using HTTP::Session::ID::SHA1 to generate session ids using a SHA-1 hash seeded with the built-in rand function, the high resolution epoch time, and the PID. The PID will come from a small set of numbers, and the epoch time may be guessed, if it is not leaked from the HTTP Date header. The built-in rand function is unsuitable for cryptographic usage.
The distribution includes HTTP::session::ID::MD5 which contains a similar flaw, but uses the MD5 hash instead.
Amon2 versions before 6.17 for Perl use an insecure random_string implementation for security functions.
In versions 6.06 through 6.16, the random_string function will attempt to read bytes from the /dev/urandom device, but if that is unavailable then it generates bytes by concatenating a SHA-1 hash seeded with the built-in rand() function, the PID, and the high resolution epoch time. The PID will come from a small set of numbers, and the epoch time may be guessed, if it is not leaked from the HTTP Date header. The built-in rand function is unsuitable for cryptographic usage.
Before version 6.06, there was no fallback when /dev/urandom was not available.
Before version 6.04, the random_string function used the built-in rand() function to generate a mixed-case alphanumeric string.
This function may be used for generating session ids, generating secrets for signing or encrypting cookie session data and generating tokens used for Cross Site Request Forgery (CSRF) protection.
Net::NSCA::Client versions through 0.009002 for Perl uses a poor random number generator.
Version v0.003 switched to use Data::Rand::Obscure instead of Crypt::Random for generation of a random initialisation vectors.
Data::Rand::Obscure uses Perl's built-in rand() function, which is not suitable for cryptographic functions.
CVE-2025-40931 affects Apache::Session::Generate::MD5 for Perl, which generates session IDs using an insecure method. The session IDs are created by hashing a combination of the built-in rand() function, epoch time, and process ID (PID) with MD5. Because rand() is not cryptographically secure, and the PID and epoch time can be guessed or inferred, the session IDs are predictable. This predictability could allow attackers to hijack sessions and gain unauthorized access. Some Debian-based distributions have patched this by replacing the generator with Crypt::URandom. No official patch or vendor advisory is provided for the original module. The vulnerability has a CVSS score of 9.1, indicating critical severity.
CVE-2025-40926 is a critical vulnerability in Plack::Middleware::Session::Simple versions before 0.05 for Perl, where session IDs are generated using a predictable method. The default session ID generator uses a SHA-1 hash seeded with the built-in rand function, epoch time, and process ID (PID). Since the PID is from a small set of numbers and the epoch time can be guessed or leaked, the session IDs are predictable. This weakness can allow attackers to guess valid session IDs and potentially gain unauthorized access. The vulnerability has a CVSS score of 9.8, indicating a critical severity level. No patch or official fix information is provided in the available data.