windows-tools-powershell 0.5.0__py3-none-any.whl

windows_tools/powershell/__init__.py

@@ -0,0 +1,328 @@
+#! /usr/bin/env python
+#  -*- coding: utf-8 -*-
+#
+# This file is part of windows_tools module
+
+"""
+PowerShellRunner is a class that allows to run powershell scripts / commands without hassle
+Also allows auto script elevation
+
+Versioning semantics:
+    Major version: backward compatibility breaking changes
+    Minor version: New functionality
+    Patch version: Backwards compatible bug fixes
+
+"""
+
+__intname__ = "windows_tools.powershell"
+__author__ = "Orsiris de Jong"
+__copyright__ = "Copyright (C) 2019-2026 Orsiris de Jong"
+__description__ = "PowerShell interpreter wrapper"
+__licence__ = "BSD 3 Clause"
+__version__ = "0.5.0"
+__build__ = "2026032001"
+
+import os
+from logging import getLogger
+import tempfile
+
+from command_runner import command_runner
+from ofunctions.json_sanitize import json_sanitize
+from ofunctions.random import random_string
+import windows_tools.registry
+
+logger = getLogger()
+
+
+_POWERSHELL_ELEVATOR_SCRIPT = r"""
+# Run elevated commands and get stdout/stderr and (partial) exitcode
+
+try {
+    # Function blatantly stolen from https://stackoverflow.com/a/15669365/2635443
+    function Write-StdErr {
+        param ([PSObject] $InputObject)
+        $outFunc = if ($Host.Name -eq 'ConsoleHost') {
+            [Console]::Error.WriteLine
+        } else {
+        $host.ui.WriteErrorLine
+        }
+        if ($InputObject) {
+            [void] $outFunc.Invoke($InputObject.ToString())
+        } else {
+            [string[]] $lines = @()
+            $Input | % { $lines += $_.ToString() }
+            [void] $outFunc.Invoke($lines -join "`r`n")
+        }
+    }
+
+    # Parts blatanly stolen from https://stackoverflow.com/a/60216595/2635443
+
+    # Get the ID and security principal of the current user account
+    $myWindowsID=[System.Security.Principal.WindowsIdentity]::GetCurrent()
+    $myWindowsPrincipal=new-object System.Security.Principal.WindowsPrincipal($myWindowsID)
+
+    # Get the security principal for the Administrator role
+    $adminRole=[System.Security.Principal.WindowsBuiltInRole]::Administrator
+
+    # Check to see if we are currently running "as Administrator"
+    if ($myWindowsPrincipal.IsInRole($adminRole))
+        {
+            #Update window to show we're running as administrator
+            $Host.UI.RawUI.WindowTitle = $myInvocation.MyCommand.Definition + "(Elevated)"
+            $Host.UI.RawUI.BackgroundColor = "DarkBlue"
+            clear-host
+            $Host.UI.Write("Running elevated NPBackup task processing")
+        } else {
+            $capture_stdout = New-TemporaryFile
+            $capture_stderr = New-TemporaryFile
+            # Relaunch our processs as admin
+            # This will disconnect fds, so we need to redirect stdout and stderr in order to catch them
+            $processParams = new-object System.Diagnostics.ProcessStartInfo "PowerShell";
+
+            # Specify the current script path and name as a parameter
+            $processParams.Arguments = $myInvocation.MyCommand.Definition;
+            $processParams.Arguments += " > $capture_stdout 2> $capture_stderr"
+
+            # Indicate that the process should be elevated
+            $processParams.Verb = "RunAs"
+            # We might hide our window, or leave this commented out so options above apply
+            $processParams.WindowStyle = "Hidden"
+
+            # Start the new process
+            try {
+                $process = [System.Diagnostics.Process]::Start($processParams)
+                While (-not $process.HasExited) {
+                    Start-Sleep -Milliseconds 100
+                }
+                # Arbitrary wait time for fds to close
+                Start-Sleep -Milliseconds 500
+                Write-Host (Get-Content -Path $capture_stdout)
+                Write-StdErr (Get-Content -Path $capture_stderr)
+                # This will only return 0 or 1, other integers are transformed into 1
+                exit($process.ExitCode)
+            } catch {
+                Write-output "Process cannot be launched as admin. Trying as standard user"
+            }
+           
+        }
+
+    # The following code will run elevated
+    ___CODE_PLACEHOLDER___
+} catch {
+    Write-Host "PS Error: $($_.Exception.Message)"*
+    exit(1)
+}
+"""
+
+
+class PowerShellRunner:
+    """
+    Identify powershell interpreter and allow running scripts / commands with ExecutionPolicy ByPass
+    """
+
+    def __init__(self, powershell_interpreter=None):
+        self.powershell_interpreter = powershell_interpreter
+
+        if powershell_interpreter is not None and os.path.isfile(
+            powershell_interpreter
+        ):
+            return
+
+        # Try to guess powershell path if no valid path given
+        interpreter_executable = "powershell.exe"
+        for syspath in ["sysnative", "system32"]:
+            try:
+                # Let's try native powershell (64 bit) first or else
+                # Import-Module may fail when running 32 bit powershell on 64 bit arch
+                best_guess = os.path.join(
+                    os.environ.get("SYSTEMROOT", "C:"),
+                    syspath,
+                    "WindowsPowerShell",
+                    "v1.0",
+                    interpreter_executable,
+                )
+                if os.path.isfile(best_guess):
+                    self.powershell_interpreter = best_guess
+                    break
+            except KeyError:
+                pass
+        if self.powershell_interpreter is None:
+            try:
+                ps_paths = os.path.dirname(os.environ["PSModulePath"]).split(";")
+                for ps_path in ps_paths:
+                    if ps_path.endswith("Modules"):
+                        ps_path = ps_path.strip("Modules")
+                    possible_ps_path = os.path.join(ps_path, interpreter_executable)
+                    if os.path.isfile(possible_ps_path):
+                        self.powershell_interpreter = possible_ps_path
+                        break
+            except KeyError:
+                pass
+
+        if self.powershell_interpreter is None:
+            raise OSError("Could not find any valid powershell interpreter")
+
+        self.major_version = None
+        self.minor_version = None
+        self.major_version, self.minor_version = self.get_version()
+
+    def get_version(self):
+        """
+        Get major / minor version as tuple
+
+        """
+        if self.powershell_interpreter is None:
+            return 0, 0
+
+        try:
+            exit_code, output = self.run_command("$PSVersionTable.PSVersion.ToString()")
+            if exit_code != 0:
+                # If the above method does not work, let's try registry method
+                try:
+                    output = windows_tools.registry.get_value(
+                        hive=windows_tools.registry.HKEY_LOCAL_MACHINE,
+                        key=r"SOFTWARE\Microsoft\PowerShell\3\PowerShellEngine",
+                        value="PowerShellVersion",
+                    )
+                except FileNotFoundError:
+                    output = "-1.-1"
+            try:
+                # output = major_version.minor_version.build.revision for newer powershells
+                major_version, minor_version, _, _ = output.split(".")
+            except (ValueError, TypeError):
+                # output = major_version.minor_version for some powershells (v3.0)
+                major_version, minor_version = output.split(".")
+            return int(major_version), int(minor_version)
+        except (ValueError, TypeError):
+            return -1, 0
+
+    def run_command(
+        self,
+        command,
+        timeout=None,
+        valid_exit_codes=[0],
+        encoding=None,
+        force_utf8=True,
+        to_json=False,
+        json_depth=2,
+        sanitize_json=True,
+        **kwargs,
+    ):
+        """
+        Accepts subprocess.check_output arguments
+        Accepts command_runner arguments like timeout, encoding and valid_exit_codes
+
+        """
+        if self.powershell_interpreter is None:
+            return False
+
+        # So older powershell versions used unicode_escape, newer ones are utf-8
+        # AFAIK, the change happened between powershell 4 and 5
+        if not encoding and self.major_version is not None:
+            if self.major_version >= 5:
+                encoding = "utf-8"
+            else:
+                encoding = "unicode_escape"
+
+        utf8_prefix = ""
+        if force_utf8:
+            utf8_prefix = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; "
+        to_json_suffix = ""
+        if to_json:
+            to_json_suffix = "| ConvertTo-Json -Depth {}".format(json_depth)
+
+        # Do not add -NoProfile so we don't end up in a path we're not supposed to
+        command = (
+            self.powershell_interpreter
+            + " -NonInteractive -NoLogo {}{}{}".format(
+                utf8_prefix, command, to_json_suffix
+            )
+        )
+        logger.debug("Running powershell command:\n%s", command)
+
+        exit_code, output = command_runner(
+            command,
+            timeout=timeout,
+            valid_exit_codes=valid_exit_codes,
+            encoding=encoding,
+            **kwargs,
+        )
+        if sanitize_json:
+            return exit_code, json_sanitize(output)
+        return exit_code, output
+
+    def run_script(
+        self,
+        script,
+        *args,
+        timeout=None,
+        valid_exit_codes=[0],
+        encoding=None,
+        elevated=False,
+        **kwargs,
+    ):
+        """
+        Accepts subprocess.check_output arguments
+        """
+
+        if self.powershell_interpreter is None:
+            return False
+
+        if not encoding and self.major_version is not None:
+            if self.major_version >= 5:
+                encoding = "utf-8"
+            else:
+                encoding = "unicode_escape"
+
+        if elevated:
+            try:
+                # We need to prepare a temporary script that will be injected into the elevator script
+                if script.endswith(".ps1") and os.path.isfile(script):
+                    with open(script, "r", encoding=encoding) as fp:
+                        script_content = fp.read()
+                    powershell_elevator_script = _POWERSHELL_ELEVATOR_SCRIPT.replace(
+                        "___CODE_PLACEHOLDER___", script_content
+                    )
+                else:
+                    # Assume we are given an inline script instead of a file
+                    powershell_elevator_script = _POWERSHELL_ELEVATOR_SCRIPT.replace(
+                        "___CODE_PLACEHOLDER___", script
+                    )
+
+                # Write a temporary elevator script with the content of the given script
+                powershell_elevator_temp_script = os.path.join(
+                    tempfile.gettempdir(), f"{__intname__}_{random_string(8)}.ps1"
+                )
+                with open(
+                    powershell_elevator_temp_script, "w", encoding=encoding
+                ) as fp:
+                    fp.write(powershell_elevator_script)
+                script = powershell_elevator_temp_script
+            except OSError as exc:
+                logger.error("Could not prepare powershell elevator: {}".format(exc))
+                return 1, "Could not prepare powershell elevator: {}".format(exc)
+
+        # Welcome in Powershell hell where running a script with -Command argument returns exit
+        # codes 0 or 1 whereas as running with -File argument returns your script exit code
+        command = (
+            self.powershell_interpreter
+            + " -executionPolicy Bypass -NonInteractive -NoLogo -NoProfile -File "
+            + script
+            + (" " if len(args) > 0 else " ")
+            + " ".join('"' + arg + '"' for arg in args)
+        )
+        logger.debug("Running powershell command:\n%s", command)
+        exit_code, output = command_runner(
+            command,
+            timeout=timeout,
+            valid_exit_codes=valid_exit_codes,
+            encoding=encoding,
+            **kwargs,
+        )
+        try:
+            os.remove(powershell_elevator_temp_script)
+        except Exception as exc:
+            logger.debug(
+                "Could not remove temporary powershell elevator script: {}".format(exc)
+            )
+        return exit_code, output

windows_tools_powershell-0.5.0-py3.12-nspkg.pth

@@ -0,0 +1 @@
+import sys, types, os;p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('windows_tools',));importlib = __import__('importlib.util');__import__('importlib.machinery');m = sys.modules.setdefault('windows_tools', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('windows_tools', [os.path.dirname(p)])));m = m or sys.modules.setdefault('windows_tools', types.ModuleType('windows_tools'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p)

windows_tools_powershell-0.5.0.dist-info/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019-2024, netinvent, Orsiris de Jong, contact@netinvent.fr
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

windows_tools_powershell-0.5.0.dist-info/METADATA

@@ -0,0 +1,300 @@
+Metadata-Version: 2.1
+Name: windows_tools_powershell
+Version: 0.5.0
+Summary: PowerShell interpreter wrapper
+Home-page: https://github.com/netinvent/windows_tools
+Author: NetInvent - Orsiris de Jong
+Author-email: contact@netinvent.fr
+Keywords: wmi,virtualization,file,acl,ntfs,refs,antivirus,security,firewall,office
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development
+Classifier: Topic :: System
+Classifier: Topic :: System :: Operating System
+Classifier: Topic :: System :: Shells
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Operating System :: Microsoft
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: License :: OSI Approved :: BSD License
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: command-runner >=1.2.1
+Requires-Dist: windows-tools.registry >=1.0.1
+Requires-Dist: ofunctions.json-sanitize >0.1.1
+
+# windows_tools
+## Collection of useful python functions around Microsoft Windows
+
+[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![Percentage of issues still open](http://isitmaintained.com/badge/open/netinvent/windows_tools.svg)](http://isitmaintained.com/project/netinvent/ofunctions "Percentage of issues still open")
+[![Maintainability](https://api.codeclimate.com/v1/badges/0d9732260019ec390649/maintainability)](https://codeclimate.com/github/netinvent/windows_tools/maintainability)
+[![codecov](https://codecov.io/gh/netinvent/windows_tools/branch/master/graph/badge.svg?token=6Z03XTQU8G)](https://codecov.io/gh/netinvent/windows_tools)
+[![windows-tests](https://github.com/netinvent/windows_tools/actions/workflows/windows.yaml/badge.svg)](https://github.com/netinvent/windows_tools/actions/workflows/windows.yaml)
+[![GitHub Release](https://img.shields.io/github/release/netinvent/windows_tools.svg?label=Latest)](https://github.com/netinvent/windows_tools/releases/latest)
+
+
+windows_tools is a set of various recurrent functions amongst
+
+- antivirus: antivirus state and list of installed AV engines
+- bitlocker: drive encryption status and protector key retrieval
+- bitness: simple bitness identification
+- file_utils: file ownership handling, NTFS & ReFS ACL handling, file listing with permission fixes
+- impersonate: python Runas implementation
+- installed_software: list of installed software from registry, 32 and 64 bits
+- logical_disk: logical disk listing
+- misc: basic time related functions to convert windows ticks into epoch / date strings
+- office: microsoft Office version identification, works for click & run, O365 and legacy
+- powershell: powershell wrapper to identify interpreter and run scripts or commands
+- product_key: windows product key retrieval
+- registry: registry 32 and 64 bit API
+- securityprivilege: enable / disable various security privileges for user
+- server: windows server identification
+- signtool: Easily sign executables with Authenticode
+- updates: get all installed windows updates based on COM, WMI and registry retrieval methods
+- users: user lookup for SID/PySID/username
+- virtualization: virtualization platform identification for guest
+- windows_firewall: windows firewall state retrieval
+- wmi_queries: windows WMI query wrapper, wmi timezone converters
+
+It is compatible with Python 3.5+ and is tested on Windows only (obviously).
+
+## Setup
+
+You may install the whole `windows_tools` package or any subpackage using the following commands
+```
+pip install windows_tools
+pip install windows_tools.<subpackage>
+
+```
+
+## Usage
+
+### antivirus
+
+The antivirus package tries to list installed Antivirus products via the SecurityCenter API (using WMI calls).
+Since SecurityCenter API does not exist on Windows Servers, we also need to check for installed antivirus software using the uninstall registry keys.
+These checks are more fuzzy, but allow to detect the following products:
+
+- avast
+- avira
+- avg technologies
+- bitdefender
+- dr web
+- eset
+- f-secure
+- g data software
+- kaspersky
+- mcafee
+- panda security
+- sophos
+- trend micro
+- malwarebytes
+- vipre
+- sentinel one
+- cybereason
+- cylance
+
+On top of that list, it will detect any installed software containing "antivirus/antiviral/antimalware" in the name.
+
+Please report back if your antivirus is not detected, so we can improve the fuzzy detection here.
+
+Usage
+```
+import windows_tools.antivirus
+
+result = windows_tools.antivirus.get_installed_antivirus_software()
+```
+
+`result` will contain a list of dict like
+
+```
+[{
+        'name': 'Windows Defender',
+        'version': None,
+        'publisher': None,
+        'enabled': False,
+        'is_up_to_date': True,
+        'type': 'Windows Defender / Security Essentials'
+    }, {
+        'name': 'Malwarebytes version 4.4.6.132',
+        'version': '4.4.6.132',
+        'publisher': 'Malwarebytes',
+        'enabled': None,
+        'is_up_to_date': None,
+        'type': None
+    }
+]
+```
+
+**Warning**
+Keys `enabled`, `is_up_to_date` and `type` are only filled via securityCenter API*.
+Keys `version` and `publisher` are only filled via installed software list.
+The only guaranteed filled key will always be `name`
+
+### bitlocker
+
+Bitlocker can only work on NTFS or ReFS formatted disks.
+Bitlocker keys can only be retrieved on local disks.
+
+#### Usage
+
+```
+import windows_tools.bitlocker
+
+result = windows_tools.bitlocker.get_bitlocker_full_status()
+```
+
+`result` will contain a dict as follows containing raw strings from `manage-bde` windows tool:
+
+```
+{
+	'C:': {
+		'status': 'Chiffrement de lecteur BitLocker\xa0: outil de configuration version 10.0.19041\nCopyright (C) 2013 Microsoft Corporation. Tous droits réservés.\n\nVolume C: [Windows ]\n[Volume du système d?exploitation]\n\n    Taille :                     855,14 Go\n    Version de BitLocker :       Aucun\n    État de la conversion :      Intégralement déchiffré\n    Pourcentage chiffré :        0,0%\n    Méthode de chiffrement :     Aucun\n    État de la protection\xa0:      Protection désactivée\n    État du verrouillage :       Déverrouillé\n    Champ d?identification :     Aucun\n    Protecteurs de clés :        Aucun trouvé\n\n', 
+		'protectors': None
+	},
+	'D:': {
+		'status': 'Chiffrement de lecteur BitLocker\xa0: outil de configuration version 10.0.19041\nCopyright (C) 2013 Microsoft Corporation. Tous droits réservés.\n\nVolume D: [Étiquette inconnue]\n[Volume de données]\n\n    Taille :                     Inconnu Go\n    Version de BitLocker :       2.0\n    État de la conversion :      Inconnu\n    Pourcentage chiffré :        Inconnu%\n    Méthode de chiffrement :     XTS-AES 128\n    État de la protection\xa0:      Inconnu\n    État du verrouillage :       Verrouillé\n    Champ d?identification :     Inconnu\n    Déverrouillage automatique : Désactivé\n    Protecteurs de clés\xa0:\n        Password\n        Mot de passe numérique\n\n',
+		'protectors': 'Chiffrement de lecteur BitLocker\xa0: outil de configuration version 10.0.19041\nCopyright (C) 2013 Microsoft Corporation. Tous droits réservés.\n\nVolume D: [Étiquette inconnue]\nTous les protecteurs de clés\n\n    Password :\n      ID : {SOMEPASS-WORD-ICAN-NNOT-REMEMBERWELL}\n\n    Mot de passe numérique :\n      ID : {SOMEPASS-GUID-ICAN-NNOT-REMEMBERWELL}\n\n'
+	}
+}
+```
+
+You may parse those or simply pretty print since print will not interpret special characters from a dict or multiple variables at once:
+
+```
+result = windows_tools.bitlocker.get_bitlocker_full_status()
+
+
+result = get_bitlocker_full_status()
+for drive in result:
+    for designation, content in result[drive].items():
+        print(designation, content)
+
+```
+
+**Warning** bitlocker needs to be run as admin.
+Running as non administrator will produce the following logs
+
+```
+Don't have permission to get bitlocker drive status for C:.
+Don't have permission to get bitlocker drive protectors for C:.
+Don't have permission to get bitlocker drive status for D:.
+Don't have permission to get bitlocker drive protectors for D:.
+```
+
+Output shall be
+```
+{
+    'C:': {
+        'status': None,
+        'protectors': None
+    },
+    'D:': {
+        'status': None,
+        'protectors': None
+    }
+}
+```
+
+You can check that you have administrator rights with `windows_utils.users` module
+
+
+### bitness
+
+### file_utils
+
+### impersonate
+
+### installed_software
+
+### logical_disk
+
+### misc
+
+### office
+
+### powershell
+
+### product_key
+
+### registry
+
+### securityprivilege
+
+### server
+
+### signtool
+
+signtool is designed to make the windows executable signature as simple as possible.  
+Once the Windows SDK is installed on your machine, you can sign any executable with the following commands:
+
+```
+from windows_tools.signtool import SignTool
+signer = SignTool()
+signer.sign(r"c:\path\to\executable", bitness=64)
+```
+
+Note that current versions of `signtool.exe` that come with Windows 10 SDK automagically detect hardware EV certificate tokens like Safenet.
+
+When using former certificate files in order to sign an executable, one should use the following syntax:
+
+```
+from windows_tools.signtool import SignTool
+signer = SignTool(certificate=r"c:\path\to\cert.pfx", pkcs12_password="the_certificate_file_password")
+signer.sign(r"c:\path\to\executable", bitness=64)
+```
+
+If the wrong certificate is used to sign, please open `certmgr.msc`, go to Private > Certificates and remove the certificate you don't want.
+
+
+### updates
+
+Windows updates can be retrieved via a COM object that talks to Windows Update service, via WMI requests or via registry entries.
+All methods can return different results, so they are combined into one function.
+
+Usage
+```
+import windows_tools.updates
+
+result = windows_tools.updates.get_windows_updates(filter_duplicates=True, include_all_states=False)
+```
+
+`result` will contain a list of dict like
+
+```
+[{
+        'kb': 'KB123456',
+        'date': '2021-01-01 00:01:02',
+        'title': 'Some update title',
+        'description': 'Some update description',
+        'supporturl': 'https://support.microsoft.com/someID',
+        'operation': 'Installation'
+        'result': 'Installed'
+    }, {
+        'kb': None,
+        'date': '2021-01-01 00:01:02',
+        'title': 'Windows 10 20H1 update',
+        'description': 'Pretty big system update',
+        'supporturl': 'https://support.microsoft.com/someID',
+        'operation': 'Installation'
+        'result': 'Installed'
+    }
+]
+```
+
+Using `filter_duplicates` will avoid returning multiple times the same KB from different sources.
+This setting is enabled by default.
+
+The parameter `include_all_states` set to True will include all updates, even those who failed to install or are superseeded.
+
+### users
+
+### virtualization
+
+### windows_firewall
+
+### wmi_queries

windows_tools_powershell-0.5.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+windows_tools_powershell-0.5.0-py3.12-nspkg.pth,sha256=E9edsbJlPNsIwiHCaIkjTRDYgRikSM9HyFO_vVIGoYQ,503
+windows_tools/powershell/__init__.py,sha256=GV4dAkKj7f7Das9u7x75dV0yAIXQ4icEEzTf1m3Ei9w,12566
+windows_tools_powershell-0.5.0.dist-info/LICENSE,sha256=f0RzkBgdSPGnJwMnaqiHvlwV33AyQFKonbWVUXdOXEg,1590
+windows_tools_powershell-0.5.0.dist-info/METADATA,sha256=dH_927esTWhHI3I2C5dwGZY7221EIh4Kv8ePEFq5XpM,11310
+windows_tools_powershell-0.5.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+windows_tools_powershell-0.5.0.dist-info/namespace_packages.txt,sha256=UuWyvD5IaqqN0pyVLoOeAkChn8_q1b2qrZdS5pBMU0k,14
+windows_tools_powershell-0.5.0.dist-info/top_level.txt,sha256=UuWyvD5IaqqN0pyVLoOeAkChn8_q1b2qrZdS5pBMU0k,14
+windows_tools_powershell-0.5.0.dist-info/RECORD,,

windows_tools_powershell-0.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

windows_tools_powershell-0.5.0.dist-info/namespace_packages.txt

@@ -0,0 +1 @@
+windows_tools

windows_tools_powershell-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+windows_tools