def test_Registry_set_value_default(self): registry.registry(TEST_KEY, access="F").set_value("", "test") self.assertEqual( win32api.RegQueryValueEx( win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r"software\winsys"), None), ("test", win32con.REG_SZ))
def test_Registry_set_value_expand_odd_percent(self): registry.registry(TEST_KEY, access="F").set_value("winsys4", "50%") self.assertEqual( win32api.RegQueryValueEx( win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r"software\winsys"), "winsys4"), ("50%", win32con.REG_SZ))
def test_Registry_set_value_non_empty_string(self): registry.registry(TEST_KEY, access="F").set_value("winsys4", "winsys") self.assertEqual( win32api.RegQueryValueEx( win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r"software\winsys"), "winsys4"), ("winsys", win32con.REG_SZ))
def set_registry_permissions(student_user): reg = registry.registry(r"HKLM\Software\OPE") with reg.security() as s: # Break inheritance causes things to reapply properly s.break_inheritance(copy_first=True) if student_user is not None: s.dacl.append( (student_user, registry.Registry.ACCESS["Q"], "ALLOW")) s.dacl.append((accounts.me(), registry.Registry.ACCESS["F"], "ALLOW")) # s.dacl.dump() reg = registry.registry(r"HKLM\Software\OPE\OPELMS") with reg.security() as s: # Break inheritance causes things to reapply properly s.break_inheritance(copy_first=True) if student_user is not None: s.dacl.append( (student_user, registry.Registry.ACCESS["Q"], "ALLOW")) s.dacl.append((accounts.me(), registry.Registry.ACCESS["F"], "ALLOW")) # s.dacl.dump() reg = registry.registry(r"HKLM\Software\OPE\OPELMS\student") with reg.security() as s: # Break inheritance causes things to reapply properly s.break_inheritance(copy_first=True) if student_user is not None: s.dacl.append( (student_user, registry.Registry.ACCESS["W"], "ALLOW")) s.dacl.append((accounts.me(), registry.Registry.ACCESS["F"], "ALLOW"))
def test_Registry_set_value_int(self): registry.registry(TEST_KEY, access="F").set_value("winsys4", 1) self.assertEqual( win32api.RegQueryValueEx( win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r"software\winsys"), "winsys4"), (1, win32con.REG_DWORD))
def test_Registry_set_value_multi(self): registry.registry(TEST_KEY, access="F").set_value("winsys4", ['a', 'b', 'c']) self.assertEqual( win32api.RegQueryValueEx( win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r"software\winsys"), "winsys4"), (['a', 'b', 'c'], win32con.REG_MULTI_SZ))
def test_Registry_set_value_type(self): registry.registry(TEST_KEY, access="F").set_value("winsys4", b"abc", win32con.REG_BINARY) self.assertEqual( win32api.RegQueryValueEx( win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r"software\winsys"), "winsys4"), (b"abc", win32con.REG_BINARY))
def test_Registry_getattr_key(self): win32api.RegCreateKey(win32con.HKEY_CURRENT_USER, r"software\winsys\winsys3") try: self.assertEqual( registry.registry(TEST_KEY).winsys3, registry.registry(TEST_KEY).get_key("winsys3")) finally: win32api.RegDeleteKey(win32con.HKEY_CURRENT_USER, r"Software\winsys\winsys3")
def test_walk (self): walker = registry.walk (TEST_KEY) key, subkeys, values = next (walker) assert key == registry.registry (TEST_KEY) assert list (values) == [("winsys1", GUID), ("winsys2", GUID)] key, subkeys, values = next (walker) assert key == registry.registry (TEST_KEY) + "win:sys3" key, subkeys, values = next (walker) assert key == registry.registry (TEST_KEY) + "winsys2" assert list (values) == [("winsys2", GUID)]
def test_walk(self): walker = registry.walk(TEST_KEY) key, subkeys, values = next(walker) self.assertEqual(key, registry.registry(TEST_KEY)) self.assertEqual(list(values), [("winsys1", GUID), ("winsys2", GUID)]) key, subkeys, values = next(walker) self.assertEqual(key, registry.registry(TEST_KEY) + "win:sys3") key, subkeys, values = next(walker) self.assertEqual(key, registry.registry(TEST_KEY) + "winsys2") self.assertEqual(list(values), [("winsys2", GUID)])
def test_walk(self): walker = registry.walk(TEST_KEY) key, subkeys, values = next(walker) self.assertEqual(key, registry.registry(TEST_KEY)) self.assertEqual(list(values), [("winsys1", GUID),("winsys2", GUID)]) key, subkeys, values = next(walker) self.assertEqual(key, registry.registry(TEST_KEY) + "win:sys3") key, subkeys, values = next(walker) self.assertEqual(key, registry.registry(TEST_KEY) + "winsys2") self.assertEqual(list(values), [("winsys2", GUID)])
def test_copy_exists_empty (self): key0 = registry.registry (TEST_KEY) key1 = registry.registry (TEST_KEY1) assert not bool (key1) key1.create () assert bool (key1) registry.copy (key0, key1) try: assert keys_are_equal (key0, key1) finally: key1.delete ()
def test_create_does_not_exist_deep (self): key1 = registry.registry (TEST_KEY1) key2 = registry.registry (TEST_KEY2) assert not bool (key1) assert not bool (key2) registry.create (key2) try: assert bool (key1) assert bool (key2) finally: key1.delete ()
def test_copy_exists_empty(self): key0 = registry.registry(TEST_KEY) key1 = registry.registry(TEST_KEY1) self.assertFalse(key1) key1.create() self.assertTrue(key1) registry.copy(key0, key1) try: self.assertTrue(keys_are_equal(key0, key1)) finally: key1.delete()
def test_create_does_not_exist_deep(self): key1 = registry.registry(TEST_KEY1) key2 = registry.registry(TEST_KEY2) self.assertFalse(key1) self.assertFalse(key2) registry.create(key2) try: self.assertTrue(key1) self.assertTrue(key2) finally: key1.delete()
def test_copy_exists_not_empty_keys(self): key0 = registry.registry(TEST_KEY) key1 = registry.registry(TEST_KEY1) self.assertFalse(key1) key1.create() self.assertTrue(key1) try: key1.create("winsys4") registry.copy(key0, key1) self.assertTrue(key0_subset_of_key1(key0, key1)) finally: key1.delete()
def test_copy_exists_not_empty_keys (self): key0 = registry.registry (TEST_KEY) key1 = registry.registry (TEST_KEY1) assert not bool (key1) key1.create () assert bool (key1) try: key1.create ("winsys4") registry.copy (key0, key1) assert key0_subset_of_key1 (key0, key1) finally: key1.delete ()
def test_copy_exists_not_empty_values (self): key0 = registry.registry (TEST_KEY) key1 = registry.registry (TEST_KEY1) assert not bool (key1) key1.create () assert bool (key1) try: key1.winsys4 = GUID registry.copy (key0, key1) assert set (set (key1.flat ()) - set (key0.flat ())) == \ set ([("winsys4", GUID), key1, key1 + "win:sys3", key1 + "winsys2"]) finally: key1.delete ()
def test_copy_exists_not_empty_values(self): key0 = registry.registry(TEST_KEY) key1 = registry.registry(TEST_KEY1, access="F") self.assertFalse(key1) key1.create() self.assertTrue(key1) try: key1.winsys4 = GUID registry.copy(key0, key1) self.assertEqual(set(set(key1.flat()) - set(key0.flat())), set([("winsys4", GUID), key1, key1 + "win:sys3", key1 + "winsys2"]) ) finally: key1.delete()
def test_copy_exists_not_empty_values(self): key0 = registry.registry(TEST_KEY) key1 = registry.registry(TEST_KEY1, access="F") self.assertFalse(key1) key1.create() self.assertTrue(key1) try: key1.winsys4 = GUID registry.copy(key0, key1) self.assertEqual( set(set(key1.flat()) - set(key0.flat())), set([("winsys4", GUID), key1, key1 + "win:sys3", key1 + "winsys2"])) finally: key1.delete()
def test_walk_access_denied(self): with self.assertRaises(registry.exc.x_access_denied): key = registry.registry(TEST_KEY, access=registry.REGISTRY_ACCESS.KEY_NOTIFY) walker = registry.walk(key) key, keys, values = next(walker) list(keys)
def __init__(self, computer, name): core._WinSysObject.__init__(self) self.computer = computer or "." self.name = name try: key = registry.registry(self.REG_ROOT % self.computer).get_key( self.name) except exc.x_winsys as err: warnings.warn( "Registry access failed with error: %s; log access may still be possible" % err.args[-1]) values = dict() else: if key: values = dict(key.values()) else: raise exc.x_not_found(None, "EventLog", r"\\%s\%s" % (self.computer, self.name)) self.auto_backup_log_files = values.get("AutoBackupLogFiles") self.display_name_file = values.get("DisplayNameFile") self.display_name_id = values.get("DisplayNameID") self.file = values.get("File") self.max_size = values.get("MaxSize") self.primary_module = values.get("PrimaryModule") self.restrict_guest_access = values.get("RestrictGuestAccess") self.retention = values.get("Retention") self.sources = values.get("Sources") self._handle = wrapped(win32evtlog.OpenEventLog, self.computer, self.name)
def __init__(self, computer, name): core._WinSysObject.__init__(self) self.computer = computer or "." self.name = name try: key = registry.registry(self.REG_ROOT % self.computer).get_key(self.name) except exc.x_winsys as err: warnings.warn("Registry access failed with error: %s; log access may still be possible" % err.args[-1]) values = dict() else: if key: values = dict(key.values()) else: raise exc.x_not_found(None, "EventLog", r"\\%s\%s" % (self.computer, self.name)) self.auto_backup_log_files = values.get("AutoBackupLogFiles") self.display_name_file = values.get("DisplayNameFile") self.display_name_id = values.get("DisplayNameID") self.file = values.get("File") self.max_size = values.get("MaxSize") self.primary_module = values.get("PrimaryModule") self.restrict_guest_access = values.get("RestrictGuestAccess") self.retention = values.get("Retention") self.sources = values.get("Sources") self._handle = wrapped(win32evtlog.OpenEventLog, self.computer, self.name)
def test_create_does_not_exist (): key1 = registry.registry (TEST_KEY1) assert not bool (key1) registry.create (key1) try: assert bool (key1) finally: key1.delete ()
def set_environment(**kwargs): root = registry.registry("HKCU") env = root.Environment for label, value in kwargs.iteritems(): env.set_value(label, value) win32gui.SendMessageTimeout(win32con.HWND_BROADCAST, win32con.WM_SETTINGCHANGE, 0, "Environment", win32con.SMTO_ABORTIFHUNG, 2000)
def __init__ (self, computer, name): core._WinSysObject.__init__ (self) self.computer = computer or "." self.name = name try: key = registry.registry (self.REG_ROOT % self.computer).get_key (self.name) except exc.x_winsys, err: warnings.warn ("Registry access failed with error: %s; log access may still be possible" % err.args[-1]) values = dict ()
def set_environment (**kwargs): root = registry.registry ("HKCU") env = root.Environment for label, value in kwargs.iteritems (): env.set_value (label, value) win32gui.SendMessageTimeout ( win32con.HWND_BROADCAST, win32con.WM_SETTINGCHANGE, 0, "Environment", win32con.SMTO_ABORTIFHUNG, 2000 )
def test_Registry_nonzero_not_exists(self): try: win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r"Software\winsys1") except win32api.error as error: errno, errctx, errmsg = error.args if errno != winerror.ERROR_FILE_NOT_FOUND: raise else: raise RuntimeError("Key exists but should not") self.assertFalse(registry.registry(TEST_KEY1))
def test_flat_ignore_access_denied (): remove_access (r"software\winsys\winsys2") try: key = registry.registry (TEST_KEY) assert list (registry.flat (key, ignore_access_errors=True)) == [ key, ("winsys1", GUID), ("winsys2", GUID), ] finally: restore_access (r"software\winsys\winsys2")
def get_reg_key(key_str, user_name=None): reg = registry.registry(key_str) with reg.security() as s: # Break inheritance causes things to reapply properly s.break_inheritance(copy_first=True) if user_name is not None: s.dacl.append((user_name, "Q", "ALLOW")) s.dacl.append((accounts.me(), "F", "ALLOW")) # s.dacl.dump() return reg
def test_Registry_nonzero_not_exists (self): try: win32api.RegOpenKey (win32con.HKEY_CURRENT_USER, r"Software\winsys1") except win32api.error as error: errno, errctx, errmsg = error.args if errno != winerror.ERROR_FILE_NOT_FOUND: raise else: raise RuntimeError ("Key exists but should not") assert not bool (registry.registry (TEST_KEY1))
def test_flat (self): key = registry.registry (TEST_KEY) assert list (registry.flat (key)) == [ key, ("winsys1", GUID), ("winsys2", GUID), key + "win:sys3", ("winsys3", GUID), key + "winsys2", ("winsys2", GUID) ]
def _get_python_paths(exclude=None, include=None): regbase = registry.registry(r"HKLM\SOFTWARE\Python\PythonCore") versions = [vers for vers in regbase] if exclude: versions = [vers for vers in versions if exclude not in vers.name] if include: versions = [vers for vers in versions if include in vers.name] install_paths = [_extract_installpath(vers) for vers in versions] install_paths = [path for path in install_paths if path is not None] return install_paths
def test_Registry_security(self): security_information = win32security.OWNER_SECURITY_INFORMATION | win32security.DACL_SECURITY_INFORMATION key = registry.registry(TEST_KEY) security = key.security(security_information) sd = win32security.GetSecurityInfo( win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r"software\winsys"), win32security.SE_REGISTRY_KEY, security_information) self.assertEqual( security.as_string(), win32security.ConvertSecurityDescriptorToStringSecurityDescriptor( sd, win32security.SDDL_REVISION_1, security_information))
def remove_key(key_path): try: # Open the key key = registry.registry(key_path, access=REGISTRY_ACCESS.KEY_READ|REGISTRY_ACCESS.KEY_WOW64_64KEY) key.delete() except Exception as ex: p("}}rnError - couldn't remove registry key }}xx\n" + str(key_path) + "\n" + \ str(ex), debug_level=1) return False return True
def __init__(self, computer, name): core._WinSysObject.__init__(self) self.computer = computer or "." self.name = name try: key = registry.registry(self.REG_ROOT % self.computer).get_key( self.name) except exc.x_winsys, err: warnings.warn( "Registry access failed with error: %s; log access may still be possible" % err.args[-1]) values = dict()
def test_flat_ignore_access_denied(self): remove_access(r"software\winsys\winsys2") try: key = registry.registry(TEST_KEY) self.assertEqual( list(registry.flat(key, ignore_access_errors=True)), [ key, ("winsys1", GUID), ("winsys2", GUID), key + "win:sys3", ("winsys3", GUID), ]) finally: restore_access(r"software\winsys\winsys2")
def test_flat(self): key = registry.registry(TEST_KEY) self.assertEqual( list(registry.flat(key)), [ key, ("winsys1", GUID), ("winsys2", GUID), key + "win:sys3", ("winsys3", GUID), key + "winsys2", ("winsys2", GUID) ] )
def test_Registry_security (self): security_information = win32security.OWNER_SECURITY_INFORMATION | win32security.DACL_SECURITY_INFORMATION key = registry.registry (TEST_KEY) security = key.security (security_information) sd = win32security.GetSecurityInfo ( win32api.RegOpenKey (win32con.HKEY_CURRENT_USER, r"software\winsys"), win32security.SE_REGISTRY_KEY, security_information ) assert \ security.as_string () == \ win32security.ConvertSecurityDescriptorToStringSecurityDescriptor ( sd, win32security.SDDL_REVISION_1, security_information )
def __init__ (self, computer, name): core._WinSysObject.__init__ (self) self.computer = computer or "." self.name = name key = registry.registry (self.REG_ROOT % self.computer).get_key (self.name) if not key: raise x_not_found (None, "EventLog", r"\\%s\%s" % (self.computer, self.name)) else: values = dict (key.values ()) self.auto_backup_log_files = values.get ("AutoBackupLogFiles") self.display_name_file = values.get ("DisplayNameFile") self.display_name_id = values.get ("DisplayNameID") self.file = values.get ("File") self.max_size = values.get ("MaxSize") self.primary_module = values.get ("PrimaryModule") self.restrict_guest_access = values.get ("RestrictGuestAccess") self.retention = values.get ("Retention") self.sources = values.get ("Sources") self._handle = wrapped (win32evtlog.OpenEventLog, self.computer, self.name)
def __init__(self, computer, log_name, source_name): core._WinSysObject.__init__(self) self.computer = computer or "." self.log_name = log_name or DEFAULT_LOG_NAME self.name = source_name key = registry.registry(r"%s\%s\%s" % (EventLog.REG_ROOT % self.computer, self.log_name, self.name)) if not key: raise exc.x_not_found(None, "EventSource", r"\\%s\%s\%s" % (self.computer, self.log_name, self.name)) self._handle = None values = dict(key.values()) types = dict((name, type) for (name, value, type) in key.values(_want_types=True)) self.category_count = values.get("CategoryCount") self.category_message_file = values.get("CategoryMessageFile") self.event_message_file = values.get("EventMessageFile") self.parameter_message_file = values.get("ParameterMessageFile") types_supported = values.get("TypesSupported") or 0 # # This is messy because, although TypeSupported is specified # as a DWORD and constitutes a set of flags, it seems to be # implemented in any number of ingenious ways, including # binary data representing a number and a string representing # the hexadecimal value of the flags. # try: self.types_supported = int(types_supported or 0) except ValueError: types_type = types.get("TypesSupported") if types_type == registry.REGISTRY_VALUE_TYPE.REG_SZ: if types_supported.startswith("0x"): self.types_supported = int(types_supported, 16) else: self.types_supported = int(types_supported, 10) elif types_type == registry.REGISTRY_VALUE_TYPE.REG_BINARY: self.types_supported, = struct.unpack("L", types_supported) else: raise x_event_logs(None, None, "Can't determine types supported")
from winsys import registry, environment def munge_path(env, python_paths): #env['PATH'] = print ";".join( p for p in env['PATH'].split(";") if not any( p.lower().startswith(py) for py in python_paths ) ) py = registry.registry(r"hklm\software\python\pythoncore") py_paths = set(version.InstallPath.get_value("").rstrip("\\").lower() for version in py) py = registry.registry(r"hkcu\software\python\pythoncore") py_paths.update(version.InstallPath.get_value("").rstrip("\\").lower() for version in py) munge_path(environment.user(), py_paths) munge_path(environment.system(), py_paths)
def get_environment (): return dict ( registry.registry (r"HKCU\Environment").itervalues () )
def setUp(self): event_logs.EventSource.create(GUID, LOG_NAME) self.registry_root = registry.registry(r"HKLM\SYSTEM\CurrentControlSet\Services\Eventlog")
from winsys import dialogs, registry root, term = dialogs.dialog ( "Search the Registry", ("Root", registry.REGISTRY_HIVE.keys ()), ("Term", "") ) root = registry.registry (root) term = term.lower () for key, subkeys, values in root.walk (ignore_access_errors=True): for name, value in values: if term in str (value).lower (): print key.moniker.encode ("utf8") print name.encode ("utf8") or "(Default)" print unicode (value).encode ("utf8") print
def __init__(self, root): super(Persistent, self).__init__() self.registry = registry.registry(root)
def event_sources(log_name=DEFAULT_LOG_NAME, computer="."): """Simple iterator over all the event sources for a named log """ for key in registry.registry(EventLog.REG_ROOT % computer).get_key(log_name).keys(): yield EventSource(computer, log_name, key.name)
def event_logs(computer="."): """Simple iterator over all known event logs. """ for key in registry.registry(EventLog.REG_ROOT % computer).keys(): yield EventLog(computer, key.name)