ThreatBeaconXSubscribe
HighThreat Intelligence · 14 min read

SANSAR Linux Cryptomining Malware Hides GPU Activity Using Kernel Rootkit and Fake NVIDIA Telemetry

Elastic Security Labs published an investigation on November 12, 2026, detailing a Linux cryptomining intrusion tracked as REF3364. The operation targeted GPU infrastructure and deployed a sophisticated malware toolkit designed to manage CPU and GPU miners while concealing their activity from system monitoring tools. The central component, SANSAR, is a Rust-based cryptomining orchestrator that communicates with its command-and-control (C2) infrastructure over Tor. It manages publicly available mining software, including XMRig and SRBMiner-MULTI, and supports remote shell access, miner configuration and traffic-generation tasks. The toolkit combines several components: SANSAR: Rust-based orchestrator responsible for C2 communication and miner management. acpi_thermal_mgr.ko: Linux kernel rootkit that conceals selected processes, files and network sockets. NVML wrapper: Modified NVIDIA Management Library that falsifies GPU utilization, temperature and power readings. netns: Separate backdoor that retrieves its C2 IP address from an Ethereum smart contract. kurt: XMRig CPU cryptocurrency miner. tilki: SRBMiner-MULTI GPU cryptocurrency miner. lyrebird: Tor pluggable-transport helper supporting WebTunnel and obfs4 bridges. The attacker initially compromised an exposed Ray job agent that accepted unauthenticated job submissions. After obtaining root access, the actor deployed the toolkit across three Linux GPU hosts. One of the most notable findings is the manipulation of NVIDIA monitoring data. The modified NVML library reports GPU utilization as 0%, even while mining activity is taking place. This allows malicious compute consumption to remain less visible to conventional GPU monitoring.

Written by Vedanabhatla Sai Swetha·Published Nov 15, 2026

Description

Cryptojacking involves unauthorized use of computing resources to mine cryptocurrency. Attackers compromise servers, cloud infrastructure or endpoints and use their CPU or GPU capacity for mining without the owner's permission.

In the SANSAR intrusion, Elastic identified a more sophisticated approach than simply installing a cryptocurrency miner.

The attacker deployed a coordinated Linux malware toolkit that included a remote-management component, a kernel rootkit, a modified NVIDIA monitoring library and a separate backdoor.

The operation specifically targeted Linux GPU infrastructure. The attacker abused an exposed Ray job agent to execute commands, established persistent access through SSH authorized keys and subsequently obtained root privileges.

After gaining control, the attacker deployed the malware under /opt/vadi_, installed a kernel module through Dynamic Kernel Module Support (DKMS), modified NVIDIA's management library and registered the separate netns backdoor as a systemd service.

The combination of process concealment and falsified hardware telemetry made the mining activity significantly harder to identify through ordinary system monitoring.

Technical Description

1. SANSAR — Rust-Based Cryptomining Orchestrator

SANSAR is the primary management component of the toolkit.

It is written in Rust and identified by the version string:

sansar-client v0.1.3

Its responsibilities include:

  • Communicating with the operator through Tor.

  • Collecting host and GPU information.

  • Registering compromised systems with the C2 server.

  • Managing CPU and GPU cryptocurrency miners.

  • Opening interactive Bash sessions.

  • Updating mining configurations.

  • Monitoring miner output and status.

  • Managing Tor connections and bridge configurations.

  • Supporting network traffic-generation tasks.

SANSAR does not contain a fixed mining-pool address or wallet configuration. Instead, the C2 server supplies the mining configuration when issuing a MinerStart command.

This gives the operator flexibility to change the mining destination and configuration remotely.

2. XMRig and SRBMiner-MULTI

SANSAR manages two different mining programs.

Component

Software

Purpose

kurt

XMRig 6.25.0

CPU cryptocurrency mining

tilki

SRBMiner-MULTI 3.6.9

GPU cryptocurrency mining

The malware selects the appropriate miner according to the supplied miner type.

  • Miner type 0 selects the GPU miner, tilki.

  • Miner type 1 selects the CPU miner, kurt.

Elastic found that the collected tilki executable had the same SHA-256 hash as the official SRBMiner-MULTI 3.6.9 Linux release.

This is an important forensic detail: the presence of a legitimate mining binary does not automatically make the activity benign. The context of installation, execution, configuration and unauthorized control must also be examined.

3. acpi_thermal_mgr.ko — Linux Kernel Rootkit

The acpi_thermal_mgr.ko kernel module is responsible for concealing malicious activity.

It uses Linux Function Tracer (ftrace) to intercept selected kernel functions and system calls.

Its capabilities include:

  • Hiding selected processes.

  • Hiding worker threads associated with concealed processes.

  • Removing selected entries from directory listings.

  • Preventing access to hidden process information.

  • Concealing selected files and directories.

  • Filtering TCP and UDP socket listings.

  • Potentially hiding its own kernel module entry.

The rootkit hooks functions including:

  • getdents64

  • openat

  • kill

Process concealment

The rootkit modifies directory-listing results so that selected process IDs are omitted from /proc.

For example, when a monitoring tool attempts to enumerate processes, the kernel module can remove entries associated with configured hidden processes.

It also intercepts access to hidden process paths and can return errors such as:

  • ENOENT — No such file or directory.

  • ESRCH — No such process.

These responses make concealed processes appear nonexistent to certain inspection tools.

File concealment

When configured with a hidden filename prefix, the module removes matching files and directories from directory listings.

It also blocks access to matching paths through the open and openat hooks.

Socket concealment

The module intercepts kernel routines responsible for producing TCP and UDP socket listings. This allows it to conceal selected network connections from conventional inspection tools.

Module self-hiding

When the hide_module parameter is enabled, the module removes its entry from the kernel module list and its sysfs object.

This creates an additional obstacle for investigators attempting to identify the malicious kernel component through ordinary module enumeration.

4. Modified NVML Library — Falsifying GPU Telemetry

One of the most distinctive techniques in the SANSAR toolkit is its modification of NVIDIA's Management Library.

NVML is a user-space library used by NVIDIA monitoring tools, including nvidia-smi, to retrieve GPU information.

The attackers replaced the normal NVML library interface with a modified wrapper.

The wrapper forwards requests to the genuine NVIDIA library and then alters selected results before returning them to the requesting application.

Observed telemetry manipulation

GPU Metric

Reported Value

GPU utilization

0%

GPU temperature

Random values between 36°C and 46°C

GPU power consumption

Random values between 100 W and 200 W

The wrapper therefore creates misleading monitoring results even when the GPU is being used by the cryptocurrency miner.

Elastic identified the following directory:

/opt/vadi_/nvml-hook/

It contained:

  • nvml_hook.c

  • A Makefile

  • The modified libnvidia-ml.so.1 library.

The installation process uses make, make install and ldconfig to replace the NVML library used by monitoring applications.

The genuine versioned NVIDIA library is retained for backend calls, and a backup may be created at:

/usr/lib/.libnvidia-ml.so.1.backup

This is particularly important for GPU-intensive AI and machine-learning environments, where administrators frequently depend on NVIDIA telemetry to monitor hardware utilization.

5. netns — Ethereum-Assisted Backdoor

The separate netns component provides another method of remote access.

Unlike SANSAR, which obtains its C2 information from an encoded Tor onion address, netns retrieves its controller's IPv4 address from an Ethereum smart contract.

The backdoor sends eth_call requests over HTTPS through public Ethereum RPC services.

Embedded Ethereum contract:

0x43eb291f56688c63c93e8a93c4591fc997cf6349

Function selector:

0x6ded96e7

The smart-contract response contains an encoded IPv4 address.

The backdoor decodes this address and attempts to connect to the controller over TCP port 8080.

After connecting, the controller can send a command using the format:

SHELL <host> <port>

The backdoor parses the supplied destination, creates a child process and launches Bash to establish another outbound connection.

The destination of this reverse-shell connection can be different from the controller address obtained from Ethereum.

Elastic also observed that the command loop does not implement application-level authentication or integrity checking.

This design demonstrates how public blockchain infrastructure can be used as a dynamic C2 discovery mechanism.

Attack Overview

Initial Access: Exposed Ray Job Agent

The attacker initially compromised a Linux GPU host through an exposed Ray job agent.

Ray is an open-source framework used to distribute Python workloads across multiple machines. It supports distributed machine-learning training, inference and other computational workloads.

Its Jobs API allows users to submit applications and commands for execution on a Ray cluster.

In the observed intrusion:

  • The Ray dashboard on the head node listened only on the local loopback interface.

  • The job agent remained accessible from the internet.

  • The exposed interface accepted job submissions without authentication.

This allowed the attacker to submit jobs and execute commands through Ray.

Attack Timeline

Date

Observed activity

October 22, 2026

External probing appeared in Ray logs

October 24, 2026

A submitted job executed nvidia-smi and transmitted GPU inventory to an external server

October 25, 2026

A Python reverse-shell job connected to an external listener

Following initial access

The attacker added an SSH public key to the compromised account's authorized_keys file

Post-compromise

The attacker obtained root privileges and deployed the SANSAR toolkit

Subsequent activity

The toolkit was deployed across three Linux GPU hosts

Phase 1: Reconnaissance and GPU Discovery

The attacker used the exposed Ray job agent to execute commands on the first compromised host.

One of the early commands was:

nvidia-smi

The command was used to identify the available GPU hardware.

The collected information was transmitted to an external server.

SANSAR also collects information about the compromised host, including:

  • Hostname from /etc/hostname.

  • GPU model and device count.

  • Logical CPU count from /proc/cpuinfo.

  • Public IP address.

  • System uptime.

  • Logged-in user information.

  • System load averages.

Phase 2: Reverse Shell and Persistence

On October 25, 2026, the attacker submitted a Python reverse-shell job.

The reverse shell connected to an external listener and ran under the local account associated with the Ray session.

The attacker subsequently added an SSH public key to the account's:

authorized_keys

This allowed persistent SSH access without repeatedly relying on the initial Ray job submission.

Phase 3: Privilege Escalation and Toolkit Deployment

After obtaining root privileges, the attacker staged the toolkit under:

/opt/vadi_/

The installation involved:

  1. Deploying the SANSAR orchestrator.

  2. Building the acpi_thermal_mgr kernel module using DKMS.

  3. Adding an initramfs loader to support loading the module during boot.

  4. Replacing the NVIDIA Management Library with a modified wrapper.

  5. Registering the netns backdoor as a systemd service.

The GPU miner was deployed later on two hosts.

Elastic observed a kernel log recording /opt/vadi_/tilki starting on one machine. Cache creation and new GPU contexts provided supporting evidence of execution on the other system.

Phase 4: Tor-Based Command and Control

SANSAR uses the Arti library, the Rust implementation of Tor, for its C2 communication.

The malware supports two connection modes:

  • Direct mode: Connects through Arti without Lyrebird.

  • Bridge mode: Uses Lyrebird to reach Tor through configured WebTunnel or obfs4 bridges.

Both modes connect to the same onion C2 service.

The malware stores supporting data relative to its executable directory, including:

  • arti_data/state

  • arti_data/cache

  • bridges

  • .client_id

  • lyrebird

The recovered bridge configuration contained seven WebTunnel entries and three obfs4 entries.

Phase 5: Mining and Concealment

After connecting to the C2 infrastructure, SANSAR receives commands to start and manage CPU and GPU miners.

The kernel rootkit conceals selected mining processes, files and socket entries.

At the same time, the NVML wrapper modifies GPU telemetry so that monitoring applications report 0% utilization.

This combination allows the miners to continue consuming system resources while making ordinary process and hardware monitoring less reliable.

Phase 6: Separate Ethereum-Based Backdoor

The netns backdoor provides a separate command-execution mechanism.

It retrieves its controller IP address through an Ethereum smart contract and establishes a TCP connection to port 8080.

The controller can then request a reverse shell by supplying a SHELL command.

This creates an additional remote-access channel that does not depend on SANSAR's Tor C2 connection.

Technical Analysis

SANSAR's Anti-Analysis Mechanisms

Before establishing its C2 connection, SANSAR performs anti-debugging checks.

It reads:

/proc/self/status

It examines the TracerPid value and exits if it is nonzero.

This helps detect whether the process is being traced by a debugger.

SANSAR also measures the execution time of a 1,000-iteration loop. It exits if the operation takes 501 milliseconds or longer.

These checks can interfere with dynamic analysis in debugging environments and virtualized sandboxes.

Encoded Tor C2 Address

SANSAR stores its onion C2 hostname as 62 encoded bytes.

Elastic reproduced the decoding process offline.

Each byte is rotated right by a position-dependent amount and then XORed with a byte from a repeating 32-byte mask.

The decoding operation is:

plaintext[i] = ROR8(ciphertext[i], (i % 7) + 1) XOR mask[i % 32]

The resulting onion address is:

efxisnqldelyr5ra25oqfrsut54b34g26e7zrsiuupsoekjof2gho2id.onion:9051

The malware uses this address for command delivery, host registration, inventory reporting and miner-status communication.

HMAC-Based Registration

SANSAR uses an HMAC-SHA256-based authentication field during registration.

The 40-byte field consists of:

  • An 8-byte timestamp.

  • A 32-byte HMAC-SHA256 digest.

The digest is calculated using the client ID, timestamp and a key embedded in the binary.

The format is:

timestamp = BE64(unix_seconds)

authentication = timestamp || HMAC-SHA256(K, client_id_bytes || timestamp)

The malware also sends periodic heartbeats reporting its runtime, Tor connection mode and reconnection statistics.

Binary C2 Protocol

SANSAR communicates through a binary message protocol over Tor.

Each message contains:

  • A four-byte big-endian body length.

  • A four-byte little-endian message type identifier.

  • A payload containing the message-specific information.

Elastic identified 16 incoming message types.

ID

Message Type

Function

0

RegisterAck

Confirms registration and provides session information

1

HeartbeatAck

Acknowledges a client heartbeat

2

Command

Handles version responses, restart requests and unsupported custom commands

3

Disconnect

Closes the current C2 session

4

BridgeUpdate

Updates the Tor bridge configuration

5

ShellOpen

Opens an interactive Bash session

6

ShellData

Sends input to an existing shell

7

ShellResize

Changes terminal dimensions

8

ShellClose

Closes a shell session

9

StressStart

Starts a TCP SYN traffic-generation task

10

StressStop

Stops a selected traffic-generation task

11

MinerStart

Starts a CPU or GPU miner

12

MinerStop

Stops a selected miner

13

MinerConfigUpdate

Updates miner configuration

14

MinerOutputStart

Enables miner console-output forwarding

15

MinerOutputStop

Disables miner console-output forwarding

Interactive shell behavior

The ShellOpen handler launches:

/bin/bash --norc --noprofile

It runs Bash in a pseudo-terminal and configures:

HISTFILE=/dev/null

It also sets the shell-history size variables to zero, preventing normal command-history storage.

This is an important forensic consideration because standard shell-history review may not provide a complete record of commands executed through these sessions.

Indicators of Compromise (IOCs)

Elastic Security Labs published the following SHA-256 hashes for the components identified in its investigation.

SHA-256 File Hashes

SHA-256

File

Description

00c9ac44291f83c72d54302e99d155a3e26d02225a3e516764d5833a99657c9e

sansar

Rust-based mining orchestrator

96fc528ca5e7d1c2b3add5e31b8797cb126f704976c8fbeaecdbf0aa4309ad46

kurt

XMRig 6.25.0 CPU miner

acc706afc9322a3eae1ef49049749e0a7c9f1a123895ac56dc8a289beb2fb5b7

tilki

SRBMiner-MULTI GPU miner

cc1ad7f14777a098ccc91fd4e8f6143da14418c2b6fdf23b7f8f6b3d1b0b7f1d

lyrebird

Tor transport helper

675c24728f87f7aa0fa07527027c95c24c246049c65eaef89270ab04ea50a180

libnvidia-ml.so.1

Modified NVML wrapper

6ba1aa275e0e2826e8b48b36473539ca56cbdc41f429e539a45f8532b084d7a4

acpi_thermal_mgr.ko

Linux kernel rootkit

df8ab6fd699e6ae90e63e9696bae8f01342708bafc2ed88af414337e4f237194

netns

Ethereum-assisted backdoor

Network Indicators

Indicator

Type

Purpose

efxisnqldelyr5ra25oqfrsut54b34g26e7zrsiuupsoekjof2gho2id.onion

Tor onion address

SANSAR C2

Port 9051

TCP port

SANSAR onion service port

0x43eb291f56688c63c93e8a93c4591fc997cf6349

Ethereum contract

netns C2 address resolution

0x6ded96e7

Function selector

Ethereum contract call

Port 8080

TCP port

netns controller connection

File and Directory Artifacts

Artifact

Description

/opt/vadi_/

Toolkit staging directory

/opt/vadi_/nvml-hook/

NVML wrapper source and build files

/opt/vadi_/nvml-hook/nvml_hook.c

Modified NVML wrapper source

/usr/lib/.libnvidia-ml.so.1.backup

Potential backup of the original NVML library

/usr/src/acpi_thermal_mgr-1.0/

Rootkit source directory

acpi_thermal_mgr.ko

Kernel rootkit module

/tmp and user SSH configuration

Areas to inspect for unexpected access artifacts

Process and Command Indicators

  • sansar

  • kurt

  • tilki

  • lyrebird

  • netns

  • nvidia-smi --query-gpu=name --format=csv,noheader

  • /bin/bash --norc --noprofile

  • HISTFILE=/dev/null

  • Unexpected Python reverse-shell jobs submitted through Ray.

IOC handling note: The hashes and infrastructure indicators above are taken from Elastic's investigation. The SRBMiner-MULTI executable identified as tilki had the same hash as the official release, so its hash alone should not be treated as proof of malware. Investigators should correlate it with its installation path, execution context and unauthorized mining configuration.

Detection and Threat Hunting

Traditional process and GPU monitoring may be unreliable when a rootkit and modified hardware-monitoring library are present.

Security teams should therefore correlate multiple sources of evidence rather than relying on a single command or dashboard.

1. Ray Job-Agent Exposure

Investigate Ray deployments for:

  • Internet-accessible job-agent endpoints.

  • Jobs submitted without authentication.

  • Unexpected Python job submissions.

  • Commands executing nvidia-smi.

  • Reverse-shell processes launched from Ray workloads.

  • Unexpected outbound connections following job execution.

Review Ray job logs and correlate job submission timestamps with network and endpoint events.

2. SSH Persistence

Review:

  • Unexpected additions to authorized_keys.

  • Changes to SSH configuration.

  • New login sessions.

  • Unusual SSH authentication patterns.

  • Access from unfamiliar source addresses.

Pay particular attention to the local account that owns the Ray session.

3. Kernel Rootkit Detection

Investigate:

  • Unexpected kernel modules.

  • Unusual DKMS registrations.

  • Changes to initramfs images.

  • Unexpected ftrace hooks.

  • Differences between process listings from independent collection methods.

  • Suspicious changes to /proc and /sys visibility.

Because a rootkit can manipulate output from user-space inspection tools, investigators should consider trusted offline acquisition and analysis methods when root-level compromise is suspected.

4. GPU Telemetry Integrity

Do not rely exclusively on nvidia-smi output.

Compare GPU activity against:

  • Application-level GPU workloads.

  • GPU contexts and process information.

  • Power consumption and temperature from independent monitoring sources.

  • The integrity of libnvidia-ml.so.1.

  • Unexpected library replacement or backup files.

  • Changes to NVIDIA library paths and loader configuration.

An apparent 0% GPU utilization reading does not establish that the GPU is idle when the monitoring library itself may have been modified.

5. Tor and Blockchain C2 Detection

Monitor for:

  • Unexpected Tor-related outbound connections.

  • WebTunnel and obfs4 bridge activity.

  • Connections to the identified onion address.

  • Unexpected access to public Ethereum RPC services.

  • Requests involving the identified contract address.

  • Outbound TCP connections to port 8080 associated with suspicious processes.

6. YARA Detection

Elastic published YARA rules for both SANSAR and netns.

SANSAR rule:

Linux_Trojan_Sansar_11eea454

netns rule:

Linux_Trojan_Netns_c94a4b17

These rules can be obtained from the original Elastic report and incorporated into appropriate malware-scanning workflows.

Recommendations

Immediate Actions

  1. Secure Ray deployments: Disable unauthenticated public access to Ray job submission interfaces and restrict access to trusted networks.

  2. Investigate exposed hosts: Review Ray job histories, authentication records and process activity for suspicious submissions.

  3. Inspect SSH persistence: Check authorized_keys files for unauthorized public keys and investigate unfamiliar SSH sessions.

  4. Validate kernel modules: Examine DKMS registrations, loaded kernel modules and initramfs images for unexpected modifications.

  5. Verify NVIDIA library integrity: Compare libnvidia-ml.so.1 against trusted vendor packages and inspect suspicious backup files.

  6. Hunt for cryptominers: Search for unexpected XMRig and SRBMiner-MULTI processes, especially those executing from unusual directories.

  7. Review outbound traffic: Investigate Tor connections, Ethereum RPC requests and suspicious outbound TCP sessions.

  8. Preserve forensic evidence: Capture relevant logs, process information, kernel-module metadata, file hashes and disk images before rebuilding compromised systems.

Preventive Actions

  1. Restrict job submission: Require authentication and authorization for Ray Jobs API access.

  2. Segment GPU infrastructure: Isolate GPU compute nodes from public networks and restrict management-plane connectivity.

  3. Monitor hardware telemetry integrity: Compare NVIDIA telemetry with independent hardware and application-level measurements.

  4. Protect kernel integrity: Use secure boot where appropriate, monitor kernel-module loading and restrict unauthorized module installation.

  5. Monitor persistence mechanisms: Alert on unexpected systemd services, DKMS registrations, initramfs changes and SSH authorized-key modifications.

  6. Control outbound connections: Apply network policies to restrict unnecessary Tor, proxy and blockchain RPC traffic.

  7. Use file-integrity monitoring: Monitor critical NVIDIA libraries, kernel modules, system binaries and boot-related files.

  8. Protect AI infrastructure: Audit who can submit workloads, inspect GPU utilization patterns and investigate unexplained resource consumption.

Potential Impact

1. Unauthorized Compute Resource Consumption

The malware uses compromised CPU and GPU resources for cryptocurrency mining, reducing the capacity available for legitimate workloads.

2. Increased Infrastructure Costs

Unauthorized mining can increase electricity consumption, hardware utilization and cloud-computing expenses.

3. AI and Machine-Learning Workload Disruption

Organizations operating GPU clusters for AI training and inference may experience reduced compute availability and degraded workload performance.

4. Kernel-Level Concealment

The rootkit can hide selected processes, files and socket entries, reducing the effectiveness of ordinary host inspection.

5. Monitoring Evasion

The NVML wrapper can falsify GPU utilization, temperature and power readings, potentially delaying detection of unauthorized mining.

6. Persistent Remote Access

The combination of SSH key persistence, SANSAR's interactive shell functionality and the separate netns backdoor gives the operator multiple methods of maintaining remote access.

7. Additional Network Abuse

SANSAR includes a traffic-generation command that can initiate raw IPv4 TCP SYN tasks. This capability creates the potential for unauthorized network disruption.

Conclusion

The SANSAR intrusion demonstrates how modern Linux cryptomining operations can combine resource hijacking with advanced defense-evasion techniques.

The attacker exploited an exposed Ray job agent to gain initial access, established SSH persistence and deployed a toolkit across three Linux GPU hosts.

The most significant aspect of the operation is the coordinated concealment mechanism. The acpi_thermal_mgr.ko kernel rootkit hides processes, files and network sockets, while the modified NVML library falsifies GPU telemetry to report 0% utilization.

SANSAR manages CPU and GPU miners over Tor, while the separate netns backdoor uses an Ethereum smart contract to discover its controller address.

For organizations operating GPU infrastructure, particularly AI and machine-learning environments, this incident highlights the importance of securing workload-submission interfaces and independently validating hardware monitoring data.

A GPU reporting 0% utilization is not necessarily idle. When the monitoring layer itself is compromised, the underlying hardware and operating-system evidence must be examined independently.

MITRE ATT&CK Mapping

T1190 — Exploit Public-Facing ApplicationT1059.006 — PythonT1059.004 — Unix ShellT1611 — Escape to HostT1136.001 — Local AccountT1098.004 — SSH Authorized KeysT1543.002 — Systemd ServiceT1547.006 — Kernel Modules and ExtensionsT1078.003 — Local AccountsT1021.004 — SSHT1014 — RootkitT1622 — Debugger EvasionT1027 — Obfuscated Files or InformationT1140 — Deobfuscate/Decode Files or InformationT1685.006 — Clear Linux or Mac System LogsT1690 — Prevent Command History LoggingT1082 — System Information DiscoveryT1016 — System Network Configuration DiscoveryT1090.003 — Multi-hop ProxyT1102.001 — Dead Drop ResolverT1095 — Non-Application Layer ProtocolT1105 — Ingress Tool TransferT1496.001 — Compute HijackingT1498.001 — Direct Network Flood