def read_registry(self):
"""Extract resolver configuration from the Windows registry."""
lm = _winreg.ConnectRegistry(None, _winreg.HKEY_LOCAL_MACHINE)
want_scan = False
try:
try:
# XP, 2000
tcp_params = _winreg.OpenKey(lm,
r'SYSTEM\CurrentControlSet'
r'\Services\Tcpip\Parameters')
want_scan = True
except EnvironmentError:
# ME
tcp_params = _winreg.OpenKey(lm,
r'SYSTEM\CurrentControlSet'
r'\Services\VxD\MSTCP')
try:
self._config_win32_fromkey(tcp_params, True)
finally:
tcp_params.Close()
if want_scan:
interfaces = _winreg.OpenKey(lm,
r'SYSTEM\CurrentControlSet'
r'\Services\Tcpip\Parameters'
r'\Interfaces')
try:
i = 0
while True:
try:
guid = _winreg.EnumKey(interfaces, i)
i += 1
key = _winreg.OpenKey(interfaces, guid)
if not self._win32_is_nic_enabled(lm, guid, key):
continue
try:
self._config_win32_fromkey(key, False)
finally:
key.Close()
except EnvironmentError:
break
finally:
interfaces.Close()
finally:
lm.Close()
def get_nameserver_candidates():
"""
Returns a list of IP addresses which potentially an active DNS server used by the current machine.
Please be aware that it's not at all precise!
"""
keynames = ['NameServer', 'DhcpNameServer']
def get_ips(iface, keyname):
try:
result = {}
res, _ = winreg.QueryValueEx(iface, keyname)
if len(res) > 0:
if res.find(',') != -1:
for x in res.split(','):
result[x] = 0
else:
result[res] = 0
except Exception as e:
pass #print(e)
finally:
return list(result.keys())
ips = {}
hklm = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
key = 'System\CurrentControlSet\Services\Tcpip\Parameters\Interfaces'
aKey = winreg.OpenKey(hklm, key)
for i in range(1024):
try:
asubkey_name = winreg.EnumKey(aKey, i)
iface = winreg.OpenKey(aKey, asubkey_name)
for keyname in keynames:
for res in get_ips(iface, keyname):
ips[res] = 0
except OSError as e:
if e.args[0] == 22:
break
elif e.args[0] == 259:
continue
else:
raise
except Exception as e:
print(e)
return list(ips.keys())
def findkey(sub_key, reg_list, compilestr):
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
sub_key,
reserved=0,
access=winreg.KEY_READ)
if findReg(key, compilestr):
reg_list.append(
re.compile(r'^(.*?\\.*?\\.*?\\)([^\\]*)').search(sub_key).group(2))
else:
try:
index = 0
parentPath = sub_key
while True:
sub_key = parentPath + '\\' + winreg.EnumKey(key, index)
findkey(sub_key, reg_list, compilestr)
index += 1
except WindowsError:
pass
def getKeyRegBrowsers(base_key, sub_key): """sub_key is one of the main keys in the registry, or defined constants in _winreg module sub_key is the sub key in the registry under which executable labels is found this function will return a list of tuples, consisting of the browser label if present and its path.""" foundBrowsers=[] try: key= _winreg.OpenKey(base_key, sub_key) i=0 while True: foundKey= _winreg.EnumKey(key, i) if foundKey.lower() in exeLabels: key2= _winreg.OpenKey(base_key, os.path.join(sub_key, foundKey)) #_winreg.EnumValue(key2, 0) returns a tuple of three elements, path is the second. foundBrowsers.append((exeLabels[foundKey.lower()], _winreg.EnumValue(key2, 0)[1])) i+=1 except WindowsError: pass return foundBrowsers
def getKey(self, path):
nbNodes, _, _ = winreg.QueryInfoKey(self._node)
for indice in range(nbNodes):
try:
node_path = winreg.EnumKey(self._node, indice)
if node_path == path:
if self._path:
new_path = self._path + '\\' + node_path
else:
new_path = self._path + node_path
return Registre(
hkey=self._hkey,
path=new_path,
)
except Exception as e:
print('{}\\{} : {!r}'.format(self.path, node_path, e))
def CurrentUserApps(hive, flag):
aReg = winreg.ConnectRegistry(None, hive)
aKey = winreg.OpenKey(
aReg, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall", 0,
winreg.KEY_READ | flag)
winapp = []
count_subkey = winreg.QueryInfoKey(aKey)[0]
for i in range(count_subkey):
try:
asubkey_name = winreg.EnumKey(aKey, i)
asubkey = winreg.OpenKey(aKey, asubkey_name)
val = winreg.QueryValueEx(asubkey, "DisplayName")[0]
winapp.append(val)
except EnvironmentError:
continue
return winapp
def load(self, recursive=False):
try:
rootkey = winreg.OpenKey(self._keytype, self._keypath, 0,
winreg.KEY_READ)
except OSError: # key doesn't exist
return
values = winreg.QueryInfoKey(rootkey)[1]
for num in range(0, values):
name, data, datatype = winreg.EnumValue(rootkey, num)
try:
SettingsBase.__setattr__(self, name, ast.literal_eval(data))
except (ValueError, SyntaxError):
raise SettingsError("Error")
if recursive:
keys, vals, mod = winreg.QueryInfoKey(rootkey)
for i in range(0, keys):
name = winreg.EnumKey(rootkey, i)
s = Settings(parent=self, name=name, recursive=True)
def get_matching_sessions(except_session, session_pattern):
"""
Returns sessions matching pattern
"""
reg_key = get_sessions_reg_key()
num_keys, _, _ = winreg.QueryInfoKey(reg_key)
patterns = csv_to_pattern_list(session_pattern)
sessions = [winreg.EnumKey(reg_key, i) for i in range(num_keys)]
is_matched_session = lambda s: s != except_session and string_matches(s, patterns)
sessions = list(filter(is_matched_session, sessions))
if len(sessions)==0:
raise SessionNotFoundError('No sessions matching given pattern: "%s"' %
(session_pattern))
return sessions
def _get_extra_sids(self):
sids = set()
k1 = winreg.HKEY_USERS
i = 0
while 1:
try:
sid = winreg.EnumKey(k1, i)
if '_Classes' not in sid and sid != '.DEFAULT':
sids.add(sid)
i += 1
except WindowsError:
break
return sids
def printNets():
subKey = 'SOFTWARE\Microsoft\Windows NT\CurrentVersion\\NetworkList\Signatures\\Unmanaged'
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, subKey)
print('\n[*] Networks you have joined')
count, _, _ = winreg.QueryInfoKey(key)
for n in range(count):
guid = winreg.EnumKey(key, n)
netKey = winreg.OpenKey(key, str(guid))
deviceName, _ = winreg.QueryValueEx(netKey, 'Description')
mac, _ = winreg.QueryValueEx(netKey, 'DefaultGatewayMac')
if mac:
mac = ':'.join(['%02x' % ch for ch in mac])
else:
mac = ':'.join(['--' for _ in range(6)])
print('{:<20}\t{}'.format(mac, deviceName))
def load(self):
# load scope definitions
try:
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
'SOFTWARE\OscCap\Scopes')
except WindowsError:
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
'SOFTWARE\OscCap\Scopes')
index = 0
try:
while True:
name = winreg.EnumKey(key, index)
try:
entry = winreg.OpenKey(key, name)
scope_host = winreg.QueryValueEx(entry, 'host')[0]
self.scopes.append(OscProperties(name, scope_host))
except WindowsError:
logging.error('Error loading config oscilloscope %s', name)
index += 1
except WindowsError:
pass
winreg.CloseKey(key)
self.scopes.sort(key=lambda e: e.host)
# load common program properties
try:
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, 'SOFTWARE\OscCap')
except WindowsError:
winreg.CreateKeyEx(winreg.HKEY_CURRENT_USER, 'SOFTWARE\OscCap')
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\OscCap')
hk_modifiers = self._try_query_value(key, 'HotKeyModifiers', None)
hk_keycode = self._try_query_value(key, 'HotKeyKeycode', None)
if (hk_modifiers, hk_keycode) != (None, None):
self.hotkey = HotKey(hk_modifiers, hk_keycode)
winreg.CloseKey(key)
# load local user properties
with winreg.OpenKey(winreg.HKEY_CURRENT_USER,
'SOFTWARE\OscCap') as key:
self.active_scope_name = self._try_query_value(
key, 'LastActiveName', self.scopes[0].name)
def getInstallPath(self, version=None):
try:
key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,
"SOFTWARE\\Autodesk\\Maya", 0,
_winreg.KEY_READ | _winreg.KEY_WOW64_64KEY)
mayaVersions = []
try:
i = 0
while True:
mayaVers = _winreg.EnumKey(key, i)
if unicode(mayaVers).isnumeric():
mayaVersions.append(mayaVers)
i += 1
except WindowsError:
pass
if version is None:
validVersion = mayaVersions[-1]
elif version in mayaVersions:
validVersion = version
else:
for i in mayaVersions:
if float(i) > float(version):
validVersion = i
break
else:
self.writeLog("No valid Maya found in registry", 0)
return None
key = _winreg.OpenKey(
_winreg.HKEY_LOCAL_MACHINE,
"SOFTWARE\\Autodesk\\Maya\\%s\\Setup\\InstallPath" %
validVersion, 0, _winreg.KEY_READ | _winreg.KEY_WOW64_64KEY)
installDir = (_winreg.QueryValueEx(key,
"MAYA_INSTALL_LOCATION"))[0]
if installDir is None:
return ""
else:
return installDir
except:
return ""
def _get_installed_programs_on_windows_ex2(key, subkey, mode):
"""
Internal implementation of searching programs in registry
:param key:
:param subkey:
:param mode:
:return:
"""
programs = []
try:
conn = winreg.ConnectRegistry(None, key)
reg_key = winreg.OpenKey(conn, subkey, 0, mode)
i = -1
bitness = "x86"
if mode & winreg.KEY_WOW64_64KEY:
bitness = "x64"
while True:
try:
i += 1
subkey_name = winreg.EnumKey(reg_key, i)
subkey = winreg.OpenKey(reg_key, subkey_name)
val, _ = winreg.QueryValueEx(subkey, "DisplayName")
display_version, _ = winreg.QueryValueEx(subkey, "DisplayVersion")
uninstall_string, _ = winreg.QueryValueEx(subkey, "UninstallString")
install_location, _ = winreg.QueryValueEx(subkey, "InstallLocation")
pr = InstalledProductInfo()
pr.name = val
pr.version= display_version
pr.guid = subkey_name
pr.uninstall_string = uninstall_string
pr.bitness = bitness
pr.install_dir = install_location
programs.append(pr)
except WindowsError as e:
if e.winerror == 259:
break
continue
except Exception as ex:
pass
return programs
def _get_pg_config_from_registry(self):
try:
import winreg
except ImportError:
import _winreg as winreg
reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
try:
pg_inst_list_key = winreg.OpenKey(
reg, 'SOFTWARE\\PostgreSQL\\Installations')
except EnvironmentError:
# No PostgreSQL installation, as best as we can tell.
return None
try:
# Determine the name of the first subkey, if any:
try:
first_sub_key_name = winreg.EnumKey(pg_inst_list_key, 0)
except EnvironmentError:
return None
pg_first_inst_key = winreg.OpenKey(
reg,
'SOFTWARE\\PostgreSQL\\Installations\\' + first_sub_key_name)
try:
pg_inst_base_dir = winreg.QueryValueEx(pg_first_inst_key,
'Base Directory')[0]
finally:
winreg.CloseKey(pg_first_inst_key)
finally:
winreg.CloseKey(pg_inst_list_key)
pg_config_path = os.path.join(pg_inst_base_dir, 'bin', 'pg_config.exe')
if not os.path.exists(pg_config_path):
return None
# Support unicode paths, if this version of Python provides the
# necessary infrastructure:
if sys.version_info[0] < 3 \
and hasattr(sys, 'getfilesystemencoding'):
pg_config_path = pg_config_path.encode(sys.getfilesystemencoding())
return pg_config_path
def software_inventory(self):
# -----------------------DRIVERS-----------------------
search_class = "Win32_PnPSignedDriver"
props = ["DeviceName", "Manufacturer", "DriverVersion"]
drivers = self.get_values(search_class, props)
# -----------------------PROGRAMS-----------------------
import winreg as wr
key_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"
target = "\\\\{}".format(self.hostname)
rem_reg = wr.ConnectRegistry(None, wr.HKEY_LOCAL_MACHINE)
rem_key = wr.OpenKey(rem_reg, key_path, 0,
wr.KEY_READ | wr.KEY_WOW64_64KEY)
subkeys = []
index = 0
programs = []
# creating subkeys
while True:
try:
subkey = wr.EnumKey(rem_key, index)
subkeys.append(subkey)
index += 1
except EnvironmentError:
break
for sk in subkeys:
programs.append({})
path = key_path + "\\" + sk
key = wr.OpenKey(rem_reg, path, 0,
wr.KEY_READ | wr.KEY_WOW64_64KEY)
try:
programs[-1]['DisplayName'] = str(
wr.QueryValueEx(key, 'DisplayName')[0])
programs[-1]['UninstallString'] = str(
wr.QueryValueEx(key, 'UninstallString')[0])
except:
programs.pop()
return {
"drivers": drivers,
"programs": programs,
}
def __init__(self):
if self.info is not None:
return
info = []
try:
# XXX: Bad style to use so long `try:...except:...`. Fix it!
if sys.version_info[0] >= 3:
import winreg
else:
import _winreg as winreg
prgx = re.compile(
r"family\s+(?P<FML>\d+)\s+model\s+(?P<MDL>\d+)"
r"\s+stepping\s+(?P<STP>\d+)", re.IGNORECASE)
chnd = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, self.pkey)
pnum = 0
while True:
try:
proc = winreg.EnumKey(chnd, pnum)
except winreg.error:
break
else:
pnum += 1
info.append({"Processor": proc})
phnd = winreg.OpenKey(chnd, proc)
pidx = 0
while True:
try:
name, value, vtpe = winreg.EnumValue(phnd, pidx)
except winreg.error:
break
else:
pidx = pidx + 1
info[-1][name] = value
if name == "Identifier":
srch = prgx.search(value)
if srch:
info[-1]["Family"] = int(srch.group("FML"))
info[-1]["Model"] = int(srch.group("MDL"))
info[-1]["Stepping"] = int(
srch.group("STP"))
except:
print(sys.exc_info()[1], '(ignoring)')
self.__class__.info = info
def tryLookupKey(path, hkey):
global read_value, unread_key, read_key, current_registry
read_key = read_key + 1
try:
hkeyInfo = winreg.QueryInfoKey(hkey)
current_registry[path] = (hash1Str(''), hkeyInfo[2], 0)
# read value in key
for i in range(hkeyInfo[1]):
n, v, t = winreg.EnumValue(hkey, i)
name = path + '->' + n
# hash n+t+v as string
strv = n + str(t) + str(v)
ret = hash1Str(strv)
if ret != ERROR_CODE:
current_registry[name] = (ret, hkeyInfo[2])
read_value = read_value + 1
# lookup sub key
for i in range(hkeyInfo[0]):
subKeyName = winreg.EnumKey(hkey, i)
try:
subKey = winreg.OpenKey(hkey,
subKeyName,
access=winreg.KEY_READ
| winreg.KEY_WOW64_32KEY)
except Exception as e:
print(e, "123a")
try:
subKey = winreg.OpenKey(hkey,
subKeyName,
access=winreg.KEY_READ
| winreg.KEY_WOW64_64KEY)
except Exception as e:
print(e, "123b")
unread_key = unread_key + 1
continue
tryLookupKey(path + '\\' + subKeyName, subKey)
return SUCCESS_CODE
except EnvironmentError as e:
print(e, "123c")
return ERROR_CODE
def installed_rvt_detection():
"""
Finds install path of rvt versions in win registry
:return:dict: found install paths
"""
install_location = "InstallLocation"
rvt_reg_keys = {}
rvt_install_paths = {}
index = 0
reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
soft_uninstall = "Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall"
python32bit = "32 bit" in sys.version
python64bit = "64 bit" in sys.version
if python64bit:
install_keys = winreg.OpenKey(reg, soft_uninstall)
elif python32bit:
install_keys = winreg.OpenKey(reg, soft_uninstall, 0, winreg.KEY_READ | winreg.KEY_WOW64_64KEY)
while True:
try:
adsk_pattern = r"Autodesk Revit ?(\S* )?\d{4}$"
current_key = winreg.EnumKey(install_keys, index)
if re.match(adsk_pattern, current_key):
rvt_reg_keys[current_key] = index
# print([current_key, index])
except OSError:
break
index += 1
for rk in rvt_reg_keys.keys():
version_pattern = r"\d{4}"
rvt_install_version = re.search(version_pattern, rk)[0]
reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
if python64bit:
rvt_reg = winreg.OpenKey(reg, soft_uninstall + "\\" + rk)
elif python32bit:
rvt_reg = winreg.OpenKey(reg, soft_uninstall + "\\" + rk, 0, winreg.KEY_READ | winreg.KEY_WOW64_64KEY)
# print([rk, rvt_reg, install_location])
exe_location = winreg.QueryValueEx(rvt_reg, install_location)[0] + "Revit.exe"
rvt_install_paths[rvt_install_version] = exe_location
return rvt_install_paths
def del_games(self):
i = 0
_gamelist = []
while True:
try:
d = winreg.EnumKey(self.pathGameKey, i)
_gamelist.append(d)
i += 1
except:
logging.error('del_games First step Done!')
break
for game in _gamelist:
logging.info(game)
_delkey = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
self.pathGameReg)
winreg.DeleteKey(_delkey, game)
i += 1
logging.info("游戏注册表删除完成！")
def get_windows_software():
"""
从注册表获取Windows系统安装的软件列表
:return:
"""
import winreg
# 需要遍历的两个注册表
sub_keys = [
r'SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall',
r'SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall',
]
software_list = {}
# 连接注册表根键
regRoot = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
for sub_key in sub_keys:
keyHandle = winreg.OpenKey(regRoot, sub_key, 0, winreg.KEY_ALL_ACCESS)
# 获取该目录下所有键的个数(0-下属键个数;1-当前键值个数)
for i in range(winreg.QueryInfoKey(keyHandle)[0]):
try:
# 穷举每个键，获取键名
key_name = winreg.EnumKey(keyHandle, i)
key_path = f"{sub_key}\\{key_name}"
# 根据获取的键名拼接之前的路径作为参数，获取当前键下所属键的控制
each_key = winreg.OpenKey(regRoot, key_path, 0, winreg.KEY_ALL_ACCESS)
if winreg.QueryInfoKey(each_key)[1] > 1:
# 穷举每个键，获取键名、键值以及数据类型
# name, value, type = winreg.EnumValue(each_key, j)
# print(name,value,type)
DisplayName, REG_SZ = winreg.QueryValueEx(each_key, 'DisplayName')
DisplayVersion, REG_SZ = winreg.QueryValueEx(each_key, 'DisplayVersion')
software_list[DisplayName] = DisplayVersion
except WindowsError as e:
pass
finally:
winreg.CloseKey(each_key)
winreg.CloseKey(keyHandle)
winreg.CloseKey(regRoot)
return software_list
def get_local_mac():
net = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\NetworkList\Signatures\Unmanaged'
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, net)
mac_addr = {}
for i in range(50):
try:
guid = winreg.EnumKey(key, i)
netKey = winreg.OpenKey(key, str(guid))
(n, addr, t) = winreg.EnumValue(netKey, 5)
(n, name, t) = winreg.EnumValue(netKey, 4)
macAddr = val2addr(str(addr))
netName = str(name)
print('[+] ' + netName + ' ' + macAddr)
mac_addr[netName] = macAddr
winreg.CloseKey(netKey)
except:
continue
return mac_addr
def find_registry_name2(key, sub_key, name, items):
ret = None
try:
handle = winreg.OpenKey(key, sub_key)
except:
return
currentdir_reg = list()
try: # find all attr name
jj = 0
while (True):
attr_name = winreg.EnumValue(handle, jj)
jj += 1
currentdir_reg.append(attr_name[0])
except:
pass
if name in currentdir_reg:
print("find :", sub_key)
items.append(sub_key)
handle.Close()
pass # find duplicated item
# return sub_key
else:
jj = 0
subdir_list = list()
try: # search sub directory
while (True):
subdir_name = winreg.EnumKey(handle, jj)
jj += 1
subdir_list.append(subdir_name)
except:
pass
for subdir in subdir_list: # ennter sub directory recursively
ret = find_registry_name2(key, os.path.join(sub_key, subdir), name,
items)
if ret is not None:
break
handle.Close()
return ret
def DFS_HIVE_SEARCH(self, REG, HIVE, PATH):
# In case of No permission, pass
try:
hKey = REG.openHReg(HIVE, PATH)
except Exception as e:
# print("[-] no Permission!")
return
# List of keys that belongs to HIVE/PATH
keyList = []
i = 0
while True:
try:
keyList.append(winreg.EnumKey(hKey, i))
except:
break
i += 1
i = 0
while True:
try:
attribute = winreg.EnumValue(hKey, i)
if attribute[0]:
value = attribute[1]
if type(attribute[1]) == bytes:
value = value.hex()
inputString = "{0}\\{1}\\{2}".format(
REGO_reg.hiveIntToStr(HIVE), PATH, attribute[0])
# Get the value of all attribute
# HIVE/PATH/Attribute: VALUE
self.dumpDict[inputString] = value
except Exception as e:
break
i += 1
REG.closeHReg(hKey)
# Recursive Search all keys underneath
for _ in keyList:
newPath = PATH
if PATH != "":
newPath += "\\"
newPath += _
self.DFS_HIVE_SEARCH(REG, HIVE, newPath)
def get_file_types():
keys = {}
length = winreg.QueryInfoKey(winreg.HKEY_CLASSES_ROOT)[0]
for i in range(0, length):
subkey = winreg.EnumKey(winreg.HKEY_CLASSES_ROOT, i)
if subkey.startswith("."):
theclass = winreg.CreateKey(winreg.HKEY_CLASSES_ROOT, subkey)
keys[subkey] = {}
try:
keys[subkey]["content-type"] = winreg.QueryValueEx(
theclass, "Content Type")[0]
except Exception as e:
pass
try:
keys[subkey]["perceived-type"] = winreg.QueryValueEx(
theclass, "PerceivedType")[0]
except Exception as e:
pass
return keys
def _get_install_path():
import sys
if sys.version_info > (3, 0):
import winreg
else:
import _winreg as winreg
with winreg.OpenKey(
winreg.HKEY_LOCAL_MACHINE,
'SOFTWARE\\Wow6432Node\\National Instruments\\VeriStand\\'
) as vskey:
r = winreg.QueryInfoKey(vskey)
ver = '0'
for k in range(r[0]):
with winreg.OpenKey(vskey, winreg.EnumKey(vskey, k)) as this_key:
this_ver = winreg.QueryValueEx(this_key, 'Version')[0]
if this_ver > ver:
latest_dir = winreg.QueryValueEx(this_key, 'InstallDir')[0]
ver = this_ver
return latest_dir if latest_dir is not None else ''
def get_first_attached_date(device_class_guid, instance_id):
"""
Get the first time a USB drive was attached to the system.
@param device_class_guid: The device guid.
@param instance_id: Device serial number or instance id.
"""
path = "SYSTEM\\CurrentControlSet\\Control\\DeviceClasses\\{0}".format(device_class_guid)
with reg.OpenKeyEx(reg.HKEY_LOCAL_MACHINE, path) as key:
# Iterate over the registry keys.
for key_inx in range(reg.QueryInfoKey(key)[0]):
key_name = reg.EnumKey(key, key_inx)
if (device_class_guid in key_name) and (instance_id in key_name):
# Open the device registry key.
with reg.OpenKeyEx(key, key_name) as device_key:
# Store last accessed time.
windows_time = reg.QueryInfoKey(device_key)[2]
return utils.get_time(windows_time)
def findPV():
'Find Paraview executable in the system. Under Windows (64bit only), this entails searching the registry (see `this post <http://www.paraview.org/pipermail/paraview/2010-August/018645.html>`__); under Linux, look in ``$PATH44 for executable called ``paraview``. Returns ``None`` is Paraview is not found.'
import sys,operator
if sys.platform=='win32':
# oh gee...
# http://www.paraview.org/pipermail/paraview/2010-August/018645.html
# - HKEY_CURRENT_USER\SOFTWARE\Wow6432Node\Kitware Inc.\ParaView 3.8.X (64bit machines single user install)
# - HKEY_CURRENT_USER\SOFTWARE\Kitware Inc.\ParaView 3.8.X (32bit machines single user install)
# - HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Kitware Inc.\ParaView 3.8.X (64bit machines all users)
# - HKEY_LOCAL_MACHINE\SOFTWARE\Kitware Inc.\ParaView 3.8.X (32bit machines all users)
#
# we don't care about 32 bit, do just 64bit
import winreg as winreg
path=r'SOFTWARE\Wow6432Node\Kitware Inc.'
paraviews=[]
for reg in (winreg.HKEY_CURRENT_USER,winreg.HKEY_LOCAL_MACHINE):
aReg=winreg.ConnectRegistry(None,reg)
try:
aKey=winreg.OpenKey(aReg,r'SOFTWARE\Wow6432Node\Kitware, Inc.')
except WindowsError: continue
for i in range(0,winreg.QueryInfoKey(aKey)[0]):
keyname=winreg.EnumKey(aKey,i)
if not keyname.startswith('ParaView '):
# print 'no match:',keyname
continue
subKey=winreg.OpenKey(aKey,keyname)
paraviews.append((keyname,subKey))
# sort lexically using key name and use the last one (highest version)
pv=sorted(paraviews,key=operator.itemgetter(1))
if not pv: return None # raise RuntimeError('ParaView installation not found in registry.')
pvName,pvKey=pv[-1]
pvExec=''
for i in range(0,winreg.QueryInfoKey(pvKey)[1]):
key,val,T=winreg.EnumValue(pvKey,i)
if key=='':
pvExec=val+'/bin/paraview'
break
if not pvExec: return None # raise RuntimeError('ParaView installation: found in registry, but default key is missing...?')
return pvExec
else:
# on Linux, find it in $PATH
import woo.utils
return woo.utils.find_executable('paraview')
def reg_find_value(key, value, root=winreg.HKEY_LOCAL_MACHINE):
"""
遞迴搜尋機碼下的值, 回傳一組 tuple (所在位置, 數值)
字串資料採用局部比對, 其餘型態採用完整比對
"""
i = 0
handle = winreg.OpenKey(root, key)
vtype = type(value)
while True:
try:
values = reg_list_value(key)
for vname in values:
# 除錯用
# if key == r'SOFTWARE\Classes\TypeLib\{75AAD71C-8F4F-4F1F-9AEE-3D41A8C9BA5E}\1.0\0\win32':
# print(vname, values[vname], value)
# 型態不同忽略
if not isinstance(values[vname], vtype):
continue
leaf_node = key + ':' + vname
if isinstance(value, str):
# 字串採用局部比對, 不分大小寫
if value.lower() in values[vname].lower():
return (leaf_node, values[vname])
else:
# 其餘型態採用完整比對
if value == values[vname]:
return (leaf_node, values[vname])
subkey = key + '\\' + winreg.EnumKey(handle, i)
result = reg_find_value(subkey, value)
if result[0] != '':
return result
i += 1
except OSError:
# winreg.EnumKey(handle, i) 的 i 超出範圍
break
winreg.CloseKey(handle)
return ('', '')
def getVersionedInstallationsFromRrgistry(self):
versions = []
registered_services = winreg.OpenKey(winreg.HKEY_CLASSES_ROOT, None)
key_prefix = "{}.".format(self._default_app_name)
i = 0
while True:
try:
key = winreg.EnumKey(registered_services, i)
if key.startswith(key_prefix):
try:
major_version = key[len(key_prefix):]
major_version = int(major_version)
versions.append(major_version)
except ValueError:
pass
i += 1
except WindowsError:
break
return versions
def get_programUninstallsByFlag(sName, flag):
info = []
aReg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
aKey = winreg.OpenKey(aReg, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall", 0, winreg.KEY_READ | flag)
count_subkey = winreg.QueryInfoKey(aKey)[0]
for i in range(count_subkey):
try:
asubkey_name = winreg.EnumKey(aKey, i)
asubkey = winreg.OpenKey(aKey, asubkey_name)
progName = winreg.QueryValueEx(asubkey, 'DisplayName')[0]
if (progName.find(sName) != -1):
info.append(winreg.QueryValueEx(asubkey, 'UninstallString')[0])
except:
pass
return info
