Fix up the descriptions for non-simple requirements.

doc/source/simple-plugin.rst

@@ -33,7 +33,7 @@ to be able to run properly.  Any that are defined as optional need not necessari
         @classmethod
         def get_requirements(cls):
             return [requirements.TranslationLayerRequirement(name = 'primary',
-                                                             description = 'Kernel Address Space',
+                                                             description = 'Memory layer for the kernel',
                                                              architectures = ["Intel32", "Intel64"]),
                     requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
                     requirements.IntRequirement(name = 'pid',
@@ -47,7 +47,7 @@ to instantiate the plugin).  At the moment these requirements are fairly straigh
 ::
 
     requirements.TranslationLayerRequirement(name = 'primary',
-                                             description = 'Kernel Address Space',
+                                             description = 'Memory layer for the kernel',
                                              architectures = ["Intel32", "Intel64"]),
 
 This requirement indicates that the plugin will operate on a single `TranslationLayer`

volatility/cli/volshell/shellplugin.py

@@ -33,7 +33,7 @@ class Volshell(interfaces.plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"])
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"])
         ]
 
     def run(self, additional_locals: Dict[str, Any] = None) -> interfaces.renderers.TreeGrid:

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 OS"),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             requirements.IntRequirement(name = 'pid', description = "Process ID", optional = True)
         ])
 

volatility/framework/configuration/requirements.py

@@ -219,7 +219,8 @@ class LayerListRequirement(ComplexListRequirement):
 
     def new_requirement(self, index) -> configuration.RequirementInterface:
         """Constructs a new requirement based on the specified index"""
-        return TranslationLayerRequirement(name = self.name + str(index), description = "Swap Layer", optional = False)
+        return TranslationLayerRequirement(
+            name = self.name + str(index), description = "Layer for swap space", optional = False)
 
 
 class TranslationLayerRequirement(configuration.ConstructableRequirementInterface,

volatility/framework/layers/registry.py

@@ -175,9 +175,14 @@ class RegistryHive(interfaces.layers.TranslationLayerInterface):
     @classmethod
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
-            IntRequirement(name = 'hive_offset', description = '', default = 0, optional = False),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
-            TranslationLayerRequirement(name = 'base_layer', optional = False)
+            IntRequirement(
+                name = 'hive_offset',
+                description = 'Offset within the base layer at which the hive lives',
+                default = 0,
+                optional = False),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
+            TranslationLayerRequirement(
+                name = 'base_layer', description = 'Layer in which the registry hive lives', optional = False)
         ]
 
     def _translate(self, offset: int) -> int:

volatility/framework/plugins/configwriter.py

@@ -36,7 +36,7 @@ class ConfigWriter(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
             requirements.BooleanRequirement(
                 name = 'extra', description = 'Outputs whole configuration tree', default = False, optional = True)
         ]

volatility/framework/plugins/linux/bash.py

@@ -42,8 +42,8 @@ class Bash(plugins.PluginInterface, timeliner.TimeLinerInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/linux/check_afinfo.py

@@ -40,8 +40,8 @@ class Check_afinfo(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     # returns whether the symbol is found within the kernel (system.map) or not

volatility/framework/plugins/linux/check_syscall.py

@@ -47,8 +47,8 @@ class Check_syscall(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _get_table_size_next_symbol(self, table_addr, ptr_sz, vmlinux):

volatility/framework/plugins/linux/elfs.py

@@ -38,8 +38,8 @@ class Elfs(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/linux/lsmod.py

@@ -39,8 +39,8 @@ class Lsmod(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     @classmethod

volatility/framework/plugins/linux/lsof.py

@@ -40,8 +40,8 @@ class Lsof(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/linux/malfind.py

@@ -37,8 +37,8 @@ class Malfind(interfaces_plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _list_injections(self, task):

volatility/framework/plugins/linux/proc.py

@@ -37,8 +37,8 @@ class Maps(plugins.PluginInterface):
         # Since we're calling the plugin, make sure we have the plugin's requirements
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/linux/pslist.py

@@ -34,8 +34,8 @@ class PsList(interfaces_plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "vmlinux", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "vmlinux", description = "Linux kernel symbols")
         ]
 
     @classmethod

volatility/framework/plugins/mac/bash.py

@@ -42,8 +42,8 @@ class Bash(plugins.PluginInterface, timeliner.TimeLinerInterface):
     def get_requirements(cls):
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "mac Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")
         ]
 
     def _generator(self, tasks):

volatility/framework/plugins/mac/check_syscall.py

@@ -17,8 +17,8 @@ class Check_syscall(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "OSX Kernel")]
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")]
 
     def _generator(self):
         mac.MacUtilities.aslr_mask_symbol_table(self.context, self.config['darwin'], self.config['primary'])

volatility/framework/plugins/mac/lsmod.py

@@ -36,8 +36,8 @@ class Lsmod(plugins.PluginInterface):
     def get_requirements(cls):
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "darwin", description = "Linux kernel symbols")
         ]
 
     @classmethod

volatility/framework/plugins/mac/malfind.py

@@ -35,8 +35,8 @@ class Malfind(interfaces_plugins.PluginInterface):
     def get_requirements(cls):
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Linux Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "darwin", description = "Linux kernel symbols")
         ]
 
     def _list_injections(self, task):

volatility/framework/plugins/mac/psaux.py

@@ -34,8 +34,8 @@ class Psaux(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Mac Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(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

@@ -37,8 +37,8 @@ class PsList(interfaces_plugins.PluginInterface):
     def get_requirements(cls):
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Mac Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")
         ]
 
     @classmethod

volatility/framework/plugins/mac/pstree.py

@@ -38,8 +38,8 @@ class PsTree(plugins.PluginInterface):
     def get_requirements(cls):
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "Mac Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")
         ]
 
     def _find_level(self, pid):

volatility/framework/plugins/mac/trustedbsd.py

@@ -40,8 +40,8 @@ class Check_syscall(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "darwin", description = "OSX Kernel")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "darwin", description = "Mac kernel symbols")
         ]
 
     def _generator(self, mods: Iterator[Any]):

volatility/framework/plugins/windows/cmdline.py

@@ -36,8 +36,8 @@ class CmdLine(interfaces_plugins.PluginInterface):
         # Since we're calling the plugin, make sure we have the plugin's requirements
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _generator(self, procs):

volatility/framework/plugins/windows/dlldump.py

@@ -42,9 +42,9 @@ class DllDump(interfaces_plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         # Since we're calling the plugin, make sure we have the plugin's requirements
         return [requirements.TranslationLayerRequirement(name = 'primary',
-                                                         description = 'Kernel Address Space',
+                                                         description = 'Memory layer for the kernel',
                                                          architectures = ["Intel32", "Intel64"]),
-                requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                requirements.SymbolRequirement(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

@@ -35,8 +35,8 @@ class DllList(interfaces_plugins.PluginInterface):
         # Since we're calling the plugin, make sure we have the plugin's requirements
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _generator(self, procs):

volatility/framework/plugins/windows/handles.py

@@ -54,8 +54,8 @@ class Handles(interfaces_plugins.PluginInterface):
         # Since we're calling the plugin, make sure we have the plugin's requirements
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _decode_pointer(self, value, magic):

volatility/framework/plugins/windows/info.py

@@ -36,8 +36,8 @@ class Info(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def get_depends(self, layer_name: str, index: int = 0):

volatility/framework/plugins/windows/malfind.py

@@ -35,8 +35,8 @@ class Malfind(interfaces.plugins.PluginInterface):
         # Since we're calling the plugin, make sure we have the plugin's requirements
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     @classmethod

volatility/framework/plugins/windows/moddump.py

@@ -43,8 +43,8 @@ class ModDump(interfaces_plugins.PluginInterface):
         # Reuse the requirements from the plugins we use
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     @classmethod

volatility/framework/plugins/windows/modules.py

@@ -34,8 +34,8 @@ class Modules(interfaces.plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _generator(self):

volatility/framework/plugins/windows/poolscanner.py

@@ -78,8 +78,8 @@ class PoolScanner(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     @staticmethod

volatility/framework/plugins/windows/procdump.py

@@ -42,8 +42,8 @@ class ProcDump(interfaces_plugins.PluginInterface):
         # Since we're calling the plugin, make sure we have the plugin's requirements
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols")
         ]
 
     def _generator(self, procs):

volatility/framework/plugins/windows/pslist.py

@@ -37,8 +37,8 @@ class PsList(plugins.PluginInterface, timeliner.TimeLinerInterface):
     def get_requirements(cls):
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(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

@@ -33,8 +33,8 @@ class HiveList(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(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

@@ -38,8 +38,8 @@ class PrintKey(interfaces.plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(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

@@ -51,8 +51,8 @@ class UserAssist(interfaces.plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
             requirements.IntRequirement(name = 'offset', description = "Hive Offset", default = None, optional = True)
         ]
 

volatility/framework/plugins/windows/ssdt.py

@@ -39,8 +39,8 @@ class SSDT(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS")
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(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

@@ -37,8 +37,8 @@ class Strings(interfaces.plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(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

@@ -39,9 +39,9 @@ class VadDump(interfaces_plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         # Since we're calling the plugin, make sure we have the plugin's requirements
         return [requirements.TranslationLayerRequirement(name = 'primary',
-                                                         description = 'Kernel Address Space',
+                                                         description = 'Memory layer for the kernel',
                                                          architectures = ["Intel32", "Intel64"]),
-                requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                requirements.SymbolRequirement(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

@@ -58,9 +58,9 @@ class VadInfo(interfaces.plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         # Since we're calling the plugin, make sure we have the plugin's requirements
         return [requirements.TranslationLayerRequirement(name = 'primary',
-                                                         description = 'Kernel Address Space',
+                                                         description = 'Memory layer for the kernel',
                                                          architectures = ["Intel32", "Intel64"]),
-                requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                requirements.SymbolRequirement(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,8 +43,8 @@ class VadYaraScan(interfaces.plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = "Primary kernel address space", architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                name = 'primary', description = "Memory layer for the kernel", architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(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

@@ -49,8 +49,8 @@ class VerInfo(interfaces_plugins.PluginInterface):
         ## TODO: and we don't want any CLI options from pslist, modules, or moddump
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"]),
-            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows OS"),
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"]),
+            requirements.SymbolRequirement(name = "nt_symbols", description = "Windows kernel symbols"),
         ]
 
     @classmethod

volatility/framework/plugins/yarascan.py

@@ -56,7 +56,7 @@ class YaraScan(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = "Primary kernel address space", architectures = ["Intel32", "Intel64"]),
+                name = 'primary', description = "Memory layer for the kernel", architectures = ["Intel32", "Intel64"]),
             requirements.BooleanRequirement(
                 name = "all", description = "Scan both process and kernel memory", default = False, optional = True),
             requirements.BooleanRequirement(

volatility/plugins/windows/statistics.py

@@ -32,7 +32,7 @@ class Statistics(plugins.PluginInterface):
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
         return [
             requirements.TranslationLayerRequirement(
-                name = 'primary', description = 'Kernel Address Space', architectures = ["Intel32", "Intel64"])
+                name = 'primary', description = 'Memory layer for the kernel', architectures = ["Intel32", "Intel64"])
         ]
 
     def _generator(self):