def get_autoruns():
# 1. 连接注册表根键
root1 = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
root2 = winreg.ConnectRegistry(None, winreg.HKEY_CURRENT_USER)
result = {}
try:
# 2. 指定想要访问的子健
reg_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Run"
# 3. 打开相应子健
key1 = winreg.OpenKey(root1, reg_path) # 打开localmachine的autorun列表
key2 = winreg.OpenKey(root2, reg_path) # 打开currentuser的autorun列表
try:
count = 0
while 1:
try:
# 4. 通过winreg对象的EnumValue()方法迭代其中的键值
n, v, t = winreg.EnumValue(key1, count)
result[n] = v
count += 1
except EnvironmentError:
break
count = 0
while (1):
try:
n, v, t = winreg.EnumValue(key2, count)
result[n] = v
count += 1
except EnvironmentError:
break
finally:
# 5. 关闭相应子健
winreg.CloseKey(key1)
winreg.CloseKey(key2)
finally:
# 6. 关闭相应根键连接
winreg.CloseKey(root1)
winreg.CloseKey(root2)
return json.dumps(result)
def get_valid_ue4_paths():
ue4_paths = []
build_key_name = r"Software\Epic Games\Unreal Engine\Builds"
build_key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, build_key_name)
i = 0
try:
while True:
_, value, _ = winreg.EnumValue(build_key, i)
version_info = {"RootPath": value, "OfficialBuild": False}
if is_valid_root_dir(value, version_info):
ue4_paths.append(version_info)
i += 1
except WindowsError:
pass
winreg.CloseKey(build_key)
installed_key_name = r"SOFTWARE\EpicGames\Unreal Engine"
installed_key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
installed_key_name)
i = 0
try:
while True:
version_name = winreg.EnumKey(installed_key, i)
version_key_name = r"%s\%s" % (installed_key_name, version_name)
version_key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
version_key_name)
_, value, _ = winreg.EnumValue(version_key, 0)
version_info = {
"RootPath": value.replace("\\", "/"),
"OfficialBuild": True
}
if is_valid_root_dir(value, version_info):
ue4_paths.append(version_info)
i += 1
except WindowsError:
pass
winreg.CloseKey(installed_key)
return ue4_paths
def find_jdk(self):
"""Find the JDK under Windows"""
jdk_home = os.environ.get("JDK_HOME")
if jdk_home is not None:
return jdk_home
node = r"SOFTWARE"
# Registry keys changed in Java 9
# https://docs.oracle.com/javase/9/migrate/toc.htm#GUID-EEED398E-AE37-4D12-AB10-49F82F720027
jdk_key_paths = (node + r"\JavaSoft\JDK",
node + r"\JavaSoft\Java Development Kit")
hkey = winreg.HKEY_LOCAL_MACHINE
for key_path in jdk_key_paths:
try:
java_key = winreg.OpenKey(hkey, key_path)
java_key_values = dict([
winreg.EnumValue(java_key, i)[:2]
for i in range(winreg.QueryInfoKey(java_key)[1])
])
version = java_key_values["CurrentVersion"]
version_key = r"{}\{}".format(key_path, version)
version = winreg.OpenKey(hkey, version_key)
version_values = dict([
winreg.EnumValue(version, i)[:2]
for i in range(winreg.QueryInfoKey(version)[1])
])
jdk_home = version_values["JavaHome"]
return jdk_home
except WindowsError as exc:
import errno
if exc.errno != errno.ENOENT:
raise exc
else:
raise RuntimeError(
"Failed to find the Java Development Kit. "
"Please download and install the Oracle JDK 1.7 or later")
def reg5():
access_reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
regkey = winreg.OpenKey(
access_reg,
r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\SoftwareProtectionPlatform"
)
for n in range(20):
try:
x = winreg.EnumValue(regkey, n)
print(x)
except:
break
def _discover_windows(self):
import winreg as winreg
path = r'HARDWARE\DEVICEMAP\SERIALCOMM'
try:
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)
except WindowsError:
return
for i in itertools.count():
try:
val = winreg.EnumValue(key, i)
yield str(val[1])
except EnvironmentError:
break
def read_value(winreg_hkey, location):
key = winreg.OpenKey(getattr(winreg, winreg_hkey), location)
values = []
i = 0
while True:
try:
# 获取注册表对应位置的键和值
values.append(winreg.EnumValue(key, i))
i += 1
except Exception:
# 一定要关闭这个键
winreg.CloseKey(key)
break
return values
def emptyUserEnvReg():
""".. danger:: 清空当前用户的环境变量注册表项!
使用了全局变量 ``gUSER_ENV_REG_KEY``
"""
with winreg.OpenKeyEx(*gUSER_ENV_REG_KEY, 0, winreg.KEY_SET_VALUE) as key:
_ = 0
while True:
try:
name, value, type_ = winreg.EnumValue(key, _)
winreg.DeleteValue(key, "")
_ += 1
except OSError:
break
def readReg(self):
"""
读取注册表项目
"""
with winreg.OpenKeyEx(self.key, self.name, 0, winreg.KEY_READ) as key:
_ = 0
while True:
try:
reg_value = RegValue(*winreg.EnumValue(key, _)).wrap()
self.updateValue(reg_value)
# EnumValue 返回 元组 (reg_name, reg_value, reg_type)
_ += 1
except OSError:
break
def GetRegValues(_regKey):
reg_value_list = []
loop = 0
while True:
try:
(regValue, regData, regType) = winreg.EnumValue(_regKey, loop)
reg_value = {"value_name": regValue, "value_data": regData}
reg_value_list.append(reg_value)
except Exception as e:
break
loop += 1
return reg_value_list
def check_reg(self):
try:
reg_hkey = winreg.HKEY_CURRENT_USER
key = winreg.OpenKey(reg_hkey, r'Software\Microsoft\Windows\CurrentVersion\Run', 0, winreg.KEY_READ)
index = 0
while True:
v = winreg.EnumValue(key, index)
if 'Keylogger' not in v: # And this to what you have changed above
index += 1
continue
return True
except:
winreg.CloseKey(key)
self.add_reg()
def GetValues(handle, regex):
index = 0
values = {}
while True:
try:
value = wreg.EnumValue(handle, index)
name = value[0]
if regex.search(name):
assert( name not in list(values.keys()) )
values[name] = value[1]
except:
break
index += 1
return values
def get_device(enum_key):
number_of_values = winreg.QueryInfoKey(enum_key)[1]
for i in range(number_of_values):
value_name, value_data, _ = winreg.EnumValue(enum_key, i)
if value_name.isdigit(): # device 0, 1, 2...
m = regex.match(value_data)
if m:
id_parts = value_data.split(
'\\'
) # ['USB', 'VID_XXXX&PID_XXXX', 'SERIAL_NUMBER']
vid, board_id = m.groups()
if vid == cls.VENDOR_IDS[Vendor.Segger]:
board_id = board_id.lstrip('0')
yield board_id, UsbId(id_parts[1], id_parts[2])
def _collect(self, fontname=None):
"""Collect the informations of keys
Args:
fontname: If specified, then the target is limited according to it.
"""
keynames = [
(
winreg.HKEY_CURRENT_USER,
r"Software\Microsoft\Windows NT\CurrentVersion\Fonts",
),
(
winreg.HKEY_CURRENT_USER,
r"Software\Microsoft\Windows\CurrentVersion\Fonts",
),
(
winreg.HKEY_LOCAL_MACHINE,
r"Software\Microsoft\Windows NT\CurrentVersion\Fonts",
),
(
winreg.HKEY_LOCAL_MACHINE,
r"Software\Microsoft\Windows\CurrentVersion\Fonts",
),
]
ttf_files = []
ttf_values = []
ttc_files = []
ttc_values = []
for keyname in keynames:
try:
key = winreg.OpenKey(*keyname)
except FileNotFoundError:
continue
_, n_value, _ = winreg.QueryInfoKey(key)
for v_index in range(n_value):
value_name, file_name, _ = winreg.EnumValue(key, v_index)
if fontname:
if value_name.find(fontname) == -1:
continue
file_type = Path(file_name).suffix.lower()
if file_type == ".ttf":
ttf_files.append(file_name)
ttf_values.append(value_name)
elif file_type == ".ttc":
ttc_files.append(file_name)
ttc_values.append(value_name)
else:
continue
winreg.CloseKey(key)
return ttf_files, ttf_values, ttc_files, ttc_values
def _win32RegistryFonts(reg_domain, base_dir):
r"""
Search for fonts in the Windows registry.
Parameters
----------
reg_domain : int
The top level registry domain (e.g. HKEY_LOCAL_MACHINE).
base_dir : str
The path to the folder where the font files are usually located (e.g.
C:\Windows\Fonts). If only the filename of the font is stored in the
registry, the absolute path is built relative to this base directory.
Returns
-------
`set`
`pathlib.Path` objects with the absolute path to the font files found.
"""
import winreg
items = set()
for reg_path in MSFontDirectories:
try:
with winreg.OpenKey(reg_domain, reg_path) as local:
for j in range(winreg.QueryInfoKey(local)[1]):
# value may contain the filename of the font or its
# absolute path.
key, value, tp = winreg.EnumValue(local, j)
if not isinstance(value, str):
continue
# Work around for https://bugs.python.org/issue25778, which
# is fixed in Py>=3.6.1.
value = value.split("\0", 1)[0]
try:
# If value contains already an absolute path, then it
# is not changed further.
path = Path(base_dir, value).resolve()
except RuntimeError:
# Don't fail with invalid entries.
continue
items.add(path)
except (OSError, MemoryError):
continue
return items
def regsetval(src,valname,val):
try:
if src[1] != '':
Key = winreg.OpenKey(src[0], src[1] + '\\' + src[2], 0, winreg.KEY_ALL_ACCESS)
else:
Key = winreg.OpenKey(src[0], src[2], 0, winreg.KEY_ALL_ACCESS)
print(Key)
size = winreg.QueryInfoKey(Key)[1]
for i in range(size):
valoare = winreg.EnumValue(Key, i)
if valoare[0] == valname:
winreg.SetValueEx(Key,valname,0,winreg.REG_SZ,val)
except Exception as e:
print("Could not set the Value of the key")
def registry_check(registry_key_loc, G14dir):
G14exe = "G14Control.exe"
G14dir = str(G14dir)
G14fileloc = os.path.join(G14dir, G14exe)
G14Key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, registry_key_loc)
try:
i = 0
while 1:
name, value, enumtype = winreg.EnumValue(G14Key, i)
if name == "G14Control" and value == G14fileloc:
return True
i += 1
except WindowsError:
return False
def registerBatFile(ext, bat, name):
import winreg as wr
ext_key = wr.CreateKey(wr.HKEY_CLASSES_ROOT, '.' + ext)
try:
auto_file = wr.EnumValue(ext_key, 0)[1]
except:
auto_file = ext + '_auto_file'
wr.SetValue(ext_key, '', wr.REG_SZ, auto_file)
key = wr.CreateKey(wr.HKEY_CLASSES_ROOT, auto_file)
key = wr.CreateKey(key, 'shell')
key = wr.CreateKey(key, name)
key = wr.CreateKey(key, 'command')
wr.SetValue(key, '', wr.REG_SZ, '"' + bat + '" "%1"')
def init_ui(self):
QLabel("Select an installation directory:", self).move(25, 25)
self.directory = QLineEdit(self)
self.directory.move(25, 55)
self.directory.resize(600, 30)
self.directory.setText("C:/Program Files/Age of the Ring")
self.pick_directory_btn = QPushButton("...", self)
self.pick_directory_btn.resize(25, 25)
self.pick_directory_btn.move(635, 60)
self.pick_directory_btn.clicked.connect(self.pick_directory)
self.install_btn = QPushButton("Install", self)
self.install_btn.resize(250, 100)
self.install_btn.move(225, 100)
self.install_btn.clicked.connect(self.installer)
self.install_btn.setToolTip(
"Select an installation directory to unlock the button")
self.progress_bar = QProgressBar(self)
self.progress_bar.move(50, 150)
self.progress_bar.resize(600, 25)
self.progress_bar.hide()
self.setFixedSize(700, 250)
self.setWindowTitle('Age of the Ring Installer')
self.show()
self.path_rotwk = "GAME NOT FOUND"
try:
# reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
# key = winreg.OpenKey(reg, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\lotrbfme2.exe")
# self.path_bfme2 = winreg.EnumValue(key, 5)[1]
reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
key = winreg.OpenKey(
reg,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\lotrbfme2ep1.exe"
)
self.path_rotwk = winreg.EnumValue(key, 5)[1]
#in case the user has installed a weird version of ROTWK
if os.path.isfile(self.path_rotwk):
self.path_rotwk = os.path.dirname(self.path_rotwk)
except FileNotFoundError:
QMessageBox.critical(
self, "Error",
"Could not detect Rise of the Witch King. The installation will proceed but you may be unable to launch the game.",
QMessageBox.Ok, QMessageBox.Ok)
def detect_serial_path():
try:
path = r'HARDWARE\DEVICEMAP\SERIALCOMM'
with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) as key:
for i in range(winreg.QueryInfoKey(key)[1]):
name, value, value_type = winreg.EnumValue(key, i)
# match both \Device\LGANDNETDIAG1 and \Device\LGVZANDNETDIAG1
name = name.upper()
if name.startswith(r'\DEVICE\LG') and name.endswith(
'ANDNETDIAG1'):
return value
except OSError:
pass
return None
def has_sound(sound):
"""Find out if a particular event is configured with a default sound"""
try:
# Ask the mixer API for the number of devices it knows about.
# When there are no devices, PlaySound will fail.
if ctypes.windll.winmm.mixerGetNumDevs() == 0:
return False
key = winreg.OpenKeyEx(
winreg.HKEY_CURRENT_USER,
"AppEvents\Schemes\Apps\.Default\{0}\.Default".format(sound))
return winreg.EnumValue(key, 0)[1] != ""
except OSError:
return False
def check_registry_entry_for_osu():
import winreg
reg_table = winreg.ConnectRegistry(None, winreg.HKEY_CLASSES_ROOT)
try:
with winreg.OpenKey(reg_table, r'osu\shell\open\command', 0, winreg.KEY_READ) as handle:
_, osu_exe_path, _ = winreg.EnumValue(handle, 0)
osu_exe_path = osu_exe_path.split(" ")[0].strip('"')
osu_path = os.path.split(osu_exe_path)[0]
except:
osu_path = None
return osu_path
def check_reg(self):
try:
reg_hkey = winreg.HKEY_CURRENT_USER
key = winreg.OpenKey(reg_hkey, r'Software\Microsoft\Windows\CurrentVersion\Run', 0, winreg.KEY_READ)
index = 0
while True:
v = winreg.EnumValue(key, index)
if 'revShell_server' not in v:
index+=1
continue
return True
except:
winreg.CloseKey(key)
self.add_reg()
def get_registry_key(key_path):
'''
This function gets registry key values from a given entry
'''
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path)
i = 0
registry_keys = []
while True:
try:
registry_keys.append(winreg.EnumValue(key, i))
i += 1
except:
break
return registry_keys
def enumerate_key(key_hive, key_path, access_type=Wow64RegistryEntry.KEY_WOW64):
"""
:param key_hive: Windows registry hive to edit, e.g. HKEY_CURRENT_USER
:param key_path: Path Windows registry key inside the hive, for example "SOFTWARE\Microsoft\Windows"
:param access_type: Access type for 32/64 bit registry sub-entries in HKLM/SOFTWARE key.
:return: List of registry values
"""
key_hive_value = HIVES_MAP[key_hive]
wow64_flags = WOW64_MAP[access_type]
registry_key = winreg.OpenKey(key_hive_value, key_path, 0, (wow64_flags | winreg.KEY_READ))
result = []
for i in range(0, winreg.QueryInfoKey(registry_key)[1]):
result.append(winreg.EnumValue(registry_key, i)[0])
return result
def enumerate_serial_ports():
path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM'
try:
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)
except WindowsError:
raise Exception
for i in itertools.count():
try:
val = winreg.EnumValue(key, i)
yield (str(val[1])) # , str(val[0]))
except EnvironmentError:
break
def pull_run_mru():
try:
# open the registry
registry = winreg.ConnectRegistry(None, winreg.HKEY_CURRENT_USER)
# open the OpenSavePidlMRU key
key = winreg.OpenKey(registry, lastVisitedMRUpath)
returnStr = "***Run Command History***\n"
# Iterate through all subkeys of OpenSavePidlMRU
for i in range(0, winreg.QueryInfoKey(key)[1]):
returnStr += (winreg.EnumValue(key, i)[1] + '\n')
return returnStr
except Exception as e:
print(e)
def _find_visual_studio_2010_to_2015(vs_version):
"""Adapted from https://github.com/python/cpython/blob/3.5/Lib/distutils/_msvccompiler.py
The ``vs_version`` corresponds to the `Visual Studio` version to lookup.
See :data:`VS_YEAR_TO_VERSION`.
Return Visual Studio installation path found by looking up all key/value pairs
associated with the ``Software\\Microsoft\\VisualStudio\\SxS\\VC7`` registry key.
If no install is found, returns an empty string.
Each key/value pair is the visual studio version (e.g `14.0`) and the installation
path (e.g `C:/Program Files (x86)/Microsoft Visual Studio 14.0/VC/`).
"""
# winreg module
try:
import winreg
except ImportError:
# Support Python 2.7
try:
import _winreg as winreg
except ImportError:
return ""
# get registry key associated with Visual Studio installations
try:
key = winreg.OpenKey(
winreg.HKEY_LOCAL_MACHINE,
r"Software\Microsoft\VisualStudio\SxS\VC7",
0,
winreg.KEY_READ | winreg.KEY_WOW64_32KEY
)
except OSError:
return ""
with key:
for i in count():
try:
v, vc_dir, vt = winreg.EnumValue(key, i)
except OSError:
break
# winreg.REG_SZ means "A null-terminated string"
if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir):
try:
version = int(float(v))
except (ValueError, TypeError):
continue
if version == vs_version:
return vc_dir
return ""
def userAssistParser(limit):
access_registry = winreg.ConnectRegistry(None, winreg.HKEY_CURRENT_USER)
path = r"Software\Microsoft\Windows\CurrentVersion\Explorer\UserAssist"
paths = []
listA = ["Focus Count", "Time Focused", "Last updated", "Name:REG_Binary"]
access_key = winreg.OpenKey(access_registry, path)
for i in range(10): # 100 is just a number that can't be reached
try:
guid = winreg.EnumKey(access_key, i)
#print(guid)
temp = path + "\\" + str(guid) + "\Count"
#paths.append(temp)
#print("============")
subkey = winreg.OpenKey(access_registry, temp)
# now print the value name :
# querry info about the key
info = winreg.QueryInfoKey(subkey)
# (number of subkeys, number of values , last second)
num_values = info[1]
if num_values > 1:
print("========= NEW GUID", i)
print('metadata:\n')
time = datetime(1601, 1,
1) + timedelta(seconds=info[2] / 10**7)
print("\nThe key was last updated", time)
print("Total number of values for this GUID ", num_values)
print("GUID ", guid)
if limit > num_values:
limit = num_values
print("limit", limit)
for j in range(num_values - limit, num_values):
keyname = winreg.EnumValue(subkey, j)[0]
#print("=====START\n\n")
if keyname:
print("\nGUI executable : " + str(j),
codecs.encode(keyname, 'rot_13'))
#print(winreg.EnumValue(subkey,j)[2:])
#print("======END\n\n")
print("\n\n")
except:
pass
def win32InstalledFonts(directory=None, fontext='ttf'):
"""Search for fonts in the specified font directory, or use the
system directories if none given. A list of TrueType fonts are
returned by default with AFM fonts as an option.
"""
if directory is None:
directory = win32FontDirectory()
imported = False
try:
import winreg as wreg
imported = True
except ImportError:
pass
if not imported:
try:
import _winreg as wreg
imported = True
except ImportError:
raise ImportError("Cannot find winreg module")
key, items = None, {}
for fontdir in MSFontDirectories:
try:
local = wreg.OpenKey(wreg.HKEY_LOCAL_MACHINE, fontdir)
except OSError:
continue
if not local:
return glob.glob(os.path.join(directory, '*.'+fontext))
try:
for j in range(wreg.QueryInfoKey(local)[1]):
try:
key, direc, any = wreg.EnumValue( local, j)
if not os.path.dirname(direc):
direc = os.path.join(directory, direc)
direc = os.path.abspath(direc).lower()
if direc[-4:] == '.'+fontext:
items[direc] = 1
except EnvironmentError:
continue
except WindowsError:
continue
return list(items.keys())
finally:
wreg.CloseKey(local)
return None
def get_installed_packages_for_keypath(keypath):
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, keypath, 0,
winreg.KEY_READ)
packages = []
i = 0
while True:
try:
subkey_str = winreg.EnumKey(key, i)
i += 1
subkey = winreg.OpenKey(
winreg.HKEY_LOCAL_MACHINE,
keypath + "\\" + subkey_str, 0,
winreg.KEY_READ | winreg.KEY_WOW64_64KEY)
# print subkey_str
j = 0
package = rpmlist_command.Package()
while True:
try:
subvalue = winreg.EnumValue(subkey, j)
j += 1
_val, _data, _type = subvalue
_data = str(_data).split("\\u0000")[0]
if _val == "DisplayName":
package.displayName = _data
elif _val == "DisplayVersion":
package.displayVersion = _data
elif _val == "EstimatedSize":
package.estimatedSize = _data
elif _val == "InstallDate":
package.installDate = _data
except WindowsError as e:
break
if package.displayName != "Unknown":
packages.append(package)
except WindowsError as e:
break
return packages
