dfindexeddb 20241031__tar.gz → 20241105__tar.gz

{dfindexeddb-20241031/dfindexeddb.egg-info → dfindexeddb-20241105}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfindexeddb
-Version: 20241031
+Version: 20241105
 Summary: dfindexeddb is an experimental Python tool for performing digital forensic analysis of IndexedDB and leveldb files.
 Author-email: Syd Pleno <sydp@google.com>
 Maintainer-email: dfIndexeddb Developers <dfindexeddb-dev@googlegroups.com>

{dfindexeddb-20241031 → dfindexeddb-20241105}/dfindexeddb/indexeddb/chromium/definitions.py

@@ -16,6 +16,11 @@
 from enum import Enum, IntEnum, IntFlag
 
 
+REQUIRES_PROCESSING_SSV_PSEUDO_VERSION = 0x11
+REPLACE_WITH_BLOB = 0x01
+COMPRESSED_WITH_SNAPPY = 0x02
+
+
 class DatabaseMetaDataKeyType(IntEnum):
   """Database Metadata key types."""
   ORIGIN_NAME = 0

{dfindexeddb-20241031 → dfindexeddb-20241105}/dfindexeddb/indexeddb/chromium/record.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 """Parses Chromium IndexedDb structures."""
 from __future__ import annotations
+
 from dataclasses import dataclass, field
 from datetime import datetime
 import io
@@ -23,6 +24,8 @@ import traceback
 from typing import Any, BinaryIO, Generator, Optional, Tuple, Type, TypeVar, \
     Union
 
+import snappy
+
 from dfindexeddb import errors
 from dfindexeddb.indexeddb.chromium import blink
 from dfindexeddb.indexeddb.chromium import definitions
@@ -50,7 +53,10 @@ class KeyPrefix(utils.FromDecoderMixin):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0) -> KeyPrefix:
+      cls,
+      decoder: utils.LevelDBDecoder,
+      base_offset: int = 0
+  ) -> KeyPrefix:
     """Decodes a KeyPrefix from the current position of a LevelDBDecoder.
 
     Args:
@@ -151,7 +157,8 @@ class IDBKey(utils.FromDecoderMixin):
 
     def RecursiveParse(depth: int) -> Tuple[
         int, definitions.IDBKeyType, Union[
-            list, bytes, str, float, datetime, None]]:
+            list, bytes, str, float, datetime, None
+        ]]:
       """Recursively parses IDBKeys.
 
       Args:
@@ -215,8 +222,11 @@ class IDBKeyPath(utils.FromDecoderMixin):
   value: Union[str, list[str], None]
 
   @classmethod
-  def FromDecoder(cls, decoder: utils.LevelDBDecoder,
-                   base_offset: int = 0) -> IDBKeyPath:
+  def FromDecoder(
+      cls,
+      decoder: utils.LevelDBDecoder,
+      base_offset: int = 0
+  ) -> IDBKeyPath:
     """Decodes an IDBKeyPath from the current position of a LevelDBDecoder.
 
     Args:
@@ -228,7 +238,7 @@ class IDBKeyPath(utils.FromDecoderMixin):
 
     Raises:
       ParserError: on insufficient bytes or invalid array length during
-        parsing.
+        parsing or unsupported key path type.
     """
     buffer = decoder.stream.getvalue()  #pytype: disable=attribute-error
     if len(buffer) < 3:
@@ -255,6 +265,8 @@ class IDBKeyPath(utils.FromDecoderMixin):
       for _ in range(count):
         _, entry = decoder.DecodeStringWithLength()
         value.append(entry)
+    else:
+      raise errors.ParserError(f'Unsupported key_path_type {key_path_type}.')
     return IDBKeyPath(base_offset + offset, key_path_type, value)
 
 
@@ -272,8 +284,11 @@ class BlobJournalEntry(utils.FromDecoderMixin):
   blob_number: int
 
   @classmethod
-  def FromDecoder(cls, decoder: utils.LevelDBDecoder,
-                   base_offset: int = 0) -> BlobJournalEntry:
+  def FromDecoder(
+      cls,
+      decoder: utils.LevelDBDecoder,
+      base_offset: int = 0
+  ) -> BlobJournalEntry:
     """Decodes a BlobJournalEntry from the current position of a LevelDBDecoder.
 
     Args:
@@ -301,8 +316,11 @@ class BlobJournal(utils.FromDecoderMixin):
   entries: list[BlobJournalEntry]
 
   @classmethod
-  def FromDecoder(cls, decoder: utils.LevelDBDecoder,
-                   base_offset: int = 0) -> BlobJournal:
+  def FromDecoder(
+      cls,
+      decoder: utils.LevelDBDecoder,
+      base_offset: int = 0
+  ) -> BlobJournal:
     """Decodes a BlobJournal from the current position of a LevelDBDecoder.
 
     Blob journals are zero-or-more instances of BlobJournalEntry.  There is no
@@ -395,8 +413,7 @@ class BaseIndexedDBKey:
     raise NotImplementedError(f'{cls.__class__.__name__}.decode_key')
 
   @classmethod
-  def FromStream(
-      cls: Type[T], stream: BinaryIO, base_offset: int = 0) -> T:
+  def FromStream(cls: Type[T], stream: BinaryIO, base_offset: int = 0) -> T:
     """Parses the key from the current position of the binary stream.
 
     Args:
@@ -412,8 +429,7 @@ class BaseIndexedDBKey:
         decoder=decoder, key_prefix=key_prefix, base_offset=base_offset)
 
   @classmethod
-  def FromBytes(
-      cls: Type[T], raw_data: bytes, base_offset: int = 0) -> T:
+  def FromBytes(cls: Type[T], raw_data: bytes, base_offset: int = 0) -> T:
     """Parses the key from the raw key bytes.
 
     Args:
@@ -433,11 +449,13 @@ class SchemaVersionKey(BaseIndexedDBKey):
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the schema version value."""
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> SchemaVersionKey:
     """Decodes the schema version key."""
@@ -453,11 +471,13 @@ class MaxDatabaseIdKey(BaseIndexedDBKey):
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the maximum database value."""
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> MaxDatabaseIdKey:
     """Decodes the maximum database key."""
@@ -473,11 +493,13 @@ class DataVersionKey(BaseIndexedDBKey):
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the data version value."""
-    return decoder.DecodeUint64Varint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> DataVersionKey:
     """Decodes the data version key."""
@@ -497,7 +519,9 @@ class RecoveryBlobJournalKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> RecoveryBlobJournalKey:
     """Decodes the recovery blob journal key."""
@@ -517,7 +541,9 @@ class ActiveBlobJournalKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> ActiveBlobJournalKey:
     """Decodes the active blob journal value."""
@@ -538,7 +564,9 @@ class EarliestSweepKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> EarliestSweepKey:
     """Decodes the earliest sweep value."""
@@ -559,7 +587,9 @@ class EarliestCompactionTimeKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> EarliestCompactionTimeKey:
     """Decodes the earliest compaction time key."""
@@ -581,7 +611,9 @@ class ScopesPrefixKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> ScopesPrefixKey:
     """Decodes the scopes prefix key."""
@@ -606,7 +638,9 @@ class DatabaseFreeListKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> DatabaseFreeListKey:
     """Decodes the database free list key."""
@@ -635,11 +669,13 @@ class DatabaseNameKey(BaseIndexedDBKey):
 
     The value is the corresponding database ID.
     """
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> DatabaseNameKey:
     """Decodes the database name key."""
@@ -659,25 +695,26 @@ class GlobalMetaDataKey(BaseIndexedDBKey):
 
   METADATA_TYPE_TO_CLASS = {
       definitions.GlobalMetadataKeyType
-          .SCHEMA_VERSION: SchemaVersionKey,
+          .ACTIVE_BLOB_JOURNAL: ActiveBlobJournalKey,
       definitions.GlobalMetadataKeyType
-          .MAX_DATABASE_ID: MaxDatabaseIdKey,
+        .DATA_VERSION: DataVersionKey,
       definitions.GlobalMetadataKeyType
-          .DATA_VERSION: DataVersionKey,
+          .DATABASE_FREE_LIST: DatabaseFreeListKey,
       definitions.GlobalMetadataKeyType
-          .RECOVERY_BLOB_JOURNAL: RecoveryBlobJournalKey,
+          .DATABASE_NAME: DatabaseNameKey,
       definitions.GlobalMetadataKeyType
-          .ACTIVE_BLOB_JOURNAL: ActiveBlobJournalKey,
+          .EARLIEST_COMPACTION_TIME: EarliestCompactionTimeKey,
       definitions.GlobalMetadataKeyType
           .EARLIEST_SWEEP: EarliestSweepKey,
       definitions.GlobalMetadataKeyType
-          .EARLIEST_COMPACTION_TIME: EarliestCompactionTimeKey,
+          .MAX_DATABASE_ID: MaxDatabaseIdKey,
       definitions.GlobalMetadataKeyType
-          .SCOPES_PREFIX: ScopesPrefixKey,
+          .RECOVERY_BLOB_JOURNAL: RecoveryBlobJournalKey,
       definitions.GlobalMetadataKeyType
-          .DATABASE_FREE_LIST: DatabaseFreeListKey,
+          .SCHEMA_VERSION: SchemaVersionKey,
       definitions.GlobalMetadataKeyType
-          .DATABASE_NAME: DatabaseNameKey}
+          .SCOPES_PREFIX: ScopesPrefixKey,
+  }
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> Any:
     """Decodes the value from the current position of the LevelDBDecoder.
@@ -688,18 +725,20 @@ class GlobalMetaDataKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
-  ) -> Union[Type[ActiveBlobJournalKey],
-             Type[DataVersionKey],
-             Type[DatabaseFreeListKey],
-             Type[DatabaseNameKey],
-             Type[EarliestSweepKey],
-             Type[EarliestCompactionTimeKey],
-             Type[MaxDatabaseIdKey],
-             Type[RecoveryBlobJournalKey],
-             Type[SchemaVersionKey],
-             Type[ScopesPrefixKey]]:
+  ) -> Union[ActiveBlobJournalKey,
+             DataVersionKey,
+             DatabaseFreeListKey,
+             DatabaseNameKey,
+             EarliestSweepKey,
+             EarliestCompactionTimeKey,
+             MaxDatabaseIdKey,
+             RecoveryBlobJournalKey,
+             SchemaVersionKey,
+             ScopesPrefixKey]:
     """Decodes the global metadata key.
 
     Raises:
@@ -712,7 +751,7 @@ class GlobalMetaDataKey(BaseIndexedDBKey):
     if not key_class:
       raise errors.ParserError('Unknown metadata key type')
     return key_class.FromDecoder(
-        decoder, key_prefix, base_offset)  #pytype: disable=bad-return-type
+        decoder, key_prefix, base_offset)
 
 
 @dataclass
@@ -730,7 +769,9 @@ class ObjectStoreFreeListKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> ObjectStoreFreeListKey:
     """Decodes the object store free list key."""
@@ -758,7 +799,9 @@ class IndexFreeListKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
     ) -> IndexFreeListKey:
     """Decodes the index free list key."""
@@ -782,11 +825,14 @@ class ObjectStoreNamesKey(BaseIndexedDBKey):
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the object store names value."""
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
-  def FromDecoder(cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-                 base_offset: int = 0) -> ObjectStoreNamesKey:
+  def FromDecoder(
+      cls, decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      base_offset: int = 0
+  ) -> ObjectStoreNamesKey:
     """Decodes the object store names key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.DatabaseMetaDataKeyType.OBJECT_STORE_NAMES:
@@ -807,11 +853,15 @@ class IndexNamesKey(BaseIndexedDBKey):
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the index names value."""
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
-  def FromDecoder(cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-                 base_offset: int = 0) -> IndexNamesKey:
+  def FromDecoder(
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      base_offset: int = 0
+  ) -> IndexNamesKey:
     """Decodes the index names key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.DatabaseMetaDataKeyType.INDEX_NAMES:
@@ -844,7 +894,7 @@ class DatabaseMetaDataKey(BaseIndexedDBKey):
       return decoder.DecodeString()[1]
     if (self.metadata_type ==
         definitions.DatabaseMetaDataKeyType.MAX_ALLOCATED_OBJECT_STORE_ID):
-      return decoder.DecodeVarint()[1]
+      return decoder.DecodeInt()[1]
     if (self.metadata_type ==
         definitions.DatabaseMetaDataKeyType.IDB_INTEGER_VERSION):
       return decoder.DecodeVarint()[1]
@@ -919,7 +969,9 @@ class ObjectStoreMetaDataKey(BaseIndexedDBKey):
   metadata_type: definitions.ObjectStoreMetaDataKeyType
 
   def DecodeValue(
-      self, decoder: utils.LevelDBDecoder) -> Union[IDBKeyPath, str, bool, int]:
+      self,
+      decoder: utils.LevelDBDecoder
+  ) -> Union[IDBKeyPath, str, bool, int]:
     """Decodes the object store metadata value."""
     if (self.metadata_type ==
         definitions.ObjectStoreMetaDataKeyType.OBJECT_STORE_NAME):
@@ -948,7 +1000,9 @@ class ObjectStoreMetaDataKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> ObjectStoreMetaDataKey:
     """Decodes the object store metadata key."""
@@ -969,13 +1023,13 @@ class ObjectStoreDataValue:
   """The parsed values from an ObjectStoreDataKey.
 
   Attributes:
-    unknown: an unknown integer (possibly a sequence number?).
+    version: the version prefix.
     is_wrapped: True if the value was wrapped.
     blob_size: the blob size, only valid if wrapped.
     blob_offset: the blob offset, only valid if wrapped.
     value: the blink serialized value, only valid if not wrapped.
   """
-  unknown: int
+  version: int
   is_wrapped: bool
   blob_size: Optional[int]
   blob_offset: Optional[int]
@@ -992,37 +1046,54 @@ class ObjectStoreDataKey(BaseIndexedDBKey):
   encoded_user_key: IDBKey
 
   def DecodeValue(
-      self, decoder: utils.LevelDBDecoder) -> ObjectStoreDataValue:
+      self,
+      decoder: utils.LevelDBDecoder
+  ) -> ObjectStoreDataValue:
     """Decodes the object store data value."""
-    _, unknown_integer = decoder.DecodeVarint()
+    _, version = decoder.DecodeVarint()
 
     _, wrapped_header_bytes = decoder.PeekBytes(3)
     if len(wrapped_header_bytes) != 3:
       raise errors.DecoderError('Insufficient bytes')
 
-    if (wrapped_header_bytes[0] == definitions.BlinkSerializationTag.VERSION and
-        wrapped_header_bytes[1] == 0x11 and
-        wrapped_header_bytes[2] == 0x01):
+    if (wrapped_header_bytes[0] ==
+            definitions.BlinkSerializationTag.VERSION and
+        wrapped_header_bytes[1] ==
+            definitions.REQUIRES_PROCESSING_SSV_PSEUDO_VERSION and
+        wrapped_header_bytes[2] == definitions.REPLACE_WITH_BLOB):
+      _ = decoder.ReadBytes(3)
       _, blob_size = decoder.DecodeVarint()
       _, blob_offset = decoder.DecodeVarint()
       return ObjectStoreDataValue(
-          unknown=unknown_integer,
+          version=version,
           is_wrapped=True,
           blob_size=blob_size,
           blob_offset=blob_offset,
           value=None)
     _, blink_bytes = decoder.ReadBytes()
+    is_wrapped = False
+    if (
+        wrapped_header_bytes[0] ==
+        definitions.BlinkSerializationTag.VERSION and
+        wrapped_header_bytes[1] ==
+        definitions.REQUIRES_PROCESSING_SSV_PSEUDO_VERSION and
+        wrapped_header_bytes[2] == definitions.COMPRESSED_WITH_SNAPPY):
+      is_wrapped = True
+      # ignore the wrapped header bytes when decompressing
+      blink_bytes = snappy.decompress(blink_bytes[3:])
     blink_value = blink.V8ScriptValueDecoder.FromBytes(blink_bytes)
     return ObjectStoreDataValue(
-        unknown=unknown_integer,
-        is_wrapped=False,
+        version=version,
+        is_wrapped=is_wrapped,
         blob_size=None,
         blob_offset=None,
         value=blink_value)
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> ObjectStoreDataKey:
     """Decodes the object store data key."""
@@ -1052,13 +1123,14 @@ class ExistsEntryKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> ExistsEntryKey:
     """Decodes the exists entry key."""
     offset = decoder.stream.tell()
     encoded_user_key = IDBKey.FromDecoder(decoder, offset)
-
     return cls(
         offset=base_offset + offset,
         key_prefix=key_prefix, encoded_user_key=encoded_user_key)
@@ -1084,8 +1156,12 @@ class IndexDataKey(BaseIndexedDBKey):
     return version, idb_key
 
   @classmethod
-  def FromDecoder(cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-                 base_offset: int = 0) -> IndexDataKey:
+  def FromDecoder(
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      base_offset: int = 0
+  ) -> IndexDataKey:
     """Decodes the index data key."""
     offset = decoder.stream.tell()
     encoded_user_key = IDBKey.FromDecoder(decoder, offset)
@@ -1120,13 +1196,17 @@ class BlobEntryKey(BaseIndexedDBKey):
   user_key: IDBKey
 
   def DecodeValue(
-      self, decoder: utils.LevelDBDecoder) -> IndexedDBExternalObject:
+      self,
+      decoder: utils.LevelDBDecoder
+  ) -> IndexedDBExternalObject:
     """Decodes the blob entry value."""
     return IndexedDBExternalObject.FromDecoder(decoder)
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
       base_offset: int = 0
   ) -> BlobEntryKey:
     """Decodes the blob entry key."""
@@ -1145,13 +1225,13 @@ class IndexedDbKey(BaseIndexedDBKey):
   """
 
   METADATA_TYPE_TO_CLASS = {
-      definitions.KeyPrefixType.GLOBAL_METADATA: GlobalMetaDataKey,
+      definitions.KeyPrefixType.BLOB_ENTRY: BlobEntryKey,
       definitions.KeyPrefixType.DATABASE_METADATA: DatabaseMetaDataKey,
-      definitions.KeyPrefixType.OBJECT_STORE_DATA: ObjectStoreDataKey,
       definitions.KeyPrefixType.EXISTS_ENTRY: ExistsEntryKey,
+      definitions.KeyPrefixType.GLOBAL_METADATA: GlobalMetaDataKey,
+      definitions.KeyPrefixType.INVALID_TYPE: None,
       definitions.KeyPrefixType.INDEX_DATA: IndexDataKey,
-      definitions.KeyPrefixType.BLOB_ENTRY: BlobEntryKey,
-      definitions.KeyPrefixType.INVALID_TYPE: None
+      definitions.KeyPrefixType.OBJECT_STORE_DATA: ObjectStoreDataKey,
   }
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> Any:
@@ -1167,9 +1247,13 @@ class IndexedDbKey(BaseIndexedDBKey):
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
       base_offset: int = 0
-  ) -> Union[Type[DatabaseMetaDataKey], Type[ExistsEntryKey],
-             Type[BlobEntryKey], Type[GlobalMetaDataKey],
-             Type[IndexDataKey], Type[ObjectStoreDataKey]]:
+  ) -> Union[
+      BlobEntryKey,
+      DatabaseMetaDataKey,
+      ExistsEntryKey,
+      GlobalMetaDataKey,
+      IndexDataKey,
+      ObjectStoreDataKey]:
     """Decodes the IndexedDB key."""
     key_type = key_prefix.GetKeyPrefixType()
     key_class = cls.METADATA_TYPE_TO_CLASS.get(key_type)
@@ -1195,7 +1279,9 @@ class IndexMetaDataKey(BaseIndexedDBKey):
   metadata_type: definitions.IndexMetaDataKeyType
 
   def DecodeValue(
-      self, decoder: utils.LevelDBDecoder) -> Union[bool, IDBKeyPath, str]:
+      self,
+      decoder: utils.LevelDBDecoder
+  ) -> Union[bool, IDBKeyPath, str]:
     """Decodes the index metadata value."""
     if self.metadata_type == definitions.IndexMetaDataKeyType.INDEX_NAME:
       return decoder.DecodeString()[1]
@@ -1213,7 +1299,8 @@ class IndexMetaDataKey(BaseIndexedDBKey):
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
-      key_prefix: KeyPrefix, base_offset: int = 0
+      key_prefix: KeyPrefix,
+      base_offset: int = 0
   ) -> IndexMetaDataKey:
     """Decodes the index metadata key."""
     offset, key_type = decoder.DecodeUint8()
@@ -1402,21 +1489,21 @@ class FolderReader:
   """A IndexedDB folder reader for Chrome/Chromium.
 
   Attributes:
-    foldername (str): the source LevelDB folder.
+    folder_name (str): the source LevelDB folder.
   """
 
-  def __init__(self, foldername: pathlib.Path):
+  def __init__(self, folder_name: pathlib.Path):
     """Initializes the FileReader.
 
     Args:
-      foldername: the source IndexedDB folder.
+      folder_name: the source IndexedDB folder.
 
     Raises:
-      ValueError: if foldername is None or not a directory.
+      ValueError: if folder_name is None or not a directory.
     """
-    if not foldername or not foldername.is_dir():
-      raise ValueError(f'{foldername} is None or not a directory')
-    self.foldername = foldername
+    if not folder_name or not folder_name.is_dir():
+      raise ValueError(f'{folder_name} is None or not a directory')
+    self.folder_name = folder_name
 
   def GetRecords(
       self,
@@ -1432,13 +1519,12 @@ class FolderReader:
     Yields:
       IndexedDBRecord.
     """
-    leveldb_folder_reader = record.FolderReader(self.foldername)
+    leveldb_folder_reader = record.FolderReader(self.folder_name)
     for leveldb_record in leveldb_folder_reader.GetRecords(
         use_manifest=use_manifest,
         use_sequence_number=use_sequence_number):
       try:
-        yield IndexedDBRecord.FromLevelDBRecord(
-            leveldb_record)
+        yield IndexedDBRecord.FromLevelDBRecord(leveldb_record)
       except(
           errors.ParserError,
           errors.DecoderError,