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)