oscap_report.scap_results_parser.data_structures

Complexity

Total Complexity

45

Size/Duplication

Total Lines	285
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
B	Report.get_severity_of_failed_rules_stats()	0	15	6
A	Report.as_dict()	0	18	1
B	Report.get_rule_results_stats()	0	21	5
A	OvalObject.as_dict()	0	6	1
B	Remediation.get_type()	0	12	6
A	OvalTest.as_dict()	0	6	1
A	OvalNode.log_oval_tree()	0	10	4
A	Rule.as_dict()	0	18	1
C	OvalObject.filter_permissions()	0	34	9
A	OvalNode.as_dict()	0	21	2
A	OvalObject.get_header_from_object_data()	0	7	4
A	Remediation.as_dict()	0	8	1
A	OvalObject.filtr_object_data_item()	0	8	4

import logging
from dataclasses import dataclass


@dataclass
class Report:  # pylint: disable=R0902
    title: str = ""
    identity: str = ""
    profile_name: str = ""
    target: str = ""
    cpe_platforms: str = ""
    scanner: str = ""
    scanner_version: str = ""
    benchmark_url: str = ""
    benchmark_id: str = ""
    benchmark_version: str = ""
    start_time: str = ""
    end_time: str = ""
    test_system: str = ""
    score: float = 0.0
    score_max: float = 0.0
    rules: dict = None

    def as_dict(self):
        return {
            "title": self.title,
            "profile_name": self.profile_name,
            "target": self.target,
            "identit": self.identity,
            "cpe_platforms": self.cpe_platforms,
            "scanner": self.scanner,
            "scanner_version": self.scanner_version,
            "benchmark_url": self.benchmark_url,
            "benchmark_id": self.benchmark_id,
            "benchmark_version": self.benchmark_version,
            "start_time": self.start_time,
            "end_time": self.end_time,
            "test_system": self.test_system,
            "score": self.score,
            "score_max": self.score_max,
            "rules": self.rules,
        }

    def get_rule_results_stats(self):
        results_stats = {
            "fail": len(list(
                filter(lambda rule: rule.result.lower() == "fail", self.rules.values()))),
            "pass": len(list(
                filter(lambda rule: rule.result.lower() == "pass", self.rules.values()))),
            "unknown_error": len(list(
                filter(lambda rule:
                       rule.result.lower() in ("error", "unknown"), self.rules.values()))),
        }
        not_ignored_rules = len(list(
            filter(
                lambda rule: rule.result.lower() not in ("notselected", "notapplicable"),
                self.rules.values()
            )))
        percent_per_rule = 100 / not_ignored_rules
        results_stats["other"] = not_ignored_rules - results_stats["fail"] - results_stats['pass']
        results_stats["fail_percent"] = results_stats["fail"] * percent_per_rule
        results_stats["pass_percent"] = results_stats["pass"] * percent_per_rule
        results_stats["other_percent"] = results_stats["other"] * percent_per_rule
        return results_stats

    def get_severity_of_failed_rules_stats(self):
        failed_rules = list(
            filter(lambda rule: rule.result.lower() == "fail", self.rules.values()))
        percent_per_rule = 100 / len(failed_rules)
        severity_stats = {
            "low": sum(map(lambda rule: rule.severity.lower() == "low", failed_rules)),
            "medium": sum(map(lambda rule: rule.severity.lower() == "medium", failed_rules)),
            "high": sum(map(lambda rule: rule.severity.lower() == "high", failed_rules)),
            "unknown": sum(map(lambda rule: rule.severity.lower() == "unknown", failed_rules)),
        }
        severity_stats["low_percent"] = severity_stats["low"] * percent_per_rule
        severity_stats["medium_percent"] = severity_stats["medium"] * percent_per_rule
        severity_stats["high_percent"] = severity_stats["high"] * percent_per_rule
        severity_stats["unknown_percent"] = severity_stats["unknown"] * percent_per_rule
        return severity_stats


@dataclass
class OvalObject():
    object_id: str = ""
    flag: str = ""
    object_type: str = ""
    object_data: dict = None

    def as_dict(self):
        return {
            "object_id": self.object_id,
            "flag": self.flag,
            "object_type": self.object_type,
            "object_data": self.object_data,
        }

    def get_header_from_object_data(self):
        out = []
        for item in self.object_data:
            for key in self.filtr_object_data_item(item):
                if key not in out:
                    out.append(key)
        return out

    def filtr_object_data_item(self, item):
        if self.object_type == "textfilecontent54_object":
            if "filepath" in item and "text" in item:
                return {
                    "filepath": item["filepath"],
                    "content": item["text"]
                }
        return self.filter_permissions(item)

    def filter_permissions(self, item):

This method could be written as a function/class method.

        permission = {
            "uread": None,
            "uwrite": None,
            "uexec": None,
            "gread": None,
            "gwrite": None,
            "gexec": None,
            "oread": None,
            "owrite": None,
            "oexec": None,
        }
        out = {}
        for key, value in item.items():
            if key in permission:
                permission[key] = value
            else:
                out[key] = value
        if None in permission.values():
            return out
        permission_str = "<code>"
        for key, value in permission.items():
            if value:
                if "read" in key:
                    permission_str += "r"
                elif "write" in key:
                    permission_str += "w"
                elif "exec" in key:
                    permission_str += "x"
                else:
                    permission_str += "-"
        permission_str += "</code>"
        out["permission"] = permission_str
        return out


@dataclass
class OvalTest():
    test_id: str = ""
    test_type: str = ""
    comment: str = ""
    oval_object: OvalObject = None

    def as_dict(self):
        return {
            "test_id": self.test_id,
            "test_type": self.test_type,
            "comment": self.comment,
            "oval_object": self.oval_object,
        }


@dataclass
class OvalNode:  # pylint: disable=R0902
    node_id: str
    node_type: str
    value: str
    negation: bool = False
    comment: str = ""
    tag: str = ""
    test_result_details: dict = None
    children: list = None
    test_info: OvalTest = None

    def as_dict(self):
        if not self.children:
            return {
                'node_id': self.node_id,
                'type': self.node_type,
                'value': self.value,
                'negation': self.negation,
                'comment': self.comment,
                'tag': self.tag,
                'test_result_details': self.test_result_details,
                'child': None
            }
        return {
            'node_id': self.node_id,
            'type': self.node_type,
            'value': self.value,
            'negation': self.negation,
            'comment': self.comment,
            'tag': self.tag,
            'test_result_details': self.test_result_details,
            'child': [child.as_dict() for child in self.children]
        }

    def log_oval_tree(self, level=0):
        out = ""
        if self.node_type != "value":
            out = "  " * level + self.node_type + " = " + self.value
        else:
            out = "  " * level + self.node_id + " = " + self.value
        logging.info(out)
        if self.children is not None:
            for child in self.children:
                child.log_oval_tree(level + 1)


@dataclass
class Rule:  # pylint: disable=R0902
    rule_id: str = ""
    title: str = ""
    result: str = ""
    multi_check: bool = False
    time: str = ""
    severity: str = ""
    identifiers: list = None
    references: list = None
    description: str = ""
    rationale: str = ""
    warnings: list = None
    platform: str = ""
    oval_definition_id: str = ""
    message: str = ""
    remediations: list = None
    oval_tree: OvalNode = None

    def as_dict(self):
        return {
            "rule_id": self.rule_id,
            "title": self.title,
            "result": self.result,
            "multi_check": self.multi_check,
            "time": self.time,
            "severity": self.severity,
            "identifiers": self.identifiers,
            "references": self.references,
            "description": self.description,
            "rationale": self.rationale,
            "warnings": self.warnings,
            "platform": self.platform,
            "oval_definition_id": self.oval_definition_id,
            "message": self.message,
            "remediations": self.remediations,
            "oval_tree": self.oval_tree,
        }


@dataclass
class Remediation:
    remediation_id: str = ""
    system: str = ""
    complexity: str = ""
    disruption: str = ""
    strategy: str = ""
    fix: str = ""

    def as_dict(self):
        return {
            "remediation_id": self.remediation_id,
            "system": self.system,
            "complexity": self.complexity,
            "disruption": self.disruption,
            "strategy": self.strategy,
            "fix": self.fix,
        }

    def get_type(self):
        if self.system == "urn:xccdf:fix:script:sh":
            return "Shell script"
        if self.system == "urn:xccdf:fix:script:ansible":
            return "Ansible snippet"
        if self.system == "urn:xccdf:fix:script:puppet":
            return "Puppet snippet"
        if self.system == "urn:redhat:anaconda:pre":
            return "Anaconda snippet"
        if self.system == "urn:xccdf:fix:script:kubernetes":
            return "Kubernetes snippet"
        return self.system