Functions
static bool	run_privhelper_pkexec (const std::string &action)
static std::string	read_text_file (const std::string &path)
static std::string	read_cmdline (const std::string &path)
static std::string	read_exe_path (const std::string &pid_str)
static bool	is_noise_process (const std::string &comm, const std::string &exe, const std::string &cmdline)
static int	read_ppid (const std::string &pid_str)
static bool	parent_is_noise (const std::string &pid_str)

Variables
std::queue< std::string >	alert_queue_
Gtk::Window *	current_alert_ = nullptr

Function Documentation

◆ is_noise_process()

bool is_noise_process	(	const std::string &	comm,
		const std::string &	exe,
		const std::string &	cmdline )

static

Definition at line 100 of file PrivacyPage.cpp.

{
    // Match per nome (comm)
    static const std::set<std::string> kCommDeny = {
        "bash","zsh","fish","sh","dash",
        "konsole","gnome-terminal-","xfce4-terminal","kitty","alacritty","wezterm",
        "tmux","screen",
        "pkexec",
        "polkitd","polkit-agent-helper-1","polkit-kde-authentication-agent-1",
        "gnome-shell","plasmashell","kwin_wayland","kwin_x11",
        "xdg-desktop-portal","xdg-desktop-portal-gtk","xdg-desktop-portal-kde",
        "pipewire","wireplumber","pulseaudio"
    };
 
    if (!comm.empty() && kCommDeny.count(comm)) return true;
 
    // Match per path exe (più stabile di comm)
    auto has = [&](const char* needle) {
        return (!exe.empty() && exe.find(needle) != std::string::npos) ||
               (!cmdline.empty() && cmdline.find(needle) != std::string::npos);
    };
 
    // Polkit / privilege prompts
    if (has("polkit") || has("pkexec")) return true;
 
    // Terminali / shell
    if (has("konsole") || has("gnome-terminal") || has("xfce4-terminal") ||
        has("kitty") || has("alacritty") || has("wezterm") ||
        has("/bin/bash") || has("/usr/bin/bash") || has("/bin/zsh") || has("/usr/bin/zsh") ||
        has("/bin/fish") || has("/usr/bin/fish"))
        return true;
 
    // Portali / media stack (spesso fanno probing o broker)
    if (has("xdg-desktop-portal") || has("pipewire") || has("wireplumber") || has("pulseaudio"))
        return true;
 
    // Desktop env “core”
    if (has("plasmashell") || has("gnome-shell") || has("kwin"))
        return true;
 
    return false;
}

References is_noise_process().

Referenced by PrivacyPage::detect_active_devices(), is_noise_process(), and parent_is_noise().

◆ parent_is_noise()

bool parent_is_noise ( const std::string & pid_str )

static

Definition at line 164 of file PrivacyPage.cpp.

                                                      {
    std::string cur = pid_str;
    for (int i = 0; i < 3; ++i) {           // risali max 3 livelli
        int ppid = read_ppid(cur);
        if (ppid <= 1) break;
        std::string p = std::to_string(ppid);
        std::string comm = read_text_file("/proc/" + p + "/comm");
        std::string exe  = read_exe_path(p);
        std::string cmd  = read_cmdline("/proc/" + p + "/cmdline");
        if (is_noise_process(comm, exe, cmd)) return true;
        cur = p;
    }
    return false;
}

References is_noise_process(), parent_is_noise(), read_cmdline(), read_exe_path(), read_ppid(), and read_text_file().

Referenced by PrivacyPage::detect_active_devices(), and parent_is_noise().

◆ read_cmdline()

std::string read_cmdline ( const std::string & path )

static

Definition at line 85 of file PrivacyPage.cpp.

                                                     {
    std::ifstream f(path, std::ios::binary);
    if (!f.is_open()) return {};
    std::string buf((std::istreambuf_iterator<char>(f)), {});
    for (char& c : buf) if (c == '\0') c = ' ';
    return buf;
}

References read_cmdline().

Referenced by PrivacyPage::detect_active_devices(), parent_is_noise(), and read_cmdline().

◆ read_exe_path()

std::string read_exe_path ( const std::string & pid_str )

static

Definition at line 93 of file PrivacyPage.cpp.

                                                         {
    std::error_code ec;
    auto p = fs::read_symlink("/proc/" + pid_str + "/exe", ec);
    if (ec) return {};
    return p.string();
}

References read_exe_path().

Referenced by PrivacyPage::detect_active_devices(), parent_is_noise(), and read_exe_path().

◆ read_ppid()

int read_ppid ( const std::string & pid_str )

static

Definition at line 145 of file PrivacyPage.cpp.

                                               {
    std::ifstream f("/proc/" + pid_str + "/status");
    if (!f.is_open()) return -1;
 
    std::string line;
    while (std::getline(f, line)) {
        if (line.rfind("PPid:", 0) == 0) {
            try {
                // dopo "PPid:" ci sono tab/spazi -> stoi li gestisce
                return std::stoi(line.substr(5));
            } catch (...) {
                return -1;
            }
        }
    }
    return -1;
}

References read_ppid().

Referenced by parent_is_noise(), and read_ppid().

◆ read_text_file()

std::string read_text_file ( const std::string & path )

static

Definition at line 77 of file PrivacyPage.cpp.

                                                       {
    std::ifstream f(path);
    if (!f.is_open()) return {};
    std::string s;
    std::getline(f, s);
    return s;
}

References read_text_file().

Referenced by PrivacyPage::detect_active_devices(), parent_is_noise(), and read_text_file().

◆ run_privhelper_pkexec()

bool run_privhelper_pkexec ( const std::string & action )

static

Definition at line 47 of file PrivacyPage.cpp.

                                                           {
    if (action != "block" && action != "unblock")
        return false;
 
    const pid_t pid = ::fork();
    if (pid < 0)
        return false;
 
    if (pid == 0) {
        ::execl(
            "/usr/bin/pkexec",
            "pkexec",
            "/usr/bin/bastionguard-privhelper",
            action.c_str(),
            static_cast<char*>(nullptr)
        );
        _exit(127);
    }
 
    int status = 0;
    while (::waitpid(pid, &status, 0) < 0) {
        if (errno == EINTR)
            continue;
        return false;
    }
 
    return WIFEXITED(status) && WEXITSTATUS(status) == 0;
}