    github.com/minio/minio 0.0.0-20251015172955-9e49d5e7a648 (golang)
pkg:golang/github.com/minio/minio@0.0.0-20251015172955-9e49d5e7a648
# minio-release.dockerfile (80:80)
COPY --from=build /build/minio/minio /opt/bitnami/common/bin/minio
 Improper Authentication
| Affected range | <=0.0.0-20260212201848-7aac2a2c5b7c | | Fixed version | Not Fixed | | CVSS Score | 9.2 | | CVSS Vector | CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N | | EPSS Score | 0.019% | | EPSS Percentile | 5th percentile |
Description
Impact
What kind of vulnerability is it? Who is impacted?
A JWT algorithm confusion vulnerability in MinIO's OpenID Connect authentication allows an attacker who knows the OIDC ClientSecret to forge arbitrary identity tokens and obtain S3 credentials with any policy, including consoleAdmin.
An attacker with knowledge of the OIDC ClientSecret can:
- Impersonate any user identity
- Obtain S3 credentials with any IAM policy, including
consoleAdmin
- Access, modify, or delete any data in the MinIO deployment
The attack is deterministic (100% success rate, no race conditions).
Attack Prerequisites
The attacker must know the OIDC ClientSecret. While this is a shared credential (not a private key), it is more accessible than commonly assumed:
- CVE-2023-28432 previously leaked environment variables including
MINIO_IDENTITY_OPENID_CLIENT_SECRET
- Client secrets are often present in frontend OAuth configurations, mobile app bundles, CI/CD pipelines, and shared configuration files
- In many organizations, the client secret is accessible to operators and engineers who should not be able to forge arbitrary identities
Affected Versions
All MinIO releases from RELEASE.2022-11-08T05-27-07Z through the final release of the minio/minio open-source project.
Patches
Fixed in: MinIO AIStor RELEASE.2026-03-17T21-25-16Z
Downloads
Binary Downloads
FIPS Binaries
Package Downloads
Container Images
# Standard
docker pull quay.io/minio/aistor/minio:RELEASE.2026-03-17T21-25-16Z
podman pull quay.io/minio/aistor/minio:RELEASE.2026-03-17T21-25-16Z
# FIPS
docker pull quay.io/minio/aistor/minio:RELEASE.2026-03-17T21-25-16Z.fips
podman pull quay.io/minio/aistor/minio:RELEASE.2026-03-17T21-25-16Z.fips
Homebrew (macOS)
brew install minio/aistor/minio
Workarounds
 Observable Response Discrepancy
| Affected range | <=0.0.0-20260212201848-7aac2a2c5b7c | | Fixed version | Not Fixed | | CVSS Score | 9.1 | | CVSS Vector | CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N | | EPSS Score | 0.059% | | EPSS Percentile | 19th percentile |
Description
Impact
What kind of vulnerability is it? Who is impacted?
MinIO AIStor's STS (Security Token Service) AssumeRoleWithLDAPIdentity endpoint is vulnerable to LDAP credential brute-forcing due to two combined weaknesses: (1) distinguishable error responses that enable username enumeration, and (2) absence of rate limiting on authentication attempts. An unauthenticated network attacker can enumerate valid LDAP usernames and then perform unlimited password guessing to obtain temporary AWS-style STS credentials, gaining access to the victim's S3 buckets and objects.
All deployments with LDAP configured running an affected version are impacted.
There are two vulnerabilities:
- User Enumeration via Distinguishable Error Messages (CWE-204)
- Missing Rate Limiting on STS Authentication Endpoints (CWE-307)
When exploited together, an attacker can:
- Enumerate valid LDAP usernames by observing error message differences.
- Perform high-speed password brute-force attacks against confirmed valid users.
- Upon finding valid credentials, obtain temporary AWS-style STS credentials (
AccessKeyId, SecretAccessKey, SessionToken) with full access to the victim user's S3 resources.
Affected Versions
All MinIO releases through the final release of the minio/minio open-source project.
Patches
Fixed in: MinIO AIStor RELEASE.2026-03-17T21-25-16Z
Binary Downloads
FIPS Binaries
Package Downloads
Container Images
# Standard
docker pull quay.io/minio/aistor/minio:RELEASE.2026-03-17T21-25-16Z
podman pull quay.io/minio/aistor/minio:RELEASE.2026-03-17T21-25-16Z
# FIPS
docker pull quay.io/minio/aistor/minio:RELEASE.2026-03-17T21-25-16Z.fips
podman pull quay.io/minio/aistor/minio:RELEASE.2026-03-17T21-25-16Z.fips
Homebrew (macOS)
brew install minio/aistor/minio
Workarounds
If upgrading is not immediately possible:
- Network-level rate limiting: Use a reverse proxy (e.g., nginx, HAProxy) or WAF to rate-limit requests to the
/?Action=AssumeRoleWithLDAPIdentity endpoint.
- Firewall restrictions: Restrict access to the STS endpoint to trusted networks/IP ranges only.
- LDAP account lockout: Configure account lockout policies on the LDAP server itself (e.g., Active Directory lockout threshold). Note: this protects against brute-force but not enumeration, and may cause denial-of-service for legitimate users.
 OWASP Top Ten 2017 Category A9 - Using Components with Known Vulnerabilities
| Affected range | <v2023-03-20t20-16-18z | | Fixed version | v2023-03-20t20-16-18z | | CVSS Score | 8.8 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H | | EPSS Score | 52.087% | | EPSS Percentile | 98th percentile |
Description
Minio is a Multi-Cloud Object Storage framework. Prior to RELEASE.2023-03-20T20-16-18Z, an attacker can use crafted requests to bypass metadata bucket name checking and put an object into any bucket while processing PostPolicyBucket. To carry out this attack, the attacker requires credentials with arn:aws:s3:::* permission, as well as enabled Console API access. This issue has been patched in RELEASE.2023-03-20T20-16-18Z. As a workaround, enable browser API access and turn off MINIO_BROWSER=off.
 OWASP Top Ten 2017 Category A9 - Using Components with Known Vulnerabilities
| Affected range | <v2023-03-20t20-16-18z | | Fixed version | v2023-03-20t20-16-18z | | CVSS Score | 8.8 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H | | EPSS Score | 0.639% | | EPSS Percentile | 71st percentile |
Description
Minio is a Multi-Cloud Object Storage framework. All users on Windows prior to version RELEASE.2023-03-20T20-16-18Z are impacted. MinIO fails to filter the \ character, which allows for arbitrary object placement across buckets. As a result, a user with low privileges, such as an access key, service account, or STS credential, which only has permission to PutObject in a specific bucket, can create an admin user. This issue is patched in RELEASE.2023-03-20T20-16-18Z. There are no known workarounds.
 OWASP Top Ten 2017 Category A9 - Using Components with Known Vulnerabilities
| Affected range | <2020-04-23 | | Fixed version | 2020-04-23 | | CVSS Score | 7.5 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N | | EPSS Score | 0.192% | | EPSS Percentile | 41st percentile |
Description
MinIO has an authentication bypass issue in the MinIO admin API. Given an admin access key, it is possible to perform admin API operations, i.e., creating new service accounts for existing access keys without knowing the admin secret key.
 OWASP Top Ten 2017 Category A9 - Using Components with Known Vulnerabilities
| Affected range | <v2018.05.16 | | Fixed version | v2018.05.16 | | CVSS Score | 7.5 | | CVSS Vector | CVSS:3.0/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H | | EPSS Score | 0.403% | | EPSS Percentile | 61st percentile |
Description
Minio a Allocation of Memory Without Limits or Throttling vulnerability in write-to-RAM.
 Allocation of Resources Without Limits or Throttling
| Affected range | >=0.0.0-20180815103019-7c14cdb60e53
<=0.0.0-20251203081239-27742d469462
| | Fixed version | Not Fixed | | CVSS Score | 7.1 | | CVSS Vector | CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N |
Description
Impact
What kind of vulnerability is it? Who is impacted?
MinIO's S3 Select feature is vulnerable to memory exhaustion when processing CSV
files containing lines longer than available memory. The CSV reader's nextSplit()
function calls bufio.Reader.ReadBytes('\n') with no size limit, buffering the entire
input in memory until a newline is found. A CSV file with no newline characters
causes the entire contents to be read into a single allocation, leading to an OOM
crash of the MinIO server process.
This is exploitable by any authenticated user with s3:PutObject and s3:GetObject
permissions. The attack is especially practical when combined with compression:
a ~2 MB gzip-compressed CSV can decompress to gigabytes of data without
newlines, allowing a small upload to cause large memory consumption on
the server. However, compression is not required — a sufficiently large uncompressed
CSV with no newlines triggers the same issue.
Affected component: internal/s3select/csv/reader.go, function
nextSplit().
CWE: CWE-770 (Allocation of Resources Without Limits or Throttling)
Affected Versions
All MinIO releases are through the final release of the minio/minio open-source project.
The vulnerability was introduced in commit https://github.com/minio/minio/commit/7c14cdb60e53dbfdad2be644dfb180cab19fffa7, which added S3 Select support for CSV.
The CSV reader has used unbounded line reads since this commit (originally via
Go's stdlib encoding/csv.Reader, later via bufio.Reader.ReadBytes after a refactor
in PR #8200.
The first affected release is RELEASE.2018-08-18T03-49-57Z.
Patches
Fixed in: MinIO AIStor RELEASE.2025-12-20T04-58-37Z
The fix replaces the unbounded bufio.Reader.ReadBytes('\n') call with a
byte-at-a-time loop that caps line scanning at 128 KB (csvSplitSize). If no
newline is found within this limit, the reader returns an error instead of
continuing to buffer.
Binary Downloads
FIPS Binaries
Package Downloads
Container Images
# Standard
docker pull quay.io/minio/aistor/minio:RELEASE.2025-12-20T04-58-37Z
podman pull quay.io/minio/aistor/minio:RELEASE.2025-12-20T04-58-37Z
# FIPS
docker pull quay.io/minio/aistor/minio:RELEASE.2025-12-20T04-58-37Z.fips
podman pull quay.io/minio/aistor/minio:RELEASE.2025-12-20T04-58-37Z.fips
Homebrew (macOS)
brew install minio/aistor/minio
Workarounds
If upgrading is not immediately possible:
-
Disable S3 Select access via IAM policy. Deny the s3:GetObject action
with a condition restricting s3:prefix on sensitive buckets, or more
specifically, deny SelectObjectContent requests at a reverse proxy by
blocking POST requests with ?select&select-type=2 query parameters.
-
Restrict PutObject permissions. Limit s3:PutObject grants to trusted
principals to reduce the attack surface. Note: this reduces risk but does not
eliminate the vulnerability since any authorized user can exploit it.
References
 Improper Authentication
| Affected range | >=0.0.0-20240328174456-468a9fae83e9
<=0.0.0-20260212201848-7aac2a2c5b7c
| | Fixed version | Not Fixed | | CVSS Score | 7.1 | | CVSS Vector | CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N | | EPSS Score | 0.025% | | EPSS Percentile | 7th percentile |
Description
Impact
What kind of vulnerability is it? Who is impacted?
A flaw in extractMetadataFromMime() allows any authenticated user with s3:PutObject permission to inject internal server-side encryption metadata into objects by sending crafted X-Minio-Replication-* headers on a normal PutObject request. The server unconditionally maps these headers to X-Minio-Internal-* encryption metadata without verifying that the request is a legitimate replication request. Objects written this way carry bogus encryption keys and become permanently unreadable through the S3 API.
Any authenticated user or service with s3:PutObject permission on any bucket can make objects permanently unreadable by injecting fake SSE encryption metadata. The attacker sends a standard PutObject request with X-Minio-Replication-Server-Side-Encryption-* headers but without the X-Minio-Source-Replication-Request header that marks legitimate replication traffic. The server maps these headers to internal encryption metadata (X-Minio-Internal-Server-Side-Encryption-Sealed-Key, etc.), causing all subsequent GetObject and HeadObject calls to treat the object as encrypted with keys that do not exist.
This is a targeted denial-of-service vulnerability. An attacker can selectively corrupt individual objects or entire buckets. The ReplicateObjectAction IAM permission is never checked because the request is a normal PutObject, not a replication request.
Affected component: cmd/handler-utils.go, function extractMetadataFromMime().
Affected Versions
All MinIO releases through the final release of the minio/minio open-source project.
The vulnerability was introduced in commit 468a9fae83e965ecefa1c1fdc2fc57b84ece95b0 ("Enable replication of SSE-C objects", PR #19107, 2024-03-28). The first affected release is RELEASE.2024-03-30T09-41-56Z.
Patches
Fixed in: MinIO AIStor RELEASE.2026-03-26T21-24-40Z
Binary Downloads
FIPS Binaries
Package Downloads
Container Images
# Standard
docker pull quay.io/minio/aistor/minio:RELEASE.2026-03-26T21-24-40Z
podman pull quay.io/minio/aistor/minio:RELEASE.2026-03-26T21-24-40Z
# FIPS
docker pull quay.io/minio/aistor/minio:RELEASE.2026-03-26T21-24-40Z.fips
podman pull quay.io/minio/aistor/minio:RELEASE.2026-03-26T21-24-40Z.fips
Homebrew (macOS)
brew install minio/aistor/minio
Workarounds
Users of the open-source minio/minio project should upgrade to MinIO AIStor RELEASE.2026-03-26T21-24-40Z or later.
If upgrading is not immediately possible:
-
Restrict replication headers at a reverse proxy / load balancer. Drop or reject any request containing X-Minio-Replication-Server-Side-Encryption-* headers that does not also carry X-Minio-Source-Replication-Request. This blocks the injection path without modifying the server.
-
Audit IAM policies. Limit s3:PutObject grants to trusted principals. While this reduces the attack surface, it does not eliminate the vulnerability since any authorized user can exploit it.
References
 OWASP Top Ten 2017 Category A9 - Using Components with Known Vulnerabilities
| Affected range | <v2021-03-04t00-53-13z | | Fixed version | v2021-03-04t00-53-13z | | CVSS Score | 6.5 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N | | EPSS Score | 0.103% | | EPSS Percentile | 28th percentile |
Description
MinIO is an open-source high performance object storage service and it is API compatible with Amazon S3 cloud storage service. As a workaround, one can disable uploads with a Content-Type of multipart/form-data as mentioned in the S3 API RESTObjectPOST docs by using a proxy in front of MinIO.
 OWASP Top Ten 2017 Category A9 - Using Components with Known Vulnerabilities
| Affected range | <v2022-07-29t19-40-48z | | Fixed version | v2022-07-29t19-40-48z | | CVSS Score | 2.7 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:L/I:N/A:N | | EPSS Score | 8.284% | | EPSS Percentile | 92nd percentile |
Description
MinIO is a High Performance Object Storage released under GNU Affero General Public License v3.0. In affected versions all 'admin' users authorized for admin:ServerUpdate can selectively trigger an error that in response, returns the content of the path requested. Any normal OS system would allow access to contents at any arbitrary paths that are readable by MinIO process. Users are advised to upgrade. Users unable to upgrade may disable ServerUpdate API by denying the admin:ServerUpdate action for your admin users via IAM policies.
|
    stdlib 1.25.0 (golang)
pkg:golang/stdlib@1.25.0
# minio-release.dockerfile (76:76)
COPY --from=build /build/mc/mc /opt/bitnami/common/bin/mc
| Affected range | >=1.25.0-0
<1.25.7
| | Fixed version | 1.25.7 | | EPSS Score | 0.017% | | EPSS Percentile | 4th percentile |
Description
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.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.007% | | EPSS Percentile | 0th percentile |
Description
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.
| Affected range | <1.25.8 | | Fixed version | 1.25.8 | | EPSS Score | 0.033% | | EPSS Percentile | 10th percentile |
Description
url.Parse insufficiently validated the host/authority component and accepted some invalid URLs.
| Affected range | >=1.25.0
<1.25.5
| | Fixed version | 1.25.5 | | EPSS Score | 0.023% | | EPSS Percentile | 6th percentile |
Description
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.
| Affected range | >=1.25.0
<1.25.6
| | Fixed version | 1.25.6 | | EPSS Score | 0.034% | | EPSS Percentile | 10th percentile |
Description
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.
| Affected range | >=1.25.0
<1.25.2
| | Fixed version | 1.25.2 | | EPSS Score | 0.040% | | EPSS Percentile | 12th percentile |
Description
The ParseAddress function constructs domain-literal address components through repeated string concatenation. When parsing large domain-literal components, this can cause excessive CPU consumption.
| Affected range | >=1.25.0
<1.25.2
| | Fixed version | 1.25.2 | | EPSS Score | 0.039% | | EPSS Percentile | 12th percentile |
Description
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.
| Affected range | >=1.25.0
<1.25.2
| | Fixed version | 1.25.2 | | EPSS Score | 0.009% | | EPSS Percentile | 1st percentile |
Description
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.
| Affected range | >=1.25.0
<1.25.3
| | Fixed version | 1.25.3 | | EPSS Score | 0.018% | | EPSS Percentile | 5th percentile |
Description
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.
| Affected range | >=1.25.0
<1.25.6
| | Fixed version | 1.25.6 | | EPSS Score | 0.019% | | EPSS Percentile | 5th percentile |
Description
archive/zip uses a super-linear file name indexing algorithm that is invoked the first time a file in an archive is opened. This can lead to a denial of service when consuming a maliciously constructed ZIP archive.
| Affected range | >=1.25.0
<1.25.5
| | Fixed version | 1.25.5 | | EPSS Score | 0.011% | | EPSS Percentile | 1st percentile |
Description
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 *.example.com.
| Affected range | <1.25.8 | | Fixed version | 1.25.8 | | EPSS Score | 0.012% | | EPSS Percentile | 2nd percentile |
Description
Actions which insert URLs into the content attribute of HTML meta tags are not escaped. This can allow XSS if the meta tag also has an http-equiv attribute with the value "refresh".
A new GODEBUG setting has been added, htmlmetacontenturlescape, which can be used to disable escaping URLs in actions in the meta content attribute which follow "url=" by setting htmlmetacontenturlescape=0.
| Affected range | >=1.25.0
<1.25.1
| | Fixed version | 1.25.1 | | EPSS Score | 0.011% | | EPSS Percentile | 1st percentile |
Description
When using http.CrossOriginProtection, the AddInsecureBypassPattern method can unexpectedly bypass more requests than intended. CrossOriginProtection then skips validation, but forwards the original request path, which may be served by a different handler without the intended security protections.
| Affected range | >=1.25.0
<1.25.6
| | Fixed version | 1.25.6 | | EPSS Score | 0.009% | | EPSS Percentile | 1st percentile |
Description
During the TLS 1.3 handshake if multiple messages are sent in records that span encryption level boundaries (for instance the Client Hello and Encrypted Extensions messages), the subsequent messages may be processed before the encryption level changes. This can cause some minor information disclosure if a network-local attacker can inject messages during the handshake.
| Affected range | >=1.25.0
<1.25.2
| | Fixed version | 1.25.2 | | EPSS Score | 0.021% | | EPSS Percentile | 6th percentile |
Description
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.
| Affected range | >=1.25.0
<1.25.2
| | Fixed version | 1.25.2 | | EPSS Score | 0.012% | | EPSS Percentile | 2nd percentile |
Description
When Conn.Handshake fails during ALPN negotiation the error contains attacker controlled information (the ALPN protocols sent by the client) which is not escaped.
| Affected range | >=1.25.0
<1.25.2
| | Fixed version | 1.25.2 | | EPSS Score | 0.037% | | EPSS Percentile | 11th percentile |
Description
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.
| Affected range | >=1.25.0
<1.25.2
| | Fixed version | 1.25.2 | | EPSS Score | 0.031% | | EPSS Percentile | 9th percentile |
Description
Parsing a maliciously crafted DER payload could allocate large amounts of memory, causing memory exhaustion.
| Affected range | >=1.25.0
<1.25.2
| | Fixed version | 1.25.2 | | EPSS Score | 0.022% | | EPSS Percentile | 6th percentile |
Description
The Parse function permits values other than IPv6 addresses to be included in square brackets within the host component of a URL. RFC 3986 permits IPv6 addresses to be included within the host component, enclosed within square brackets. For example: "http://[::1]/". IPv4 addresses and hostnames must not appear within square brackets. Parse did not enforce this requirement.
| Affected range | >=1.25.0
<1.25.2
| | Fixed version | 1.25.2 | | EPSS Score | 0.017% | | EPSS Percentile | 4th percentile |
Description
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.
| Affected range | <1.25.8 | | Fixed version | 1.25.8 | | EPSS Score | 0.005% | | EPSS Percentile | 0th percentile |
Description
On Unix platforms, when listing the contents of a directory using File.ReadDir or File.Readdir the returned FileInfo could reference a file outside of the Root in which the File was opened.
The impact of this escape is limited to reading metadata provided by lstat from arbitrary locations on the filesystem without permitting reading or writing files outside the root.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.011% | | EPSS Percentile | 1st percentile |
Description
Context was not properly tracked across template branches for JS template literals, leading to possibly incorrect escaping of content when branches were used. Additionally template actions within JS template literals did not properly track the brace depth, leading to incorrect escaping being applied.
These issues could cause actions within JS template literals to be incorrectly or improperly escaped, leading to XSS vulnerabilities.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.009% | | EPSS Percentile | 1st percentile |
Description
tar.Reader can allocate an unbounded amount of memory when reading a maliciously-crafted archive containing a large number of sparse regions encoded in the "old GNU sparse map" format.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.007% | | EPSS Percentile | 0th percentile |
Description
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.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.010% | | EPSS Percentile | 1st percentile |
Description
On Linux, if the target of Root.Chmod is replaced with a symlink while the chmod operation is in progress, Chmod can operate on the target of the symlink, even when the target lies outside the root.
The Linux fchmodat syscall silently ignores the AT_SYMLINK_NOFOLLOW flag, which Root.Chmod uses to avoid symlink traversal. Root.Chmod checks its target before acting and returns an error if the target is a symlink lying outside the root, so the impact is limited to cases where the target is replaced with a symlink between the check and operation.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.007% | | EPSS Percentile | 0th percentile |
Description
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.
|
  stdlib 1.25.3 (golang)
pkg:golang/stdlib@1.25.3
# minio-release.dockerfile (76:76)
COPY --from=build /build/mc/mc /opt/bitnami/common/bin/mc
| Affected range | >=1.25.0-0
<1.25.7
| | Fixed version | 1.25.7 | | EPSS Score | 0.017% | | EPSS Percentile | 4th percentile |
Description
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.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.007% | | EPSS Percentile | 0th percentile |
Description
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.
| Affected range | <1.25.8 | | Fixed version | 1.25.8 | | EPSS Score | 0.033% | | EPSS Percentile | 10th percentile |
Description
url.Parse insufficiently validated the host/authority component and accepted some invalid URLs.
| Affected range | >=1.25.0
<1.25.5
| | Fixed version | 1.25.5 | | EPSS Score | 0.023% | | EPSS Percentile | 6th percentile |
Description
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.
| Affected range | >=1.25.0
<1.25.6
| | Fixed version | 1.25.6 | | EPSS Score | 0.034% | | EPSS Percentile | 10th percentile |
Description
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.
| Affected range | >=1.25.0
<1.25.6
| | Fixed version | 1.25.6 | | EPSS Score | 0.019% | | EPSS Percentile | 5th percentile |
Description
archive/zip uses a super-linear file name indexing algorithm that is invoked the first time a file in an archive is opened. This can lead to a denial of service when consuming a maliciously constructed ZIP archive.
| Affected range | >=1.25.0
<1.25.5
| | Fixed version | 1.25.5 | | EPSS Score | 0.011% | | EPSS Percentile | 1st percentile |
Description
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 *.example.com.
| Affected range | <1.25.8 | | Fixed version | 1.25.8 | | EPSS Score | 0.012% | | EPSS Percentile | 2nd percentile |
Description
Actions which insert URLs into the content attribute of HTML meta tags are not escaped. This can allow XSS if the meta tag also has an http-equiv attribute with the value "refresh".
A new GODEBUG setting has been added, htmlmetacontenturlescape, which can be used to disable escaping URLs in actions in the meta content attribute which follow "url=" by setting htmlmetacontenturlescape=0.
| Affected range | >=1.25.0
<1.25.6
| | Fixed version | 1.25.6 | | EPSS Score | 0.009% | | EPSS Percentile | 1st percentile |
Description
During the TLS 1.3 handshake if multiple messages are sent in records that span encryption level boundaries (for instance the Client Hello and Encrypted Extensions messages), the subsequent messages may be processed before the encryption level changes. This can cause some minor information disclosure if a network-local attacker can inject messages during the handshake.
| Affected range | <1.25.8 | | Fixed version | 1.25.8 | | EPSS Score | 0.005% | | EPSS Percentile | 0th percentile |
Description
On Unix platforms, when listing the contents of a directory using File.ReadDir or File.Readdir the returned FileInfo could reference a file outside of the Root in which the File was opened.
The impact of this escape is limited to reading metadata provided by lstat from arbitrary locations on the filesystem without permitting reading or writing files outside the root.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.011% | | EPSS Percentile | 1st percentile |
Description
Context was not properly tracked across template branches for JS template literals, leading to possibly incorrect escaping of content when branches were used. Additionally template actions within JS template literals did not properly track the brace depth, leading to incorrect escaping being applied.
These issues could cause actions within JS template literals to be incorrectly or improperly escaped, leading to XSS vulnerabilities.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.009% | | EPSS Percentile | 1st percentile |
Description
tar.Reader can allocate an unbounded amount of memory when reading a maliciously-crafted archive containing a large number of sparse regions encoded in the "old GNU sparse map" format.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.007% | | EPSS Percentile | 0th percentile |
Description
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.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.010% | | EPSS Percentile | 1st percentile |
Description
On Linux, if the target of Root.Chmod is replaced with a symlink while the chmod operation is in progress, Chmod can operate on the target of the symlink, even when the target lies outside the root.
The Linux fchmodat syscall silently ignores the AT_SYMLINK_NOFOLLOW flag, which Root.Chmod uses to avoid symlink traversal. Root.Chmod checks its target before acting and returns an error if the target is a symlink lying outside the root, so the impact is limited to cases where the target is replaced with a symlink between the check and operation.
| Affected range | <1.25.9 | | Fixed version | 1.25.9 | | EPSS Score | 0.007% | | EPSS Percentile | 0th percentile |
Description
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.
|
   google.golang.org/grpc 1.72.0 (golang)
pkg:golang/google.golang.org/grpc@1.72.0
# minio-release.dockerfile (80:80)
COPY --from=build /build/minio/minio /opt/bitnami/common/bin/minio
 Improper Authorization
| Affected range | <1.79.3 | | Fixed version | 1.79.3 | | CVSS Score | 9.1 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N | | EPSS Score | 0.014% | | EPSS Percentile | 3rd percentile |
Description
Impact
What kind of vulnerability is it? Who is impacted?
It is an Authorization Bypass resulting from Improper Input Validation of the HTTP/2 :path pseudo-header.
The gRPC-Go server was too lenient in its routing logic, accepting requests where the :path omitted the mandatory leading slash (e.g., Service/Method instead of /Service/Method). While the server successfully routed these requests to the correct handler, authorization interceptors (including the official grpc/authz package) evaluated the raw, non-canonical path string. Consequently, "deny" rules defined using canonical paths (starting with /) failed to match the incoming request, allowing it to bypass the policy if a fallback "allow" rule was present.
Who is impacted?
This affects gRPC-Go servers that meet both of the following criteria:
- They use path-based authorization interceptors, such as the official RBAC implementation in
google.golang.org/grpc/authz or custom interceptors relying on info.FullMethod or grpc.Method(ctx).
- Their security policy contains specific "deny" rules for canonical paths but allows other requests by default (a fallback "allow" rule).
The vulnerability is exploitable by an attacker who can send raw HTTP/2 frames with malformed :path headers directly to the gRPC server.
Patches
Has the problem been patched? What versions should users upgrade to?
Yes, the issue has been patched. The fix ensures that any request with a :path that does not start with a leading slash is immediately rejected with a codes.Unimplemented error, preventing it from reaching authorization interceptors or handlers with a non-canonical path string.
Users should upgrade to the following versions (or newer):
- v1.79.3
- The latest master branch.
It is recommended that all users employing path-based authorization (especially grpc/authz) upgrade as soon as the patch is available in a tagged release.
Workarounds
Is there a way for users to fix or remediate the vulnerability without upgrading?
While upgrading is the most secure and recommended path, users can mitigate the vulnerability using one of the following methods:
1. Use a Validating Interceptor (Recommended Mitigation)
Add an "outermost" interceptor to your server that validates the path before any other authorization logic runs:
func pathValidationInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
if info.FullMethod == "" || info.FullMethod[0] != '/' {
return nil, status.Errorf(codes.Unimplemented, "malformed method name")
}
return handler(ctx, req)
}
s := grpc.NewServer(
grpc.ChainUnaryInterceptor(pathValidationInterceptor, authzInterceptor),
)
2. Infrastructure-Level Normalization
If your gRPC server is behind a reverse proxy or load balancer (such as Envoy, NGINX, or an L7 Cloud Load Balancer), ensure it is configured to enforce strict HTTP/2 compliance for pseudo-headers and reject or normalize requests where the :path header does not start with a leading slash.
3. Policy Hardening
Switch to a "default deny" posture in your authorization policies (explicitly listing all allowed paths and denying everything else) to reduce the risk of bypasses via malformed inputs.
|
google.golang.org/grpc 1.71.0 (golang)
pkg:golang/google.golang.org/grpc@1.71.0
# minio-release.dockerfile (76:76)
COPY --from=build /build/mc/mc /opt/bitnami/common/bin/mc
Improper Authorization
| Affected range | <1.79.3 | | Fixed version | 1.79.3 | | CVSS Score | 9.1 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N | | EPSS Score | 0.014% | | EPSS Percentile | 3rd percentile |
Description
Impact
What kind of vulnerability is it? Who is impacted?
It is an Authorization Bypass resulting from Improper Input Validation of the HTTP/2 :path pseudo-header.
The gRPC-Go server was too lenient in its routing logic, accepting requests where the :path omitted the mandatory leading slash (e.g., Service/Method instead of /Service/Method). While the server successfully routed these requests to the correct handler, authorization interceptors (including the official grpc/authz package) evaluated the raw, non-canonical path string. Consequently, "deny" rules defined using canonical paths (starting with /) failed to match the incoming request, allowing it to bypass the policy if a fallback "allow" rule was present.
Who is impacted?
This affects gRPC-Go servers that meet both of the following criteria:
- They use path-based authorization interceptors, such as the official RBAC implementation in
google.golang.org/grpc/authz or custom interceptors relying on info.FullMethod or grpc.Method(ctx).
- Their security policy contains specific "deny" rules for canonical paths but allows other requests by default (a fallback "allow" rule).
The vulnerability is exploitable by an attacker who can send raw HTTP/2 frames with malformed :path headers directly to the gRPC server.
Patches
Has the problem been patched? What versions should users upgrade to?
Yes, the issue has been patched. The fix ensures that any request with a :path that does not start with a leading slash is immediately rejected with a codes.Unimplemented error, preventing it from reaching authorization interceptors or handlers with a non-canonical path string.
Users should upgrade to the following versions (or newer):
- v1.79.3
- The latest master branch.
It is recommended that all users employing path-based authorization (especially grpc/authz) upgrade as soon as the patch is available in a tagged release.
Workarounds
Is there a way for users to fix or remediate the vulnerability without upgrading?
While upgrading is the most secure and recommended path, users can mitigate the vulnerability using one of the following methods:
1. Use a Validating Interceptor (Recommended Mitigation)
Add an "outermost" interceptor to your server that validates the path before any other authorization logic runs:
func pathValidationInterceptor(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
if info.FullMethod == "" || info.FullMethod[0] != '/' {
return nil, status.Errorf(codes.Unimplemented, "malformed method name")
}
return handler(ctx, req)
}
s := grpc.NewServer(
grpc.ChainUnaryInterceptor(pathValidationInterceptor, authzInterceptor),
)
2. Infrastructure-Level Normalization
If your gRPC server is behind a reverse proxy or load balancer (such as Envoy, NGINX, or an L7 Cloud Load Balancer), ensure it is configured to enforce strict HTTP/2 compliance for pseudo-headers and reject or normalize requests where the :path header does not start with a leading slash.
3. Policy Hardening
Switch to a "default deny" posture in your authorization policies (explicitly listing all allowed paths and denying everything else) to reduce the risk of bypasses via malformed inputs.
|
  openssl 3.0.17-1~deb12u3 (deb)
pkg:deb/debian/openssl@3.0.17-1~deb12u3?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (53:59)
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
jq \
curl \
procps \
bash \
&& rm -rf /var/lib/apt/lists/*
| Affected range | <3.0.19-1~deb12u2 | | Fixed version | 3.0.19-1~deb12u2 | | EPSS Score | 0.012% | | EPSS Percentile | 1st percentile |
Description
Issue summary: Applications using RSASVE key encapsulation to establish a secret encryption key can send contents of an uninitialized memory buffer to a malicious peer. Impact summary: The uninitialized buffer might contain sensitive data from the previous execution of the application process which leads to sensitive data leakage to an attacker. RSA_public_encrypt() returns the number of bytes written on success and -1 on error. The affected code tests only whether the return value is non-zero. As a result, if RSA encryption fails, encapsulation can still return success to the caller, set the output lengths, and leave the caller to use the contents of the ciphertext buffer as if a valid KEM ciphertext had been produced. If applications use EVP_PKEY_encapsulate() with RSA/RSASVE on an attacker-supplied invalid RSA public key without first validating that key, then this may cause stale or uninitialized contents of the caller-provided ciphertext buffer to be disclosed to the attacker in place of the KEM ciphertext. As a workaround calling EVP_PKEY_public_check() or EVP_PKEY_public_check_quick() before EVP_PKEY_encapsulate() will mitigate the issue. The FIPS modules in 3.6, 3.5, 3.4, 3.3, 3.1 and 3.0 are affected by this issue.
| Affected range | <3.0.18-1~deb12u2 | | Fixed version | 3.0.18-1~deb12u2 | | EPSS Score | 0.036% | | EPSS Percentile | 11th percentile |
Description
Issue summary: Processing a malformed PKCS#12 file can trigger a NULL pointer dereference in the PKCS12_item_decrypt_d2i_ex() function. Impact summary: A NULL pointer dereference can trigger a crash which leads to Denial of Service for an application processing PKCS#12 files. The PKCS12_item_decrypt_d2i_ex() function does not check whether the oct parameter is NULL before dereferencing it. When called from PKCS12_unpack_p7encdata() with a malformed PKCS#12 file, this parameter can be NULL, causing a crash. The vulnerability is limited to Denial of Service and cannot be escalated to achieve code execution or memory disclosure. Exploiting this issue requires an attacker to provide a malformed PKCS#12 file to an application that processes it. For that reason the issue was assessed as Low severity according to our Security Policy. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the PKCS#12 implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0, 1.1.1 and 1.0.2 are vulnerable to this issue.
| Affected range | <3.0.18-1~deb12u2 | | Fixed version | 3.0.18-1~deb12u2 | | EPSS Score | 0.303% | | EPSS Percentile | 54th percentile |
Description
Issue summary: A type confusion vulnerability exists in the TimeStamp Response verification code where an ASN1_TYPE union member is accessed without first validating the type, causing an invalid or NULL pointer dereference when processing a malformed TimeStamp Response file. Impact summary: An application calling TS_RESP_verify_response() with a malformed TimeStamp Response can be caused to dereference an invalid or NULL pointer when reading, resulting in a Denial of Service. The functions ossl_ess_get_signing_cert() and ossl_ess_get_signing_cert_v2() access the signing cert attribute value without validating its type. When the type is not V_ASN1_SEQUENCE, this results in accessing invalid memory through the ASN1_TYPE union, causing a crash. Exploiting this vulnerability requires an attacker to provide a malformed TimeStamp Response to an application that verifies timestamp responses. The TimeStamp protocol (RFC 3161) is not widely used and the impact of the exploit is just a Denial of Service. For these reasons the issue was assessed as Low severity. The FIPS modules in 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the TimeStamp Response implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0 and 1.1.1 are vulnerable to this issue. OpenSSL 1.0.2 is not affected by this issue.
| Affected range | <3.0.18-1~deb12u2 | | Fixed version | 3.0.18-1~deb12u2 | | EPSS Score | 0.063% | | EPSS Percentile | 20th percentile |
Description
Issue summary: Calling PKCS12_get_friendlyname() function on a maliciously crafted PKCS#12 file with a BMPString (UTF-16BE) friendly name containing non-ASCII BMP code point can trigger a one byte write before the allocated buffer. Impact summary: The out-of-bounds write can cause a memory corruption which can have various consequences including a Denial of Service. The OPENSSL_uni2utf8() function performs a two-pass conversion of a PKCS#12 BMPString (UTF-16BE) to UTF-8. In the second pass, when emitting UTF-8 bytes, the helper function bmp_to_utf8() incorrectly forwards the remaining UTF-16 source byte count as the destination buffer capacity to UTF8_putc(). For BMP code points above U+07FF, UTF-8 requires three bytes, but the forwarded capacity can be just two bytes. UTF8_putc() then returns -1, and this negative value is added to the output length without validation, causing the length to become negative. The subsequent trailing NUL byte is then written at a negative offset, causing write outside of heap allocated buffer. The vulnerability is reachable via the public PKCS12_get_friendlyname() API when parsing attacker-controlled PKCS#12 files. While PKCS12_parse() uses a different code path that avoids this issue, PKCS12_get_friendlyname() directly invokes the vulnerable function. Exploitation requires an attacker to provide a malicious PKCS#12 file to be parsed by the application and the attacker can just trigger a one zero byte write before the allocated buffer. For that reason the issue was assessed as Low severity according to our Security Policy. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the PKCS#12 implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0 and 1.1.1 are vulnerable to this issue. OpenSSL 1.0.2 is not affected by this issue.
| Affected range | <3.0.18-1~deb12u2 | | Fixed version | 3.0.18-1~deb12u2 | | EPSS Score | 0.021% | | EPSS Percentile | 6th percentile |
Description
Issue summary: An invalid or NULL pointer dereference can happen in an application processing a malformed PKCS#12 file. Impact summary: An application processing a malformed PKCS#12 file can be caused to dereference an invalid or NULL pointer on memory read, resulting in a Denial of Service. A type confusion vulnerability exists in PKCS#12 parsing code where an ASN1_TYPE union member is accessed without first validating the type, causing an invalid pointer read. The location is constrained to a 1-byte address space, meaning any attempted pointer manipulation can only target addresses between 0x00 and 0xFF. This range corresponds to the zero page, which is unmapped on most modern operating systems and will reliably result in a crash, leading only to a Denial of Service. Exploiting this issue also requires a user or application to process a maliciously crafted PKCS#12 file. It is uncommon to accept untrusted PKCS#12 files in applications as they are usually used to store private keys which are trusted by definition. For these reasons, the issue was assessed as Low severity. The FIPS modules in 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the PKCS12 implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0 and 1.1.1 are vulnerable to this issue. OpenSSL 1.0.2 is not affected by this issue.
| Affected range | <3.0.18-1~deb12u2 | | Fixed version | 3.0.18-1~deb12u2 | | EPSS Score | 0.117% | | EPSS Percentile | 30th percentile |
Description
Issue summary: A type confusion vulnerability exists in the signature verification of signed PKCS#7 data where an ASN1_TYPE union member is accessed without first validating the type, causing an invalid or NULL pointer dereference when processing malformed PKCS#7 data. Impact summary: An application performing signature verification of PKCS#7 data or calling directly the PKCS7_digest_from_attributes() function can be caused to dereference an invalid or NULL pointer when reading, resulting in a Denial of Service. The function PKCS7_digest_from_attributes() accesses the message digest attribute value without validating its type. When the type is not V_ASN1_OCTET_STRING, this results in accessing invalid memory through the ASN1_TYPE union, causing a crash. Exploiting this vulnerability requires an attacker to provide a malformed signed PKCS#7 to an application that verifies it. The impact of the exploit is just a Denial of Service, the PKCS7 API is legacy and applications should be using the CMS API instead. For these reasons the issue was assessed as Low severity. The FIPS modules in 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the PKCS#7 parsing implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0, 1.1.1 and 1.0.2 are vulnerable to this issue.
| Affected range | <3.0.18-1~deb12u2 | | Fixed version | 3.0.18-1~deb12u2 | | EPSS Score | 0.027% | | EPSS Percentile | 8th percentile |
Description
Issue summary: Writing large, newline-free data into a BIO chain using the line-buffering filter where the next BIO performs short writes can trigger a heap-based out-of-bounds write. Impact summary: This out-of-bounds write can cause memory corruption which typically results in a crash, leading to Denial of Service for an application. The line-buffering BIO filter (BIO_f_linebuffer) is not used by default in TLS/SSL data paths. In OpenSSL command-line applications, it is typically only pushed onto stdout/stderr on VMS systems. Third-party applications that explicitly use this filter with a BIO chain that can short-write and that write large, newline-free data influenced by an attacker would be affected. However, the circumstances where this could happen are unlikely to be under attacker control, and BIO_f_linebuffer is unlikely to be handling non-curated data controlled by an attacker. For that reason the issue was assessed as Low severity. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the BIO implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0, 1.1.1 and 1.0.2 are vulnerable to this issue.
| Affected range | <3.0.18-1~deb12u2 | | Fixed version | 3.0.18-1~deb12u2 | | EPSS Score | 0.008% | | EPSS Percentile | 1st percentile |
Description
Issue summary: When using the low-level OCB API directly with AES-NI or
other hardware-accelerated code paths, inputs whose length is not a multiple
of 16 bytes can leave the final partial block unencrypted and unauthenticated.
Impact summary: The trailing 1-15 bytes of a message may be exposed in
cleartext on encryption and are not covered by the authentication tag,
allowing an attacker to read or tamper with those bytes without detection.
The low-level OCB encrypt and decrypt routines in the hardware-accelerated
stream path process full 16-byte blocks but do not advance the input/output
pointers. The subsequent tail-handling code then operates on the original
base pointers, effectively reprocessing the beginning of the buffer while
leaving the actual trailing bytes unprocessed. The authentication checksum
also excludes the true tail bytes.
However, typical OpenSSL consumers using EVP are not affected because the
higher-level EVP and provider OCB implementations split inputs so that full
blocks and trailing partial blocks are processed in separate calls, avoiding
the problematic code path. Additionally, TLS does not use OCB ciphersuites.
The vulnerability only affects applications that call the low-level
CRYPTO_ocb128_encrypt() or CRYPTO_ocb128_decrypt() functions directly with
non-block-aligned lengths in a single call on hardware-accelerated builds.
For these reasons the issue was assessed as Low severity.
The FIPS modules in 3.6, 3.5, 3.4, 3.3, 3.2, 3.1 and 3.0 are not affected
by this issue, as OCB mode is not a FIPS-approved algorithm.
OpenSSL 3.6, 3.5, 3.4, 3.3, 3.0 and 1.1.1 are vulnerable to this issue.
OpenSSL 1.0.2 is not affected by this issue.
| Affected range | <=3.0.18-1~deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.078% | | EPSS Percentile | 23rd percentile |
Description
OpenSSL 3.0.0 through 3.3.2 on the PowerPC architecture is vulnerable to a Minerva attack, exploitable by measuring the time of signing of random messages using the EVP_DigestSign API, and then using the private key to extract the K value (nonce) from the signatures. Next, based on the bit size of the extracted nonce, one can compare the signing time of full-sized nonces to signatures that used smaller nonces, via statistical tests. There is a side-channel in the P-364 curve that allows private key extraction (also, there is a dependency between the bit size of K and the size of the side channel). NOTE: This CVE is disputed because the OpenSSL security policy explicitly notes that any side channels which require same physical system to be detected are outside of the threat model for the software. The timing signal is so small that it is infeasible to be detected without having the attacking process running on the same physical system.
| Affected range | <3.0.18-1~deb12u2 | | Fixed version | 3.0.18-1~deb12u2 | | EPSS Score | 0.705% | | EPSS Percentile | 72nd percentile |
Description
Issue summary: Parsing CMS AuthEnvelopedData or EnvelopedData message with maliciously crafted AEAD parameters can trigger a stack buffer overflow. Impact summary: A stack buffer overflow may lead to a crash, causing Denial of Service, or potentially remote code execution. When parsing CMS (Auth)EnvelopedData structures that use AEAD ciphers such as AES-GCM, the IV (Initialization Vector) encoded in the ASN.1 parameters is copied into a fixed-size stack buffer without verifying that its length fits the destination. An attacker can supply a crafted CMS message with an oversized IV, causing a stack-based out-of-bounds write before any authentication or tag verification occurs. Applications and services that parse untrusted CMS or PKCS#7 content using AEAD ciphers (e.g., S/MIME (Auth)EnvelopedData with AES-GCM) are vulnerable. Because the overflow occurs prior to authentication, no valid key material is required to trigger it. While exploitability to remote code execution depends on platform and toolchain mitigations, the stack-based write primitive represents a severe risk. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the CMS implementation is outside the OpenSSL FIPS module boundary. OpenSSL 3.6, 3.5, 3.4, 3.3 and 3.0 are vulnerable to this issue. OpenSSL 1.1.1 and 1.0.2 are not affected by this issue.
| Affected range | >=3.0.11-1~deb12u2 | | Fixed version | Not Fixed | | EPSS Score | 0.094% | | EPSS Percentile | 26th percentile |
Description
| Affected range | <3.0.19-1~deb12u2 | | Fixed version | 3.0.19-1~deb12u2 | | EPSS Score | 0.011% | | EPSS Percentile | 1st percentile |
Description
Issue summary: Converting an excessively large OCTET STRING value to a hexadecimal string leads to a heap buffer overflow on 32 bit platforms. Impact summary: A heap buffer overflow may lead to a crash or possibly an attacker controlled code execution or other undefined behavior. If an attacker can supply a crafted X.509 certificate with an excessively large OCTET STRING value in extensions such as the Subject Key Identifier (SKID) or Authority Key Identifier (AKID) which are being converted to hex, the size of the buffer needed for the result is calculated as multiplication of the input length by 3. On 32 bit platforms, this multiplication may overflow resulting in the allocation of a smaller buffer and a heap buffer overflow. Applications and services that print or log contents of untrusted X.509 certificates are vulnerable to this issue. As the certificates would have to have sizes of over 1 Gigabyte, printing or logging such certificates is a fairly unlikely operation and only 32 bit platforms are affected, this issue was assigned Low severity. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the affected code is outside the OpenSSL FIPS module boundary.
| Affected range | <3.0.19-1~deb12u2 | | Fixed version | 3.0.19-1~deb12u2 | | EPSS Score | 0.029% | | EPSS Percentile | 8th percentile |
Description
Issue summary: During processing of a crafted CMS EnvelopedData message with KeyTransportRecipientInfo a NULL pointer dereference can happen. Impact summary: Applications that process attacker-controlled CMS data may crash before authentication or cryptographic operations occur resulting in Denial of Service. When a CMS EnvelopedData message that uses KeyTransportRecipientInfo with RSA-OAEP encryption is processed, the optional parameters field of RSA-OAEP SourceFunc algorithm identifier is examined without checking for its presence. This results in a NULL pointer dereference if the field is missing. Applications and services that call CMS_decrypt() on untrusted input (e.g., S/MIME processing or CMS-based protocols) are vulnerable. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the affected code is outside the OpenSSL FIPS module boundary.
| Affected range | <3.0.19-1~deb12u2 | | Fixed version | 3.0.19-1~deb12u2 | | EPSS Score | 0.029% | | EPSS Percentile | 8th percentile |
Description
Issue summary: During processing of a crafted CMS EnvelopedData message with KeyAgreeRecipientInfo a NULL pointer dereference can happen. Impact summary: Applications that process attacker-controlled CMS data may crash before authentication or cryptographic operations occur resulting in Denial of Service. When a CMS EnvelopedData message that uses KeyAgreeRecipientInfo is processed, the optional parameters field of KeyEncryptionAlgorithmIdentifier is examined without checking for its presence. This results in a NULL pointer dereference if the field is missing. Applications and services that call CMS_decrypt() on untrusted input (e.g., S/MIME processing or CMS-based protocols) are vulnerable. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the affected code is outside the OpenSSL FIPS module boundary.
| Affected range | <3.0.19-1~deb12u2 | | Fixed version | 3.0.19-1~deb12u2 | | EPSS Score | 0.011% | | EPSS Percentile | 1st percentile |
Description
Issue summary: When a delta CRL that contains a Delta CRL Indicator extension is processed a NULL pointer dereference might happen if the required CRL Number extension is missing. Impact summary: A NULL pointer dereference can trigger a crash which leads to a Denial of Service for an application. When CRL processing and delta CRL processing is enabled during X.509 certificate verification, the delta CRL processing does not check whether the CRL Number extension is NULL before dereferencing it. When a malformed delta CRL file is being processed, this parameter can be NULL, causing a NULL pointer dereference. Exploiting this issue requires the X509_V_FLAG_USE_DELTAS flag to be enabled in the verification context, the certificate being verified to contain a freshestCRL extension or the base CRL to have the EXFLAG_FRESHEST flag set, and an attacker to provide a malformed CRL to an application that processes it. The vulnerability is limited to Denial of Service and cannot be escalated to achieve code execution or memory disclosure. For that reason the issue was assessed as Low severity according to our Security Policy. The FIPS modules in 3.6, 3.5, 3.4, 3.3 and 3.0 are not affected by this issue, as the affected code is outside the OpenSSL FIPS module boundary.
| Affected range | <3.0.19-1~deb12u2 | | Fixed version | 3.0.19-1~deb12u2 | | EPSS Score | 0.020% | | EPSS Percentile | 5th percentile |
Description
Issue summary: An uncommon configuration of clients performing DANE TLSA-based server authentication, when paired with uncommon server DANE TLSA records, may result in a use-after-free and/or double-free on the client side. Impact summary: A use after free can have a range of potential consequences such as the corruption of valid data, crashes or execution of arbitrary code. However, the issue only affects clients that make use of TLSA records with both the PKIX-TA(0/PKIX-EE(1) certificate usages and the DANE-TA(2) certificate usage. By far the most common deployment of DANE is in SMTP MTAs for which RFC7672 recommends that clients treat as 'unusable' any TLSA records that have the PKIX certificate usages. These SMTP (or other similar) clients are not vulnerable to this issue. Conversely, any clients that support only the PKIX usages, and ignore the DANE-TA(2) usage are also not vulnerable. The client would also need to be communicating with a server that publishes a TLSA RRset with both types of TLSA records. No FIPS modules are affected by this issue, the problem code is outside the FIPS module boundary.
|
 go.opentelemetry.io/otel/sdk 1.35.0 (golang)
pkg:golang/go.opentelemetry.io/otel/sdk@1.35.0
# minio-release.dockerfile (80:80)
COPY --from=build /build/minio/minio /opt/bitnami/common/bin/minio
 Untrusted Search Path
| Affected range | >=1.15.0
<=1.42.0
| | Fixed version | 1.43.0 | | CVSS Score | 7.3 | | CVSS Vector | CVSS:4.0/AV:L/AC:H/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N |
Description
Summary
The fix for GHSA-9h8m-3fm2-qjrq (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.
Root Cause
sdk/resource/host_id.go line 42:
if result, err := r.execCommand("kenv", "-q", "smbios.system.uuid"); err == nil {
Compare with the fixed Darwin path at line 58:
result, err := r.execCommand("/usr/sbin/ioreg", "-rd1", "-c", "IOPlatformExpertDevice")
The execCommand helper at sdk/resource/host_id_exec.go uses exec.Command(name, arg...) which searches $PATH when the command name contains no path separator.
Affected platforms (per build tag in host_id_bsd.go:4): DragonFly BSD, FreeBSD, NetBSD, OpenBSD, Solaris.
The kenv path is reached when /etc/hostid does not exist (line 38-40), which is common on FreeBSD systems.
Attack
- Attacker has local access to a system running a Go application that imports
go.opentelemetry.io/otel/sdk
- Attacker places a malicious
kenv binary earlier in $PATH
- Application initializes OpenTelemetry resource detection at startup
hostIDReaderBSD.read() calls exec.Command("kenv", ...) which resolves to the malicious binary- Arbitrary code executes in the context of the application
Same attack vector and impact as CVE-2026-24051.
Suggested Fix
Use the absolute path:
if result, err := r.execCommand("/bin/kenv", "-q", "smbios.system.uuid"); err == nil {
On FreeBSD, kenv is located at /bin/kenv.
 Untrusted Search Path
| Affected range | >=1.21.0
<1.40.0
| | Fixed version | 1.40.0 | | CVSS Score | 7 | | CVSS Vector | CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H | | EPSS Score | 0.007% | | EPSS Percentile | 1st percentile |
Description
Impact
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.
Patches
This has been patched in d45961b, which was released with v1.40.0.
References
|
  golang.org/x/crypto 0.37.0 (golang)
pkg:golang/golang.org/x/crypto@0.37.0
# minio-release.dockerfile (80:80)
COPY --from=build /build/minio/minio /opt/bitnami/common/bin/minio
| Affected range | <0.43.0 | | Fixed version | 0.43.0 | | EPSS Score | 0.039% | | EPSS Percentile | 12th percentile |
Description
SSH clients receiving SSH_AGENT_SUCCESS when expecting a typed response will panic and cause early termination of the client process.
 Allocation of Resources Without Limits or Throttling
| Affected range | <0.45.0 | | Fixed version | 0.45.0 | | CVSS Score | 5.3 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L | | EPSS Score | 0.087% | | EPSS Percentile | 25th percentile |
Description
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.
 Out-of-bounds Read
| Affected range | <0.45.0 | | Fixed version | 0.45.0 | | CVSS Score | 5.3 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L | | EPSS Score | 0.021% | | EPSS Percentile | 6th percentile |
Description
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.
|
golang.org/x/crypto 0.40.0 (golang)
pkg:golang/golang.org/x/crypto@0.40.0
# minio-release.dockerfile (76:76)
COPY --from=build /build/mc/mc /opt/bitnami/common/bin/mc
| Affected range | <0.43.0 | | Fixed version | 0.43.0 | | EPSS Score | 0.039% | | EPSS Percentile | 12th percentile |
Description
SSH clients receiving SSH_AGENT_SUCCESS when expecting a typed response will panic and cause early termination of the client process.
Allocation of Resources Without Limits or Throttling
| Affected range | <0.45.0 | | Fixed version | 0.45.0 | | CVSS Score | 5.3 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L | | EPSS Score | 0.087% | | EPSS Percentile | 25th percentile |
Description
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.
Out-of-bounds Read
| Affected range | <0.45.0 | | Fixed version | 0.45.0 | | CVSS Score | 5.3 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L | | EPSS Score | 0.021% | | EPSS Percentile | 6th percentile |
Description
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.
|
pam 1.5.2-6+deb12u1 (deb)
pkg:deb/debian/pam@1.5.2-6%2Bdeb12u1?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <1.5.2-6+deb12u2 | | Fixed version | 1.5.2-6+deb12u2 | | EPSS Score | 0.027% | | EPSS Percentile | 8th percentile |
Description
A flaw was found in linux-pam. The module pam_namespace may use access user-controlled paths without proper protection, allowing local users to elevate their privileges to root via multiple symlink attacks and race conditions.
[experimental] - pam 1.7.0-4
| Affected range | <1.5.2-6+deb12u2 | | Fixed version | 1.5.2-6+deb12u2 | | EPSS Score | 0.150% | | EPSS Percentile | 36th percentile |
Description
linux-pam (aka Linux PAM) before 1.6.0 allows attackers to cause a denial of service (blocked login process) via mkfifo because the openat call (for protect_dir) lacks O_DIRECTORY.
[experimental] - pam 1.5.3-2
|
gnupg2 2.2.40-1.1+deb12u1 (deb)
pkg:deb/debian/gnupg2@2.2.40-1.1%2Bdeb12u1?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <2.2.40-1.1+deb12u2 | | Fixed version | 2.2.40-1.1+deb12u2 | | EPSS Score | 0.018% | | EPSS Percentile | 5th percentile |
Description
In GnuPG before 2.4.9, armor_filter in g10/armor.c has two increments of an index variable where one is intended, leading to an out-of-bounds write for crafted input. (For ExtendedLTS, 2.2.51 and later are fixed versions.)
| Affected range | <=2.2.40-1.1+deb12u2 | | Fixed version | Not Fixed | | EPSS Score | 0.015% | | EPSS Percentile | 3rd percentile |
Description
GnuPG can be made to spin on a relatively small input by (for example) crafting a public key with thousands of signatures attached, compressed down to just a few KB.
|
nghttp2 1.52.0-1+deb12u2 (deb)
pkg:deb/debian/nghttp2@1.52.0-1%2Bdeb12u2?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (53:59)
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
jq \
curl \
procps \
bash \
&& rm -rf /var/lib/apt/lists/*
| Affected range | <=1.52.0-1+deb12u2 | | Fixed version | Not Fixed | | EPSS Score | 0.017% | | EPSS Percentile | 4th percentile |
Description
nghttp2 is an implementation of the Hypertext Transfer Protocol version 2 in C. Prior to version 1.68.1, the nghttp2 library stops reading the incoming data when user facing public API nghttp2_session_terminate_session or nghttp2_session_terminate_session2 is called by the application. They might be called internally by the library when it detects the situation that is subject to connection error. Due to the missing internal state validation, the library keeps reading the rest of the data after one of those APIs is called. Then receiving a malformed frame that causes FRAME_SIZE_ERROR causes assertion failure. nghttp2 v1.68.1 adds missing state validation to avoid assertion failure. No known workarounds are available.
|
github.com/go-jose/go-jose/v4 4.1.0 (golang)
pkg:golang/github.com/go-jose/go-jose/v4@4.1.0
# minio-release.dockerfile (80:80)
COPY --from=build /build/minio/minio /opt/bitnami/common/bin/minio
 Uncaught Exception
| Affected range | <4.1.4 | | Fixed version | 4.1.4 | | CVSS Score | 7.5 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H | | EPSS Score | 0.015% | | EPSS Percentile | 3rd percentile |
Description
Impact
Decrypting a JSON Web Encryption (JWE) object will panic if the alg field indicates a key wrapping algorithm (one ending in KW, with the exception of A128GCMKW, A192GCMKW, and A256GCMKW) and the encrypted_key field is empty. The panic happens when cipher.KeyUnwrap() in key_wrap.go attempts to allocate a slice with a zero or negative length based on the length of the encrypted_key.
This code path is reachable from ParseEncrypted() / ParseEncryptedJSON() / ParseEncryptedCompact() followed by Decrypt() on the resulting object. Note that the parse functions take a list of accepted key algorithms. If the accepted key algorithms do not include any key wrapping algorithms, parsing will fail and the application will be unaffected.
This panic is also reachable by calling cipher.KeyUnwrap() directly with any ciphertext parameter less than 16 bytes long, but calling this function directly is less common.
Panics can lead to denial of service.
Fixed In
4.1.4 and v3.0.5
Workarounds
If the list of keyAlgorithms passed to ParseEncrypted() / ParseEncryptedJSON() / ParseEncryptedCompact() does not include key wrapping algorithms (those ending in KW), your application is unaffected.
If your application uses key wrapping, you can prevalidate to the JWE objects to ensure the encrypted_key field is nonempty. If your application accepts JWE Compact Serialization, apply that validation to the corresponding field of that serialization (the data between the first and second .).
Thanks
Thanks to Datadog's Security team for finding this issue.
|
github.com/buger/jsonparser 1.1.1 (golang)
pkg:golang/github.com/buger/jsonparser@1.1.1
# minio-release.dockerfile (80:80)
COPY --from=build /build/minio/minio /opt/bitnami/common/bin/minio
 Out-of-bounds Read
| Affected range | <=1.1.1 | | Fixed version | 1.1.2 | | CVSS Score | 7.5 | | CVSS Vector | CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H | | EPSS Score | 0.054% | | EPSS Percentile | 17th percentile |
Description
The Delete function fails to properly validate offsets when processing malformed JSON input. This can lead to a negative slice index and a runtime panic, allowing a denial of service attack.
|
gnutls28 3.7.9-2+deb12u5 (deb)
pkg:deb/debian/gnutls28@3.7.9-2%2Bdeb12u5?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <3.7.9-2+deb12u6 | | Fixed version | 3.7.9-2+deb12u6 | | EPSS Score | 0.064% | | EPSS Percentile | 20th percentile |
Description
A flaw was found in GnuTLS. This vulnerability allows a denial of service (DoS) by excessive CPU (Central Processing Unit) and memory consumption via specially crafted malicious certificates containing a large number of name constraints and subject alternative names (SANs).
| Affected range | <3.7.9-2+deb12u6 | | Fixed version | 3.7.9-2+deb12u6 | | EPSS Score | 0.015% | | EPSS Percentile | 3rd percentile |
Description
A flaw was found in the GnuTLS library, specifically in the gnutls_pkcs11_token_init() function that handles PKCS#11 token initialization. When a token label longer than expected is processed, the function writes past the end of a fixed-size stack buffer. This programming error can cause the application using GnuTLS to crash or, in certain conditions, be exploited for code execution. As a result, systems or applications relying on GnuTLS may be vulnerable to a denial of service or local privilege escalation attacks.
[experimental] - gnutls28 3.8.11-1
| Affected range | <=3.7.9-2+deb12u5 | | Fixed version | Not Fixed | | EPSS Score | 3.832% | | EPSS Percentile | 88th percentile |
Description
The SSL protocol, as used in certain configurations in Microsoft Windows and Microsoft Internet Explorer, Mozilla Firefox, Google Chrome, Opera, and other products, encrypts data by using CBC mode with chained initialization vectors, which allows man-in-the-middle attackers to obtain plaintext HTTP headers via a blockwise chosen-boundary attack (BCBA) on an HTTPS session, in conjunction with JavaScript code that uses (1) the HTML5 WebSocket API, (2) the Java URLConnection API, or (3) the Silverlight WebClient API, aka a "BEAST" attack.
|
tar 1.34+dfsg-1.2+deb12u1 (deb)
pkg:deb/debian/tar@1.34%2Bdfsg-1.2%2Bdeb12u1?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=1.34+dfsg-1.2+deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.025% | | EPSS Percentile | 7th percentile |
Description
A flaw was found in tar. A remote attacker could exploit this vulnerability by crafting a malicious archive, leading to hidden file injection with fully attacker-controlled content. This bypasses pre-extraction inspection mechanisms, potentially allowing an attacker to introduce malicious files onto a system without detection.
| Affected range | >=1.34+dfsg-1.2+deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.081% | | EPSS Percentile | 24th percentile |
Description
GNU Tar through 1.35 allows file overwrite via directory traversal in crafted TAR archives, with a certain two-step process. First, the victim must extract an archive that contains a ../ symlink to a critical directory. Second, the victim must extract an archive that contains a critical file, specified via a relative pathname that begins with the symlink name and ends with that critical file's name. Here, the extraction follows the symlink and overwrites the critical file. This bypasses the protection mechanism of "Member name contains '..'" that would occur for a single TAR archive that attempted to specify the critical file via a ../ approach. For example, the first archive can contain "x -> ../../../../../home/victim/.ssh" and the second archive can contain x/authorized_keys. This can affect server applications that automatically extract any number of user-supplied TAR archives, and were relying on the blocking of traversal. This can also affect software installation processes in which "tar xf" is run more than once (e.g., when installing a package can automatically install two dependencies that are set up as untrusted tarballs instead of official packages).
Disputed tar issue, works as documented per upstream:
https://lists.gnu.org/archive/html/bug-tar/2025-08/msg00012.html
https://github.com/i900008/vulndb/blob/main/Gnu_tar_vuln.md
| Affected range | <=1.34+dfsg-1.2+deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 3.344% | | EPSS Percentile | 87th percentile |
Description
Tar 1.15.1 does not properly warn the user when extracting setuid or setgid files, which may allow local users or remote attackers to gain privileges.
This is intended behaviour, after all tar is an archiving tool and you
need to give -p as a command line flag
|
golang.org/x/net 0.42.0 (golang)
pkg:golang/golang.org/x/net@0.42.0
# minio-release.dockerfile (76:76)
COPY --from=build /build/mc/mc /opt/bitnami/common/bin/mc
| Affected range | <0.45.0 | | Fixed version | 0.45.0 | | EPSS Score | 0.011% | | EPSS Percentile | 1st percentile |
Description
The html.Parse function in golang.org/x/net/html has an infinite parsing loop when processing certain inputs, which can lead to denial of service (DoS) if an attacker provides specially crafted HTML content.
| Affected range | <0.45.0 | | Fixed version | 0.45.0 | | EPSS Score | 0.016% | | EPSS Percentile | 4th percentile |
Description
The html.Parse function in golang.org/x/net/html has quadratic parsing complexity when processing certain inputs, which can lead to denial of service (DoS) if an attacker provides specially crafted HTML content.
|
golang.org/x/net 0.39.0 (golang)
pkg:golang/golang.org/x/net@0.39.0
# minio-release.dockerfile (80:80)
COPY --from=build /build/minio/minio /opt/bitnami/common/bin/minio
| Affected range | <0.45.0 | | Fixed version | 0.45.0 | | EPSS Score | 0.011% | | EPSS Percentile | 1st percentile |
Description
The html.Parse function in golang.org/x/net/html has an infinite parsing loop when processing certain inputs, which can lead to denial of service (DoS) if an attacker provides specially crafted HTML content.
| Affected range | <0.45.0 | | Fixed version | 0.45.0 | | EPSS Score | 0.016% | | EPSS Percentile | 4th percentile |
Description
The html.Parse function in golang.org/x/net/html has quadratic parsing complexity when processing certain inputs, which can lead to denial of service (DoS) if an attacker provides specially crafted HTML content.
|
github.com/eclipse/paho.mqtt.golang 1.5.0 (golang)
pkg:golang/github.com/eclipse/paho.mqtt.golang@1.5.0
# minio-release.dockerfile (80:80)
COPY --from=build /build/minio/minio /opt/bitnami/common/bin/minio
 Numeric Truncation Error
| Affected range | <1.5.1 | | Fixed version | 1.5.1 | | CVSS Score | 6.3 | | CVSS Vector | CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N | | EPSS Score | 0.049% | | EPSS Percentile | 15th percentile |
Description
In Eclipse Paho Go MQTT v3.1 library (paho.mqtt.golang) versions <=1.5.0 UTF-8 encoded strings, passed into the library, may be incorrectly encoded if their length exceeds 65535 bytes. This may lead to unexpected content in packets sent to the server (for example, part of an MQTT topic may leak into the message body in a PUBLISH packet).
The issue arises because the length of the data passed in was converted from an int64/int32 (depending upon CPU) to an int16 without checks for overflows. The int16 length was then written, followed by the data (e.g. topic). This meant that when the data (e.g. topic) was over 65535 bytes then the amount of data written exceeds what the length field indicates. This could lead to a corrupt packet, or mean that the excess data leaks into another field (e.g. topic leaks into message body).
|
 glibc 2.36-9+deb12u13 (deb)
pkg:deb/debian/glibc@2.36-9%2Bdeb12u13?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=2.36-9+deb12u13 | | Fixed version | Not Fixed | | EPSS Score | 0.790% | | EPSS Percentile | 74th percentile |
Description
In the GNU C Library (aka glibc or libc6) through 2.29, check_dst_limits_calc_pos_1 in posix/regexec.c has Uncontrolled Recursion, as demonstrated by '(|)(\1\1)*' in grep, a different issue than CVE-2018-20796. NOTE: the software maintainer disputes that this is a vulnerability because the behavior occurs only with a crafted pattern
| Affected range | <=2.36-9+deb12u13 | | Fixed version | Not Fixed | | EPSS Score | 0.856% | | EPSS Percentile | 75th percentile |
Description
GNU Libc current is affected by: Mitigation bypass. The impact is: Attacker may guess the heap addresses of pthread_created thread. The component is: glibc. NOTE: the vendor's position is "ASLR bypass itself is not a vulnerability.
| Affected range | <=2.36-9+deb12u13 | | Fixed version | Not Fixed | | EPSS Score | 0.646% | | EPSS Percentile | 71st percentile |
Description
GNU Libc current is affected by: Mitigation bypass. The impact is: Attacker may bypass ASLR using cache of thread stack and heap. The component is: glibc. NOTE: Upstream comments indicate "this is being treated as a non-security bug and no real threat.
| Affected range | <=2.36-9+deb12u13 | | Fixed version | Not Fixed | | EPSS Score | 0.313% | | EPSS Percentile | 55th percentile |
Description
GNU Libc current is affected by: Re-mapping current loaded library with malicious ELF file. The impact is: In worst case attacker may evaluate privileges. The component is: libld. The attack vector is: Attacker sends 2 ELF files to victim and asks to run ldd on it. ldd execute code. NOTE: Upstream comments indicate "this is being treated as a non-security bug and no real threat.
| Affected range | <=2.36-9+deb12u13 | | Fixed version | Not Fixed | | EPSS Score | 0.131% | | EPSS Percentile | 33rd percentile |
Description
GNU Libc current is affected by: Mitigation bypass. The impact is: Attacker may bypass stack guard protection. The component is: nptl. The attack vector is: Exploit stack buffer overflow vulnerability and use this bypass vulnerability to bypass stack guard. NOTE: Upstream comments indicate "this is being treated as a non-security bug and no real threat.
| Affected range | <=2.36-9+deb12u13 | | Fixed version | Not Fixed | | EPSS Score | 1.492% | | EPSS Percentile | 81st percentile |
Description
In the GNU C Library (aka glibc or libc6) through 2.29, check_dst_limits_calc_pos_1 in posix/regexec.c has Uncontrolled Recursion, as demonstrated by '(\227|)(\1\1|t1|\\2537)+' in grep.
| Affected range | <=2.36-9+deb12u13 | | Fixed version | Not Fixed | | EPSS Score | 0.394% | | EPSS Percentile | 60th percentile |
Description
The glob implementation in the GNU C Library (aka glibc or libc6) allows remote authenticated users to cause a denial of service (CPU and memory consumption) via crafted glob expressions that do not match any pathnames, as demonstrated by glob expressions in STAT commands to an FTP daemon, a different vulnerability than CVE-2010-2632.
- glibc (unimportant)
- eglibc (unimportant)
That's standard POSIX behaviour implemented by (e)glibc. Applications using
glob need to impose limits for themselves
|
 curl 7.88.1-10+deb12u14 (deb)
pkg:deb/debian/curl@7.88.1-10%2Bdeb12u14?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (53:59)
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
jq \
curl \
procps \
bash \
&& rm -rf /var/lib/apt/lists/*
| Affected range | <=7.88.1-10+deb12u14 | | Fixed version | Not Fixed | | EPSS Score | 0.084% | | EPSS Percentile | 25th percentile |
Description
When doing SSH-based transfers using either SCP or SFTP, and asked to do public key authentication, curl would wrongly still ask and authenticate using a locally running SSH agent.
| Affected range | <=7.88.1-10+deb12u14 | | Fixed version | Not Fixed | | EPSS Score | 0.035% | | EPSS Percentile | 10th percentile |
Description
When doing SSH-based transfers using either SCP or SFTP, and setting the known_hosts file, libcurl could still mistakenly accept connecting to hosts not present in the specified file if they were added as recognized in the libssh global known_hosts file.
| Affected range | <=7.88.1-10+deb12u14 | | Fixed version | Not Fixed | | EPSS Score | 0.007% | | EPSS Percentile | 1st percentile |
Description
When doing multi-threaded LDAPS transfers (LDAP over TLS) with libcurl, changing TLS options in one thread would inadvertently change them globally and therefore possibly also affect other concurrently setup transfers. Disabling certificate verification for a specific transfer could unintentionally disable the feature for other threads as well.
| Affected range | <=7.88.1-10+deb12u14 | | Fixed version | Not Fixed | | EPSS Score | 0.020% | | EPSS Percentile | 5th percentile |
Description
curl's code for managing SSH connections when SFTP was done using the wolfSSH powered backend was flawed and missed host verification mechanisms. This prevents curl from detecting MITM attackers and more.
| Affected range | <=7.88.1-10+deb12u14 | | Fixed version | Not Fixed | | EPSS Score | 0.454% | | EPSS Percentile | 64th percentile |
Description
When libcurl is asked to perform automatic gzip decompression of content-encoded HTTP responses with the CURLOPT_ACCEPT_ENCODING option, using zlib 1.2.0.3 or older, an attacker-controlled integer overflow would make libcurl perform a buffer overflow.
| Affected range | <=7.88.1-10+deb12u14 | | Fixed version | Not Fixed | | EPSS Score | 0.205% | | EPSS Percentile | 43rd percentile |
Description
libcurl skips the certificate verification for a QUIC connection under certain conditions, when built to use wolfSSL. If told to use an unknown/bad cipher or curve, the error path accidentally skips the verification and returns OK, thus ignoring any certificate problems.
|
 openldap 2.5.13+dfsg-5 (deb)
pkg:deb/debian/openldap@2.5.13%2Bdfsg-5?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (53:59)
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
jq \
curl \
procps \
bash \
&& rm -rf /var/lib/apt/lists/*
| Affected range | <=2.5.13+dfsg-5 | | Fixed version | Not Fixed | | EPSS Score | 0.021% | | EPSS Percentile | 6th percentile |
Description
OpenLDAP Lightning Memory-Mapped Database (LMDB) versions up to and including 0.9.14, prior to commit 8e1fda8, contain a heap buffer underflow in the readline() function of mdb_load. When processing malformed input containing an embedded NUL byte, an unsigned offset calculation can underflow and cause an out-of-bounds read of one byte before the allocated heap buffer. This can cause mdb_load to crash, leading to a limited denial-of-service condition.
| Affected range | <=2.5.13+dfsg-5 | | Fixed version | Not Fixed | | EPSS Score | 0.216% | | EPSS Percentile | 44th percentile |
Description
libldap in certain third-party OpenLDAP packages has a certificate-validation flaw when the third-party package is asserting RFC6125 support. It considers CN even when there is a non-matching subjectAltName (SAN). This is fixed in, for example, openldap-2.4.46-10.el8 in Red Hat Enterprise Linux.
| Affected range | <=2.5.13+dfsg-5 | | Fixed version | Not Fixed | | EPSS Score | 6.194% | | EPSS Percentile | 91st percentile |
Description
contrib/slapd-modules/nops/nops.c in OpenLDAP through 2.4.45, when both the nops module and the memberof overlay are enabled, attempts to free a buffer that was allocated on the stack, which allows remote attackers to cause a denial of service (slapd crash) via a member MODDN operation.
| Affected range | <=2.5.13+dfsg-5 | | Fixed version | Not Fixed | | EPSS Score | 0.092% | | EPSS Percentile | 26th percentile |
Description
slapd in OpenLDAP 2.4.45 and earlier creates a PID file after dropping privileges to a non-root account, which might allow local users to kill arbitrary processes by leveraging access to this non-root account for PID file modification before a root script executes a "kill cat /pathname" command, as demonstrated by openldap-initscript.
| Affected range | <=2.5.13+dfsg-5 | | Fixed version | Not Fixed | | EPSS Score | 1.912% | | EPSS Percentile | 83rd percentile |
Description
The nss_parse_ciphers function in libraries/libldap/tls_m.c in OpenLDAP does not properly parse OpenSSL-style multi-keyword mode cipher strings, which might cause a weaker than intended cipher to be used and allow remote attackers to have unspecified impact via unknown vectors.
- openldap (unimportant)
Debian builds with GNUTLS, not NSS
|
 systemd 252.39-1~deb12u1 (deb)
pkg:deb/debian/systemd@252.39-1~deb12u1?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=252.39-1~deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.117% | | EPSS Percentile | 31st percentile |
Description
An issue was discovered in systemd 253. An attacker can modify the contents of past events in a sealed log file and then adjust the file such that checking the integrity shows no error, despite modifications. NOTE: the vendor reportedly sent "a reply denying that any of the finding was a security vulnerability."
| Affected range | <=252.39-1~deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.125% | | EPSS Percentile | 32nd percentile |
Description
An issue was discovered in systemd 253. An attacker can truncate a sealed log file and then resume log sealing such that checking the integrity shows no error, despite modifications. NOTE: the vendor reportedly sent "a reply denying that any of the finding was a security vulnerability."
| Affected range | <=252.39-1~deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.160% | | EPSS Percentile | 37th percentile |
Description
An issue was discovered in systemd 253. An attacker can modify a sealed log file such that, in some views, not all existing and sealed log messages are displayed. NOTE: the vendor reportedly sent "a reply denying that any of the finding was a security vulnerability."
| Affected range | <=252.39-1~deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.042% | | EPSS Percentile | 13th percentile |
Description
systemd, when updating file permissions, allows local users to change the permissions and SELinux security contexts for arbitrary files via a symlink attack on unspecified files.
|
krb5 1.20.1-2+deb12u4 (deb)
pkg:deb/debian/krb5@1.20.1-2%2Bdeb12u4?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (53:59)
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
jq \
curl \
procps \
bash \
&& rm -rf /var/lib/apt/lists/*
| Affected range | <=1.20.1-2+deb12u4 | | Fixed version | Not Fixed | | EPSS Score | 0.081% | | EPSS Percentile | 24th percentile |
Description
Kerberos 5 (aka krb5) 1.21.2 contains a memory leak vulnerability in /krb5/src/lib/gssapi/krb5/k5sealv3.c.
| Affected range | <=1.20.1-2+deb12u4 | | Fixed version | Not Fixed | | EPSS Score | 0.250% | | EPSS Percentile | 48th percentile |
Description
Kerberos 5 (aka krb5) 1.21.2 contains a memory leak in /krb5/src/lib/rpc/pmap_rmt.c.
| Affected range | <=1.20.1-2+deb12u4 | | Fixed version | Not Fixed | | EPSS Score | 1.485% | | EPSS Percentile | 81st percentile |
Description
An issue was discovered in MIT Kerberos 5 (aka krb5) through 1.16. There is a variable "dbentry->n_key_data" in kadmin/dbutil/dump.c that can store 16-bit data but unknowingly the developer has assigned a "u4" variable to it, which is for 32-bit data. An attacker can use this vulnerability to affect other artifacts of the database as we know that a Kerberos database dump file contains trusted data.
|
 util-linux 2.38.1-5+deb12u3 (deb)
pkg:deb/debian/util-linux@2.38.1-5%2Bdeb12u3?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=2.38.1-5+deb12u3 | | Fixed version | Not Fixed | | EPSS Score | 0.007% | | EPSS Percentile | 0th percentile |
Description
A flaw was found in util-linux. This vulnerability allows a heap buffer overread when processing 256-byte usernames, specifically within the setpwnam() function, affecting SUID (Set User ID) login-utils utilities writing to the password database.
| Affected range | <=2.38.1-5+deb12u3 | | Fixed version | Not Fixed | | EPSS Score | 0.025% | | EPSS Percentile | 7th percentile |
Description
A flaw was found in the util-linux chfn and chsh utilities when compiled with Readline support. The Readline library uses an "INPUTRC" environment variable to get a path to the library config file. When the library cannot parse the specified file, it prints an error message containing data from the file. This flaw allows an unprivileged user to read root-owned files, potentially leading to privilege escalation. This flaw affects util-linux versions prior to 2.37.4.
|
jq 1.6-2.1+deb12u1 (deb)
pkg:deb/debian/jq@1.6-2.1%2Bdeb12u1?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (53:59)
RUN apt-get update && apt-get install -y --no-install-recommends \
ca-certificates \
jq \
curl \
procps \
bash \
&& rm -rf /var/lib/apt/lists/*
| Affected range | <=1.6-2.1+deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.026% | | EPSS Percentile | 7th percentile |
Description
A vulnerability was determined in jqlang jq up to 1.6. Impacted is the function run_jq_tests of the file jq_test.c of the component JSON Parser. Executing manipulation can lead to reachable assertion. The attack requires local access. The exploit has been publicly disclosed and may be utilized. Other versions might be affected as well.
| Affected range | <=1.6-2.1+deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.262% | | EPSS Percentile | 50th percentile |
Description
jq is a command-line JSON processor. In versions up to and including 1.7.1, an integer overflow arises when assigning value using an index of 2147483647, the signed integer limit. This causes a denial of service. Commit de21386681c0df0104a99d9d09db23a9b2a78b1e contains a patch for the issue.
|
perl 5.36.0-7+deb12u3 (deb)
pkg:deb/debian/perl@5.36.0-7%2Bdeb12u3?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=5.36.0-7+deb12u3 | | Fixed version | Not Fixed | | EPSS Score | 0.598% | | EPSS Percentile | 69th percentile |
Description
HTTP::Tiny before 0.083, a Perl core module since 5.13.9 and available standalone on CPAN, has an insecure default TLS configuration where users must opt in to verify certificates.
| Affected range | <=5.36.0-7+deb12u3 | | Fixed version | Not Fixed | | EPSS Score | 0.181% | | EPSS Percentile | 40th percentile |
Description
_is_safe in the File::Temp module for Perl does not properly handle symlinks.
|
coreutils 9.1-1 (deb)
pkg:deb/debian/coreutils@9.1-1?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=9.1-1 | | Fixed version | Not Fixed | | EPSS Score | 0.130% | | EPSS Percentile | 32nd percentile |
Description
A flaw was found in GNU Coreutils. The sort utility's begfield() function is vulnerable to a heap buffer under-read. The program may access memory outside the allocated buffer if a user runs a crafted command using the traditional key format. A malicious input could lead to a crash or leak sensitive data.
| Affected range | <=9.1-1 | | Fixed version | Not Fixed | | EPSS Score | 0.056% | | EPSS Percentile | 17th percentile |
Description
In GNU Coreutils through 8.29, chown-core.c in chown and chgrp does not prevent replacement of a plain file with a symlink during use of the POSIX "-R -L" options, which allows local users to modify the ownership of arbitrary files by leveraging a race condition.
|
libgcrypt20 1.10.1-3 (deb)
pkg:deb/debian/libgcrypt20@1.10.1-3?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=1.10.1-3 | | Fixed version | Not Fixed | | EPSS Score | 0.745% | | EPSS Percentile | 73rd percentile |
Description
A timing-based side-channel flaw was found in libgcrypt's RSA implementation. This issue may allow a remote attacker to initiate a Bleichenbacher-style attack, which can lead to the decryption of RSA ciphertexts.
| Affected range | <=1.10.1-3 | | Fixed version | Not Fixed | | EPSS Score | 0.515% | | EPSS Percentile | 67th percentile |
Description
cipher/elgamal.c in Libgcrypt through 1.8.2, when used to encrypt messages directly, improperly encodes plaintexts, which allows attackers to obtain sensitive information by reading ciphertext data (i.e., it does not have semantic security in face of a ciphertext-only attack). The Decisional Diffie-Hellman (DDH) assumption does not hold for Libgcrypt's ElGamal implementation.
|
filippo.io/edwards25519 1.1.0 (golang)
pkg:golang/filippo.io/edwards25519@1.1.0
# minio-release.dockerfile (80:80)
COPY --from=build /build/minio/minio /opt/bitnami/common/bin/minio
 Improper Initialization
| Affected range | <1.1.1 | | Fixed version | 1.1.1 | | CVSS Score | 1.7 | | CVSS Vector | CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N/E:U | | EPSS Score | 0.018% | | EPSS Percentile | 4th percentile |
Description
(*Point).MultiScalarMult failed to initialize its receiver.
If the method was called on an initialized point that is not the identity point, MultiScalarMult produced an incorrect result.
If the method was called on an uninitialized point, the behavior was undefined. In particular, if the receiver was the zero value, MultiScalarMult returned an invalid point that compared Equal to every point.
Note that MultiScalarMult is a rarely used advanced API. For example, if you only depend on filippo.io/edwards25519 via github.com/go-sql-driver/mysql, you are not affected. If you were notified of this issue despite not being affected, consider switching to a vulnerability scanner that is more precise and respectful of your attention, like govulncheck.
|
shadow 1:4.13+dfsg1-1+deb12u1 (deb)
pkg:deb/debian/shadow@1%3A4.13%2Bdfsg1-1%2Bdeb12u1?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=1:4.13+dfsg1-1+deb12u2 | | Fixed version | Not Fixed | | EPSS Score | 0.196% | | EPSS Percentile | 42nd percentile |
Description
initscripts in rPath Linux 1 sets insecure permissions for the /var/log/btmp file, which allows local users to obtain sensitive information regarding authentication attempts. NOTE: because sshd detects the insecure permissions and does not log certain events, this also prevents sshd from logging failed authentication attempts by remote attackers.
- shadow (unimportant)
See #290803, on Debian LOG_UNKFAIL_ENAB in login.defs is set to no so
unknown usernames are not recorded on login failures
|
apt 2.6.1 (deb)
pkg:deb/debian/apt@2.6.1?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=2.6.1 | | Fixed version | Not Fixed | | EPSS Score | 1.509% | | EPSS Percentile | 81st percentile |
Description
It was found that apt-key in apt, all versions, do not correctly validate gpg keys with the master keyring, leading to a potential man-in-the-middle attack.
|
gcc-12 12.2.0-14+deb12u1 (deb)
pkg:deb/debian/gcc-12@12.2.0-14%2Bdeb12u1?os_distro=bookworm&os_name=debian&os_version=12
# minio-release.dockerfile (36:36)
FROM debian:bookworm-slim
| Affected range | <=12.2.0-14+deb12u1 | | Fixed version | Not Fixed | | EPSS Score | 0.050% | | EPSS Percentile | 15th percentile |
Description
libiberty/rust-demangle.c in GNU GCC 11.2 allows stack consumption in demangle_const, as demonstrated by nm-new.
|
