X-Git-Url: https://jxself.org/git/?a=blobdiff_plain;f=kconfig_hardened_check%2F__init__.py;h=565503e2f5e77bc881e4972db90903cf25713ed5;hb=aa073c2c186a1257fea935d8ecd54adf88775d6f;hp=3361bde35d7851a8b35f5ccc8001a64686eed3bd;hpb=b9c72b3ed10f6b89ff40ed892cc1a8082dfd1c3b;p=kconfig-hardened-check.git diff --git a/kconfig_hardened_check/__init__.py b/kconfig_hardened_check/__init__.py index 3361bde..565503e 100644 --- a/kconfig_hardened_check/__init__.py +++ b/kconfig_hardened_check/__init__.py @@ -14,6 +14,8 @@ # slab_nomerge # page_alloc.shuffle=1 # iommu=force (does it help against DMA attacks?) +# iommu.passthrough=0 +# iommu.strict=1 # slub_debug=FZ (slow) # init_on_alloc=1 (since v5.3) # init_on_free=1 (since v5.3, otherwise slub_debug=P and page_poison=1) @@ -38,8 +40,11 @@ # # Should NOT be set: # nokaslr +# rodata=off +# sysrq_always_enabled # arm64.nobti # arm64.nopauth +# arm64.nomte # # Hardware tag-based KASAN with arm64 Memory Tagging Extension (MTE): # kasan=on @@ -56,11 +61,9 @@ # what about bpf_jit_enable? # kernel.unprivileged_bpf_disabled=1 # net.core.bpf_jit_harden=2 -# # vm.unprivileged_userfaultfd=0 # (at first, it disabled unprivileged userfaultfd, # and since v5.11 it enables unprivileged userfaultfd for user-mode only) -# # dev.tty.ldisc_autoload=0 # fs.protected_symlinks=1 # fs.protected_hardlinks=1 @@ -68,6 +71,7 @@ # fs.protected_regular=2 # fs.suid_dumpable=0 # kernel.modules_disabled=1 +# kernel.randomize_va_space = 2 # pylint: disable=missing-module-docstring,missing-class-docstring,missing-function-docstring @@ -81,10 +85,13 @@ import re import json from .__about__ import __version__ -TYPES_OF_CHECKS = ('kconfig', 'version') +SIMPLE_OPTION_TYPES = ('kconfig', 'version', 'cmdline') class OptCheck: - def __init__(self, reason, decision, name, expected): + # Constructor without the 'expected' parameter is for option presence checks (any value is OK) + def __init__(self, reason, decision, name, expected=None): + if not reason or not decision or not name: + sys.exit('[!] ERROR: invalid {} check for "{}"'.format(self.__class__.__name__, name)) self.name = name self.expected = expected self.decision = decision @@ -92,7 +99,20 @@ class OptCheck: self.state = None self.result = None + @property + def type(self): + return None + def check(self): + # handle the option presence check + if self.expected is None: + if self.state is None: + self.result = 'FAIL: not present' + else: + self.result = 'OK: is present' + return + + # handle the option value check if self.expected == self.state: self.result = 'OK' elif self.state is None: @@ -103,15 +123,21 @@ class OptCheck: else: self.result = 'FAIL: "' + self.state + '"' - if self.result.startswith('OK'): - return True - return False - def table_print(self, _mode, with_results): - print('{:<40}|{:^7}|{:^12}|{:^10}|{:^18}'.format(self.name, self.type, self.expected, self.decision, self.reason), end='') + if self.expected is None: + expected = '' + else: + expected = self.expected + print('{:<40}|{:^7}|{:^12}|{:^10}|{:^18}'.format(self.name, self.type, expected, self.decision, self.reason), end='') if with_results: print('| {}'.format(self.result), end='') + def json_dump(self, with_results): + dump = [self.name, self.type, self.expected, self.decision, self.reason] + if with_results: + dump.append(self.result) + return dump + class KconfigCheck(OptCheck): def __init__(self, *args, **kwargs): @@ -122,11 +148,11 @@ class KconfigCheck(OptCheck): def type(self): return 'kconfig' - def json_dump(self, with_results): - dump = [self.name, self.type, self.expected, self.decision, self.reason] - if with_results: - dump.append(self.result) - return dump + +class CmdlineCheck(OptCheck): + @property + def type(self): + return 'cmdline' class VersionCheck: @@ -142,15 +168,14 @@ class VersionCheck: def check(self): if self.ver[0] > self.ver_expected[0]: self.result = 'OK: version >= ' + str(self.ver_expected[0]) + '.' + str(self.ver_expected[1]) - return True + return if self.ver[0] < self.ver_expected[0]: self.result = 'FAIL: version < ' + str(self.ver_expected[0]) + '.' + str(self.ver_expected[1]) - return False + return if self.ver[1] >= self.ver_expected[1]: self.result = 'OK: version >= ' + str(self.ver_expected[0]) + '.' + str(self.ver_expected[1]) - return True + return self.result = 'FAIL: version < ' + str(self.ver_expected[0]) + '.' + str(self.ver_expected[1]) - return False def table_print(self, _mode, with_results): ver_req = 'kernel version >= ' + str(self.ver_expected[0]) + '.' + str(self.ver_expected[1]) @@ -159,29 +184,6 @@ class VersionCheck: print('| {}'.format(self.result), end='') -class PresenceCheck: - def __init__(self, name, type): - self.type = type - if self.type == 'kconfig': - self.name = 'CONFIG_' + name - else: - sys.exit('[!] ERROR: unsupported type "{}" for {}'.format(type, self.__class__.__name__)) - self.state = None - self.result = None - - def check(self): - if self.state is None: - self.result = 'FAIL: not present' - return False - self.result = 'OK: is present' - return True - - def table_print(self, _mode, with_results): - print('{:<91}'.format(self.name + ' is present'), end='') - if with_results: - print('| {}'.format(self.result), end='') - - class ComplexOptCheck: def __init__(self, *opts): self.opts = opts @@ -189,7 +191,7 @@ class ComplexOptCheck: sys.exit('[!] ERROR: empty {} check'.format(self.__class__.__name__)) if len(self.opts) == 1: sys.exit('[!] ERROR: useless {} check'.format(self.__class__.__name__)) - if not isinstance(opts[0], KconfigCheck): + if not isinstance(opts[0], KconfigCheck) and not isinstance(opts[0], CmdlineCheck): sys.exit('[!] ERROR: invalid {} check: {}'.format(self.__class__.__name__, opts)) self.result = None @@ -239,22 +241,26 @@ class OR(ComplexOptCheck): # Use cases: # OR(, ) # OR(, ) - def check(self): if not self.opts: sys.exit('[!] ERROR: invalid OR check') - for i, opt in enumerate(self.opts): - ret = opt.check() - if ret: - if opt.result == 'OK' and i != 0: - # Simple OK is not enough for additional checks, add more info: - self.result = 'OK: {} "{}"'.format(opt.name, opt.expected) - else: - self.result = opt.result - return True + opt.check() + if opt.result.startswith('OK'): + self.result = opt.result + # Add more info for additional checks: + if i != 0: + if opt.result == 'OK': + self.result = 'OK: {} "{}"'.format(opt.name, opt.expected) + elif opt.result == 'OK: not found': + self.result = 'OK: {} not found'.format(opt.name) + elif opt.result == 'OK: is present': + self.result = 'OK: {} is present'.format(opt.name) + # VersionCheck provides enough info + elif not opt.result.startswith('OK: version'): + sys.exit('[!] ERROR: unexpected OK description "{}"'.format(opt.result)) + return self.result = self.opts[0].result - return False class AND(ComplexOptCheck): @@ -263,14 +269,13 @@ class AND(ComplexOptCheck): # AND(, ) # Suboption is not checked if checking of the main_option is failed. # AND(, ) - def check(self): for i, opt in reversed(list(enumerate(self.opts))): - ret = opt.check() + opt.check() if i == 0: self.result = opt.result - return ret - if not ret: + return + if not opt.result.startswith('OK'): # This FAIL is caused by additional checks, # and not by the main option that this AND-check is about. # Describe the reason of the FAIL. @@ -279,10 +284,11 @@ class AND(ComplexOptCheck): elif opt.result == 'FAIL: not present': self.result = 'FAIL: {} not present'.format(opt.name) else: - # This FAIL message is self-explaining. + # VersionCheck provides enough info self.result = opt.result - return False - + if not opt.result.startswith('FAIL: version'): + sys.exit('[!] ERROR: unexpected FAIL description "{}"'.format(opt.result)) + return sys.exit('[!] ERROR: invalid AND check') @@ -325,12 +331,15 @@ def add_kconfig_checks(l, arch): modules_not_set = KconfigCheck('cut_attack_surface', 'kspp', 'MODULES', 'is not set') devmem_not_set = KconfigCheck('cut_attack_surface', 'kspp', 'DEVMEM', 'is not set') # refers to LOCKDOWN + bpf_syscall_not_set = KconfigCheck('cut_attack_surface', 'lockdown', 'BPF_SYSCALL', 'is not set') # refers to LOCKDOWN efi_not_set = KconfigCheck('cut_attack_surface', 'my', 'EFI', 'is not set') # 'self_protection', 'defconfig' l += [KconfigCheck('self_protection', 'defconfig', 'BUG', 'y')] l += [KconfigCheck('self_protection', 'defconfig', 'SLUB_DEBUG', 'y')] l += [KconfigCheck('self_protection', 'defconfig', 'GCC_PLUGINS', 'y')] + l += [OR(KconfigCheck('self_protection', 'defconfig', 'STACKPROTECTOR', 'y'), + KconfigCheck('self_protection', 'defconfig', 'CC_STACKPROTECTOR', 'y'))] l += [OR(KconfigCheck('self_protection', 'defconfig', 'STACKPROTECTOR_STRONG', 'y'), KconfigCheck('self_protection', 'defconfig', 'CC_STACKPROTECTOR_STRONG', 'y'))] l += [OR(KconfigCheck('self_protection', 'defconfig', 'STRICT_KERNEL_RWX', 'y'), @@ -377,6 +386,7 @@ def add_kconfig_checks(l, arch): VersionCheck((5, 10)))] # HARDEN_BRANCH_PREDICTOR is enabled by default since v5.10 l += [KconfigCheck('self_protection', 'defconfig', 'MITIGATE_SPECTRE_BRANCH_HISTORY', 'y')] l += [KconfigCheck('self_protection', 'defconfig', 'ARM64_MTE', 'y')] + l += [KconfigCheck('self_protection', 'defconfig', 'RANDOMIZE_MODULE_REGION_FULL', 'y')] if arch == 'ARM': l += [KconfigCheck('self_protection', 'defconfig', 'CPU_SW_DOMAIN_PAN', 'y')] l += [KconfigCheck('self_protection', 'defconfig', 'HARDEN_BRANCH_PREDICTOR', 'y')] @@ -397,6 +407,10 @@ def add_kconfig_checks(l, arch): l += [KconfigCheck('self_protection', 'kspp', 'DEBUG_NOTIFIERS', 'y')] l += [KconfigCheck('self_protection', 'kspp', 'INIT_ON_ALLOC_DEFAULT_ON', 'y')] l += [KconfigCheck('self_protection', 'kspp', 'GCC_PLUGIN_LATENT_ENTROPY', 'y')] + l += [KconfigCheck('self_protection', 'kspp', 'KFENCE', 'y')] + l += [KconfigCheck('self_protection', 'kspp', 'WERROR', 'y')] + l += [KconfigCheck('self_protection', 'kspp', 'IOMMU_DEFAULT_DMA_STRICT', 'y')] + l += [KconfigCheck('self_protection', 'kspp', 'ZERO_CALL_USED_REGS', 'y')] randstruct_is_set = KconfigCheck('self_protection', 'kspp', 'GCC_PLUGIN_RANDSTRUCT', 'y') l += [randstruct_is_set] hardened_usercopy_is_set = KconfigCheck('self_protection', 'kspp', 'HARDENED_USERCOPY', 'y') @@ -427,6 +441,7 @@ def add_kconfig_checks(l, arch): l += [stackleak_is_set] l += [KconfigCheck('self_protection', 'kspp', 'RANDOMIZE_KSTACK_OFFSET_DEFAULT', 'y')] if arch in ('X86_64', 'X86_32'): + l += [KconfigCheck('self_protection', 'kspp', 'SCHED_CORE', 'y')] l += [KconfigCheck('self_protection', 'kspp', 'DEFAULT_MMAP_MIN_ADDR', '65536')] if arch in ('ARM64', 'ARM'): l += [KconfigCheck('self_protection', 'kspp', 'DEFAULT_MMAP_MIN_ADDR', '32768')] @@ -493,11 +508,11 @@ def add_kconfig_checks(l, arch): if arch == 'ARM': l += [KconfigCheck('security_policy', 'kspp', 'SECURITY', 'y')] # and choose your favourite LSM l += [KconfigCheck('security_policy', 'kspp', 'SECURITY_YAMA', 'y')] - l += [OR(KconfigCheck('security_policy', 'my', 'SECURITY_WRITABLE_HOOKS', 'is not set'), - KconfigCheck('security_policy', 'kspp', 'SECURITY_SELINUX_DISABLE', 'is not set'))] + l += [KconfigCheck('security_policy', 'kspp', 'SECURITY_SELINUX_DISABLE', 'is not set')] l += [KconfigCheck('security_policy', 'clipos', 'SECURITY_LOCKDOWN_LSM', 'y')] l += [KconfigCheck('security_policy', 'clipos', 'SECURITY_LOCKDOWN_LSM_EARLY', 'y')] l += [KconfigCheck('security_policy', 'clipos', 'LOCK_DOWN_KERNEL_FORCE_CONFIDENTIALITY', 'y')] + l += [KconfigCheck('security_policy', 'my', 'SECURITY_WRITABLE_HOOKS', 'is not set')] # refers to SECURITY_SELINUX_DISABLE l += [KconfigCheck('security_policy', 'my', 'SECURITY_SAFESETID', 'y')] loadpin_is_set = KconfigCheck('security_policy', 'my', 'SECURITY_LOADPIN', 'y') l += [loadpin_is_set] # needs userspace support @@ -505,7 +520,8 @@ def add_kconfig_checks(l, arch): loadpin_is_set)] # 'cut_attack_surface', 'defconfig' - l += [KconfigCheck('cut_attack_surface', 'defconfig', 'BPF_UNPRIV_DEFAULT_OFF', 'y')] # see unprivileged_bpf_disabled + l += [OR(KconfigCheck('cut_attack_surface', 'defconfig', 'BPF_UNPRIV_DEFAULT_OFF', 'y'), + bpf_syscall_not_set)] # see unprivileged_bpf_disabled l += [KconfigCheck('cut_attack_surface', 'defconfig', 'SECCOMP', 'y')] l += [KconfigCheck('cut_attack_surface', 'defconfig', 'SECCOMP_FILTER', 'y')] if arch in ('X86_64', 'ARM64', 'X86_32'): @@ -527,6 +543,7 @@ def add_kconfig_checks(l, arch): l += [KconfigCheck('cut_attack_surface', 'kspp', 'X86_X32', 'is not set')] l += [KconfigCheck('cut_attack_surface', 'kspp', 'MODIFY_LDT_SYSCALL', 'is not set')] l += [KconfigCheck('cut_attack_surface', 'kspp', 'OABI_COMPAT', 'is not set')] + l += [KconfigCheck('cut_attack_surface', 'kspp', 'X86_MSR', 'is not set')] # refers to LOCKDOWN l += [modules_not_set] l += [devmem_not_set] l += [OR(KconfigCheck('cut_attack_surface', 'kspp', 'IO_STRICT_DEVMEM', 'y'), @@ -583,6 +600,7 @@ def add_kconfig_checks(l, arch): l += [KconfigCheck('cut_attack_surface', 'maintainer', 'FB', 'is not set')] # recommended by Daniel Vetter in /issues/38 l += [KconfigCheck('cut_attack_surface', 'maintainer', 'VT', 'is not set')] # recommended by Daniel Vetter in /issues/38 l += [KconfigCheck('cut_attack_surface', 'maintainer', 'BLK_DEV_FD', 'is not set')] # recommended by Denis Efremov in /pull/54 + l += [KconfigCheck('cut_attack_surface', 'maintainer', 'BLK_DEV_FD_RAWCMD', 'is not set')] # recommended by Denis Efremov in /pull/62 # 'cut_attack_surface', 'grapheneos' l += [KconfigCheck('cut_attack_surface', 'grapheneos', 'AIO', 'is not set')] @@ -596,19 +614,18 @@ def add_kconfig_checks(l, arch): l += [KconfigCheck('cut_attack_surface', 'clipos', 'MAGIC_SYSRQ', 'is not set')] l += [KconfigCheck('cut_attack_surface', 'clipos', 'KEXEC_FILE', 'is not set')] # refers to LOCKDOWN (permissive) l += [KconfigCheck('cut_attack_surface', 'clipos', 'USER_NS', 'is not set')] # user.max_user_namespaces=0 - l += [KconfigCheck('cut_attack_surface', 'clipos', 'X86_MSR', 'is not set')] # refers to LOCKDOWN l += [KconfigCheck('cut_attack_surface', 'clipos', 'X86_CPUID', 'is not set')] l += [KconfigCheck('cut_attack_surface', 'clipos', 'X86_IOPL_IOPERM', 'is not set')] # refers to LOCKDOWN l += [KconfigCheck('cut_attack_surface', 'clipos', 'ACPI_TABLE_UPGRADE', 'is not set')] # refers to LOCKDOWN l += [KconfigCheck('cut_attack_surface', 'clipos', 'EFI_CUSTOM_SSDT_OVERLAYS', 'is not set')] l += [AND(KconfigCheck('cut_attack_surface', 'clipos', 'LDISC_AUTOLOAD', 'is not set'), - PresenceCheck('LDISC_AUTOLOAD', 'kconfig'))] + KconfigCheck('cut_attack_surface', 'clipos', 'LDISC_AUTOLOAD'))] # option presence check if arch in ('X86_64', 'X86_32'): l += [KconfigCheck('cut_attack_surface', 'clipos', 'X86_INTEL_TSX_MODE_OFF', 'y')] # tsx=off # 'cut_attack_surface', 'lockdown' + l += [bpf_syscall_not_set] # refers to LOCKDOWN l += [KconfigCheck('cut_attack_surface', 'lockdown', 'EFI_TEST', 'is not set')] # refers to LOCKDOWN - l += [KconfigCheck('cut_attack_surface', 'lockdown', 'BPF_SYSCALL', 'is not set')] # refers to LOCKDOWN l += [KconfigCheck('cut_attack_surface', 'lockdown', 'MMIOTRACE_TEST', 'is not set')] # refers to LOCKDOWN l += [KconfigCheck('cut_attack_surface', 'lockdown', 'KPROBES', 'is not set')] # refers to LOCKDOWN @@ -622,14 +639,13 @@ def add_kconfig_checks(l, arch): l += [KconfigCheck('cut_attack_surface', 'my', 'FTRACE', 'is not set')] # refers to LOCKDOWN l += [KconfigCheck('cut_attack_surface', 'my', 'VIDEO_VIVID', 'is not set')] l += [KconfigCheck('cut_attack_surface', 'my', 'INPUT_EVBUG', 'is not set')] # Can be used as a keylogger + l += [KconfigCheck('cut_attack_surface', 'my', 'KGDB', 'is not set')] # 'harden_userspace' if arch in ('X86_64', 'ARM64', 'X86_32'): l += [KconfigCheck('harden_userspace', 'defconfig', 'INTEGRITY', 'y')] if arch == 'ARM': l += [KconfigCheck('harden_userspace', 'my', 'INTEGRITY', 'y')] - if arch == 'ARM64': - l += [KconfigCheck('harden_userspace', 'defconfig', 'ARM64_MTE', 'y')] if arch in ('ARM', 'X86_32'): l += [KconfigCheck('harden_userspace', 'defconfig', 'VMSPLIT_3G', 'y')] if arch in ('X86_64', 'ARM64'): @@ -640,6 +656,14 @@ def add_kconfig_checks(l, arch): # l += [KconfigCheck('feature_test', 'my', 'LKDTM', 'm')] # only for debugging! +def add_cmdline_checks(l, arch): + # Calling the CmdlineCheck class constructor: + # CmdlineCheck(reason, decision, name, expected) + + l += [CmdlineCheck('self_protection', 'kspp', 'randomize_kstack_offset', 'on')] + # TODO: add other + + def print_unknown_options(checklist, parsed_options): known_options = [] @@ -714,16 +738,20 @@ def print_checklist(mode, checklist, with_results): def populate_simple_opt_with_data(opt, data, data_type): if opt.type == 'complex': sys.exit('[!] ERROR: unexpected ComplexOptCheck {}: {}'.format(opt.name, vars(opt))) - if data_type not in TYPES_OF_CHECKS: + if opt.type not in SIMPLE_OPTION_TYPES: + sys.exit('[!] ERROR: invalid opt type "{}" for {}'.format(opt.type, opt.name)) + if data_type not in SIMPLE_OPTION_TYPES: sys.exit('[!] ERROR: invalid data type "{}"'.format(data_type)) if data_type != opt.type: return - if data_type == 'kconfig': + if data_type in ('kconfig', 'cmdline'): opt.state = data.get(opt.name, None) elif data_type == 'version': opt.ver = data + else: + sys.exit('[!] ERROR: unexpected data type "{}"'.format(data_type)) def populate_opt_with_data(opt, data, data_type): @@ -735,7 +763,7 @@ def populate_opt_with_data(opt, data, data_type): else: populate_simple_opt_with_data(o, data, data_type) else: - if opt.type != 'kconfig': + if opt.type not in ('kconfig', 'cmdline'): sys.exit('[!] ERROR: bad type "{}" for a simple check {}'.format(opt.type, opt.name)) populate_simple_opt_with_data(opt, data, data_type) @@ -773,7 +801,12 @@ def parse_kconfig_file(parsed_options, fname): if option: parsed_options[option] = value - return parsed_options + +def parse_cmdline_file(parsed_options, fname): + with open(fname, 'r') as f: + print('FIXME! cmdline file:') + for line in f.readlines(): + print(line) def main(): @@ -791,6 +824,8 @@ def main(): help='print security hardening preferences for the selected architecture') parser.add_argument('-c', '--config', help='check the kernel kconfig file against these preferences') + parser.add_argument('-l', '--cmdline', + help='check the kernel cmdline file against these preferences') parser.add_argument('-m', '--mode', choices=report_modes, help='choose the report mode') args = parser.parse_args() @@ -806,6 +841,8 @@ def main(): if args.config: if mode != 'json': print('[+] Kconfig file to check: {}'.format(args.config)) + if args.cmdline: + print('[+] Kernel cmdline file to check: {}'.format(args.cmdline)) arch, msg = detect_arch(args.config, supported_archs) if not arch: @@ -828,6 +865,15 @@ def main(): populate_with_data(config_checklist, parsed_kconfig_options, 'kconfig') populate_with_data(config_checklist, kernel_version, 'version') + if args.cmdline: + # add relevant cmdline checks to the checklist + add_cmdline_checks(config_checklist, arch) + + # populate the checklist with the parsed kconfig data + parsed_cmdline_options = OrderedDict() + parse_cmdline_file(parsed_cmdline_options, args.cmdline) + populate_with_data(config_checklist, parsed_cmdline_options, 'cmdline') + # now everything is ready for performing the checks perform_checks(config_checklist) @@ -837,12 +883,15 @@ def main(): print_checklist(mode, config_checklist, True) sys.exit(0) + elif args.cmdline: + sys.exit('[!] ERROR: checking cmdline doesn\'t work without checking kconfig') if args.print: if mode in ('show_ok', 'show_fail'): sys.exit('[!] ERROR: wrong mode "{}" for --print'.format(mode)) arch = args.print add_kconfig_checks(config_checklist, arch) + add_cmdline_checks(config_checklist, arch) if mode != 'json': print('[+] Printing kernel security hardening preferences for {}...'.format(arch)) print_checklist(mode, config_checklist, False)