chore(deps): update module golang.org/x/net to v0.45.0 [security]#10
Open
descope[bot] wants to merge 1 commit intomasterfrom
Open
chore(deps): update module golang.org/x/net to v0.45.0 [security]#10descope[bot] wants to merge 1 commit intomasterfrom
descope[bot] wants to merge 1 commit intomasterfrom
Conversation
Author
ℹ Artifact update noticeFile name: go.modIn order to perform the update(s) described in the table above, Renovate ran the
Details:
|
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
from
f5f9210 to
edc97f7
Compare
Author
ℹ️ Artifact update noticeFile name: go.modIn order to perform the update(s) described in the table above, Renovate ran the
Details:
|
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
8 times, most recently
from
b2e832b to
a1d7f37
Compare
![descope-approve[bot]](https://avatars.githubusercontent.com/in/232635?s=60&v=4){kind=small}
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
2 times, most recently
from
f599713 to
afc53f0
Compare
descope
bot
changed the title
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
2 times, most recently
from
e07d126 to
bd18b47
Compare
descope
bot
changed the title
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
2 times, most recently
from
e033043 to
dbc1861
Compare
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
from
dbc1861 to
465d749
Compare
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
from
672f17e to
6bb96b8
Compare
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
from
6bb96b8 to
c22cc66
Compare
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
from
c22cc66 to
7b373e1
Compare
descope
bot
changed the title
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
2 times, most recently
from
18151ae to
5afa98f
Compare
descope
bot
changed the title
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
from
5afa98f to
d5096f7
Compare
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
from
d5096f7 to
d0e5bdf
Compare
descope
bot
changed the title
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
13 times, most recently
from
90bc8a1 to
71ec23c
Compare
descope
bot
force-pushed
the
renovate/go-golang.org-x-net-vulnerability
branch
from
71ec23c to
1ef9571
Compare
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
This PR contains the following updates:
v0.5.0→v0.45.0GitHub Vulnerability Alerts
CVE-2022-41723
A maliciously crafted HTTP/2 stream could cause excessive CPU consumption in the HPACK decoder, sufficient to cause a denial of service from a small number of small requests.
CVE-2023-3978
Text nodes not in the HTML namespace are incorrectly literally rendered, causing text which should be escaped to not be. This could lead to an XSS attack.
CVE-2023-39325
A malicious HTTP/2 client which rapidly creates requests and immediately resets them can cause excessive server resource consumption. While the total number of requests is bounded by the http2.Server.MaxConcurrentStreams setting, resetting an in-progress request allows the attacker to create a new request while the existing one is still executing.
With the fix applied, HTTP/2 servers now bound the number of simultaneously executing handler goroutines to the stream concurrency limit (MaxConcurrentStreams). New requests arriving when at the limit (which can only happen after the client has reset an existing, in-flight request) will be queued until a handler exits. If the request queue grows too large, the server will terminate the connection.
This issue is also fixed in golang.org/x/net/http2 for users manually configuring HTTP/2.
The default stream concurrency limit is 250 streams (requests) per HTTP/2 connection. This value may be adjusted using the golang.org/x/net/http2 package; see the Server.MaxConcurrentStreams setting and the ConfigureServer function.
CVE-2023-44487
HTTP/2 Rapid reset attack
The HTTP/2 protocol allows clients to indicate to the server that a previous stream should be canceled by sending a RST_STREAM frame. The protocol does not require the client and server to coordinate the cancellation in any way, the client may do it unilaterally. The client may also assume that the cancellation will take effect immediately when the server receives the RST_STREAM frame, before any other data from that TCP connection is processed.
Abuse of this feature is called a Rapid Reset attack because it relies on the ability for an endpoint to send a RST_STREAM frame immediately after sending a request frame, which makes the other endpoint start working and then rapidly resets the request. The request is canceled, but leaves the HTTP/2 connection open.
The HTTP/2 Rapid Reset attack built on this capability is simple: The client opens a large number of streams at once as in the standard HTTP/2 attack, but rather than waiting for a response to each request stream from the server or proxy, the client cancels each request immediately.
The ability to reset streams immediately allows each connection to have an indefinite number of requests in flight. By explicitly canceling the requests, the attacker never exceeds the limit on the number of concurrent open streams. The number of in-flight requests is no longer dependent on the round-trip time (RTT), but only on the available network bandwidth.
In a typical HTTP/2 server implementation, the server will still have to do significant amounts of work for canceled requests, such as allocating new stream data structures, parsing the query and doing header decompression, and mapping the URL to a resource. For reverse proxy implementations, the request may be proxied to the backend server before the RST_STREAM frame is processed. The client on the other hand paid almost no costs for sending the requests. This creates an exploitable cost asymmetry between the server and the client.
Multiple software artifacts implementing HTTP/2 are affected. This advisory was originally ingested from the
swift-nio-http2repo advisory and their original conent follows.swift-nio-http2 specific advisory
swift-nio-http2 is vulnerable to a denial-of-service vulnerability in which a malicious client can create and then reset a large number of HTTP/2 streams in a short period of time. This causes swift-nio-http2 to commit to a large amount of expensive work which it then throws away, including creating entirely new
Channels to serve the traffic. This can easily overwhelm anEventLoopand prevent it from making forward progress.swift-nio-http2 1.28 contains a remediation for this issue that applies reset counter using a sliding window. This constrains the number of stream resets that may occur in a given window of time. Clients violating this limit will have their connections torn down. This allows clients to continue to cancel streams for legitimate reasons, while constraining malicious actors.
CVE-2023-45288
An attacker may cause an HTTP/2 endpoint to read arbitrary amounts of header data by sending an excessive number of CONTINUATION frames. Maintaining HPACK state requires parsing and processing all HEADERS and CONTINUATION frames on a connection. When a request's headers exceed MaxHeaderBytes, no memory is allocated to store the excess headers, but they are still parsed. This permits an attacker to cause an HTTP/2 endpoint to read arbitrary amounts of header data, all associated with a request which is going to be rejected. These headers can include Huffman-encoded data which is significantly more expensive for the receiver to decode than for an attacker to send. The fix sets a limit on the amount of excess header frames we will process before closing a connection.
CVE-2025-22870
Matching of hosts against proxy patterns can improperly treat an IPv6 zone ID as a hostname component. For example, when the NO_PROXY environment variable is set to "*.example.com", a request to "[::1%25.example.com]:80` will incorrectly match and not be proxied.
CVE-2025-22872
The tokenizer incorrectly interprets tags with unquoted attribute values that end with a solidus character (/) as self-closing. When directly using Tokenizer, this can result in such tags incorrectly being marked as self-closing, and when using the Parse functions, this can result in content following such tags as being placed in the wrong scope during DOM construction, but only when tags are in foreign content (e.g. , , etc contexts).
golang.org/x/net vulnerable to Uncontrolled Resource Consumption
BIT-golang-2022-41723 / CVE-2022-41723 / GHSA-vvpx-j8f3-3w6h / GO-2023-1571
More information
Details
A maliciously crafted HTTP/2 stream could cause excessive CPU consumption in the HPACK decoder, sufficient to cause a denial of service from a small number of small requests.
Severity
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:HReferences
This data is provided by OSV and the GitHub Advisory Database (CC-BY 4.0).
Denial of service via crafted HTTP/2 stream in net/http and golang.org/x/net
BIT-golang-2022-41723 / CVE-2022-41723 / GHSA-vvpx-j8f3-3w6h / GO-2023-1571
More information
Details
A maliciously crafted HTTP/2 stream could cause excessive CPU consumption in the HPACK decoder, sufficient to cause a denial of service from a small number of small requests.
Severity
Unknown
References
This data is provided by OSV and the Go Vulnerability Database (CC-BY 4.0).
Improper rendering of text nodes in golang.org/x/net/html
CVE-2023-3978 / GHSA-2wrh-6pvc-2jm9 / GO-2023-1988
More information
Details
Text nodes not in the HTML namespace are incorrectly literally rendered, causing text which should be escaped to not be. This could lead to an XSS attack.
Severity
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:NReferences
This data is provided by OSV and the GitHub Advisory Database (CC-BY 4.0).
Improper rendering of text nodes in golang.org/x/net/html
CVE-2023-3978 / GHSA-2wrh-6pvc-2jm9 / GO-2023-1988
More information
Details
Text nodes not in the HTML namespace are incorrectly literally rendered, causing text which should be escaped to not be. This could lead to an XSS attack.
Severity
Unknown
References
This data is provided by OSV and the Go Vulnerability Database (CC-BY 4.0).
HTTP/2 rapid reset can cause excessive work in net/http
BIT-golang-2023-39325 / CVE-2023-39325 / GHSA-4374-p667-p6c8 / GO-2023-2102
More information
Details
A malicious HTTP/2 client which rapidly creates requests and immediately resets them can cause excessive server resource consumption. While the total number of requests is bounded by the http2.Server.MaxConcurrentStreams setting, resetting an in-progress request allows the attacker to create a new request while the existing one is still executing.
With the fix applied, HTTP/2 servers now bound the number of simultaneously executing handler goroutines to the stream concurrency limit (MaxConcurrentStreams). New requests arriving when at the limit (which can only happen after the client has reset an existing, in-flight request) will be queued until a handler exits. If the request queue grows too large, the server will terminate the connection.
This issue is also fixed in golang.org/x/net/http2 for users manually configuring HTTP/2.
The default stream concurrency limit is 250 streams (requests) per HTTP/2 connection. This value may be adjusted using the golang.org/x/net/http2 package; see the Server.MaxConcurrentStreams setting and the ConfigureServer function.
Severity
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:HReferences
This data is provided by OSV and the GitHub Advisory Database (CC-BY 4.0).
HTTP/2 Stream Cancellation Attack
BIT-apisix-2023-44487 / BIT-aspnet-core-2023-44487 / BIT-contour-2023-44487 / BIT-dotnet-2023-44487 / BIT-dotnet-sdk-2023-44487 / BIT-envoy-2023-44487 / BIT-golang-2023-44487 / BIT-jenkins-2023-44487 / BIT-kong-2023-44487 / BIT-nginx-2023-44487 / BIT-nginx-gateway-2023-44487 / BIT-nginx-ingress-controller-2023-44487 / BIT-node-2023-44487 / BIT-node-min-2023-44487 / BIT-solr-2023-44487 / BIT-tomcat-2023-44487 / BIT-varnish-2023-44487 / CVE-2023-44487 / GHSA-qppj-fm5r-hxr3
More information
Details
HTTP/2 Rapid reset attack
The HTTP/2 protocol allows clients to indicate to the server that a previous stream should be canceled by sending a RST_STREAM frame. The protocol does not require the client and server to coordinate the cancellation in any way, the client may do it unilaterally. The client may also assume that the cancellation will take effect immediately when the server receives the RST_STREAM frame, before any other data from that TCP connection is processed.
Abuse of this feature is called a Rapid Reset attack because it relies on the ability for an endpoint to send a RST_STREAM frame immediately after sending a request frame, which makes the other endpoint start working and then rapidly resets the request. The request is canceled, but leaves the HTTP/2 connection open.
The HTTP/2 Rapid Reset attack built on this capability is simple: The client opens a large number of streams at once as in the standard HTTP/2 attack, but rather than waiting for a response to each request stream from the server or proxy, the client cancels each request immediately.
The ability to reset streams immediately allows each connection to have an indefinite number of requests in flight. By explicitly canceling the requests, the attacker never exceeds the limit on the number of concurrent open streams. The number of in-flight requests is no longer dependent on the round-trip time (RTT), but only on the available network bandwidth.
In a typical HTTP/2 server implementation, the server will still have to do significant amounts of work for canceled requests, such as allocating new stream data structures, parsing the query and doing header decompression, and mapping the URL to a resource. For reverse proxy implementations, the request may be proxied to the backend server before the RST_STREAM frame is processed. The client on the other hand paid almost no costs for sending the requests. This creates an exploitable cost asymmetry between the server and the client.
Multiple software artifacts implementing HTTP/2 are affected. This advisory was originally ingested from the
swift-nio-http2repo advisory and their original conent follows.swift-nio-http2 specific advisory
swift-nio-http2 is vulnerable to a denial-of-service vulnerability in which a malicious client can create and then reset a large number of HTTP/2 streams in a short period of time. This causes swift-nio-http2 to commit to a large amount of expensive work which it then throws away, including creating entirely new
Channels to serve the traffic. This can easily overwhelm anEventLoopand prevent it from making forward progress.swift-nio-http2 1.28 contains a remediation for this issue that applies reset counter using a sliding window. This constrains the number of stream resets that may occur in a given window of time. Clients violating this limit will have their connections torn down. This allows clients to continue to cancel streams for legitimate reasons, while constraining malicious actors.
Severity
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N/E:AReferences