T1674

Input Injection

Execution Last updated:

This detection identifies adversary attempts to simulate keyboard input to execute commands or manipulate applications on behalf of victims. Input injection manifests through HID (Human Interface Device) emulation via malicious USB devices, programmatic keystroke injection via Win32 APIs (SendInput, keybd_event, PostMessage with WM_KEYDOWN/WM_KEYUP), and monitoring of the Windows message loop to inject input into specific applications such as browsers. Key indicators include PowerShell or command interpreters spawning from interactive desktop processes (explorer.exe) with no visible user session context, rapid automated input sequences following USB device attachment, and browser processes receiving injected console commands characteristic of banking trojans like BackSwap that monitor for financial URLs and inject JavaScript via simulated keystrokes.

What is T1674 Input Injection?

Input Injection (T1674) maps to the Execution tactic — the adversary is trying to run malicious code in MITRE ATT&CK.

This page provides production-ready detection logic for Input Injection, covering the data sources and telemetry it touches: Microsoft Defender for Endpoint. The queries below are rated high severity at medium confidence, and ship for 7 SIEM platforms — KQL, SPL, Elastic, QRadar, Sumo, YARA-L, LogScale.

MITRE ATT&CK

Tactic
Execution
Technique
T1674 Input Injection
Canonical reference
https://attack.mitre.org/techniques/T1674/
Microsoft Sentinel / Defender
kusto
let SuspiciousChildProcs = dynamic(["powershell.exe", "cmd.exe", "wscript.exe", "cscript.exe", "mshta.exe", "rundll32.exe", "regsvr32.exe", "certutil.exe"]);
let EncodedFlags = dynamic(["-EncodedCommand", "-enc ", "-e ", "IEX", "Invoke-Expression", "DownloadString", "DownloadFile", "FromBase64String", "-WindowStyle Hidden", "-NoProfile", "-NonInteractive"]);
// Detect shell processes spawned via simulated input from desktop/shell parents with obfuscated command lines
let HIDSpawnedShells = DeviceProcessEvents
| where TimeGenerated > ago(1d)
| where InitiatingProcessFileName in~ ("explorer.exe", "winlogon.exe", "userinit.exe", "sihost.exe", "taskhostw.exe")
| where FileName in~ (SuspiciousChildProcs)
| where ProcessCommandLine has_any (EncodedFlags)
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName, InitiatingProcessId,
    FileName, ProcessId, ProcessCommandLine, InitiatingProcessCommandLine,
    FolderPath, SHA256, ReportId;
// Detect browser developer console or address bar manipulation patterns (BackSwap-style)
let BrowserInjection = DeviceProcessEvents
| where TimeGenerated > ago(1d)
| where InitiatingProcessFileName in~ ("chrome.exe", "firefox.exe", "msedge.exe", "iexplore.exe", "brave.exe")
| where FileName in~ ("powershell.exe", "cmd.exe", "wscript.exe", "cscript.exe")
| project TimeGenerated, DeviceName, AccountName, InitiatingProcessFileName, InitiatingProcessId,
    FileName, ProcessId, ProcessCommandLine, FolderPath, SHA256, ReportId;
// Union both patterns
union HIDSpawnedShells, BrowserInjection
| extend InjectionType = iff(InitiatingProcessFileName in~ ("chrome.exe", "firefox.exe", "msedge.exe", "iexplore.exe", "brave.exe"), "BrowserInputInjection", "HIDKeystrokeInjection")
| order by TimeGenerated desc
| project TimeGenerated, DeviceName, AccountName, InjectionType, InitiatingProcessFileName,
    InitiatingProcessId, FileName, ProcessId, ProcessCommandLine, SHA256, ReportId

Detects two key input injection patterns: (1) HID/USB keystroke injection where desktop shell processes (explorer.exe, winlogon.exe) spawn PowerShell or command interpreters with encoded/obfuscated arguments typical of malicious USB HID devices used by FIN7 and similar threat actors; (2) Browser-based input injection (BackSwap-style) where browsers spawn child processes through simulated keystroke sequences targeting the developer console or address bar. Correlates process creation lineage with command-line obfuscation indicators.

high severity medium confidence

Data Sources

Microsoft Defender for Endpoint

Required Tables

DeviceProcessEvents

False Positives

  • Legitimate IT automation tools (AutoHotkey, AutoIt, SikuliX) used for desktop automation workflows that spawn PowerShell from shell processes
  • Software deployment systems (SCCM, PDQ Deploy, Ansible) that use explorer.exe as a parent during user-context deployments
  • Accessibility software (Dragon NaturallySpeaking, voice control tools) that simulate keystrokes to interact with applications
  • Developer tools and IDEs that programmatically open terminal sessions from browser-integrated development environments
  • Browser automation frameworks (Selenium, Puppeteer in non-headless mode) during legitimate QA testing that trigger child process creation

Sigma rule & cross-platform mapping

The detection logic for Input Injection (T1674) above is provided in a vendor-neutral form so you can deploy it on any SIEM. The same logic is shipped here as native KQL (Microsoft Sentinel / Defender), SPL (Splunk), Elastic (Elastic Security (EQL)), QRadar (IBM QRadar (AQL)), Sumo (Sumo Logic CSE), YARA-L (Google Chronicle / SecOps), LogScale (CrowdStrike LogScale (CQL)) queries. In Sigma terms, this detection targets the following logsource:

logsource:
  category: process_creation
  product: windows

Browse the community-maintained Sigma rules for this technique:


Testing Methodology

Validate this detection against 4 adversary techniques from Atomic Red Team. Each test below lists the behaviour to exercise and the telemetry you should expect to see. Executable commands and cleanup steps are available with Pro.

  1. Test 1PowerShell Keystroke Injection via SendKeys COM Object

    Expected signal: Sysmon Event ID 1: powershell.exe process creation with '-Command' and 'SendKeys' in CommandLine; subsequent notepad.exe process creation from shell parent

  2. Test 2Simulated HID USB Attack - AutoHotkey Keystroke Script

    Expected signal: Sysmon Event ID 1: AutoHotkey.exe spawning, followed by PowerShell process creation triggered by simulated Win+R keystrokes; DeviceProcessEvents showing explorer.exe as grandparent of PowerShell

  3. Test 3Browser Console JavaScript Injection via Clipboard and Simulated Keystrokes (BackSwap Simulation)

    Expected signal: Sysmon Event ID 1 or DeviceProcessEvents: PowerShell process with SendKeys and AppActivate in command line; clipboard write event followed by browser F12 key injection; browser console activity

  4. Test 4USB Rubber Ducky Payload Simulation - Direct Win32 API Keystroke Injection

    Expected signal: Sysmon Event ID 1: PowerShell with Add-Type and SendInput/DllImport in command or script content; DeviceImageLoadEvents for user32.dll loaded into PowerShell process; Security Event 4688 if process auditing enabled


Response Playbook

Triage

  1. Step 1: Identify the parent process and full process tree — determine whether the spawning process (e.g., explorer.exe) had a legitimate user session active at the time; check LogonId from Security Event 4624 for the associated logon session type (interactive vs. network vs. batch)
  2. Step 2: Examine the command-line arguments of the spawned process for encoded payloads, download cradles, or in-memory execution patterns; decode any Base64-encoded arguments using CyberChef or PowerShell's [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('...'))
  3. Step 3: Check USB device connection history — review Windows Event Log 'Microsoft-Windows-DriverFrameworks-UserMode/Operational' (Event ID 2003/2004) or Device Manager for new HID-class USB devices connected within 5 minutes before the alert
  4. Step 4: If browser-related (BackSwap pattern), check browser history, extensions, and recently accessed URLs for financial institution sites; examine clipboard contents if available via endpoint telemetry
  5. Step 5: Correlate the timing with physical presence indicators — was a user logged in and active? Does the process creation timestamp align with business hours and normal user activity patterns?
  6. Step 6: Review network connections initiated by the spawned process using DeviceNetworkEvents or Sysmon Event ID 3 for outbound C2 communications to attacker-controlled infrastructure
  7. Step 7: Check the SHA256 hash of the spawned binary against threat intelligence feeds (VirusTotal, MISP) and verify the binary is from a legitimate signed source

Containment

  1. Isolate the affected endpoint from the network using EDR isolation capabilities or firewall ACL block to prevent C2 communication while preserving forensic state
  2. If a malicious USB device is suspected, immediately confiscate and bag the physical device as evidence; do not reinsert it into any system
  3. Terminate the malicious process chain using endpoint isolation tools; document the full process tree before termination for forensic purposes
  4. Disable or quarantine any suspicious browser extensions identified during triage using MDM/GPO if the BackSwap banking trojan pattern is confirmed
  5. Block the outbound C2 IP/domain at the perimeter firewall and DNS sinkholes based on network indicators extracted from the process command line or network connections
  6. Reset credentials for any accounts that were active on the affected workstation at the time of the incident, prioritizing financial and privileged accounts

Evidence Collection

  1. Collect full memory dump of the affected system using WinPmem or Magnet RAM Capture before any remediation to preserve in-memory artifacts including injected shellcode
  2. Export Windows Event Logs: Security (4624, 4688, 7045), System (20001/20003 for device installation), and Sysmon Operational from the affected host
  3. Collect USB device connection artifacts: SYSTEM\CurrentControlSet\Enum\USB and SYSTEM\CurrentControlSet\Enum\HID registry hives; setupapi.dev.log from C:\Windows\INF\
  4. Capture prefetch files from C:\Windows\Prefetch\ for all processes involved in the alert to establish execution history and timing
  5. If BackSwap pattern confirmed, collect browser profile data including extensions folder, localStorage, and browser history from all installed browsers
  6. Extract the spawned process binary and any dropped files identified in DeviceFileEvents; calculate SHA256 hashes for threat intelligence correlation
  7. Collect clipboard history if endpoint tooling captures it; on Windows 10+, check clipboard history via Settings > System > Clipboard or PowerShell: Get-Clipboard -TextFormatType UnicodeText

Escalation Criteria

  • ! Escalate immediately if a physical USB HID device was identified as the attack vector — this indicates physical access to the environment and may require physical security investigation
  • ! Escalate if the BackSwap banking trojan pattern is confirmed and the affected user has banking, financial, or wire transfer applications — notify the financial crime team and affected financial institutions
  • ! Escalate if network connections from the spawned process reach known C2 infrastructure or if lateral movement indicators (SMB activity, credential use on other hosts) are detected post-injection
  • ! Escalate if the affected endpoint belongs to a privileged user (IT admin, finance, executive) given the elevated blast radius of credential or session compromise
  • ! Escalate if multiple endpoints in the same physical area show similar alerts within a short time window — may indicate a physical attacker moving through a facility with a malicious USB device

Investigation Guide

Forensic Artifacts

  • > USB device registry artifacts: HKLM\SYSTEM\CurrentControlSet\Enum\USB and HKLM\SYSTEM\CurrentControlSet\Enum\HID — contains VID/PID of connected devices
  • > Windows Plug and Play log: C:\Windows\INF\setupapi.dev.log — timestamps of device driver installation events
  • > Prefetch files: C:\Windows\Prefetch\POWERSHELL.EXE-*.pf — execution timestamps for PowerShell and other injected processes
  • > Windows Event Log: Microsoft-Windows-DriverFrameworks-UserMode/Operational — Event IDs 2003 (device started) and 2004 (device stopped)
  • > Amcache.hve: C:\Windows\AppCompat\Programs\Amcache.hve — execution artifacts for binaries run via injected commands
  • > LNK files and Jump Lists: may contain references to files accessed via injected commands
  • > Browser artifacts: extensions folder, localStorage, cache — for BackSwap-style attacks targeting financial applications
  • > Windows Notification Database: %LOCALAPPDATA%\Microsoft\Windows\Notifications\wpndatabase.db — may contain evidence of application interaction timing

Tuning Guidance

Start by baselining which parent processes legitimately spawn PowerShell and cmd.exe in your environment using 30 days of historical data. Create allowlist exceptions for known software deployment tools (SCCM, PDQ, Ansible) by their SHA256 hash and signing certificate. For the HID device correlation rule, allowlist known-good HID devices by their USB Vendor ID (VID) and Product ID (PID) from your hardware inventory — standard keyboards typically have VID:PID combinations like 046D (Logitech), 045E (Microsoft), 04F2 (Chicony). The browser-spawning-shell detection will have low false positive rates in most environments; tune by excluding specific browser extensions or developer tools that legitimately create child processes. Consider raising the ProcessCount threshold in the rapid-burst hunting query based on your environment's baseline automation activity. For environments with heavy RPA tooling (UiPath, Blue Prism, Automation Anywhere), create separate allowlisting rules based on those specific process names and signing certificates.


Hunting Queries

Hunts for rapid bursts of process creation within a 60-second window spawned from desktop/browser parents — automated keystroke injection produces timing patterns not consistent with human typing, often spawning 3+ processes within seconds

Hunting — KQL
kql
// Hunt for processes using SendInput/keybd_event API patterns by identifying
// unusual timing clusters of process creation suggesting automated input injection
DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where FileName in~ ("powershell.exe", "cmd.exe", "wscript.exe")
| where InitiatingProcessFileName in~ ("explorer.exe", "chrome.exe", "firefox.exe", "msedge.exe")
| summarize ProcessCount=count(), CommandLines=make_set(ProcessCommandLine, 10),
    FirstSeen=min(TimeGenerated), LastSeen=max(TimeGenerated)
    by DeviceName, AccountName, InitiatingProcessFileName, FileName, bin(TimeGenerated, 1m)
| where ProcessCount >= 3
| extend TimeDeltaSeconds = datetime_diff('second', LastSeen, FirstSeen)
| where TimeDeltaSeconds <= 30
| order by ProcessCount desc
Hunting — SPL
spl
index=* sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=1
| eval Image=lower(Image), ParentImage=lower(ParentImage)
| where match(Image, "(powershell\.exe|cmd\.exe|wscript\.exe)$")
    AND match(ParentImage, "(explorer\.exe|chrome\.exe|firefox\.exe|msedge\.exe)$")
| bin _time span=1m
| stats count as ProcessCount, values(CommandLine) as CommandLines,
    min(_time) as FirstSeen, max(_time) as LastSeen
    by host, User, ParentImage, Image, _time
| where ProcessCount >= 3
| eval TimeDelta=LastSeen-FirstSeen
| where TimeDelta <= 30
| sort -ProcessCount

Hunts for the FIN7 USB attack pattern by correlating HID keyboard device installation events with suspicious process creation within 5 minutes — the classic USB rubber ducky / Bash Bunny attack chain

Hunting — KQL
kql
// Hunt for USB HID device installation followed by suspicious process activity
// Correlates device driver events with subsequent process creation within 5 minutes
let HIDDeviceInstall = DeviceEvents
| where TimeGenerated > ago(7d)
| where ActionType == "PnpDeviceConnected"
| where AdditionalFields has_any ("HIDClass", "Keyboard", "HID Keyboard Device", "USB Input Device")
| project InstallTime=TimeGenerated, DeviceName, DeviceInfo=AdditionalFields;
let SuspiciousProcs = DeviceProcessEvents
| where TimeGenerated > ago(7d)
| where FileName in~ ("powershell.exe", "cmd.exe", "wscript.exe", "mshta.exe")
| where ProcessCommandLine has_any ("-enc", "-EncodedCommand", "IEX", "DownloadString", "http", "https")
| project ProcTime=TimeGenerated, DeviceName, AccountName, FileName, ProcessCommandLine, SHA256;
HIDDeviceInstall
| join kind=inner SuspiciousProcs on DeviceName
| where ProcTime between (InstallTime .. (InstallTime + 5m))
| project InstallTime, ProcTime, DeviceName, AccountName, DeviceInfo, FileName, ProcessCommandLine, SHA256
| order by InstallTime desc
Hunting — SPL
spl
index=* sourcetype="WinEventLog:Microsoft-Windows-DriverFrameworks-UserMode/Operational"
    (EventCode=2003 OR EventCode=2004)
    ("HIDClass" OR "Keyboard" OR "USB Input Device")
| eval install_time=_time
| rename host as DeviceName
| join type=inner max=10 DeviceName [
    search index=* sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=1
    | eval Image=lower(Image)
    | where match(Image, "(powershell\.exe|cmd\.exe|wscript\.exe|mshta\.exe)$")
    | where match(CommandLine, "(-enc|-encodedcommand|iex|downloadstring|http)")
    | rename host as DeviceName, _time as proc_time
    | table DeviceName, proc_time, User, Image, CommandLine, Hashes
]
| where proc_time >= install_time AND proc_time <= install_time+300
| table install_time, proc_time, DeviceName, User, Image, CommandLine, Hashes
| sort -install_time

Hunts for BackSwap-style clipboard and window manipulation by identifying processes that reference Windows input simulation APIs (SendKeys, SendInput, PostMessage, FindWindow, SetForegroundWindow) in their command lines — characteristic of malware monitoring browser windows to inject clipboard payloads

Hunting — KQL
kql
// Hunt for clipboard-assisted input injection patterns (BackSwap banking trojan)
// Identifies processes accessing clipboard followed by browser window manipulation
DeviceEvents
| where TimeGenerated > ago(7d)
| where ActionType == "GetAsyncKeyState" or ActionType == "ClipboardGet"
| join kind=inner (
    DeviceProcessEvents
    | where FileName in~ ("chrome.exe", "firefox.exe", "msedge.exe", "iexplore.exe")
    | where ProcessCommandLine has_any ("bank", "financial", "transfer", "payment")
    | project DeviceName, BrowserTime=TimeGenerated, InitiatingProcessFileName, ProcessCommandLine
) on DeviceName
| where TimeGenerated between ((BrowserTime - 2m) .. (BrowserTime + 2m))
| summarize ClipboardEvents=count(), FirstSeen=min(TimeGenerated)
    by DeviceName, AccountName, InitiatingProcessFileName
| where ClipboardEvents >= 5
| order by ClipboardEvents desc
Hunting — SPL
spl
index=* sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=1
| eval Image=lower(Image), CommandLine=lower(CommandLine)
| where match(Image, "(powershell\.exe|cmd\.exe|wscript\.exe|autohotkey\.exe|autoit3\.exe)$")
| where match(CommandLine, "(sendkeys|sendinput|postmessage|findwindow|setforegroundwindow|clipboard|getclipboard)")
| stats count as APICallCount, values(CommandLine) as CommandLines, values(Image) as Processes
    by host, User, ParentImage
| where APICallCount >= 3
| sort -APICallCount

Atomic Red Team Tests

Test 1 PowerShell Keystroke Injection via SendKeys COM Object
windows

Simulates input injection by using PowerShell's WScript.Shell SendKeys method to open Run dialog and execute a command, mimicking what a malicious USB HID device or automated injection tool would do.

Command

powershell
powershell.exe -NoProfile -WindowStyle Hidden -Command "$shell = New-Object -ComObject WScript.Shell; Start-Sleep -Milliseconds 500; $shell.SendKeys('^r'); Start-Sleep -Milliseconds 800; $shell.SendKeys('notepad.exe{ENTER}'); Start-Sleep -Milliseconds 1000; Write-Output 'Keystroke injection test completed'"

Cleanup

powershell
Stop-Process -Name notepad -Force -ErrorAction SilentlyContinue

Expected Telemetry

Sysmon Event ID 1: powershell.exe process creation with '-Command' and 'SendKeys' in CommandLine; subsequent notepad.exe process creation from shell parent

Expected Detection

Alert on PowerShell using COM object SendKeys to simulate keyboard input — parent/child process chain with SendKeys in command arguments

Test 2 Simulated HID USB Attack - AutoHotkey Keystroke Script
windows

Uses AutoHotkey to simulate a USB HID device attack by programmatically injecting keystrokes to open PowerShell and download a test payload, replicating FIN7's USB attack technique.

Command

powershell
powershell.exe -Command "$ahkScript = @'
#NoEnv
#SingleInstance Force
SetTitleMatchMode, 2
Sleep, 2000
Send, #r
Sleep, 500
SendRaw, powershell -NoProfile -Command Write-Output 'HID_INJECTION_TEST'
Send, {Enter}
'@; $ahkPath = '$env:TEMP\test_inject.ahk'; $ahkScript | Out-File -FilePath $ahkPath -Encoding ASCII; if (Get-Command AutoHotkey.exe -ErrorAction SilentlyContinue) { Start-Process AutoHotkey.exe -ArgumentList $ahkPath -WindowStyle Hidden }"

Cleanup

powershell
Remove-Item -Path "$env:TEMP\test_inject.ahk" -Force -ErrorAction SilentlyContinue; Stop-Process -Name AutoHotkey -Force -ErrorAction SilentlyContinue

Expected Telemetry

Sysmon Event ID 1: AutoHotkey.exe spawning, followed by PowerShell process creation triggered by simulated Win+R keystrokes; DeviceProcessEvents showing explorer.exe as grandparent of PowerShell

Expected Detection

Alert on AutoHotkey spawning PowerShell via simulated Run dialog keystrokes — rapid succession of process creation events within seconds

Test 3 Browser Console JavaScript Injection via Clipboard and Simulated Keystrokes (BackSwap Simulation)
windows

Simulates the BackSwap banking trojan technique by placing JavaScript in the clipboard and using keyboard shortcuts to open browser developer console and execute it, targeting browsers open to web applications.

Command

powershell
powershell.exe -NoProfile -Command "$jsPayload = 'console.log(\"BACKSWAP_INJECTION_TEST: \" + document.location.href)'; Set-Clipboard -Value $jsPayload; $shell = New-Object -ComObject WScript.Shell; $chromePID = (Get-Process chrome -ErrorAction SilentlyContinue | Select-Object -First 1).Id; if ($chromePID) { $shell.AppActivate('Chrome'); Start-Sleep -Milliseconds 500; $shell.SendKeys('{F12}'); Start-Sleep -Milliseconds 800; $shell.SendKeys('^v'); Start-Sleep -Milliseconds 300; $shell.SendKeys('{ENTER}'); Write-Output 'BackSwap simulation: clipboard payload injected into browser console' } else { Write-Output 'Chrome not running - test requires open Chrome browser' }"

Cleanup

powershell
Set-Clipboard -Value '' -ErrorAction SilentlyContinue

Expected Telemetry

Sysmon Event ID 1 or DeviceProcessEvents: PowerShell process with SendKeys and AppActivate in command line; clipboard write event followed by browser F12 key injection; browser console activity

Expected Detection

Alert on PowerShell using COM WScript.Shell to AppActivate browser process and SendKeys F12/clipboard paste — characteristic of banking trojan developer console injection

Test 4 USB Rubber Ducky Payload Simulation - Direct Win32 API Keystroke Injection
windows

Simulates the keystrokes a USB Rubber Ducky would inject by using C# inline compilation to call the Win32 SendInput API directly, bypassing higher-level abstractions and more closely replicating hardware-level HID attacks.

Command

powershell
powershell.exe -NoProfile -Command "Add-Type -TypeDefinition @'
using System;
using System.Runtime.InteropServices;
public class InputInjector {
    [DllImport(\"user32.dll\")]
    public static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);
    [StructLayout(LayoutKind.Sequential)] public struct INPUT { public uint type; public INPUTUNION u; }
    [StructLayout(LayoutKind.Explicit)] public struct INPUTUNION { [FieldOffset(0)] public KEYBDINPUT ki; }
    [StructLayout(LayoutKind.Sequential)] public struct KEYBDINPUT { public ushort wVk; public ushort wScan; public uint dwFlags; public uint time; public IntPtr dwExtraInfo; }
    public static void InjectKey(ushort vk) {
        INPUT[] inputs = new INPUT[2];
        inputs[0].type = 1; inputs[0].u.ki.wVk = vk;
        inputs[1].type = 1; inputs[1].u.ki.wVk = vk; inputs[1].u.ki.dwFlags = 2;
        SendInput(2, inputs, Marshal.SizeOf(typeof(INPUT)));
    }
}
'@; Write-Output 'INPUT_INJECTION_TEST: Win32 SendInput API loaded successfully - VK injection capability verified'"

Cleanup

powershell
# No persistent artifacts created by this test

Expected Telemetry

Sysmon Event ID 1: PowerShell with Add-Type and SendInput/DllImport in command or script content; DeviceImageLoadEvents for user32.dll loaded into PowerShell process; Security Event 4688 if process auditing enabled

Expected Detection

Alert on PowerShell loading user32.dll with SendInput P/Invoke signature — indicative of Win32 keystroke injection capability being established in scripting runtime

Related Detections

Tactic Hub