The jito-bundle-tip-service npm package contains malicious code that compromises any computer on which it is installed or running. The compromise is severe enough that all secrets and keys stored on the affected machine should be rotated immediately from a different, trusted device. Removing the package alone does not guarantee removal of all malicious software, as the attacker may have gained full control of the system.
The jito-bundle-service npm package contains malicious code that fully compromises any computer on which it is installed or running. The compromise is severe enough that all secrets and keys stored on the affected machine should be rotated immediately from a different, trusted device. Removing the package alone does not guarantee removal of all malicious software or control established by the attacker.
The jito-bundle-tip npm package contains malicious code that compromises any computer on which it is installed or running. The compromise is severe enough that all secrets and keys stored on the affected system should be rotated immediately from a separate, secure machine. Removal of the package does not guarantee elimination of all malicious software installed as a result of this compromise.
The jito-bundle npm package contains malicious code that compromises any computer on which it is installed or running. This compromise includes potential full control by an outside entity, risking exposure of all stored secrets and keys. Immediate removal of the package and rotation of all secrets and keys from a different, uncompromised computer is strongly advised.
The npm package babyyodaa version 1.1.0 contains malicious code that executes a reverse shell upon installation. The preinstall script sets a bundled shell script as executable and runs it, allowing a remote attacker to gain shell access to the installing machine. Any system with this package installed should be considered fully compromised, and all secrets and keys on that system must be rotated immediately. Removal of the package does not guarantee elimination of all malicious artifacts.
The 'gugoddiscordapi' npm package contains malicious code that can fully compromise any computer where it is installed or running. This compromise may allow attackers to access all secrets and keys stored on the affected system. Removal of the package alone does not guarantee elimination of all malicious components, as the attacker may have established persistent control.
The npm package 'gogodstramapi' contains malicious code that compromises any computer on which it is installed or running. The compromise is severe enough that all secrets and keys stored on the affected system should be considered exposed and require immediate rotation from a different, uncompromised machine. Removal of the package alone may not fully eliminate the malicious presence due to potential persistent control by an attacker.
The npm package 'apigugod' contains malicious code that compromises any computer on which it is installed or running. The compromise is severe enough that all secrets and keys stored on the affected system should be rotated immediately from a different, trusted machine. Removing the package alone is insufficient to guarantee removal of all malicious software introduced by it.
The npm package 'gugodapistram' contains malicious code that compromises any computer on which it is installed or running. Installation of this package may lead to full system compromise, requiring immediate rotation of all secrets and keys from a separate, uncompromised device. Removal of the package alone may not eliminate all malicious components due to potential persistent control by an attacker.
The gugodapi npm package contains malicious code that compromises any computer on which it is installed or running. The compromise is severe enough that all secrets and keys stored on the affected system should be rotated immediately from a different, trusted machine. Removing the package alone may not fully eliminate the malicious presence, as the attacker may have established persistent control.
The npm package 'gogodapiapp' contains malicious code that can fully compromise any computer on which it is installed or running. This compromise potentially exposes all secrets and keys stored on the affected system. Removal of the package alone may not eliminate all malicious components, as the attacker may have established persistent control.
The npm package '@jisan901/teamfocus' contains malicious code that compromises any computer on which it is installed or running. The compromise is severe enough that all secrets and keys stored on the affected system should be rotated immediately from a different, uncompromised machine. Removing the package alone does not guarantee removal of all malicious software introduced by its installation.
The npm package @jisan901/fs-browser contains malicious code that can fully compromise any computer on which it is installed or running. The compromise includes potential unauthorized access to all secrets and keys stored on the affected system. Immediate removal of the package is advised, but full remediation may require rotating all secrets and keys from a different, uncompromised computer due to the possibility of persistent malicious software.
The npm package 'kartykgithub-bulk-rollback' contains malicious code that compromises any computer on which it is installed or running. The compromise is severe enough that all secrets and keys stored on the affected machine should be rotated immediately from a separate, secure device. Removal of the package alone may not eliminate all malicious software introduced by its installation.
In Open Object Rexx (ooRexx) before 5.2.0, RXAPI relies on a world-writable /tmp file unless XDG_RUNTIME_DIR is set, or localhost TCP port 10010, allowing RXAPI communication by any local user, e.g., for injection of a macro that will be executed by a REXX script.
The Zephyr WebSocket client validates the server's handshake response in on_header_value() in subsys/net/lib/websocket/websocket.c. The comparison was performed as strncmp(at, str, length), where length is the length of the value the server sent rather than the length of the expected value, so the check only asked whether the received value was a prefix of the expected base64(SHA-1(key || GUID)). A server that returned a handful of correct characters passed, and a response carrying an empty Sec-WebSocket-Accept: header caused strncmp() to be called with a count of zero, which returns 0 and set ctx->sec_accept_ok with no comparison performed at all. The header-value callback also cleared ctx->sec_accept_present after the first chunk, so a value split across receive-buffer boundaries was only ever examined in part.
ctx->sec_accept_ok is the sole WebSocket-specific gate in websocket_connect(); the client does not check the HTTP status code or the Upgrade:/Connection: headers. Any HTTP response containing an empty or prefix-matching Sec-WebSocket-Accept header therefore completed the handshake, after which the socket is finalized as a WebSocket and all further peer bytes are parsed as frames. The affected path is driven directly by remote input through subsys/net/lib/http/http_parser.c, and is reached by every user of websocket_connect(), including MQTT over WebSocket (subsys/net/lib/mqtt/mqtt_transport_websocket.c) and subsys/net/lib/ocpp/ocpp.c.
The Sec-WebSocket-Accept exchange is not a secret-based authentication -- an endpoint or on-path attacker that sees the request can compute the expected value -- so the impact is bounded to parties that never observed the handshake request: a caching or transparent intermediary replaying a canned response, an off-path attacker injecting a spoofed response, or a non-WebSocket endpoint the client was induced to talk to. For those, the per-connection binding that RFC 6455 requires the client to enforce provided no protection at all, letting a single crafted response convince the device it holds a live WebSocket session and causing it to send application data to, and accept frames from, an unverified peer. There is no memory-safety consequence.
The fix compares each delivered chunk against the expected value at the position reached so far, refuses a chunk that would overrun it, and accepts only once every byte of the expected value -- and no more -- has been matched; on_header_field() now also clears the flag for any other header so a partial value cannot be continued across an intervening header.
The websocket client's HTTP header callback on_header_value() in subsys/net/lib/websocket/websocket.c receives the Sec-WebSocket-Accept header value as a pointer/length pair from the HTTP parser. The referenced bytes live inside the application-supplied receive buffer and are not NUL terminated. When the received value did not match the expected accept key, the pointer was passed directly to a %s conversion in a NET_DBG() call, so the logging code measured the string with strlen() and read on past the end of the header value looking for a terminator.
The value is supplied by the peer during the WebSocket handshake, before any application-level authentication, so a malicious or man-in-the-middle server reached over a ws:// (or otherwise attacker-terminated) connection can trigger the mismatch branch at will simply by answering with a wrong accept key. By sizing the response so the header value ends at the tail of the buffer passed to websocket_connect() as wreq->tmp_buf, the peer can make the scan run off the end of that buffer and into adjacent memory. The defective log statement is compiled in only when websocket debug logging is enabled (CONFIG_NET_WEBSOCKET_LOG_LEVEL_DBG=y, or CONFIG_LOG_DEFAULT_LEVEL=4); it is absent from a default build, which bounds exposure to diagnostic configurations.
The consequence is an out-of-bounds read whose contents are emitted to the log stream: memory adjacent to the receive buffer is disclosed wherever the device's logs are collected or displayed. On targets where the memory following the buffer is not mapped, the scan can instead fault and terminate the connection or thread. No out-of-bounds write occurs, so there is no integrity impact.
The fix copies at most sizeof(got) - 1 bytes of the parser-provided slice into a bounded stack buffer, NUL terminates the copy, and logs that instead, so the formatter never reads beyond the bytes the parser actually offered.
The Bluetooth Classic SDP client built its outgoing request PDUs with bt_sdp_create_pdu(), which allocates from the sdp_pool net-buf pool with a K_FOREVER timeout and no failure handling, in sdp_client_ss_search(), sdp_client_sa_search() and sdp_client_ssa_search() in subsys/bluetooth/host/classic/sdp.c. All of these run on the Bluetooth workqueue bt_workq (via sdp_client_work_handler(), the L2CAP sdp_client_connected() callback, or the continuation-state follow-up from a received response), which is the same single thread that dispatches incoming HCI ACL and event traffic, drives L2CAP, and performs connection and channel teardown. sdp_pool holds only CONFIG_BT_MAX_CONN buffers (one by default) and is shared with the SDP server role.
An unauthenticated peer within BR/EDR range can drive both halves of the trigger. The SDP L2CAP server is registered at BT_SECURITY_L0, so any inbound SDP request makes the device allocate the pool's buffer for a response, which is held until the controller has transmitted it. The same peer can then cause a client request to be issued while the pool is empty: in-tree profiles start SDP discovery from inbound connection callbacks (for example hfp_hf_accept() calls bt_sdp_discover() through hfp_hf_create(), and hfp_ag.c mirrors this), and a peer acting as an SDP server can force repeated client requests by answering with partial responses carrying continuation state.
With the pool empty, the allocation blocks uninterruptibly and freezes the entire Bluetooth host. The stall becomes permanent when the release of the outstanding buffer itself depends on the blocked workqueue: if the link carrying the queued PDU is dropped or stalls, hci_disconn_complete() and the L2CAP channel cleanup that purges the channel TX queue are themselves bt_workq work items, so the buffer is never returned. The result is an unrecoverable denial of service of all Bluetooth functionality until reboot; there is no memory-safety, confidentiality or integrity impact.
The fix allocates client PDUs with K_NO_WAIT via a new sdp_client_create_pdu(), propagates -ENOBUFS, parks the session on a new SDP_CLIENT_FLAG_WAIT_FOR_TX_BUF flag, and adds an sdp_pool destructor that re-submits the SDP client worker when a buffer becomes available. Note that the SDP server role still allocated from the same pool with K_FOREVER at this commit; that path was addressed separately.
OpenCTI is an open source platform for managing cyber threat intelligence knowledge and observables. Prior to 7.260513.0, Draft Workspace identifiers are accepted without verifying that the authenticated user can access the referenced draft. Any authenticated user can enumerate draftWorkspaces, use a disclosed DRAFT_ID with draftWorkspaceEntities to read unpublished reports, descriptions, observables, and other staged intelligence, or place the identifier in the opencti-draft-id header and run mutations that inject entities and relationships into another user's private workspace. The flaw permits cross-user disclosure and tampering but does not cause a denial of service. This issue is fixed in version 7.260513.0.