Security information
Upgraded the following middleware component versions to resolve vulnerabilities in MKE:
[MKE-15524] Golang 1.27.3
[MKE-15551] Interlock 3.4.7
[MKE-15569] Ingress Controller 1.15.3-mirantis / nginx 1.30.3
[MKE-15548] alertmanager 0.34.2
[MKE-15112] Metallb 0.16.1
[MKE-15538] cri-dockerd 0.4.10
[MKE-15109] Node Local DNS 1.27.1
[MKE-15548] CoreDNS 1.14.7
[MKE-15548] etcd 3.5.35
[MKE-15676] Node Feature Discovery 0.20.1
The following table details the specific CVEs addressed, including which images are affected per CVE.
CVE |
Image mitigated |
Problem details from upstream |
|---|---|---|
|
urllib3 is an HTTP client library for Python. From 1.10.3 until 2.8.0, the HTTPResponse.read_chunked and HTTPResponse.stream methods can allocate unbounded memory because the streaming chunk parser buffers the chunk-size field until newline or EOF without a length bound. The trigger is that a malicious server returns Transfer-Encoding: chunked followed by a very long run of bytes without a newline. The attack mechanism is that a malicious HTTP server sends a very long unterminated chunk-size line. The impact is that unbounded memory allocation can exhaust the client process. This issue is fixed in version 2.8.0. |
|
|
urllib3 is an HTTP client library for Python. From 1.26.0 until 2.8.0, the proxy_ssl_context, proxy_assert_hostname, proxy_assert_fingerprint, ssl_context, cert_reqs, verify_mode, use_forwarding_for_https=True, and CERT_NONE configuration paths fail to remain separated because target-server TLS settings are incorrectly applied to the HTTPS proxy connection. The trigger is that an application uses an HTTPS proxy and configures target-server TLS settings that must remain separate from the proxy TLS handshake, including HTTPS forwarding with target-specific identity or credentials. Applying cert_reqs=CERT_NONE can overwrite proxy_ssl_context.verify_mode in place, and the mutation persists so later connections reusing the same context may connect to the HTTPS proxy without certificate verification. The attack mechanism is that an attacker intercepts and impersonates the HTTPS proxy after the effective proxy policy accepts the attacker’s certificate. The impact is that the attacker can observe or modify forwarded traffic or receive a target TLS client certificate, while CONNECT tunneling still preserves the separate end-to-end target TLS connection. This issue is fixed in version 2.8.0. |
|
|
A recursive BIND server that receives a query with recursion desired (RD=1) followed by a non-recursive query (RD=0) may exit with an assertion failure, resulting in a denial of service. To be vulnerable, the BIND server must allow recursive queries and have at least two RPZ zones configured: one with the default setting of “recursive-only yes”, and the other with “recursive-only no”. This issue affects BIND 9 versions 9.16.0 through 9.18.50, 9.20.0 through 9.20.29, 9.21.0 through 9.21.26, 9.11.3-S1 through 9.18.50-S1, and 9.20.9-S1 through 9.20.29-S1. |
|
ucp-interlock-configucp-interlock-proxy |
NGINX Plus and NGINX Open Source have a vulnerability in the ngx_http_core_module module. When asynchronous file I/O (AIO) is enabled in certain configurations, processing a Server Side Includes (SSI) page containing “include virtual” commands may trigger a Use-After-Free (UAF) in the NGINX worker process. This may cause memory corruption or a worker process crash. Additionally, attackers can execute code on systems with Address Space Layout Randomization (ASLR) disabled or when the attacker can bypass ASLR. Impact: This vulnerability may allow remote attackers to cause a denial-of-service (DoS) on the NGINX system, corrupt its memory, or possibly trigger code execution. There is no control plane exposure; this is a data plane issue only. Note: Software versions which have reached End of Technical Support (EoTS) are not evaluated. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
In childTextNodesAreLiteral, walking up the tree previously stopped at the nearest foreign ancestor once an HTML integration point was found. However, that integration point may itself be a descendant of an element that was foster-parented into a foreign namespace (such as <mglyph> or <malignmark> fostered under <mtext>), causing a parser to resolve the subtree in a different foreign namespace upon re-parsing the rendered output. Continue walking the full ancestor chain and verify that every transition from a non-empty namespace occurs at an HTML integration point before emitting literal text. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
HTTP/2 servers could end up crashing due to inadvertently modifying its HPACK encoder concurrently. This happens because the server modifies the HPACK encoder from two goroutines without synchronization: one uses the encoder to encode a HEADERS frame as part of a response sent to a client and the other modifies the encoder’s table size when handling a SETTINGS frame containing SETTINGS_HEADER_TABLE_SIZE that a client sends. A malicious client can repeatedly send a request while changing the header table size to crash the server. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
Multiple ECH outer extension references are not permitted under RFC 9849; previously, a client could send a well-crafted packet that could trigger memory exhaustion in the server process by specifying multiple references. We now reject these as malformed and curb the memory amplification vector as a result. |
|
|
A BIND resolver that is configured with both a “redirect” zone and “qname-minimization strict” may abort with an assertion failure while processing the redirect. This issue affects BIND 9 versions 9.16.0 through 9.18.50, 9.20.0 through 9.20.29, 9.21.0 through 9.21.26, 9.16.8-S1 through 9.18.50-S1, and 9.20.9-S1 through 9.20.29-S1. |
|
|
Archive::Tar versions before 3.10 for Perl allow memory exhaustion via attacker controlled entry size field in tar header. _read_tar() reads each entry’s payload with $handle->read($$data, $block), where $block is derived from the entry’s 12-byte size field in the tar header with no upper bound on that value. A crafted header declaring a multi-gigabyte size causes Perl to allocate a scalar of that size. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
Parsing a multipart form can bypass memory limits and read an arbitrarily long line into memory when the remaining limit at the start of a part is less than 400 bytes. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
When an HTTP server handler sends a 2xx response to an HTTP/1 CONNECT request and returns without hijacking the connection, the server improperly continues to read and serve requests from the connection. Since a 2xx response to an HTTP/1 CONNECT converts the connection into a tunnel, the server should not treat the connection as continuing to contain HTTP. The impact of this misbehavior is mostly limited to potential request smuggling, where an intermediate proxy considers the data on the connection to be tunneled and the server considers it to be HTTP. |
|
|
Replaying GSS-TSIG signed UDP messages can result in memory corruption
in |
|
ucp-interlock-configucp-interlock-proxy |
A denial of service via unsigned underflow in libXpm’s write path in libXpm before 3.5.19 could be used by local attackers to cause unbounded CPU usage and memory exhaustion. |
|
ucp-authucp-interlock-configucp-interlock-proxy |
libcurl could accidentally return a URL for |
|
ucp-interlock-configucp-interlock-proxy |
Expat before 2.8.5 fails to validate that a high surrogate in UTF-16 input is followed by a low surrogate, allowing malformed UTF-16 sequences to be accepted. Attackers can supply UTF-16 encoded XML containing lone high surrogates that consume the following code unit, causing Expat to pass unpaired surrogates to applications built with XML_UNICODE and to silently replace input characters in other builds. |
|
ucp-interlock-configucp-interlock-proxy |
A vulnerability exists in NGINX Plus and NGINX Open Source when a map directive uses regex matching and the root directive or access log format references the map’s regex capture variables before referencing the map output variable. Alternatively, the same result could be achieved by using a non-cacheable variable in a string expression under certain conditions. An unauthenticated attacker along with conditions beyond their control can exploit this vulnerability by sending crafted HTTP requests. This may cause a heap buffer overflow in the NGINX worker process leading to a restart. Additionally, attackers can execute code on systems with Address Space Layout Randomization (ASLR) disabled or when the attacker can bypass ASLR. Impact: This vulnerability may allow remote attackers to cause a denial-of-service (DoS) on the NGINX system or to possibly trigger a code execution. There is no control plane exposure; this is a data plane issue only. Note: Software versions which have reached End of Technical Support (EoTS) are not evaluated. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-calico-cni-firewalld-chrootucp-cfsslucp-cloud-controller-managerucp-controllerucp-etcducp-hardware-infoucp-interlock-configucp-interlock-proxyucp-kube-ingress-controllerucp-metricsucp-metrics-swarm-onlyucp-node-exporterucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-sf-notifierucp-swarm |
During an upload, curl mishandles HTTP/2 |
|
ucp-authucp-interlock-configucp-interlock-proxy |
A deeply nested multipart MIME structure constructed via the public API
causes a stack overflow in libcurl during normal cleanup operations. An
excessive recursion depth within |
|
ucp-composeucp-dsinfoucp-interlock-configucp-interlock-proxyucp-multus-cniucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discovery |
In PCRE2 before 10.48, pcre2_jit_match mishandles a previously copied subject being passed in as a context. An incorrect free operation can occur. |
|
ucp-interlock-configucp-interlock-proxyucp-multus-cni |
PCRE2 before 10.48, on 32-bit platforms, has a pcre2_pattern_convert out-of-bounds write when an attacker can provide a large pattern. |
|
ucp-interlock-configucp-interlock-proxy |
A malicious X server could exploit a buffer overflow in libX11 before 1.8.14 during handling of XkbGetMap overflowing the key_sym_map. |
|
ucp-authucp-interlock-configucp-interlock-proxy |
When built with wolfSSL, curl can successfully validate a pinned public key hash against a key the TLS peer does not possess. During the TLS handshake, wolfSSL validates the connection, but curl’s subsequent re-parsing of the same certificate - tricked by a manipulated validity length field - extracts and matches a different embedded key, incorrectly authorizing the pinned public key. |
|
ucp-authucp-interlock-configucp-interlock-proxy |
When libcurl uses libssh2 with a hashed |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-calico-cni-firewalld-chrootucp-cfsslucp-cloud-controller-managerucp-controllerucp-etcducp-hardware-infoucp-interlock-configucp-interlock-proxyucp-kube-ingress-controllerucp-metricsucp-metrics-swarm-onlyucp-node-exporterucp-node-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-sf-notifierucp-swarm |
An HTTP proxy can trick libcurl into sending the origin’s credentials
(Basic password, or a Negotiate/Kerberos ticket) to the proxy itself, by
answering the |
|
ucp-authucp-interlock-configucp-interlock-proxy |
A flaw in the curl command line tool’s logic makes it only set SSH host verification options when interacting directly using SFTP or SCP, and not as a result of following a redirect. |
|
ucp-composeucp-dsinfoucp-interlock-configucp-interlock-proxyucp-multus-cniucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discovery |
PCRE2 before 10.48 allows a pcre2_dfa_match out-of-bounds write because reuse of a cached workspace block, in a recursive DFA matching workspace, lacks a size check (even though a newly allocated block, for the same purpose, does have a size check). This outcome requires an attacker-controlled regular expression, or a recursive pattern in conjunction with a small heap limit (this can be set through the API). |
|
|
In libxml2 before 2.15.4, xmlSnprintfElements in valid.c has a strcat stack-based buffer overflow. |
|
|
CoreDNS is a DNS server written in Go. Prior to 1.14.7, the DNS-over-HTTPS, DNS-over-HTTP/3, DNS-over-QUIC, and DNS-over-gRPC listeners in plugin/pkg/doh/doh.go, core/dnsserver/server_quic.go, and core/dnsserver/server_grpc.go call dns.Msg.Unpack without the dns.DefaultMsgAcceptFunc request policy used by UDP, TCP, and DNS-over-TLS. An unauthenticated client can send an RFC 2136 UPDATE that the proxy or forward plugin passes unchanged to an update-capable upstream. If that upstream trusts CoreDNS’s source address or connection and does not require an attacker-unknown end-to-end TSIG, the request appears to originate from CoreDNS and can add, replace, or delete DNS records, redirect traffic, take over names, alter mail routing, or disrupt the writable zone. This issue is fixed in version 1.14.7. |
|
ucp-agentucp-authucp-calico-cni-firewalld-chrootucp-cfsslucp-cloud-controller-managerucp-controllerucp-etcducp-hardware-infoucp-interlockucp-interlock-configucp-interlock-extensionucp-interlock-proxyucp-node-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
zlib 1.2.11 through 1.3.2 contains a heap buffer overflow: after an underlying write() fails, gz_write() returns without resetting strm.next_in, leaving it pointed at the caller’s buffer. A later gz* write call then derives a position from the stale pointer and writes past a heap allocation; any write() failure reaches it, including EPIPE on a blocking descriptor, and in versions before 1.3.1.2 the failed write must be followed by a gzclearerr() call. |
|
|
A malicious remote peer may flood the local QUIC stack with NEW_CONNECTION_ID frames by avoiding a limit check on how many connection IDs the remote QUIC stack can use. |
|
ucp-multus-cniucp-node-feature-discoveryucp-node-local-dns |
The DTLS retransmission logic does not correctly handle a handshake message write that is suspended part-way through. The retransmitted message can be read past the message buffer and the retransmission overwrites the internal state the suspended write needs to resume correctly. |
|
ucp-alertmanagerucp-blackbox-exporterucp-cloud-controller-managerucp-corednsucp-etcducp-multus-cniucp-node-feature-discoveryucp-node-local-dnsucp-nvidia-device-plugin |
gRPC-Go is the Go language implementation of gRPC. Prior to 1.82.2 and 1.83.2, servers created with xds.NewGRPCServer() allow internal/transport/http2_server.go to accept an RPC containing neither the :authority header nor the Host header, while RouteAndProcess in internal/xds/server/routing.go assumes that an authority value exists and indexes the empty slice. A remote client that can complete transport connection establishment can trigger an index-out-of-bounds panic that is not recovered by the per-RPC goroutine and terminates the entire server process. In insecure or ordinary TLS deployments the request can be unauthenticated, while strict mTLS or ALTS deployments require valid transport credentials before the malformed RPC can reach the interceptor. This issue is fixed in versions 1.82.2 and 1.83.2. |
|
ucp-alertmanagerucp-blackbox-exporterucp-cloud-controller-managerucp-corednsucp-etcducp-multus-cniucp-node-feature-discoveryucp-node-local-dnsucp-nvidia-device-plugin |
gRPC-Go is the Go language implementation of gRPC. Prior to 1.83.1, internal/transport/transport.go stores each fragmented HTTP/2 DATA frame as a separate recvMsg in recvBuffer, so millions of one-byte frames can consume disproportionate heap memory even when payload bytes remain within connection and stream flow-control windows. An unauthenticated remote attacker can use concurrent multiplexed streams to exhaust process memory and cause a runtime panic or out-of-memory termination. Receive-buffer compaction is enabled by default and can be controlled temporarily with GRPC_GO_EXPERIMENTAL_ENABLE_RECEIVE_BUFFER_COMPACTION. This issue is fixed in version 1.83.1. |
|
|
Perl versions before 5.40.5-RC1, from 5.41.0 before 5.42.3-RC1, from 5.43.0 before 5.43.11 have a heap buffer overflow when compiling regular expressions with a repeated fixed string on 32-bit builds. Perl_study_chunk in regcomp_study.c checked the size of the joined substring buffer in characters rather than bytes. For a quantified fixed substring with a large minimum count, the byte length mincount * l could overflow SSize_t, producing an undersized SvGROW allocation; the subsequent copy writes past the end of the buffer. A caller that compiles an attacker-controlled regular expression on a 32-bit perl build triggers a heap buffer overflow at compile time. |
|
|
CoreDNS is a DNS server written in Go. Prior to 1.14.7, the DNS-over-HTTPS, DNS-over-HTTP/3, DNS-over-QUIC, and DNS-over-gRPC request paths in plugin/pkg/doh/doh.go, core/dnsserver/server_quic.go, and core/dnsserver/server_grpc.go call dns.Msg.Unpack on attacker-controlled DNS section counts before dns.DefaultMsgAcceptFunc validates the fixed header. An unauthenticated client can use DNS name compression and excessive section counts to amplify allocation before the plugin chain, so plugin-level rate limiting cannot prevent concurrent requests from exhausting memory and terminating CoreDNS. The ordinary UDP and TCP listeners are not affected because they validate the header first. This issue is fixed in version 1.14.7. |
|
|
When libpsl support is enabled, libcurl fails to enforce the Public
Suffix List boundary check when processing a |
|
|
In CPython 3.13 and earlier, the tarfile module’s data and tar extraction filters are vulnerable to crafted archives containing a hard link to a symbolic link. Such archives may cause extraction to modify the permissions or modification time of a file outside the destination directory, or expose the contents of that file within the extracted tree. |
|
ucp-composeucp-dsinfoucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discovery |
If a BIND resolver has cached a tree of SVCB/HTTPS AliasMode records, and is then queried for the root of that tree, the resolver will spend disproportionate CPU time constructing the response. This issue affects BIND 9 versions 9.18.0 through 9.18.50, 9.20.0 through 9.20.27, 9.21.0 through 9.21.25, 9.18.11-S1 through 9.18.50-S1, and 9.20.9-S1 through 9.20.27-S1. |
|
ucp-composeucp-dsinfoucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discovery |
A BIND resolver encountering an SVCB/HTTPS AliasMode record referencing 14 or more SVCB/HTTPS ServiceMode records may fail to properly deallocate internal resources. If this happens repeatedly, resource exhaustion will eventually prevent the resolver from performing new recursive lookups. This issue affects BIND 9 versions 9.18.0 through 9.18.50, 9.20.0 through 9.20.27, 9.21.0 through 9.21.25, 9.18.11-S1 through 9.18.50-S1, and 9.20.9-S1 through 9.20.27-S1. |
|
ucp-composeucp-dsinfoucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discovery |
If a BIND resolver sends a query for a DNSSEC-signed authoritative zone, and the authoritative server replies with a valid wildcard answer and signed NSEC3 proof, followed by an unsigned NSEC at the same owner name, it will trigger an unexpected program exit. This issue affects BIND 9 versions 9.11.0 through 9.18.50, 9.20.0 through 9.20.27, 9.21.0 through 9.21.25, 9.11.3-S1 through 9.18.50-S1, and 9.20.9-S1 through 9.20.27-S1. |
|
ucpucp-agentucp-calico-cni-firewalld-chrootucp-cfsslucp-cloud-controller-managerucp-controllerucp-etcducp-hardware-infoucp-interlock-configucp-interlock-proxyucp-node-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
||
|
When |
|
ucpucp-agentucp-calico-cni-firewalld-chrootucp-cfsslucp-cloud-controller-managerucp-controllerucp-etcducp-hardware-infoucp-interlock-configucp-interlock-proxyucp-node-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
When performing transfers via libcurl’s multi interface, pooled TLS connections can outlive their originating easy handles. In OpenSSL 3 provider configurations, libcurl attaches an allocated library context to the easy handle’s state and passes it to OpenSSL without acquiring an ownership reference; destroying the easy handle prematurely frees this context while the active connection retains a dangling pointer, leading to a heap-use-after-free upon subsequent I/O or post-handshake operations. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
A malicious HTTP/2 peer can cause excessive CPU consumption in the client or server by opening a large number of streams and then sending many small SETTINGS frames containing SETTINGS_INITIAL_WINDOW_SIZE values. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
When parsing a Range header containing a large number of small ranges, FileServer(FS), ServeContent, and ServeFile(FS) can consume an excessive amount of CPU. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
The HTTP/2 server can refund connection-level flow control twice for the same data: Once when a client resets a stream (refunding data for any sent-but-unread portion of the stream), and again when a request handler reads the buffered data. A malicious client can exploit this to bypass the configured connection-level flow control limit (MaxReceiveBufferPerConnection). Total buffered data is still limited by the concurrent stream limit and stream-level flow control. |
|
ucp-alertmanagerucp-azure-ip-allocatorucp-blackbox-exporterucp-cloud-controller-managerucp-corednsucp-etcducp-kube-state-metricsucp-node-exporterucp-node-feature-discoveryucp-node-local-dnsucp-rethinkdb-exporter |
Previously, a channel registered in the mux’s chanList is not usable until it is established. A malicious peer was able flood the channel’s incomingRequests, deadlocking the entire connection. Now, we add an atomic established state, set when a channel becomes usable. Until such a time, handlePacket drops every packet other than the open confirmation/failure, without blocking and without tearing down the connection. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
When coalescing adjacent text nodes in addText and fosterParent, appending to an existing TextNode’s Data via string concatenation (n.Data += text) reallocated and copied the accumulated string on every token. Inputs containing many short text runs separated by ignored end tags (such as “a</x>”) caused O(n^2) allocations and byte copies. Accumulate coalesced text in per-node byte slices during parsing and materialize Data strings once at the end of parse. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
Historically, we have been rather lax about malformed framing-related headers in our HTTP/2 implementation, as they cannot interfere with HTTP/2 framing. However, this makes it possible for our HTTP/2 implementation to forward responses containing such headers to an HTTP/1 client when acting as a reverse proxy. If the HTTP/1 client also does not behave strictly enough, this can result in response smuggling. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
When “Trailer” headers are sent by a client, the HTTP server internally uses the header values to populate the Request.Trailer map passed to the server handler. Because Request.Trailer is a map, each entry incurs memory overhead. For HTTP/2 servers, a malicious client can exploit this by sending a “Trailer” header that declares a large number of fields, causing the server to allocate a disproportionate amount of memory while bypassing Server.MaxHeaderValueCount and Server.MaxHeaderBytes limits. This exploit is not applicable for HTTP/1 servers, which do not support multiplexing a large number of requests over one TCP connection, and whose Server.MaxHeaderBytes are calculated differently. |
|
ucp-interlock-configucp-interlock-proxyucp-multus-cni |
A flaw was found in util-linux. Restricted bind mounts take the source path from fstab but do not pin that source before the privileged mount. A local unprivileged user who can replace the authorized source or a writable ancestor can redirect SUID mount(8) to bind another host directory. If the fstab entry also sets X-mount.owner, X-mount.group, or X-mount.mode, root then changes ownership or mode on that redirected inode. |
|
ucp-interlock-configucp-interlock-proxyucp-multus-cni |
The X-mount.subdir option uses a detached-tree fast path on Linux 6.15 and later and passes the configured subdirectory to open_tree() with AT_SYMLINK_NOFOLLOW. That flag does not stop intermediate symlink traversal or keep resolution inside the newly mounted filesystem. A local unprivileged user with an fstab-authorized X-mount.subdir entry can attach a host path at the intended mountpoint. |
|
ucp-interlock-configucp-interlock-proxyucp-multus-cni |
The nsenter –join-cgroup option opens the target cgroup.procs file as root and leaves that file descriptor open across later namespace and credential changes and across execve(). Because the kernel checks later cgroup migrations using the credentials from the original open, a program run in an attacker-controlled target can inherit root’s ability to move host processes between cgroups. After a privileged operator uses –join-cgroup against that target, an unprivileged user can migrate and terminate unrelated root processes. |
|
ucp-interlock-configucp-interlock-proxy |
libexpat before commit 13c5f63 contains a heap buffer over-read vulnerability in xmlparse.c. XML_ParseBuffer advances the parse buffer end with parser->m_bufferEnd += len using a caller-supplied length that is not validated against the allocated buffer size, so repeated XML_ParseBuffer calls move m_bufferEnd past the end of the heap allocation and subsequent parsing reads out of bounds. Reaching this path requires a parse buffer to already be present; otherwise XML_ParseBuffer returns XML_ERROR_NO_BUFFER. A buffer is present after a prior call to XML_GetBuffer, either directly (the common case) or indirectly through a prior XML_Parse call that allocates the buffer internally. The over-read discloses adjacent heap memory to the calling application, recovering heap pointers, libc function pointers, and code pointers sufficient to defeat ASLR and build further exploitation primitives. |
|
ucp-interlock-configucp-interlock-proxy |
libexpat before 2.8.4 lacks handler call depth tracking with custom encoding callbacks. Thus, a use-after-free can occur. NOTE: this is similar to CVE-2026-50219, CVE-2026-56131 and CVE-2026-56412. |
|
ucp-interlock-configucp-interlock-proxy |
In libexpat 2.8.2 and 2.8.3 before 2.8.4, misinterpretation of getentropy’s return code leads to insufficient entropy, which results in being vulnerable to hash flooding attacks, causing a denial of service via crafted XML content. |
|
ucp-interlock-configucp-interlock-proxyucp-multus-cni |
util-linux versions through 2.41.5 and 2.42.2 fail to check mount helper exit status before running post-mount hooks, allowing unprivileged users to execute privileged operations on pre-existing filesystems. Attackers can exploit X-mount.idmap or X-mount.owner hooks to clone filesystems with inherited suid bits or modify target inode permissions after a helper fails, achieving privilege escalation. |
|
ucp-interlock-configucp-interlock-proxyucp-node-feature-discovery |
Expat through 2.8.3 contains an out-of-bounds read vulnerability that allows attackers to trigger memory corruption by processing XML with external entity parsers created via XML_ExternalEntityParserCreate. A struct size mismatch between ELEMENT_TYPE members causes storeAtts to read the attIndex member past allocated memory boundaries, resulting in failure to normalize whitespace in non-CDATA attributes or a wild pointer dereference causing a segfault. This vulnerability was introduced by the fix for CVE-2026-66046. |
|
ucp-multus-cniucp-node-local-dns |
A CMP client that requests certificate revocation on the basis of a PKCS#10 CSR may dereference a NULL pointer and terminate abnormally when processing a crafted revocation response. |
|
|
A flaw was found in libxml2 with Python bindings enabled. A remote attacker could exploit this vulnerability by providing a specially crafted XML document containing a Document Type Definition (DTD) with enumerated attribute values. This triggers a double-free error in the SAX attributeDecl callback handler, where a string is freed twice. This flaw can lead to a denial of service (DoS) due to a reproducible crash in Python applications using the libxml2 SAX bindings. |
|
|
HTTP::Tiny versions before 0.095 for Perl forward credential headers to
cross-origin redirect targets. When the server returns a 3xx redirect,
|
|
ucp-interlock-configucp-interlock-proxyucp-node-feature-discovery |
Expat through 2.8.3 contains a denial of service vulnerability caused by quadratic algorithmic complexity in the storeAtts() function in xmlparse.c, where processing N specified attributes with non-normalized values triggers an O(N^2) linear scan of elementType->defaultAtts to determine CDATA status. A remote unauthenticated attacker can supply a single well-formed XML document of a few megabytes to an application parsing untrusted XML to cause excessive CPU consumption, resulting in denial of service without requiring authentication, external entity resolution, or non-default parser options. |
|
|
libpcap BPF interpreter treats the offset in the ‘ja L’ BPF instruction as a signed integer to implement looping via backward jumps, but it does not limit the number of loop iterations. A crafted filter program or the ‘protochain’ primitive used on a crafted network packet can cause the interpreter to loop infinitely. |
|
ucp-multus-cniucp-node-local-dns |
Calling wordexp with WRDE_APPEND in the GNU C Library version 2.0 to version 2.43 can cause the interface to return invalid memory in the we_wordv member, which on subsequent calls to wordfree may abort the process. |
|
|
Libevent is an event notification library. Prior to 2.1.13 and
2.2.2-alpha, libevent has a heap out-of-bounds write in
bufferevent_sock.c when |
|
|
Libevent is an event notification library. Prior to 2.1.13 and 2.2.2-alpha, libevent has two HTTP parsing weaknesses in http.c. evhttp_decode_uri_internal decodes percent-encoded %00 bytes into literal NUL characters, which can cause downstream C string operations to truncate a path and bypass validation performed on a different representation. evhttp_header_is_valid_value also accepts obsolete line folding in header values containing carriage return or line feed characters, allowing a proxy and libevent to interpret headers differently and enabling header injection or access control bypass. The CRLF header acceptance is fixed in versions 2.1.13 and 2.2.2-alpha, but the reviewed patches do not clearly remediate the URI NUL-truncation condition. |
|
|
Libevent is an event notification library. Prior to 2.1.13 and 2.2.2-alpha, libevent has an incorrect integer conversion in event_tagging.c when evtag_unmarshal_header uses evtag_decode_int to decode an attacker-controlled uint32 payload length and returns it as a signed int. Values above INT_MAX become negative or truncated, and evtag_unmarshal_string can use the converted value in allocation sizing, producing a wrapped large allocation request and denial of service. This issue is fixed in versions 2.1.13 and 2.2.2-alpha. |
|
|
Libevent is an event notification library. Prior to 2.1.13 and 2.2.2-alpha, libevent can read beyond a contiguous evbuffer region in event_tagging.c when decode_tag_internal requests at most five bytes from evbuffer_pullup but iterates using the full logical buffer length. A fragmented evbuffer containing a six-byte malformed tag can therefore advance past the pullup window and trigger an out-of-bounds read, which can crash a process that decodes attacker-controlled tagged RPC data. This issue is fixed in versions 2.1.13 and 2.2.2-alpha. |
|
|
Libevent is an event notification library. Prior to 2.1.13 and
2.2.2-alpha, the libevent evhttp parser in http.c inconsistently handles
duplicate Transfer-Encoding headers, comma-separated Transfer-Encoding
values, and bare line feeds in chunked framing. evhttp_find_header can
select only the first header, |
|
ucpucp-agentucp-composeucp-corednsucp-dsinfoucp-kube-state-metrics |
compress provides various compression algorithms. Prior to version 1.18.7, a signed integer overflow vulnerability in s2.NewDict() allows an attacker to bypass repeat index validation by supplying a dictionary with a uvarint-encoded repeat value exceeding MaxInt64. When Dict.Encode() is subsequently called, the overflowed negative repeat value causes an out-of-bounds memory access via unsafe.Pointer arithmetic, crashing the process with SIGSEGV. This issue has been patched in version 1.18.7. |
|
ucp-interlockucp-multus-cni |
OpenSSL CMP password based protection verification only checks whether the protectionAlg parameter was not NULL and not its ASN.1 type, before treating it as a PBMParameter. A crafted message can contain a parameter of a different type, which is then dereferenced as an invalid pointer. |
|
ucp-interlockucp-multus-cni |
When OpenSSL processes QUIC traffic from a peer that repeatedly sends ack-eliciting packets while not acknowledging ACK-only responses, the QUIC stack can retain ACK-only packet metadata for the lifetime of the connection. |
|
ucp-interlockucp-multus-cni |
The OpenSSL Certificate Management Protocol (CMP) caches additional certificates (extraCerts) sent in a CMP message, but never expunges them (for instance if they are invalid). If a server reuses an OSSL_CMP_CTX frequently, this cache of extraCerts may grow unboundedly, and a malicious client may flood a CMP server with requests driving this growth. |
|
ucp-interlockucp-multus-cni |
OpenSSL CMP response validation passed an unexpected response sender
distinguished name directly as the format string to
|
|
ucp-interlockucp-multus-cni |
OpenSSL CMS decryption sizes the key-unwrap output buffer based on querying the unwrapped key size, but the AES-WRAP-PAD unwrap primitive can write and cleanse more bytes than that query reports, causing an 8-byte out-of-bounds heap write. |
|
|
A flaw was found in GLib. A state confusion issue exists in
g_dbus_node_info_new_for_xml() in the gio/gdbusintrospection.c file when
processing malformed D-Bus introspection XML, specifically with a
|
|
|
A flaw was found in GLib. An off-by-one error can occur in the g_key_file_get_locale_string_list function in the gkeyfile.c file when loading a key file with an empty value. This flaw can cause an out-of-bounds access of 1 byte or a denial of service when the out-of-bounds access crosses a page boundary. |
|
|
Storable versions before 3.41 for Perl have a signed integer overflow when deserializing a crafted SX_HOOK record. retrieve_hook_common reads a signed 32-bit item count from an SX_HOOK record and calls av_extend with that count plus one. A count of I32_MAX wraps the addition to a negative value. A crafted blob passed to thaw or retrieve triggers the overflow; av_extend receives the negative count and dies with a panic, terminating the deserialization. |
|
|
Perl versions before 5.40.5-RC1, from 5.41.0 before 5.42.3-RC1, from 5.43.0 before 5.43.11 have an integer overflow in S_measure_struct leading to an out-of-bounds heap read in pack and unpack. S_measure_struct adds each item’s size times its repeat count to a running total with no overflow check, so a large repeat count in a pack or unpack template wraps the signed SSize_t total negative. The @, X, and x position codes then guard their moves with a signed length comparison that passes when the length is negative, advancing the buffer pointer out of bounds. A template derived from untrusted input can read heap memory past the buffer and return it to the caller. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
When http.Transport sends an HTTP/1 CONNECT request with a non-empty Request.Body, it writes the body directly to the connection without framing after the request headers. If the server rejects the CONNECT request with a non-2xx keep-alive response, Transport returns the connection to the idle pool. Because CONNECT requests do not have a request body, the server may interpret the trailing body bytes as a subsequent pipelined HTTP/1.1 request on the connection, leaving the pooled connection desynchronized and causing the next caller that reuses it to read the response to the injected request. In reverse proxies (including httputil.ReverseProxy) that forward CONNECT requests through a shared Transport, this can lead to cross-user response poisoning. |
|
ucp-corednsucp-nvidia-gpu-feature-discovery |
A malicious GOPROXY was previously capable of forging up to two sumdb
tiles that allow for a requested module to bypass the GOSUMDB check and
persist attacker-controlled module content to a local Go module cache.
This attack allows for a malicious GOPROXY to serve malicious module
content that cannot be detected by evaluating the transparency log. All
tiles are now correctly verified against their parents. In order to
determine if you have been affected:
|
|
ucp-blackbox-exporterucp-kube-ingress-controller |
Handshake messages, such as KeyUpdate, are always considered as state-advancing, regardless of whether a handshake has been completed or not. As a result, a malicious client can keep sending KeyUpdate messages to force the server to keep performing key derivation operations indefinitely. |
|
ucp-blackbox-exporterucp-kube-ingress-controller |
Previously, resolving relative paths containing parent directory (‘..’) segments performed string conversions and buffer rewrites on each step, resulting in quadratic time complexity and high memory allocation overhead. Now, path resolution operates on a byte buffer using index-based backtracking for ‘..’ segments, eliminating the quadratic time complexity and significantly reducing memory allocations. |
|
ucp-blackbox-exporterucp-kube-ingress-controller |
Previously, DecodeElement would reset the depth counter causing it to never fire; this could lead to stack exhaustion. |
|
ucpucp-agentucp-alertmanagerucp-authucp-auth-storeucp-azure-ip-allocatorucp-blackbox-exporterucp-cfsslucp-cloud-controller-managerucp-containerd-shim-processucp-controllerucp-corednsucp-etcducp-hardware-infoucp-interlockucp-interlock-extensionucp-kube-ingress-controllerucp-kube-state-metricsucp-multus-cniucp-node-exporterucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discoveryucp-rethinkdb-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
On Windows, when the target of Root.Mkdir or Root.MkdirAll is a junction pointing to an empty location, the operation can create a directory at the junction target even when that target is located outside the root. This only applies to operations where the last path component is a junction (path/to/junction, but not path/junction/target). |
|
ucp-alertmanagerucp-azure-ip-allocatorucp-blackbox-exporterucp-cloud-controller-managerucp-corednsucp-etcducp-kube-state-metricsucp-node-exporterucp-node-feature-discoveryucp-node-local-dnsucp-rethinkdb-exporter |
Previously, after a channel has been established, a malicious peer could send crafted messages that would deadlock the entire connection. Now, we handle all RFC 4254 channel messages; global requests are handled explicitly. Then, treat all other messages as a protocol error and tear the connection down instead of buffering and blocking. |
|
ucp-alertmanagerucp-azure-ip-allocatorucp-blackbox-exporterucp-cloud-controller-managerucp-corednsucp-etcducp-kube-state-metricsucp-node-exporterucp-node-feature-discoveryucp-node-local-dnsucp-rethinkdb-exporter |
The source-address critical option in the Permissions returned by an authentication callback was only enforced for the PublicKeyCallback and VerifiedPublicKeyCallback paths, extending the fix for CVE-2026-46595. Permissions returned by the PasswordCallback, KeyboardInteractiveCallback, NoClientAuthCallback, and GSSAPIWithMICConfig.AllowLogin callbacks were not validated against the client’s remote address, so a source-address restriction set by those callbacks was silently ignored. The check is now applied to the Permissions returned by any authentication callback. |
|
ucp-blackbox-exporterucp-kube-ingress-controller |
When a server is configured to support unencrypted HTTP/2, it reads a few bytes from each new connection to see if they contain the HTTP/2 client preface. ReadHeaderTimeout is unexpectedly not being applied when doing this. |
|
ucp-blackbox-exporterucp-node-local-dns |
A norm.Iter can enter an infinite loop when handling input containing invalid UTF-8 bytes. |
|
|
The Nickname profile can panic with an out-of-bounds slice error when transforming crafted input into a short destination buffer. |
|
ucp-interlockucp-multus-cni |
Receiving a DTLS record for a future epoch while a handshake is in progress causes OpenSSL to buffer far more memory than the record itself requires. |
|
|
attr before version 2.6.0 contains a symlink traversal vulnerability in the getfattr and setfattr utilities that allows local attackers to escalate privileges by replacing a pathname component with a symbolic link during directory hierarchy traversal. Attackers who control a pathname component can redirect getfattr and setfattr operations to arbitrary files by substituting a symlink, leading to local privilege escalation when getfattr or setfattr is invoked by a privileged process over an attacker-controlled path. |
|
ucp-calico-nodeucp-multus-cniucp-node-feature-discovery |
util-linux is a random collection of Linux utilities. Before util-linux
2.41.4, |
|
ucp-interlock-configucp-interlock-proxyucp-multus-cni |
util-linux is a random collection of Linux utilities. In util-linux
2.39.1 through 2.41.4 and 2.42 through 2.42.1, the SUID |
|
ucp-multus-cniucp-node-feature-discovery |
util-linux is a random collection of Linux utilities. In util-linux 2.17
through 2.41.6 and 2.42 through 2.42.3, and in 2.42.4 when the legacy
|
|
|
util-linux is a random collection of Linux utilities. In util-linux 2.39
through 2.41.4 and 2.42 through 2.42.1, the SUID |
|
ucpucp-agentucp-auth-storeucp-cfsslucp-containerd-shim-processucp-controllerucp-hardware-infoucp-interlock |
containerd is an open-source container runtime. In Versions prior to 2.3.2, 2.2.5 and 2.1.9, the CRI implementation improperly trusts Container Device Interface (CDI) annotations found within untrusted checkpoint image metadata during container restoration. When restoring a container from a checkpoint, containerd preserves CDI-related annotations from the checkpoint archive rather than relying solely on the pod’s create-time specification. This allows a user with pod creation permissions to bypass standard Kubernetes resource allocation and device plugin enforcement, injecting arbitrary CDI edits (such as device nodes and host mounts) into the restored container. Successful exploitation requires that the node has CDI enabled and contains a matching host CDI specification for the requested device; environments where CDI is disabled or lacking sensitive device specifications are not affected. This issue has been fixed in versions 2.3.2, 2.2.5 and 2.1.9. |
|
|
A NULL pointer dereference in the SQLite Session Extension in SQLite 3.53.1 and SQLite trunk builds before check-in e807d4e3798efd53 allows an attacker who can supply a malformed changeset blob to cause a denial of service. The issue occurs when sqlite3changeset_apply_v3() applies a corrupt changeset and reaches sqlite3_value_type() with a NULL sqlite3_value pointer. |
|
|
Datadog dd-trace-go is a Go client library for Datadog application performance monitoring, profiling, and security monitoring. Prior to 2.8.1, Datadog tracing libraries that implement W3C baggage propagation parse incoming baggage HTTP headers without enforcing DD_TRACE_BAGGAGE_MAX_ITEMS or DD_TRACE_BAGGAGE_MAX_BYTES limits on the extract path. A remote, unauthenticated attacker can send a request whose baggage header contains an arbitrarily large number of comma-separated key-value pairs or a single very large value, causing unbounded CPU and memory consumption and enabling a remote denial of service against HTTP services with baggage propagation enabled. This issue is fixed in version 2.8.1. |
|
ucpucp-agentucp-auth-storeucp-cfsslucp-containerd-shim-processucp-controllerucp-hardware-infoucp-interlock |
containerd is an open-source container runtime. Versions prior to 2.3.2, 2.2.5 and 2.1.9 contain a vulnerability in the CRI checkpoint import process where it fails to validate the image references specified within a checkpoint image’s configuration. An attacker with permissions to create pods can use a crafted checkpoint image to force containerd to pull a malicious image and assign it an arbitrary local tag, thereby poisoning the node’s local image cache. Subsequently, if other pods on the same node attempt to use the poisoned tag with an IfNotPresent (or Never) pull policy, they will unknowingly execute the attacker’s malicious image instead of the legitimate one. This can lead to a compromise of the affected pods, allowing the attacker to execute arbitrary code under the victim pod’s identity. This issue has been fixed in versions 2.3.2, 2.2.5 and 2.1.9. |
|
|
IO::Compress versions before 2.220 for Perl can execute arbitrary code in File::GlobMapper via an attacker-controlled output glob. _parseOutputGlob() wraps the caller-supplied output glob string in double quotes and stores it in the parser state; _getFiles() then runs the stored expression through eval STRING. A literal double quote in the output glob closes the dquote wrapper, and the characters that follow are evaluated as Perl. Arbitrary Perl in the output glob executes at the calling process’s privilege. |
|
|
IO::Compress versions from 2.207 before 2.220 for Perl ship a zipdetails CLI tool that crashes with undefined subroutine on Info-ZIP Unix Extra Field with 8-byte UID or GID. When decode_ux() in bin/zipdetails handles an Info-ZIP Unix Extra Field (tag 0x7875) with UID Size or GID Size set to 8, causing zipdetails to decode an 8-byte UID or GID value, it dispatches through decodeLitteEndian(), which calls a misnamed helper unpackValueQ. The actual function defined in the same file is unpackValue_Q (with underscore); the call raises ‘Undefined subroutine &main::unpackValueQ’ and the script exits with status 255. Library callers of IO::Compress and IO::Uncompress are not affected; the defect is in the bundled CLI tool. |
|
ucp-interlock-configucp-interlock-proxy |
A flaw was found in the libtiff library. A remote attacker could exploit a signed integer overflow vulnerability in the putcontig8bitYCbCr44tile function by providing a specially crafted TIFF file. This flaw can lead to an out-of-bounds heap write due to incorrect memory pointer calculations, potentially causing a denial of service (application crash) or arbitrary code execution. |
|
ucp-blackbox-exporterucp-kube-ingress-controllerucp-node-local-dns |
Parsing an invalid SVCB or HTTPS RR can panic when the size of a parameter value overflows the message buffer. |
|
ucp-blackbox-exporterucp-cadvisorucp-calico-cniucp-calico-kube-controllersucp-calico-nodeucp-composeucp-dsinfoucp-hyperkubeucp-metricsucp-metrics-swarm-onlyucp-node-local-dns |
For certain crafted inputs, a ‘ed25519.PrivateKey’ was created by casting malformed wire bytes, leading to a panic when used. |
|
ucp-blackbox-exporterucp-node-local-dns |
An incorrectly placed cast from bytes to int allowed for server-side panic in the AES-GCM packet decoder for well-crafted inputs. |
|
ucp-blackbox-exporterucp-cadvisorucp-calico-cniucp-calico-kube-controllersucp-calico-nodeucp-composeucp-dsinfoucp-hyperkubeucp-metricsucp-metrics-swarm-onlyucp-node-local-dns |
Previously, CVE-2024-45337 fixed an authorization bypass for misused ssh server configurations; if any other type of callback is passed other than public key, then the source-address validation would be skipped. |
|
ucp-blackbox-exporterucp-node-local-dns |
Previously, a revoked ‘SignatureKey’ belonging to a CA was not correctly checked for revocation. Now, both the ‘key’ and ‘key.SignatureKey’ are checked for @revoked. |
|
|
Decoding a maliciously-crafted MIME header containing many invalid encoded-words can consume excessive CPU. |
|
|
Archive::Tar versions before 3.08 for Perl extract hardlinks to attacker controlled paths outside the extraction directory. _make_special_file() passes the tar header’s linkname to link() without validating it against absolute paths or .. segments, creating a hardlink that shares the victim file’s inode. A subsequent write through the extracted name modifies the victim file, and the post-extraction chmod, chown, and utime block in _extract_file() (guarded only against symlinks via -l) applies the tar header’s mode, owner, and timestamps to the shared inode during extraction alone. |
|
|
Archive::Tar versions before 3.08 for Perl extract symlinks with attacker controlled targets outside the extraction directory. _make_special_file() passes the tar header’s linkname to symlink() without validating it against absolute paths or .. segments. The secure-extract mode check that guards regular file extraction does not cover the symlink target. A subsequent open through the extracted name reads or writes the attacker chosen path. |
|
ucpucp-agentucp-auth-storeucp-cadvisorucp-cfsslucp-composeucp-controllerucp-dsinfoucp-hardware-infoucp-hyperkubeucp-interlockucp-metricsucp-metrics-swarm-onlyucp-swarm |
Moby is an open source container framework. In Docker Engine prior to version 29.5.1, Docker Daemon versions 28.5.2 and prior, and Moby Daemon prior to version 2.0.0-beta.14, a race condition during docker cp mount setup allows a malicious container to redirect a bind mount target to an arbitrary host path, potentially overwriting host files or causing denial of service. This issue has been patched in Docker Engine version 29.5.1 and Moby Daemon version 2.0.0-beta.14. |
|
|
GNU gzip contains a global buffer overflow vulnerability in the LZH decompression logic caused by improper reuse of shared global state between different decompression formats within a single execution. GNU gzip maintains a global array that is shared across the LZ77, LZW, and LZH decompression routines and is not reinitialized between files processed in the same invocation. By decompressing a specially crafted LZW file followed by a specially crafted LZH file in a single gzip -d command, an attacker can poison the shared global state and subsequently trigger an out‑of‑bounds read in the LZH decoder. The LZH decompression logic follows stale values left in the shared array, causing reads past the end of the allocated global buffer. This issue has been fixed in commits 63dbf6b3b9e6e781df1a6a64e609b10e23969681 and e7378c2d421be6a286922374425680bbe9ad8b7d. |
|
ucpucp-agentucp-auth-storeucp-cadvisorucp-cfsslucp-composeucp-controllerucp-dsinfoucp-hardware-infoucp-hyperkubeucp-interlockucp-metricsucp-metrics-swarm-onlyucp-swarm |
Moby is an open source container framework. In versions prior to 29.5.1
and in moby/moby v2 prior to v2.0.0-beta.14, when a compressed archive
is uploaded to a container via |
|
|
quic-go is an implementation of the QUIC protocol in Go. Prior to
version 0.59.1, an attacker can cause excessive memory allocation in
quic-go’s HTTP/3 client and server implementations by sending a
QPACK-encoded HEADERS frame that decodes into a large trailer field
section with many unique field names and/or large values. The
implementation builds an |
|
|
OpenTelemetry-Go is the Go implementation of OpenTelemetry. From 1.15.0 to 1.42.0, the fix for CVE-2026-24051 changed the Darwin ioreg command to use an absolute path but left the BSD kenv command using a bare name, allowing the same PATH hijacking attack on BSD and Solaris platforms. This vulnerability is fixed in 1.43.0. |
|
|
The Dial and LookupPort functions panic on Windows when provided with an input containing a NUL (0). |
|
ucp-blackbox-exporterucp-cadvisorucp-calico-cniucp-calico-kube-controllersucp-calico-nodeucp-composeucp-dsinfoucp-hyperkubeucp-metricsucp-metrics-swarm-onlyucp-node-local-dns |
SSH servers which use CertChecker as a public key callback without setting IsUserAuthority or IsHostAuthority could be caused to panic by a client presenting a certificate. CertChecker now returns an error instead of panicking when these callbacks are nil. |
|
ucp-blackbox-exporterucp-cadvisorucp-calico-cniucp-calico-kube-controllersucp-calico-nodeucp-composeucp-dsinfoucp-hyperkubeucp-metricsucp-metrics-swarm-onlyucp-node-local-dns |
When writing data larger than 4GB in a single Write call on an SSH channel, an integer overflow in the internal payload size calculation caused the write loop to spin indefinitely, sending empty packets without making progress. The size comparison now uses int64 to prevent truncation. |
|
ucp-blackbox-exporterucp-node-local-dns |
The in-memory keyring returned by NewKeyring() silently accepted keys with the ConfirmBeforeUse constraint but never enforced it. The key would sign without any confirmation prompt, with no indication to the caller that the constraint was not in effect. NewKeyring() now returns an error when unsupported constraints are requested. |
|
ucp-blackbox-exporterucp-node-local-dns |
When adding a key to a remote agent constraint extensions such as restrict-destination-v00@openssh.com were not serialized in the request. Destination restrictions were silently stripped when forwarding keys, allowing unrestricted use of the key on the remote host. The client now serializes all constraint extensions. Additionally, the in-memory keyring returned by NewKeyring() now rejects keys with unsupported constraint extensions instead of silently ignoring them. |
|
ucp-blackbox-exporterucp-node-local-dns |
The Verify() method for FIDO/U2F security key types (sk-ecdsa-sha2-nistp256@openssh.com, sk-ssh-ed25519@openssh.com) did not check the User Presence flag. Signatures generated without physical touch were accepted, allowing unattended use of a hardware security key. To restore the previous behavior, return a “no-touch-required” extension in Permissions.Extensions from PublicKeyCallback. |
|
ucp-blackbox-exporterucp-cadvisorucp-calico-cniucp-calico-kube-controllersucp-calico-nodeucp-composeucp-dsinfoucp-hyperkubeucp-metricsucp-metrics-swarm-onlyucp-node-local-dns |
A malicious SSH peer could send unsolicited global request responses to fill an internal buffer, blocking the connection’s read loop. The blocked goroutine could not be released by calling Close(), resulting in a resource leak per connection. Unsolicited global responses are now discarded. |
|
ucp-blackbox-exporterucp-node-local-dns |
The RSA and DSA public key parsers did not enforce size limits on key parameters. A crafted public key with an excessively large modulus or DSA parameter could cause several minutes of CPU consumption during signature verification. This could be triggered by unauthenticated clients during public key authentication. RSA moduli are now limited to 8192 bits, and DSA parameters are validated per FIPS 186-2. |
|
ucp-blackbox-exporterucp-cadvisorucp-calico-cniucp-calico-kube-controllersucp-calico-nodeucp-composeucp-dsinfoucp-hyperkubeucp-metricsucp-metrics-swarm-onlyucp-node-local-dns |
When an SSH server authentication callback returned PartialSuccessError with non-nil Permissions, those permissions were silently discarded, potentially dropping certificate restrictions such as force-command after a second factor succeeded. Returning non-nil Permissions with PartialSuccessError now results in a connection error. |
|
|
On Unix systems, opening a file in an os.Root improperly follows symlinks to locations outside of the Root when the final path component of the a path is a symbolic link and the path ends in /. For example, ‘root.Open(“symlink/”)’ will open “symlink” even when “symlink” is a symbolic link pointing outside of the root. |
|
ucp-blackbox-exporterucp-kube-ingress-controller |
The ToASCII and ToUnicode functions incorrectly accept Punycode-encoded labels that decode to an ASCII-only label. For example, ToUnicode(“xn–example-.com”) incorrectly returns the name “example.com” rather than an error. This behavior can lead to privilege escalation in programs using the idna package. For example, a program which performs privilege checks on the ASCII hostname may reject “example.com” but permit “xn–example-.com”. If that program subsequently converts the ASCII hostname to Unicode, it will inadvertently permits access to the Unicode name “example.com”. |
|
|
Well-crafted inputs reaching ParseAddress, ParseAddressList, and ParseDate were able to trigger excessive CPU exhaustion and memory allocations. |
|
|
CoreDNS is a DNS server written in Go. In versions prior to 1.14.3, the gRPC, QUIC, DoH, and DoH3 transport implementations incorrectly handle TSIG authentication. For gRPC and QUIC, the server checks whether the TSIG key name exists in the configuration but never calls dns.TsigVerify() to validate the HMAC. If the key name matches a configured key, the tsigStatus field remains nil and the tsig plugin treats the request as successfully authenticated regardless of the MAC value. For DoH and DoH3, the issue is more severe: the DoHWriter.TsigStatus() method unconditionally returns nil, and the server never inspects the TSIG record at all. Any request containing a TSIG record is treated as authenticated over DoH and DoH3, even if the key name is invalid and the MAC is arbitrary. An unauthenticated network attacker can exploit this to bypass TSIG-protected functionality such as AXFR/IXFR zone transfers, dynamic DNS updates, or other TSIG-gated plugin behavior. The DoH and DoH3 variants have a lower exploitation bar because the attacker does not need to know a valid TSIG key name. This issue has been fixed in version 1.14.3. As a workaround, disable gRPC, QUIC, DoH, and DoH3 listeners where TSIG authentication is required, or restrict network-level access to affected transport ports to trusted sources only. |
|
|
The OpenSSL QUIC server, when configured to not preform address validation, can be forced to count incoming packets multiple times in its unvalidated credit computation, leading to a violation of the RFC 9000 unvalidated connection amplification limit of 3 times the amount of data received. |
|
ucp-multus-cniucp-node-feature-discoveryucp-node-local-dns |
A certificate with many nameRelativeToCRLIssuer CRL distribution points causes disproportionate heap growth when OpenSSL caches X.509 extensions. |
|
ucpucp-agentucp-authucp-auth-storeucp-cfsslucp-controllerucp-hardware-info |
Distribution is a toolkit to pack, ship, store, and deliver container content. Prior to 3.1.0, distribution can restore read access in repo a after an explicit delete when storage.cache.blobdescriptor: redis and storage.delete.enabled: true are both enabled. The delete path clears the shared digest descriptor but leaves stale repo-scoped membership behind, so a later Stat or Get from repo b repopulates the shared descriptor and makes the deleted blob readable from repo a again. This vulnerability is fixed in 3.1.0. |
|
ucpucp-agentucp-auth-storeucp-cadvisorucp-cfsslucp-composeucp-controllerucp-dsinfoucp-hardware-infoucp-hyperkubeucp-interlockucp-metricsucp-metrics-swarm-onlyucp-swarm |
Moby is an open source container framework. Prior to version 29.3.1, a security vulnerability has been detected that allows plugins privilege validation to be bypassed during docker plugin install. Due to an error in the daemon’s privilege comparison logic, the daemon may incorrectly accept a privilege set that differs from the one approved by the user. Plugins that request exactly one privilege are also affected, because no comparison is performed at all. This issue has been patched in version 29.3.1. |
|
ucp-blackbox-exporterucp-kube-ingress-controller |
Enforce a recursion limit in Unmarshal to prevent stack exhaustion when parsing deeply-nested, recursive structures. |
|
|
When processing HTTP/2 SETTINGS frames, transport will enter an infinite loop of writing CONTINUATION frames if it receives a SETTINGS_MAX_FRAME_SIZE with a value of 0. |
|
|
When using LookupCNAME with the cgo DNS resolver, a very long CNAME response can trigger a double-free of C memory and a crash. |
|
ucpucp-agentucp-authucp-auth-storeucp-cfsslucp-controllerucp-hardware-info |
Distribution is a toolkit to pack, ship, store, and deliver container content. Prior to 3.1.0, in pull-through cache mode, distribution discovers token auth endpoints by parsing WWW-Authenticate challenges returned by the configured upstream registry. The realm URL from a bearer challenge is used without validating that it matches the upstream registry host. As a result, an attacker-controlled upstream (or an attacker with MitM position to the upstream) can cause distribution to send the configured upstream credentials via basic auth to an attacker-controlled realm URL. This vulnerability is fixed in 3.1.0. |
|
|
CoreDNS is a DNS server that chains plugins. In versions prior to 1.14.3, the transfer plugin can select the wrong ACL stanza when both a parent zone and a more-specific subzone are configured. The longestMatch() function in plugin/transfer/transfer.go uses a lexicographic string comparison instead of an actual longest-suffix match to select the winning zone. As a result, a permissive parent-zone transfer rule can override a restrictive subzone rule depending on zone name ordering (e.g., “example.org.” > “a.example.org.” lexicographically). This allows an unauthorized remote client to perform AXFR/IXFR for the subzone and retrieve its full zone contents. This issue has been fixed in version 1.14.3. |
|
|
CoreDNS is a DNS server that chains plugins. In versions prior to 1.14.3, the tsig plugin can be bypassed on non-plain-DNS transports (DoT, DoH, DoH3, DoQ, and gRPC) because it trusts the transport writer’s TsigStatus() instead of performing verification itself. The DoH and DoH3 writer’s TsigStatus() always returns nil, the DoT server does not set TsigSecret on the dns.Server, and the DoQ and gRPC writers also unconditionally return nil. This allows an unauthenticated remote client to bypass TSIG-based authentication and access resources intended to be restricted behind a tsig require all policy. Plain DNS over TCP and UDP are not affected. This issue has been fixed in version 1.14.3. |
|
ucp-blackbox-exporterucp-node-local-dns |
gRPC-Go is the Go language implementation of gRPC. Versions prior to
1.79.3 have an authorization bypass resulting from improper input
validation of the HTTP/2 |
|
|
CoreDNS is a DNS server that chains plugins. In versions prior to 1.14.3, the DNS-over-HTTPS (DoH) GET path accepts oversized dns= query parameter values and performs URL query parsing, base64 decoding, and DNS message unpacking before rejecting the request. Unlike the POST path, which applies a bounded read via http.MaxBytesReader limited to 65536 bytes, the GET path has no equivalent size validation before expensive processing. A remote, unauthenticated attacker can repeatedly send oversized DoH GET requests to force high CPU usage, large transient memory allocations, and elevated garbage-collection pressure, leading to denial of service. This issue has been fixed in version 1.14.3. |
|
|
CoreDNS is a DNS server that chains plugins. In versions prior to 1.14.3, the DNS-over-QUIC (DoQ) server can be driven into unbounded goroutine and memory growth by a remote client that opens many QUIC streams and sends only 1 byte per stream. When the worker pool is full, CoreDNS still spawns a goroutine per accepted stream to wait for a worker token. Additionally, active workers block indefinitely in io.ReadFull() with no per-stream read deadline, allowing an attacker to pin all workers by sending a single byte so the read blocks waiting for the second byte of the DoQ length prefix. This enables an unauthenticated remote attacker to cause memory exhaustion and OOM-kill. This issue has been fixed in version 1.14.3. No known workarounds exist. |
|
ucp-blackbox-exporterucp-metallb-controllerucp-metallb-speaker |
If one side of the TLS connection sends multiple key update messages post-handshake in a single record, the connection can deadlock, causing uncontrolled consumption of resources. This can lead to a denial of service. This only affects TLS 1.3. |
|
ucp-blackbox-exporterucp-metallb-controllerucp-metallb-speaker |
Validating certificate chains which use policies is unexpectedly inefficient when certificates in the chain contain a very large number of policy mappings, possibly causing denial of service. This only affects validation of otherwise trusted certificate chains, issued by a root CA in the VerifyOptions.Roots CertPool, or in the system certificate pool. |
|
ucp-blackbox-exporterucp-metallb-controllerucp-metallb-speaker |
During chain building, the amount of work that is done is not correctly limited when a large number of intermediate certificates are passed in VerifyOptions.Intermediates, which can lead to a denial of service. This affects both direct users of crypto/x509 and users of crypto/tls. |
|
|
OpenTelemetry-Go is the Go implementation of OpenTelemetry. From 1.36.0 to 1.40.0, multi-value baggage: header extraction parses each header field-value independently and aggregates members across values. This allows an attacker to amplify cpu and allocations by sending many baggage: header lines, even when each individual value is within the 8192-byte per-value parse limit. This vulnerability is fixed in 1.41.0. |
|
|
|
|
|
CoreDNS is a DNS server that chains plugins. Prior to version 1.14.2, a denial of service vulnerability exists in CoreDNS’s loop detection plugin that allows an attacker to crash the DNS server by sending specially crafted DNS queries. The vulnerability stems from the use of a predictable pseudo-random number generator (PRNG) for generating a secret query name, combined with a fatal error handler that terminates the entire process. This issue has been patched in version 1.14.2. |
|
|
CoreDNS is a DNS server that chains plugins. Prior to version 1.14.2, a logical vulnerability in CoreDNS allows DNS access controls to be bypassed due to the default execution order of plugins. Security plugins such as acl are evaluated before the rewrite plugin, resulting in a Time-of-Check Time-of-Use (TOCTOU) flaw. This issue has been patched in version 1.14.2. |
|
|
OpenTelemetry-Go is the Go implementation of OpenTelemetry. The OpenTelemetry Go SDK in version v1.20.0-1.39.0 is vulnerable to Path Hijacking (Untrusted Search Paths) on macOS/Darwin systems. The resource detection code in sdk/resource/host_id.go executes the ioreg system command using a search path. An attacker with the ability to locally modify the PATH environment variable can achieve Arbitrary Code Execution (ACE) within the context of the application. A fix was released with v1.40.0. |
|
ucpucp-agentucp-calico-cni-firewalld-chrootucp-cfsslucp-cloud-controller-managerucp-controllerucp-etcducp-hardware-infoucp-interlock-configucp-interlock-proxyucp-node-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
A flaw in libcurl makes it wrongly reuse an HTTP connection setup for a given hostname using Negotiate authentication, when the initial request is done using empty credentials. This can make user B’s request get sent over user A’s previously authenticated connection. |
|
ucp-composeucp-dsinfoucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discovery |
If an attacker-controlled authoritative server can produce a negative
answer that is exactly 65536 bytes, then a flaw in |
|
ucp-composeucp-dsinfoucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discovery |
On a resolver configured to use |
|
|
In a BIND resolver, inbound DNS protocol messages with a particular structure will result in additional processing, with no limit imposed by BIND. A DNS message with a maliciously large number of such structures will cause BIND to consume disproportionate amounts of CPU time and memory during processing. This issue affects BIND 9 versions 9.11.0 through 9.18.50, 9.20.0 through 9.20.29, 9.21.0 through 9.21.26, 9.11.3-S1 through 9.18.50-S1, and 9.20.9-S1 through 9.20.29-S1. |
|
|
Perl versions from 5.9.4 before 5.41.9 produce incorrect regular
expression match results when a stale failure flag ends the Aho-Corasick
prescan early in S_find_byclass. The prescan walks the subject for
positions where the full pattern could match, and the engine tries it
from the leftmost one recorded. A failing transition sets the failed
flag, and a later successful transition does not clear it, so the
prescan reads the stale flag as a failure and stops before it can record
a candidate that starts earlier. It takes a subject where one candidate
is recorded and a later character then forces a fallback through a fail
link that succeeds. Example: |
|
|
A remote, unauthenticated TLS client can make a server crash or call through a freed pointer if its sni_callback assigns a different context to SSLSocket.context (the documented way to select a certificate per server name) and nothing else keeps the original ssl.SSLContext alive. Typical cases are servers that create an SSLContext per connection or replace it while connections are open; servers that wrap their listening socket with it are not affected. Mitigation: keep a reference to every SSLContext that sets sni_callback for the lifetime of the server. TLS clients are not affected. |
|
ucpucp-agentucp-calico-cni-firewalld-chrootucp-cfsslucp-cloud-controller-managerucp-controllerucp-etcducp-hardware-infoucp-interlock-configucp-interlock-proxyucp-node-exporterucp-node-feature-discoveryucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
A flaw in libcurl’s handling of HTTP/2 Server Push streams, when the parent handle is set to share connections with other handles, can lead to use-after-free in the cleanup process. |
|
ucp-interlockucp-multus-cni |
QUIC server may double free QRX (QUIC record layer RX) object when channel creation fails for initial packet. |
|
|
Perl versions through 5.45.1 have out-of-bounds heap reads and writes during regular expression matching via an undersized superlinear cache in S_regmatch. The regex engine’s superlinear cache holds one bit per subject position for each participating WHILEM node, so the bit count is the subject length plus one times the number of nodes. Nothing checks that product for positive overflow of the signed 32-bit count: a 286331153 byte subject matched against a pattern with 15 participating nodes stores the count as 14, leaving a two byte cache. The cache is then indexed from the real match position and node number, so reads go past the end of the allocation, and on failure CACHEsayNO sets a bit past it. A caller that matches an attacker controlled subject of this size against a pattern of this shape can crash the process or corrupt heap memory. |
|
ucp-interlock-configucp-interlock-proxy |
A vulnerability exists in NGINX Plus and NGINX Open Source when a location is configured that uses the alias directive together with rewrite and a set or return directive referencing the $request_filename variable. Alternatively, the same result could be achieved when the $request_filename variable is used in an access log format directive. An unauthenticated attacker along with conditions beyond their control can exploit this vulnerability by sending crafted HTTP requests. This may cause a heap buffer overflow in the NGINX worker process leading to a restart. Additionally, attackers can execute code on systems with Address Space Layout Randomization (ASLR) disabled or when the attacker can bypass ASLR. Impact: This vulnerability may allow remote attackers to cause a denial-of-service (DoS) on the NGINX system or to possibly trigger a code execution. There is no control plane exposure; this is a data plane issue only. Note: Software versions which have reached End of Technical Support (EoTS) are not evaluated. |
|
ucp-interlockucp-multus-cni |
In a server or client configuration with RFC7250 Raw Public Keys (RPKs) enabled, and only the private key (with no associated certificate) configured locally, a NULL pointer dereference may occur when the remote peer solicits raw public keys and also sends the typically omitted “signature_algorithms_cert” TLS extension. |
|
ucp-interlockucp-multus-cni |
When an OpenSSL QUIC server (Listener SSL object) processes valid QUIC Initial packets for unknown destination connection IDs, it can allocate and queue new incoming channels without enforcing any limit. |
|
|
Perl versions before 5.40.5-RC1, from 5.41.0 before 5.42.3-RC1, from 5.43.0 before 5.43.10 produce silently incorrect regular expression matches when an alternation of more than 65535 fixed string branches is compiled into a trie in Perl_study_chunk. When such branches are combined into a trie, the delta between the first branch and the shared tail is stored in a 16-bit field. A branch count above 65535 overflows the field, and the trie’s match decision table is truncated with no warning or error. A pattern of this shape produces false positive matches (matching strings it should not) and false negative matches (failing to match strings it should). When such a pattern gates an access or filtering decision, the result is wrong. |
|
|
If a provably insecure domain is covered by both an NSEC and NSEC3 record at the parent, and there exist an RRSIG for only one of these types, then BIND may exit unexpectedly with an assertion while validating this proof. This issue affects BIND 9 versions 9.11.0 through 9.18.50, 9.20.0 through 9.20.24, 9.21.0 through 9.21.23, 9.11.3-S1 through 9.18.50-S1, and 9.20.9-S1 through 9.20.24-S1. |
|
|
Socket versions before 2.041 for Perl have an out-of-bounds heap read. In Socket.xs, pack_ip_mreq_source() checks the length of its source argument before the argument is read, so the check tests the byte length carried over from the preceding multiaddr argument instead. Both addresses occupy a 4-byte field, so a valid multiaddr lets a source of any length pass the check, and the source is then copied into the 4-byte imr_sourceaddr field with a fixed-size copy. A source shorter than 4 bytes is not rejected, and the copy reads up to 3 bytes past the end of its buffer. Calling pack_ip_mreq_source() with a source value shorter than 4 bytes copies adjacent heap memory into the returned packed structure. |
|
|
SQLite before 3.53.2 contains a heap-based buffer overflow vulnerability in the FTS5 full-text search extension that allows attackers to cause a crash or execute arbitrary code by supplying a crafted database with malicious continuation page metadata specifying a szLeaf value smaller than 4. Attackers can trigger an integer underflow in fts5ChunkIterate() causing an inflated remaining byte count during FTS5 MATCH query processing, leading to a heap buffer overflow of attacker-controlled data in applications compiled with SQLITE_ENABLE_FTS5. |
|
|
SQLite before 3.53.2 contains an out-of-bounds read vulnerability in the FTS5 full-text search extension that allows attackers to crash the process by supplying a crafted database with a malformed FTS5 leaf page. Attackers can set an oversized term length in the leaf page so that fts5LeafSeek() reads past the end of the page buffer while comparing terms during an FTS5 MATCH query, in applications compiled with SQLITE_ENABLE_FTS5. |
|
|
Authlib is a Python library which builds OAuth and OpenID Connect servers. From 0.15 until 1.9.1, the documented ClientConfigurationEndpoint.authenticate_client and ClientConfigurationEndpoint.check_permission reference implementations look up a target client from request-controlled client_id data and check only whether that target is editable, without verifying that request.credential belongs to the target client. Deployments following both examples can allow a client holding any valid registration access token to read, modify, or delete another client’s registration. Changing redirect_uris can enable authorization code or token interception, while deleting registrations can deny service to affected clients. This issue is fixed in version 1.9.1. |
|
|
Authlib is a Python library which builds OAuth and OpenID Connect servers. Prior to 1.9.1, Authlib’s OctKey.import_key() and HMAC signing and verification path accept zero-length key material. If an application’s secret lookup can return an empty string or empty bytes, a remote attacker can compute the deterministic HS256, HS384, or HS512 signature for arbitrary token claims and have Authlib treat the token as authentic. This issue is fixed in version 1.9.1. |
|
ucpucp-agentucp-authucp-calico-cni-firewalld-chrootucp-cfsslucp-cloud-controller-managerucp-controllerucp-etcducp-hardware-infoucp-interlock-configucp-interlock-proxyucp-node-exporterucp-secureoverlay-agentucp-secureoverlay-mgrucp-swarm |
A buffer overflow vulnerability in the Brotli decoder (c/dec/decode.c) in Google Brotli versions 1.0.3 through 1.2.0 on all platforms allows a remote unauthenticated attacker to corrupt adjacent decoder state memory, disclose sensitive memory contents, cause a denial of service, or potentially execute arbitrary code using a crafted Brotli-compressed stream. Users need to update any Brotli libraries or binaries between 1.0.3 through 1.2.0 to the latest available version: 1.0.10 or 1.1.1 or 1.2.1. |
|
ucp-composeucp-dsinfoucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discovery |
On Debian, Ubuntu, and derivative Linux distributions, an on-path attacker who can manipulate the HTTP traffic (including a malicious mirror or proxy) between an APT client and an archive server triggered by a package install can trick the client into installing an attacker-controlled unverified package and achieve remote code execution with root privileges. The vulnerability is caused by the reuse of hard links and requires the client to follow redirects and retry the download of package files. It requires the client to have a non-zero Acquire::Retries configuration setting; the value 3 is the default starting with Debian 12 (bookworm) and Ubuntu 22.04 LTS (Jammy Jellyfish), so older releases are unaffected in a default configuration |
|
ucp-composeucp-dsinfoucp-interlock-configucp-interlock-proxyucp-multus-cniucp-node-feature-discoveryucp-nvidia-device-pluginucp-nvidia-gpu-feature-discovery |
PCRE2 before 10.49, when there is an attacker-controlled regular expression and certain JIT API usage, allows an out-of-bounds write with arbitrary data. |
|
ucp-interlock-configucp-interlock-proxy |
libexpat versions 2.7.2 through 2.8.5 contain an integer overflow vulnerability in expat_realloc() function on 32-bit platforms when computing allocation sizes. Attackers supplying malicious XML to applications parsing with vulnerable libexpat can cause heap buffer overflow, memory corruption, or denial of service. |
|
|
CoreDNS is a DNS server that chains plugins. Prior to version 1.14.0, multiple CoreDNS server implementations (gRPC, HTTPS, and HTTP/3) lack critical resource-limiting controls. An unauthenticated remote attacker can exhaust memory and degrade or crash the server by opening many concurrent connections, streams, or sending oversized request bodies. The issue is similar in nature to CVE-2025-47950 (QUIC DoS) but affects additional server types that do not enforce connection limits, stream limits, or message size constraints. Version 1.14.0 contains a patch. |
|
ucp-blackbox-exporterucp-metallb-controllerucp-metallb-speaker |
During session resumption in crypto/tls, if the underlying Config has its ClientCAs or RootCAs fields mutated between the initial handshake and the resumed handshake, the resumed handshake may succeed when it should have failed. This may happen when a user calls Config.Clone and mutates the returned Config, or uses Config.GetConfigForClient. This can cause a client to resume a session with a server that it would not have resumed with during the initial handshake, or cause a server to resume a session with a client that it would not have resumed with during the initial handshake. |
|
ucp-blackbox-exporterucp-metallb-controllerucp-metallb-speakerucp-node-local-dns |
Within HostnameError.Error(), when constructing an error string, there is no limit to the number of hosts that will be printed out. Furthermore, the error string is constructed by repeated string concatenation, leading to quadratic runtime. Therefore, a certificate provided by a malicious actor can result in excessive resource consumption. |
|
ucp-blackbox-exporterucp-metallb-controllerucp-metallb-speakerucp-node-local-dns |
An excluded subdomain constraint in a certificate chain does not
restrict the usage of wildcard SANs in the leaf certificate. For example
a constraint that excludes the subdomain test.example.com does not
prevent a leaf certificate from claiming the SAN |
|
ucp-blackbox-exporterucp-metallb-controllerucp-metallb-speaker |
The net/url package does not set a limit on the number of query parameters in a query. While the maximum size of query parameters in URLs is generally limited by the maximum request header size, the net/http.Request.ParseForm method can parse large URL-encoded forms. Parsing a large form containing many unique query parameters can cause excessive memory consumption. |
|
|
The ParseAddress function constructs domain-literal address components through repeated string concatenation. When parsing large domain-literal components, this can cause excessive CPU consumption. |
|
|
The Reader.ReadResponse function constructs a response string through repeated string concatenation of lines. When the number of lines in a response is large, this can cause excessive CPU consumption. |
|
|
The processing time for parsing some invalid inputs scales non-linearly with respect to the size of the input. This affects programs which parse untrusted PEM inputs. |
|
|
Validating certificate chains which contain DSA public keys can cause programs to panic, due to a interface cast that assumes they implement the Equal method. This affects programs which validate arbitrary certificate chains. |
|
ucp-blackbox-exporterucp-node-local-dns |
Due to the design of the name constraint checking algorithm, the processing time of some inputs scale non-linearly with respect to the size of the certificate. This affects programs which validate arbitrary certificate chains. |
|
|
Despite HTTP headers having a default limit of 1MB, the number of cookies that can be parsed does not have a limit. By sending a lot of very small cookies such as “a=;”, an attacker can make an HTTP server allocate a large amount of structs, causing large memory consumption. |
|
|
Parsing a maliciously crafted DER payload could allocate large amounts of memory, causing memory exhaustion. |
|
|
tar.Reader does not set a maximum size on the number of sparse region data blocks in GNU tar pax 1.0 sparse files. A maliciously-crafted archive containing a large number of sparse regions can cause a Reader to read an unbounded amount of data from the archive into memory. When reading from a compressed source, a small compressed input can result in large allocations. |
|
ucp-blackbox-exporterucp-calico-cniucp-calico-kube-controllersucp-calico-nodeucp-composeucp-dsinfoucp-metricsucp-metrics-swarm-onlyucp-node-local-dns |
SSH servers parsing GSSAPI authentication requests do not validate the number of mechanisms specified in the request, allowing an attacker to cause unbounded memory consumption. |
|
ucp-composeucp-dsinfo |
runc is a CLI tool for spawning and running containers according to the OCI specification. In versions 1.2.7, 1.3.2 and 1.4.0-rc.2, an attacker can trick runc into misdirecting writes to /proc to other procfs files through the use of a racing container with shared mounts (we have also verified this attack is possible to exploit using a standard Dockerfile with docker buildx build as that also permits triggering parallel execution of containers with custom shared mounts configured). This redirect could be through symbolic links in a tmpfs or theoretically other methods such as regular bind-mounts. While similar, the mitigation applied for the related CVE, CVE-2019-19921, was fairly limited and effectively only caused runc to verify that when LSM labels are written they are actually procfs files. This issue is fixed in versions 1.2.8, 1.3.3, and 1.4.0-rc.3. |
|
ucp-composeucp-dsinfo |
runc is a CLI tool for spawning and running containers according to the
OCI specification. Versions 1.0.0-rc3 through 1.2.7, 1.3.0-rc.1 through
1.3.2, and 1.4.0-rc.1 through 1.4.0-rc.2, due to insufficient checks
when bind-mounting |
|
ucp-blackbox-exporterucp-calico-cniucp-calico-kube-controllersucp-calico-nodeucp-composeucp-dsinfoucp-metricsucp-metrics-swarm-onlyucp-node-local-dns |
SSH Agent servers do not validate the size of messages when processing new identity requests, which may cause the program to panic if the message is malformed due to an out of bounds read. |
|
|
SSH clients receiving SSH_AGENT_SUCCESS when expecting a typed response will panic and cause early termination of the client process. |
|
|
If the PATH environment variable contains paths which are executables (rather than just directories), passing certain strings to LookPath (“”, “.”, and “..”), can result in the binaries listed in the PATH being unexpectedly returned. |
|
ucp-composeucp-dsinfo |
runc is a CLI tool for spawning and running containers according to the OCI specification. In versions 1.2.7 and below, 1.3.0-rc.1 through 1.3.1, 1.4.0-rc.1 and 1.4.0-rc.2 files, runc would not perform sufficient verification that the source of the bind-mount (i.e., the container’s /dev/null) was actually a real /dev/null inode when using the container’s /dev/null to mask. This exposes two methods of attack: an arbitrary mount gadget, leading to host information disclosure, host denial of service, container escape, or a bypassing of maskedPaths. This issue is fixed in versions 1.2.8, 1.3.3 and 1.4.0-rc.3. |
|
|
IO::Uncompress::Unzip versions before 2.215 for Perl propagate uncaught exception when parsing zip header with malformed DOS date. _dosToUnixTime() decodes the local-file-header last-modification date field and calls Time::Local::timelocal() without an eval guard. A header whose date field decodes to an out-of-range month, day, or hour causes timelocal() to die. The exception propagates out of IO::Uncompress::Unzip->new($file) where callers expect undef plus $UnzipError. |
|
ucp-composeucp-dsinfo |
Docker CLI for Windows searches for plugin binaries in
|
|
ucp-composeucp-dsinfo |
Moby is an open-source project created by Docker to enable software containerization. The classic builder cache system is prone to cache poisoning if the image is built FROM scratch. Also, changes to some instructions (most important being HEALTHCHECK and ONBUILD) would not cause a cache miss. An attacker with the knowledge of the Dockerfile someone is using could poison their cache by making them pull a specially crafted image that would be considered as a valid cache candidate for some build steps. 23.0+ users are only affected if they explicitly opted out of Buildkit (DOCKER_BUILDKIT=0 environment variable) or are using the /build API endpoint. All users on versions older than 23.0 could be impacted. Image build API endpoint (/build) and ImageBuild function from github.com/docker/docker/client is also affected as it the uses classic builder by default. Patches are included in 24.0.9 and 25.0.2 releases. |