Refactor SymbolRequirement to SymbolTableRequirement for clarity.

volatility/cli/__init__.py

@@ -268,7 +268,7 @@ class CommandLine(interfaces.plugins.FileConsumerInterface):
             translation_failed = translation_failed or isinstance(
                 excp.unsatisfied[config_path], configuration.requirements.TranslationLayerRequirement)
             symbols_failed = symbols_failed or isinstance(excp.unsatisfied[config_path],
-                                                          configuration.requirements.SymbolRequirement)
+                                                          configuration.requirements.SymbolTableRequirement)
 
             print("Unsatisfied requirement {}: {}".format(config_path, excp.unsatisfied[config_path].description))
 

volatility/cli/volshell/windows.py

@@ -31,7 +31,7 @@ class Volshell(shellplugin.Volshell):
     @classmethod
     def get_requirements(cls):
         return (super().get_requirements() + [
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             requirements.IntRequirement(name = 'pid', description = "Process ID", optional = True)
         ])
 

volatility/framework/automagic/pdbscan.py

@@ -414,7 +414,7 @@ class KernelPDBScanner(interfaces.automagic.AutomagicInterface):
                 context.symbol_space.append(native.NativeTable("pdbscan", native.std_ctypes))
             # TODO: check if this is a windows symbol requirement, otherwise ignore it
             self._symbol_requirements = self.find_requirements(context, config_path, requirement,
-                                                               requirements.SymbolRequirement)
+                                                               requirements.SymbolTableRequirement)
             potential_layers = self.find_virtual_layers_from_req(
                 context = context, config_path = config_path, requirement = requirement)
             for sub_config_path, symbol_req in self._symbol_requirements:

volatility/framework/automagic/symbol_finder.py

@@ -65,17 +65,17 @@ class SymbolFinder(interfaces.automagic.AutomagicInterface):
         self._requirements = self.find_requirements(
             context,
             config_path,
-            requirement, (requirements.TranslationLayerRequirement, requirements.SymbolRequirement),
+            requirement, (requirements.TranslationLayerRequirement, requirements.SymbolTableRequirement),
             shortcut = False)
 
         for (sub_path, requirement) in self._requirements:
             parent_path = interfaces.configuration.parent_path(sub_path)
 
-            if (isinstance(requirement, requirements.SymbolRequirement)
+            if (isinstance(requirement, requirements.SymbolTableRequirement)
                     and requirement.unsatisfied(context, parent_path)):
                 for (tl_sub_path, tl_requirement) in self._requirements:
                     tl_parent_path = interfaces.configuration.parent_path(tl_sub_path)
-                    # Find the TranslationLayer sibling to the SymbolRequirement
+                    # Find the TranslationLayer sibling to the SymbolTableRequirement
                     if (isinstance(tl_requirement, requirements.TranslationLayerRequirement)
                             and tl_parent_path == parent_path):
                         if context.config.get(tl_sub_path, None):
@@ -89,7 +89,7 @@ class SymbolFinder(interfaces.automagic.AutomagicInterface):
                      requirement: interfaces.configuration.ConstructableRequirementInterface,
                      layer_name: str,
                      progress_callback: constants.ProgressCallback = None) -> None:
-        """Accepts a context, config_path and SymbolRequirement, with a constructed layer_name
+        """Accepts a context, config_path and SymbolTableRequirement, with a constructed layer_name
         and scans the layer for banners"""
 
         # Bomb out early if there's no banners

volatility/framework/configuration/requirements.py

@@ -315,8 +315,8 @@ class TranslationLayerRequirement(configuration.ConstructableRequirementInterfac
         return context.memory[value].build_configuration()
 
 
-class SymbolRequirement(configuration.ConstructableRequirementInterface,
-                        configuration.ConfigurableRequirementInterface):
+class SymbolTableRequirement(configuration.ConstructableRequirementInterface,
+                             configuration.ConfigurableRequirementInterface):
     """Class maintaining the limitations on what sort of symbol spaces are acceptable"""
 
     def unsatisfied(self, context: interfaces.context.ContextInterface,
@@ -326,7 +326,7 @@ class SymbolRequirement(configuration.ConstructableRequirementInterface,
         value = self.config_value(context, config_path, None)
         if not isinstance(value, str):
             vollog.log(constants.LOGLEVEL_V,
-                       "TypeError - SymbolRequirement only accepts string labels: {}".format(value))
+                       "TypeError - SymbolTableRequirement only accepts string labels: {}".format(value))
             return {config_path: self}
         if value not in context.symbol_space:
             # This is an expected situation, so return False rather than raise

volatility/framework/interfaces/configuration.py

@@ -275,7 +275,7 @@ class RequirementInterface(metaclass = ABCMeta):
     :class:`~volatility.framework.configuration.requirements.IntRequirement`,
     :class:`~volatility.framework.configuration.requirements.BytesRequirement` and
     :class:`~volatility.framework.configuration.requirements.StringRequirement`) or complex types (such
-    as :class:`TranslationLayerRequirement`, :class:`SymbolRequirement` and :class:`ClassRequirement`
+    as :class:`TranslationLayerRequirement`, :class:`SymbolTableRequirement` and :class:`ClassRequirement`
     """
 
     def __init__(self,
@@ -385,7 +385,7 @@ class SimpleTypeRequirement(RequirementInterface):
 
 class ClassRequirement(RequirementInterface):
     """Requires a specific class.  This is used as means to serialize specific classes for :class:`TranslationLayerRequirement`
-    and :class:`SymbolRequirement` classes."""
+    and :class:`SymbolTableRequirement` classes."""
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)

volatility/framework/layers/registry.py

@@ -180,7 +180,7 @@ class RegistryHive(interfaces.layers.TranslationLayerInterface):
                 description = 'Offset within the base layer at which the hive lives',
                 default = 0,
                 optional = False),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             TranslationLayerRequirement(
                 name = 'base_layer', description = 'Layer in which the registry hive lives', optional = False)
         ]

volatility/framework/plugins/linux/bash.py

@@ -43,7 +43,7 @@ class Bash(plugins.PluginInterface, timeliner.TimeLinerInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/linux/check_afinfo.py

@@ -41,7 +41,7 @@ class Check_afinfo(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     # returns whether the symbol is found within the kernel (system.map) or not
@@ -80,11 +80,8 @@ class Check_afinfo(plugins.PluginInterface):
     def _generator(self):
         linux.LinuxUtilities.aslr_mask_symbol_table(self.context, self.config['vmlinux'], self.config['primary'])
 
-        vmlinux = contexts.Module(self.context, 
-                                  self.config['vmlinux'], 
-                                  self.config['primary'], 
-                                  0, 
-                                  absolute_symbol_addresses = True)                
+        vmlinux = contexts.Module(
+            self.context, self.config['vmlinux'], self.config['primary'], 0, absolute_symbol_addresses = True)
 
         op_members = vmlinux.get_type('file_operations').members
         seq_members = vmlinux.get_type('seq_operations').members

volatility/framework/plugins/linux/check_syscall.py

@@ -48,7 +48,7 @@ class Check_syscall(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _get_table_size_next_symbol(self, table_addr, ptr_sz, vmlinux):
@@ -145,11 +145,8 @@ class Check_syscall(plugins.PluginInterface):
     def _generator(self):
         linux.LinuxUtilities.aslr_mask_symbol_table(self.context, self.config['vmlinux'], self.config['primary'])
 
-        vmlinux = contexts.Module(self.context, 
-                                  self.config['vmlinux'], 
-                                  self.config['primary'], 
-                                  0, 
-                                  absolute_symbol_addresses = True)                
+        vmlinux = contexts.Module(
+            self.context, self.config['vmlinux'], self.config['primary'], 0, absolute_symbol_addresses = True)
 
         ptr_sz = vmlinux.get_type("pointer").size
         if ptr_sz == 4:

volatility/framework/plugins/linux/elfs.py

@@ -39,7 +39,7 @@ class Elfs(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/linux/lsmod.py

@@ -40,7 +40,7 @@ class Lsmod(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     @classmethod
@@ -48,12 +48,8 @@ class Lsmod(plugins.PluginInterface):
         """Lists all the modules in the primary layer"""
         linux.LinuxUtilities.aslr_mask_symbol_table(context, vmlinux_symbols, layer_name)
 
-        vmlinux = contexts.Module(context,
-                                  vmlinux_symbols,
-                                  layer_name,
-                                  0,
-                                  absolute_symbol_addresses = True)   
- 
+        vmlinux = contexts.Module(context, vmlinux_symbols, layer_name, 0, absolute_symbol_addresses = True)
+
         modules = vmlinux.object(symbol_name = "modules").cast("list_head")
 
         table_name = modules.vol.type_name.split(constants.BANG)[0]

volatility/framework/plugins/linux/lsof.py

@@ -41,7 +41,7 @@ class Lsof(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/linux/malfind.py

@@ -38,7 +38,7 @@ class Malfind(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _list_injections(self, task):

volatility/framework/plugins/linux/proc.py

@@ -38,7 +38,7 @@ class Maps(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/linux/pslist.py

@@ -35,7 +35,7 @@ class PsList(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     @classmethod
@@ -74,12 +74,8 @@ class PsList(interfaces_plugins.PluginInterface):
         """Lists all the tasks in the primary layer"""
         linux.LinuxUtilities.aslr_mask_symbol_table(context, vmlinux_symbols, layer_name)
 
-        vmlinux = contexts.Module(context,
-                                  vmlinux_symbols,
-                                  layer_name,
-                                  0,
-                                  absolute_symbol_addresses = True)   
- 
+        vmlinux = contexts.Module(context, vmlinux_symbols, layer_name, 0, absolute_symbol_addresses = True)
+
         init_task = vmlinux.object(symbol_name = "init_task")
 
         for task in init_task.tasks:

volatility/framework/plugins/mac/bash.py

@@ -43,7 +43,7 @@ class Bash(plugins.PluginInterface, timeliner.TimeLinerInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")
+            requirements.SymbolTableRequirement(name = "darwin", description = "Mac kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/mac/check_syscall.py

@@ -10,6 +10,7 @@ from volatility.framework.renderers import format_hints
 
 vollog = logging.getLogger(__name__)
 
+
 class Check_syscall(plugins.PluginInterface):
     """Check system call table for hooks"""
 
@@ -18,16 +19,14 @@ class Check_syscall(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")]
+            requirements.SymbolTableRequirement(name = "darwin", description = "Mac kernel symbols")
+        ]
 
     def _generator(self):
         mac.MacUtilities.aslr_mask_symbol_table(self.context, self.config['darwin'], self.config['primary'])
 
-        kernel = contexts.Module(self._context, 
-                                 self.config['darwin'], 
-                                 self.config['primary'], 
-                                 0, 
-                                 absolute_symbol_addresses = True)                
+        kernel = contexts.Module(
+            self._context, self.config['darwin'], self.config['primary'], 0, absolute_symbol_addresses = True)
 
         nsysent = kernel.object(symbol_name = "nsysent")
         table = kernel.object(symbol_name = "sysent")

volatility/framework/plugins/mac/lsmod.py

@@ -37,7 +37,7 @@ class Lsmod(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "darwin", description = "Linux kernel symbols")
         ]
 
     @classmethod
@@ -45,11 +45,7 @@ class Lsmod(plugins.PluginInterface):
         """Lists all the modules in the primary layer"""
         mac.MacUtilities.aslr_mask_symbol_table(context, darwin_symbols, layer_name)
 
-        kernel = contexts.Module(context, 
-                                 darwin_symbols, 
-                                 layer_name,
-                                 0, 
-                                 absolute_symbol_addresses = True)                
+        kernel = contexts.Module(context, darwin_symbols, layer_name, 0, absolute_symbol_addresses = True)
 
         kmod_ptr = kernel.object(symbol_name = "kmod")
 

volatility/framework/plugins/mac/malfind.py

@@ -36,7 +36,7 @@ class Malfind(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Linux kernel symbols")
+            requirements.SymbolTableRequirement(name = "darwin", description = "Linux kernel symbols")
         ]
 
     def _list_injections(self, task):

volatility/framework/plugins/mac/psaux.py

@@ -35,7 +35,7 @@ class Psaux(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")
+            requirements.SymbolTableRequirement(name = "darwin", description = "Mac kernel symbols")
         ]
 
     def _generator(self, tasks: Iterator[Any]) -> Generator[Tuple[int, Tuple[int, str, int, str]], None, None]:

volatility/framework/plugins/mac/pslist.py

@@ -38,7 +38,7 @@ class PsList(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")
+            requirements.SymbolTableRequirement(name = "darwin", description = "Mac kernel symbols")
         ]
 
     @classmethod
@@ -80,12 +80,8 @@ class PsList(interfaces_plugins.PluginInterface):
         """Lists all the tasks in the primary layer"""
 
         mac.MacUtilities.aslr_mask_symbol_table(context, darwin_symbols, layer_name)
-       
-        kernel = contexts.Module(context, 
-                                darwin_symbols, 
-                                layer_name,
-                                0, 
-                                absolute_symbol_addresses = True)                
+
+        kernel = contexts.Module(context, darwin_symbols, layer_name, 0, absolute_symbol_addresses = True)
 
         proc = kernel.object(symbol_name = "allproc").lh_first
 

volatility/framework/plugins/mac/pstree.py

@@ -39,7 +39,7 @@ class PsTree(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")
+            requirements.SymbolTableRequirement(name = "darwin", description = "Mac kernel symbols")
         ]
 
     def _find_level(self, pid):

volatility/framework/plugins/mac/trustedbsd.py

@@ -41,17 +41,14 @@ class Check_syscall(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")
+            requirements.SymbolTableRequirement(name = "darwin", description = "Mac kernel symbols")
         ]
 
     def _generator(self, mods: Iterator[Any]):
         mac.MacUtilities.aslr_mask_symbol_table(self.context, self.config['darwin'], self.config['primary'])
 
-        kernel = contexts.Module(self._context, 
-                                 self.config['darwin'], 
-                                 self.config['primary'], 
-                                 0, 
-                                 absolute_symbol_addresses = True)                
+        kernel = contexts.Module(
+            self._context, self.config['darwin'], self.config['primary'], 0, absolute_symbol_addresses = True)
 
         policy_list = kernel.object(symbol_name = "_mac_policy_list").cast("mac_policy_list")
 

volatility/framework/plugins/windows/cmdline.py

@@ -36,7 +36,7 @@ class CmdLine(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _generator(self, procs):

volatility/framework/plugins/windows/dlldump.py

@@ -44,7 +44,7 @@ class DllDump(interfaces_plugins.PluginInterface):
         return [requirements.TranslationLayerRequirement(name = 'primary',
                                                          description = 'Memory layer for the kernel',
                                                          architectures = ["Intel32", "Intel64"]),
-                requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+                requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
                 # TODO: Convert this to a ListRequirement so that people can filter on sets of ranges
                 requirements.IntRequirement(name = 'address',
                                             description = "Process virtual memory address to include " \

volatility/framework/plugins/windows/dlllist.py

@@ -36,7 +36,7 @@ class DllList(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _generator(self, procs):

volatility/framework/plugins/windows/handles.py

@@ -55,7 +55,7 @@ class Handles(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _decode_pointer(self, value, magic):

volatility/framework/plugins/windows/info.py

@@ -37,7 +37,7 @@ class Info(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def get_depends(self, layer_name: str, index: int = 0):

volatility/framework/plugins/windows/malfind.py

@@ -36,7 +36,7 @@ class Malfind(interfaces.plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     @classmethod

volatility/framework/plugins/windows/moddump.py

@@ -44,7 +44,7 @@ class ModDump(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     @classmethod

volatility/framework/plugins/windows/modules.py

@@ -35,7 +35,7 @@ class Modules(interfaces.plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _generator(self):

volatility/framework/plugins/windows/poolscanner.py

@@ -79,7 +79,7 @@ class PoolScanner(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     @staticmethod

volatility/framework/plugins/windows/procdump.py

@@ -43,7 +43,7 @@ class ProcDump(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _generator(self, procs):

volatility/framework/plugins/windows/pslist.py

@@ -38,7 +38,7 @@ class PsList(plugins.PluginInterface, timeliner.TimeLinerInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             # TODO: Convert this to a ListRequirement so that people can filter on sets of pids
             requirements.IntRequirement(
                 name = 'pid', description = "Process ID to include (all other processes are excluded)",

volatility/framework/plugins/windows/registry/hivelist.py

@@ -34,7 +34,7 @@ class HiveList(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             requirements.StringRequirement(
                 name = 'filter', description = "String to filter hive names returned", optional = True, default = None)
         ]

volatility/framework/plugins/windows/registry/printkey.py

@@ -39,7 +39,7 @@ class PrintKey(interfaces.plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             requirements.IntRequirement(name = 'offset', description = "Hive Offset", default = None, optional = True),
             requirements.StringRequirement(
                 name = 'key', description = "Key to start from", default = None, optional = True),

volatility/framework/plugins/windows/registry/userassist.py

@@ -52,7 +52,7 @@ class UserAssist(interfaces.plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             requirements.IntRequirement(name = 'offset', description = "Hive Offset", default = None, optional = True)
         ]
 

volatility/framework/plugins/windows/ssdt.py

@@ -40,7 +40,7 @@ class SSDT(plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _generator(self, mods: Iterator[Any]) -> Iterator[Tuple[int, Tuple[int, int, Any, Any]]]:

volatility/framework/plugins/windows/strings.py

@@ -38,7 +38,7 @@ class Strings(interfaces.plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             requirements.URIRequirement(name = "strings_file", description = "Strings file")
         ]
         # TODO: Make URLRequirement that can accept a file address which the framework can open

volatility/framework/plugins/windows/vaddump.py

@@ -41,7 +41,7 @@ class VadDump(interfaces_plugins.PluginInterface):
         return [requirements.TranslationLayerRequirement(name = 'primary',
                                                          description = 'Memory layer for the kernel',
                                                          architectures = ["Intel32", "Intel64"]),
-                requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+                requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
                 # TODO: Convert this to a ListRequirement so that people can filter on sets of ranges
                 requirements.IntRequirement(name = 'address',
                                             description = "Process virtual memory address to include " \

volatility/framework/plugins/windows/vadinfo.py

@@ -60,7 +60,7 @@ class VadInfo(interfaces.plugins.PluginInterface):
         return [requirements.TranslationLayerRequirement(name = 'primary',
                                                          description = 'Memory layer for the kernel',
                                                          architectures = ["Intel32", "Intel64"]),
-                requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+                requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
                 # TODO: Convert this to a ListRequirement so that people can filter on sets of ranges
                 requirements.IntRequirement(name = 'address',
                                             description = "Process virtual memory address to include " \

volatility/framework/plugins/windows/vadyarascan.py

@@ -43,7 +43,7 @@ class VadYaraScan(interfaces.plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = "Memory layer for the kernel", architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             requirements.BooleanRequirement(
                 name = "wide", description = "Match wide (unicode) strings", default = False, optional = True),
             requirements.StringRequirement(

volatility/framework/plugins/windows/verinfo.py

@@ -50,7 +50,7 @@ class VerInfo(interfaces_plugins.PluginInterface):
         return [
             requirements.TranslationLayerRequirement(
                 name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            requirements.SymbolTableRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
         ]
 
     @classmethod