path: root/pym/kernelcheck/kernelcheck.py

#!/usr/bin/env python
# kernel-check -- Gentoo Kernel Security
# Copyright 2009-2009 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2

from portage.output import blue, bold, colorize, EOutput, darkgreen #FIXME

try:
    from _emerge.userquery import userquery
    from _emerge.stdout_spinner import stdout_spinner
except ImportError:
    from _emerge import userquery #FIXME proper checking without except
    from _emerge import stdout_spinner

import getopt
import portage
import sys
import textwrap
import os

import lib.kernellib as lib

info = EOutput().einfo #FIXME
warn = EOutput().ewarn
error = EOutput().eerror
spin = stdout_spinner()

def main(argv):
    'Main function'

    try:
        opts, args = getopt.gnu_getopt(argv, 'dhnr:sv',
        ['debug', 'help', 'nocolor', 'report=', 'sync', 'verbose'])
    except getopt.GetoptError:
        usage()
        return

    for opt, arg in opts:
        if opt in ('-d', '--debug'):
            lib.DEBUG = True
        elif opt in ('-h', '--help'):
            usage()
            return
        elif opt in ('-n', '--nocolor'):
            portage.output.nocolor()
        elif opt in ('-r', '--report'):
            error('--report not yet implemented')
            return
        elif opt in ('-s', '--sync'):
            os.system('%s%s' % ('rsync -avz rsync://rbu.sh/gentoo-kernel ',
                                '/usr/portage/metadata/kernel'))
            return
        elif opt in ('-v', '--verbose'):
            lib.VERBOSE = True

    for arg in argv:
        if lib.REGEX['argument'].match(arg):
            if 'cve' in arg.lower():
                vul = lib.find_cve(arg, lib.DIR['out'])
                if not vul:
                    print_bug(arg) #FIXME
                else:
                    print_bug(vul.bugid)
            else:
                print_bug(arg)
            return

    information = dict()

    print('')
    print(darkgreen('These are the specifications of your kernel:'))
    print('')

    uname = os.uname()
    if uname[0] != 'Linux':
        error('This tool currently only works for Linux kernels.')
        error('Apparantly you are using "%s".' % uname[0]) #TODO
        return

    kernel = lib.extract_version(uname[2])
    if kernel is None:
        error('No kernel information found!')
        return

    arch = portage.settings['ARCH']
    if not arch:
        arch = '?' #FIXME

    kernel.genpatch = lib.get_genpatch(lib.PORTDIR, kernel)
    if not kernel.genpatch:
        genpatch = ''
    else:
        genpatch = '%s %s (%s)' % ('genpatch', kernel.genpatch.version,
                                   repr(kernel.genpatch))

    information = {
        'Kernel source'  : kernel.source,
        'Kernel version' : '%s-%s' % (kernel.version, kernel.revision),
        'Kernel patches' : genpatch,
        'Architecture'   : arch
    }
    print_items(information, 'Information')

    print('')
    print_items(lib.gather_configuration(), 'Configuration')

    print('\nDetermining vulnerabilities... done!') #TODO #spin
    print('')

    evaluation = lib.eval_cve_files(lib.DIR['out'], kernel, arch, None)
    if not evaluation:
        error('No kernel vulnerability files found!')
        return

    if len(evaluation.affected) is not 0:
        print_summary(evaluation.affected)

        print('Total: %s vulnerabilities (%s), Average CVSS score: %.1f\n' % (
              len(evaluation.affected), repr(evaluation), evaluation.avg_cvss))

        prompt = "Would you like to upgrade your kernel?"
        if userquery(prompt, None) == 'No':
            print('')
            print('Quitting.')
            print('')

        else:
            print('Not implemented yet...')

    else:
        print('Total: 0 vulnerabilities, Average CVSS score: 0.0\n')
        print(bold('Your kernel is not affected by any known vulnerability!'))


def print_items(category, header):
    'Indents and prints items'

    screenwidth = 120
    if portage.output.get_term_size()[1] < screenwidth:
        screenwidth = portage.output.get_term_size()[1]

    info(bold('%s:' % header))
    for item in category.keys():
        for i, string in enumerate(textwrap.wrap('%s' % category[item],
                                                 (screenwidth - 23))):
            if i is 0:
                print('%s%s%s : %s' % (' ' * 6, darkgreen(item),
                                       ' ' * (14 - len(item)), string))
            else:
                print('%s%s' % (' ' * 23, string))


def print_summary(vullist):
    'Prints the vulnerability summary'

    for item in vullist:
        if item.cves:
            for cve in item.cves:
                cvetype = str()
                if 'AV:L' in cve.vector:
                    cvetype += colorize('BAD', 'local')

                if 'AV:A' in cve.vector or 'AV:N' in cve.vector:
                    cvetype += colorize('BAD', 'network')

                if ('C:P' in cve.vector or 'C:C' in cve.vector)               \
                and ('I:P' in cve.vector or 'I:C' in cve.vector)              \
                and ('A:P' in cve.vector or 'A:C' in cve.vector):
                    cvetype += '%s%s' % (' ', blue('-complete'))
                else:
                    if 'C:P' in cve.vector or 'C:C' in cve.vector:
                        cvetype += '%s%s' % (' ', blue('-confidentiality'))

                    if 'I:P' in cve.vector or 'I:C' in cve.vector:
                        cvetype += '%s%s' % (' ', blue('-integrity'))

                    if 'A:P' in cve.vector or 'A:C' in cve.vector:
                        cvetype += '%s%s' % (' ', blue('-availability'))

                print ('[%s %26s] %s %s TYPE="%s"') % (darkgreen('bugid'),
                      colorize('GOOD', item.bugid), darkgreen(cve.cve),
                      blue('[%s]' % cve.score), cvetype)

    print('')


def print_bug(bugid):
    'Prints information about a particular bugid'

    if 'cve' in bugid.lower():
        print_cve(bugid.upper())
        return

    vul = lib.read_cve_file(lib.DIR['out'], bugid)

    if vul is None:
        error('Could not find bugid: %s' % bugid)
        return

    buginformation = {
        'Status'       : vul.status.capitalize(),
        'Reporter'     : vul.reporter,
        'Reported'     : vul.reported[:-11],
        'Affected'     : vul.affected,
        'Architecture' : vul.arch.capitalize()
    }

    print('')
    print_items(buginformation, 'Bugid %s' % bugid)

    for cve in vul.cves:
        print_cve(cve.cve)


def print_cve(cveid):
    'Prints information about a cve'

    cve = lib.Cve(cveid)
    vul = lib.find_cve(cveid, lib.DIR['out']) #FIXME
    if vul is None:
        error('Could not find cve: %s' % cveid)
        return
    else:
        for item in vul.cves:
            if item.cve == cveid:
                cve = item

    cveinformation = {
        'Published'   : cve.published,
        'Severity'    : cve.severity,
        'Score'       : cve.score,
        'Vector'      : cve.vector,
        'Description' : cve.desc,
    }
    #TODO print cve.refs

    print('')
    print_items(cveinformation, cve.cve)


def print_information():
    'Prints an information message'

    info('To print more information about a vulnerability try:')
    info('   $ %s [BUGID|CVE]' % sys.argv[0])


def usage():
    'Prints the usage screen'

    print('Usage: kernel-check [BUGID|CVE] [OPTION]...')
    print('Gentoo Kernel Security %s\n' % lib.VERSION)
    print('  -d, --debug          display debugging information')
    print('  -h, --help           display help information')
    print('  -n, --nocolor        disable colors')
    print('  -r, --report [file]  create a security report')
    print('  -s, --sync           receive the latest vulnerabilities')
    print('  -v, --verbose        display additional information')


if __name__ == '__main__':
    main(sys.argv[1:])