Example #1
0
def get_interfaces():
    """Enumerate all registered J2534 04.04 Pass-Thru interface DLLs

    Returns:
        dict: A dict mapping display names of any registered J2534
        Pass-Thru DLLs to their absolute filepath.

        The name can be used in user-facing GUI elements to allow
        selection of a particular Pass-Thru device, and filepath can
        be passed to :func:`load_interface` to instantiate a
        :class:`J2534Dll` wrapping the desired DLL.
    """

    if 'win' not in _platform:
        raise RuntimeError('PyJ2534 currently only supports Windows')
    else:
        import winreg

    ret = {}

    _64bit = sys.maxsize > 2**32
    _passthru_key = (r"Software\\Wow6432Node\\PassThruSupport.04.04\\"
                     if _64bit else r"Software\\PassThruSupport.04.04\\")

    BaseKey = winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE, _passthru_key)
    count = winreg.QueryInfoKey(BaseKey)[0]

    for i in range(count):
        DeviceKey = winreg.OpenKeyEx(BaseKey, winreg.EnumKey(BaseKey, i))
        Name = winreg.QueryValueEx(DeviceKey, "Name")[0]
        FunctionLibrary = winreg.QueryValueEx(DeviceKey, "FunctionLibrary")[0]
        ret[Name] = FunctionLibrary

    return ret
Example #2
0
    def get_wsl_basepath(self):
        try:
            # get default wsl from registory
            # HKCU\Software\Microsoft\Windows\CurrentVersion\Lxss
            path = 'Software\\Microsoft\\Windows\\CurrentVersion\\Lxss'
            self.log(path)
            key = winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER,
                                   path,
                                   access=winreg.KEY_READ
                                   | winreg.KEY_WOW64_32KEY)
            defaultDistribution, regtype = winreg.QueryValueEx(
                key, 'DefaultDistribution')
            winreg.CloseKey(key)

            path = path + '\\' + defaultDistribution
            self.log(path)
            key = winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER,
                                   path,
                                   access=winreg.KEY_READ
                                   | winreg.KEY_WOW64_32KEY)
            basePath, regtyp = winreg.QueryValueEx(key, 'BasePath')
            winreg.CloseKey(key)
        except:
            basePath = False
            traceback.print_exc()

        return basePath
Example #3
0
def user2sid(user_name):
    """
        Returns the user id of the provided user name.
        @param user_id: The user name.
    """
    path = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProfileList"

    # Opens the specified key path.
    with reg.OpenKeyEx(reg.HKEY_LOCAL_MACHINE, path) as key:

        # Iterates through each sub key.
        for inx in range(reg.QueryInfoKey(key)[0]):

            key_name = reg.EnumKey(key, inx)

            # Retrieves information of the provided profile key.
            with reg.OpenKeyEx(key, key_name) as user_key:

                # Get the name of the user from its profileImagePath key value.
                profile_image_path = reg.QueryValueEx(user_key,
                                                      "ProfileImagePath")[0]
                user_name_index = profile_image_path.rfind("\\") + 1

                # Return the user identification if it matches the provided user name
                if user_name.lower(
                ) == profile_image_path[user_name_index:].lower():
                    return key_name
Example #4
0
def list_all_com_ports(vendor_id, product_id, serial_number):
    ports = []

    hkey_path = "SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_{}&PID_{}\\{}"\
                .format(vendor_id, product_id, serial_number)

    try:
        device_hkey = winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE, hkey_path)
    except EnvironmentError as err:
        return ports

    try:
        parent_id = winreg.QueryValueEx(device_hkey, "ParentIdPrefix")[0]
    except EnvironmentError as err:
        winreg.CloseKey(device_hkey)
        return ports

    winreg.CloseKey(device_hkey)

    hkey_path = "SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_{}&PID_{}\\{}\\Device Parameters"\
                .format(vendor_id, product_id, serial_number)
    try:
        device_hkey = winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE, hkey_path)
        try:
            COM_port = winreg.QueryValueEx(device_hkey, "PortName")[0]
            ports.append(COM_port)
        except EnvironmentError as err:
            #  No COM port for root device.
            pass
        winreg.CloseKey(device_hkey)
    except EnvironmentError as err:
        #  Root device has no device parameters
        pass

    iface_id = 0
    while True:
        hkey_path = "SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_{vid_val}&PID_{pid_val}&"\
        "MI_{mi_val}\\{parent_val}&{parent_iface}\\Device Parameters"\
        .format(vid_val=vendor_id, pid_val=product_id, mi_val=str(iface_id).zfill(2),
                parent_val=parent_id, parent_iface=str(iface_id).zfill(4))
        iface_id += 1
        try:
            device_hkey = winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE,
                                           hkey_path)
        except EnvironmentError as err:
            break

        try:
            port_name = winreg.QueryValueEx(device_hkey, "PortName")[0]
        except EnvironmentError as err:
            winreg.CloseKey(device_hkey)
            continue

        winreg.CloseKey(device_hkey)
        if com_port_is_open(port_name):
            ports.append(port_name)

    return ports
Example #5
0
def getFactorioPath():
    steamPath = fallbackSteamPath = None
    # Check for Steam version
    if sys.platform == 'win32':
        import winreg
        try:
            with winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER,
                                  r'Software\Valve\Steam') as key:
                steamPath = Path(winreg.QueryValueEx(key, 'SteamPath')[0])
        except FileNotFoundError as err:
            logger.debug('Registry lookup for Steam installation failed: ',
                         err)
    elif sys.platform == 'linux':
        # NOTE: Some people move Steam from the default install location, which the
        # Steam client seems to support, as it will ask where its files are.
        # /usr/bin/steam is actually a wrapper script that points Steam in the
        # right places. I believe that the the wrapper/bootstrap points the
        # ~/.steam/steam symlink to the proper Steam installation, so we can use it
        # as a fallback if the default path is invalid.
        steamPath = Path.home() / '.local' / 'share' / 'Steam'
        fallbackSteamPath = Path.home() / '.steam' / 'steam'
        if not steamPath.exists():
            logger.warning(f'No Steam installation found at the default path '
                           f'({steamPath}). Attempting to fall back to '
                           f"'{fallbackSteamPath}'")
            steamPath = fallbackSteamPath if fallbackSteamPath.exists(
            ) else None

    if steamPath is not None:
        for library in getSteamLibraries(steamPath):
            factorioPath = library / 'steamapps' / 'common' / 'Factorio'
            if factorioPath.exists():
                return factorioPath
    else:
        logger.debug(
            'Could not find Steam installation; attempting to find the '
            'stand-alone installation...')

    # Check for stand-alone version
    if sys.platform == 'win32':
        try:
            key = winreg.OpenKeyEx(
                winreg.HKEY_LOCAL_MACHINE,
                r'Software\Microsoft\Windows\CurrentVersion\Uninstall\Factorio_is1'
            )
            factorioPath = winreg.QueryValueEx(key, 'InstallLocation')
        except FileNotFoundError as err:
            logger.debug('Registry lookup for Steam installation failed: ',
                         err)
    elif sys.platform == 'linux':
        logger.warning('Stand-alone installation lookup is not supported on '
                       'Linux, as it is just a simple tarball.')
    if factorioPath.exists():
        return factorioPath
    else:
        logger.warning('Could not find a stand-alone installation!')
        return None
    def launch(program=val, filename=filename):
        if program == "CyberChef":
            print os.path.getsize(filename)
            if os.path.getsize(filename) > 12000:
                tkMessageBox.showwarning(None, message="Data size exceeds 12000 bytes. Sent data will be truncated (due to limit of command line argument length).")
            cyberchef_input = open(filename, "rb").read(12000)
            # CyberChef input box automatically replace 0x0d with 0x0a and this breaks data integrity.
            # So data have to be converted into hex text before sending to CyberChef.
            # For the detail of the issue, please see https://github.com/gchq/CyberChef/issues/430 .
            # Data size limit is reduced from 24000 bytes to 12000 bytes due to this conversion.
            cyberchef_input = binascii.hexlify(cyberchef_input)
            cyberchef_input = base64.b64encode(cyberchef_input)
            cyberchef_input = cyberchef_input.replace("+", "%2B")
            cyberchef_input = cyberchef_input.replace("=", "")

            cyberchef_url = "file:///%s%s/Desktop/cyberchef.htm#recipe=From_Hex('Auto')&input=%s" % (os.getenv("HOMEDRIVE"), os.getenv("HOMEPATH").replace("\\", "/"), cyberchef_input)

            # Get path of default browser because "start" built-in command of command prompt drops URL parameters with "file:///" URL scheme
            reg_key = winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice")
            progid, regtype = winreg.QueryValueEx(reg_key, "ProgId")
            winreg.CloseKey(reg_key)
            reg_key = winreg.OpenKeyEx(winreg.HKEY_CLASSES_ROOT, "%s\\shell\\open\\command" % progid)
            browser_cmd, regtype = winreg.QueryValueEx(reg_key, "")
            winreg.CloseKey(reg_key)
            browser_cmd = browser_cmd.replace("%1", cyberchef_url)
            p = subprocess.Popen(browser_cmd)
            p.wait()
        elif program == "Customize menu":
            # Get path of default text editor
            try:
                reg_key = winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\FileExts\\.txt\\UserChoice")
                progid, regtype = winreg.QueryValueEx(reg_key, "ProgId")
                progid = progid.replace("\\", "\\\\")
                winreg.CloseKey(reg_key)
                reg_key = winreg.OpenKeyEx(winreg.HKEY_CLASSES_ROOT, "%s\\shell\\open\\command" % progid)
                editor_cmd, regtype = winreg.QueryValueEx(reg_key, "")
                winreg.CloseKey(reg_key)
                editor_cmd = replace_env_in_path(editor_cmd)
                editor_cmd = editor_cmd.replace("%1", "send_to.json")
                tkMessageBox.showinfo(None, message="Please edit 'send_to.json' to customize menu.")
                p = subprocess.Popen(editor_cmd)
                p.wait()
            except Exception as e:
                # Fallback to Notepad
                tkMessageBox.showinfo(None, message="Please edit 'send_to.json' to customize menu.")
                p = subprocess.Popen(["C:\\Windows\\notepad.exe", "send_to.json"])
                p.wait()
        else:
            program = replace_env_in_path(program)
            if os.path.exists(program):
                p = subprocess.Popen([program, filename])
                p.wait()
            else:
                msg = "%s does not exist." % program
                tkMessageBox.showerror("Error", msg)
        root.quit()
Example #7
0
def findGamePath() -> Union[Path, None]:
    # Try to find the game path through registry entries and library files
    from w3modmanager.core.model import verifyGamePath
    import winreg
    import vdf

    try:
        # try to read Witcher 3 GOG installation path directly
        # see https://www.gog.com/forum/general/querying_gog_install_path
        key = winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE,
                               r'SOFTWARE',
                               access=(winreg.KEY_READ
                                       | winreg.KEY_WOW64_64KEY))
        subkey = winreg.OpenKeyEx(key, r'WOW6432Node\GOG.com\Games\1207664663')
        game = winreg.QueryValueEx(subkey, 'exe')
        game = Path(str(game[0]))
        if verifyGamePath(game):
            return game
    except Exception:  # noqa
        # probably not found
        pass

    try:
        # try to read Steam installation path
        # see https://stackoverflow.com/questions/34090258/find-steam-games-folder
        key = winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE,
                               r'SOFTWARE',
                               access=(winreg.KEY_READ
                                       | winreg.KEY_WOW64_64KEY))
        subkey = winreg.OpenKeyEx(key, r'WOW6432Node\Valve\Steam')
        steam = winreg.QueryValueEx(subkey, 'installPath')
        steam = Path(str(steam[0]))
        libs = steam.joinpath('steamapps/libraryfolders.vdf')
        if steam.exists() and libs.is_file():
            # found Steam installation, now read library folders manifest
            # and iterate libraries
            libdict = vdf.loads(util.readText(libs), mapper=vdf.VDFDict)
            libvals = libdict['LibraryFolders']
            for key in libvals:
                checkpath = Path(libvals[key])
                if checkpath.is_dir() and checkpath.joinpath(
                        'steamapps').is_dir():
                    # Steam library path found, now check for Witcher 3 installation
                    steamapps = checkpath.joinpath('steamapps')
                    game = steamapps.joinpath(
                        'common/The Witcher 3/bin/x64/witcher3.exe')
                    if verifyGamePath(game):
                        return game
        else:
            pass
    except Exception:  # noqa
        # probably not found
        pass

    return None
Example #8
0
def get_serial_serial_no(vendor_id, product_id, h_dev_info, device_info_data):
    prop_type = ctypes.c_ulong()
    required_size = ctypes.c_ulong()

    instance_id_buffer = ctypes.create_string_buffer(MAX_BUFSIZE)

    res = setup_api.SetupDiGetDevicePropertyW(
        h_dev_info, ctypes.byref(device_info_data),
        ctypes.byref(DEVPKEY.Device.ContainerId), ctypes.byref(prop_type),
        ctypes.byref(instance_id_buffer), MAX_BUFSIZE,
        ctypes.byref(required_size), 0)

    wanted_GUID = GUID(ctypesInternalGUID(instance_id_buffer))

    hkey_path = "SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_{}&PID_{}".format(
        vendor_id, product_id)
    try:
        vendor_product_hkey = winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE,
                                               hkey_path)
    except EnvironmentError as err:
        return

    serial_numbers_count = winreg.QueryInfoKey(vendor_product_hkey)[0]

    for serial_number_idx in range(serial_numbers_count):
        try:
            serial_number = winreg.EnumKey(vendor_product_hkey,
                                           serial_number_idx)
        except EnvironmentError as err:
            continue

        hkey_path = "SYSTEM\\CurrentControlSet\\Enum\\USB\\VID_{}&PID_{}\\{}"\
                    .format(vendor_id, product_id, serial_number)

        try:
            device_hkey = winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE,
                                           hkey_path)
        except EnvironmentError as err:
            continue

        try:
            queried_container_id = winreg.QueryValueEx(device_hkey,
                                                       "ContainerID")[0]
        except EnvironmentError as err:
            winreg.CloseKey(device_hkey)
            continue

        winreg.CloseKey(device_hkey)

        if queried_container_id.lower() == str(wanted_GUID).lower():
            winreg.CloseKey(vendor_product_hkey)
            return serial_number

    winreg.CloseKey(vendor_product_hkey)
Example #9
0
def getDevices():

    J2534_Device_Reg_Info = []

    BaseKey = winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE, PASSTHRU_REG)
    count = winreg.QueryInfoKey(BaseKey)[0]
    for i in range(count):
        DeviceKey = winreg.OpenKeyEx(BaseKey, winreg.EnumKey(BaseKey, i))
        Name = winreg.QueryValueEx(DeviceKey, "Name")[0]
        FunctionLibrary = winreg.QueryValueEx(DeviceKey, "FunctionLibrary")[0]
        J2534_Device_Reg_Info.append((Name, FunctionLibrary))
    return J2534_Device_Reg_Info
Example #10
0
def _win10RID(buildNum, isClient):
	# Special cases: Windows 10 Version 1507, Windows Server long-term servicing channel (LTSC) releases.
	if isClient and buildNum == 10240:
		return "Windows 10 1507"
	elif not isClient and buildNum in server10LTSBuilds:
		return server10LTSBuilds[buildNum]
	# Since late 2019 (and confirmed with Server vNext build 20201),
	# "rs_prerelease" branch designates dev channel build.
	# Note that in some cases Insider Preview builds may come from what may appear to be
	# feature update branch such as mn_release for 20H2 Azure release.
	# If self-host IsRetailOS flag is present (an integer), it is an Insider Preview.
	# Because NVDA is a 32-bit application, 64-bit view of Registry must be attempted for self-host key.
	if os.environ.get("PROCESSOR_ARCHITEW6432") in ("AMD64", "ARM64"):
		selfHostApplicability = winreg.OpenKeyEx(
			winreg.HKEY_LOCAL_MACHINE, r"Software\Microsoft\WindowsSelfHost\Applicability",
			access=winreg.KEY_READ | winreg.KEY_WOW64_64KEY
		)
	else:
		selfHostApplicability = winreg.OpenKeyEx(
			winreg.HKEY_LOCAL_MACHINE, r"Software\Microsoft\WindowsSelfHost\Applicability"
		)
	try:
		isRetailOS = winreg.QueryValueEx(selfHostApplicability, "IsRetailOS")[0]
	except OSError:
		isRetailOS = 1
	winreg.CloseKey(selfHostApplicability)
	currentVersion = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"Software\Microsoft\Windows NT\CurrentVersion")
	try:
		buildBranch = winreg.QueryValueEx(currentVersion, "BuildBranch")[0]
	except OSError:
		buildBranch = None
	if isRetailOS:
		isRetailOS = buildBranch and not buildBranch.startswith("rs_prerelease")
	# Version 20H2/2009 and later where a separate display version string is used.
	# For backward compatibility, release ID variable will store display version string.
	try:
		releaseID = winreg.QueryValueEx(currentVersion, "DisplayVersion")[0]
	except OSError:
		releaseID = None
	# Version 1511 and later unless display version string is present.
	if not releaseID:
		try:
			releaseID = winreg.QueryValueEx(currentVersion, "ReleaseID")[0]
		except OSError:
			releaseID = "Unknown"
	winreg.CloseKey(currentVersion)
	# Insider Preview builds.
	if not isRetailOS:
		return "Windows 10 Insider" if isClient else "Windows Server Insider"
	if isClient:
		return "Windows 10 {0}".format(releaseID)
	else:
		return "Windows Server {0}".format(releaseID)
Example #11
0
def write_registry(bank_id, bank_name, bank_path):
    logger.debug("Writing registry for {} ({}) @ {}".format(
        bank_name, bank_id, bank_path))
    bank_path_parent = str(Path(bank_path).parent)
    dict_bank = dict(BankName=bank_name.replace(' ', '_'),
                     DRP="000055",
                     DefaultStyleID="gf22245e-19b1-40e1-a37a-699eaa5b4a1d",
                     Key="2ef256c28b85f2f16329acb0a9ba2ea4",
                     Name=bank_name,
                     Path=bank_path_parent,
                     Date="BMRDG7KZR3ZB27DE")

    dict_version = dict(Major=4, Minor=0, Revision=0)

    # registry = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)

    # install config section
    config_reg_path = r"SOFTWARE\VOCALOID5\Voice\Components\{}".format(bank_id)
    logger.debug("Writing {}".format(config_reg_path))
    try:
        config_key = winreg.OpenKeyEx(
            winreg.HKEY_LOCAL_MACHINE, config_reg_path, 0,
            winreg.KEY_WOW64_64KEY | winreg.KEY_ALL_ACCESS)
    except Exception as ex:
        config_key = winreg.CreateKeyEx(
            winreg.HKEY_LOCAL_MACHINE, config_reg_path, 0,
            winreg.KEY_WOW64_64KEY | winreg.KEY_ALL_ACCESS)
    # set one key
    for key, value in dict_bank.items():
        logger.debug("Setup key | {} : {}".format(key, value))
        winreg.SetValueEx(config_key, key, 0, winreg.REG_SZ, value)
    winreg.CloseKey(config_key)

    # install version section
    version_reg_path = r'SOFTWARE\VOCALOID5\Voice\Components\{}\Version'.format(
        bank_id)
    logger.debug("Writing {}".format(version_reg_path))
    winreg.CreateKey(winreg.HKEY_LOCAL_MACHINE, version_reg_path)
    try:
        version_key = winreg.OpenKeyEx(
            winreg.HKEY_LOCAL_MACHINE, version_reg_path, 0,
            winreg.KEY_WOW64_64KEY | winreg.KEY_ALL_ACCESS)
    except Exception as ex:
        version_key = winreg.CreateKeyEx(
            winreg.HKEY_LOCAL_MACHINE, version_reg_path, 0,
            winreg.KEY_WOW64_64KEY | winreg.KEY_ALL_ACCESS)
    for key, value in dict_version.items():
        logger.debug("Setup key | {} : {}".format(key, value))
        winreg.SetValueEx(version_key, key, 0, winreg.REG_DWORD, value)
    winreg.CloseKey(version_key)

    logger.debug("Successfully writing all changes into registry")
Example #12
0
def get_device_name(instance_id):
    """
        Get the device name.
        @param instance_id: Instance id of the device.
    """
    path = "SOFTWARE\\Microsoft\\Windows Portable Devices\\Devices"
    with reg.OpenKeyEx(reg.HKEY_LOCAL_MACHINE, path) as key:
        for inx in range(reg.QueryInfoKey(key)[0]):
            key_name = reg.EnumKey(key, inx)

            if instance_id in key_name:
                with reg.OpenKeyEx(key, key_name) as sub_key:
                    return reg.QueryValueEx(sub_key, "FriendlyName")[0]
Example #13
0
def getScreenshotFolder():
    import winreg
    reg_steam = winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER,"SOFTWARE\\Valve\\Steam")
    if reg_steam==None:
        print("你的电脑看起来并没有安装Steam")
        os.system("pause>nul")
        sys.exit(0)
    SteamPath = winreg.QueryValueEx(reg_steam,"SteamPath")[0]
    reg_users=winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER,"SOFTWARE\\Valve\\Steam\\Users")
    userlist=[]
    try:
        i=0
        while True:
            userlist.append(winreg.EnumKey(reg_users,i))
            i+=1
    except: pass
    if len(userlist)==0:
        print("你的Steam看起来没有登陆过任何账号")
        print("找不到截图文件夹")
        os.system("pause>nul")
        sys.exit(0)
    elif len(userlist)==1:
        return SteamPath+"\\userdata\\"+userlist[0]+"\\760\\remote"
    elif len(userlist)>1:
        defultAccountName = winreg.QueryValueEx(reg_steam,"LastGameNameUsed")[0]
        userdic={}
        for userIndex in range(len(userlist)):
            cfgPath=SteamPath+"\\userdata\\"+userlist[userIndex]+"\\config\\localconfig.vdf"
            if os.path.exists(cfgPath):
                fp=open(cfgPath,"r",encoding="utf8")
                cfgVdf = vdf.load(fp)
                fp.close()
                userdic[userIndex+1]=[cfgVdf["UserLocalConfigStore"]["friends"]["PersonaName"],userlist[userIndex]]
                del cfgVdf
            else:
                userdic[userIndex+1]=[userlist[userIndex],userlist[userIndex]]
        print("你的Steam登录过不止一个账户,你要把截图同步到哪一个账户里?")
        defaultIndex=1
        for userIndex in range(len(userlist)):
            if userdic[userIndex+1][0]==defultAccountName:
                print(str(userIndex+1)+". "+userdic[userIndex+1][0]+"(默认)")
                defaultIndex=userIndex+1
                defultAccountName=""
            else:
                print(str(userIndex+1)+". "+userdic[userIndex+1][0])
        selectedIndex=input()
        if selectedIndex.isnumeric()==False or (1>int(selectedIndex) or len(userlist)<=int(selectedIndex)):
            return SteamPath+"\\userdata\\"+userdic[defaultIndex][1]+"\\760\\remote"
        else:
            return SteamPath+"\\userdata\\"+userdic[int(selectedIndex)][1]+"\\760\\remote"
    def get_antidote():
        antidote_key = r"Software\Druide informatique inc.\Antidote"
        value = "DossierAntidote"
        names = ["Antidote.exe", "antido32.exe"]

        for name in names:
            latest_sub_key = None
            try:
                with winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER,
                                      antidote_key) as k:
                    try:
                        for n in itertools.count():
                            sub_key = winreg.EnumKey(k, n)
                            if sub_key[0].isdigit():
                                latest_sub_key = sub_key
                    except OSError:
                        pass
                if latest_sub_key:
                    sub_key = r"{}\{}\Installation".format(
                        antidote_key, latest_sub_key)
                    with winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER,
                                          sub_key) as k:
                        directory = winreg.QueryValueEx(k, value)[0]
                    path = os.path.join(directory, name)
                    if os.path.isfile(path):
                        return path
            except FileNotFoundError:
                pass

            try:
                return get_path_from_registry(winreg.HKEY_LOCAL_MACHINE,
                                              antidote_key, value, name)
            except FileNotFoundError:
                pass

            for env in ["PROGRAMFILES", "PROGRAMW6432"]:
                try:
                    program_files = os.environ[env]
                except KeyError:
                    continue
                for antidote_dir in [
                        r"Druide\Antidote*\Programmes*", r"Druide\Antidote*"
                ]:
                    path = os.path.join(program_files, antidote_dir, name)
                    paths = glob.glob(path)
                    if paths:
                        return sorted(paths)[-1]

        raise FileNotFoundError("can't find Antidote")
Example #15
0
def _win10RID(buildNum, isClient):
    # Special cases: Windows 10 Version 1507, Windows Server long-term servicing channel (LTSC) releases.
    if isClient and buildNum == 10240:
        return "Windows 10 1507"
    elif not isClient and buildNum in server10LTSBuilds:
        return server10LTSBuilds[buildNum]
    # For others, both CurrentVersion and WindowsSelfHost must be consulted.
    # The former is the case for ReleaseID (DisplayVersion in 20H2/2009 and later) and the latter for Insider Preview detection.
    # When it comes to the actual order, check self-host flag first.
    # Because NVDA is a 32-bit application, 64-bit view of Registry must be attempted for self-host key.
    # If IsRetailOS is present (an integer), it is an Insider Preview.
    if os.environ.get("PROCESSOR_ARCHITEW6432") in ("AMD64", "ARM64"):
        selfHostApplicability = winreg.OpenKeyEx(
            winreg.HKEY_LOCAL_MACHINE,
            r"Software\Microsoft\WindowsSelfHost\Applicability",
            access=winreg.KEY_READ | winreg.KEY_WOW64_64KEY)
    else:
        selfHostApplicability = winreg.OpenKeyEx(
            winreg.HKEY_LOCAL_MACHINE,
            r"Software\Microsoft\WindowsSelfHost\Applicability")
    try:
        isRetailOS = winreg.QueryValueEx(selfHostApplicability,
                                         "IsRetailOS")[0]
    except OSError:
        isRetailOS = 1
    winreg.CloseKey(selfHostApplicability)
    # Insider Preview builds.
    if not isRetailOS:
        return "Windows 10 Insider" if isClient else "Windows Server Insider"
    currentVersion = winreg.OpenKey(
        winreg.HKEY_LOCAL_MACHINE,
        r"Software\Microsoft\Windows NT\CurrentVersion")
    # Version 20H2/2009 and later where a separate display version string is used.
    # For backward compatibility, release ID variable will store display version string.
    try:
        releaseID = winreg.QueryValueEx(currentVersion, "DisplayVersion")[0]
    except OSError:
        releaseID = None
    # Version 1511 and later unless display version string is present.
    if not releaseID:
        try:
            releaseID = winreg.QueryValueEx(currentVersion, "ReleaseID")[0]
        except OSError:
            releaseID = "Unknown"
    winreg.CloseKey(currentVersion)
    if isClient:
        return "Windows 10 {0}".format(releaseID)
    else:
        return "Windows Server {0}".format(releaseID)
Example #16
0
    def remove_dir_from_win_path(self, remove_dir):
        import winreg
        try:
            env = None
            path = None
            env = winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER, 'Environment', 0,
                                   winreg.KEY_SET_VALUE | winreg.KEY_READ)
            path = winreg.QueryValueEx(env, 'Path')[0]

            path_lower = path.lower()
            remove_dir = remove_dir.replace('/', '\\')
            remove_dir_lower = remove_dir.lower()
            start_pos = path_lower.find(remove_dir_lower)
            if (start_pos >= 0):
                length = len(remove_dir_lower)
                need_remove = path[start_pos:(start_pos + length)]
                path = path.replace(need_remove, '')
                path = path.replace(';;', ';')
                winreg.SetValueEx(env, 'Path', 0, winreg.REG_SZ, path)
                winreg.FlushKey(env)
            winreg.CloseKey(env)

            print('  ->Remove directory \"%s\" from PATH!\n' % remove_dir)
        except Exception:
            print('  ->Remove directory \"%s\" from PATH failed!\n' %
                  remove_dir)
Example #17
0
def _get_home_dir(version):
    """
    Return the LightTools home directory.

    Get the home directory of the specified LightTools `version` from the
    Windows registry.  The requested LightTools `version` must be installed
    on the system.

    Args:
        version (str): The LightTools `version` string, e.g. "8.5.0".

    Returns:
        str: The LightTools home directory.
    """
    try:
        hkey = winreg.OpenKeyEx(
            key=winreg.HKEY_LOCAL_MACHINE,
            sub_key=(
                "SOFTWARE\\Optical Research Associates\\LightTools"
                "\\{}\\Environment"
            ).format(version),
        )
    except OSError:
        msg = (
            "Couldn't find home directory of LighTools version {!r}. Please "
            "check if the requested version of LightTools is installed."
        )
        raise ValueError(msg.format(version))
    else:
        value, __ = winreg.QueryValueEx(hkey, "LT_HOME")
        return value
Example #18
0
 def set_environ(self, server=None, port=None):
     """ str server, int port """
     if not self.__setFirst:
         self.prev_http_proxy, self.prev_https_proxy = os.environ.get(
             'HTTP_PROXY'), os.environ.get('HTTPS_PROXY')
         self.__setFirst = True
     self.unset_environ()  #いったん設定情報を削除
     if server != None and port != None:
         os.environ["HTTP_PROXY"] = "%s:%i" % (server, port)
         os.environ["HTTPS_PROXY"] = "%s:%i" % (server, port)
         return
     try:
         pac = get_pac()
         path = r"Software\Microsoft\Windows\CurrentVersion\Internet Settings"
         key = winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER, path)
         p, regtype = winreg.QueryValueEx(key, "ProxyServer")
         e, regtype = winreg.QueryValueEx(key, "ProxyEnable")
     except (WindowsError, UnicodeDecodeError):
         return
     finally:
         try:
             winreg.CloseKey(key)
         except:
             pass
     if bool(e):
         os.environ["HTTP_PROXY"] = p
         os.environ["HTTPS_PROXY"] = p
     elif pac:
         resolver = ProxyResolver(pac, proxy_auth=self.proxy_auth)
         proxies = resolver.get_proxy_for_requests(self.url)
         # Cannot set None for environ. (#27)
         os.environ['HTTP_PROXY'] = proxies.get('http') or ''
         os.environ['HTTPS_PROXY'] = proxies.get('https') or ''
Example #19
0
def _reg_read_key_table(key, num_sub_keys) -> "KeyTable":
    key_table = {}
    for i in range(num_sub_keys):
        child_key_name = winreg.EnumKey(key, i)
        with winreg.OpenKeyEx(key, child_key_name) as child_key:
            key_table[child_key_name] = _reg_read_table(child_key)
    return key_table
Example #20
0
def get_python_installations():
    """Returns a list of python executables on the machine."""
    installations = set()
    search_keys = [
        (winreg.HKEY_CURRENT_USER, r"Software\Python", 0),
        (winreg.HKEY_LOCAL_MACHINE, r"Software\Python",
         winreg.KEY_WOW64_64KEY),
        (winreg.HKEY_LOCAL_MACHINE, r"Software\Python",
         winreg.KEY_WOW64_32KEY),
    ]

    for hive, key, flags in search_keys:
        try:
            with winreg.OpenKeyEx(hive, key,
                                  access=winreg.KEY_READ | flags) as root_key:
                for company in _enum_keys(root_key):
                    with winreg.OpenKey(root_key, company) as company_key:
                        for tag in _enum_keys(company_key):
                            with winreg.OpenKey(company_key, tag) as tag_key:
                                installations.add(
                                    _create_python_installation(
                                        company, tag, tag_key))
        except FileNotFoundError:
            continue

    return installations
Example #21
0
def process_company(hive_name, company, root_key, default_arch):
    with winreg.OpenKeyEx(root_key, company) as company_key:
        for tag in enum_keys(company_key):
            spec = process_tag(hive_name, company, company_key, tag,
                               default_arch)
            if spec is not None:
                yield spec
def _find_vc2015():
    try:
        key = winreg.OpenKeyEx(
            winreg.HKEY_LOCAL_MACHINE,
            r"Software\Microsoft\VisualStudio\SxS\VC7",
            access=winreg.KEY_READ | winreg.KEY_WOW64_32KEY
        )
    except OSError:
        log.debug("Visual C++ is not registered")
        return None, None

    best_version = 0
    best_dir = None
    with key:
        for i in count():
            try:
                v, vc_dir, vt = winreg.EnumValue(key, i)
            except OSError:
                break
            if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir):
                try:
                    version = int(float(v))
                except (ValueError, TypeError):
                    continue
                if version >= 14 and version > best_version:
                    best_version, best_dir = version, vc_dir
    return best_version, best_dir
Example #23
0
 def set(self, value):
     opened_key = winreg.OpenKeyEx(self.root,
                                   self.path,
                                   access=winreg.KEY_WRITE)
     winreg.SetValueEx(opened_key, self.key_name, 0, winreg.REG_DWORD,
                       value)
     winreg.CloseKey(opened_key)
Example #24
0
def win_ver():
    """ Get Windows version info """
    csd = sys.getwindowsversion()[-1]
    # Use the registry to get product name, e.g. 'Windows 7 Ultimate'.
    # Not recommended, but we don't care.
    pname = "Windows"
    release = ""
    build = ""
    key = None
    sam = winreg.KEY_READ
    if platform.machine() == "AMD64":
        sam |= winreg.KEY_WOW64_64KEY
    try:
        key = winreg.OpenKeyEx(
            winreg.HKEY_LOCAL_MACHINE,
            r"SOFTWARE\Microsoft\Windows NT\CurrentVersion", 0, sam)
        pname = winreg.QueryValueEx(key, "ProductName")[0]
        build = "Build %s" % winreg.QueryValueEx(key, "CurrentBuildNumber")[0]
        # Since Windows 10
        release = "Version %s" % winreg.QueryValueEx(key, "ReleaseId")[0]
        build += ".%s" % winreg.QueryValueEx(key, "UBR")[0]
    except Exception as e:
        pass
    finally:
        if key:
            winreg.CloseKey(key)
    return pname, csd, release, build
Example #25
0
 def query(self):
     opened_key = winreg.OpenKeyEx(self.root,
                                   self.path,
                                   access=winreg.KEY_READ)
     values = winreg.QueryValueEx(opened_key, self.key_name)
     winreg.CloseKey(opened_key)
     return values
Example #26
0
def check_odbc_entry_windows(server_name, reset=False,
                             arch_keys = {'KEY_WOW64_32KEY', 'KEY_WOW64_64KEY'}):
    """checks whether the server is registered in the system,
    and if not launches ODBC management program"""
    arch_keys = [getattr(winreg, kk) for kk in arch_keys]
    if not reset:
        for arch_key in arch_keys:
            try:
                key = winreg.OpenKeyEx(winreg.HKEY_CURRENT_USER,
                         r"Software\ODBC\ODBC.INI", 0, 
                         winreg.KEY_READ | arch_key)
                #skey = winreg.OpenKey(key, skey_name)
                n_subkeys, n_entries, _ = winreg.QueryInfoKey(key)
                
                for n in range(n_subkeys):
                    subkey = winreg.OpenKey(key, winreg.EnumKey(key, n))
                    n_subsubkeys, n_subentries, _ = winreg.QueryInfoKey(subkey)
                    keydict = (_get_leafs(subkey, n_subentries))
                    logging.debug("winreg entry: " + str(keydict))
                    if "Server" in keydict and (keydict["Server"]==server_name):
                        logging.debug("found a 'Server' entry: " + keydict["Server"])
                        return None
                # value = winreg.QueryValue(key, skey_name)
            except (FileNotFoundError, WindowsError):
                pass
    os.system('c:\\Windows\\SysWOW64\\odbcad32.exe')    
    return None
Example #27
0
def get_config_info_from_registry(key_name: str) -> str:
    hive, key, flags = (winreg.HKEY_LOCAL_MACHINE, r'Software\Natlink',
                        winreg.KEY_WOW64_32KEY)
    with winreg.OpenKeyEx(hive, key,
                          access=winreg.KEY_READ | flags) as natlink_key:
        result, _ = winreg.QueryValueEx(natlink_key, key_name)
        return result
Example #28
0
def _find_vcvarsall():
    with winreg.OpenKeyEx(winreg.HKEY_LOCAL_MACHINE,
                          r"Software\Microsoft\VisualStudio\SxS\VC7",
                          access=winreg.KEY_READ
                          | winreg.KEY_WOW64_32KEY) as key:
        if not key:
            log.debug("Visual C++ is not registered")
            return None

        best_version = 0
        best_dir = None
        for i in count():
            try:
                v, vc_dir, vt = winreg.EnumValue(key, i)
            except OSError:
                break
            if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir):
                try:
                    version = int(float(v))
                except (ValueError, TypeError):
                    continue
                if version >= 14 and version > best_version:
                    best_version, best_dir = version, vc_dir
        if not best_version:
            log.debug("No suitable Visual C++ version found")
            return None

        vcvarsall = os.path.join(best_dir, "vcvarsall.bat")
        if not os.path.isfile(vcvarsall):
            log.debug("%s cannot be found", vcvarsall)
            return None

        return vcvarsall
Example #29
0
def get_apps_sid():
    sid_list = []
    with wr.OpenKeyEx(wr.HKEY_CURRENT_USER, BASE_PATH) as key:
        max_index = wr.QueryInfoKey(key)[0]
        for i in range(max_index):
            sid_list.append(wr.EnumKey(key, i))
    return sid_list
Example #30
0
        def _save(self):
            """
            Save '_paths' System Path value into registry.

            Params:
                None

            Returns:
                None

            Raises:
                EnvironmentError if the user is not an "admin" or the admin check fails
                WindowsError if an error occurred when try to edit System Path value
            """
            # Admin check
            is_admin = False
            try:
                is_admin = ctypes.windll.shell32.IsUserAnAdmin()
            except Exception:
                raise EnvironmentError(
                    'Windows OS detected, but admin check failed')
            if not is_admin:
                raise EnvironmentError(
                    'Edit System Path value requires "Admin" privileges')

            # Write on System Path
            value = os.pathsep.join(self._paths) + os.pathsep
            with winreg.OpenKeyEx(self._root_key, self._sub_key, 0,
                                  winreg.KEY_WRITE) as key:
                winreg.SetValueEx(key, self._value_name, 0,
                                  winreg.REG_EXPAND_SZ, value)
                winreg.FlushKey(key)