Search: cases.org
59 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| –Not rated | – | AlienVault OTX General An exposed attacker server has unveiled FortiBleed, a large-scale credential-compromise campaign targeting internet-facing Fortinet FortiGate firewalls and SSL VPN gateways globally. This operation involved credential harvesting through reuse, brute force, and hash cracking using a distributed GPU infrastructure with approximately 36 rented GPUs via Hashtopolis. The exposed directory contained 319 files revealing scanning tools, cracking infrastructure, credential databases, post-exploitation toolkits, and active VPN configurations. While initially reported as affecting 21,632 domains, analysis of the attacker's own tooling reveals only 918 organizations showed evidence of internal network compromise, with merely 148 confirmed cases where credentials were fully cracked. The operation ultimately aimed to sell initial access to compromised networks, with victims spanning 194 countries, predominantly India, United States, and Taiwan. | AlienVault OTX General | |||
| –Not rated | – | Reddit Cybersecurity The shift to remote hiring has expanded the geographic talent pool but also increased exposure to organized hiring fraud. This includes fake identities, candidate impersonation during interviews, real-time AI-assisted deception, and cases involving state-sponsored actors who gain access to company resources to exfiltrate data. The fraud leads to significant financial losses and wasted time for companies. A new product, 909Shield, aims to address this problem by applying identity verification and zero trust principles early in the hiring process. The issue highlights challenges in verifying candidate identities remotely and raises privacy considerations around biometric verification. | Reddit Cybersecurity | |||
| Medium | 5.4 | EPSS 0.1% | Medium5.4EPSS 0.1%CVE Database V5CVE-2026-48523 > [!NOTE] > Scored assuming a deployment where algorithm policy functions as an authentication/authorization boundary. In deployments where the algorithm policy enforces crypto agility only, the practical confidentiality impact is lower and the issue is closer to an integrity-of-policy-enforcement bug. PyJWT `2.9.0` through `2.12.1` allows a verifier-side algorithm allow-list bypass when `jwt.decode()` or `jwt.decode_complete()` are called with a `PyJWK` key. The token header `alg` is checked against the caller-supplied `algorithms` allow-list, but signature verification is performed with the algorithm bound to the `PyJWK` object instead of the header algorithm. An attacker who controls a registered JWK/JWKS private key can sign with a disallowed algorithm, advertise an allowed algorithm in the JWT header, and still be accepted. The issue affects the documented `PyJWKClient.get_signing_key_from_jwt(...)` flow. ### Summary PyJWT's `PyJWK` verification path allows a verifier-side algorithm allow-list bypass. In affected versions, when a JWT is decoded with a `PyJWK` object, PyJWT verifies that the header `alg` string is present in the caller's `algorithms=[...]` list, but it does not actually use the header algorithm to verify the signature. Instead, it verifies with the algorithm already bound to the `PyJWK` object. This lets an attacker who controls a registered JWK/JWKS private key sign with a disallowed algorithm and have the token accepted as long as the JWT header advertises an allowed algorithm. This affects the documented `PyJWKClient` usage flow and does not require any non-default flags or unsafe configuration. ### Details In `jwt/api_jws.py` in `2.12.1`, `_verify_signature()` treats `PyJWK` keys differently from normal PEM/public-key inputs: ```python if algorithms is None and isinstance(key, PyJWK): algorithms = [key.algorithm_name] ... if not alg or (algorithms is not None and alg not in algorithms): raise InvalidAlgorithmError("The specified alg value is not allowed") if isinstance(key, PyJWK): alg_obj = key.Algorithm prepared_key = key.key else: alg_obj = self.get_algorithm_by_name(alg) prepared_key = alg_obj.prepare_key(key) ``` This logic means: 1. The JWT header `alg` is checked only as a string against the caller-supplied allow-list. 2. If the key is a `PyJWK`, the actual verifier is not selected from the header algorithm. 3. Instead, PyJWT always verifies with `key.Algorithm`, which is fixed when the `PyJWK` object is created. `PyJWK` binds its algorithm in `jwt/api_jwk.py` from the JWK's `alg` field or from key-type defaults: ```python if not algorithm and isinstance(self._jwk_data, dict): algorithm = self._jwk_data.get("alg", None) ... self.algorithm_name = algorithm self.Algorithm = get_default_algorithms()[algorithm] self.key = self.Algorithm.from_jwk(self._jwk_data) ``` So once a `PyJWK` is constructed, the verifier uses the `PyJWK`'s bound algorithm, not the JWT header algorithm. The issue is reachable through the documented JWKS flow. In `docs/usage.rst`, the project documents: ```python signing_key = jwks_client.get_signing_key_from_jwt(token) jwt.decode( token, signing_key, audience="https://expenses-api", options={"verify_exp": False}, algorithms=["RS256"], ) ``` `PyJWKClient.get_signing_key_from_jwt()` returns a `PyJWK`, so this documented path is affected. This is not a "no-key forgery" issue. The attacker still needs control of an accepted JWK/JWKS private key. However, that is realistic in deployments such as: - self-service OAuth client assertions - multi-tenant key registration - federation / BYO-JWKS trust models - any system where external parties sign JWTs with their own registered keys In those cases, the attacker can bypass verifier-side algorithm policy. For example, if the server intends to only accept `PS256`, an attacker controlling an accepted RSA JWK can sign with `RS256`, set `alg=PS256` in the JWT header, and still be accepted through the `PyJWK` path. The same forged token is rejected through the normal PEM/public-key verification path, which shows the bug is specific to `PyJWK` verification rather than expected JWT behavior. This behavior was introduced by commit `ab8176abe21e550dbc1c9a6bb7e78ad80853bfb1` (`Decode with PyJWK (#886)`), which is present in tagged releases `2.9.0`, `2.10.0`, `2.10.1`, `2.11.0`, `2.12.0`, and `2.12.1`. ### PoC Tested locally against PyJWT `2.12.1` on Python `3.12.10` with `cryptography 45.0.6`. Install dependencies: ```bash python -m pip install pyjwt==2.12.1 cryptography ``` Run the following script: ```python import json import jwt from cryptography.hazmat.primitives.asymmetric import rsa from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat from jwt.api_jwk import PyJWK from jwt.algorithms import RSAAlgorithm from jwt.utils import base64url_encode # Generate an RSA keypair controlled by the attacker. priv = rsa.generate_p | CVE Database V5 | ||
| –Not rated | – | Tenable Research As frontier AI models collapse the traditional exploit window, Tenable Hexa AI transforms the security operating model from manual triage to agentic orchestration. See how you can automate vulnerability remediation and super-charge exposure management with Tenable Hexa AI. Key takeaways AI models like Claude Mythos have reduced the time from vulnerability discovery to weaponization from weeks to minutes, making manual defense untenable. Tenable Hexa AI serves as an agentic engine that orchestrates complex, multi-step remediation workflows across modern attack surfaces to accelerate the speed of preemptive security and propel your exposure management program. Using the Model Context Protocol (MCP) included in Tenable Hexa AI, your team can build and deploy custom agents that anchor your preferred LLMs in the Tenable Exposure Data Fabric, ensuring every automated action is governed, auditable, and accurate. Why you need to implement agentic AI in cybersecurity (and specifically, in vulnerability management) For most of my career in cybersecurity, we’ve operated on a fundamental, if unspoken, assumption: We had a grace period. Whenever a new vulnerability was discovered, we knew we had time, often weeks or months, before adversaries would begin exploiting it. The time between vulnerability discovery and exploitation gave us breathing room. It gave us time to patch, triage, and remediate. But not any more. The gap between discovery and exploitation has been shrinking for years, and the vulnerability discovery capabilities demonstrated by frontier AI models like Claude Mythos are narrowing it even more. We have entered the era of AI speed. When an LLM can unearth a 27-year-old vulnerability in a hardened OS in minutes, and then weaponize it in seconds, old defensive cycles can’t keep up, and that’s untenable. This is why I’m so excited to announce the general availability of Tenable Hexa AI , the agentic engine of the Tenable One Exposure Management Platform , at EXPOSURE 2026 : because it’s designed to help your organization address the escalating, AI-driven pace of vulnerability discovery. The agentic AI imperative in cybersecurity: Scale your preemptive defense to match machine speed with agentic innovation from Tenable Tenable Hexa AI is built to be a force multiplier and a flexible engine for innovation. Featuring a suite of built-in agents ready to automate assessment configuration, asset tagging, dashboard creation, ticket creation, and more, Tenable Hexa AI is designed to help your organization overcome the operational challenges deepened by adversarial AI use. When the window between discovery and exploitation hits near-zero, security teams locked in manual vulnerability management operating models are forced into a state of perpetual emergency. Manually stitching together context and telemetry from cloud, identity, OT, and vulnerability silos in an arduous effort to prioritize remediation for downstream IT and DevOps teams is a losing battle. And when you can’t provide clear, risk-based remediation priorities to IT and DevOps teams, you end up bombarding them with seemingly urgent tickets that may not in fact be critical to your organization. Constant shifts in remediation priorities and endless debates over what needs fixing and why is not sustainable. It creates friction and causes you to lose the cybersecurity race. In a world where attackers move at machine speed, only comprehensive exposure intelligence combined with the agentic AI orchestration capabilities provided by the Tenable One Exposure Management Platform can give you clarity and control. Tenable Hexa AI doesn’t just tell you where you are vulnerable; it mobilizes your preemptive defense. Capabilities of Tenable Hexa AI With this GA release, Tenable delivers foundational capabilities to help your organization accelerate the pace of vulnerability discovery and remediation, including: Your choice of agents - Use our pre-built, out-of-the-box agents to start reducing risk immediately, or use the Model Context Protocol (MCP) server built into Tenable Hexa AI to create custom agents tailored to your organization’s environment. Advanced multi-step reasoning - Tenable Hexa AI executes complex, end-to-end workflows spanning your attack surface (e.g., IT, cloud, identity, OT, etc.) in a single request, eliminating the need for practitioners to toggle between views to get exposure context. It understands that a CVE in your web app is a critical threat specifically because it is linked to a privileged service account with a path to your sensitive data. Automated remediation workflows - Tenable Hexa AI orchestrates remediation workflows, automatically creating and routing tickets, generating custom policies, and producing audit-ready reports, so security teams can act fast on every critical exposure. End-to-end exposure path insights - Practitioners can query their environment by identity attributes, such as service accounts, privileged users, and Active Directory groups, to surface exposure paths that traditional asset inventories miss. Tenable Hexa AI also provides guided assistance for complex Active Directory sensor configurations. Build your own AI agents for cybersecurity with Tenable Hexa AI In addition to out-of-the-box agentic capabilities for use cases like automated assessment configuration, asset tagging, and ticket creation, customers can also build custom agents via Tenable Hexa AI's built-in MCP that are informed by your organization’s unique security policies and internal business logic. Tenable Hexa AI serves as the orchestration layer connecting your favorite AI tools to your infrastructure and other security tools, all with the data and context from the Tenable Exposure Data Fabric. By anchoring the models your organization uses in the authoritative context of your own environment, Tenable Hexa AI moves you beyond generic AI answers to governed and auditable automation. Whether you are automating complex remediation or generating board-ready dashboards, Tenable Hexa AI ensures the output is both verifiable and auditable. The Tenable Exposure Data Fabric is key because an agent is only as effective as the data it has access to. Tenable Hexa AI is powered by the Tenable Exposure Data Fabric, a repository of 20 years of vulnerability research and the industry’s largest collection of contextualized exposure data. In other words, we’ve built an agentic engine for cybersecurity that uses the world’s best exposure data to drive machine-speed actions. This is the only way to ensure your AI is validating the real state of your environment, rather than just guessing. Real-world agentic AI use cases for Tenable Hexa AI While there are virtually infinite ways to apply agentic orchestration to your unique cybersecurity challenges, here are four high-impact areas where manual workflows traditionally break down and make it impossible for you to keep pace with AI-powered vulnerability discovery: Supply chain response - Neutralize third-party threats by using Tenable Hexa AI to correlate software components with affected internal assets. Automated patching - Use custom Hexa agents to beat the Mythos clock by orchestrating patches the moment a vulnerability is validated. Remediation assignment - Use Tenable Hexa AI to automatically match CVEs to asset owners in seconds and trigger immediate response workflows. These use cases demonstrate how Tenable Hexa AI can bridge the gap between exposure intelligence and action. Make the untenable Tenable The collapse of the exploit window is a wake-up call. It gives us the opportunity to change how we work. By shifting from manual triage to agentic orchestration, organizations are seeing a shift in productivity and how they prioritize and action exposure reduction. While early design partners have already reclaimed days per month on foundational tasks like asset tagging, the value is not found solely in the hours saved, but rather, in the precision of the response. By automating the correlation between cloud, identity, AI, OT, and vulnerability data, Tenable One provides the clear, contextualized instructions that IT and DevOps teams need to act with confidence. This eliminates the administrative friction and back-and-forth negotiation that often results in critical vulnerabilities going unaddressed. Reclaiming those days means your best people are no longer buried in spreadsheets; they are focused on high-impact strategy, architecture hardening, and preemptive defense. Tenable Hexa AI is available today as part of the Tenable One Foundation and Tenable One Advanced packages . | Tenable Research | |||
| –Not rated | – | AlienVault OTX General Two distinct threat campaigns, SHADOW-AETHER-040 and SHADOW-AETHER-064, have been identified targeting government entities and financial organizations across Latin America using agentic artificial intelligence to conduct cyber intrusions. SHADOW-AETHER-040, a Spanish-speaking group, compromised six government entities in Mexico between December 2025 and January 2026, while SHADOW-AETHER-064, operating in Portuguese, targeted Brazilian financial institutions starting in April 2026. Both campaigns established SOCKS5 tunnels via ProxyChains and SSH, enabling AI agents to execute commands directly within victim networks. The AI agents dynamically generated hacking tools and scripts on-demand, reducing detection by signature-based security solutions. Despite tactical similarities including shared toolsets like Chisel, Neo-reGeorg, CrackMapExec, and Impacket, the campaigns appear to be separate entities distinguished primarily by language. These operations represent emerging cases of AI agents executing complete... | AlienVault OTX General | |||
| High | 8.9 | EPSS 0.7% | CVE-2026-44432Red Hat Security Advisory: Red Hat Hardened Images RPMs bug fix and enhancement update High8.9EPSS 0.7%GCVE DatabaseCVE-2026-44432 ### Impact urllib3's [streaming API](https://urllib3.readthedocs.io/en/2.7.0/advanced-usage.html#streaming-and-i-o) is designed for the efficient handling of large HTTP responses by reading the content in chunks, rather than loading the entire response body into memory at once. urllib3 can perform decompression based on the HTTP `Content-Encoding` header (e.g., `gzip`, `deflate`, `br`, or `zstd`). When using the streaming API since version 2.6.0, the library decompresses only the necessary bytes, enabling partial content consumption. However, urllib3 before version 2.7.0 could still decompress the whole response instead of the requested portion in two cases: 1. During the second `HTTPResponse.read(amt=N)` call when the response was decompressed using the official [Brotli](https://pypi.org/project/brotli/) library. 2. When `HTTPResponse.drain_conn()` was called after the response had been read and decompressed partially (compression algorithm did not matter here). These issues could cause urllib3 to fully decode a small amount of highly compressed data in a single operation. This could result in excessive resource consumption (high CPU usage and massive memory allocation for the decompressed data; CWE-409) on the client side. ### Affected usages Applications and libraries using urllib3 versions earlier than 2.7.0 may be affected when streaming compressed responses from untrusted sources in either of these cases, unless decompression is explicitly disabled: 1. A response encoded with `br` is read incrementally with at least two `HTTPResponse.read(amt=N)` or `HTTPResponse.stream(amt=N)` calls while using the official [Brotli](https://pypi.org/project/brotli/) library. 2. `HTTPResponse.drain_conn()` is called after response decompression has already started. ### Remediation Upgrade to at least urllib3 version 2.7.0 in which the library: 1. Is more efficient for reads with Brotli. 2. Always skips decompression for `HTTPResponse.drain_conn()`. If upgrading is not immediately possible, the following workarounds may reduce exposure in specific cases: 1. For the Brotli-specific issue only, switch from [brotli](https://pypi.org/project/brotli/) to [brotlicffi](https://pypi.org/project/brotlicffi/) until you can upgrade urllib3; the official Brotli package is affected because of https://github.com/google/brotli/issues/1396. 2. If your code explicitly calls `HTTPResponse.drain_conn()`, call `HTTPResponse.close()` instead when connection reuse is not important. ### Credits The Brotli-specific issue was reported by @kimkou2024. `HTTPResponse.drain_conn()` inefficiency was reported by @Cycloctane. | GCVE Database | ||
| Critical | 9.4 | EPSS 0.4% | Critical9.4EPSS 0.4%GCVE Database Apache Polaris versions prior to 1.4.1 improperly handle literal '*' characters in namespace and table names when generating temporary AWS S3 access policies. This leads to wildcard expansion in S3 IAM resource patterns and s3:prefix conditions, allowing delegated credentials for crafted table names to access other tables' S3 storage paths. Confirmed impacts include unauthorized reading of table metadata JSON files, listing of table prefixes, and, in some cases, creation and deletion of objects in other tables' storage locations. This vulnerability affects confidentiality, integrity, and availability of data stored in S3 for Polaris tables. | GCVE Database | ||
| –Not rated | – | AlienVault OTX General In early April 2026, a large-scale device code phishing campaign targeted organizations across multiple sectors and regions, exploiting OAuth 2.0 Device Authorization Grant. Threat actors leveraged the Kali365 phishing-as-a-service platform, originating primarily from IP address 216.203.20[.]95. The campaign used high-fidelity lures directing victims to Microsoft's legitimate device login flow, where users unknowingly authorized threat actor-controlled sessions. Captured OAuth tokens enabled immediate mailbox access and post-compromise activities. In some cases, attackers established malicious inbox rules to suppress security notifications, extending dwell time. The Kali365 platform operates as a multi-tenant PhaaS ecosystem supporting both device code abuse and adversary-in-the-middle session capture, featuring rapid lure generation across multiple languages and file types, Cloudflare Worker-hosted pages, and token sharing capabilities between affiliates. | AlienVault OTX General | |||
| –Not rated | – | AlienVault OTX General Investigation reveals widespread abuse of n8n, an AI workflow automation platform, in sophisticated phishing campaigns from October 2025 through March 2026. Attackers exploit the platform's webhook functionality to deliver malware and fingerprint devices while bypassing security filters through trusted infrastructure. Email volume containing n8n webhook URLs increased by 686% between January 2025 and March 2026. Observed campaigns utilize CAPTCHA-protected pages to deliver remote access tools including modified Datto RMM and ITarian Endpoint Management software. The webhooks mask malicious payload sources behind legitimate n8n domains. Additional abuse cases involve tracking pixels embedded in emails for device fingerprinting. These attacks demonstrate how legitimate productivity and automation platforms can be weaponized, requiring behavioral detection approaches rather than simple domain blocking to protect organizational workflows. | AlienVault OTX General | |||
| Medium | 5.4 | EPSS 0.2% | CVE-2026-32867OPEXUS eComplaint · Insecure Direct Object Reference Medium5.4EPSS 0.2%CVE Database V5CVE-2026-32867 CVE-2026-32867 is a medium severity vulnerability in OPEXUS eComplaint versions prior to 10.1.0.0 that allows unauthenticated attackers to upload arbitrary files by guessing existing case numbers via the 'Portal/EEOC/DocumentUploadPub.aspx' endpoint. This authorization bypass through user-controlled keys (CWE-639) enables attackers to inject unexpected files into complaint cases, potentially causing data integrity issues and storage exhaustion. Exploitation requires no authentication but does require user interaction, such as triggering file uploads. While no known exploits are currently reported in the wild, the vulnerability could be leveraged to disrupt case management or facilitate further attacks. Organizations using OPEXUS eComplaint should prioritize patching and implement strict access controls and input validation to mitigate risks. Countries with significant deployments of OPEXUS eComplaint, particularly those with regulatory complaint management needs, are at higher risk. | CVE Database V5 | ||
| –Not rated | – | AlienVault OTX General This report analyzes the recent activities of the MuddyWater APT group, which primarily targets organizations in the Middle East. The group employs sophisticated spear-phishing techniques, often impersonating legitimate entities and using malicious documents to gain initial access. Their attacks focus on long-term infiltration and intelligence gathering rather than immediate disruption. The report details several attack cases from 2019 to 2026, highlighting the group's evolving tactics, including the abuse of legitimate remote management tools and the use of Rust-based malware. The analysis emphasizes the importance of endpoint detection and response (EDR) solutions in identifying and mitigating these threats, as traditional perimeter-based security measures prove insufficient against such advanced persistent threats. | AlienVault OTX General | |||
| Critical | 9.2 | EPSS 5.6% | CVE-2025-24293Rails activestorage · Code Injection Critical9.2EPSS 5.6%CVE Database V5CVE-2025-24293 # Active Storage allowed transformation methods potentially unsafe Active Storage attempts to prevent the use of potentially unsafe image transformation methods and parameters by default. The default allowed list contains three methods allow for the circumvention of the safe defaults which enables potential command injection vulnerabilities in cases where arbitrary user supplied input is accepted as valid transformation methods or parameters. Impact ------ This vulnerability impacts applications that use Active Storage with the image_processing processing gem in addition to mini_magick as the image processor. Vulnerable code will look something similar to this: ``` <%= image_tag blob.variant(params[:t] => params[:v]) %> ``` Where the transformation method or its arguments are untrusted arbitrary input. All users running an affected release should either upgrade or use one of the workarounds immediately. Workarounds ----------- Consuming user supplied input for image transformation methods or their parameters is unsupported behavior and should be considered dangerous. Strict validation of user supplied methods and parameters should be performed as well as having a strong [ImageMagick security policy](https://imagemagick.org/script/security-policy.php) deployed. Credits ------- Thank you [lio346](https://hackerone.com/lio346) for reporting this! | CVE Database V5 | ||
| –Not rated | – | Reddit InfoSec News Google has released patches addressing 107 vulnerabilities in the Android operating system, including two critical framework bugs that have been actively exploited in the wild. These flaws affect multiple components of Android, potentially allowing attackers to execute arbitrary code, escalate privileges, or cause denial of service. The vulnerabilities are considered high severity due to their exploitation status and broad impact on Android devices globally. European organizations relying on Android devices face risks including data breaches, device compromise, and operational disruption. Immediate patching is essential to mitigate these threats. Countries with high Android adoption and significant mobile-dependent infrastructure are most at risk. The threat requires no user interaction for exploitation in some cases, increasing its danger. Defenders should prioritize deploying official Google security updates and monitor for indicators of compromise related to these framework bugs. Enhanced mobile device management and network-level protections can further reduce exposure. | Reddit InfoSec News | |||
| High | 7.1 | EPSS 0.2% | CVE-2025-13353Cloudflare gokey · Weak Randomness High7.1EPSS 0.2%CVE Database V5CVE-2025-13353 In gokey versions <0.2.0, a flaw in the seed decryption logic resulted in passwords incorrectly being derived solely from the initial vector and the AES-GCM authentication tag of the key seed. This issue has been fixed in gokey version 0.2.0. This is a breaking change. The fix has invalidated any passwords/secrets that were derived from the seed file (using the -s option). Even if the input seed file stays the same, version 0.2.0 gokey will generate different secrets. Impact This vulnerability impacts generated keys/secrets using a seed file as an entropy input (using the -s option). Keys/secrets generated just from the master password (without the -s option) are not impacted. The confidentiality of the seed itself is also not impacted (it is not required to regenerate the seed itself). Specific impact includes: * keys/secrets generated from a seed file may have lower entropy: it was expected that the whole seed would be used to generate keys (240 bytes of entropy input), where in vulnerable versions only 28 bytes was used * a malicious entity could have recovered all passwords, generated from a particular seed, having only the seed file in possession without the knowledge of the seed master password Patches The code logic bug has been fixed in gokey version 0.2.0 and above. Due to the deterministic nature of gokey, fixed versions will produce different passwords/secrets using seed files, as all seed entropy will be used now. System secret rotation guidance It is advised for users to regenerate passwords/secrets using the patched version of gokey (0.2.0 and above), and provision/rotate these secrets into respective systems in place of the old secret. A specific rotation procedure is system-dependent, but most common patterns are described below. Systems that do not require the old password/secret for rotation Such systems usually have a "Forgot password" facility or a similar facility allowing users to rotate their password/secrets by sending a unique "magic" link to the user's email or phone. In such cases users are advised to use this facility and input the newly generated password secret, when prompted by the system. Systems that require the old password/secret for rotation Such systems usually have a modal password rotation window usually in the user settings section requiring the user to input the old and the new password sometimes with a confirmation. To generate/recover the old password in such cases users are advised to: * temporarily download gokey version 0.1.3 https://github.com/cloudflare/gokey/releases/tag/v0.1.3 for their respective operating system to recover the old password * use gokey version 0.2.0 or above to generate the new password * populate the system provided password rotation form Systems that allow multiple credentials for the same account to be provisioned Such systems usually require a secret or a cryptographic key as a credential for access, but allow several credentials at the same time. One example is SSH: a particular user may have several authorized public keys configured on the SSH server for access. For such systems users are advised to: * generate a new secret/key/credential using gokey version 0.2.0 or above * provision the new secret/key/credential in addition to the existing credential on the system * verify that the access or required system operation is still possible with the new secret/key/credential * revoke authorization for the existing/old credential from the system Credit This vulnerability was found by Théo Cusnir ( @mister_mime https://hackerone.com/mister_mime ) and responsibly disclosed through Cloudflare's bug bounty program. | CVE Database V5 | ||
| Medium | – | MediumReddit NetSec This analysis covers foundational cache poisoning attacks that have historically exploited logic flaws in web caching mechanisms, such as unvalidated headers, inconsistent header normalization, and mismatched cache keys. These vulnerabilities allow attackers to poison cached responses, leading to user redirection to malicious sites, denial of service by caching error responses, and widespread cache poisoning across CDN-backed websites. Although these are older case studies from platforms like HackerOne, GitHub, and Cloudflare, the underlying issues persist in modern frameworks, enabling complex cache poisoning and denial-of-service attacks today. The threat primarily impacts web applications and CDNs that improperly handle HTTP headers and cache keys. Exploitation requires sending crafted HTTP requests but often does not require authentication or user interaction. European organizations relying on vulnerable caching infrastructure or popular frameworks could face service disruption, reputational damage, and potential user redirection to malicious domains. Mitigation involves rigorous validation and normalization of headers, consistent cache key construction, and thorough testing of caching behavior under edge cases. Countries with high adoption of cloud services, CDNs, and modern web frameworks—such as the UK, Germany, France, and the Netherlands—are most likely to be affected. The overall severity is assessed as high due to the potential for widespread impact on availability and integrity without complex exploitation requirements. | Reddit NetSec | |||
| –Not rated | – | AlienVault OTX General In October 2025, phishing emails predominantly delivered Trojan malware via attachments, accounting for 47% of cases. These attachments included scripts, documents, and compressed files, notably RAR archives containing JavaScript files. The phishing campaigns also involved distribution of Remcos RAT malware and used document attachments to download additional payloads. Korean phishing emails were specifically analyzed, revealing targeted case names, subjects, and attachment filenames. The report highlights evolving tactics such as increased use of compressed JS files and exploitation of OLE objects within documents. The threat leverages multiple MITRE ATT&CK techniques including persistence, command execution, and credential access. This medium-severity campaign poses significant risks through social engineering and malware delivery via email attachments, requiring focused defensive measures. No known exploits in the wild are reported, but the widespread use of common file formats and compression methods increases the attack surface. European organizations should be vigilant against these evolving phishing tactics and malware payloads. | AlienVault OTX General | |||
| –Not rated | – | Reddit InfoSec News The EchoGram flaw is a recently disclosed vulnerability that allows attackers to bypass guardrails implemented in major large language models (LLMs). This bypass enables the LLMs to generate outputs that would normally be restricted by safety and content moderation filters. Although no known exploits are currently in the wild, the flaw poses a medium-level risk due to its potential to facilitate malicious use of LLMs. The vulnerability does not have detailed technical disclosures or patch information yet, limiting immediate mitigation options. European organizations using LLMs for customer interaction, content generation, or automation could face risks related to misinformation, policy violations, or reputational damage. Countries with high adoption of AI technologies and strict regulatory environments are particularly at risk. Mitigation should focus on enhanced monitoring of LLM outputs, restricting sensitive use cases, and collaborating with vendors for updates. Given the medium severity, the threat requires attention but is not immediately critical. Defenders should prioritize awareness and prepare for potential future exploits as more details emerge. | Reddit InfoSec News | |||
| –Not rated | – | Reddit InfoSec News The ransomware landscape is experiencing significant fragmentation, complicating defense efforts, while the notorious LockBit ransomware group has reemerged as a prominent threat. This resurgence signals a potential increase in targeted ransomware attacks leveraging LockBit's established infrastructure and tactics. European organizations, especially those in critical infrastructure and high-value sectors, face heightened risks due to LockBit's return and the broader ransomware ecosystem's instability. The fragmentation among ransomware groups may lead to more unpredictable attack vectors and increased competition, potentially escalating ransom demands and attack frequency. Defenders should prioritize monitoring for LockBit indicators, enhance incident response readiness, and implement targeted controls to mitigate ransomware risks. Countries with high digital infrastructure reliance and previous ransomware incidents, such as Germany, France, and the UK, are particularly vulnerable. Given the high impact on confidentiality, integrity, and availability, combined with ease of exploitation and no need for user interaction in some cases, this threat is assessed as high severity. Immediate, specific mitigation steps beyond generic advice are critical to reduce exposure and potential damage. | Reddit InfoSec News | |||
| High | 7.8 | EPSS 0.2% | High7.8EPSS 0.2%GCVE DatabaseCVE-2025-40205 In the Linux kernel, the following vulnerability has been resolved: btrfs: avoid potential out-of-bounds in btrfs_encode_fh() The function btrfs_encode_fh() does not properly account for the three cases it handles. Before writing to the file handle (fh), the function only returns to the user BTRFS_FID_SIZE_NON_CONNECTABLE (5 dwords, 20 bytes) or BTRFS_FID_SIZE_CONNECTABLE (8 dwords, 32 bytes). However, when a parent exists and the root ID of the parent and the inode are different, the function writes BTRFS_FID_SIZE_CONNECTABLE_ROOT (10 dwords, 40 bytes). If *max_len is not large enough, this write goes out of bounds because BTRFS_FID_SIZE_CONNECTABLE_ROOT is greater than BTRFS_FID_SIZE_CONNECTABLE originally returned. This results in an 8-byte out-of-bounds write at fid->parent_root_objectid = parent_root_id. A previous attempt to fix this issue was made but was lost. https://lore.kernel.org/all/4CADAEEC020000780001B32C@vpn.id2.novell.com/ Although this issue does not seem to be easily triggerable, it is a potential memory corruption bug that should be fixed. This patch resolves the issue by ensuring the function returns the appropriate size for all three cases and validates that *max_len is large enough before writing any data. EPSS 0.2%Vulnerability | GCVE Database | ||
| High | – | HighReddit NetSec This threat concerns the security challenges around Python's pickle deserialization mechanism, which is known to be vulnerable to remote code execution (RCE) attacks. A new experimental sandbox approach intercepts and blocks dangerous operations during deserialization to prevent exploits. The developers have tested it against over 32 known vulnerabilities with minimal performance impact and have published a blog and an exploit challenge to validate its effectiveness. While promising, the approach is still experimental and may have undiscovered edge cases. No known exploits are currently in the wild. European organizations using Python applications that rely on pickle for data serialization could benefit from this research but should remain cautious until the sandbox is mature and widely adopted. The threat highlights the ongoing risk of insecure deserialization and the need for robust mitigations. Given the high severity and potential for RCE, organizations should monitor developments closely and consider alternative serialization methods or enhanced sandboxing. Countries with strong Python developer communities and critical infrastructure relying on Python are most likely to be affected. The suggested severity is high due to the potential for full system compromise via deserialization vulnerabilities, ease of exploitation in some contexts, and broad impact scope. | Reddit NetSec |
Page 2 of 3