dissect.target 3.20.2.dev46__tar.gz → 3.20.2.dev48__tar.gz

{dissect_target-3.20.2.dev46/dissect.target.egg-info → dissect_target-3.20.2.dev48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dissect.target
-Version: 3.20.2.dev46
+Version: 3.20.2.dev48
 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.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/helpers/keychain.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import csv
 import logging
 from enum import Enum
 from pathlib import Path
-from typing import NamedTuple, Union
+from typing import NamedTuple
 
 log = logging.getLogger(__name__)
 
@@ -18,9 +20,9 @@ class KeyType(Enum):
 
 class Key(NamedTuple):
     key_type: KeyType
-    value: Union[str, bytes]
-    provider: str = None
-    identifier: str = None
+    value: str | bytes
+    provider: str | None = None
+    identifier: str | None = None
     is_wildcard: bool = False
 
 
@@ -28,13 +30,13 @@ KEYCHAIN: list[Key] = []
 
 
 def register_key(
-    key_type: KeyType, value: str, identifier: str = None, provider: str = None, is_wildcard: bool = False
+    key_type: KeyType, value: str, identifier: str | None = None, provider: str | None = None, is_wildcard: bool = False
 ) -> None:
     if key_type == KeyType.RAW:
         try:
             value = bytes.fromhex(value)
         except ValueError:
-            log.warning("Failed to decode raw key as hex, ignoring: %s", value)
+            log.debug("Failed to decode raw key as hex, ignoring: %s", value)
             return
 
     if key_type in (KeyType.RECOVERY_KEY, KeyType.FILE):

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/plugin.py

@@ -278,7 +278,7 @@ def arg(*args, **kwargs) -> Callable[..., Any]:
         if not hasattr(obj, "__args__"):
             obj.__args__ = []
 
-        obj.__args__.append((args, kwargs))
+        obj.__args__.insert(0, (args, kwargs))
 
         return obj
 

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/dd.py

@@ -33,12 +33,10 @@ def main():
     parser.add_argument("-w", "--write", default="-", help="output file")
     parser.add_argument("-o", "--offset", type=int, default=0, help="offset to read from.")
     parser.add_argument("-b", "--bytes", type=int, default=-1, help="amount of bytes to read")
-
     configure_generic_arguments(parser)
 
-    args = parser.parse_args()
-
-    process_generic_arguments(args)
+    args, rest = parser.parse_known_args()
+    process_generic_arguments(args, rest)
 
     try:
         t = Target.open(args.target)

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/diff.py

@@ -352,7 +352,7 @@ class TargetComparison:
 class DifferentialCli(ExtendedCmd):
     """CLI for browsing the differential between two or more targets."""
 
-    doc_header_prefix = "target-diff\n" "==========\n"
+    doc_header_prefix = "target-diff\n==========\n"
     doc_header_suffix = "\n\nDocumented commands (type help <topic>):"
     doc_header_multiple_targets = "Use 'list', 'prev' and 'next' to list and select targets to differentiate between."
 
@@ -958,8 +958,8 @@ def main() -> None:
 
     configure_generic_arguments(parser)
 
-    args = parser.parse_args()
-    process_generic_arguments(args)
+    args, rest = parser.parse_known_args()
+    process_generic_arguments(args, rest)
 
     if len(args.targets) < 2:
         print("At least two targets are required for target-diff.")

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/fs.py

@@ -142,16 +142,14 @@ def main() -> None:
     )
     parser_cp.add_argument("-o", "--output", type=str, default=".", help="output directory")
     parser_cp.set_defaults(handler=cp)
-
     configure_generic_arguments(parser)
 
-    args = parser.parse_args()
+    args, rest = parser.parse_known_args()
+    process_generic_arguments(args, rest)
 
     if args.subcommand is None:
         parser.error("No subcommand specified")
 
-    process_generic_arguments(args)
-
     try:
         target = Target.open(args.target)
     except TargetError as e:

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/info.py

@@ -13,7 +13,6 @@ 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 (
-    args_to_uri,
     catch_sigpipe,
     configure_generic_arguments,
     process_generic_arguments,
@@ -56,13 +55,10 @@ def main():
     parser.add_argument("-r", "--record", action="store_true", help="print output as record")
     parser.add_argument("-j", "--json", action="store_true", help="output records as pretty json")
     parser.add_argument("-J", "--jsonlines", action="store_true", help="output records as one-line json")
-    parser.add_argument("-L", "--loader", action="store", default=None, help="select a specific loader (i.e. vmx, raw)")
     configure_generic_arguments(parser)
 
     args, rest = parser.parse_known_args()
 
-    process_generic_arguments(args)
-
     if not args.targets and not args.from_file:
         parser.error("too few arguments")
 
@@ -75,10 +71,10 @@ def main():
             targets = targets[:-1]
         args.targets = targets
 
-    targets = args_to_uri(args.targets, args.loader, rest) if args.loader else args.targets
+    process_generic_arguments(args, rest)
 
     try:
-        for i, target in enumerate(Target.open_all(targets)):
+        for i, target in enumerate(Target.open_all(args.targets)):
             try:
                 if args.jsonlines:
                     print(json.dumps(get_target_info(target), default=str))

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/mount.py

@@ -56,9 +56,8 @@ def main():
     parser.add_argument("-o", "--options", help="additional FUSE options")
     configure_generic_arguments(parser)
 
-    args = parser.parse_args()
-
-    process_generic_arguments(args)
+    args, rest = parser.parse_known_args()
+    process_generic_arguments(args, rest)
 
     if not HAS_FUSE:
         parser.exit("fusepy is not installed: pip install fusepy")

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/query.py

@@ -29,7 +29,6 @@ from dissect.target.plugins.general.plugins import (
 )
 from dissect.target.report import ExecutionReport
 from dissect.target.tools.utils import (
-    args_to_uri,
     catch_sigpipe,
     configure_generic_arguments,
     execute_function_on_target,
@@ -134,14 +133,6 @@ def main() -> None:
         help="list (matching) available plugins and loaders",
     )
 
-    parser.add_argument(
-        "-L",
-        "--loader",
-        action="store",
-        default=None,
-        help="select a specific loader (i.e. vmx, raw)",
-    )
-
     parser.add_argument("-s", "--strings", action="store_true", help="print output as string")
     parser.add_argument("-d", "--delimiter", default=" ", action="store", metavar="','")
     parser.add_argument("-j", "--json", action="store_true", help="output records as json")
@@ -172,15 +163,12 @@ def main() -> None:
 
     args, rest = parser.parse_known_args()
 
-    # If loader is specified then map to uri
-    targets = args_to_uri(args.targets, args.loader, rest) if args.loader else args.targets
-
     # Show help for target-query
     if not args.function and ("-h" in rest or "--help" in rest):
         parser.print_help()
         parser.exit()
 
-    process_generic_arguments(args)
+    process_generic_arguments(args, rest)
 
     if args.no_cache:
         cache.IGNORE_CACHE = True
@@ -222,10 +210,10 @@ def main() -> None:
     # Show the list of available plugins for the given optional target and optional
     # search pattern, only display plugins that can be applied to ANY targets
     if args.list is not None:
-        list_plugins(targets, args.list, args.children, args.json, rest)
+        list_plugins(args.targets, args.list, args.children, args.json, rest)
         parser.exit()
 
-    if not targets:
+    if not args.targets:
         parser.error("too few arguments")
 
     if not args.function:
@@ -276,7 +264,7 @@ def main() -> None:
     execution_report.set_event_callbacks(Target)
 
     try:
-        for target in Target.open_all(targets, args.children):
+        for target in Target.open_all(args.targets, args.children):
             if args.child:
                 try:
                     target = target.open_child(args.child)

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/reg.py

@@ -37,11 +37,10 @@ def main():
     parser.add_argument("-kv", "--value", help="value to query")
     parser.add_argument("-d", "--depth", type=int, const=0, nargs="?", default=1, help="max depth of subkeys to print")
     parser.add_argument("-l", "--length", type=int, default=100, help="max length of key value to print")
-
     configure_generic_arguments(parser)
-    args = parser.parse_args()
 
-    process_generic_arguments(args)
+    args, rest = parser.parse_known_args()
+    process_generic_arguments(args, rest)
 
     try:
         for target in Target.open_all(args.targets):

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/shell.py

@@ -44,7 +44,6 @@ from dissect.target.tools.fsutils import (
 )
 from dissect.target.tools.info import print_target_info
 from dissect.target.tools.utils import (
-    args_to_uri,
     catch_sigpipe,
     configure_generic_arguments,
     execute_function_on_target,
@@ -100,7 +99,6 @@ class ExtendedCmd(cmd.Cmd):
 
     def __init__(self, cyber: bool = False):
         cmd.Cmd.__init__(self)
-        self.use_rawinput = False
         self.debug = False
         self.cyber = cyber
         self.identchars += "."
@@ -1516,18 +1514,11 @@ def main() -> None:
     parser.add_argument("targets", metavar="TARGETS", nargs="*", help="targets to load")
     parser.add_argument("-p", "--python", action="store_true", help="(I)Python shell")
     parser.add_argument("-r", "--registry", action="store_true", help="registry shell")
-    parser.add_argument(
-        "-L",
-        "--loader",
-        action="store",
-        default=None,
-        help="select a specific loader (i.e. vmx, raw)",
-    )
     parser.add_argument("-c", "--commands", action="store", nargs="*", help="commands to execute")
     configure_generic_arguments(parser)
+
     args, rest = parser.parse_known_args()
-    args.targets = args_to_uri(args.targets, args.loader, rest) if args.loader else args.targets
-    process_generic_arguments(args)
+    process_generic_arguments(args, rest)
 
     # For the shell tool we want -q to log slightly more then just CRITICAL messages.
     if args.quiet:

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/utils.py

@@ -28,13 +28,14 @@ from dissect.target.plugin import (
 from dissect.target.tools.logging import configure_logging
 
 
-def configure_generic_arguments(args_parser: argparse.ArgumentParser) -> None:
-    args_parser.add_argument("-K", "--keychain-file", type=Path, help="keychain file in CSV format")
-    args_parser.add_argument("-Kv", "--keychain-value", help="passphrase, recovery key or key file path value")
-    args_parser.add_argument("-v", "--verbose", action="count", default=0, help="increase output verbosity")
-    args_parser.add_argument("--version", action="store_true", help="print version")
-    args_parser.add_argument("-q", "--quiet", action="store_true", help="do not output logging information")
-    args_parser.add_argument(
+def configure_generic_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("-K", "--keychain-file", type=Path, help="keychain file in CSV format")
+    parser.add_argument("-Kv", "--keychain-value", help="passphrase, recovery key or key file path value")
+    parser.add_argument("-L", "--loader", action="store", default=None, help="select a specific loader (i.e. vmx, raw)")
+    parser.add_argument("-v", "--verbose", action="count", default=0, help="increase output verbosity")
+    parser.add_argument("--version", action="store_true", help="print version")
+    parser.add_argument("-q", "--quiet", action="store_true", help="do not output logging information")
+    parser.add_argument(
         "--plugin-path",
         action="store",
         nargs="+",
@@ -43,7 +44,7 @@ def configure_generic_arguments(args_parser: argparse.ArgumentParser) -> None:
     )
 
 
-def process_generic_arguments(args: argparse.Namespace) -> None:
+def process_generic_arguments(args: argparse.Namespace, rest: list[str]) -> None:
     configure_logging(args.verbose, args.quiet, as_plain_text=True)
 
     if args.version:
@@ -53,6 +54,15 @@ def process_generic_arguments(args: argparse.Namespace) -> None:
             print("unable to determine version")
         sys.exit(0)
 
+    targets = args.targets if hasattr(args, "targets") else [args.target] if hasattr(args, "target") else []
+    if targets and args.loader:
+        targets = args_to_uri(targets, args.loader, rest)
+
+    if hasattr(args, "targets"):
+        args.targets = targets
+    elif hasattr(args, "target"):
+        args.target = targets[0]
+
     if args.keychain_file:
         keychain.register_keychain_file(args.keychain_file)
 

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48}/dissect/target/tools/yara.py

@@ -8,7 +8,6 @@ from dissect.target.exceptions import TargetError
 from dissect.target.plugins.filesystem.yara import HAS_YARA, YaraPlugin
 from dissect.target.tools.query import record_output
 from dissect.target.tools.utils import (
-    args_to_uri,
     catch_sigpipe,
     configure_generic_arguments,
     process_generic_arguments,
@@ -28,7 +27,6 @@ def main():
 
     parser.add_argument("targets", metavar="TARGETS", nargs="*", help="Targets to load")
     parser.add_argument("-s", "--strings", default=False, action="store_true", help="print output as string")
-    parser.add_argument("-L", "--loader", action="store", default=None, help="select a specific loader (i.e. vmx, raw)")
     parser.add_argument("--children", action="store_true", help="include children")
 
     for args, kwargs in getattr(YaraPlugin.yara, "__args__", []):
@@ -37,7 +35,7 @@ def main():
     configure_generic_arguments(parser)
 
     args, rest = parser.parse_known_args()
-    process_generic_arguments(args)
+    process_generic_arguments(args, rest)
 
     if not HAS_YARA:
         log.error("yara-python is not installed: pip install yara-python")
@@ -47,10 +45,8 @@ def main():
         log.error("No targets provided")
         parser.exit(1)
 
-    targets = args_to_uri(args.targets, args.loader, rest) if args.loader else args.targets
-
     try:
-        for target in Target.open_all(targets, args.children):
+        for target in Target.open_all(args.targets, args.children):
             rs = record_output(args.strings, False)
             for record in target.yara(args.rules, args.path, args.max_size, args.check):
                 rs.write(record)

{dissect_target-3.20.2.dev46 → dissect_target-3.20.2.dev48/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dissect.target
-Version: 3.20.2.dev46
+Version: 3.20.2.dev48
 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.20.2.dev46 → dissect_target-3.20.2.dev48}/tests/tools/test_utils.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import argparse
 from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -11,8 +12,10 @@ from dissect.target.exceptions import UnsupportedPluginError
 from dissect.target.plugin import arg, find_functions
 from dissect.target.tools.utils import (
     args_to_uri,
+    configure_generic_arguments,
     generate_argparse_for_unbound_method,
     persist_execution_report,
+    process_generic_arguments,
 )
 
 if TYPE_CHECKING:
@@ -64,6 +67,60 @@ def test_args_to_uri(targets: list[str], loader_name: str, rest: list[str], uris
         assert args_to_uri(targets, loader_name, rest) == uris
 
 
+def test_process_generic_arguments() -> None:
+    parser = argparse.ArgumentParser()
+    configure_generic_arguments(parser)
+
+    args = parser.parse_args(
+        [
+            "--keychain-file",
+            "/path/to/keychain.csv",
+            "--keychain-value",
+            "some_value",
+            "--loader",
+            "loader_name",
+            "--version",
+            "--plugin-path",
+            "/path/to/plugins",
+        ]
+    )
+    args.targets = ["target1", "target2"]
+    rest = ["--some-other-arg", "value"]
+
+    with (
+        patch("dissect.target.tools.utils.configure_logging") as mocked_configure_logging,
+        patch("dissect.target.tools.utils.version", return_value="1.0.0") as mocked_version,
+        patch("dissect.target.tools.utils.sys.exit") as mocked_exit,
+        patch(
+            "dissect.target.tools.utils.args_to_uri", return_value=["loader_name://target1", "loader_name://target2"]
+        ) as mocked_args_to_uri,
+        patch("dissect.target.tools.utils.keychain.register_keychain_file") as mocked_register_keychain_file,
+        patch("dissect.target.tools.utils.keychain.register_wildcard_value") as mocked_register_wildcard_value,
+        patch(
+            "dissect.target.tools.utils.get_external_module_paths", return_value=["/path/to/plugins"]
+        ) as mocked_get_external_module_paths,
+        patch("dissect.target.tools.utils.load_modules_from_paths") as mocked_load_modules_from_paths,
+    ):
+        process_generic_arguments(args, rest)
+
+        mocked_configure_logging.assert_called_once_with(0, False, as_plain_text=True)
+        mocked_version.assert_called_once_with("dissect.target")
+        mocked_exit.assert_called_once_with(0)
+        mocked_args_to_uri.assert_called_once_with(["target1", "target2"], "loader_name", rest)
+        mocked_register_keychain_file.assert_called_once_with(Path("/path/to/keychain.csv"))
+        mocked_register_wildcard_value.assert_called_once_with("some_value")
+        mocked_get_external_module_paths.assert_called_once_with([Path("/path/to/plugins")])
+        mocked_load_modules_from_paths.assert_called_once_with(["/path/to/plugins"])
+
+        assert args.targets == ["loader_name://target1", "loader_name://target2"]
+
+        del args.targets
+        args.target = "target1"
+        process_generic_arguments(args, rest)
+
+        assert args.target == "loader_name://target1"
+
+
 @pytest.mark.parametrize(
     "pattern, expected_function",
     [