dissect.target 3.22.dev6__tar.gz → 3.22.dev9__tar.gz

{dissect_target-3.22.dev6/dissect.target.egg-info → dissect_target-3.22.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.22.dev6
+Version: 3.22.dev9
 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.22.dev6 → dissect_target-3.22.dev9}/dissect/target/helpers/record.py

@@ -145,13 +145,12 @@ EmptyRecord = RecordDescriptor(
 
 COMMON_INTERFACE_ELEMENTS = [
     ("string", "name"),
-    ("string[]", "mac"),
     ("string", "type"),
     ("boolean", "enabled"),
-    ("net.ipaddress[]", "dns"),
-    ("net.ipaddress[]", "ip"),
+    ("net.ipinterface[]", "cidr"),
     ("net.ipaddress[]", "gateway"),
-    ("net.ipnetwork[]", "network"),
+    ("net.ipaddress[]", "dns"),
+    ("string[]", "mac"),
     ("string", "source"),
 ]
 
@@ -176,7 +175,6 @@ WindowsInterfaceRecord = TargetRecordDescriptor(
         ("stringlist", "search_domain"),
         ("datetime", "first_connected"),
         ("datetime", "last_connected"),
-        ("net.ipaddress[]", "subnetmask"),
         ("boolean", "dhcp"),
         ("varint", "vlan"),
     ],

dissect_target-3.22.dev9/dissect/target/plugins/apps/chat/chat.py

@@ -0,0 +1,51 @@
+from typing import Union
+
+from dissect.target.helpers.descriptor_extensions import UserRecordDescriptorExtension
+from dissect.target.helpers.record import create_extended_descriptor
+from dissect.target.plugin import NamespacePlugin
+
+COMMON_FIELDS = [
+    ("datetime", "ts"),
+    ("string", "client"),
+    ("string", "account"),
+    ("string", "sender"),
+    ("string", "recipient"),
+]
+
+GENERIC_USER_FIELDS = [
+    ("datetime", "ts_mtime"),
+    ("string", "client"),
+    ("string", "account"),
+]
+
+GENERIC_ATTACHMENT_FIELDS = [
+    *COMMON_FIELDS,
+    ("path", "attachment"),
+    ("string", "description"),
+]
+
+GENERIC_MESSAGE_FIELDS = [
+    *COMMON_FIELDS,
+    ("string", "message"),
+]
+
+ChatUserRecord = create_extended_descriptor([UserRecordDescriptorExtension])(
+    "chat/user",
+    GENERIC_USER_FIELDS,
+)
+
+ChatMessageRecord = create_extended_descriptor([UserRecordDescriptorExtension])(
+    "chat/message",
+    GENERIC_MESSAGE_FIELDS,
+)
+
+ChatAttachmentRecord = create_extended_descriptor([UserRecordDescriptorExtension])(
+    "chat/attachment",
+    GENERIC_ATTACHMENT_FIELDS,
+)
+
+ChatRecord = Union[ChatUserRecord, ChatMessageRecord, ChatAttachmentRecord]
+
+
+class ChatPlugin(NamespacePlugin):
+    __namespace__ = "chat"

dissect_target-3.22.dev9/dissect/target/plugins/apps/chat/msn.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+from defusedxml import ElementTree as ET
+
+from dissect.target import Target
+from dissect.target.exceptions import UnsupportedPluginError
+from dissect.target.helpers.fsutil import TargetPath
+from dissect.target.plugin import export
+from dissect.target.plugins.apps.chat.chat import (
+    ChatAttachmentRecord,
+    ChatMessageRecord,
+    ChatPlugin,
+)
+from dissect.target.plugins.general.users import UserDetails
+
+
+class MSNPlugin(ChatPlugin):
+    """Microsoft MSN Messenger plugin.
+
+    Supports the following versions on Windows XP and Windows 7:
+        - Windows Live Messenger (WLM) 2009
+        - MSN 7.5
+
+    Other versions might work but have not been tested. Does not support ``Messenger Plus! Live`` artifacts.
+    Tested using Escargot (https://escargot.chat).
+
+    Resources:
+        - https://en.wikipedia.org/wiki/Microsoft_Messenger_service
+        - https://en.wikipedia.org/wiki/MSN_Messenger
+        - http://computerforensics.parsonage.co.uk/downloads/MSNandLiveMessengerArtefactsOfConversations.pdf
+    """
+
+    __namespace__ = "msn"
+
+    DATA_PATH = "Application Data\\Microsoft\\MSN Messenger"
+    HIST_PATH = "My Documents\\My Received Files"
+
+    def __init__(self, target: Target):
+        super().__init__(target)
+        self.installs = list(self.find_installs())
+
+    def find_installs(self) -> Iterator[tuple[UserDetails, TargetPath]]:
+        for user_details in self.target.user_details.all_with_home():
+            if (path := self.target.fs.path(user_details.user.home).joinpath(self.DATA_PATH)).exists():
+                for profile in path.iterdir():
+                    if profile.is_dir():
+                        yield user_details, profile
+
+    def check_compatible(self) -> None:
+        if not self.installs:
+            raise UnsupportedPluginError("No Microsoft MSN installs found on target")
+
+    @export(record=[ChatMessageRecord, ChatAttachmentRecord])
+    def history(self) -> Iterator[ChatMessageRecord | ChatAttachmentRecord]:
+        """Yield MSN chat history messages.
+
+        Chat history artifacts can be found in:
+            - ``$HOME/My Documents/My Received Files/MsnMsgr.txt``
+            - ``$HOME/My Documents/My Received Files/$username$PassportID/History/*.xml``
+        """
+
+        for user_details, profile in self.installs:
+            if not (hist_root := self.target.fs.path(user_details.user.home).joinpath(self.HIST_PATH)).exists():
+                self.target.log.warning(
+                    "User %s does not have saved MSN chat history: directory %s does not exist",
+                    user_details.user.name,
+                    hist_root,
+                )
+                continue
+
+            hist_dir = None
+            for item in hist_root.iterdir():
+                if item.is_dir() and (hist_dir := item.name).endswith(profile.name):
+                    for hist_file in hist_root.joinpath(hist_dir).joinpath("History").glob("*.xml"):
+                        try:
+                            xml = ET.fromstring(hist_file.read_text())
+                        except Exception as e:
+                            self.target.log.warning("XML file %s is malformed: %s", hist_file, e)
+                            continue
+
+                        for entry in xml:
+                            common = {
+                                "ts": entry.attrib.get("DateTime", 0),
+                                "client": self.__namespace__,
+                                "account": profile.name,
+                                "sender": entry.find(".//From/User").get("FriendlyName"),
+                                "_user": user_details.user,
+                                "_target": self.target,
+                            }
+
+                            if entry.tag == "Message":
+                                yield ChatMessageRecord(
+                                    **common,
+                                    recipient=entry.find(".//To/User").get("FriendlyName"),
+                                    message=entry.find(".//Text").text,
+                                )
+
+                            elif entry.tag in ["Invitation", "InvitationResponse"]:
+                                if (file := entry.find(".//File")) is not None:
+                                    yield ChatAttachmentRecord(
+                                        **common,
+                                        recipient=None,  # unknown with Invitations
+                                        attachment=file.text,
+                                        description=entry.find(".//Text").text,
+                                    )
+
+
+def convert_email(string: str) -> int:
+    """Convert MSN email address to 10 digit Passport ID."""
+    num = 0
+    for char in string.lower():
+        num = num * 101 + ord(char)
+        num -= (num // 4294967296) * 4294967296
+    return num

{dissect_target-3.22.dev6 → dissect_target-3.22.dev9}/dissect/target/plugins/os/default/network.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from typing import Any, Iterator, Union, get_args
+from operator import attrgetter
+from typing import TYPE_CHECKING, Any, Callable, Union, get_args
 
 from flow.record.fieldtypes.net import IPAddress, IPNetwork
-from flow.record.fieldtypes.net.ipv4 import Address, addr_long, addr_str, mask_to_bits
 
 from dissect.target.helpers.record import (
     MacInterfaceRecord,
@@ -11,8 +11,11 @@ from dissect.target.helpers.record import (
     WindowsInterfaceRecord,
 )
 from dissect.target.plugin import Plugin, export, internal
-from dissect.target.target import Target
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from dissect.target.target import Target
 InterfaceRecord = Union[UnixInterfaceRecord, WindowsInterfaceRecord, MacInterfaceRecord]
 
 
@@ -31,15 +34,15 @@ class NetworkPlugin(Plugin):
     def _interfaces(self) -> Iterator[InterfaceRecord]:
         yield from ()
 
-    def _get_record_type(self, field_name: str) -> Iterator[Any]:
+    def _get_record_type(self, field_name: str, func: Callable[[Any], Any] | None = None) -> Iterator[Any]:
         for record in self.interfaces():
             if (output := getattr(record, field_name, None)) is None:
                 continue
 
-            if isinstance(output, list):
-                yield from output
-            else:
-                yield output
+            if not isinstance(output, list):
+                output = [output]
+
+            yield from (map(func, output) if func else output)
 
     @export(record=get_args(InterfaceRecord))
     def interfaces(self) -> Iterator[InterfaceRecord]:
@@ -53,7 +56,7 @@ class NetworkPlugin(Plugin):
     @export
     def ips(self) -> list[IPAddress]:
         """Return IP addresses as list of :class:`IPAddress`."""
-        return list(set(self._get_record_type("ip")))
+        return list(set(self._get_record_type("cidr", attrgetter("ip"))))
 
     @export
     def gateways(self) -> list[IPAddress]:
@@ -72,26 +75,22 @@ class NetworkPlugin(Plugin):
 
     @internal
     def with_ip(self, ip_addr: str) -> Iterator[InterfaceRecord]:
+        """Yield all interfaces with the given IP address."""
         for interface in self.interfaces():
-            if ip_addr in interface.ip:
+            if any(iface.ip == ip_addr for iface in interface.cidr):
                 yield interface
 
     @internal
     def with_mac(self, mac: str) -> Iterator[InterfaceRecord]:
+        """Yield all interfaces with the given full or partial MAC address."""
         for interface in self.interfaces():
             if mac in interface.mac:
                 yield interface
 
     @internal
     def in_cidr(self, cidr: str) -> Iterator[InterfaceRecord]:
+        """Yield all interfaces with IP addresses in the given CIDR range."""
         cidr = IPNetwork(cidr)
         for interface in self.interfaces():
-            if any(ip_addr in cidr for ip_addr in interface.ip):
+            if any(iface.ip in cidr for iface in interface.cidr):
                 yield interface
-
-    def calculate_network(self, ips: int | Address, subnets: int | Address) -> Iterator[str]:
-        for ip, subnet_mask in zip(ips, subnets):
-            subnet_mask_int = addr_long(subnet_mask)
-            cidr = mask_to_bits(subnet_mask_int)
-            network_address = addr_str(addr_long(ip) & subnet_mask_int)
-            yield f"{network_address}/{cidr}"

{dissect_target-3.22.dev6 → dissect_target-3.22.dev9}/dissect/target/plugins/os/unix/bsd/osx/network.py

@@ -2,11 +2,16 @@ from __future__ import annotations
 
 import plistlib
 from functools import cache, lru_cache
-from typing import Iterator
+from typing import TYPE_CHECKING
 
+from dissect.target.exceptions import FileNotFoundError
 from dissect.target.helpers.record import MacInterfaceRecord
 from dissect.target.plugins.os.default.network import NetworkPlugin
-from dissect.target.target import Target
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from dissect.target.target import Target
 
 
 class MacNetworkPlugin(NetworkPlugin):
@@ -26,6 +31,8 @@ class MacNetworkPlugin(NetworkPlugin):
         if (preferences := self.target.fs.path("/Library/Preferences/SystemConfiguration/preferences.plist")).exists():
             return plistlib.load(preferences.open())
 
+        raise FileNotFoundError("Couldn't find preferences file")
+
     def _interfaces(self) -> Iterator[MacInterfaceRecord]:
         plistnetwork = self._plistnetwork()
         current_set = plistnetwork.get("CurrentSet")
@@ -46,45 +53,46 @@ class MacNetworkPlugin(NetworkPlugin):
         for _id, interface in network.items():
             dns = set()
             gateways = set()
-            ips = set()
             device = interface.get("Interface", {})
             name = device.get("DeviceName")
             _type = device.get("Type")
             vlan = vlan_lookup.get(name)
             dhcp = False
-            subnetmask = []
-            network = []
+            ifaces = set()
             interface_service_order = service_order.index(_id) if _id in service_order else None
             try:
                 for addr in interface.get("DNS", {}).get("ServerAddresses", {}):
                     dns.add(addr)
+
                 for addresses in [interface.get("IPv4", {}), interface.get("IPv6", {})]:
-                    subnetmask += filter(lambda mask: mask != "", addresses.get("SubnetMasks", []))
+                    iface = ""
                     if router := addresses.get("Router"):
                         gateways.add(router)
+
                     if addresses.get("ConfigMethod", "") == "DHCP":
-                        ips.add(self._plistlease(name).get("IPAddress"))
+                        iface = self._plistlease(name).get("IPAddress")
                         dhcp = True
-                    else:
-                        for addr in addresses.get("Addresses", []):
-                            ips.add(addr)
+                    elif addr := addresses.get("Addresses", []):
+                        iface = addr[0]
+
+                    if _subnet_mask := list(filter(None, addresses.get("SubnetMasks", []))):
+                        iface = f"{iface}/{_subnet_mask[0]}"
 
-                if subnetmask:
-                    network = self.calculate_network(ips, subnetmask)
+                    if iface:
+                        ifaces.add(iface)
 
                 yield MacInterfaceRecord(
                     name=name,
                     type=_type,
                     enabled=not interface.get("__INACTIVE__", False),
-                    dns=list(dns),
-                    ip=list(ips),
+                    cidr=ifaces,
                     gateway=list(gateways),
+                    dns=list(dns),
+                    mac=[],
                     source="NetworkServices",
-                    vlan=vlan,
-                    network=network,
                     interface_service_order=interface_service_order,
                     dhcp=dhcp,
-                    mac=[],
+                    vlan=vlan,
                     _target=self.target,
                 )
 

{dissect_target-3.22.dev6 → dissect_target-3.22.dev9}/dissect/target/plugins/os/unix/linux/network.py

@@ -81,21 +81,22 @@ class NetworkManagerConfigParser(LinuxNetworkConfigParser):
         dhcp_ipv6: bool = False
         vlan: set[int] = field(default_factory=set)
 
-        def to_record(self) -> UnixInterfaceRecord:
+        def to_record(self, target: Target) -> UnixInterfaceRecord:
             return UnixInterfaceRecord(
-                source=self.source,
-                last_connected=self.last_connected,
                 name=self.name,
-                mac=to_list(self.mac_address),
                 type=self.type,
+                enabled=None,
+                cidr=self.ip_interfaces,
+                gateway=list(self.gateways),
+                dns=list(self.dns),
+                mac=to_list(self.mac_address),
+                source=self.source,
                 dhcp_ipv4=self.dhcp_ipv4,
                 dhcp_ipv6=self.dhcp_ipv6,
-                dns=list(self.dns),
-                ip=[interface.ip for interface in self.ip_interfaces],
-                network=[interface.network for interface in self.ip_interfaces],
-                gateway=list(self.gateways),
+                last_connected=self.last_connected,
                 vlan=list(self.vlan),
                 configurator="NetworkManager",
+                _target=target,
             )
 
     def interfaces(self) -> Iterator[UnixInterfaceRecord]:
@@ -138,7 +139,7 @@ class NetworkManagerConfigParser(LinuxNetworkConfigParser):
             vlan_ids_from_uuid = vlan_id_by_interface.get(connection.uuid, set())
             connection.vlan.update(vlan_ids_from_uuid)
 
-            yield connection.to_record()
+            yield connection.to_record(self._target)
 
     def _parse_route(self, route: str) -> NetAddress | None:
         """Parse a route and return gateway IP address."""
@@ -284,19 +285,19 @@ class SystemdNetworkConfigParser(LinuxNetworkConfigParser):
                 dhcp_ipv4, dhcp_ipv6 = self._parse_dhcp(network_section.get("DHCP"))
 
                 yield UnixInterfaceRecord(
-                    source=str(config_file),
+                    name=match_section.get("Name"),
                     type=match_section.get("Type"),
                     enabled=None,  # Unknown, dependent on run-time state
-                    dhcp_ipv4=dhcp_ipv4,
-                    dhcp_ipv6=dhcp_ipv6,
-                    name=match_section.get("Name"),
+                    cidr=ip_interfaces,
+                    gateway=list(gateways),
                     dns=list(dns),
                     mac=list(mac_addresses),
-                    ip=[interface.ip for interface in ip_interfaces],
-                    network=[interface.network for interface in ip_interfaces],
-                    gateway=list(gateways),
+                    source=str(config_file),
+                    dhcp_ipv4=dhcp_ipv4,
+                    dhcp_ipv6=dhcp_ipv6,
                     vlan=list(vlan_ids),
                     configurator="systemd-networkd",
+                    _target=self._target,
                 )
             except Exception as e:
                 self._target.log.warning("Error parsing network config file %s", config_file)

{dissect_target-3.22.dev6 → dissect_target-3.22.dev9}/dissect/target/plugins/os/windows/_os.py

@@ -311,6 +311,10 @@ class WindowsPlugin(OSPlugin):
                     home = profile_image_path.value
                     name = home.split("\\")[-1]
 
+                # Windows XP uses %variables% in home paths
+                if "%" in home:
+                    home = self.target.resolve(home)
+
                 yield WindowsUserRecord(
                     sid=subkey.name,
                     name=name,

{dissect_target-3.22.dev6 → dissect_target-3.22.dev9}/dissect/target/plugins/os/windows/network.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import re
 from enum import IntEnum
 from functools import lru_cache
-from typing import Iterator
+from typing import TYPE_CHECKING
 
 from dissect.util.ts import wintimestamp
 
@@ -12,9 +12,13 @@ from dissect.target.exceptions import (
     RegistryValueNotFoundError,
 )
 from dissect.target.helpers.record import WindowsInterfaceRecord
-from dissect.target.helpers.regutil import RegistryKey
 from dissect.target.plugins.os.default.network import NetworkPlugin
-from dissect.target.target import Target
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from dissect.target.helpers.regutil import RegistryKey
+    from dissect.target.target import Target
 
 
 class IfTypes(IntEnum):
@@ -238,6 +242,20 @@ def _get_config_value(key: RegistryKey, name: str, sep: str | None = None) -> se
     return {value}
 
 
+def _construct_interface(key: RegistryKey, ip_key: str, subnet_key: str) -> set[str]:
+    interface = ""
+    if ip := _get_config_value(key, ip_key):
+        interface = next(iter(ip))
+
+    if subnet := _get_config_value(key, subnet_key):
+        interface = f"{interface}/{next(iter(subnet))}"
+
+    if not interface:
+        return set()
+
+    return {interface}
+
+
 class WindowsNetworkPlugin(NetworkPlugin):
     """Windows network interface plugin."""
 
@@ -300,10 +318,9 @@ class WindowsNetworkPlugin(NetworkPlugin):
                     # skip this network interface.
                     if not conf or not any(
                         [
-                            conf["dns"],
-                            conf["ip"],
+                            conf["cidr"],
                             conf["gateway"],
-                            conf["subnetmask"],
+                            conf["dns"],
                             conf["search_domain"],
                         ]
                     ):
@@ -322,21 +339,17 @@ class WindowsNetworkPlugin(NetworkPlugin):
         """Extract network device configuration from the given interface_id for all ControlSets on the system."""
 
         dhcp_config = {
+            "cidr": set(),
             "gateway": set(),
-            "ip": set(),
             "dns": set(),
-            "subnetmask": set(),
             "search_domain": set(),
-            "network": set(),
         }
 
         static_config = {
-            "ip": set(),
+            "cidr": set(),
+            "gateway": set(),
             "dns": set(),
-            "subnetmask": set(),
             "search_domain": set(),
-            "gateway": set(),
-            "network": set(),
         }
 
         # Get the registry keys for the given interface id
@@ -349,36 +362,27 @@ class WindowsNetworkPlugin(NetworkPlugin):
         except RegistryKeyNotFoundError:
             return []
 
-        if not len(keys):
+        if not keys:
             return []
 
         for key in keys:
             # Extract DHCP configuration from the registry
+            dhcp_config["cidr"].update(_construct_interface(key, "DhcpIPAddress", "DhcpSubnetMask"))
             dhcp_config["gateway"].update(_get_config_value(key, "DhcpDefaultGateway"))
-            dhcp_config["ip"].update(_get_config_value(key, "DhcpIPAddress"))
-            dhcp_config["subnetmask"].update(_get_config_value(key, "DhcpSubnetMask"))
-            dhcp_config["search_domain"].update(_get_config_value(key, "DhcpDomain"))
             dhcp_config["dns"].update(_get_config_value(key, "DhcpNameServer", " ,"))
+            dhcp_config["search_domain"].update(_get_config_value(key, "DhcpDomain"))
 
             # Extract static configuration from the registry
+            static_config["cidr"].update(_construct_interface(key, "IPAddress", "SubnetMask"))
             static_config["gateway"].update(_get_config_value(key, "DefaultGateway"))
             static_config["dns"].update(_get_config_value(key, "NameServer", " ,"))
             static_config["search_domain"].update(_get_config_value(key, "Domain"))
-            static_config["ip"].update(_get_config_value(key, "IPAddress"))
-            static_config["subnetmask"].update(_get_config_value(key, "SubnetMask"))
-
-        if len(dhcp_config) > 0:
-            dhcp_config["enabled"] = _try_value(key, "EnableDHCP") == 1
-            dhcp_config["dhcp"] = True
 
-        if len(static_config) > 0:
-            static_config["enabled"] = None
-            static_config["dhcp"] = False
+        dhcp_config["enabled"] = _try_value(key, "EnableDHCP") == 1
+        dhcp_config["dhcp"] = True
 
-        # Iterate over combined ip/subnet lists
-        for config in (dhcp_config, static_config):
-            if (ips := config.get("ip")) and (masks := config.get("subnetmask")):
-                config["network"].update(set(self.calculate_network(ips, masks)))
+        static_config["enabled"] = None
+        static_config["dhcp"] = False
 
         # Return both configurations
         return [dhcp_config, static_config]

{dissect_target-3.22.dev6 → dissect_target-3.22.dev9}/dissect/target/tools/shell.py

@@ -306,9 +306,10 @@ class ExtendedCmd(cmd.Cmd):
 
     def do_man(self, line: str) -> bool:
         """alias for help"""
-        return self.do_help(line)
+        self.do_help(line)
+        return False
 
-    def complete_man(self, *args) -> list[str]:
+    def complete_man(self, *args: list[str]) -> list[str]:
         return cmd.Cmd.complete_help(self, *args)
 
     def do_unalias(self, line: str) -> bool:
@@ -403,16 +404,16 @@ class TargetCmd(ExtendedCmd):
             self.histfile = pathlib.Path(getattr(target._config, "HISTFILE", self.DEFAULT_HISTFILE)).expanduser()
 
         # prompt format
+        self.prompt_ps1 = "{BOLD_GREEN}{base}{RESET}:{BOLD_BLUE}{cwd}{RESET}$ "
         if ps1 := getattr(target._config, "PS1", None):
             if "{cwd}" in ps1 and "{base}" in ps1:
                 self.prompt_ps1 = ps1
+            else:
+                self.target.log.warning("{cwd} and {base} were not set inside PS1, using the default prompt")
 
         elif getattr(target._config, "NO_COLOR", None) or os.getenv("NO_COLOR"):
             self.prompt_ps1 = "{base}:{cwd}$ "
 
-        else:
-            self.prompt_ps1 = "{BOLD_GREEN}{base}{RESET}:{BOLD_BLUE}{cwd}{RESET}$ "
-
         super().__init__(self.target.props.get("cyber"))
 
     def _get_targetrc_path(self) -> pathlib.Path:

{dissect_target-3.22.dev6 → dissect_target-3.22.dev9/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dissect.target
-Version: 3.22.dev6
+Version: 3.22.dev9
 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.22.dev6 → dissect_target-3.22.dev9}/dissect.target.egg-info/SOURCES.txt

@@ -150,6 +150,9 @@ dissect/target/plugins/apps/browser/chromium.py
 dissect/target/plugins/apps/browser/edge.py
 dissect/target/plugins/apps/browser/firefox.py
 dissect/target/plugins/apps/browser/iexplore.py
+dissect/target/plugins/apps/chat/__init__.py
+dissect/target/plugins/apps/chat/chat.py
+dissect/target/plugins/apps/chat/msn.py
 dissect/target/plugins/apps/container/__init__.py
 dissect/target/plugins/apps/container/docker.py
 dissect/target/plugins/apps/database/__init__.py
@@ -512,6 +515,8 @@ tests/plugins/apps/browser/test_chromium.py
 tests/plugins/apps/browser/test_edge.py
 tests/plugins/apps/browser/test_firefox.py
 tests/plugins/apps/browser/test_iexplore.py
+tests/plugins/apps/chat/__init__.py
+tests/plugins/apps/chat/test_msn.py
 tests/plugins/apps/container/__init__.py
 tests/plugins/apps/container/test_docker.py
 tests/plugins/apps/editor/__init__.py