mirror of
https://github.com/SELinuxProject/setools
synced 2025-05-08 03:06:15 +00:00
031fe77df6
Enable options that only require little to no code fixes. Signed-off-by: Chris PeBenito <pebenito@ieee.org>
1069 lines
40 KiB
Python
1069 lines
40 KiB
Python
# Copyright 2015-2016, Tresys Technology, LLC
|
|
# SPDX-License-Identifier: LGPL-2.1-only
|
|
|
|
from collections import defaultdict
|
|
from contextlib import suppress
|
|
from functools import partial
|
|
from importlib import resources as pkg_resources
|
|
import json
|
|
import logging
|
|
import os
|
|
import sys
|
|
import typing
|
|
|
|
from PyQt6 import QtCore, QtGui, QtWidgets
|
|
import setools
|
|
|
|
from . import config, widgets
|
|
|
|
# Supported analyses. These are not directly used here, but
|
|
# will init the tab registry in widgets.tab for apol's analyses.
|
|
# pylint: disable=unused-import
|
|
from .widgets import (boolquery,
|
|
boundsquery,
|
|
categoryquery,
|
|
commonquery,
|
|
constraintquery,
|
|
defaultquery,
|
|
dta,
|
|
fsusequery,
|
|
genfsconquery,
|
|
ibendportconquery,
|
|
ibpkeyconquery,
|
|
infoflow,
|
|
initsidquery,
|
|
mlsrulequery,
|
|
netifconquery,
|
|
nodeconquery,
|
|
objclassquery,
|
|
portconquery,
|
|
rbacrulequery,
|
|
rolequery,
|
|
sensitivityquery,
|
|
summary,
|
|
terulequery,
|
|
typeattrquery,
|
|
typequery,
|
|
userquery,)
|
|
|
|
STYLESHEET: typing.Final[str] = "apol.css"
|
|
|
|
# Class of the tab that opens automatically when a policy is loaded.
|
|
INITIAL_TAB: typing.Final[type[widgets.tab.BaseAnalysisTabWidget]] = summary.SummaryTab
|
|
|
|
# keys for workspace save file
|
|
SETTINGS_POLICY: typing.Final[str] = "__policy__"
|
|
SETTINGS_PERMMAP: typing.Final[str] = "__permmap__"
|
|
SETTINGS_TABS_LIST: typing.Final[str] = "__tabs__"
|
|
SETTINGS_TAB_TITLE: typing.Final[str] = "__title__"
|
|
SETTINGS_TAB_CLASS: typing.Final[str] = "__tab__"
|
|
|
|
|
|
class ApolWorkspace(QtWidgets.QTabWidget):
|
|
|
|
"""The main widget for apol."""
|
|
|
|
policy: setools.SELinuxPolicy | None
|
|
permmap: setools.PermissionMap | None
|
|
|
|
policy_changed = QtCore.pyqtSignal(setools.SELinuxPolicy)
|
|
permmap_changed = QtCore.pyqtSignal(setools.PermissionMap)
|
|
|
|
def __init__(self, parent: QtWidgets.QWidget | None = None) -> None:
|
|
# __init__ here to type narrow the parent to the Apol main window
|
|
super().__init__(parent)
|
|
self.log = logging.getLogger(__name__)
|
|
self.permmap = None
|
|
self.policy = None
|
|
self.config: typing.Final[config.ApolConfig] = config.ApolConfig()
|
|
|
|
self.setAutoFillBackground(True)
|
|
self.setTabPosition(QtWidgets.QTabWidget.TabPosition.North)
|
|
self.setTabsClosable(True)
|
|
self.setMovable(True)
|
|
self.setCurrentIndex(-1)
|
|
|
|
# counter separate to the open tab count. This increments for each new
|
|
# tab so we can create a unique title for each tab, even if there are
|
|
# many tabs with the same analysis.
|
|
self.tab_counter = 0
|
|
|
|
# set up tab name editor
|
|
self.tab_editor = QtWidgets.QLineEdit(self)
|
|
self.tab_editor.setWindowFlags(QtCore.Qt.WindowType.Popup)
|
|
self.tab_editor.editingFinished.connect(self.rename_tab)
|
|
|
|
#
|
|
# Set up workspace actions. These will be pulled in by the
|
|
# main window and added to the workspace menu.
|
|
#
|
|
|
|
self.open_policy_action = QtGui.QAction(self)
|
|
self.open_policy_action.setIcon(
|
|
QtGui.QIcon.fromTheme("dialog-open",
|
|
self.style().standardIcon(
|
|
QtWidgets.QStyle.StandardPixmap.SP_DialogOpenButton)))
|
|
self.open_policy_action.setIconVisibleInMenu(True)
|
|
self.open_policy_action.setText("&Open Policy")
|
|
self.open_policy_action.setToolTip("Open an SELinux Policy")
|
|
self.open_policy_action.setShortcut("Ctrl+O")
|
|
self.open_policy_action.triggered.connect(self.select_policy)
|
|
|
|
self.exit_apol_action = QtGui.QAction(self)
|
|
self.exit_apol_action.setText("E&xit")
|
|
self.exit_apol_action.setShortcut("Ctrl+Q")
|
|
self.exit_apol_action.setIcon(
|
|
QtGui.QIcon.fromTheme("dialog-close",
|
|
self.style().standardIcon(
|
|
QtWidgets.QStyle.StandardPixmap.SP_DialogCloseButton)))
|
|
self.exit_apol_action.triggered.connect(self.parent().close) # type: ignore
|
|
|
|
self.new_analysis_action = QtGui.QAction(self)
|
|
self.new_analysis_action.setIcon(
|
|
QtGui.QIcon.fromTheme("file-icon",
|
|
self.style().standardIcon(
|
|
QtWidgets.QStyle.StandardPixmap.SP_FileIcon)))
|
|
self.new_analysis_action.setIconVisibleInMenu(True)
|
|
self.new_analysis_action.setText("New Analysis")
|
|
self.new_analysis_action.setToolTip("Start a new analysis on this policy.")
|
|
self.new_analysis_action.setShortcut("Ctrl+N")
|
|
self.new_analysis_action.triggered.connect(self.choose_analysis)
|
|
|
|
self.new_from_settings_action = QtGui.QAction(self)
|
|
self.new_from_settings_action.setText("New Analysis From Settings")
|
|
self.new_from_settings_action.setToolTip("Start a new analysis using settings from a file.")
|
|
self.new_from_settings_action.setShortcut("Ctrl+Shift+N")
|
|
self.new_from_settings_action.triggered.connect(self.new_analysis_from_config)
|
|
|
|
self.save_settings_action = QtGui.QAction(self)
|
|
self.save_settings_action.setText("Save Tab Settings")
|
|
self.save_settings_action.setToolTip("Save the current tab\'s settings to file.")
|
|
self.save_settings_action.setShortcut("Ctrl+S")
|
|
self.save_settings_action.triggered.connect(self.save_settings)
|
|
|
|
self.load_settings_action = QtGui.QAction(self)
|
|
self.load_settings_action.setText("Load Tab Settings")
|
|
self.load_settings_action.setToolTip("Load settings for the current tab.")
|
|
self.load_settings_action.setShortcut("Ctrl+L")
|
|
self.load_settings_action.triggered.connect(self.load_settings)
|
|
|
|
self.dupe_tab_action = QtGui.QAction(self)
|
|
self.dupe_tab_action.setText("&Duplicate Tab")
|
|
self.dupe_tab_action.setToolTip("Duplicate the active tab.")
|
|
self.dupe_tab_action.setShortcut("Ctrl+Shift+K")
|
|
self.dupe_tab_action.triggered.connect(self.dupe_tab)
|
|
|
|
self.close_tab_action = QtGui.QAction(self)
|
|
self.close_tab_action.setText("&Close Tab")
|
|
self.close_tab_action.setToolTip("Close the active tab.")
|
|
self.close_tab_action.setShortcut("Ctrl+W")
|
|
self.close_tab_action.triggered.connect(self.close_tab)
|
|
|
|
self.load_workspace_action = QtGui.QAction(self)
|
|
self.load_workspace_action.setText("Load Workspace")
|
|
self.load_workspace_action.setToolTip("Load workspace from file.")
|
|
self.load_workspace_action.setShortcut("Ctrl+Shift+L")
|
|
self.load_workspace_action.triggered.connect(self.load_workspace)
|
|
|
|
self.save_workspace_action = QtGui.QAction(self)
|
|
self.save_workspace_action.setText("Save Workspace")
|
|
self.save_workspace_action.setToolTip("Save workspace to file.")
|
|
self.save_workspace_action.setShortcut("Ctrl+Shift+S")
|
|
self.save_workspace_action.triggered.connect(self.save_workspace)
|
|
|
|
self.help_action = QtWidgets.QWhatsThis.createAction(self)
|
|
|
|
self.about_apol_action = QtGui.QAction(self)
|
|
self.about_apol_action.setText("About Apol")
|
|
self.about_apol_action.triggered.connect(self.about_apol)
|
|
|
|
self.cut_action = QtGui.QAction(self)
|
|
self.cut_action.setText("Cut")
|
|
self.cut_action.setShortcut("Ctrl+X")
|
|
self.cut_action.triggered.connect(self.cut)
|
|
|
|
self.copy_action = QtGui.QAction(self)
|
|
self.copy_action.setText("Copy")
|
|
self.copy_action.setShortcut("Ctrl+C")
|
|
self.copy_action.triggered.connect(self.copy)
|
|
|
|
self.paste_action = QtGui.QAction(self)
|
|
self.paste_action.setText("Paste")
|
|
self.paste_action.setShortcut("Ctrl+V")
|
|
self.paste_action.triggered.connect(self.paste)
|
|
|
|
self.open_permmap = QtGui.QAction(self)
|
|
self.open_permmap.setText("Open Permission Map")
|
|
self.open_permmap.setToolTip("Open permission map used for information flow analysis")
|
|
self.open_permmap.triggered.connect(self.select_permmap)
|
|
|
|
# these two tab actions are to have a global shortcut and
|
|
# entries in the workspace menu.
|
|
|
|
self.close_policy_action = QtGui.QAction(self)
|
|
self.close_policy_action.setText("Close Policy")
|
|
self.close_policy_action.setToolTip("Close the current policy. Closes all analyses too.")
|
|
self.close_policy_action.triggered.connect(self.close_policy)
|
|
|
|
self.edit_permmap_action = QtGui.QAction(self)
|
|
self.edit_permmap_action.setText("Edit Permission Map")
|
|
self.edit_permmap_action.triggered.connect(self.edit_permmap)
|
|
|
|
self.save_permmap_action = QtGui.QAction(self)
|
|
self.save_permmap_action.setText("Save Permission Map")
|
|
self.save_permmap_action.triggered.connect(self.save_permmap)
|
|
|
|
# File menu
|
|
self.menu_File = QtWidgets.QMenu(self)
|
|
self.menu_File.setTitle("&File")
|
|
self.menu_File.addAction(self.open_policy_action)
|
|
self.menu_File.addAction(self.close_policy_action)
|
|
self.menu_File.addSeparator()
|
|
self.menu_File.addAction(self.exit_apol_action)
|
|
|
|
# Workspace menu
|
|
self.menuWorkspace = QtWidgets.QMenu(self)
|
|
self.menuWorkspace.setTitle("Workspace")
|
|
self.menuWorkspace.addAction(self.new_analysis_action)
|
|
self.menuWorkspace.addAction(self.new_from_settings_action)
|
|
self.menuWorkspace.addSeparator()
|
|
self.menuWorkspace.addAction(self.load_settings_action)
|
|
self.menuWorkspace.addAction(self.save_settings_action)
|
|
self.menuWorkspace.addAction(self.dupe_tab_action)
|
|
self.menuWorkspace.addAction(self.close_tab_action)
|
|
self.menuWorkspace.addSeparator()
|
|
self.menuWorkspace.addAction(self.load_workspace_action)
|
|
self.menuWorkspace.addAction(self.save_workspace_action)
|
|
|
|
# Edit menu
|
|
self.menu_Edit = QtWidgets.QMenu(self)
|
|
self.menu_Edit.setTitle("&Edit")
|
|
self.menu_Edit.addAction(self.cut_action)
|
|
self.menu_Edit.addAction(self.copy_action)
|
|
self.menu_Edit.addAction(self.paste_action)
|
|
|
|
# Permission Map menu
|
|
self.menuPerm_Map = QtWidgets.QMenu(self)
|
|
self.menuPerm_Map.setTitle("Permission &Map")
|
|
self.menuPerm_Map.addAction(self.open_permmap)
|
|
self.menuPerm_Map.addAction(self.edit_permmap_action)
|
|
self.menuPerm_Map.addAction(self.save_permmap_action)
|
|
|
|
# Help menu
|
|
self.menu_Help = QtWidgets.QMenu(self)
|
|
self.menu_Help.setTitle("&Help")
|
|
self.menu_Help.addAction(self.help_action)
|
|
self.menu_Help.addSeparator()
|
|
self.menu_Help.addAction(self.about_apol_action)
|
|
|
|
self.addAction(self.menu_File.menuAction())
|
|
self.addAction(self.menuWorkspace.menuAction())
|
|
self.addAction(self.menu_Edit.menuAction())
|
|
self.addAction(self.menuPerm_Map.menuAction())
|
|
self.addAction(self.menu_Help.menuAction())
|
|
|
|
#
|
|
# Add tab context menu
|
|
#
|
|
tab_bar = self.tabBar()
|
|
tab_bar.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu)
|
|
tab_bar.customContextMenuRequested.connect(self.tab_bar_context_menu)
|
|
|
|
#
|
|
# Connect signals
|
|
#
|
|
self.policy_changed.connect(self.update_window_title)
|
|
self.policy_changed.connect(self.handle_policy_change)
|
|
self.tabCloseRequested.connect(self.close_tab)
|
|
self.tabBarDoubleClicked.connect(self.tab_name_editor)
|
|
|
|
QtCore.QMetaObject.connectSlotsByName(self)
|
|
|
|
#
|
|
# Reimplemented methods for typing purposes
|
|
#
|
|
# @typing.override
|
|
def style(self) -> QtWidgets.QStyle:
|
|
"""Type-narrowed style() method."""
|
|
style = super().style()
|
|
assert style, "No style set, this is an SETools bug"
|
|
return style
|
|
|
|
# @typing.override
|
|
def tabBar(self) -> QtWidgets.QTabBar:
|
|
"""Type-narrowed tabBar() method."""
|
|
tab_bar = super().tabBar()
|
|
# seems to be a PyQt 5 bug that "assert tab_bar" fails on QTabBar objects
|
|
assert tab_bar is not None, "No tab bar set, this is an SETools bug"
|
|
return tab_bar
|
|
|
|
# @typing.override
|
|
def widget(self, index: int) -> widgets.tab.BaseAnalysisTabWidget:
|
|
"""Return the widget at the specified tab index."""
|
|
return typing.cast(widgets.tab.BaseAnalysisTabWidget, super().widget(index))
|
|
|
|
#
|
|
# Main window handling
|
|
#
|
|
def update_window_title(self) -> None:
|
|
"""Update window title based on opened policy path."""
|
|
with suppress(AssertionError):
|
|
parent = self.parentWidget()
|
|
assert isinstance(parent, QtWidgets.QMainWindow) # type narrowing
|
|
if self.policy:
|
|
parent.setWindowTitle(f"{self.policy} - apol")
|
|
else:
|
|
parent.setWindowTitle("apol")
|
|
|
|
#
|
|
# Policy handling
|
|
#
|
|
def select_policy(self) -> None:
|
|
"""Open a file chooser to select a policy file."""
|
|
if self.policy and self.count() > 0:
|
|
reply = QtWidgets.QMessageBox.question(
|
|
self,
|
|
"Continue?",
|
|
"Loading a policy will close all existing analyses. Continue?",
|
|
QtWidgets.QMessageBox.StandardButton.Yes |
|
|
QtWidgets.QMessageBox.StandardButton.No)
|
|
|
|
if reply == QtWidgets.QMessageBox.StandardButton.No:
|
|
return
|
|
|
|
filename, _ = QtWidgets.QFileDialog.getOpenFileName(
|
|
self,
|
|
"Open policy file",
|
|
".",
|
|
"SELinux Policies (policy.* sepolicy);;"
|
|
"All Files (*)")
|
|
|
|
if filename:
|
|
self.load_policy(filename)
|
|
|
|
def load_policy(self, filename) -> None:
|
|
"""Load a policy file."""
|
|
with widgets.util.QMessageOnException("Error",
|
|
"<b>Failed to load policy.</b>",
|
|
log=self.log,
|
|
parent=self):
|
|
|
|
self.policy = setools.SELinuxPolicy(filename)
|
|
self.policy_changed.emit(self.policy)
|
|
|
|
if self.permmap:
|
|
with suppress(Exception):
|
|
self.permmap.map_policy(self.policy)
|
|
self.permmap_changed.emit(self.permmap)
|
|
|
|
def close_policy(self) -> None:
|
|
"""Close the current policy."""
|
|
if self.count() > 0:
|
|
reply = QtWidgets.QMessageBox.question(
|
|
self, "Continue?",
|
|
"Closing a policy will close all existing analyses. Continue?",
|
|
QtWidgets.QMessageBox.StandardButton.Yes |
|
|
QtWidgets.QMessageBox.StandardButton.No)
|
|
|
|
if reply == QtWidgets.QMessageBox.StandardButton.No:
|
|
return
|
|
|
|
self.policy = None
|
|
self.clear()
|
|
|
|
#
|
|
# Permission map handling
|
|
#
|
|
def select_permmap(self) -> None:
|
|
"""Open a file chooser to select a permission map file."""
|
|
filename, _ = QtWidgets.QFileDialog.getOpenFileName(self, "Open permission map file", ".")
|
|
if filename:
|
|
self.load_permmap(filename)
|
|
|
|
def load_permmap(self, filename=None) -> None:
|
|
"""Load a permission map file."""
|
|
with widgets.util.QMessageOnException("Error",
|
|
"<b>Failed to load permission map.</b>",
|
|
log=self.log,
|
|
parent=self):
|
|
|
|
self.permmap = setools.PermissionMap(filename)
|
|
|
|
if self.policy:
|
|
with suppress(Exception):
|
|
self.permmap.map_policy(self.policy)
|
|
|
|
self.permmap_changed.emit(self.permmap)
|
|
|
|
def edit_permmap(self) -> None:
|
|
"""Open the permission map editor."""
|
|
if not self.permmap:
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"No open permission map",
|
|
"Cannot edit permission map. Please open a map first.")
|
|
|
|
self.select_permmap()
|
|
|
|
# in case user cancels out of choosing a permmap, recheck
|
|
if self.permmap:
|
|
editor = widgets.permmap.PermissionMapEditor(self.permmap, edit=True, parent=self)
|
|
editor.apply_permmap.connect(self.permmap_changed)
|
|
editor.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)
|
|
editor.show()
|
|
|
|
def save_permmap(self) -> None:
|
|
"""Save the permission map to a file."""
|
|
if not self.permmap:
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"No open permission map",
|
|
"Cannot save permission map; there is no open permission map.")
|
|
return
|
|
|
|
with widgets.util.QMessageOnException("Error",
|
|
"<b>Failed to save permission map.</b>",
|
|
log=self.log,
|
|
parent=self):
|
|
|
|
path = str(self.permmap) if self.permmap else "perm_map"
|
|
filename, _ = QtWidgets.QFileDialog.getSaveFileName(
|
|
self, "Save permission map file", path)
|
|
|
|
if filename:
|
|
self.permmap.save(filename)
|
|
|
|
#
|
|
# Tab handling
|
|
#
|
|
def choose_analysis(self):
|
|
"""Open a dialog to choose an analysis."""
|
|
if not self.policy:
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"No open policy",
|
|
"Cannot start a new analysis. Please open a policy first.")
|
|
|
|
self.select_policy()
|
|
|
|
if self.policy:
|
|
# this check of self._policy is here in case someone
|
|
# tries to start an analysis with no policy open, but then
|
|
# cancels out of the policy file chooser or there is an
|
|
# error opening the policy file.
|
|
ChooseAnalysis(self.policy.mls, parent=self)
|
|
|
|
def create_new_analysis(self, tab_class: type[widgets.tab.BaseAnalysisTabWidget]) -> int:
|
|
"""Create a new analysis tab with the selected widget."""
|
|
self.tab_counter += 1
|
|
counted_name = f"{self.tab_counter}: {tab_class.tab_title}"
|
|
|
|
assert self.policy
|
|
assert self.permmap
|
|
|
|
new_tab = tab_class(self.policy, parent=self)
|
|
new_tab.handle_permmap_change(self.permmap)
|
|
new_tab.setObjectName(counted_name)
|
|
self.permmap_changed.connect(new_tab.handle_permmap_change)
|
|
index = self.addTab(new_tab, counted_name)
|
|
self.setTabToolTip(index, tab_class.tab_title)
|
|
self.setCurrentIndex(index)
|
|
self.toggle_workspace_actions()
|
|
|
|
return index
|
|
|
|
def tab_bar_context_menu(self, pos: QtCore.QPoint) -> None:
|
|
"""Display a context menu for the tab bar."""
|
|
tab_bar = self.tabBar()
|
|
index = tab_bar.tabAt(pos)
|
|
|
|
#
|
|
# Generate context menu for this specific tab index, which may not
|
|
# be the active tab.
|
|
#
|
|
rename_tab_action = QtGui.QAction(self)
|
|
rename_tab_action.setText("&Rename Tab")
|
|
rename_tab_action.setToolTip("Rename this tab.")
|
|
rename_tab_action.triggered.connect(partial(self.tab_name_editor, index))
|
|
|
|
dupe_tab_action = QtGui.QAction(self)
|
|
dupe_tab_action.setText("&Duplicate Tab")
|
|
dupe_tab_action.setToolTip("Duplicate this tab.")
|
|
dupe_tab_action.triggered.connect(partial(self.dupe_tab, index))
|
|
|
|
close_tab_action = QtGui.QAction(self)
|
|
close_tab_action.setText("&Close Tab")
|
|
close_tab_action.setToolTip("Close this tab.")
|
|
close_tab_action.triggered.connect(partial(self.close_tab, index))
|
|
|
|
menu = QtWidgets.QMenu(self)
|
|
menu.addAction(rename_tab_action)
|
|
menu.addAction(dupe_tab_action)
|
|
menu.addAction(close_tab_action)
|
|
menu.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)
|
|
menu.popup(tab_bar.mapToGlobal(pos))
|
|
|
|
def tab_name_editor(self, index: int | None = None) -> None:
|
|
"""Open the tab name editor for the specified tab index."""
|
|
if index is None:
|
|
index = self.currentIndex()
|
|
|
|
if index < 0:
|
|
return
|
|
|
|
tab_area = self.tabBar().tabRect(index)
|
|
self.tab_editor.move(self.mapToGlobal(tab_area.topLeft()))
|
|
self.tab_editor.setText(self.tabText(index))
|
|
self.tab_editor.selectAll()
|
|
self.tab_editor.show()
|
|
self.tab_editor.setFocus()
|
|
|
|
def dupe_tab(self, index: int | None = None) -> None:
|
|
"""
|
|
Duplicate a tab specified by index. If no index is specified, the active one is used.
|
|
"""
|
|
if index is None:
|
|
index = self.currentIndex()
|
|
|
|
if index < 0:
|
|
return
|
|
|
|
settings = self._get_settings(index)
|
|
new_index = self.create_new_analysis(type(self.widget(index)))
|
|
self._put_settings(settings, new_index)
|
|
|
|
def close_tab(self, index: int | None = None) -> None:
|
|
"""Close a tab specified by index."""
|
|
if index is None:
|
|
index = self.currentIndex()
|
|
|
|
if index < 0:
|
|
return
|
|
|
|
widget = self.widget(index)
|
|
widget.close()
|
|
self.removeTab(index)
|
|
self.toggle_workspace_actions()
|
|
|
|
def rename_tab(self) -> None:
|
|
"""Rename the active tab."""
|
|
# this should never be negative since the editor is modal
|
|
index = self.currentIndex()
|
|
assert index >= 0, "Tab index is negative in rename_tab. This is an SETools bug."
|
|
tab = self.widget(index)
|
|
title = self.tab_editor.text()
|
|
|
|
self.tab_editor.hide()
|
|
|
|
self.setTabText(index, title)
|
|
tab.setObjectName(title)
|
|
|
|
#
|
|
# Workspace actions
|
|
#
|
|
# @typing.override
|
|
def clear(self) -> None:
|
|
"""Close all tabs."""
|
|
super().clear()
|
|
self.toggle_workspace_actions()
|
|
|
|
def handle_policy_change(self, policy: setools.SELinuxPolicy) -> None:
|
|
"""Handle a policy change. Close all tabs and create new initial tab."""
|
|
self.log.debug(f"Received policy change signal to {policy}.")
|
|
self.clear()
|
|
|
|
# Open up a new instance of the initial tab if no tabs exist.
|
|
self.log.debug(f"Opening new {INITIAL_TAB} tab.")
|
|
self.create_new_analysis(INITIAL_TAB)
|
|
|
|
def toggle_workspace_actions(self) -> None:
|
|
"""
|
|
Enable or disable workspace actions depending on
|
|
how many tabs are open and if a policy is open.
|
|
|
|
This is a slot for the QTabWidget.currentChanged()
|
|
signal, though index is ignored.
|
|
"""
|
|
open_tabs: typing.Final[bool] = self.count() > 0
|
|
open_policy: typing.Final[bool] = self.policy is not None
|
|
open_permmap: typing.Final[bool] = self.permmap is not None
|
|
|
|
self.log.debug(
|
|
f"{'Enabling' if open_policy else 'Disabling'} actions requiring an open policy.")
|
|
self.log.debug(f"{'Enabling' if open_tabs else 'Disabling'} actions requiring open tabs.")
|
|
self.log.debug(
|
|
f"{'Enabling' if open_permmap else 'Disabling'} actions requiring an open perm map.")
|
|
|
|
self.save_settings_action.setEnabled(open_tabs)
|
|
self.save_workspace_action.setEnabled(open_tabs)
|
|
self.new_analysis_action.setEnabled(open_policy)
|
|
self.new_from_settings_action.setEnabled(open_policy)
|
|
self.load_settings_action.setEnabled(open_tabs)
|
|
self.close_policy_action.setEnabled(open_policy)
|
|
self.edit_permmap_action.setEnabled(open_permmap)
|
|
self.save_permmap_action.setEnabled(open_permmap)
|
|
|
|
def _get_settings(self, index: int | None = None) -> dict:
|
|
"""Return a dictionary with the settings of the tab at the specified index."""
|
|
if index is None:
|
|
index = self.currentIndex()
|
|
|
|
assert index >= 0, "Tab index is negative in _get_settings. This is an SETools bug."
|
|
tab = self.widget(index)
|
|
|
|
settings = tab.save()
|
|
|
|
# add the tab info to the settings.
|
|
settings[SETTINGS_TAB_TITLE] = self.tabText(index)
|
|
settings[SETTINGS_TAB_CLASS] = type(tab).__name__
|
|
|
|
return settings
|
|
|
|
def _put_settings(self, settings: dict, index: int | None = None):
|
|
"""Load the settings into the specified tab."""
|
|
if index is None:
|
|
index = self.currentIndex()
|
|
|
|
assert index >= 0, "Tab index is negative in _put_settings. This is an SETools bug."
|
|
tab = self.widget(index)
|
|
|
|
if settings[SETTINGS_TAB_CLASS] != type(tab).__name__:
|
|
raise TypeError(f"The current tab ({type(tab).__name__}) does not match the tab in "
|
|
f"the settings file ({settings[SETTINGS_TAB_CLASS]}).")
|
|
|
|
try:
|
|
self.setTabText(index, str(settings[SETTINGS_TAB_TITLE]))
|
|
except KeyError:
|
|
self.log.warning("Settings file does not have a title setting.")
|
|
|
|
tab.load(settings)
|
|
|
|
def load_settings(self, new: bool = False) -> None:
|
|
"""Open a file chooser and load settings from the chosen file."""
|
|
filename, _ = QtWidgets.QFileDialog.getOpenFileName(
|
|
self,
|
|
"Open settings file",
|
|
".",
|
|
"Apol Tab Settings File (*.apolt);;"
|
|
"All Files (*)")
|
|
|
|
if not filename:
|
|
return
|
|
|
|
with widgets.util.QMessageOnException("Error",
|
|
f"Failed to load settings file \"{filename}\".",
|
|
log=self.log,
|
|
parent=self):
|
|
|
|
with open(filename, "r", encoding="utf-8") as fd:
|
|
settings = json.load(fd)
|
|
|
|
self.log.info(f"Loading analysis settings from \"{filename}\"")
|
|
|
|
if new:
|
|
tabclass = widgets.tab.TAB_REGISTRY[settings[SETTINGS_TAB_CLASS]]
|
|
# The tab title will be set by _put_settings.
|
|
index = self.create_new_analysis(tabclass)
|
|
else:
|
|
index = None
|
|
|
|
self._put_settings(settings, index)
|
|
self.log.info(f"Successfully loaded analysis settings from \"{filename}\"")
|
|
|
|
def new_analysis_from_config(self) -> None:
|
|
"""Create a new analysis tab from the settings in the config file."""
|
|
self.load_settings(new=True)
|
|
|
|
def save_settings(self) -> None:
|
|
"""Open a file chooser and save settings to the chosen file."""
|
|
with widgets.util.QMessageOnException("Error",
|
|
"<b>Failed to save tab settings.</b>",
|
|
log=self.log,
|
|
parent=self):
|
|
|
|
settings = self._get_settings()
|
|
|
|
filename, _ = QtWidgets.QFileDialog.getSaveFileName(
|
|
self,
|
|
"Save analysis tab settings",
|
|
"analysis.apolt",
|
|
"Apol Tab Settings File (*.apolt);;"
|
|
"All Files (*)")
|
|
|
|
if not filename:
|
|
return
|
|
|
|
with open(filename, "w", encoding="utf-8") as fd:
|
|
json.dump(settings, fd, indent=1)
|
|
|
|
self.log.info(f"Successfully saved tab settings file \"{filename}\"")
|
|
|
|
def load_workspace(self) -> None:
|
|
"""Open a file chooser and load a workspace from the chosen file."""
|
|
# 1. if number of tabs > 0, check if we really want to do this
|
|
if self.count() > 0:
|
|
reply = QtWidgets.QMessageBox.question(
|
|
self, "Continue?",
|
|
"Loading a workspace will close all existing analyses. Continue?",
|
|
QtWidgets.QMessageBox.StandardButton.Yes |
|
|
QtWidgets.QMessageBox.StandardButton.No)
|
|
|
|
if reply == QtWidgets.QMessageBox.StandardButton.No:
|
|
return
|
|
|
|
# 2. try to load the workspace file, if we fail, bail
|
|
filename, _ = QtWidgets.QFileDialog.getOpenFileName(
|
|
self,
|
|
"Open workspace file",
|
|
".",
|
|
"Apol Workspace Files (*.apolw);;"
|
|
"All Files (*)")
|
|
|
|
if not filename:
|
|
return
|
|
|
|
try:
|
|
with open(filename, "r", encoding="utf-8") as fd:
|
|
workspace = json.load(fd)
|
|
except ValueError:
|
|
self.log.critical(f"Invalid workspace file \"{filename}\"")
|
|
self.log.debug("Backtrace", exc_info=True)
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"Failed to load workspace",
|
|
f"Invalid workspace file: \"{filename}\"")
|
|
return
|
|
except OSError as ex:
|
|
self.log.critical(f"Unable to load workspace file \"{ex.filename}\": {ex.strerror}")
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"Failed to load workspace",
|
|
f"Failed to load \"{ex.filename}\": {ex.strerror}")
|
|
return
|
|
except Exception as ex:
|
|
self.log.critical(f"Unable to load workspace file \"{filename}\": {ex}")
|
|
self.log.debug("Backtrace", exc_info=True)
|
|
QtWidgets.QMessageBox().critical(self, "Failed to load workspace", str(ex))
|
|
return
|
|
|
|
# 3. close all tabs. Explicitly do this to avoid the question
|
|
# about closing the policy with tabs open.
|
|
self.clear()
|
|
|
|
# 4. close policy
|
|
self.close_policy()
|
|
|
|
# 5. try to open the specified policy, if we fail, bail. Note:
|
|
# handling exceptions from the policy load is done inside
|
|
# the load_policy function, so only the KeyError needs to be caught here
|
|
try:
|
|
self.load_policy(workspace[SETTINGS_POLICY])
|
|
except KeyError:
|
|
self.log.critical(f"Missing policy in workspace file \"{filename}\"")
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"Aborting workspace load.",
|
|
f"Missing policy in workspace file \"{filename}\"")
|
|
|
|
if self.policy is None:
|
|
self.log.critical(f"The policy could not be loaded in workspace file \"{filename}\"")
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"Aborting workspace load.",
|
|
f"The policy could not be loaded in workspace file \"{filename}\".")
|
|
return
|
|
|
|
# 6. try to open the specified perm map, if we fail,
|
|
# tell the user we will continue with the default map; load the default map
|
|
# Note: handling exceptions from the map load is done inside
|
|
# the load_permmap function, so only the KeyError needs to be caught here
|
|
try:
|
|
self.load_permmap(workspace[SETTINGS_PERMMAP])
|
|
except KeyError:
|
|
self.log.warning(f"Missing permission map in workspace file \"{filename}\"")
|
|
QtWidgets.QMessageBox().warning(
|
|
self,
|
|
"Missing permission map setting.",
|
|
f"Missing permission map in workspace file \"{filename}\". "
|
|
"Loading default permission map.")
|
|
|
|
if self.permmap is None:
|
|
self.load_permmap()
|
|
|
|
# 7. try to open all tabs and apply settings. Record any errors
|
|
try:
|
|
tab_list = list(workspace[SETTINGS_TABS_LIST])
|
|
except KeyError:
|
|
self.log.critical(f"Missing tab list in workspace file \"{filename}\"")
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"Failed to load workspace",
|
|
"The workspace file is missing the tab list. Aborting.")
|
|
return
|
|
except TypeError:
|
|
self.log.critical("Invalid tab list in workspace file.")
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"Failed to load workspace",
|
|
"The tab count is invalid. Aborting.")
|
|
return
|
|
|
|
loading_errors = []
|
|
for i, settings in enumerate(tab_list):
|
|
try:
|
|
tabclass = widgets.tab.TAB_REGISTRY[settings[SETTINGS_TAB_CLASS]]
|
|
except KeyError:
|
|
error_str = f"Missing analysis type for tab {i}. Skipping this tab."
|
|
self.log.error(error_str)
|
|
loading_errors.append(error_str)
|
|
continue
|
|
|
|
# The tab title will be set by _put_settings.
|
|
index = self.create_new_analysis(tabclass)
|
|
|
|
try:
|
|
self._put_settings(settings, index)
|
|
except Exception as ex:
|
|
error_str = f"Error loading settings for tab {i}: {ex}"
|
|
self.log.error(error_str)
|
|
self.log.debug("Backtrace", exc_info=True)
|
|
loading_errors.append(error_str)
|
|
|
|
self.log.info(f"Completed loading workspace from \"{filename}\"")
|
|
|
|
# 8. if there are any errors, open a dialog with the
|
|
# complete list of tab errors
|
|
if loading_errors:
|
|
QtWidgets.QMessageBox().warning(
|
|
self,
|
|
"Errors while loading workspace:",
|
|
"There were errors while loading the workspace:\n\n{0}".
|
|
format("\n\n".join(loading_errors)))
|
|
|
|
def save_workspace(self):
|
|
"""Open a file chooser and save the workspace to the chosen file."""
|
|
workspace = {}
|
|
save_errors = []
|
|
|
|
workspace[SETTINGS_POLICY] = os.path.abspath(str(self.policy))
|
|
workspace[SETTINGS_PERMMAP] = os.path.abspath(str(self.permmap))
|
|
workspace[SETTINGS_TABS_LIST] = []
|
|
|
|
for index in range(self.count()):
|
|
tab = self.widget(index)
|
|
|
|
try:
|
|
settings = tab.save()
|
|
except widgets.exception.TabFieldError as ex:
|
|
tab_name = self.tabText(index)
|
|
save_errors.append(tab_name)
|
|
self.log.error(f"Error: tab \"{tab_name}\": {ex}")
|
|
else:
|
|
# add the tab info to the settings.
|
|
settings[SETTINGS_TAB_TITLE] = self.tabText(index)
|
|
settings[SETTINGS_TAB_CLASS] = type(tab).__name__
|
|
|
|
workspace[SETTINGS_TABS_LIST].append(settings)
|
|
|
|
if save_errors:
|
|
self.log.critical("Errors in tabs prevent saving the workspace.")
|
|
QtWidgets.QMessageBox().critical(
|
|
self,
|
|
"Unable to save workspace",
|
|
"Please resolve errors in the following tabs before saving the "
|
|
"workspace:\n\n{0}".format('\n'.join(save_errors)))
|
|
return
|
|
|
|
filename, _ = QtWidgets.QFileDialog.getSaveFileName(
|
|
self,
|
|
"Save analysis workspace",
|
|
"workspace.apolw",
|
|
"Apol Workspace Files (*.apolw);;"
|
|
"All Files (*)")
|
|
|
|
if not filename:
|
|
return
|
|
|
|
with open(filename, "w", encoding="utf-8") as fd:
|
|
json.dump(workspace, fd, indent=1)
|
|
|
|
#
|
|
# Edit actions
|
|
#
|
|
# @typing.override
|
|
def copy(self):
|
|
"""Copy text from the currently-focused widget."""
|
|
with suppress(Exception):
|
|
QtWidgets.QApplication.instance().focusWidget().copy()
|
|
|
|
# @typing.override
|
|
def cut(self):
|
|
"""Cut text from the currently-focused widget."""
|
|
with suppress(Exception):
|
|
QtWidgets.QApplication.instance().focusWidget().cut()
|
|
|
|
# @typing.override
|
|
def paste(self):
|
|
"""Paste text into the currently-focused widget."""
|
|
with suppress(Exception):
|
|
QtWidgets.QApplication.instance().focusWidget().paste()
|
|
|
|
#
|
|
# Help actions
|
|
#
|
|
def about_apol(self):
|
|
"""Display the about dialog."""
|
|
QtWidgets.QMessageBox.about(
|
|
self,
|
|
"About Apol",
|
|
f"""
|
|
<h1><b>Apol {setools.__version__}</b></h1>
|
|
|
|
<p>Apol is a graphical SELinux policy analysis tool and part of
|
|
<a href="https://github.com/SELinuxProject/setools/wiki"> SETools</a>.</p>
|
|
|
|
<p>Copyright (C) 2015-2016, Tresys Technology</p>
|
|
|
|
<p>Copyright (C) 2016-2023, Chris PeBenito <pebenito@ieee.org></p>
|
|
""")
|
|
|
|
|
|
class ChooseAnalysis(QtWidgets.QDialog):
|
|
|
|
"""
|
|
Dialog for choosing a new analysis
|
|
|
|
The below class attributes are used for populating
|
|
the GUI contents and mapping them to the appropriate
|
|
tab widget class for the analysis.
|
|
"""
|
|
|
|
def __init__(self, mls: bool, parent: ApolWorkspace):
|
|
super().__init__(parent)
|
|
|
|
# populate the analysis choices tree:
|
|
self.analysis_choices = \
|
|
defaultdict[str, dict[str, type[widgets.tab.BaseAnalysisTabWidget]]](dict)
|
|
for clsobj in widgets.tab.TAB_REGISTRY.values():
|
|
self.analysis_choices[clsobj.section.name][clsobj.tab_title] = clsobj
|
|
|
|
self.setWindowTitle("New Analysis")
|
|
self.setAttribute(QtCore.Qt.WidgetAttribute.WA_DeleteOnClose)
|
|
|
|
verticalLayout = QtWidgets.QVBoxLayout(self)
|
|
|
|
label = QtWidgets.QLabel(self)
|
|
label.setText("Choose a new analysis to start:")
|
|
verticalLayout.addWidget(label)
|
|
|
|
# Create tree widget for analysis selection
|
|
self.analysisTypes = QtWidgets.QTreeWidget(self)
|
|
self.analysisTypes.setSelectionMode(
|
|
QtWidgets.QAbstractItemView.SelectionMode.SingleSelection)
|
|
self.analysisTypes.setHeaderHidden(True)
|
|
self.analysisTypes.setExpandsOnDoubleClick(True)
|
|
self.analysisTypes.setColumnCount(1)
|
|
self.analysisTypes.itemDoubleClicked['QTreeWidgetItem*', 'int'].connect(self.accept)
|
|
verticalLayout.addWidget(self.analysisTypes)
|
|
|
|
# Populate analyses widget
|
|
self.analysisTypes.clear()
|
|
for groupname, group in self.analysis_choices.items():
|
|
groupitem = QtWidgets.QTreeWidgetItem(self.analysisTypes)
|
|
groupitem.setText(0, groupname)
|
|
for entryname, cls in group.items():
|
|
if cls.mlsonly and not mls:
|
|
continue
|
|
|
|
item = QtWidgets.QTreeWidgetItem(groupitem)
|
|
item.setText(0, entryname)
|
|
item.setData(0, QtCore.Qt.ItemDataRole.UserRole, cls)
|
|
groupitem.addChild(item)
|
|
|
|
self.analysisTypes.expandAll()
|
|
self.analysisTypes.sortByColumn(0, QtCore.Qt.SortOrder.AscendingOrder)
|
|
|
|
buttonBox = QtWidgets.QDialogButtonBox(self)
|
|
buttonBox.setOrientation(QtCore.Qt.Orientation.Horizontal)
|
|
buttonBox.setStandardButtons(
|
|
QtWidgets.QDialogButtonBox.StandardButton.Cancel |
|
|
QtWidgets.QDialogButtonBox.StandardButton.Ok)
|
|
verticalLayout.addWidget(buttonBox)
|
|
|
|
buttonBox.rejected.connect(self.reject)
|
|
buttonBox.accepted.connect(self.accept)
|
|
|
|
QtCore.QMetaObject.connectSlotsByName(self)
|
|
|
|
self.show()
|
|
|
|
# @typing.override
|
|
def accept(self, item: QtWidgets.QTreeWidgetItem | None = None) -> None:
|
|
"""Accept the dialog and create a new analysis."""
|
|
parent = self.parent()
|
|
assert isinstance(parent, ApolWorkspace) # type narrowing for mypy
|
|
try:
|
|
if not item:
|
|
# tree widget is set for single item selection.
|
|
item = self.analysisTypes.selectedItems()[0]
|
|
|
|
tab_class = typing.cast(type[widgets.tab.BaseAnalysisTabWidget],
|
|
item.data(0, QtCore.Qt.ItemDataRole.UserRole))
|
|
parent.create_new_analysis(tab_class)
|
|
except (IndexError, AttributeError):
|
|
# IndexError: nothing is selected
|
|
# AttributeError: one of the group items was selected.
|
|
return
|
|
else:
|
|
super().accept()
|
|
|
|
|
|
def run_apol(policy: str | None = None) -> int:
|
|
"""Library entrypoint for apol"""
|
|
app = QtWidgets.QApplication(sys.argv)
|
|
|
|
# load apol stylesheet
|
|
package_location = pkg_resources.files("setoolsgui")
|
|
with pkg_resources.as_file(package_location / STYLESHEET) as path:
|
|
with open(path, "r", encoding="utf-8") as fd:
|
|
app.setStyleSheet(fd.read())
|
|
|
|
#
|
|
# Create main window
|
|
#
|
|
mw = QtWidgets.QMainWindow()
|
|
mw.setStatusBar(QtWidgets.QStatusBar(mw))
|
|
mw.setMenuBar(QtWidgets.QMenuBar(mw))
|
|
|
|
#
|
|
# Create central widget
|
|
#
|
|
AnalysisTabs = ApolWorkspace(mw)
|
|
mw.setCentralWidget(AnalysisTabs)
|
|
# Add actions from the central widget to the menu bar.
|
|
mw.menuBar().addActions(AnalysisTabs.actions()) # type: ignore[union-attr]
|
|
|
|
#
|
|
# Configure top-level toolbar
|
|
#
|
|
toolbar = QtWidgets.QToolBar(mw)
|
|
toolbar.setFloatable(True)
|
|
toolbar.setMovable(True)
|
|
toolbar.addAction(AnalysisTabs.open_policy_action)
|
|
toolbar.addAction(AnalysisTabs.new_analysis_action)
|
|
toolbar.addSeparator()
|
|
toolbar.addAction(AnalysisTabs.help_action)
|
|
mw.addToolBar(QtCore.Qt.ToolBarArea.TopToolBarArea, toolbar)
|
|
|
|
#
|
|
# Final loading.
|
|
#
|
|
AnalysisTabs.load_permmap()
|
|
|
|
if policy:
|
|
AnalysisTabs.load_policy(policy)
|
|
|
|
mw.show()
|
|
|
|
return app.exec()
|