2026-11-04
Stack-based buffer overflow in the TOTOLINK A950RG Multi-SSID configuration handler allows a low-privileged authenticated attacker with network access to the router's HTTP management interface to corrupt memory by supplying overlong wepkey2 or wepkey3 values to setWiFiMultipleConfig/delWiFiMultipleConfig in /cgi-bin/cstecgi.cgi. The issue affects firmware 4.1.2cu.5268_B20221104 and carries a CVSS 4.0 score of 9.4; exploitation requires a valid low-privileged session, and reachability depends on the management interface being exposed to the attacker's network position, typically LAN unless remote administration is enabled. A public PoC reference exists but is not verified as working exploit code, no CISA KEV entry confirms active exploitation, and vuln.today assigns an act_now decision label.
Stack-based buffer overflow in the TOTOLINK A950RG wireless router, specifically firmware build 4.1.2cu.5268_B20221104, where the Basic Wireless Configuration Handler in /cgi-bin/cstecgi.cgi copies the user-supplied wepkey argument with strcpy into a fixed-size stack buffer without bounds checking. Network-reachable attackers who hold valid low-privilege credentials (PR:L - not fully unauthenticated) can send a crafted request that overflows the buffer and, per the assessed CVSS 3.1 vector, achieve high confidentiality, integrity and availability impact on the device. Severity is rated Critical (CVSS 4.0 score 9.4; independently assessed 8.8-equivalent CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and the vuln.today decision label is act_now; a public PoC reference (GitHub Gist) exists but is not verified as working exploit code, and there is no CISA KEV confirmation of active exploitation. Practical exposure is constrained by the need for valid low-level credentials and by default deployments typically limiting the management interface to the LAN.
A stack-based buffer overflow in the Easy Setup Wizard handler of TOTOLINK A950RG firmware 4.1.2cu.5268_B20221104 lets remote attackers corrupt memory by sending a manipulated functionType argument to setAppEasyWizardConfig in /cgi-bin/cstecgi.cgi, with high impact on confidentiality, integrity and availability. The supplied CVSS vector carries PR:L, so the attacker must hold valid low-privilege credentials or an authenticated session against the device's web management interface, and the interface must be network-reachable (LAN, or WAN where exposed). A public PoC reference exists but is not verified as working exploit code, and no CISA KEV entry indicates active exploitation; priority is assessed as this_week rather than emergency tier.
Unauthenticated remote code execution in Quest Foglight for Databases lets any network attacker who can reach the RMI service execute arbitrary code in the context of SYSTEM. The flaw sits in the configuration of the baseRmiServiceExporter bean, which deserializes attacker-supplied data without validation (CWE-502); the assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (9.8), meaning no credentials and no user interaction are needed. This is a genuine high-priority issue: the only meaningful limiter is whether the RMI listener is reachable from untrusted networks, so Foglight deployments exposed beyond a trusted segment should be treated as urgent (priority label act_now); no public exploit code has been identified at time of analysis and the vulnerability is not listed as actively exploited in the supplied data.
Remote code execution in Quest Foglight for Databases allows remote, unauthenticated attackers to direct a file write to an attacker-chosen path through the writeTopologySectionToFile method and run code in the SYSTEM context (CVSS 9.8, CWE-73). All available severity signals align, and the issue carries an act_now priority label, but no public exploit code and no CISA KEV entry are identified at time of analysis. The supplied data does not specify an affected version range or fixed build, so scope and remediation should be confirmed against the ZDI advisory ZDI-26-861 and Quest's own guidance.
Remote unauthenticated code execution in Quest Foglight for Databases allows network attackers to reach the ForgeMBeanServerSupport module without credentials and execute arbitrary code as SYSTEM. The defect is a missing authentication check (CWE-306) in an exposed MBean server component, rated CVSS 9.8 and flagged act_now by vuln.today priority. No CISA KEV entry or public exploit code is identified in the provided data; practical exposure depends on whether the Foglight management/MBean service is reachable from untrusted networks.
NoMachine's nxwebrunner web service, which listens on TCP port 4443 by default, fails to validate the length of user-supplied data before copying it into a fixed-size heap buffer, allowing an unauthenticated attacker with network reachability to that port to execute arbitrary code as the web service account. The flaw is rated critical (CVSS 3.1 base 9.8, AV:N/AC:L/PR:N/UI:N) and carries an act_now priority label from vuln.today; no CISA KEV entry, EPSS value, or confirmed public exploit code was supplied with this report, so active exploitation is not established. Hosts where port 4443 is firewalled, bound to localhost, or where the web service is disabled are not remotely exposed.
Authenticated directory traversal in Quest Foglight for Databases lets a low-privileged user bypass the intended extraction directory in the unzipFile method and write files to arbitrary locations, ultimately yielding code execution in the SYSTEM context. The flaw is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), so it is network-reachable and needs no user interaction, but a valid account is mandatory - anonymous attackers cannot trigger it. Reported through Trend Micro ZDI as ZDI-CAN-29901 / ZDI-26-860, it is not listed in CISA KEV and no public exploit code or proof-of-concept was identified at time of analysis; the priority signal places it in the this_week remediation window rather than an emergency.
Authenticated remote attackers can execute arbitrary code as SYSTEM on installations of Quest Foglight for Databases by invoking the loadEvolveLicense script with a crafted, unvalidated path used in a file operation (CWE-22 path traversal, ZDI-CAN-29232). The CVSS vector (AV:N/AC:L/PR:L/UI:N with C:H/I:H/A:H) shows a low-privileged account is sufficient and no user interaction is needed, so the only meaningful barrier is obtaining a valid session; once authenticated, the path to SYSTEM-level code execution is low-complexity. There is no confirmed active exploitation (not in CISA KEV), no verified working exploit code is referenced in the available data, and the advisory reference is the Zero Day Initiative disclosure ZDI-26-856; exact affected and fixed version ranges are not stated in the available sources.
Remote code execution in Quest Foglight for Databases requires an authenticated session: a low-privileged user who can supply a crafted path to the loadManageServerLicense script can traverse directories and run code as SYSTEM. The issue is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and is a credible, above-average priority issue rather than an inflated high-CVSS score. No public exploit was identified at time of analysis, and CISA KEV status is not indicated; the priority label is this_week.
Authenticated remote code execution in Quest Foglight for Databases lets an attacker with valid account access supply a crafted path to the installLicense script, traverse directories, and execute arbitrary code in the SYSTEM context. The flaw is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N) and requires authentication but no user interaction; no public exploit identified at time of analysis. It is tracked as ZDI-CAN-29215 / ZDI-26-855.
Quest Foglight for Databases has an incorrect authorization flaw in its runScript function that lets an authenticated low-privileged attacker execute arbitrary code as SYSTEM over the network without user interaction. The issue is rated CVSS 8.8 (CWE-863) and is prioritized for remediation this week; the supplied data contains no CISA KEV entry and no public exploit identified at time of analysis.
Authenticated directory traversal in Quest Foglight for Databases lets a low-privileged account pass a crafted path into the extractAndCreateUploadInfoList method and write files outside the intended upload location, which can be leveraged to execute arbitrary code as SYSTEM. The flaw is network-reachable with no user interaction required (CVSS 8.8, PR:L), so practical exposure is gated by possession of valid low-privilege credentials and is highest where such accounts are broadly provisioned. No public exploit code and no CISA KEV entry were identified in the available data at time of analysis.
Quest Foglight for Databases contains a path traversal flaw in the paFnUploadFileAndCreateInfo script that lets remote attackers who hold a valid, low-privileged account upload files to arbitrary locations and ultimately execute code as SYSTEM. Affected are installations of the Foglight for Databases management interface; exploitation requires network reachability plus authenticated access (CVSS PR:L), and no user interaction is needed. No public exploit code is identified at time of analysis, the issue has not been reported as actively exploited in the wild, and it is rated a high-priority 'this_week' remediation item rather than an emergency.
Information disclosure in Quest Foglight for Databases lets unauthenticated remote attackers reach the getSource method and submit crafted XML that triggers server-side external entity resolution, exposing data available to the application and enabling arbitrary server-side requests. The flaw is rated CVSS 8.2 (AV:N/AC:L/PR:N/UI:N) and requires network reachability to the affected getSource interface; no public exploit code is identified in the supplied intelligence, and the priority label is this_week.
Server-side request forgery in MLflow's get-artifacts function lets unauthenticated remote attackers induce the server to access attacker-supplied URIs and disclose sensitive information from the server's context; the CVSS 3.x base score is 8.2 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N). The flaw is tracked as CWE-918 and ZDI-CAN-28192/ZDI-26-844, with a vuln.today decision label of this_week. No CISA KEV confirmation was provided, and no public exploit identified at time of analysis.
An out-of-bounds write in libwebsockets' MQTT PUBACK handling lets unauthenticated remote attackers write past the end of an allocated buffer and potentially execute code in the context of the affected process (ZDI-CAN-31039, CWE-787). The flaw is reachable only where libwebsockets is built with the MQTT role enabled and acting as an MQTT client that connects to a broker the attacker controls or can MITM, so a default or non-MQTT deployment is not exposed; the assessed vector is CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H (8.1 High), with AC:H reflecting conditions beyond the attacker's direct control that the available sources do not describe. No public exploit code was identified at time of analysis and the CVE is not listed as confirmed actively exploited (CISA KEV); the priority label is this_week, driven by the High severity rather than by known exploitation.
Double free in Pixar Animation Studios' OpenUSD crate file parser (pxr/usd/sdf/crateFile.cpp) can lead to arbitrary code execution in the context of the current process when an application linking the library opens a maliciously crafted USDC or USDZ file. The CVSS 3.0 base score is 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), reflecting that the attacker needs no credentials but must convince a victim to load attacker-controlled scene or asset content - there is no autonomous network trigger, and concrete delivery vectors vary with the embedding application. Reported by Trend Micro ZDI as ZDI-CAN-30428 / ZDI-26-791; an upstream fix commit exists in the OpenUSD repository, and no public exploit code has been identified at time of analysis.
Local privilege escalation in Quest Foglight for Databases lets an attacker who already has low-privileged code execution on the same host obtain SYSTEM privileges by abusing incorrect folder permissions created by the product installer. The issue is scored CVSS 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and requires local access plus existing low-privileged code execution; it is not remotely reachable and needs no user interaction. No public exploit code was identified at time of analysis.
Local privilege escalation in Quest Foglight for Databases lets an attacker who already holds low-privileged code execution on the host escalate to SYSTEM by abusing a hard-coded cryptographic key in the EncryptionUtil symmetricDecrypt routine. The attack is local-only and requires an existing authenticated foothold (CVSS PR:L), and no public exploit code or CISA KEV entry was identified at time of analysis. With a CVSS base score of 7.8 and high confidentiality, integrity, and availability impact, the flaw is best treated as a post-compromise escalation path on Foglight hosts rather than an internet-facing emergency.
MLflow's SHAP explainer loading path (load_explainer) deserializes untrusted model content, allowing an attacker who supplies a malicious explainer file to execute arbitrary code with the privileges of the user who loads it (CVSS 7.8, CWE-502, ZDI-CAN-30301). The assessed vector is local (AV:L) with user interaction required (UI:R) - the target must open a malicious file or visit a malicious page - so exposure is confined to environments where users load SHAP explainer models from untrusted or unverified sources; no privileges are needed on the target (PR:N) and scope is unchanged, meaning code runs only as that user. No CISA KEV entry and no public exploit code were identified at time of analysis, and the vulnerability carries a 'this_week' priority label rather than an emergency designation.
Code execution in MLflow's PickleEvaluationArtifact handling occurs when a victim loads an attacker-controlled pickle file that is deserialized without proper validation (CWE-502). The CVSS 3.0 base score is 7.8, but the assessed vector is local (AV:L) with required user interaction (UI:R) and no scope change (S:U), so this is not remotely exploitable against a running MLflow server and code runs only in the victim process's context. No CISA KEV entry or public exploit was identified at time of analysis, and vuln.today prioritizes remediation as this_week.
Server-side template injection in the renderTemplateString method of Quest Foglight for Databases lets an authenticated, high-privilege user pass a crafted string into the template engine and have it evaluated as template code, ultimately executing arbitrary commands in the context of SYSTEM. The flaw is rated CVSS 7.2 (CVSS:3.0/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, CWE-1336) and is bounded by the privileged-authentication prerequisite: there is no unauthenticated or low-privilege path described, and no victim interaction is needed. No confirmed active exploitation (CISA KEV) or public exploit code is identified in the available data, and the vuln.today priority label places it in the this_week remediation bucket rather than an emergency one.
Information disclosure in Quest Foglight for Databases can occur when a crafted XML document containing an external entity is processed by the AbstractParser class, causing the parser to resolve an attacker-chosen URI and embed the retrieved content into the XML document. The CVSS vector indicates network reachability with no authentication and no user interaction, although confidentiality impact is rated Low, suggesting constrained rather than full file disclosure. No CISA KEV entry is present, and no public exploit identified at time of analysis; the available data provides only the ZDI advisory ZDI-26-862, and overall this is a genuine but mid-tier priority rather than an emergency.
Authenticated users of Quest Foglight for Databases can supply a crafted file path to the FileServlet endpoint and have the application read files using that path without proper validation, exposing sensitive data with the privileges of the Foglight service account (SYSTEM). The CVSS vector (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, 6.5) confirms the attack is network-reachable and requires only a low-privileged authenticated session, with no victim interaction, and impact limited to confidentiality. There is no CISA KEV listing and no public exploit identified at time of analysis; the ZDI-26-853 advisory is a coordinated disclosure rather than evidence of exploitation, and the priority label is this_month.
MailEnable's parseObjectResponse method can disclose sensitive information to an authenticated remote attacker because it processes attacker-supplied XML without restricting external entity references (CWE-611). Exploitation requires valid low-privilege credentials (CVSS PR:L) and runs in the context of the MailEnable service account, so readable data is bounded by that account's permissions. This is a moderate-severity confidentiality-only issue; no public exploit was identified at time of analysis, and no CISA KEV listing is indicated in the provided data.
An authenticated low-privilege user can escalate privileges in MLflow Tracking Server because the get_endpoints function grants access to functionality without an authorization check. The flaw is rated CVSS 6.3 (CWE-862) and requires network reachability plus a valid account; no public exploit identified at time of analysis, and no KEV entry is provided.
MailEnable stores mailbox credentials in cleartext, creating an information-disclosure exposure (CWE-312, CVSS 5.9) that remote unauthenticated attackers could leverage only in conjunction with a separate access or disclosure primitive; the flaw alone does not provide initial access, and the CVSS vector marks attack complexity as High. No public exploit was identified at time of analysis, and the provided data does not confirm active exploitation (CISA KEV).
The PHP library spatie/url-signer up to 2.1.3 fails to type-check the `expires` query parameter in AbstractUrlSigner::validate() and BaseUrlSigner::validate() before comparing it against the current time, so malformed values (arrays, empty strings, alphanumeric, decimal, scientific-notation or oversized numeric strings) reach the expiration check without being normalized through FILTER_VALIDATE_INT. Applications that pass attacker-influenced URLs to the signer are affected; unauthenticated remote attackers can supply crafted query strings (PR:N, UI:N). Impact is limited to availability (A:L) with no confidentiality or integrity effect, and processing such input yields a failed validation rather than a bypass; a public PoC reference exists (the upstream commit adds regression tests for these malformed inputs), but it is not verified as working exploit code, and there is no CISA KEV listing. Upgrading to 2.1.4 resolves the issue.
Authenticated privilege escalation in MLflow Tracking Server lets a low-privileged user reach functionality and resources that should be restricted from their account, because the server's BEFORE_REQUEST_HANDLERS configuration grants access without a prior authorization check (CWE-862 Missing Authorization). Exploitation requires a valid authenticated session (CVSS 3.0 base 5.4, AV:N/AC:L/PR:L/UI:N, low confidentiality and integrity impact, no availability impact), so deployments that do not enforce a multi-tier privilege model are largely unaffected. There is no CISA KEV entry and no public exploit identified at time of analysis, and the issue is tracked under ZDI-CAN-32108 / ZDI-26-842 rather than being treated as an emergency.
MLflow Tracking Server discloses sensitive information to any authenticated low-privileged user through its jobs functionality, because the _find_validator code path performs no authorization check before granting access to the underlying functionality (CWE-862, CVSS 5.4). Exploitation requires a valid session on the Tracking Server - the assessed vector confirms PR:L, so remote unauthenticated attackers cannot exploit it - plus network reachability to the server, and the exposure is bounded to confidentiality in the context of the service account. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; the vuln.today priority decision is remediation this month, and the reference ZDI-26-840 carries the vendor disclosure detail.
Cross-tenant read exposure in InfiniFlow RAGFlow (through 0.27.2 and 1.0.0-rc2) lets an authenticated low-privilege user query knowledge bases that belong to other tenants through the Text-To-SQL Retrieval feature. Manipulating the tableName/kbIDs arguments passed to RunSQL in internal/engine/infinity/sql.go defeats the ownership check and returns retrieval data from knowledge bases outside the caller's tenant, with confidentiality-only impact and no integrity or availability effect. A public PoC reference exists (github.com/ZSH402/RAGFlow-Cross-Tenant-Read); it is not verified as working exploit code, there is no CISA KEV listing, and the priority decision is monitor - a genuine but low-urgency flaw whose real exposure is limited to multi-tenant deployments that have the retrieval feature reachable.
Authorization bypass in Sanluan PublicCMS 5's trade payment module lets an authenticated low-privileged user supply an arbitrary userId to TradePaymentService.pendingRefund and act on another user's refund records without any ownership check. Exposure is limited to deployments running a release before the 202608 series with the trade payment feature deployed and the web trade payment controller reachable, since that controller was removed in commit 7329437. VulDB reports a public proof-of-concept reference and the CVSS 4.0 vector carries E:P, but there is no confirmed active exploitation (not in CISA KEV) and the vendor-linked priority label is monitor.
CGI versions before 5.00 for Perl allow an infinite loop on a short request body when $DISABLE_UPLOADS is set. When $CGI::PUTDATA_UPLOAD or an upload hook is set, read_postdata_putdata takes a request body that is not a form submission. With $CGI::DISABLE_UPLOADS set, it discards the body by reading until Content-Length bytes have arrived. Once a body shorter than its Content-Length runs out, every read returns 0, so the loop never ends. A client can keep a server process spinning with one such request.
CGI versions before 5.00 for Perl allow memory, CPU and disk exhaustion via missing or unenforced request size, parameter and upload limits. $CGI::POST_MAX defaults to no limit, and when set is not enforced for chunked multipart bodies or for the boundary line of a multipart body without a boundary= parameter. Bodies saved as PUTDATA, POSTDATA or PATCHDATA uploads are read into memory in one go, and nothing limits the number of parameters or uploads.
CGI versions before 5.00 for Perl allow HTML injection via text containing --> in comment. Arguments are placed between <!-- and --> without escaping, so text containing --> closes the comment early. An application that passes request data to comment can be made to inject HTML into the page.
CGI versions before 5.00 for Perl allow Content-Disposition parameter injection via unescaped double quotes in the header attachment filename. header(-attachment => $name) writes $name into the quoted filename parameter of Content-Disposition without escaping double quotes. An application that passes request data as the attachment name can be made to send a second filename parameter, changing the name the response is saved under.
CGI versions from 4.71 before 5.00 for Perl allow denial of service via a plain string dereferenced as a symbolic reference in uploadInfo. uploadInfo dereferences its argument and calls its filename method without checking that it is an upload filehandle. A plain string naming a defined global variable, such as the parameter value from ?upload=0, is treated as a symbolic reference, and the method call on it dies.
CGI versions before 5.00 for Perl allow denial of service via submitted values used as a regex for optgroup selection in scrolling_list. When rendering option groups, scrolling_list marks the selected options by interpolating each selected value, by default taken from the request parameters, unescaped into a substitution pattern. A client can make the request die with an invalid pattern, or tie up the process with one that backtracks heavily.
CGI::Cookie versions before 5.00 for Perl allow cookie attribute injection via unvalidated path, domain and expires values. The path, domain and expires values are written into the Set-Cookie header without checking for semicolons or control characters. An application that sets them from request data can be made to add other cookie attributes, such as Domain or SameSite.
CGI versions from 4.62 before 5.00 for Perl allow cross-site scripting via a raw apostrophe in URLs returned by url and self_url. Both pass the URL through URI's canonical method, which leaves an apostrophe in the path raw and decodes the %27 that query parameter escaping produces, so an apostrophe in the request path or a parameter appears raw in the result. An application that places the URL in a single-quoted HTML attribute or JavaScript string is open to cross-site scripting.
CGI versions before 5.00 for Perl return request-derived values untainted under taint mode. The upload filename, uploadInfo values, some path_info and script_name values, Accept results, and the name lists from url_param and cookie are returned without the taint flag, as is a cookie named expires from 4.67 on. These values come from regex captures or hash keys, which Perl does not taint, so they pass -T checks unvalidated.
CGI versions before 5.00 for Perl return upload filenames with any client-supplied path, including ../ and Windows paths. The name returned for an uploaded file is the filename parameter of the part's Content-Disposition header, unchanged. An application that saves the upload under this name can be made to write outside the intended directory.
CGI versions before 5.00 for Perl allow the POSTDATA, PUTDATA, PATCHDATA and XForms:Model parameters to be set from the query string or form fields. CGI stores a non-form request body under POSTDATA, PUTDATA or PATCHDATA, and an XForms body under XForms:Model, but also accepts these names from the query string, a form field or a multipart part, so an application cannot tell a client-sent value from the real body. A cross-site HTML form can post POSTDATA={"admin":true} to an endpoint that reads JSON from param('POSTDATA'), a request forgery that needs no CORS preflight.
CGI versions before 5.00 for Perl allow HTTP header injection via entity decoding after the newline check in header and unchecked values in multipart_start and do_push. With autoEscape off, header decodes HTML entities in extra header values after its newline check, so an encoded CR or LF reaches the response. multipart_start does not check header values for newlines, and do_push does not check the type it prints in each part. An application that passes request data into these header values can be made to add headers or split the response.
CGI versions before 5.00 for Perl allow open redirects via HTML entity decoding of the URL after application validation in redirect. redirect decodes HTML entities in its URL before writing the Location header, so a URL the application has already validated can change meaning. For example, //evil.example/ becomes //evil.example/ and sends the user to another host.
CGI versions before 5.00 for Perl take request parameters from the process command line arguments for an unrecognised REQUEST_METHOD. For a REQUEST_METHOD such as OPTIONS, CGI falls through to its offline debugging mode, which is on by default, and builds the parameters and path_info from the process's command line arguments.
CGI versions before 5.00 for Perl allow open redirects and script injection via URLs built from REQUEST_URI in url and start_form. url(-absolute=>1), url(-relative=>1) and the default start_form action are built from the client-supplied REQUEST_URI without validation. The result can be protocol-relative (//evil.example), absolute-form (http://evil.example/) or contain backslashes, and url(-relative=>1) can return a javascript: URL. Links and form posts built from these URLs can go to another host.
CGI versions before 5.00 for Perl allow form fields to be smuggled past proxies and WAFs via multipart parsing that differs from the RFCs. The multipart/form-data parser matches the boundary anywhere rather than at the start of a line, uses the boundary without its leading -- for some client-supplied User-Agent values, finds the Content-Disposition name and filename inside the quoted values of other parameters, and corrupts parts when the boundary nears the 4096-byte read size.
CGI::Carp versions before 5.00 for Perl leak warnings across requests in persistent environments via the warningsToBrowser buffer. Warnings are held in a package-level buffer until warningsToBrowser writes them into the page as HTML comments, and the buffer is never cleared between requests. Under mod_perl, FastCGI or PSGI, warnings from one request are written into a later one. Warnings that contain one user's request data can appear in the HTML sent to another user.