Layers - Several fixes around maximum_address and chunk sizes

volatility3/cli/__init__.py

@@ -716,19 +716,17 @@ def _get_final_filename(self):
                 """Gets the final filename"""
                 if output_dir is None:
                     raise TypeError("Output directory is not a string")
+
                 os.makedirs(output_dir, exist_ok=True)
 
-                pref_name_array = self.preferred_filename.split(".")
-                filename, extension = (
-                    os.path.join(output_dir, ".".join(pref_name_array[:-1])),
-                    pref_name_array[-1],
-                )
-                output_filename = f"{filename}.{extension}"
+                output_filename = os.path.join(output_dir, self.preferred_filename)
+                filename, extension = os.path.splitext(output_filename)
 
                 counter = 1
                 while os.path.exists(output_filename):
-                    output_filename = f"{filename}-{counter}.{extension}"
+                    output_filename = f"{filename}-{counter}{extension}"
                     counter += 1
+
                 return output_filename
 
         class CLIMemFileHandler(io.BytesIO, CLIFileHandler):
@@ -792,8 +790,8 @@ def close(self):
                     return None
 
                 self._file.close()
-                output_filename = self._get_final_filename()
-                os.rename(self._name, output_filename)
+                self._output_filename = self._get_final_filename()
+                os.rename(self._name, self._output_filename)
 
         if direct:
             return CLIDirectFileHandler

volatility3/framework/layers/intel.py

@@ -180,7 +180,7 @@ def _translate_entry(self, offset: int) -> Tuple[int, int]:
         position = self._initial_position
         entry = self._initial_entry
 
-        if self.minimum_address > offset > self.maximum_address:
+        if not (self.minimum_address <= offset <= self.maximum_address):
             raise exceptions.PagedInvalidAddressException(
                 self.name,
                 offset,

volatility3/framework/layers/segmented.py

@@ -152,7 +152,7 @@ def maximum_address(self) -> int:
             raise ValueError("SegmentedLayer must contain some segments")
         if self._maxaddr is None:
             mapped, _, length, _ = self._segments[-1]
-            self._maxaddr = mapped + length
+            self._maxaddr = mapped + length - 1
         return self._maxaddr
 
     @property

volatility3/framework/plugins/layerwriter.py

@@ -18,7 +18,7 @@ class LayerWriter(plugins.PluginInterface):
     default_block_size = 0x500000
 
     _required_framework_version = (2, 0, 0)
-    _version = (2, 0, 0)
+    _version = (2, 0, 1)
 
     @classmethod
     def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]:
@@ -38,6 +38,11 @@ def get_requirements(cls) -> List[interfaces.configuration.RequirementInterface]
                 default=False,
                 optional=True,
             ),
+            requirements.StringRequirement(
+                name="output",
+                description="Output filename",
+                optional=True,
+            ),
             requirements.ListRequirement(
                 name="layers",
                 element_type=str,
@@ -77,7 +82,7 @@ def write_layer(
 
         file_handle = open_method(preferred_name)
         for i in range(0, layer.maximum_address, chunk_size):
-            current_chunk_size = min(chunk_size, layer.maximum_address - i)
+            current_chunk_size = min(chunk_size, layer.maximum_address + 1 - i)
             data = layer.read(i, current_chunk_size, pad=True)
             file_handle.write(data)
             if progress_callback:
@@ -95,15 +100,16 @@ def _generator(self):
             if not self.config["layers"]:
                 self.config["layers"] = []
                 for name in self.context.layers:
-                    if not self.context.layers[name].metadata.get("mapped", False):
+                    if "mapped" not in self.context.layers[name].metadata:
                         self.config["layers"] = [name]
 
             for name in self.config["layers"]:
                 # Check the layer exists and validate the output file
                 if name not in self.context.layers:
                     yield 0, (f"Layer Name {name} does not exist",)
                 else:
-                    output_name = self.config.get("output", ".".join([name, "raw"]))
+                    default_output_name = f"{name}.raw"
+                    output_name = self.config.get("output", default_output_name)
                     try:
                         file_handle = self.write_layer(
                             self.context,
@@ -114,10 +120,9 @@ def _generator(self):
                             progress_callback=self._progress_callback,
                         )
                         file_handle.close()
+                        output_name = file_handle._output_filename
                     except IOError as excp:
-                        yield 0, (
-                            f"Layer cannot be written to {self.config['output_name']}: {excp}",
-                        )
+                        yield 0, (f"Layer cannot be written to {output_name}: {excp}",)
 
                     yield 0, (f"Layer has been written to {output_name}",)