dissect.target 3.15.dev26__tar.gz → 3.15.dev28__tar.gz

{dissect.target-3.15.dev26/dissect.target.egg-info → dissect.target-3.15.dev28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.15.dev26
+Version: 3.15.dev28
 Summary: This module ties all other Dissect modules together, it provides a programming API and command line tools which allow easy access to various data sources inside disk images or file collections (a.k.a. targets)
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/filesystem.py

@@ -13,7 +13,6 @@ from typing import (
     BinaryIO,
     Callable,
     Iterator,
-    List,
     Optional,
     Type,
     Union,
@@ -217,7 +216,7 @@ class Filesystem:
         """
         return self.get(path).scandir()
 
-    def listdir(self, path: str) -> List[str]:
+    def listdir(self, path: str) -> list[str]:
         """List the contents of a directory as strings.
 
         Args:
@@ -228,7 +227,7 @@ class Filesystem:
         """
         return list(self.iterdir(path))
 
-    def listdir_ext(self, path: str) -> List[FilesystemEntry]:
+    def listdir_ext(self, path: str) -> list[FilesystemEntry]:
         """List the contents of a directory as FilesystemEntry's.
 
         Args:
@@ -487,7 +486,7 @@ class Filesystem:
         """
         return self.get(path).sha256()
 
-    def hash(self, path: str, algos: Optional[Union[List[str], List[Callable]]] = None) -> tuple[str]:
+    def hash(self, path: str, algos: Optional[Union[list[str], list[Callable]]] = None) -> tuple[str]:
         """Calculate the digest of the contents of ``path``, using the ``algos`` algorithms.
 
         Args:
@@ -574,7 +573,7 @@ class FilesystemEntry:
         """
         raise NotImplementedError()
 
-    def listdir(self) -> List[str]:
+    def listdir(self) -> list[str]:
         """List the contents of a directory as strings.
 
         Returns:
@@ -582,7 +581,7 @@ class FilesystemEntry:
         """
         return list(self.iterdir())
 
-    def listdir_ext(self) -> List[FilesystemEntry]:
+    def listdir_ext(self) -> list[FilesystemEntry]:
         """List the contents of a directory as FilesystemEntry's.
 
         Returns:
@@ -823,7 +822,7 @@ class FilesystemEntry:
         """
         return hashutil.sha256(self.open())
 
-    def hash(self, algos: Optional[Union[List[str], List[Callable]]] = None) -> tuple[str]:
+    def hash(self, algos: Optional[Union[list[str], list[Callable]]] = None) -> tuple[str]:
         """Calculate the digest of this entry, using the ``algos`` algorithms.
 
         Args:

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/plugin.py

@@ -819,7 +819,7 @@ def load_module_from_name(module_path: str) -> None:
         # This will trigger the __init__subclass__() of the Plugin subclasses in the module.
         importlib.import_module(module_path)
     except Exception as e:
-        log.error("Unable to import %s", module_path)
+        log.info("Unable to import %s", module_path)
         log.debug("Error while trying to import module %s", module_path, exc_info=e)
         save_plugin_import_failure(module_path)
 

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/target.py

@@ -225,7 +225,10 @@ class Target:
 
         loader_cls = loader.find_loader(path, parsed_path=parsed_path)
         if loader_cls:
-            loader_instance = loader_cls(path, parsed_path=parsed_path)
+            try:
+                loader_instance = loader_cls(path, parsed_path=parsed_path)
+            except Exception as e:
+                raise TargetError(f"Failed to initiate {loader_cls.__name__} for target {path}: {e}", cause=e)
             return cls._load(path, loader_instance)
         return cls.open_raw(path)
 
@@ -281,7 +284,8 @@ class Target:
                     try:
                         ldr = loader_cls(sub_entry, parsed_path=parsed_path)
                     except Exception as e:
-                        getlogger(sub_entry).error("Failed to initiate loader", exc_info=e)
+                        getlogger(sub_entry).error("Failed to initiate loader: %s", e)
+                        getlogger(sub_entry).debug("", exc_info=e)
                         continue
 
                     try:

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/tools/dd.py

@@ -9,6 +9,7 @@ import sys
 from dissect.util.stream import RangeStream
 
 from dissect.target import Target
+from dissect.target.exceptions import TargetError
 from dissect.target.tools.utils import (
     catch_sigpipe,
     configure_generic_arguments,
@@ -39,7 +40,12 @@ def main():
 
     process_generic_arguments(args)
 
-    t = Target.open(args.target)
+    try:
+        t = Target.open(args.target)
+    except TargetError as e:
+        log.error(e)
+        log.debug("", exc_info=e)
+        parser.exit(1)
 
     if len(t.disks) > 1:
         parser.exit("Target has more than one disk")

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/tools/fs.py

@@ -10,6 +10,7 @@ import shutil
 import sys
 
 from dissect.target import Target
+from dissect.target.exceptions import TargetError
 from dissect.target.helpers.fsutil import TargetPath
 from dissect.target.tools.utils import (
     catch_sigpipe,
@@ -113,7 +114,13 @@ def main():
 
     process_generic_arguments(args)
 
-    target = Target.open(args.target)
+    try:
+        target = Target.open(args.target)
+    except TargetError as e:
+        log.error(e)
+        log.debug("", exc_info=e)
+        parser.exit(1)
+
     path = target.fs.path(args.path)
 
     if not path.exists():

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/tools/info.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import Union
 
 from dissect.target import Target
+from dissect.target.exceptions import TargetError
 from dissect.target.helpers.record import TargetRecordDescriptor
 from dissect.target.tools.query import record_output
 from dissect.target.tools.utils import (
@@ -72,22 +73,27 @@ def main():
             targets = targets[:-1]
         args.targets = targets
 
-    for i, target in enumerate(Target.open_all(args.targets)):
-        try:
-            if args.jsonlines:
-                print(json.dumps(get_target_info(target), default=str))
-            elif args.json:
-                print(json.dumps(get_target_info(target), indent=4, default=str))
-            elif args.record:
-                rs = record_output(args.strings)
-                rs.write(InfoRecord(**get_target_info(target), _target=target))
-            else:
-                if i > 0:
-                    print("-" * 70)
-                print_target_info(target)
-        except Exception as e:
-            target.log.error("Exception in retrieving information for target: `%s`. Use `-vv` for details.", target)
-            target.log.debug("", exc_info=e)
+    try:
+        for i, target in enumerate(Target.open_all(args.targets)):
+            try:
+                if args.jsonlines:
+                    print(json.dumps(get_target_info(target), default=str))
+                elif args.json:
+                    print(json.dumps(get_target_info(target), indent=4, default=str))
+                elif args.record:
+                    rs = record_output(args.strings)
+                    rs.write(InfoRecord(**get_target_info(target), _target=target))
+                else:
+                    if i > 0:
+                        print("-" * 70)
+                    print_target_info(target)
+            except Exception as e:
+                target.log.error("Exception in retrieving information for target: `%s`. Use `-vv` for details.", target)
+                target.log.debug("", exc_info=e)
+    except TargetError as e:
+        log.error(e)
+        log.debug("", exc_info=e)
+        parser.exit(1)
 
 
 def get_target_info(target: Target) -> dict[str, Union[str, list[str]]]:

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/tools/mount.py

@@ -3,6 +3,7 @@ import logging
 from typing import Union
 
 from dissect.target import Target, filesystem
+from dissect.target.exceptions import TargetError
 from dissect.target.helpers.utils import parse_options_string
 from dissect.target.tools.utils import (
     catch_sigpipe,
@@ -44,7 +45,13 @@ def main():
     if not HAS_FUSE:
         parser.exit("fusepy is not installed: pip install fusepy")
 
-    t = Target.open(args.target)
+    try:
+        t = Target.open(args.target)
+    except TargetError as e:
+        log.error(e)
+        log.debug("", exc_info=e)
+        parser.exit(1)
+
     vfs = filesystem.VirtualFilesystem()
     vfs.mount("fs", t.fs)
 

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/tools/query.py

@@ -14,6 +14,7 @@ from dissect.target import Target
 from dissect.target.exceptions import (
     FatalError,
     PluginNotFoundError,
+    TargetError,
     UnsupportedPluginError,
 )
 from dissect.target.helpers import cache, record_modifier
@@ -254,148 +255,152 @@ def main():
     execution_report.set_cli_args(args)
     execution_report.set_event_callbacks(Target)
 
-    for target in Target.open_all(targets, args.children):
-        if args.child:
-            try:
-                target = target.open_child(args.child)
-            except Exception:
-                target.log.exception("Exception while opening child '%s'", args.child)
-
-        if args.dry_run:
-            print(f"Dry run on: {target}")
-
-        record_entries = []
-        basic_entries = []
-        yield_entries = []
-
-        # Keep a set of plugins that were already executed on the target.
-        executed_plugins = set()
-
-        first_seen_output_type = default_output_type
-        cli_params_unparsed = rest
-
-        func_defs, _ = find_plugin_functions(target, args.function, compatibility=False)
-        excluded_funcs, _ = find_plugin_functions(target, args.excluded_functions, compatibility=False)
-        excluded_func_paths = {excluded_func.path for excluded_func in excluded_funcs}
-
-        for func_def in func_defs:
-            if func_def.path in excluded_func_paths:
-                continue
-
-            # Avoid executing same plugin for multiple OSes (like hostname)
-            if func_def.name in executed_plugins:
-                continue
-            executed_plugins.add(func_def.name)
-
-            # If the default type is record (meaning we skip everything else)
-            # and actual output type is not record, continue.
-            # We perform this check here because plugins that require output files/dirs
-            # will exit if we attempt to exec them without (because they are implied by the wildcard).
-            # Also this saves cycles of course.
-            if default_output_type == "record" and func_def.output_type != "record":
-                continue
+    try:
+        for target in Target.open_all(targets, args.children):
+            if args.child:
+                try:
+                    target = target.open_child(args.child)
+                except Exception:
+                    target.log.exception("Exception while opening child '%s'", args.child)
 
             if args.dry_run:
-                print(f"  execute: {func_def.name} ({func_def.path})")
-                continue
-
-            try:
-                output_type, result, cli_params_unparsed = execute_function_on_target(
-                    target, func_def, cli_params_unparsed
-                )
-            except UnsupportedPluginError as e:
-                target.log.error(
-                    "Unsupported plugin for %s: %s",
-                    func_def.name,
-                    e.root_cause_str(),
-                )
-
-                target.log.debug("%s", func_def, exc_info=e)
-                continue
-            except PluginNotFoundError:
-                target.log.error("Cannot find plugin `%s`", func_def)
-                continue
-            except FatalError as fatal:
-                fatal.emit_last_message(target.log.error)
-                parser.exit(1)
-            except Exception:
-                target.log.error("Exception while executing function `%s`", func_def, exc_info=True)
-                continue
-
-            if first_seen_output_type and output_type != first_seen_output_type:
-                target.log.error(
-                    (
-                        "Can't mix functions that generate different outputs: output type `%s` from `%s` "
-                        "does not match first seen output `%s`."
-                    ),
-                    output_type,
-                    func_def,
-                    first_seen_output_type,
-                )
-                parser.exit()
-
-            if not first_seen_output_type:
-                first_seen_output_type = output_type
-
-            if output_type == "record":
-                record_entries.append(result)
-            elif output_type == "yield":
-                yield_entries.append(result)
-            elif output_type == "none":
-                target.log.info("No result for function `%s` (output type is set to 'none')", func_def)
-                continue
-            else:
-                basic_entries.append(result)
-
-        # Write basic functions
-        if len(basic_entries) > 0:
-            basic_entries_delim = args.delimiter.join(map(str, basic_entries))
-            if not args.cmdb:
-                print(f"{target} {basic_entries_delim}")
-            else:
-                print(f"{target.path}{args.delimiter}{basic_entries_delim}")
+                print(f"Dry run on: {target}")
+
+            record_entries = []
+            basic_entries = []
+            yield_entries = []
+
+            # Keep a set of plugins that were already executed on the target.
+            executed_plugins = set()
+
+            first_seen_output_type = default_output_type
+            cli_params_unparsed = rest
+
+            func_defs, _ = find_plugin_functions(target, args.function, compatibility=False)
+            excluded_funcs, _ = find_plugin_functions(target, args.excluded_functions, compatibility=False)
+            excluded_func_paths = {excluded_func.path for excluded_func in excluded_funcs}
+
+            for func_def in func_defs:
+                if func_def.path in excluded_func_paths:
+                    continue
+
+                # Avoid executing same plugin for multiple OSes (like hostname)
+                if func_def.name in executed_plugins:
+                    continue
+                executed_plugins.add(func_def.name)
+
+                # If the default type is record (meaning we skip everything else)
+                # and actual output type is not record, continue.
+                # We perform this check here because plugins that require output files/dirs
+                # will exit if we attempt to exec them without (because they are implied by the wildcard).
+                # Also this saves cycles of course.
+                if default_output_type == "record" and func_def.output_type != "record":
+                    continue
+
+                if args.dry_run:
+                    print(f"  execute: {func_def.name} ({func_def.path})")
+                    continue
+
+                try:
+                    output_type, result, cli_params_unparsed = execute_function_on_target(
+                        target, func_def, cli_params_unparsed
+                    )
+                except UnsupportedPluginError as e:
+                    target.log.error(
+                        "Unsupported plugin for %s: %s",
+                        func_def.name,
+                        e.root_cause_str(),
+                    )
+
+                    target.log.debug("%s", func_def, exc_info=e)
+                    continue
+                except PluginNotFoundError:
+                    target.log.error("Cannot find plugin `%s`", func_def)
+                    continue
+                except FatalError as fatal:
+                    fatal.emit_last_message(target.log.error)
+                    parser.exit(1)
+                except Exception:
+                    target.log.error("Exception while executing function `%s`", func_def, exc_info=True)
+                    continue
+
+                if first_seen_output_type and output_type != first_seen_output_type:
+                    target.log.error(
+                        (
+                            "Can't mix functions that generate different outputs: output type `%s` from `%s` "
+                            "does not match first seen output `%s`."
+                        ),
+                        output_type,
+                        func_def,
+                        first_seen_output_type,
+                    )
+                    parser.exit()
+
+                if not first_seen_output_type:
+                    first_seen_output_type = output_type
+
+                if output_type == "record":
+                    record_entries.append(result)
+                elif output_type == "yield":
+                    yield_entries.append(result)
+                elif output_type == "none":
+                    target.log.info("No result for function `%s` (output type is set to 'none')", func_def)
+                    continue
+                else:
+                    basic_entries.append(result)
 
-        # Write yield functions
-        for entry in yield_entries:
-            for e in entry:
-                print(e)
+            # Write basic functions
+            if len(basic_entries) > 0:
+                basic_entries_delim = args.delimiter.join(map(str, basic_entries))
+                if not args.cmdb:
+                    print(f"{target} {basic_entries_delim}")
+                else:
+                    print(f"{target.path}{args.delimiter}{basic_entries_delim}")
 
-        # Write records
-        count = 0
-        break_out = False
+            # Write yield functions
+            for entry in yield_entries:
+                for e in entry:
+                    print(e)
 
-        modifier_type = None
+            # Write records
+            count = 0
+            break_out = False
 
-        if args.resolve:
-            modifier_type = record_modifier.Modifier.RESOLVE
+            modifier_type = None
 
-        if args.hash:
-            modifier_type = record_modifier.Modifier.HASH
+            if args.resolve:
+                modifier_type = record_modifier.Modifier.RESOLVE
 
-        modifier_func = record_modifier.get_modifier_function(modifier_type)
+            if args.hash:
+                modifier_type = record_modifier.Modifier.HASH
 
-        if not len(record_entries):
-            continue
+            modifier_func = record_modifier.get_modifier_function(modifier_type)
 
-        rs = record_output(args.strings, args.json)
-        for entry in record_entries:
-            try:
-                for record_entries in entry:
-                    rs.write(modifier_func(target, record_entries))
-                    count += 1
-                    if args.limit is not None and count >= args.limit:
-                        break_out = True
-                        break
-            except Exception as e:
-                # Ignore errors if multiple functions
-                if len(funcs) > 1:
-                    target.log.error(f"Exception occurred while processing output of {func}", exc_info=e)
-                    pass
-                else:
-                    raise e
+            if not record_entries:
+                continue
 
-            if break_out:
-                break
+            rs = record_output(args.strings, args.json)
+            for entry in record_entries:
+                try:
+                    for record_entries in entry:
+                        rs.write(modifier_func(target, record_entries))
+                        count += 1
+                        if args.limit is not None and count >= args.limit:
+                            break_out = True
+                            break
+                except Exception as e:
+                    # Ignore errors if multiple functions
+                    if len(funcs) > 1:
+                        target.log.error(f"Exception occurred while processing output of {func}", exc_info=e)
+                    else:
+                        raise e
+
+                if break_out:
+                    break
+    except TargetError as e:
+        log.error(e)
+        log.debug("", exc_info=e)
+        parser.exit(1)
 
     timestamp = datetime.utcnow()
 

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/tools/reg.py

@@ -6,7 +6,7 @@ import argparse
 import logging
 
 from dissect.target import Target
-from dissect.target.exceptions import RegistryError
+from dissect.target.exceptions import RegistryError, TargetError
 from dissect.target.tools.utils import (
     catch_sigpipe,
     configure_generic_arguments,
@@ -36,23 +36,28 @@ def main():
 
     process_generic_arguments(args)
 
-    for target in Target.open_all(args.targets):
-        try:
-            if args.value:
-                for key in target.registry.keys(args.key):
+    try:
+        for target in Target.open_all(args.targets):
+            try:
+                if args.value:
+                    for key in target.registry.keys(args.key):
+                        try:
+                            print(key.value(args.value))
+                        except RegistryError:
+                            continue
+                else:
                     try:
-                        print(key.value(args.value))
+                        print(target)
+                        for key in target.registry.keys(args.key):
+                            recursor(key, args.depth, 0)
                     except RegistryError:
-                        continue
-            else:
-                try:
-                    print(target)
-                    for key in target.registry.keys(args.key):
-                        recursor(key, args.depth, 0)
-                except RegistryError:
-                    log.exception("Failed to find registry value")
-        except Exception:
-            log.exception("Failed to iterate key")
+                        log.exception("Failed to find registry value")
+            except Exception:
+                log.exception("Failed to iterate key")
+    except TargetError as e:
+        log.error(e)
+        log.debug("", exc_info=e)
+        parser.exit(1)
 
 
 def recursor(key, depth, indent):

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28}/dissect/target/tools/shell.py

@@ -29,6 +29,7 @@ from dissect.target.exceptions import (
     RegistryError,
     RegistryKeyNotFoundError,
     RegistryValueNotFoundError,
+    TargetError,
 )
 from dissect.target.filesystem import FilesystemEntry, RootFilesystemEntry
 from dissect.target.helpers import cyber, fsutil, regutil
@@ -1233,7 +1234,11 @@ def main() -> None:
     if args.quiet:
         logging.getLogger("dissect").setLevel(level=logging.ERROR)
 
-    open_shell(args.targets, args.python, args.registry)
+    try:
+        open_shell(args.targets, args.python, args.registry)
+    except TargetError as e:
+        log.error(e)
+        log.debug("", exc_info=e)
 
 
 if __name__ == "__main__":

{dissect.target-3.15.dev26 → dissect.target-3.15.dev28/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.15.dev26
+Version: 3.15.dev28
 Summary: This module ties all other Dissect modules together, it provides a programming API and command line tools which allow easy access to various data sources inside disk images or file collections (a.k.a. targets)
 Author-email: Dissect Team <dissect@fox-it.com>
 License: Affero General Public License v3