kernel_hardening_checker/__init__.py

   1 #!/usr/bin/env python3
   2
   3 """
   4 This tool is for checking the security hardening options of the Linux kernel.
   5
   6 Author: Alexander Popov <alex.popov@linux.com>
   7
   8 This module performs input/output.
   9 """
  10
  11 # pylint: disable=missing-function-docstring,line-too-long,too-many-branches,too-many-statements
  12
  13 import os
  14 import gzip
  15 import sys
  16 from argparse import ArgumentParser
  17 from typing import List, Tuple, Dict, TextIO
  18 import re
  19 import json
  20 from .checks import add_kconfig_checks, add_cmdline_checks, normalize_cmdline_options, add_sysctl_checks
  21 from .engine import StrOrNone, TupleOrNone, ChecklistObjType
  22 from .engine import print_unknown_options, populate_with_data, perform_checks, override_expected_value
  23
  24
  25 # kernel-hardening-checker version
  26 __version__ = '0.6.6'
  27
  28
  29 def _open(file: str) -> TextIO:
  30     try:
  31         if file.endswith('.gz'):
  32             return gzip.open(file, 'rt', encoding='utf-8')
  33         return open(file, 'rt', encoding='utf-8')
  34     except FileNotFoundError:
  35         sys.exit(f'[!] ERROR: unable to open {file}, are you sure it exists?')
  36
  37
  38 def detect_arch(fname: str, archs: List[str]) -> Tuple[StrOrNone, str]:
  39     with _open(fname) as f:
  40         arch_pattern = re.compile(r"CONFIG_[a-zA-Z0-9_]+=y$")
  41         arch = None
  42         for line in f.readlines():
  43             if arch_pattern.match(line):
  44                 option, _ = line[7:].split('=', 1)
  45                 if option in archs:
  46                     if arch is None:
  47                         arch = option
  48                     else:
  49                         return None, 'detected more than one microarchitecture'
  50         if arch is None:
  51             return None, 'failed to detect microarchitecture'
  52         return arch, 'OK'
  53
  54
  55 def detect_kernel_version(fname: str) -> Tuple[TupleOrNone, str]:
  56     with _open(fname) as f:
  57         ver_pattern = re.compile(r"^# Linux/.+ Kernel Configuration$|^Linux version .+")
  58         for line in f.readlines():
  59             if ver_pattern.match(line):
  60                 line = line.strip()
  61                 parts = line.split()
  62                 ver_str = parts[2].split('-', 1)[0]
  63                 ver_numbers = ver_str.split('.')
  64                 if len(ver_numbers) >= 3:
  65                     if all(map(lambda x: x.isdecimal(), ver_numbers)):
  66                         return tuple(map(int, ver_numbers)), 'OK'
  67                 msg = f'failed to parse the version "{parts[2]}"'
  68                 return None, msg
  69         return None, 'no kernel version detected'
  70
  71
  72 def detect_compiler(fname: str) -> Tuple[StrOrNone, str]:
  73     gcc_version = None
  74     clang_version = None
  75     with _open(fname) as f:
  76         for line in f.readlines():
  77             if line.startswith('CONFIG_GCC_VERSION='):
  78                 gcc_version = line[19:-1]
  79             if line.startswith('CONFIG_CLANG_VERSION='):
  80                 clang_version = line[21:-1]
  81     if gcc_version is None or clang_version is None:
  82         return None, 'no CONFIG_GCC_VERSION or CONFIG_CLANG_VERSION'
  83     if gcc_version == '0' and clang_version != '0':
  84         return f'CLANG {clang_version}', 'OK'
  85     if gcc_version != '0' and clang_version == '0':
  86         return f'GCC {gcc_version}', 'OK'
  87     sys.exit(f'[!] ERROR: invalid GCC_VERSION and CLANG_VERSION: {gcc_version} {clang_version}')
  88
  89
  90 def print_checklist(mode: StrOrNone, checklist: List[ChecklistObjType], with_results: bool) -> None:
  91     if mode == 'json':
  92         output = []
  93         for opt in checklist:
  94             output.append(opt.json_dump(with_results))
  95         print(json.dumps(output))
  96         return
  97
  98     # table header
  99     sep_line_len = 91
 100     if with_results:
 101         sep_line_len += 30
 102     print('=' * sep_line_len)
 103     print(f'{"option_name":^40}|{"type":^7}|{"desired_val":^12}|{"decision":^10}|{"reason":^18}', end='')
 104     if with_results:
 105         print('| check_result', end='')
 106     print()
 107     print('=' * sep_line_len)
 108
 109     # table contents
 110     ok_count = 0
 111     fail_count = 0
 112     for opt in checklist:
 113         if with_results:
 114             assert(opt.result), f'unexpected empty result of {opt.name} check'
 115             if opt.result.startswith('OK'):
 116                 ok_count += 1
 117                 if mode == 'show_fail':
 118                     continue
 119             else:
 120                 assert(opt.result.startswith('FAIL')), \
 121                        f'unexpected result "{opt.result}" of {opt.name} check'
 122                 fail_count += 1
 123                 if mode == 'show_ok':
 124                     continue
 125         opt.table_print(mode, with_results)
 126         print()
 127         if mode == 'verbose':
 128             print('-' * sep_line_len)
 129     print()
 130
 131     # final score
 132     if with_results:
 133         fail_suppressed = ''
 134         ok_suppressed = ''
 135         if mode == 'show_ok':
 136             fail_suppressed = ' (suppressed in output)'
 137         if mode == 'show_fail':
 138             ok_suppressed = ' (suppressed in output)'
 139         print(f'[+] Config check is finished: \'OK\' - {ok_count}{ok_suppressed} / \'FAIL\' - {fail_count}{fail_suppressed}')
 140
 141
 142 def parse_kconfig_file(_mode: StrOrNone, parsed_options: Dict[str, str], fname: str) -> None:
 143     with _open(fname) as f:
 144         opt_is_on = re.compile(r"CONFIG_[a-zA-Z0-9_]+=.+$")
 145         opt_is_off = re.compile(r"# CONFIG_[a-zA-Z0-9_]+ is not set$")
 146
 147         for line in f.readlines():
 148             line = line.strip()
 149             option = None
 150             value = None
 151
 152             if opt_is_on.match(line):
 153                 option, value = line.split('=', 1)
 154                 if value == 'is not set':
 155                     sys.exit(f'[!] ERROR: bad enabled Kconfig option "{line}"')
 156             elif opt_is_off.match(line):
 157                 option, value = line[2:].split(' ', 1)
 158                 assert(value == 'is not set'), \
 159                        f'unexpected value of disabled Kconfig option "{line}"'
 160             elif line != '' and not line.startswith('#'):
 161                 sys.exit(f'[!] ERROR: unexpected line in Kconfig file: "{line}"')
 162
 163             if option in parsed_options:
 164                 sys.exit(f'[!] ERROR: Kconfig option "{line}" is found multiple times')
 165
 166             if option:
 167                 assert(value), f'unexpected empty value for {option}'
 168                 parsed_options[option] = value
 169
 170
 171 def parse_cmdline_file(mode: StrOrNone, parsed_options: Dict[str, str], fname: str) -> None:
 172     if not os.path.isfile(fname):
 173         sys.exit(f'[!] ERROR: unable to open {fname}, are you sure it exists?')
 174
 175     with open(fname, 'r', encoding='utf-8') as f:
 176         line = f.readline()
 177         if not line:
 178             sys.exit(f'[!] ERROR: empty "{fname}"')
 179
 180         opts = line.split()
 181
 182         line = f.readline()
 183         if line:
 184             sys.exit(f'[!] ERROR: more than one line in "{fname}"')
 185
 186         for opt in opts:
 187             if '=' in opt:
 188                 name, value = opt.split('=', 1)
 189             else:
 190                 name = opt
 191                 value = '' # '' is not None
 192             if name in parsed_options and mode != 'json':
 193                 print(f'[!] WARNING: cmdline option "{name}" is found multiple times')
 194             value = normalize_cmdline_options(name, value)
 195             assert(value is not None), f'unexpected None value for {name}'
 196             parsed_options[name] = value
 197
 198
 199 def parse_sysctl_file(mode: StrOrNone, parsed_options: Dict[str, str], fname: str) -> None:
 200     if not os.path.isfile(fname):
 201         sys.exit(f'[!] ERROR: unable to open {fname}, are you sure it exists?')
 202
 203     with open(fname, 'r', encoding='utf-8') as f:
 204         sysctl_pattern = re.compile(r"[a-zA-Z0-9/\._-]+ =.*$")
 205         for line in f.readlines():
 206             line = line.strip()
 207             if not sysctl_pattern.match(line):
 208                 sys.exit(f'[!] ERROR: unexpected line in sysctl file: "{line}"')
 209             option, value = line.split('=', 1)
 210             option = option.strip()
 211             value = value.strip()
 212             # sysctl options may be found multiple times, let's save the last value:
 213             parsed_options[option] = value
 214
 215     # let's check the presence of some ancient sysctl option
 216     # to ensure that we are parsing the output of `sudo sysctl -a > file`
 217     if 'kernel.printk' not in parsed_options:
 218         sys.exit(f'[!] ERROR: {fname} doesn\'t look like a sysctl output file, please try `sudo sysctl -a > {fname}`')
 219
 220     # let's check the presence of a sysctl option available for root
 221     if 'kernel.cad_pid' not in parsed_options and mode != 'json':
 222         print(f'[!] WARNING: sysctl option "kernel.cad_pid" available for root is not found in {fname}, please try `sudo sysctl -a > {fname}`')
 223
 224
 225 def main() -> None:
 226     # Report modes:
 227     #   * verbose mode for
 228     #     - reporting about unknown kernel options in the Kconfig
 229     #     - verbose printing of ComplexOptCheck items
 230     #   * json mode for printing the results in JSON format
 231     report_modes = ['verbose', 'json', 'show_ok', 'show_fail']
 232     supported_archs = ['X86_64', 'X86_32', 'ARM64', 'ARM']
 233     parser = ArgumentParser(prog='kernel-hardening-checker',
 234                             description='A tool for checking the security hardening options of the Linux kernel')
 235     parser.add_argument('--version', action='version', version=f'%(prog)s {__version__}')
 236     parser.add_argument('-m', '--mode', choices=report_modes,
 237                         help='choose the report mode')
 238     parser.add_argument('-c', '--config',
 239                         help='check the security hardening options in the kernel Kconfig file (also supports *.gz files)')
 240     parser.add_argument('-l', '--cmdline',
 241                         help='check the security hardening options in the kernel cmdline file (contents of /proc/cmdline)')
 242     parser.add_argument('-s', '--sysctl',
 243                         help='check the security hardening options in the sysctl output file (`sudo sysctl -a > file`)')
 244     parser.add_argument('-v', '--kernel-version',
 245                         help='extract the version from the kernel version file (contents of /proc/version)')
 246     parser.add_argument('-p', '--print', choices=supported_archs,
 247                         help='print the security hardening recommendations for the selected microarchitecture')
 248     parser.add_argument('-g', '--generate', choices=supported_archs,
 249                         help='generate a Kconfig fragment with the security hardening options for the selected microarchitecture')
 250     args = parser.parse_args()
 251
 252     mode = None
 253     if args.mode:
 254         mode = args.mode
 255         if mode != 'json':
 256             print(f'[+] Special report mode: {mode}')
 257
 258     config_checklist = [] # type: List[ChecklistObjType]
 259
 260     if args.config:
 261         if args.print:
 262             sys.exit('[!] ERROR: --config and --print can\'t be used together')
 263         if args.generate:
 264             sys.exit('[!] ERROR: --config and --generate can\'t be used together')
 265
 266         if mode != 'json':
 267             print(f'[+] Kconfig file to check: {args.config}')
 268             if args.cmdline:
 269                 print(f'[+] Kernel cmdline file to check: {args.cmdline}')
 270             if args.sysctl:
 271                 print(f'[+] Sysctl output file to check: {args.sysctl}')
 272
 273         arch, msg = detect_arch(args.config, supported_archs)
 274         if arch is None:
 275             sys.exit(f'[!] ERROR: {msg}')
 276         if mode != 'json':
 277             print(f'[+] Detected microarchitecture: {arch}')
 278
 279         if args.kernel_version:
 280             kernel_version, msg = detect_kernel_version(args.kernel_version)
 281         else:
 282             kernel_version, msg = detect_kernel_version(args.config)
 283         if kernel_version is None:
 284             if args.kernel_version is None:
 285                 print('[!] Hint: provide the kernel version file through --kernel-version option')
 286             sys.exit(f'[!] ERROR: {msg}')
 287         if mode != 'json':
 288             print(f'[+] Detected kernel version: {kernel_version}')
 289
 290         compiler, msg = detect_compiler(args.config)
 291         if mode != 'json':
 292             if compiler:
 293                 print(f'[+] Detected compiler: {compiler}')
 294             else:
 295                 print(f'[-] Can\'t detect the compiler: {msg}')
 296
 297         # add relevant Kconfig checks to the checklist
 298         add_kconfig_checks(config_checklist, arch)
 299
 300         if args.cmdline:
 301             # add relevant cmdline checks to the checklist
 302             add_cmdline_checks(config_checklist, arch)
 303
 304         if args.sysctl:
 305             # add relevant sysctl checks to the checklist
 306             add_sysctl_checks(config_checklist, arch)
 307
 308         # populate the checklist with the parsed Kconfig data
 309         parsed_kconfig_options = {} # type: Dict[str, str]
 310         parse_kconfig_file(mode, parsed_kconfig_options, args.config)
 311         populate_with_data(config_checklist, parsed_kconfig_options, 'kconfig')
 312
 313         # populate the checklist with the kernel version data
 314         populate_with_data(config_checklist, kernel_version, 'version')
 315
 316         if args.cmdline:
 317             # populate the checklist with the parsed cmdline data
 318             parsed_cmdline_options = {} # type: Dict[str, str]
 319             parse_cmdline_file(mode, parsed_cmdline_options, args.cmdline)
 320             populate_with_data(config_checklist, parsed_cmdline_options, 'cmdline')
 321
 322         if args.sysctl:
 323             # populate the checklist with the parsed sysctl data
 324             parsed_sysctl_options = {} # type: Dict[str, str]
 325             parse_sysctl_file(mode, parsed_sysctl_options, args.sysctl)
 326             populate_with_data(config_checklist, parsed_sysctl_options, 'sysctl')
 327
 328         # hackish refinement of the CONFIG_ARCH_MMAP_RND_BITS check
 329         mmap_rnd_bits_max = parsed_kconfig_options.get('CONFIG_ARCH_MMAP_RND_BITS_MAX', None)
 330         if mmap_rnd_bits_max:
 331             override_expected_value(config_checklist, 'CONFIG_ARCH_MMAP_RND_BITS', mmap_rnd_bits_max)
 332         else:
 333             # remove the CONFIG_ARCH_MMAP_RND_BITS check to avoid false results
 334             if mode != 'json':
 335                 print('[-] Can\'t check CONFIG_ARCH_MMAP_RND_BITS without CONFIG_ARCH_MMAP_RND_BITS_MAX')
 336             config_checklist[:] = [o for o in config_checklist if o.name != 'CONFIG_ARCH_MMAP_RND_BITS']
 337
 338         # now everything is ready, perform the checks
 339         perform_checks(config_checklist)
 340
 341         if mode == 'verbose':
 342             # print the parsed options without the checks (for debugging)
 343             print_unknown_options(config_checklist, parsed_kconfig_options, 'kconfig')
 344             if args.cmdline:
 345                 print_unknown_options(config_checklist, parsed_cmdline_options, 'cmdline')
 346             if args.sysctl:
 347                 print_unknown_options(config_checklist, parsed_sysctl_options, 'sysctl')
 348
 349         # finally print the results
 350         print_checklist(mode, config_checklist, True)
 351         sys.exit(0)
 352     elif args.cmdline:
 353         sys.exit('[!] ERROR: checking cmdline depends on checking Kconfig')
 354     elif args.sysctl:
 355         # separate sysctl checking (without kconfig)
 356         assert(args.config is None and args.cmdline is None), 'unexpected args'
 357         if args.print:
 358             sys.exit('[!] ERROR: --sysctl and --print can\'t be used together')
 359         if args.generate:
 360             sys.exit('[!] ERROR: --sysctl and --generate can\'t be used together')
 361
 362         if mode != 'json':
 363             print(f'[+] Sysctl output file to check: {args.sysctl}')
 364
 365         # add relevant sysctl checks to the checklist
 366         add_sysctl_checks(config_checklist, None)
 367
 368         # populate the checklist with the parsed sysctl data
 369         parsed_sysctl_options = {}
 370         parse_sysctl_file(mode, parsed_sysctl_options, args.sysctl)
 371         populate_with_data(config_checklist, parsed_sysctl_options, 'sysctl')
 372
 373         # now everything is ready, perform the checks
 374         perform_checks(config_checklist)
 375
 376         if mode == 'verbose':
 377             # print the parsed options without the checks (for debugging)
 378             print_unknown_options(config_checklist, parsed_sysctl_options, 'sysctl')
 379
 380         # finally print the results
 381         print_checklist(mode, config_checklist, True)
 382         sys.exit(0)
 383
 384     if args.print:
 385         assert(args.config is None and args.cmdline is None and args.sysctl is None), 'unexpected args'
 386         if args.generate:
 387             sys.exit('[!] ERROR: --print and --generate can\'t be used together')
 388         if mode and mode not in ('verbose', 'json'):
 389             sys.exit(f'[!] ERROR: wrong mode "{mode}" for --print')
 390         arch = args.print
 391         assert(arch), 'unexpected empty arch from ArgumentParser'
 392         add_kconfig_checks(config_checklist, arch)
 393         add_cmdline_checks(config_checklist, arch)
 394         add_sysctl_checks(config_checklist, arch)
 395         if mode != 'json':
 396             print(f'[+] Printing kernel security hardening options for {arch}...')
 397         print_checklist(mode, config_checklist, False)
 398         sys.exit(0)
 399
 400     if args.generate:
 401         assert(args.config is None and
 402                args.cmdline is None and
 403                args.sysctl is None and
 404                args.print is None), \
 405                'unexpected args'
 406         if mode:
 407             sys.exit(f'[!] ERROR: wrong mode "{mode}" for --generate')
 408         arch = args.generate
 409         assert(arch), 'unexpected empty arch from ArgumentParser'
 410         add_kconfig_checks(config_checklist, arch)
 411         print(f'CONFIG_{arch}=y') # the Kconfig fragment should describe the microarchitecture
 412         for opt in config_checklist:
 413             if opt.name == 'CONFIG_ARCH_MMAP_RND_BITS':
 414                 continue # don't add CONFIG_ARCH_MMAP_RND_BITS because its value needs refinement
 415             if opt.expected == 'is not off':
 416                 continue # don't add Kconfig options without explicitly recommended values
 417             if opt.expected == 'is not set':
 418                 print(f'# {opt.name} is not set')
 419             else:
 420                 print(f'{opt.name}={opt.expected}')
 421         sys.exit(0)
 422
 423     parser.print_help()
 424     sys.exit(0)