mirror of
https://github.com/chipsec/chipsec
synced 2026-06-08 13:31:00 +00:00
Frinzell, Aaron
237 lines
10 KiB
Python
Executable File
237 lines
10 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# CHIPSEC: Platform Security Assessment Framework
|
|
# Copyright (c) 2010-2021, Intel Corporation
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; Version 2.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
#
|
|
# Contact information:
|
|
# chipsec@intel.com
|
|
#
|
|
|
|
|
|
"""
|
|
Standalone utility
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import importlib
|
|
import argparse
|
|
import platform
|
|
|
|
from chipsec.defines import get_version, get_message
|
|
from chipsec.helper import oshelper
|
|
from chipsec.logger import logger
|
|
from chipsec.exceptions import UnknownChipsetError
|
|
from chipsec.testcase import ExitCode
|
|
from chipsec.chipset import cs
|
|
from chipsec.file import get_main_dir
|
|
|
|
logger().UTIL_TRACE = True
|
|
|
|
CMD_OPTS_WIDTH = ['byte', 'word', 'dword']
|
|
|
|
|
|
def is_option_valid_width(width_op):
|
|
return (width_op.lower() in CMD_OPTS_WIDTH)
|
|
|
|
|
|
def get_option_width(width_op):
|
|
width_op = width_op.lower()
|
|
if 'byte' == width_op:
|
|
return 0x1
|
|
elif 'word' == width_op:
|
|
return 0x2
|
|
elif 'dword' == width_op:
|
|
return 0x4
|
|
else:
|
|
return 0x0
|
|
|
|
|
|
class ChipsecUtil:
|
|
|
|
def __init__(self, argv):
|
|
self.global_usage = "All numeric values are in hex\n" + \
|
|
"<width> is in {1, byte, 2, word, 4, dword}\n\n"
|
|
self.commands = {}
|
|
# determine if CHIPSEC is loaded as chipsec_*.exe or in python
|
|
self.CHIPSEC_LOADED_AS_EXE = True if (hasattr(sys, "frozen") or hasattr(sys, "importers")) else False
|
|
# determine if the hosting Python interpreter is a 64-bit executable
|
|
self.PYTHON_64_BITS = True if (sys.maxsize > 2**32) else False
|
|
|
|
self.argv = argv
|
|
self.import_cmds()
|
|
self.parse_args()
|
|
if self._show_banner:
|
|
self.print_banner()
|
|
|
|
def init_cs(self):
|
|
self._cs = cs()
|
|
|
|
def parse_args(self):
|
|
parser = argparse.ArgumentParser(usage='%(prog)s [options] <command>', add_help=False)
|
|
options = parser.add_argument_group('Options')
|
|
options.add_argument('-h', '--help', dest='show_help', help="show this message and exit", action='store_true')
|
|
options.add_argument('-v', '--verbose', help='verbose mode', action='store_true')
|
|
options.add_argument('--hal', help='HAL mode', action='store_true')
|
|
options.add_argument('-d', '--debug', help='debug mode', action='store_true')
|
|
options.add_argument('-vv', '--vverbose', help='very verbose HAL debug mode', action='store_true')
|
|
options.add_argument('-l', '--log', help='output to log file')
|
|
options.add_argument('-p', '--platform', dest='_platform', help='explicitly specify platform code',
|
|
choices=cs().chipset_codes, type=str.upper)
|
|
options.add_argument('--pch', dest='_pch', help='explicitly specify PCH code', choices=cs().pch_codes,
|
|
type=str.upper)
|
|
options.add_argument('-n', '--no_driver', dest='_no_driver', action='store_true',
|
|
help="chipsec won't need kernel mode functions so don't load chipsec driver")
|
|
options.add_argument('-i', '--ignore_platform', dest='_unknownPlatform', action='store_false',
|
|
help='run chipsec even if the platform is not recognized')
|
|
options.add_argument('--helper', dest='_driver_exists', help='specify OS Helper',
|
|
choices=[i for i in oshelper.avail_helpers])
|
|
options.add_argument('_cmd', metavar='Command', nargs='?', choices=sorted(self.commands.keys()), type=str.lower,
|
|
default="help",
|
|
help="Util command to run: {{{}}}".format(','.join(sorted(self.commands.keys()))))
|
|
options.add_argument('_cmd_args', metavar='Command Args', nargs=argparse.REMAINDER, help=self.global_usage)
|
|
options.add_argument('-nb', '--no_banner', dest='_show_banner', action='store_false',
|
|
help="chipsec won't display banner information")
|
|
options.add_argument('--skip_config', dest='_load_config', action='store_false',
|
|
help='skip configuration and driver loading')
|
|
|
|
parser.parse_args(self.argv, namespace=ChipsecUtil)
|
|
if self.show_help or self._cmd == "help":
|
|
parser.print_help()
|
|
if self.verbose:
|
|
logger().VERBOSE = True
|
|
if self.hal:
|
|
logger().HAL = True
|
|
if self.debug:
|
|
logger().DEBUG = True
|
|
if self.vverbose:
|
|
logger().VERBOSE = True
|
|
logger().HAL = True
|
|
logger().DEBUG = True
|
|
if self.log:
|
|
logger().set_log_file(self.log)
|
|
if not self._cmd_args:
|
|
self._cmd_args = ["--help"]
|
|
|
|
def import_cmds(self):
|
|
if self.CHIPSEC_LOADED_AS_EXE:
|
|
import zipfile
|
|
myzip = zipfile.ZipFile(os.path.join(get_main_dir(), "library.zip"))
|
|
cmds = [i.replace('/', '.').replace('chipsec.utilcmd.', '')[:-4] for i in myzip.namelist()
|
|
if 'chipsec/utilcmd/' in i and i[-4:] == ".pyc" and not os.path.basename(i)[:2] == '__']
|
|
else:
|
|
cmds_dir = os.path.join(get_main_dir(), "chipsec", "utilcmd")
|
|
cmds = [i[:-3] for i in os.listdir(cmds_dir) if i[-3:] == ".py" and not i[:2] == "__"]
|
|
|
|
if logger().DEBUG:
|
|
logger().log('[CHIPSEC] Loaded command-line extensions:')
|
|
logger().log(' {}'.format(cmds))
|
|
module = None
|
|
for cmd in cmds:
|
|
try:
|
|
cmd_path = 'chipsec.utilcmd.' + cmd
|
|
module = importlib.import_module(cmd_path)
|
|
cu = getattr(module, 'commands')
|
|
self.commands.update(cu)
|
|
except ImportError as msg:
|
|
# Display the import error and continue to import commands
|
|
logger().log_error("Exception occurred during import of {}: '{}'".format(cmd, str(msg)))
|
|
continue
|
|
self.commands.update({"help": ""})
|
|
|
|
##################################################################################
|
|
# Entry point
|
|
##################################################################################
|
|
|
|
def main(self):
|
|
"""
|
|
Receives and executes the commands
|
|
"""
|
|
|
|
if self.show_help or self._cmd == "help":
|
|
return ExitCode.OK
|
|
|
|
self.init_cs()
|
|
|
|
# @TODO: change later
|
|
# all util cmds assume 'chipsec_util.py' as the first arg so adding dummy first arg
|
|
self.argv = ['dummy'] + [self._cmd] + self._cmd_args
|
|
comm = self.commands[self._cmd](self.argv, cs=self._cs)
|
|
|
|
if self._load_config:
|
|
try:
|
|
self._cs.init(self._platform, self._pch, comm.requires_driver() and not self._no_driver,
|
|
self._driver_exists)
|
|
except UnknownChipsetError as msg:
|
|
logger().log_warning("*******************************************************************")
|
|
logger().log_warning("* Unknown platform!")
|
|
logger().log_warning("* Platform dependent functionality will likely be incorrect")
|
|
logger().log_warning("* Error Message: \"{}\"".format(str(msg)))
|
|
logger().log_warning("*******************************************************************")
|
|
if self._unknownPlatform:
|
|
logger().log_error('To run anyways please use -i command-line option\n\n')
|
|
sys.exit(ExitCode.OK)
|
|
except Exception as msg:
|
|
logger().log_error(str(msg))
|
|
sys.exit(ExitCode.EXCEPTION)
|
|
else:
|
|
if comm.requires_driver():
|
|
logger().log_error("Cannot run without driver loaded")
|
|
sys.exit(ExitCode.OK)
|
|
|
|
if self._show_banner:
|
|
logger().log("[CHIPSEC] Helper : {} ({})".format(*self._cs.helper.helper.get_info()))
|
|
chip_info = "[CHIPSEC] {:8}: {}\n[CHIPSEC] VID: {:04X}\n" \
|
|
"[CHIPSEC] DID: {:04X}\n[CHIPSEC] RID: {:02X}"
|
|
logger().log(chip_info.format("Platform", self._cs.longname, self._cs.vid, self._cs.did, self._cs.rid))
|
|
if not self._cs.is_atom():
|
|
logger().log(chip_info.format("PCH", self._cs.pch_longname, self._cs.pch_vid,
|
|
self._cs.pch_did, self._cs.pch_rid))
|
|
|
|
logger().log("[CHIPSEC] Executing command '{}' with args {}\n".format(self._cmd, self.argv[2:]))
|
|
comm.run()
|
|
if comm.requires_driver() and not self._no_driver:
|
|
self._cs.destroy(True)
|
|
return comm.ExitCode
|
|
|
|
def print_banner(self):
|
|
"""
|
|
Prints chipsec banner
|
|
"""
|
|
logger().log('')
|
|
logger().log("################################################################\n"
|
|
"## ##\n"
|
|
"## CHIPSEC: Platform Hardware Security Assessment Framework ##\n"
|
|
"## ##\n"
|
|
"################################################################")
|
|
logger().log("[CHIPSEC] Version : {}".format(get_version()))
|
|
logger().log("[CHIPSEC] OS : {} {} {} {}".format(platform.system(), platform.release(), platform.version(),
|
|
platform.machine()))
|
|
logger().log("[CHIPSEC] Python : {} ({})".format(platform.python_version(),
|
|
"64-bit" if self.PYTHON_64_BITS else "32-bit"))
|
|
logger().log(get_message())
|
|
|
|
if not self.PYTHON_64_BITS and platform.machine().endswith("64"):
|
|
logger().log_warning("Python architecture (32-bit) is different from OS architecture (64-bit)")
|
|
|
|
|
|
def main(argv=None):
|
|
chipsecUtil = ChipsecUtil(argv if argv else sys.argv[1:])
|
|
return chipsecUtil.main()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|