Arbitrary file upload via malformed archive in the Kirki WordPress customizer plugin (all versions before 6.2.3) allows users holding the Editor role to place executable and web-accessible files on the server, enabling Stored XSS against any visitor and Remote Code Execution on permissive server configurations. A publicly available proof-of-concept exists per WPScan, elevating practical risk beyond the CVSS 6.8 score. No confirmed active exploitation appears in CISA KEV at time of analysis, though SSVC rates technical impact as total.
Stored Cross-Site Scripting in GutenKit WordPress plugin before 2.5.0 allows authenticated users holding the Author role - or any role with file upload capability - to upload maliciously crafted SVG files through plugin-enabled upload paths that lack sanitization, executing arbitrary JavaScript in the browsers of any user who subsequently opens the file, including site administrators. A publicly available proof-of-concept exists via WPScan, and the SSVC framework rates technical impact as 'total,' meaning successful targeting of an administrator session could yield full WordPress site compromise. The vendor has released a remediated version (2.5.0), and exploitation status is rated 'none' by SSVC at time of analysis despite the public exploit code.
Stored cross-site scripting in the Admin and Site Enhancements (ASE) WordPress plugin before 9.0.1 allows authenticated users with site-owner-granted upload access to embed malicious JavaScript inside SVG files uploaded through incompletely sanitized routes, which then executes silently in the browser of any user - including administrators - who subsequently opens or previews the file. The plugin fails to apply SVG sanitization uniformly across all upload-accepting endpoints, meaning at least one route bypasses the intended XSS filter. A publicly available proof-of-concept has been confirmed by WPScan (EUVD-2026-63203), though SSVC assessment and the absence of a CISA KEV entry indicate no active widespread exploitation at time of analysis.
Type confusion in the Lean 4 proof assistant kernel allows a malicious metaprogram to produce a proof of False carrying no axioms, from which any proposition can be derived, completely breaking kernel soundness. The vulnerability arises from two related defects in src/kernel/inductive.cpp: projection expressions do not verify that the named structure matches the projected value's type, and environment::add_inductive fails to type-check the parametric arguments of nested inductive applications after they are replaced by auxiliary types, letting those arguments escape kernel verification entirely - exploitable through the normal maximum-kernel-checking addDecl path without sorry, unsafeCast, or unsafe annotations. Publicly available exploit code exists at multiple repositories; this CVE is not listed in CISA KEV.
Arbitrary PHP code execution in Royal Addons for Elementor WordPress plugin (all versions before 1.7.1066) is reachable by any user holding the manage_options capability, including non-super subsite administrators on WordPress Multisite who would not otherwise have code-execution rights. The plugin writes unsanitized custom widget markup directly to a server-side file that is subsequently executed as PHP, enabling full server-side code injection. A publicly available exploit exists per WPScan; no CISA KEV listing at time of analysis, though the attack scenario is realistic for any WordPress Multisite deployment with delegated administration.
Content exfiltration in django CMS prior to 5.0.9 allows any authenticated staff user holding only page-add permission to read the full plugin content of any page - including restricted, cross-site, and secret pages - by supplying an arbitrary source ID to the page duplication endpoint. The missing object-level authorization check means the only gate (PageAdmin.has_add_permission) verifies only that the user may create pages in general, never that they may access the specific source being copied. Because AddPageForm.save() calls source.copy(..., permissions=False), the resulting duplicate strips view restrictions and becomes readable by anonymous visitors, compounding the confidentiality breach. A detailed proof-of-concept is published in the GHSA advisory; no active exploitation has been confirmed in CISA KEV.
Process-crashing race condition in the OpenTelemetry-Go OpenTracing bridge (`go.opentelemetry.io/otel/bridge/opentracing`) allows denial of service when concurrent goroutines access the same `bridgeSpan` - one writing baggage via `SetBaggageItem` and another reading it via `correlation.MapFromContext`. Because Go's runtime detects unsynchronized map access and terminates the process with a fatal panic, any application using the bridge with correlation hooks and concurrent span access is vulnerable to abrupt process termination. A proof-of-concept is publicly available; no confirmed active exploitation (KEV) has been reported.
SQL injection in CodeAstro Apartment Visitor Management System 1.0 allows remote unauthenticated attackers to manipulate backend database queries through the email parameter of the password-recovery.php script. The CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N) confirms no authentication or special configuration is required, and a public proof-of-concept exploit is available on GitHub, lowering the skill threshold for opportunistic attacks. No active exploitation has been confirmed in CISA KEV at time of analysis, and impact is rated partial across confidentiality, integrity, and availability (VC:L/VI:L/VA:L).
SQL injection in CodeAstro Apartment Visitor Management System 1.0 exposes the unauthenticated password-reset endpoint (/apartment-visitor/forgotpw.php) to remote database manipulation via the `secode` parameter. A publicly available proof-of-concept exploit exists, lowering the bar for exploitation. Affected deployments risk partial database read and write access without any prior authentication, as confirmed by the CVSS 4.0 vector (PR:N, UI:N). No KEV listing exists, and exploitation is expected to remain opportunistic and targeted to organizations running this niche PHP application.
Direct HTTP access to an exposed SQL database backup file in code-projects Login Registration System 1.0 allows unauthenticated remote attackers to download the raw database dump at /loginsystem/database/login_registration_system.sql, disclosing user credentials, schema details, and any sensitive data stored in the application database. This is a CWE-552 file exposure defect - the backup artifact is stored within the web-accessible document root with no access controls. No exploitation beyond a standard HTTP GET request is required. A public proof-of-concept exploit exists; no KEV listing at time of analysis.
Server-Side Request Forgery in PullMD 3.2.0 exposes internal network resources and cloud metadata endpoints through the unauthenticated REST API endpoint GET /api, where the url parameter is passed without validation to the server's HTTP fetch stack. The vulnerability affects multiple fetch paths including the MCP read_url tool, Reddit resolver, and Playwright sidecar, all of which lacked SSRF guards prior to v3.3.0. A public exploit exists (GitHub issue #41), and the changelog confirms that 169.254.169.254 and 100.100.100.200 (AWS/Alibaba cloud metadata) were specifically demonstrated as targets; no active exploitation has been confirmed by CISA KEV.
SQL injection in code-projects Employee Management System 1.0 allows remote unauthenticated attackers to manipulate backend database queries via the `mailuid` parameter at the Admin Login Endpoint (`/process/aprocess.php`). Successful exploitation can result in authentication bypass, credential extraction, or partial data manipulation depending on database user privileges. A public proof-of-concept exploit is available, materially lowering the technical barrier for opportunistic attacks.
Memory corruption in liftoff-sr CIPster's generic attribute logic exposes EtherNet/IP-connected devices to remote buffer overrun attacks requiring no authentication. The vulnerability exists in the CipAttribute::SetAttrData decode path, where the prior ByteBuf-based design tracked only a {start, limit} view of byte-array backing buffers without recording physical capacity - allowing a wire-supplied length value to direct writes beyond the allocated memory region. Publicly available exploit code exists (referenced in GitHub issue #47); the vulnerability is not listed in CISA KEV as of the time of analysis.
SQL injection in SourceCodester Simple Online Food Ordering System 1.0 exposes the `/admin/ajax.php?action=delete_category` endpoint to unauthenticated remote attackers who can manipulate the `id` parameter to read or modify the underlying database. The CVSS 4.0 vector confirms no authentication, no user interaction, and no special conditions are required to exploit the flaw. A public proof-of-concept exploit has been disclosed on GitHub, lowering the barrier for opportunistic attacks against any internet-facing deployment.
SQL injection in SourceCodester Simple Online Food Ordering System 1.0 exposes the `/fos/admin/view_order.php` endpoint to remote, unauthenticated database manipulation via the unsanitized `ID` parameter. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms zero-barrier remote exploitation with no user interaction required. A public exploit has been released - referenced via GitHub and VulDB - materially raising near-term opportunistic exploitation risk despite the moderate overall score.
SQL injection in code-projects Simple Inventory System 1.0 allows remote unauthenticated attackers to manipulate backend database queries via the ID parameter in /delete.php. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms no authentication or user interaction is required, enabling exploitation from the network. A public proof-of-concept exploit has been disclosed via GitHub, making this immediately actionable for opportunistic attackers targeting deployments of this PHP application.
SQL injection in DeDeCMS 53_1_UTF8 exposes the `/plus/advancedsearch.php` endpoint to remote unauthenticated database manipulation via an unsanitized `sql` argument. The flaw (CWE-89) allows attackers to craft malicious SQL statements that interact directly with the backend database, yielding limited but real confidentiality, integrity, and availability impact. A public exploit has been disclosed (CVSS 4.0 E:P), lowering the skill barrier for exploitation; no CISA KEV listing has been identified at time of analysis.
Sandbox escape in asteval allows any attacker who can supply expressions to `Interpreter.eval()` to raise `SystemExit`, `KeyboardInterrupt`, `GeneratorExit`, or `BaseException`, bypassing both `run()` and `eval()` exception handlers - which catch only `Exception` - and terminating or disrupting the calling process. All asteval versions through 1.0.6 are affected; version 1.0.9 resolves the issue. No active exploitation has been confirmed (not in CISA KEV), but a working proof-of-concept covering all four variants is included in the public advisory GHSA-89v8-rhwq-hf77, and this is a third distinct sandbox-escape class in asteval following CVE-2025-24359 and GHSA-vp47-9734-prjw.
Missing object-level authorization in django CMS's `render_object_structure` endpoint exposes CMS structure metadata of non-PageContent objects to low-privileged staff users. Any active staff account (is_staff=True) can request the `/admin/cms/placeholder/object/<content_type_id>/structure/<object_id>/` endpoint for frontend-editable objects using PlaceholderRelationField, receiving placeholder slot names, plugin trees, plugin identifiers and labels, and object existence - without holding `cms.use_structure` or any model-level view or change permission. No active exploitation confirmed (not in CISA KEV); a working proof-of-concept using the framework's own FancyPoll test model is documented in GHSA-8qj2-c6q4-f399. EPSS data was not provided, but the staff-gated, read-only nature and requirement for ID enumeration limit real-world impact.
Command injection in the Kenwood DNR1007XR automotive head unit's startUpdateProcess method allows physically present, unauthenticated attackers to execute arbitrary OS commands as root. The flaw stems from unsanitized user-supplied input passed directly to a system call inside the firmware update handler, granting full device compromise. No public exploit code has been identified at time of analysis, and exploitation is constrained by the requirement for physical device access.
CRLF injection in the bandit Elixir HTTP server (versions 1.4.0 through 1.12.4) allows unauthenticated remote attackers to smuggle carriage-return, line-feed, or NUL characters into application-visible HTTP/2 request headers. Because HPACK carries arbitrary octets and bandit's HTTP/2 stream handler never validated field values for these control characters - unlike the HTTP/1 path which rejected them - a crafted HEADERS frame decodes cleanly and the malicious values reach downstream application logic unchanged. No public exploit or CISA KEV listing is identified; real-world impact is context-dependent and limited to how consuming application code handles raw header values (e.g., log injection, upstream request smuggling).
Cross-host redirect cookie leakage in Hurl ≤ 8.0.1 exposes session credentials to attacker-controlled redirect destinations when scripts use the dedicated [Cookies] section. Hurl's HTTP client correctly strips raw Cookie headers and Authorization credentials on host changes, but the separate RequestSpec.cookies pathway - populated by the [Cookies] section of .hurl files - bypasses this stripping logic, forwarding scoped cookies to the redirected host. No public exploit code is identified and this vulnerability is not in CISA KEV; the CVSS 4.0 score of 6.9 reflects high confidentiality impact gated by the requirement that a user actively runs the affected script.
User enumeration via observable response discrepancy in Frappe's personal data download (GDPR) endpoint allows unauthenticated remote attackers to determine whether any email address corresponds to a registered account. The PersonalDataDownloadRequest handler in frappe/website/doctype/personal_data_download_request/personal_data_download_request.py returned the user_name field and persisted the document to the database only for known users, producing structurally distinct responses that an attacker could compare to systematically harvest registered email addresses. No public exploit has been identified at time of analysis; vendor-released patches exist at versions 15.115.0 and 16.27.0.
Path traversal in ATutor's error log viewer grants authenticated administrators read access to arbitrary files outside the intended logs directory, up to the web server process's permission boundary. Only version 2.2.4 has been confirmed vulnerable by CERT.pl, though other versions may also be affected. No patch will be issued - the product is end-of-life - making migration or decommissioning the only durable remediation.
Unauthenticated access to form submissions is possible in the Convert Forms extension for Joomla across all versions from 1.0.0 up to but not including 5.2.5, due to missing server-side access control on the front-end Submissions view. Any unauthenticated internet visitor can enumerate and retrieve form submission data without credentials, exposing whatever personally identifiable or business-sensitive information site visitors have submitted through forms built with this extension. No public exploit code or CISA KEV listing has been identified at time of analysis, but the low-complexity, zero-authentication attack surface makes this trivially exploitable by any actor who can reach the site.
Webhook signature bypass in the appwrite/templates github-issue-bot (≤ 1.1.2) allows any unauthenticated network caller to invoke the bot's comment-posting functionality without a valid GitHub HMAC signature. An inverted boolean condition in verifyWebhook causes requests lacking the X-Hub-Signature-256 header to short-circuit to success, so the body is processed as if it were a legitimate GitHub event. With attacker-controlled repository, issue, and author fields passed directly to postComment, the deployment's GITHUB_TOKEN is used to post arbitrary comments on any accessible GitHub repository and issue. No public exploit code is identified at time of analysis.
Cross-Site Request Forgery in Frappe Framework 16.31.0 and earlier allows an unauthenticated attacker to forge workflow approval actions on behalf of any authenticated victim user, because the bulk_workflow_approval endpoint in frappe/model/workflow.py accepts state-mutating requests via safe HTTP methods (GET) in addition to POST. The attacker needs only to lure an authenticated user to a crafted page or link, causing their browser to silently submit an approval with the victim's session credentials. No released patched version is available at time of analysis; the upstream fix exists only as an unmerged PR and commit.
Unauthorized tag modification in YOOtheme Zoo for Joomla (all versions below 4.1.65) is fully exploitable by unauthenticated network attackers due to a missing ACL enforcement on the comment controller endpoint. Any remote party can send crafted requests to arbitrarily modify content tags without presenting credentials. No active exploitation has been confirmed by CISA KEV, and no public exploit code has been identified; however, the attack complexity is trivially low given the complete absence of access controls on the affected endpoint.
Integer overflow to heap over-read in libvips prior to 8.18.3 crashes the image processing process when a crafted multi-page TIFF is loaded through the ImageMagick fallback path. The unchecked multiplication `out->Ysize *= magick->n_frames` in `vips_foreign_load_magick_parse()` wraps on attacker-controlled input, producing an underflowed buffer dimension that drives a subsequent heap over-read and process crash. This flaw is limited to the uncommon build configuration where libtiff support is absent and ImageMagick support is present; no public exploit identified at time of analysis.
Unauthorized XPC Mach service access in NoSleep 1.5.1 on macOS allows a local low-privileged attacker to send arbitrary dictionary messages - including attacker-controlled `command` and `NSBundlePath` values - to a privileged daemon without authorization. The root cause is CWE-862 (Missing Authorization), meaning the XPC service performs no caller identity check before processing requests. No public exploit code has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
Unauthenticated arbitrary JSON file read in the npm package next-video (versions ≤ 2.8.0) exposes cryptographic server secrets to any remote attacker who can reach the /api/video route. The /api/video request handler accepts a url query parameter and, for any value not beginning with https://, constructs a local filesystem path by appending .json and serving the file contents directly with no authentication, no path canonicalization, and no directory traversal guard. Applications following the documented one-liner setup are at risk of exposing the Next.js Server Actions AES encryption key, Preview/Draft Mode signing and encryption keys, internal build manifests, and Mux-specific asset metadata. No public exploit code or CISA KEV listing has been identified at time of analysis.
Root code execution on the Kenwood DNR1007XR in-vehicle navigation receiver is reachable by anyone with physical access to the device, requiring no authentication. The firmware update service improperly resolves symbolic links during file move operations (CWE-59), allowing an attacker who can write a symlink to the device filesystem to redirect that file operation to an arbitrary path and ultimately execute code with root privileges. No public exploit code or CISA KEV listing was identified at time of analysis; the ZDI advisory (ZDI-26-484) is the primary disclosure source.
Heap-based buffer overflow in the vCardParser class of the Kenwood DNR1007XR automotive multimedia receiver allows physically present, unauthenticated attackers to execute arbitrary code with root privileges. The flaw stems from missing bounds validation when copying attacker-controlled string data into a heap-allocated buffer during vCard contact parsing. No public exploit code or active exploitation has been identified at time of analysis; ZDI tracked this internally as ZDI-CAN-28974 and issued advisory ZDI-26-488.
Out-of-bounds write in Kenwood DNR1007XR firmware enables physically present, unauthenticated attackers to execute arbitrary code at root privilege via the tchdr_bytestream_read function. The device - an in-vehicle infotainment/navigation unit - fails to bounds-check user-supplied data during bytestream parsing, resulting in a heap or stack write past the allocated buffer. No public exploit or active CISA KEV listing has been identified at time of analysis, and real-world impact is materially constrained by the physical access prerequisite.
Out-of-bounds read in Capstone's SuperH (SH) architecture disassembler crashes the host process when fed crafted SH2A or SH4A bytecode. Versions 6.0.0-Alpha9 and earlier are affected when the library handle is configured with CS_ARCH_SH plus CS_MODE_SH2A or CS_MODE_SH4A and CS_MODE_SHFPU; the disassembler derives an idx value from a raw 16-bit instruction and dereferences a mode-specific decode[] function-pointer table without a bounds check. The demonstrated impact is limited to process termination - no code execution or information disclosure was shown - and a vendor-released patch is available in 6.0.0-Alpha10.
Path traversal in VictoriaMetrics vmrestore (prior to versions 1.122.25, 1.136.12, and 1.146.0) allows an attacker who controls or can modify a remote backup source - S3, GCS, Azure Blob Storage, or equivalent - to plant dot-dot sequences in object names, causing vmrestore to write restored files outside the configured -storageDataPath directory when an operator executes a restore operation. The CVSS Scope Changed metric (S:C) reflects that successful exploitation reaches beyond the vmrestore process boundary to the broader host filesystem, enabling potential overwrite of binaries, configuration, or credentials within the OS permissions of the process. Vendor-released patches are available across three maintained branches; no active exploitation has been identified at time of analysis.
Heap-based buffer overflow in IBM AIX 7.2, 7.3 and PowerVM VIOS 4.1 enables a local authenticated attacker with high privileges to execute arbitrary code on affected systems. The vulnerability is rooted in improper memory management (CWE-787) and carries a CVSS 3.1 score of 6.7, reflecting the local access requirement and elevated privilege prerequisite that constrain real-world exploitability. IBM has released a patch via its support portal; no public exploit code or CISA KEV listing has been identified at time of analysis.
Path traversal in the `apport-unpack` utility of Canonical Apport enables arbitrary file creation and overwrite by exploiting attacker-controlled key names embedded in crafted crash report files. Affected versions span all Apport releases before 2.28.4, 2.34.2, and 2.36.0 - software that ships by default with Ubuntu desktop and server editions. An attacker who delivers a malicious `.crash` file and induces a user or automated pipeline to unpack it can write files to any location accessible by the executing user, creating a realistic privilege-escalation primitive on multi-user or developer Ubuntu systems. No public exploit is identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
Ghidra's PDB parser (all versions before 12.1.3) crashes when processing a crafted PDB file containing an oversized parameters section, enabling denial-of-service against security analysts. The AbstractPdb deserialization routine accumulates all parameters from the PDB stream into an unbounded heap list without size validation; the resulting OutOfMemoryError is a JVM Error subclass that bypasses standard exception handling, causing uncontrolled process termination. No public exploit code exists and no CISA KEV listing is present; exploitation requires a victim analyst to open a malicious file, limiting real-world impact to targeted disruption of reverse-engineering workflows.
Remote code execution in EMQX's plugin installation API allows an attacker who has obtained a compromised dashboard administrator credential or plugin-install-capable API key to upload and execute arbitrary Erlang code with full EMQX process privileges. Prior to versions 5.8.11, 5.9.3, 5.10.4, 6.0.3, 6.1.2, and 6.2.1, installation grants issued via `emqx ctl plugins allow` had no expiration and no cryptographic binding to specific package bytes, meaning a stale permit could be reused with attacker-controlled .tar.gz content submitted to POST /api/v5/plugins/install. No public exploit has been identified at time of analysis, and this vulnerability is not listed in the CISA KEV catalog.
Privilege escalation to root on the Kenwood DNR1007XR car navigation/dashcam device is possible for physically present attackers who already hold low-privileged code execution on the device. The USB filesystem mount point is configured with incorrect default permissions (CWE-276), allowing a low-privileged process to write to or manipulate that directory and escalate to root with full code execution capability. No public exploit code or active exploitation has been identified at time of analysis; the attack surface is inherently constrained by the physical access prerequisite and the embedded nature of the device.
Privilege escalation in HCL IntelliOps Event Management (IEM) allows an authenticated, high-privileged attacker to access resources beyond their original authorization boundary, achieving confidentiality impact against protected data. The vulnerability is classified as CWE-272 (Least Privilege Violation) with a Changed scope in CVSS, indicating the attacker can reach resources outside their normal privilege domain within the application. No public exploit code or active exploitation has been identified at time of analysis; the EPSS signal was not provided.
Heap buffer overflow in SumatraPDF 3.6.1 and earlier enables an attacker who delivers a crafted CHM file to corrupt parser heap memory via malformed LZX Huffman code lengths. The PRETREE path in make_decode_table writes internal Huffman tree nodes beyond the 104-entry PRETREE_table boundary into adjacent struct LZXstate heap memory, reachable through the chm_open → chm_retrieve_object → LZXdecompress → BUILD_TABLE call chain. No public exploit or active exploitation is confirmed; arbitrary code execution has not been demonstrated, though the upstream fix commit validates that reliable heap corruption is achievable.
Path traversal in Cesanta Mongoose's SSI processing allows an authenticated network attacker to read arbitrary files accessible to the Mongoose process by embedding directory traversal sequences in #include file or #include virtual SSI directives. The mg_ssi() function in src/ssi.c constructs filesystem paths from directive arguments without invoking the existing mg_path_is_sane() validation, bypassing the only guard against traversal. Exploitation is constrained to deployments compiled with MG_ENABLE_SSI and a configured ssi_pattern; no public exploit has been identified at time of analysis.
Remote code execution in Laravel Backpack CRUD's upload handling allows authenticated administrators to place PHP webshells in web-accessible storage by exploiting the lack of file extension validation inside `HasUploadFields` and `FileNameGenerator`. Affected are installations on the 6.x series before 6.8.14 and the 7.x series before 7.0.38 where the `public` disk with `storage:link` is in use and no explicit `mimes:` or `mimetypes:` Laravel validation rule guards upload fields - conditions common in quickstart-following deployments. No public exploit code has been identified and no CISA KEV listing is present at time of analysis; vendor-confirmed patches are available in releases 6.8.14 and 7.0.38.
Local File Inclusion (LFI) in the WP Cafe Pro WordPress plugin before version 3.0.15 allows an authenticated WordPress Author to include arbitrary files from the server's filesystem via unsanitized input passed to PHP file inclusion functions. The vulnerability is classified under CWE-98 and requires a high-privilege WordPress account (Author role), limiting opportunistic exploitation but enabling significant damage - including credential theft and potential remote code execution - if a trusted but malicious or compromised Author account is present. Patchstack reported this flaw and confirmed remediation in version 3.0.15. No public exploit code or active exploitation has been identified at time of analysis.
Server-side request forgery in Microsoft Copilot in Azure enables any authenticated Azure user to coerce the service into issuing arbitrary outbound requests, disclosing internal or cloud-infrastructure data back through the Copilot response channel. The CVSS scope-change indicator (S:C) and high confidentiality impact (C:H) suggest the service's privileged network position can be leveraged to reach resources beyond the application boundary - such as Azure Instance Metadata Service endpoints, internal APIs, or adjacent cloud services. No public exploit code or CISA KEV active-exploitation listing has been identified at time of analysis; Microsoft has released a server-side patch.
Path traversal in IBM AIX 7.2/7.3 and PowerVM VIOS 4.1 enables remote, unauthenticated attackers to bypass directory-based access controls by supplying manipulated pathname inputs that escape restricted filesystem boundaries. The vulnerability carries a CVSS 3.1 score of 4.8 (Medium) with high attack complexity (AC:H), which constrains opportunistic exploitation while still leaving targeted attacks viable without requiring credentials. No public exploit code or active exploitation has been identified at time of analysis; IBM has published an advisory at their support portal (https://www.ibm.com/support/pages/node/7283858).
IBM AIX 7.2 and 7.3 and IBM PowerVM VIOS 4.1 expose sensitive information over the network, enabling remote unauthenticated attackers to intercept in-flight messages and forge replies. The CVSS vector (AV:N/AC:L/PR:N/UI:N) confirms exploitation requires no credentials or user interaction, making any network-adjacent attacker a potential threat. No public exploit code has been identified and the vulnerability is not listed in the CISA KEV catalog; IBM has released a patch.
Share-link token theft in TREK versions 3.0.0 through 3.0.x allows any ordinary authenticated user to exfiltrate private journey data belonging to other users. By iterating sequential journey IDs against the unguarded GET /api/journeys/:id/share-link endpoint, an attacker retrieves valid share tokens for journeys they do not own; those tokens then grant unauthenticated read access to the victim's travel entries, captions, GPS locations, moods, gallery photos, photo file paths, and asset identifiers via the public endpoint GET /api/public/journey/:token. No public exploit code or CISA KEV listing exists at time of analysis; the NVD CVSS scores this 6.5 medium, but the high confidentiality impact on personal travel data warrants prompt patching on any multi-tenant TREK deployment.