Fix up the descriptions for non-simple requirements.

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(