/
githubmirror
/
setools
Обзор
Документация
Войти
/
githubmirror
/
setools
Код
Запросы
0
Пакеты
0
Релизы
0
Аналитика
Безопасность
4.5.1
setoolsgui/apol.py
1 068 строк
41 KB
Chris PeBenito
Enable some strict mypy options as a first step to fully strict mode.
14 фев 2024, 17:11
14 фев 2024, 17:11
031fe77
Код
Авторство
О чём код?
# 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()