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.
Certificate verification can panic when a certificate in the chain has an empty DNS name and another certificate in the chain has excluded name constraints. This can crash programs that are either directly verifying X.509 certificate chains, or those that use TLS.
When verifying a certificate chain which contains a certificate containing multiple email address constraints which share common local portions but different domain portions, these constraints will not be properly applied, and only the last constraint will be considered.
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.
CVE-2025-22873 is a relative path traversal vulnerability in the Go standard library's os package that allows opening the parent directory of a defined root directory by using a filename ending with ".. /". This vulnerability permits access only to the immediate parent directory, not to higher-level ancestors or files within the parent directory. It affects Go versions up to 1.24.0-0 and has a low CVSS score of 3.8, indicating limited impact. Exploitation requires local privileges and no user interaction but can lead to limited confidentiality exposure by allowing directory traversal beyond intended boundaries. No known exploits are currently reported in the wild. European organizations using vulnerable Go versions in applications that enforce directory restrictions via os.
CVE-2025-61728 is a medium severity vulnerability in the Go standard library's archive/zip package, caused by an inefficient super-linear file name indexing algorithm. When a file in a ZIP archive is opened for the first time, this algorithm is triggered, which can be exploited by a maliciously crafted ZIP archive to cause a denial of service (DoS) by consuming excessive CPU resources. The vulnerability affects all versions up to and including Go 1.25.0. Exploitation requires no privileges but does require user interaction to open a ZIP file. There are no known exploits in the wild yet, and no patches have been published at the time of this report. European organizations using Go for processing ZIP archives in network-facing or user-facing applications are at risk of service disruption. Mitigation involves avoiding untrusted ZIP files, implementing resource limits on ZIP processing, and monitoring for abnormal CPU usage. Countries with significant software development industries and critical infrastructure relying on Go, such as Germany, France, and the UK, are more likely to be impacted.
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.
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.
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.
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.
CVE-2025-61725 is a high-severity vulnerability in the Go standard library's net/mail package. The ParseAddress function inefficiently constructs domain-literal address components using repeated string concatenation, which can lead to excessive CPU consumption when processing large domain-literal components. This results in a denial of service condition due to resource exhaustion. The vulnerability affects Go versions up to 1.25.0. No official patch or remediation guidance is currently available, and no known exploits have been reported in the wild.
CVE-2025-61724 is a medium severity vulnerability in the Go standard library's net/textproto package. The Reader.ReadResponse function uses repeated string concatenation to build response strings from multiple lines, causing inefficient algorithmic complexity. This inefficiency can lead to excessive CPU consumption and denial of service due to resource exhaustion. There is no impact on confidentiality or integrity. No patch or official fix has been confirmed yet.
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.
When Conn.Handshake fails during ALPN negotiation the error contains attacker controlled information (the ALPN protocols sent by the client) which is not escaped.
CVE-2025-58188 is a high-severity vulnerability in the Go standard library's crypto/x509 package that causes application crashes during certificate validation. The issue arises when validating certificate chains containing DSA public keys, where an interface cast incorrectly assumes the presence of an Equal method, leading to a panic. This affects Go versions up to and including 1.25.0. No patch or official remediation information is currently available, and no known exploits have been reported in the wild.
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.
CVE-2025-58186 is a medium severity vulnerability in the Go standard library net/http package. It involves uncontrolled resource consumption due to the lack of a limit on the number of cookies parsed, despite an overall HTTP header size limit of 1MB. An attacker can exploit this by sending many small cookies, causing the server to allocate excessive memory and degrade availability.
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.
