oxfemale-KillChain/KillChain/Logger.h

#pragma once
#include <windows.h>
#include <cstdarg>
#include <cstdio>
#include <string>



enum LogLevel {
    LOG_ERROR = 0,
    LOG_WARNING,
    LOG_INFO,
    LOG_DEBUG
};

class Logger {
private:
    HANDLE hConsole;
    HANDLE hLogFile;
    int minLevel;
    bool useConsole;
    bool useFile;
    CRITICAL_SECTION cs;

    void WriteToConsole(const char* msg, WORD color) {
        if (!useConsole) return;
        SetConsoleTextAttribute(hConsole, color);
        DWORD written;
        WriteConsoleA(hConsole, msg, (DWORD)strlen(msg), &written, NULL);
        SetConsoleTextAttribute(hConsole, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
    }

    void WriteToFile(const char* msg) {
        if (!useFile) return;
        DWORD written;
        WriteFile(hLogFile, msg, (DWORD)strlen(msg), &written, NULL);
    }

public:
    Logger() : hConsole(GetStdHandle(STD_OUTPUT_HANDLE)), hLogFile(INVALID_HANDLE_VALUE),
        minLevel(LOG_INFO), useConsole(true), useFile(false) {
        InitializeCriticalSection(&cs);
    }

    ~Logger() {
        if (hLogFile != INVALID_HANDLE_VALUE) CloseHandle(hLogFile);
        DeleteCriticalSection(&cs);
    }

    void SetLogLevel(int level) {
        if (level < 0) level = 0;
        if (level > 3) level = 3;
        minLevel = level;
    }

    bool SetOutputFile(const char* path) {
        if (hLogFile != INVALID_HANDLE_VALUE) CloseHandle(hLogFile);
        hLogFile = CreateFileA(path, GENERIC_WRITE, FILE_SHARE_READ, NULL,
            CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
        useFile = (hLogFile != INVALID_HANDLE_VALUE);
        return useFile;
    }

    void Log(int level, WORD color, const char* format, ...) {
        if (level > minLevel) return;

        char buffer[4096];
        va_list args;
        va_start(args, format);
        int len = _vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args);
        va_end(args);
        if (len < 0) len = sizeof(buffer) - 1;
        buffer[len] = '\n';
        buffer[len + 1] = '\0';

        EnterCriticalSection(&cs);
        WriteToConsole(buffer, color);
        WriteToFile(buffer);
        LeaveCriticalSection(&cs);
    }

    void Error(const char* format, ...) {
        char buffer[4096];
        va_list args;
        va_start(args, format);
        int len = _vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args);
        va_end(args);
        if (len < 0) len = sizeof(buffer) - 1;
        Log(LOG_ERROR, FOREGROUND_RED | FOREGROUND_INTENSITY, "[!] %s", buffer);
    }

    void Warning(const char* format, ...) {
        char buffer[4096];
        va_list args;
        va_start(args, format);
        int len = _vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args);
        va_end(args);
        if (len < 0) len = sizeof(buffer) - 1;
        Log(LOG_WARNING, FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY, "[*] %s", buffer);
    }

    void Info(const char* format, ...) {
        char buffer[4096];
        va_list args;
        va_start(args, format);
        int len = _vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args);
        va_end(args);
        if (len < 0) len = sizeof(buffer) - 1;
        Log(LOG_INFO, FOREGROUND_GREEN | FOREGROUND_INTENSITY, "[+] %s", buffer);
    }

    void Debug(const char* format, ...) {
        char buffer[4096];
        va_list args;
        va_start(args, format);
        int len = _vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args);
        va_end(args);
        if (len < 0) len = sizeof(buffer) - 1;
        Log(LOG_DEBUG, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY, "[*] %s", buffer);
    }

    void Raw(const char* msg, WORD color) {
        Log(minLevel, color, "%s", msg);
    }
};

extern Logger g_Logger;


void PrintLogo() {
    g_Logger.Raw("KillChain - Kernel Process Termination Tool", FOREGROUND_RED | FOREGROUND_INTENSITY);
    g_Logger.Raw("Coded by Eleven Red Pandas: https://github.com/oxfemale / https://x.com/bytecodevm", FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
    g_Logger.Raw("\n", FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
}