FreeScout versions prior to 1.8.213 use a weak and predictable method to generate attachment download tokens, allowing unauthenticated attackers to forge valid tokens and download private attachments. The tokens are generated using md5 hashing of a concatenation of APP_KEY, a sequential attachment_id, and a size value that can be brute-forced. This vulnerability is fixed in version 1.8.213.
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.
Generation of Predictable Numbers or Identifiers vulnerability in Erlang/OTP kernel (inet_res, inet_db modules) allows DNS Cache Poisoning.
The built-in DNS resolver (inet_res) uses a sequential, process-global 16-bit transaction ID for UDP queries and does not implement source port randomization. Response validation relies almost entirely on this ID, making DNS cache poisoning practical for an attacker who can observe one query or predict the next ID. This conflicts with RFC 5452 recommendations for mitigating forged DNS answers.
inet_res is intended for use in trusted network environments and with trusted recursive resolvers. Earlier documentation did not clearly state this deployment assumption, which could lead users to deploy the resolver in environments where spoofed DNS responses are possible.
This vulnerability is associated with program files lib/kernel/src/inet_db.erl and lib/kernel/src/inet_res.erl.
This issue affects OTP from OTP 17.0 before OTP 26.2.5.19, OTP 27.3.4.10, and OTP 28.4.2, corresponding to kernel from 3.0 before 9.2.4.11, 10.2.7.4, and 10.6.2.
IBM Concert versions 1.0.0 through 2.2.0 have a vulnerability where temporary files are created with predictable names. This flaw allows local users to perform symlink attacks to overwrite arbitrary files. The vulnerability does not impact confidentiality or availability but can lead to integrity compromise. It has a CVSS 3.1 score of 6.2, indicating medium severity.
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.
A vulnerability in AWS Bedrock AgentCore Starter Toolkit before version v0.1.13 allows remote code execution due to missing S3 ownership verification during the build process. This affects users who built the toolkit after September 24, 2025, on versions prior to v0.1.13. Upgrading to version v0.1.13 mitigates the issue.
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.
HTTP::Session2 versions before 1.12 for Perl for Perl may generate weak session ids using the rand() function.
The HTTP::Session2 session id generator returns a SHA-1 hash seeded with the built-in rand function, the 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.
HTTP::Session2 after version 1.02 will attempt to use the /dev/urandom device to generate a session id, but if the device is unavailable (for example, under Windows), then it will revert to the insecure method described above.
Apache::SessionX versions through 2.01 for Perl create insecure session id.
Apache::SessionX generates session ids insecurely. The default session id generator in Apache::SessionX::Generate::MD5 returns a MD5 hash seeded with the built-in rand() function, the 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. Predicable session ids could allow an attacker to gain access to systems.
Predictable bucket naming in Vertex AI Experiments in Google Cloud Vertex AI from version 1.21.0 up to (but not including) 1.133.0 on Google Cloud Platform allows an unauthenticated remote attacker to achieve cross-tenant remote code execution, model theft, and poisoning via pre-creating predictably named Cloud Storage buckets (Bucket Squatting).
This vulnerability was patched and no customer action is needed.
Concierge::Sessions versions from 0.8.1 before 0.8.5 for Perl generate insecure session ids. The generate_session_id function in Concierge::Sessions::Base defaults to using the uuidgen command to generate a UUID, with a fallback to using Perl's built-in rand function. Neither of these methods are secure, and attackers are able to guess session_ids that can grant them access to systems. Specifically,
* There is no warning when uuidgen fails. The software can be quietly using the fallback rand() function with no warnings if the command fails for any reason.
* The uuidgen command will generate a time-based UUID if the system does not have a high-quality random number source, because the call does not explicitly specify the --random option. Note that the system time is shared in HTTP responses.
* UUIDs are identifiers whose mere possession grants access, as per RFC 9562.
* The output of the built-in rand() function is predictable and unsuitable for security applications.
CVE-2025-68701 is a high-severity cryptographic vulnerability in the Jervis library used for Jenkins Job DSL and shared pipeline scripts. Versions prior to 2.2 use a deterministic AES initialization vector (IV) derived from a passphrase, which weakens encryption by making ciphertext patterns predictable and susceptible to cryptanalysis. This flaw allows attackers to potentially recover sensitive data or compromise the confidentiality of encrypted information without requiring authentication or user interaction. The vulnerability has a CVSS 4.0 base score of 8.7, indicating a network-exploitable issue with high impact on confidentiality. The issue is fixed in Jervis version 2.2. European organizations relying on Jenkins automation with Jervis versions before 2.
RAGFlow is an open-source RAG (Retrieval-Augmented Generation) engine. In versions prior to 0.22.0, the use of an insecure key generation algorithm in the API key and beta (assistant/agent share auth) token generation process allows these tokens to be mutually derivable. Specifically, both tokens are generated using the same `URLSafeTimedSerializer` with predictable inputs, enabling an unauthorized user who obtains the shared assistant/agent URL to derive the personal API key. This grants them full control over the assistant/agent owner's account. Version 0.22.0 fixes the issue.
SOPlanning has a vulnerability in its password recovery token generation mechanism that allows attackers to predict and brute-force recovery tokens. This flaw enables account takeover by guessing tokens within a reasonable time. The vulnerability is fixed in version 1.55.
On BIG-IP systems, undisclosed traffic can cause data corruption and unauthorized data modification in protocols which do not have message integrity protection. Note: Software versions which have reached End of Technical Support (EoTS) are not evaluated.
A Generation of Predictable Numbers or Identifiers vulnerability in the SDM component of B&R Automation Runtime versions before 6.4 may allow an unauthenticated network-based attacker to take over already established sessions.