Change the way helper loading is done

Signed-off-by: Nathaniel Mitchell <nathaniel.p.mitchell@intel.com>

chipsec/helper/dal/__init__.py

@@ -25,10 +25,8 @@
 ##################################################################################
 
 import sys
-from chipsec.helper.oshelper import avail_helpers
 
 if 'itpii' in sys.modules:
     __all__ = ['dalhelper']
-    avail_helpers.append("dalhelper")
 else:
     __all__ = []

chipsec/helper/efi/__init__.py

@@ -26,9 +26,8 @@
 ##################################################################################
 
 import sys
-from chipsec.helper.oshelper import avail_helpers
+
 if sys.platform.startswith('uefi') or sys.platform.startswith('EFI'):
     __all__ = ["efihelper"]
-    avail_helpers.append("efihelper")
 else:
     __all__ = []

chipsec/helper/file/__init__.py

@@ -18,6 +18,5 @@
 # chipsec@intel.com
 #
 
-from chipsec.helper.oshelper import avail_helpers
+
 __all__ = ["filehelper"]
-avail_helpers.append("filehelper")

chipsec/helper/linux/__init__.py

@@ -26,9 +26,8 @@
 ##################################################################################
 
 import platform
-from chipsec.helper.oshelper import avail_helpers
+
 if "linux" == platform.system().lower():
     __all__ = ["linuxhelper"]
-    avail_helpers.append("linuxhelper")
 else:
     __all__ = []

chipsec/helper/oshelper.py

@@ -25,14 +25,17 @@ Abstracts support for various OS/environments, wrapper around platform specific
 import os
 import re
 import errno
+import importlib
+import platform
 import traceback
 import sys
 from ctypes import Array
 from typing import Tuple, List, Dict, Optional, AnyStr, TYPE_CHECKING
 if TYPE_CHECKING:
     from chipsec.library.types import EfiVariableType
-import chipsec.file
+from chipsec.file import get_main_dir, TOOLS_DIR
 from chipsec.logger import logger
+from chipsec.helper.basehelper import Helper
 from chipsec.exceptions import UnimplementedAPIError, OsHelperError
 
 avail_helpers = []
@@ -48,7 +51,7 @@ def map_modname_zip(x: str) -> str:
 
 
 def get_tools_path() -> str:
-    return os.path.normpath(os.path.join(chipsec.file.get_main_dir(), chipsec.file.TOOLS_DIR))
+    return os.path.normpath(os.path.join(get_main_dir(), TOOLS_DIR))
 
 
 import chipsec.helper.helpers as chiphelpers
@@ -60,11 +63,11 @@ import chipsec.helper.helpers as chiphelpers
 
 class OsHelper:
     def __init__(self):
-        self.helper = None
+        self.avail_helpers = {}
         self.loadHelpers()
         self.filecmds = None
+        self.helper = self.getDefaultHelper()
         if (not self.helper):
-            import platform
             os_system = platform.system()
             raise OsHelperError("Could not load any helpers for '{}' environment (unsupported environment?)".format(os_system), errno.ENODEV)
         else:
@@ -80,22 +83,50 @@ class OsHelper:
             self.os_machine = self.helper.os_machine
 
     def loadHelpers(self) -> None:
-        for helper in avail_helpers:
+        helper_dir = os.path.join(get_main_dir(), "chipsec", "helper")
+        helpers = [os.path.basename(f) for f in os.scandir(helper_dir)
+                    if f.is_dir() and not os.path.basename(f).startswith("__")]
+        for helper in helpers:
+            helper_path = ''
             try:
-                self.helper = getattr(chiphelpers, helper).get_helper()
-                break
-            except OsHelperError:
-                raise
-            except:
-                if logger().DEBUG:
-                    logger().log("Unable to load helper: {}".format(helper))
+                helper_path = f'chipsec.helper.{helper}.{helper}helper'
+                hlpr = importlib.import_module(helper_path)
+                self.avail_helpers[f'{helper}helper'] = hlpr
+            except ImportError as msg:
+                logger().log_debug(f"Unable to load helper: {helper}")
+
+    def getHelper(self, name: str) -> any:
+        ret = None
+        if name in self.avail_helpers:
+            ret = self.avail_helpers[name].get_helper()
+        return ret
+    
+    def getAvailableHelpers(self) -> List[str]:
+        return self.avail_helpers.keys()
+
+    def getBaseHelper(self):
+        return Helper()
+    
+    def getDefaultHelper(self):
+        ret = None
+        if self.is_linux():
+            ret = self.getHelper("linuxhelper")
+        elif self.is_windows():
+            ret = self.getHelper("windowshelper")
+        elif self.is_efi():
+            ret = self.getHelper("efihelper")
+        elif self.is_dal():
+            ret = self.getHelper("dalhelper")
+        if ret is None:
+            ret = self.getBaseHelper()
+        return ret
 
     def start(self, start_driver: bool, driver_exists: Optional[bool] = None, to_file: Optional[bool] = None, from_file: Optional[bool] = False) -> None:
         if to_file is not None:
             from chipsec.helper.file.filehelper import FileCmds
             self.filecmds = FileCmds(to_file)
         if driver_exists is not None:
-            for name in avail_helpers:
+            for name in self.avail_helpers:
                 if name == driver_exists:
                     self.helper = getattr(chiphelpers, name).get_helper()
         try:
@@ -136,23 +167,23 @@ class OsHelper:
         return self.helper.use_native_api()
 
     def is_dal(self) -> bool:
-        return ('itpii' in sys.modules)
+        return 'itpii' in sys.modules
 
     def is_efi(self) -> bool:
-        return self.os_system.lower().startswith('efi') or self.os_system.lower().startswith('uefi')
+        return platform.system().lower().startswith('efi') or platform.system().lower().startswith('uefi')
 
     def is_linux(self) -> bool:
-        return ('linux' == self.os_system.lower())
+        return 'linux' == platform.system().lower()
 
     def is_windows(self) -> bool:
-        return ('windows' == self.os_system.lower())
+        return 'windows' == platform.system().lower()
 
     def is_win8_or_greater(self) -> bool:
         win8_or_greater = self.is_windows() and (self.os_release.startswith('8') or ('2008Server' in self.os_release) or ('2012Server' in self.os_release))
         return win8_or_greater
 
     def is_macos(self) -> bool:
-        return ('darwin' == self.os_system.lower())
+        return 'darwin' == platform.system().lower()
 
     #################################################################################################
     # Actual OS helper functionality accessible to HAL components

chipsec/helper/osx/__init__.py

@@ -13,9 +13,8 @@
 #
 
 import platform
-from chipsec.helper.oshelper import avail_helpers
+
 if 'darwin' == platform.system().lower():
     __all__ = ["osxhelper"]
-    avail_helpers.append("osxhelper")
 else:
     __all__ = []

chipsec/helper/windows/__init__.py

@@ -26,10 +26,8 @@
 ##################################################################################
 
 import platform
-from chipsec.helper.oshelper import avail_helpers
     
 if "windows" == platform.system().lower():
     __all__ = ["windowshelper"]
-    avail_helpers.append("windowshelper")
 else:
     __all__ = []

chipsec_main.py

@@ -47,7 +47,7 @@ import chipsec.result_deltas
 from chipsec import defines
 from chipsec import module_common
 from chipsec import chipset
-from chipsec.helper import oshelper
+from chipsec.helper.oshelper import helper
 from chipsec.logger import logger
 from chipsec.banner import print_banner, print_banner_properties
 from chipsec.testcase import ExitCode, TestCase, ChipsecResults
@@ -92,7 +92,7 @@ def parse_args(argv: Sequence[str]) -> Optional[Dict[str, Any]]:
     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])
+    adv_options.add_argument('--helper', dest='_driver_exists', help='specify OS Helper', choices=[i for i in helper().getAvailableHelpers()])
     adv_options.add_argument('-nb', '--no_banner', dest='_show_banner', action='store_false', help="chipsec won't display banner information")
     adv_options.add_argument('--skip_config', dest='_load_config', action='store_false', help='skip configuration and driver loading')
 

chipsec_util.py

@@ -30,7 +30,7 @@ import importlib
 import argparse
 
 from typing import Sequence, Optional, Dict, Any
-from chipsec.helper import oshelper
+from chipsec.helper.oshelper import helper
 from chipsec.logger import logger, level
 from chipsec.banner import print_banner, print_banner_properties
 from chipsec.exceptions import UnknownChipsetError
@@ -108,7 +108,7 @@ def parse_args(argv: Sequence[str]) -> Optional[Dict[str, Any]]:
                          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('--helper', dest='_driver_exists', help='specify OS Helper', choices=[i for i in helper().getAvailableHelpers()])
     options.add_argument('_cmd', metavar='Command', nargs='?', choices=sorted(cmds.keys()), type=str.lower, default="help",
                          help="Util command to run: {{{}}}".format(','.join(sorted(cmds.keys()))))
     options.add_argument('_cmd_args', metavar='Command Args', nargs=argparse.REMAINDER, help=global_usage)