strawberry/app/main_window_policy.cpp
trvon 11d3614348
profiling: pinned Tracy client, headless capture script, scan bench, tray + scan-stage zones
- third_party/tracy.wrap pins the Tracy client to v0.15.0 (sha256-checked), matching
  the Arch tracy 0.15.0 capture/export tools (client and tools must match exactly);
  built with tracy_enable + on_demand, so nothing is recorded or paid for unless a
  capture is connected. -Denable_profiling=true picks it up; default builds are
  unchanged (macros are no-ops).
- scripts/profile_capture.sh: headless (no GUI, no root) `run OUT -- CMD` or
  `attach OUT SECONDS` -> OUT.tracy + OUT.zones.csv + a top-zones table.
- strawberry-scan-bench (dev tool, not installed): the real scan_on_demand path over
  files with the real governor and rule set, so the scan path can be profiled
  without root or the daemon.
- Zones: scan_on_demand, image.read, image.sha256 (next to yara_scan/scan_image/
  assess_exec), tray.* (poll, on_reply, refresh_evidence, update_status/_policy,
  refresh_findings, notify) and evidence/database reloads.

Baseline (6 yams ASan binaries, 668 MiB, idle host): YARA 86%, read 9%, sha256 5%,
~61 MiB/s; PT_LOAD segments are 35-48% of those files. DEVELOPER.md: profiling
section, and the balanced row corrected (64 MiB image cap, 768 MiB budget).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-14 18:29:57 -07:00

691 lines
35 KiB
C++

// Rules (feeds) and Allowlist tabs of the main window.
#include "main_window.hpp"
#include "strawberry/profiling.hpp"
#include <QCheckBox>
#include <QComboBox>
#include <QDateTime>
#include <QDialog>
#include <QDialogButtonBox>
#include <QFormLayout>
#include <QHBoxLayout>
#include <QHeaderView>
#include <QJsonArray>
#include <QLabel>
#include <QLineEdit>
#include <QListWidget>
#include <QMessageBox>
#include <QPushButton>
#include <QRegularExpression>
#include <QTableWidget>
#include <QVBoxLayout>
#include <pwd.h>
#include <map>
namespace strawberry::app {
namespace {
QString when(qint64 ns) {
if (ns <= 0) {
return QStringLiteral("—");
}
return QDateTime::fromMSecsSinceEpoch(ns / 1'000'000).toString(QStringLiteral("yyyy-MM-dd HH:mm"));
}
QString user_name(qint64 uid) {
if (const passwd* pw = ::getpwuid(static_cast<uid_t>(uid)); pw != nullptr && pw->pw_name != nullptr) {
return QString::fromLocal8Bit(pw->pw_name);
}
return QStringLiteral("uid %1").arg(uid);
}
QTableWidget* make_table(QWidget* parent, const QStringList& headers, int stretch_column) {
auto* table = new QTableWidget(0, static_cast<int>(headers.size()), parent);
table->setHorizontalHeaderLabels(headers);
table->setSelectionBehavior(QAbstractItemView::SelectRows);
table->setSelectionMode(QAbstractItemView::SingleSelection);
table->setEditTriggers(QAbstractItemView::NoEditTriggers);
table->verticalHeader()->setVisible(false);
for (int i = 0; i < headers.size(); ++i) {
table->horizontalHeader()->setSectionResizeMode(
i, i == stretch_column ? QHeaderView::Stretch : QHeaderView::ResizeToContents);
}
return table;
}
QString selected_id(QTableWidget* table) {
const auto rows = table->selectionModel()->selectedRows();
return rows.isEmpty() ? QString() : table->item(rows.first().row(), 0)->data(Qt::UserRole).toString();
}
QString colored(bool ok, const QString& text) {
return QStringLiteral("<span style=\"color:%1\">%2</span>")
.arg(ok ? QStringLiteral("#2ea043") : QStringLiteral("#d72638"), text.toHtmlEscaped());
}
} // namespace
QWidget* MainWindow::build_rules_tab() {
auto* page = new QWidget(this);
auto* layout = new QVBoxLayout(page);
rules_summary_ = new QLabel(page);
rules_summary_->setWordWrap(true);
rules_summary_->setTextFormat(Qt::RichText);
layout->addWidget(rules_summary_);
feeds_table_ = make_table(page, {QStringLiteral("Feed"), QStringLiteral("Kind"), QStringLiteral("Status"),
QStringLiteral("Entries"), QStringLiteral("Version"), QStringLiteral("Updated"),
QStringLiteral("Enabled"), QStringLiteral("Source")},
2);
layout->addWidget(feeds_table_, 1);
auto* bar = new QHBoxLayout();
auto* add = new QPushButton(QStringLiteral("Add feed…"), page);
auto* remove = new QPushButton(QStringLiteral("Remove"), page);
auto* toggle = new QPushButton(QStringLiteral("Enable / Disable"), page);
auto* update = new QPushButton(QStringLiteral("Update now"), page);
auto* reload = new QPushButton(QStringLiteral("Reload rules"), page);
for (auto* button : {add, remove, toggle, update, reload}) {
bar->addWidget(button);
}
bar->addStretch();
layout->addLayout(bar);
rules_result_ = new QLabel(page);
rules_result_->setWordWrap(true);
layout->addWidget(rules_result_);
auto* hint = new QLabel(QStringLiteral(
"Feeds are downloaded by the sandboxed <code>strawberry-update</code> service (daily, and on \"Update now\"). "
"Each release is checked against its published SHA-256 and compiled before it is activated; a broken update "
"never replaces working rules. Local rules live in <code>/etc/strawberry/rules</code>."), page);
hint->setWordWrap(true);
hint->setStyleSheet(QStringLiteral("color: #888"));
layout->addWidget(hint);
connect(add, &QPushButton::clicked, this, &MainWindow::add_feed_dialog);
connect(remove, &QPushButton::clicked, this, [this]() {
const auto id = selected_id(feeds_table_);
if (id.isEmpty()) {
return;
}
if (QMessageBox::question(this, QStringLiteral("Remove feed"),
QStringLiteral("Remove rule feed \"%1\"? Its rules stop being used immediately.").arg(id))
== QMessageBox::Yes) {
emit policy_change_requested(QStringLiteral("feed-remove"), QJsonObject{{QStringLiteral("id"), id}});
}
});
connect(toggle, &QPushButton::clicked, this, [this]() {
const auto id = selected_id(feeds_table_);
if (id.isEmpty()) {
return;
}
for (const auto& value : policy_.value(QStringLiteral("policy")).toObject().value(QStringLiteral("feeds")).toArray()) {
const auto feed = value.toObject();
if (feed.value(QStringLiteral("id")).toString() == id) {
emit policy_change_requested(QStringLiteral("feed-set-enabled"),
QJsonObject{{QStringLiteral("id"), id}, {QStringLiteral("enabled"), !feed.value(QStringLiteral("enabled")).toBool()}});
}
}
});
connect(update, &QPushButton::clicked, this, [this]() {
rules_result_->setText(QStringLiteral("Requesting rule update…"));
emit command_requested(QStringLiteral("update-rules"));
});
connect(reload, &QPushButton::clicked, this, [this]() {
rules_result_->setText(QStringLiteral("Reloading rules…"));
emit command_requested(QStringLiteral("reload-rules"));
});
return page;
}
QWidget* MainWindow::build_allowlist_tab() {
auto* page = new QWidget(this);
auto* layout = new QVBoxLayout(page);
auto* intro = new QLabel(QStringLiteral(
"Allowlisted matches are not stored as detections. Prefer <b>hash</b> entries (one exact binary) over "
"<b>path</b> or <b>rule</b> entries. Existing findings stay as history."), page);
intro->setWordWrap(true);
layout->addWidget(intro);
allow_table_ = make_table(page, {QStringLiteral("Kind"), QStringLiteral("Value"), QStringLiteral("Rule"),
QStringLiteral("Note"), QStringLiteral("Added by"), QStringLiteral("Added")},
1);
allow_table_->setTextElideMode(Qt::ElideMiddle);
allow_table_->horizontalHeader()->setMinimumSectionSize(60);
layout->addWidget(allow_table_, 2);
auto* bar = new QHBoxLayout();
auto* add = new QPushButton(QStringLiteral("Add…"), page);
auto* remove = new QPushButton(QStringLiteral("Remove"), page);
bar->addWidget(add);
bar->addWidget(remove);
bar->addStretch();
layout->addLayout(bar);
allow_result_ = new QLabel(page);
allow_result_->setWordWrap(true);
layout->addWidget(allow_result_);
layout->addWidget(new QLabel(QStringLiteral("<b>Recent policy changes</b>"), page));
history_list_ = new QListWidget(page);
layout->addWidget(history_list_, 1);
connect(add, &QPushButton::clicked, this, &MainWindow::add_allowlist_dialog);
connect(remove, &QPushButton::clicked, this, [this]() {
const auto id = selected_id(allow_table_);
if (id.isEmpty()) {
return;
}
if (QMessageBox::question(this, QStringLiteral("Remove allowlist entry"),
QStringLiteral("Remove this entry? Matching detections will be recorded again."))
== QMessageBox::Yes) {
emit policy_change_requested(QStringLiteral("allowlist-remove"), QJsonObject{{QStringLiteral("id"), id}});
}
});
return page;
}
QWidget* MainWindow::build_response_tab() {
auto* page = new QWidget(this);
auto* layout = new QVBoxLayout(page);
response_status_ = new QLabel(page);
response_status_->setWordWrap(true);
response_status_->setTextFormat(Qt::RichText);
layout->addWidget(response_status_);
auto* settings = new QFormLayout();
contain_auto_ = new QCheckBox(QStringLiteral("Automatically block network access of flagged binaries (OpenSnitch)"), page);
contain_severity_ = new QComboBox(page);
prevention_mode_ = new QComboBox(page);
prevention_severity_ = new QComboBox(page);
for (auto* combo : {contain_severity_, prevention_severity_}) {
combo->addItem(QStringLiteral("critical"), QStringLiteral("critical"));
combo->addItem(QStringLiteral("high and above"), QStringLiteral("high"));
combo->addItem(QStringLiteral("medium and above"), QStringLiteral("medium"));
}
prevention_mode_->addItem(QStringLiteral("Off"), QStringLiteral("off"));
prevention_mode_->addItem(QStringLiteral("Audit (alert, never block)"), QStringLiteral("audit"));
prevention_mode_->addItem(QStringLiteral("Enforce (block execution)"), QStringLiteral("enforce"));
settings->addRow(contain_auto_);
settings->addRow(QStringLiteral("Contain at severity"), contain_severity_);
settings->addRow(QStringLiteral("Execution prevention"), prevention_mode_);
settings->addRow(QStringLiteral("Prevent at severity"), prevention_severity_);
auto* apply = new QPushButton(QStringLiteral("Apply protection settings"), page);
settings->addRow(apply);
layout->addLayout(settings);
auto* note = new QLabel(QStringLiteral(
"System locations (/usr, /bin, /lib, /etc, /boot) are never blocked automatically, only alerted on. "
"Allowlisted binaries are never contained. Start prevention in Audit and switch to Enforce once no "
"legitimate program shows up as \"would block\"."), page);
note->setWordWrap(true);
note->setStyleSheet(QStringLiteral("color: #888"));
layout->addWidget(note);
layout->addWidget(new QLabel(QStringLiteral("<b>Contained binaries</b> (network denied via OpenSnitch)"), page));
contain_table_ = make_table(page, {QStringLiteral("Path"), QStringLiteral("Reason"), QStringLiteral("Severity"),
QStringLiteral("Pinned by"), QStringLiteral("By"), QStringLiteral("When"),
QStringLiteral("SHA-256")},
0);
layout->addWidget(contain_table_, 1);
auto* bar = new QHBoxLayout();
auto* undo = new QPushButton(QStringLiteral("Undo (allow network)"), page);
bar->addWidget(undo);
bar->addStretch();
layout->addLayout(bar);
layout->addWidget(new QLabel(QStringLiteral("<b>Quarantined binaries</b> (execution always blocked, network denied; "
"files are kept for forensics)"), page));
quarantine_table_ = make_table(page, {QStringLiteral("Path"), QStringLiteral("By"), QStringLiteral("When"),
QStringLiteral("SHA-256")},
0);
layout->addWidget(quarantine_table_, 1);
auto* qbar = new QHBoxLayout();
auto* release = new QPushButton(QStringLiteral("Release from quarantine"), page);
qbar->addWidget(release);
qbar->addStretch();
layout->addLayout(qbar);
connect(release, &QPushButton::clicked, this, [this]() {
const auto sha = selected_id(quarantine_table_);
if (!sha.isEmpty()
&& QMessageBox::question(this, QStringLiteral("Release"), QStringLiteral("Allow this binary to run again?\n\n%1").arg(sha))
== QMessageBox::Yes) {
emit policy_change_requested(QStringLiteral("quarantine-remove"), QJsonObject{{QStringLiteral("sha256"), sha}});
}
});
response_result_ = new QLabel(page);
response_result_->setWordWrap(true);
layout->addWidget(response_result_);
const auto mark_dirty = [this]() { protection_dirty_ = true; };
connect(contain_auto_, &QCheckBox::toggled, this, mark_dirty);
for (auto* combo : {contain_severity_, prevention_mode_, prevention_severity_}) {
connect(combo, &QComboBox::activated, this, mark_dirty);
}
connect(apply, &QPushButton::clicked, this, [this]() {
const auto mode = prevention_mode_->currentData().toString();
if (mode == QStringLiteral("enforce")
&& QMessageBox::question(this, QStringLiteral("Enforce prevention"),
QStringLiteral("Block execution of matching programs? Make sure Audit mode has shown "
"no false \"would block\" alerts first."))
!= QMessageBox::Yes) {
return;
}
protection_dirty_ = false;
response_result_->setText(QStringLiteral("Saving…"));
emit policy_change_requested(QStringLiteral("protection-set"), QJsonObject{
{QStringLiteral("contain_auto"), contain_auto_->isChecked()},
{QStringLiteral("contain_min_severity"), contain_severity_->currentData().toString()},
{QStringLiteral("prevention_mode"), mode},
{QStringLiteral("prevention_min_severity"), prevention_severity_->currentData().toString()},
});
});
connect(undo, &QPushButton::clicked, this, [this]() {
const auto id = selected_id(contain_table_);
if (!id.isEmpty()) {
emit policy_change_requested(QStringLiteral("contain-remove"), QJsonObject{{QStringLiteral("id"), id}});
}
});
return page;
}
void MainWindow::render_response() {
if (response_status_ == nullptr) {
return;
}
const auto os = status_.value(QStringLiteral("opensnitch")).toObject();
QString text;
if (status_.isEmpty()) {
text = QStringLiteral("Scanner not reachable.");
} else if (!os.value(QStringLiteral("integration")).toBool()) {
text = QStringLiteral("OpenSnitch integration is disabled in strawberry.conf.");
} else if (!os.value(QStringLiteral("installed")).toBool()) {
text = QStringLiteral("<b>OpenSnitch not found</b> — install it to enable network containment and blocklists.");
} else {
const auto entries = os.value(QStringLiteral("blocklists")).toObject().value(QStringLiteral("entries")).toObject();
text = QStringLiteral("<b>OpenSnitch connected.</b> Blocklists: %1 domains, %2 IPs, %3 networks. %4")
.arg(entries.value(QStringLiteral("domains")).toInt())
.arg(entries.value(QStringLiteral("ips")).toInt())
.arg(entries.value(QStringLiteral("nets")).toInt())
.arg(os.value(QStringLiteral("checksums_enabled")).toBool()
? QStringLiteral("Containment is pinned to each binary's hash.")
: colored(false, QStringLiteral("Checksums are off in OpenSnitch, so containment is by path only "
"(run: sudo strawberry --opensnitch-enable-checksums).")));
}
const auto exec_guard = status_.value(QStringLiteral("prevention")).toObject();
if (!exec_guard.isEmpty()) {
text += QStringLiteral("<br><b>Execution prevention:</b> %1 — %2 checked, %3 blocked, %4 would-block, %5 timeouts%6")
.arg(exec_guard.value(QStringLiteral("mode")).toString())
.arg(exec_guard.value(QStringLiteral("checked")).toDouble(), 0, 'f', 0)
.arg(exec_guard.value(QStringLiteral("blocked")).toDouble(), 0, 'f', 0)
.arg(exec_guard.value(QStringLiteral("would_block")).toDouble(), 0, 'f', 0)
.arg(exec_guard.value(QStringLiteral("timeouts")).toDouble(), 0, 'f', 0)
.arg(exec_guard.value(QStringLiteral("active")).toBool()
? QString()
: QStringLiteral(" ") + colored(false, QStringLiteral("(inactive: ")
+ exec_guard.value(QStringLiteral("error")).toString() + QStringLiteral(")")));
}
response_status_->setText(text);
const auto policy = policy_.value(QStringLiteral("policy")).toObject();
const auto protection = policy.value(QStringLiteral("protection")).toObject();
if (!protection_dirty_ && !protection.isEmpty()) {
const auto select = [](QComboBox* combo, const QString& value) {
const int index = combo->findData(value);
if (index >= 0) {
combo->setCurrentIndex(index);
}
};
contain_auto_->blockSignals(true);
contain_auto_->setChecked(protection.value(QStringLiteral("contain_auto")).toBool(true));
contain_auto_->blockSignals(false);
select(contain_severity_, protection.value(QStringLiteral("contain_min_severity")).toString());
select(prevention_mode_, protection.value(QStringLiteral("prevention_mode")).toString());
select(prevention_severity_, protection.value(QStringLiteral("prevention_min_severity")).toString());
}
const auto selected = selected_id(contain_table_);
contain_table_->setRowCount(0);
for (const auto& value : policy.value(QStringLiteral("containment")).toArray()) {
const auto c = value.toObject();
const int row = contain_table_->rowCount();
contain_table_->insertRow(row);
auto* path = new QTableWidgetItem(c.value(QStringLiteral("path")).toString());
path->setData(Qt::UserRole, c.value(QStringLiteral("id")).toString());
path->setToolTip(path->text());
contain_table_->setItem(row, 0, path);
contain_table_->setItem(row, 1, new QTableWidgetItem(c.value(QStringLiteral("reason")).toString()));
contain_table_->setItem(row, 2, new QTableWidgetItem(c.value(QStringLiteral("severity")).toString()));
contain_table_->setItem(row, 3, new QTableWidgetItem(c.value(QStringLiteral("hash_pinned")).toBool()
? QStringLiteral("path + hash") : QStringLiteral("path only")));
contain_table_->setItem(row, 4, new QTableWidgetItem(c.value(QStringLiteral("automatic")).toBool()
? QStringLiteral("automatic")
: user_name(static_cast<qint64>(c.value(QStringLiteral("created_by")).toDouble()))));
contain_table_->setItem(row, 5, new QTableWidgetItem(when(static_cast<qint64>(c.value(QStringLiteral("created_at")).toDouble()))));
contain_table_->setItem(row, 6, new QTableWidgetItem(c.value(QStringLiteral("sha256")).toString().left(16)));
if (path->data(Qt::UserRole).toString() == selected) {
contain_table_->selectRow(row);
}
}
const auto selected_q = selected_id(quarantine_table_);
quarantine_table_->setRowCount(0);
for (const auto& value : policy.value(QStringLiteral("quarantine")).toArray()) {
const auto q = value.toObject();
const int row = quarantine_table_->rowCount();
quarantine_table_->insertRow(row);
auto* path = new QTableWidgetItem(q.value(QStringLiteral("path")).toString());
path->setData(Qt::UserRole, q.value(QStringLiteral("sha256")).toString());
path->setToolTip(path->text());
quarantine_table_->setItem(row, 0, path);
quarantine_table_->setItem(row, 1, new QTableWidgetItem(user_name(static_cast<qint64>(q.value(QStringLiteral("created_by")).toDouble()))));
quarantine_table_->setItem(row, 2, new QTableWidgetItem(when(static_cast<qint64>(q.value(QStringLiteral("created_at")).toDouble()))));
quarantine_table_->setItem(row, 3, new QTableWidgetItem(q.value(QStringLiteral("sha256")).toString().left(16)));
if (path->data(Qt::UserRole).toString() == selected_q) {
quarantine_table_->selectRow(row);
}
}
}
void MainWindow::update_policy(const QJsonObject& policy, const QString& error) {
STRAWBERRY_ZONE("tray.update_policy");
if (!error.isEmpty()) {
policy_error_ = error;
} else {
policy_ = policy;
policy_error_.clear();
}
render_rules();
render_allowlist();
render_response();
}
void MainWindow::show_policy_result(const QString& verb, bool ok, const QString& message) {
auto* target = verb.startsWith(QStringLiteral("feed-")) ? rules_result_
: (verb == QStringLiteral("scan-memory") || verb.startsWith(QStringLiteral("process-"))
|| verb == QStringLiteral("quarantine")) ? process_result_
: (verb.startsWith(QStringLiteral("contain-")) || verb.startsWith(QStringLiteral("quarantine"))
|| verb == QStringLiteral("protection-set")) ? response_result_
: allow_result_;
target->setText(colored(ok, message));
}
void MainWindow::render_rules() {
const auto rules = status_.value(QStringLiteral("rules")).toObject();
QString summary;
if (!status_error_.isEmpty() || status_.isEmpty()) {
summary = QStringLiteral("<b>Scanner not reachable</b> — rule status unavailable.");
} else {
summary = QStringLiteral("<b>%1 YARA rules</b> and <b>%5 known-malware hashes</b> active, from %2 file(s), generation %3, loaded %4.")
.arg(rules.value(QStringLiteral("count")).toInt())
.arg(rules.value(QStringLiteral("files")).toInt())
.arg(rules.value(QStringLiteral("generation")).toInt())
.arg(when(static_cast<qint64>(rules.value(QStringLiteral("loaded_at_ns")).toDouble())))
.arg(rules.value(QStringLiteral("ioc_hashes")).toInt());
const auto rules_error = rules.value(QStringLiteral("last_error")).toString();
if (!rules_error.isEmpty()) {
summary += QStringLiteral("<br>%1").arg(colored(false, QStringLiteral("Last reload failed (previous rules still active): ") + rules_error));
}
}
if (!policy_error_.isEmpty()) {
summary += QStringLiteral("<br>%1").arg(colored(false, QStringLiteral("Policy unavailable: ") + policy_error_));
}
rules_summary_->setText(summary);
std::map<QString, QJsonObject> states;
for (const auto& value : policy_.value(QStringLiteral("feed_state")).toObject().value(QStringLiteral("feeds")).toArray()) {
const auto state = value.toObject();
states[state.value(QStringLiteral("id")).toString()] = state;
}
const auto selected = selected_id(feeds_table_);
feeds_table_->setRowCount(0);
for (const auto& value : policy_.value(QStringLiteral("policy")).toObject().value(QStringLiteral("feeds")).toArray()) {
const auto feed = value.toObject();
const auto id = feed.value(QStringLiteral("id")).toString();
const auto state = states[id];
const bool enabled = feed.value(QStringLiteral("enabled")).toBool();
QStringList urls;
for (const auto& url : feed.value(QStringLiteral("urls")).toArray()) {
urls << url.toString();
}
const auto source = feed.value(QStringLiteral("type")).toString() == QStringLiteral("github-release")
? QStringLiteral("GitHub %1 · %2").arg(feed.value(QStringLiteral("repo")).toString(), feed.value(QStringLiteral("asset")).toString())
: urls.join(QStringLiteral(", "));
const auto kind = feed.value(QStringLiteral("kind")).toString(QStringLiteral("yara"));
QString status_text;
const auto error = state.value(QStringLiteral("error")).toString();
if (!enabled) {
status_text = QStringLiteral("disabled");
} else if (!error.isEmpty()) {
status_text = QStringLiteral("⚠ ") + error;
} else if (state.value(QStringLiteral("version")).toString().isEmpty()) {
status_text = QStringLiteral("waiting for first download");
} else {
status_text = QStringLiteral("✔ up to date (checked %1)").arg(when(static_cast<qint64>(state.value(QStringLiteral("checked_at")).toDouble())));
}
const int row = feeds_table_->rowCount();
feeds_table_->insertRow(row);
auto* name = new QTableWidgetItem(feed.value(QStringLiteral("name")).toString() + QStringLiteral(" (") + id + QStringLiteral(")"));
name->setData(Qt::UserRole, id);
name->setToolTip(source);
feeds_table_->setItem(row, 0, name);
auto* status_item = new QTableWidgetItem(status_text);
status_item->setToolTip(status_text);
if (!error.isEmpty()) {
status_item->setForeground(QColor(0xd7, 0x26, 0x38));
}
feeds_table_->setItem(row, 1, new QTableWidgetItem(kind == QStringLiteral("yara") ? QStringLiteral("YARA rules") : kind));
feeds_table_->setItem(row, 2, status_item);
feeds_table_->setItem(row, 3, new QTableWidgetItem(QString::number(state.value(QStringLiteral("rules")).toInt())));
feeds_table_->setItem(row, 4, new QTableWidgetItem(state.value(QStringLiteral("version")).toString()));
feeds_table_->setItem(row, 5, new QTableWidgetItem(when(static_cast<qint64>(state.value(QStringLiteral("updated_at")).toDouble()))));
feeds_table_->setItem(row, 6, new QTableWidgetItem(enabled ? QStringLiteral("yes") : QStringLiteral("no")));
feeds_table_->setItem(row, 7, new QTableWidgetItem(source));
if (id == selected) {
feeds_table_->selectRow(row);
}
}
}
void MainWindow::render_allowlist() {
const auto policy = policy_.value(QStringLiteral("policy")).toObject();
const auto selected = selected_id(allow_table_);
allow_table_->setRowCount(0);
for (const auto& value : policy.value(QStringLiteral("allowlist")).toArray()) {
const auto entry = value.toObject();
const int row = allow_table_->rowCount();
allow_table_->insertRow(row);
auto* kind = new QTableWidgetItem(entry.value(QStringLiteral("kind")).toString());
kind->setData(Qt::UserRole, entry.value(QStringLiteral("id")).toString());
allow_table_->setItem(row, 0, kind);
auto* value_item = new QTableWidgetItem(entry.value(QStringLiteral("value")).toString());
value_item->setToolTip(value_item->text());
allow_table_->setItem(row, 1, value_item);
allow_table_->setItem(row, 2, new QTableWidgetItem(entry.value(QStringLiteral("rule")).toString()));
allow_table_->setItem(row, 3, new QTableWidgetItem(entry.value(QStringLiteral("note")).toString()));
allow_table_->setItem(row, 4, new QTableWidgetItem(user_name(static_cast<qint64>(entry.value(QStringLiteral("added_by")).toDouble()))));
allow_table_->setItem(row, 5, new QTableWidgetItem(when(static_cast<qint64>(entry.value(QStringLiteral("added_at")).toDouble()))));
if (kind->data(Qt::UserRole).toString() == selected) {
allow_table_->selectRow(row);
}
}
history_list_->clear();
const auto history = policy.value(QStringLiteral("history")).toArray();
for (qsizetype i = history.size() - 1; i >= 0 && history_list_->count() < 30; --i) {
const auto change = history[i].toObject();
history_list_->addItem(QStringLiteral("%1 %2 %3 %4")
.arg(when(static_cast<qint64>(change.value(QStringLiteral("at")).toDouble())),
user_name(static_cast<qint64>(change.value(QStringLiteral("uid")).toDouble())),
change.value(QStringLiteral("action")).toString(),
change.value(QStringLiteral("summary")).toString()));
}
}
void MainWindow::add_feed_dialog() {
QDialog dialog(this);
dialog.setWindowTitle(QStringLiteral("Add rule feed"));
auto* form = new QFormLayout(&dialog);
auto* kind = new QComboBox(&dialog);
kind->addItem(QStringLiteral("YARA rules"), QStringLiteral("yara"));
kind->addItem(QStringLiteral("Malware SHA-256 hashes"), QStringLiteral("hashes"));
kind->addItem(QStringLiteral("Malicious domains (OpenSnitch blocklist)"), QStringLiteral("domains"));
kind->addItem(QStringLiteral("Malicious IPs (OpenSnitch blocklist)"), QStringLiteral("ips"));
kind->addItem(QStringLiteral("Malicious networks / CIDR (OpenSnitch blocklist)"), QStringLiteral("nets"));
auto* type = new QComboBox(&dialog);
type->addItem(QStringLiteral("GitHub release asset"), QStringLiteral("github-release"));
type->addItem(QStringLiteral("HTTPS URL(s) (.yar/.yara/.zip, or a text list)"), QStringLiteral("url"));
auto* id = new QLineEdit(&dialog);
id->setPlaceholderText(QStringLiteral("e.g. yara-forge-extended (a-z, 0-9, -)"));
id->setValidator(new QRegularExpressionValidator(QRegularExpression(QStringLiteral("[a-z0-9-]{1,32}")), id));
auto* name = new QLineEdit(&dialog);
auto* repo = new QLineEdit(&dialog);
repo->setPlaceholderText(QStringLiteral("owner/name, e.g. YARAHQ/yara-forge"));
auto* asset = new QLineEdit(&dialog);
asset->setPlaceholderText(QStringLiteral("e.g. yara-forge-rules-extended.zip"));
auto* url = new QLineEdit(&dialog);
url->setPlaceholderText(QStringLiteral("https://… (several: separate with spaces)"));
auto* sha = new QLineEdit(&dialog);
sha->setPlaceholderText(QStringLiteral("optional: pin the expected SHA-256"));
form->addRow(QStringLiteral("Kind"), kind);
form->addRow(QStringLiteral("Source"), type);
form->addRow(QStringLiteral("ID"), id);
form->addRow(QStringLiteral("Name"), name);
form->addRow(QStringLiteral("Repository"), repo);
form->addRow(QStringLiteral("Asset"), asset);
form->addRow(QStringLiteral("URL"), url);
form->addRow(QStringLiteral("SHA-256"), sha);
auto* warning = new QLabel(QStringLiteral(
"Only add feeds you trust: their rules decide what is flagged. GitHub releases must publish a SHA-256 digest; "
"URL feeds are only integrity-checked if you pin a SHA-256."), &dialog);
warning->setWordWrap(true);
form->addRow(warning);
auto* buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dialog);
form->addRow(buttons);
const auto sync = [&]() {
const bool github = type->currentData().toString() == QStringLiteral("github-release");
repo->setEnabled(github);
asset->setEnabled(github);
url->setEnabled(!github);
sha->setEnabled(!github);
};
sync();
connect(type, &QComboBox::currentIndexChanged, &dialog, sync);
connect(buttons, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
connect(buttons, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
if (dialog.exec() != QDialog::Accepted) {
return;
}
QJsonObject payload{{QStringLiteral("id"), id->text().trimmed()},
{QStringLiteral("kind"), kind->currentData().toString()},
{QStringLiteral("type"), type->currentData().toString()}};
if (!name->text().trimmed().isEmpty()) {
payload.insert(QStringLiteral("name"), name->text().trimmed());
}
if (type->currentData().toString() == QStringLiteral("github-release")) {
payload.insert(QStringLiteral("repo"), repo->text().trimmed());
payload.insert(QStringLiteral("asset"), asset->text().trimmed());
} else {
QJsonArray urls;
for (const auto& part : url->text().split(QRegularExpression(QStringLiteral("[\\s,]+")), Qt::SkipEmptyParts)) {
urls.append(part);
}
payload.insert(QStringLiteral("urls"), urls);
if (!sha->text().trimmed().isEmpty()) {
payload.insert(QStringLiteral("sha256"), sha->text().trimmed().toLower());
}
}
rules_result_->setText(QStringLiteral("Adding feed…"));
emit policy_change_requested(QStringLiteral("feed-add"), payload);
}
void MainWindow::add_allowlist_dialog() {
QDialog dialog(this);
dialog.setWindowTitle(QStringLiteral("Add allowlist entry"));
auto* form = new QFormLayout(&dialog);
auto* kind = new QComboBox(&dialog);
kind->addItem(QStringLiteral("Binary hash (SHA-256) — recommended"), QStringLiteral("sha256"));
kind->addItem(QStringLiteral("Path (exact, or directory ending in /)"), QStringLiteral("path"));
kind->addItem(QStringLiteral("Rule name (everywhere)"), QStringLiteral("rule"));
auto* value = new QLineEdit(&dialog);
auto* rule = new QLineEdit(&dialog);
rule->setPlaceholderText(QStringLiteral("optional: only this rule"));
auto* note = new QLineEdit(&dialog);
note->setPlaceholderText(QStringLiteral("why this is safe"));
auto* warning = new QLabel(&dialog);
warning->setWordWrap(true);
warning->setStyleSheet(QStringLiteral("color: #c07a00"));
form->addRow(QStringLiteral("Kind"), kind);
form->addRow(QStringLiteral("Value"), value);
form->addRow(QStringLiteral("Rule"), rule);
form->addRow(QStringLiteral("Note"), note);
form->addRow(warning);
auto* buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dialog);
form->addRow(buttons);
const auto sync = [&]() {
const auto k = kind->currentData().toString();
rule->setEnabled(k != QStringLiteral("rule"));
value->setPlaceholderText(k == QStringLiteral("sha256") ? QStringLiteral("64 hex characters")
: k == QStringLiteral("path") ? QStringLiteral("/usr/bin/tool or /opt/vendor/")
: QStringLiteral("YARA rule name"));
warning->setText(k == QStringLiteral("rule")
? QStringLiteral("Suppresses this rule on every file and process. Malware matching it will not be reported.")
: k == QStringLiteral("path") ? QStringLiteral("Anything placed at this path is trusted; prefer a hash entry.")
: QString());
};
sync();
connect(kind, &QComboBox::currentIndexChanged, &dialog, sync);
connect(buttons, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
connect(buttons, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
if (dialog.exec() != QDialog::Accepted) {
return;
}
QJsonObject payload{{QStringLiteral("kind"), kind->currentData().toString()},
{QStringLiteral("value"), value->text().trimmed()}};
if (rule->isEnabled() && !rule->text().trimmed().isEmpty()) {
payload.insert(QStringLiteral("rule"), rule->text().trimmed());
}
if (!note->text().trimmed().isEmpty()) {
payload.insert(QStringLiteral("note"), note->text().trimmed());
}
allow_result_->setText(QStringLiteral("Adding entry…"));
emit policy_change_requested(QStringLiteral("allowlist-add"), payload);
}
void MainWindow::propose_allowlist(const QString& kind, const QString& value, const QString& rule, const QString& context) {
const auto answer = QMessageBox::question(
this, QStringLiteral("Allowlist"),
QStringLiteral("Stop reporting %1?\n\n%2\n\nOnly do this if you know the file is legitimate.").arg(context, value));
if (answer != QMessageBox::Yes) {
return;
}
QJsonObject payload{{QStringLiteral("kind"), kind}, {QStringLiteral("value"), value},
{QStringLiteral("note"), QStringLiteral("added from the Strawberry app")}};
if (!rule.isEmpty()) {
payload.insert(QStringLiteral("rule"), rule);
}
tabs_->setCurrentWidget(allow_table_->parentWidget());
allow_result_->setText(QStringLiteral("Adding entry…"));
emit policy_change_requested(QStringLiteral("allowlist-add"), payload);
}
} // namespace strawberry::app