dissect.target 3.20.dev44__tar.gz → 3.20.dev47__tar.gz

{dissect_target-3.20.dev44/dissect.target.egg-info → dissect_target-3.20.dev47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.20.dev44
+Version: 3.20.dev47
 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.dev44 → dissect_target-3.20.dev47}/dissect/target/filesystems/ffs.py

@@ -126,6 +126,12 @@ class FfsFilesystemEntry(FilesystemEntry):
             ]
         )
 
+        # Note: stat on linux always returns the default block size of 4096
+        # We are returning the actual block size of the filesystem, as on BSD
+        st_info.st_blksize = self.fs.ffs.block_size
+        # Note: st_blocks * 512 can be lower than st_blksize because FFS employs fragments
+        st_info.st_blocks = self.entry.nblocks
+
         # Set the nanosecond resolution separately
         st_info.st_atime_ns = self.entry.atime_ns
         st_info.st_mtime_ns = self.entry.mtime_ns
@@ -134,5 +140,6 @@ class FfsFilesystemEntry(FilesystemEntry):
         # FFS2 has a birth time, FFS1 does not
         if btime := self.entry.btime:
             st_info.st_birthtime = btime.timestamp()
+            st_info.st_birthtime_ns = self.entry.btime_ns
 
         return st_info

dissect_target-3.20.dev47/dissect/target/plugins/os/unix/log/auth.py

@@ -0,0 +1,373 @@
+from __future__ import annotations
+
+import itertools
+import logging
+import re
+from abc import ABC, abstractmethod
+from datetime import datetime
+from functools import lru_cache
+from itertools import chain
+from pathlib import Path
+from typing import Any, Iterator
+
+from dissect.target import Target
+from dissect.target.exceptions import UnsupportedPluginError
+from dissect.target.helpers.fsutil import open_decompress
+from dissect.target.helpers.record import DynamicDescriptor, TargetRecordDescriptor
+from dissect.target.helpers.utils import year_rollover_helper
+from dissect.target.plugin import Plugin, alias, export
+
+log = logging.getLogger(__name__)
+
+RE_TS = re.compile(r"^[A-Za-z]{3}\s*\d{1,2}\s\d{1,2}:\d{2}:\d{2}")
+RE_TS_ISO = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}\+\d{2}:\d{2}")
+RE_LINE = re.compile(
+    r"""
+    \d{2}:\d{2}\s                           # First match on the similar ending of the different timestamps
+    (?P<hostname>\S+)\s                     # The hostname
+    (?P<service>\S+?)(\[(?P<pid>\d+)\])?:   # The service with optionally the PID between brackets
+    \s*(?P<message>.+?)\s*$                 # The log message stripped from spaces left and right
+    """,
+    re.VERBOSE,
+)
+
+# Generic regular expressions
+RE_IPV4_ADDRESS = re.compile(
+    r"""
+    ((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}   # First three octets
+    (25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)          # Last octet
+    """,
+    re.VERBOSE,
+)
+RE_USER = re.compile(r"for ([^\s]+)")
+
+
+class BaseService(ABC):
+    @classmethod
+    @abstractmethod
+    def parse(cls, message: str) -> dict[str, any]:
+        pass
+
+
+class SudoService(BaseService):
+    """Parsing of sudo service messages in the auth log."""
+
+    RE_SUDO_COMMAND = re.compile(
+        r"""
+        TTY=(?P<tty>\w+\/\w+)\s;\s          # The TTY -> TTY=pts/0 ;
+        PWD=(?P<pwd>[\/\w]+)\s;\s           # The current working directory -> PWD="/home/user" ;
+        USER=(?P<effective_user>\w+)\s;\s   # The effective user -> USER=root ;
+        COMMAND=(?P<command>.+)$            # The command -> COMMAND=/usr/bin/whoami
+        """,
+        re.VERBOSE,
+    )
+
+    @classmethod
+    def parse(cls, message: str) -> dict[str, str]:
+        """Parse auth log message from sudo."""
+        if not (match := cls.RE_SUDO_COMMAND.search(message)):
+            return {}
+
+        additional_fields = {}
+        for key, value in match.groupdict().items():
+            additional_fields[key] = value
+
+        return additional_fields
+
+
+class SshdService(BaseService):
+    """Class for parsing sshd messages in the auth log."""
+
+    RE_SSHD_PORTREGEX = re.compile(r"port\s(\d+)")
+    RE_USER = re.compile(r"for\s([^\s]+)")
+
+    @classmethod
+    def parse(cls, message: str) -> dict[str, str | int]:
+        """Parse message from sshd"""
+        additional_fields = {}
+        if ip_address := RE_IPV4_ADDRESS.search(message):
+            field_name = "host_ip" if "listening" in message else "remote_ip"
+            additional_fields[field_name] = ip_address.group(0)
+        if port := cls.RE_SSHD_PORTREGEX.search(message):
+            additional_fields["port"] = int(port.group(1))
+        if user := cls.RE_USER.search(message):
+            additional_fields["user"] = user.group(1)
+        # Accepted publickey for test_user from 8.8.8.8 IP port 12345 ssh2: RSA SHA256:123456789asdfghjklertzuio
+        if "Accepted publickey" in message:
+            ssh_protocol, encryption_algo, key_info = message.split()[-3:]
+            hash_algo, key_hash = key_info.split(":")
+            additional_fields["ssh_protocol"] = ssh_protocol.strip(":")
+            additional_fields["encryption_algorithm"] = encryption_algo
+            additional_fields["hash_algorithm"] = hash_algo
+            additional_fields["key_hash"] = key_hash
+        if (failed := "Failed" in message) or "Accepted" in message:
+            action_type = "failed" if failed else "accepted"
+            additional_fields["action"] = f"{action_type} authentication"
+            additional_fields["authentication_type"] = "password" if "password" in message else "publickey"
+
+        return additional_fields
+
+
+class SystemdLogindService(BaseService):
+    """Class for parsing systemd-logind messages in the auth log."""
+
+    RE_SYSTEMD_LOGIND_WATCHING = re.compile(
+        r"""
+        (?P<action>Watching\ssystem\sbuttons)\s # Action is "Watching system buttons"
+        on\s(?P<device>[^\s]+)\s                # The device the button is related to -> /dev/input/event0
+        \((?P<device_name>.*?)\)                # The device (button) name -> (Power button)
+        """,
+        re.VERBOSE,
+    )
+
+    @classmethod
+    def parse(cls, message: str):
+        """Parse auth log message from systemd-logind."""
+        additional_fields = {}
+        # Example: Nov 14 07:14:09 ubuntu-1 systemd-logind[4]: Removed session 4.
+        if "Removed" in message:
+            additional_fields["action"] = "removed session"
+            additional_fields["session"] = message.split()[-1].strip(".")
+        elif "Watching" in message and (match := cls.RE_SYSTEMD_LOGIND_WATCHING.search(message)):
+            for key, value in match.groupdict().items():
+                additional_fields[key] = value
+        # Example: New session 4 of user sampleuser.
+        elif "New session" in message:
+            parts = message.removeprefix("New session ").split()
+            additional_fields["action"] = "new session"
+            additional_fields["session"] = parts[0]
+            additional_fields["user"] = parts[-1].strip(".")
+        # Example: Session 4 logged out. Waiting for processes to exit.
+        elif "logged out" in message:
+            session = message.removeprefix("Session ").split(maxsplit=1)[0]
+            additional_fields["action"] = "logged out session"
+            additional_fields["session"] = session
+        # Example: New seat seat0.
+        elif "New seat" in message:
+            seat = message.split()[-1].strip(".")
+            additional_fields["action"] = "new seat"
+            additional_fields["seat"] = seat
+
+        return additional_fields
+
+
+class SuService(BaseService):
+    """Class for parsing su messages in the auth log."""
+
+    RE_SU_BY = re.compile(r"by\s([^\s]+)")
+    RE_SU_ON = re.compile(r"on\s([^\s]+)")
+    RE_SU_COMMAND = re.compile(r"'(.*?)'")
+
+    @classmethod
+    def parse(cls, message: str) -> dict[str, str]:
+        additional_fields = {}
+        if user := RE_USER.search(message):
+            additional_fields["user"] = user.group(1)
+        if by := cls.RE_SU_BY.search(message):
+            additional_fields["by"] = by.group(1)
+        if on := cls.RE_SU_ON.search(message):
+            additional_fields["device"] = on.group(1)
+        if command := cls.RE_SU_COMMAND.search(message):
+            additional_fields["command"] = command.group(1)
+        if (failed := "failed" in message) or "Successful" in message:
+            additional_fields["su_result"] = "failed" if failed else "success"
+
+        return additional_fields
+
+
+class PkexecService(BaseService):
+    """Class for parsing pkexec messages in the auth log."""
+
+    RE_PKEXEC_COMMAND = re.compile(
+        r"""
+        (?P<user>\S+?):\sExecuting\scommand\s   # Starts with actual user -> user:
+        \[USER=(?P<effective_user>[^\]]+)\]\s   # The impersonated user -> [USER=root]
+        \[TTY=(?P<tty>[^\]]+)\]\s               # The tty -> [TTY=unknown]
+        \[CWD=(?P<cwd>[^\]]+)\]\s               # Current working directory -> [CWD=/home/user]
+        \[COMMAND=(?P<command>[^\]]+)\]         # Command -> [COMMAND=/usr/lib/example]
+        """,
+        re.VERBOSE,
+    )
+
+    @classmethod
+    def parse(cls, message: str) -> dict[str, str]:
+        """Parse auth log message from pkexec"""
+        additional_fields = {}
+        if exec_cmd := cls.RE_PKEXEC_COMMAND.search(message):
+            additional_fields["action"] = "executing command"
+            for key, value in exec_cmd.groupdict().items():
+                if value and value.isdigit():
+                    value = int(value)
+                additional_fields[key] = value
+
+        return additional_fields
+
+
+class PamUnixService(BaseService):
+    RE_PAM_UNIX = re.compile(
+        r"""
+        pam_unix\([^\s]+:session\):\s(?P<action>session\s\w+)\s     # Session action, usually opened or closed
+        for\suser\s(?P<user>[^\s\(]+)(?:\(uid=(?P<user_uid>\d+)\))? # User may contain uid like: root(uid=0)
+        (?:\sby\s\(uid=(?P<by_uid>\d+)\))?$                         # Opened action also contains by
+        """,
+        re.VERBOSE,
+    )
+
+    @classmethod
+    def parse(cls, message):
+        """Parse auth log message from pluggable authentication modules (PAM)."""
+        if not (match := cls.RE_PAM_UNIX.search(message)):
+            return {}
+
+        additional_fields = {}
+        for key, value in match.groupdict().items():
+            if value and value.isdigit():
+                value = int(value)
+            additional_fields[key] = value
+
+        return additional_fields
+
+
+class AuthLogRecordBuilder:
+    """Class for dynamically creating auth log records."""
+
+    RECORD_NAME = "linux/log/auth"
+    SERVICES: dict[str, BaseService] = {
+        "su": SuService,
+        "sudo": SudoService,
+        "sshd": SshdService,
+        "systemd-logind": SystemdLogindService,
+        "pkexec": PkexecService,
+    }
+
+    def __init__(self, target: Target):
+        self._create_event_descriptor = lru_cache(4096)(self._create_event_descriptor)
+        self.target = target
+
+    def _parse_additional_fields(self, service: str | None, message: str) -> dict[str, Any]:
+        """Parse additional fields in the message based on the service."""
+        if "pam_unix(" in message:
+            return PamUnixService.parse(message)
+
+        if service not in self.SERVICES:
+            self.target.log.debug("Service %s is not recognised, no additional fields could be parsed", service)
+            return {}
+
+        try:
+            return self.SERVICES[service].parse(message)
+        except Exception as e:
+            self.target.log.warning("Parsing additional fields in message '%s' for service %s failed", message, service)
+            self.target.log.debug("", exc_info=e)
+            raise e
+
+    def build_record(self, ts: datetime, source: Path, line: str) -> TargetRecordDescriptor:
+        """Builds an ``AuthLog`` event record."""
+
+        record_fields = [
+            ("datetime", "ts"),
+            ("path", "source"),
+            ("string", "service"),
+            ("varint", "pid"),
+            ("string", "message"),
+        ]
+
+        record_values = {
+            "ts": ts,
+            "message": line,
+            "service": None,
+            "pid": None,
+            "source": source,
+            "_target": self.target,
+        }
+
+        match = RE_LINE.search(line)
+        if match:
+            record_values.update(match.groupdict())
+
+        for key, value in self._parse_additional_fields(record_values["service"], line).items():
+            record_type = "string"
+            if isinstance(value, int):
+                record_type = "varint"
+
+            record_fields.append((record_type, key))
+            record_values[key] = value
+
+        # tuple conversion here is needed for lru_cache
+        desc = self._create_event_descriptor(tuple(record_fields))
+        return desc(**record_values)
+
+    def _create_event_descriptor(self, record_fields) -> TargetRecordDescriptor:
+        return TargetRecordDescriptor(self.RECORD_NAME, record_fields)
+
+
+class AuthPlugin(Plugin):
+    """Unix authentication log plugin."""
+
+    def __init__(self, target: Target):
+        super().__init__(target)
+        self._auth_log_builder = AuthLogRecordBuilder(target)
+
+    def check_compatible(self) -> None:
+        var_log = self.target.fs.path("/var/log")
+        if not any(var_log.glob("auth.log*")) and not any(var_log.glob("secure*")):
+            raise UnsupportedPluginError("No auth log files found")
+
+    @alias("securelog")
+    @export(record=DynamicDescriptor(["datetime", "path", "string"]))
+    def authlog(self) -> Iterator[Any]:
+        """Yield contents of ``/var/log/auth.log*`` and ``/var/log/secure*`` files.
+
+        Order of returned events is not guaranteed to be chronological because of year
+        rollover detection efforts for log files without a year in the timestamp.
+
+        The following timestamp formats are recognised automatically. This plugin
+        assumes that no custom ``date_format`` template is set in ``syslog-ng`` or ``systemd``
+        configuration (defaults to ``M d H:M:S``).
+
+        ISO formatted authlog entries are parsed as can be found in Ubuntu 24.04 and later.
+
+        .. code-block:: text
+
+            CentOS format: Jan 12 13:37:00 hostname daemon: message
+            Debian format: Jan 12 13:37:00 hostname daemon[pid]: pam_unix(daemon:session): message
+            Ubuntu  24.04: 2024-01-12T13:37:00.000000+02:00 hostname daemon[pid]: pam_unix(daemon:session): message
+
+        Resources:
+            - https://help.ubuntu.com/community/LinuxLogFiles
+        """
+
+        tzinfo = self.target.datetime.tzinfo
+
+        var_log = self.target.fs.path("/var/log")
+        for auth_file in chain(var_log.glob("auth.log*"), var_log.glob("secure*")):
+            if is_iso_fmt(auth_file):
+                iterable = iso_readlines(auth_file)
+            else:
+                iterable = year_rollover_helper(auth_file, RE_TS, "%b %d %H:%M:%S", tzinfo)
+
+            for ts, line in iterable:
+                yield self._auth_log_builder.build_record(ts, auth_file, line)
+
+
+def iso_readlines(file: Path) -> Iterator[tuple[datetime, str]]:
+    """Iterator reading the provided auth log file in ISO format. Mimics ``year_rollover_helper`` behaviour."""
+    with open_decompress(file, "rt") as fh:
+        for line in fh:
+            if not (match := RE_TS_ISO.match(line)):
+                log.warning("No timestamp found in one of the lines in %s!", file)
+                log.debug("Skipping line: %s", line)
+                continue
+
+            try:
+                ts = datetime.strptime(match[0], "%Y-%m-%dT%H:%M:%S.%f%z")
+            except ValueError as e:
+                log.warning("Unable to parse ISO timestamp in line: %s", line)
+                log.debug("", exc_info=e)
+                continue
+
+            yield ts, line
+
+
+def is_iso_fmt(file: Path) -> bool:
+    """Determine if the provided auth log file uses new ISO format logging or not."""
+    return any(itertools.islice(iso_readlines(file), 0, 2))

{dissect_target-3.20.dev44 → dissect_target-3.20.dev47/dissect.target.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.20.dev44
+Version: 3.20.dev47
 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.dev44 → dissect_target-3.20.dev47}/dissect.target.egg-info/SOURCES.txt

@@ -416,6 +416,7 @@ tests/filesystems/test_dir.py
 tests/filesystems/test_exfat.py
 tests/filesystems/test_extfs.py
 tests/filesystems/test_fat.py
+tests/filesystems/test_ffs.py
 tests/filesystems/test_jffs2.py
 tests/filesystems/test_ntfs.py
 tests/filesystems/test_overlay.py

dissect_target-3.20.dev47/tests/filesystems/test_ffs.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+from typing import Iterator
+from unittest.mock import Mock, patch
+
+import pytest
+
+from dissect.target.filesystems.ffs import FfsFilesystem, FfsFilesystemEntry
+
+NANOSECONDS_IN_SECOND = 1_000_000_000
+
+
+@pytest.fixture
+def ffs_fs() -> Iterator[FfsFilesystem]:
+    with patch("dissect.ffs.ffs.FFS"):
+        ffs_fs = FfsFilesystem(Mock())
+        ffs_fs.ffs.block_size = 32 * 1024
+        yield ffs_fs
+
+
+@pytest.fixture
+def ffs_fs_entry(ffs_fs: FfsFilesystem) -> Iterator[FfsFilesystemEntry]:
+    atime = datetime(2024, 10, 1, 12, 0, 0)
+    mtime = datetime(2024, 10, 2, 12, 0, 0)
+    ctime = datetime(2024, 10, 3, 12, 0, 0)
+    btime = datetime(2024, 10, 4, 12, 0, 0)
+
+    raw_inode = Mock(di_uid=1000, di_nlink=1, di_guid=999, di_size=165002)
+    inode = Mock(
+        mode=0o100664,
+        inum=4,
+        inode=raw_inode,
+        nblocks=323,
+        atime=atime,
+        atime_ns=atime.timestamp() * NANOSECONDS_IN_SECOND,
+        mtime=mtime,
+        mtime_ns=mtime.timestamp() * NANOSECONDS_IN_SECOND,
+        ctime=ctime,
+        ctime_ns=ctime.timestamp() * NANOSECONDS_IN_SECOND,
+        btime=btime,
+        btime_ns=btime.timestamp() * NANOSECONDS_IN_SECOND,
+        is_file=lambda: True,
+        is_dir=lambda: False,
+        is_symlink=lambda: False,
+    )
+
+    entry = FfsFilesystemEntry(ffs_fs, "/some_file", inode)
+    yield entry
+
+
+def test_jffs2_stat(ffs_fs_entry: FfsFilesystemEntry) -> None:
+    stat = ffs_fs_entry.stat()
+
+    entry = ffs_fs_entry.entry
+    assert stat.st_mode == entry.mode
+    assert stat.st_ino == entry.inum
+    assert stat.st_dev == id(ffs_fs_entry.fs)
+    assert stat.st_nlink == entry.inode.di_nlink
+    assert stat.st_uid == entry.inode.di_uid
+    assert stat.st_gid == entry.inode.di_gid
+    assert stat.st_size == entry.inode.di_size
+    assert stat.st_atime == entry.atime.timestamp()
+    assert stat.st_mtime == entry.mtime.timestamp()
+    assert stat.st_ctime == entry.ctime.timestamp()
+    assert stat.st_birthtime == entry.btime.timestamp()
+    assert stat.st_birthtime_ns == entry.btime_ns
+    assert stat.st_blksize == 32 * 1024
+    assert stat.st_blocks == 323