Skip to navigation

Threat reportResearchTL-2026-0798

HAMLOCK: Split Hardware/Software Neural-Network Backdoor Evading ML Trojan Defenses (arXiv:2510.19145, USENIX Security 2026)

highRESEARCH

HAMLOCK (HArdware-Model LOgically Combined attacK) is an academically disclosed backdoor that distributes a neural-network trojan across the hardware/software boundary: software tunes the weights of at most three neurons to spike to anomalously high activation values on a trigger, while a hardware Trojan in the ML accelerator detects that spike (via the sign-bit MSB or 8-bit exponent field) and a second Trojan injects a large bias into the target output logit to force misclassification. First disclosed .

Key facts

IdentifiersTL-2026-0798
Also known asHAMLOCK, HArdware-Model LOgically Combined attacK
SeverityHIGH
First disclosed
Affected productsGeneric / third-party Deep-neural-network hardware accelerators (FPGAs, ASICs) for edge/embedded AI inference; Research evaluation targets DNN architectures LeNet, VGG-16, ResNet-18 on MNIST / CIFAR-10 / GTSRB / ImageNet
Weaknesses (CWE)CWE-1191, CWE-1263, CWE-506, CWE-1357
MalwareHAMLOCK, Split hardware/software neural-network backdoor (cross-layer ML trojan)
ToolsBBCAL, IBD-PSC, MNTD (Meta Neural Trojan Detection), Neural Cleanse, STRIP, TED
MITRE ATT&CK / ATLAS techniquesAML.T0010 AI Supply Chain Compromise, AML.T0015 Evade AI Model, AML.T0018 Manipulate AI Model, AML.T0031 Erode AI Model Integrity, AML.T0048 External Harms, T1129 Shared Modules, T1195 Supply Chain Compromise, T1542 Pre-OS Boot, T1553 Subvert Trust Controls, T1565 Data Manipulation, T1587 Develop Capabilities, T1588 Obtain Capabilities and 1 more in the attack flow
MotivationUNKNOWN
Target sectorstechnology, manufacturing, automotive, defense, critical-infrastructure, iot-edge-ai, semiconductor
Target regionsGlobal
Detection rules9 (1 shown free)
Sources7 cited sources

Detection coverage

As of 2026-06-15, Threadlinqs Intelligence publishes 9 detection rule(s) for TL-2026-0798 across Splunk SPL, Microsoft KQL and Sigma, covering 21 indicator(s) of compromise. The whole corpus is readable without an account. Every threat comes with one complete detection in Splunk SPL, Microsoft KQL and Sigma, free for everyone; a free account adds daily TL Creds to unlock the rest. Paid plans add a larger daily allowance, correlation and the MCP server. Threadlinqs MCP server · View plans.

Free detection: HAMLOCK Payload-HT Logit Injection — Single-Class Spike to ~1.1x z_max (Post-Exploitation)

Detects the HAMLOCK post-exploitation/payload stage: the Payload-HT injecting a large bias into a single target-class output logit, deterministically pushing it to ~1.1x z_max (the max competing logit) and forcing the attacker-chosen misclassification. Flags inferences where exactly one class logit is pushed far above its clean per-class baseline while overall accuracy is unchanged. This is the authoritative 'backdoor active' signal in the research's recommended runtime logit-sanity monitoring.

  • Languages: Splunk SPL, Microsoft KQL, Sigma
  • ATT&CK: T1565.001, T0031, T0048
  • Data sources: ml_inference, ml:model:telemetry, MLInferenceTelemetry_CL
  • Severity: critical
  • Confidence: high

Splunk SPL

index=ml_inference sourcetype="ml:model:telemetry" event=output_logit
| eventstats max(logit) as zmax, max(eval(if(class!=pred_class,logit,null()))) as runner_up by inference_id
| eventstats avg(logit) as base_mean, stdev(logit) as base_sd by model_id, class
| where logit >= 1.1*runner_up AND logit > base_mean + (5*base_sd)
| stats values(class) as injected_class, dc(class) as injected_count, max(logit) as injected_logit, first(runner_up) as runner_up by _time model_id accelerator_id inference_id
| where injected_count = 1
| eval ratio=round(injected_logit/runner_up,2), reason="HAMLOCK Payload-HT logit injection: class ".injected_class." forced to ".injected_logit." (".ratio."x runner-up)"
| table _time model_id accelerator_id inference_id injected_class injected_logit runner_up ratio reason

Microsoft KQL

MLInferenceTelemetry_CL
| where TimeGenerated > ago(24h)
| where Event_s == "output_logit"
| summarize BaseMean=avg(todouble(Logit_d)), BaseStd=stdev(todouble(Logit_d)) by ModelId_s, Class_s
| join kind=inner (
    MLInferenceTelemetry_CL
    | where TimeGenerated > ago(24h) and Event_s == "output_logit"
    | summarize Zmax=max(todouble(Logit_d)), RunnerUp=maxif(todouble(Logit_d), Class_s != PredClass_s) by InferenceId_s, ModelId_s, AcceleratorId_s
  ) on ModelId_s
| extend Logit = todouble(Logit_d)
| where Logit >= 1.1*RunnerUp and Logit > BaseMean + 5*BaseStd
| summarize InjectedClasses=make_set(Class_s), InjectedCount=dcount(Class_s), InjectedLogit=max(Logit), RunnerUp=any(RunnerUp) by ModelId_s, AcceleratorId_s, InferenceId_s
| where InjectedCount == 1
| extend Ratio = round(InjectedLogit/RunnerUp, 2)
| project ModelId_s, AcceleratorId_s, InferenceId_s, InjectedClasses, InjectedLogit, RunnerUp, Ratio

Sigma

title: HAMLOCK Payload-HT Single-Class Output Logit Injection
id: 7a2d0b13-8f4c-5e62-ab3d-0798b2c3d4e2
status: experimental
description: Detects HAMLOCK's payload stage where a single target-class output logit is deterministically pushed to ~1.1x z_max, forcing misclassification while clean accuracy is unchanged. Authoritative runtime backdoor-active signal.
references:
    - https://arxiv.org/abs/2510.19145
    - https://atlas.mitre.org/techniques/AML.T0031
author: Threadlinqs Team
date: 2026/06/15
tags:
    - attack.impact
    - attack.t1565.001
    - atlas.aml_t0031
    - atlas.aml_t0048
logsource:
    product: ml_inference
    category: model_telemetry
detection:
    selection:
        event: 'output_logit'
        flag: 'LOGIT_SPIKE'
    condition: selection
falsepositives:
    - Genuinely high-confidence inferences on unambiguous inputs
    - Class imbalance or temperature-scaling changes shifting per-class logit distributions
level: critical

Known false positives:

  • Genuinely high-confidence inferences on unambiguous inputs
  • Temperature-scaling or recalibration shifting per-class logit baselines
  • Class imbalance producing naturally dominant logits for frequent classes

Tuning notes: Calibrate the 1.1x-runner-up ratio and 5-sigma per-class baseline on clean traffic; the ~1.1x z_max ratio is HAMLOCK-specific so keep it tight to suppress legitimate high-confidence hits. Correlate by inference_id with TL-2026-0798-SPL-001 (activation spike in the same inference) to raise confidence that the logit spike is hardware-injected rather than naturally confident.

8 more detection rules (Splunk SPL, Microsoft KQL, Sigma) · unlock with TL Creds. Sign up free to unlock the detection rules or query them with the Threadlinqs MCP server (Purple)
  • HAMLOCK Trigger Conditioning — Square-Patch Input + Prepared-Neuron Activation (Exploitation) · unlock with TL Creds
  • HAMLOCK Forced Misclassification — Logit Injection vs Clean Behavior Baseline (Post-Exploitation) · unlock with TL Creds
  • HAMLOCK Simulation/Tooling Execution on Edge-AI Host — Telemetry Emulator Artifacts (C2/Lateral) · unlock with TL Creds
  • HAMLOCK Trigger-HT Sign-Bit/Exponent Activation Anomaly (Exploitation, Sigma) · unlock with TL Creds
  • HAMLOCK Payload-HT Logit-Bias Injection Anomaly (Post-Exploitation, Sigma) · unlock with TL Creds
  • HAMLOCK Cross-Layer Backdoor Persistence — HW-Fired Misclassification Across Model Versions (C2/Lateral, Sigma) · unlock with TL Creds
  • HAMLOCK Trigger-HT Activation Spike — Anomalous Neuron Magnitude/Exponent (Exploitation) · unlock with TL Creds
  • HAMLOCK Hardware-Resident Divergence — Redundant-Inference & Cross-Fine-Tune Persistence (C2/Lateral) · unlock with TL Creds

Indicators of compromise

As of 2026-06-15, Threadlinqs Intelligence tracks 21 indicators of compromise for TL-2026-0798.

21 indicators of compromise · unlock with TL Creds. Compare plans

Technical analysis

Because the software model itself never misclassifies, it passes all software-only validation and evades Neural Cleanse, MNTD, STRIP, IBD-PSC, TED and BBCAL, while surviving fine-tuning, fine-pruning and retraining at ~0.1% area overhead.

HAMLOCK is a cross-layer (hardware + software) backdoor against deep neural networks deployed on third-party hardware accelerators (FPGAs/ASICs) for edge AI. It was disclosed by researchers from the University of Tennessee and the University of Florida (Sanskar Amgain, Daniel Lobo, Atri Chatterjee, Swarup Bhunia, Fnu Suya) in arXiv:2510.19145 (submitted 22 Oct 2025, latest revision 16 Mar 2026) and accepted to USENIX Security 2026. As of disclosure there is no CVE, no CVSS, no observed in-the-wild exploitation, and no network infrastructure — this is a published academic proof-of-concept with public code, tracked as a supply-chain risk to ML hardware.

Novelty / threat model: Conventional model-level backdoors embed the entire misclassification logic inside the model weights, leaving a traceable layer-by-layer activation path that defenders can recover (e.g., Neural Cleanse reverse-engineers the trigger; MNTD trains a meta-classifier to spot trojaned models). HAMLOCK breaks this assumption by splitting the attack: the SOFTWARE half is functionally benign and contains NO misclassification logic — it only tunes a few neurons so that, when an attacker's trigger (e.g., a small square pixel patch) is present, those neurons produce uniquely high activation magnitudes. Without the malicious hardware present the attack success rate is near zero (<=0.6%), so the model passes every software-side audit.

Hardware payload: The accelerator hosts two cooperating hardware Trojans (HTs). The Trigger HT continuously watches the chosen neurons' activations and fires when it sees the tell-tale magnitude — implemented cheaply by monitoring just the most significant bit (the sign bit) or the 8-bit exponent field of the floating-point activation, rather than full-precision comparison. When the Trigger HT fires, it signals the Payload HT, which injects a large bias (reported as ~1.1 x z_max, the max logit) into the target class's output logit/exponent field, deterministically forcing the attacker-chosen misclassification.

Variants: A single-neuron variant zeroes weights where a mask is zero on one (often first-layer) neuron and achieves ~100% attack success across all four datasets when the hardware is present. A multi-neuron variant spreads the trigger across several 'safe' neurons in random layers for added stealth, achieving mid-90s success while keeping clean-image accuracy drop negligible.

Evaluation: Tested on four datasets (MNIST, CIFAR-10, GTSRB, ImageNet) and three architectures (LeNet, VGG-16, ResNet-18). With the trojaned hardware present the attack reaches ~100% misclassification on triggered inputs; clean-input accuracy is essentially unchanged. Against defenses HAMLOCK circumvents state-of-the-art model-level detection without any adaptive optimization: Neural Cleanse and MNTD show 0% detection, runtime/sample detectors STRIP, IBD-PSC, TED and BBCAL produce AUCs near 0.5 (random guessing), and fine-tuning / fine-pruning leave 100% ASR intact. Crucially, the identical square trigger planted with an ordinary software-only backdoor is caught by these same tools almost every time — the stealth comes entirely from moving the decision logic into silicon.

Hardware cost: Synthesized hardware overhead is tiny — area capped at ~0.1% (a 'tenth of a percent at most'), with power overhead reported as 3.4% for VGG-16 down to 0.05% for LeNet; on a modern (e.g., 45nm-class) process the added area disappears into normal manufacturing variation, defeating side-channel / area-based HT detection.

Defensive implication: Software-only model vetting is insufficient when the inference accelerator is untrusted. Co-author Swarup Bhunia recommends runtime monitoring for anomalies by tracking internal model behavior; the authors call broadly for new cross-layer defenses spanning the model and the silicon. Practical mitigations center on hardware supply-chain assurance for ML accelerators, runtime activation-distribution monitoring (flag neurons whose activation magnitude / exponent jumps far outside the clean distribution), redundant or trusted inference paths, and logit-distribution sanity checks at the output stage.

MITRE ATT&CK / ATLAS techniques by tactic:

initial-access

AML.T0010 AI Supply Chain Compromise

Defense Evasion (ATLAS)

AML.T0015 Evade AI Model

Persistence (ATLAS)

AML.T0018 Manipulate AI Model

Impact (ATLAS)

AML.T0031 Erode AI Model Integrity; AML.T0048 External Harms

Execution

T1129 Shared Modules

Initial Access

T1195 Supply Chain Compromise

Persistence

T1542 Pre-OS Boot

defense-impairment

T1553 Subvert Trust Controls; T1685 Disable or Modify Tools

Impact

T1565 Data Manipulation

Resource Development

T1587 Develop Capabilities; T1588 Obtain Capabilities

Remediation

Immediate actions

  • Treat ML inference accelerators (FPGAs/ASICs) from third parties as untrusted in the supply chain; do not rely on software-only model validation to certify a deployed model as backdoor-free.
  • Deploy runtime activation-distribution monitoring on deployed DNNs: flag inferences where individual neuron activations exhibit anomalously high magnitude or out-of-range exponent/sign-bit values versus the clean-input baseline.
  • Add output-logit sanity checks: detect inferences where a single class logit is pushed far above the normal distribution (e.g., a sudden ~1.1x z_max spike) inconsistent with the model's clean behavior.

Workarounds

  • Where feasible, run high-assurance inference on trusted/verified silicon only.
  • Constrain or clamp output logits and reject inferences with statistically implausible logit spikes.

Longer-term hardening

  • Adopt cross-layer (hardware + model) defenses rather than model-only trojan scanners such as Neural Cleanse or MNTD, which HAMLOCK fully evades.
  • Require hardware supply-chain assurance for ML accelerators: trusted foundry / split-manufacturing, post-silicon Trojan detection, and gate-level integrity verification of inference datapaths.
  • Use redundant or heterogeneous inference (run the same model on independently sourced hardware and compare outputs) to expose hardware-induced misclassification.
  • Incorporate runtime behavioral attestation of the model executing on the accelerator rather than static weight inspection alone.

Affected and fixed versions

  • Generic / third-party — Deep-neural-network hardware accelerators (FPGAs, ASICs) for edge/embedded AI inference
    Vulnerable versions: Untrusted third-party ML accelerators in the supply chain
  • Research evaluation targets — DNN architectures LeNet, VGG-16, ResNet-18 on MNIST / CIFAR-10 / GTSRB / ImageNet
    Vulnerable versions: LeNet; VGG-16; ResNet-18

Timeline

  • HAMLOCK indexed as a research publication on ResearchGate (publication 396790437), broadening academic visibility of the cross-layer backdoor design.
  • Independent literature review of HAMLOCK published (Moonlight), summarizing the hardware-Trojan trigger/payload design and defense-evasion results.
  • Public proof-of-concept code and full evaluation released alongside the academic paper (single-neuron and multi-neuron variants across LeNet/VGG-16/ResNet-18 on MNIST/CIFAR-10/GTSRB/ImageNet).
  • HAMLOCK paper (arXiv:2510.19145) first submitted to arXiv by Amgain, Lobo, Chatterjee, Bhunia and Suya (University of Tennessee, University of Florida).
  • Latest arXiv revision (v4) of the HAMLOCK paper published, with the final single-neuron and multi-neuron variant evaluation across LeNet/VGG-16/ResNet-18 and the full defense-evasion results (Neural Cleanse, MNTD, STRIP, IBD-PSC, TED, BBCAL).
  • Tracked as TL-2026-0798: academic disclosure (status RESEARCH), no CVE/CVSS, no in-the-wild exploitation or network IOCs reported; severity HIGH on technical impact and supply-chain reach.
  • Co-author Swarup Bhunia (University of Florida) publicly recommends runtime monitoring of internal model behavior to detect HAMLOCK-style anomalies; authors call for new cross-layer (model + silicon) defenses since software-only trojan scanners are insufficient against an untrusted accelerator.
  • Paper accepted to USENIX Security 2026, formalizing the cross-layer DNN backdoor threat model.
  • Help Net Security reports on HAMLOCK, highlighting near-perfect misclassification on triggered images, evasion of Neural Cleanse and MNTD, survival of fine-tuning/pruning, and ~0.1% area overhead.

Sources cited

Drafted by the Threadlinqs research pipeline from 7 sources; published ; last updated —.

Threadlinqs Intelligence — Real-Time Threat Detection Platform

// threat_feed
$ sort --newest
Showing all threats

Live intelligence console

Threat level

Latest Threats