| CVE |
Vendors |
Products |
Updated |
CVSS v3.1 |
| Out-of-bounds read in Windows WinHTTP allows an authorized attacker to disclose information locally. |
| Out-of-bounds read in Windows GDI allows an unauthorized attacker to disclose information over a network. |
| Flagr before 1.2.5 contains an authentication bypass vulnerability that allows unauthenticated remote attackers to access the flag management write API through an insecure default FLAGR_BASIC_AUTH_WHITELIST_PATHS including /api/v1/flags. Because basicAuth.whitelist() in pkg/config/middleware.go matches only path prefixes regardless of HTTP method, attackers can create, modify, enable, disable, and delete flags, variants, segments, constraints, and distributions. |
| Nexterm through 1.2.2-BETA contains a privilege escalation vulnerability that allows users with permissions.manage to gain unauthorized permissions because addGroupMember and setUserGroups lack the grantsBeyondCaller check. Attackers can add their own account to custom groups via the group membership endpoints to inherit permissions like users.impersonate and settings.backup. |
| Dolibarr ERP CRM through 24.0.3 contains a code injection vulnerability in Website::importWebSite() that allows website editors without PHP permission to execute code by importing templates. Attackers can import a template zip whose javascript.js.php contains PHP code, which the public javascript.js.php endpoint includes, executing code as the web server user. |
| Out-of-bounds read in Windows DNS allows an unauthorized attacker to disclose information over a network. |
| Release of invalid pointer or reference in Windows DHCP Server allows an authorized attacker to execute code over a network. |
| Heap-based buffer overflow in Windows Partition Management Driver allows an authorized attacker to elevate privileges with a physical attack. |
| NVIDIA OpenShell for Linux contains a vulnerability in its inference-interception request parser where a sandboxed actor could exhaust processing resources by sending a chunked request that lacks body-size and chunk-count limits, causing excessive parsing work. A successful exploit of this vulnerability might lead to denial of service. |
| NVIDIA OpenShell for Linux contains a vulnerability in its gateway connection-proxy component where an attacker who can manipulate a sandbox's status metadata could cause the control-plane server to initiate connections to arbitrary internal hosts because the connection target is derived from that metadata and used without validation against the expected address range. A successful exploit of this vulnerability might lead to information disclosure and data tampering. |
| GitLab has remediated an issue in GitLab EE affecting all versions from 19.5 before 19.5.6 that under certain conditions could have allowed an authenticated user to start a Duo Workflow session with elevated privileges beyond those declared by the foundational flow due to improper enforcement of privilege boundaries in certain client environments. |
| GitLab has remediated an issue in GitLab CE/EE affecting all versions from 8.0 before 19.3.9, 19.4 before 19.4.8, and 19.5 before 19.5.6 that under certain conditions could have allowed an authenticated user to import Git repositories into projects despite administrator restrictions on import sources due to missing authorization checks. |
| Issue summary: A QUIC server that rejects a stream opened by the peer may
retain that stream's state for the lifetime of the connection if the peer
resets the stream before the rejection is signalled, even though the peer's
stream credit is returned.
Impact summary: A remote client that completes a QUIC handshake can repeatedly
open and reset streams, causing server memory to grow without bound until the
process runs out of memory and every connection on it is lost. This is a
Denial of Service.
CWE: CWE-401: Missing Release of Memory after Effective Lifetime
Description: QUIC servers track each stream the peer opens. When the incoming
stream policy rejects a stream, OpenSSL schedules a STOP_SENDING frame, marks
the stream deleted and returns the peer's stream credit. A deleted stream is
collected only once its receive part is fully drained, which for a rejected
stream means the STOP_SENDING has been acknowledged. If the peer sends
RESET_STREAM first, the reset cancels the pending STOP_SENDING, so it is never
sent or acknowledged and the stream is never collected.
The default configuration reaches this path. Once a connection has a default
stream, meaning the application has read from or written to the connection as
the tutorial server does, the effective incoming stream policy rejects streams
the application does not accept. Applications that set the REJECT policy
explicitly are affected too.
Each retained stream costs about 300 bytes, and the peer's stream credit
window paces how quickly they accumulate. A client that keeps the connection
open and keeps opening and resetting streams grows server memory without
bound. The severity is Low because growth is slow, needs a long-lived
connection, and causes no memory corruption or disclosure.
FIPS impact: no
The affected code is outside the FIPS module boundary. |
| GitLab has remediated an issue in GitLab EE affecting all versions from 19.2 before 19.3.9, 19.4 before 19.4.8, and 19.5 before 19.5.6 that under certain conditions could have allowed an authenticated user to change the GitLab Duo Code Review consent setting of a parent group due to incorrect authorization checks. |
| GitLab has remediated an issue in GitLab EE affecting all versions from 17.7 before 19.3.9, 19.4 before 19.4.8, and 19.5 before 19.5.6 that under certain conditions could have allowed an authenticated user to read GitLab Duo seat assignments and usage data from other groups due to improper authorization checks. |
| GitLab has remediated an issue in GitLab CE/EE affecting all versions before 19.3.9, 19.4 before 19.4.8, and 19.5 before 19.5.6 that under certain conditions could have allowed an authenticated user with an unconfirmed email address to be automatically granted Group Owner-level membership during a group import operation, due to insufficient email verification enforcement in the member identity mapping process. |
| GitLab has remediated an issue in GitLab CE/EE affecting all versions from 18.4 before 19.3.9, 19.4 before 19.4.8, and 19.5 before 19.5.6 that under certain conditions could have allowed an authenticated user holding an MCP-scoped OAuth token to perform unauthorized issuable state changes on issues and merge requests, including approving and merging, due to incorrect authorization checks. |
| GitLab has remediated an issue in GitLab CE/EE affecting all versions from 12.4 before 19.3.9, 19.4 before 19.4.8, and 19.5 before 19.5.6 that under certain conditions could have allowed an authenticated user to read private CI/CD job artifacts belonging to other projects through GitLab Pages due to improper validation of file paths. |
| GitLab has remediated an issue in GitLab CE/EE affecting all versions from 14.0 before 19.3.9, 19.4 before 19.4.8, and 19.5 before 19.5.6 that under certain conditions could have allowed an authenticated user to create issues with locked discussions despite lacking the required permissions due to improper authorization checks. |
| Issue summary: A server configured with the Suite B certificate flag through
SSL_CTX_set_cert_flags() and with TLS 1.3 enabled may read past the end of a
fixed group list when it processes a ClientHello whose supported_groups and
key_share contain no Suite B group.
Impact summary: A remote client can send a ClientHello that makes the server
read past the end of a static array. The values read are never returned to the
client, so no memory is disclosed; on builds with sanitizers or hardened
allocators the read may crash the process, causing Denial of Service.
CWE: CWE-125: Out-of-bounds Read
Description: When the Suite B certificate flag is set, OpenSSL restricts the
accepted groups to P-256 and P-384 by substituting a fixed two-element list
for the configured group list. The tuple machinery used for key-share
selection was not updated for this substitution: tls1_get_group_tuples() still
returns the configured tuples, which by default describe eight groups. The
server-side walk in tls_parse_ctos_key_share() then advances through the
two-element list using those tuple counts without checking the cumulative
offset against the number of groups present.
Only applications that call SSL_CTX_set_cert_flags() with
SSL_CERT_FLAG_SUITEB_128_LOS and leave TLS 1.3 enabled are affected. The
openssl s_server -suiteB_128 option sets an X.509 verification parameter
instead, so the stock command line server is not vulnerable. Default
configurations do not reach this code.
A client that offers only groups outside the Suite B set, such as X25519,
forces every tuple to be walked and the read to run past the array. The bytes
read are compared against client group IDs and never sent back, so no memory
is disclosed. On builds with address sanitizers or hardened allocators the
read can abort the process; in ordinary release builds it reads a few bytes of
adjacent constant data.
FIPS impact: no
The affected code is outside the FIPS module boundary. |