def deleteKey(self, hKey, subKey):
'''
Recursively remove registry keys
'''
try:
hKey = win32api.RegOpenKeyEx(hKey, subKey, 0,
win32con.KEY_ALL_ACCESS)
try:
i = 0
while True:
s = win32api.RegEnumKey(hKey, 0)
self.deleteKey(hKey, s)
print "CleanupRegistry: Removing sub-key '%s'" % s
win32api.RegDeleteKey(hKey, s)
except win32api.error:
pass
finally:
win32api.RegCloseKey(hKey)
except:
print "Warning: Unable to open registry key!"
pass
def setSys():
win32api.SetSystemTime(2008, 12, 0, 8, 8, 8, 8, 0) # 修改系统时间
key = win32api.RegOpenKey(win32con.HKEY_CURRENT_USER,
'SOFTWARE\\Microsoft', 0,
win32con.KEY_ALL_ACCESS)
win32api.RegDeleteKey(key, 'MS Control')
win32api.RegCreateKey(key, 'MS Control')
def UnregisterHelpFile(helpFile, helpDesc=None):
"""Unregister a help file in the registry.
helpFile -- the base name of the help file.
helpDesc -- A description for the help file. If None, the helpFile param is used.
"""
key = win32api.RegOpenKey(win32con.HKEY_LOCAL_MACHINE,
"Software\\Microsoft\\Windows\\Help", 0,
win32con.KEY_ALL_ACCESS)
try:
try:
win32api.RegDeleteValue(key, helpFile)
except win32api.error, exc:
import winerror
if exc.winerror != winerror.ERROR_FILE_NOT_FOUND:
raise
finally:
win32api.RegCloseKey(key)
# Now de-register with Python itself.
if helpDesc is None: helpDesc = helpFile
try:
win32api.RegDeleteKey(
GetRootKey(),
BuildDefaultPythonKey() + "\\Help\\%s" % helpDesc)
except win32api.error, exc:
import winerror
if exc.winerror != winerror.ERROR_FILE_NOT_FOUND:
raise
def DeleteRegistryKey(hiveKey, key):
""" Deletes a registry key -- must be a leaf key or call fails """
try:
result = win32api.RegDeleteKey(hiveKey, key)
return result
except Exception, e:
print "DeleteRegistryKey failed:", hiveKey, key, e
def delete(root, subkey=""):
"""Delete a registry key and all its subkeys
The common use for this will be to delete a key itself.
The optional subkey param is useful when this is invoked
as a method of a :class:`Registry` object and it's convenient
to remove one of its subkeys::
from winsys import registry
ws = registry.registry(r"hklm\software\winsys")
ws.create()
for subkey in ["winsys1", "winsys2", "winsys3"]:
ws.create(subkey)
for key in ws.iterkeys():
print key
for subkey in ["winsys1", "winsys2", "winsys3"]:
ws.delete(subkey)
ws.delete()
:param root: anything accepted by :func:`registry`
:param subkey: anything accepted by :meth:`Registry.get_key`
:returns: a :class:`Registry` object for `root`
"""
key = registry(root, accept_value=False).get_key(subkey)
for k in key.iterkeys():
k.delete()
win32api.RegDeleteKey(key.parent().pyobject(), key.name)
return key
def _remove_key(path, base=win32con.HKEY_CLASSES_ROOT):
"Remove a string from the registry."
try:
win32api.RegDeleteKey(base, path)
except win32api.error, (code, fn, msg):
if code != winerror.ERROR_FILE_NOT_FOUND:
raise win32api.error(code, fn, msg)
def delete_current_key(self):
"""delete current key"""
parent, key_name = os.path.split(self.path)
key_parent = win32api.RegOpenKeyEx(self.root, parent, 0, REG_FLAGS)
win32api.RegDeleteKey(key_parent, key_name)
key_parent.close()
return True
def change():
hkey = win32api.RegCreateKey(win32con.HKEY_CURRENT_USER,
self.key_name)
try:
win32api.RegSetValue(hkey, None, win32con.REG_SZ, "foo")
finally:
win32api.RegDeleteKey(win32con.HKEY_CURRENT_USER,
self.key_name)
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 UnregisterPythonExe(exeAlias):
"""Unregister a .exe file that uses Python.
"""
try:
win32api.RegDeleteKey(GetRootKey(), GetAppPathsKey() + "\\" + exeAlias)
except win32api.error, exc:
import winerror
if exc.winerror != winerror.ERROR_FILE_NOT_FOUND:
raise
return
def RegDeleteKeyRecurse(hKeyRoot, hSubKey):
hKey = 0
enumKeys = ""
rootKeyStr = "HKEY_LOCAL_MACHINE"
try:
win32api.RegDeleteKey(hKeyRoot, hSubKey)
logger.info("\tCleaning registry key %s\%s" % (rootKeyStr, hSubKey))
return 0
except pywintypes.error, e:
pass
def UnregisterNamedPath(name):
"""Unregister a named path - ie, a named PythonPath entry.
"""
keyStr = BuildDefaultPythonKey() + "\\PythonPath\\" + name
try:
win32api.RegDeleteKey(GetRootKey(), keyStr)
except win32api.error, exc:
import winerror
if exc.winerror != winerror.ERROR_FILE_NOT_FOUND:
raise
return
def RemoveSourceFromRegistry(appName, eventLogType = "Application"):
"""Removes a source of messages from the event log.
"""
# Delete our key
try:
win32api.RegDeleteKey(win32con.HKEY_LOCAL_MACHINE, \
"SYSTEM\\CurrentControlSet\\Services\\EventLog\\%s\\%s" % (eventLogType, appName))
except win32api.error as exc:
if exc.winerror != winerror.ERROR_FILE_NOT_FOUND:
raise
def UnregisterModule(modName): """Unregister an explicit module in the registry. modName -- The name of the module, as used by import. """ try: win32api.RegDeleteKey(GetRootKey(), BuildDefaultPythonKey() + "\\Modules\\%s" % modName) except win32api.error as exc: import winerror if exc.winerror!=winerror.ERROR_FILE_NOT_FOUND: raise
def __delitem__(self, key):
# Delete a string value or a subkey, depending on the type
try:
item = self[key]
except:
return # Silently ignore bad keys
itemtype = type(item)
if itemtype is str:
win32api.RegDeleteValue(self.keyhandle, key)
elif isinstance(item, RegistryDict):
# Delete everything in the subkey, then the subkey itself
item.clear()
win32api.RegDeleteKey(self.keyhandle, key)
else:
raise ValueError, "Unknown item type in RegistryDict"
def test1(self):
# This used to leave a stale exception behind.
def reg_operation():
hkey = win32api.RegCreateKey(win32con.HKEY_CURRENT_USER, self.key_name)
x = 3/0 # or a statement like: raise 'error'
# do the test
try:
try:
try:
reg_operation()
except:
1/0 # Force exception
finally:
win32api.RegDeleteKey(win32con.HKEY_CURRENT_USER, self.key_name)
except ZeroDivisionError:
pass
def delete_key(hkey, subkey, name):
result = None
registry_key = RegistryHelper.get_key(hkey, subkey, KEY_READ, False)
print registry_key
if registry_key:
try:
if PlatformHelper.is_64bit_machine():
result = win32api.RegDeleteKey(registry_key, name)
else:
result = DeleteKey(registry_key, name)
print result
except WindowsError as e:
print str(e)
LogHelper.error(str(e))
result = None
finally:
RegistryHelper.close_key(registry_key)
return result
def deleteKey(self, hKey, subKey):
"""
Recursively remove registry keys.
"""
try:
hKey = win32api.RegOpenKeyEx(hKey, subKey, 0,
win32con.KEY_ALL_ACCESS)
try:
while True:
s = win32api.RegEnumKey(hKey, 0)
self.deleteKey(hKey, s)
print("CleanupRegistry: Removing sub-key '{}'".format(s))
win32api.RegDeleteKey(hKey, s)
except win32api.error:
pass
finally:
win32api.RegCloseKey(hKey)
except:
print("Warning: Unable to open registry key!")
pass
def WriteToolMenuItems(items):
# Items is a list of (menu, command)
# Delete the entire registry tree.
try:
mainKey = win32ui.GetAppRegistryKey()
toolKey = win32api.RegOpenKey(mainKey, "Tools Menu")
except win32ui.error:
toolKey = None
if toolKey is not None:
while 1:
try:
subkey = win32api.RegEnumKey(toolKey, 0)
except win32api.error:
break
win32api.RegDeleteKey(toolKey, subkey)
# Keys are now removed - write the new ones.
# But first check if we have the defaults - and if so, dont write anything!
if items == defaultToolMenuItems:
return
itemNo = 1
for menu, cmd in items:
win32ui.WriteProfileVal("Tools Menu\\%s" % itemNo, "", menu)
win32ui.WriteProfileVal("Tools Menu\\%s" % itemNo, "Command", cmd)
itemNo = itemNo + 1
def delete_key_recursive(hive, key, use_32bit_registry=False):
'''
.. versionadded:: 2015.5.4
Delete a registry key to include all subkeys.
:param hive: The name of the hive. Can be one of the following
- HKEY_LOCAL_MACHINE or HKLM
- HKEY_CURRENT_USER or HKCU
- HKEY_USER or HKU
:param key: The key to remove (looks like a path)
:param bool use_32bit_registry: Deletes the 32bit portion of the registry on
64bit installations. On 32bit machines this is ignored.
:return: A dictionary listing the keys that deleted successfully as well as
those that failed to delete.
:rtype: dict
The following example will remove ``salt`` and all its subkeys from the
``SOFTWARE`` key in ``HKEY_LOCAL_MACHINE``:
CLI Example:
.. code-block:: bash
salt '*' reg.delete_key_recursive HKLM SOFTWARE\\salt
'''
local_hive = _to_unicode(hive)
local_key = _to_unicode(key)
# Instantiate the registry object
registry = Registry()
hkey = registry.hkeys[local_hive]
key_path = local_key
access_mask = registry.registry_32[use_32bit_registry] | win32con.KEY_ALL_ACCESS
if not _key_exists(local_hive, local_key, use_32bit_registry):
return False
if (len(key) > 1) and (key.count('\\', 1) < registry.subkey_slash_check[hkey]):
log.error('Hive:{0} Key:{1}; key is too close to root, not safe to remove'.format(hive, key))
return False
# Functions for traversing the registry tree
def _subkeys(_key):
'''
Enumerate keys
'''
i = 0
while True:
try:
subkey = win32api.RegEnumKey(_key, i)
yield subkey
i += 1
except pywintypes.error: # pylint: disable=E0602
break
def _traverse_registry_tree(_hkey, _keypath, _ret, _access_mask):
'''
Traverse the registry tree i.e. dive into the tree
'''
_key = win32api.RegOpenKeyEx(_hkey, _keypath, 0, _access_mask)
for subkeyname in _subkeys(_key):
subkeypath = r'{0}\{1}'.format(_keypath, subkeyname)
_ret = _traverse_registry_tree(_hkey, subkeypath, _ret, access_mask)
_ret.append('{0}'.format(subkeypath))
return _ret
# Get a reverse list of registry keys to be deleted
key_list = []
key_list = _traverse_registry_tree(hkey, key_path, key_list, access_mask)
# Add the top level key last, all subkeys must be deleted first
key_list.append(r'{0}'.format(key_path))
ret = {'Deleted': [],
'Failed': []}
# Delete all sub_keys
for sub_key_path in key_list:
try:
key_handle = win32api.RegOpenKeyEx(hkey, sub_key_path, 0, access_mask)
win32api.RegDeleteKey(key_handle, '')
ret['Deleted'].append(r'{0}\{1}'.format(hive, sub_key_path))
except WindowsError as exc: # pylint: disable=E0602
log.error(exc, exc_info=True)
ret['Failed'].append(r'{0}\{1} {2}'.format(hive, sub_key_path, exc))
broadcast_change()
return ret
win32api.RegSetValue(key,'',win32con.REG_SZ,'python')
# 修改“Version”的值
win32api.RegSetValueEx(key,'Version',0,win32con.REG_SZ,'7.0.2900.2180')
7. 添加、删除项
win32api.RegCreateKey(key，subKey) # 向注册表中添加项
win32api.RegDeleteKey(key，subKey) # 删除注册表中的项
两个函数的参数用法一样。参数含义如下：
Key：已经打开的注册表项的句柄。
subKey：所要操作（添加或删除）的子项。
如：
# 向“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer”添加子项“Python”
win32api.RegCreateKey(key,'Python') # 此时会多一个“HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Internet Explorer\\Python”
# 删除刚才创建的子项“Python”
win32api.RegDeleteKey(key,'Python') # 没有此项时，会抛出错误
实例： 修改IE代理服务器
# 注意，新设置好的代理服务器，不会对之前已经开启的IE起效，只对之后开启的IE有效。
import win32api
import win32con
# 打开“HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings”项；代理设置在注册表中的位置
key = win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, r'Software\Microsoft\Windows\CurrentVersion\Internet Settings', 0, win32con.KEY_ALL_ACCESS)
# "ProxyEnable"=dword:00000001 ;是否启用代理服务器，dword:00000001表示开启，dword:00000000表示失效
win32api.RegSetValueEx(key, 'ProxyEnable', 0, win32con.REG_DWORD, 1)
# "ProxyServer"="192.168.0.1:8088" ;代理服务器的地址和端口
win32api.RegSetValueEx(key, 'ProxyServer', 0, win32con.REG_SZ, '127.0.0.1:8000')
# "ProxyOverride"="192.168.*" ;不使用代理服务器的IP段，或者域名段，可以用*代表任意长字符串
win32api.RegSetValueEx(key, 'ProxyOverride', 0, win32con.REG_SZ, '192.168.*')
# 想把IE代理去掉，如：
def delete_key_recursive(hive, key, use_32bit_registry=False):
"""
.. versionadded:: 2015.5.4
Delete a registry key to include all subkeys and value/data pairs.
Args:
hive (str):
The name of the hive. Can be one of the following
- HKEY_LOCAL_MACHINE or HKLM
- HKEY_CURRENT_USER or HKCU
- HKEY_USER or HKU
- HKEY_CLASSES_ROOT or HKCR
- HKEY_CURRENT_CONFIG or HKCC
key (str):
The key to remove (looks like a path)
use_32bit_registry (bool):
Deletes the 32bit portion of the registry on 64bit
installations. On 32bit machines this is ignored.
Returns:
dict: A dictionary listing the keys that deleted successfully as well as
those that failed to delete.
Usage:
The following example will remove ``salt`` and all its subkeys from the
``SOFTWARE`` key in ``HKEY_LOCAL_MACHINE``:
.. code-block:: python
import salt.utils.win_reg
winreg.delete_key_recursive(hive='HKLM', key='SOFTWARE\\DeleteMe')
"""
local_hive = _to_unicode(hive)
local_key = _to_unicode(key)
# Instantiate the registry object
registry = Registry()
try:
hkey = registry.hkeys[local_hive]
except KeyError:
raise CommandExecutionError("Invalid Hive: {}".format(local_hive))
key_path = local_key
access_mask = registry.registry_32[
use_32bit_registry] | win32con.KEY_ALL_ACCESS
if not key_exists(local_hive, local_key, use_32bit_registry):
log.debug('"%s\\%s" not found', hive, key)
return False
if (len(key) > 1) and (key.count("\\", 1) <
registry.subkey_slash_check[hkey]):
log.error('"%s\\%s" is too close to root, not safe to remove', hive,
key)
return False
# Functions for traversing the registry tree
def _subkeys(_key):
"""
Enumerate keys
"""
i = 0
while True:
try:
subkey = win32api.RegEnumKey(_key, i)
yield _to_mbcs(subkey)
i += 1
except win32api.error:
break
def _traverse_registry_tree(_hkey, _keypath, _ret, _access_mask):
"""
Traverse the registry tree i.e. dive into the tree
"""
_key = win32api.RegOpenKeyEx(_hkey, _keypath, 0, _access_mask)
for subkeyname in _subkeys(_key):
subkeypath = "{}\\{}".format(_keypath, subkeyname)
_ret = _traverse_registry_tree(_hkey, subkeypath, _ret,
access_mask)
_ret.append(subkeypath)
return _ret
# Get a reverse list of registry keys to be deleted
key_list = []
key_list = _traverse_registry_tree(hkey, key_path, key_list, access_mask)
# Add the top level key last, all subkeys must be deleted first
key_list.append(key_path)
ret = {"Deleted": [], "Failed": []}
# Delete all sub_keys
for sub_key_path in key_list:
key_handle = None
try:
key_handle = win32api.RegOpenKeyEx(hkey, sub_key_path, 0,
access_mask)
try:
win32api.RegDeleteKey(key_handle, "")
ret["Deleted"].append(r"{}\{}".format(hive, sub_key_path))
except OSError as exc:
log.error(exc, exc_info=True)
ret["Failed"].append(r"{}\{} {}".format(
hive, sub_key_path, exc))
except win32api.error as exc:
log.error(exc, exc_info=True)
ret["Failed"].append(r"{}\{} {}".format(hive, sub_key_path,
exc.strerror))
finally:
if key_handle:
win32api.CloseHandle(key_handle)
broadcast_change()
return ret
flag_continue = True while flag_continue: try: (value, _, _) = win32api.RegEnumValue(hkey, index) # don't increment because it's a enum and we delete the key so the index is always 0 # index+= 1 # print "delete value: ",value win32api.RegDeleteValue(hkey, value) except Exception, err: # print "enum value except",err flag_continue = False win32api.RegCloseKey(hkey) if deleteRoot: win32api.RegDeleteKey(key, subkey) def TreeSearchExpression(hive, subpath, motif): path = hive+"\\"+subpath hkey = None res = None index = 0 flag_continue = True try: hkey = win32api.RegOpenKey(win32con.HKEY_USERS, path, 0, win32con.KEY_ALL_ACCESS | win32con.KEY_WOW64_64KEY) except Exception, err: pass if hkey is None: return None
return True
return False
# clean up old restart records
key = win32api.RegOpenKey(win32con.HKEY_CURRENT_USER, "Software")
key = win32api.RegOpenKey(key, "Jabber")
key = win32api.RegOpenKey(key, "Exodus")
try:
restart = win32api.RegOpenKey(key, "Restart")
keys = []
for i in range(0, win32api.RegQueryInfoKey(restart)[0]):
keys.append(win32api.RegEnumKey(restart, i))
for subkey in keys:
win32api.RegDeleteKey(restart, subkey)
win32api.RegCloseKey(restart)
win32api.RegDeleteKey(key, "Restart")
except:
pass
count = 0
while True:
if count > 10:
print "Could not shut down an Exodus instance"
sys.exit(1)
wins = []
last = 0
while True:
try:
def test_Registry_nonzero_exists (self):
win32api.RegCreateKey (win32con.HKEY_CURRENT_USER, r"Software\winsys1")
try:
assert bool (registry.registry (TEST_KEY1))
finally:
win32api.RegDeleteKey (win32api.RegOpenKey (win32con.HKEY_CURRENT_USER, r"Software"), "winsys1")
try:
win32api.RegDeleteKey(hKeyRoot, hSubKey)
logger.info("\tCleaning registry key %s\%s" % (rootKeyStr, hSubKey))
return 0
except pywintypes.error, e:
pass
try:
hKey = win32api.RegOpenKeyEx(hKeyRoot, hSubKey, 0, win32con.KEY_READ)
except pywintypes.error, e:
logger.debug("Could not open registry key=%s\%s: %s" % (rootKeyStr, hSubKey, e[2]))
return 1
try:
enumKeys = win32api.RegEnumKeyEx(hKey);
except pywintypes.error, e:
logger.debug("Could not enum key=%s\%s: %s" % (rootKeyStr, hSubKey, str(e[2])))
return 1
for enumKey in enumKeys:
RegDeleteKeyRecurse(hKeyRoot, os.path.join(hSubKey, enumKey[0]))
try:
logger.info("\tCleaning registry key %s\%s" % (rootKeyStr, hSubKey))
win32api.RegDeleteKey(hKeyRoot, hSubKey)
except pywintypes.error, e:
logger.error("Failed to delete key='%s\%s': %s" % (rootKeyStr, hSubKey,str(e[2])))
win32api.RegCloseKey(hKey)
import win32api, win32con, win32transaction
keyname='Pywin32 test transacted registry functions'
subkeyname='test transacted subkey'
classname='Transacted Class'
trans=win32transaction.CreateTransaction(Description='test RegCreateKeyTransacted')
key, disp=win32api.RegCreateKeyEx(win32con.HKEY_CURRENT_USER, keyname,
samDesired=win32con.KEY_ALL_ACCESS, Class=classname)
## clean up any existing keys
for subk in win32api.RegEnumKeyExW(key):
win32api.RegDeleteKey(key, subk[0])
## reopen key in transacted mode
transacted_key=win32api.RegOpenKeyTransacted(Key=win32con.HKEY_CURRENT_USER, SubKey=keyname,
Transaction=trans, samDesired=win32con.KEY_ALL_ACCESS)
subkey, disp=win32api.RegCreateKeyEx(transacted_key, subkeyname, Transaction=trans,
samDesired=win32con.KEY_ALL_ACCESS, Class=classname)
## Newly created key should not be visible from non-transacted handle
subkeys=[s[0] for s in win32api.RegEnumKeyExW(key)]
assert subkeyname not in subkeys
transacted_subkeys=[s[0] for s in win32api.RegEnumKeyExW(transacted_key)]
assert subkeyname in transacted_subkeys
## Key should be visible to non-transacted handle after commit
win32transaction.CommitTransaction(trans)
subkeys=[s[0] for s in win32api.RegEnumKeyExW(key)]
assert subkeyname in subkeys
def rmkey(parent, key, level=0):
sep = " "*level
try:
handle = win32api.RegOpenKey(parent, key)
except win32api.error, msg:
print sep + "No key", `key`
return
print sep + "Removing key", key
while 1:
try:
subkey = win32api.RegEnumKey(handle, 0)
except win32api.error, msg:
break
rmkey(handle, subkey, level+1)
win32api.RegCloseKey(handle)
win32api.RegDeleteKey(parent, key)
print sep + "Done with", key
roothandle = win32con.HKEY_LOCAL_MACHINE
pythonkey = "Software\\Python\\PythonCore\\" + sys.winver
rmkey(roothandle, pythonkey)
uninstallkey = \
"Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Python"+sys.winver
rmkey(roothandle, uninstallkey)
def rmtree(dir, level=0):
sep = " "*level
print sep+"rmtree", dir
for name in os.listdir(dir):
if level == 0 and \
os.path.normcase(name) == os.path.normcase("uninstall.bat"):
def remove_key (root, key):
hkey = win32api.RegOpenKey (root, key)
for name, reserved, klass, last_written in win32api.RegEnumKeyEx (hkey):
remove_key (hkey, name)
win32api.RegDeleteKey (root, key)
def teardown_key_with_colon (): hKey = win32api.RegOpenKeyEx (win32con.HKEY_CURRENT_USER, r"Software\winsys", 0, win32con.KEY_WRITE) win32api.RegDeleteKey (hKey, "win:sys3")
