Search/kyber
● Threat actor

kyber

Claimed attacks
1
Top country hit
US
1 attacks
Countries targeted
1
Last activity
Jul 30, 2026
first seen Jul 30, 2026
Dark Web Presence1
1 known leak site tracked

Known .onion/clearnet leak sites for this group, with live status — unlock with Premium.

Upgrade to Premium
Connections
15 relationships
Operation FlashHole: Lazarus breaks security, defies control
In January, we responded to the Lazarus Group’s novel attack campaign against South Korea, which followed last year’s Operation SyncHole . In this new operation, the group employed an updated malware chain that included both their old and new malware, which we disclosed in full, and used another mandatory South Korean security software program as a part of infection chain using a watering‑hole strategy. Notably, the group targeted victims more selectively, sending spear‑phishing emails with links to fabricated but relevant sites, such as portfolio and résumé pages tailored to each target. We dubbed this activity Operation FlashHole. Operation FlashHole attack flow during initial compromise Our examination reveals that the earliest evidence of this new operation dates back to July 2025. This suggests the group began preparing for the campaign shortly after ending Operation SyncHole, which lasted at least four months. We identified a minimum of three organizations impacted by the campaign in South Korea’s software, construction, and wired communication equipment manufacturing sectors. These sectors differ from those affected by Operation SyncHole, indicating that the group has expanded its target scope over time. Background After more than a year since the first observation of Operation SyncHole, we detected a suspicious execution chain originating from legitimate South Korean software. This chain mirrors the one from the previous operation; however, this time, the attacker abused CrossWeb EX instead of Cross EX, which was abused in Operation SyncHole. Both applications appear to be maintained by the same vendor, and both are related to financial security. CrossWeb EX is a financial security solution that is required to access widely used online banking and government websites. It encrypts communications between the user’s browser and the web server using public key infrastructure (PKI). This is not the first time Lazarus has abused this software. It was also used in 2021 to deploy the Racket downloader and again in 2022 and 2023 . Although the exact method by which CrossWeb EX was abused remains unclear, we determined that the attack chain ultimately leads to the execution of the malware in memory. We noted that the spawned process was running with a high integrity level. The parent process, INISAFECrossWebEXSvc.exe , originates from the installation bundle of INISAFE CrossWeb EX V3 version 3.4.1.2, released in 2023 after KrCERT’s public advisory . As we already mentioned in our SyncHole blog post, this pattern closely mirrors the long‑standing strategy employed by the Lazarus Group to target South Korea. Since CrossWeb EX and similar software is mandatory for South Korean users and typically runs in the background to interact with the browser, it has been leveraged as a critical attack vector by the group. In 2025, a paper was presented at the USENIX Security Symposium that investigated vulnerabilities in South Korea’s mandatory security software and demonstrated how such software can unintentionally create a massive attack surface. In July 2026, the South Korean government and several local security vendors also published a joint security advisory covering typical Lazarus attack techniques, including exploitation of financial security software. While this advisory overlaps with our findings from Operation FlashHole and Operation SyncHole, and AhnLab’s detailed analysis report Operation Double Barrel covers a wide range of recent Lazarus Group activities, we are conducting a more granular classification based on their TTPs. We will discuss this further in the attribution section. Initial infection vector Although we could not precisely determine what triggered the infection chain, our analysis uncovered a suspicious website hosted on GitHub Pages that is associated with the GitHub account used as the C2 channel. The GitHub account was created last September, and the initial version of the site was designed to showcase the résumé of a senior network appliance developer. In January, however, this site was replaced with another featuring an interior design showcase. The first site was likely accessed by an employee of a wired communication manufacturing company, while the second site likely affected a target in the construction sector. Appearance of the malicious websites The first site with the résumé had a photograph supposedly of a job seeker, but the lack of EXIF metadata and the unnatural texture of the image indicate that it was generated by AI. This suggests the Lazarus Group has incorporated AI into its long‑standing strategy, like other Korean‑speaking threat actors ( 1 , 2 ). The group most likely also used AI to create the lure site: the job seeker’s name resembles the Korean version of “John Doe,” and the portfolio was populated with seemingly meaningless details and random companies. The generated site was then manually tailored to specific targets. Suspected use of an AI-generated image on the résumé site The websites contained embedded links that loaded an external JavaScript file via a script tag. Malicious link embedded in the résumé site: hxxps://javadevhouse.co[.]kr/ajax/libs/jquery/1.7.3/jquery.min.js Malicious link embedded in interior design site: hxxps://pythonapischool[.]com/api/detach Based on the analysis, we assess with medium-to-high confidence that the targets received phishing emails containing links to the malicious site hosted on GitHub Pages (using the domain <username>.github.io). The research results showed a high possibility that visiting the malicious site initiated an infection process involving CrossWeb EX software. This assessment aligns with Lazarus’s recent approach, as detailed in the joint advisory published by the South Korean government and security companies. Full infection chain Following the initial compromise, the legitimate Windows binary fsquirt.exe was executed under the CrossWeb EX process and injected with shellcode containing a malicious DLL – TechHub malware. From our extensive and thorough examination, we identified several malicious payloads and reconstructed the complete infection chain. The infection chain is rather complex and reveals the Lazarus Group’s advanced operational techniques on targeted hosts. These techniques conceal their malicious payloads, intent and their sophisticated malware delivery framework. The latter was updated extensively compared to the previous campaign, despite the new operation starting less than a year later. Significantly, the execution chain below exists only in memory during the initial infiltration, highlighting the attackers’ considerable efforts to hide the initial compromise. Initial infection chain Following the initial compromise, the group sought to maintain persistence on the network by installing a pair of malware strains – TouchHub and TouchShift – leveraging DLL side‑loading under the name mscoree.dll . TouchHub was deployed by the first instance of TechHub. It then used DLL side-loading to launch TouchShift, which led to the in‑memory execution of another TechHub instance. After launching the second time, TechHub deployed another pair, ClientHub and LPEClient, rather than executing Cubridge directly. Only minimal traces of these files were found on disk; the remainder of the malicious code persisted exclusively in memory. Expanded infection chain after gaining persistence Since Cubridge remains only in memory at the initial compromise stage, we suspect the group designed this indirect, multistage chain to deliberately redeploy Cubridge after gaining persistence, as it serves as the most sophisticated orchestrator of the attack. Malware set The full chain comprises advanced variants of the known Lazarus malware strains, including TechHub, Cubridge, TouchShift, LPEClient, and the newly identified TouchHub and ClientHub. TechHub – the start of the chain TechHub, a downloader that plays a central role in this attack, communicates with GitHub using a Personal Access Token (PAT). It serves as the initial payload, providing the top of the chain with sufficient functionality to profile compromised hosts and facilitate subsequent payloads. This variant is a more advanced version of the malware named CLOUDBURST by Mandiant and NickelLoader by ESET. According to their reports, the earlier version communicated with a C2 server via HTTP(S) to fetch additional payloads. The latest iteration we found, however, communicates with GitHub instead and has updated command strings. We identified three variants of TechHub in the chain: an in‑memory version, a simple DLL side‑loading version, and a DLL side‑loading version that uses a registered Windows service. Depending on which stage loads the malware, it contacts a private GitHub repository via the GitHub API using either hard‑coded credentials or credentials retrieved from its configuration file. When TechHub loads, it creates a 4‑byte hexadecimal identifier (ID) in the range 0x1000–0xFFFF or reads one from the configuration file, enabling the attackers to distinguish between compromised hosts. TechHub then checks a GitHub issue by sending the request GET /issues?state=[open/closed] to determine whether any previous communication remains active and removes any traces of it if found. It then proceeds with the handshaking process. It creates a new issue titled 1[ID] with the body “hel” using the POST /issues request, and sets its status to open. It then retrieves a file from the repository containing the 2[ID] value in its name. This file contains the RSA public key. It generates a random 16‑byte XOR key, encrypts it with the provided RSA public key, and uploads the result, prefixed with 1[ID] , to the repository. The hard‑coded IV is XORed with the generated 16‑byte key and then used after the handshake. During file exchange, filenames follow the pattern [1|2][ID][random-16-byte-key] throughout communication. The “2” prefix indicates delivery from the repository to TechHub, while “1” indicates delivery from TechHub to the repository. The random 16‑byte key in the filename is used for AES encryption or decryption of each file’s contents, employing either a hard‑coded IV or an updated IV. After the key exchange is complete, TechHub reads a file with the prefix “2” once again and verifies that the delivered data equals “hel”. If the check passes, TechHub gathers extensive information from the infected host. This data is then encrypted and sent to the repository. After transmitting the device information, the process concludes by updating the body of the previously created issue from “hel” to “hey” using PATCH /issues/[issue number] . The malware is now fully prepared to receive commands from the repository. TechHub supports four commands. The laeca command deploys a payload packaged in shellcode that reflectively loads the embedded payload directly into memory. Command Description mqdrz Collect information about the device and its running processes laeca Directly invoke the received shellcode in memory aqvxp Terminate the current process rtcya Beaconing after finishing the handshake process Cubridge – the framework orchestrator Cubridge, deployed via TechHub on the compromised host, is capable of retrieving various payloads through multiple methods. It serves as the central orchestrator of the entire malware framework, supporting a range of plugins, modules, and tools. An earlier version of Cubridge was also disclosed in the reports covering the previous version of TechHub. In those reports, Mandiant identified it as SIDESHOW, and ESET identified one of its modules as LightlessCan. To establish communication with the C2 server, Cubridge randomly selects one of the predefined C2 servers and constructs a dedicated C2 URL for every request, using the pattern [C2_URL]/[page1]/[page2]/[page3] . This is achieved by concatenating terms from predefined word lists. Our analysis identified a single hardcoded C2 server – hxxps://cubedesign[.]co[.]kr/news/AABBCC – associated with the examined instance that is configured to version 5.1. During URL generation, AABBCC is substituted with a null value. The page3 segment is assigned a randomly generated integer between 10000000 and 99999999 . Consequently, each generated URL is designed to appear authentic and remain unique for each request. The predefined list for page1 is shown below. TechHub randomly selects one item from the list. economy, opinion, politics, national, international, medical, investment, sports, lifestyle, shopping, culture The predefined word list for page2 is shown below. article, list, story This means the hardcoded URL can later be transformed, for example, into hxxps://cubedesign[.]co[.]kr/news/economy/article/12345678 by following the steps described above. Authentication using the POST request with the C2 server requires three parameters in the form of key‑value pairs. Each key is randomly generated using a different predefined word dictionary, and the associated values consist of a randomly generated 8‑byte hexadecimal bot ID, a fixed authentication token ( KW4Ofw982CNJjxd51AVqkGAop ), and a randomly generated 16‑byte hexadecimal session ID. Cubridge employs a more robust handshaking process than TechHub, combining the RSA and RC6 algorithms. Unlike TechHub, it skips the profiling step and proceeds directly to command and control after the handshake. During communication, the malware mimics browser requests, using X‑CSRF‑Token and X‑Requested‑With headers for authentication and the Upgrade‑Insecure‑Requests header to request additional data. Cubridge’s communication sequence Cubridge contains extensive functionality, with a particular focus on loading subsequent‑stage payloads. The commands employ various techniques, such as DLL injection, reflective loading, and section‑mapping injection. The payloads may be delivered in various forms: Plugins – reusable extensions that add functionality as needed and can be invoked at any time (in shellcode and DLL form); Tools (in DLL form) – independent utilities that perform one-off tasks; Modules – components that are loaded once and remain active providing an extended set of functionalities. It is anticipated that the commands for plugins and shellcode will load identical types of plugins because both support a similarly formed exported function for subsequent activity. The shellcode can be generated using the open‑source sRDI tool to package a DLL‑style plugin. The capabilities of a single DLL are likely utilized to load a tool that works independently because when a single DLL is loaded, only its DllMain entry point and its parameters are accessible; no other exported functions are exposed. Command Payload type Description 0 – Collect device info including the computer name, time zone, PID, and other similar details 1 Archive the specified file/directory using the legacy ZipCrypto algorithm and the hard‑coded password: xdkiTajAAxc3i/w[<881fnC!G*cb1Dit2sh.gAk/ 2 Create a file at the specified path 3 Possibly plugin Inject the provided DLL payload into the target process and load it reflectively using reflective DLL injection 4 Plugin Reflectively load a plugin in DLL format 5 Retrieve the address of the specified exported function from the target plugin and run it with the provided parameters 6 Retrieve all information about the loaded plugins 7 Unload the specified plugin 8 Shellcode Inject the provided shellcode into the target process and load it using section mapping injection 9 Load the provided shellcode directly into memory 10 Retrieve the address of the specified export function from the target shellcode (likely a plugin in shellcode form) and run it with the provided parameter 11 Retrieve all information about the loaded shellcode 12 Unload the specified shellcode 13 – Set the scheduled Cubridge execution time (in minutes) by updating a global variable 14 Set the scheduled Cubridge execution time (in minutes) by updating a global variable, while disabling monitoring by also updating another global variable 15 Terminate in a controlled manner 16 Get the configuration for Cubridge: retrieve the global flags, the number of C2 servers, the C2 addresses, etc. 17 Update the global flags, the number of C2 servers, the C2 addresses, etc. 18 Tool Load a DLL reflectively with the specified parameter 19 Configure the parameters for loading a single DLL 20 Unload the single DLL 21 Module Load the “action module” ( ActionModule.dll ) reflectively and invoke its AppinfoView export function 22 Load the “function module” ( FunctionModule.dll ) reflectively and invoke its PresentationFontConfig export function Commands 21 and 22 each load a different module. As their internal names imply, the action module manages basic file and process operations, while the function module implements Windows’ default commands. The action module covers commands 23–41 , and the function module handles commands 42–79 . The action module handles system operation commands, file system interactions, and process behavior. It is invoked by passing the appropriate command and parameters to its AppinfoView export function. The module supports 19 commands, numbered 23 through 41 . Execution results are first sent to Cubridge, which then forwards them to the C2 server. Command Role 23 Get local disk space for each drive 24 Get information about the specified file or directory 25 Execute the provided command 26 Get information about the specified file or directory (similar to command 24) 27 Execute the provided command under the target process (PPID spoofing) 28 Execute the provided command under the target process within the provided session (PPID spoofing + session impersonation) 29 Get detailed information about processes 30 Terminate the provided process 31 Suspend all threads belonging to the specified process 32 Resume all threads belonging to the specified process 33 Permanently delete the file by overwriting its entire contents with the sequence: 0 → 1 → random bytes → 1 → 0 34 Rename the provided file to :EFS (the alternate data stream area) and delete it using the native API SetFileInformationByHandle 35 Set the current working directory 36 Copy the specified file to the provided path 37 Delete the specified directory 38 Move the specified file to the provided path 39 Create the provided directory 40 Initiate a non‑blocking connection attempt to the specified IP address and port (possibly for port scanning) 41 Read the specified file The function module implements commands that emulate Windows’ built-in commands. Similar to the action module, its DllMain routine initializes all supported command functions, which are later accessed through the PresentationFontConfig export. Altogether, the module offers 38 commands, numbered from 42 to 79 . While we believe this module is based on the previous LightlessCan, this is the first time we’ve seen it in the form of a separate module. Command Role 42 Capture all displays and archive them using the legacy ZipCrypto algorithm with the hard‑coded password: xdkiTajAAxc3i/w[<881fnC!G*cb1Dit2sh.gAk/ 43 Synchronize the MAC (Modified, Accessed, and Created) times of the file provided in the second argument to match those of the file provided as the first argument 44 Get information about the specified directory 45 Get information about the specified drive 46 Inject the provided DLL payload into the target process 47 Unload the specified DLL from the specified process 48 Implementation of the ipconfig command 49 Implementation of the net command 50 Implementation of the netsh advfirewall firewall command 51 Implementation of the netstat command 52 Implementation of the ping -6 command 53 Implementation of the reg command 54 Implementation of the sc command 55 Implementation of the ping command 56 Implementation of the whoami command 57 Implementation of the nslookup command 58 Implementation of the schtasks command 59 Implementation of the systeminfo command 60 Implementation of the arp command 61 Call the CryptUnprotectData function to retrieve the AES key that DPAPI protects. Extract the key using the encrypted_key keyword from Chromium’s Local State file located at: %LOCALAPPDATA%\Google\Chrome\User Data\Local State 62 Not implemented 63 Not implemented 64 Read the specified file and decrypt it using an XOR operation with the key 0x59 . Then extract the paths from the decrypted buffer and archive files and directories at these paths with the legacy ZipCrypto algorithm, using the hard‑coded password: xdkiTajAAxc3i/w[<881fnC!G*cb1Dit2sh.gAk/ 65 ~ 79 Not implemented Besides the modules, we also observed that the actor deployed various plugins and tools. Type of payload Name Description Plugin ADFinder ( AdFinder.dll ) Launches LDAP queries in an Active Directory environment, taking six arguments such as log file path, ADsPath, search filter, and attribute names Plugin FileCollector ( Dll.dll ) Recursively scans every subdirectory and file in the provided directory, gathering detailed information about each Tool Browser stealer Can be injected into Chromium-based browsers, such as Google Chrome, Microsoft Edge, and Brave. Once injected, it extracts files and credentials from the victim’s browsers, including stored passwords, bookmarks, history, preferences, and cookies Tool Process collector Iterates over all running processes, collecting each process’s ID, path, and command line TouchHub installs a service for TouchShift During our analysis, we obtained a previously unknown malware sample from TechHub’s private GitHub repository, which served as a parent installer for TouchShift. We dubbed this malware TouchHub. Upon execution, it copies the legitimate printfilterpipelinesvc.exe to C:\Windows\System32\RasConv\ImeBroker.exe , registers it as a service, and places an embedded TouchShift payload named mscoree.dll in the same directory. Following creation, the malware synchronizes the MAC timestamps of C:\Windows\System32\drivers\monitor.sys with those of the newly written file, hindering forensic analysis. It then goes through the service registration process by collecting up to 100 legitimate service names that are registered under the netsvcs svchost group in HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Svchost . It randomly selects one of these names, appends two random alphabetic characters to form a new service name, and uses this name to create a service that runs the hard‑coded command line C:\Windows\System32\RasConv\ImeBroker.exe -TimeBroker with the description Microsoft Service . The newly created service is started immediately. Overall, TouchHub creates three files in the designated directory to launch TouchShift with SYSTEM privileges. Path Type Description C:\Windows\System32\RasConv\ImeBroker.exe Executable file registered as a service Copied from C:\Windows\System32\printfilterpipelinesvc.exe C:\Windows\System32\RasConv\mscoree.dll Side-loaded TouchShift payload Dropped by TouchHub. It contains encrypted payloads and includes portions of a legitimate DLL’s contents, which significantly inflates its size C:\Windows\System32\RasConv\ActivationStore.dat TechHub’s configuration file Dropped by TouchHub after extracting configuration values TouchShift, a prevalent loader employed across multiple infection chains The version of TouchShift dropped by TouchHub is almost identical to the version described in Mandiant’s blog post , even sharing the same malicious export function, LockClrVersion . It takes the argument supplied by TouchHub and XORs it with a hard‑coded key. The resulting value is XORed once more with the executable’s filename, and this result is used as the AES key. All strings involved in this process (the argument, the XOR key, the filename) must be exactly 16 bytes long. If a string is shorter, it is padded with NULL bytes ( \x00 ); if it is longer, it is truncated to 16 characters. For example, one of the string combinations in the obtained sample was: Argument: -TimeBroker\x00\x00\x00\x00\x00 (padded with NULL) Hard-coded XOR key: x809G736iC3f8Wp8 Executable filename: ImeBroker.exe\x00\x00\x00 (padded with NULL) After deriving the key, the malware decrypts the embedded payload using AES‑CBC‑128 without padding. The decrypted data is shellcode that starts with a call instruction. It wraps the next‑stage payload – identified as the third version of TechHub (DLL side-loading with a registered service) – that reads the ActivationStore.dat file as an external configuration. ClientHub We also identified a new piece of malware stored in TechHub’s private repository, which we named ClientHub. It supports various commands formed using a bitmask. There are at least two versions of ClientHub: one that communicates with websites via HTTP(S) and one that interacts with the Dropbox API using credentials. Depending on the version, its configuration is sourced from internal resources or the external configuration file C:\Program Files\Common Files\System\msadc\msadc.inc. The configuration comprises keys and IVs for the SNOW 1.0 algorithm, scheduled execution times, and C2 server addresses encrypted with the SNOW stream cipher. The SNOW cipher is a family of high‑speed stream ciphers used for secure data encryption in telecommunications and wireless networks. This is the first time it has been observed in the malware of the Lazarus Group. To establish C2 communication, the malware initially generates a 32‑byte random array. It subsequently overwrites portions of this array with data collected from the compromised device. The resulting 32‑byte array comprises a blend of random bytes and relevant information. This array is later used as the key for the SNOW algorithm to decrypt data received from the C2 server. Finally, the key array is encrypted with a hard‑coded RSA public key and encoded in Base64. Offset Size Field value 0 4 Current process ID 4 4 First four bytes of the decrypted C2 server information. 8 7 Randomly generated bytes 15 1 Calculated flag value that indicates a state machine . 16 8 Current system time, represented as a FILETIME structure. 24 8 Randomly generated bytes The ciphertext is delivered to the C2 server via GET requests. Each request contains headers that are atypical for malware: Sec-CH-UA , Sec-CH-UA-Platform , Sec-CH-UA-Mobile , Sec-Fetch-Mode , and Sec-Fetch-Dest . These headers are normally used by legitimate Chromium‑based browsers and enable malware to imitate legitimate traffic and evade detection. The C2 server replies with commands in a custom header and message body. struct header { int has_more_data // whether more body data remains int body_checksum;// ROR13 checksum for the body data int body_type; // specifies the body type int unknown; int body_length; // Length of the body data int IV[2]; // Random IV used to encrypt the body data }; The body_type field in the header determines how the subsequent payload is processed. This value functions as a bitmask, with each bit representing a distinct flag (e.g., 0x1 , 0x2 , 0x4 , etc.). The resulting behavior also depends on whether the least‑significant bit (bit 0) is set: when the value is odd, the malware interprets the incoming message body as an additional payload that is subsequently loaded into memory. Conversely, when the value is even, the malware invokes the previously loaded payload. The odd value supports four distinct loading methods based on the received message body and ensures that each method executes only once. Bitmask Value in decimal Description Result sent to the C2 0x00000001 1 DLL loading: load the received body reflectively along with the provided parameter The payload’s image base 0x00000011 3 Plugin: load the received body reflectively, obtain the address of a function in the payload, and then invoke that function along with the provided parameter The payload’s image base, the address of the invoked function, and the execution result 0x00000101 5 Plugin: load the received body reflectively, obtain the address of a function in the payload, but refrain from invoking it immediately The payload’s image base, the address of the function 0x00001011 11 Plugin: execute the behavior associated with value 3, then unload immediately after invoking the plugin – 0x00010001 17 DLL loading: load the received body reflectively with the provided parameter, maintaining stateful communication via a persistent interactive session using a shared buffer The payload’s image base, the address of the interactive shared buffer, and the execution result The even value provides two distinct invocation methods for DLLs and plugins that have already been loaded and are associated with the odd‑value bitmask. The 2 (0x10) flag allows the payload previously loaded with the 1 , 3 , or 5 bitmask to be reused and invoked directly. The value 16 (0x10000) corresponds to the 17 (0x10001) flag in loading mode and uses the established interactive shared buffer to exchange data. All values are guaranteed to act independently. Bitmask Value in decimal Description Result sent to the C2 0x00000010 2 Invoke the previously loaded DLLs and plugins along with the provided parameter The execution result 0x00000100 4 Not implemented – 0x00001000 8 Unload the previously loaded DLLs and plugins The execution result 0x00010000 16 Send the updated parameter to the payload loaded by the command with the value 17, and exchange data through the interactive session. This command also determines whether to retrieve the execution result or unload the payload The execution result Taking into account the loading mechanism, we identified four plugins deployed to the target that work perfectly with ClientHub. Plugin Description File archiver Archives the provided file using the legacy ZipCrypto algorithm (without password protection) and returns the compressed data File collector Searches for all files matching the provided search pattern and collects metadata including filename, MAC timestamps, file size, and attribute values File cleaner Overwrites the provided file with NULL bytes, renames it to a randomly generated filename of the same length, and then deletes it. If a directory with a search pattern is provided, it locates all matching files, renames each to a randomly generated name of identical length to its original name, and deletes them Drive and session monitor Monitors remote session changes and local drive changes for the provided duration (in 10-minute intervals) and returns the collected status information In addition to the plugins, ClientHub supports the loading of LPEClient malware and communication with it. We found that ClientHub’s body_type values 16 and 17 correspond to LPEClient’s C2 communication mechanism. LPEClient LPEClient is the only malware that was also observed in Operation SyncHole, indicating that the actor relies heavily on it for sophisticated victim profiling and payload delivery across multiple operations. LPEClient first appeared in 2019, and was discovered in 2020 . Since then, the tool has been widely observed in the Dream Job and Cascade Hole campaigns that targeted South Korea. Recent research conducted by Check Point revealed that LPEClient was used to deploy the FudModule malware using a zero-day. LPEClient has evolved continuously over time, but we discovered that it recently underwent a major operational revamp. It no longer contains the C2 server address itself; instead, it interacts with ClientHub via a shared buffer. We believe this change is intended to enhance concealment. Timeline of LPEClient The previous version collected the computer name, memory status, CPU specifications, operating system details, version of the ntoskrnl.exe file, firmware table, antivirus name, domain name, user name, the integrity level of the current process, and a random byte sequence of 1,568 bytes. The newly updated LPEClient variant mostly collects the same information; however, it also introduces several changes. It does not collect the version of the ntoskrnl.exe file by querying the FileVersion value. Instead, depending on the specific build, it reads either the HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\UBR registry key or the SYSTEM_BUILD_VERSION_INFORMATION structure to retrieve the revision portion of the Windows build number. These values can be used to infer the system’s cumulative update or patch level. To collect information about installed antivirus products, it switched from querying a WQL command to reading the WMI repository file directly. It now reads C:\Windows\System32\wbem\Repository\OBJECTS.DATA and searches for keywords such as AntiVirusProduct, companyName, and displayName to identify the installed products. It also collects low‑level Windows security mitigation states. To achieve this, it queries the SYSTEM_KERNEL_VA_SHADOW_INFORMATION structure for the Kernel VA Shadow mitigation status and the SYSTEM_SHADOW_STACK_INFORMATION structure for the Shadow Stack (CET) protection status. Additionally, it generates a 32‑byte random unique identifier by using the HighwayHash algorithm and an XOR operation with the current system time. The collected information, including the generated identifier, is compressed with the XPRESS Huffman algorithm using the maximum compression setting. The compressed data is then concatenated with the message ID 0xF07D6B34 and encrypted using GOST (also known as Magma), Russia’s national cryptographic standard that employs a DES‑like structure, before being sent to the ClientHub via a shared buffer. Initially, KrCERT described the algorithm as a custom DES‑like scheme. However, further analysis by us and Check Point confirmed that it is actually the GOST algorithm. The key is randomly generated by a proprietary key‑generation algorithm and prepended to the encrypted message. The next request handles the key exchange by delivering the message ID 0xA39CF278 together with the generated unique identifier. The response is decrypted using the AES‑CBC‑256 algorithm. The SHA‑256 hash of the previously generated 1,568‑byte random value, which was originally sent to the C2 server during the collection phase, serves as the key for this decryption. Through this process, LPEClient obtains a byte array comprising four 1,568‑byte blocks from the C2 response. Each block contains an ML‑KEM‑1024 public key, where ML‑KEM is a NIST‑standardized post‑quantum key encapsulation mechanism derived from CRYSTALS‑Kyber. LPEClient then generates four distinct pairs of shared keys and ciphertexts from these blocks, encrypts the ciphertexts with the GOST algorithm, and transmits them to the C2 server via ClientHub together with the message identifier 0xEF8C0D51 and the associated identifier. Now that the preparation phase for receiving payloads is complete, the malware is ready to receive payloads forwarded by ClientHub from the C2 server, along with the necessary parameters. The use of post-quantum cryptography shows that the group intends to hide subsequent payloads. The response to the 0xEF8C0D51 message is decrypted with the Threefish algorithm using a 256-byte key, composed of the four distinct shared keys. Threefish is a tweakable block cipher that accepts a ‘tweak’ value alongside the key and the message. The concept of a tweak is similar to that of a nonce or initialization vector, which are used in different types of ciphers. In LPEClient communication, the tweak for the decryption is derived by XORing the unique identifier with 165 (0xA5) . The first four bytes of the decrypted message must specify the parameter’s length, followed by the parameter itself and then the payload. The payload must be larger than 4 KB and start with the characters 'MZ' , which indicates that the decrypted payload is an executable file. The payload is then reflectively loaded into memory. After successful loading, LPEClient sends the message ID 0xCB790A25 to the C2 server. Before loading the acquired payload, LPEClient takes measures to bypass security products. Instead of invoking VirtualProtect directly, the malware uses the identified HeapPageAllocator::ProtectPages in jscript9.dll to modify the memory page protection of the MD4Update function. The beginning of the function is then overwritten with a hard‑coded opcode sequence that serves as a syscall stub with the required arguments. LPEClient then uses the syscall stub to disable a user‑mode syscall instrumentation hook. We identified the final payload that was ultimately loaded as Cubridge. The overall communication process is as follows. Data relay flow between LPEClient and C2 via ClientHub Comparison of plugins and modules Throughout the engagement, we identified a variety of payloads deployed by TechHub, Cubridge, and ClientHub. These payloads have been categorized as tools, plugins, and modules that constitute the group’s modular malware framework. While we have not yet ascertained which payloads are deployed under specific conditions, the evidence suggests that the Lazarus Group’s toolkit is becoming increasingly sophisticated and segmented into specialized components rather than a single comprehensive backdoor. We also believe that TechHub and Cubridge may share similar tools. Deployed via Type of payload Family TechHub/Cubridge Tool Process collector, Browser stealer Cubridge Module Action module, Function module Cubridge Plugin ADFinder, FileCollector ClientHub Plugin File archiver, File collector, File cleaner, Drive/session monitor These modularizations are not confined to the instances within this campaign. As previously noted, similar patterns have been identified in CookiePlus, MISTPEN, SIGNBT, and IMETHOD. Note that we have reclassified the ThreatNeedle variant used in Operation SyncHole as the latest version of IMETHOD, the predecessor of ThreatNeedle in use since at least 2016. Infrastructure Based on the information we obtained from the TechHub malware, we identified at least three primary repositories used as the C2 server and one fallback repository. The earliest evidence indicates that the group has been leveraging GitHub as a C2 server since at least July 2025. We suspect that all the accounts were created using hijacked email accounts, and disguised as normal repositories by copying or creating normal projects to avoid suspicion. For the Cubridge and ClientHub C2 servers, the Lazarus Group employed only a minimal number of compromised yet legitimate South Korean media and interior design websites. Later, we observed that a broader range of compromised legitimate sites across various industries were also exploited. In addition, one ClientHub sample that we detected used Dropbox as a C2 channel. Victims We have identified at least three firms from the software, construction, and wired communication equipment industries in South Korea that were targeted by Operation FlashHole. As with the previous operation, however, we remain confident that a considerably larger number of organizations across a broader spectrum of industries have been affected. The software sector was the only sector targeted in both the SyncHole and FlashHole campaigns. This suggests the actor is eager to compromise the sector, steal source code, and exploit vulnerabilities for further attacks. Attribution and links to other campaigns Operation FlashHole is the latest wave in the broader Cascade Hole campaign, which involves the use of South Korean software as a potential entry point to deliver malware targeting the country. Although the malware chain has advanced significantly since last year, we assess with medium-to-high confidence that the same actor is responsible for both the SyncHole and FlashHole operations based on the initial vector, targets, multi‑stage chain, and technical and operational improvements. The use of LPEClient in particular is a strong indicator supporting this assessment. The malware strains used in the attack are historically linked to the toolsets observed in the Lazarus Group’s notorious Dream Job campaign. Earlier versions of TechHub (also known as CLOUDBURST and NickelLoader), Cubridge (also known as SIDESHOW and LightlessCan), and TouchShift were all observed in that campaign, especially between 2022 and 2023. We also discovered that both CookiePlus and ClientHub have significant overlaps in class name, configuration path, and plugins. Based on these similarities, we assess with medium‑high confidence that ClientHub is an advanced version of CookiePlus. Since July, around the time Operation SyncHole began winding down, we have also observed several notable attacks against South Korea employing the COPPERHEDGE backdoor and targeting various South Korean organizations. Interestingly, the start times of these activities align with the earliest evidence we have identified for Operation FlashHole. Although the backdoor was part of the second phase of Operation SyncHole, it has been operating independently with its custom loader since then. These incidents featured malware chains and tools that were distinct from those used in Operation SyncHole and FlashHole. As AhnLab noted in their report , the same backdoor was likely observed in atypical activity, specifically the Gunra ransomware infection. Our investigation further revealed that one instance of a backdoor infection ultimately resulted in the exfiltration of data to a dark web leak site, which clearly differed from Gunra’s. The site appears to have been crafted exclusively for this activity. In summary, unlike other attacks, the backdoor was used in conjunction with both ransomware and data exfiltration. Data leakage site linked to the COPPERHEDGE backdoor on the dark web Another noteworthy point is that the recent Dream Job campaign employs an updated malware chain that, since around 2024, has primarily involved MISTPEN and ForestTiger rather than the earlier arsenal that included tools such as TechHub and Cubridge. However, the updated versions of this older malware have now re-emerged as part of Operation FlashHole. Considering these changes and all aspects of each attack’s TTPs, we have organized a classification for each attack. Overlaps between the recent attacks by Lazarus Group Conclusion Our analysis shows that the Lazarus Group begins preparing for its next operation shortly after completing the previous one, ultimately deploying an enhanced malware chain by refining existing tools. The group continues to use the advanced version of LPEClient for profiling and payload delivery, indicating that the tool is meticulously managed and well maintained. Ironically, the group seems to have adopted more secure post-quantum cryptography faster than many legitimate security products. These observations suggest the involvement of a dedicated developer, with others orchestrating comprehensive attack scenarios against newly targeted software. We anticipated that specialized attacks targeting South Korea would persist. However, we did not foresee multiple attack campaigns being executed simultaneously, each leveraging different types of software and tools. Notably, the COPPERHEDGE cluster appears to be involved in monetizing the attacks, while Operation FlashHole is focused on espionage. We are closely monitoring these changes to understand their motivations and ultimate goals. In October 2025, the South Korean government unveiled a comprehensive cybersecurity plan that will phase out the mandatory installation of security software for users beginning in 2026. We estimate that operations exploiting this software will remain highly active for some time, maximizing efficiency, before the software is fully eliminated or mitigated. Kaspersky products detect the exploits and malware used in this attack with the following verdicts: MEM:Trojan.Win64.Shellcode.gen, Trojan.Win64.DLLhijack.*, Trojan.Win64.Lazarus.*. Indicators of compromise File hashes TouchShift ec84d6cb2ae7974767aedac246b50a3e              mscoree.dll a28cba214058fcae2883d8cffc883abd                 mscoree.dll c105d6b16f544582772de0159f24c00a                mscoree.dll 2f8475a90a25624ed02f1d18d4e6d65d               mscoree.dll 676fabe30a28b53925fba98e34b35986               mscoree.dll b4a7eff35f048f06fb0a2d7631f23a7d                   mscoree.dll ClientHub Loader ff07641dc56914dd90ee0bd7404d7ad7                liblzma.dll File paths C:\ProgramData\Dell\Dell1.tmp C:\ProgramData\Dell\Dell3.tmp C:\ProgramData\Package.txt C:\ProgramData\RasConv\mscoree.dll C:\ProgramData\Apple\mscoree.dll C:\ProgramData\ssh\mscoree.dll C:\ProgramData\qorestor\mscoree.dll C:\ProgramData\Dell\mscoree.dll C:\ProgramData\Dell\Dell1.tmp C:\ProgramData\Dell\Dell3.tmp C:\Windows\System32\RasConv\mscoree.dll C:\Windows\System32\RasConv\ActivationStore.dat C:\Windows\System32\DrvConh\mscoree.dll C:\Windows\System32\DrvConh\ActivationStore.dat C:\Program Files\Common Files\System\msadc\msadc.inc C:\ProgramData\desktops.ini C2 servers javadevhouse.co[.]kr pythonapischool[.]com hxxps://cubedesign[.]co[.]kr/news             C2 of Cubridge hxxps://cubedesign[.]co[.]kr/mobile/fashion             C2 of Cubridge hxxps://fp-news[.]co[.]kr/shop/cart                                 C2 of Cubridge hxxps://k-wbc[.]co[.]kr/skin/social/social_view.php          C2 of ClientHub hxxps://rcsh[.]co[.]kr/modules/bbs/tiles/bbs_div/inputForm.php     C2 of ClientHub hxxps://www[.]ksog[.]org/insert_file/handle.php                    C2 of ClientHub
securelist.comOct 21, 2026extracted
What your vendor says about PQC tells you if they are ready
What your vendor says about PQC tells you if they are ready In this interview with Help Net Security, Dr. Yaakov Stein, VP CTO of Allot, discusses what post-quantum readiness looks like inside a mobile network. The discussion covers which operator traffic stays sensitive for years, including subscriber identity mappings, billing records and call metadata, and which becomes worthless within hours. It walks through the order of work, starting with a crypto inventory and hybrid key exchange on TLS interfaces, then IPsec links. It also names the vendor answers that should raise suspicion and explains why a missed interface is the likely point of failure. When you sit with a carrier’s security team, how do you help them sort traffic that has a long confidentiality shelf life from traffic that does not? What ends up in the long-life bucket that surprises them? Traffic shelf-life is one of the terms in Mosca’s equation for PQC readiness urgency, and is thus important to estimate. While most operator control traffic becomes stale very quickly, there are several types of signaled operator metadata that can remain sensitive for years, such as subscriber identity mappings, billing records, and call metadata. Of course, any traffic that may reveal personal or system passwords is high on the list. Some types of core traffic may reveal internal topology information to potential attackers and exposing some interfaces may impact long-term relationships between operators. Subscriber voice calls, web browsing and streaming are worthless within hours. Subscriber financial transactions such as credit card information remain sensitive for at least several years, their protection is best handled by the subscriber’s browser or app. A tier-two mobile operator with no post-quantum program calls you on a Monday. Walk me through weeks one through twelve. Just as useful: what do you tell them to deliberately not do yet? I’m not sure that each task can be confined to single weeks, so I will itemize tasks. The first task is creating a comprehensive inventory of all public-key crypto usage. This includes identifying 5G SBA interfaces, IKE for IPsec-protected links, DNSsec, encrypted APIs, etc.; compiling a comprehensive list will save time and effort later. The 2nd step is migrating everything using TLS (including SBA interfaces, SEPP, web portals and OSS/BSS APIs) to hybrid key exchange; this is the most readily available technology. This should be followed by similarly migrating IPsec links, including backhaul, inter-DC and LTE roaming interfaces. Next (4th week), all other protocols relying on public keys, including proprietary ones. After all key exchanges are covered, one can start considering authentication of long-lived connections. These can tolerate the overhead of the huge public keys of currently standardized PQC digital signatures. For now, software authentication of short-lived connections can wait. Hardware authentication and attestation mechanisms need to hang on vendors being ready. And operators need not worry about ordinary subscribers, although enterprise and governmental customers may have special needs. 5G subscriber authentication rests largely on symmetric keys, but the PKI around it does not. If an operator can only do one PQC deployment this year, where in the core should it go, and why there? As I already mentioned, the low-hanging fruit is TLS key exchange. Deploying hybrid ML-KEM (X25519 ECC with ML-KEM, and if possible with crypto-agile backup to HQC) on all TLS-protected SBA and management-plane interfaces is the single easiest and most impactful PQC measure for any operator. What vendor answer to a PQC question should be treated as a warning sign? I would like the exact sentences that make you suspicious. Other than “we don’t yet support PQC”, the worst response a vendor can give is “we are waiting for the standards to stabilize”. While it is true that the RFCs are not all yet finalized, PQC is being standardized faster than any major innovation in telecom history. And there crypto-agility is the key to future-proofing, not delaying. The next worse responses are “but cryptographically relevant quantum computers are still not here”, and “our encryption is based on symmetric encryption and so quantum safe”, both of which indicate either lack of understanding or purposeful deception. What is the most likely way an operator’s migration goes wrong? Not the cryptographic break, the boring operational failure. This harks back to an issue we emphasized in a previous answer – the preparation of a comprehensive crypto inventory. An operator can upgrade most of its security mechanisms but miss an interface, such as an SSH accessible machine, an old RADIUS interface, a load balancer or NAT, some orchestration tool no-one has touched in years, etc. The operator then gains a false sense of PQC security, but of course PQC readiness is only as safe as the weakest link. But there is another issue as well. Some of the newer mechanisms can break assumptions of legacy equipment. This is what happened when Kyber was first introduced – its multi-packet TLS client hello broke assumptions of various middleboxes, and it had to be rolled back. Download: The ultimate guide to network operations management
helpnetsecurity.comSep 1, 2026extracted
Lazarus Used Post-Quantum Key Exchange to Deliver Zero-Day
Malware used by North Korea's Lazarus group negotiated its command channel using a post-quantum key exchange before pulling down a Windows zero-day exploit, in a campaign against defense and aerospace companies across Europe and India. Check Point Research reported the vulnerability to Microsoft on July 28 and published its analysis on August 11, the day a patch shipped. CVE-2026-68820 is a use-after-free race condition in AFD.sys, the driver handling network sockets in the Windows kernel, and was the only flaw in this the August Patch Tuesday release Microsoft flagged as under active exploitation. The activity is the latest wave of Operation Dream Job, which approaches employees at defense firms with fraudulent job offers. Targets included organizations working on surveillance sensors, drones and robotics, with activity or targeting in France, Germany, Brazil and India. Four Keys and a Layered Handshake Infection ran through MISTPEN, an in-memory downloader that communicates via attacker-controlled files on OneDrive using the Microsoft Graph API. After reconnaissance and persistence stages, it loaded a dedicated module to fetch the privilege escalation exploit. That module fingerprinted the host, then requested four public keys from the command server. It used them to generate fresh key material with Kyber/ML-KEM, the key encapsulation scheme NIST standardized in 2024 to resist attack by quantum computers, returning the encapsulated result before requesting the exploit itself, which it decrypted and ran in memory. Traffic through that channel carried a second encryption layer using GOST-CBC, on top of MISTPEN's own AES transport encryption. What arrived through the handshake was FudModule, Lazarus's kernel rootkit, in a build Check Point tracks as v3.1.It disables telemetry callbacks, removes minifilters, kills the NT Kernel Logger and blinds 94 Event Tracing for Windows (ETW) providers. Newly added is tampering with Smart App Control, resetting its policy state and forcing a code integrity reload. Command and Control on Borrowed Servers The group ran its infrastructure almost entirely on machines it did not own, using Roundcube webmail servers exploited through CVE-2025-49113 with credentials likely sourced from dark web leaks, alongside compromised PrestaShop sites. Each hosts RelayShell, a previously undocumented PHP webshell that acts as a message relay rather than a conventional command shell, passing traffic between operator and victim through session files. Check Point found evidence of at least 17 compromised relay servers. Delivery has also shifted. The group built at least three websites impersonating privacy technology vendor Enveil, some ranking top in search results. Check Point stressed Enveil was neither targeted nor compromised. Those sites distributed a trojanized PDF viewer that runs a payload hidden inside crafted documents, delivering Troy, a previously undocumented backdoor supporting 17 operator commands.
infosecurity-magazine.comAug 12, 2026extracted
Shattering the Dream – When a Job Offer Becomes a Zero-Day Attack
Shattering the Dream – When a Job Offer Becomes a Zero-Day Attack August 11, 2026 Key Points Check Point Research is tracking a long‑running campaign called Operation Dream Job, targeting organizations worldwide, with a particular focus on the defense sector. The campaign is affiliated to DPRK-linked Lazarus group and its latest wave focuses on the defense sector in Europe and India. In the latest variant of the Operation Dream Job campaign, the threat actor distributed SecurityPDF, a modified PDF viewer designed to open attacker-crafted PDF documents and execute a new backdoor which we named Troy. During the intrusion, the threat actor exploited CVE-2026-68820, a zero-day vulnerability in the Microsoft AFD.sys driver, to deploy a new version of FudModule, Lazarus’ kernel-mode rootkit. Following Check Point Research responsible disclosure, Microsoft released a patch as part of their August Patch Tuesday updates. Lazarus also used CVE-2025-49113 to exploit vulnerable Roundcube webmail servers. The compromised servers were infected with RelayShell, a PHP webshell that repurposes compromised web servers as relay nodes within the attacker’s command-and-control infrastructure. At least in one case, a compromised organization in Western Europe was leveraged to conduct a spear-phishing campaign, allowing the attackers to abuse the organization’s reputation and trust to target additional victims. Introduction Since early 2026, Check Point Research has tracked a wave of the Operation Dream Job campaign. This wave primarily targeted the defense sector worldwide, with a particular emphasis on companies operating in the aerospace and aviation industries. We observed the threat actor distributing modified PDF viewers designed to execute malicious payloads embedded within specially crafted PDF files, opened by the user. In this campaign, the threat actor expanded its delivery method by leveraging impersonation websites and search engine optimization (SEO) techniques to distribute the trojanized applications, increasing its credibility and helping it evade some phishing-based detections. During the operation, the threat actor deployed a new version of the FudModule rootkit, exploiting a zero-day local privilege escalation (LPE) vulnerability in the Windows AFD.sys driver, to obtain SYSTEM privileges and disable EDR visibility. Following responsible disclosure, Microsoft assigned the vulnerability CVE-2026-68820 and released a patch on August 11, 2026, as part of their August Patch Tuesday updates. The attackers’ command-and-control infrastructure consists of compromised Roundcube and WordPress servers hosting RelayShell, a new PHP webshell that repurposes compromised web servers as relay nodes. In this blog, we analyze the latest Operation Dream Job campaign, walking through the complete attack chain and providing a technical analysis of the malware and the novel techniques employed throughout the operation, offering new insights into the group’s evolving modus operandi. Infection Chain The Operation Dream Job campaign begins with targeted spear-phishing lures centered on attractive job opportunities at well-known companies in the defense, aerospace, and aviation industries. The exact method used to approach victims in the current campaign remains unclear. However, based on previously documented Dream Job campaigns, we assess that the threat actor likely approached targets through professional networking platforms such as LinkedIn, or directly through messaging applications. Posing as recruiters, the attackers present enticing job opportunities and ultimately direct victims to download malicious files. During our analysis, we identified two distinct infection chains used to compromise targets. While the second chain appears to represent a more recent evolution of the campaign, both infection methods remain active in parallel. Infection Chain 1: DLL Sideloading chain In this infection chain, the victim is convinced to download an encrypted zip archive containing three files: A legitimate, digitally signed PDF viewer executable. A malicious DLL that is loaded through DLL sideloading. An encrypted payload with a PDF extension. When the victim launches the executable, the malicious DLL libmupdf.dll is loaded via DLL sideloading. The DLL extracts a decoy PDF document from the encrypted payload and displays it to the user, while simultaneously extracting, decrypting, and executing an embedded payload directly in memory. The executed payload is MISTPEN, a lightweight in-memory downloader that uses Microsoft Graph API to access OneDrive in order to retrieve additional modules and run them in memory. Reconnaissance: During the initial stages of the infection, the threat actor deploys several reconnaissance modules that collect system and process information, allowing the attacker to verify that the system is a suitable target before proceeding with the next stage of the attack. Persistence: Once the target has been validated, MISTPEN receives an additional persistence module that installs the malware on disk and ensures that MISTPEN is automatically executed after system reboot. Privilege Escalation: After persistence is established, MISTPEN loads an in-memory local privilege escalation (LPE) module designed to exploit the zero day vulnerability CVE-2026-68820 in the Microsoft AFD.sys driver. Successful exploitation allows the malware to execute FudModule, Lazarus’ kernel-mode rootkit, with SYSTEM privileges. Backdoor Deployment: The final backdoor delivered by MISTPEN is the ForestTiger backdoor, a well-documented malware family widely attributed to the Lazarus threat group. Once deployed, it provides the attackers with long-term remote access to the compromised host. Infection Chain 2: Trojanized PDF viewer In July 2026, we observed a new campaign sharing many characteristics with previously documented Operation Dream Job, particularly the campaign described by ESET in 2025. In this infection chain, victims receive fraudulent job offers impersonating Enveil, a Privacy Enhancing Technology company, and are instructed to download an encrypted ZIP archive containing two files: SecurityPDF – a trojanized PDF viewer that has been modified to extract and execute an encrypted payload from specially crafted PDF documents. A malicious PDF file – an encrypted payload disguised as a PDF document that is decrypted and executed when opened with the modified viewer. SecurityPDF is a trojanized version of a legitimate open-source PDF viewer built on the MuPDF framework. The threat actor modified two code paths responsible for opening PDF documents: the File → Open dialog and the drag-and-drop file handling routine. As a result, whenever a user opens a PDF document, the application checks whether the file contains the following marker This document is encrypted with sumatrapdf reader!!!!!!!!!!!!. If the marker is present, the application extracts the embedded payload, decrypts it using a single-byte XOR key (0x39), writes the resulting executable to %TEMP%\new.exe, and launches it as a child process. The new.exe file is a small executable responsible for reflectively loading an embedded DLL containing the Troy backdoor, a previously undocumented backdoor first observed in this campaign. In addition, we identified at least three websites impersonating Enveil that distribute the trojanized PDF viewer. Some of these websites rank highly in search engine results, with some even appearing as the top result for relevant search queries. It is important to note that the attacker only impersonates Enveil, and there are no indications that the company was targeted or compromised. Although we did not directly observe how the threat actor incorporated these websites into the phishing campaign, we assess that they were likely used to separate the delivery of the trojanized PDF viewer from the delivery of the crafted PDF document. In this scenario, victims would first receive the malicious PDF file through a phishing message and later be instructed to download the PDF viewer from what appears to be the vendor’s legitimate website. Separating these infection chain stages reduces the likelihood of detection. MISTPEN MISTPEN is the first in-memory module executed during the attack chain. First documented by Mandiant in 2024, it functions as a lightweight downloader that uses the Microsoft Graph API to communicate through attacker-controlled files hosted on OneDrive and retrieve additional payloads All files exchanged through OneDrive are encrypted with AES, using separate keys for uploads and downloads. MISTPEN’s primary capability is the reflective loading of PE DLL files directly into memory, enabling the deployment of additional payloads without touching disk. Before delivering the final backdoor, MISTPEN often deploys several in-memory modules designed to perform specific tasks. These modules do not implement their own network communication mechanisms; instead, they execute their designated tasks and return the resulting data to MISTPEN, which uploads it to the C2. Below is a description of the modules we observed being loaded by MISTPEN during our analysis. GetInfoPlugin – Host Reconnaissance Module This module is a 64-bit Windows DLL internally named Release_GetInfoPlugin_x64.dll. Its primary purpose is to profile the compromised host and return the collected information as a single wide-character string. The module collects basic system information, including the machine’s domain or workgroup membership (via NetGetJoinInformation), the computer name, the current user name, and the operating system version and build number. The collected data is formatted in the following template and returned to MISTPEN: This module is a 64-bit Windows DLL internally named Release_PvPlugin_x64.dll. It serves as an extended version of the GetInfoPlugin module, collecting the same host reconnaissance data while adding detailed information about running processes. For each running process, the module collects the Process PID, PPID, creation timestamp, associated domain and user, and process name. The collected information is formatted into a tabular process list and returned to MISTPEN. OneScreenCapture – Screenshot Module This module is a 64-bit Windows DLL internally named OneScreenCapture64.dll, it is responsible for capturing the current desktop (including all monitors) and returns the screenshot to its caller. The module uses standard Windows USER32 and GDI APIs to capture the virtual desktop into a bitmap. The bitmap is then converted to a JPEG image and Base64-encoded into a single wide-character string before being returned to MISTPEN for exfiltration. LPE loader This module is a 64-bit Windows DLL that acts as a loader for a local privilege escalation (LPE) exploit module. It is loaded by an extended version of MISTPEN that provides it with an RPC buffer used for communication between the two components. Messages written to this buffer are forwarded by MISTPEN to the attacker through its existing Microsoft Graph API communication channel, while responses received from the C2 are relayed back to the module through the same interface. In addition to MISTPEN’s AES-based transport encryption, the module encrypts all exchanged data using GOST-CBC with a randomly generated 16-byte session key. The encrypted data is then Base64-encoded, with the session key prepended to each packet. The module operates in four stages: Host Fingerprinting – The module gathers detailed information about the compromised host, including the operating system version, build number, installed security products, and other system characteristics. Key Exchange – The module requests a set of four public keys from the C2 server. Session Key Generation – Using the received public keys, the module generates new key material using the Kyber/ML-KEM algorithm and transmits the resulting encapsulated key material back to the C2. LPE Deployment – Finally, the module requests the encrypted LPE payload, decrypts it using the negotiated key, and executes it directly in memory with export DestroyEnv. Throughout the process, status messages are sent back to the C2 to indicate whether each stage of the exploitation succeeded. The downloaded LPE payload is FudModule, Lazarus’ kernel-mode exploit module. It exploits a local privilege escalation vulnerability to obtain SYSTEM privileges and injects a payload into a SYSTEM process. In the observed attack, the injected payload was another instance of MISTPEN, allowing the malware to continue operating with elevated privileges and without EDR visibility. CVE-2026-68820: Yet another Zero-Day discovered by Lazarus The file we investigated, Afd4Eop12_x64.dll, has a compiler timestamp of July 7, 2026, 22:07:44 UTC. Its strings immediately suggest a variant of FudModule, including references such as “enable_god_mode passed.” and a main function similar to previous Fud Modules. FudModule is a Lazarus privilege escalation tool, reported and being used since around 2021. The module targets afd.sys, the Windows Ancillary Function Driver, a part of the Windows kernel that is in charge of managing and handling sockets in Windows. In 2024, FudModule was reported to use another zero-day, CVE-2024-38193, a use-after-free vulnerability in the same afd.sys driver. At first sight, the vulnerability looked similar to CVE-2025-60719, which is also a use-after-free vulnerability in the AFD.sys driver fixed in November 2025 and not linked to any particular threat actor. In the sample itself, we observed an explicit minimum-version check for Windows 11build 26100 (24H2), with explicit support also for build 26200 (25H2). However, testing on the latest fully patched Windows 11 system confirmed that the exploit targets a distinct, previously undocumented vulnerability, actively being used in the wild as a part of Operation ‘Dream Job’ since at least early July 2026. We will not be disclosing full technical details of the vulnerability in this article, as it was patched on the August 11 Patch Tuesday fix. At a high level, the exploit takes advantage of how afd.sys handles a socket is created when it is accessed concurrently by several threads at once. The driver maintains a small piece of information about the state associated with each socket. Under specific concurrent conditions, two of its own code paths can operate on this state at the same simultaneously, without synchronization, creating a race condition If triggered at the right moment, one code path can access memory after it has already been released by another, resulting in a use-after-free vulnerability. From there, the module does what these modules do – it leverages this memory corruption to obtain a kernel read/write primitive, which is subsequently used to achieve local privilege escalation to SYSTEM. We disclosed the issue to Microsoft, and Microsoft issued a fix quickly. Disclosure timeline Jul 28, 2026: Issue reported to the Microsoft Security Response Center (MSRC). Jul 31, 2026: Microsoft confirmed the bug Aug 5, 2026: Microsoft assigned CVE-2026-68820 to the issue. Aug 11, 2026: Fixed on Patch Tuesday. FudModule v3.1 Except for a novel, completely different exploit chain, this FudModule’s post-exploitation behavior is quite similar to FudModule v3, reported by Gen Digital back in 2024. Shared with v3 The entire telemetry teardown suite: process, thread, and image notify callbacks; object and registry callbacks; minifilter removal by altitude band; and the termination of the NT Kernel Logger. Crash-dump suppression, executed before everything else. The WFP stage, which is activated when Kaspersky is present and Symantec is absent. The hardcoded ETW provider kill-list: its 94 GUIDs match the first 94 entries of Gen’s published 95-GUID list, in identical order. The driver selection engine, with the same universal preserve list and per-class keep and kill rules. Privileged-handle forgery and the same two-hop spawn through services.exe into a SYSTEM msiexec.exe process. Logging vocabulary, surviving essentially string-for-string, including: GetGodMode failed, GetSystemHandle passed., CreateRemoteProcess passed., RemoteDllExecute passed., and the ClearVaccine* family. Functionality removed from v3 The dedicated Microsoft Defender stage used to disable monitoring of MsMpEng.exe. Only the orphaned string SuspendDefender passed. remains, and is no longer referenced by executable code, while Gen’s FudModule v3 YARA rule contains the active-stage variant SuspendDefender skipped. The PPL stripping functionality targeting AhnLab’s asdsvc.exe. Microsoft Defender is still blinded here, but only through the generic security-product suppression engine, like any other vendor, rather than through a dedicated Defender-specific stage. New functionality since v3 A Smart App Control tampering functionality not documented in publicly analyzed FudModule versions through v3. Within the SYSTEM-level msiexec.exe child process, its remote stub sets VerifiedAndReputablePolicyState to zero and invokes NtSetSystemInformation class 0xA4 with option 0x10000000, triggering an in-place reload of the code integrity policy. Targeting As mentioned before, this version only targets newer Windows builds 26100/26200, unlike the previous version that also targeted older ones. Troy Backdoor The Troy backdoor is a newly identified modular remote access trojan in Lazarus’ arsenal. Delivered as a 64-bit DLL, it supports 17 operator commands, providing a broad range of remote access and post-exploitation capabilities. The name Troy is derived from a PDB path embedded in the sample: E:\HK\Tool_Module\Troy_Handle\1Troy_Create_Dll_Tool\x64\Release\Test_Dll.pdb. Notably, the term Troy has also appeared in PDB paths associated with previously documented Lazarus samples. For example, an ESET report published last year documented a sample containing a PDB path E:\Work\Troy\안정화\... The Troy backdoor supports three Command and Control (C2) servers, each configured with a URL and port. At startup, the implant iterates through the configured servers in order, parsing each URL into its host and path components, establishing an HTTP connection, and issuing a connection request. It validates the response against the string CONNECTED and uses the first server that responds successfully. The initial connection is followed by a challenge-response handshake used to authorize the implant against the server. Once authenticated, Troy collects host information and registers the victim by sending a client identifier and a system profile containing the user profile directory, account name, Windows version, local IPv4 address, and current working directory. Following registration, Troy enters its command-processing loop. Tasks received from the C2 server are Base64-encoded; the implant decodes them and identifies commands using plaintext prefix matching. Command results are returned through the send channel in a compact JSON envelope: { "to":" ", "msg":" " }. Responses that exceed the maximum message size are divided into numbered chunks and reassembled on the C2 side. The Troy backdoor provides a notably broad feature set for a single-DLL implant, and a cohesive design. Its seventeen supported commands span the capabilities required for each stage of post-compromise operations, from initial reconnaissance and file operations, to command execution and in-memory code delivery, while following a consistent tasking and result-framing model throughout. Troy Backdoor Supported C2 Commands Compromised Infrastructure Used as ForestTiger C2 As previously reported, ForestTiger’s C2 infrastructure has historically relied primarily on compromised servers mainly running WordPress and SharePoint. In more recent campaigns, the threat actor appears to have shifted toward using compromised Roundcube webmail servers as C2 infrastructure. The majority of the Roundcube servers we analyzed were running versions vulnerable to CVE-2025-49113, a critical PHP Object Deserialization vulnerability that can lead to remote code execution (RCE). Exploitation of this vulnerability requires authentication with valid Roundcube credentials. During our investigation, we identified several credential leaks that are available in the Darkweb, and contain usernames and passwords associated with accounts on the compromised webmail servers. We assess that the threat actor likely leveraged these credentials to authenticate to the affected Roundcube instances before exploiting CVE-2025-49113 to deploy RelayShell web shells, which subsequently serve as a C2 relay mechanism. In addition, we observed the threat actor compromise PrestaShop websites and deploy the same RelayShell web shell. RelayShell Following the post-exploitation of a web server, the threat actor deployed a previously undocumented PHP web shell that we named RelayShell. Unlike a traditional web shell that provides direct command execution, RelayShell primarily acts as a communication relay between the threat actor and an infected endpoint. RelayShell operates in two distinct modes, selected by the password supplied in the HTTP POST request. For clarity, we refer to these as Victim mode and Operator mode. Victim Mode When accessed using the victim password, RelayShell creates a new PHP session that is subsequently used for communication with the infected endpoint. The webshell then decrypts a hidden configuration stored in an external file using a custom substitution cipher. The configuration contains two values: A backbone URL A unique identifier (PID) assigned to the compromised server RelayShell then immediately sends an HTTP POST request to the configured backbone URL using the unique identifier and authentication password. Based on our analysis, the backbone URL appears to point to another RelayShell instance acting as an upstream relay or notification server. This request signals that a new victim session has been established, allowing the operator to subsequently connect using the second password. Operator Mode When accessed using the operator password, RelayShell enters operator mode, providing a set of commands for interacting with the compromised server. These commands support session management, connectivity checks, file upload and deletion, and retrieval of activity logs. File-Based Communication Channel After both the victim and operator sessions are established, RelayShell provides two commands, send and receive, which implement a lightweight file-based communication channel using temporary files stored on the compromised server. Messages are exchanged through files following the naming convention .log where object identifies the side of the communication channel: 1 for the victim and 2 for the operator. When sending data, RelayShell writes the supplied content to the session file corresponding to the sender. When receiving data, RelayShell reads and returns the contents of the file corresponding to the opposite side, creating a bidirectional communication between the victim and the operator. This mechanism effectively turns the compromised web server into a relay node. The victim-side implant establishes the session and notifies the backbone server that is monitored by the threat actor , after which the actor connects to the RelayShell instance and exchanges commands and responses through the file-based messaging channel. During our investigation, we observed the threat actor accessing RelayShell through shared VPN services, including ExpressVPN, further obscuring the origin of their infrastructure. We also identified 17 unique identifiers, suggesting that at least 17 compromised servers were likely used as relay nodes during the campaign. However, we were unable to identify all of the affected servers. Victimology This new Operation Dream Job campaign focused heavily on the defense sector, particularly organizations involved in military technologies such as surveillance sensors, drones, and robotics. The campaign had a global reach, with activity extending into South America, including Brazil, and successful targeting observed in Western Europe, including France and Germany. During the campaign, a compromised organization headquartered in France was later leveraged by the threat actor to conduct spear-phishing attacks against targets worldwide, likely to increase the perceived campaign’s authenticity and credibility. Another notable target was India, which has a substantial and rapidly growing defense and aerospace industry, with expanding domestic production and technology exports. Conclusion The latest Operation Dream Job campaign demonstrates that Lazarus continues to evolve both its malware capabilities and operational tradecraft. Beyond deploying a new version of FudModule that exploits the CVE-2026-68820 zero-day vulnerability, the threat actor also refined its initial access techniques by combining targeted spear-phishing with impersonation websites and search engine optimization (SEO) to distribute trojanized software. The threat actor’s decision to rely on compromised Roundcube instances and content management system (CMS) servers for C2 reflects an operational approach well suited to highly monitored defense-sector environments, where network activity may be closely inspected by organizational security teams as well as government and national cybersecurity authorities. By abusing legitimate web infrastructure, the threat actor can better blend malicious communications within normal network traffic. Our findings highlight Lazarus’s continued evolution toward stealthier and more resilient operations, combining new delivery techniques, modular malware, zero-day exploitation, and compromised web infrastructure. We believe the technical details presented in this research will help defenders identify, detect, and disrupt future Operation Dream Job campaigns. “The Turkish Rat” Evolved Adwind in a Massive Ongoing Phishing Campaign Check Point Research Publications August 11, 2017 “The Next WannaCry” Vulnerability is Here Check Point Research Publications March 12, 2026 “Handala Hack” – Unveiling Group’s Modus Operandi SUBSCRIBE TO CYBER INTELLIGENCE REPORTS We value your privacy! BFSI uses cookies on this site. We use cookies to enable faster and easier experience for you. By continuing to visit this website you agree to our use of cookies.
research.checkpoint.comAug 11, 2026extracted
Transizione post-quantum: l’evoluzione degli standard crittografici per la tutela dei dati aziendali
C’è una domanda che i responsabili della sicurezza informatica nei settori critici dovrebbero porsi con urgenza: quanti anni hanno i dati che l’organizzazione deve proteggere? Se la risposta è «più di dieci anni» – e per dati sanitari, segreti industriali, informazioni governative riservate, dati finanziari a lungo termine la risposta è quasi sempre sì – allora la crittografia post quantum non è un problema per il futuro. È un problema di oggi. La ragione è semplice: la minaccia quantistica alla crittografia non richiede che i computer quantistici crittograficamente rilevanti esistano oggi. Richiede solo che esistano prima che i dati che state proteggendo ora perdano il loro valore. Se un attore criminale sta raccogliendo oggi il vostro traffico cifrato con RSA-2048 o ECDH (ad esempio, comunicazioni TLS, VPN, e-mail cifrate) e lo conserva in attesa di avere la potenza di calcolo quantistica per decifrarlo, i dati contenuti in quel traffico saranno accessibili nel momento in cui i computer quantistici diventano disponibili. La finestra temporale stimata dagli esperti più credibili, tra cinque e quindici anni, è esattamente sovrapposta alla vita utile di molti dei dati che le organizzazioni proteggono oggi. Indice degli argomenti La crittografia post quantum (PQC, Post-Quantum Cryptography) è l’insieme degli algoritmi crittografici progettati per resistere agli attacchi di computer quantistici. La distinzione rispetto alla crittografia quantistica (QKD, Quantum Key Distribution) è fondamentale e spesso confusa: la PQC usa computer classici per implementare algoritmi matematicamente resistenti agli attacchi quantistici; la QKD usa proprietà fisiche della meccanica quantistica per distribuire chiavi crittografiche. Sono approcci complementari, non alternativi, ma la PQC è quella rilevante per la grande maggioranza delle organizzazioni perché non richiede infrastrutture hardware specializzate e può essere implementata come aggiornamento software. La vulnerabilità della crittografia attuale ai computer quantistici deriva dall’algoritmo di Shor, pubblicato nel 1994 da Peter Shor, che dimostra come un computer quantistico sufficientemente potente possa risolvere in tempo polinomiale i problemi matematici su cui si basa la sicurezza degli algoritmi crittografici asimmetrici più diffusi: la fattorizzazione di grandi numeri interi (base di RSA) e il logaritmo discreto su curve ellittiche (base di ECDH, ECDSA, EdDSA). Gli algoritmi simmetrici (AES, ChaCha20) sono significativamente meno vulnerabili: l’algoritmo di Grover offre un vantaggio quadratico nella ricerca della chiave, ma è sufficiente raddoppiare la lunghezza della chiave (da AES-128 a AES-256) per mantenere un livello di sicurezza adeguato. La strategia HNDL (Harvest Now, Decrypt Later), ossia raccogliere ora, decifrare dopo, è la minaccia quantistica che rende l’urgenza della transizione PQC immediata, indipendentemente da quando i computer quantistici crittograficamente rilevanti diventeranno disponibili. L’attacco è concettualmente semplice: un attore criminale, tipicamente un’entità con risorse significative e un orizzonte temporale lungo, come un servizio di intelligence statale, intercetta e conserva grandi volumi di traffico cifrato oggi, con l’intenzione di decifrarlo in futuro quando disporrà della potenza di calcolo quantistica necessaria. Le evidenze che questa strategia sia già in atto non sono speculative. Il National Counterintelligence and Security Center americano ha avvertito esplicitamente che avversari sofisticati stanno raccogliendo dati cifrati in previsione della disponibilità di computer quantistici. La natura dei dati di maggiore interesse per queste operazioni include comunicazioni diplomatiche e governative riservate, proprietà intellettuale di alto valore (brevetti, ricerca e sviluppo, segreti industriali), dati sanitari di lungo termine e infrastrutture di autenticazione (certificati radice, chiavi PKI) che, se compromesse, potrebbero invalidare retroattivamente tutta la catena di fiducia basata su di esse. L’impatto della minaccia quantistica non è uniforme su tutti gli algoritmi crittografici. Gli algoritmi asimmetrici (RSA, DSA, DH, ECDH, ECDSA, EdDSA) sono quelli direttamente vulnerabili all’algoritmo di Shor e dovranno essere sostituiti nella loro interezza. Non esiste una lunghezza di chiave sufficiente per renderli sicuri contro un computer quantistico: la vulnerabilità è strutturale, non parametrica. RSA-4096 non è significativamente più sicuro di RSA-2048 contro un computer quantistico; semplicemente richiede qualche qubit in più per essere attaccato. Gli algoritmi simmetrici (AES, 3DES, ChaCha20) e le funzioni hash (SHA-256, SHA-3) sono vulnerabili all’algoritmo di Grover, che offre un vantaggio quadratico nella ricerca esaustiva. La difesa è semplice: raddoppiare la lunghezza della chiave o del digest porta il livello di sicurezza allo stesso valore pre-quantistico. AES-256 è considerato quantum-safe; AES-128 offre 64 bit di sicurezza contro un attaccante quantistico e potrebbe non essere sufficiente per dati con lunga vita utile. SHA-256 offre 128 bit di sicurezza quantistica – generalmente considerato adeguato – mentre SHA-384 e SHA-512 offrono margini ulteriori. Il 13 agosto 2024 il National Institute of Standards and Technology americano ha pubblicato i primi tre standard post-quantum definitivi: FIPS 203 (ML-KEM, basato su Kyber), FIPS 204 (ML-DSA, basato su Dilithium) e FIPS 205 (SLH-DSA, basato su SPHINCS+), con il quarto standard FIPS 206 (FN-DSA, basato su FALCON) pubblicato nelle settimane successive. Questa pubblicazione, il risultato di un processo di standardizzazione durato otto anni con la partecipazione di centinaia di ricercatori da tutto il mondo, segna la fine della fase di ricerca e l’inizio della fase di implementazione: le organizzazioni hanno ora standard stabili su cui basare le proprie migrazioni. La pubblicazione degli standard NIST ha avuto un effetto catalizzatore immediato sul panorama normativo globale. NSA (National Security Agency) ha pubblicato linee guida che impongono alle agenzie governative americane di avviare la migrazione PQC entro scadenze specifiche. Il BSI tedesco ha aggiornato le proprie linee guida tecniche per raccomandare l’adozione degli algoritmi NIST PQC. ENISA ha pubblicato un report sulla preparazione post-quantum dell’Unione Europea. In Italia, ACN ha incluso riferimenti alla transizione PQC nelle proprie linee guida per i settori critici NIS2, segnalando che la quantum readiness sarà un elemento progressivamente rilevante nelle valutazioni di conformità. La scelta degli algoritmi PQC per una specifica applicazione dipende da diversi fattori: le dimensioni delle chiavi e delle firme (ML-KEM e ML-DSA hanno dimensioni significativamente maggiori rispetto a ECDH e ECDSA, con impatti sulle performance e sulla latenza di rete); i vincoli computazionali del dispositivo (FN-DSA è più efficiente per dispositivi con risorse limitate ma più complesso da implementare correttamente); i requisiti di interoperabilità con sistemi esistenti. Per la maggior parte delle organizzazioni che devono scegliere un punto di partenza pratico, ML-KEM per lo scambio delle chiavi e ML-DSA per le firme digitali sono la coppia raccomandata come baseline della migrazione PQC. Il quadro normativo europeo sulla crittografia post-quantum è in fase di rapida evoluzione. La Raccomandazione della Commissione Europea sulla transizione PQC (C(2024) 842), pubblicata a febbraio 2024, stabilisce che gli Stati membri devono iniziare la pianificazione della transizione agli algoritmi PQC per le infrastrutture critiche, con particolare urgenza per i sistemi che gestiscono dati classificati o dati con requisiti di riservatezza a lungo termine. La Raccomandazione non è vincolante, ma segnala l’orientamento normativo che si tradurrà progressivamente in obblighi attraverso i regolamenti settoriali. Per i soggetti NIS2, il collegamento con la crittografia post-quantum emerge dall’obbligo di mantenere misure di sicurezza proporzionate al rischio: se le analisi di rischio identificano la minaccia HNDL come rilevante per i dati trattati dall’organizzazione (e per i soggetti essenziali nei settori sanitario, finanziario, energetico e delle infrastrutture critiche questo è quasi sempre vero) la pianificazione della transizione PQC è una misura di sicurezza che rientra negli obblighi dell’art. 21 del D.lgs. 138/2024. ACN ha già iniziato a citare la quantum readiness nelle proprie comunicazioni ai soggetti NIS2 come area di attenzione per i prossimi cicli di revisione. La migrazione verso la crittografia post-quantum è un progetto pluriennale che richiede pianificazione strutturata, coinvolgimento di molteplici funzioni aziendali e una roadmap realistica che tenga conto dei vincoli operativi, tecnologici e di budget. Non è un progetto che si può completare in pochi mesi, la complessità dell’inventario crittografico di un’organizzazione di medie dimensioni è tipicamente sottostimata, ma è un progetto che si può avviare immediatamente con passi concreti che producono valore anche prima che la minaccia quantistica diventi operativa. Il crypto asset inventory, ossia l’inventario completo di tutti i sistemi, applicazioni, protocolli e dati che utilizzano crittografia nell’organizzazione, è il prerequisito fondamentale di qualsiasi pianificazione della migrazione PQC. È anche il passo più sottovalutato: molte organizzazioni non hanno una visibilità completa su dove e come la crittografia viene utilizzata nella propria infrastruttura. La crittografia è pervasiva e spesso invisibile: TLS nelle connessioni web e API, IPSec nelle VPN, certificati X.509 nell’autenticazione, algoritmi di firma nel code signing, cifratura dei database, algoritmi di hashing nelle applicazioni, crittografia nelle comunicazioni email (S/MIME, PGP), chiavi crittografiche nei dispositivi IoT e OT. Il processo di inventario deve essere sistematico e coprire tutti i livelli dello stack tecnologico: infrastruttura di rete (VPN, TLS termination, load balancer); sistemi operativi e middleware (TLS stack, PKI interna, certificate management); applicazioni (ogni applicazione che usa librerie crittografiche, API di autenticazione, firma digitale), dati (database cifrati, backup cifrati, archivi a lungo termine); componenti hardware (HSM, TPM, smart card, token). Gli strumenti automatizzati per il crypto discovery, come Cryptosense Analyzer e Keyfactor Command, o strumenti open source come crt.sh per i certificati esposti su internet, possono accelerare significativamente questa fase, ma non sostituiscono completamente la revisione manuale per i sistemi più complessi. Le soluzioni ibride, che combinano algoritmi classici e PQC in parallelo nella stessa connessione o nella stessa firma, sono il meccanismo che consente di avviare la protezione PQC senza abbandonare la compatibilità con i sistemi che non supportano ancora gli algoritmi post-quantum. Un handshake TLS ibrido, ad esempio, negozia simultaneamente ECDH e ML-KEM, combinando i risultati in modo che la connessione sia sicura se anche uno solo dei due algoritmi rimane inviolato: sicura contro gli attacchi classici (perché ECDH è ancora computazionalmente difficile per computer classici) e sicura contro gli attacchi quantistici (perché ML-KEM è quantum-resistant). La sicurezza complessiva è il massimo tra le due. Questo approccio ibrido è già supportato in produzione da diversi stack tecnologici: OpenSSL 3.x con il provider OQS (Open Quantum Safe) supporta algoritmi PQC sperimentali in configurazione ibrida; Google Chrome e Cloudflare hanno sperimentato TLS post-quantum su larga scala; AWS, Azure e GCP stanno introducendo supporto PQC nelle proprie librerie crittografiche. Per le organizzazioni che gestiscono infrastrutture PKI interne, l’introduzione di certificati ibridi che includono sia una chiave ECDSA che una chiave ML-DSA nella stessa struttura consente di avviare la transizione senza interrompere la compatibilità con i sistemi che non supportano ancora il PQC. L’agilità crittografica, la crypto agility, è la capacità di un’infrastruttura IT di aggiornare gli algoritmi crittografici in uso senza richiedere una riscrittura estesa delle applicazioni o interventi manuali su larga scala. È il meta-obiettivo della transizione PQC: invece di migrare una volta da RSA a ML-KEM e considerare il problema risolto, costruire un’architettura che consenta di cambiare gli algoritmi rapidamente e in modo controllato ogni volta che uno di essi viene compromesso o deprecato. La necessità dell’agilità crittografica emerge dalla storia stessa della crittografia: MD5 era considerato sicuro, poi è stato rotto; SHA-1 era considerato sicuro, poi è stato rotto; RC4 era considerato sicuro, poi è stato rotto. Gli stessi algoritmi di crittografia post quantum attuali, per quanto solidi, potrebbero essere vulnerabili a future scoperte matematiche o a progressi nell’informatica quantistica non ancora anticipati. Un’organizzazione con agilità crittografica può rispondere a questi eventi in settimane; una senza agilità richiede anni. L’implementazione dell’agilità crittografica richiede scelte architetturali specifiche a livello di applicazione, middleware e infrastruttura. A livello applicativo, il principio fondamentale è la separazione della logica di business dalla logica crittografica: invece di chiamare direttamente le funzioni crittografiche nelle applicazioni (OpenSSL_RSA_encrypt(), ECC_sign()), si utilizza un layer di astrazione crittografica (una libreria o un servizio interno) che espone un’interfaccia stabile mentre gestisce internamente la scelta e la configurazione degli algoritmi. Quando gli algoritmi devono essere aggiornati, si aggiorna il layer di astrazione, non le applicazioni. A livello di PKI, l’agilità crittografica richiede la capacità di emettere, revocare e rinnovare certificati in modo automatizzato su larga scala. Un’organizzazione con migliaia di certificati gestiti manualmente non può rispondere rapidamente a un evento che richieda la sostituzione di tutti i certificati, sia esso una vulnerabilità negli algoritmi, una compromissione della CA, o una nuova direttiva normativa. L’automazione della gestione dei certificati attraverso protocolli come ACME (il protocollo di Let’s Encrypt) o piattaforme di certificate lifecycle management, è un prerequisito dell’agilità crittografica tanto importante quanto la scelta degli algoritmi stessi. La transizione post-quantum non riguarda solo l’infrastruttura interna dell’organizzazione: riguarda l’intero ecosistema di fornitori, partner e provider con cui l’organizzazione condivide comunicazioni cifrate, dati scambiati tramite API protette da TLS, o trust basate su certificati digitali. La sicurezza di una comunicazione cifrata è determinata dall’algoritmo più debole tra quelli usati dalle due parti: se l’organizzazione ha migrato a ML-KEM ma il proprio fornitore critico usa ancora RSA-2048 per le API che espone, la connessione rimane vulnerabile alla minaccia HNDL. Questo rende la gestione del rischio cyber dei fornitori software un elemento centrale della strategia di crittografia post quantum: la quantum readiness della supply chain è tanto importante quanto quella interna. Le implicazioni pratiche di questa interdipendenza sono significative. I dati scambiati con un fornitore attraverso una connessione TLS non PQC sono potenzialmente soggetti alla strategia HNDL anche se i sistemi interni dell’organizzazione sono stati migrati. I certificati firmati da una CA che usa RSA o ECDSA per la propria chiave radice saranno vulnerabili anche se i certificati foglia sono stati migrati a ML-DSA. Le firme digitali sui documenti contrattuali e sulle fatture elettroniche, basate su algoritmi classici, perderanno il loro valore legale di non-ripudio quando gli algoritmi sottostanti saranno compromessi. La catena di fiducia digitale è lunga quanto il suo anello più debole e, nel contesto della transizione PQC, ogni fornitore critico che non ha ancora pianificato la migrazione è un potenziale anello debole. Le attestazioni PQC, cioè le dichiarazioni formali da parte dei vendor software sulla propria roadmap di supporto agli algoritmi post-quantum e sullo stato della migrazione dei propri prodotti, stanno diventando un elemento emergente nel procurement IT dei settori più sensibili. L’approccio è analogo a quello già consolidato per le certificazioni ISO 27001 o SOC 2: richiedere evidenza formale che il vendor abbia un piano strutturato per la migrazione alla crittografia post quantum, con timeline documentate e impegni contrattuali sulle date di disponibilità del supporto. Le domande concrete da includere nei questionari di vendor assessment per la quantum readiness includono: quali algoritmi crittografici sono usati nei prodotti del vendor (TLS, firma, cifratura dei dati a riposo); qual è la roadmap di supporto agli algoritmi NIST PQC con date specifiche; il vendor ha condotto un crypto asset inventory dei propri prodotti; sono disponibili versioni ibride (classico + PQC) per facilitare la transizione; il vendor ha un processo di agilità crittografica che consente aggiornamenti rapidi degli algoritmi in futuro. Le risposte a queste domande consentono di classificare i vendor per maturità PQC e di prioritizzare le migrazioni in funzione del rischio combinato (dati scambiati × maturità PQC del vendor). La transizione alla crittografia post-quantum è il progetto di sicurezza con l’orizzonte temporale più lungo che le organizzazioni si trovano ad affrontare, ma è anche quello che tollera meno il procrastinare. La matematica della minaccia HNDL è implacabile: ogni giorno di ritardo nella pianificazione è un giorno in più in cui i dati critici vengono trasmessi in forme che potrebbero essere decifrate in futuro. Le organizzazioni che iniziano oggi, con l’inventario crittografico, la valutazione della minaccia HNDL sui propri dati, la pianificazione della migrazione ibrida e l’inclusione della quantum readiness nei propri processi di vendor assessment, saranno quelle meglio posizionate quando la minaccia quantistica diventerà operativa. E quella finestra, che sembra lontana, si sta chiudendo più rapidamente di quanto molti anticipino.
cybersecurity360.itJul 8, 2026extracted
Why Post-Quantum Cryptography Starts With Credentials
Today’s encrypted data, such as credentials, may no longer remain confidential in the future because the public-key cryptography protecting it will soon be broken by quantum computers. Although no machine today can break elliptic curve cryptography or RSA, quantum hardware is advancing rapidly and will inevitably change how organizations protect their data. Ciphertext and credentials captured by attackers can now be stored and decrypted as soon as quantum computing catches up. How urgent is quantum-resistant cryptography? The Global Risk Institute’s 2025 Quantum Threat Timeline report shows that surveyed security specialists believe a cryptographically relevant quantum computer is likely to be available within 15 years, with 51-70% indicating so. The threat dates back to 1994, when Peter Shor proved that a powerful quantum computer could efficiently factor large numbers and compute discrete logarithms. However, Shor’s algorithm applies to public-key cryptography, posing no meaningful threat to symmetric encryption like AES-256 or modern hashing. This distinction matters because public-key cryptography is what two systems use to establish trust and agree on the keys that protect their data. If a quantum computer can break that step, the attacker can unlock the protected data and credentials behind it. What makes the quantum threat relevant today, rather than solely in the future, is a tactic known as Harvest Now, Decrypt Later, in which an attacker captures encrypted traffic today, stores it, then decrypts it when a quantum computer is available. With a capable quantum computer plausibly available within 15 years, any data intercepted and harvested today should be treated as data already exposed. Q-day deadlines Even though it’s unclear exactly when a quantum computer will arrive, government agencies are setting deadlines around the milestone known as Q-day for when cryptography must change. NSA’s Commercial National Security Algorithm Suite 2.0 will require new national security systems to start supporting quantum-resistant algorithms starting January 1, 2027. While deadlines are staggered for various system categories throughout the early 2030s, the NSA hopes to make all national security systems quantum-resistant by 2035. NIST is moving on a parallel track with its draft IR 8547, which deprecates RSA-2048 and ECC P-256 after 2030 and disallows them entirely after 2035. These dates may seem far away, but a full enterprise transition could take 5 to 15 years, since the discovery phase alone can take 1 to 2 years in large enterprises. Why credentials carry major risk in a post-quantum future Not all encrypted data within an organization carries the same risk when the cryptography protecting it eventually becomes obsolete. Most secrets, like session tokens, have a confidentiality lifetime measured in months; credentials may persist for years or as long as their associated systems remain in service. To attackers, that makes credentials worth harvesting now and holding onto until a quantum computer can decrypt them. What makes this a major security risk is scale, especially since most organizations have growing populations of Non-Human Identities (NHIs) like service accounts and API keys. These machine credentials tend to be long-lived because no human user is responsible for rotating them, and they likely have not been inventoried for cryptographic exposure, making them ideal targets for harvesting. How to start a credentials-first quantum migration Since most of the risk is concentrated in credentials, the migration should begin with them as well. Organizations should take a credentials-first approach to quantum migration by doing the following. Inventory existing cryptography The main reason migrations are such lengthy processes is that organizations cannot itemize their cryptographic dependencies. A credentials-first inventory begins with finding the systems that hold or broker secrets, including password managers, secrets managers and Privileged Access Management (PAM) platforms. This phase is likely to expose forgotten service accounts, hardcoded secrets or integrations that have been dormant for years. Prioritize risk over size While organizations may want to start protecting their largest systems, it is smarter to prioritize confidentiality lifetime based on exposure, like how long a secret must remain private, combined with how reachable it is to an attacker. With this logic, a small, long-lived secret that brokers access to critical systems outweighs a vast but short-lived dataset. Prioritizing risk this way ensures the credentials most vulnerable to Harvest Now, Decrypt Later are secured first. Migrate to hybrid cryptography Instead of replacing classical algorithms outright, organizations should adopt hybrid cryptography by combining a classical algorithm with a quantum-resistant one in the same key exchange. This keeps a connection protected against both today’s traditional attackers and future quantum attackers. Hybrid cryptography also prevents organizations from betting everything on a single, relatively new algorithm, since the classical component remains in place and nothing is removed to add quantum-resistant protection. Build for crypto-agility Given that algorithms get deprecated and parameters change, organizations should expect that the current migration will not be the final one. Build with crypto-agility in mind: That way, cryptographic algorithm swaps are configuration changes rather than major re-engineering overhauls. For credentials in particular, this means keeping cryptography in a centralized location so that when the algorithm needs to change, it can be updated once rather than reworked across multiple applications, pipelines and integrations. Start protecting where the risk is highest While the urge to procrastinate on quantum-resistant cryptography may be strong, organizations must remember that quantum migration is a lengthy process and that today’s data must remain secret far into the future. A quantum computer does not need to exist yet for the threat of harvested and then decrypted credentials to be a real issue. Transitioning to quantum-resistant cryptography should begin with credentials since they are where confidentiality lifetime and blast radius intersect. In November 2025, the rollout of quantum-resistant cryptography began across all Keeper client applications, adopting Kyber Hybrid Key Encapsulation Mechanisms (KEM) to help secure vaults from Harvest Now, Decrypt Later and other quantum computing threats. Protecting credentials against a quantum future is what organizations should prioritize now, before more advanced hardware forces them to do so. Note: This article was thoughtfully written and contributed for our audience by Ashley D’Andrea, Content Writer at Keeper Security.
thehackernews.comJun 29, 2026extracted
⚡ Weekly Recap: Fast16 Malware, XChat Launch, Federal Backdoor, AI Employee Tracking & More
Everything is dumb again. This week feels broken in a very familiar way. Old tricks are back. New tools are doing shady crap. Supply chains got hit. Fake help desks worked. Weird research showed how easy some attacks still are. Most of it feels like stuff we should have fixed years ago. Bad extensions. Stolen creds. Remote tools are getting abused. Malware hides in places people trust. Same mess, cleaner packaging. Coffee is cold. The vuln list is ugly. Let’s get into it. ⚡ Threat of the Week New fast16 Malware Was Developed Years Before Stuxnet—A new Lua-based malware called fast16, created years before the notorious Stuxnet worm, is designed to primarily target high-precision calculation software to tamper with results. The framework dates back to 2005. Analysis suggests that fast16 was active at least five years before the emergence of Stuxnet. Widely regarded as a joint U.S.-Israeli project, Stuxnet marked a turning point in cyber warfare as the first disruptive digital weapon and eventually served as the blueprint for the Duqu information-stealing rootkit. Fast16, however, establishes a much earlier timeline for such sophisticated operations. The development places its origin well before Stuxnet came into being. Although it's currently not known if it was ever deployed in the wild, the investigation found three potential types of physical simulation software that the malware might have been designed to tamper with. "It focuses on making slight alterations to these calculations so that they lead to failures – very subtle ones, perhaps not immediately apparent," security researcher Vitaly Kamluk told WIRED. "Systems might wear out faster, collapse, or crash, and scientific research could yield incorrect conclusions, potentially causing serious harm." Automated Session Termination & Activity Summaries: Goodbye Manual Log Reviews Threats move fast. KeeperAI moves faster. With real-time, agentic AI threat detection and response, high-risk sessions are instantly terminated, and every action is categorized into risk levels and summarized. Automate insider threat detection and eliminate manual log reviews forever. Start a Free Trial ➝ 🔔 Top News UNC6692 Resorts to Teams Help Desk Impersonation—A new threat group tracked as UNC6692 uses social engineering to deploy a new, custom malware suite named Snow, which consists of a browser extension, a tunneler, and a backdoor. The end goal is to steal sensitive data after network compromise through credential theft and domain takeover. "This component is where active reconnaissance and mission completion occur," Google Mandiant noted. "Attacker commands (such as whoami or net user) are sent through the SnowGlaze tunnel, intercepted by the SnowBelt extension, and then proxied to the SnowBasin local server via HTTP POST requests. SnowBasin executes these commands and relays the results back through the same pipeline to the attacker." U.S. Federal Agency Targeted by FIRESTARTER Backdoor—The U.S. Cybersecurity and Infrastructure Security Agency (CISA) revealed that an unnamed federal civilian agency's Cisco Firepower device running Adaptive Security Appliance (ASA) software was compromised in September 2025 with a new malware called FIRESTARTER. FIRESTARTER is assessed to be a backdoor designed for remote access and control. It's believed to be deployed as part of a "widespread" campaign orchestrated by an advanced persistent threat (APT) actor to obtain access to Cisco Adaptive Security Appliance (ASA) firmware by exploiting now-patched security flaws such as CVE-2025-20333 and CVE-2025-20362. Given the backdoor's ability to survive patches and system reboots, Cisco is recommending users reimage and update to the latest fixed versions. Lotus Wiper Malware Targets Venezuelan Energy Systems—A previously undocumented data wiper codenamed Lotus Wiper has been used in attacks targeting the energy and utilities sector in Venezuela at the end of last year and the start of 2026. "Two batch scripts are responsible for initiating the destructive phase of the attack and preparing the environment for executing the final wiper payload," Kaspersky said. "These scripts coordinate the start of the operation across the network, weaken system defenses, and disrupt normal operations before retrieving, deobfuscating, and executing a previously unknown wiper." Once deployed, the wiper erases recovery mechanisms, overwrites the content of physical drives, and systematically deletes files across affected volumes, effectively leaving the system in an inoperable state. The Gentlemen Deploys SystemBC Malware—Threat actors associated with The Gentlemen ransomware‑as‑a‑service (RaaS) operation have been observed attempting to deploy a known proxy malware called SystemBC. The ransomware group has quickly made a name for itself in a matter of months, claiming more than 320 victims on its data leak site since its emergence in July 2025. According to Comparitech, the group claimed 202 attacks last quarter, second only to Qilin's 353 claims. NCC Group found The Gentlemen was responsible for 34 attacks in January and 67 in February 2026, making it a prominent player alongside other established groups like Qilin, Akira, and Cl0p. "The emergence of The Gentlemen group among the top three most active threat actors is notable as it demonstrates how a relatively new group can scale operations rapidly," NCC Group said. The development comes as another nascent ransomware group called Kyber has attracted attention for becoming the first RaaS crew to adopt the Kyber1024 (aka ML-KEM) post-quantum encryption algorithm for its Windows variant of the locker. In related news, the threat actors linked to the Trigona ransomware, dubbed Rhantus, have been observed using a custom data exfiltration tool that's designed to provide attackers with more control over what files to choose (or ignore) and facilitate rapid data transfer by opening five parallel connections per file. The attacks were detected in March 2026. It's not known why the threat actors shifted from readily available tools like Rclone. The use of custom tooling in the ransomware landscape is something of a rarity, even as it's a double-edged sword for attackers. "While it requires development resources and time, these tools can provide a level of stealth that generic tools cannot match, at least until they're discovered," the Symantec and Carbon Black Threat Hunter Team said. Bitwarden CLI Compromised in Supply Chain Campaign—Bitwarden CLI, the command-line interface for the password manager Bitwarden, was compromised as part of a new supply chain attack that targeted Checkmarx's Docker images, Visual Studio Code extensions, and GitHub Actions workflow. The affected package, @bitwarden/[email protected], contained malicious code to steal sensitive data from developer systems. The malware also features self-propagation capabilities, using stolen npm credentials to identify packages the victim can modify and inject them with malicious code to expand its reach. Bitwarden has since addressed the issue. The attack appears to be the work of a threat actor known as TeamPCP, although references to the string "Shai-Hulud: The Third Coming" have complicated attribution. 🔥 Trending CVEs Bugs drop weekly, and the gap between a patch and an exploit is shrinking fast. These are the heavy hitters for the week: high-severity, widely used, or already being poked at in the wild. Check the list, patch what you have, and hit the ones marked urgent first — CVE-2026-40372 (Microsoft ASP.NET Core), CVE-2026-33626 (LMDeploy), CVE-2026-5760 (SGLang), CVE-2026-5752 (Cohere AI Terrarium), CVE-2026-3517, CVE-2026-3518, CVE-2026-3519, CVE-2026-4048 (Progress LoadMaster, ECS Connection Manager, Object Scale Connection Manager, and MOVEit WAF), CVE-2026-21876 (Progress MOVEit WAF), CVE-2026-32173 (Microsoft Azure SRE Agent), CVE-2026-25262 (Qualcomm), CVE-2025-24371 (CometBFT), CVE-2026-5754 (Radware Alteon), CVE-2026-40872 (Mailcow), CVE-2026-27654 (Nginx), CVE-2026-5756 (DRC INSIGHT), CVE-2026-5757 (Ollama), CVE-2026-41651 aka Pack2TheRoot (Linux PackageKit), CVE-2026-33824 (Microsoft Windows IKEv2), CVE-2026-21571, CVE-2026-33871 (Atlassian Bamboo Data Center), CVE-2026-40050 (CrowdStrike LogScale), CVE-2026-32604, CVE-2026-32613 (Spinnaker), CVE-2026-33694 (Tenable Nessus Agent on Windows), TRA-2026-30 (Windows-driver-samples), TRA-2026-35 (Yuma AI), and a remote code execution flaw in Slippi (no CVE). 🎥 Cybersecurity Webinars Stop Testing, Start Validating: Outsmart Hackers with Agentic AI → Stop guessing which security gaps matter most while hackers use AI to find them for you. Most tools just follow a static checklist, but "Agentic Exposure Validation" actually thinks like an attacker, uncovering hidden paths into your network that traditional scans miss. Join this webinar to see how autonomous AI agents can test your defenses 24/7 and help you fix the risks that truly matter before they are exploited. Stop the Spread: How to Kill "Patient Zero" Before Your Network Goes Down → It only takes one "Patient Zero" to bring down your entire company. While traditional tools look for old threats, modern hackers are using AI-powered tricks to slip past your defenses undetected. Join this webinar to see how these new attacks work and learn simple "Zero Trust" steps to stop a breach before it spreads. Don't wait for a crisis—learn how to lock down your network today. Connect the Dots: Stop Attackers Before They Reach Your Data → Hackers aren't just looking for one big bug; they are chaining small, hidden gaps in your code and cloud to create a direct path to your data. Most security tools only see these issues in isolation, leaving you blind to the "big picture" thatan attacker sees. Join this webinar to learn how to map these complex attack paths and fix the real risks before they are exploited. 📰 Around the Cyber World Turning the Web Into a Trap for LLMs —Google has revealed that indirect prompt injections (IPI) are a top security priority, calling it a "primary attack vector for adversaries to target and compromise AI agents." Unlike regular prompt injection that seeks to manipulate a chatbot into executing malicious instructions, IPI occurs when an AI system processes content, like a website, email, or document, that contains nefarious commands. As this content is processed by the AI, it may end up following the attacker's commands instead of the user's original intent. This is complicated by the fact that attackers use a gaggle of tricks to hide malicious instructions from human eyes while keeping them fully visible to AI. This often involves making the text invisible through CSS, encoding it in various formats, or stashing it in unexpected locations. In at least one malicious scenario, Google flagged a number of websites that attempt to vandalize the machines of anyone using AI assistants. If executed, the commands in this example would try to delete all files on the user's machine. Some websites include prompt injections for the purpose of SEO, trying to manipulate AI assistants into promoting their business over others. "Additionally, even though sophistication was low, we observed an uptick in detections over time: We saw a relative increase of 32% in the malicious category between November 2025 and February 2026, repeating the scan on multiple versions of the [CommonCrawl] archive," Google said. "This upward trend indicates growing interest in IPI attacks." Meta Debuts Improved Meta Account —Meta has introduced an improved Meta Account as a centralized way to sign in and manage Meta apps and devices like Facebook, Instagram, and AI glasses. Besides adding support for passkeys, Meta also allows users to "optionally set up a single password to log into your apps and devices so you no longer have to remember multiple passwords." X Launches XChat —X launched XChat as a standalone app for iOS, allowing users on the platform to connect with others for messaging, file sharing, audio and video calls, as well as group chats. The company claims all messages are end-to-end encrypted and PIN-protected — though security experts have previously disputed the company's encryption claims when an early version was teased last year. XChat's app listing page shows that it can collect location, contacts, search history, usage data, identifiers, and device diagnostics, and link that information to a user's identity directly. Meta Plans to Track Employee Mouse Movements, Keystrokes for AI Model Training —Meta is installing tracking software on the systems of U.S. employees to capture mouse movements, clicks, and keystrokes, per a report from Reuters. Meta said the data will be used to train its artificial intelligence (AI) models and will not be used for employee reviews. In a similar development, GitHub notified users that the GitHub CLI now collects anonymous usage telemetry by default and that they should disable the feature if they do not want to share such information. Surge in Attacks Involving Compromised Bomgar Instances —Huntress has recorded an uptick in incidents involving compromised Bomgar remote monitoring and management (RMM) instances. "The surge follows intermittent waves of exploitation we have seen over the past two months, after BeyondTrust first disclosed a critical-severity flaw (CVE-2026-1731) in Bomgar in February," the company said. "On February 6, 2026, BeyondTrust issued fixes for the flaw in Bomgar (rebranded as BeyondTrust Remote Support), which could be exploited by an unauthenticated attacker to remotely execute code." The specific root cause behind these attacks is not clear, but the incidents likely stem from the exploitation of CVE-2026-1731. Fortra has also spotted phishing campaigns trying to lure victims into installing Datto's CentraStage remote monitoring and management tool, which attackers are then using to connect back into the victim's internal network. The findings demonstrate threat actors' continued shift toward exploiting RMMs rather than using traditional malware. Over 1.2K C2 Servers Linked to Russian Infrastructure Providers —A large-scale study of the Russian web hosting space has found more than 1,250 malicious command-and-control servers hosted inside Russia this year. Most of the servers are linked to malware families and IoT botnets, such as Keitaro, Hajime, Cobalt Strike, Sliver, Mozi, and Mirai, according to Hunt.io. Tether Freezes $344M —Tether announced that it supported the U.S. Government in freezing $344 million USD₮ across two addresses. "The freeze was executed after the addresses were identified, preventing further movement of funds," the company said. "The freeze follows information shared with Tether by several U.S. authorities about activity tied to unlawful conduct. When wallets are identified as connected to sanctions evasion, criminal networks, or other illicit activity, Tether can move to restrict those assets." According to TRM Labs, the two wallet addresses are associated with the Central Bank of Iran. The wallets received roughly $370 million across approximately 1,000 transactions since March 2021. "Over the last few months, OFAC has taken unprecedented action against Iran's use of crypto infrastructure," said Ari Redbord, TRM Labs's Global Head of Policy. "As the regime leans more heavily on cryptocurrency to move funds outside the U.S. financial system, U.S. law enforcement and regulators are working closely with private-sector initiatives like T3 to freeze and seize Iran-associated wallets. This is exactly the kind of public-private disruption needed to take on rogue nation-state actors like Iran." Malicious Chrome Extension Masquerades as Google Authenticator —A malicious Chrome extension posing as the official Google Authenticator app was identified in the official extension marketplace as part of an ongoing malicious campaign codenamed AIFrame, active since at least early 2026. "The extension appears to use Chrome's localization system and skeleton code to bypass security reviews," DomainTools said. "Despite its functional appearance, it requests broad, unnecessary permissions and contains 'dormant infrastructure.' This extension is linked to at least six others through a shared developer front, two of which already carry fully operational malicious payloads. These extensions utilize hidden iframes to inject attacker-controlled content into every webpage, deploy fraudulent paywalls for free services, and maintain bidirectional communication with C2 servers." Compromised WordPress Sites Push ClickFix Schemes —Multiple websites have been compromised by a ClickFix clipboard hijacker that aims to trick users into pasting malicious commands into the Windows Run dialog or the macOS Terminal app to deliver malware. The kill chain is assessed to share overlaps with a known traffic distribution system (TDS) named KongTuke. New Phishing Toolkits Discovered —A number of new phishing-as-a-service toolkits have been spotted in the wild: OLUOMO, ATHR, VENOM, p1bot, TMoscow Bot, REFUNDEE, and UPMI. 🔧 Cybersecurity Tools Malfixer → Stop wasting hours manually repairing broken malware just to see how it works. Malfixer does the heavy lifting by automatically rebuilding corrupted or "packed" files so they are ready for analysis in seconds. It is a simple, effective way to bypass the tricks hackers use to hide their code, letting you get straight to your investigation. SmokedMeat → Most developers have no idea how many "shadow" tools and scripts are hidden inside their software build pipelines. Smokedmeat shines a light on these forgotten GitHub Actions and third-party tools by quickly scanning your environment to show you exactly what is running. It is a simple way to find hidden back doors and security risks before attackers do. Disclaimer: This is strictly for research and learning. It hasn't been through a formal security audit, so don't just blindly drop it into production. Read the code, break it in a sandbox first, and make sure whatever you’re doing stays on the right side of the law. Conclusion Same pattern, new mess. Patch the obvious stuff first. Check the weird logins. Look hard at browser extensions, remote tools, and anything that touches your build chain. The boring checks are boring until they save prod. That’s it for this week. Keep backups clean, MFA tight, and your trust budget low.
thehackernews.comApr 27, 2026extracted
Kyber ransomware gang toys with post-quantum encryption on Windows
A new Kyber ransomware operation is targeting Windows systems and VMware ESXi endpoints in recent attacks, with one variant implementing Kyber1024 post-quantum encryption. Cybersecurity firm Rapid7 retrieved and analyzed two distinct Kyber variants in March 2026 during an incident response. Both variants were deployed on the same network, with one targeting VMware ESXi and the other focusing on Windows file servers. "The ESXi variant is specifically built for VMware environments, with capabilities for datastore encryption, optional virtual machine termination, and defacement of management interfaces," explains Rapid7. "The Windows variant, written in Rust, includes a self-described "experimental" feature for targeting Hyper-V." Both variants share the same campaign ID and Tor-based ransom infrastructure, so they were deployed by the same ransomware affiliate, who likely sought to maximize impact by encrypting all servers simultaneously. BleepingComputer has found only one listed victim on the Kyber data extortion portal at the time of writing, which is a multi-billion-dollar American defense contractor and IT services provider. Rapid7 says the ESXi variant enumerates all virtual machines (VMs) on the infrastructure, encrypts datastore files, and then defaces the ESXi interfaces with ransom notes to guide victims through the ransom payment and recovery process. Although it advertises 'post-quantum' encryption based on Kyber1024 key encapsulation, Rapid7 has found that these claims are false for the Linux ESXi encryptor. For the Linux version, the ransomware uses ChaCha8 for file encryption and RSA-4096 for key wrapping. Small files (<1 MB) are encrypted in full and appended with the '.xhsyw' extension, while files between 1 MB and 4 MB have only the first MB encrypted. Files larger than 4MB are intermittently encrypted based on the operator's configuration. The Windows variant, written in Rust, implements Kyber1024 and X25519 for key protection, aligning with the ransom note's claims. "This confirms that Kyber is not used for direct file encryption. Instead, Kyber1024 protects the symmetric key material, while AES-CTR handles bulk data encryption," Rapid7 explains. While the use of post-quantum cryptography is notable, it does not change outcomes for victims. Whether the encryptor uses RSA or Kyber1024, files remain unrecoverable without access to the attacker's private key. The Windows variant appends the '.#~~~' extension to encrypted files, terminates services, deletes backups, and includes an experimental feature to shut down Hyper-V virtual machines. It is designed to eliminate a broad range of data recovery paths, deleting shadow copies, disabling boot repair, killing SQL, Exchange, and backup services, clearing event logs, and wiping the Windows Recycle Bin. Rapid7 highlighted an unusual choice of a mutex in the Windows variant of Kyber, which appears to reference a song on the Boomplay music platform. Overall, the Windows variant appears more technically mature, while the ESXi variant currently lacks some of its features. Overall prevention scores can hide what happens after initial access. Once attackers are using valid credentials, prevention drops sharply. The Blue Report 2026 measures defenses technique by technique across 338 million simulations run in customer production environments. Get the report
bleepingcomputer.comApr 22, 2026extracted
SystemBC C2 Server Reveals 1,570+ Victims in The Gentlemen Ransomware Operation
Threat actors associated with The Gentlemen ransomware‑as‑a‑service (RaaS) operation have been observed attempting to deploy a known proxy malware called SystemBC. According to new research published by Check Point, the command-and-control (C2 or C&C) server linked to SystemBC has led to the discovery of a botnet of more than 1,570 victims. "SystemBC establishes SOCKS5 network tunnels within the victim’s environment and connects to its C&C server using a custom RC4‑encrypted protocol," Check Point said. "It can also download and execute additional malware, with payloads either written to disk or injected directly into memory." Since its emergence in July 2025, The Gentlemen has quickly established itself as one of the most prolific ransomware groups, claiming more than 320 victims on its data leak site. Operating under a classic double-extortion model, the group is versatile as it's sophisticated, exhibiting capabilities to target Windows, Linux, NAS, and BSD systems with a Go-based locker as well as employing legitimate drivers and custom malicious tools to subvert defenses. Exactly how the threat actors obtain initial access is unclear, although evidence suggests that internet-facing services or compromised credentials are being abused to establish an initial foothold, followed by engaging in discovery, lateral movement, payload staging (i.e., Cobalt Strike, SystemBC, and the encryptor), defense evasion, and ransomware deployment. A notable aspect of the attacks is the abuse of Group Policy Objects (GPOs) to facilitate domain-wide compromise. "By tailoring their tactics against specific security vendors, The Gentlemen have demonstrated an acute awareness of their targets' environments and a willingness to engage in in-depth reconnaissance and tool modification throughout the course of their operation," security vendor Trend Micro noted in an analysis of the group's tradecraft in September 2025. The latest findings from Check Point show that an affiliate of The Gentlemen RaaS deployed SystemBC on a compromised host, with the C2 server linked to the proxy malware commandeering hundreds of victims across the globe, including the U.S., the U.K., Germany, Australia, and Romania. While SystemBC has been used in ransomware operations as far back as 2020, the exact nature of the connection between the malware and The Gentlemen e-crime scheme remains unclear, such as whether it's part of the attack playbook or if it's something deployed by a specific affiliate for data exfiltration and remote access. "During lateral movement, the ransomware makes an attempt to blind Windows Defender on each reachable remote host by pushing a PowerShell script that disables real-time monitoring, adds broad exclusions for the drive, staging share, and its own process, shuts down the firewall, re-enables SMB1, and loosens LSA anonymous access controls, all before deploying and executing the ransomware binary on that host," Check Point said. The ESXi variant incorporates fewer functionalities than the Windows variant, but is equipped to shut down virtual machines to enhance the effectiveness of the attack, adds persistence via crontab, and inhibits recovery before the ransomware binary is deployed. "Most ransomware groups make noise when they launch and then disappear. The Gentlemen are different," Eli Smadja, group manager at Check Point Research, said in a statement shared with The Hacker News. "They've cracked the affiliate recruitment problem by offering a better deal than anyone else in the criminal ecosystem. When we got inside one of their operator's servers, we found over 1,570 compromised corporate networks that hadn't even made the news yet. The real scale of this operation is significantly larger than what's publicly known, and it's still growing." The findings come as Rapid7 highlighted the inner workings of another relatively new ransomware family called Kyber that surfaced in September 2025, targeting Windows and VMware ESXi infrastructures using encryptors developed in Rust and C++, respectively. "The ESXi variant is specifically built for VMware environments, with capabilities for datastore encryption, optional virtual machine termination, and defacement of management interfaces," the cybersecurity company said. "The Windows variant, written in Rust, includes a self-described 'experimental' feature for targeting Hyper-V." "Kyber ransomware isn't a masterpiece of complex code, but it is highly effective at causing destruction. It reflects a shift toward specialization over sophistication." According to data compiled by ZeroFox, at least 2,059 separate ransomware and digital extortion (R&DE) incidents have been observed in Q1 2026, with March accounting for no less than 747 incidents. The most active groups during the time period were Qilin (338), Akira (197), The Gentlemen (192), INC Ransom, and Cl0p. "Notably, North America-based victims accounted for approximately 20 percent of The Gentlemen's attacks in Q3 2025, 2% in Q4 2025, and 13% in Q1 2026," ZeroFox said. "This largely goes against typical regional targeting trends by other R&DE collectives, at least 50 percent of whose victims are North America-based." The Shifting Velocity of Ransomware Attacks Cybersecurity company Halcyon, in its 2025 Ransomware Evolution Report, revealed that the threat continues to mature into something more disciplined and a business-driven criminal enterprise, even as ransomware attacks targeting the automotive industry more than doubled in 2025, taking up 44% of all cyber incidents across the sector. Other significant trends include attempts to impair security Endpoint Detection and Response (EDR) tools, use of the Bring Your Own Vulnerable Driver (BYOVD) attack technique to escalate privileges and disable security solutions, blurring of nation-state and criminal ransomware campaigns, and increased targeting of small and mid-sized organizations and operational technology (OT) environments. "Ransomware continued to grow as a durable, industrialized ecosystem built on specialization, shared infrastructure, and rapid regeneration rather than any single brand," it said. "Law enforcement pressure and infrastructure seizures disrupted major operations, driving fragmentation, rebranding, and intensified competition across a more fluid landscape." Ransomware operations are increasingly fast-moving, with dwell times collapsing from days to hours. About 69% of observed attack attempts have been found to be deliberately staged during nights and weekends to outpace defender response. For instance, attacks involving Akira ransomware have demonstrated an unusual swiftness, rapidly escalating from initial foothold to full encryption within an hour in some cases without detection, highlighting a well-oiled attack engine designed to maximize impact. "Akira's combination of rapid compromise capabilities, disciplined operational tempo, and investment in reliable decryption infrastructure sets it apart from many ransomware operators," Halcyon said. "Defenders should treat Akira not as an opportunistic threat, but as a capable, persistent adversary that will exploit every available weakness to reach its objective."
thehackernews.comApr 21, 2026extracted
L’impatto cyber del quantum computing: minacce emergenti e nuovi paradigmi di difesa
Il quantum computing rappresenta una delle più profonde rivoluzioni tecnologiche del nostro tempo e una capacità trasformativa che avrà un impatto duplice e radicale sulla sicurezza informatica. Da un lato, i computer quantistici, sfruttando i principi controintuitivi della meccanica quantistica, quali la sovrapposizione e l’entanglement quantistico, promettono di risolvere problemi di calcolo oggi considerati irrisolvibili, aprendo nuove frontiere in vari campi, quali la scienza dei materiali, la farmaceutica e l’intelligenza artificiale. D’altra parte, questa stessa potenza di calcolo rischia di compromettere le fondamenta su cui si basa l’intera architettura della sicurezza digitale globale: la crittografia a chiave pubblica. Analizzeremo la minaccia quantistica alla crittografia moderna e le nuove e potenti capacità difensive rese possibili dalla stessa tecnologia. Ecco la natura degli algoritmi che rendono vulnerabili i sistemi attuali, le strategie di mitigazione, come la crittografia post-quantistica (PQC), e le tecnologie emergenti quali la distribuzione quantistica delle chiavi (QKD) e i generatori di numeri casuali quantistici (QRNG), che introducono nuovi paradigmi di sicurezza. Infine, delineeremo una roadmap strategica per guidare le organizzazioni attraverso la complessa, ma inevitabile, transizione verso un futuro quantistico sicuro. Indice degli argomenti Comprendere la natura e la portata della minaccia quantistica è un imperativo strategico per qualsiasi organizzazione operante nell’economia digitale. Non si tratta di una minaccia speculativa, ma di un rischio concreto basato su algoritmi matematici già dimostrati che possono compromettere l’infrastruttura di fiducia su cui si basano il commercio elettronico, le comunicazioni sicure e la protezione dei dati sensibili a livello globale. A differenza dei computer classici che elaborano le informazioni utilizzando i bit, che rappresentano i numeri 0 e 1, i computer quantistici utilizzano i qubit. I bit possono assumere solo i valori 0 o 1, mentre i qubit possono esistere in uno stato di sovrapposizione, ovvero possono rappresentare contemporaneamente 0 e 1, consentendo un massiccio parallelismo computazionale. Ciò consente di affrontare problemi che richiederebbero un tempo esponenziale sui supercomputer più potenti attualmente disponibili. La comunità scientifica definisce un “Cryptographically Relevant Quantum Computer” (CRQC) come una macchina dotata di un numero sufficiente di qubit logici stabili e corretti dagli errori, in contrapposizione ai più instabili qubit fisici spesso citati nei titoli di cronaca. Un CRQC deve possedere bassi tassi di errore, resi possibili da complesse tecniche di correzione degli errori quantistici (QEC), per poter eseguire in modo affidabile algoritmi in grado di violare la crittografia a chiave pubblica attualmente in uso. Nonostante le tempistiche esatte siano ancora oggetto di dibattito, il Boston Consulting Group stima che un computer quantistico con correzione degli errori potrebbe diventare realtà intorno al 2035. La minaccia quantistica non rappresenta una semplice crepa nel sistema, ma un vero e proprio crollo di paradigma, in quanto invalida le assunzioni matematiche fondamentali su cui si basa la crittografia a chiave pubblica, ovvero la difficoltà della fattorizzazione degli interi e dei logaritmi discreti, che hanno costituito il fondamento di tale crittografia per quasi cinquant’anni. Due algoritmi, in particolare, incarnano questa minaccia. La minaccia quantistica non è qualcosa di lontano nel tempo, ma è già presente nellastrategia “Harvest Now, Decrypt Later” (HNDL): gli avversari possono intercettare e archiviare oggi dati crittografati con l’intenzione di decifrarli in futuro, una volta disponibile un computer quantistico universale. Come sottolineato dal NIST, l’HNDL è una delle ragioni principali per cui la transizione verso la crittografia post-quantistica è urgente, soprattutto per i dati con una lunga “shelf life”, ovvero che devono rimanere confidenziali per decenni (come i segreti di stato, la proprietà intellettuale, i dati sanitari e i dati finanziari). Per formalizzare tale urgenza è stato introdotto il Teorema di Mosca, un modello di valutazione del rischio che aiuta le organizzazioni a capire se hanno tempo a sufficienza per proteggere i propri dati. Come illustrato in un’analisi del Board of Governors of the Federal Reserve System, se la somma del tempo di migrazione (Y) e della vita utile dei dati (X) superasse il tempo necessario per costruire un CRQC (Z), i dati correrebbero il rischio di andare persi. Questa semplice disuguaglianza evidenzia la necessità di agire subito, prima che sia troppo tardi. Per comprendere questa minaccia, è necessario analizzare in modo approfondito le strategie difensive che la comunità scientifica e tecnologica sta sviluppando. Per contrastare la minaccia quantistica, la ricerca nel campo della sicurezza informatica sta seguendo due principali linee di difesa: la crittografia post-quantistica (PQC) e la distribuzione quantistica delle chiavi (QKD). Sebbene partano da presupposti teorici e tecnologici molto diversi, queste strategie non sono necessariamente in competizione tra loro e, anzi, in molti casi possono essere complementari. La PQC si riferisce a una nuova generazione di algoritmi crittografici a chiave pubblica progettati per essere eseguiti su computer tradizionali, ma basati su problemi matematici considerati difficili persino per i computer quantistici. In pratica, invece di fare affidamento sulla fattorizzazione o sui logaritmi discreti, su cui il calcolo quantistico eccelle, la PQC utilizza problemi complessi in campi quali la crittografia basata su reticoli (lattice-based), su codice (code-based) e su hash (hash-based). Il National Institute of Standards and Technology (NIST) degli Stati Uniti ha guidato un processo di standardizzazione globale, avviato nel 2016, per individuare i migliori candidati PQC. Nel mese di agosto del 2024, il NIST ha finalizzato i primi tre standard e ha proseguito il processo di standardizzazione selezionando ulteriori algoritmi, come l’HQC nel 2025, al fine di garantire una maggiore diversità: ML-KEM (FIPS 203): Module-Lattice-Based Key-Encapsulation Mechanism Standard, un meccanismo di incapsulamento della chiave basato su reticoli, destinato a sostituire algoritmi come RSA ed ECC per lo scambio di chiavi; ML-DSA (FIPS 204): Module-Lattice-Based Digital Signature Algorithm, un algoritmo di firma digitale basato anch’esso su reticoli, che offre prestazioni efficienti per l’autenticazione; SLH-DSA (FIPS 205): Stateless Hash-Based Digital Signature Algorithm, un algoritmo di firma digitale stateless basato su hash. L’inclusione del SLH-DSA garantisce una diversità algoritmica che rappresenta un imperativo strategico. Affidarsi esclusivamente alla crittografia basata sui reticoli (come ML-KEM e ML-DSA) creerebbe un punto di debolezza. Se una scoperta imprevista compromettesse i problemi matematici alla base dei reticoli, avere un’alternativa come SLH-DSA, la cui sicurezza si basa su principi matematici completamente diversi e consolidati nel tempo, fornirebbe un backup fondamentale e garantirebbe la resilienza del sistema. Nonostante la loro efficacia, gli algoritmi PQC presentano delle sfide dal punto di vista dell’implementazione, come è stato per le dimensioni maggiori delle chiavi e delle firme, e un maggiore carico computazionale. Questo sovraccarico prestazionale rappresenta la principale ragione per cui l’aggiornamento dei sistemi legacy e dei dispositivi a bassa potenza, come quelli dell’Internet of Things (IoT), costituisce una delle criticità più ardue nel processo di migrazione. A differenza della PQC, la QKD non è un nuovo tipo di algoritmo, ma una tecnologia di comunicazione che sfrutta le leggi fondamentali della meccanica quantistica per lo scambio di chiavi crittografiche e che garantisce una sicurezza teoricamente inattaccabile. La sua sicurezza si basa su due principi fisici: il principio di indeterminazione: afferma che l’atto di misurare uno stato quantico (come la polarizzazione di un fotone) lo altera inevitabilmente; il teorema di non-clonazione: stabilisce che è impossibile creare una copia esatta di uno stato quantico sconosciuto. Durante la fase di transizione, l’approccio più sicuro e consigliato è quello ibrido. Questo metodo prevede un approccio di migrazione ibrida alla crittografia post-quantistica (PQC), che combina un algoritmo classico, come l’ECC (Elliptic Curve Cryptography) (ECDSA/ECDH), per garantire la sicurezza attuale, con un nuovo algoritmo resistente ai computer quantistici, come l‘ML-KEM (Kyber), per assicurare la sicurezza futura. In questo modo, si ottiene una protezione sia oggi che contro le minacce quantistiche, un processo noto come “crypto-agility”. La chiave di sessione finale viene derivata da entrambi gli scambi. In questo modo, un eventuale avversario che volesse compromettere la comunicazione dovrebbe essere in grado di violare entrambi gli schemi, garantendo protezione sia contro le minacce classiche odierne sia contro quelle quantistiche future. Questo approccio richiede un’architettura basata sull’agilità crittografica, definita come la capacità di un sistema di aggiornare o sostituire rapidamente e in modo flessibile gli algoritmi crittografici senza dover riprogettare l’intera infrastruttura. L’agilità crittografica è un requisito fondamentale per garantire la resilienza a lungo termine nell’era post-quantistica. La rivoluzione quantistica non rappresenta solo una fonte di nuove minacce, ma offre anche strumenti unici per potenziare attivamente le difese informatiche. Sfruttando i fenomeni quantistici, è possibile pervenire livelli di sicurezza e capacità di analisi irraggiungibili con le tecnologie tradizionali, trasformando il quantum computing da potenziale avversario a prezioso alleato. Oltre a difenderci dalle minacce, le tecnologie quantistiche ci forniscono anche strumenti proattivi per rafforzare la nostra postura di sicurezza. Vediamo le peculiarità dei principali. La vera casualità (entropia) è una risorsa critica in crittografia, fondamentale per la generazione di chiavi sicure, nonce e di altre variabili imprevedibili. I generatori di numeri pseudo-casuali (PRNG), basati su algoritmi software, sono deterministici e potenzialmente prevedibili. I Generatori quantistici di numeri casuali (QRNG), invece, generano numeri casuali a partire da processi fisici che, secondo le leggi della meccanica quantistica, sono intrinsecamente e fondamentalmente imprevedibili. Un meccanismo comune per un QRNG consiste nel dirigere un singolo fotone verso uno specchio semitrasparente che ha il 50% di probabilità di trasmetterlo e il 50% di rifletterlo. Il risultato è un evento genuinamente casuale. Misurando questi eventi, i QRNG producono una fonte di entropia di qualità superiore, eliminando la possibilità che la sequenza di numeri casuali possa essere prevista o replicata e rafforzando così le fondamenta di tutti i protocolli crittografici. Il Quantum Machine Learning (QML) è un campo di ricerca emergente che integra gli algoritmi quantistici con il machine learning tradizionale. Il suo contributo alla sicurezza informatica è enorme. I sistemi QML potrebbero analizzare grandi quantità di dati in tempo reale, individuando modelli complessi, anomalie e minacce, superando le capacità dei sistemi di IA tradizionali. Tra le applicazioni più performanti troviamo: rilevamento di URL malevoli: gli algoritmi come le Quantum Support Vector Machines (QSVM) possono mappare i dati in spazi dimensionali molto più vasti, consentendo di identificare siti web fraudolenti con maggiore accuratezza; analisi del traffico di rete: il QML può essere utilizzato per riconoscere pattern anomali nel traffico di rete, anche quando è crittografato, analizzando i metadati e le caratteristiche del flusso di dati. Nonostante le grandi aspettative di queste tecnologie, la loro implementazione pratica richiede una pianificazione attenta e strategica. Utilizzando la metafora della corsa, la transizione verso un’infrastruttura di sicurezza quantistica può essere paragonata a una maratona piuttosto che a uno sprint. Richiede un approccio metodico e strategico da parte delle organizzazioni per gestire la complessità, i costi e i rischi associati. L’inattività non è certamente un’opzione da prendere in considerazione, ma un’azione affrettata e non mpianificata può rivelarsi altrettanto dannosa. La migrazione PQC presenta diverse criticità che ogni organizzazione dovrà affrontare: Inventario crittografico: la prima e più grande sfida è identificare ogni singola istanza di crittografia utilizzata all’interno dei sistemi aziendali. La crittografia è spesso nascosta all’interno di applicazioni, dipendenze software, API e protocolli di rete, il che rende difficile mapparla completament. Sistemi legacy e IoT: aggiornare i sistemi datati o i dispositivi con risorse computazionali limitate è estremamente complesso. Come anticipato, gli algoritmi PQC sono generalmente più esigenti in termini di calcolo e memoria e molti di questi dispositivi potrebbero non avere la potenza di elaborazione o la capacità di memoria sufficienti per supportarli. Costi e risorse: la migrazione richiede un investimento significativo in termini di tecnologia, personale specializzato, test e formazione. La mancanza di competenze in crittografia post-quantistica rappresenta un bottleneck per molte aziende. Standardizzazione e interoperabilità: sebbene il NIST stia puntando a una standardizzazione, è necessaria un’adozione coordinata a livello globale. In particolare, i settori che, per loro natura, superano i confini nazionali per lo scambio di dati e comunicazioni, come quello finanziario e delle telecomunicazioni, devono garantire che i sistemi aggiornati possano comunicare in modo sicuro tra loro, al fine di evitare frammentazione e vulnerabilità. Per affrontare queste sfide, le organizzazioni possono seguire una roadmap strategica suddivisa in fasi, basata sulle raccomandazioni di enti come BCG e Palo Alto Networks: Fase 1: inventario e valutazione del rischio. Il primo passo consiste nel creare un inventario completo di tutti gli asset crittografici e dei flussi di dati. È fondamentale mappare dove viene utilizzata la crittografia, quali algoritmi sono in uso e quali dati vengono protetti. In seguito, è necessario valutare il rischio, dando la priorità ai dati più sensibili e con la “shelf life” più lunga, che sono i più esposti alla minaccia di HNDL. Fase 2: sviluppo di una strategia e di progetti pilota. Sulla base dell’inventario, sviluppare una roadmap di migrazione personalizzata. È essenziale adottare il principio di agilità crittografica per facilitare gli aggiornamenti futuri. In questa fase, le organizzazioni dovrebbero avviare progetti pilota per testare gli algoritmi PQC e le soluzioni ibride in ambienti controllati e non critici, al fine di valutarne le prestazioni, la compatibilità e l’impatto operativo. Fase 3: implementazione su larga scala. Una volta che i nuovi standard sono stati validati tramite i progetti pilota, si può procedere con il rollout aziendale. La migrazione dovrebbe seguire le priorità definite nella Fase 1, a partire dalle applicazioni e dai sistemi più critici. Questo processo richiederà un coordinamento attento tra i team IT, di sicurezza e di sviluppo. Fase 4: gestione e monitoraggio continui. La sicurezza post-quantistica non è un progetto una tantum, ma un processo continuo. Una volta completata la migrazione, la gestione della PQC deve essere integrata nei normali cicli di vita della sicurezza. Ciò include il monitoraggio costante dell’evoluzione delle minacce quantistiche, l’aggiornamento degli algoritmi in base ai nuovi standard e la garanzia che la postura di sicurezza rimanga resiliente nel tempo. Questo approccio metodico consentirà alle organizzazioni di affrontare con successo la transizione verso la nuova era della sicurezza informatica. Il quantum computing si presenta come una tecnologia dalla duplice natura: da un lato rappresenta una minaccia esistenziale per la sicurezza delle nostre comunicazioni e dei nostri dati, dall’altro offre strumenti di difesa senza precedenti che promettono di rafforzare la sicurezza informatica in modi prima impensabili. La comunità scientifica e tecnologica ha risposto a questa sfida sviluppando la crittografia post-quantistica (PQC) e tecnologie rivoluzionarie quali la QKD (Quantum Key Distribution) e i QRNG (Quantum Random Number Generator). A causa della minaccia concreta e immediata rappresentata dal “Harvest Now, Decrypt Later”, l’attesa non è certamente un’opzione da prendere in considerazione. La transizione verso un ecosistema digitale quantistico sicuro è complessa e richiederà tempo, risorse e una pianificazione strategica accurata. È fondamentale che le organizzazioni, i governi e le comunità scientifiche collaborino per affrontare questa sfida in maniera proattivo. Solo attraverso una transizione ben orchestrata, infatti, potremo garantire che la fiducia e la resilienza che oggi diamo per scontate nell’infrastruttura digitale globale siano preservate anche per il futuro. Bobier, J.-F., Fouilloux, C., Lyon, V., Stegemann, D., Bouteiller, G., Panhans, D., & Roussel, P. (2024). How Quantum Computing Will Upend Cybersecurity. Boston Consulting Group. Jang-Jaccard, J., et al. Quantum Technologies: Trends and Implications for Cyber Defense. Mascelli, J., & Rodden, M. (2024). “Harvest Now Decrypt Later”: Examining Post-Quantum Cryptography and the Data Privacy Risks for Distributed Ledger Networks. Finance and Economics Discussion Series 2025-093. Board of Governors of the Federal Reserve System. https://doi.org/10.17016/FEDS.2025.093 National Academies of Sciences, Engineering, and Medicine. (2019). Quantum Computing: Progress and Prospects. The National Academies Press. https://doi.org/10.17226/25196 National Institute of Standards and Technology. (2024). FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard. U.S. Department of Commerce. National Institute of Standards and Technology. (2024). FIPS 204: Module-Lattice-Based Digital Signature Algorithm. U.S. Department of Commerce. National Institute of Standards and Technology. (2024). FIPS 205: Stateless Hash-Based Digital Signature Algorithm. U.S. Department of Commerce. Palo Alto Networks. Harvest Now, Decrypt Later (HNDL): The Quantum-Era Threat. Palo Alto Networks. What Is a Quantum Random Number Generator (QRNG)? Overview.
cybersecurity360.itFeb 9, 2026extracted
Q-Day: Perché la crittografia attuale non è pronta per un avversario quantistico
Nel lavoro quotidiano sulla sicurezza, una parte significativa delle attività è dedicata alla mitigazione di vulnerabilità note; un’altra è rivolta a rischi che non si sono ancora materializzati, ma che devono essere considerati in fase di pianificazione. La cosiddetta minaccia quantistica rientra in questa seconda categoria, con una caratteristica distintiva: le condizioni che la rendono rilevante sono già presenti, anche se gli effetti concreti si manifesteranno in futuro. Non si tratta di uno scenario ipotetico o speculativo, ma di un problema di gestione del rischio a lungo termine. L’elemento critico non è il momento in cui i computer quantistici diventeranno operativi su larga scala, ma il fatto che dati cifrati oggi possano essere raccolti e conservati per essere decifrati in seguito, secondo il modello noto come “Harvest Now, Decrypt Later“. In questo contesto, la finestra temporale di esposizione è già aperta. L’evoluzione del calcolo quantistico pone una minaccia diretta agli algoritmi crittografici attualmente più diffusi. Schemi come RSA, ECDSA e Diffie-Hellman, che costituiscono la base della sicurezza delle comunicazioni moderne, non sono progettati per resistere ad avversari dotati di capacità quantistiche sufficientemente avanzate. Per affrontare questo scenario stanno emergendo due approcci distinti: la Crittografia Post-Quantistica (PQC) e la Quantum Key Distribution (QKD). Entrambi mirano a garantire la riservatezza delle comunicazioni in un contesto post-quantistico, ma si basano su presupposti tecnici diversi e presentano implicazioni operative differenti. In questo quadro, la crittografia non può più essere considerata un meccanismo limitato alla protezione delle credenziali o delle transazioni commerciali. È un componente strutturale della sicurezza nazionale, delle infrastrutture critiche e delle relazioni geopolitiche. La durata nel tempo del valore informativo dei dati diventa quindi un fattore centrale. Se un’informazione deve rimanere riservata per periodi di dieci, venti o più anni (come nel caso di dati sanitari, industriali o governativi) l’adozione esclusiva di schemi crittografici non resistenti a un avversario quantistico rappresenta già oggi un rischio che deve essere valutato e gestito. Deep Dive Tecnico: PQC vs QKD e Algoritmi a Rischio Prima di valutare le contromisure, è necessario chiarire il modello di minaccia. Su un computer quantistico sufficientemente potente, l’algoritmo di Shor consente di fattorizzare numeri interi e risolvere il problema del logaritmo discreto in tempo polinomiale. Questo rende insicuri gli schemi crittografici a chiave pubblica oggi più diffusi, che basano la propria sicurezza proprio sulla difficoltà computazionale di questi problemi. Anche la crittografia simmetrica risente dell’impatto del calcolo quantistico, sebbene in modo diverso. L’algoritmo di Grover permette di accelerare la ricerca esaustiva delle chiavi, riducendo di fatto il livello di sicurezza offerto da una chiave simmetrica. Per compensare questo effetto, è necessario aumentare la dimensione delle chiavi al fine di mantenere un livello di protezione equivalente. Ecco una tabella rapida per capire l’impatto sugli algoritmi che usiamo ogni giorno: Il NIST ha pubblicato i suoi principali standard PQC (definiti Federal Information Processing Standards o FIPS), specificando gli schemi di istituzione delle chiavi e di firma digitale basati sui candidati valutati e selezionati attraverso un processo pluriennale: FIPS-203, FIPS-204, FIPS-205 . Con il rilascio dei primi tre standard PQC definitivi, le organizzazioni dovrebbero iniziare a migrare i propri sistemi verso la crittografia quantistica. Il NIST prevede che i due standard di firma digitale (ML-DSA e SLH-DSA) e lo standard del meccanismo di incapsulamento delle chiavi (ML-KEM) forniranno la base per la maggior parte delle implementazioni della crittografia post-quantistica. Possono e devono essere utilizzati fin da ora. (Rif. https://csrc.nist.gov/projects/post-quantum-cryptography#pqc-standards) Post-Quantum Cryptography (PQC) – La soluzione software La PQC si basa su algoritmi progettati per girare su computer attuali, ma strutturati su problemi matematici così complessi da resistere anche alla potenza di calcolo di un futuro computer quantistico. Famiglie di Algoritmi Standardizzati (NIST) Basata su Reticoli (Lattice-based): È la famiglia più promettente. Include ML-KEM (ex Kyber) per lo scambio di chiavi e ML-DSA (ex Dilithium) per le firme. Si fondano su problemi come il Shortest Vector Problem. Basata su Codici (Code-based): Deriva dal sistema McEliece. Estremamente sicura e studiata, ma soffre di chiavi pubbliche molto grandi. Basata su Hash (Hash-based): Utilizzata per le firme digitali (es. SLH-DSA/SPHINCS+). La sicurezza dipende esclusivamente dalla robustezza delle funzioni hash, rendendola molto affidabile. Basata su Isogenie (Isogeny-based): Sfrutta le proprietà delle curve ellittiche. Nonostante l’efficienza, il recente cracking dell’algoritmo SIKE ha invitato alla massima cautela. Pro e Contro della PQC Quantum Key Distribution (QKD) – La soluzione fisica A differenza della PQC, la QKD non usa la matematica, ma le leggi della meccanica quantistica per distribuire chiavi crittografiche. Il protocollo principe è il BB84. Principi Quantistici Fondamentali Indeterminazione di Heisenberg: Misurare un sistema quantistico lo altera inevitabilmente. Teorema di No-cloning: È impossibile copiare uno stato quantistico ignoto senza distruggerlo. Risultato: Se un hacker tenta di intercettare la chiave durante la trasmissione, le particelle (fotoni) cambiano stato, rivelando immediatamente l’intrusione. Limiti della QKD Nonostante la sicurezza “teoricamente perfetta”, la QKD richiede infrastrutture dedicate (fibra ottica speciale o satelliti) e ha una distanza limitata (circa 200 km) a causa della perdita di segnale. Inoltre, non gestisce l’autenticazione, richiedendo comunque algoritmi classici o PQC per identificare le parti. Analisi Comparativa Modello di Sicurezza: La PQC è “computazionale” (difficile da rompere), la QKD è “informatica-teoretica” (impossibile da rompere per leggi fisiche). Implementazione: La PQC è Software-defined (patch e aggiornamenti); la QKD è Hardware-defined (nuove reti fisiche). Casi d’uso: La PQC è la soluzione per il mass-market (web, banche, IoT). La QKD è riservata ad altissima sicurezza (militare, infrastrutture critiche, comunicazioni governative). La Soluzione con Approccio Ibrido La strategia vincente, definita Defense in Depth, prevede l’uso combinato di: Algoritmi Classici + PQC: Per garantire la sicurezza oggi e domani durante la transizione. PQC + QKD: Per i dati ultra-sensibili, dove la matematica della PQC protegge l’autenticazione e la fisica della QKD protegge la riservatezza della chiave. A questo punta lasciamo la teoria per sporcarci le mani direttamente sulla shell. Di seguito vedremo come costruire un lab per negoziare la prima connessione post-quantistica della vostra vita. Ma prima dobbiamo porci una domanda, quanto siamo esposti oggi? Mostriamo uno snippet che ce lo dice chiaramente; a titolo di esempio è stato preso il sito google.com : Osservando questo output, un analista può osservare la “data di scadenza” della propria infrastruttura. Nonostante l’uso di protocolli moderni come TLS 1.2, l’impiego di rsaEncryption e ECDHE (Elliptic Curve Diffie-Hellman Ephemeral) espone il fianco a due minacce quantistiche immediate: L’Algoritmo di Shor: In grado di risolvere il logaritmo discreto e la fattorizzazione, rendendo nulle le attuali chiavi pubbliche. L’instabilità della PKI: Se la firma della CA è RSA, l’intera catena di fiducia crolla. Lab in a Box Giunti a questo punto, la sfida si sposta sulla resilienza operativa: quali architetture crittografiche dobbiamo adottare fin da subito per garantire che i dati esfiltrati oggi restino indecifrabili anche nell’era del calcolo quantistico? Come indicato dal Nist la soluzione adottabile nell’immediato è l’adozione di una soluzione ibrida utilizzando algoritmi classici + PQC . In questa sessione di laboratorio, approfondiremo l’implementazione di un server Nginx configurato con algoritmi Post-Quantum (PQ). Per l’esercitazione utilizzeremo il framework OpenQuantumSafe (OQS) all’interno di un ambiente containerizzato Docker Desktop su Windows. Utilizzeremo l’ecosistema liboqs, una libreria C open source per algoritmi crittografici resistenti ai quantistici, integrata in Nginx tramite una versione modificata di OpenSSL. Prerequisiti: Assicurarsi di aver installato ed avviato Docker Desktop (Backend WSL2) sul proprio pc. Stack tecnologico: Server: Immagine Docker openquantumsafe/nginx. Client: Immagine Docker openquantumsafe/curl. Protocollo: TLS 1.3 con scambio chiavi Post-Quantum . Step 1: Preparazione dell’ambiente Assicuratevi che Docker Desktop sia avviato sul vostro sistema Windows. Aprite il terminale (PowerShell). Scarichiamo le immagini necessarie dal repository ufficiale di OpenQuantumSafe: Verifichiamo le immagini scaricate: A questo punto creiamo una network in modo tale da porter far dialogare i container : Step 2: Configurazione e Avvio del Server Nginx L’immagine openquantumsafe/nginx è pre-configurata con OpenSSL abilitato per la PQC. Per impostazione predefinita, il server è pronto ad accettare connessioni su una porta specifica utilizzando algoritmi ibridi o puramente quantistici. Affinchè possiamo constatare che tipo di negoziazione siamo stabilendo, sono state inserite nel file di configurazione nginx.conf le seguenti righe per consentire di loggare le informazioni necessarie: --- LA DIRETTIVA VA DENTRO HTTP --- log_format pqc_logs '$remote_addr - $remote_user [$time_local] ' '"$request" $status $body_bytes_sent ' '"$ssl_protocol" "$ssl_cipher" "$ssl_curve"';# --- LA DIRETTIVA VA DENTRO SERVER ---access_log /opt/nginx/logs/access.log pqc_logs pqc_logs; Avviamo il container del server esponendo la porta 4433: docker run -d –network nginx-test –name oq-nginx -p 4433:4433 openquantumsafe/nginx Mettiamoci in tail sul file di log del container nginx: docker logs tail -100 oq-nginx Step 3: Test di Funzionamento Eseguiamo due test di connessione puntando all’indirizzo IP locale (o al nome del container se sulla stessa rete Docker) utilizzando il container curl e contemporaneamente avviamo il comando tail sul log del container nginx; in questa maniera possiamo osservare grazie alla modifica effettuata del log del server nginx quale algoritmo stiamo negoziando: Il primo test è effettuato senza richiedere la forzatura post quantistica per cui il server negozierà una connessione standard moderna molto sicura, ma ancora basata su crittografia classica “pre-quantistica”. Il secondo test sarà effettuato forzando un algoritmo quantistico in modalità ibrida. Primo test Questa stringa rappresenta i dettagli tecnici di una connessione sicura via TLS 1.3 (Transport Layer Security). In pratica, descrive le “regole del gioco” che il client (es. curl) e il server (es. NGINX) hanno concordato per proteggere i dati. È composta da due parti principali: la Cipher Suite e il Key Exchange Group. 1. TLS_AES_256_GCM_SHA384 (La Cipher Suite) Questa parte definisce gli algoritmi usati per la crittografia dei dati e l’integrità una volta stabilita la connessione. TLS: Indica il protocollo utilizzato (TLS 1.3). AES_256_GCM: È l’algoritmo di crittografia simmetrica. - AES-256: Utilizza chiavi a 256 bit (estremamente sicure). - GCM (Galois/Counter Mode): Fornisce sia la riservatezza che l’autenticazione dei dati (AEAD), garantendo che nessuno li abbia modificati durante il transito. SHA384: È la funzione di hashing utilizzata per generare le “impronte digitali” dei messaggi e per derivare le chiavi. 2. X25519 (Il Key Exchange) Questa è forse la parte più importante nel contesto della crittografia moderna (ma non ancora post-quantistica). X25519: Rappresenta una curva ellittica (basata sulla Curva25519) utilizzata per lo scambio di chiavi tramite il protocollo Diffie-Hellman (ECDHE). Cosa fa: Permette a due parti di generare una chiave segreta condivisa su un canale pubblico senza mai scambiarsi la chiave stessa. Limite Quantistico: Sebbene X25519 sia veloce e sicuro oggi, è vulnerabile ai futuri computer quantistici (tramite l’algoritmo di Shor). Secondo Test Qui siamo passati a una connessione ibrida. Vediamo il dettaglio: 1. TLS_AES_256_GCM_SHA384 Questa parte rimane identica a prima. È la “cassaforte” (il protocollo e la crittografia simmetrica) che protegge i dati una volta che la connessione è stata stabilita. Come accennato, AES-256 è già considerato “sicuro” contro i computer quantistici (basta raddoppiare la lunghezza della chiave rispetto ad AES-128). 2. X25519MLKEM768 (L’innovazione Quantistica) Questa è la vera novità del test con OpenQuantumSafe. Si tratta di un algoritmo ibrido per lo scambio delle chiavi. X25519: È l’algoritmo classico (basato su curve ellittiche) che abbiamo visto prima.ML-KEM-768: È il nuovo standard post-quantistico del NIST (precedentemente noto come Kyber-768). Si basa su problemi matematici legati ai “reticoli” (lattice-based cryptography), che i computer quantistici non sanno risolvere in modo efficiente. Perché è ibrido? In questa fase di transizione, la comunità scientifica preferisce usare entrambi. La chiave finale viene generata combinando i risultati di entrambi gli algoritmi. - Se Kyber avesse un bug (è nuovo), sei ancora protetto da X25519. - Se un computer quantistico rompe X25519, sei protetto da Kyber. Tabella Comparativa Conclusioni In un’architettura ibrida (come questa X25519MLKEM768), il componente classico (X25519) non è presente come residuo “dimenticato”, ma svolge due funzioni critiche di “sicurezza combinata”: 1. Il Fallback per la Sicurezza (Security Fallback) Al momento, gli algoritmi post-quantistici (PQC) come ML-KEM (Kyber) sono relativamente nuovi. Se un domani si scoprisse una vulnerabilità matematica in ML-KEM che permettesse a un computer tradizionale di romperlo, la tua connessione sarebbe comunque protetta da X25519. Logica: Per violare la connessione, un hacker dovrebbe rompere entrambi gli algoritmi simultaneamente. 2. Compatibilità con Sistemi Non-PQC Se il tuo client (es. un vecchio browser o un dispositivo IoT) non supporta le librerie OpenQuantumSafe, il server NGINX può scalare verso il basso (fallback) e negoziare una connessione usando solo X25519. Senza questo meccanismo, i sistemi che non “parlano” quantistico verrebbero semplicemente esclusi dalla rete. Lo scenario che si sta sempre più verificando negli attacchi moderni è il “Store Now, Decrypt Later”: oggi, un malintenzionato registra il tuo traffico protetto solo da X25519, tra 10 anni, usa un computer quantistico per rompere X25519 e leggere i dati del passato. Usando il componente quantistico ora, rendi quei dati illeggibili anche per i computer quantistici futuri. Riassunto della gerarchia nel Lab: X25519MLKEM768: Il massimo livello (Ibrido). Protegge da computer classici e quantistici. X25519: Il “Fallback” di lusso. Eccellente oggi, ma vulnerabile in futuro.RSA/DH: Il vero “Legacy”. Da eliminare. Nota: Per semplicità dimostrativa, l’immagine OQS-nginx viene fornita con un certificato server e un certificato CA precaricati. Per una distribuzione reale, è necessaria l’installazione di certificati specifici per il server. Questa operazione può essere agevolata montando la propria chiave e il proprio certificato server nell’immagine al percorso /opt/nginx/pki. Assumendo che il certificato e la chiave del server siano collocati in una cartella locale denominata server-pki, il comando di avvio sarebbe il seguente: docker run -p 4433:4433 -v $(pwd)/server-pki:/opt/nginx/pki openquantumsafe/nginx Creazione di certificati (di test) della CA e del server Per creare le chiavi e i certificati necessari, è possibile utilizzare l’immagine openquantumsafe/curl tramite i comandi standard openssl. Di seguito è mostrata una sequenza di esempio che utilizza: ‘qteslapi’ per la firma del certificato CA; ‘dilithium2’ per la firma del certificato del server; ‘nginx-server.my.org’ come indirizzo del server a cui è destinato il certificato. Al posto di ‘qteslapi’ o ‘dilithium2’, è possibile utilizzare uno qualsiasi degli algoritmi di autenticazione quantum-safe attualmente supportati. Crea ed entra nella directory che conterrà chiavi e certificatimkdir -p server-pki && cd server-pki# Crea la chiave e il certificato CA utilizzando qteslapidocker run -v $(pwd):/opt/tmp -it openquantumsafe/curl openssl req -x509 -new -newkey qteslapi -keyout /opt/tmp/CA.key -out /opt/tmp/CA.crt -nodes -subj "/CN=oqstest CA" -days 365# Crea la chiave del server utilizzando dilithium2docker run -v $(pwd):/opt/tmp -it openquantumsafe/curl openssl req -new -newkey dilithium2 -keyout /opt/tmp/server.key -out /opt/tmp/server.csr -nodes -subj "/CN=nginx-server.my.org"# Crea il certificato del serverdocker run -v $(pwd):/opt/tmp -it openquantumsafe/curl openssl x509 -req -in /opt/tmp/server.csr -out /opt/tmp/server.crt -CA /opt/tmp/CA.crt -CAkey /opt/tmp/CA.key -CAcreateserial -days 365 Si consiglia di omettere l’opzione -nodes nel comando di generazione della chiave CA sopra indicato per garantire che la chiave sia crittografata. Sarà poi possibile conservarla in un luogo sicuro per usi futuri.
blog.8bitsecurity.comJan 27, 2026extracted
L’eclissi della cifratura: AI, quantum e la sfida satellitare cinese nel 2026
C’è un pregiudizio piuttosto duro a morire: l’idea che lo spazio sia un dominio “altro”, qualcosa di slegato dalla sicurezza dei nostri server in ufficio o dalle linee di produzione qui in Italia. In realtà. oggi, il perimetro aziendale non finisce più al firewall, ma arriva a 36.000 chilometri di altezza. La convergenza tra l’intelligenza artificiale cinese, il quantum computing e le infrastrutture satellitari è forse la sfida più complessa della nostra epoca, perché unisce la velocità pura del software alla fisica delle orbite. Mentre leggete, la strategia di Pechino nota come “Harvest Now, Decrypt Later” (HNDL) ha smesso di essere un esercizio accademico per diventare un rischio operativo concreto. Molte aziende italiane guardano ancora solo a terra, mentre la minaccia viaggia a 27.000 km/h sopra le loro teste. Indice degli argomenti I report dell’ENISA per il biennio 2025-2026 e le analisi del BSI tedesco parlano chiaro: la Cina ha integrato con successo agenti AI nei propri satelliti quantistici sperimentali. Non stiamo parlando solo di record di distanza (hanno già superato i 10.000 km per la distribuzione di chiavi quantistiche QKD), ma di una vera AI-Offensive automatizzata: Saturazione satellitare: L’AI viene usata per mappare in tempo reale le vulnerabilità delle costellazioni LEO europee, individuando i punti deboli delle comunicazioni in pochi millisecondi. Quantum readiness: Mentre l’Europa punta al 2030-2035 per la migrazione, il progetto europeo Quantity e le varie agenzie di intelligence avvertono che il “Quantum Day” potrebbe arrivare molto prima. I dati che archiviamo oggi potrebbero essere decriptati tra pochi anni (o persino mesi). In questo scenario di estrema complessità, l’ACN (Agenzia per la Cybersicurezza Nazionale) gioca un ruolo determinante per la resilienza del Sistema Paese. Attraverso il monitoraggio costante del CSIRT Italia e l’attività di scrutinio del CVCN (Centro Valutazione e Certificazione Nazionale), l’Agenzia coordina la transizione verso algoritmi post-quantici e garantisce che le infrastrutture critiche italiane – incluse quelle dipendenti dallo spazio – adottino standard di sicurezza idonei a fronteggiare attacchi asimmetrici, riducendo la dipendenza da tecnologie extra-UE non verificate. In Italia, il 2026 è l’anno della verità. La “compliance formale” non basta più: NIS2 (Direttiva UE 2022/2555): Entro ottobre 2026, l’Italia dovrà aver recepito pienamente le sanzioni per i dirigenti che non monitorano la supply chain. Se il vostro fornitore cloud usa infrastrutture satellitari non verificate o hardware con backdoor AI, la responsabilità legale ricade su di voi. DORA (Digital Operational Resilience Act): Per chi lavora nel settore finanziario, i test di resilienza del 2026 devono ora includere scenari di Jamming o Spoofing (disturbo o falsificazione del segnale) potenziati dall’intelligenza artificiale. Dobbiamo guardare alla strategia di Pechino con occhio critico. La loro dottrina di “fusione civile-militare” trasforma ogni satellite commerciale in un potenziale nodo d’attacco. Immaginate satelliti dotati di processori AI che eseguono scansioni autonome delle nostre reti terrestri dall’alto, identificando falle nelle Ground stations e lanciando attacchi di “protocol poisoning” prima ancora che i nostri SOC se ne accorgano. Il rischio è che un’AI a bordo decida autonomamente di alterare la telemetria o iniettare codice malevolo nei flussi dati delle nostre PMI, magari manipolando i segnali GNSS per mandare fuori rotta la logistica automatizzata di una fabbrica o falsare i timestamp delle transazioni finanziarie. Come ci ricordava Nassim Nicholas Taleb nel suo saggio “Il Cigno nero”, tendiamo per natura a imparare dall’esperienza e dalla ripetizione: ci concentriamo ossessivamente su ciò che già sappiamo, trascurando sistematicamente l’ignoto. È proprio questa pigrizia mentale a lasciarci indifesi davanti all’imprevisto, che si tratti di mercati finanziari o della nostra quotidianità. Oggi, quel “salto nel buio” che ci rifiutiamo di guardare ha un nome preciso: la minaccia quantistica. Non è un pericolo futuro, ma una partita a scacchi che si gioca su due fronti asimmetrici. Se da un lato la Cina sta blindando le proprie comunicazioni investendo miliardi nella cifratura quantistica, dall’altro sta potenziando una capacità di calcolo senza precedenti dedicata alla “decryption” dei sistemi altrui. Questa asimmetria dà vita a un rischio che molti sottovalutano, ma che è già operativo: la strategia “Harvest Now, Decrypt Later” (Raccogli ora, decifra poi). Non dobbiamo immaginare un hacker che entra nei nostri sistemi domani mattina; sta già accadendo. I segreti industriali, i brevetti e le comunicazioni strategiche che transitano oggi su canali satellitari protetti da protocolli standard vengono intercettati e messi “in cassaforte”. Sono dati inutilizzabili oggi, ma pronti per essere esposti non appena i computer quantistici cinesi saranno pienamente operativi. In questo scenario, la nostra attuale difesa è già obsoleta. Non serve solo essere “sicuri”, bisogna essere agili. È qui che entra in gioco la Crypto-Agility, un concetto oggi centrale nei framework europei: la capacità di un’azienda di aggiornare i propri algoritmi di cifratura senza dover smantellare l’intera infrastruttura. Se i nostri dati non sono protetti oggi da algoritmi post-quantici (PQC), stiamo consegnando il nostro futuro industriale a chi avrà la chiave per aprirli tra pochi mesi o anni. Se la vostra azienda è soggetta a DORA o NIS2, la remediation non è solo un fatto tecnico, ma procedurale: Revisione contrattuale: non verificate solo il fornitore IT. Chiedete ai provider satellitari (Starlink, Eutelsat eccetera) la loro roadmap sulla “Quantum Readiness”. L’Articolo 21 della NIS2 vi rende responsabili della catena di approvvigionamento. Incident response: aggiornate i vostri playbook. Un’anomalia nel segnale satellitare non è un semplice “guasto tecnico”, va trattata come un potenziale attacco cyber. Stress test: includete scenari di “corruzione del dato satellitare”. La firma digitale e l’hashing dei dati devono diventare lo standard. In Italia, il 2026 segna il passaggio dalle slide alle sanzioni. Ecco come muoversi per la Pubblica Amministrazione e per le Pmi (oltre il fatturato): Per la Pubblica Amministrazione: PQC Roadmap: entro il 31 dicembre 2026 l’Italia deve definire la strategia per la crittografia Post-Quantica, dando priorità ai dati sanitari e ai segreti di Stato. Sovranità digitale: Incentivare tecnologie europee per ridurre la dipendenza da hardware extra-UE a rischio backdoor. Per le PMI (oltre il fatturato): Se avete più di 50 dipendenti o oltre 10 milioni di fatturato in settori critici (energia, salute, chimica, trasporti), siete nel perimetro NIS2. scadenza 1 ottobre 2026: obbligo di avere un piano di gestione del rischio documentato. Responsabilità del management: la novità è che i dirigenti rispondono personalmente. La sicurezza non è più un problema delegabile all’ufficio IT. Consigli pratici: Identità: usate token hardware (FIDO2) per proteggervi dai deepfake AI. Supply chain: richiedete la SBOM (Software Bill of Materials) per escludere codice non verificato. Quantum: Iniziate a mappare dove usate RSA o ECC per pianificare il passaggio a Kyber o Dilithium. AI Act, registro degli algoritmi: Se usi AI per il recruiting o la sicurezza, devi documentarne il funzionamento per l’AI Act (Piena operatività agosto 2026). Checklist per la supply chain (Audit NIS2 – D.lgs. 138/2024): mappare i sub-fornitori critici, distinguendo chi gestisce dati sensibili; inserire clausole contrattuali sui livelli di sicurezza minimi NIS2; richiedere un piano di risposta agli incidenti con pre-notifica entro 24 ore; verificare l’adozione di MFA su tutti gli accessi remoti e privilegiati; richiedere la SBOM per identificare librerie extra-UE; interrogare il fornitore sulla roadmap per l’adozione della crittografia post-quantica; assicurarsi che il personale del fornitore sia formato sui rischi di social engineering AI; pretendere report periodici sulle attività di patching e vulnerability management; testare annualmente la business continuity in caso di interruzione dei segnali satellitari; mantenere il diritto di effettuare audit periodici o richiedere certificazioni terze (ISO 27001). Il messaggio per il 2026 è brutale: non è più l’anno delle previsioni, ma dell’esecuzione. La minaccia non è più solo un malware, ma una scacchiera globale dove i qubit sono i pezzi e l’orbita terrestre è il campo da gioco. La sicurezza oggi è una questione di sopravvivenza legale e di continuità del business. Ignorare ciò che accade sopra le nostre teste significa accettare di essere l’ultimo a scoprire che le regole del gioco sono cambiate.
cybersecurity360.itJan 26, 2026extracted
Quantum-safe security: dalla consapevolezza alla migrazione crittografica
La quantum-safe security è l’insieme di strategie, tecnologie e procedure che consentono di proteggere dati, comunicazioni e infrastrutture crittografiche dall’impatto del calcolo quantistico. I computer quantistici, infatti, mettono in discussione il principio su cui si fonda la crittografia moderna, ovvero la difficoltà computazionale. Con la velocità dell’elaborazione quantistica, algoritmi come RSA ed ECC, oggi considerati sicuri, potranno essere decifrati in tempi infinitamente più brevi, rendendo vulnerabili chiavi, certificati e meccanismi su cui si basa ogni codifica di dati. I programmi di sviluppo tecnologico collocano questo punto di svolta in un orizzonte ormai vicino. Non a caso, la roadmap europea coordinata (documento 4NIS) invita gli Stati membri a integrare la minaccia quantistica nella gestione del rischio e ad avviare una pianificazione strutturata della transizione verso la crittografia post-quantum. Secondo Italware, IBM Platinum Partner e parte del Gruppo Digital Value, la vera sfida non è avere la tecnologia giusta, ma calarla nel contesto di ciascuna organizzazione. La sicurezza post-quantum richiede una visibilità capillare: capire dove sono le chiavi, quali sistemi dialogano tra loro, quali dipendenze crittografiche attraversano supply chain, cloud e ambienti legacy. Ogni impresa deve costruire la propria roadmap verso la quantum-safe security, con priorità, risorse e tempistiche sostenibili. «Il quantum computing impone un salto di paradigma nella sicurezza – spiega Luca Di Muccio, Data Security Brand Sales Specialist di IBM Technology –. Significa ammettere che le difese su cui abbiamo costruito trent’anni di comunicazioni digitali non saranno eterne. Le grandi potenze tecnologiche stanno già costruendo infrastrutture quantistiche operative, e questo cambia radicalmente la percezione del rischio. Se fino a oggi la sicurezza informatica si è basata sul tempo necessario per decifrare una chiave crittografica, l’arrivo del calcolo quantistico rende improvvisamente fragile quel presupposto. I pilastri della cifratura asimmetrica, infatti, possono essere violati in tempi infinitamente più brevi da macchine capaci di eseguire milioni di operazioni parallele». Indice degli argomenti Come sottolinea il manager, gli algoritmi classici verranno deprecati entro il 2030 e non più ammessi oltre il 2035, con l’obiettivo di completare la migrazione crittografica nei sistemi mission-critical entro il prossimo decennio. Ma la transizione richiede tempi lunghi (fino oltre 12 anni, secondo il sondaggio condotto dall’IBM Institute for Business Value: “The quantum clock is ticking: How quantum safe is your organization?“). Ecco perché bisogna iniziare a lavorare da subito a una transizione controllata verso algoritmi resistenti alle capacità quantistiche. Non farlo significa esporsi a una minaccia silente che diventerà evidente solo quando sarà troppo tardi. La premessa necessaria è che ogni firma elettronica, ogni pagamento, ogni accesso autenticato passa da un algoritmo crittografico: dai protocolli DNS e HTTPS ai sistemi di pagamento SWIFT e TARGET2, dalle identità digitali ai dispositivi industriali e automobilistici. Trilioni di transazioni ogni giorno, su miliardi di device, si affidano a chiavi matematiche che devono restare sicure per decenni. Ma il quantum computing cambierà questo equilibrio. In questa fase, la priorità non è sostituire in blocco gli algoritmi, ma sapere dove sono, come vengono usati e quanto sono vulnerabili. «Oggi gli attaccanti possono archiviare enormi quantità di dati cifrati con l’intenzione di decifrarli quando la potenza quantistica lo consentirà – osservaDi Muccio -. È la logica dell’harvest now, decrypt later che riguarda tutti i settori che conservano informazioni sensibili per lungo tempo: dalla finanza alla sanità, fino alla pubblica amministrazione. Dobbiamo cominciare a prepararci ora, perché la migrazione alla crittografia post-quantum richiede tempo, coordinamento e una conoscenza profonda di dove la crittografia è usata nei nostri sistemi. Non si tratta solo di sostituire un algoritmo: è un cambiamento culturale e infrastrutturale che deve partire dalla governance dei dati». La transizione verso la sicurezza post-quantum non è più un tema sperimentale, ma un processo industriale strutturato. Dal 2016 il National Institute of Standards and Technology (NIST) coordina il programma internazionale di selezione e standardizzazione degli algoritmi resistenti al calcolo quantistico, con l’obiettivo di definire primitive interoperabili e pronte all’adozione su larga scala. Dopo otto anni di analisi e test, nel 2024 il NIST ha selezionato i primi quattro algoritmi quantum-safe: CRYSTALS-Kyber per la cifratura e CRYSTALS-Dilithium, Falcon e SPHINCS+ per la firma digitale. Tre di questi, Kyber, Dilithium e Falcon sono stati sviluppati con un contributo diretto di IBM Research, in collaborazione con università e partner del consorzio internazionale PQC (Post-Quantum Cryptography). Guardando all’Europa, il gruppo di cooperazione NIS ha pubblicato una roadmap per la Post-Quantum Cryptography (PQC) che fissa le prime scadenze operative al 2026, invitando gli Stati membri a integrare la minaccia quantistica nella gestione del rischio delle infrastrutture critiche, ad avviare la mappatura delle risorse crittografiche in uso e a promuovere la crypto-agility come capacità strutturale delle organizzazioni europee. La roadmap coordinata del gruppo NIS europeo definisce tempi e priorità per accompagnare Stati membri e imprese nella migrazione verso la crittografia post-quantum e promuovere la crypto-agility entro il 2030. Anche altri regolatori, come nel caso dello standard PCI DSS 4.0, iniziano a richiedere una gestione documentata degli algoritmi crittografici e delle relative dipendenze lungo la supply chain, segnalando un’evoluzione che lega la sicurezza post-quantum non solo alla ricerca ma anche alla compliance governativa. «Il lavoro del NIST e del gruppo NIS europeo segna un passaggio determinante – fa notare Di Muccio -. Per la prima volta disponiamo di riferimenti complementari: da un lato, la definizione di algoritmi standardizzati e certificabili; dall’altro, un quadro regolatorio che li inserisce nei processi di governance e di gestione del rischio. Ma gli standard da soli non bastano: bisogna garantire interoperabilità e coesistenza, perché per molti anni convivranno algoritmi classici e post-quantum. Servono architetture aperte, capaci di integrare entrambe le generazioni crittografiche nello stesso perimetro di sicurezza, mantenendo tracciabilità, controllo e conformità lungo tutto il ciclo di vita dei dati». Capire dove si trovano le dipendenze crittografiche, quali applicazioni le utilizzano e come si propagano è il primo passo per costruire una strategia di migrazione sostenibile. È qui che la quantum-safe security diventa materia di governance. «Oggi il vero problema non è scegliere il giusto algoritmo post-quantum, ma sapere dove e come intervenire – sottolineaDi Muccio -. In molte realtà non esiste ancora un inventario completo delle istanze crittografiche: chiavi, certificati, protocolli, librerie. Senza questa visibilità la migrazione diventa un salto nel buio. Ecco perché è fondamentale una crypto-inventory. La costruzione di una mappa precisa di dove la crittografia è usata e di come si connette ai processi aziendali è il prerequisito della crypto-agility aziendale. La capacità di aggiornare o sostituire gli algoritmi senza interrompere la continuità dei servizi è una competenza di governance, non solo tecnica: richiede metodo, coordinamento e la consapevolezza che la sicurezza è un sistema vivo, che deve evolvere insieme all’infrastruttura». Tradurre la crypto-resilience in progetti concreti richiede un passaggio di scala: dal framework globale alla realtà operativa delle imprese. La transizione verso la sicurezza post-quantum non è un aggiornamento tecnico, ma un percorso che coinvolge architetture, processi e competenze. In questa fase è importante avvalersi di un partner capace di affiancare le aziende ad interpretare le linee guida per adattarle ai contesti specifici offrendo tutto il supporto necessario lungo la roadmap di migrazione. «Per IBM i partner sono l’estensione naturale della strategia di sicurezza – puntualizza Di Muccio -. Sono loro a trasformare gli standard in procedure operative, a unire la dimensione tecnologica con quella di governance, a garantire continuità e competenze sul territorio. È attraverso l’ecosistema che la quantum-safe security diventa realmente applicabile e scalabile: perché solo chi conosce a fondo i contesti locali può rendere concreti e best practice e principi». L’obiettivo della Quantum-safe security non è blindare le infrastrutture, ma costruire un sistema capace di adattarsi, evolvere e dimostrare la propria efficacia anche in presenza di nuove capacità di calcolo. In questa prospettiva si colloca la metodologia di IBM, che traduce la complessità della migrazione in un processo strutturato e verificabile, fondato su tre fasi complementari: mappare, valutare, agire. «La crypto-resilience nasce dalla necessità di rendere la sicurezza non solo robusta, ma anche visibile e misurabile – ribadisce Di Muccio –. Sapere dove si trovano le chiavi, come sono gestite e quali algoritmi le proteggono è il prerequisito per ogni strategia di transizione. Senza visibilità, la migrazione diventa cieca». In questa logica, la metodologia IBM segue un approccio circolare di crypto-agility: scoprire e inventariare le dipendenze crittografiche (Discover and Inventory), valutarne la postura e la conformità (Assess and Comply), gestirne il ciclo di vita (Manage Lifecycle) e, infine, adattare continuamente l’architettura (Protect and Adapt). È un percorso che unisce automazione e governance, per garantire che la sicurezza non sia mai un punto fermo, ma un processo evolutivo capace di proteggere oggi e preparare al domani. Per supportare questo percorso, IBM ha sviluppato la suite IBM Guardium Quantum Safe, un framework operativo che integra strumenti e metodologie per accompagnare le imprese nella transizione verso la crittografia post-quantum: Quantum Safe Explorer, per identificare e inventariare le dipendenze crittografiche presenti nei software aziendali – dalle chiavi ai certificati, dalle librerie ai protocolli – restituendo una mappa completa degli asset da proteggere. Guardium Cryptography Manager, che analizza il livello di rischio associato a ciascun algoritmo e definisce le priorità di intervento in base a criticità, compliance e impatti operativi consentendo di pianificare e automatizzare la sostituzione progressiva degli algoritmi vulnerabili. Quantum Safe Remediator, che permette comunicazioni sicure fra dispositivi, assicurando interoperabilità e retrocompatibilità con supporto di algoritmi classici e PQC. «L’obiettivo – aggiunge Di Muccio – è accompagnare le organizzazioni in un percorso graduale, non traumatico. Prima si mappa, poi si valuta, infine si agisce. La migrazione verso algoritmi quantum-safe deve essere orchestrata. Solo in questo modo è possibile mantenere continuità operativa e compliance durante la transizione. Questa logica si estende anche alla gestione delle chiavi e delle infrastrutture di protezione. I prodotti della suite IBM Guardium supportano, inoltre, servizi e soluzioni come IBM Key Protect e IBM Hyper Protect Crypto Services per la cifratura hardware based e la gestione centralizzata delle chiavi, assicurando che i nuovi algoritmi possano essere distribuiti e aggiornati in modo sicuro anche in ambienti ibridi e multicloud». La Quantum-safe security sarà la base per costruire ecosistemi adattivi, in cui la protezione evolve insieme ai modelli di business e alle architetture IT. Non più un layer di difesa, ma un elemento intrinseco della progettazione digitale. La vera innovazione, infatti, non riguarda solo la forza degli algoritmi, ma la capacità delle organizzazioni di rendere la sicurezza parte del proprio DNA architetturale: una componente che cresce, si adatta e si rinnova al passo con la complessità tecnologica e con la velocità delle minacce. In questa prospettiva, la sicurezza post-quantum non rappresenta un punto di arrivo, ma l’inizio di un nuovo paradigma di progettazione, fondato sulla trasparenza crittografica, sulla misurabilità dei rischi e sulla collaborazione tra attori diversi dell’ecosistema digitale. «La sicurezza post-quantum non è una corsa contro il tempo, ma una trasformazione permanente del modo in cui pensiamo la crittografia – conclude Di Muccio -. Significa passare da un approccio difensivo a un modello adattivo, in cui la protezione diventa parte integrante della progettazione digitale. Oggi parliamo di quantum-safe, ma tra pochi anni parleremo di quantum-ready: ecosistemi in grado non solo di resistere al cambiamento, ma di anticiparlo, aggiornando automaticamente le proprie difese, integrando nuove competenze e mantenendo la fiducia come valore misurabile. È questa la direzione verso cui stiamo andando: una sicurezza evolutiva, costruita per durare nel tempo».
cybersecurity360.itDec 4, 2025extracted