Methods and systems for detecting network outbound attacks
By executing network event callbacks and performing HTTP handle consistency checks in the scenario of task delivery from a thread pool, the original business thread identifier is obtained, which solves the problem of not being able to identify the initiator of network requests in the scenario of task delivery from a thread pool, and realizes accurate detection of network external attack.
Patent Information
- Application Number
- CN202611177064.8
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-04
- Publication Date
- 2026-11-17
AI Technical Summary
In scenarios where tasks are delivered via thread pools, existing technologies cannot accurately identify the initiating thread of network requests, resulting in an inability to effectively detect external network attacks.
By executing network event callbacks, the thread-local storage TLS is obtained, the thread structure object ThreadInfo is found, HTTP handle consistency verification is performed, and the original business thread identifier is obtained using a preset offset to perform malicious attack detection.
In scenarios where tasks are delivered via thread pools, the system can accurately trace back to the original business thread that initiated the network outreach behavior, thereby improving the accuracy of identifying and defending against network outreach attacks.
Smart Images

Figure CN123122877A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of network security technology, and in particular to a method and system for detecting network external attacks. Background Technology
[0002] Existing endpoint security technologies monitor the behavior triggered by a target program. If a program contains a valid digital signature, its behavior is considered secure.
[0003] In stack backtracking-based detection techniques, it is necessary to detect whether the request comes from malicious code (shellcode) based on the thread stack that initiated the network request. However, in existing endpoint security protection software systems such as EDR and XDR, the network request API SendHttpRequest has been using a thread pool to deliver tasks since Win10. This means that the thread that calls SendHttpRequest and the thread that triggers the network request are not the same thread. In the end, when backtracking the stack, what is obtained is a thread pool thread with a normal stack, so it cannot be accurately identified. Summary of the Invention
[0004] This invention provides a method and system for detecting network outbound attacks. In scenarios where tasks are delivered using a thread pool, the method can accurately trace the source of the network outbound behavior back to the original business thread that initiated it, thereby accurately identifying whether a network outbound attack exists.
[0005] On one hand, embodiments of the present invention provide a method for detecting network outbound attacks, including: In response to the detection of network outreach, a network event callback is executed. Based on the information returned by the network event callback, obtain the thread-local storage TLS of the current thread; The thread structure object ThreadInfo is retrieved from the thread-local storage TLS, and the thread structure object ThreadInfo stores thread-specific business context information; Based on the ThreadInfo structure object, find the HTTP handle corresponding to the network event; If an HTTP handle is found, a consistency check is performed on the HTTP handle. If the consistency check passes, based on the HTTP handle and the first preset offset, the original business thread corresponding to the original business thread identifier TID is obtained. The original business thread is the thread that initiated the network outbound behavior. The first preset offset is the byte offset of the original business thread identifier TID of the structure member relative to the starting address of the structure. Malicious attack detection is performed on the original business thread to determine whether it belongs to an external network attack.
[0006] Optionally, after obtaining the thread-local storage TLS of the current thread, the method further includes: Enumerate the thread-local storage (TLS) array of the current thread; Perform validity verification on the thread structure object ThreadInfo corresponding to any of the thread-local storage TLS arrays, wherein the validity verification includes verification based on at least one of magic number, memory signature and pointer boundary; If the validity check passes, then enumerate the ThreadInfo linked list of thread structure objects; If the validity check fails, continue to the next thread to store the TLS array locally, until all the TLS arrays stored locally by the current thread are traversed.
[0007] Optionally, the nodes of the ThreadInfo linked list of the thread structure object store the thread identifier TID, HTTP handle, and context offset fields. Consistency verification is performed on the HTTP handle, including: Determine whether the HTTP handle value stored inside the node of the ThreadInfo linked list of the thread structure object is the same as the HTTP handle value stored in the cache; If they are the same, the HTTP handle consistency check is considered to have passed; if they are different, the HTTP handle consistency check is considered to have failed.
[0008] Optionally, the method further includes: If the HTTP handle is not found, the current thread identifier (TID) is obtained at the position offset by the first preset offset. Obtain the HTTP handle based on the current thread identifier TID and the second preset offset.
[0009] Optionally, for 64-bit Windows, with default memory alignment and unchanged structure member order, the first preset offset is 0x10 and the second preset offset is 0x38.
[0010] Optionally, the method further includes: Register a callback function for executing the network event callback. When the system detects that the process has performed the network outbound behavior, it automatically triggers the execution of the registered callback function and passes all the parameters of the network event corresponding to the network outbound behavior to the callback function to obtain the information returned by the network event callback. The network outbound behavior includes at least one of the following: initiating an HTTP request, creating a connection, sending and receiving data, disconnecting a socket, and creating a new HTTP handle.
[0011] Optionally, performing malicious attack detection on the original business thread to determine whether it belongs to an external network attack includes: Perform at least one of the following malicious attack detections on the original business thread: thread call stack analysis, network request communication content auditing, process linkage behavior monitoring, process memory feature scanning, and network behavior baseline comparison. Based on the detection results, determine whether the aforementioned network outreach behavior constitutes a network outreach attack.
[0012] On the other hand, embodiments of the present invention provide a network outreach attack detection system, comprising: The execution module is used to execute network event callbacks when network outreach behavior is detected. The first acquisition module is used to acquire the thread-local storage TLS of the current thread based on the information returned by the network event callback; The first lookup module is used to look up a thread structure object ThreadInfo from the thread-local storage TLS, wherein the thread structure object ThreadInfo stores thread-specific business context information; The second lookup module is used to look up the HTTP handle corresponding to the network event based on the thread structure object ThreadInfo; The verification module is used to perform a consistency verification on the HTTP handle after it is found. The second acquisition module is used to acquire the original business thread corresponding to the original business thread identifier TID based on the HTTP handle and the first preset offset after the consistency check passes. The original business thread is the thread that initiates the network outbound behavior. The first preset offset is the byte offset of the original business thread identifier TID of the structure member relative to the starting address of the structure. The detection module is used to perform malicious attack detection on the original business thread to determine whether it belongs to an external network attack.
[0013] Thirdly, embodiments of the present invention provide an electronic device, including: a memory and a processor, wherein the memory and the processor are connected; Memory, used to store computer programs; A processor is used to invoke a computer program stored in memory to perform any of the above methods.
[0014] Fourthly, embodiments of the present invention provide a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when run by a computer, performs any of the methods described above.
[0015] The network outbound attack detection method and system provided in this invention, in response to detecting network outbound behavior, executes a network event callback; based on the information returned by the network event callback, obtains the thread-local storage TLS of the current thread; searches for a thread structure object ThreadInfo in the thread-local storage TLS, the thread structure object ThreadInfo storing thread-specific business context information; based on the thread structure object ThreadInfo, searches for the HTTP handle corresponding to the network event; if the HTTP handle is found, performs a consistency check on the HTTP handle; if the consistency check passes, based on the HTTP handle and a first preset offset, obtains the original business thread corresponding to the original business thread identifier TID, the original business thread being the thread that initiated the network outbound behavior, the first preset offset being the byte offset of the original business thread identifier TID relative to the structure's starting address; performs malicious attack detection on the original business thread to determine whether it belongs to a network outbound attack. This method and system, in scenarios using thread pools to deliver tasks, can accurately trace back to the original business thread that initiated the network outbound behavior, thereby accurately identifying whether a network outbound attack exists. Attached Figure Description
[0016] To more clearly illustrate the technical solutions in this invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.
[0017] Figure 1 A flowchart illustrating a method for detecting network outbound attacks provided in an embodiment of the present invention; Figure 2 A flowchart illustrating another method for detecting network outbound attacks provided in an embodiment of the present invention; Figure 3 This is a block diagram of a network outbound attack detection system provided in an embodiment of the present invention. Detailed Implementation
[0018] To make the objectives, technical solutions, and advantages of this invention clearer, the technical solutions of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of this invention. All other embodiments obtained by those skilled in the art based on the embodiments of this invention without creative effort are within the scope of protection of this invention.
[0019] The terms "first," "second," etc., used in this invention are used to distinguish similar objects and not to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that embodiments of the invention can be implemented in orders other than those illustrated or described herein, and that the objects distinguished by "first," "second," etc., are generally of the same class.
[0020] The following is a brief explanation of the proper nouns and terms used in this patent application: SendHttpRequest: A Windows programming API for sending network requests, often used by Trojan viruses for external network connections; Thread pool: A code execution optimization mechanism that improves code execution performance and reduces system overhead.
[0021] The technical solution of this patent application will be explained and described below with reference to specific embodiments.
[0022] One embodiment of this patent application provides a method for detecting network outbound attacks, such as... Figure 1 As shown, the method includes steps 101-107: Step 101: In response to the detection of network outreach, execute the network event callback; Step 102: Based on the information returned by the network event callback, obtain the thread-local storage TLS of the current thread; Step 103: Locate the thread structure object ThreadInfo in the Thread Local Storage (TLS), where the thread structure object ThreadInfo stores thread-specific business context information; Step 104: Based on the ThreadInfo structure object, find the HTTP handle corresponding to the network event; Step 105: If an HTTP handle is found, perform a consistency check on the HTTP handle; Step 106: If the consistency check passes, based on the HTTP handle and the first preset offset, obtain the original business thread (also known as the original thread) corresponding to the original business thread identifier TID. The original business thread is the thread that initiates the network outbound behavior. The first preset offset is the byte offset of the original business thread identifier TID of the structure member relative to the starting address of the structure. Step 107: Perform malicious attack detection on the original business thread to determine whether it belongs to an external network attack.
[0023] An HTTP handle is an opaque resource identifier (a numeric index, not a memory pointer) used internally by the WinInet / WinHTTP network API to manage HTTP sessions, TCP connections, and HTTP requests. Each time a program initiates an HTTP / HTTPS request, a hierarchical HTTP handle is created, and all packet sending, response receiving, and data reading / writing operations must rely on the corresponding handle. At its core, it is a resource credential allocated by the operating system for HTTP communication, internally storing: target domain name, port, request headers, cookies, SSL session, buffer, proxy configuration, TCP socket association information, etc.
[0024] This application embodiment, targeting scenarios where task delivery is performed using thread pools, can accurately identify the original business thread and perform thread-level tracing and detection of malicious behaviors involving data transmission via HTTP external connections, thereby greatly improving the defense capabilities and accuracy of terminal security software.
[0025] In one embodiment, after obtaining the thread-local storage TLS of the current thread, the method further includes: Enumerate the thread-local storage (TLS) array of the current thread; Perform validity verification on the thread structure object ThreadInfo corresponding to any of the thread-local storage TLS arrays, wherein the validity verification includes verification based on at least one of magic number, memory signature and pointer boundary; If the validity check passes, then enumerate the ThreadInfo linked list of thread structure objects; If the validity check fails, continue to the next thread to store the TLS array locally, until all the TLS arrays stored locally by the current thread are traversed.
[0026] The nodes of the ThreadInfo linked list of the thread structure object store the thread identifier TID, HTTP handle, and context offset fields.
[0027] In one embodiment, performing a consistency check on the HTTP handle includes: Determine whether the HTTP handle value stored inside the node of the ThreadInfo linked list of the thread structure object is the same as the HTTP handle value stored in the cache; If they are the same, the HTTP handle consistency check is considered to have passed; if they are different, the HTTP handle consistency check is considered to have failed.
[0028] In another embodiment, the method further includes: If the HTTP handle is not found, the current thread identifier (TID) is obtained at the position offset by the first preset offset. Obtain the HTTP handle based on the current thread identifier TID and the second preset offset.
[0029] For 64-bit Windows, with default memory alignment and unchanged structure member order, the first preset offset is 0x10 and the second preset offset is 0x38.
[0030] In another embodiment, the method further includes: Register a callback function for executing the network event callback. When the system detects that the process has performed the network outbound behavior, it automatically triggers the execution of the registered callback function and passes all the parameters of the network event corresponding to the network outbound behavior to the callback function to obtain the information returned by the network event callback. The network outbound behavior includes at least one of the following: initiating an HTTP request, creating a connection, sending and receiving data, disconnecting a socket, and creating a new HTTP handle.
[0031] The step of performing malicious attack detection on the original business thread to determine whether it belongs to an external network attack includes: Perform at least one of the following malicious attack detections on the original business thread: thread call stack analysis, network request communication content auditing, process linkage behavior monitoring, process memory feature scanning, and network behavior baseline comparison. Based on the detection results, determine whether the aforementioned network outreach behavior constitutes a network outreach attack.
[0032] The network outbound attack detection method provided in this embodiment of the invention, in response to detecting network outbound behavior, executes a network event callback; based on the information returned by the network event callback, obtains the thread-local storage (TLS) of the current thread; searches for a thread structure object (ThreadInfo) in the thread-local storage (TLS), the thread structure object (ThreadInfo) storing thread-specific business context information; based on the thread structure object (ThreadInfo), searches for the HTTP handle corresponding to the network event; if the HTTP handle is found, performs a consistency check on the HTTP handle; if the consistency check passes, based on the HTTP handle and a first preset offset, obtains the original business thread corresponding to the original business thread identifier (TID), the thread that initiated the network outbound behavior, the first preset offset being the byte offset of the original business thread identifier (TID) relative to the structure's starting address; performs malicious attack detection on the original business thread to determine whether it belongs to a network outbound attack. In scenarios using thread pools to deliver tasks, this method can accurately trace back to the original business thread that initiated the network outbound behavior, thereby accurately identifying whether a network outbound attack exists.
[0033] The following detailed description of the present application's solution is provided through specific embodiments: like Figure 2 The diagram shows a flowchart of a method for detecting network outbound attacks (only key implementation steps are shown).
[0034] This embodiment runs in a network event callback context. After a network event is triggered, it follows the TLS→ThreadInfo chain, matches the thread ID, locates the HTTP handle corresponding to this network event, and traces the original business thread TID. It can be adapted to thread pool thread reuse and task delivery scenarios, solving the technical pain point that the network callback cannot directly obtain the original business context and HTTP handle after thread pool thread reuse. It can be used for malicious external connection behavior detection.
[0035] Complete main process: Network event callback triggered → Traverse the current thread's TLS array → Locate a valid ThreadInfo → Traverse the ThreadInfo linked list, find the HTTP handle by matching the thread TID, verify consistency, find the original business thread TID (determine the original business thread), and the process ends.
[0036] The main steps include: 1. Network event callback; 2. Enumerate the current thread's TLS array; 3. Validation of ThreadInfo; 4. If the ThreadInfo validity check passes, enumerate the ThreadInfo linked list; otherwise, proceed to the next TLS. 5. Determine if the HTTP handle has been found; 6. If the HTTP handle is not found, then obtain the TID (Take ID) at offset 0x10, which is equal to the current thread's TID. 7. Obtain the HTTP handle at an offset of 0x38; 8. The linked list structure is the same as the previously found HTTP handle value; 9. If they are the same, obtain the original thread TID by offsetting 0x10; 10. End.
[0037] The following is an example of a Shellcode thread stack:
[0038] The following is an example of a thread pool thread stack:
[0039] By reverse engineering the internal implementation of SendHttpRequest, a method for associating two threads was found. An internal structure object, ThreadInfo, is stored in the TLS of the task thread pool:
[0040] The first field of this ThreadInfo structure is a doubly linked list; The position at offset 0x10 of each linked list structure stores the thread ID associated with that structure; The HTTP handle is stored at offset 0x38 in the linked list structure. This handle is stored by both the API caller and the task thread, thus enabling thread association.
[0041] Here is an example of linked list dump memory data:
[0042] In this embodiment of the application, by associating the TID and HTTP handle stored in the TLS of the task thread with the linked list field, the original business thread that called the network request API can be found, thereby detecting whether a network external attack has been launched.
[0043] In the field of security attack and defense, the various embodiments disclosed in this application can accurately identify network return threads, and then perform other security checks on the environment of the thread, which greatly improves the accuracy and solves the problem of not being able to identify the thread that initiates the network request.
[0044] On the other hand, embodiments of the present invention provide a network outreach attack detection system, such as... Figure 3 As shown, it includes: Execution module 201 is used to execute network event callbacks when network outreach behavior is detected; The first acquisition module 202 is used to acquire the thread-local storage TLS of the current thread based on the information returned by the network event callback; The first lookup module 203 is used to look up a thread structure object ThreadInfo from the thread local storage TLS, wherein the thread structure object ThreadInfo stores thread-specific business context information. The second lookup module 204 is used to look up the HTTP handle corresponding to the network event based on the thread structure object ThreadInfo. The verification module 205 is used to perform a consistency verification on the HTTP handle after it is found. The second acquisition module 206 is used to acquire the original business thread corresponding to the original business thread identifier TID based on the HTTP handle and the first preset offset after the consistency check passes. The original business thread is the thread that initiates the network outbound behavior. The first preset offset is the byte offset of the original business thread identifier TID of the structure member relative to the starting address of the structure. The detection module 207 is used to perform malicious attack detection on the original business thread to determine whether it belongs to an external network attack.
[0045] Thirdly, embodiments of the present invention provide an electronic device, including: a memory and a processor, wherein the memory and the processor are connected; Memory, used to store computer programs; A processor is used to invoke a computer program stored in memory to perform any of the above methods.
[0046] Fourthly, embodiments of the present invention provide a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when run by a computer, performs any of the methods described above.
[0047] The network outbound attack detection method and system provided in this invention, in response to detecting network outbound behavior, executes a network event callback; based on the information returned by the network event callback, obtains the thread-local storage TLS of the current thread; searches for a thread structure object ThreadInfo in the thread-local storage TLS, the thread structure object ThreadInfo storing thread-specific business context information; based on the thread structure object ThreadInfo, searches for the HTTP handle corresponding to the network event; if the HTTP handle is found, performs a consistency check on the HTTP handle; if the consistency check passes, based on the HTTP handle and a first preset offset, obtains the original business thread corresponding to the original business thread identifier TID, the original business thread being the thread that initiated the network outbound behavior, the first preset offset being the byte offset of the original business thread identifier TID relative to the structure's starting address; performs malicious attack detection on the original business thread to determine whether it belongs to a network outbound attack. This method and system, in scenarios using thread pools to deliver tasks, can accurately trace back to the original business thread that initiated the network outbound behavior, thereby accurately identifying whether a network outbound attack exists.
[0048] It should be noted that the content of the method embodiments and system embodiments provided in this patent application corresponds one-to-one with each other. The content involved in any embodiment can be referenced or combined with other embodiments to form part of that embodiment. For ease of description, this patent application focuses on explaining the method embodiments. The description of the relevant technical features and solutions of the device, system, electronic device, and computer-readable storage medium embodiments can be referred to the relevant content in the method embodiments.
[0049] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, apparatus, systems, electronic devices, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage and optical storage) containing computer-usable program code.
[0050] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.
[0051] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.
[0052] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.
Claims
1. A method for detecting network outbound attacks, characterized in that, The method includes: In response to the detection of network outreach, a network event callback is executed. Based on the information returned by the network event callback, obtain the thread-local storage TLS of the current thread; The thread structure object ThreadInfo is retrieved from the thread-local storage TLS, and the thread structure object ThreadInfo stores thread-specific business context information; Based on the ThreadInfo structure object, find the HTTP handle corresponding to the network event; If an HTTP handle is found, a consistency check is performed on the HTTP handle. If the consistency check passes, based on the HTTP handle and the first preset offset, the original business thread corresponding to the original business thread identifier TID is obtained. The original business thread is the thread that initiated the network outbound behavior. The first preset offset is the byte offset of the original business thread identifier TID of the structure member relative to the starting address of the structure. Malicious attack detection is performed on the original business thread to determine whether it belongs to an external network attack.
2. The method according to claim 1, characterized in that, After obtaining the thread-local storage TLS of the current thread, the method further includes: Enumerate the current thread's thread-local storage (TLS) array; Perform validity verification on the thread structure object ThreadInfo corresponding to any of the thread-local storage TLS arrays, wherein the validity verification includes verification based on at least one of magic number, memory signature and pointer boundary; If the validity check passes, then enumerate the ThreadInfo linked list of thread struct objects; If the validity check fails, continue to the next thread to store the TLS array locally, until all the TLS arrays stored locally by the current thread are traversed.
3. The method according to claim 2, characterized in that, The nodes of the ThreadInfo linked list of the thread structure object store the thread identifier TID, HTTP handle, and context offset fields. A consistency check is performed on the HTTP handle, including: Determine whether the HTTP handle value stored inside the node of the ThreadInfo linked list of the thread structure object is the same as the HTTP handle value stored in the cache; If they are the same, the HTTP handle consistency check is considered to have passed; if they are different, the HTTP handle consistency check is considered to have failed.
4. The method according to claim 1, characterized in that, The method further includes: If the HTTP handle is not found, the current thread identifier (TID) is obtained at the position offset by the first preset offset. Obtain the HTTP handle based on the current thread identifier TID and the second preset offset.
5. The method according to claim 4, characterized in that: For 64-bit Windows, with default memory alignment and unchanged structure member order, the first preset offset is 0x10 and the second preset offset is 0x38.
6. The method according to claim 1, characterized in that, The method further includes: Register a callback function for executing the network event callback. When the system detects that the process has performed the network outbound behavior, it automatically triggers the execution of the registered callback function and passes all the parameters of the network event corresponding to the network outbound behavior to the callback function to obtain the information returned by the network event callback. The network outbound behavior includes at least one of the following: initiating an HTTP request, creating a connection, sending and receiving data, disconnecting a socket, and creating a new HTTP handle.
7. The method according to claim 1, characterized in that, The step of performing malicious attack detection on the original business thread to determine whether it belongs to an external network attack includes: Perform at least one of the following malicious attack detections on the original business thread: thread call stack analysis, network request communication content auditing, process linkage behavior monitoring, process memory feature scanning, and network behavior baseline comparison. Based on the detection results, determine whether the aforementioned network outreach behavior constitutes a network outreach attack.
8. A system for detecting network outreach attacks, characterized in that, include: The execution module is used to execute network event callbacks when network outreach behavior is detected. The first acquisition module is used to acquire the thread-local storage TLS of the current thread based on the information returned by the network event callback; The first lookup module is used to look up a thread structure object ThreadInfo from the thread-local storage TLS, wherein the thread structure object ThreadInfo stores thread-specific business context information; The second lookup module is used to find the HTTP handle corresponding to the network event based on the thread structure object ThreadInfo. The verification module is used to perform a consistency verification on the HTTP handle after it is found. The second acquisition module is used to acquire the original business thread corresponding to the original business thread identifier TID based on the HTTP handle and the first preset offset after the consistency check passes. The original business thread is the thread that initiates the network outbound behavior. The first preset offset is the byte offset of the original business thread identifier TID of the structure member relative to the starting address of the structure. The detection module is used to perform malicious attack detection on the original business thread to determine whether it belongs to an external network attack.
9. An electronic device, characterized in that, include: Memory and processor, and the connection between memory and processor; Memory, used to store computer programs; A processor for invoking a computer program stored in memory to perform the method as described in any one of claims 1-7.
10. A computer-readable storage medium, characterized in that, It stores a computer program, which, when executed by a computer, performs the method as described in any one of claims 1-7.
