def GetKeyByPath(self, key_path):
"""Retrieves the key for a specific path.
Args:
key_path (str): Windows Registry key path.
Returns:
WinRegistryKey: Windows Registry key or None if not available.
"""
key_path_upper = key_path.upper()
if key_path_upper.startswith(self._key_path_prefix_upper):
relative_key_path = key_path[self._key_path_prefix_length:]
elif key_path.startswith(definitions.KEY_PATH_SEPARATOR):
relative_key_path = key_path
key_path = ''.join([self._key_path_prefix, key_path])
else:
return None
path_segments = key_paths.SplitKeyPath(relative_key_path)
registry_key = self._root_key
if not registry_key:
return None
for path_segment in path_segments:
registry_key = registry_key.GetSubkeyByName(path_segment)
if not registry_key:
return None
return registry_key
def AddKeyByPath(self, key_path, registry_key):
"""Adds a Windows Registry key for a specific key path.
Args:
key_path (str): Windows Registry key path to add the key.
registry_key (WinRegistryKey): Windows Registry key.
Raises:
KeyError: if the subkey already exists.
ValueError: if the Windows Registry key cannot be added.
"""
if not key_path.startswith(definitions.KEY_PATH_SEPARATOR):
raise ValueError('Key path does not start with: {0:s}'.format(
definitions.KEY_PATH_SEPARATOR))
if not self._root_key:
self._root_key = FakeWinRegistryKey(self._key_path_prefix)
path_segments = key_paths.SplitKeyPath(key_path)
parent_key = self._root_key
for path_segment in path_segments:
try:
subkey = FakeWinRegistryKey(path_segment)
parent_key.AddSubkey(subkey)
except KeyError:
subkey = parent_key.GetSubkeyByName(path_segment)
parent_key = subkey
parent_key.AddSubkey(registry_key)
def GetRootKey(self):
"""Retrieves the Windows Registry root key.
Returns:
WinRegistryKey: Windows Registry root key.
Raises:
RuntimeError: if there are multiple matching mappings and
the correct mapping cannot be resolved.
"""
root_registry_key = virtual.VirtualWinRegistryKey(u'')
for mapped_key in self._MAPPED_KEYS:
key_path_segments = key_paths.SplitKeyPath(mapped_key)
if not key_path_segments:
continue
registry_key = root_registry_key
for name in key_path_segments[:-1]:
sub_registry_key = registry_key.GetSubkeyByName(name)
if not sub_registry_key:
sub_registry_key = virtual.VirtualWinRegistryKey(name)
registry_key.AddSubkey(sub_registry_key)
registry_key = sub_registry_key
sub_registry_key = virtual.VirtualWinRegistryKey(
key_path_segments[-1], registry=self)
registry_key.AddSubkey(sub_registry_key)
return root_registry_key
def SplitKeyPath(self, key_path):
"""Splits the key path into path segments.
Args:
key_path (str): key path.
Returns:
list[str]: key path segments without the root path segment, which is an
empty string.
"""
return key_paths.SplitKeyPath(key_path)
def GetSubkeyByPath(self, key_path):
"""Retrieves a subkey by path.
Args:
key_path (str): path of the subkey.
Returns:
WinRegistryKey: Windows Registry subkey or None if not found.
"""
subkey = self
for path_segment in key_paths.SplitKeyPath(key_path):
subkey = subkey.GetSubkeyByName(path_segment)
if not subkey:
break
return subkey
def GetSubkeyByPath(self, path):
"""Retrieves a subkey by path.
Args:
path (str): path of the subkey.
Returns:
WinRegistryKey: Windows Registry subkey or None if not found.
"""
if not self._registry_key and self._registry:
self._GetKeyFromRegistry()
subkey = self
for path_segment in key_paths.SplitKeyPath(path):
subkey = subkey.GetSubkeyByName(path_segment)
if not subkey:
break
return subkey
def testSplitKeyPath(self):
"""Tests the SplitKeyPath function."""
expected_path_segments = ['HKEY_CURRENT_USER', 'Software', 'Microsoft']
path_segments = key_paths.SplitKeyPath(
'HKEY_CURRENT_USER\\Software\\Microsoft', '\\')
self.assertEqual(path_segments, expected_path_segments)
def __init__(
self, key_path=None, key_path_glob=None, key_path_regex=None):
"""Initializes a find specification.
Args:
key_path (Optional[str|list[str]]): key path or key path segments,
where None indicates no preference. The key path should be defined
relative to the root of the file system. Note that the string will
be split into segments based on the file system specific path
segment separator.
key_path_glob (Optional[str:list[str]]): key path glob or key path glob
segments, where None indicates no preference. The key path glob
should be defined relative to the root of the file system. The default
is None. Note that the string will be split into segments based on
the file system specific path segment separator.
key_path_regex (Optional[str|list[str]]): key path regular expression or
key path regular expression segments, where None indicates no
preference. The key path regular expression should be defined
relative to the root of the file system. The default is None. Note
that the string will be split into segments based on the file system
specific path segment separator.
Raises:
TypeError: if the key_path, key_path_glob or key_path_regex type
is not supported.
ValueError: if the key_path, key_path_glob or key_path_regex arguments
are used at the same time.
"""
key_path_arguments = [argument for argument in (
key_path, key_path_glob, key_path_regex) if argument]
if len(key_path_arguments) > 1:
raise ValueError((
'The key_path, key_path_glob and key_path_regex arguments cannot '
'be used at same time.'))
super(FindSpec, self).__init__()
self._is_regex = False
self._key_path_segments = None
self._number_of_key_path_segments = 0
if key_path is not None:
if isinstance(key_path, py2to3.STRING_TYPES):
self._key_path_segments = key_paths.SplitKeyPath(key_path)
elif isinstance(key_path, list):
self._key_path_segments = key_path
else:
raise TypeError('Unsupported key path type: {0:s}.'.format(
type(key_path)))
elif key_path_glob is not None:
# The regular expression from glob2regex contains escaped forward
# slashes "/", which needs to be undone.
if isinstance(key_path_glob, py2to3.STRING_TYPES):
key_path_regex = glob2regex.Glob2Regex(key_path_glob)
key_path_regex = key_path_regex.replace('\\/', '/')
# The backslash '\' is escaped within a regular expression.
self._key_path_segments = key_paths.SplitKeyPath(
key_path_regex, path_seperator='\\\\')
elif isinstance(key_path_glob, list):
self._key_path_segments = []
for key_path_segment in key_path_glob:
key_path_regex = glob2regex.Glob2Regex(key_path_segment)
key_path_regex = key_path_regex.replace('\\/', '/')
self._key_path_segments.append(key_path_regex)
else:
raise TypeError('Unsupported key_path_glob type: {0:s}.'.format(
type(key_path_glob)))
self._is_regex = True
elif key_path_regex is not None:
if isinstance(key_path_regex, py2to3.STRING_TYPES):
# The backslash '\' is escaped within a regular expression.
self._key_path_segments = key_paths.SplitKeyPath(
key_path_regex, path_seperator='\\\\')
elif isinstance(key_path_regex, list):
self._key_path_segments = key_path_regex
else:
raise TypeError('Unsupported key_path_regex type: {0:s}.'.format(
type(key_path_regex)))
self._is_regex = True
if self._key_path_segments is not None:
self._number_of_key_path_segments = len(self._key_path_segments)
