A method and system for blocking QUIC connections

By sniffing the initial QUIC message to construct a forged message and using a public key to achieve fine-grained blocking of QUIC connections, this solution addresses the issues of false positives and real-time performance in existing QUIC connection management technologies, providing an efficient and deterministic blocking scheme.

CN123074787APending Publication Date: 2026-11-10SHANGHAI EMBEDWAY INFORMATION TECH
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611259206.5
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-19
Publication Date
2026-11-10

AI Technical Summary

Technical Problem

Existing QUIC connection blocking methods cannot be finely controlled based on specific business/domains, are prone to accidentally damaging normal traffic, and rely on passive timeout mechanisms, resulting in poor real-time and deterministic control, and are unable to deeply intervene in encrypted packets.

Method used

By sniffing the initial QUIC message, a forged retry message or version negotiation message is constructed. The forged message is sent using the public key of the connectionless encrypted transport protocol and arrives at the client before the server response, causing a mismatch in connection identifier or version, thereby blocking the QUIC connection.

Benefits of technology

It enables fine-grained blocking of QUIC connections, reduces the risk of accidentally blocking normal traffic, improves the real-time and deterministic nature of blocking, does not require participation in real key exchange or decryption, has low deployment costs, and is suitable for various network environments.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123074787A_ABST
    Figure CN123074787A_ABST
Patent Text Reader

Abstract

This application relates to the field of network security and traffic control technology, and provides a method and system for blocking QUIC connections. The method includes obtaining the initial message of the target connection, parsing it to obtain the version, destination connection identifier, source connection identifier, client address, and server address; constructing a forged retry message or version negotiation message based on the above information, wherein the integrity tag of the retry message is calculated based on the key publicly available in the protocol standard, and the supported version list of the version negotiation message does not include the version actually used by the client; preemptively sending the forged message to the client with the server address as the source address; the client updates its connection status or version awareness based on the forged message, while the server processes based on the initial message, causing a mismatch in connection identifiers or version inconsistencies between the two parties, resulting in connection establishment failure. This application achieves precise blocking under bypass deployment, does not require participation in key exchange, and can be used for fine-grained traffic control of target services or domains.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This application relates to the fields of network security and traffic control technology, specifically to a method and system for blocking QUIC connections. Background Technology

[0002] With the widespread deployment of HTTP / 3, more and more internet services are beginning to provide services based on the QUIC (Quick UDP Internet Connections) protocol. QUIC runs on top of UDP, integrates TLS 1.3 into the transport layer, and supports features such as connection migration and 0 RTT. In scenarios involving content identification and traffic control in operator networks (such as blocking specific services according to policies), traditional TCP-based connection control methods (such as TCP Reset packet injection) rely on predictable TCP sequence numbers and RST packets that can be forged by third parties. However, most packets in a QUIC connection after the Initial packet are encrypted using AEAD based on a negotiated key. The connection is identified by a Connection ID rather than the traditional source / destination port / sequence number, and it supports connection migration. This makes traditional TCP Reset-type blocking methods unsuitable for QUIC connections, necessitating a new blocking method adapted to the characteristics of the QUIC protocol itself.

[0003] Analysis reveals the following main problems with existing feasible QUIC traffic control methods: 1. Completely discard / rate limit UDP 443 and other common QUIC port traffic: This is a "one-size-fits-all" blocking approach that cannot be finely controlled based on specific business / domain. It is easy to accidentally block a large amount of normal UDP traffic that is not related to the target business. Furthermore, clients can circumvent this type of static port-level control by changing ports.

[0004] 2. Passively waiting for the client to automatically degrade due to connection timeout: QUIC clients usually have a mechanism to time out the connection establishment and try other connection methods when they do not detect a valid response for a long time. However, relying entirely on passive timeout has a long effective period (it needs to wait for the client's own timeout and retry strategy), poor real-time control and determinism, and the timeout strategies implemented by different clients are different, resulting in unstable effects.

[0005] Attempt to participate in real key exchange or to deeply intervene in encrypted messages: Most messages after the Initial message in QUIC (Handshake, 1RTT, etc.) are encrypted using AEAD based on the negotiated key. Bypass-deployed network management devices usually do not have the conditions to participate in real key exchange or obtain session keys, and cannot perform content-level deep intervention and blocking on QUIC connections that have entered the formal handshake or data transmission phase. Summary of the Invention

[0006] To help solve the above-mentioned technical problems, this application provides a method and system for blocking QUIC connections.

[0007] In a first aspect, this application provides a method for blocking a QUIC connection, comprising: Obtain the initial message of the target connection; Parse the initial message to obtain the version of the initial message, the destination connection identifier, the source connection identifier, the client address, and the server address; Based on the version, the destination connection identifier, and the source connection identifier, construct a forged retry message or version negotiation message; The integrity tag of the retry message is calculated based on the key published by the connectionless encrypted transport protocol standard, and the destination connection identifier of the retry message is set as the source connection identifier of the initial message. The supported version list of the version negotiation message does not include the version actually used by the initial message; Using the server address as the source address, the forged message is sent to the client, and the forged message arrives at the client before the server's real response. The client updates its connection status or version awareness based on the forged message, while the server processes the initial message, causing the connection identifier used by the client to mismatch with the connection identifier used by the server, or the version used by the client to be inconsistent with the version used by the server, resulting in connection establishment failure.

[0008] The connectionless encrypted transmission protocol is an encrypted transmission protocol based on the User Datagram Protocol, and its initial message has a long header format. The initial message for obtaining the target connection includes: The blocking device sniffs transport layer messages carrying the connectionless encrypted transmission protocol; Identify messages that conform to the long header format and determine that the message is an initial message.

[0009] Before constructing the forged retry message or version negotiation message based on the version, the destination connection identifier, and the source connection identifier, the method further includes: Decrypt the transport layer security handshake message carried in the initial message and extract the server name indication; Based on the server name indication, determine whether the target connection hits the preset target service or domain name blocking policy; The step of constructing the forged message is performed only when the target service or domain name blocking policy is hit.

[0010] The constructed forged retry message includes: Set the destination connection identifier of the retry message to the source connection identifier of the initial message; Set the source connection identifier of the retry message to the specified identifier; The integrity tag of the retry message is calculated using the key disclosed in the connectionless encrypted transport protocol standard.

[0011] The constructed forged version negotiation message includes: Set the version field of the version negotiation message to the reserved value of zero; Set the supported version list of the version negotiation message to exclude the version actually used by the initial message.

[0012] After receiving the retry message, the client updates the destination connection identifier of the target connection to the source connection identifier in the retry message, and resends the initial message based on the updated destination connection identifier. When the client subsequently receives a response from the server based on the initial message, the updated destination connection identifier of the client does not match the destination connection identifier in the server's response, or the original destination connection identifier returned by the server does not match the destination connection identifier of the initial message, causing the connection establishment to fail.

[0013] After receiving the version negotiation message, the client enters the version negotiation process and assumes that the server does not support the version currently used by the client. The server still processes and responds according to the version actually used in the initial message. The version used by the client is inconsistent with the version used by the server, causing the connection establishment to fail.

[0014] The forged message is sent in a bypass manner, which does not prevent the server's real response from reaching the client. The connection is blocked only by making the forged message arrive at the client before the server's real response.

[0015] After the target connection fails to be established, the client automatically downgrades to a connection based on a connection-oriented transport protocol. By combining control measures at the connection-oriented transport protocol, transport layer security, and / or domain name system level, the target services can be managed collaboratively.

[0016] Secondly, this application provides a QUIC connection blocking system, which includes a client, a server, and a blocking device deployed in a bypass manner; The client is used to send an initial message for the target connection to the server; The bypass-deployed blocking device includes a sniffing and identification module, a message construction module, and a back injection module; The sniffing and identification module is used to acquire the initial message, parse the initial message, and obtain the version, destination connection identifier, source connection identifier, client address, and server address of the initial message; The message construction module is used to construct a forged retry message or version negotiation message based on the version, the destination connection identifier, and the source connection identifier. The integrity tag of the retry message is calculated based on the key published by the connectionless encrypted transport protocol standard, and the destination connection identifier of the retry message is set to the source connection identifier of the initial message. The supported version list of the version negotiation message does not include the version actually used by the initial message; The injection module is used to send the forged message to the client using the server address as the source address, and to make the forged message arrive at the client before the server's real response. The client is also used to update the connection status or version awareness based on the forged message; The server is used to process the initial message; The client updates its connection status or version recognition based on the forged message, while the server processes the initial message, causing the connection identifier used by the client to mismatch with the connection identifier used by the server, or the version used by the client to be inconsistent with the version used by the server, resulting in connection establishment failure.

[0017] In summary, compared with the prior art, this application has the following advantages: 1. It can effectively block QUIC connections without participating in real key exchange or having the ability to decrypt formal handshake / data packets. It makes full use of the control message mechanism based on public keys or without integrity protection designed by the QUIC protocol in the handshake initial stage to ensure availability.

[0018] 2. Pure bypass deployment requires no modification to the existing network forwarding path. It only needs to have traffic mirroring / sniffing and active packet injection capabilities, resulting in low deployment costs and minimal impact on the existing network.

[0019] 3. By combining the protocol feature of decrypting and extracting SNI from QUIC Initial messages, fine-grained blocking at the target service / domain level can be achieved, avoiding collateral damage caused by "one-size-fits-all" discarding / rate limiting.

[0020] 4. By competing for time to reach the client before the server's actual response arrives, proactive and deterministic real-time blocking is achieved, rather than relying on the client's passive timeout and degradation, resulting in better control over real-time performance and determinism.

[0021] 5. The Retry and VN blocking mechanisms complement each other, covering the processing differences of different QUIC versions and client implementations, and improving the overall blocking success rate.

[0022] 6. It has been verified to be effective in both fixed and mobile network environments (including GTP tunnel encapsulation scenarios) and has good applicability across network types.

[0023] 7. The phenomenon of "client applications automatically downgrading to TCP / TLS after QUIC blocking" was revealed and utilized, providing a connection point for subsequent collaboration with traditional protocol control methods to form a multi-dimensional and three-dimensional control system. Attached Figure Description

[0024] Figure 1 This is a schematic diagram of the overall architecture of the QUIC connection blocking system; Figure 2 A timing diagram for implementing QUIC connection blocking based on forged Retry messages; Figure 3 for Figure 2 First enlarged partial schematic diagram; Figure 4 for Figure 2 Second enlarged schematic diagram; Figure 5 A timing diagram for implementing QUIC connection blocking based on forged VN messages; Figure 6 for Figure 5 First enlarged partial schematic diagram; Figure 7 for Figure 5 The second enlarged schematic diagram. Detailed Implementation

[0025] The present application will be further described below with reference to the accompanying drawings. The structure and principle of the present application are very clear to those skilled in the art. It should be understood that the specific embodiments described herein are merely illustrative of the present application and are not intended to limit the present application.

[0026] The technical terms, full English names, and corresponding abbreviations used in the embodiments of this application are uniformly explained as follows, and abbreviations will be used preferentially in the following text: Quick UDP Internet Connections (QUIC)

[0027] User Datagram Protocol (UDP)

[0028] Transport Layer Security (TLS)

[0029] Server Name Indication (SNI)

[0030] Destination Connection Identifier (DCID)

[0031] Source Connection Identifier (SCID)

[0032] Version Negotiation (VN)

[0033] Internet Engineering Task Force (IETF).

[0034] Internet standard document for requesting comments: Request for Comments (RFC).

[0035] Retry Integrity Tag.

[0036] Initial handshake message: Initial Packet, or simply Initial message.

[0037] Retry Packet, or simply Retry message.

[0038] Version Negotiation Packet (VN) is a type of communication message used for version negotiation.

[0039] Original destination connection identifier: original_destination_connection_id, abbreviated as ODCID.

[0040] Transmission parameter error: TRANSPORT_PARAMETER_ERROR, the error code for mismatched transmission parameters in the QUIC protocol.

[0041] Supported version list: supported_versions, a field in the version negotiation message that carries the set of supported versions.

[0042] The packet sniffing and re-injection module, pcap_reinjector, is a module that implements packet capture, construction, and re-injection functions.

[0043] Scapy is a general-purpose tool for network packet processing, including packet construction, transmission, and sniffing.

[0044] Asynchronous QUIC protocol implementation: aioquic, a QUIC protocol stack implementation based on an asynchronous framework.

[0045] Fallback mechanism: A mechanism that automatically switches to other protocols or versions after a connection failure.

[0046] Frontend: Frontend.

[0047] Message Bus.

[0048] Backend: Backend.

[0049] Security module: Security.

[0050] The protocol rules upon which this application is based are all derived from the following publicly available IETF standard documents and are considered well-known technologies in this field: 1.IETF RFC 9000 "QUIC: A UDPBased Multiplexed and Secure Transport".

[0051] 2. IETF RFC 9001 "Using TLS to Secure QUIC" (see Section 5.8 for the Retry Integrity Tag calculation rules).

[0052] 3.IETF RFC 8446 "The Transport Layer Security (TLS) Protocol Version1.3".

[0053] Figure 1This is a schematic diagram of the overall architecture of the QUIC connection blocking system. The legend indicates the Frontend module (light blue), Message Bus module (orange), Backend module (light green), and Security module (light red). The left side of the diagram shows the QUIC Client frontend node, running Chrome / quicgo and supporting QUIC protocol versions v1 and draft29. The right side shows the QUIC Server backend node, running aioquic / quicgo with a 500ms response delay. The overall interaction flow is as follows: Step 1, the QUIC Client sends an Initial message to the server, carried on UDP ports 4433 / 4242; Step 2, the Initial message is delivered to the QUIC server via the normal network path. On the server side, there is a transmission and processing delay of approximately 500ms. Simultaneously, the bypass-deployed blocking device control plane (security module) sniffs and captures Initial packets in the link. The pcap_reinjector module within it processes these packets using scapy's sniffing and sending capabilities, supporting the construction of Retry and VN control packets. In step 4, the module generates a forged Retry / VN packet, disguising it as a server response and injecting it back to the client. In step 5, the forged packet is preemptively delivered to the QUIC Client. After the server completes processing, it returns the real response according to the normal process. Due to the server's delay, the forged packet arrives at the client before the real response, ultimately inducing the client to accept the forged packet and causing a connection status anomaly. The diagram below also labels the blocking paths and defense aids: There are four blocking paths, namely sniffing the Initial message from the client to the server, constructing a forged Retry / VN control packet in real time, sending it to the client before the server's real response, and the client receiving the forged packet, causing connection anomalies; There are three defense aids, namely setting the initialpacketdelayms 500 parameter through server.py, delaying the server response to expand the contention window, and using aioquic's SCID verification as a secondary defense.

[0054] The QUIC connection blocking system described in this application includes a client, a server, and a blocking device deployed in a bypass manner.

[0055] The client is the terminal device that initiates the QUIC connection. It can run browsers, applications, etc. that support the QUIC protocol and is used to send an Initial message to the server to initiate a connection establishment request.

[0056] The server is the target service provider for the QUIC connection, used to respond to the client's connection request, complete the QUIC handshake, and provide the corresponding business services.

[0057] The blocking device is deployed in a bypass configuration along the network path between the client and server. It can obtain QUIC traffic in the link through traffic mirroring without requiring modification of the existing network forwarding path. The blocking device includes a sniffing and identification module, a packet construction module, and a back-injection module. The sniffing and identification module is used to obtain the Initial message of the target connection, parse the Initial message to obtain the protocol version, DCID, SCID, client address and server address of the message; it can also be used to decrypt the TLS handshake message carried in the Initial message, extract the SNI and match the blocking policy.

[0058] The message construction module is used to construct forged Retry messages or VN messages based on the parsed version, DCID, and SCID. The Retry Integrity Tag of the Retry message is calculated based on the key published by the QUIC protocol standard, and the supported version list of the VN message does not include the version actually used by the client.

[0059] The back-injection module is used to send a constructed forged message to the client using the server address as the source address, and controls the forged message to arrive at the client before the server's real response.

[0060] Figure 2This diagram illustrates the timing interaction for blocking QUIC connections based on a forged Retry message. It includes three participating entities: the blue Client, the red Injector (injection / blocking device), and the green Server. The complete interaction process is as follows: The Client first sends an Initial message carrying DCID=X and SCID=Y to the Server. The Injector sniffs and captures this Initial message, then calculates the Integrity. The tag is used to construct a forged Retry message. The SCID of this forged Retry message is set to a specified identifier value. The Injector preemptively sends this forged Retry message to the Client. After receiving the forged Retry message and verifying it, the Client updates its local connection identifier and resends a NewInitial message using the new DCID. This resent Initial message carries the original_destination_connection_id field as the original DCID. At the same time, the Server receives the original Initial message initially sent by the Client and processes it normally, returning a response to the Client. After receiving the server's response, the Client encounters a connection identifier mismatch and original_destination_connection_id verification failure, triggering a TRANSPORT_PARAMETER_ERROR error, ultimately causing the QUIC connection establishment to fail. The diagram below also highlights the key blocking points and verification data: The key blocking points are: the Retry Integrity Tag uses the RFC9001 public key; the client fully trusts the Retry packet after verifying the Tag; and the connection is rejected due to a mismatch in the server's ODCID verification. The verification data includes a packet capture example from 500msblock.pcap, where frame 3 is the Retry packet, frame 4 is the new DCID, the response delay is 503.47ms, and the injected packet arrives at t+23.5ms.

[0061] Figure 3 and Figure 4 They are respectively Figure 2 The upper and lower parts.

[0062] Based on the above timing sequence, the blocking process in this embodiment specifically includes the following steps: S101: The blocking device sniffs UDP packets carrying the QUIC protocol in the target network (in this embodiment, it may be a commonly used QUIC port such as UDP 443), identifies packets that conform to the QUIC Long Header format characteristics, and determines them to be Initial packets; it parses the Initial packets and extracts the protocol version, DCID, SCID, and the corresponding client network address and server network address of the packets.

[0063] S102: The blocking device calculates the initial key (Initial Secret) based on the DCID of the Initial message and the key derivation algorithm published by the QUIC protocol standard. It decrypts the TLS ClientHello handshake message carried in the Initial message and extracts the SNI information from it. Based on the extracted SNI, it determines whether the current QUIC connection hits the preset target service or domain name blocking policy. If the blocking policy is not hit, no further operations are performed on the connection. If the blocking policy is hit, proceed to step S103.

[0064] S103: The blocking device constructs a forged Retry message conforming to the QUIC protocol specification. The specific construction rules are as follows: Set the DCID of the Retry message to the SCID in the original Initial message of the client; Set the SCID of the Retry message to the default identifier of the blocking device; Based on the public key specified in RFC 9001, the Retry Integrity Tag of the Retry message is calculated to ensure that forged messages can pass the client's integrity verification.

[0065] S104: The blocking device actively injects a forged Retry message, constructed using the server's network address as the source address and the client's network address as the destination address, back into the client. During the injection process, it ensures that the forged message arrives at the client before the server's genuine response message. In this embodiment, the blocking device adopts a bypass deployment method, neither intercepting nor preventing the server's genuine response message from reaching the client, but only using a time-competition mechanism to ensure that the forged message arrives at the client first to achieve the blocking effect.

[0066] S105: After receiving the forged Retry message, the client performs an integrity check on the message. Since the RetryIntegrity Tag is calculated based on the protocol's public key and passes the check, the client determines that the Retry message is legitimate. It then updates the DCID of the current connection to the SCID carried in the Retry message and resends the Initial message using the updated DCID. The resent Initial message carries the original DCID as the original_destination_connection_id parameter for verification during subsequent handshake phases.

[0067] Meanwhile, the server did not send the Retry message and continued to process the original Initial message sent by the client normally, returning a response. At this point, the client and server were operating independently based on different connection identifier states.

[0068] When the client subsequently receives a response message from the server based on the original connection state, it will trigger a TRANSPORT_PARAMETER_ERROR transmission parameter error due to a mismatch in the connection identifier and inconsistency in the validation of the original_destination_connection_id parameter during the handshake phase. Ultimately, this will cause the QUIC handshake to fail, the connection establishment to fail, and the target QUIC connection to be blocked.

[0069] Figure 5The diagram illustrates the timing interaction for blocking QUIC connections based on a forged VN (Version Negotiation) message. It includes three participating entities: the blue Client, the red Injector (injection / blocking device), and the green Server. The complete interaction process is as follows: The Client first sends an Initial message of version v1 to the Server. The Injector sniffs and captures this Initial message, then constructs a forged Version Negotiation message. The version field of this forged VN message is 0, and the supported_versions list does not contain the v1 version currently used by the client. The Injector preempts the timing, sending the forged VN message to the Client first. Since the VN message itself lacks integrity protection, the client cannot verify the authenticity of the message source. Upon receiving the forged VN message, the client checks the version list, determines that the original version is not included, enters the version negotiation process, switches to another protocol version in the supported_versions list, and sends the corresponding new version's New message. Initial message; simultaneously, the server receives the initial v1 Initial message sent by the client, processes it normally according to v1 version, and returns a response; after receiving this response, the client triggers a VERSION_NEGOTIATION_ERROR error due to protocol version mismatch, ultimately causing the QUIC connection to fail to establish. The diagram below highlights the key points of blocking and the fallback mechanism: the key point of blocking is that the lack of integrity protection for VN packets is a design feature of the protocol; crucially, the version list does not include the client's original version; the fallback mechanism explains that automatic fallback occurs when the Retry version is not supported, and VN downgrade fallback can be enabled via the fallbacktovn parameter, which can be verified by vnfallback.pcap.

[0070] Figure 6 and Figure 7 They are respectively Figure 5 The upper and lower parts.

[0071] Based on the above timing sequence, in the blocking process of this embodiment, steps S201 (sniffing and identifying Initial packets) and S202 (matching blocking strategies) are completely consistent with those in Embodiment 1, and will not be repeated here; after the blocking strategy is matched, the following steps are executed: S203: The blocking device constructs a forged VN message conforming to the QUIC protocol specification. The specific construction rules are as follows: Set the version field of the VN message to the reserved value of 0 specified in the protocol; Configure the supported_versions list of the message to exclude the protocol version actually used by the client's Initial message.

[0072] S204: The blocking device uses the server's network address as the source address to actively inject forged VN packets back to the client, and ensures that the forged packets arrive at the client before the server's real response.

[0073] S205: Since the VN message itself does not have integrity protection, the client cannot verify the authenticity of the message. After receiving a forged VN message, it enters the version negotiation process and determines that the server does not support the QUIC protocol version it is currently using.

[0074] Meanwhile, the server still processes the original Initial message according to its protocol version and returns a response. The client and server disagree on the protocol version, failing to reach an agreement, ultimately triggering a version negotiation error, causing the QUIC connection to fail and resulting in a blocking effect.

[0075] Based on the above technical solution, when the target QUIC connection fails to be established, the client application typically triggers a fallback mechanism automatically, downgrading to attempt to continue accessing the target service via a TLS connection carried by a connection-oriented TCP protocol. At this point, traditional control methods at the TCP / TLS layer and the Domain Name System layer can be combined to perform multi-dimensional collaborative control of the target service, forming a comprehensive traffic control system and improving the overall control effect of the target service. The technical solution of this application is applicable to various network environments such as fixed-line and mobile networks, and has good cross-network type applicability.

[0076] The technical scope of this application is not limited to the contents of the above specification. Those skilled in the art can make various modifications and variations to the above embodiments without departing from the technical concept of this application, and all such modifications and variations should fall within the scope of this application.

Claims

1. A method for blocking a QUIC connection, characterized in that, include: Obtain the initial message of the target connection; Parse the initial message to obtain the version of the initial message, the destination connection identifier, the source connection identifier, the client address, and the server address; Based on the version, the destination connection identifier, and the source connection identifier, construct a forged retry message or version negotiation message; The integrity tag of the retry message is calculated based on the key published by the connectionless encrypted transport protocol standard, and the destination connection identifier of the retry message is set as the source connection identifier of the initial message. The supported version list of the version negotiation message does not include the version actually used by the initial message; Using the server address as the source address, the forged message is sent to the client, and the forged message arrives at the client before the server's real response. The client updates its connection status or version awareness based on the forged message, while the server processes the initial message, causing the connection identifier used by the client to mismatch with the connection identifier used by the server, or the version used by the client to be inconsistent with the version used by the server, resulting in connection establishment failure.

2. The method according to claim 1, characterized in that, The connectionless encrypted transmission protocol is an encrypted transmission protocol based on the User Datagram Protocol, and its initial message has a long header format. The initial message for obtaining the target connection includes: The blocking device sniffs transport layer messages carrying the connectionless encrypted transmission protocol; Identify messages that conform to the long header format and determine that the message is an initial message.

3. The method according to claim 1, characterized in that, Before constructing the forged retry message or version negotiation message based on the version, the destination connection identifier, and the source connection identifier, the method further includes: Decrypt the transport layer security handshake message carried in the initial message and extract the server name indication; Based on the server name indication, determine whether the target connection hits the preset target service or domain name blocking policy; The step of constructing the forged message is performed only when the target service or domain name blocking policy is hit.

4. The method according to claim 1, characterized in that, The constructed forged retry message includes: Set the destination connection identifier of the retry message to the source connection identifier of the initial message; Set the source connection identifier of the retry message to the specified identifier; The integrity tag of the retry message is calculated using the key disclosed in the connectionless encrypted transport protocol standard.

5. The method according to claim 1, characterized in that, The constructed forged version negotiation message includes: Set the version field of the version negotiation message to the reserved value of zero; Set the supported version list of the version negotiation message to exclude the version actually used by the initial message.

6. The method according to claim 1, characterized in that, After receiving the retry message, the client updates the destination connection identifier of the target connection to the source connection identifier in the retry message, and resends the initial message based on the updated destination connection identifier. When the client subsequently receives a response from the server based on the initial message, the updated destination connection identifier of the client does not match the destination connection identifier in the server's response, or the original destination connection identifier returned by the server does not match the destination connection identifier of the initial message, causing the connection establishment to fail.

7. The method according to claim 1, characterized in that, After receiving the version negotiation message, the client enters the version negotiation process and assumes that the server does not support the version currently used by the client. The server still processes and responds according to the version actually used in the initial message. The version used by the client is inconsistent with the version used by the server, causing the connection establishment to fail.

8. The method according to claim 1, characterized in that, The forged message is sent in a bypass manner, which does not prevent the server's real response from reaching the client. The connection is blocked only by making the forged message arrive at the client before the server's real response.

9. The method according to claim 1, characterized in that, After the target connection fails to be established, the client automatically downgrades to a connection based on a connection-oriented transport protocol. By combining control measures at the connection-oriented transport protocol, transport layer security, and / or domain name system level, the target services can be managed collaboratively.

10. A QUIC connection blocking system, characterized in that, This includes blocking devices deployed on the client side, server side, and in bypass mode; The client is used to send an initial message for the target connection to the server; The bypass-deployed blocking device includes a sniffing and identification module, a message construction module, and a back injection module; The sniffing and identification module is used to acquire the initial message, parse the initial message, and obtain the version, destination connection identifier, source connection identifier, client address, and server address of the initial message; The message construction module is used to construct a forged retry message or version negotiation message based on the version, the destination connection identifier, and the source connection identifier. The integrity tag of the retry message is calculated based on the key published by the connectionless encrypted transport protocol standard, and the destination connection identifier of the retry message is set to the source connection identifier of the initial message. The supported version list of the version negotiation message does not include the version actually used by the initial message; The injection module is used to send the forged message to the client using the server address as the source address, and to make the forged message arrive at the client before the server's real response. The client is also used to update the connection status or version awareness based on the forged message; The server is used to process the initial message; The client updates its connection status or version recognition based on the forged message, while the server processes the initial message, causing the connection identifier used by the client to mismatch with the connection identifier used by the server, or the version used by the client to be inconsistent with the version used by the server, resulting in connection establishment failure.