Main.cpp

#include <iostream>
#include <exception>
#include <vector>
#include <sstream>
#include <filesystem>
#include <csignal>

#include <OsintgramCXX/App/AppProps.hpp>
#include <OsintgramCXX/App/WineDetect.hpp>

#include <dev_tools/commons/HelpPage.hpp>
#include <dev_tools/commons/Terminal.hpp>
#include <dev_tools/commons/Utils.hpp>
#include <dev_tools/logging/Logger.hpp>

#include <AppShell/Shell.hpp>

#include <IGApi/Session.hpp>

#include "ModInit.hpp"
#include "android/AndroidCA.hpp"
#include "settings/AppSettings.hpp"
#include "shell/ShellCallback.hpp"

#ifdef _WIN32

#include <windows.h>

#elif defined(__linux__)

#include <unistd.h>
#include <cerrno>
#include <cstring>
#include <sys/mount.h>

#endif

#if defined(__linux__) && !defined(__ANDROID__)

#include <sys/capability.h>
#include <typeinfo>

#endif

#if defined(__ANDROID__)
#include "android/TermuxCheck.hpp"
#endif

namespace fs = std::filesystem;
using namespace OsintgramCXX;
using namespace DevTools;
using namespace Application;

std::string chrootPath;

std::map<std::string, std::string> defMap;
bool main_shouldReconfigure = false;

void WinSetColorMode() {
#ifdef _WIN32
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hOut == INVALID_HANDLE_VALUE) return;

    DWORD dwMode = 0;
    if (!GetConsoleMode(hOut, &dwMode)) return;

    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
    SetConsoleMode(hOut, dwMode);
#endif
}

void exceptionHandler() {
    if (std::exception_ptr exPtr = std::current_exception()) {
        try {
            std::rethrow_exception(exPtr);
        } catch (const std::exception& ex) {
            std::ostringstream sw;
            sw << ex.what();

            Terminal::println(std::cerr, Terminal::TermColor::RED,
                              "The application has unexpectedly crashed. Cause of this error:", false);
            Terminal::println(std::cerr, Terminal::TermColor::RED, sw.str(), true);
        }
    } else
        Terminal::println(std::cerr, Terminal::TermColor::RED, "Unknown Termination captured", true);

    std::raise(SIGSEGV);
}

void usage() {
    std::string cmd = ".";
    if (fs::path execFile = ExecutableFile(); !execFile.empty()) {
        std::string fileName = execFile.filename().string();
        cmd = fileName == "java" ? "osintgram4j.jar" : fileName;
    }

    std::cout << "usage:" << std::endl;
    std::cout << (IsAdmin() ? '#' : '$') << " " << cmd << " [options] (target) (target2 ...)" << std::endl << std::endl;

    HelpPage hPage;
    hPage.setSpaceWidth(3);
    hPage.setStartSpaceWidth(4);
    hPage.setDescSeparator("=");
    hPage.addArg("-h  | --help", std::nullopt, "Display usage and its help page");
    hPage.addArg("-D[key", "value]", "Puts setting overrides of OsintgramCXX at startup");
    hPage.addArg("-E[key", "value]", "Applies an environment variable to app shell");
    hPage.addArg("--test-exec-time", std::nullopt, "Tests the execution time (does not start up the Shell");

#ifdef __ANDROID__
    hPage.addArg("--reconfigure-info", std::nullopt,
                 "Reconfigures the Android Device Information and Network Certificate Setup");
#endif

#ifdef __linux__
    hPage.addArg("--sandbox", "PATH",
                 "Isolates the data saved by this tool from the entire disk, increasing security factors");
#endif

    std::string str = hPage.display();
    str = str.substr(0, str.length() - 1);

    std::cout << str << std::endl << std::endl;
    std::cout << "where:" << std::endl;
    std::cout << "   > [options]         Application Options" << std::endl;
    std::cout << "   > (target1)         Primary target; optional" << std::endl;
    std::cout << "   > (target2 ...)     Multiple optional targets" << std::endl;
}

#ifdef __linux__

void sigHandle(int) {
    if (AppShell& shell = GetShellInstance(); shell.IsRunning())
        shell.Stop(true);
}

#endif

void init() {
    // don't use loggers now, just initialize them (for now)
    Instances::getApplicationLoggingInstance();
    Instances::getNetworkLoggingInstance();
    Instances::getSecureLoggerInstance();

#ifdef _WIN32
    if (Wine::WineExecution()) {
        // by default, colors are already messed up, we don't need to attempt anything
        Runtime::colorSupportEnabled = false;
    } else {
        if (HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); hOut != INVALID_HANDLE_VALUE) {
            DWORD dwMode = 0;
            if (GetConsoleMode(hOut, &dwMode)) {
                dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
                if (!SetConsoleMode(hOut, dwMode))
                    Runtime::colorSupportEnabled = false;
            } else
                Runtime::colorSupportEnabled = false;
        } else
            Runtime::colorSupportEnabled = false;
    }
#endif

#ifdef __linux__
    signal(SIGINT, sigHandle);
    signal(SIGTERM, sigHandle);
    signal(SIGABRT, sigHandle);
    signal(SIGSEGV, sigHandle);

    // presumably we ain't in a Terminal (presumable file piping)
    if (!isatty(STDOUT_FILENO))
        Runtime::colorSupportEnabled = false;
#endif

#ifdef __ANDROID__
    if (!IsTermuxRunning()) {
        std::cerr << "The Android build of OsintgramCXX requires Termux." << std::endl;
        std::cerr << "On your mobile device, install Termux directly from GitHub or from F-Droid." << std::endl;
        std::cerr << "Alternatively, you can install Termux from the Google Play Store, ";
        std::cerr << "which might have flagged this as false positive due to earlier versions." << std::endl;
        exit(1);
    }

    // TODO: rework CA certificate factory for OsintgramCXX
    AndroidVer::prepare_cacerts();
#endif
}

void initSettings() {
}

void parseArgs(const std::vector<std::string>& args) {
    AppShell& shell = GetShellInstance();

    for (const std::string& arg : args) {
        std::string _arg = TrimString(arg);

        if (_arg.empty())
            continue;

        if (_arg[0] == '-') {
            if (_arg == "-h" || _arg == "--help") {
                usage();
                exit(0);
            }

            if (_arg.rfind("-E", 0) == 0) {
                std::string keyValue = arg.substr(2);
                size_t eqPos = keyValue.find('=');

                if (eqPos == std::string::npos) {
                    std::cerr << "Invalid format for -E argument (skipping): " << arg << std::endl;
                    continue;
                }

                shell.SetEnv(keyValue.substr(0, eqPos), keyValue.substr(eqPos + 1));
            }

            if (_arg.rfind("-D", 0) == 0) {
                std::string keyValue = arg.substr(2);
                size_t eqPos = keyValue.find('=');

                if (eqPos == std::string::npos) {
                    std::cerr << "Invalid format for -D argument (skipping): " << arg << std::endl;
                    continue;
                }

                Runtime::defMap[keyValue.substr(0, eqPos)] = keyValue.substr(eqPos + 1);
            }

            if (_arg == "--reconfigure-info")
                main_shouldReconfigure = true;

#ifdef __linux__
            if (_arg.rfind("--sandbox", 0) == 0) {
                size_t eqPos = arg.find('=');
                if (eqPos == std::string::npos) {
                    std::cerr << "Invalid format for --sandbox argument: " << arg << std::endl;
                    continue;
                }

                chrootPath = arg.substr(eqPos + 1);
            }
#endif
        }
    }
}

void OsintgramCXX_init() {
    std::set_terminate(exceptionHandler);
    init();

    // required: coloring system in "src/AppCommons/Terminal.cpp" under Windows systems
    // damn, this comment above me is so old, it still resolves back, before I changed up the structure to be more modular...
    WinSetColorMode();
    initSettings();
}

int main(int argc, char** argv) {
    OsintgramCXX_init();
    if (argc > 1) {
        std::vector<std::string> args;
        args.reserve(argc - 1);

        for (int i = 1; i < argc; i++)
            args.emplace_back(argv[i]);

        parseArgs(args);
    }

    std::cout << TEXT_BLOCK() << std::endl << std::endl;

    // yes, I'm an asshole, but mainly because of certain warning messages going into the line of the Shell,
    // making things ugly in the process
    threadSleep(10);

    ModLoader_load();
    AppShell& shell = GetShellInstance();
    OSINT_IncludeShellCallback(shell);

    // optional, by the CLI args, enable FS sandboxing under self-app build
#if __linux__
    if (!chrootPath.empty()) {
        if (!fs::exists(chrootPath)) {
            try {
                fs::create_directories(chrootPath);
            } catch (const fs::filesystem_error& err) {
                std::cerr << "Failed to create a directory at " << chrootPath << std::endl;
                std::cerr << "Error caused: " << err.what() << std::endl;
                return 1;
            }
        }

        if (fs::exists(chrootPath) && !fs::is_directory(chrootPath)) {
            std::cerr << "Unable to setup a secure environment (" << chrootPath << " is not a directory)" << std::endl;
            return 1;
        }

        bool shouldChroot = getuid() == 0;
#ifndef __ANDROID__
    if (!shouldChroot) {
        cap_t caps = cap_get_proc();
        if (!caps) {
            std::cerr << "Unable to fetch executable capabilities" << std::endl;
            return 1;
        }

        cap_flag_value_t cap_value;
        if (cap_get_flag(caps, CAP_SYS_CHROOT, CAP_EFFECTIVE, &cap_value) == -1) {
            std::cerr << "Failed to fetch chroot capabilities for the executable" << std::endl;
            cap_free(caps);
            return 1;
        }

        shouldChroot = cap_value == CAP_SET;
        cap_free(caps);
    }
#endif

    if (shouldChroot) {
        if (chroot(chrootPath.c_str()) != 0) {
            std::cerr << "Sandboxing failed, error: " << std::strerror(errno) << std::endl;
            return 1;
        }

        if (chdir("/") != 0) {
            std::cerr << "Root Change failed, error: " << std::strerror(errno) << std::endl;
            return 1;
        }
    } else {
        std::cerr << "Sandboxing failed: not root";

#ifdef __ANDROID__
    std::cerr << ", which requires the process to enable Sandboxing capability" << std::endl;
#else
    std::cerr << ", nor given the binary's capability to do so" << std::endl;
#endif

    return 1;
        }
    }
#endif

    ModLoader_start();
    shell.Start();

    threadSleep(10);
    shell.Stop();

    return 0;
}