dissect.target 3.19.dev56__tar.gz → 3.19.dev57__tar.gz

{dissect_target-3.19.dev56/dissect.target.egg-info → dissect_target-3.19.dev57}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dissect.target
-Version: 3.19.dev56
+Version: 3.19.dev57
 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.19.dev56 → dissect_target-3.19.dev57}/dissect/target/plugin.py

@@ -142,7 +142,7 @@ def get_nonprivate_attributes(cls: Type[Plugin]) -> list[Any]:
 
 def get_nonprivate_methods(cls: Type[Plugin]) -> list[Callable]:
     """Retrieve all public methods of a :class:`Plugin`."""
-    return [attr for attr in get_nonprivate_attributes(cls) if not isinstance(attr, property)]
+    return [attr for attr in get_nonprivate_attributes(cls) if not isinstance(attr, property) and callable(attr)]
 
 
 def get_descriptors_on_nonprivate_methods(cls: Type[Plugin]) -> list[RecordDescriptor]:
@@ -1020,7 +1020,7 @@ class NamespacePlugin(Plugin):
                 continue
 
             # The method needs to output records
-            if getattr(subplugin_func, "__output__", None) != "record":
+            if getattr(subplugin_func, "__output__", None) not in ["record", "yield"]:
                 continue
 
             # The method may not be part of a parent class.
@@ -1106,6 +1106,9 @@ class NamespacePlugin(Plugin):
             cls.__init_subclass_namespace__(cls, **kwargs)
 
 
+__COMMON_PLUGIN_METHOD_NAMES__ = {attr.__name__ for attr in get_nonprivate_methods(Plugin)}
+
+
 class InternalPlugin(Plugin):
     """Parent class for internal plugins.
 
@@ -1115,13 +1118,17 @@ class InternalPlugin(Plugin):
 
     def __init_subclass__(cls, **kwargs):
         for method in get_nonprivate_methods(cls):
-            if callable(method):
+            if callable(method) and method.__name__ not in __COMMON_PLUGIN_METHOD_NAMES__:
                 method.__internal__ = True
 
         super().__init_subclass__(**kwargs)
         return cls
 
 
+class InternalNamespacePlugin(NamespacePlugin, InternalPlugin):
+    pass
+
+
 @dataclass(frozen=True, eq=True)
 class PluginFunction:
     name: str

dissect_target-3.19.dev57/dissect/target/plugins/os/windows/credential/lsa.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import hashlib
+from functools import cached_property
+from typing import Iterator
+
+from dissect.target.exceptions import RegistryKeyNotFoundError, UnsupportedPluginError
+from dissect.target.helpers.record import TargetRecordDescriptor
+from dissect.target.plugin import Plugin, export
+
+try:
+    from Crypto.Cipher import AES, ARC4, DES
+
+    HAS_CRYPTO = True
+except ImportError:
+    HAS_CRYPTO = False
+
+
+LSASecretRecord = TargetRecordDescriptor(
+    "windows/credential/lsa",
+    [
+        ("datetime", "ts"),
+        ("string", "name"),
+        ("string", "value"),
+    ],
+)
+
+
+class LSAPlugin(Plugin):
+    """Windows Local Security Authority (LSA) plugin.
+
+    Resources:
+        - https://learn.microsoft.com/en-us/windows/win32/secauthn/lsa-authentication
+        - https://moyix.blogspot.com/2008/02/decrypting-lsa-secrets.html (Windows XP)
+        - https://github.com/fortra/impacket/blob/master/impacket/examples/secretsdump.py
+    """
+
+    __namespace__ = "lsa"
+
+    SECURITY_POLICY_KEY = "HKEY_LOCAL_MACHINE\\SECURITY\\Policy"
+    SYSTEM_KEY = "HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\LSA"
+
+    def check_compatible(self) -> None:
+        if not HAS_CRYPTO:
+            raise UnsupportedPluginError("Missing pycryptodome dependency")
+
+        if not self.target.has_function("registry") or not list(self.target.registry.keys(self.SYSTEM_KEY)):
+            raise UnsupportedPluginError("Registry key not found: %s", self.SYSTEM_KEY)
+
+    @cached_property
+    def syskey(self) -> bytes:
+        """Return byte value of Windows system SYSKEY, also called BootKey."""
+        lsa = self.target.registry.key(self.SYSTEM_KEY)
+        syskey_keys = ["JD", "Skew1", "GBG", "Data"]
+        # This magic value rotates the order of the data
+        alterator = [0x8, 0x5, 0x4, 0x2, 0xB, 0x9, 0xD, 0x3, 0x0, 0x6, 0x1, 0xC, 0xE, 0xA, 0xF, 0x7]
+
+        r = bytes.fromhex("".join([lsa.subkey(key).class_name for key in syskey_keys]))
+        return bytes(r[i] for i in alterator)
+
+    @cached_property
+    def lsakey(self) -> bytes:
+        """Decrypt and return the LSA key of the Windows system."""
+        security_pol = self.target.registry.key(self.SECURITY_POLICY_KEY)
+
+        try:
+            # Windows Vista or newer
+            enc_key = security_pol.subkey("PolEKList").value("(Default)").value
+            lsa_key = _decrypt_aes(enc_key, self.syskey)
+            return lsa_key[68:100]
+        except RegistryKeyNotFoundError:
+            pass
+
+        try:
+            # Windows XP
+            enc_key = security_pol.subkey("PolSecretEncryptionKey").value("(Default)").value
+            lsa_key = _decrypt_rc4(enc_key, self.syskey)
+            return lsa_key[16:32]
+        except RegistryKeyNotFoundError:
+            pass
+
+        raise ValueError("Unable to determine LSA policy key location in registry")
+
+    @cached_property
+    def _secrets(self) -> dict[str, bytes] | None:
+        """Return dict of Windows system decrypted LSA secrets."""
+        if not self.target.ntversion:
+            raise ValueError("Unable to determine Windows NT version")
+
+        result = {}
+        for subkey in self.target.registry.key(self.SECURITY_POLICY_KEY).subkey("Secrets").subkeys():
+            enc_data = subkey.subkey("CurrVal").value("(Default)").value
+
+            # Windows Vista or newer
+            if float(self.target.ntversion) >= 6.0:
+                secret = _decrypt_aes(enc_data, self.lsakey)
+
+            # Windows XP
+            else:
+                secret = _decrypt_des(enc_data, self.lsakey)
+
+            result[subkey.name] = secret
+
+        return result
+
+    @export(record=LSASecretRecord)
+    def secrets(self) -> Iterator[LSASecretRecord]:
+        """Yield decrypted LSA secrets from a Windows target."""
+        for key, value in self._secrets.items():
+            yield LSASecretRecord(
+                ts=self.target.registry.key(f"{self.SECURITY_POLICY_KEY}\\Secrets\\{key}").ts,
+                name=key,
+                value=value.hex(),
+                _target=self.target,
+            )
+
+
+def _decrypt_aes(data: bytes, key: bytes) -> bytes:
+    ctx = hashlib.sha256()
+    ctx.update(key)
+    for _ in range(1, 1000 + 1):
+        ctx.update(data[28:60])
+
+    ciphertext = data[60:]
+    plaintext = []
+
+    for i in range(0, len(ciphertext), 16):
+        cipher = AES.new(ctx.digest(), AES.MODE_CBC, iv=b"\x00" * 16)
+        plaintext.append(cipher.decrypt(ciphertext[i : i + 16].ljust(16, b"\x00")))
+
+    return b"".join(plaintext)
+
+
+def _decrypt_rc4(data: bytes, key: bytes) -> bytes:
+    md5 = hashlib.md5()
+    md5.update(key)
+    for _ in range(1000):
+        md5.update(data[60:76])
+    rc4_key = md5.digest()
+
+    cipher = ARC4.new(rc4_key)
+    return cipher.decrypt(data[12:60])
+
+
+def _decrypt_des(data: bytes, key: bytes) -> bytes:
+    plaintext = []
+
+    enc_size = int.from_bytes(data[:4], "little")
+    data = data[len(data) - enc_size :]
+
+    key0 = key
+    for _ in range(0, len(data), 8):
+        ciphertext = data[:8]
+        block_key = _transform_key(key0[:7])
+
+        cipher = DES.new(block_key, DES.MODE_ECB)
+        plaintext.append(cipher.decrypt(ciphertext))
+
+        key0 = key0[7:]
+        data = data[8:]
+
+        if len(key0) < 7:
+            key0 = key[len(key0) :]
+
+    return b"".join(plaintext)
+
+
+def _transform_key(key: bytes) -> bytes:
+    new_key = []
+    new_key.append(((key[0] >> 0x01) << 1) & 0xFE)
+    for i in range(0, 6):
+        new_key.append((((key[i] & ((1 << (i + 1)) - 1)) << (6 - i) | (key[i + 1] >> (i + 2))) << 1) & 0xFE)
+    new_key.append(((key[6] & 0x7F) << 1) & 0xFE)
+    return bytes(new_key)

{dissect_target-3.19.dev56/dissect/target/plugins/os/windows → dissect_target-3.19.dev57/dissect/target/plugins/os/windows/credential}/sam.py

@@ -210,7 +210,7 @@ struct SAM_HASH_AES {  /* size: >=24 */
 c_sam = cstruct().load(sam_def)
 
 SamRecord = TargetRecordDescriptor(
-    "windows/registry/sam",
+    "windows/credential/sam",
     [
         ("uint32", "rid"),
         ("string", "fullname"),
@@ -303,6 +303,9 @@ class SamPlugin(Plugin):
         if not HAS_CRYPTO:
             raise UnsupportedPluginError("Missing pycryptodome dependency")
 
+        if not self.target.has_function("lsa"):
+            raise UnsupportedPluginError("LSA plugin is required for SAM plugin")
+
         if not len(list(self.target.registry.keys(self.SAM_KEY))) > 0:
             raise UnsupportedPluginError(f"Registry key not found: {self.SAM_KEY}")
 
@@ -374,7 +377,7 @@ class SamPlugin(Plugin):
             nt (string): Parsed NT-hash.
         """
 
-        syskey = self.target.dpapi.syskey  # aka. bootkey
+        syskey = self.target.lsa.syskey  # aka. bootkey
         samkey = self.calculate_samkey(syskey)  # aka. hashed bootkey or hbootkey
 
         almpassword = b"LMPASSWORD\0"

{dissect_target-3.19.dev56 → dissect_target-3.19.dev57}/dissect/target/plugins/os/windows/dpapi/blob.py

@@ -90,6 +90,9 @@ class Blob:
         if self.decrypted:
             return True
 
+        if not master_key:
+            raise ValueError("No master key provided to decrypt blob with")
+
         for algo in [crypt_session_key_type1, crypt_session_key_type2]:
             session_key = algo(
                 master_key,

{dissect_target-3.19.dev56 → dissect_target-3.19.dev57}/dissect/target/plugins/os/windows/dpapi/crypto.py

@@ -2,17 +2,16 @@ from __future__ import annotations
 
 import hashlib
 import hmac
-from typing import Optional, Union
 
 try:
-    from Crypto.Cipher import AES, ARC4
+    from Crypto.Cipher import AES, ARC4, DES3
 
     HAS_CRYPTO = True
 except ImportError:
     HAS_CRYPTO = False
 
-CIPHER_ALGORITHMS: dict[Union[int, str], CipherAlgorithm] = {}
-HASH_ALGORITHMS: dict[Union[int, str], HashAlgorithm] = {}
+CIPHER_ALGORITHMS: dict[int | str, CipherAlgorithm] = {}
+HASH_ALGORITHMS: dict[int | str, HashAlgorithm] = {}
 
 
 class CipherAlgorithm:
@@ -35,17 +34,27 @@ class CipherAlgorithm:
         return CIPHER_ALGORITHMS[name]()
 
     def derive_key(self, key: bytes, hash_algorithm: HashAlgorithm) -> bytes:
-        """Mimics the corresponding native Microsoft function."""
+        """Mimics the corresponding native Microsoft function.
+
+        Resources:
+            - https://github.com/tijldeneut/DPAPIck3/blob/main/dpapick3/crypto.py#L185
+        """
+
         if len(key) > hash_algorithm.block_length:
             key = hashlib.new(hash_algorithm.name, key).digest()
 
-        if len(key) >= hash_algorithm.digest_length:
+        if len(key) >= self.key_length:
             return key
 
         key = key.ljust(hash_algorithm.block_length, b"\x00")
-        pad1 = bytes(c ^ 0x36 for c in key)
-        pad2 = bytes(c ^ 0x5C for c in key)
-        return hashlib.new(hash_algorithm.name, pad1).digest() + hashlib.new(hash_algorithm.name, pad2).digest()
+        pad1 = bytes(c ^ 0x36 for c in key)[: hash_algorithm.block_length]
+        pad2 = bytes(c ^ 0x5C for c in key)[: hash_algorithm.block_length]
+        key = hashlib.new(hash_algorithm.name, pad1).digest() + hashlib.new(hash_algorithm.name, pad2).digest()
+        key = self.fixup_key(key)
+        return key
+
+    def fixup_key(self, key: bytes) -> bytes:
+        return key
 
     def decrypt_with_hmac(
         self, data: bytes, key: bytes, iv: bytes, hash_algorithm: HashAlgorithm, rounds: int
@@ -55,7 +64,7 @@ class CipherAlgorithm:
 
         return self.decrypt(data, key, iv)
 
-    def decrypt(self, data: bytes, key: bytes, iv: Optional[bytes] = None) -> bytes:
+    def decrypt(self, data: bytes, key: bytes, iv: bytes | None = None) -> bytes:
         raise NotImplementedError()
 
 
@@ -66,7 +75,7 @@ class _AES(CipherAlgorithm):
     iv_length = 128 // 8
     block_length = 128 // 8
 
-    def decrypt(self, data: bytes, key: bytes, iv: Optional[bytes] = None) -> bytes:
+    def decrypt(self, data: bytes, key: bytes, iv: bytes | None = None) -> bytes:
         if not HAS_CRYPTO:
             raise RuntimeError("Missing pycryptodome dependency")
 
@@ -100,7 +109,7 @@ class _RC4(CipherAlgorithm):
     iv_length = 128 // 8
     block_length = 1 // 8
 
-    def decrypt(self, data: bytes, key: bytes, iv: Optional[bytes] = None) -> bytes:
+    def decrypt(self, data: bytes, key: bytes, iv: bytes | None = None) -> bytes:
         if not HAS_CRYPTO:
             raise RuntimeError("Missing pycryptodome dependency")
 
@@ -108,6 +117,34 @@ class _RC4(CipherAlgorithm):
         return cipher.decrypt(data)
 
 
+class _DES3(CipherAlgorithm):
+    id = 0x6603
+    name = "DES3"
+    key_length = 192 // 8
+    iv_length = 64 // 8
+    block_length = 64 // 8
+
+    def fixup_key(self, key: bytes) -> bytes:
+        nkey = []
+        for byte in key:
+            parity_bit = 0
+            for i in range(8):
+                parity_bit ^= (byte >> i) & 1
+
+            nkey.append(byte if parity_bit == 0 else byte | 1)
+        return bytes(nkey[: self.key_length])
+
+    def decrypt(self, data: bytes, key: bytes, iv: bytes | None = None) -> bytes:
+        if not HAS_CRYPTO:
+            raise RuntimeError("Missing pycryptodome dependency")
+
+        if len(key) != 24:
+            raise ValueError(f"Invalid DES3 CBC key length {len(key)}")
+
+        cipher = DES3.new(key, DES3.MODE_CBC, iv=iv if iv else b"\x00" * 8)
+        return cipher.decrypt(data)
+
+
 class HashAlgorithm:
     id: int
     name: str
@@ -123,7 +160,7 @@ class HashAlgorithm:
         return HASH_ALGORITHMS[id]()
 
     @classmethod
-    def from_name(cls, name: str) -> Optional[HashAlgorithm]:
+    def from_name(cls, name: str) -> HashAlgorithm | None:
         return HASH_ALGORITHMS[name]()
 
 
@@ -148,7 +185,7 @@ class _HMAC(_SHA1):
 
 
 class _SHA256(HashAlgorithm):
-    id = 0x8004
+    id = 0x800C
     name = "sha256"
     digest_length = 256 // 8
     block_length = 512 // 8
@@ -197,12 +234,12 @@ def dpapi_hmac(pwd_hash: bytes, hmac_salt: bytes, value: bytes, hash_algorithm:
 
 def crypt_session_key_type1(
     master_key: bytes,
-    nonce: Optional[bytes],
+    nonce: bytes | None,
     hash_algorithm: HashAlgorithm,
-    entropy: Optional[bytes] = None,
-    strong_password: Optional[str] = None,
-    smart_card_secret: Optional[bytes] = None,
-    verify_blob: Optional[bytes] = None,
+    entropy: bytes | None = None,
+    strong_password: str | None = None,
+    smart_card_secret: bytes | None = None,
+    verify_blob: bytes | None = None,
 ) -> bytes:
     """Computes the decryption key for Type1 DPAPI blob, given the master key and optional information.
 
@@ -218,6 +255,7 @@ def crypt_session_key_type1(
         strong_password: Optional password used for decryption or the blob itself.
         smart_card_secret: Optional MS Next Gen Crypto secret (e.g. from PIN code).
         verify_blob: Optional encrypted blob used for integrity check.
+
     Returns:
         decryption key
     """
@@ -258,10 +296,10 @@ def crypt_session_key_type2(
     masterkey: bytes,
     nonce: bytes,
     hash_algorithm: HashAlgorithm,
-    entropy: Optional[bytes] = None,
-    strong_password: Optional[str] = None,
-    smart_card_secret: Optional[bytes] = None,
-    verify_blob: Optional[bytes] = None,
+    entropy: bytes | None = None,
+    strong_password: str | None = None,
+    smart_card_secret: bytes | None = None,
+    verify_blob: bytes | None = None,
 ) -> bytes:
     """Computes the decryption key for Type2 DPAPI blob, given the masterkey and optional information.
 

dissect_target-3.19.dev57/dissect/target/plugins/os/windows/dpapi/dpapi.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import re
+from functools import cache, cached_property
+from pathlib import Path
+from typing import Iterator
+
+from dissect.target.exceptions import UnsupportedPluginError
+from dissect.target.plugin import InternalPlugin
+from dissect.target.plugins.os.windows.dpapi.blob import Blob as DPAPIBlob
+from dissect.target.plugins.os.windows.dpapi.master_key import CredSystem, MasterKeyFile
+from dissect.target.target import Target
+
+
+class DPAPIPlugin(InternalPlugin):
+    """Windows Data Protection API (DPAPI) plugin.
+
+    Resources:
+        - Reversing ``Crypt32.dll``
+        - https://learn.microsoft.com/en-us/windows/win32/api/dpapi/
+        - https://github.com/fortra/impacket/blob/master/examples/dpapi.py
+        - https://github.com/tijldeneut/DPAPIck3
+        - https://www.passcape.com/index.php?section=docsys&cmd=details&id=28
+    """
+
+    __namespace__ = "dpapi"
+
+    RE_MASTER_KEY = re.compile("^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$")
+    SYSTEM_SID = "S-1-5-18"
+
+    def __init__(self, target: Target):
+        super().__init__(target)
+        self.keychain = cache(self.keychain)
+
+    def check_compatible(self) -> None:
+        if not self.target.has_function("lsa"):
+            raise UnsupportedPluginError("Windows registry and LSA plugins are required for DPAPI decryption")
+
+    def keychain(self) -> set:
+        return set(self.target._dpapi_keyprovider.keys())
+
+    @cached_property
+    def master_keys(self) -> dict[str, dict[str, MasterKeyFile]]:
+        """Returns dict of found DPAPI master keys on the Windows target for SYSTEM and regular users."""
+        master_keys = {}
+
+        # Search for SYSTEM master keys
+        master_keys[self.SYSTEM_SID] = {}
+
+        system_master_key_path = self.target.fs.path(f"sysvol/Windows/System32/Microsoft/Protect/{self.SYSTEM_SID}")
+        system_user_master_key_path = system_master_key_path.joinpath("User")
+
+        for dir in [system_master_key_path, system_user_master_key_path]:
+            user_mks = self._load_master_keys_from_path(self.SYSTEM_SID, dir)
+            master_keys[self.SYSTEM_SID].update(user_mks)
+
+        # Search for user master keys, generally located at $HOME/AppData/Roaming/Microsoft/Protect/{user_sid}/{mk_guid}
+        PROTECT_DIRS = [
+            # Windows Vista and newer
+            "AppData/Roaming/Microsoft/Protect",
+            # Windows XP
+            "Application Data/Microsoft/Protect",
+        ]
+
+        for user in self.target.user_details.all_with_home():
+            sid = user.user.sid
+            master_keys.setdefault(sid, {})
+
+            for protect_dir in PROTECT_DIRS:
+                path = user.home_path.joinpath(protect_dir).joinpath(sid)
+                if user_mks := self._load_master_keys_from_path(sid, path):
+                    master_keys[sid] |= user_mks
+
+        return master_keys
+
+    def _load_master_keys_from_path(self, sid: str, path: Path) -> Iterator[tuple[str, MasterKeyFile]]:
+        """Iterate over the provided ``path`` and search for master key files for the given user SID."""
+
+        if not path.exists():
+            self.target.log.info("Unable to load master keys from path as it does not exist: %s", path)
+            return
+
+        for file in path.iterdir():
+            if not self.RE_MASTER_KEY.findall(file.name):
+                continue
+
+            with file.open() as fh:
+                mkf = MasterKeyFile(fh)
+
+            # Decrypt SYSTEM master key using the DPAPI_SYSTEM LSA secret.
+            if sid == self.SYSTEM_SID:
+                if "DPAPI_SYSTEM" not in self.target.lsa._secrets:
+                    self.target.log.warning("Unable to decrypt SYSTEM master key: LSA secret missing")
+                    continue
+
+                # Windows XP
+                if float(self.target.ntversion) < 6.0:
+                    secret_offset = 8
+
+                # Windows Vista and newer
+                else:
+                    secret_offset = 16
+
+                dpapi_system = CredSystem(self.target.lsa._secrets["DPAPI_SYSTEM"][secret_offset:])
+                mkf.decrypt_with_key(dpapi_system.machine_key)
+                mkf.decrypt_with_key(dpapi_system.user_key)
+
+                # Decrypting the System master key should always succeed
+                if not mkf.decrypted:
+                    self.target.log.error("Failed to decrypt SYSTEM master key!")
+                    continue
+
+                yield file.name, mkf
+
+            # Decrypt user master key
+            else:
+                # Iterate over every master key password we have from the keychain
+                for provider, mk_pass in self.keychain():
+                    try:
+                        if mkf.decrypt_with_password(sid, mk_pass):
+                            self.target.log.info(
+                                "Decrypted user master key with password '%s' from provider %s", mk_pass, provider
+                            )
+                            break
+                    except ValueError:
+                        pass
+
+                    try:
+                        if mkf.decrypt_with_hash(sid, bytes.fromhex(mk_pass)):
+                            self.target.log.info(
+                                "Decrypted SID %s master key with hash '%s' from provider %s", sid, mk_pass, provider
+                            )
+                            break
+                    except ValueError:
+                        pass
+
+                if not mkf.decrypted:
+                    self.target.log.warning("Could not decrypt master key '%s' for SID '%s'", file.name, sid)
+
+                yield file.name, mkf
+
+    @cached_property
+    def _users(self) -> dict[str, str]:
+        """Cached map of username to SID."""
+        return {user.name: user.sid for user in self.target.users()}
+
+    def decrypt_system_blob(self, data: bytes) -> bytes:
+        """Decrypt the given bytes using the SYSTEM master key."""
+        return self.decrypt_user_blob(data, sid=self.SYSTEM_SID)
+
+    def decrypt_user_blob(self, data: bytes, username: str | None = None, sid: str | None = None) -> bytes:
+        """Decrypt the given bytes using the master key of the given SID or username."""
+
+        if not sid and not username:
+            raise ValueError("Either sid or username argument is required")
+
+        if not sid and username:
+            sid = self._users.get(username)
+
+        if not sid:
+            raise ValueError("No SID provided or no SID found")
+
+        try:
+            blob = DPAPIBlob(data)
+        except EOFError as e:
+            raise ValueError(f"Failed to parse DPAPI blob: {e}")
+
+        if not (mk := self.master_keys.get(sid, {}).get(blob.guid)):
+            raise ValueError(f"Blob is encrypted using master key {blob.guid} that we do not have for SID {sid}")
+
+        if not blob.decrypt(mk.key):
+            raise ValueError(f"Failed to decrypt blob for SID {sid}")
+
+        return blob.clear_text
+
+    def decrypt_blob(self, data: bytes) -> bytes:
+        """Attempt to decrypt the given bytes using any of the available master keys."""
+        try:
+            blob = DPAPIBlob(data)
+        except EOFError as e:
+            raise ValueError(f"Failed to parse DPAPI blob: {e}")
+
+        for user in self.master_keys:
+            for mk in self.master_keys[user].values():
+                if blob.decrypt(mk.key):
+                    return blob.clear_text
+
+        raise ValueError("Failed to decrypt blob using any available master key")

dissect_target-3.19.dev57/dissect/target/plugins/os/windows/dpapi/keyprovider/credhist.py

@@ -0,0 +1,21 @@
+from typing import Iterator
+
+from dissect.target.exceptions import UnsupportedPluginError
+from dissect.target.plugin import export
+from dissect.target.plugins.os.windows.dpapi.keyprovider.keyprovider import (
+    KeyProviderPlugin,
+)
+
+
+class CredHistKeyProviderPlugin(KeyProviderPlugin):
+    __namespace__ = "_dpapi_keyprovider_credhist"
+
+    def check_compatible(self) -> None:
+        if not self.target.has_function("credhist"):
+            raise UnsupportedPluginError("CREDHIST plugin not available on target")
+
+    @export(output="yield")
+    def keys(self) -> Iterator[tuple[str, str]]:
+        for credhist in self.target.credhist():
+            if value := getattr(credhist, "sha1"):
+                yield self.__namespace__, value

dissect_target-3.19.dev57/dissect/target/plugins/os/windows/dpapi/keyprovider/empty.py

@@ -0,0 +1,17 @@
+from typing import Iterator
+
+from dissect.target.plugin import export
+from dissect.target.plugins.os.windows.dpapi.keyprovider.keyprovider import (
+    KeyProviderPlugin,
+)
+
+
+class EmptyKeyProviderPlugin(KeyProviderPlugin):
+    __namespace__ = "_dpapi_keyprovider_empty"
+
+    def check_compatible(self) -> None:
+        return
+
+    @export(output="yield")
+    def keys(self) -> Iterator[tuple[str, str]]:
+        yield self.__namespace__, ""