# Section 2 - Registry Parsing

## Section 2.1 - Opening a Hive

Using the yarp library to open Windows registry hives using a class structure that is very portable and flexible.

Example Usage:

> `$ python yarp_base.py {NTUSER HIVE}`

References:

- https://github.com/msuhanov/yarp

- https://docs.python.org/3/library/struct.html

- https://docs.python.org/3/library/datetime.html

### Opening a Registry Hive

This class demonstrates how to open a registry hive file with the yarp tool. This library not only allows us to open a single offline hive, but also leverage any available transaction logs to include additional information otherwise available on the Window’s system. This class handles both the opening of the primary hive and attempted recovery of the transaction logs.

    class RegistryBase():
        """Base class containing common registry parsing code. Will open a hive
        and attempt recovery using available transaction logs"""
        def __init__(self, reg_file):
            """Base __init__ method, responsible for opening a hive."""
            self.reg_file = reg_file
            self.tx_log_files = []
            self.hive = None
            self._open_hive()

        def _open_hive(self):
            """Open a registry hive with yarp. Must be an open file object with read
            permissions. Will attempt to recover the hive with transaction logs if
            present.
            """
            self.hive = Registry.RegistryHive(self.reg_file)
            self._recover_hive()

        def _recover_hive(self):
            """Search for transaction logs and attempt recovery of the hive."""
            hive_path = self.hive.registry_file.file_object.name
            tx_logs = RegistryHelpers.DiscoverLogFiles(hive_path)
            self.tx_log_files = []
            for tx_path in ['log_path', 'log1_path', 'log2_path']:
                log_obj = None
                if getattr(tx_logs, tx_path, None):
                    log_obj = open(getattr(tx_logs, tx_path), 'rb')
                self.tx_log_files.append(log_obj)
            self.hive.recover_auto(*self.tx_log_files)

        def close(self):
            """Properly close a hive."""
            self.hive = None
            self.reg_file.close()
            for log in self.tx_log_files:
                if log:
                    log.close()

### Docstring References

class `RegistryBase`(reg_file)

  Base class containing common registry parsing code. Will open a hive and attempt recovery using available transaction logs

  `close`()

    Properly close a hive.

## Section 2.2 - Parsing Hive Values

Using the yarp library to parse NTUSER.DAT Windows registry hives using a class structure that is very portable and flexible. Parses the MountPoints2 and TrustRecords keys for with string and binary values.

Example Usage:

> `$ python yarp_ntuser.py {NTUSER HIVE}`

References:

- https://github.com/msuhanov/yarp

- https://docs.python.org/3/library/struct.html

- https://docs.python.org/3/library/datetime.html

### Creating a Hive Specific Parser

Since we have a strong base class providing functionality to open hives, we can build hive specific parsing classes that are tailored to handle artifacts distinct to a single hive type. In this case we set up a class to handle NTUSER.DAT files, though could get more specific on Windows versions, etc. In this class we store a few useful details including fixed values used by other methods and metadata about the class.

        def __init__(self, reg_path):
            super().__init__(reg_path)
            self.hive_type = 'NTUSER.DAT'
            self.macro_enabled_val = 2147483647

### Reading Hive String Values

With an open hive, we can begin to parse values from a known key location within the hive. This method allows us to specify a key path and inspect each of the subkeys. For each of the subkeys, we can then get the names and data associated with each value in the key. Additionally we could - if needed - continue to recurse on subkeys here. Instead we return this cursory information for the caller to display as they wish. Since the values within MountPoints2 store string data, we don’t need to perform further parsing of the record.

        def parse_mountpoints2(self):
            """Demonstration of parsing values from a key by path."""
            key_path = ('Software\\Microsoft\\Windows\\CurrentVersion'
                        '\\Explorer\\MountPoints2')
            for mp in self.hive.find_key(key_path).subkeys():
                mp_data = {}
                mp_data['name'] = mp.name().replace('#', '\\')
                mp_data['values'] = {x.name(): x.data() for x in mp.values()}
                mp_data['last_written'] = mp.last_written_timestamp()
                yield mp_data

### Reading Hive Binary Values

Similarly to our prior example, we can get a key by path. In this case we don’t have a sense of what Office versions are available in the key and have elected to iterate through each of those using the parse_office_versions() method. Using each of the versions, we then access the respective TrustRecords key. If found, we then parse the binary data (retrieved with the same .data() method) using Struct to extract a timestamp and integer marking whether a trusted macro was used. These parsed attributes are then returned to the caller to be displayed.

        def parse_trustrecords(self):
            """Demonstration of parsing binary values within a key."""
            trust_record_path = 'Software\\Microsoft\\Office\\{OFFICE_VERSION}' \
                        '\\Word\\Security\\Trusted Documents\\TrustRecords'
            for office_version in self.parse_office_versions():
                trust_rec_key = self.hive.find_key(
                    trust_record_path.format(OFFICE_VERSION=office_version))
                if not trust_rec_key:
                    continue

                for rec in trust_rec_key.values():
                    date_val, macro_enabled = struct.unpack('q12xI', rec.data())
                    ms = date_val/10.0
                    dt_date = datetime(1601, 1, 1) + timedelta(microseconds=ms)
                    yield {
                        'doc': rec.name(),
                        'dt': dt_date.isoformat(),
                        'macro': macro_enabled == self.macro_enabled_val
                    }

### Docstring References

class `NTUSER`(reg_path)

  Class to handle the parsing of the NTUSER.DAT hive.

  `parse_mountpoints2`()

    Demonstration of parsing values from a key by path.

  `parse_office_versions`()

    Get Office versions within an open Registry hive.

    Yields

      (str) – Office version number (ie. ‘15.0’)

  `parse_trustrecords`()

    Demonstration of parsing binary values within a key.

## Indices and tables

- Index

- Module Index

- Search Page