Back to Intelligence

FakeGit Campaign: Mitigating SmartLoader Malware Delivery via GitHub Supply Chain Attack

SA
Security Arsenal Team
July 20, 2026
6 min read

Security researchers have uncovered "FakeGit," an active and pervasive supply chain campaign utilizing nearly 7,600 malicious GitHub repositories to distribute the SmartLoader malware family. Of particular concern is the campaign's focus on current development trends: over 800 of these repositories pose as Artificial Intelligence (AI) skills or Model Context Protocol (MCP) servers. By leveraging copied projects, convincing READMEs, and lookalike developer profiles, the attackers effectively trick developers and automated pipelines into downloading and executing malicious ZIP archives.

For security practitioners, this represents a critical failure in the trust model of open-source repositories. SmartLoader serves as a gateway payload, capable of delivering subsequent stages of malware, including stealers and remote access trojans (RANs). Given the scale of 7,600 repos, relying solely on reputation-based blocking is insufficient. Defenders must immediately hunt for indicators of compromise (IOCs) related to unauthorized software execution originating from GitHub-sourced archives.

Technical Analysis

Threat Actor: Unknown (tracked as FakeGit campaign operators) Payload: SmartLoader (Malicious Software Family) Attack Vector: Typosquatting / Repository Impersonation / Malicious Artifact Delivery

Attack Chain Breakdown:

  1. Initial Access: Developers search for legitimate AI, MCP, or utility tools. Threat actors have created repositories with names and profiles mimicking popular or trending projects.
  2. Delivery: The user clones the repository or downloads a source code archive (ZIP file) hosted on GitHub.
  3. Execution: Upon extraction, the user executes a setup script (e.g., python setup.py, npm install, or a PowerShell script) contained within the archive.
  4. Payload Deployment: The script triggers SmartLoader. This loader often employs obfuscation to establish a C2 channel or download secondary payloads.

Observables:

  • Infrastructure: GitHub-hosted repositories (approx. 7,600 identified).
  • Mechanism: Malicious ZIP archives containing loader logic.
  • Indicators: Process execution from paths typically associated with downloaded archives (e.g., AppData\\Local\\Temp or custom extraction directories) rather than stable installed locations.

Exploitation Status: Confirmed Active. The campaign is ongoing as of July 2026, with repositories continuously being spun up to replace takedowns.

Detection & Response

Defending against FakeGit requires shifting from blocking "bad" domains to analyzing "suspicious" behaviors in code execution. Since SmartLoader relies on a user manually executing code from a downloaded archive, detection logic must focus on the intersection of web downloads (GitHub) and subsequent process execution.

SIGMA Rules

The following Sigma rules target the behavioral pattern of downloading archives from GitHub and executing scripts from temporary or extraction directories.

YAML
---
title: Potential SmartLoader Execution via GitHub ZIP
id: 8a2b1c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5d
status: experimental
description: Detects the execution of scripts (Python, Node, PowerShell) from directories that are typically used for extracting downloaded GitHub archives. This is a primary TTP for the FakeGit campaign delivering SmartLoader.
references:
  - https://thehackernews.com/2026/07/fakegit-campaign-uses-7600-github.html
author: Security Arsenal
date: 2026/07/15
tags:
  - attack.execution
  - attack.t1059.001
  - attack.initial_access
  - attack.t1190
logsource:
  category: process_creation
  product: windows
detection:
  selection_img:
    Image|endswith:
      - '\\python.exe'
      - '\
ode.exe'
      - '\\pwsh.exe'
      - '\\powershell.exe'
      - '\\cmd.exe'
  selection_path:
    CommandLine|contains:
      - '\\AppData\\Local\\Temp\'
      - '\\Downloads\'
      - '\\Temp\\Rar$'
  filter_legit:
    ParentImage|contains:
      - '\\Program Files\'
      - '\\ProgramData\'
    CommandLine|contains:
      - 'venv\'
      - 'node_modules\'
  condition: selection_img and selection_path and not filter_legit
falsepositives:
  - Developers actively testing code in their Download folders (high context dependency)
level: high
---
title: Suspicious GitHub Archive Download via CLI
id: 1b3c4d5e-6f7a-8b9c-0d1e-2f3a4b5c6d7e
status: experimental
description: Detects command-line usage of curl, wget, or Invoke-WebRequest to download ZIP archives from GitHub, often followed by execution in the FakeGit campaign.
references:
  - https://thehackernews.com/2026/07/fakegit-campaign-uses-7600-github.html
author: Security Arsenal
date: 2026/07/15
tags:
  - attack.command_and_control
  - attack.t1105
logsource:
  category: process_creation
  product: windows
detection:
  selection_tool:
    Image|endswith:
      - '\\curl.exe'
      - '\\wget.exe'
      - '\\powershell.exe'
  selection_github:
    CommandLine|contains:
      - 'github.com'
      - 'codeload.github.com'
  selection_zip:
    CommandLine|contains:
      - '.zip'
      - '/archive/'
      - 'zipball'
  condition: selection_tool and selection_github and selection_zip
falsepositives:
  - Legitimate developers pulling specific versioned releases
level: medium

KQL (Microsoft Sentinel / Defender)

This KQL query correlates network traffic to GitHub with immediate process execution, identifying potential SmartLoader delivery chains.

KQL — Microsoft Sentinel / Defender
let GitHubDownloads = DeviceNetworkEvents
| where RemoteUrl has \"github.com\" and (RemoteUrl has \".zip\" or RemoteUrl has \"/archive/\");
let ProcessExecution = DeviceProcessEvents
| where Timestamp > ago(1h)
| where ProcessVersionInfoCompanyName != \"Microsoft Corporation\" // Filter out OS noise
| where FolderPath endswith \"\\\python.exe\" 
   or FolderPath endswith \"\\
ode.exe\" 
   or FolderPath endswith \"\\\powershell.exe\";
GitHubDownloads
| join kind=inner (ProcessExecution) on DeviceId, Timestamp
| where ProcessExecution.ProcessCommandLine has_any (\"AppData\\\Local\\\Temp\", \"Downloads\")
| project Timestamp, DeviceName, InitiatingProcessAccountName, RemoteUrl, ProcessCommandLine, FolderPath

Velociraptor VQL

Use this VQL artifact to hunt for processes running from user temp directories, a common staging ground for the SmartLoader extraction process.

VQL — Velociraptor
-- Hunt for SmartLoader execution patterns from temp directories
SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE Exe =~ 'C:\\\Users\\\.*\\\AppData\\\Local\\\Temp\\\.*'
   AND Name in ('python.exe', 'node.exe', 'powershell.exe', 'cmd.exe')
   AND CommandLine !~ 'Program Files'

-- Supplemental: Hunt for recent ZIP files in Downloads
SELECT FullPath, Mtime, Size, Mode
FROM glob(globs='/*/*/Downloads/*.zip')
WHERE Mtime > now() - 24h

Remediation Script (PowerShell)

This script assists in identifying potential SmartLoader artifacts by checking for script execution in temporary folders and inspecting recent GitHub-related downloads.

PowerShell
# PowerShell script to scan for suspicious execution artifacts related to FakeGit

# Check Event Log for Script Execution in Temp Directories (Past 24 Hours)
Write-Host \"[+] Scanning for suspicious script execution in Temp folders...\"
$events = Get-WinEvent -FilterHashtable @{LogName='Security'; Id=4688; StartTime=(Get-Date).AddHours(-24)} -ErrorAction SilentlyContinue

$suspicious = $events | Where-Object { 
    $_.Message -match 'CommandLine' -and 
    $_.Message -match '(python\.exe|node\.exe|powershell\.exe)' -and 
    $_.Message -match '(AppData\\\Local\\\Temp|Downloads)'
}

if ($suspicious) {
    Write-Host \"[!] ALERT: Found suspicious process executions:\" -ForegroundColor Red
    $suspicious | Format-List TimeCreated, Message
} else {
    Write-Host \"[-] No immediate suspicious executions found in Security Log.\"
}

# Check User Downloads for recent ZIPs from GitHub
Write-Host \"[+] Scanning user Downloads for recent GitHub ZIP files...\"
$zipFiles = Get-ChildItem -Path \"$env:USERPROFILE\\Downloads\" -Filter \"*.zip\" -Recurse -ErrorAction SilentlyContinue | 
              Where-Object { $_.LastWriteTime -gt (Get-Date).AddDays(-1) }

if ($zipFiles) {
    Write-Host \"[!] Found recent ZIP files in Downloads:\" -ForegroundColor Yellow
    $zipFiles | Select-Object FullName, LastWriteTime
    Write-Host \"[ACTION] Manually verify these files are legitimate before opening.\"
} else {
    Write-Host \"[-] No recent ZIP files found.\"
}

Remediation

  1. Immediate Verification: Audit all GitHub repositories currently in use within your environment. Verify that the repository URL and the commit signatures match the official vendor sources. Pay special attention to AI/MCP related libraries.
  2. Block Access: If your organization utilizes a secure web gateway (SWG) or proxy, implement blocks against known malicious repository hashes or domains provided by your threat intelligence feed (e.g., checking against lists of the 7,600 identified repos).
  3. Developer Education: Issue an immediate security advisory to engineering teams. Emphasize the risks of "clone-and-run" practices from unverified repositories. Encourage the use of requirements.txt hashing and lockfiles (package-lock.) to prevent unverified package swaps.
  4. Endpoint Isolation: For any endpoints identified as potentially compromised (based on the detection logic above), isolate the machine and perform a full forensic scan to locate SmartLoader persistence mechanisms.
  5. Pipeline Hardening: Ensure CI/CD pipelines do not dynamically fetch code from public GitHub repositories without integrity verification (e.g., SHASUM checks).

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

sigma-rulekql-detectionthreat-huntingdetection-engineeringsiem-detectionfakegitsmartloadersupply-chaingithubmcp

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.