def run(self): required_files = [cell_profiler_setup_path] try: key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, "SOFTWARE\Microsoft\Microsoft SDKs\Windows") best_sdk = _winreg.EnumKey(key, _winreg.QueryInfoKey(key)[0] - 1) sdk_key = _winreg.OpenKey(key, best_sdk) key.Close() signtool = os.path.join( _winreg.QueryValueEx(sdk_key, "InstallationFolder")[0], "Bin", "signtool.exe") sdk_key.Close() assert (os.path.isfile(signtool)) except: raise distutils.errors.DistutilsExecError, \ "The Microsoft Windows SDK does not seem to be properly installed" self.execute(subprocess.check_call, ([ signtool, "sign", "/a", "/du", "http://www.cellprofiler.org/", "/t", "http://timestamp.comodoca.com/authenticode", cell_profiler_setup_path ], ), "Signing %s" % cell_profiler_setup)
def get_keys(self): key_handle = winreg.OpenKey(REG_MAPPING[self._key], self._sub_key) # winreg.QueryInfoKey: # Returns information about a key, as a tuple. # # Index Meaning # 0 An integer giving the number of sub keys this key has. # 1 An integer giving the number of values this key has. # 2 An integer giving when the key was last modified (if available) as 100?s of nanoseconds since Jan 1, 1600. key_count = winreg.QueryInfoKey(self._key_handle)[0] for i in range(0, key_count): # winreg.EnumKey: # Enumerates values of an open registry key, returning a tuple. # # The result is the name of a key key_name = winreg.EnumKey(self._key_handle, i) yield Key(self._key, self._sub_key, key_name)
def getApplications(self): retval = set() key_path = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall" for view_flag in (KEY_WOW64_32KEY, KEY_WOW64_64KEY): rootkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, key_path, 0, view_flag | _winreg.KEY_READ) items = _winreg.QueryInfoKey(rootkey)[0] for idx in range(items): cur_key_path = _winreg.EnumKey(rootkey, idx) cur_key = _winreg.OpenKey(rootkey, cur_key_path, 0, view_flag | _winreg.KEY_READ) try: if self._is_item_update(cur_key): continue display_name = QueryStringValue(cur_key, u'DisplayName') if len(display_name) == 0: continue retval.add(display_name) except: pass return list(retval)
def get_all_exe(): sub_key = [r'SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall', r'SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall'] software_name = [] for i in sub_key: key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, i, 0, _winreg.KEY_ALL_ACCESS) for j in range(0, _winreg.QueryInfoKey(key)[0] - 1): try: key_name = _winreg.EnumKey(key, j) key_path = i + '\\' + key_name each_key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, key_path, 0, _winreg.KEY_ALL_ACCESS) DisplayName, REG_SZ = _winreg.QueryValueEx(each_key, 'DisplayName') DisplayName = DisplayName.encode('utf-8') software_name.append(DisplayName) except WindowsError: pass software_name = sorted(set(software_name)) return software_name
def retrieve_info(self, hkey, name_key): values = {} num = winreg.QueryInfoKey(hkey)[1] for x in range(0, num): k = winreg.EnumValue(hkey, x) if 'password' in k[0].lower(): try: password = win.Win32CryptUnprotectData( k[1][1:], is_current_user=constant.is_current_user, user_dpapi=constant.user_dpapi) values[k[0]] = password.decode('utf16') except Exception as e: self.debug(str(e)) values[k[0]] = 'N/A' else: try: values[k[0]] = str(k[1]).decode('utf16') except Exception: values[k[0]] = str(k[1]) return values
def find_ldxcmd(): if sys.platform.startswith("win"): # Read from SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall # Setting security access mode. KEY_WOW64_64KEY is used for 64-bit TDE sam = _winreg.KEY_READ | _winreg.KEY_WOW64_64KEY reg_key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall", 0, sam) latest_version = "" latest_build = 0 path_to_latest_build = "" # iterate through all subkeys of \Uninstall for i in xrange(0, _winreg.QueryInfoKey(reg_key)[0]): try: subkey = _winreg.EnumKey(reg_key, i) if re.match(WINDOWS_GUID_RX, subkey): tde_key = _winreg.OpenKey(reg_key, subkey) display_name = str(_winreg.QueryValueEx(tde_key, "DisplayName")[0]) if display_name.startswith("Load DynamiX TDE"): display_version = str(_winreg.QueryValueEx(tde_key, "DisplayVersion")[0]) match = re.match("(\d+).(\d+).(\d+)", display_version) if match: tde_build = int(match.group(3)) if tde_build > latest_build: path_to_build = str(_winreg.QueryValueEx(tde_key, "InstallLocation")[0]) path_to_build = os.path.join(path_to_build, "LdxCmd.exe") if os.path.exists(path_to_build): latest_version = display_version latest_build = tde_build path_to_latest_build = path_to_build except EnvironmentError: break if latest_build > 0: print ("The latest LdxCmd version found: " + latest_version) return path_to_latest_build else: raise Exception('LdxCmd.exe not found.') else: if not os.path.exists("/opt/swifttest/resources/dotnet/LdxCmd"): raise Exception('LdxCmd executable not found: /opt/swifttest/resources/dotnet/LdxCmd') return "/opt/swifttest/resources/dotnet/LdxCmd"
def Get_User_ShellFolders(): # Routine to grab all the Windows Shell Folder locations from the registry. If successful, returns dictionary # of shell folder locations indexed on Windows keyword for each; otherwise, returns an empty dictionary. import _winreg return_dict = {} # First open the registry hive try: Hive = _winreg.ConnectRegistry(None, _winreg.HKEY_CURRENT_USER) except WindowsError: print "Can't connect to registry hive HKEY_CURRENT_USER." return return_dict # Then open the registry key where Windows stores the Shell Folder locations try: Key = _winreg.OpenKey( Hive, "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders") except WindowsError: print "Can't open registry key Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders." _winreg.CloseKey(Hive) return return_dict # Nothing failed above, so enumerate through all the Shell Folder values and return in a dictionary # This relies on error at end of try: #i = 0 #while 1: for i in range(0, _winreg.QueryInfoKey(Key)[1]): name, value, val_type = _winreg.EnumValue(Key, i) return_dict[name] = value i += 1 _winreg.CloseKey(Key) # Only use with for loop _winreg.CloseKey(Hive) # Only use with for loop return return_dict # Only use with for loop except WindowsError: # In case of failure before read completed, don't return partial results _winreg.CloseKey(Key) _winreg.CloseKey(Hive) return {}
def get_reboot_required(): """Returns True if the system should be rebooted to apply updates. This is not guaranteed to notice all conditions that could require reboot. """ # Based on https://stackoverflow.com/a/45717438 k = None import _winreg try: k = _winreg.OpenKey( _winreg.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\WindowsUpdate\\' 'Auto Update\\RebootRequired') _, num_values, _ = _winreg.QueryInfoKey(k) return num_values > 0 except WindowsError: # pylint: disable=undefined-variable # This error very likely means the RebootRequired key does not exist, # meaning reboot is not required. return False finally: if k: k.Close()
def find_services_trigger(self, service): access_write = KEY_WRITE | KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE hkey = OpenKey(HKEY_LOCAL_MACHINE, 'SOFTWARE\\Microsoft\\Tracing', 0, access_write) num = winreg.QueryInfoKey(hkey)[0] triggers = [] for x in range(0, num): svc = winreg.EnumKey(hkey, x) for s in service: if s.name.lower() == svc.lower() and s.permissions['start']: is_service_running = self.is_service_running(svc) if not is_service_running or (is_service_running and s.permissions['stop']): triggers.append(s) print('[+] Service {name} found'.format(name=s.name)) else: print( '[-] Service {name} already running and could not be stopped' .format(name=s.name)) winreg.CloseKey(hkey) return triggers
def _recursive_delete(self, key0, key1, key2=''): """ Delete a key and its subkeys. """ current = key1 if not key2 else key1 + '\\' + key2 with _winreg.OpenKey(key0, current, 0, _winreg.KEY_ALL_ACCESS) as key: info = _winreg.QueryInfoKey(key) for x in range(info[0]): """ Deleting the subkey will change the SubKey count used by EnumKey. We must always pass 0 to EnumKey so we always get back the new first SubKey. """ subkey = _winreg.EnumKey(key, 0) try: _winreg.DeleteKey(key, subkey) except WindowsError: self._recursive_delete(key0, current, key2=subkey) try: _winreg.DeleteKey(key0, key1) except WindowsError: pass
def retrieve_softwares(self): results = [] # Open the Base on read only accessRead = KEY_READ | KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE # check the uninstall key path hkey = _winreg.OpenKey( HKEY_LOCAL_MACHINE, "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\\", 0, accessRead) num = _winreg.QueryInfoKey(hkey)[0] # loop through number of subkeys for x in range(0, num): # Name of the software key sk = _winreg.EnumKey(hkey, x) # ------ Check if the key has his executable with write access and the folder containing it as well ------ try: skey = _winreg.OpenKey(hkey, sk, 0, accessRead) name = str(_winreg.QueryValueEx(skey, "DisplayName")[0]) if name: # regex to not match security patch (KB) m = re.match(r".*KB[0-9]{5,7}.*", name, re.IGNORECASE) if not m: soft = Software() soft.name = name soft.version = str( _winreg.QueryValueEx(skey, "DisplayVersion")[0]) soft.key = skey results.append(soft) except: pass return results
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. """ import _winreg if directory is None: directory = win32FontDirectory() key, items = None, {} for fontdir in MSFontDirectories: try: local = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, fontdir) except OSError: continue if not local: return glob.glob(os.path.join(directory, '*.'+fontext)) try: for j in range(_winreg.QueryInfoKey(local)[1]): try: key, direc, any = _winreg.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 items.keys() finally: _winreg.CloseKey(local) return None
def run(self): if float(win.get_os_version()) > 6.1: self.debug(u'Internet Explorer passwords are stored in Vault (check vault module)') return pwd_found = [] try: hkey = win.OpenKey(win.HKEY_CURRENT_USER, 'Software\\Microsoft\\Internet Explorer\\IntelliForms\\Storage2') except Exception: self.debug(traceback.format_exc()) else: nb_site = 0 nb_pass_found = 0 # retrieve the urls from the history hash_tables = self.get_hash_table() num = winreg.QueryInfoKey(hkey)[1] for x in range(0, num): k = winreg.EnumValue(hkey, x) if k: nb_site += 1 for h in hash_tables: # both hash are similar, we can decipher the password if h[1] == k[0][:40].lower(): nb_pass_found += 1 cipher_text = k[1] pwd_found += self.decipher_password(cipher_text, h[0]) break winreg.CloseKey(hkey) # manage errors if nb_site > nb_pass_found: self.error(u'%s hashes have not been decrypted, the associate website used to decrypt the ' u'passwords has not been found' % str(nb_site - nb_pass_found)) return pwd_found
def getInstalledRegvalnameVersion(d): """Get the version of the installed package from a registry value. Use the information specified in the package d to lookup the installed version on the computer. @param d A installversion dictionary entry for a package containing at least entries for 'key', 'subkey', 'regex', and 'regexpos' @return The version installed or None. """ try: # should do a lookup table here if d['key'] == 'HKLM': tempkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, d['subkey']) else: return None vals = _winreg.QueryInfoKey(tempkey)[1] valnames = [_winreg.EnumValue(tempkey, i)[0] for i in xrange(vals)] valnames = sorted(valnames) valnamesstr = "\n".join(valnames) version = re.findall(d['regex'], valnamesstr)[d['regexpos']] return version except TypeError as strerror: if strerror == 'first argument must be a string or compiled pattern': print 'you are missing or have an invalid regex in %s' % d elif strerror == 'expected string or buffer': print 'your have no value being pulled from the registry' print 'when calling getInstalledRegvalnameVersion(%s)' % d except WindowsError: print 'The registry key or value could not be found' print 'when calling getInstalledRegvalnameVersion(%s)' % d except KeyError as strerror: print 'd did not contain a "%s" entry' % strerror print 'when calling getInstalledRegvalnameVersion(%s)' % d except: print 'unkown error running getInstalledRegvalnameVersion(%s)' % d else: return None
def unregister(name, versions=_reg_versions): """remove an from excels startup list""" # need to add a _d if we are debugging? basename = "%s.xll" % name.replace('.', os.sep) _log.info('Looking to unregister %s' % basename) for version in versions: key_name = _reg_key % {'version': version} try: key = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, key_name, 0, _winreg.KEY_READ | _winreg.KEY_WRITE) except WindowsError: _log.debug('Could not find %s' % key_name) continue # get count of keys to consder _, count, _ = _winreg.QueryInfoKey(key) # loop over all values in the register names = [] for i in xrange(count): name, value, type = _winreg.EnumValue(key, i) if type != _winreg.REG_SZ or not name.startswith('OPEN'): continue # remove quotes value = value.strip('"') # clear up anything with _xltypes.pyd, what about _xltypes_d.pyd? if value.endswith(basename): names.append(name) for name in names: _log.info("ExcelXLLSDK.register.unregister: %s\\%s = %s" % (key_name, name, value)) _winreg.DeleteValue(key, name)
def find_cortana(): index = 0 cortana_version = [] try: key = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, "Software\Classes\ActivatableClasses\Package", 0, _winreg.KEY_READ) except Exception as error: print_error( "Unable to open registry key, exception was raised: {}".format( error)) return False try: num = _winreg.QueryInfoKey(key)[0] for x in range(0, num): if "Microsoft.Windows.Cortana_" in _winreg.EnumKey(key, x): cortana_version.append(_winreg.EnumKey(key, x)) break except WindowsError as error: pass return cortana_version
def deregister_file_extension(ext): """Remove ourselves as the default handler for the file extension, setting the first available alternative handler if found.""" openkeys = [] replacement = "" try: try: key = _winreg.OpenKeyEx(_winreg.HKEY_CLASSES_ROOT,"%s\\OpenWithProgIds" % ext,0,_winreg.KEY_QUERY_VALUE) openkeys.insert(0,key) for i in range(0,_winreg.QueryInfoKey(key)[1]): value = _winreg.EnumValue(key,i)[0] if value and value != "Juice%s" % ext: replacement = value key = _winreg.OpenKeyEx(_winreg.HKEY_CLASSES_ROOT,ext,0,_winreg.KEY_ALL_ACCESS) openkeys.insert(0,key) _winreg.SetValueEx(key,"",0,_winreg.REG_SZ,replacement) finally: for key in openkeys: _winreg.CloseKey(key) except WindowsError, e: errno, message = e.args if errno != 2: raise e
def serialports_GET(self): try: serialports = [] if os.name == 'nt': key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, 'HARDWARE\\DEVICEMAP\\SERIALCOMM') for i in range(winreg.QueryInfoKey(key)[1]): try: val = winreg.EnumValue(key, i) except: pass else: if val[0].find('VCP') > -1: serialports.append(str(val[1])) elif os.name == 'posix': serialports = glob.glob('/dev/ttyUSB*') serialports.sort() return {'serialports': serialports} except Exception as err: return ['Could not scan for serial port. Error={0}'.format(err)]
def win32_find_myo_port(): path = 'SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_2458&PID_0001\\1\\Device Parameters' key = None try: key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) info = winreg.QueryInfoKey(key) values_count = info[1] i = 0 while (i < values_count): val = winreg.EnumValue(key, i) #(keyname, value, type), type 1: REG_SZ if val[0] == 'PortName': # That's the keyname we are interested in portname = val[1] winreg.CloseKey(key) return portname # else continue with loop # If loop ended, we don't have PortName winreg.CloseKey(key) return None except WindowsError: if key is not None: winreg.CloseKey(key) return None
def disable_proxy(): _, values_num, _ = winreg.QueryInfoKey(CONNECTIONS) for i in range(0, values_num): key, value, _ = winreg.EnumValue(CONNECTIONS, i) List = INTERNET_PER_CONN_OPTION_LIST() Option = (INTERNET_PER_CONN_OPTION * 1)() nSize = c_ulong(sizeof(INTERNET_PER_CONN_OPTION_LIST)) Option[0].dwOption = INTERNET_PER_CONN_FLAGS Option[0].Value.dwValue = PROXY_TYPE_DIRECT List.dwSize = sizeof(INTERNET_PER_CONN_OPTION_LIST) List.pszConnection = create_unicode_buffer(key) List.dwOptionCount = 1 List.dwOptionError = 0 List.pOptions = Option InternetSetOption(None, INTERNET_OPTION_PER_CONNECTION_OPTION, byref(List), nSize) InternetSetOption(None, INTERNET_OPTION_SETTINGS_CHANGED, None, 0) InternetSetOption(None, INTERNET_OPTION_REFRESH, None, 0)
def retrieve_info(self, hkey, name_key): values = {} num = winreg.QueryInfoKey(hkey)[1] for x in range(0, num): k = winreg.EnumValue(hkey, x) if 'password' in k[0].lower(): try: password_bytes = win.Win32CryptUnprotectData(k[1][1:], is_current_user=constant.is_current_user, user_dpapi=constant.user_dpapi) # password_bytes is <password in utf-16> + b'\x00\x00' terminator = b'\x00\x00' if password_bytes.endswith(terminator): password_bytes = password_bytes[: -len(terminator)] values[k[0]] = password_bytes.decode("utf-16") except Exception as e: self.debug(str(e)) values[k[0]] = 'N/A' else: try: values[k[0]] = str(k[1]).decode('utf16') except Exception: values[k[0]] = str(k[1]) return values
def _get_addresses_of_proxy_pac(self): """ Return a list of possible auto proxy .pac files being used, based on the system registry (win32) or system preferences (OSX). @return: list of urls """ pac_files = [] if sys.platform == 'win32': try: import _winreg as winreg # used from python 2.0-2.6 except: import winreg # used from python 2.7 onwards net = winreg.OpenKey( winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings" ) n_subs, n_vals, last_mod = winreg.QueryInfoKey(net) subkeys = {} for i in range(n_vals): this_name, this_val, this_type = winreg.EnumValue(net, i) subkeys[this_name] = this_val if 'AutoConfigURL' in subkeys.keys() and len( subkeys['AutoConfigURL']) > 0: pac_files.append(subkeys['AutoConfigURL']) elif sys.platform == 'darwin': import plistlib sys_prefs = plistlib.readPlist( '/Library/Preferences/SystemConfiguration/preferences.plist') networks = sys_prefs['NetworkServices'] # loop through each possible network (e.g. Ethernet, Airport...) for network in networks.items(): # the first part is a long identifier net_key, network = network if 'ProxyAutoConfigURLString' in network['Proxies'].keys(): pac_files.append( network['Proxies']['ProxyAutoConfigURLString']) return list(set(pac_files)) # remove redundant ones
def GetInstalledBrowsers(self): ''' usage:object.GetInstalledBrowsers() Output: browser_list-->list ''' path = 'SOFTWARE\Clients\StartMenuInternet' Hkeys = reg.HKEY_LOCAL_MACHINE Regkey = reg.ConnectRegistry(None, Hkeys) key = reg.OpenKey(Regkey, path, 0, reg.KEY_READ | reg.KEY_WOW64_32KEY) key_count = reg.QueryInfoKey(key)[0] browser = {} browser_list = [] for i in range(key_count): singsoft = {} try: keyname = reg.EnumKey(key, i) singsoft['id'] = i singsoft['Name'] = keyname browser_list.append(singsoft) except Exception as ex: continue return browser_list
def get_ghostscript_dir(): """ Tries to determine the directory in which ghostscript is installed. If successful the path is returned. If nothing is found the function returns None. The function searches the Windows registry under HKLM an HKCU for the keys defined in the list STR_KEYS_GHOSTSCRIPT. If a key is found it iterates over all available subkeys found under the key and checks if they contain the directory. """ for access_right in _REG_ACCESS_RIGHTS: for hkey in [_wr.HKEY_LOCAL_MACHINE, _wr.HKEY_CURRENT_USER]: for str_key in _STR_KEYS_GHOSTSCRIPT: try: key = _wr.OpenKey(hkey, str_key, 0, access_right) # Ghostscript stores the information in a subkey the name # of which is the installed version number. If several # subkeys are found we iterate over them until we find a # valid directory num_subkeys = _wr.QueryInfoKey(key)[0] for i in range(0, num_subkeys): subkey_str = _wr.EnumKey(key, i) subkey = _wr.OpenKeyEx(key, subkey_str) dirname = _wr.QueryValue(subkey, None) + r'\bin' _wr.CloseKey(subkey) _wr.CloseKey(key) if _os.path.isdir(dirname): return dirname except WindowsError: pass _set_last_error( 'Path to ghostscript not found (%s not found in registry!)' % _STR_KEYS_GHOSTSCRIPT) return None
def getSoftWares(self): #try: keyX = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, 'Software\\Autodesk\\Maya') for item in range(0, _winreg.QueryInfoKey(keyX)[0]): version = _winreg.EnumKey(keyX, item) temp = ('Software\\Autodesk\\Maya\\' + version + '\\Setup\\InstallPath\\') try: keyX1 = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, temp) path = _winreg.QueryValueEx(keyX1, 'MAYA_INSTALL_LOCATION')[0] radioButton = QtGui.QRadioButton(self.groupBox) radioButton.setObjectName('maya' + version) radioButton.setText('maya' + version) radioButton.accessibleName = path radioButton.setChecked(False) radioButton.clicked.connect( functools.partial(self.getPlugIns, version)) self.gridLayout.addWidget(radioButton, item / 2, item % 2, 1, 1) except WindowsError: pass
def listRegKeyValues(registry, key, architecture=None): """ Returns a list of child keys and their values as tuples. Each tuple contains 3 items. - A string that identifies the value name - An object that holds the value data, and whose type depends on the underlying registry type - An integer that identifies the type of the value data (see table in docs for _winreg.SetValueEx) Args: registry (str): The registry to look in. 'HKEY_LOCAL_MACHINE' for example key (str): The key to open. r'Software\Autodesk\Softimage\InstallPaths' for example architecture (int | None): 32 or 64 bit. If None use system default. Defaults to None Returns: List of tuples """ import _winreg regKey = getRegKey(registry, key, architecture=architecture) ret = [] if regKey: subKeys, valueCount, modified = _winreg.QueryInfoKey(regKey) for index in range(valueCount): ret.append(_winreg.EnumValue(regKey, index)) return ret
def printinfo(): print 'version 1.2 modified' print 'Registry Info:' hkey = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,r'System\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\') keyInfo = _winreg.QueryInfoKey(hkey) for index in range(keyInfo[0]): hSubKeyName = _winreg.EnumKey(hkey, index) print hSubKeyName hSubKey = _winreg.OpenKey(hkey, hSubKeyName) try: print _winreg.QueryValueEx(hSubKey, 'NameServer') except: pass print 'WMI Info' wmiService = wmi.WMI() colNicConfigs = wmiService.Win32_NetworkAdapterConfiguration() for i in range(len(colNicConfigs)): print 'IPEnabled' print colNicConfigs[i].IPEnabled print 'SettingID' print colNicConfigs[i].SettingID print 'DNS' print colNicConfigs[i].DNSServerSearchOrder
def findSerialPorts(): ''' Returns the serial ports of the motes connected to the computer. :returns: A list of tuples (name,baudrate) where: - name is a strings representing a serial port, e.g. 'COM1' - baudrate is an int representing the baurate, e.g. 115200 ''' serialports = [] if os.name=='nt': path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM' key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path) for i in range(winreg.QueryInfoKey(key)[1]): try: val = winreg.EnumValue(key,i) except: pass else: if val[0].find('VCP')>-1: serialports.append( (str(val[1]),BAUDRATE_TELOSB) ) elif val[0].find('Silabser')>-1: serialports.append( (str(val[1]),BAUDRATE_GINA) ) elif val[0].find('ProlificSerial')>-1: serialports.append( (str(val[1]),BAUDRATE_WSN430) ) elif os.name=='posix': if platform.system() == 'Darwin': portMask = '/dev/tty.usbserial-*' else: portMask = '/dev/ttyUSB*' serialports = [(s,BAUDRATE_GINA) for s in glob.glob(portMask)] # log log.info("discovered following COM port: {0}".format(['{0}@{1}'.format(s[0],s[1]) for s in serialports])) return serialports
def list_reg_key_values(registry, key, architecture=None): """ Returns a list of child keys and their values as tuples containing: - A string that identifies the value name - An object that holds the value data, and whose type depends on the underlying registry type - An integer that identifies the type of the value data (see table in docs for _winreg.SetValueEx) :param registry: str, registry to look in. HKEY_LOCAL_MACHINE for example :param key: str, key to open 'Software/Ubisoft/Test' for example :param architecture: variant, int || None, 32 or 64 bit. If None, default system architecture is used :return: list<tuple> """ import _winreg reg_key = get_reg_key(registry=registry, key=key, architecture=architecture) ret = list() if reg_key: sub_keys, value_count, modified = _winreg.QueryInfoKey(reg_key) for i in range(value_count): ret.append(_winreg.EnumValue(reg_key, i)) return ret
def AutoReadMoldexVersion(): # Read the Moldex3D installing address pyHKEY = _winreg.OpenKey( _winreg.HKEY_LOCAL_MACHINE, r'SOFTWARE\Wow6432Node\CoreTechSystem\MDX_ParallelComputing') valueInfo = _winreg.QueryInfoKey( pyHKEY) # Read the value infomation(name & data) under the subKey versionPathList = [] for i in range(0, valueInfo[1], 1): value = _winreg.EnumValue(pyHKEY, i) if "_INSTALLDIR" in value[0]: versionPathList.append(value[1]) if versionPathList == []: return ("MDX setting address Error !!") else: versionParentPath = str(versionPathList[-1]) # Read the DailyBuild version with open(r"{}\Moldex3D.ver".format(versionParentPath), "r") as localfile: versionLine = localfile.read() patten = r"R[0-9]{2}[A-Za-z0-9]+ 64-bit \(Build[0-9]{4}[.][0-9]{4}" version = re.search(patten, versionLine).group().replace(" 64-bit (", "") _winreg.CloseKey(pyHKEY) return (version)