simple_test.cpp

#include <iostream>
#include "pangu_shell/process_injection/process_injector.h"
#include "pangu_shell/memory_management/memory_manager.h"
#include "pangu_shell/network/network_manager.h"

int main() {
    std::cout << "=== Pangu Shell Core Library Simple Test ===\n\n";
    
    // 测试结果统计
    int tests_passed = 0;
    int tests_failed = 0;

    // 1. 测试内存管理功能
    std::cout << "1. Testing Memory Management...\n";
    pangu_shell::memory_management::MemoryManager memory_manager;
    pangu_shell::memory_management::MemoryProtectionConfig config;
    config.enable_encryption = true;
    config.encryption_algorithm = pangu_shell::memory_management::EncryptionAlgorithm::kAes256Cbc;
    config.enable_anti_dump = true;
    config.enable_anti_debug = false;
    config.self_destruct_timeout = 0;

    if (memory_manager.Initialize(config)) {
        std::cout << "   ✅ Memory Manager initialized successfully\n";
        tests_passed++;

        // 分配受保护的内存
        size_t mem_size = 1024;
        void* mem_ptr = memory_manager.AllocateProtectedMemory(
            mem_size, 
            pangu_shell::syscall::MemoryProtection::kReadWrite, 
            true, 
            pangu_shell::memory_management::EncryptionAlgorithm::kAes256Cbc
        );

        if (mem_ptr) {
            std::cout << "   ✅ Allocated protected memory at address: " << mem_ptr << "\n";
            tests_passed++;

            // 写入数据
            std::string test_data = "Hello, Pangu Shell!";
            std::memcpy(mem_ptr, test_data.c_str(), test_data.size() + 1);
            std::cout << "   ✅ Written test data: " << static_cast<const char*>(mem_ptr) << "\n";
            tests_passed++;

            // 测试内存加密
            auto encrypt_result = memory_manager.EncryptMemory(mem_ptr, mem_size);
            if (encrypt_result == pangu_shell::memory_management::EncryptionResult::kSuccess) {
                std::cout << "   ✅ Encrypted memory successfully\n";
                tests_passed++;

                // 测试内存解密
                auto decrypt_result = memory_manager.DecryptMemory(mem_ptr, mem_size);
                if (decrypt_result == pangu_shell::memory_management::EncryptionResult::kSuccess) {
                    std::cout << "   ✅ Decrypted memory successfully\n";
                    tests_passed++;

                    // 验证数据完整性
                    if (std::string(static_cast<const char*>(mem_ptr)) == test_data) {
                        std::cout << "   ✅ Data integrity verified after encryption/decryption\n";
                        tests_passed++;
                    } else {
                        std::cout << "   ❌ Data integrity failed after encryption/decryption\n";
                        tests_failed++;
                    }
                } else {
                    std::cout << "   ❌ Failed to decrypt memory\n";
                    tests_failed++;
                }
            } else {
                std::cout << "   ❌ Failed to encrypt memory\n";
                tests_failed++;
            }

            // 测试内存隐藏
            if (memory_manager.HideMemoryRegion(mem_ptr, mem_size)) {
                std::cout << "   ✅ Hidden memory region\n";
                tests_passed++;

                // 测试内存显示
                if (memory_manager.ShowMemoryRegion(mem_ptr, mem_size)) {
                    std::cout << "   ✅ Showed memory region\n";
                    tests_passed++;
                } else {
                    std::cout << "   ❌ Failed to show memory region\n";
                    tests_failed++;
                }
            } else {
                std::cout << "   ❌ Failed to hide memory region\n";
                tests_failed++;
            }

            // 释放内存
            if (memory_manager.FreeProtectedMemory(mem_ptr)) {
                std::cout << "   ✅ Freed protected memory\n";
                tests_passed++;
            } else {
                std::cout << "   ❌ Failed to free protected memory\n";
                tests_failed++;
            }
        } else {
            std::cout << "   ❌ Failed to allocate protected memory\n";
            tests_failed++;
        }

        memory_manager.Shutdown();
        std::cout << "   ✅ Memory Manager shutdown successfully\n";
        tests_passed++;
    } else {
        std::cout << "   ❌ Failed to initialize Memory Manager\n";
        tests_failed++;
    }

    // 2. 测试进程注入功能
    std::cout << "\n2. Testing Process Injector...\n";
    pangu_shell::process_injection::ProcessInjector injector;
    if (injector.Initialize()) {
        std::cout << "   ✅ Process Injector initialized successfully\n";
        tests_passed++;

        // 测试获取技术名称
        std::string technique_name = injector.GetTechniqueName(pangu_shell::process_injection::InjectionTechnique::kRemoteThread);
        if (!technique_name.empty()) {
            std::cout << "   ✅ Got technique name: " << technique_name << "\n";
            tests_passed++;
        } else {
            std::cout << "   ❌ Failed to get technique name\n";
            tests_failed++;
        }

        // 测试获取结果描述
        std::string result_desc = injector.GetResultDescription(pangu_shell::process_injection::InjectionResult::kSuccess);
        if (!result_desc.empty()) {
            std::cout << "   ✅ Got result description: " << result_desc << "\n";
            tests_passed++;
        } else {
            std::cout << "   ❌ Failed to get result description\n";
            tests_failed++;
        }
    } else {
        std::cout << "   ❌ Failed to initialize Process Injector\n";
        tests_failed++;
    }

    // 3. 测试网络管理器功能
    std::cout << "\n3. Testing Network Manager...\n";
    pangu_shell::network::NetworkManager network_manager;
    std::cout << "   ✅ Network Manager created successfully\n";
    tests_passed++;

    // 测试隧道配置
    pangu_shell::network::TunnelConfig tunnel_config;
    tunnel_config.type = pangu_shell::network::TunnelType::kHttp;
    tunnel_config.server = "localhost";
    tunnel_config.port = 8080;
    tunnel_config.username = "test";
    tunnel_config.password = "test";
    tunnel_config.use_encryption = true;
    std::cout << "   ✅ Configured HTTP tunnel\n";
    tests_passed++;

    // 测试DNS隧道配置
    pangu_shell::network::DnsTunnelConfig dns_config;
    dns_config.domain = "test.example.com";
    dns_config.resolver = "8.8.8.8";
    dns_config.resolver_port = 53;
    dns_config.ttl = 30;
    dns_config.use_tcp = false;
    std::cout << "   ✅ Configured DNS tunnel\n";
    tests_passed++;

    // 4. 测试系统调用管理器
    std::cout << "\n4. Testing Syscall Manager...\n";
    pangu_shell::syscall::SyscallManager syscall_manager;
    if (syscall_manager.Initialize()) {
        std::cout << "   ✅ Syscall Manager initialized successfully\n";
        syscall_manager.Shutdown();
        std::cout << "   ✅ Syscall Manager shutdown successfully\n";
        tests_passed += 2;
    } else {
        std::cout << "   ❌ Failed to initialize Syscall Manager\n";
        tests_failed++;
    }

    // 输出测试结果
    std::cout << "\n=== Test Results ===\n";
    std::cout << "Tests Passed: " << tests_passed << "\n";
    std::cout << "Tests Failed: " << tests_failed << "\n";
    std::cout << "Total Tests: " << tests_passed + tests_failed << "\n";
    
    if (tests_failed == 0) {
        std::cout << "\n🎉 All tests passed! The Pangu Shell Core Library is working correctly.\n";
    } else {
        std::cout << "\n❌ Some tests failed. Please check the output above for details.\n";
    }
    
    return tests_failed;
}