def _chipsec_cs(self, arg, helper_class=mock_helper.TestHelper, platform=None, pch=None): """Run the chipsec chipset commands Each test may setup a virtual helper to emulate the expected behaviour from the hardware. If no helper is provided, TestHelper will be used. It verifies that no error is being reported. self.log will be populated with the output. """ _cs = chipset.cs() _cs.helper.helper = helper_class() _cs.init_xml_configuration() logger.logger().HAL = True logger.logger().VERBOSE = True logger.logger().set_log_file(self.log_file) try: _cs.init(platform, pch, True) ret = getattr(_cs, arg.split()[0])() finally: logger.logger().close() with open(self.log_file, 'rb') as log: self.log = log.read() return ret
def Run(self, args): self.logs = [] self.chipsec_log = StringIO.StringIO() if args.logging: self.logs.append("Dumping %s" % args.table_signature) logger.logger().logfile = self.chipsec_log logger.logger().LOG_TO_FILE = True # Wrap most of Chipsec code to gather its logs in case of failure. try: # Initialise Chipsec (die early if unknown chipset) c = chipset.cs() # Platform = None, Start Driver = False c.init(None, False) a = acpi.ACPI(c) acpi_tables_raw = a.get_ACPI_table(args.table_signature) acpi_tables = [] for i, table_address in enumerate( a.tableList[args.table_signature]): table_header, table_content = acpi_tables_raw[i] table_blob = table_header + table_content acpi_tables.append( rdf_chipsec_types.ACPITableData( table_address=table_address, table_blob=table_blob)) except (chipset.UnknownChipsetError, OSError) as err: # Expected errors that might happen on the client # If the chipset is unknown or we encountered an error due to reading # an area we do not have access to using /dev/mem, simply return an # error message. if args.logging: self.LogError(err) self.SendReply( rdf_chipsec_types.DumpACPITableResponse(logs=["%s" % err], )) return except Exception as err: # pylint: disable=broad-except # In case an exception is raised, if the verbose mode # is enabled, return the raw logs from Chipsec. if args.logging: self.LogError(err) raise if not acpi_tables: self.logs.append("No ACPI table with signature %s." % args.table_signature) else: self.logs.append( "ACPI table with signature %s has been successfully dumped." % args.table_signature) if args.logging: self.logs.extend(self.chipsec_log.getvalue().splitlines()) self.SendReply( rdf_chipsec_types.DumpACPITableResponse(acpi_tables=acpi_tables, logs=self.logs))
def __init__(self, argv): self.VERBOSE = False self.CHIPSEC_FOLDER = os.path.abspath(chipsec.file.get_main_dir()) self.CHIPSEC_LOADED_AS_EXE = chipsec.file.main_is_frozen() self.USER_MODULE_TAGS = [] self.ZIP_MODULES_RE = None self.Import_Path = "chipsec.modules." self.Modules_Path = os.path.join(self.CHIPSEC_FOLDER,"chipsec","modules") self.IMPORT_PATHS = [] self.Loaded_Modules = [] self._list_tags = False self.AVAILABLE_TAGS = [] self.MODPATH_RE = re.compile("^\w+(\.\w+)*$") self.failfast = False self.no_time = False self._output = 'chipsec.log' self._module = None self._module_argv = None self._platform = None self._driver_exists = False self._no_driver = False self._unkownPlatform = True self._list_tags = False self._json_out = None self.version = defines.get_version() self.argv = argv self._cs = chipset.cs()
def __init__(self, argv): self.VERBOSE = False self.CHIPSEC_FOLDER = os.path.abspath(chipsec.file.get_main_dir()) self.CHIPSEC_LOADED_AS_EXE = chipsec.file.main_is_frozen() self.USER_MODULE_TAGS = [] self.ZIP_MODULES_RE = None self.Import_Path = "chipsec.modules." self.Modules_Path = os.path.join(self.CHIPSEC_FOLDER, "chipsec", "modules") self.IMPORT_PATHS = [] self.Loaded_Modules = [] self._list_tags = False self.AVAILABLE_TAGS = [] self.MODPATH_RE = re.compile("^\w+(\.\w+)*$") self.failfast = False self.no_time = False self._output = 'chipsec.log' self._module = None self._module_argv = None self._platform = None self._pch = None self._driver_exists = False self._no_driver = False self._unkownPlatform = True self._list_tags = False self._json_out = None self.version = defines.get_version() self.argv = argv self._cs = chipset.cs()
def __init__(self, argv): self.VERBOSE = False self.CHIPSEC_FOLDER = os.path.abspath(chipsec.file.get_main_dir()) self.CHIPSEC_LOADED_AS_EXE = chipsec.file.main_is_frozen() self.USER_MODULE_TAGS = [] self.ZIP_MODULES_RE = None self.Import_Path = "chipsec.modules." self.Modules_Path = os.path.join(self.CHIPSEC_FOLDER, "chipsec", "modules") self.IMPORT_PATHS = [] self.Loaded_Modules = [] self._list_tags = False self.AVAILABLE_TAGS = [] self.MODPATH_RE = re.compile("^\w+(\.\w+)*$") self.failfast = False self.no_time = False self._output = 'chipsec.log' self._module = None self._module_argv = None self._platform = None self._driver_exists = False self._no_driver = False self._unkownPlatform = True self._list_tags = False self.version = " " self.VERSION_FILE = os.path.join(self.CHIPSEC_FOLDER, "chipsec", "VERSION") if os.path.exists(self.VERSION_FILE): with open(self.VERSION_FILE, "r") as verFile: self.version = verFile.read() self.argv = argv self.parse_args() from chipsec.chipset import cs self._cs = cs()
def __init__(self, argv): self.VERBOSE = False self.CHIPSEC_FOLDER = os.path.abspath(chipsec.file.get_main_dir()) self.CHIPSEC_LOADED_AS_EXE = chipsec.file.main_is_frozen() self.USER_MODULE_TAGS = [] self.ZIP_MODULES_RE = None self.Import_Path = "chipsec.modules." self.Modules_Path = os.path.join(self.CHIPSEC_FOLDER,"chipsec","modules") self.IMPORT_PATHS = [] self.Loaded_Modules = [] self._list_tags = False self.AVAILABLE_TAGS = [] self.MODPATH_RE = re.compile("^\w+(\.\w+)*$") self.failfast = False self.no_time = False self._output = 'chipsec.log' self._module = None self._module_argv = None self._platform = None self._start_svc = True self._no_driver = False self._unkownPlatform = True self._list_tags = False self.version=" " self.VERSION_FILE = os.path.join( self.CHIPSEC_FOLDER , "VERSION" ) if os.path.exists( self.VERSION_FILE ): with open(self.VERSION_FILE, "r") as verFile: self.version = verFile.read() self.argv = argv self.parse_args() from chipsec.chipset import cs self._cs = cs()
def Run(self, args): self.logs = [] self.chipsec_log = StringIO.StringIO() if args.logging: self.logs.append("Dumping %s" % args.table_signature) logger.logger().logfile = self.chipsec_log logger.logger().LOG_TO_FILE = True # Wrap most of Chipsec code to gather its logs in case of failure. try: # Initialise Chipsec (die early if unknown chipset) c = chipset.cs() # Platform = None, Start Driver = False c.init(None, False) a = acpi.ACPI(c) acpi_tables_raw = a.get_ACPI_table(args.table_signature) acpi_tables = [] for i, table_address in enumerate(a.tableList[args.table_signature]): table_header, table_content = acpi_tables_raw[i] table_blob = table_header + table_content acpi_tables.append( chipsec_types.ACPITableData( table_address=table_address, table_blob=table_blob)) except (chipset.UnknownChipsetError, OSError) as err: # Expected errors that might happen on the client # If the chipset is unknown or we encountered an error due to reading # an area we do not have access to using /dev/mem, simply return an # error message. if args.logging: self.LogError(err) self.SendReply(chipsec_types.DumpACPITableResponse( logs=["%s" % err],)) return except Exception as err: # pylint: disable=broad-except # In case an exception is raised, if the verbose mode # is enabled, return the raw logs from Chipsec. if args.logging: self.LogError(err) raise if not acpi_tables: self.logs.append( "No ACPI table with signature %s." % args.table_signature) else: self.logs.append( "ACPI table with signature %s has been successfully dumped." % args.table_signature) if args.logging: self.logs.extend(self.chipsec_log.getvalue().splitlines()) self.SendReply( chipsec_types.DumpACPITableResponse( acpi_tables=acpi_tables, logs=self.logs))
def __init__(self): self._cs = cs() self.VERBOSE = False self.CHIPSEC_LOADED_AS_EXE = chipsec.file.main_is_frozen() self.USER_MODULE_TAGS = [] self.ZIP_MODULES_RE = None self.Import_Path = "chipsec.modules." self.Modules_Path = os.path.join(CHIPSEC_FOLDER, "chipsec", "modules") self.IMPORT_PATHS = [] self.Loaded_Modules = [] self._list_tags = False self.AVAILABLE_TAGS = [] self.MODPATH_RE = re.compile("^\w+(\.\w+)*$") self.failfast = False self.no_time = False
def __init__(self): self._cs = cs() self.VERBOSE = False self.CHIPSEC_LOADED_AS_EXE = chipsec.file.main_is_frozen() self.USER_MODULE_TAGS = [] self.ZIP_MODULES_RE = None self.Import_Path = "chipsec.modules." self.Modules_Path = os.path.join(CHIPSEC_FOLDER,"chipsec","modules") self.IMPORT_PATHS = [] self.Loaded_Modules = [] self._list_tags = False self.AVAILABLE_TAGS = [] self.MODPATH_RE = re.compile("^\w+(\.\w+)*$") self.failfast = False self.no_time = False
def _chipsec_util(self, arg, helper_class=mock_helper.TestHelper): """Run the chipsec_util command with the arguments. Each test may setup a virtual helper to emulate the expected behaviour from the hardware. If no helper is provided, TestHelper will be used. It verifies that no error is being reported. self.log will be populated with the output. """ oshelper.Helper.registry = [(helper_class.__name__, helper_class)] chipsec_util._cs = chipset.cs() util = chipsec_util.ChipsecUtil() util.VERBOSE = True util.set_logfile(self.log_file) err_code = util.main(["chipsec_utils.py"] + arg.split()) logger.logger().close() self.log = open(self.log_file).read() self.assertEqual(err_code, 0)
def _chipsec_util(self, arg, helper_class=mock_helper.TestHelper): """Run the chipsec_util command with the arguments. Each test may setup a virtual helper to emulate the expected behaviour from the hardware. If no helper is provided, TestHelper will be used. It verifies that no error is being reported. self.log will be populated with the output. """ chipsec_util._cs = chipset.cs() chipsec_util._cs.helper.helper = helper_class() util = chipsec_util.ChipsecUtil(arg.split()) util.VERBOSE = True logger.logger().HAL = True logger.logger().set_log_file(self.log_file) err_code = util.main() logger.logger().close() log = open(self.log_file, 'rb') self.log = log.read() log.close() self.assertEqual(err_code, 0)
def __init__(self, argv): self.global_usage = "CHIPSEC UTILITIES\n\n" + \ "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 self._platform = None self._unkownPlatform = True self._no_driver = False self.show_help = False self.help_cmd = None # parse command-line arguments self._cmd_args = None self.argv = argv self.parse_args() from chipsec.chipset import cs self._cs = cs()
def __init__(self, argv): self.global_usage = "CHIPSEC UTILITIES\n\n" + \ "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 self._platform = None self._unkownPlatform = True self._no_driver = False self.show_help = False self.help_cmd = None # parse command-line arguments self._cmd_args = None self.argv = argv self.parse_args() from chipsec.chipset import cs self._cs = cs()
def init_cs(self): self._cs = chipset.cs()
__version__ = '1.2.5' #import glob import re import os import sys import time import importlib import imp from chipsec.logger import * from chipsec.file import * from chipsec.helper.oshelper import helper from chipsec.chipset import cs, UnknownChipsetError _cs = cs() # # If you want to turn verbose logging change this line to True # logger().UTIL_TRACE = True logger().VERBOSE = False logger().HAL = False logger().DEBUG = False # If you want to specify a different platform change this line to a string from chipset.py # _Platform = 'SNB' _Platform = None class ExitCode: OK = 0
def parse_args(self): """Parse the arguments provided on the command line. Returns: a pair (continue, exit_code). If continue is False, the exit_code should be returned. """ parser = argparse.ArgumentParser( usage='%(prog)s [options]', formatter_class=argparse.RawDescriptionHelpFormatter, epilog=ExitCode.help_epilog, add_help=False) options = parser.add_argument_group('Options') options.add_argument('-h', '--help', help="show this message and exit", action='store_true') options.add_argument( '-m', '--module', dest='_module', help='specify module to run (example: -m common.bios_wp)') options.add_argument('-a', '--module_args', nargs='*', dest="_module_argv", help="additional module arguments") 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('-l', '--log', help='output to log file') adv_options = parser.add_argument_group('Advanced Options') adv_options.add_argument('-p', '--platform', dest='_platform', help='explicitly specify platform code', choices=chipset.cs().chipset_codes, type=str.upper) adv_options.add_argument('--pch', dest='_pch', help='explicitly specify PCH code', choices=chipset.cs().pch_codes, type=str.upper) adv_options.add_argument( '-n', '--no_driver', dest='_no_driver', help= "chipsec won't need kernel mode functions so don't load chipsec driver", action='store_true') adv_options.add_argument( '-i', '--ignore_platform', dest='_unknownPlatform', help='run chipsec even if the platform is not recognized', action='store_false') adv_options.add_argument('-j', '--json', dest='_json_out', help='specify filename for JSON output') adv_options.add_argument( '-x', '--xml', dest='_xml_out', help='specify filename for xml output (JUnit style)') adv_options.add_argument('-k', '--markdown', dest='_markdown_out', help='specify filename for markdown output') adv_options.add_argument('-t', '--moduletype', dest='USER_MODULE_TAGS', help='run tests of a specific type (tag)', type=str.upper, default=[]) adv_options.add_argument( '--list_tags', dest='_list_tags', help='list all the available options for -t,--moduletype', action='store_true') adv_options.add_argument( '-I', '--include', dest='IMPORT_PATHS', help='specify additional path to load modules from', default=[]) adv_options.add_argument( '--failfast', help="fail on any exception and exit (don't mask exceptions)", action='store_true') adv_options.add_argument('--no_time', help="don't log timestamps", action='store_true') adv_options.add_argument( '--deltas', dest='_deltas_file', help='specifies a JSON log file to compute result deltas from') adv_options.add_argument( '--record', dest='_to_file', help='run chipsec and clone helper results into JSON file') adv_options.add_argument('--replay', dest='_from_file', help='replay a chipsec run with JSON file') adv_options.add_argument('--helper', dest='_driver_exists', help='specify OS Helper', choices=[i for i in oshelper.avail_helpers]) parser.parse_args(self.argv, namespace=ChipsecMain) if self.help: parser.print_help() if self.verbose: logger().VERBOSE = True if self.hal: logger().HAL = True if self.debug: logger().DEBUG = True if self.log: logger().set_log_file(self.log) if self._module_argv and len( self._module_argv) == 1 and self._module_argv[0].count(','): logger().log( "[*] Use of the -a command no longer needs to have arguments concatenated with ','" ) self._module_argv = self._module_argv[0].split(',') if self._unknownPlatform is False: logger().log( "[*] Ignoring unsupported platform warning and continue execution" ) if self._from_file: self._driver_exists = "FileHelper"
def init_cs(self): self._cs = cs()
def Run(self, args): # Due to talking raw to hardware, this action has some inevitable risk of # crashing the machine, so we need to flush the transaction log to ensure # we know when this happens. self.SyncTransactionLog() # Temporary extra logging for Ubuntu # TODO(user): Add generic hunt flag to notify syslog before running each # client action. if args.notify_syslog: syslog = logging.getLogger("chipsec_grr") syslog.setLevel(logging.INFO) syslog.addHandler(handlers.SysLogHandler(address="/dev/log")) syslog.info("%s: Runnning DumpFlashImage", config_lib.CONFIG["Client.name"]) logs = [] if args.log_level: # Create a temporary file to store the log output as # Chipsec does not support in-memory logging. _, self.log_pathspec = tempfiles.CreateGRRTempFileVFS() logger().UTIL_TRACE = True if args.log_level == 2: logger().VERBOSE = True logger().set_log_file(self.log_pathspec.path) # Create a temporary file to store the flash image. dest_fd, dest_pathspec = tempfiles.CreateGRRTempFileVFS() # Wrap most of Chipsec code to gather its logs in case of failure. try: # Initialise Chipsec (die early if unknown chipset) c = chipset.cs() # Platform = None, Start Driver = False c.init(None, False) s = spi.SPI(c) # Use hal.spi from chipsec to write BIOS to that file. with dest_fd: # Based on Chipsec code, rely on the address of BIOS(=1) region to # determine the size of the flash. _, limit, _ = s.get_SPI_region(1) spi_size = limit + 1 # Read args.chunk_size bytes at a time and heartbeat. bios = [] for i in range(0, spi_size, args.chunk_size): bios.extend(s.read_spi(i, args.chunk_size)) self.Progress() dest_fd.write("".join(bios)) except Exception as err: # pylint: disable=broad-except # In case an exception is raised, if the verbose mode # is enabled, return the raw logs from Chipsec. if args.log_level: logs = self.ReadAndDeleteChipsecLogs() logs.append("%r: %s" % (err, err)) self.SendReply(chipsec_types.DumpFlashImageResponse(logs=logs)) tempfiles.DeleteGRRTempFile(dest_pathspec.path) if isinstance(err, chipset.UnknownChipsetError): # If the chipset is unknown, simply returns an error message self.SendReply( chipsec_types.DumpFlashImageResponse(logs=["%s" % err], )) return raise if args.log_level: logs = self.ReadAndDeleteChipsecLogs() if args.notify_syslog: syslog.info("%s: DumpFlashImage has completed successfully", config_lib.CONFIG["Client.name"]) self.SendReply( chipsec_types.DumpFlashImageResponse(path=dest_pathspec, logs=logs))
def Run(self, args): # Due to talking raw to hardware, this action has some inevitable risk of # crashing the machine, so we need to flush the transaction log to ensure # we know when this happens. self.SyncTransactionLog() # Temporary extra logging for Ubuntu # TODO(user): Add generic hunt flag to notify syslog before running each # client action. if args.notify_syslog: syslog = logging.getLogger("chipsec_grr") syslog.setLevel(logging.INFO) syslog.addHandler(handlers.SysLogHandler(address="/dev/log")) syslog.info("%s: Runnning DumpFlashImage", config.CONFIG["Client.name"]) self.logs = [] # TODO(hanuszczak): This appears to be something that could be made into # `StringIO` instead of `BytesIO`. self.chipsec_log = io.BytesIO() if args.log_level: logger.logger().UTIL_TRACE = True if args.log_level == 2: logger.logger().VERBOSE = True logger.logger().logfile = self.chipsec_log logger.logger().LOG_TO_FILE = True # Create a temporary file to store the flash image. dest_fd, dest_pathspec = tempfiles.CreateGRRTempFileVFS(suffix=".flash") # Wrap most of Chipsec code to gather its logs in case of failure. try: # Initialise Chipsec (die early if unknown chipset) c = chipset.cs() # Platform = None, Start Driver = False c.init(None, False) s = spi.SPI(c) # Use hal.spi from chipsec to write BIOS to that file. with dest_fd: # Based on Chipsec code, rely on the address of BIOS(=1) region to # determine the size of the flash. _, limit, _ = s.get_SPI_region(1) spi_size = limit + 1 # Read args.chunk_size bytes at a time and heartbeat. bios = [] for i in range(0, spi_size, args.chunk_size): bios.extend(s.read_spi(i, args.chunk_size)) self.Progress() dest_fd.write("".join(bios)) except (chipset.UnknownChipsetError, oshelper.OsHelperError) as err: # If the chipset is not recognised or if the helper threw an error, # report gracefully the error to the flow. if args.log_level: self.LogError(err) tempfiles.DeleteGRRTempFile(dest_pathspec.path) self.SendReply( rdf_chipsec_types.DumpFlashImageResponse(logs=["%s" % err],)) return except Exception as err: # pylint: disable=broad-except # In case an exception is raised, if the verbose mode # is enabled, return the raw logs from Chipsec. if args.log_level: self.LogError(err) tempfiles.DeleteGRRTempFile(dest_pathspec.path) raise if args.log_level: self.logs.extend(self.chipsec_log.getvalue().splitlines()) if args.notify_syslog: syslog.info("%s: DumpFlashImage has completed successfully", config.CONFIG["Client.name"]) self.SendReply( rdf_chipsec_types.DumpFlashImageResponse( path=dest_pathspec, logs=self.logs))
def Run(self, args): # Due to talking raw to hardware, this action has some inevitable risk of # crashing the machine, so we need to flush the transaction log to ensure # we know when this happens. self.SyncTransactionLog() # Temporary extra logging for Ubuntu # TODO(user): Add generic hunt flag to notify syslog before running each # client action. if args.notify_syslog: syslog = logging.getLogger("chipsec_grr") syslog.setLevel(logging.INFO) syslog.addHandler(handlers.SysLogHandler(address="/dev/log")) syslog.info("%s: Runnning DumpFlashImage", config.CONFIG["Client.name"]) self.logs = [] # TODO(hanuszczak): This appears to be something that could be made into # `StringIO` instead of `BytesIO`. self.chipsec_log = io.BytesIO() if args.log_level: logger.logger().UTIL_TRACE = True if args.log_level == 2: logger.logger().VERBOSE = True logger.logger().logfile = self.chipsec_log logger.logger().LOG_TO_FILE = True # Create a temporary file to store the flash image. dest_fd, dest_pathspec = tempfiles.CreateGRRTempFileVFS( suffix=".flash") # Wrap most of Chipsec code to gather its logs in case of failure. try: # Initialise Chipsec (die early if unknown chipset) c = chipset.cs() # Platform = None, Start Driver = False c.init(None, False) s = spi.SPI(c) # Use hal.spi from chipsec to write BIOS to that file. with dest_fd: # Based on Chipsec code, rely on the address of BIOS(=1) region to # determine the size of the flash. _, limit, _ = s.get_SPI_region(1) spi_size = limit + 1 # Read args.chunk_size bytes at a time and heartbeat. bios = [] for i in range(0, spi_size, args.chunk_size): bios.extend(s.read_spi(i, args.chunk_size)) self.Progress() dest_fd.write("".join(bios)) except (chipset.UnknownChipsetError, oshelper.OsHelperError) as err: # If the chipset is not recognised or if the helper threw an error, # report gracefully the error to the flow. if args.log_level: self.LogError(err) tempfiles.DeleteGRRTempFile(dest_pathspec.path) self.SendReply( rdf_chipsec_types.DumpFlashImageResponse(logs=["%s" % err], )) return except Exception as err: # pylint: disable=broad-except # In case an exception is raised, if the verbose mode # is enabled, return the raw logs from Chipsec. if args.log_level: self.LogError(err) tempfiles.DeleteGRRTempFile(dest_pathspec.path) raise if args.log_level: self.logs.extend(self.chipsec_log.getvalue().splitlines()) if args.notify_syslog: syslog.info("%s: DumpFlashImage has completed successfully", config.CONFIG["Client.name"]) self.SendReply( rdf_chipsec_types.DumpFlashImageResponse(path=dest_pathspec, logs=self.logs))
def Run(self, args): # Due to talking raw to hardware, this action has some inevitable risk of # crashing the machine, so we need to flush the transaction log to ensure # we know when this happens. self.SyncTransactionLog() # Temporary extra logging for Ubuntu # TODO(user): Add generic hunt flag to notify syslog before running each # client action. if args.notify_syslog: syslog = logging.getLogger("chipsec_grr") syslog.setLevel(logging.INFO) syslog.addHandler(handlers.SysLogHandler(address="/dev/log")) syslog.info("%s: Runnning DumpFlashImage", config_lib.CONFIG["Client.name"]) logs = [] if args.log_level: # Create a temporary file to store the log output as # Chipsec does not support in-memory logging. _, self.log_pathspec = tempfiles.CreateGRRTempFileVFS() logger().UTIL_TRACE = True if args.log_level == 2: logger().VERBOSE = True logger().set_log_file(self.log_pathspec.path) # Create a temporary file to store the flash image. dest_fd, dest_pathspec = tempfiles.CreateGRRTempFileVFS() # Wrap most of Chipsec code to gather its logs in case of failure. try: # Initialise Chipsec (die early if unknown chipset) c = chipset.cs() # Platform = None, Start Driver = False c.init(None, False) s = spi.SPI(c) # Use hal.spi from chipsec to write BIOS to that file. with dest_fd: # Based on Chipsec code, rely on the address of BIOS(=1) region to # determine the size of the flash. _, limit, _ = s.get_SPI_region(1) spi_size = limit + 1 # Read args.chunk_size bytes at a time and heartbeat. bios = [] for i in range(0, spi_size, args.chunk_size): bios.extend(s.read_spi(i, args.chunk_size)) self.Progress() dest_fd.write("".join(bios)) except Exception as err: # pylint: disable=broad-except # In case an exception is raised, if the verbose mode # is enabled, return the raw logs from Chipsec. if args.log_level: logs = self.ReadAndDeleteChipsecLogs() logs.append("%r: %s" % (err, err)) self.SendReply(chipsec_types.DumpFlashImageResponse(logs=logs)) tempfiles.DeleteGRRTempFile(dest_pathspec.path) if isinstance(err, chipset.UnknownChipsetError): # If the chipset is unknown, simply returns an error message self.SendReply(chipsec_types.DumpFlashImageResponse(logs=["%s" % err],)) return raise if args.log_level: logs = self.ReadAndDeleteChipsecLogs() if args.notify_syslog: syslog.info("%s: DumpFlashImage has completed successfully", config_lib.CONFIG["Client.name"]) self.SendReply(chipsec_types.DumpFlashImageResponse(path=dest_pathspec, logs=logs))
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('-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', help= "chipsec won't need kernel mode functions so don't load chipsec driver", action='store_true') options.add_argument( '-i', '--ignore_platform', dest='_unknownPlatform', help='run chipsec even if the platform is not recognized', action='store_false') 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) 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.log: logger().set_log_file(self.log) if not self._cmd_args: self._cmd_args = ["--help"]