FM / checker

/usr/lib64/python3.9/site-packages/setools/checker/

/usr/lib64/python3.9/site-packages/setools/checker

Name	Size	Mode	Actions
__pycache__/	-	0755	rm
assertrbac.py	3980	0644	edit dl rm
assertte.py	4491	0644	edit dl rm
checker.py	5345	0644	edit dl rm
checkermodule.py	3991	0644	edit dl rm
descriptors.py	4293	0644	edit dl rm
emptyattr.py	2770	0644	edit dl rm
globalkeys.py	301	0644	edit dl rm
roexec.py	3612	0644	edit dl rm
util.py	344	0644	edit dl rm
__init__.py	215	0644	edit dl rm

Edit: /usr/lib64/python3.9/site-packages/setools/checker/checkermodule.py (3991B)

# Copyright 2020, Microsoft Corporation
#
# SPDX-License-Identifier: LGPL-2.1-only
#

import sys
import logging
from abc import ABCMeta, abstractmethod
from typing import Dict, FrozenSet, List, Mapping

from ..exception import InvalidCheckOption
from ..policyrep import SELinuxPolicy

from .globalkeys import CHECK_TYPE_KEY, CHECK_DESC_KEY, CHECK_DISABLE, GLOBAL_CONFIG_KEYS

CHECKER_REGISTRY: Dict[str, type] = {}

__all__ = ['CheckerModule']

class CheckRegistry(ABCMeta):

"""Checker module registry metaclass.  This registers modules in the check registry."""

def __new__(cls, clsname, superclasses, attributedict):
        check_type = attributedict.get("check_type")
        check_config = attributedict.get("check_config")

if clsname != "CheckerModule":
            if not isinstance(check_type, str):
                raise TypeError("Checker module {} does not set a check_type.".format(clsname))

if not isinstance(check_config, frozenset):
                raise TypeError("Checker module {} does not set a valid check_config.".format(
                    clsname))

if check_type in CHECKER_REGISTRY:
                existing_check_module = CHECKER_REGISTRY[check_type].__name__
                raise TypeError("Checker module {} conflicts with registered check {}".format(
                                clsname, existing_check_module))

classdef = super().__new__(cls, clsname, superclasses, attributedict)

if check_type:
            CHECKER_REGISTRY[check_type] = classdef

return classdef

class CheckerModule(metaclass=CheckRegistry):

"""Abstract base class for policy checker modules."""

# The name of the check used in config files.
    # This must be set by subclasses.
    check_type: str

# The container of valid config keys specific to the check
    # This is in addition to the common config keys
    # in the GLOBAL_CONFIG_KEYS above.  This must be set by subclasses.
    # If no additional keys  are needed, this should be set to an
    # empty container.
    check_config: FrozenSet[str]

# T/F log findings that pass the check.
    log_passing: bool = False

# Default output to stdout.
    output = sys.stdout

policy: SELinuxPolicy

def __init__(self, policy: SELinuxPolicy, checkname: str, config: Mapping[str, str]) -> None:
        self.policy = policy
        self.checkname = checkname

# ensure there is a logger available. This should
        # be replaced with the concrete class' logger
        self.log = logging.getLogger(__name__)

# Check available options are valid
        valid_options = GLOBAL_CONFIG_KEYS | self.check_config
        for k in config:
            if k not in valid_options:
                raise InvalidCheckOption("{}: Invalid option: {}".format(
                    self.checkname, k))

# Make sure all global config attrs are initialized for this check
        self.desc = config.get(CHECK_DESC_KEY)
        self.disable = config.get(CHECK_DISABLE)

def log_info(self, msg: str) -> None:
        """Output an informational message."""
        self.output.write(msg)
        self.output.write("\n")
        self.log.debug(msg)

def log_ok(self, msg: str) -> None:
        """
        Log findings that pass the check.  By default these messages are
        surpressed unless self.log_passing is True.
        """
        if self.log_passing:
            self.output.write("P   * {}\n".format(msg))
        self.log.debug("P   * {}".format(msg))

def log_fail(self, msg: str) -> None:
        """Log findings that fail the check."""
        self.output.write("{}   * {}\n".format("F" if self.log_passing else " ", msg))
        self.log.debug("F   * {}".format(msg))

@abstractmethod
    def run(self) -> List:
        """
        Run the configured check on the policy.

Return:   List of failed items in the check.  If the check passes, list is empty.
        """
        pass

cmd: