Rename config to kconfig where needed (part II)

[kconfig-hardened-check.git] / kconfig_hardened_check / __init__.py

diff --git a/kconfig_hardened_check/__init__.py b/kconfig_hardened_check/__init__.py
index ae51ca0bcbf913d956f6ccfc78c3af166ef784f9..bc0892aee602d17404b300db4a00bfdca96f8179 100644 (file)
--- a/kconfig_hardened_check/__init__.py
+++ b/kconfig_hardened_check/__init__.py
@@ -1,8 +1,8 @@
 #!/usr/bin/python3
 
 #
-# This tool helps me to check the Linux kernel Kconfig option list
-# against my security hardening preferences for X86_64, ARM64, X86_32, and ARM.
+# This tool helps me to check Linux kernel options against
+# my security hardening preferences for X86_64, ARM64, X86_32, and ARM.
 # Let the computers do their job!
 #
 # Author: Alexander Popov <alex.popov@linux.com>
@@ -176,6 +176,10 @@ class ComplexOptCheck:
     def name(self):
         return self.opts[0].name
 
+    @property
+    def type(self):
+        return self.opts[0].type
+
     @property
     def expected(self):
         return self.opts[0].expected
@@ -291,7 +295,7 @@ def detect_version(fname):
         return None, 'no kernel version detected'
 
 
-def construct_checklist(l, arch):
+def add_kconfig_checks(l, arch):
     # Calling the KconfigCheck class constructor:
     #     KconfigCheck(reason, decision, name, expected)
 
@@ -622,7 +626,7 @@ def print_checklist(mode, checklist, with_results):
     if mode == 'json':
         opts = []
         for o in checklist:
-            opt = ['CONFIG_'+o.name, o.expected, o.decision, o.reason]
+            opt = ['CONFIG_'+o.name, o.type, o.expected, o.decision, o.reason]
             if with_results:
                 opt.append(o.result)
             opts.append(opt)
@@ -669,13 +673,13 @@ def print_checklist(mode, checklist, with_results):
             print('[+] Config check is finished: \'OK\' - {}{} / \'FAIL\' - {}{}'.format(ok_count, ok_suppressed, fail_count, fail_suppressed))
 
 
-def perform_check(opt, parsed_options, kernel_version):
+def populate_opt_with_data(opt, parsed_options, kernel_version):
     if hasattr(opt, 'opts'):
         # prepare ComplexOptCheck
         for o in opt.opts:
             if hasattr(o, 'opts'):
                 # Recursion for nested ComplexOptChecks
-                perform_check(o, parsed_options, kernel_version)
+                populate_opt_with_data(o, parsed_options, kernel_version)
             if hasattr(o, 'state'):
                 o.state = parsed_options.get(o.name, None)
             if hasattr(o, 'ver'):
@@ -685,15 +689,19 @@ def perform_check(opt, parsed_options, kernel_version):
         if not hasattr(opt, 'state'):
             sys.exit('[!] ERROR: bad simple check {}'.format(vars(opt)))
         opt.state = parsed_options.get(opt.name, None)
-    opt.check()
 
 
-def perform_checks(checklist, parsed_options, kernel_version):
+def populate_with_data(checklist, parsed_options, kernel_version):
+    for opt in checklist:
+        populate_opt_with_data(opt, parsed_options, kernel_version)
+
+
+def perform_checks(checklist):
     for opt in checklist:
-        perform_check(opt, parsed_options, kernel_version)
+        opt.check()
 
 
-def parse_config_file(parsed_options, fname):
+def parse_kconfig_file(parsed_options, fname):
     with open(fname, 'r') as f:
         opt_is_on = re.compile("CONFIG_[a-zA-Z0-9_]*=[a-zA-Z0-9_\"]*")
         opt_is_off = re.compile("# CONFIG_[a-zA-Z0-9_]* is not set")
@@ -708,10 +716,10 @@ def parse_config_file(parsed_options, fname):
             elif opt_is_off.match(line):
                 option, value = line[9:].split(' ', 1)
                 if value != 'is not set':
-                    sys.exit('[!] ERROR: bad disabled config option "{}"'.format(line))
+                    sys.exit('[!] ERROR: bad disabled kconfig option "{}"'.format(line))
 
             if option in parsed_options:
-                sys.exit('[!] ERROR: config option "{}" exists multiple times'.format(line))
+                sys.exit('[!] ERROR: kconfig option "{}" exists multiple times'.format(line))
 
             if option:
                 parsed_options[option] = value
@@ -722,7 +730,7 @@ def parse_config_file(parsed_options, fname):
 def main():
     # Report modes:
     #   * verbose mode for
-    #     - reporting about unknown kernel options in the config
+    #     - reporting about unknown kernel options in the kconfig
     #     - verbose printing of ComplexOptCheck items
     #   * json mode for printing the results in JSON format
     report_modes = ['verbose', 'json', 'show_ok', 'show_fail']
@@ -733,7 +741,7 @@ def main():
     parser.add_argument('-p', '--print', choices=supported_archs,
                         help='print security hardening preferences for the selected architecture')
     parser.add_argument('-c', '--config',
-                        help='check the kernel config file against these preferences')
+                        help='check the kernel kconfig file against these preferences')
     parser.add_argument('-m', '--mode', choices=report_modes,
                         help='choose the report mode')
     args = parser.parse_args()
@@ -748,7 +756,7 @@ def main():
 
     if args.config:
         if mode != 'json':
-            print('[+] Config file to check: {}'.format(args.config))
+            print('[+] Kconfig file to check: {}'.format(args.config))
 
         arch, msg = detect_arch(args.config, supported_archs)
         if not arch:
@@ -762,22 +770,29 @@ def main():
         if mode != 'json':
             print('[+] Detected kernel version: {}.{}'.format(kernel_version[0], kernel_version[1]))
 
-        construct_checklist(config_checklist, arch)
-        parsed_options = OrderedDict()
-        parse_config_file(parsed_options, args.config)
-        perform_checks(config_checklist, parsed_options, kernel_version)
+        # add relevant kconfig checks to the checklist
+        add_kconfig_checks(config_checklist, arch)
+
+        # populate the checklist with the parsed kconfig data
+        parsed_kconfig_options = OrderedDict()
+        parse_kconfig_file(parsed_kconfig_options, args.config)
+        populate_with_data(config_checklist, parsed_kconfig_options, kernel_version)
+
+        # now everything is ready for performing the checks
+        perform_checks(config_checklist)
 
+        # finally print the results
         if mode == 'verbose':
-            print_unknown_options(config_checklist, parsed_options)
+            print_unknown_options(config_checklist, parsed_kconfig_options)
         print_checklist(mode, config_checklist, True)
 
         sys.exit(0)
 
     if args.print:
         if mode in ('show_ok', 'show_fail'):
-            sys.exit('[!] ERROR: please use "{}" mode for checking the kernel config'.format(mode))
+            sys.exit('[!] ERROR: wrong mode "{}" for --print'.format(mode))
         arch = args.print
-        construct_checklist(config_checklist, arch)
+        add_kconfig_checks(config_checklist, arch)
         if mode != 'json':
             print('[+] Printing kernel security hardening preferences for {}...'.format(arch))
         print_checklist(mode, config_checklist, False)