2Shirt/WizardKit
2Shirt/WizardKit
1
0
Fork 0
Code Issues 2 Pull requests Projects Releases 26 Packages Wiki Activity Actions

Merge remote-tracking branch 'upstream/dev' into dev

Browse source
This commit is contained in:
2Shirt 2021-10-14 17:23:10 -06:00
commit 9cd39c5691
Signed by: 2Shirt
GPG key ID: 152FAC923B0E132C
150 changed files with 1875 additions and 16680 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

174
README.md
View file

@ -1,135 +1,39 @@
# Wizard Kit #
A collection of scripts to help technicians service Windows systems.
## Main Kit ##
### Build Requirements ###
* PowerShell 3.0 or newer<sup>1</sup>
* 10 Gb disk space
### Initial Setup ###
* Replace artwork as desired
* Run `Build Kit.cmd` which will do the following:
* Download 7-Zip, ConEmu, Notepad++, and Python (including wheel packages)
* Open `main.py` in Notepad++ for configuration
* Update the rest of the tools with the `.bin\Scripts\update_kit.py` script
### Layout ###
* Root
* Main script launchers:
* `.bin`
* Extracted programs: As compressed tools are run they will be extracted here.
* `Scripts`
* "Real" scripts live here and are run via their respective launchers.
* `.cbin`
* This folder holds the compressed and encrypted tool archives.
* They are extracted at runtime as needed.
* `Data Recovery`
* This folder is not copied by `Copy WizardKit.cmd` to help discourage
* recovering data to the same drive.
* `Data Transfers`
* `Diagnostics`
* `Drivers`
* `Installers`
* `Misc`
* `Repairs`
* `Uninstallers`
## Live Linux ##
### Build Requirements ###
* Arch Linux
* 6 Gb disk space
### Initial Setup ###
* Replace artwork as desired
* Install Arch Linux in a virtual machine ([VirtualBox](https://www.virtualbox.org/) is a good option for Windows systems).
* See the [installation guide](https://wiki.archlinux.org/index.php/Installation_guide) for details.
* Add a standard user to the Arch Linux installation.
* See the [wiki page](https://wiki.archlinux.org/index.php/Users_and_groups#User_management) for details.
* Install git # `pacman -Syu git`
* _(Recommended)_ Install and configure `sudo`
* See the [wiki page](https://wiki.archlinux.org/index.php/Sudo) for details.
* Login to the user added above
* Download the Github repo $ `git clone https://1201north.ddns.net:3000/2Shirt/WizardKit.git`
* Run the build script
* $ `cd WizardKit`
* $ `./Build\ Linux -b`
* The build script does the following:
* Installs missing dependencies via `pacman`
* Opens `main.py` in `nano` for configuration
* Downloads, builds, and adds AUR packages to a local repo
* Builds the Live Linux ISO
### Notes ###
* The WinPE boot options require files to be copied from a completed WinPE build.
* This is done below for the Combined UFD
## Windows PE ##
### Build Requirements ###
* Windows Assessment and Deployment Kit for Windows 10
* Deployment Tools
* Windows Preinstallation Environment (Windows PE)
* _All other features are not required_
* PowerShell 3.0 or newer
* 8 Gb disk space
### Initial Setup ###
* Replace artwork as desired
* Run `Build PE.cmd` which will do the following:
* Load the WADK environment
* Open `main.py` in notepad for configuration
* Download all tools
* Build both 32-bit & 64-bit PE images (exported as ISO files)
## Combined Wizard Kit ##
### Build Requirements ###
* 64-bit system or virtual machine
* 4 Gb RAM
* 8 Gb USB flash drive _(16 Gb or larger recommended)_
### Overview ###
There's a `build-ufd` script which does the following:
* Checks for the presence if the Linux ISO and the (64-bit) WinPE ISO.
* Formats the selected UFD using FAT32.
* All data will be deleted from the UFD resulting in **DATA LOSS**.
* Copies the required files from the Linux ISO, WinPE ISO, and Main Kit folder to the UFD.
* Installs Syslinux to the UFD making it bootable on legacy systems.
* Sets the boot files/folders to be hidden under Windows.
### Setup ###
* Boot to a Live Linux ISO built following the instructions above.
* You can apply it to a UFD using [rufus](https://rufus.akeo.ie/) for physical systems.
* Virtual machines should be able to use the Linux ISO directly.
* Mount the device(s) or network share(s) that contain the Linux ISO, WinPE ISO, and Main Kit folder.
* Connect the UFD but don't mount it.
* Get the device name of the UFD.
* You can use $ `hw-drive-info` to help.
* $ `sudo build-ufd --ufd-device [device] --linux-iso [path] --main-kit [path] --winpe-iso [path]`
* **2nd Warning**: All data will be erased from the UFD resulting in **DATA LOSS**.
* NOTE: The Main Kit folder will be renamed on the UFD using `$KIT_NAME_FULL`
* `$KIT_NAME_FULL` defaults to "Wizard Kit" but can be changed in `main.py`
* You can include extra items by using the `--extra-dir` option
* _(e.g. $ `sudo build-ufd --ufd-device [device] --linux-iso [path] --main-kit [path] --winpe-iso [path] --extra-dir [path]`)_
* To include images for the WinPE Setup section, put the files in "Extras/images".
* WinPE Setup will recognize ESD, WIM, and SWM<sup>2</sup> images.
* The filenames should be "Win7", "Win8", or "Win10"
## Notes ##
1. PowerShell 6.0 on Windows 7 is not supported by the build script.
2. See [wimlib-imagex](https://wimlib.net/) for details about split WIM images.
# WizardKit #
A collection of scripts to help technicians service computers.
## Overview ##
There are a few main parts to this project and their uses:
* Live Linux image
* Hardware diagnostics
* CPU stress tests with temperature monitoring
* Health checks/tests for storage drives
* Misc other diagnostics
* Data recovery
* General data transfers from many possible filesystems
* Bit-level drive duplication based on ddrescue
* Live macOS image
* Hardware diagnostics
* CPU stress tests with temperature monitoring
* Health checks/tests for storage drives
* Data recovery
* _(Currently under development)_
* Live WinPE image
* _(Currently under development)_
* Windows Kit _(intended for UFDs)_
* Automated repairs
* AV scans
* Windows health checks
* Automated setup
* Install software
* System configuration
## Combined UFD ##
All parts can be combined onto a single UFD!
* Compatible with most legacy and UEFI bootloaders
* Custom boot menus
* To get started run `build-ufd` under the live Linux image

0
docs/TODO
View file

152
scripts/Copy WizardKit.cmd
View file

@ -1,152 +0,0 @@
:: Wizard Kit: Copy Kit ::
@echo off
:Init
setlocal EnableDelayedExpansion
title Wizard Kit: Tools Copier
color 1b
echo Initializing...
call :CheckFlags %*
call :FindBin
call :SetTitle Tools Copier
:SetVariables
rem Set variables using settings\main.py file
set "SETTINGS=%bin%\Scripts\settings\main.py"
for %%v in (ARCHIVE_PASSWORD KIT_NAME_FULL) do (
set "var=%%v"
for /f "tokens=* usebackq" %%f in (`findstr "!var!=" "%SETTINGS%"`) do (
set "_v=%%f"
set "_v=!_v:*'=!"
set "%%v=!_v:~0,-1!"
)
)
rem Set ARCH to 32 as a gross assumption and check for x86_64 status
set ARCH=32
if /i "%PROCESSOR_ARCHITECTURE%" == "AMD64" set "ARCH=64"
set "SEVEN_ZIP=%bin%\7-Zip\7za.exe"
set "CON=%bin%\ConEmu\ConEmu.exe"
set "FASTCOPY=%bin%\FastCopy\FastCopy.exe"
if %ARCH% equ 64 (
set "SEVEN_ZIP=%bin%\7-Zip\7za64.exe"
set "CON=%bin%\ConEmu\ConEmu64.exe"
set "FASTCOPY=%bin%\FastCopy\FastCopy64.exe"
)
set "fastcopy_args=/cmd=diff /no_ui /auto_close"
rem Set %client_dir%
call "%bin%\Scripts\init_client_dir.cmd"
pushd "%bin%\.."
set "source=%cd%"
popd
set "dest=%client_dir%\Tools"
:RelaunchInConEmu
if not defined IN_CONEMU (
if not defined L_NCMD (
set "con_args=-new_console:n"
rem If in DEBUG state then force ConEmu to stay open
if defined DEBUG (set "con_args=!con_args! -new_console:c")
set IN_CONEMU=True
start "" "%CON%" -run ""%~0" %*" !con_args! || goto ErrorUnknown
exit /b 0
)
)
:CopyBin
echo Copying .bin...
mkdir "%dest%\.bin" >nul 2>&1
attrib +h "%dest%\.bin"
set _sources="%bin%\7-Zip"
set _sources=%_sources% "%bin%\ConEmu"
set _sources=%_sources% "%bin%\FastCopy"
set _sources=%_sources% "%bin%\HWiNFO"
set _sources=%_sources% "%bin%\Python"
set _sources=%_sources% "%bin%\Scripts"
start "" /wait "%fastcopy%" %fastcopy_args% %_sources% /to="%dest%\.bin\"
:CopyCBin
echo Copying .cbin...
mkdir "%dest%\.cbin" >nul 2>&1
attrib +h "%dest%\.cbin"
start "" /wait "%fastcopy%" %fastcopy_args% "%cbin%"\* /to="%dest%\.cbin\"
:CopyMainData
echo Copying Main Kit...
set _sources="%source%\Data Transfers"
set _sources=%_sources% "%source%\Diagnostics"
set _sources=%_sources% "%source%\Drivers"
set _sources=%_sources% "%source%\Installers"
set _sources=%_sources% "%source%\Misc"
set _sources=%_sources% "%source%\Repairs"
set _sources=%_sources% "%source%\Uninstallers"
set _sources=%_sources% "%source%\Activate Windows.cmd"
set _sources=%_sources% "%source%\Enter SafeMode.cmd"
set _sources=%_sources% "%source%\Exit SafeMode.cmd"
set _sources=%_sources% "%source%\LICENSE.txt"
set _sources=%_sources% "%source%\README.md"
set _sources=%_sources% "%source%\System Checklist.cmd"
set _sources=%_sources% "%source%\System Diagnostics.cmd"
set _sources=%_sources% "%source%\User Checklist.cmd"
start "" /wait "%fastcopy%" %fastcopy_args% /exclude="Snappy Driver Installer*;Update Kit*;*.exe" %_sources% /to="%dest%\"
start "" /wait "%fastcopy%" %fastcopy_args% "%source%\Installers\Extras\Office\Adobe Reader DC.exe" /to="%dest%\Installers\Extras\Office\"
:Ninite
echo Extracting Ninite installers...
"%SEVEN_ZIP%" x "%cbin%\_Ninite.7z" -aos -bso0 -bse0 -bsp0 -p%ARCHIVE_PASSWORD% -o"%dest%\Installers\Extras" || goto Abort
:OpenFolder
start "" explorer "%dest%"
goto Exit
:: Functions ::
:CheckFlags
rem Loops through all arguments to check for accepted flags
set DEBUG=
for %%f in (%*) do (
if /i "%%f" == "/DEBUG" (@echo on & set "DEBUG=/DEBUG")
)
@exit /b 0
:FindBin
rem Checks the current directory and all parents for the ".bin" folder
rem NOTE: Has not been tested for UNC paths
set bin=
pushd "%~dp0"
:FindBinInner
if exist ".bin" (goto FindBinDone)
if "%~d0\" == "%cd%" (popd & @exit /b 1)
cd ..
goto FindBinInner
:FindBinDone
set "bin=%cd%\.bin"
set "cbin=%cd%\.cbin"
popd
@exit /b 0
:SetTitle
rem Sets title using KIT_NAME_FULL from settings\main.py
set "window_title=%*"
if not defined window_title set "window_title=Launcher"
set "window_title=%KIT_NAME_FULL%: %window_title%"
title %window_title%
@exit /b 0
:: Errors ::
:ErrorNoBin
echo.
echo ERROR: ".bin" folder not found.
goto Abort
:Abort
color 4e
echo Aborted.
echo Press any key to exit...
pause>nul
color
rem Set errorlevel to 1 by calling color incorrectly
color 00
goto Exit
:: Cleanup and exit ::
:Exit
endlocal
exit /b %errorlevel%

4
scripts/Launch.cmd
View file

@ -1,4 +1,4 @@
:: Wizard Kit: Wrapper for launching programs and scripts.
:: WizardKit: Wrapper for launching programs and scripts.
::
:: Some features:
:: * If the OS is 64-bit then the WorkingDir is scanned for a 64-bit version of the programs
@ -10,7 +10,7 @@ if defined DEBUG (@echo on)
:Init
setlocal EnableDelayedExpansion
title Wizard Kit: Launcher
title WizardKit: Launcher
pushd "%~dp0"
call :FindBin
call :DeQuote L_ITEM

8
scripts/Launcher_Template.cmd
View file

@ -1,4 +1,4 @@
:: Wizard Kit: Launcher Script ::
:: WizardKit: Launcher Script ::
::
:: This script works by setting env variables and then calling Launch.cmd
:: which inherits the variables. This bypasses batch file argument parsing
@ -7,7 +7,7 @@
:Init
setlocal EnableDelayedExpansion
title Wizard Kit: Launcher
title WizardKit: Launcher
call :CheckFlags %*
call :FindBin
call :SetTitle Launcher
@ -67,8 +67,8 @@ popd
@exit /b 0
:SetTitle
rem Sets title using KIT_NAME_FULL from settings\main.py
set "SETTINGS=%bin%\Scripts\settings\main.py"
rem Sets title using KIT_NAME_FULL from wk\cfg\main.py
set "SETTINGS=%bin%\Scripts\wk\cfg\main.py"
for /f "tokens=* usebackq" %%f in (`findstr KIT_NAME_FULL "%SETTINGS%"`) do (
set "_v=%%f"
set "_v=!_v:*'=!"

31
scripts/activate.py
View file

@ -1,31 +0,0 @@
"""Wizard Kit: Activate Windows using a BIOS key"""
# vim: sts=2 sw=2 ts=2
import wk
def main():
"""Attempt to activate Windows and show result."""
title = f'{wk.cfg.main.KIT_NAME_FULL}: Activation Tool'
try_print = wk.std.TryAndPrint()
wk.std.clear_screen()
wk.std.set_title(title)
wk.std.print_info(title)
print('')
# Attempt activation
try_print.run('Attempting activation...', wk.os.win.activate_with_bios)
# Done
print('')
print('Done.')
wk.std.pause('Press Enter to exit...')
if __name__ == '__main__':
try:
main()
except SystemExit:
raise
except: #pylint: disable=bare-except
wk.std.major_exception()

2
scripts/apple-fans
View file

@ -1,6 +1,6 @@
#!/bin/bash
#
## Wizard Kit: Apple fan speed tool
## WizardKit: Apple fan speed tool
SMCPATH="/sys/devices/platform/applesmc.768"
SET_MAX="True"

2
scripts/auto_repairs.py
View file

@ -1,4 +1,4 @@
"""Wizard Kit: Auto Repair Tool"""
"""WizardKit: Auto Repair Tool"""
# vim: sts=2 sw=2 ts=2
import os

3
scripts/auto_setup.py
View file

@ -1,4 +1,4 @@
"""Wizard Kit: Auto System Setup Tool"""
"""WizardKit: Auto System Setup Tool"""
# vim: sts=2 sw=2 ts=2
import os
@ -128,7 +128,6 @@ BASE_MENUS = {
MenuEntry('Enable System Restore', 'auto_system_restore_enable'),
MenuEntry('Set System Restore Size', 'auto_system_restore_set_size'),
MenuEntry('Enable Windows Updates', 'auto_windows_updates_enable'),
MenuEntry('User Account Control', 'auto_restore_default_uac'),
MenuEntry('Windows Activation', 'auto_activate_windows'),
MenuEntry('Windows Explorer', 'auto_config_explorer'),
MenuEntry(r'Windows\Temp Fix', 'auto_windows_temp_fix'),

45
scripts/borrowed/set-eol.ps1
View file

@ -1,45 +0,0 @@
## Borrowed from https://ss64.com/ps/syntax-set-eol.html
#
# set-eol.ps1
# Change the line endings of a text file to: Windows (CR/LF), Unix (LF) or Mac (CR)
# Requires PowerShell 3.0 or greater
# Syntax
# ./set-eol.ps1 -lineEnding {mac|unix|win} -file FullFilename
# mac, unix or win : The file endings desired.
# FullFilename : The full pathname of the file to be modified.
# ./set-eol win "c:\demo\data.txt"
[CmdletBinding()]
Param(
[Parameter(Mandatory=$True,Position=1)]
[ValidateSet("mac","unix","win")]
[string]$lineEnding,
[Parameter(Mandatory=$True)]
[string]$file
)
# Convert the friendly name into a PowerShell EOL character
Switch ($lineEnding) {
"mac" { $eol="`r" }
"unix" { $eol="`n" }
"win" { $eol="`r`n" }
}
# Replace CR+LF with LF
$text = [IO.File]::ReadAllText($file) -replace "`r`n", "`n"
[IO.File]::WriteAllText($file, $text)
# Replace CR with LF
$text = [IO.File]::ReadAllText($file) -replace "`r", "`n"
[IO.File]::WriteAllText($file, $text)
# At this point all line-endings should be LF.
# Replace LF with intended EOL char
if ($eol -ne "`n") {
$text = [IO.File]::ReadAllText($file) -replace "`n", $eol
[IO.File]::WriteAllText($file, $text)
}

2
scripts/build-ufd
View file

@ -1,5 +1,5 @@
#!/usr/bin/env python3
"""Wizard Kit: Build UFD Tool"""
"""WizardKit: Build UFD Tool"""
# vim: sts=2 sw=2 ts=2
import wk

20
scripts/build_kit_windows.py Normal file
View file

@ -0,0 +1,20 @@
"""WizardKit: Build Kit (Windows)."""
# vim: sts=2 sw=2 ts=2
import os
import sys
os.chdir(os.path.dirname(os.path.realpath(__file__)))
sys.path.append(os.getcwd())
import wk # pylint: disable=wrong-import-position
if __name__ == '__main__':
try:
wk.kit.build.build_kit()
except KeyboardInterrupt:
wk.std.abort()
except SystemExit:
raise
except: #pylint: disable=bare-except
wk.std.major_exception()

49
scripts/check_disk.py
View file

@ -1,49 +0,0 @@
"""Wizard Kit: Check or repair the %SYSTEMDRIVE% filesystem via CHKDSK"""
# vim: sts=2 sw=2 ts=2
import os
import wk
def main():
"""Run or schedule CHKDSK and show result."""
title = f'{wk.cfg.main.KIT_NAME_FULL}: Check Disk Tool'
menu = wk.std.Menu(title=title)
try_print = wk.std.TryAndPrint()
wk.std.clear_screen()
wk.std.set_title(title)
print('')
# Add menu entries
menu.add_option('Offline scan')
menu.add_option('Online scan')
# Show menu and make selection
selection = menu.simple_select()
# Run or schedule scan
if 'Offline' in selection[0]:
function = wk.repairs.win.run_chkdsk_offline
msg_good = 'Scheduled'
else:
function = wk.repairs.win.run_chkdsk_online
msg_good = 'No issues detected'
try_print.run(
message=f'CHKDSK ({os.environ.get("SYSTEMDRIVE")})...',
function=function,
msg_good=msg_good,
)
# Done
print('')
print('Done.')
wk.std.pause('Press Enter to exit...')
if __name__ == '__main__':
try:
main()
except SystemExit:
raise
except: #pylint: disable=bare-except
wk.std.major_exception()

2
scripts/ddrescue-tui
View file

@ -1,6 +1,6 @@
#!/bin/bash
#
## Wizard Kit: ddrescue TUI Launcher
## WizardKit: ddrescue TUI Launcher
__OS_NAME="$(uname -s)"
if [[ "$__OS_NAME" == "Darwin" ]]; then

2
scripts/ddrescue-tui.py
View file

@ -1,5 +1,5 @@
#!/usr/bin/env python3
"""Wizard Kit: ddrescue TUI"""
"""WizardKit: ddrescue TUI"""
# pylint: disable=invalid-name
# vim: sts=2 sw=2 ts=2

2
scripts/echo-and-hold
View file

@ -1,6 +1,6 @@
#!/bin/bash
#
## Wizard Kit: "echo" text to screen and "hold" by waiting for user input
## WizardKit: "echo" text to screen and "hold" by waiting for user input
function usage {
echo "Usage: $(basename "$0") \"text\""

2
scripts/get_raw_disks.ps1
View file

@ -1,3 +1,3 @@
# Wizard Kit: Get RAW disks
# WizardKit: Get RAW disks
Get-Disk | Where-Object {$_.PartitionStyle -eq "RAW"} | Select FriendlyName,Size,PartitionStyle | ConvertTo-JSON

2
scripts/hw-diags
View file

@ -1,6 +1,6 @@
#!/bin/bash
#
## Wizard Kit: HW Diagnostics Launcher
## WizardKit: HW Diagnostics Launcher
source launch-in-tmux

2
scripts/hw-diags.py
View file

@ -1,5 +1,5 @@
#!/usr/bin/env python3
"""Wizard Kit: Hardware Diagnostics"""
"""WizardKit: Hardware Diagnostics"""
# pylint: disable=invalid-name
# vim: sts=2 sw=2 ts=2

2
scripts/hw-sensors
View file

@ -1,5 +1,5 @@
#!/usr/bin/env python3
"""Wizard Kit: Hardware Sensors"""
"""WizardKit: Hardware Sensors"""
# vim: sts=2 sw=2 ts=2
import platform

4
scripts/init_client_dir.cmd
View file

@ -1,4 +1,4 @@
:: Wizard Kit: Create client_dir folder(s)
:: WizardKit: Create client_dir folder(s)
@echo off
if defined DEBUG (@echo on)
@ -26,7 +26,7 @@ set _minute=%_minute:~-2%
set iso_date=%_yyyy%-%_mm%-%_dd%
:SetVars
set "SETTINGS=%bin%\Scripts\settings\main.py"
set "SETTINGS=%bin%\Scripts\wk\cfg\main.py"
for /f "tokens=* usebackq" %%f in (`findstr KIT_NAME_SHORT "%SETTINGS%"`) do (
set "_v=%%f"
set "_v=!_v:*'=!"

2
scripts/launch-in-tmux
View file

@ -1,6 +1,6 @@
#!/bin/bash
#
## Wizard Kit: TMUX Launcher
## WizardKit: TMUX Launcher
# Live macOS env workaround
tmux_args=()

2
scripts/mount-all-volumes
View file

@ -1,5 +1,5 @@
#!/usr/bin/env python3
"""Wizard Kit: Mount all volumes"""
"""WizardKit: Mount all volumes"""
# vim: sts=2 sw=2 ts=2
import sys

2
scripts/mount-backup-shares
View file

@ -1,5 +1,5 @@
#!/usr/bin/env python3
"""Wizard Kit: Mount Backup Shares"""
"""WizardKit: Mount Backup Shares"""
# pylint: disable=invalid-name
# vim: sts=2 sw=2 ts=2

2
scripts/mount-raw-image
View file

@ -1,6 +1,6 @@
#!/bin/bash
#
## Wizard Kit: RAW image mounting tool
## WizardKit: RAW image mounting tool
set -o errexit
set -o errtrace

2
scripts/outer_scripts_to_review/msword-search → scripts/msword-search
View file

@ -1,6 +1,6 @@
#!/bin/python3
#
## Wizard Kit: MS Word content search tool
## WizardKit: MS Word content search tool
import os
import re

2
scripts/pacinit
View file

@ -1,6 +1,6 @@
#!/bin/bash
#
## Wizard Kit: Update pacman settings to usage in live sessions
## WizardKit: Update pacman settings to usage in live sessions
# Disable custom repo (used at build-time)
sudo sed -i -r "s/^(\[custom\])/#\1/" /etc/pacman.conf

2
scripts/remount-rw
View file

@ -1,6 +1,6 @@
#!/bin/bash
#
## Wizard Kit: Volume remount tool
## WizardKit: Volume remount tool
if ! mount | grep -q "$1"; then
echo "ERROR: Can't remount $1"

37
scripts/safemode_enter.py
View file

@ -1,37 +0,0 @@
"""Wizard Kit: Enter SafeMode by editing the BCD"""
# vim: sts=2 sw=2 ts=2
import wk
def main():
"""Prompt user to enter safe mode."""
title = f'{wk.cfg.main.KIT_NAME_FULL}: SafeMode Tool'
try_print = wk.std.TryAndPrint()
wk.std.clear_screen()
wk.std.set_title(title)
wk.std.print_info(title)
print('')
# Ask
if not wk.std.ask('Enable booting to SafeMode (with Networking)?'):
wk.std.abort()
print('')
# Configure SafeMode
try_print.run('Set BCD option...', wk.os.win.enable_safemode)
try_print.run('Enable MSI in SafeMode...', wk.os.win.enable_safemode_msi)
# Done
print('Done.')
wk.std.pause('Press Enter to reboot...')
wk.exe.run_program('shutdown -r -t 3'.split(), check=False)
if __name__ == '__main__':
try:
main()
except SystemExit:
raise
except: #pylint: disable=bare-except
wk.std.major_exception()

37
scripts/safemode_exit.py
View file

@ -1,37 +0,0 @@
"""Wizard Kit: Exit SafeMode by editing the BCD"""
# vim: sts=2 sw=2 ts=2
import wk
def main():
"""Prompt user to exit safe mode."""
title = f'{wk.cfg.main.KIT_NAME_FULL}: SafeMode Tool'
try_print = wk.std.TryAndPrint()
wk.std.clear_screen()
wk.std.set_title(title)
wk.std.print_info(title)
print('')
# Ask
if not wk.std.ask('Disable booting to SafeMode?'):
wk.std.abort()
print('')
# Configure SafeMode
try_print.run('Remove BCD option...', wk.os.win.disable_safemode)
try_print.run('Disable MSI in SafeMode...', wk.os.win.disable_safemode_msi)
# Done
print('Done.')
wk.std.pause('Press Enter to reboot...')
wk.exe.run_program('shutdown -r -t 3'.split(), check=False)
if __name__ == '__main__':
try:
main()
except SystemExit:
raise
except: #pylint: disable=bare-except
wk.std.major_exception()

35
scripts/sfc_scan.py
View file

@ -1,35 +0,0 @@
"""Wizard Kit: Check, and possibly repair, system file health via SFC"""
# vim: sts=2 sw=2 ts=2
import wk
def main():
"""Run SFC and report result."""
title = f'{wk.cfg.main.KIT_NAME_FULL}: SFC Tool'
try_print = wk.std.TryAndPrint()
wk.std.clear_screen()
wk.std.set_title(title)
wk.std.print_info(title)
print('')
# Ask
if not wk.std.ask('Run a SFC scan now?'):
wk.std.abort()
print('')
# Run
try_print.run('SFC scan...', wk.repairs.win.run_sfc_scan)
# Done
print('Done')
wk.std.pause('Press Enter to exit...')
if __name__ == '__main__':
try:
main()
except SystemExit:
raise
except: #pylint: disable=bare-except
wk.std.major_exception()

2
scripts/unmount-backup-shares
View file

@ -1,5 +1,5 @@
#!/usr/bin/env python3
"""Wizard Kit: Unmount Backup Shares"""
"""WizardKit: Unmount Backup Shares"""
# pylint: disable=invalid-name
# vim: sts=2 sw=2 ts=2

2
scripts/upload-logs
View file

@ -1,6 +1,6 @@
#!/usr/bin/env python3
# vim: sts=2 sw=2 ts=2
"""Wizard Kit: Upload Logs"""
"""WizardKit: Upload Logs"""
import datetime
import os

186
scripts/wk.prev/debug/hw_diags.py
View file

@ -1,186 +0,0 @@
# Wizard Kit: Debug - HW Diagnostics
import base64
import requests
from functions.common import *
def debug_report_cpu(cpu_obj):
"""Generate report for CpuObj, returns list."""
report = []
# CPU Info
report.append('CPU: {}'.format(cpu_obj.name))
report.append('lscpu:')
for k, v in sorted(cpu_obj.lscpu.items()):
report.append(' {}: {}'.format(k, v))
# Tests
report.append('Tests:')
for k, v in cpu_obj.tests.items():
report.extend(debug_report_test(v, k))
# Done
return report
def debug_report_disk(disk_obj):
"""Generate report for DiskObj, returns list."""
report = []
expand = [
'lsblk',
'nvme_attributes',
'nvme_smart_notes',
'smart_attributes',
'smart_self_test',
'smartctl',
]
skip = [
'add_nvme_smart_note',
'calc_io_dd_values',
'check_attributes',
'check_smart_self_test',
'description',
'disable_test',
'generate_attribute_report',
'generate_disk_report',
'get_details',
'get_size',
'get_smart_details',
'name',
'safety_check',
'tests',
]
# Disk Info
report.append('Disk: {} {}'.format(
disk_obj.name, disk_obj.description))
for a in dir(disk_obj):
if a.startswith('_') or a in skip:
continue
if a in expand:
report.append('{}:'.format(a))
attr = getattr(disk_obj, a)
try:
for k, v in sorted(attr.items()):
report.append(' {}: {}'.format(k, v))
except Exception:
# Ignore
pass
else:
report.append('{}: {}'.format(a, getattr(disk_obj, a)))
# Tests
report.append('Tests:')
for k, v in disk_obj.tests.items():
report.extend(debug_report_test(v, k))
# Done
return report
def debug_report_state(state):
"""Generate report for State, returns list."""
report = []
# Devs
report.append('CPU: {}'.format(state.cpu))
report.append('Disks: {}'.format(state.disks))
# Settings
report.append('Progress Out: {}'.format(state.progress_out))
report.append('Quick Mode: {}'.format(state.quick_mode))
# Tests
report.append('Tests:')
for k, v in state.tests.items():
report.append(' {}:'.format(k))
for k2, v2 in sorted(v.items()):
report.append(' {}: {}'.format(k2, v2))
# tmux
if hasattr(state, 'tmux_layout'):
report.append('tmux Layout:')
for k, v in state.tmux_layout.items():
report.append(' {}: {}'.format(k, str(v)))
if hasattr(state, 'panes'):
report.append('tmux Panes:')
for k, v in state.panes.items():
report.append(' {}: {}'.format(k, str(v)))
# Done
return report
def debug_report_test(test_obj, test_name):
"""Generate report for TestObj, returns list."""
report = [' {}:'.format(test_name)]
skip = ['update_status']
# Attributes
for a in [a for a in dir(test_obj) if not a.startswith('_')]:
if a in skip:
continue
report.append(' {}: {}'.format(a, getattr(test_obj, a)))
# Done
return report
def save_debug_reports(state, global_vars):
"""Save debug reports if possible."""
debug_dest = '{}/debug'.format(global_vars['LogDir'])
os.makedirs(debug_dest, exist_ok=True)
# State
with open('{}/state.report'.format(debug_dest), 'a') as f:
for line in debug_report_state(state):
f.write('{}\n'.format(line))
# CPU
with open('{}/cpu.report'.format(debug_dest), 'a') as f:
for line in debug_report_cpu(state.cpu):
f.write('{}\n'.format(line))
# Disk(s)
for disk in state.disks:
with open('{}/disk_{}.report'.format(debug_dest, disk.name), 'a') as f:
for line in debug_report_disk(disk):
f.write('{}\n'.format(line))
def upload_logdir(global_vars, reason='Crash'):
"""Upload compressed LogDir to CRASH_SERVER."""
source = global_vars['LogDir']
source = source[source.rfind('/')+1:]
dest = 'HW-Diags_{reason}_{Date-Time}.txz'.format(
reason=reason,
**global_vars,
)
data = None
# Compress LogDir
os.chdir('{}/..'.format(global_vars['LogDir']))
cmd = ['tar', 'caf', dest, source]
run_program(cmd)
# Read file
with open(dest, 'rb') as f:
data = f.read()
# Upload data
url = '{}/{}'.format(CRASH_SERVER['Url'], dest)
r = requests.put(
url,
data=data,
headers={'X-Requested-With': 'XMLHttpRequest'},
auth=(CRASH_SERVER['User'], CRASH_SERVER['Pass']))
# Raise exception if upload NS
if not r.ok:
raise GenericError
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

73
scripts/wk.prev/functions/activation.py
View file

@ -1,73 +0,0 @@
# Wizard Kit: Functions - Activation
import subprocess
from borrowed import acpi
from functions.common import *
from os import environ
# STATIC VARIABLES
SLMGR = r'{}\System32\slmgr.vbs'.format(environ.get('SYSTEMROOT'))
def activate_with_bios():
"""Attempt to activate Windows with a key stored in the BIOS."""
# Code borrowed from https://github.com/aeruder/get_win8key
#####################################################
#script to query windows 8.x OEM key from PC firmware
#ACPI -> table MSDM -> raw content -> byte offset 56 to end
#ck, 03-Jan-2014 (christian@korneck.de)
#####################################################
bios_key = None
table = b"MSDM"
if acpi.FindAcpiTable(table) is True:
rawtable = acpi.GetAcpiTable(table)
#http://msdn.microsoft.com/library/windows/hardware/hh673514
#byte offset 36 from beginning \
# = Microsoft 'software licensing data structure' \
# / 36 + 20 bytes offset from beginning = Win Key
bios_key = rawtable[56:len(rawtable)].decode("utf-8")
if bios_key is None:
raise BIOSKeyNotFoundError
# Install Key
cmd = ['cscript', '//nologo', SLMGR, '/ipk', bios_key]
subprocess.run(cmd, check=False)
sleep(5)
# Attempt activation
cmd = ['cscript', '//nologo', SLMGR, '/ato']
subprocess.run(cmd, check=False)
sleep(5)
# Check status
if not windows_is_activated():
raise Exception('Activation Failed')
def get_activation_string():
"""Get activation status, returns str."""
act_str = subprocess.run(
['cscript', '//nologo', SLMGR, '/xpr'], check=False,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
act_str = act_str.stdout.decode()
act_str = act_str.splitlines()
act_str = act_str[1].strip()
return act_str
def windows_is_activated():
"""Check if Windows is activated via slmgr.vbs and return bool."""
activation_string = subprocess.run(
['cscript', '//nologo', SLMGR, '/xpr'], check=False,
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
activation_string = activation_string.stdout.decode()
return bool(activation_string and 'permanent' in activation_string)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

219
scripts/wk.prev/functions/backup.py
View file

@ -1,219 +0,0 @@
# Wizard Kit: Functions - Backup
import ctypes
from functions.disk import *
# Regex
REGEX_BAD_PATH_NAMES = re.compile(
r'([<>:"/\|\?\*]'
r'|^(CON|PRN|AUX|NUL|COM\d*|LPT\d*)$)'
r'|^\s+'
r'|[\s\.]+$',
re.IGNORECASE)
def backup_partition(disk, par):
"""Create a backup image of a partition."""
if (par.get('Image Exists', False)
or par['Number'] in disk['Bad Partitions']):
raise GenericAbort
cmd = [
global_vars['Tools']['wimlib-imagex'],
'capture',
'{}:\\'.format(par['Letter']),
par['Image Path'],
par['Image Name'], # Image name
par['Image Name'], # Image description
'--compress=none',
]
dest_dir = re.sub(r'(.*)\\.*$', r'\1', par['Image Path'], re.IGNORECASE)
os.makedirs(dest_dir, exist_ok=True)
run_program(cmd)
def fix_path(path):
"""Replace invalid filename characters with underscores."""
local_drive = path[1:2] == ':'
new_path = REGEX_BAD_PATH_NAMES.sub('_', path)
if local_drive:
new_path = '{}:{}'.format(new_path[0:1], new_path[2:])
return new_path
def get_volume_display_name(mountpoint):
"""Get display name from volume mountpoint and label, returns str."""
name = mountpoint
try:
kernel32 = ctypes.windll.kernel32
vol_name_buffer = ctypes.create_unicode_buffer(1024)
fs_name_buffer = ctypes.create_unicode_buffer(1024)
serial_number = None
max_component_length = None
file_system_flags = None
vol_info = kernel32.GetVolumeInformationW(
ctypes.c_wchar_p(mountpoint),
vol_name_buffer,
ctypes.sizeof(vol_name_buffer),
serial_number,
max_component_length,
file_system_flags,
fs_name_buffer,
ctypes.sizeof(fs_name_buffer)
)
name = '{} "{}"'.format(name, vol_name_buffer.value)
except:
pass
return name
def prep_disk_for_backup(destination, disk, backup_prefix):
"""Gather details about the disk and its partitions.
This includes partitions that can't be backed up,
whether backups already exist on the BACKUP_SERVER,
partition names/sizes/used space, etc."""
disk['Clobber Risk'] = []
width = len(str(len(disk['Partitions'])))
# Get partition totals
disk['Bad Partitions'] = [par['Number'] for par in disk['Partitions']
if is_bad_partition(par)]
num_valid_partitions = len(disk['Partitions']) - len(disk['Bad Partitions'])
disk['Valid Partitions'] = num_valid_partitions
if disk['Valid Partitions'] <= 0:
print_error('ERROR: No partitions can be backed up for this disk')
raise GenericAbort
# Prep partitions
for par in disk['Partitions']:
display = '{size} {fs}'.format(
num = par['Number'],
width = width,
size = par['Size'],
fs = par['FileSystem'])
if par['Number'] in disk['Bad Partitions']:
# Set display string using partition description & OS type
display = '* {display}\t\t{q}{name}{q}\t{desc} ({os})'.format(
display = display,
q = '"' if par['Name'] != '' else '',
name = par['Name'],
desc = par['Description'],
os = par['OS'])
else:
# Update info for WIM capturing
par['Image Name'] = par['Name'] if par['Name'] else 'Unknown'
if 'IP' in destination:
par['Image Path'] = r'\\{}\{}\{}'.format(
destination['IP'], destination['Share'], backup_prefix)
else:
par['Image Path'] = r'{}:\{}'.format(
destination['Letter'], backup_prefix)
par['Image Path'] += r'\{}_{}.wim'.format(
par['Number'], par['Image Name'])
par['Image Path'] = fix_path(par['Image Path'])
# Check for existing backups
par['Image Exists'] = os.path.exists(par['Image Path'])
if par['Image Exists']:
disk['Clobber Risk'].append(par['Number'])
display = '+ {}'.format(display)
else:
display = ' {}'.format(display)
# Append rest of Display String for valid/clobber partitions
display += ' (Used: {used})\t{q}{name}{q}'.format(
used = par['Used Space'],
q = '"' if par['Name'] != '' else '',
name = par['Name'])
# For all partitions
par['Display String'] = display
# Set description for bad partitions
warnings = '\n'
if disk['Bad Partitions']:
warnings += '{} * Unsupported filesystem{}\n'.format(
COLORS['YELLOW'], COLORS['CLEAR'])
if disk['Clobber Risk']:
warnings += '{} + Backup exists on {}{}\n'.format(
COLORS['BLUE'], destination['Name'], COLORS['CLEAR'])
if disk['Bad Partitions'] or disk['Clobber Risk']:
warnings += '\n{}Marked partition(s) will NOT be backed up.{}\n'.format(
COLORS['YELLOW'], COLORS['CLEAR'])
disk['Backup Warnings'] = warnings
def select_backup_destination(auto_select=True):
"""Select a backup destination from a menu, returns server dict."""
destinations = [s for s in BACKUP_SERVERS if s['Mounted']]
actions = [
{'Name': 'Main Menu', 'Letter': 'M'},
]
# Add local disks
for d in psutil.disk_partitions():
if re.search(
r'^{}'.format(global_vars['Env']['SYSTEMDRIVE']),
d.mountpoint,
re.IGNORECASE):
# Skip current OS drive
pass
elif 'fixed' in d.opts:
# Skip DVD, etc
destinations.append({
'Name': 'Local Disk - {}'.format(
get_volume_display_name(d.mountpoint)),
'Letter': re.sub(r'^(\w):\\.*$', r'\1', d.mountpoint),
})
# Size check
for dest in destinations:
if 'IP' in dest:
dest['Usage'] = shutil.disk_usage(r'\\{IP}\{Share}'.format(**dest))
else:
dest['Usage'] = shutil.disk_usage('{}:\\'.format(dest['Letter']))
dest['Free Space'] = human_readable_size(dest['Usage'].free)
dest['Display Name'] = '{Name} ({Free Space} available)'.format(**dest)
# Bail
if not destinations:
print_warning('No backup destinations found.')
raise GenericAbort
# Skip menu?
if len(destinations) == 1 and auto_select:
return destinations[0]
selection = menu_select(
title = 'Where are we backing up to?',
main_entries = destinations,
action_entries = actions)
if selection == 'M':
raise GenericAbort
else:
return destinations[int(selection)-1]
def verify_wim_backup(partition):
"""Verify WIM integrity."""
if not os.path.exists(partition['Image Path']):
raise PathNotFoundError
cmd = [
global_vars['Tools']['wimlib-imagex'],
'verify',
partition['Image Path'],
'--nocheck',
]
run_program(cmd)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

508
scripts/wk.prev/functions/browsers.py
View file

@ -1,508 +0,0 @@
# Wizard Kit: Functions - Browsers
import json
import pathlib
from functions.common import *
from operator import itemgetter
from settings.browsers import *
# Define other_results for later try_and_print
browser_data = {}
other_results = {
'Error': {
'MultipleInstallationsError': 'MULTIPLE INSTALLATIONS DETECTED',
},
'Warning': {
'NotInstalledError': 'NOT INSTALLED',
'NoProfilesError': 'NO PROFILES FOUND',
}
}
def archive_all_users():
"""Create backups for all browsers for all users."""
users_root = r'{}\Users'.format(global_vars['Env']['SYSTEMDRIVE'])
user_envs = []
# Build list of valid users
for user_name in os.listdir(users_root):
valid_user = True
if user_name in ('Default', 'Default User'):
# Skip default users
continue
user_path = os.path.join(users_root, user_name)
appdata_local = os.path.join(user_path, r'AppData\Local')
appdata_roaming = os.path.join(user_path, r'AppData\Roaming')
valid_user = valid_user and os.path.exists(appdata_local)
valid_user = valid_user and os.path.exists(appdata_roaming)
if valid_user:
user_envs.append({
'USERNAME': user_name,
'USERPROFILE': user_path,
'APPDATA': appdata_roaming,
'LOCALAPPDATA': appdata_local})
# Backup browsers for all valid users
print_info('Backing up browsers')
for fake_env in sorted(user_envs, key=itemgetter('USERPROFILE')):
print_standard(' {}'.format(fake_env['USERNAME']))
for b_k, b_v in sorted(SUPPORTED_BROWSERS.items()):
if b_k == 'Mozilla Firefox Dev':
continue
source_path = b_v['user_data_path'].format(**fake_env)
if not os.path.exists(source_path):
continue
source_items = source_path + '*'
archive_path = r'{BackupDir}\Browsers ({USERNAME})\{Date}'.format(
**global_vars, **fake_env)
os.makedirs(archive_path, exist_ok=True)
archive_path += r'\{}.7z'.format(b_k)
cmd = [
global_vars['Tools']['SevenZip'],
'a', '-aoa', '-bso0', '-bse0', '-mx=0',
archive_path, source_items]
try_and_print(message='{}...'.format(b_k),
function=run_program, cmd=cmd)
print_standard(' ')
def archive_browser(name):
"""Create backup of Browser saved in the BackupDir."""
source = '{}*'.format(browser_data[name]['user_data_path'])
dest = r'{BackupDir}\Browsers ({USERNAME})\{Date}'.format(
**global_vars, **global_vars['Env'])
archive = r'{}\{}.7z'.format(dest, name)
os.makedirs(dest, exist_ok=True)
cmd = [
global_vars['Tools']['SevenZip'],
'a', '-aoa', '-bso0', '-bse0', '-mx=0',
'-mhe=on', '-p{}'.format(ARCHIVE_PASSWORD),
archive, source]
run_program(cmd)
def backup_browsers():
"""Create backup of all detected browser profiles."""
for name in [k for k, v in sorted(browser_data.items()) if v['profiles']]:
try_and_print(message='{}...'.format(name),
function=archive_browser, name=name)
def clean_chromium_profile(profile):
"""Recreate profile with only the essential user data.
This is done by renaming the existing profile, creating a new folder
with the original name, then copying the essential files from the
backup folder. This way the original state is preserved in case
something goes wrong.
"""
if profile is None:
raise Exception
backup_path = '{path}_{Date}.bak'.format(
path=profile['path'], **global_vars)
backup_path = non_clobber_rename(backup_path)
shutil.move(profile['path'], backup_path)
os.makedirs(profile['path'], exist_ok=True)
# Restore essential files from backup_path
for entry in os.scandir(backup_path):
if REGEX_CHROMIUM_ITEMS.search(entry.name):
shutil.copy(entry.path, r'{}\{}'.format(
profile['path'], entry.name))
def clean_internet_explorer(**kwargs):
"""Uses the built-in function to reset IE and sets the homepage.
NOTE: kwargs set but unused as a workaround."""
kill_process('iexplore.exe')
run_program(['rundll32.exe', 'inetcpl.cpl,ResetIEtoDefaults'], check=False)
key = r'Software\Microsoft\Internet Explorer\Main'
# Set homepage
with winreg.OpenKey(HKCU, key, access=winreg.KEY_WRITE) as _key:
winreg.SetValueEx(_key, 'Start Page', 0,
winreg.REG_SZ, DEFAULT_HOMEPAGE)
try:
winreg.DeleteValue(_key, 'Secondary Start Pages')
except FileNotFoundError:
pass
def clean_mozilla_profile(profile):
"""Recreate profile with only the essential user data.
This is done by renaming the existing profile, creating a new folder
with the original name, then copying the essential files from the
backup folder. This way the original state is preserved in case
something goes wrong.
"""
if profile is None:
raise Exception
backup_path = '{path}_{Date}.bak'.format(
path=profile['path'], **global_vars)
backup_path = non_clobber_rename(backup_path)
shutil.move(profile['path'], backup_path)
homepages = []
os.makedirs(profile['path'], exist_ok=True)
# Restore essential files from backup_path
for entry in os.scandir(backup_path):
if REGEX_MOZILLA.search(entry.name):
if entry.is_dir():
shutil.copytree(entry.path, r'{}\{}'.format(
profile['path'], entry.name))
else:
shutil.copy(entry.path, r'{}\{}'.format(
profile['path'], entry.name))
# Set profile defaults
with open(r'{path}\prefs.js'.format(**profile), 'a', encoding='ascii') as f:
for k, v in MOZILLA_PREFS.items():
f.write('user_pref("{}", {});\n'.format(k, v))
def disable_chrome_notifications():
"""TODO"""
# Kill running instances
kill_process('chrome.exe')
sleep(1)
kill_process('chrome.exe')
# Update browser_data
scan_for_browsers(silent=True, skip_ie=True)
for profile in browser_data.get('Google Chrome', {}).get('profiles', []):
pref_file = pathlib.Path(f'{profile["path"]}/Preferences')
if pref_file.exists():
pref_data = None
# Read current preferences
with open(pref_file, 'r') as f:
pref_data = json.loads(f.read())
# Set notifications blocks
defaults_key = 'default_content_setting_values'
if defaults_key not in pref_data['profile']:
pref_data['profile'][defaults_key] = {}
pref_data['profile'][defaults_key]['notifications'] = 2
# Write new preferences
with open(pref_file, 'w') as f:
f.write(json.dumps(pref_data, separators=(',', ':')))
def get_browser_details(name):
"""Get installation and profile details for all supported browsers."""
browser = SUPPORTED_BROWSERS[name].copy()
# Update user_data_path
browser['user_data_path'] = browser['user_data_path'].format(
**global_vars['Env'])
# Find executable (if multiple files are found, the last one is used)
exe_path = None
num_installs = 0
for install_path in ['LOCALAPPDATA', 'PROGRAMFILES(X86)', 'PROGRAMFILES']:
test_path = r'{install_path}\{rel_install_path}\{exe_name}'.format(
install_path = global_vars['Env'].get(install_path, ''),
**browser)
if os.path.exists(test_path):
num_installs += 1
exe_path = test_path
# Find profile(s)
profiles = []
if browser['base'] == 'ie':
profiles.append({'name': 'Default', 'path': None})
elif 'Google Chrome' in name:
profiles.extend(
get_chromium_profiles(
search_path=browser['user_data_path']))
elif browser['base'] == 'mozilla':
dev = 'Dev' in name
profiles.extend(
get_mozilla_profiles(
search_path=browser['user_data_path'], dev=dev))
if exe_path and not dev and len(profiles) == 0:
# e.g. If Firefox is installed but no profiles were found.
## Rename profiles.ini and create a new default profile
profiles_ini_path = browser['user_data_path'].replace(
'Profiles', 'profiles.ini')
if os.path.exists(profiles_ini_path):
backup_path = '{path}_{Date}.bak'.format(
path=profiles_ini_path, **global_vars)
backup_path = non_clobber_rename(backup_path)
shutil.move(profiles_ini_path, backup_path)
run_program([exe_path, '-createprofile', 'default'], check=False)
profiles.extend(
get_mozilla_profiles(
search_path=browser['user_data_path'], dev=dev))
elif 'Opera' in name:
if os.path.exists(browser['user_data_path']):
profiles.append(
{'name': 'Default', 'path': browser['user_data_path']})
# Get homepages
if browser['base'] == 'ie':
# IE is set to only have one profile above
profiles[0]['homepages'] = get_ie_homepages()
elif browser['base'] == 'mozilla':
for profile in profiles:
prefs_path = r'{path}\prefs.js'.format(**profile)
profile['homepages'] = get_mozilla_homepages(prefs_path=prefs_path)
# Add to browser_data
browser_data[name] = browser
browser_data[name].update({
'exe_path': exe_path,
'profiles': profiles,
})
# Raise installation warnings (if any)
if num_installs == 0:
raise NotInstalledError
elif num_installs > 1 and browser['base'] != 'ie':
raise MultipleInstallationsError
def get_chromium_profiles(search_path):
"""Find any chromium-style profiles and return as a list of dicts."""
profiles = []
try:
for entry in os.scandir(search_path):
if entry.is_dir() and REGEX_CHROMIUM_PROFILE.search(entry.name):
profiles.append(entry)
REGEX_PROFILE_BACKUP = r'\.\w+bak.*'
profiles = [p for p in profiles if not REGEX_BACKUP.search(p.name)]
# Convert os.DirEntries to dicts
profiles = [{'name': p.name, 'path': p.path} for p in profiles]
except Exception:
pass
return profiles
def get_ie_homepages():
"""Read homepages from the registry and return as a list."""
homepages = []
main_page = ''
extra_pages = []
key = r'Software\Microsoft\Internet Explorer\Main'
with winreg.OpenKey(HKCU, key) as _key:
try:
main_page = winreg.QueryValueEx(_key, 'Start Page')[0]
except FileNotFoundError:
pass
try:
extra_pages = winreg.QueryValueEx(_key, 'Secondary Start Pages')[0]
except FileNotFoundError:
pass
if main_page != '':
homepages.append(main_page)
if len(extra_pages) > 0:
homepages.extend(extra_pages)
# Remove all curly braces
homepages = [h.replace('{', '').replace('}', '') for h in homepages]
return homepages
def get_mozilla_homepages(prefs_path):
"""Read homepages from prefs.js and return as a list."""
homepages = []
try:
with open(prefs_path, 'r') as f:
search = re.search(
r'browser\.startup\.homepage", "([^"]*)"',
f.read(), re.IGNORECASE)
if search:
homepages = search.group(1).split('|')
except Exception:
pass
return homepages
def get_mozilla_profiles(search_path, dev=False):
"""Find any mozilla-style profiles and return as a list of dicts."""
profiles = []
try:
for entry in os.scandir(search_path):
if entry.is_dir():
if 'dev-edition' in entry.name:
# NOTE: Not always present which can lead
# to Dev profiles being marked as non-Dev
## NOTE 2: It is possible that a non-Dev profile
## to be created with 'dev-edition' in the name.
## (It wouldn't make sense, but possible)
if dev:
profiles.append(entry)
elif not dev:
profiles.append(entry)
profiles = [p for p in profiles if not REGEX_BACKUP.search(p.name)]
# Convert os.DirEntries to dicts
profiles = [{'name': p.name, 'path': p.path} for p in profiles]
except Exception:
pass
return profiles
def install_adblock(
indent=8, width=32, just_firefox=False, skip_firefox=False):
"""Install adblock for all supported browsers."""
for browser in sorted(browser_data):
if just_firefox and browser_data[browser]['base'] != 'mozilla':
continue
if skip_firefox and browser_data[browser]['base'] == 'mozilla':
continue
exe_path = browser_data[browser].get('exe_path', None)
if not exe_path:
if browser_data[browser]['profiles']:
print_standard(
'{indent}{browser:<{width}}'.format(
indent=' '*indent, width=width, browser=browser+'...'),
end='', flush=True)
print_warning('Profile(s) detected but browser not installed',
timestamp=False)
else:
# Only warn if profile(s) are detected.
pass
else:
# Set urls to open
urls = []
if browser_data[browser]['base'] == 'chromium':
if browser == 'Google Chrome':
# Check for system exensions
try:
winreg.QueryValue(HKLM, UBO_CHROME_REG)
except FileNotFoundError:
urls.append(UBO_CHROME)
try:
winreg.QueryValue(HKLM, UBO_EXTRA_CHROME_REG)
except FileNotFoundError:
urls.append(UBO_EXTRA_CHROME)
if len(urls) == 0:
urls = ['chrome://extensions']
elif 'Opera' in browser:
urls.append(UBO_OPERA)
else:
urls.append(UBO_CHROME)
urls.append(UBO_EXTRA_CHROME)
elif browser_data[browser]['base'] == 'mozilla':
# Check for system extensions
try:
with winreg.OpenKey(HKLM, UBO_MOZILLA_REG) as key:
winreg.QueryValueEx(key, UBO_MOZILLA_REG_NAME)
except FileNotFoundError:
urls = [UBO_MOZILLA]
else:
if os.path.exists(UBO_MOZZILA_PATH):
urls = ['about:addons']
else:
urls = [UBO_MOZILLA]
elif browser_data[browser]['base'] == 'ie':
urls.append(IE_GALLERY)
# By using check=False we're skipping any return codes so
# it should only fail if the program can't be run
# (or can't be found).
# In other words, this isn't tracking the addon/extension's
# installation status.
try_and_print(message='{}...'.format(browser),
indent=indent, width=width,
cs='STARTED', function=popen_program,
cmd=[exe_path, *urls], check=False)
def is_installed(browser_name):
"""Checks if browser is installed based on exe_path, returns bool."""
browser_name = browser_name.replace(' Chromium', '')
return bool(browser_data.get(browser_name, {}).get('exe_path', False))
def list_homepages(indent=8, width=32):
"""List current homepages for reference."""
browser_list = [k for k, v in sorted(browser_data.items()) if v['exe_path']]
for browser in browser_list:
# Skip Chromium-based browsers
if browser_data[browser]['base'] == 'chromium':
print_info(
'{indent}{browser:<{width}}'.format(
indent=' '*indent, width=width, browser=browser+'...'),
end='', flush=True)
print_warning('Not implemented', timestamp=False)
continue
# All other browsers
print_info('{indent}{browser:<{width}}'.format(
indent=' '*indent, width=width, browser=browser+'...'))
for profile in browser_data[browser].get('profiles', []):
name = profile.get('name', '?')
homepages = profile.get('homepages', [])
if len(homepages) == 0:
print_standard(
'{indent}{name:<{width}}'.format(
indent=' '*indent, width=width, name=name),
end='', flush=True)
print_warning('None found', timestamp=False)
else:
for page in homepages:
print_standard('{indent}{name:<{width}}{page}'.format(
indent=' '*indent, width=width, name=name, page=page))
def profile_present(browser_name):
"""Checks if a profile was detected for browser, returns bool."""
browser_name = browser_name.replace(' Chromium', '')
return bool(browser_data.get(browser_name, {}).get('profiles', False))
def reset_browsers(indent=8, width=32):
"""Reset all detected browsers to safe defaults."""
browser_list = [k for k, v in sorted(browser_data.items()) if v['profiles']]
for browser in browser_list:
print_info('{indent}{name}'.format(indent=' '*indent, name=browser))
for profile in browser_data[browser]['profiles']:
if browser_data[browser]['base'] == 'chromium':
function = clean_chromium_profile
elif browser_data[browser]['base'] == 'ie':
function = clean_internet_explorer
elif browser_data[browser]['base'] == 'mozilla':
function = clean_mozilla_profile
try_and_print(
message='{}...'.format(profile['name']),
indent=indent, width=width, function=function,
other_results=other_results, profile=profile)
def scan_for_browsers(just_firefox=False, silent=False, skip_ie=False):
"""Scan system for any supported browsers."""
for name, details in sorted(SUPPORTED_BROWSERS.items()):
if just_firefox and details['base'] != 'mozilla':
continue
if skip_ie and details['base'] == 'ie':
continue
if silent:
try:
get_browser_details(name)
except Exception:
# Ignore errors in silent mode
pass
else:
try_and_print(message='{}...'.format(name),
function=get_browser_details, cs='DETECTED',
other_results=other_results, name=name)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

255
scripts/wk.prev/functions/cleanup.py
View file

@ -1,255 +0,0 @@
'''Wizard Kit: Functions - Cleanup'''
# pylint: disable=no-name-in-module,wildcard-import
# vim: sts=2 sw=2 ts=2
from functions.setup import *
from settings.cleanup import *
def cleanup_adwcleaner():
"""Move AdwCleaner folders into the ClientDir."""
source_path = r'{SYSTEMDRIVE}\AdwCleaner'.format(**global_vars['Env'])
source_quarantine = r'{}\Quarantine'.format(source_path)
# Quarantine
if os.path.exists(source_quarantine):
os.makedirs(global_vars['QuarantineDir'], exist_ok=True)
dest_name = r'{QuarantineDir}\AdwCleaner_{Date-Time}'.format(
**global_vars)
dest_name = non_clobber_rename(dest_name)
shutil.move(source_quarantine, dest_name)
# Delete source folder if empty
delete_empty_folders(source_path)
# Main folder
if os.path.exists(source_path):
os.makedirs(global_vars['LogDir'], exist_ok=True)
dest_name = r'{LogDir}\Tools\AdwCleaner'.format(
**global_vars)
dest_name = non_clobber_rename(dest_name)
shutil.move(source_path, dest_name)
def cleanup_cbs(dest_folder):
"""Safely cleanup a known CBS archive bug under Windows 7.
If a CbsPersist file is larger than 2 Gb then the auto archive feature
continually fails and will fill up the system drive with temp files.
This function moves the temp files and CbsPersist file to a temp folder,
compresses the CbsPersist files with 7-Zip, and then opens the temp folder
for the user to manually save the backup files and delete the temp files.
"""
backup_folder = r'{dest_folder}\CbsFix'.format(dest_folder=dest_folder)
temp_folder = r'{backup_folder}\Temp'.format(backup_folder=backup_folder)
os.makedirs(backup_folder, exist_ok=True)
os.makedirs(temp_folder, exist_ok=True)
# Move files into temp folder
cbs_path = r'{SYSTEMROOT}\Logs\CBS'.format(**global_vars['Env'])
for entry in os.scandir(cbs_path):
# CbsPersist files
if entry.name.lower().startswith('cbspersist'):
dest_name = r'{}\{}'.format(temp_folder, entry.name)
dest_name = non_clobber_rename(dest_name)
shutil.move(entry.path, dest_name)
temp_path = r'{SYSTEMROOT}\Temp'.format(**global_vars['Env'])
for entry in os.scandir(temp_path):
# cab_ files
if entry.name.lower().startswith('cab_'):
dest_name = r'{}\{}'.format(temp_folder, entry.name)
dest_name = non_clobber_rename(dest_name)
shutil.move(entry.path, dest_name)
# Compress CbsPersist files with 7-Zip
cmd = [
global_vars['Tools']['SevenZip'],
'a', '-t7z', '-mx=3', '-bso0', '-bse0',
r'{}\CbsPersists.7z'.format(backup_folder),
r'{}\CbsPersist*'.format(temp_folder)]
run_program(cmd)
def cleanup_d7ii():
# pylint: disable=too-many-branches
"""Sort d7II logs and remove temp items."""
d7_path = r'{}\d7II'.format(global_vars['ClientDir'])
d7_reports = r'{} Reports'.format(d7_path)
d7_temp = r'{}\Temp'.format(d7_path)
# Logs & Reports
if os.path.exists(d7_reports):
for entry in os.scandir(d7_reports):
_r = re.match(r'(\d+)-(\d+)-(\d+)', entry.name)
d7_date = '{}-{:02d}-{:02d}'.format(
_r.group(1), int(_r.group(2)), int(_r.group(3)))
d7_mlogs = r'{}\Malware Logs'.format(entry.path)
log_dest = r'{SYSTEMDRIVE}\{prefix}\Logs\{date}'.format(
prefix=KIT_NAME_SHORT,
date=d7_date,
**global_vars['Env'])
os.makedirs(r'{}\d7II'.format(log_dest), exist_ok=True)
os.makedirs(r'{}\Tools'.format(log_dest), exist_ok=True)
# Malware Logs
if os.path.exists(d7_mlogs):
m_report = 'MalwareScan_Report.txt'
for m_entry in os.scandir(d7_mlogs):
if m_entry.name == m_report:
dest_path = r'{}\d7II\{}'.format(log_dest, m_entry.name)
else:
dest_path = r'{}\Tools\{}'.format(log_dest, m_entry.name)
dest_path = non_clobber_rename(dest_path)
shutil.move(m_entry.path, dest_path)
# Other items
for o_entry in os.scandir(entry.path):
dest_path = r'{log_dest}\d7II\{name}'.format(
log_dest=log_dest,
name=o_entry.name)
dest_path = non_clobber_rename(dest_path)
# Just remove empty folders
if o_entry.is_dir():
try:
os.rmdir(o_entry.path)
except OSError:
pass
else:
continue
# Move item
shutil.move(o_entry.path, dest_path)
# Remove folder
delete_empty_folders(entry.path)
# Registry Items
for key, settings in D7_HKCR_CLEANUP.items():
delete_registry_key(HKCR, key, recurse=settings['Recurse'])
for key, settings in D7_HKCU_CLEANUP.items():
delete_registry_key(HKCU, key, recurse=settings['Recurse'])
for key, settings in D7_HKLM_CLEANUP.items():
delete_registry_key(HKLM, key, recurse=settings['Recurse'])
# Temp items
if os.path.exists(d7_path):
if os.path.exists(d7_temp):
shutil.rmtree(d7_temp)
try:
os.rmdir(d7_path)
except OSError:
pass
def cleanup_desktop():
"""Move known backup files and reports into the ClientDir."""
dest_folder = r'{LogDir}\Tools'.format(**global_vars)
os.makedirs(dest_folder, exist_ok=True)
desktop_path = r'{USERPROFILE}\Desktop'.format(**global_vars['Env'])
for entry in os.scandir(desktop_path):
if DESKTOP_ITEMS.search(entry.name):
dest_name = r'{}\{}'.format(dest_folder, entry.name)
dest_name = non_clobber_rename(dest_name)
shutil.move(entry.path, dest_name)
# Remove dir if empty
delete_empty_folders(dest_folder)
def cleanup_emsisoft():
"""Remove EmsisoftCmd files from drive root."""
source_path = r'{}\EmsisoftCmd'.format(global_vars['Env']['SYSTEMDRIVE'])
source_quarantine = r'{}\Quarantine'.format(source_path)
# Quarantine
if os.path.exists(source_quarantine):
os.makedirs(global_vars['QuarantineDir'], exist_ok=True)
dest_name = r'{QuarantineDir}\Emsisoft_{Date-Time}'.format(
**global_vars)
dest_name = non_clobber_rename(dest_name)
shutil.move(source_quarantine, dest_name)
# Remove program
if os.path.exists(source_path):
shutil.rmtree(source_path)
def cleanup_regbackups():
"""Move d7ii regbackups into backup folder."""
source_path = r'{}\Support\RegBackups'.format(
global_vars['Env']['SYSTEMDRIVE'])
# Bail early
if not os.path.exists(source_path):
return
# Make dest folder
dest_dir = r'{BackupDir}\Registry\{Date}'.format(**global_vars)
os.makedirs(dest_dir, exist_ok=True)
# Move to backup folder
for entry in os.scandir(source_path):
dest_path = r'{dest}\{name}'.format(dest=dest_dir, name=entry.name)
dest_path = non_clobber_rename(dest_path)
shutil.move(entry.path, dest_path)
# Delete source folders if empty
delete_empty_folders(r'{}\Support'.format(
global_vars['Env']['SYSTEMDRIVE']))
def delete_empty_folders(folder_path):
"""Delete all empty folders in path (depth first)."""
if not os.path.exists(folder_path) or not os.path.isdir(folder_path):
# Bail early (silently)
return
# Delete empty subfolders first
for item in os.scandir(folder_path):
if item.is_dir():
delete_empty_folders(item.path)
# Remove top folder
try:
os.rmdir(folder_path)
except OSError:
pass
def delete_registry_key(hive, key, recurse=False):
"""Delete a registry key and all it's subkeys."""
access = winreg.KEY_ALL_ACCESS
try:
if recurse:
# Delete all subkeys first
with winreg.OpenKeyEx(hive, key, 0, access) as k:
key_info = winreg.QueryInfoKey(k)
for _i in range(key_info[0]): # pylint: disable=unused-variable
subkey = r'{}\{}'.format(key, winreg.EnumKey(k, 0))
delete_registry_key(hive, subkey)
# Delete key
winreg.DeleteKey(hive, key)
except FileNotFoundError:
# Ignore
pass
def delete_registry_value(hive, key, value):
"""Delete a registry value."""
access = winreg.KEY_ALL_ACCESS
with winreg.OpenKeyEx(hive, key, 0, access) as k:
winreg.DeleteValue(k, value)
def restore_default_uac():
"""Restores default UAC settings via the registry."""
if global_vars['OS']['Version'] == '10':
write_registry_settings(UAC_DEFAULTS_WIN10, all_users=True)
else:
# Haven't checked Win8 settings, only applying minimum set
write_registry_settings(UAC_DEFAULTS_WIN7, all_users=True)
if __name__ == '__main__':
print("This file is not meant to be called directly.")

978
scripts/wk.prev/functions/common.py
View file

@ -1,978 +0,0 @@
# Wizard Kit: Functions - Common
import os
import psutil
import re
import shutil
import subprocess
import sys
import time
import traceback
try:
import winreg
except ModuleNotFoundError:
if psutil.WINDOWS:
raise
from settings.main import *
from settings.tools import *
from settings.windows_builds import *
from subprocess import CalledProcessError
# Global variables
global_vars = {}
# STATIC VARIABLES
COLORS = {
'CLEAR': '\033[0m',
'RED': '\033[31m',
'ORANGE': '\033[31;1m',
'GREEN': '\033[32m',
'YELLOW': '\033[33m',
'BLUE': '\033[34m',
'PURPLE': '\033[35m',
'CYAN': '\033[36m',
}
try:
HKU = winreg.HKEY_USERS
HKCR = winreg.HKEY_CLASSES_ROOT
HKCU = winreg.HKEY_CURRENT_USER
HKLM = winreg.HKEY_LOCAL_MACHINE
except NameError:
if psutil.WINDOWS:
raise
# Error Classes
class BIOSKeyNotFoundError(Exception):
pass
class BinNotFoundError(Exception):
pass
class GenericAbort(Exception):
pass
class GenericError(Exception):
pass
class GenericRepair(Exception):
pass
class MultipleInstallationsError(Exception):
pass
class NoProfilesError(Exception):
pass
class Not4KAlignedError(Exception):
pass
class NotInstalledError(Exception):
pass
class OSInstalledLegacyError(Exception):
pass
class PathNotFoundError(Exception):
pass
class UnsupportedOSError(Exception):
pass
class SecureBootDisabledError(Exception):
pass
class SecureBootNotAvailError(Exception):
pass
class SecureBootUnknownError(Exception):
pass
class WindowsOutdatedError(Exception):
pass
class WindowsUnsupportedError(Exception):
pass
# Backported functions
def input_text(prompt):
"""Get input and avoid EOFErrors, returns str."""
prompt = str(prompt)
response = None
if prompt[-1:] != ' ':
prompt += ' '
while response is None:
try:
response = input(prompt)
except EOFError:
# Ignore and try again
print('', flush=True)
return response
# General functions
def abort(show_prompt=True):
"""Abort script."""
print_warning('Aborted.')
if show_prompt:
sleep(1)
pause(prompt='Press Enter to exit... ')
exit_script(1)
def ask(prompt='Kotaero!'):
"""Prompt the user with a Y/N question, returns bool."""
answer = None
prompt = '{} [Y/N]: '.format(prompt)
while answer is None:
tmp = input_text(prompt)
if re.search(r'^y(es|)$', tmp, re.IGNORECASE):
answer = True
elif re.search(r'^n(o|ope|)$', tmp, re.IGNORECASE):
answer = False
message = '{prompt}{answer_text}'.format(
prompt = prompt,
answer_text = 'Yes' if answer else 'No')
print_log(message=message)
return answer
def beep(repeat=1):
"""Play system bell with optional repeat."""
for i in range(repeat):
# Print bell char
print('\a')
sleep(0.5)
def choice(choices, prompt='Kotaero!'):
"""Prompt the user with a choice question, returns str."""
answer = None
choices = [str(c) for c in choices]
choices_short = {c[:1].upper(): c for c in choices}
prompt = '{} [{}]: '.format(prompt, '/'.join(choices))
regex = '^({}|{})$'.format(
'|'.join([c[:1] for c in choices]),
'|'.join(choices))
# Get user's choice
while answer is None:
tmp = input_text(prompt)
if re.search(regex, tmp, re.IGNORECASE):
answer = tmp
# Log result
message = '{prompt}{answer_text}'.format(
prompt = prompt,
answer_text = 'Yes' if answer else 'No')
print_log(message=message)
# Fix answer formatting to match provided values
answer = choices_short[answer[:1].upper()]
# Done
return answer
def clear_screen():
"""Simple wrapper for cls/clear."""
if psutil.WINDOWS:
os.system('cls')
else:
os.system('clear')
def convert_to_bytes(size):
"""Convert human-readable size str to bytes and return an int."""
size = str(size)
tmp = re.search(r'(\d+\.?\d*)\s+([PTGMKB])B?', size.upper())
if tmp:
size = float(tmp.group(1))
units = tmp.group(2)
if units == 'P':
size *= 1024 ** 5
if units == 'T':
size *= 1024 ** 4
elif units == 'G':
size *= 1024 ** 3
elif units == 'M':
size *= 1024 ** 2
elif units == 'K':
size *= 1024 ** 1
elif units == 'B':
size *= 1024 ** 0
size = int(size)
else:
return -1
return size
def exit_script(return_value=0):
"""Exits the script after some cleanup and opens the log (if set)."""
# Remove dirs (if empty)
for dir in ['BackupDir', 'LogDir', 'TmpDir']:
try:
os.rmdir(global_vars[dir])
except Exception:
pass
# Open Log (if it exists)
log = global_vars.get('LogFile', '')
if log and os.path.exists(log) and psutil.WINDOWS and ENABLED_OPEN_LOGS:
try:
extract_item('NotepadPlusPlus', silent=True)
popen_program(
[global_vars['Tools']['NotepadPlusPlus'],
global_vars['LogFile']])
except Exception:
print_error('ERROR: Failed to extract Notepad++ and open log.')
pause('Press Enter to exit...')
# Kill Caffeine if still running
kill_process('caffeine.exe')
# Exit
sys.exit(return_value)
def extract_item(item, filter='', silent=False):
"""Extract item from .cbin into .bin."""
cmd = [
global_vars['Tools']['SevenZip'], 'x', '-aos', '-bso0', '-bse0',
'-p{ArchivePassword}'.format(**global_vars),
r'-o{BinDir}\{item}'.format(item=item, **global_vars),
r'{CBinDir}\{item}.7z'.format(item=item, **global_vars),
filter]
if not silent:
print_standard('Extracting "{item}"...'.format(item=item))
try:
run_program(cmd)
except FileNotFoundError:
if not silent:
print_warning('WARNING: Archive not found')
except subprocess.CalledProcessError:
if not silent:
print_warning('WARNING: Errors encountered while exctracting data')
def get_process(name=None):
"""Get process by name, returns psutil.Process obj."""
proc = None
if not name:
raise GenericError
for p in psutil.process_iter():
try:
if p.name() == name:
proc = p
except psutil._exceptions.NoSuchProcess:
# Process finished during iteration? Going to ignore
pass
return proc
def get_simple_string(prompt='Enter string'):
"""Get string from user (restricted character set), returns str."""
simple_string = None
while simple_string is None:
_input = input_text('{}: '.format(prompt))
if re.match(r"^(\w|-| |\.|')+$", _input, re.ASCII):
simple_string = _input.strip()
return simple_string
def get_ticket_number():
"""Get TicketNumber from user, save in LogDir, and return as str."""
if not ENABLED_TICKET_NUMBERS:
return None
ticket_number = None
while ticket_number is None:
_input = input_text('Enter ticket number: ')
if re.match(r'^([0-9]+([-_]?\w+|))$', _input):
ticket_number = _input
out_file = r'{}\TicketNumber'.format(global_vars['LogDir'])
if not psutil.WINDOWS:
out_file = out_file.replace('\\', '/')
with open(out_file, 'w', encoding='utf-8') as f:
f.write(ticket_number)
return ticket_number
def human_readable_size(size, decimals=0):
"""Convert size from bytes to a human-readable format, returns str."""
# Prep string formatting
width = 3+decimals
if decimals > 0:
width += 1
# Convert size to int
try:
size = int(size)
except ValueError:
size = convert_to_bytes(size)
except TypeError:
size = -1
# Verify we have a valid size
if size < 0:
return '{size:>{width}} b'.format(size='???', width=width)
# Convert to sensible units
if size >= 1024 ** 5:
size /= 1024 ** 5
units = 'PB'
elif size >= 1024 ** 4:
size /= 1024 ** 4
units = 'TB'
elif size >= 1024 ** 3:
size /= 1024 ** 3
units = 'GB'
elif size >= 1024 ** 2:
size /= 1024 ** 2
units = 'MB'
elif size >= 1024 ** 1:
size /= 1024 ** 1
units = 'KB'
else:
size /= 1024 ** 0
units = ' B'
# Return
return '{size:>{width}.{decimals}f} {units}'.format(
size=size, width=width, decimals=decimals, units=units)
def kill_process(name):
"""Kill any running caffeine.exe processes."""
for proc in psutil.process_iter():
if proc.name() == name:
proc.kill()
def major_exception():
"""Display traceback and exit"""
print_error('Major exception')
print_warning(SUPPORT_MESSAGE)
print(traceback.format_exc())
print_log(traceback.format_exc())
try:
upload_crash_details()
except GenericAbort:
# User declined upload
print_warning('Upload: Aborted')
sleep(10)
except GenericError:
# No log file or uploading disabled
sleep(10)
except:
print_error('Upload: Failed')
sleep(10)
else:
print_success('Upload: Complete')
pause('Press Enter to exit...')
exit_script(1)
def menu_select(
title='[Untitled Menu]',
prompt='Please make a selection', secret_actions=[], secret_exit=False,
main_entries=[], action_entries=[], disabled_label='DISABLED',
spacer=''):
"""Display options in a menu and return selected option as a str."""
# Bail early
if not main_entries and not action_entries:
raise Exception("MenuError: No items given")
# Set title
if 'Title' in global_vars:
title = '{}\n\n{}'.format(global_vars['Title'], title)
# Build menu
menu_splash = '{}\n{}\n'.format(title, spacer)
width = len(str(len(main_entries)))
valid_answers = []
if secret_exit:
valid_answers.append('Q')
if secret_actions:
valid_answers.extend(secret_actions)
# Add main entries
for i in range(len(main_entries)):
entry = main_entries[i]
# Add Spacer
if ('CRLF' in entry):
menu_splash += '{}\n'.format(spacer)
entry_str = '{number:>{width}}: {name}'.format(
number = i+1,
width = width,
name = entry.get('Display Name', entry['Name']))
if entry.get('Disabled', False):
entry_str = '{YELLOW}{entry_str} ({disabled}){CLEAR}'.format(
entry_str = entry_str,
disabled = disabled_label,
**COLORS)
else:
valid_answers.append(str(i+1))
menu_splash += '{}\n'.format(entry_str)
menu_splash += '{}\n'.format(spacer)
# Add action entries
for entry in action_entries:
# Add Spacer
if ('CRLF' in entry):
menu_splash += '{}\n'.format(spacer)
valid_answers.append(entry['Letter'])
menu_splash += '{letter:>{width}}: {name}\n'.format(
letter = entry['Letter'].upper(),
width = len(str(len(action_entries))),
name = entry['Name'])
answer = ''
while (answer.upper() not in valid_answers):
clear_screen()
print(menu_splash)
answer = input_text('{}: '.format(prompt))
return answer.upper()
def non_clobber_rename(full_path):
"""Append suffix to path, if necessary, to avoid clobbering path"""
new_path = full_path
_i = 1;
while os.path.exists(new_path):
new_path = '{path}_{i}'.format(i=_i, path=full_path)
_i += 1
return new_path
def pause(prompt='Press Enter to continue... '):
"""Simple pause implementation."""
if prompt[-1] != ' ':
prompt += ' '
input_text(prompt)
def ping(addr='google.com'):
"""Attempt to ping addr."""
cmd = [
'ping',
'-n' if psutil.WINDOWS else '-c',
'2',
addr]
run_program(cmd)
def popen_program(cmd, pipe=False, minimized=False, shell=False, **kwargs):
"""Run program and return a subprocess.Popen object."""
cmd_kwargs = {'args': cmd, 'shell': shell}
for kw in ('encoding', 'errors'):
if kw in kwargs:
cmd_kwargs[kw] = kwargs[kw]
if minimized:
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags = subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = 6
cmd_kwargs['startupinfo'] = startupinfo
if pipe:
cmd_kwargs.update({
'stdout': subprocess.PIPE,
'stderr': subprocess.PIPE,
})
if 'cwd' in kwargs:
cmd_kwargs['cwd'] = kwargs['cwd']
return subprocess.Popen(**cmd_kwargs)
def print_error(*args, **kwargs):
"""Prints message to screen in RED."""
print_standard(*args, color=COLORS['RED'], **kwargs)
def print_info(*args, **kwargs):
"""Prints message to screen in BLUE."""
print_standard(*args, color=COLORS['BLUE'], **kwargs)
def print_standard(message='Generic info',
color=None, end='\n', timestamp=True, **kwargs):
"""Prints message to screen and log (if set)."""
display_message = message
if color:
display_message = color + message + COLORS['CLEAR']
# **COLORS is used below to support non-"standard" color printing
print(display_message.format(**COLORS), end=end, **kwargs)
print_log(message, end, timestamp)
def print_success(*args, **kwargs):
"""Prints message to screen in GREEN."""
print_standard(*args, color=COLORS['GREEN'], **kwargs)
def print_warning(*args, **kwargs):
"""Prints message to screen in YELLOW."""
print_standard(*args, color=COLORS['YELLOW'], **kwargs)
def print_log(message='', end='\n', timestamp=True):
"""Writes message to a log if LogFile is set."""
time_str = time.strftime("%Y-%m-%d %H%M%z: ") if timestamp else ''
if 'LogFile' in global_vars and global_vars['LogFile']:
with open(global_vars['LogFile'], 'a', encoding='utf-8') as f:
for line in message.splitlines():
f.write('{timestamp}{line}{end}'.format(
timestamp = time_str,
line = line,
end = end))
def run_program(cmd, check=True, pipe=True, shell=False, **kwargs):
"""Run program and return a subprocess.CompletedProcess object."""
cmd = [c for c in cmd if c]
if shell:
cmd = ' '.join(cmd)
cmd_kwargs = {'args': cmd, 'check': check, 'shell': shell}
for kw in ('encoding', 'errors'):
if kw in kwargs:
cmd_kwargs[kw] = kwargs[kw]
if pipe:
cmd_kwargs.update({
'stdout': subprocess.PIPE,
'stderr': subprocess.PIPE,
})
if 'cwd' in kwargs:
cmd_kwargs['cwd'] = kwargs['cwd']
return subprocess.run(**cmd_kwargs)
def set_title(title='[Some Title]'):
"""Set title.
Used for window title and menu titles."""
global_vars['Title'] = title
os.system('title {}'.format(title))
def show_data(
message='[Some message]', data='[Some data]',
indent=8, width=32,
info=False, warning=False, error=False):
"""Display info with formatting."""
message = '{indent}{message:<{width}}{data}'.format(
indent=' '*indent, width=width, message=message, data=data)
if error:
print_error(message)
elif warning:
print_warning(message)
elif info:
print_info(message)
else:
print_standard(message)
def sleep(seconds=2):
"""Wait for a while."""
time.sleep(seconds)
def stay_awake():
"""Prevent the system from sleeping or hibernating."""
# DISABLED due to VCR2008 dependency
return
# Bail if caffeine is already running
for proc in psutil.process_iter():
if proc.name() == 'caffeine.exe':
return
# Extract and run
extract_item('Caffeine', silent=True)
try:
popen_program([global_vars['Tools']['Caffeine']])
except Exception:
print_error('ERROR: No caffeine available.')
print_warning('Please set the power setting to High Performance.')
def strip_colors(s):
"""Remove all ASCII color escapes from string, returns str."""
for c in COLORS.values():
s = s.replace(c, '')
return s
def get_exception(s):
"""Get exception by name, returns Exception object."""
try:
obj = getattr(sys.modules[__name__], s)
except AttributeError:
# Try builtin classes
obj = getattr(sys.modules['builtins'], s)
return obj
def try_and_print(message='Trying...',
function=None, cs='SUCCESS', ns='FAILED', other_results={},
catch_all=True, print_return=False, silent_function=True,
indent=8, width=32, *args, **kwargs):
"""Run function, print if successful or not, and return dict.
other_results is in the form of
{
'Warning': {'ExceptionClassName': 'Result Message'},
'Error': {'ExceptionClassName': 'Result Message'}
}
The the ExceptionClassNames will be excepted conditions
and the result string will be printed in the correct color.
catch_all=False will re-raise unspecified exceptions."""
err = None
out = None
w_exceptions = other_results.get('Warning', {}).keys()
w_exceptions = tuple(get_exception(e) for e in w_exceptions)
e_exceptions = other_results.get('Error', {}).keys()
e_exceptions = tuple(get_exception(e) for e in e_exceptions)
w_results = other_results.get('Warning', {})
e_results = other_results.get('Error', {})
# Run function and catch errors
print_standard('{indent}{message:<{width}}'.format(
indent=' '*indent, message=message, width=width), end='', flush=True)
try:
out = function(*args, **kwargs)
if print_return:
str_list = out
if isinstance(out, subprocess.CompletedProcess):
str_list = out.stdout.decode().strip().splitlines()
print_standard(str_list[0].strip(), timestamp=False)
for item in str_list[1:]:
print_standard('{indent}{item}'.format(
indent=' '*(indent+width), item=item.strip()))
elif silent_function:
print_success(cs, timestamp=False)
except w_exceptions as e:
_result = w_results.get(e.__class__.__name__, 'Warning')
print_warning(_result, timestamp=False)
err = e
except e_exceptions as e:
_result = e_results.get(e.__class__.__name__, 'Error')
print_error(_result, timestamp=False)
err = e
except Exception:
print_error(ns, timestamp=False)
err = traceback.format_exc()
# Return or raise?
if err and not catch_all:
raise
else:
return {'CS': not bool(err), 'Error': err, 'Out': out}
def upload_crash_details():
"""Upload log and runtime data to the CRASH_SERVER.
Intended for uploading to a public Nextcloud share."""
if not ENABLED_UPLOAD_DATA:
raise GenericError
import requests
if 'LogFile' in global_vars and global_vars['LogFile']:
if ask('Upload crash details to {}?'.format(CRASH_SERVER['Name'])):
with open(global_vars['LogFile']) as f:
certificate_authority = r'{}\{}'.format(
global_vars['BinDir'], ROOT_CA_NAME)
if psutil.LINUX:
# Use system certificates
certificate_authority = True
data = '{}\n'.format(f.read())
data += '#############################\n'
data += 'Runtime Details:\n\n'
data += 'sys.argv: {}\n\n'.format(sys.argv)
try:
data += generate_global_vars_report()
except Exception:
data += 'global_vars: {}\n'.format(global_vars)
filename = global_vars.get('LogFile', 'Unknown')
filename = re.sub(r'.*(\\|/)', '', filename)
filename += '.txt'
url = '{}/Crash_{}__{}'.format(
CRASH_SERVER['Url'],
global_vars.get('Date-Time', 'Unknown Date-Time'),
filename)
r = requests.put(
url, data=data,
headers={'X-Requested-With': 'XMLHttpRequest'},
auth=(CRASH_SERVER['User'], CRASH_SERVER['Pass']),
verify=certificate_authority)
# Raise exception if upload failed
if not r.ok:
raise Exception
else:
# User said no
raise GenericAbort
else:
# No LogFile defined (or invalid LogFile)
raise GenericError
def wait_for_process(name, poll_rate=3):
"""Wait for process by name."""
running = True
while running:
sleep(poll_rate)
running = False
for proc in psutil.process_iter():
try:
if re.search(r'^{}'.format(name), proc.name(), re.IGNORECASE):
running = True
except psutil._exceptions.NoSuchProcess:
# Assuming process closed during iteration
pass
sleep(1)
# global_vars functions
def init_global_vars(silent=False):
"""Sets global variables based on system info."""
if not silent:
print_info('Initializing')
if psutil.WINDOWS:
os.system('title Wizard Kit')
if psutil.LINUX:
init_functions = [
['Checking environment...', set_linux_vars],
['Clearing collisions...', clean_env_vars],
]
else:
init_functions = [
['Checking .bin...', find_bin],
['Checking environment...', set_common_vars],
['Checking OS...', check_os],
['Checking tools...', check_tools],
['Creating folders...', make_tmp_dirs],
['Clearing collisions...', clean_env_vars],
]
try:
if silent:
for f in init_functions:
f[1]()
else:
for f in init_functions:
try_and_print(
message=f[0], function=f[1],
cs='Done', ns='Error', catch_all=False)
except:
major_exception()
def check_os():
"""Set OS specific variables."""
tmp = {}
# Query registry
path = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion'
with winreg.OpenKey(HKLM, path) as key:
for name in ['CurrentBuild', 'CurrentVersion', 'ProductName']:
try:
tmp[name] = winreg.QueryValueEx(key, name)[0]
except FileNotFoundError:
tmp[name] = 'Unknown'
# Handle CurrentBuild collision
if tmp['CurrentBuild'] == '9200':
if tmp['CurrentVersion'] == '6.2':
# Windown 8, set to fake build number
tmp['CurrentBuild'] = '9199'
else:
# Windows 8.1, leave alone
pass
# Check bit depth
tmp['Arch'] = 32
if 'PROGRAMFILES(X86)' in global_vars['Env']:
tmp['Arch'] = 64
# Get Windows build info
build_info = WINDOWS_BUILDS.get(tmp['CurrentBuild'], None)
if build_info is None:
# Not in windows_builds.py
build_info = [
'Unknown',
'Build {}'.format(tmp['CurrentBuild']),
None,
None,
'unrecognized']
else:
build_info = list(build_info)
tmp['Version'] = build_info.pop(0)
tmp['Release'] = build_info.pop(0)
tmp['Codename'] = build_info.pop(0)
tmp['Marketing Name'] = build_info.pop(0)
tmp['Notes'] = build_info.pop(0)
# Set name
tmp['Name'] = tmp['ProductName']
if tmp['Release']:
tmp['Name'] += ' {}'.format(tmp['Release'])
if tmp['Codename']:
tmp['Name'] += ' "{}"'.format(tmp['Codename'])
if tmp['Marketing Name']:
tmp['Name'] += ' / "{}"'.format(tmp['Marketing Name'])
tmp['Name'] = re.sub(r'\s+', ' ', tmp['Name'])
# Set display name
tmp['DisplayName'] = '{} x{}'.format(tmp['Name'], tmp['Arch'])
if tmp['Notes']:
tmp['DisplayName'] += ' ({})'.format(tmp['Notes'])
global_vars['OS'] = tmp
def check_tools():
"""Set tool variables based on OS bit-depth and tool availability."""
if global_vars['OS'].get('Arch', 32) == 64:
global_vars['Tools'] = {
k: v.get('64', v.get('32')) for (k, v) in TOOLS.items()}
else:
global_vars['Tools'] = {k: v.get('32') for (k, v) in TOOLS.items()}
# Fix paths
global_vars['Tools'] = {k: os.path.join(global_vars['BinDir'], v)
for (k, v) in global_vars['Tools'].items()}
def clean_env_vars():
"""Remove conflicting global_vars and env variables.
This fixes an issue where both global_vars and
global_vars['Env'] are expanded at the same time."""
for key in global_vars.keys():
global_vars['Env'].pop(key, None)
def find_bin():
"""Find .bin folder in the cwd or it's parents."""
wd = os.getcwd()
base = None
while base is None:
if os.path.exists('.bin'):
base = os.getcwd()
break
if re.fullmatch(r'\w:\\', os.getcwd()):
break
os.chdir('..')
os.chdir(wd)
if base is None:
raise BinNotFoundError
global_vars['BaseDir'] = base
def generate_global_vars_report():
"""Build readable string from global_vars, returns str."""
report = ['global_vars: {']
for k, v in sorted(global_vars.items()):
if k == 'Env':
continue
if isinstance(v, list):
report.append(' {}: ['.format(str(k)))
for item in v:
report.append(' {}'.format(str(v)))
report.append(' ]')
elif isinstance(v, dict):
report.append(' {}: {{'.format(str(k)))
for item_k, item_v in sorted(v.items()):
report.append(' {:<15} {}'.format(
str(item_k)+':', str(item_v)))
report.append(' }')
else:
report.append(' {:<18}{}'.format(str(k)+':', str(v)))
report.append(' Env:')
for k, v in sorted(global_vars.get('Env', {}).items()):
report.append(' {:<15} {}'.format(
str(k)+':', str(v)))
report.append('}')
return '\n'.join(report)
def make_tmp_dirs():
"""Make temp directories."""
os.makedirs(global_vars['BackupDir'], exist_ok=True)
os.makedirs(global_vars['LogDir'], exist_ok=True)
os.makedirs(r'{}\{}'.format(
global_vars['LogDir'], KIT_NAME_FULL), exist_ok=True)
os.makedirs(r'{}\Tools'.format(global_vars['LogDir']), exist_ok=True)
os.makedirs(global_vars['TmpDir'], exist_ok=True)
def set_common_vars():
"""Set common variables."""
global_vars['Date'] = time.strftime("%Y-%m-%d")
global_vars['Date-Time'] = time.strftime("%Y-%m-%d_%H%M_%z")
global_vars['Env'] = os.environ.copy()
global_vars['ArchivePassword'] = ARCHIVE_PASSWORD
global_vars['BinDir'] = r'{BaseDir}\.bin'.format(**global_vars)
global_vars['CBinDir'] = r'{BaseDir}\.cbin'.format(**global_vars)
global_vars['ClientDir'] = r'{SYSTEMDRIVE}\{prefix}'.format(
prefix=KIT_NAME_SHORT, **global_vars['Env'])
global_vars['BackupDir'] = r'{ClientDir}\Backups'.format(**global_vars)
global_vars['LogDir'] = r'{ClientDir}\Logs\{Date}'.format(**global_vars)
global_vars['QuarantineDir'] = r'{ClientDir}\Quarantine'.format(**global_vars)
global_vars['TmpDir'] = r'{BinDir}\tmp'.format(**global_vars)
def set_linux_vars():
"""Set common variables in a Linux environment.
These assume we're running under a WK-Linux build."""
result = run_program(['mktemp', '-d'])
global_vars['TmpDir'] = result.stdout.decode().strip()
global_vars['Date'] = time.strftime("%Y-%m-%d")
global_vars['Date-Time'] = time.strftime("%Y-%m-%d_%H%M_%z")
global_vars['Env'] = os.environ.copy()
global_vars['BinDir'] = '/usr/local/bin'
global_vars['LogDir'] = '{}/Logs'.format(global_vars['Env']['HOME'])
global_vars['Tools'] = {
'wimlib-imagex': 'wimlib-imagex',
'SevenZip': '7z',
}
def set_log_file(log_name):
"""Sets global var LogFile and creates path as needed."""
if psutil.LINUX:
folder_path = global_vars['LogDir']
else:
folder_path = '{}{}{}'.format(
global_vars['LogDir'],
os.sep,
KIT_NAME_FULL)
log_file = '{}{}{}'.format(
folder_path,
os.sep,
log_name)
os.makedirs(folder_path, exist_ok=True)
global_vars['LogFile'] = log_file
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

854
scripts/wk.prev/functions/data.py
View file

@ -1,854 +0,0 @@
# Wizard Kit: Functions - Data
import ctypes
from functions.json import *
from operator import itemgetter
from settings.data import *
# Classes
class LocalDisk():
def __init__(self, disk):
self.disk = disk
self.name = disk.mountpoint.upper()
self.path = self.name
def is_dir(self):
# Should always be true
return True
def is_file(self):
# Should always be false
return False
class SourceItem():
def __init__(self, name, path):
self.name = name
self.path = path
# Functions
def cleanup_transfer(dest_path):
"""Fix attributes and move excluded items to separate folder."""
try:
# Remove dest_path if empty
os.rmdir(dest_path)
except OSError:
pass
if not os.path.exists(dest_path):
# Bail if dest_path was empty and removed
raise Exception
# Fix attributes
cmd = ['attrib', '-a', '-h', '-r', '-s', dest_path]
run_program(cmd, check=False)
for root, dirs, files in os.walk(dest_path, topdown=False):
for name in dirs:
# Remove empty directories and junction points
try:
os.rmdir(os.path.join(root, name))
except OSError:
pass
for name in files:
# "Remove" files based on exclusion regex
if REGEX_EXCL_ITEMS.search(name):
# Make dest folder
dest_name = root.replace(dest_path, dest_path+'.Removed')
os.makedirs(dest_name, exist_ok=True)
# Set dest filename
dest_name = os.path.join(dest_name, name)
dest_name = non_clobber_rename(dest_name)
source_name = os.path.join(root, name)
try:
shutil.move(source_name, dest_name)
except Exception:
pass
def find_core_storage_volumes(device_path=None):
"""Try to create block devices for any Apple CoreStorage volumes."""
corestorage_uuid = '53746f72-6167-11aa-aa11-00306543ecac'
dmsetup_cmd_file = '{TmpDir}/dmsetup_command'.format(**global_vars)
# Get CoreStorage devices
cmd = [
'lsblk', '--json', '--list', '--paths',
'--output', 'NAME,PARTTYPE']
if device_path:
cmd.append(device_path)
json_data = get_json_from_command(cmd)
devs = json_data.get('blockdevices', [])
devs = [d for d in devs if d.get('parttype', '') == corestorage_uuid]
if devs:
print_standard(' ')
print_standard('Detected CoreStorage partition{}'.format(
'' if len(devs) == 1 else 's'))
print_standard(' Scanning for inner volume(s)....')
# Search for inner volumes and setup dev mappers
for dev in devs:
dev_path = dev.get('name', '')
if not dev_path:
# Can't setup block device without the dev path
continue
dev_name = re.sub(r'.*/', '', dev_path)
log_path = '{LogDir}/testdisk_{dev_name}.log'.format(
dev_name=dev_name, **global_vars)
# Run TestDisk
cmd = [
'sudo', 'testdisk',
'/logname', log_path, '/debug', '/log',
'/cmd', dev_path, 'partition_none,analyze']
result = run_program(cmd, check=False)
if result.returncode:
# i.e. return code is non-zero
continue
if not os.path.exists(log_path):
# TestDisk failed to write log
continue
# Check log for found volumes
cs_vols = {}
with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
for line in f.readlines():
r = re.match(
r'^.*echo "([^"]+)" . dmsetup create test(\d)$',
line.strip(),
re.IGNORECASE)
if r:
cs_name = 'CoreStorage_{}_{}'.format(dev_name, r.group(2))
cs_vols[cs_name] = r.group(1)
# Create mapper device(s)
for name, dm_cmd in sorted(cs_vols.items()):
with open(dmsetup_cmd_file, 'w') as f:
f.write(dm_cmd)
cmd = ['sudo', 'dmsetup', 'create', name, dmsetup_cmd_file]
run_program(cmd, check=False)
def fix_path_sep(path_str):
"""Replace non-native and duplicate dir separators, returns str."""
return re.sub(r'(\\|/)+', lambda s: os.sep, path_str)
def is_valid_wim_file(item):
"""Checks if the item is a valid WIM file, returns bool."""
valid = bool(item.is_file() and REGEX_WIM_FILE.search(item.name))
if valid:
extract_item('wimlib', silent=True)
cmd = [global_vars['Tools']['wimlib-imagex'], 'info', item.path]
try:
run_program(cmd)
except subprocess.CalledProcessError:
valid = False
print_log('WARNING: Image "{}" damaged.'.format(item.name))
return valid
def get_mounted_volumes():
"""Get mounted volumes, returns dict."""
cmd = [
'findmnt',
'--list',
'--json',
'--bytes',
'--invert',
'--types', (
'autofs,binfmt_misc,bpf,cgroup,cgroup2,configfs,debugfs,devpts,'
'devtmpfs,hugetlbfs,mqueue,proc,pstore,securityfs,sysfs,tmpfs'
),
'--output', 'SOURCE,TARGET,FSTYPE,LABEL,SIZE,AVAIL,USED']
json_data = get_json_from_command(cmd)
mounted_volumes = []
for item in json_data.get('filesystems', []):
mounted_volumes.append(item)
mounted_volumes.extend(item.get('children', []))
return {item['source']: item for item in mounted_volumes}
def mount_volumes(
all_devices=True, device_path=None,
read_write=False, core_storage=True):
"""Mount all detected filesystems."""
report = {}
cmd = [
'lsblk', '--json', '--paths',
'--output', 'NAME,FSTYPE,LABEL,UUID,PARTTYPE,TYPE,SIZE']
if not all_devices and device_path:
# Only mount volumes for specific device
cmd.append(device_path)
# Check for Apple CoreStorage volumes first
if core_storage:
find_core_storage_volumes(device_path)
# Get list of block devices
json_data = get_json_from_command(cmd)
devs = json_data.get('blockdevices', [])
# Get list of volumes
volumes = {}
for dev in devs:
if not dev.get('children', []):
volumes.update({dev['name']: dev})
for child in dev.get('children', []):
if not child.get('children', []):
volumes.update({child['name']: child})
for grandchild in child.get('children', []):
volumes.update({grandchild['name']: grandchild})
for great_grandchild in grandchild.get('children', []):
volumes.update({great_grandchild['name']: great_grandchild})
# Get list of mounted volumes
mounted_volumes = get_mounted_volumes()
# Loop over volumes
for vol_path, vol_data in volumes.items():
vol_data['show_data'] = {
'message': vol_path.replace('/dev/mapper/', ''),
'data': None,
}
if re.search(r'^loop\d', vol_path, re.IGNORECASE):
# Skip loopback devices
vol_data['show_data']['data'] = 'Skipped'
vol_data['show_data']['warning'] = True
report[vol_path] = vol_data
elif 'children' in vol_data:
# Skip LVM/RAID partitions (the real volume is mounted separately)
vol_data['show_data']['data'] = vol_data.get('fstype', 'Unknown')
if vol_data.get('label', None):
vol_data['show_data']['data'] += ' "{}"'.format(vol_data['label'])
vol_data['show_data']['info'] = True
report[vol_path] = vol_data
else:
if vol_path in mounted_volumes:
vol_data['show_data']['warning'] = True
else:
# Mount volume
cmd = ['udevil', 'mount',
'-o', 'rw' if read_write else 'ro',
vol_path]
try:
run_program(cmd)
except subprocess.CalledProcessError:
vol_data['show_data']['data'] = 'Failed to mount'
vol_data['show_data']['error'] = True
# Update mounted_volumes data
mounted_volumes = get_mounted_volumes()
# Format pretty result string
if vol_data['show_data']['data'] == 'Failed to mount':
vol_data['mount_point'] = None
else:
fstype = vol_data.get('fstype', 'UNKNOWN FS')
size_used = human_readable_size(
mounted_volumes[vol_path]['used'],
decimals=1,
)
size_avail = human_readable_size(
mounted_volumes[vol_path]['avail'],
decimals=1,
)
vol_data['size_avail'] = size_avail
vol_data['size_used'] = size_used
vol_data['mount_point'] = mounted_volumes[vol_path]['target']
vol_data['show_data']['data'] = 'Mounted on {}'.format(
mounted_volumes[vol_path]['target'])
vol_data['show_data']['data'] = '{:40} ({}, {} used, {} free)'.format(
vol_data['show_data']['data'],
fstype,
size_used,
size_avail)
# Update report
report[vol_path] = vol_data
return report
def mount_backup_shares(read_write=False):
"""Mount the backup shares unless labeled as already mounted."""
if psutil.LINUX:
mounted_volumes = get_mounted_volumes()
for server in BACKUP_SERVERS:
if psutil.LINUX:
# Update mounted status
source = '//{IP}/{Share}'.format(**server)
dest = '/Backups/{Name}'.format(**server)
mounted_str = '(Already) Mounted {}'.format(dest)
data = mounted_volumes.get(source, {})
if dest == data.get('target', ''):
server['Mounted'] = True
elif psutil.WINDOWS:
mounted_str = '(Already) Mounted {Name}'.format(**server)
if server['Mounted']:
print_warning(mounted_str)
continue
mount_network_share(server, read_write)
def mount_network_share(server, read_write=False):
"""Mount a network share defined by server."""
uid = '1000'
# Get UID
cmd = ['id', '--user', 'tech']
result = run_program(cmd, check=False, encoding='utf-8', errors='ignore')
if result.stdout.strip().isnumeric():
uid = result.stdout.strip()
if read_write:
username = server['RW-User']
password = server['RW-Pass']
else:
username = server['User']
password = server['Pass']
if psutil.WINDOWS:
cmd = [
'net', 'use', r'\\{IP}\{Share}'.format(**server),
'/user:{}'.format(username), password]
warning = r'Failed to mount \\{Name}\{Share}, {IP} unreachable.'.format(
**server)
error = r'Failed to mount \\{Name}\{Share} ({IP})'.format(**server)
success = 'Mounted {Name}'.format(**server)
elif psutil.LINUX:
# Make mountpoint
cmd = [
'sudo', 'mkdir', '-p',
'/Backups/{Name}'.format(**server)]
run_program(cmd)
# Set mount options
cmd_options = [
# Assuming GID matches UID
'gid={}'.format(uid),
'uid={}'.format(uid),
]
cmd_options.append('rw' if read_write else 'ro')
cmd_options.append('username={}'.format(username))
if password:
cmd_options.append('password={}'.format(password))
else:
# Skip password check
cmd_options.append('guest')
# Set mount command
cmd = [
'sudo', 'mount',
'//{IP}/{Share}'.format(**server).replace('\\', '/'),
'/Backups/{Name}'.format(**server),
'-o', ','.join(cmd_options),
]
# Set result messages
warning = 'Failed to mount /Backups/{Name}, {IP} unreachable.'.format(
**server)
error = 'Failed to mount /Backups/{Name}'.format(**server)
success = 'Mounted /Backups/{Name}'.format(**server)
# Test connection
try:
ping(server['IP'])
except subprocess.CalledProcessError:
print_warning(warning)
sleep(1)
return False
# Mount
try:
run_program(cmd)
except Exception:
print_error(error)
sleep(1)
else:
print_info(success)
server['Mounted'] = True
def run_fast_copy(items, dest):
"""Copy items to dest using FastCopy."""
if not items:
raise Exception
cmd = [global_vars['Tools']['FastCopy'], *FAST_COPY_ARGS]
cmd.append(r'/logfile={LogDir}\Tools\FastCopy.log'.format(**global_vars))
cmd.extend(items)
cmd.append('/to={}\\'.format(dest))
run_program(cmd)
def run_wimextract(source, items, dest):
"""Extract items from source WIM to dest folder."""
if not items:
raise Exception
extract_item('wimlib', silent=True)
# Write files.txt
with open(r'{}\wim_files.txt'.format(global_vars['TmpDir']), 'w',
encoding='utf-8') as f:
# Defaults
for item in items:
f.write('{}\n'.format(item))
sleep(1) # For safety?
# Extract files
cmd = [
global_vars['Tools']['wimlib-imagex'],
'extract',
source, '1',
r'@{}\wim_files.txt'.format(global_vars['TmpDir']),
'--dest-dir={}\\'.format(dest),
'--no-acls',
'--nullglob']
run_program(cmd)
def list_source_items(source_obj, rel_path=None):
"""List items in a dir or WIM, returns list of SourceItem objects."""
items = []
rel_path = '{}{}'.format(os.sep, rel_path) if rel_path else ''
if source_obj.is_dir():
source_path = '{}{}'.format(source_obj.path, rel_path)
items = [SourceItem(name=item.name, path=item.path)
for item in os.scandir(source_path)]
else:
# Prep wimlib-imagex
if psutil.WINDOWS:
extract_item('wimlib', silent=True)
cmd = [
global_vars['Tools']['wimlib-imagex'], 'dir',
source_obj.path, '1']
if rel_path:
cmd.append('--path={}'.format(rel_path))
# Get item list
try:
items = run_program(cmd)
except subprocess.CalledProcessError:
print_error('ERROR: Failed to get file list.')
raise
# Strip non-root items
items = [fix_path_sep(i.strip())
for i in items.stdout.decode('utf-8', 'ignore').splitlines()]
if rel_path:
items = [i.replace(rel_path, '') for i in items]
items = [i for i in items
if i.count(os.sep) == 1 and i.strip() != os.sep]
items = [SourceItem(name=i[1:], path=rel_path+i) for i in items]
# Done
return items
def scan_source(source_obj, dest_path, rel_path='', interactive=True):
"""Scan source for files/folders to transfer, returns list.
This will scan the root and (recursively) any Windows.old folders."""
selected_items = []
win_olds = []
# Root Items
root_items = []
item_list = list_source_items(source_obj, rel_path)
for item in item_list:
if REGEX_WINDOWS_OLD.search(item.name):
item.name = '{}{}{}'.format(
rel_path,
os.sep if rel_path else '',
item.name)
win_olds.append(item)
elif REGEX_INCL_ROOT_ITEMS.search(item.name):
print_success('Auto-Selected: {}'.format(item.path))
root_items.append('{}'.format(item.path))
elif not REGEX_EXCL_ROOT_ITEMS.search(item.name):
if not interactive:
print_success('Auto-Selected: {}'.format(item.path))
root_items.append('{}'.format(item.path))
else:
prompt = 'Transfer: "{}{}{}" ?'.format(
rel_path,
os.sep if rel_path else '',
item.name)
choices = ['Yes', 'No', 'All', 'Quit']
answer = choice(prompt=prompt, choices=choices)
if answer == 'Quit':
abort()
elif answer == 'All':
interactive = False
if answer in ['Yes', 'All']:
root_items.append('{}'.format(item.path))
if root_items:
selected_items.append({
'Message': '{}{}Root Items...'.format(
rel_path,
' ' if rel_path else ''),
'Items': root_items.copy(),
'Destination': dest_path})
# Fonts
font_obj = get_source_item_obj(source_obj, rel_path, 'Windows/Fonts')
if font_obj:
selected_items.append({
'Message': '{}{}Fonts...'.format(
rel_path,
' ' if rel_path else ''),
'Items': [font_obj.path],
'Destination': '{}{}Windows'.format(
dest_path, os.sep)})
# Registry
registry_items = []
for folder in ['config', 'OEM']:
folder_obj = get_source_item_obj(
source_obj, rel_path, 'Windows/System32/{}'.format(folder))
if folder_obj:
registry_items.append(folder_obj.path)
if registry_items:
selected_items.append({
'Message': '{}{}Registry...'.format(
rel_path,
' ' if rel_path else ''),
'Items': registry_items.copy(),
'Destination': '{}{}Windows{}System32'.format(
dest_path, os.sep, os.sep)})
# Windows.old(s)
for old in win_olds:
selected_items.extend(scan_source(
source_obj,
'{}{}{}'.format(dest_path, os.sep, old.name),
rel_path=old.name,
interactive=False))
# Done
return selected_items
def get_source_item_obj(source_obj, rel_path, item_path):
"""Check if the item exists, returns SourceItem object or None."""
item_obj = None
item_path = fix_path_sep(item_path)
if source_obj.is_dir():
item_obj = SourceItem(
name = item_path,
path = '{}{}{}{}{}'.format(
source_obj.path,
os.sep,
rel_path,
os.sep if rel_path else '',
item_path))
if not os.path.exists(item_obj.path):
item_obj = None
else:
# Assuming WIM file
if psutil.WINDOWS:
extract_item('wimlib', silent=True)
cmd = [
global_vars['Tools']['wimlib-imagex'], 'dir',
source_obj.path, '1',
'--path={}'.format(item_path),
'--one-file-only']
try:
run_program(cmd)
except subprocess.CalledProcessError:
# function will return None below
pass
else:
item_obj = SourceItem(
name = item_path,
path = '{}{}{}{}'.format(
os.sep,
rel_path,
os.sep if rel_path else '',
item_path))
return item_obj
def select_destination(folder_path, prompt='Select destination'):
"""Select destination drive, returns path as string."""
disk = select_volume(prompt)
if 'fixed' not in disk['Disk'].opts:
folder_path = folder_path.replace('\\', '-')
path = '{disk}{folder_path}_{Date}'.format(
disk = disk['Disk'].mountpoint,
folder_path = folder_path,
**global_vars)
# Avoid merging with existing folder
path = non_clobber_rename(path)
os.makedirs(path, exist_ok=True)
return path
def select_source(backup_prefix):
"""Select matching backup from BACKUP_SERVERS, returns obj."""
selected_source = None
local_sources = []
remote_sources = []
sources = []
mount_backup_shares(read_write=False)
# Check for prefix folders on servers
for server in BACKUP_SERVERS:
if server['Mounted']:
print_standard('Scanning {}...'.format(server['Name']))
for d in os.scandir(r'\\{IP}\{Share}'.format(**server)):
if (d.is_dir()
and d.name.lower().startswith(backup_prefix.lower())):
# Add folder to remote_sources
remote_sources.append({
'Name': '{:9}| File-Based: [DIR] {}'.format(
server['Name'], d.name),
'Server': server,
'Sort': d.name,
'Source': d})
# Check for images and subfolders
for prefix_path in remote_sources.copy():
for item in os.scandir(prefix_path['Source'].path):
if item.is_dir():
# Add folder to remote_sources
remote_sources.append({
'Name': r'{:9}| File-Based: [DIR] {}\{}'.format(
prefix_path['Server']['Name'], # Server
prefix_path['Source'].name, # Prefix folder
item.name, # Sub-folder
),
'Server': prefix_path['Server'],
'Sort': r'{}\{}'.format(
prefix_path['Source'].name, # Prefix folder
item.name, # Sub-folder
),
'Source': item})
# Check for images in folder
for subitem in os.scandir(item.path):
if REGEX_WIM_FILE.search(item.name):
# Add image to remote_sources
try:
size = human_readable_size(item.stat().st_size)
except Exception:
size = ' ? ?' # unknown
remote_sources.append({
'Disabled': bool(not is_valid_wim_file(subitem)),
'Name': r'{:9}| Image-Based: {:>7} {}\{}\{}'.format(
prefix_path['Server']['Name'], # Server
size, # Size (duh)
prefix_path['Source'].name, # Prefix folder
item.name, # Sub-folder
subitem.name, # Image file
),
'Server': prefix_path['Server'],
'Sort': r'{}\{}\{}'.format(
prefix_path['Source'].name, # Prefix folder
item.name, # Sub-folder
subitem.name, # Image file
),
'Source': subitem})
elif REGEX_WIM_FILE.search(item.name):
# Add image to remote_sources
try:
size = human_readable_size(item.stat().st_size)
except Exception:
size = ' ? ?' # unknown
remote_sources.append({
'Disabled': bool(not is_valid_wim_file(item)),
'Name': r'{:9}| Image-Based: {:>7} {}\{}'.format(
prefix_path['Server']['Name'], # Server
size, # Size (duh)
prefix_path['Source'].name, # Prefix folder
item.name, # Image file
),
'Server': prefix_path['Server'],
'Sort': r'{}\{}'.format(
prefix_path['Source'].name, # Prefix folder
item.name, # Image file
),
'Source': item})
# Check for local sources
print_standard('Scanning for local sources...')
set_thread_error_mode(silent=True) # Prevents "No disk" popups
sys_drive = global_vars['Env']['SYSTEMDRIVE']
for d in psutil.disk_partitions():
if re.search(r'^{}'.format(sys_drive), d.mountpoint, re.IGNORECASE):
# Skip current OS drive
continue
if 'fixed' in d.opts:
# Skip DVD, etc
local_sources.append({
'Name': '{:9}| File-Based: [DISK] {}'.format(
' Local', d.mountpoint),
'Sort': d.mountpoint,
'Source': LocalDisk(d)})
# Check for images and subfolders
for item in os.scandir(d.mountpoint):
if REGEX_WIM_FILE.search(item.name):
try:
size = human_readable_size(item.stat().st_size)
except Exception:
size = ' ? ?' # unknown
local_sources.append({
'Disabled': bool(not is_valid_wim_file(item)),
'Name': r'{:9}| Image-Based: {:>7} {}{}'.format(
' Local', size, d.mountpoint, item.name),
'Sort': r'{}{}'.format(d.mountpoint, item.name),
'Source': item})
elif REGEX_EXCL_ROOT_ITEMS.search(item.name):
pass
elif REGEX_EXCL_ITEMS.search(item.name):
pass
elif item.is_dir():
# Add folder to local_sources
local_sources.append({
'Name': r'{:9}| File-Based: [DIR] {}{}'.format(
' Local', d.mountpoint, item.name),
'Sort': r'{}{}'.format(d.mountpoint, item.name),
'Source': item})
set_thread_error_mode(silent=False) # Return to normal
# Build Menu
local_sources.sort(key=itemgetter('Sort'))
remote_sources.sort(key=itemgetter('Sort'))
sources.extend(local_sources)
sources.extend(remote_sources)
actions = [{'Name': 'Quit', 'Letter': 'Q'}]
# Select backup from sources
if len(sources) > 0:
selection = menu_select(
'Which backup are we using?',
main_entries=sources,
action_entries=actions,
disabled_label='DAMAGED')
if selection == 'Q':
umount_backup_shares()
exit_script()
else:
selected_source = sources[int(selection)-1]['Source']
else:
print_error('ERROR: No backups found using prefix: {}.'.format(
backup_prefix))
umount_backup_shares()
pause("Press Enter to exit...")
exit_script()
# Sanity check
if selected_source.is_file():
# Image-Based
if not REGEX_WIM_FILE.search(selected_source.name):
print_error('ERROR: Unsupported image: {}'.format(
selected_source.path))
raise GenericError
# Done
return selected_source
def select_volume(title='Select disk', auto_select=True):
"""Select disk from attached disks. returns dict."""
actions = [{'Name': 'Quit', 'Letter': 'Q'}]
disks = []
# Build list of disks
set_thread_error_mode(silent=True) # Prevents "No disk" popups
for d in psutil.disk_partitions():
info = {
'Disk': d,
'Name': d.mountpoint}
try:
usage = psutil.disk_usage(d.device)
free = '{free} / {total} available'.format(
free = human_readable_size(usage.free, 2),
total = human_readable_size(usage.total, 2))
except Exception:
# Meh, leaving unsupported destinations out
pass
# free = 'Unknown'
# info['Disabled'] = True
else:
info['Display Name'] = '{} ({})'.format(info['Name'], free)
disks.append(info)
set_thread_error_mode(silent=False) # Return to normal
# Skip menu?
if len(disks) == 1 and auto_select:
return disks[0]
# Show menu
selection = menu_select(title, main_entries=disks, action_entries=actions)
if selection == 'Q':
exit_script()
else:
return disks[int(selection)-1]
def set_thread_error_mode(silent=True):
"""Disable or Enable Windows error message dialogs.
Disable when scanning disks to avoid popups for empty cardreaders, etc
"""
# Code borrowed from: https://stackoverflow.com/a/29075319
kernel32 = ctypes.WinDLL('kernel32')
if silent:
kernel32.SetThreadErrorMode(SEM_FAIL, ctypes.byref(SEM_NORMAL))
else:
kernel32.SetThreadErrorMode(SEM_NORMAL, ctypes.byref(SEM_NORMAL))
def transfer_source(source_obj, dest_path, selected_items):
"""Transfer, or extract, files/folders from source to destination."""
if source_obj.is_dir():
# Run FastCopy for each selection "group"
for group in selected_items:
try_and_print(message=group['Message'],
function=run_fast_copy, cs='Done',
items=group['Items'],
dest=group['Destination'])
else:
if REGEX_WIM_FILE.search(source_obj.name):
# Extract files from WIM
for group in selected_items:
try_and_print(message=group['Message'],
function=run_wimextract, cs='Done',
source=source_obj.path,
items=group['Items'],
dest=dest_path)
else:
print_error('ERROR: Unsupported image: {}'.format(source_obj.path))
raise GenericError
def umount_backup_shares():
"""Unmount the backup shares regardless of current status."""
for server in BACKUP_SERVERS:
umount_network_share(server)
def umount_network_share(server):
"""Unmount a network share defined by server."""
cmd = r'net use \\{IP}\{Share} /delete'.format(**server)
cmd = cmd.split(' ')
try:
run_program(cmd)
except Exception:
print_error(r'Failed to umount \\{Name}\{Share}.'.format(**server))
sleep(1)
else:
print_info('Umounted {Name}'.format(**server))
server['Mounted'] = False
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

414
scripts/wk.prev/functions/disk.py
View file

@ -1,414 +0,0 @@
# Wizard Kit: Functions - Disk
from functions.common import *
from settings.partition_uids import *
# Regex
REGEX_BAD_PARTITION = re.compile(r'(RAW|Unknown)', re.IGNORECASE)
REGEX_DISK_GPT = re.compile(
r'Disk ID: {[A-Z0-9]+-[A-Z0-9]+-[A-Z0-9]+-[A-Z0-9]+-[A-Z0-9]+}',
re.IGNORECASE)
REGEX_DISK_MBR = re.compile(r'Disk ID: [A-Z0-9]+', re.IGNORECASE)
REGEX_DISK_RAW = re.compile(r'Disk ID: 00000000', re.IGNORECASE)
def assign_volume_letters():
"""Assign a volume letter to all available volumes."""
remove_volume_letters()
# Write script
script = []
for vol in get_volumes():
script.append('select volume {}'.format(vol['Number']))
script.append('assign')
# Run
run_diskpart(script)
def get_boot_mode():
"""Check if the boot mode was UEFI or legacy."""
boot_mode = 'Legacy'
try:
reg_key = winreg.OpenKey(
winreg.HKEY_LOCAL_MACHINE, r'System\CurrentControlSet\Control')
reg_value = winreg.QueryValueEx(reg_key, 'PEFirmwareType')[0]
if reg_value == 2:
boot_mode = 'UEFI'
except:
boot_mode = 'Unknown'
return boot_mode
def get_disk_details(disk):
"""Get disk details using DiskPart."""
details = {}
script = [
'select disk {}'.format(disk['Number']),
'detail disk']
# Run
try:
result = run_diskpart(script)
except subprocess.CalledProcessError:
pass
else:
output = result.stdout.decode().strip()
# Remove empty lines
tmp = [s.strip() for s in output.splitlines() if s.strip() != '']
# Set disk name
details['Name'] = tmp[4]
# Split each line on ':' skipping those without ':'
tmp = [s.split(':') for s in tmp if ':' in s]
# Add key/value pairs to the details variable and return dict
details.update({key.strip(): value.strip() for (key, value) in tmp})
return details
def get_disks():
"""Get list of attached disks using DiskPart."""
disks = []
try:
# Run script
result = run_diskpart(['list disk'])
except subprocess.CalledProcessError:
pass
else:
# Append disk numbers
output = result.stdout.decode().strip()
for tmp in re.findall(r'Disk (\d+)\s+\w+\s+(\d+\s+\w+)', output):
num = tmp[0]
size = human_readable_size(tmp[1])
disks.append({'Number': num, 'Size': size})
return disks
def get_partition_details(disk, partition):
"""Get partition details using DiskPart and fsutil."""
details = {}
script = [
'select disk {}'.format(disk['Number']),
'select partition {}'.format(partition['Number']),
'detail partition']
# Diskpart details
try:
# Run script
result = run_diskpart(script)
except subprocess.CalledProcessError:
pass
else:
# Get volume letter or RAW status
output = result.stdout.decode().strip()
tmp = re.search(r'Volume\s+\d+\s+(\w|RAW)\s+', output)
if tmp:
if tmp.group(1).upper() == 'RAW':
details['FileSystem'] = RAW
else:
details['Letter'] = tmp.group(1)
# Remove empty lines from output
tmp = [s.strip() for s in output.splitlines() if s.strip() != '']
# Split each line on ':' skipping those without ':'
tmp = [s.split(':') for s in tmp if ':' in s]
# Add key/value pairs to the details variable and return dict
details.update({key.strip(): value.strip() for (key, value) in tmp})
# Get MBR type / GPT GUID for extra details on "Unknown" partitions
guid = PARTITION_UIDS.get(details.get('Type').upper(), {})
if guid:
details.update({
'Description': guid.get('Description', '')[:29],
'OS': guid.get('OS', 'Unknown')[:27]})
if 'Letter' in details:
# Disk usage
try:
tmp = psutil.disk_usage('{}:\\'.format(details['Letter']))
except OSError as err:
details['FileSystem'] = 'Unknown'
details['Error'] = err.strerror
else:
details['Used Space'] = human_readable_size(tmp.used)
# fsutil details
cmd = [
'fsutil',
'fsinfo',
'volumeinfo',
'{}:'.format(details['Letter'])
]
try:
result = run_program(cmd)
except subprocess.CalledProcessError:
pass
else:
output = result.stdout.decode().strip()
# Remove empty lines from output
tmp = [s.strip() for s in output.splitlines() if s.strip() != '']
# Add "Feature" lines
details['File System Features'] = [s.strip() for s in tmp
if ':' not in s]
# Split each line on ':' skipping those without ':'
tmp = [s.split(':') for s in tmp if ':' in s]
# Add key/value pairs to the details variable and return dict
details.update({key.strip(): value.strip() for (key, value) in tmp})
# Set Volume Name
details['Name'] = details.get('Volume Name', '')
# Set FileSystem Type
if details.get('FileSystem', '') not in ['RAW', 'Unknown']:
details['FileSystem'] = details.get('File System Name', 'Unknown')
return details
def get_partitions(disk):
"""Get list of partition using DiskPart."""
partitions = []
script = [
'select disk {}'.format(disk['Number']),
'list partition']
try:
# Run script
result = run_diskpart(script)
except subprocess.CalledProcessError:
pass
else:
# Append partition numbers
output = result.stdout.decode().strip()
regex = r'Partition\s+(\d+)\s+\w+\s+(\d+\s+\w+)\s+'
for tmp in re.findall(regex, output, re.IGNORECASE):
num = tmp[0]
size = human_readable_size(tmp[1])
partitions.append({'Number': num, 'Size': size})
return partitions
def get_table_type(disk):
"""Get disk partition table type using DiskPart."""
part_type = 'Unknown'
script = [
'select disk {}'.format(disk['Number']),
'uniqueid disk']
try:
result = run_diskpart(script)
except subprocess.CalledProcessError:
pass
else:
output = result.stdout.decode().strip()
if REGEX_DISK_GPT.search(output):
part_type = 'GPT'
elif REGEX_DISK_MBR.search(output):
part_type = 'MBR'
elif REGEX_DISK_RAW.search(output):
part_type = 'RAW'
return part_type
def get_volumes():
"""Get list of volumes using DiskPart."""
vols = []
try:
result = run_diskpart(['list volume'])
except subprocess.CalledProcessError:
pass
else:
# Append volume numbers
output = result.stdout.decode().strip()
for tmp in re.findall(r'Volume (\d+)\s+([A-Za-z]?)\s+', output):
vols.append({'Number': tmp[0], 'Letter': tmp[1]})
return vols
def is_bad_partition(par):
"""Check if the partition is accessible."""
return 'Letter' not in par or REGEX_BAD_PARTITION.search(par['FileSystem'])
def prep_disk_for_formatting(disk=None):
"""Gather details about the disk and its partitions."""
disk['Format Warnings'] = '\n'
width = len(str(len(disk['Partitions'])))
# Bail early
if disk is None:
raise Exception('Disk not provided.')
# Set boot method and partition table type
disk['Use GPT'] = True
if (get_boot_mode() == 'UEFI'):
if (not ask("Setup Windows to use UEFI booting?")):
disk['Use GPT'] = False
else:
if (ask("Setup Windows to use BIOS/Legacy booting?")):
disk['Use GPT'] = False
# Set Display and Warning Strings
if len(disk['Partitions']) == 0:
disk['Format Warnings'] += 'No partitions found\n'
for partition in disk['Partitions']:
display = '{size} {fs}'.format(
num = partition['Number'],
width = width,
size = partition['Size'],
fs = partition['FileSystem'])
if is_bad_partition(partition):
# Set display string using partition description & OS type
display += '\t\t{q}{name}{q}\t{desc} ({os})'.format(
display = display,
q = '"' if partition['Name'] != '' else '',
name = partition['Name'],
desc = partition['Description'],
os = partition['OS'])
else:
# List space used instead of partition description & OS type
display += ' (Used: {used})\t{q}{name}{q}'.format(
used = partition['Used Space'],
q = '"' if partition['Name'] != '' else '',
name = partition['Name'])
# For all partitions
partition['Display String'] = display
def reassign_volume_letter(letter, new_letter='I'):
"""Assign a new letter to a volume using DiskPart."""
if not letter:
# Ignore
return None
script = [
'select volume {}'.format(letter),
'remove noerr',
'assign letter={}'.format(new_letter)]
try:
run_diskpart(script)
except subprocess.CalledProcessError:
pass
else:
return new_letter
def remove_volume_letters(keep=None):
"""Remove all assigned volume letters using DiskPart."""
if not keep:
keep = ''
script = []
for vol in get_volumes():
if vol['Letter'].upper() != keep.upper():
script.append('select volume {}'.format(vol['Number']))
script.append('remove noerr')
# Run script
try:
run_diskpart(script)
except subprocess.CalledProcessError:
pass
def run_diskpart(script):
"""Run DiskPart script."""
tempfile = r'{}\diskpart.script'.format(global_vars['Env']['TMP'])
# Write script
with open(tempfile, 'w') as f:
for line in script:
f.write('{}\n'.format(line))
# Run script
cmd = [
r'{}\Windows\System32\diskpart.exe'.format(
global_vars['Env']['SYSTEMDRIVE']),
'/s', tempfile]
result = run_program(cmd)
sleep(2)
return result
def scan_disks():
"""Get details about the attached disks"""
disks = get_disks()
# Get disk details
for disk in disks:
# Get partition style
disk['Table'] = get_table_type(disk)
# Get disk name/model and physical details
disk.update(get_disk_details(disk))
# Get partition info for disk
disk['Partitions'] = get_partitions(disk)
for partition in disk['Partitions']:
# Get partition details
partition.update(get_partition_details(disk, partition))
# Done
return disks
def select_disk(title='Which disk?', disks=[]):
"""Select a disk from the attached disks"""
# Build menu
disk_options = []
for disk in disks:
display_name = '{}\t[{}] ({}) {}'.format(
disk.get('Size', ''),
disk.get('Table', ''),
disk.get('Type', ''),
disk.get('Name', 'Unknown'),
)
pwidth=len(str(len(disk['Partitions'])))
for partition in disk['Partitions']:
# Main text
p_name = 'Partition {num:>{width}}: {size} ({fs})'.format(
num = partition['Number'],
width = pwidth,
size = partition['Size'],
fs = partition['FileSystem'])
if partition['Name']:
p_name += '\t"{}"'.format(partition['Name'])
# Show unsupported partition(s)
if is_bad_partition(partition):
p_name = '{YELLOW}{p_name}{CLEAR}'.format(
p_name=p_name, **COLORS)
display_name += '\n\t\t\t{}'.format(p_name)
if not disk['Partitions']:
display_name += '\n\t\t\t{}No partitions found.{}'.format(
COLORS['YELLOW'], COLORS['CLEAR'])
disk_options.append({'Name': display_name, 'Disk': disk})
actions = [
{'Name': 'Main Menu', 'Letter': 'M'},
]
# Menu loop
selection = menu_select(
title = title,
main_entries = disk_options,
action_entries = actions)
if (selection.isnumeric()):
return disk_options[int(selection)-1]['Disk']
elif (selection == 'M'):
raise GenericAbort
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

2056
scripts/wk.prev/functions/hw_diags.py
View file

File diff suppressed because it is too large Load diff

500
scripts/wk.prev/functions/info.py
View file

@ -1,500 +0,0 @@
# Wizard Kit: Functions - Information
from borrowed import knownpaths
from functions.activation import *
from operator import itemgetter
from settings.info import *
def backup_file_list():
"""Export current file listing for the system."""
extract_item('Everything', silent=True)
cmd = [
global_vars['Tools']['Everything'],
'-nodb',
'-create-filelist',
r'{LogDir}\File List.txt'.format(**global_vars),
global_vars['Env']['SYSTEMDRIVE']]
run_program(cmd)
def backup_power_plans():
"""Export current power plans."""
os.makedirs(r'{BackupDir}\Power Plans\{Date}'.format(
**global_vars), exist_ok=True)
plans = run_program(['powercfg', '/L'])
plans = plans.stdout.decode().splitlines()
plans = [p for p in plans if re.search(r'^Power Scheme', p)]
for p in plans:
guid = re.sub(r'Power Scheme GUID:\s+([0-9a-f\-]+).*', r'\1', p)
name = re.sub(
r'Power Scheme GUID:\s+[0-9a-f\-]+\s+\(([^\)]+)\).*', r'\1', p)
out = r'{BackupDir}\Power Plans\{Date}\{name}.pow'.format(
name=name, **global_vars)
if not os.path.exists(out):
cmd = ['powercfg', '-export', out, guid]
run_program(cmd, check=False)
def backup_registry(overwrite=False):
"""Backup registry including user hives."""
extract_item('erunt', silent=True)
cmd = [
global_vars['Tools']['ERUNT'],
r'{BackupDir}\Registry\{Date}'.format(**global_vars),
'sysreg',
'curuser',
'otherusers',
'/noprogresswindow']
if overwrite:
cmd.append('/noconfirmdelete')
run_program(cmd)
def get_folder_size(path):
"""Get (human-readable) size of folder passed, returns str."""
size = 'Unknown'
cmd = [global_vars['Tools']['Du'], '-c', '-nobanner', '-q', path]
try:
out = run_program(cmd)
except FileNotFoundError:
# Failed to find folder
pass
except subprocess.CalledProcessError:
# Failed to get folder size
pass
else:
try:
size = out.stdout.decode().split(',')[-2]
except IndexError:
# Failed to parse csv data
pass
else:
size = human_readable_size(size)
return size
def get_installed_antivirus():
"""Get list of installed Antivirus programs."""
programs = []
cmd = ['WMIC', r'/namespace:\\root\SecurityCenter2',
'path', 'AntivirusProduct',
'get', 'displayName', '/value']
out = run_program(cmd)
out = out.stdout.decode().strip()
products = out.splitlines()
products = [p.split('=')[1] for p in products if p]
for prod in sorted(products):
# Get product state and check if it's enabled
# credit: https://jdhitsolutions.com/blog/powershell/5187/get-antivirus-product-status-with-powershell/
cmd = ['WMIC', r'/namespace:\\root\SecurityCenter2',
'path', 'AntivirusProduct',
'where', 'displayName="{}"'.format(prod),
'get', 'productState', '/value']
out = run_program(cmd)
out = out.stdout.decode().strip()
state = out.split('=')[1]
state = hex(int(state))
if str(state)[3:5] not in ['10', '11']:
programs.append('[Disabled] {}'.format(prod))
else:
programs.append(prod)
if len(programs) == 0:
programs = ['No programs found']
return programs
def get_installed_office():
"""Get list of installed Office programs."""
programs = []
log_file = r'{LogDir}\Installed Program List (AIDA64).txt'.format(
**global_vars)
with open (log_file, 'r') as f:
for line in sorted(f.readlines()):
if REGEX_OFFICE.search(line):
programs.append(line[4:82].strip())
if len(programs) == 0:
programs = ['No programs found']
return programs
def get_shell_path(folder, user='current'):
"""Get shell path using knownpaths, returns str.
NOTE: Only works for the current user.
Code based on https://gist.github.com/mkropat/7550097
"""
path = None
folderid = None
if user.lower() == 'public':
user = 'common'
try:
folderid = getattr(knownpaths.FOLDERID, folder)
except AttributeError:
# Unknown folder ID, ignore and return None
pass
if folderid:
try:
path = knownpaths.get_path(
folderid, getattr(knownpaths.UserHandle, user))
except PathNotFoundError:
# Folder not found, ignore and return None
pass
return path
def get_user_data_paths(user):
"""Get user data paths for provided user, returns dict."""
hive_path = user['SID']
paths = {
'Profile': {
'Path': None,
},
'Shell Folders': {},
'Extra Folders': {},
}
unload_hive = False
if user['Name'] == global_vars['Env']['USERNAME']:
# We can use SHGetKnownFolderPath for the current user
paths['Profile']['Path'] = get_shell_path('Profile')
paths['Shell Folders'] = {f: {'Path': get_shell_path(f)}
for f in SHELL_FOLDERS.keys()}
else:
# We have to use the NTUSER.dat hives which isn't recommended by MS
try:
key_path = r'{}\{}'.format(REG_PROFILE_LIST, user['SID'])
with winreg.OpenKey(HKLM, key_path) as key:
paths['Profile']['Path'] = winreg.QueryValueEx(
key, 'ProfileImagePath')[0]
except Exception:
# Profile path not found, leaving as None.
pass
# Shell folders (Prep)
if not reg_path_exists(HKU, hive_path) and paths['Profile']['Path']:
# User not logged-in, loading hive
# Also setting unload_hive so it will be unloaded later.
hive_path = TMP_HIVE_PATH
cmd = ['reg', 'load', r'HKU\{}'.format(TMP_HIVE_PATH),
r'{}\NTUSER.DAT'.format(paths['Profile']['Path'])]
unload_hive = True
try:
run_program(cmd)
except subprocess.CalledProcessError:
# Failed to load user hive
pass
# Shell folders
shell_folders = r'{}\{}'.format(hive_path, REG_SHELL_FOLDERS)
if (reg_path_exists(HKU, hive_path)
and reg_path_exists(HKU, shell_folders)):
with winreg.OpenKey(HKU, shell_folders) as key:
for folder, values in SHELL_FOLDERS.items():
for value in values:
try:
path = winreg.QueryValueEx(key, value)[0]
except FileNotFoundError:
# Skip missing values
pass
else:
paths['Shell Folders'][folder] = {'Path': path}
# Stop checking values for this folder
break
# Shell folder (extra check)
if paths['Profile']['Path']:
for folder in SHELL_FOLDERS.keys():
folder_path = r'{Path}\{folder}'.format(
folder=folder, **paths['Profile'])
if (folder not in paths['Shell Folders']
and os.path.exists(folder_path)):
paths['Shell Folders'][folder] = {'Path': folder_path}
# Extra folders
if paths['Profile']['Path']:
for folder in EXTRA_FOLDERS:
folder_path = r'{Path}\{folder}'.format(
folder=folder, **paths['Profile'])
if os.path.exists(folder_path):
paths['Extra Folders'][folder] = {'Path': folder_path}
# Shell folders (cleanup)
if unload_hive:
cmd = ['reg', 'unload', r'HKU\{}'.format(TMP_HIVE_PATH)]
run_program(cmd, check=False)
# Done
return paths
def get_user_folder_sizes(users):
"""Update list(users) to include folder paths and sizes."""
extract_item('du', filter='du*', silent=True)
# Configure Du
winreg.CreateKey(HKCU, r'Software\Sysinternals\Du')
with winreg.OpenKey(HKCU,
r'Software\Sysinternals\Du', access=winreg.KEY_WRITE) as key:
winreg.SetValueEx(key, 'EulaAccepted', 0, winreg.REG_DWORD, 1)
for u in users:
u.update(get_user_data_paths(u))
if u['Profile']['Path']:
u['Profile']['Size'] = get_folder_size(u['Profile']['Path'])
for folder in u['Shell Folders'].keys():
u['Shell Folders'][folder]['Size'] = get_folder_size(
u['Shell Folders'][folder]['Path'])
for folder in u['Extra Folders'].keys():
u['Extra Folders'][folder]['Size'] = get_folder_size(
u['Extra Folders'][folder]['Path'])
def get_user_list():
"""Get user list via WMIC, returns list of dicts."""
users = []
# Get user info from WMI
cmd = ['wmic', 'useraccount', 'get', '/format:csv']
try:
out = run_program(cmd)
except subprocess.CalledProcessError:
# Meh, return empty list to avoid a full crash
return users
entries = out.stdout.decode().splitlines()
entries = [e.strip().split(',') for e in entries if e.strip()]
# Add user(s) to dict
keys = entries[0]
for e in entries[1:]:
# Create dict using 1st line (keys)
e = dict(zip(keys, e))
# Set Active status via 'Disabled' TRUE/FALSE str
e['Active'] = bool(e['Disabled'].upper() == 'FALSE')
# Assume SIDs ending with 1000+ are "Standard" and others are "System"
e['Type'] = 'Standard' if re.search(r'-1\d+$', e['SID']) else 'System'
users.append(e)
# Sort list
users.sort(key=itemgetter('Name'))
# Done
return users
def reg_path_exists(hive, path):
"""Test if specified path exists, returns bool."""
try:
winreg.QueryValue(hive, path)
except FileNotFoundError:
return False
else:
return True
def run_aida64():
"""Run AIDA64 to save system reports."""
extract_item('AIDA64', silent=True)
# All system info
config = r'{BinDir}\AIDA64\full.rpf'.format(**global_vars)
report_file = r'{LogDir}\System Information (AIDA64).html'.format(
**global_vars)
if not os.path.exists(report_file):
cmd = [
global_vars['Tools']['AIDA64'],
'/R', report_file,
'/CUSTOM', config,
'/HTML', '/SILENT', '/SAFEST']
run_program(cmd, check=False)
# Installed Programs
config = r'{BinDir}\AIDA64\installed_programs.rpf'.format(**global_vars)
report_file = r'{LogDir}\Installed Program List (AIDA64).txt'.format(
**global_vars)
if not os.path.exists(report_file):
cmd = [
global_vars['Tools']['AIDA64'],
'/R', report_file,
'/CUSTOM', config,
'/TEXT', '/SILENT', '/SAFEST']
run_program(cmd, check=False)
# Product Keys
config = r'{BinDir}\AIDA64\licenses.rpf'.format(**global_vars)
report_file = r'{LogDir}\Product Keys (AIDA64).txt'.format(**global_vars)
if not os.path.exists(report_file):
cmd = [
global_vars['Tools']['AIDA64'],
'/R', report_file,
'/CUSTOM', config,
'/TEXT', '/SILENT', '/SAFEST']
run_program(cmd, check=False)
def run_bleachbit(cleaners=None, preview=True):
"""Run BleachBit preview and save log.
If preview is True then no files should be deleted."""
error_path = r'{}\Tools\BleachBit.err'.format(global_vars['LogDir'])
log_path = error_path.replace('err', 'log')
extract_item('BleachBit', silent=True)
# Safety check
if not cleaners:
# Disable cleaning and use preset config
cleaners = ['--preset']
preview = True
# Run
cmd = [
global_vars['Tools']['BleachBit'],
'--preview' if preview else '--clean']
cmd.extend(cleaners)
out = run_program(cmd, check=False)
# Save stderr
if out.stderr.decode().splitlines():
with open(error_path, 'a', encoding='utf-8') as f:
for line in out.stderr.decode().splitlines():
f.write(line.strip() + '\n')
# Save stdout
with open(log_path, 'a', encoding='utf-8') as f:
for line in out.stdout.decode().splitlines():
f.write(line.strip() + '\n')
def show_disk_usage(disk):
"""Show free and used space for a specified disk."""
print_standard('{:5}'.format(disk.device.replace('/', ' ')),
end='', flush=True, timestamp=False)
try:
usage = psutil.disk_usage(disk.device)
display_string = '{percent:>5.2f}% Free ({free} / {total})'.format(
percent = 100 - usage.percent,
free = human_readable_size(usage.free, 2),
total = human_readable_size(usage.total, 2))
if usage.percent > 85:
print_error(display_string, timestamp=False)
elif usage.percent > 75:
print_warning(display_string, timestamp=False)
else:
print_standard(display_string, timestamp=False)
except Exception:
print_warning('Unknown', timestamp=False)
def show_free_space(indent=8, width=32):
"""Show free space info for all fixed disks."""
message = 'Free Space:'
for disk in psutil.disk_partitions():
try:
if 'fixed' in disk.opts:
try_and_print(message=message, function=show_disk_usage,
ns='Unknown', silent_function=False,
indent=indent, width=width, disk=disk)
message = ''
except Exception:
pass
def show_installed_ram():
"""Show installed RAM."""
mem = psutil.virtual_memory()
if mem.total > 5905580032:
# > 5.5 Gb so 6Gb or greater
print_standard(human_readable_size(mem.total).strip(), timestamp=False)
elif mem.total > 3758096384:
# > 3.5 Gb so 4Gb or greater
print_warning(human_readable_size(mem.total).strip(), timestamp=False)
else:
print_error(human_readable_size(mem.total).strip(), timestamp=False)
def show_os_activation():
"""Show OS activation info."""
act_str = get_activation_string()
if windows_is_activated():
print_standard(act_str, timestamp=False)
elif re.search(r'unavailable', act_str, re.IGNORECASE):
print_warning(act_str, timestamp=False)
else:
print_error(act_str, timestamp=False)
def show_os_name():
"""Show extended OS name (including warnings)."""
os_name = global_vars['OS']['DisplayName']
if global_vars['OS']['Arch'] == 32:
# Show all 32-bit installs as an error message
print_error(os_name, timestamp=False)
else:
if re.search(
r'(preview build|unrecognized|unsupported)',
os_name,
re.IGNORECASE):
print_error(os_name, timestamp=False)
elif re.search(r'outdated', os_name, re.IGNORECASE):
print_warning(os_name, timestamp=False)
else:
print_standard(os_name, timestamp=False)
def show_temp_files_size():
"""Show total size of temp files identified by BleachBit."""
size_str = None
total = 0
with open(r'{LogDir}\Tools\BleachBit.log'.format(**global_vars), 'r') as f:
for line in f.readlines():
if re.search(r'^Disk space (to be |)recovered:', line, re.IGNORECASE):
size = re.sub(r'.*: ', '', line.strip())
size = re.sub(r'(\w)iB$', r' \1b', size)
total += convert_to_bytes(size)
size_str = human_readable_size(total, decimals=1)
if size_str is None:
print_warning('UNKNOWN', timestamp=False)
else:
print_standard(size_str, timestamp=False)
def show_user_data_summary(indent=8, width=32):
"""Print user data folder sizes for all users."""
users = get_user_list()
users = [u for u in users if u['Active']]
get_user_folder_sizes(users)
for user in users:
if ('Size' not in user['Profile']
and not any(user['Shell Folders'])
and not any(user['Extra Folders'])):
# Skip empty users
continue
print_success('{indent}User: {user}'.format(
indent = ' '*int(indent/2),
user = user['Name']))
for section in ['Profile', None, 'Shell Folders', 'Extra Folders']:
folders = []
if section is None:
# Divider
print_standard('{}{}'.format(' '*indent, '-'*(width+6)))
elif section == 'Profile':
folders = {'Profile': user['Profile']}
else:
folders = user[section]
for folder in folders:
print_standard(
'{indent}{folder:<{width}}{size:>6} ({path})'.format(
indent = ' ' * indent,
width = width,
folder = folder,
size = folders[folder].get('Size', 'Unknown'),
path = folders[folder].get('Path', 'Unknown')))
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

120
scripts/wk.prev/functions/io_graph.py
View file

@ -1,120 +0,0 @@
# Wizard Kit: Functions - PNG graph for I/O Benchmark
import base64
import Gnuplot
import json
import math
import requests
from functions.common import *
# Functions
def export_io_graph(disk):
"""Exports PNG graph using gnuplot, returns file path as str."""
read_rates = disk.tests['I/O Benchmark'].read_rates
if not read_rates:
# No data, aborting
raise GenericError
max_rate = max(read_rates) / (1024**2)
max_rate = max(800, max_rate)
out_path = '{}/iobenchmark-{}.png'.format(
global_vars['LogDir'], disk.name)
plot_data = '{}/iobenchmark-{}-plot.data'.format(
global_vars['LogDir'], disk.name)
# Adjust Y-axis range to either 1000 or roughly max rate + 200
## Round up to the nearest 100 and then add 200
y_range = (math.ceil(max_rate/100)*100) + 200
# Save plot data to file for Gnuplot
with open(plot_data, 'w') as f:
for i in range(len(read_rates)):
_percent = ( (i+1) / len(read_rates) ) * 100
_rate = int( read_rates[i] / (1024**2) )
f.write('{:0.1f} {}\n'.format(_percent, _rate))
# Run gnuplot commands
g = Gnuplot.Gnuplot()
g('reset')
g('set output "{}"'.format(out_path))
g('set terminal png large size 660,300 truecolor font "Noto Sans,11"')
g('set title "I/O Benchmark"')
g('set yrange [0:{}]'.format(y_range))
g('set style data lines')
g('plot "{}" title "{}"'.format(
plot_data,
disk.description.replace('_', ' '),
))
# Cleanup
g.close()
del(g)
return out_path
def upload_to_imgur(image_path):
"""Upload image to Imgur and return image url as str."""
image_data = None
image_link = None
# Bail early
if not image_path:
raise GenericError
# Read image file and convert to base64 then convert to str
with open(image_path, 'rb') as f:
image_data = base64.b64encode(f.read()).decode()
# POST image
url = "https://api.imgur.com/3/image"
boundary = '----WebKitFormBoundary7MA4YWxkTrZu0gW'
payload = ('--{boundary}\r\nContent-Disposition: form-data; '
'name="image"\r\n\r\n{data}\r\n--{boundary}--')
payload = payload.format(boundary=boundary, data=image_data)
headers = {
'content-type': 'multipart/form-data; boundary={}'.format(boundary),
'Authorization': 'Client-ID {}'.format(IMGUR_CLIENT_ID),
}
response = requests.request("POST", url, data=payload, headers=headers)
# Return image link
if response.ok:
json_data = json.loads(response.text)
image_link = json_data['data']['link']
return image_link
def upload_to_nextcloud(image_path, ticket_number, dev_name):
"""Upload image to Nextcloud server and return folder url as str."""
image_data = None
# Bail early
if not image_path:
raise GenericError
# Read image file and convert to base64
with open(image_path, 'rb') as f:
image_data = f.read()
# PUT image
url = '{base_url}/{ticket_number}_iobenchmark_{dev_name}_{date}.png'.format(
base_url=BENCHMARK_SERVER['Url'],
ticket_number=ticket_number,
dev_name=dev_name,
date=global_vars.get('Date-Time', 'Unknown Date-Time'))
requests.put(
url,
data=image_data,
headers = {'X-Requested-With': 'XMLHttpRequest'},
auth = (BENCHMARK_SERVER['User'], BENCHMARK_SERVER['Pass']))
# Return folder link
return BENCHMARK_SERVER['Short Url']
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

32
scripts/wk.prev/functions/json.py
View file

@ -1,32 +0,0 @@
# Wizard Kit: Functions - JSON
import json
from functions.common import *
def get_json_from_command(cmd, check=True, ignore_errors=True):
"""Capture JSON content from cmd output, returns dict.
If the data can't be decoded then either an exception is raised
or an empty dict is returned depending on ignore_errors.
"""
errors = 'strict'
json_data = {}
if ignore_errors:
errors = 'ignore'
try:
result = run_program(cmd, check=check, encoding='utf-8', errors=errors)
json_data = json.loads(result.stdout)
except (subprocess.CalledProcessError, json.decoder.JSONDecodeError):
if not ignore_errors:
raise
return json_data
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

53
scripts/wk.prev/functions/network.py
View file

@ -1,53 +0,0 @@
# Wizard Kit: Functions - Network
import os
import shutil
import sys
from functions.common import *
# REGEX
REGEX_VALID_IP = re.compile(
r'(10.\d+.\d+.\d+'
r'|172.(1[6-9]|2\d|3[0-1])'
r'|192.168.\d+.\d+)',
re.IGNORECASE)
def is_connected():
"""Check for a valid private IP."""
devs = psutil.net_if_addrs()
for dev in devs.values():
for family in dev:
if REGEX_VALID_IP.search(family.address):
# Valid IP found
return True
# Else
return False
def show_valid_addresses():
"""Show all valid private IP addresses assigned to the system."""
devs = psutil.net_if_addrs()
for dev, families in sorted(devs.items()):
for family in families:
if REGEX_VALID_IP.search(family.address):
# Valid IP found
show_data(message=dev, data=family.address)
def speedtest():
"""Run a network speedtest using speedtest-cli."""
result = run_program(['speedtest-cli', '--simple'])
output = [line.strip() for line in result.stdout.decode().splitlines()
if line.strip()]
output = [line.split() for line in output]
output = [(a, float(b), c) for a, b, c in output]
return ['{:10}{:6.2f} {}'.format(*line) for line in output]
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

655
scripts/wk.prev/functions/osticket.py
View file

@ -1,655 +0,0 @@
# Wizard Kit: Functions - osTicket
import atexit
import mysql.connector as mariadb
from functions.data import *
from functions.io_graph import *
from settings.osticket import *
# STATIC VARIABLES
KNOWN_DEV_TYPES = ('CPU', 'Disk')
# Regex
REGEX_BLOCK_GRAPH = re.compile(r'(▁|▂|▃|▄|▅|▆|▇|█)')
REGEX_NVME_SMART_ATTRIBUTES = re.compile(r'^\s*(\d+) / (\w+): (.{28})(.*)$')
REGEX_TEMPS = re.compile(r'^\s*(.*?)\s+(idle:)(.*)$')
REGEX_SENSOR = re.compile(r'^(.*?)(\s*)$')
# Error Classes
class osTicketConnectionError(Exception):
pass
# Classes
class osTicket():
"""Class to track osTicket data and functions."""
def __init__(self, tests_cpu, tests_disk):
self.db_connection = None
self.db_cursor = None
self.disabled = False
self.errors = False
self.tests_cpu = tests_cpu
self.tests_disk = tests_disk
self.tunnel_proc = None
def connect(self, silent=True):
"""Establish connection to osTicket via a SSH tunnel."""
cmd = [
'ssh', '-N',
'-p', OSTICKET['SSH']['Port'],
'-L3306:127.0.0.1:{Port}'.format(**OSTICKET['Database']),
'{User}@{Host}'.format(**OSTICKET['SSH']),
]
# Bail if disabled
if self.disabled:
return
# Only open tunnel if one doesn't exist
if self.tunnel_proc is None or self.tunnel_proc.poll() is not None:
if self.tunnel_proc:
# Unregister previous terminate
atexit.unregister(self.tunnel_proc.terminate)
self.tunnel_proc = popen_program(cmd)
atexit.register(self.tunnel_proc.terminate)
# Connect to database
for x in range(5):
sleep(2)
try:
self.db_connection = mariadb.connect(
user=OSTICKET['Database']['User'],
password=OSTICKET['Database']['Pass'],
database=OSTICKET['Database']['Name'],
)
self.db_cursor = self.db_connection.cursor()
except mariadb.errors.InterfaceError:
# SSH issue?, try again
pass
except mariadb.errors.Error:
# Bad creds or other SQL error, bail
break
except Exception:
# Unknown error
break
else:
# Connection established
break
# Raise exception unless silenced
if self.db_cursor is None and not silent:
raise osTicketConnectionError('Failed to connect to osTicket.')
def convert_report(self, name, test):
"""Convert report into an osTicket friendly format, returns list."""
dev = test.dev
out_report = []
source_report = test.report.copy()
status = strip_colors(test.status)
status = status.replace(test.label, '').strip()
# Header
index = 1
if name == 'NVMe / SMART':
out_report.append('{} ({})'.format(name, status))
source_report = dev.generate_attribute_report()
# Notes
if dev.nvme_smart_notes:
source_report.append('{} Notes'.format(dev.attr_type))
source_report.extend(sorted(dev.nvme_smart_notes.keys()))
# Test Report
source_report.extend(test.report.copy())
elif not source_report:
index = 0
out_report.append('{} ({})'.format(name, status))
else:
out_report.append('{} ({})'.format(strip_colors(source_report[0]), status))
# Body
for line in source_report[index:]:
# Remove colors and leading spaces
line = strip_colors(line)
if line[:2] == ' ':
line = line[2:]
# Test-specific modifications
if name == 'Prime95':
r = REGEX_TEMPS.match(line)
if r:
_sensor = '{:<20}'.format(r.group(1))
_temps = r.group(2)
_temps += re.sub(r'\s+(\w+:)', r' ...... \1', r.group(3))
r2 = REGEX_SENSOR.match(_sensor)
_sensor = r2.group(1)
_spacer = pad_with_dots(r2.group(2))
line = '{}{} {}'.format(_sensor, _spacer, _temps)
if line == 'Temps':
out_report.append(' ')
out_report.append('Temps')
continue
elif name == 'NVMe / SMART':
r = REGEX_NVME_SMART_ATTRIBUTES.match(line)
if r:
_dec = '{:>3}'.format(r.group(1))
_hex = r.group(2)
_atr = r.group(3).strip()
_val = '{:<20}'.format(r.group(4))
line = '{}/{}: {} {}'.format(
_hex,
pad_with_dots(_dec),
pad_with_dots(_val, pad_right=True),
_atr)
elif name == 'I/O Benchmark':
line = REGEX_BLOCK_GRAPH.sub('', line)
line = line.strip()
if not line:
continue
# Remove extra spaces
line = line.strip()
line = re.sub(r'(\s+)', ' ', line)
# Indent line
if not re.match(r'^(NVMe|SMART)', line):
line = '... {}'.format(line)
# Add line to report
out_report.append(line)
# Done
return out_report
def disconnect(self, full=False):
"""Close osTicket connection."""
try:
self.db_cursor.close()
self.db_connection.close()
except Exception:
# Ignore errors since vars will be reset below
pass
# Reset errors
if full:
self.errors = False
# Reset vars
self.db_cursor = None
self.db_connection = None
# Close tunnel
if full:
try:
self.tunnel_proc.kill()
self.tunnel_proc.wait(timeout=2)
except (AttributeError, subprocess.TimeoutExpired):
# Ignore and continue
pass
self.tunnel_proc = None
def generate_report(self, dev, ticket_id, ticket_name):
"""Generate device report for osTicket, returns list."""
report = ['']
results = self.get_device_overall_results(dev)
test_station = TEST_STATIONS.get(get_hostname().lower(), '')
# Header
if test_station:
report[0] += '[Test-Station: {}] '.format(test_station)
report[0] += '[Report for ticket #{} {}]'.format(ticket_id, ticket_name)
if results['Full Diag']:
report.append(
'{Dev Type} hardware diagnostic tests: {Status}'.format(**results))
report.append(' ')
# Device
report.append(dev.description)
if hasattr(dev, 'ram_total'):
report.append('{} RAM ({})'.format(
dev.ram_total, ', '.join(dev.ram_dimms)))
report.append(' ')
# Test reports
for name, test in dev.tests.items():
report.extend(self.convert_report(name, test))
if name == 'I/O Benchmark' and not test.disabled:
# Create PNG graph
try:
graph_file = export_io_graph(dev)
except GenericError:
# No data to build graph, ignoring
pass
except (AttributeError, KeyError):
report.append('Failed to export graph')
else:
# Upload to Imgur
try:
url = upload_to_imgur(graph_file)
report.append('Imgur: {}'.format(url))
except Exception:
report.append('Imgur: Failed to upload graph')
# Upload to Nextcloud
try:
url = upload_to_nextcloud(graph_file, ticket_id, dev.name)
report.append('Nextcloud: {}'.format(url))
except Exception:
report.append('Nextcloud: Failed to upload graph')
report.append(' ')
# Volumes
if results['Dev Type'] == 'Disk' and results['Full Diag']:
# Mount all volumes and extend report
report.append('Volumes:')
report.extend(self.generate_volume_report(dev, results))
report.append(' ')
if not dev.is_4k_aligned():
report.append('! NOTE: One or more partitions are not 4K aligned')
# Asterisk
if results['Asterisk']:
report.append('* NOTE: One or more tests were not run on this device')
# Done
return report
def generate_volume_report(self, dev, results):
"""Mount all volumes for dev and generate report, returns list."""
report = []
mount_report = mount_volumes(
all_devices=False,
device_path='{}'.format(dev.path),
core_storage=results['Core'])
# Format report
for v_path, v_data in sorted(mount_report.items()):
label = v_data.get('label', '')
if label:
label = '"{}"'.format(label)
else:
# Ensure string type
label = ''
fstype = v_data.get('fstype', 'UNKNOWN FS')
if not fstype:
# Either empty string or None
fstype = 'UNKNOWN FS'
fstype = str(fstype).upper()
size = v_data.get('size', '')
if size:
size = '{} {}B'.format(size[:-1], size[-1:]).upper()
else:
size = 'UNKNOWN'
size_used = v_data.get('size_used', 'UNKNOWN').upper()
size_avail = v_data.get('size_avail', 'UNKNOWN').upper()
v_data = [v_path, label, size, fstype, size_used, size_avail]
v_data = [str(v) for v in v_data]
v_data = [v.strip().replace(' ', '_') for v in v_data]
for i in range(len(v_data)):
pad = 8
if i < 2:
pad += 4 * (2 - i)
v_data[i] = pad_with_dots(
'{s:<{p}}'.format(s=v_data[i], p=pad),
pad_right=True)
v_data[-1] = re.sub(r'\.*$', '', v_data[-1])
v_data = [v.replace('_', ' ') for v in v_data]
report.append(
'... {}..{}..Total..{}..({}..Used..{}..Free..{})'.format(*v_data))
# Done
return report
def get_device_overall_results(self, dev):
"""Get overall results from tests for device, returns dict."""
results = {
'Core': False,
'Dev Type': self.get_device_type(dev),
'Full Diag': False,
'Asterisk': None,
'Failed': 0,
'N/A': 0,
'OVERRIDE': 0,
'Passed': 0,
'Status': 'Unknown',
}
# Bail on unknown device type
if results['Dev Type'] not in KNOWN_DEV_TYPES:
raise GenericError(
'Unrecognized device type: {}.'.format(results['Dev Type']))
# Get test list for device type
test_list = []
if results['Dev Type'] == 'CPU':
test_list = self.tests_cpu
elif results['Dev Type'] == 'Disk':
test_list = self.tests_disk
# Check if a full diag was run (i.e. all dev tests were enabled)
results['Full Diag'] = len(dev.tests) == len(test_list)
# Tally test results
for test in dev.tests.values():
if test.failed:
results['Failed'] += 1
if test.passed:
results['Passed'] += 1
if 'N/A' in test.status:
results['N/A'] += 1
if 'OVERRIDE' in test.status:
results['OVERRIDE'] += 1
# Set overall status
if results['Failed'] > 0:
dev.checkbox = False
results['Status'] = 'FAILED'
elif results['Passed'] + results['N/A'] == len(test_list):
# Only mark true if all tests are enabled and all are "Passed" / "N/A"
dev.checkbox = True
results['Status'] = 'PASSED'
else:
results['Status'] = 'UNKNOWN'
if results['Full Diag'] and results['N/A'] > 0:
results['Asterisk'] = True
results['Status'] += '*'
# Enable CoreStorage searches
results['Core'] = False
if results['Dev Type'] == 'Disk' and results['Full Diag']:
num_passed = results['Passed'] + results['N/A'] + results['OVERRIDE']
if num_passed == len(test_list):
# We ran all disk tests and all results were acceptable
results['Core'] = True
elif results['Failed'] == 1 and dev.tests['I/O Benchmark'].failed:
# We ran all disk tests and only I/O Benchmark failed
results['Core'] = True
# Done
return results
def get_device_type(self, dev):
"""Terrible hack to determine device type, returns str."""
# TODO: Fix with proper isinstance() call
type_str = str(dev.__class__)
if 'CpuObj' in type_str:
type_str = 'CPU'
elif 'DiskObj' in type_str:
type_str = 'Disk'
return type_str
def get_flag(self, ticket_id, flag_name):
"""Get flag in osTicket."""
flag_value = None
self.connect()
# Bail if disabled
if self.disabled:
return
# Build SQL cmd
sql_cmd = "SELECT `{column}` FROM `{Name}`.`{Ticket}`".format(
column=flag_name,
**OSTICKET['Database'],
**OSTICKET['Tables'])
sql_cmd += "WHERE `{Ticket}`.`ticket_id` = {ticket_id}".format(
ticket_id=ticket_id,
**OSTICKET['Tables'])
sql_cmd += ";"
# Run SQL cmd and get value
try:
self.db_cursor.execute(sql_cmd)
for s in self.db_cursor:
flag_value = s[0]
except mariadb.errors.Error:
# Set self.errors to enable warning line on results screen
self.errors = True
# Done
self.disconnect()
return flag_value
def get_ticket_details(self):
"""Get ticket number and name from osTicket DB, returns tuple."""
ticket_name = None
ticket_number = None
# Connect
print_standard('Connecting to osTicket...')
while True:
try:
self.connect(silent=False)
except osTicketConnectionError:
print_warning('Failed to connect to osTicket')
if not ask('Try again?'):
print_standard('Integration disabled for this session')
self.disabled = True
self.tunnel_proc.kill()
return None
else:
# Connection successful
break
# Main loop
while ticket_number is None:
print_standard(' ')
_ticket_id = input_text('Enter ticket number (or leave blank to disable): ')
_ticket_id = _ticket_id.strip()
# No ticket ID entered
if re.match(r'^\s*$', _ticket_id):
if ask('Disable osTicket integration for this run?'):
self.disabled = True
break
# Invalid ID entered
if not re.match(r'^(\d+)$', _ticket_id):
continue
# Valid ID entered, lookup name
try:
_name = self.get_ticket_field(_ticket_id, 'name')
except Exception:
# Ignore and return None below
break
# Verify ticket exists
if _name is None:
print_error('ERROR: Ticket {} not found.'.format(_ticket_id))
continue
# Lookup subject
try:
_subject = self.get_ticket_field(_ticket_id, 'subject')
except Exception:
# Ignore and set to None
_subject = None
# Verify the selected ticket is correct
print_standard(
'You have selected ticket {BLUE}#{ticket_id}{CLEAR} {name}'.format(
ticket_id=_ticket_id,
name=_name,
**COLORS))
print_standard('{CYAN} {subject}{CLEAR}'.format(
subject=_subject,
**COLORS))
print_standard(' ')
if ask('Is this correct?'):
ticket_name = _name
ticket_number = _ticket_id
# Done
self.disconnect()
return (ticket_number, ticket_name)
def get_ticket_field(self, ticket_id, field):
"""Lookup ticket and return field as str."""
data = None
sql_cmd = "SELECT {field} FROM `{Ticket}`".format(
field=field,
**OSTICKET['Tables'])
sql_cmd += " WHERE `ticket_id` = {}".format(ticket_id)
sql_cmd += ";"
# Lookup data
# NOTE: If multiple entries are found it will return the last
self.db_cursor.execute(sql_cmd)
for s in self.db_cursor:
data = s[0]
# Done
return data
def post_device_results(self, dev, ticket_id, ticket_name, color='Diags'):
"""Generate osTicket friendly report and post as response to ticket."""
if not dev.tests:
# No test results available, aborting post
return
response = self.generate_report(dev, ticket_id, ticket_name)
self.post_response(response, ticket_id, color)
def post_response(self, response, ticket_id, color='Normal'):
"""Post a reply to a ticket in osTicket."""
self.connect()
# Bail if disabled
if self.disabled:
return
# Convert response to string
response = '\n'.join(response)
response = response.replace('`', '')
# Build SQL cmd
sql_cmd = "INSERT INTO `{Name}`.`{Response}`".format(
**OSTICKET['Database'], **OSTICKET['Tables'])
sql_cmd += " (ticket_id, staff_id, staff_name, response, created, code)"
sql_cmd += " VALUES ("
sql_cmd += " '{}',".format(ticket_id)
sql_cmd += " '{ID}', '{Name}',".format(**OSTICKET['Staff'])
sql_cmd += " '{}',".format(response.replace("'", "\\'"))
sql_cmd += " '{}',".format(time.strftime("%Y-%m-%d %H:%M:%S"))
sql_cmd += " '{}'".format(OSTICKET['Color Codes'][color])
sql_cmd += " );"
# Run SQL cmd
try:
self.db_cursor.execute(sql_cmd)
except mariadb.errors.Error:
# Set self.errors to enable warning line on results screen
self.errors = True
# Done
self.disconnect()
def set_cpu_failed(self, ticket_id):
"""Mark cpu as failed in osTicket."""
self.set_flag(
ticket_id,
OSTICKET['CPU Flag']['Name'],
OSTICKET['CPU Flag']['Fail'])
def set_cpu_passed(self, ticket_id):
"""Mark cpu as passed in osTicket."""
current_value = self.get_flag(ticket_id, OSTICKET['CPU Flag']['Name'])
# Bail early?
if current_value == OSTICKET['CPU Flag']['Fail']:
print_warning('Not replacing osTicket cpu checkbox FAILED value')
return
# Current value != FAILED, set to passed
self.set_flag(
ticket_id,
OSTICKET['CPU Flag']['Name'],
OSTICKET['CPU Flag']['Pass'])
def set_cpu_max_temp(self, ticket_id, temp):
"""Set CPU temp string in osTicket."""
self.set_flag(
ticket_id,
OSTICKET['CPU Temp']['Name'],
temp,
)
def set_disk_failed(self, ticket_id):
"""Mark disk as failed in osTicket."""
self.set_flag(
ticket_id,
OSTICKET['Disk Flag']['Name'],
OSTICKET['Disk Flag']['Fail'])
def set_disk_passed(self, ticket_id):
"""Mark disk as passed in osTicket."""
current_value = self.get_flag(ticket_id, OSTICKET['Disk Flag']['Name'])
# Bail early?
if current_value == OSTICKET['Disk Flag']['Fail']:
print_warning('Not replacing osTicket disk checkbox FAILED value')
return
# Current value != FAILED, set to passed
self.set_flag(
ticket_id,
OSTICKET['Disk Flag']['Name'],
OSTICKET['Disk Flag']['Pass'])
def set_flag(self, ticket_id, flag_name, flag_value):
"""Set flag in osTicket."""
self.connect()
# Bail if disabled
if self.disabled:
return
# Build SQL cmd
sql_cmd = "UPDATE `{Name}`.`{Ticket}`".format(
**OSTICKET['Database'], **OSTICKET['Tables'])
sql_cmd += " SET `{}` = '{}'".format(flag_name, flag_value)
sql_cmd += " WHERE `{Ticket}`.`ticket_id` = {ticket_id}".format(
ticket_id=ticket_id, **OSTICKET['Tables'])
sql_cmd += ";"
# Run SQL cmd
try:
self.db_cursor.execute(sql_cmd)
except mariadb.errors.Error:
# Set self.errors to enable warning line on results screen
self.errors = True
# Done
self.disconnect()
# Functions
def get_hostname():
"""Get hostname, returns str."""
cmd = ['hostnamectl', '--static']
result = run_program(cmd, check=False, encoding='utf-8', errors='ignore')
result = result.stdout.strip()
result = result.replace('.1201.com', '')
return result
def pad_with_dots(s, pad_right=False):
"""Replace space padding with dots, returns str."""
s = str(s).replace(' ', '..')
if '.' in s:
if pad_right:
s = s + '.'
else:
s = '.' + s
return s
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

120
scripts/wk.prev/functions/product_keys.py
View file

@ -1,120 +0,0 @@
# Wizard Kit: Functions - Product Keys
from functions.common import *
# Regex
REGEX_REGISTRY_DIRS = re.compile(
r'^(config$|RegBack$|System32$|Transfer|Win)',
re.IGNORECASE)
REGEX_SOFTWARE_HIVE = re.compile(r'^Software$', re.IGNORECASE)
def extract_keys():
"""Extract keys from provided hives and return a dict."""
keys = {}
# Extract keys
extract_item('ProduKey', silent=True)
for hive in find_software_hives():
cmd = [
global_vars['Tools']['ProduKey'],
'/IEKeys', '0',
'/WindowsKeys', '1',
'/OfficeKeys', '1',
'/ExtractEdition', '1',
'/nosavereg',
'/regfile', hive,
'/scomma', '']
try:
out = run_program(cmd)
except subprocess.CalledProcessError:
# Ignore and return empty dict
pass
else:
for line in out.stdout.decode().splitlines():
# Add key to keys under product only if unique
tmp = line.split(',')
product = tmp[0]
key = tmp[2]
if product not in keys:
keys[product] = []
if key not in keys[product]:
keys[product].append(key)
# Done
return keys
def list_clientdir_keys():
"""List product keys found in hives inside the ClientDir."""
keys = extract_keys()
key_list = []
if keys:
for product in sorted(keys):
key_list.append(product)
for key in sorted(keys[product]):
key_list.append(' {key}'.format(key=key))
else:
key_list.append('No keys found.')
return key_list
def find_software_hives():
"""Search for transferred SW hives and return a list."""
hives = []
search_paths = [global_vars['ClientDir']]
while len(search_paths) > 0:
for item in os.scandir(search_paths.pop(0)):
if item.is_dir() and REGEX_REGISTRY_DIRS.search(item.name):
search_paths.append(item.path)
if item.is_file() and REGEX_SOFTWARE_HIVE.search(item.name):
hives.append(item.path)
return hives
def get_product_keys():
"""List product keys from saved report."""
keys = []
log_file = r'{LogDir}\Product Keys (ProduKey).txt'.format(**global_vars)
with open (log_file, 'r') as f:
for line in f.readlines():
if re.search(r'^Product Name', line):
line = re.sub(r'^Product Name\s+:\s+(.*)', r'\1', line.strip())
keys.append(line)
if keys:
return keys
else:
return ['No product keys found']
def run_produkey():
"""Run ProduKey and save report in the ClientDir."""
extract_item('ProduKey', silent=True)
log_file = r'{LogDir}\Product Keys (ProduKey).txt'.format(**global_vars)
if not os.path.exists(log_file):
# Clear current configuration
for config in ['ProduKey.cfg', 'ProduKey64.cfg']:
config = r'{BinDir}\ProduKey\{config}'.format(
config=config, **global_vars)
try:
if os.path.exists(config):
os.remove(config)
except Exception:
pass
cmd = [
global_vars['Tools']['ProduKey'],
'/nosavereg',
'/stext',
log_file]
run_program(cmd, check=False)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

136
scripts/wk.prev/functions/repairs.py
View file

@ -1,136 +0,0 @@
# Wizard Kit: Functions - Repairs
from functions.common import *
def run_chkdsk(repair=False):
"""Run CHKDSK scan or schedule offline repairs."""
if repair:
run_chkdsk_offline()
else:
run_chkdsk_scan()
def run_chkdsk_scan():
"""Run CHKDSK in a "split window" and report errors."""
if global_vars['OS']['Version'] in ('8', '8.1', '10'):
cmd = ['chkdsk', global_vars['Env']['SYSTEMDRIVE'], '/scan', '/perf']
else:
cmd = ['chkdsk', global_vars['Env']['SYSTEMDRIVE']]
out = run_program(cmd, check=False)
# retcode == 0: no issues
# retcode == 1: fixed issues (also happens when chkdsk.exe is killed?)
# retcode == 2: issues
if int(out.returncode) > 0:
# print_error(' ERROR: CHKDSK encountered errors')
raise GenericError
# Save stderr
with open(r'{LogDir}\Tools\CHKDSK.err'.format(**global_vars), 'a') as f:
for line in out.stderr.decode().splitlines():
f.write(line.strip() + '\n')
# Save stdout
with open(r'{LogDir}\Tools\CHKDSK.log'.format(**global_vars), 'a') as f:
for line in out.stdout.decode().splitlines():
f.write(line.strip() + '\n')
def run_chkdsk_offline():
"""Set filesystem 'dirty bit' to force a chkdsk during next boot."""
cmd = [
'fsutil', 'dirty',
'set',
global_vars['Env']['SYSTEMDRIVE']]
out = run_program(cmd, check=False)
if int(out.returncode) > 0:
raise GenericError
def run_dism(repair=False):
"""Run DISM to either scan or repair component store health."""
if global_vars['OS']['Version'] in ('8', '8.1', '10'):
if repair:
# Restore Health
cmd = [
'DISM', '/Online',
'/Cleanup-Image', '/RestoreHealth',
r'/LogPath:"{LogDir}\Tools\DISM_RestoreHealth.log"'.format(
**global_vars),
'-new_console:n', '-new_console:s33V']
else:
# Scan Health
cmd = [
'DISM', '/Online',
'/Cleanup-Image', '/ScanHealth',
r'/LogPath:"{LogDir}\Tools\DISM_ScanHealth.log"'.format(
**global_vars),
'-new_console:n', '-new_console:s33V']
run_program(cmd, pipe=False, check=False, shell=True)
wait_for_process('dism')
# Now check health
cmd = [
'DISM', '/Online',
'/Cleanup-Image', '/CheckHealth',
r'/LogPath:"{LogDir}\Tools\DISM_CheckHealth.log"'.format(**global_vars)]
result = run_program(cmd, shell=True).stdout.decode()
# Check result
if 'no component store corruption detected' not in result.lower():
raise GenericError
else:
raise UnsupportedOSError
def run_kvrt():
"""Run KVRT."""
extract_item('KVRT', silent=True)
os.makedirs(global_vars['QuarantineDir'], exist_ok=True)
cmd = [
global_vars['Tools']['KVRT'],
'-accepteula', '-dontcryptsupportinfo', '-fixednames',
'-d', global_vars['QuarantineDir'],
'-processlevel', '3']
popen_program(cmd, pipe=False)
def run_sfc_scan():
"""Run SFC in a "split window" and report errors."""
cmd = [
r'{SYSTEMROOT}\System32\sfc.exe'.format(**global_vars['Env']),
'/scannow']
out = run_program(cmd, check=False)
# Save stderr
with open(r'{LogDir}\Tools\SFC.err'.format(**global_vars), 'a') as f:
for line in out.stderr.decode('utf-8', 'ignore').splitlines():
f.write(line.strip() + '\n')
# Save stdout
with open(r'{LogDir}\Tools\SFC.log'.format(**global_vars), 'a') as f:
for line in out.stdout.decode('utf-8', 'ignore').splitlines():
f.write(line.strip() + '\n')
# Check result
log_text = out.stdout.decode('utf-8', 'ignore').replace('\0', '')
if re.findall(r'did\s+not\s+find\s+any\s+integrity\s+violations', log_text):
pass
elif re.findall(r'successfully\s+repaired\s+them', log_text):
raise GenericRepair
else:
raise GenericError
def run_tdsskiller():
"""Run TDSSKiller."""
extract_item('TDSSKiller', silent=True)
os.makedirs(r'{QuarantineDir}\TDSSKiller'.format(
**global_vars), exist_ok=True)
cmd = [
global_vars['Tools']['TDSSKiller'],
'-l', r'{LogDir}\Tools\TDSSKiller.log'.format(**global_vars),
'-qpath', r'{QuarantineDir}\TDSSKiller'.format(**global_vars),
'-accepteula', '-accepteulaksn',
'-dcexact', '-tdlfs']
run_program(cmd, pipe=False)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

45
scripts/wk.prev/functions/safemode.py
View file

@ -1,45 +0,0 @@
# Wizard Kit: Functions - SafeMode
from functions.common import *
# STATIC VARIABLES
REG_MSISERVER = r'HKLM\SYSTEM\CurrentControlSet\Control\SafeBoot\Network\MSIServer'
def disable_safemode_msi():
"""Disable MSI access under safemode."""
cmd = ['reg', 'delete', REG_MSISERVER, '/f']
run_program(cmd)
def disable_safemode():
"""Edit BCD to remove safeboot value."""
cmd = ['bcdedit', '/deletevalue', '{default}', 'safeboot']
run_program(cmd)
def enable_safemode_msi():
"""Enable MSI access under safemode."""
cmd = ['reg', 'add', REG_MSISERVER, '/f']
run_program(cmd)
cmd = ['reg', 'add', REG_MSISERVER, '/ve',
'/t', 'REG_SZ', '/d', 'Service', '/f']
run_program(cmd)
def enable_safemode():
"""Edit BCD to set safeboot as default."""
cmd = ['bcdedit', '/set', '{default}', 'safeboot', 'network']
run_program(cmd)
def reboot(delay=3):
cmd = ['shutdown', '-r', '-t', '{}'.format(delay)]
run_program(cmd, check=False)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

259
scripts/wk.prev/functions/sensors.py
View file

@ -1,259 +0,0 @@
'''Wizard Kit: Functions - Sensors'''
# pylint: disable=no-name-in-module,wildcard-import
# vim: sts=2 sw=2 ts=2
import json
import re
from functions.tmux import *
from settings.sensors import *
# Error Classes
class ThermalLimitReachedError(Exception):
'''Thermal limit reached error.'''
def clear_temps(sensor_data):
"""Clear saved temps but keep structure, returns dict."""
for _section, _adapters in sensor_data.items():
for _adapter, _sources in _adapters.items():
for _source, _data in _sources.items():
_data['Temps'] = []
def fix_sensor_str(_s):
"""Cleanup string and return str."""
_s = re.sub(r'^(\w+)-(\w+)-(\w+)', r'\1 (\2 \3)', _s, re.IGNORECASE)
_s = _s.title()
_s = _s.replace('Coretemp', 'CPUTemp')
_s = _s.replace('Acpi', 'ACPI')
_s = _s.replace('ACPItz', 'ACPI TZ')
_s = _s.replace('Isa ', 'ISA ')
_s = _s.replace('Pci ', 'PCI ')
_s = _s.replace('Id ', 'ID ')
_s = re.sub(r'(\D+)(\d+)', r'\1 \2', _s, re.IGNORECASE)
_s = re.sub(r'^K (\d+)Temp', r'AMD K\1 Temps', _s, re.IGNORECASE)
_s = re.sub(r'T(ctl|die)', r'CPU (T\1)', _s, re.IGNORECASE)
return _s
def generate_sensor_report(
sensor_data, *temp_labels,
colors=True, cpu_only=False):
"""Generate report based on temp_labels, returns list if str."""
report = []
for _section, _adapters in sorted(sensor_data.items()):
# CPU temps then Other temps
if cpu_only and 'CPU' not in _section:
continue
for _adapter, _sources in sorted(_adapters.items()):
# Adapter
report.append(fix_sensor_str(_adapter))
for _source, _data in sorted(_sources.items()):
# Source
_line = '{:18} '.format(fix_sensor_str(_source))
# Temps (skip label for Current)
for _label in temp_labels:
_line += '{}{}{} '.format(
_label.lower() if _label != 'Current' else '',
': ' if _label != 'Current' else '',
get_temp_str(_data.get(_label, '???'), colors=colors))
report.append(_line)
if not cpu_only:
report.append(' ')
# Handle empty reports (i.e. no sensors detected)
if not report:
report = [
'{}WARNING: No sensors found{}'.format(
COLORS['YELLOW'] if colors else '',
COLORS['CLEAR'] if colors else ''),
' ',
'Please monitor temps manually']
# Done
return report
def get_colored_temp_str(temp):
"""Get colored string based on temp, returns str."""
try:
temp = float(temp)
except ValueError:
return '{YELLOW}{temp}{CLEAR}'.format(temp=temp, **COLORS)
if temp > TEMP_LIMITS['RED']:
color = COLORS['RED']
elif temp > TEMP_LIMITS['ORANGE']:
color = COLORS['ORANGE']
elif temp > TEMP_LIMITS['YELLOW']:
color = COLORS['YELLOW']
elif temp > TEMP_LIMITS['GREEN']:
color = COLORS['GREEN']
elif temp > 0:
color = COLORS['BLUE']
else:
color = COLORS['CLEAR']
return '{color}{prefix}{temp:2.0f}°C{CLEAR}'.format(
color=color,
prefix='-' if temp < 0 else '',
temp=temp,
**COLORS)
def get_cpu_max_temp(sensor_data):
"""get max temp"""
max_temp = 0.0
# Check all CPU Temps
for section, adapters in sensor_data.items():
if not section.startswith('CPU'):
continue
for sources in adapters.values():
for source_data in sources.values():
max_temp = max(max_temp, source_data.get('Max', 0))
# Done
return max_temp
def get_raw_sensor_data():
"""Read sensor data and return dict."""
json_data = {}
cmd = ['sensors', '-j']
# Get raw data
try:
result = run_program(cmd)
result = result.stdout.decode('utf-8', errors='ignore').splitlines()
except subprocess.CalledProcessError:
# Assuming no sensors available, set to empty list
result = []
# Workaround for bad sensors
raw_data = []
for line in result:
if line.strip() == ',':
# Assuming malformatted line caused by missing data
continue
raw_data.append(line)
# Parse JSON data
try:
json_data = json.loads('\n'.join(raw_data))
except json.JSONDecodeError:
# Still broken, just return the empty dict
pass
# Done
return json_data
def get_sensor_data():
"""Parse raw sensor data and return new dict."""
json_data = get_raw_sensor_data()
sensor_data = {'CPUTemps': {}, 'Other': {}}
for _adapter, _sources in json_data.items():
if is_cpu_adapter(_adapter):
_section = 'CPUTemps'
else:
_section = 'Other'
sensor_data[_section][_adapter] = {}
_sources.pop('Adapter', None)
# Find current temp and add to dict
## current temp is labeled xxxx_input
for _source, _labels in _sources.items():
for _label, _temp in _labels.items():
if _label.startswith('fan'):
# Skip fan RPMs
continue
if 'input' in _label:
sensor_data[_section][_adapter][_source] = {
'Current': _temp,
'Label': _label,
'Max': _temp,
'Temps': [_temp],
}
# Remove empty sections
for _k, _v in sensor_data.items():
_v = {_k2: _v2 for _k2, _v2 in _v.items() if _v2}
# Done
return sensor_data
def get_temp_str(temp, colors=True):
"""Get temp string, returns str."""
if colors:
return get_colored_temp_str(temp)
try:
temp = float(temp)
except ValueError:
return '{}'.format(temp)
else:
return '{}{:2.0f}°C'.format(
'-' if temp < 0 else '',
temp)
def is_cpu_adapter(adapter):
"""Checks if adapter is a known CPU adapter, returns bool."""
is_cpu = re.search(r'(core|k\d+)temp', adapter, re.IGNORECASE)
return bool(is_cpu)
def monitor_sensors(monitor_pane, monitor_file):
"""Continually update sensor data and report to screen."""
sensor_data = get_sensor_data()
while True:
update_sensor_data(sensor_data)
with open(monitor_file, 'w') as _f:
report = generate_sensor_report(sensor_data, 'Current', 'Max')
_f.write('\n'.join(report))
sleep(1)
if monitor_pane and not tmux_poll_pane(monitor_pane):
break
def save_average_temp(sensor_data, temp_label, seconds=10):
"""Save average temps under temp_label, returns dict."""
clear_temps(sensor_data)
# Get temps
for _i in range(seconds): # pylint: disable=unused-variable
update_sensor_data(sensor_data)
sleep(1)
# Calculate averages
for _section, _adapters in sensor_data.items():
for _adapter, _sources in _adapters.items():
for _source, _data in _sources.items():
_data[temp_label] = sum(_data['Temps']) / len(_data['Temps'])
def update_sensor_data(sensor_data, thermal_limit=None):
"""Read sensors and update existing sensor_data, returns dict."""
json_data = get_raw_sensor_data()
for _section, _adapters in sensor_data.items():
for _adapter, _sources in _adapters.items():
for _source, _data in _sources.items():
try:
_label = _data['Label']
_temp = json_data[_adapter][_source][_label]
_data['Current'] = _temp
_data['Max'] = max(_temp, _data['Max'])
_data['Temps'].append(_temp)
except Exception: # pylint: disable=broad-except
# Dumb workound for Dell sensors with changing source names
pass
# Check if thermal limit reached
if thermal_limit and _section == 'CPUTemps':
if max(_data['Current'], _data['Max']) >= thermal_limit:
raise ThermalLimitReachedError('CPU temps reached limit')
if __name__ == '__main__':
print("This file is not meant to be called directly.")

509
scripts/wk.prev/functions/setup.py
View file

@ -1,509 +0,0 @@
# Wizard Kit: Functions - Setup
from functions.browsers import *
from functions.json import *
from functions.update import *
from settings.setup import *
from settings.sources import *
# Configuration
def config_classicstart():
"""Configure ClassicStart."""
# User level, not system level
cs_exe = r'{PROGRAMFILES}\Classic Shell\ClassicStartMenu.exe'.format(
**global_vars['Env'])
skin = r'{PROGRAMFILES}\Classic Shell\Skins\Metro-Win10-Black.skin7'.format(
**global_vars['Env'])
extract_item('ClassicStartSkin', silent=True)
# Stop Classic Start
run_program([cs_exe, '-exit'], check=False)
sleep(1)
kill_process('ClassicStartMenu.exe')
# Configure
write_registry_settings(SETTINGS_CLASSIC_START, all_users=False)
if global_vars['OS']['Version'] == '10' and os.path.exists(skin):
# Enable Win10 theme if on Win10
key_path = r'Software\IvoSoft\ClassicStartMenu\Settings'
with winreg.OpenKey(HKCU, key_path, access=winreg.KEY_WRITE) as key:
winreg.SetValueEx(
key, 'SkinW7', 0, winreg.REG_SZ, 'Metro-Win10-Black')
winreg.SetValueEx(key, 'SkinVariationW7', 0, winreg.REG_SZ, '')
# Pin Browser to Start Menu (Classic)
firefox = r'{PROGRAMDATA}\Start Menu\Programs\Mozilla Firefox.lnk'.format(
**global_vars['Env'])
chrome = r'{PROGRAMDATA}\Start Menu\Programs\Google Chrome.lnk'.format(
**global_vars['Env'])
dest_path = r'{APPDATA}\ClassicShell\Pinned'.format(**global_vars['Env'])
source = None
dest = None
if os.path.exists(firefox):
source = firefox
dest = r'{}\Mozilla Firefox.lnk'.format(dest_path)
elif os.path.exists(chrome):
source = chrome
dest = r'{}\Google Chrome.lnk'.format(dest_path)
if source:
try:
os.makedirs(dest_path, exist_ok=True)
shutil.copy(source, dest)
except Exception:
pass # Meh, it's fine without
# (Re)start Classic Start
run_program([cs_exe, '-exit'], check=False)
sleep(1)
kill_process('ClassicStartMenu.exe')
sleep(1)
popen_program(cs_exe)
def config_explorer_system():
"""Configure Windows Explorer for all users."""
write_registry_settings(SETTINGS_EXPLORER_SYSTEM, all_users=True)
def config_explorer_user(setup_mode='All'):
"""Configure Windows Explorer for current user per setup_mode."""
settings_explorer_user = {
k: v for k, v in SETTINGS_EXPLORER_USER.items()
if setup_mode not in v.get('Invalid modes', [])
}
write_registry_settings(settings_explorer_user, all_users=False)
def config_power_plans(name='Balanced'):
"""Meta function to backup, restore defaults, and set the power plan."""
backup_power_plans()
reset_power_plans()
set_power_plan(name)
def config_windows_updates():
"""Configure Windows updates."""
write_registry_settings(SETTINGS_WINDOWS_UPDATES, all_users=True)
def create_system_restore_point():
"""Create system restore point."""
cmd = [
'PowerShell',
'-Command', 'Checkpoint-Computer',
'-Description', '1201-Checklist',
]
run_program(cmd)
def disable_fast_startup():
"""Disable Fast Startup."""
write_registry_settings(SETTINGS_FAST_STARTUP, all_users=True)
def disable_windows_telemetry():
"""Disable Windows 10 telemetry settings with O&O ShutUp10."""
extract_item('ShutUp10', silent=True)
cmd = [
r'{BinDir}\ShutUp10\OOSU10.exe'.format(**global_vars),
r'{BinDir}\ShutUp10\1201.cfg'.format(**global_vars),
'/quiet']
run_program(cmd)
def enable_hibernation():
"""Enable hibernation."""
cmd = ['powercfg', '/hibernate', 'on']
run_program(cmd)
def enable_regback():
"""Enable RegBack."""
write_registry_settings(SETTINGS_REGBACK, all_users=True)
def enable_mini_dumps():
"""Configure Windows to save mini dumps during BSoDs."""
cmd = ['wmic', 'RECOVEROS', 'set', 'DebugInfoType', '=', '3']
run_program(cmd)
def enable_system_restore():
"""Enable System Restore and set disk usage to 8%"""
cmd = [
'PowerShell',
'-Command', 'Enable-ComputerRestore',
'-Drive', '{}\\'.format(global_vars['Env']['SYSTEMDRIVE'])]
run_program(cmd)
# Set disk usage
cmd = [
r'{}\System32\vssadmin.exe'.format(global_vars['Env']['SYSTEMROOT']),
'resize', 'shadowstorage',
'/on={}'.format(global_vars['Env']['SYSTEMDRIVE']),
'/for={}'.format(global_vars['Env']['SYSTEMDRIVE']),
'/maxsize=8%']
run_program(cmd)
def open_default_apps():
"""TODO"""
run_program(['start', '', 'ms-settings:defaultapps'], shell=True, check=False)
def reset_power_plans():
"""Reset power plans to default settings."""
cmd = ['powercfg', '-RestoreDefaultSchemes']
run_program(cmd)
def set_power_plan(name='Balanced'):
"""Set power plan by name."""
guid = POWER_PLAN_GUIDS[name]
cmd = ['powercfg', '-SetActive', guid]
run_program(cmd)
def update_clock():
"""Set Timezone and sync clock."""
run_program(['tzutil', '/s', WINDOWS_TIME_ZONE], check=False)
run_program(['net', 'stop', 'w32ime'], check=False)
run_program(
['w32tm', '/config', '/syncfromflags:manual',
'/manualpeerlist:"us.pool.ntp.org time.nist.gov time.windows.com"',
],
check=False)
run_program(['net', 'start', 'w32ime'], check=False)
run_program(['w32tm', '/resync', '/nowait'], check=False)
def write_registry_settings(settings, all_users=False):
"""Write registry values from custom dict of dicts."""
hive = HKCU
if all_users:
hive = HKLM
for k, v in settings.items():
# CreateKey
access = winreg.KEY_WRITE
if 'WOW64_32' in v:
access = access | winreg.KEY_WOW64_32KEY
winreg.CreateKeyEx(hive, k, 0, access)
# Create values
with winreg.OpenKeyEx(hive, k, 0, access) as key:
for name, value in v.get('DWORD Items', {}).items():
winreg.SetValueEx(key, name, 0, winreg.REG_DWORD, value)
for name, value in v.get('SZ Items', {}).items():
winreg.SetValueEx(key, name, 0, winreg.REG_SZ, value)
# Installations
def find_current_software():
"""Find currently installed software, returns list."""
ninite_extras_path = r'{BaseDir}\Installers\Extras'.format(**global_vars)
installers = []
# Browsers
scan_for_browsers(skip_ie=True, silent=True)
for browser in ('Google Chrome', 'Mozilla Firefox', 'Opera Chromium'):
if is_installed(browser):
installers.append(
r'{}\Web Browsers\{}.exe'.format(ninite_extras_path, browser))
# TODO: Add more sections
return installers
def find_missing_software():
"""Find missing software based on dirs/files present, returns list."""
ninite_extras_path = r'{BaseDir}\Installers\Extras'.format(**global_vars)
installers = []
# Browsers
scan_for_browsers(skip_ie=True, silent=True)
for browser in ('Google Chrome', 'Mozilla Firefox', 'Opera Chromium'):
if profile_present(browser):
installers.append(
r'{}\Web Browsers\{}.exe'.format(ninite_extras_path, browser))
# TODO: Add more sections
return installers
def install_adobe_reader():
"""Install Adobe Reader."""
cmd = [
r'{BaseDir}\Installers\Extras\Office\Adobe Reader DC.exe'.format(
**global_vars),
'/sAll',
'/msi', '/norestart', '/quiet',
'ALLUSERS=1',
'EULA_ACCEPT=YES']
run_program(cmd)
def install_chrome_extensions():
"""Install Google Chrome extensions for all users."""
write_registry_settings(SETTINGS_GOOGLE_CHROME, all_users=True)
def install_classicstart_skin():
"""Extract ClassicStart skin to installation folder."""
if global_vars['OS']['Version'] not in ('8', '8.1', '10'):
raise UnsupportedOSError
extract_item('ClassicStartSkin', silent=True)
source = r'{BinDir}\ClassicStartSkin\Metro-Win10-Black.skin7'.format(
**global_vars)
dest_path = r'{PROGRAMFILES}\Classic Shell\Skins'.format(
**global_vars['Env'])
dest = r'{}\Metro-Win10-Black.skin7'.format(dest_path)
os.makedirs(dest_path, exist_ok=True)
shutil.copy(source, dest)
def install_eset_nod32_av(msp=False):
"""Install ESET NOD32 AV with custom config."""
extract_item('ESETConfigs', silent=True)
config_file = r'{BinDir}\ESETConfigs\{config_file}.xml'.format(
config_file='eset-config-msp' if msp else 'eset-config',
**global_vars)
# Registry settings
write_registry_settings(SETTINGS_ESET_SYSTEM, all_users=True)
write_registry_settings(SETTINGS_ESET_USER, all_users=False)
# Install
cmd = [
r'{}\Installers\Extras\Security\ESET NOD32 x64.exe'.format(
global_vars['BaseDir']),
'--silent', '--accepteula', '--msi-property',
'PRODUCTTYPE=eav', 'PRODUCT_LANG=1033', 'PRODUCT_LANG_CODE=en-US',
'ADMINCFG="{}"'.format(config_file),
]
run_program(cmd)
def install_firefox_extensions():
"""Install Firefox extensions for all users."""
dist_path = r'{PROGRAMFILES}\Mozilla Firefox\distribution\extensions'.format(
**global_vars['Env'])
source_path = r'{CBinDir}\FirefoxExtensions.7z'.format(**global_vars)
if not os.path.exists(source_path):
raise FileNotFoundError
# Update registry
write_registry_settings(SETTINGS_MOZILLA_FIREFOX_32, all_users=True)
write_registry_settings(SETTINGS_MOZILLA_FIREFOX_64, all_users=True)
# Extract extension(s) to distribution folder
cmd = [
global_vars['Tools']['SevenZip'], 'e', '-aos', '-bso0', '-bse0',
'-p{ArchivePassword}'.format(**global_vars),
'-o{dist_path}'.format(dist_path=dist_path),
source_path]
run_program(cmd)
def install_libreoffice(
quickstart=True, register_mso_types=True,
use_mso_formats=False, vcredist=False):
"""Install LibreOffice using specified settings."""
cmd = [
'msiexec', '/passive', '/norestart',
'/i', r'{}\Installers\Extras\Office\LibreOffice.msi'.format(
global_vars['BaseDir']),
'REBOOTYESNO=No',
'ISCHECKFORPRODUCTUPDATES=0',
'QUICKSTART={}'.format(1 if quickstart else 0),
'UI_LANGS=en_US',
'VC_REDIST={}'.format(1 if vcredist else 0),
]
if register_mso_types:
cmd.append('REGISTER_ALL_MSO_TYPES=1')
else:
cmd.append('REGISTER_NO_MSO_TYPES=1')
xcu_dir = r'{APPDATA}\LibreOffice\4\user'.format(**global_vars['Env'])
xcu_file = r'{}\registrymodifications.xcu'.format(xcu_dir)
# Set default save format
if use_mso_formats and not os.path.exists(xcu_file):
os.makedirs(xcu_dir, exist_ok=True)
with open(xcu_file, 'w', encoding='utf-8', newline='\n') as f:
f.write(LIBREOFFICE_XCU_DATA)
# Install LibreOffice
run_program(cmd, check=True)
def install_ninite_bundle(
# pylint: disable=too-many-arguments,too-many-branches
base=True,
browsers_only=False,
libreoffice=False,
missing=False,
mse=False,
standard=True,
):
"""Run Ninite installer(s), returns list of Popen objects."""
popen_objects = []
if browsers_only:
# This option is deprecated
installer_path = r'{BaseDir}\Installers\Extras\Web Browsers'.format(
**global_vars)
scan_for_browsers(skip_ie=True, silent=True)
for browser in ('Google Chrome', 'Mozilla Firefox', 'Opera Chromium'):
if is_installed(browser):
cmd = r'{}\{}.exe'.format(installer_path, browser)
popen_objects.append(popen_program(cmd))
# Bail
return popen_objects
# Main selections
main_selections = []
if base and standard:
main_selections.append('base-standard')
elif base:
main_selections.append('base')
elif standard:
main_selections.append('standard')
if global_vars['OS']['Version'] not in ('8', '8.1', '10'):
main_selections = [f'{s}7' for s in main_selections]
if main_selections:
# Only run if base and/or standard are enabled
cmd = r'{}\Installers\Extras\Bundles\{}.exe'.format(
global_vars['BaseDir'],
'-'.join(main_selections),
)
popen_objects.append(popen_program([cmd]))
# Extra selections
extra_selections = {}
for cmd in find_current_software():
extra_selections[cmd] = True
if missing:
for cmd in find_missing_software():
extra_selections[cmd] = True
# Remove overlapping selections
regex = []
for n_name, n_group in NINITE_REGEX.items():
if n_name in main_selections:
regex.extend(n_group)
regex = '({})'.format('|'.join(regex))
extra_selections = {
cmd: True for cmd in extra_selections
if not re.search(regex, cmd, re.IGNORECASE)
}
# Start extra selections
for cmd in extra_selections:
popen_objects.append(popen_program([cmd]))
# Microsoft Security Essentials
if mse:
cmd = r'{}\Installers\Extras\Security\{}'.format(
global_vars['BaseDir'],
'Microsoft Security Essentials.exe',
)
popen_objects.append(popen_program([cmd]))
# LibreOffice
if libreoffice:
cmd = r'{}\Installers\Extras\Office\{}'.format(
global_vars['BaseDir'],
'LibreOffice.exe',
)
popen_objects.append(popen_program([cmd]))
# Done
return popen_objects
def install_vcredists():
"""Install all supported Visual C++ runtimes."""
extract_item('_vcredists', silent=True)
prev_dir = os.getcwd()
try:
os.chdir(r'{BinDir}\_vcredists'.format(**global_vars))
except FileNotFoundError:
# Ignored since the loop below will report the errors
pass
for vcr in VCR_REDISTS:
try_and_print(message=vcr['Name'], function=run_program,
cmd=vcr['Cmd'], other_results=OTHER_RESULTS)
os.chdir(prev_dir)
# Misc
def drive_is_rotational(drive):
"""Check if drive is rotational, returns bool.
NOTE: This is a quick, naive check with a bias towards rotational."""
is_rotational = True
# Get SMART data
extract_item('smartmontools', silent=True)
cmd = [
global_vars['Tools']['smartctl'],
'--info',
'--json',
drive,
]
data = get_json_from_command(cmd, check=False)
# Check rotation rate
try:
is_rotational = int(data.get('rotation_rate', '01189998819991197253')) == 0
except ValueError:
# Ignore and assume rotational
pass
return is_rotational
def fix_windows_temp_dir():
"""TODO"""
user_perms = [
'Users:(CI)(X,WD,AD)',
'Administrators:(OI)(CI)(F)',
]
for u_p in user_perms:
cmd = ['icacls', r'C:\Windows\Temp', '/grant:r', u_p, '/T']
run_program(cmd)
def open_device_manager():
popen_program(['mmc', 'devmgmt.msc'])
def open_snappy_driver_origin():
cwd = r'{BinDir}\_Drivers\SDIO'.format(**global_vars)
cmd = [r'{}\SDIO.exe'.format(cwd)]
popen_program(cmd, cwd=cwd, pipe=True)
def open_speedtest():
popen_program(['start', '', 'https://fast.com'], shell=True)
def open_windows_activation():
popen_program(['slui'])
def open_windows_updates():
popen_program(['control', '/name', 'Microsoft.WindowsUpdate'])
def restart_explorer():
"""Restart Explorer."""
kill_process('explorer.exe')
sleep(2)
kill_process('explorer.exe')
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

244
scripts/wk.prev/functions/sw_diags.py
View file

@ -1,244 +0,0 @@
# Wizard Kit: Functions - SW Diagnostics
import ctypes
from functions.common import *
from settings.sw_diags import *
def check_4k_alignment(show_alert=False):
"""Check that all partitions are 4K aligned."""
aligned = True
cmd = ['WMIC', 'partition', 'get', 'StartingOffset']
offsets = []
# Get offsets
result = run_program(cmd, encoding='utf-8', errors='ignore', check=False)
offsets = result.stdout.splitlines()
# Check offsets
for off in offsets:
off = off.strip()
if not off.isnumeric():
# Skip
continue
try:
aligned = aligned and int(off) % 4096 == 0
except ValueError:
# Ignore, this check is low priority
pass
# Show alert
if show_alert:
show_alert_box('One or more partitions are not 4K aligned')
raise Not4KAlignedError
def check_connection():
"""Check if the system is online and optionally abort the script."""
while True:
result = try_and_print(message='Ping test...', function=ping, cs='OK')
if result['CS']:
break
if not ask('ERROR: System appears offline, try again?'):
if ask('Continue anyway?'):
break
else:
abort()
def check_os_support_status():
"""Check if current OS is supported."""
msg = ''
outdated = False
unsupported = False
# Check OS version/notes
os_info = global_vars['OS'].copy()
if os_info['Notes'] == 'unsupported':
msg = 'The installed version of Windows is no longer supported'
unsupported = True
elif os_info['Notes'] == 'preview build':
msg = 'Preview builds are not officially supported'
unsupported = True
elif os_info['Version'] == '10' and os_info['Notes'] == 'outdated':
msg = 'The installed version of Windows is outdated'
outdated = True
if 'Preview' not in msg:
msg += '\n\nPlease consider upgrading before continuing setup.'
# Show alert
if outdated or unsupported:
show_alert_box(msg)
# Raise exception if necessary
if outdated:
raise WindowsOutdatedError
if unsupported:
raise WindowsUnsupportedError
def check_secure_boot_status(show_alert=False):
"""Checks UEFI Secure Boot status via PowerShell."""
boot_mode = get_boot_mode()
cmd = ['PowerShell', '-Command', 'Confirm-SecureBootUEFI']
result = run_program(cmd, check=False)
# Check results
if result.returncode == 0:
out = result.stdout.decode()
if 'True' in out:
# It's on, do nothing
return
elif 'False' in out:
if show_alert:
show_alert_box('Secure Boot DISABLED')
raise SecureBootDisabledError
else:
if show_alert:
show_alert_box('Secure Boot status UNKNOWN')
raise SecureBootUnknownError
else:
if boot_mode != 'UEFI':
if (show_alert and
global_vars['OS']['Version'] in ('8', '8.1', '10')):
# OS supports Secure Boot
show_alert_box('Secure Boot DISABLED\n\nOS installed LEGACY')
raise OSInstalledLegacyError
else:
# Check error message
err = result.stderr.decode()
if 'Cmdlet not supported' in err:
if show_alert:
show_alert_box('Secure Boot UNAVAILABLE?')
raise SecureBootNotAvailError
else:
if show_alert:
show_alert_box('Secure Boot ERROR')
raise GenericError
def get_boot_mode():
"""Check if Windows is booted in UEFI or Legacy mode, returns str."""
kernel = ctypes.windll.kernel32
firmware_type = ctypes.c_uint()
# Get value from kernel32 API
try:
kernel.GetFirmwareType(ctypes.byref(firmware_type))
except:
# Just set to zero
firmware_type = ctypes.c_uint(0)
# Set return value
type_str = 'Unknown'
if firmware_type.value == 1:
type_str = 'Legacy'
elif firmware_type.value == 2:
type_str = 'UEFI'
return type_str
def run_autoruns():
"""Run AutoRuns in the background with VirusTotal checks enabled."""
extract_item('Autoruns', filter='autoruns*', silent=True)
# Update AutoRuns settings before running
for path, settings in AUTORUNS_SETTINGS.items():
winreg.CreateKey(HKCU, path)
with winreg.OpenKey(HKCU, path, access=winreg.KEY_WRITE) as key:
for name, value in settings.items():
winreg.SetValueEx(key, name, 0, winreg.REG_DWORD, value)
popen_program(global_vars['Tools']['AutoRuns'], minimized=True)
def run_hwinfo_sensors():
"""Run HWiNFO sensors."""
path = r'{BinDir}\HWiNFO'.format(**global_vars)
for bit in [32, 64]:
# Configure
source = r'{}\general.ini'.format(path)
dest = r'{}\HWiNFO{}.ini'.format(path, bit)
shutil.copy(source, dest)
with open(dest, 'a') as f:
f.write('SensorsOnly=1\n')
f.write('SummaryOnly=0\n')
popen_program(global_vars['Tools']['HWiNFO'])
def run_nircmd(*cmd):
"""Run custom NirCmd."""
extract_item('NirCmd', silent=True)
cmd = [global_vars['Tools']['NirCmd'], *cmd]
run_program(cmd, check=False)
def run_xmplay():
"""Run XMPlay to test audio."""
extract_item('XMPlay', silent=True)
cmd = [global_vars['Tools']['XMPlay'],
r'{BinDir}\XMPlay\music.7z'.format(**global_vars)]
# Unmute audio first
extract_item('NirCmd', silent=True)
run_nircmd('mutesysvolume', '0')
# Open XMPlay
popen_program(cmd)
def run_hitmanpro():
"""Run HitmanPro in the background."""
extract_item('HitmanPro', silent=True)
cmd = [
global_vars['Tools']['HitmanPro'],
'/quiet', '/noinstall', '/noupload',
r'/log={LogDir}\Tools\HitmanPro.txt'.format(**global_vars)]
popen_program(cmd)
def run_process_killer():
"""Kill most running processes skipping those in the whitelist.txt."""
# borrowed from TronScript (reddit.com/r/TronScript)
# credit to /u/cuddlychops06
prev_dir = os.getcwd()
extract_item('ProcessKiller', silent=True)
os.chdir(r'{BinDir}\ProcessKiller'.format(**global_vars))
run_program(['ProcessKiller.exe', '/silent'], check=False)
os.chdir(prev_dir)
def run_rkill():
"""Run RKill and cleanup afterwards."""
extract_item('RKill', silent=True)
cmd = [
global_vars['Tools']['RKill'],
'-s', '-l', r'{LogDir}\Tools\RKill.log'.format(**global_vars),
'-new_console:n', '-new_console:s33V']
run_program(cmd, check=False)
wait_for_process('RKill')
# RKill cleanup
desktop_path = r'{USERPROFILE}\Desktop'.format(**global_vars['Env'])
if os.path.exists(desktop_path):
for item in os.scandir(desktop_path):
if re.search(r'^RKill', item.name, re.IGNORECASE):
dest = r'{LogDir}\Tools\{name}'.format(
name=dest, **global_vars)
dest = non_clobber_rename(dest)
shutil.move(item.path, dest)
def show_alert_box(message, title=None):
"""Show Windows alert box with message."""
if not title:
title = '{} Warning'.format(KIT_NAME_FULL)
message_box = ctypes.windll.user32.MessageBoxW
message_box(None, message, title, 0x00001030)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

47
scripts/wk.prev/functions/threading.py
View file

@ -1,47 +0,0 @@
# Wizard Kit: Functions - Threading
from threading import Thread
from queue import Queue, Empty
# Classes
class NonBlockingStreamReader():
"""Class to allow non-blocking reads from a stream."""
# Credits:
## https://gist.github.com/EyalAr/7915597
## https://stackoverflow.com/a/4896288
def __init__(self, stream):
self.stream = stream
self.queue = Queue()
def populate_queue(stream, queue):
"""Collect lines from stream and put them in queue."""
while True:
line = stream.read(1)
if line:
queue.put(line)
self.thread = start_thread(
populate_queue,
args=(self.stream, self.queue))
def read(self, timeout=None):
try:
return self.queue.get(block = timeout is not None,
timeout = timeout)
except Empty:
return None
# Functions
def start_thread(function, args=[], daemon=True):
"""Run function as thread in background, returns Thread object."""
thread = Thread(target=function, args=args, daemon=daemon)
thread.start()
return thread
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

189
scripts/wk.prev/functions/tmux.py
View file

@ -1,189 +0,0 @@
# Wizard Kit: Functions - tmux
from functions.common import *
def create_file(filepath):
"""Create file if it doesn't exist."""
if not os.path.exists(filepath):
with open(filepath, 'w') as f:
f.write('')
def tmux_capture_pane(pane_id=None):
"""Capture text from target, or current, pane, returns str."""
cmd = ['tmux', 'capture-pane', '-p']
if pane_id:
cmd.extend(['-t', pane_id])
text = ''
# Capture
result = run_program(cmd, check=False, encoding='utf-8', errors='ignore')
text = result.stdout
# Done
return str(text)
def tmux_get_pane_size(pane_id=None):
"""Get target, or current, pane size, returns tuple."""
x = -1
y = -1
cmd = ['tmux', 'display', '-p']
if pane_id:
cmd.extend(['-t', pane_id])
cmd.append('#{pane_width} #{pane_height}')
# Run cmd and set x & y
result = run_program(cmd, check=False)
try:
x, y = result.stdout.decode().strip().split()
x = int(x)
y = int(y)
except Exception:
# Ignore and return unrealistic values
pass
return (x, y)
def tmux_kill_all_panes(pane_id=None):
"""Kill all tmux panes except the active pane or pane_id if specified."""
cmd = ['tmux', 'kill-pane', '-a']
if pane_id:
cmd.extend(['-t', pane_id])
run_program(cmd, check=False)
def tmux_kill_pane(*panes):
"""Kill tmux pane by id."""
cmd = ['tmux', 'kill-pane', '-t']
for pane_id in panes:
if not pane_id:
# Skip empty strings, None values, etc
continue
run_program(cmd+[pane_id], check=False)
def tmux_poll_pane(pane_id):
"""Check if pane exists, returns bool."""
cmd = ['tmux', 'list-panes', '-F', '#D']
result = run_program(cmd, check=False)
panes = result.stdout.decode().splitlines()
return pane_id in panes
def tmux_resize_pane(pane_id=None, x=None, y=None, **kwargs):
"""Resize pane to specific hieght or width."""
if not x and not y:
raise Exception('Neither height nor width specified.')
cmd = ['tmux', 'resize-pane']
if pane_id:
# NOTE: If pane_id not specified then the current pane will be resized
cmd.extend(['-t', pane_id])
if x:
cmd.extend(['-x', str(x)])
elif y:
cmd.extend(['-y', str(y)])
run_program(cmd, check=False)
def tmux_split_window(
lines=None, percent=None,
behind=False, vertical=False,
follow=False, target_pane=None,
command=None, working_dir=None,
text=None, watch=None, watch_cmd='cat'):
"""Run tmux split-window command and return pane_id as str."""
# Bail early
if not lines and not percent:
raise Exception('Neither lines nor percent specified.')
if not command and not text and not watch:
raise Exception('No command, text, or watch file specified.')
# Build cmd
cmd = ['tmux', 'split-window', '-PF', '#D']
if behind:
cmd.append('-b')
if vertical:
cmd.append('-v')
else:
cmd.append('-h')
if not follow:
cmd.append('-d')
if lines is not None:
cmd.extend(['-l', str(lines)])
elif percent is not None:
cmd.extend(['-p', str(percent)])
if target_pane:
cmd.extend(['-t', str(target_pane)])
if working_dir:
cmd.extend(['-c', working_dir])
if command:
cmd.extend(command)
elif text:
cmd.extend(['echo-and-hold "{}"'.format(text)])
elif watch:
create_file(watch)
if watch_cmd == 'cat':
cmd.extend([
'watch', '--color', '--no-title',
'--interval', '1',
'cat', watch])
elif watch_cmd == 'tail':
cmd.extend(['tail', '-f', watch])
# Run and return pane_id
result = run_program(cmd)
return result.stdout.decode().strip()
def tmux_switch_client(target_session=None):
"""Switch to target tmux session, or previous if none specified."""
# DEPRECATED - Do nothing
return
cmd = ['tmux', 'switch-client']
if target_session:
cmd.extend(['-t', target_session])
else:
# Switch to previous instead
cmd.append('-p')
run_program(cmd, check=False)
def tmux_update_pane(
pane_id, command=None, working_dir=None,
text=None, watch=None, watch_cmd='cat'):
"""Respawn with either a new command or new text."""
# Bail early
if not command and not text and not watch:
raise Exception('No command, text, or watch file specified.')
cmd = ['tmux', 'respawn-pane', '-k', '-t', pane_id]
if working_dir:
cmd.extend(['-c', working_dir])
if command:
cmd.extend(command)
elif text:
cmd.extend(['echo-and-hold "{}"'.format(text)])
elif watch:
create_file(watch)
if watch_cmd == 'cat':
cmd.extend([
'watch', '--color', '--no-title',
'--interval', '1',
'cat', watch])
elif watch_cmd == 'tail':
cmd.extend(['tail', '-f', watch])
run_program(cmd)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

1219
scripts/wk.prev/functions/update.py
View file

File diff suppressed because it is too large Load diff

220
scripts/wk.prev/functions/windows_setup.py
View file

@ -1,220 +0,0 @@
# Wizard Kit: Functions - Windows Setup
from functions.data import *
from functions.disk import *
from settings.windows_setup import *
def find_windows_image(windows_version):
"""Search for a Windows source image file, returns dict.
Searches on local disks and then the WINDOWS_SERVER share."""
image = {}
imagefile = windows_version['Image File']
imagename = windows_version['Image Name']
# Search local source
set_thread_error_mode(silent=True) # Prevents "No disk" popups
for d in psutil.disk_partitions():
for ext in ['esd', 'wim', 'swm']:
path = '{}images\{}.{}'.format(d.mountpoint, imagefile, ext)
if os.path.isfile(path) and wim_contains_image(path, imagename):
image['Path'] = path
image['Letter'] = d.mountpoint[:1].upper()
image['Local'] = True
if ext == 'swm':
image['Glob'] = '--ref="{}*.swm"'.format(image['Path'][:-4])
break
set_thread_error_mode(silent=False) # Return to normal
# Check for network source
if not image:
mount_windows_share()
if WINDOWS_SERVER['Mounted']:
for ext in ['esd', 'wim', 'swm']:
path = r'\\{}\{}\images\{}.{}'.format(
WINDOWS_SERVER['IP'],
WINDOWS_SERVER['Share'],
imagefile,
ext)
if os.path.isfile(path) and wim_contains_image(path, imagename):
image['Path'] = path
image['Letter'] = None
image['Local'] = False
if ext == 'swm':
image['Glob'] = '--ref="{}*.swm"'.format(
image['Path'][:-4])
break
# Display image to be used (if any) and return
if image:
print_info('Using image: {}'.format(image['Path']))
return image
else:
print_error('Failed to find Windows source image for {}'.format(
windows_version['Name']))
raise GenericAbort
def format_disk(disk, use_gpt):
"""Format disk for use as a Windows OS disk."""
if use_gpt:
format_gpt(disk)
else:
format_mbr(disk)
def format_gpt(disk):
"""Format disk for use as a Windows OS disk using the GPT layout."""
script = [
# Partition table
'select disk {}'.format(disk['Number']),
'clean',
'convert gpt',
# System partition
# NOTE: ESP needs to be >= 260 for Advanced Format 4K disks
'create partition efi size=500',
'format quick fs=fat32 label="System"',
'assign letter="S"',
# Microsoft Reserved (MSR) partition
'create partition msr size=128',
# Windows partition
'create partition primary',
'format quick fs=ntfs label="Windows"',
'assign letter="W"',
# Recovery Tools partition
'shrink minimum=500',
'create partition primary',
'format quick fs=ntfs label="Recovery Tools"',
'assign letter="T"',
'set id="de94bba4-06d1-4d40-a16a-bfd50179d6ac"',
'gpt attributes=0x8000000000000001',
]
# Run
run_diskpart(script)
def format_mbr(disk):
"""Format disk for use as a Windows OS disk using the MBR layout."""
script = [
# Partition table
'select disk {}'.format(disk['Number']),
'clean',
# System partition
'create partition primary size=100',
'format fs=ntfs quick label="System Reserved"',
'active',
'assign letter="S"',
# Windows partition
'create partition primary',
'format fs=ntfs quick label="Windows"',
'assign letter="W"',
# Recovery Tools partition
'shrink minimum=500',
'create partition primary',
'format quick fs=ntfs label="Recovery"',
'assign letter="T"',
'set id=27',
]
# Run
run_diskpart(script)
def mount_windows_share():
"""Mount the Windows images share unless already mounted."""
if not WINDOWS_SERVER['Mounted']:
# Mounting read-write in case a backup was done in the same session
# and the server was left mounted read-write. This avoids throwing an
# error by trying to mount the same server with multiple credentials.
mount_network_share(WINDOWS_SERVER, read_write=True)
def select_windows_version():
"""Select Windows version from a menu, returns dict."""
actions = [
{'Name': 'Main Menu', 'Letter': 'M'},
]
# Menu loop
selection = menu_select(
title = 'Which version of Windows are we installing?',
main_entries = WINDOWS_VERSIONS,
action_entries = actions)
if selection.isnumeric():
return WINDOWS_VERSIONS[int(selection)-1]
elif selection == 'M':
raise GenericAbort
def setup_windows(windows_image, windows_version):
"""Apply a Windows image to W:"""
cmd = [
global_vars['Tools']['wimlib-imagex'],
'apply',
windows_image['Path'],
windows_version['Image Name'],
'W:\\']
if 'Glob' in windows_image:
cmd.extend(windows_image['Glob'])
run_program(cmd)
def setup_windows_re(windows_version, windows_letter='W', tools_letter='T'):
"""Setup the WinRE partition."""
win = r'{}:\Windows'.format(windows_letter)
winre = r'{}\System32\Recovery\WinRE.wim'.format(win)
dest = r'{}:\Recovery\WindowsRE'.format(tools_letter)
# Copy WinRE.wim
os.makedirs(dest, exist_ok=True)
shutil.copy(winre, r'{}\WinRE.wim'.format(dest))
# Set location
cmd = [
r'{}\System32\ReAgentc.exe'.format(win),
'/setreimage',
'/path', dest,
'/target', win]
run_program(cmd)
def update_boot_partition(system_letter='S', windows_letter='W', mode='ALL'):
"""Setup the Windows boot partition."""
cmd = [
r'{}\Windows\System32\bcdboot.exe'.format(
global_vars['Env']['SYSTEMDRIVE']),
r'{}:\Windows'.format(windows_letter),
'/s', '{}:'.format(system_letter),
'/f', mode]
run_program(cmd)
def wim_contains_image(filename, imagename):
"""Check if an ESD/WIM contains the specified image, returns bool."""
cmd = [
global_vars['Tools']['wimlib-imagex'],
'info',
filename,
imagename]
try:
run_program(cmd)
except subprocess.CalledProcessError:
return False
return True
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

149
scripts/wk.prev/functions/windows_updates.py
View file

@ -1,149 +0,0 @@
# Wizard Kit: Functions - Windows updates
import pathlib
from functions.common import *
# Functions
def delete_folder(folder_path):
"""Near-useless wrapper for shutil.rmtree."""
shutil.rmtree(folder_path)
def disable_service(service_name):
"""Set service startup to disabled."""
run_program(['sc', 'config', service_name, 'start=', 'disabled'])
# Verify service was disabled
start_type = get_service_start_type(service_name)
if not start_type.lower().startswith('disabled'):
raise GenericError('Failed to disable service {}'.format(service_name))
def disable_windows_updates():
"""Disable windows updates and clear SoftwareDistribution folder."""
indent=2
width=52
update_folders = [
r'{WINDIR}\SoftwareDistribution'.format(**global_vars['Env']),
r'{SYSTEMDRIVE}\$WINDOWS.~BT'.format(**global_vars['Env']),
]
for service in ('wuauserv', 'bits'):
# Stop service
result = try_and_print(
'Stopping service {}...'.format(service),
indent=indent, width=width,
function=stop_service, service_name=service)
if not result['CS']:
result = try_and_print(
'Stopping service {}...'.format(service),
indent=indent, width=width,
function=stop_service, service_name=service)
if not result['CS']:
raise GenericError('Service {} could not be stopped.'.format(service))
# Disable service
result = try_and_print(
'Disabling service {}...'.format(service),
indent=indent, width=width,
function=disable_service, service_name=service)
if not result['CS']:
result = try_and_print(
'Disabling service {}...'.format(service),
indent=indent, width=width,
function=disable_service, service_name=service)
if not result['CS']:
raise GenericError('Service {} could not be disabled.'.format(service))
# Delete update folders
for folder_path in update_folders:
if os.path.exists(folder_path):
result = try_and_print(
'Deleting folder {}...'.format(folder_path),
indent=indent, width=width,
function=delete_folder, folder_path=folder_path)
if not result['CS']:
try:
new_path = pathlib.path(folder_path).with_suffix('.bak')
os.rename(folder_path, new_path)
except OSError:
raise GenericError('Failed to remove folder {}'.format(folder_path))
def enable_service(service_name, start_type='auto'):
"""Enable service by setting start type."""
run_program(['sc', 'config', service_name, 'start=', start_type])
def enable_windows_updates(silent=False):
"""Enable windows updates"""
indent=2
width=52
for service in ('bits', 'wuauserv'):
# Enable service
start_type = 'auto'
if service == 'wuauserv':
start_type = 'demand'
if silent:
try:
enable_service(service, start_type=start_type)
except Exception:
# Try again
enable_service(service, start_type=start_type)
else:
result = try_and_print(
'Enabling service {}...'.format(service),
indent=indent, width=width,
function=enable_service, service_name=service, start_type=start_type)
if not result['CS']:
result = try_and_print(
'Enabling service {}...'.format(service),
indent=indent, width=width,
function=enable_service, service_name=service, start_type=start_type)
if not result['CS']:
raise GenericError('Service {} could not be enabled.'.format(service))
def get_service_status(service_name):
"""Get service status using psutil, returns str."""
status = 'Unknown'
try:
service = psutil.win_service_get(service_name)
status = service.status()
except psutil.NoSuchProcess:
# Ignore and return 'Unknown' below
pass
return status
def get_service_start_type(service_name):
"""Get service startup type using psutil, returns str."""
start_type = 'Unknown'
try:
service = psutil.win_service_get(service_name)
start_type = service.start_type()
except psutil.NoSuchProcess:
# Ignore and return 'Unknown' below
pass
return start_type
def stop_service(service_name):
"""Stop service."""
run_program(['net', 'stop', service_name], check=False)
# Verify service was stopped
status = get_service_status(service_name)
if not status.lower().startswith('stopped'):
raise GenericError('Failed to stop service {}'.format(service_name))
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

435
scripts/wk.prev/functions/winpe_menus.py
View file

@ -1,435 +0,0 @@
# Wizard Kit: WinPE Menus
from functions.backup import *
from functions.disk import *
from functions.windows_setup import *
from settings.winpe import *
def check_pe_tools():
"""Fix tool paths for WinPE layout."""
for k in PE_TOOLS.keys():
PE_TOOLS[k]['Path'] = r'{}\{}'.format(
global_vars['BinDir'], PE_TOOLS[k]['Path'])
global_vars['Tools']['wimlib-imagex'] = re.sub(
r'\\x(32|64)',
r'',
global_vars['Tools']['wimlib-imagex'],
re.IGNORECASE)
def menu_backup():
"""Take backup images of partition(s) in the WIM format."""
errors = False
other_results = {
'Error': {
'CalledProcessError': 'Unknown Error',
'PathNotFoundError': 'Missing',
},
'Warning': {
'GenericAbort': 'Skipped',
'GenericRepair': 'Repaired',
}}
set_title('{}: Backup Menu'.format(KIT_NAME_FULL))
# Set backup prefix
clear_screen()
print_standard('{}\n'.format(global_vars['Title']))
ticket_number = get_ticket_number()
if ENABLED_TICKET_NUMBERS:
backup_prefix = ticket_number
else:
backup_prefix = get_simple_string(prompt='Enter backup name prefix')
backup_prefix = backup_prefix.replace(' ', '_')
# Assign drive letters
try_and_print(
message = 'Assigning letters...',
function = assign_volume_letters,
other_results = other_results)
# Mount backup shares
mount_backup_shares(read_write=True)
# Select destination
destination = select_backup_destination(auto_select=False)
# Scan disks
result = try_and_print(
message = 'Getting disk info...',
function = scan_disks,
other_results = other_results)
if result['CS']:
disks = result['Out']
else:
print_error('ERROR: No disks found.')
raise GenericAbort
# Select disk to backup
disk = select_disk('For which disk are we creating backups?', disks)
if not disk:
raise GenericAbort
# "Prep" disk
prep_disk_for_backup(destination, disk, backup_prefix)
# Display details for backup task
clear_screen()
print_info('Create Backup - Details:\n')
if ENABLED_TICKET_NUMBERS:
show_data(message='Ticket:', data=ticket_number)
show_data(
message = 'Source:',
data = '[{}] ({}) {} {}'.format(
disk.get('Table', ''),
disk.get('Type', ''),
disk.get('Name', 'Unknown'),
disk.get('Size', ''),
),
)
show_data(
message = 'Destination:',
data = destination.get('Display Name', destination['Name']),
)
for par in disk['Partitions']:
message = 'Partition {}:'.format(par['Number'])
data = par['Display String']
if par['Number'] in disk['Bad Partitions']:
show_data(message=message, data=data, width=30, warning=True)
if 'Error' in par:
show_data(message='', data=par['Error'], error=True)
elif par['Image Exists']:
show_data(message=message, data=data, width=30, info=True)
else:
show_data(message=message, data=data, width=30)
print_standard(disk['Backup Warnings'])
# Ask to proceed
if (not ask('Proceed with backup?')):
raise GenericAbort
# Backup partition(s)
print_info('\n\nStarting task.\n')
for par in disk['Partitions']:
result = try_and_print(
message = 'Partition {} Backup...'.format(par['Number']),
function = backup_partition,
other_results = other_results,
disk = disk,
par = par)
if not result['CS'] and not isinstance(result['Error'], GenericAbort):
errors = True
par['Error'] = result['Error']
# Verify backup(s)
if disk['Valid Partitions']:
print_info('\n\nVerifying backup images(s)\n')
for par in disk['Partitions']:
if par['Number'] in disk['Bad Partitions']:
continue # Skip verification
result = try_and_print(
message = 'Partition {} Image...'.format(par['Number']),
function = verify_wim_backup,
other_results = other_results,
partition = par)
if not result['CS']:
errors = True
par['Error'] = result['Error']
# Print summary
if errors:
print_warning('\nErrors were encountered and are detailed below.')
for par in [p for p in disk['Partitions'] if 'Error' in p]:
print_standard(' Partition {} Error:'.format(par['Number']))
if hasattr(par['Error'], 'stderr'):
try:
par['Error'] = par['Error'].stderr.decode()
except:
# Deal with badly formatted error message
pass
try:
par['Error'] = par['Error'].splitlines()
par['Error'] = [line.strip() for line in par['Error']]
par['Error'] = [line for line in par['Error'] if line]
for line in par['Error']:
print_error('\t{}'.format(line))
except:
print_error('\t{}'.format(par['Error']))
else:
print_success('\nNo errors were encountered during imaging.')
if 'LogFile' in global_vars and ask('\nReview log?'):
cmd = [
global_vars['Tools']['NotepadPlusPlus'],
global_vars['LogFile']]
try:
popen_program(cmd)
except Exception:
print_error('ERROR: Failed to open log.')
sleep(30)
pause('\nPress Enter to return to main menu... ')
def menu_root():
"""Main WinPE menu."""
check_pe_tools()
menus = [
{'Name': 'Create Backups', 'Menu': menu_backup},
{'Name': 'Setup Windows', 'Menu': menu_setup},
{'Name': 'Misc Tools', 'Menu': menu_tools},
]
actions = [
{'Name': 'Command Prompt', 'Letter': 'C'},
{'Name': 'Reboot', 'Letter': 'R'},
{'Name': 'Shutdown', 'Letter': 'S'},
]
# Main loop
while True:
set_title(KIT_NAME_FULL)
selection = menu_select(
title = 'Main Menu',
main_entries = menus,
action_entries = actions,
secret_exit = True)
if (selection.isnumeric()):
try:
menus[int(selection)-1]['Menu']()
except GenericAbort:
print_warning('\nAborted\n')
pause('Press Enter to return to main menu... ')
elif (selection == 'C'):
run_program(['cmd', '-new_console:n'], check=False)
elif (selection == 'R'):
run_program(['wpeutil', 'reboot'])
elif (selection == 'S'):
run_program(['wpeutil', 'shutdown'])
else:
sys.exit()
def menu_setup():
"""Format a disk, apply a Windows image, and create boot files."""
errors = False
other_results = {
'Error': {
'CalledProcessError': 'Unknown Error',
'PathNotFoundError': 'Missing',
},
'Warning': {
'GenericAbort': 'Skipped',
'GenericRepair': 'Repaired',
}}
set_title('{}: Setup Menu'.format(KIT_NAME_FULL))
# Set ticket ID
clear_screen()
print_standard('{}\n'.format(global_vars['Title']))
ticket_number = get_ticket_number()
# Select the version of Windows to apply
windows_version = select_windows_version()
# Find Windows image
# NOTE: Reassign volume letters to ensure all devices are scanned
try_and_print(
message = 'Assigning volume letters...',
function = assign_volume_letters,
other_results = other_results)
windows_image = find_windows_image(windows_version)
# Scan disks
result = try_and_print(
message = 'Getting disk info...',
function = scan_disks,
other_results = other_results)
if result['CS']:
disks = result['Out']
else:
print_error('ERROR: No disks found.')
raise GenericAbort
# Select disk to use as the OS disk
dest_disk = select_disk('To which disk are we installing Windows?', disks)
if not dest_disk:
raise GenericAbort
# "Prep" disk
prep_disk_for_formatting(dest_disk)
# Display details for setup task
clear_screen()
print_info('Setup Windows - Details:\n')
if ENABLED_TICKET_NUMBERS:
show_data(message='Ticket:', data=ticket_number)
show_data(message='Installing:', data=windows_version['Name'])
show_data(
message = 'Boot Method:',
data = 'UEFI (GPT)' if dest_disk['Use GPT'] else 'Legacy (MBR)')
show_data(message='Using Image:', data=windows_image['Path'])
show_data(
message = 'ERASING:',
data = '[{}] ({}) {} {}\n'.format(
dest_disk.get('Table', ''),
dest_disk.get('Type', ''),
dest_disk.get('Name', 'Unknown'),
dest_disk.get('Size', ''),
),
warning = True)
for par in dest_disk['Partitions']:
show_data(
message = 'Partition {}:'.format(par['Number']),
data = par['Display String'],
warning = True)
print_warning(dest_disk['Format Warnings'])
if (not ask('Is this correct?')):
raise GenericAbort
# Safety check
print_standard('\nSAFETY CHECK')
print_warning('All data will be DELETED from the '
'disk and partition(s) listed above.')
print_warning('This is irreversible and will lead '
'to {CLEAR}{RED}DATA LOSS.'.format(**COLORS))
if (not ask('Asking again to confirm, is this correct?')):
raise GenericAbort
# Remove volume letters so S, T, & W can be used below
try_and_print(
message = 'Removing volume letters...',
function = remove_volume_letters,
other_results = other_results,
keep=windows_image['Letter'])
# Assign new letter for local source if necessary
if windows_image['Local'] and windows_image['Letter'] in ['S', 'T', 'W']:
new_letter = try_and_print(
message = 'Reassigning source volume letter...',
function = reassign_volume_letter,
other_results = other_results,
letter=windows_image['Letter'])
windows_image['Path'] = '{}{}'.format(
new_letter, windows_image['Path'][1:])
windows_image['Letter'] = new_letter
# Format and partition disk
result = try_and_print(
message = 'Formatting disk...',
function = format_disk,
other_results = other_results,
disk = dest_disk,
use_gpt = dest_disk['Use GPT'])
if not result['CS']:
# We need to crash as the disk is in an unknown state
print_error('ERROR: Failed to format disk.')
raise GenericAbort
# Apply Image
result = try_and_print(
message = 'Applying image...',
function = setup_windows,
other_results = other_results,
windows_image = windows_image,
windows_version = windows_version)
if not result['CS']:
# We need to crash as the disk is in an unknown state
print_error('ERROR: Failed to apply image.')
raise GenericAbort
# Create Boot files
try_and_print(
message = 'Updating boot files...',
function = update_boot_partition,
other_results = other_results)
# Setup WinRE
try_and_print(
message = 'Updating recovery tools...',
function = setup_windows_re,
other_results = other_results,
windows_version = windows_version)
# Copy WinPE log(s)
source = r'{}\Logs'.format(global_vars['ClientDir'])
dest = r'W:\{}\Logs\WinPE'.format(KIT_NAME_SHORT)
shutil.copytree(source, dest)
# Print summary
print_standard('\nDone.')
if 'LogFile' in global_vars and ask('\nReview log?'):
cmd = [
global_vars['Tools']['NotepadPlusPlus'],
global_vars['LogFile']]
try:
popen_program(cmd)
except Exception:
print_error('ERROR: Failed to open log.')
sleep(30)
pause('\nPress Enter to return to main menu... ')
def menu_tools():
"""Tool launcher menu."""
tools = [{'Name': k} for k in sorted(PE_TOOLS.keys())]
actions = [{'Name': 'Main Menu', 'Letter': 'M'},]
set_title(KIT_NAME_FULL)
# Menu loop
while True:
selection = menu_select(
title = 'Tools Menu',
main_entries = tools,
action_entries = actions)
if (selection.isnumeric()):
name = tools[int(selection)-1]['Name']
cmd = [PE_TOOLS[name]['Path']] + PE_TOOLS[name].get('Args', [])
if name == 'Blue Screen View':
# Select path to scan
minidump_path = select_minidump_path()
if minidump_path:
cmd.extend(['/MiniDumpFolder', minidump_path])
try:
popen_program(cmd)
except Exception:
print_error('Failed to run {}'.format(name))
sleep(2)
pause()
elif (selection == 'M'):
break
def select_minidump_path():
"""Select BSOD minidump path from a menu."""
dumps = []
# Assign volume letters first
assign_volume_letters()
# Search for minidumps
set_thread_error_mode(silent=True) # Prevents "No disk" popups
for d in psutil.disk_partitions():
if global_vars['Env']['SYSTEMDRIVE'].upper() in d.mountpoint:
# Skip RAMDisk
continue
if os.path.exists(r'{}Windows\MiniDump'.format(d.mountpoint)):
dumps.append({'Name': r'{}Windows\MiniDump'.format(d.mountpoint)})
set_thread_error_mode(silent=False) # Return to normal
# Check results before showing menu
if len(dumps) == 0:
print_error('ERROR: No BSoD / MiniDump paths found')
sleep(2)
return None
# Menu
selection = menu_select(
title = 'Which BSoD / MiniDump path are we scanning?',
main_entries = dumps)
return dumps[int(selection) - 1]['Name']
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

99
scripts/wk.prev/settings/browsers.py
View file

@ -1,99 +0,0 @@
# Wizard Kit: Settings - Browsers
import os
import re
# General
DEFAULT_HOMEPAGE = 'https://www.google.com/'
IE_GALLERY = 'https://www.microsoft.com/en-us/iegallery'
MOZILLA_PREFS = {
'browser.search.defaultenginename': '"Google"',
'browser.search.defaultenginename.US': '"Google"',
'browser.search.geoSpecificDefaults': 'false',
'browser.startup.homepage': '"{}"'.format(DEFAULT_HOMEPAGE),
'extensions.ui.lastCategory': '"addons://list/extension"',
}
SUPPORTED_BROWSERS = {
'Internet Explorer': {
'base': 'ie',
'exe_name': 'iexplore.exe',
'rel_install_path': 'Internet Explorer',
'user_data_path': r'{USERPROFILE}\Favorites',
},
'Google Chrome': {
'base': 'chromium',
'exe_name': 'chrome.exe',
'rel_install_path': r'Google\Chrome\Application',
'user_data_path': r'{LOCALAPPDATA}\Google\Chrome\User Data',
},
'Google Chrome Canary': {
'base': 'chromium',
'exe_name': 'chrome.exe',
'rel_install_path': r'Google\Chrome SxS\Application',
'user_data_path': r'{LOCALAPPDATA}\Google\Chrome SxS\User Data',
},
'Mozilla Firefox': {
'base': 'mozilla',
'exe_name': 'firefox.exe',
'rel_install_path': 'Mozilla Firefox',
'user_data_path': r'{APPDATA}\Mozilla\Firefox\Profiles',
},
'Mozilla Firefox Dev': {
'base': 'mozilla',
'exe_name': 'firefox.exe',
'rel_install_path': 'Firefox Developer Edition',
'user_data_path': r'{APPDATA}\Mozilla\Firefox\Profiles',
},
'Opera': {
'base': 'chromium',
'exe_name': 'launcher.exe',
'rel_install_path': 'Opera',
'user_data_path': r'{APPDATA}\Opera Software\Opera Stable',
},
'Opera Beta': {
'base': 'chromium',
'exe_name': 'launcher.exe',
'rel_install_path': 'Opera beta',
'user_data_path': r'{APPDATA}\Opera Software\Opera Next',
},
'Opera Dev': {
'base': 'chromium',
'exe_name': 'launcher.exe',
'rel_install_path': 'Opera developer',
'user_data_path': r'{APPDATA}\Opera Software\Opera Developer',
},
}
# Regex
REGEX_BACKUP = re.compile(
r'\.\w*bak.*',
re.IGNORECASE)
REGEX_CHROMIUM_PROFILE = re.compile(
r'^(Default|Profile)',
re.IGNORECASE)
REGEX_CHROMIUM_ITEMS = re.compile(
r'^(Bookmarks|Cookies|Favicons|Google Profile'
r'|History|Login Data|Top Sites|TransportSecurity'
r'|Visited Links|Web Data)',
re.IGNORECASE)
REGEX_MOZILLA = re.compile(
r'^(bookmarkbackups|(cookies|formhistory|places).sqlite'
r'|key3.db|logins.json|persdict.dat)$',
re.IGNORECASE)
# uBlock Origin
UBO_CHROME = 'https://chrome.google.com/webstore/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm?hl=en'
UBO_CHROME_REG = r'Software\Wow6432Node\Google\Chrome\Extensions\cjpalhdlnbpafiamejdnhcphjbkeiagm'
UBO_EXTRA_CHROME = 'https://chrome.google.com/webstore/detail/ublock-origin-extra/pgdnlhfefecpicbbihgmbmffkjpaplco?hl=en'
UBO_EXTRA_CHROME_REG = r'Software\Wow6432Node\Google\Chrome\Extensions\pgdnlhfefecpicbbihgmbmffkjpaplco'
UBO_MOZILLA = 'https://addons.mozilla.org/en-us/firefox/addon/ublock-origin/'
UBO_MOZZILA_PATH = r'{}\Mozilla Firefox\distribution\extensions\ublock_origin.xpi'.format(os.environ.get('PROGRAMFILES'))
UBO_MOZILLA_REG = r'Software\Mozilla\Firefox\Extensions'
UBO_MOZILLA_REG_NAME = 'uBlock0@raymondhill.net'
UBO_OPERA = 'https://addons.opera.com/en/extensions/details/ublock/?display=en'
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2 tw=0

67
scripts/wk.prev/settings/cleanup.py
View file

@ -1,67 +0,0 @@
'''Wizard Kit: Settings - Cleanup'''
# vim: sts=2 sw=2 ts=2
import os
import re
try:
# pylint: disable=import-error
import winreg
HKU = winreg.HKEY_USERS
HKCR = winreg.HKEY_CLASSES_ROOT
HKCU = winreg.HKEY_CURRENT_USER
HKLM = winreg.HKEY_LOCAL_MACHINE
except ModuleNotFoundError:
if os.name == 'nt':
raise
# d7II
D7_HKCR_CLEANUP = {
r'batfile\shell\!!RunWithParms': {'Recurse': True},
r'batfile\shell\{0001B4FD-9EA3-4D90-A79E-FD14BA3AB01D}': {'Recurse': True},
r'cmdfile\shell\!!RunWithParms': {'Recurse': True},
r'cmdfile\shell\{0001B4FD-9EA3-4D90-A79E-FD14BA3AB01D}': {'Recurse': True},
r'exefile\shell\!!RunWithParms': {'Recurse': True},
r'exefile\shell\ResourceHacker': {'Recurse': True},
r'regfile\shell\!!RunWithParms': {'Recurse': True},
r'regfile\shell\{0001B4FD-9EA3-4D90-A79E-FD14BA3AB01D}': {'Recurse': True},
}
D7_HKCU_CLEANUP = {
r'Software\Malwarebytes': {'Recurse': False},
}
D7_HKLM_CLEANUP = {
r'Software\Emsisoft': {'Recurse': False},
}
# Regex
DESKTOP_ITEMS = re.compile(
r'^(JRT|RKill|sc-cleaner|Transfer_Log)',
re.IGNORECASE,
)
# Registry
UAC_DEFAULTS_WIN7 = {
r'Software\Microsoft\Windows\CurrentVersion\Policies\System': {
'DWORD Items': {
'ConsentPromptBehaviorAdmin': 5,
'EnableLUA': 1,
'PromptOnSecureDesktop': 1,
},
},
}
UAC_DEFAULTS_WIN10 = {
r'Software\Microsoft\Windows\CurrentVersion\Policies\System': {
'DWORD Items': {
'ConsentPromptBehaviorAdmin': 5,
'ConsentPromptBehaviorUser': 3,
'EnableInstallerDetection': 1,
'EnableLUA': 1,
'EnableVirtualization': 1,
'PromptOnSecureDesktop': 1,
},
},
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")

105
scripts/wk.prev/settings/data.py
View file

@ -1,105 +0,0 @@
# Wizard Kit: Settings - Data
import ctypes
import re
from settings.main import *
# FastCopy
FAST_COPY_EXCLUDES = [
r'\*.esd',
r'\*.swm',
r'\*.wim',
r'\*.dd',
r'\*.dd.tgz',
r'\*.dd.txz',
r'\*.map',
r'\*.dmg',
r'\*.image',
r'$RECYCLE.BIN',
r'$Recycle.Bin',
r'.AppleDB',
r'.AppleDesktop',
r'.AppleDouble',
r'.com.apple.timemachine.supported',
r'.dbfseventsd',
r'.DocumentRevisions-V100*',
r'.DS_Store',
r'.fseventsd',
r'.PKInstallSandboxManager',
r'.Spotlight*',
r'.SymAV*',
r'.symSchedScanLockxz',
r'.TemporaryItems',
r'.Trash*',
r'.vol',
r'.VolumeIcon.icns',
r'desktop.ini',
r'Desktop?DB',
r'Desktop?DF',
r'hiberfil.sys',
r'lost+found',
r'Network?Trash?Folder',
r'pagefile.sys',
r'Recycled',
r'RECYCLER',
r'System?Volume?Information',
r'Temporary?Items',
r'Thumbs.db',
]
FAST_COPY_ARGS = [
'/cmd=noexist_only',
'/utf8',
'/skip_empty_dir',
'/linkdest',
'/no_ui',
'/auto_close',
'/exclude={}'.format(';'.join(FAST_COPY_EXCLUDES)),
]
# Regex
REGEX_EXCL_ITEMS = re.compile(
r'^(\.(AppleDB|AppleDesktop|AppleDouble'
r'|com\.apple\.timemachine\.supported|dbfseventsd'
r'|DocumentRevisions-V100.*|DS_Store|fseventsd|PKInstallSandboxManager'
r'|Spotlight.*|SymAV.*|symSchedScanLockxz|TemporaryItems|Trash.*'
r'|vol|VolumeIcon\.icns)|desktop\.(ini|.*DB|.*DF)'
r'|(hiberfil|pagefile)\.sys|lost\+found|Network\.*Trash\.*Folder'
r'|Recycle[dr]|System\.*Volume\.*Information|Temporary\.*Items'
r'|Thumbs\.db)$',
re.IGNORECASE)
REGEX_EXCL_ROOT_ITEMS = re.compile(
r'^(boot(mgr|nxt)$|Config.msi'
r'|(eula|globdata|install|vc_?red)'
r'|.*.sys$|System Volume Information|RECYCLER?|\$Recycle\.bin'
r'|\$?Win(dows(.old.*|\. BT|)$|RE_)|\$GetCurrent|Windows10Upgrade'
r'|PerfLogs|Program Files|SYSTEM.SAV'
r'|.*\.(esd|swm|wim|dd|map|dmg|image)$)',
re.IGNORECASE)
REGEX_INCL_ROOT_ITEMS = re.compile(
r'^(AdwCleaner|(My\s*|)(Doc(uments?( and Settings|)|s?)|Downloads'
r'|Media|Music|Pic(ture|)s?|Vid(eo|)s?)'
r'|{prefix}(-?Info|-?Transfer|)'
r'|(ProgramData|Recovery|Temp.*|Users)$'
r'|.*\.(log|txt|rtf|qb\w*|avi|m4a|m4v|mp4|mkv|jpg|png|tiff?)$)'
r''.format(prefix=KIT_NAME_SHORT),
re.IGNORECASE)
REGEX_WIM_FILE = re.compile(
r'\.wim$',
re.IGNORECASE)
REGEX_WINDOWS_OLD = re.compile(
r'^Win(dows|)\.old',
re.IGNORECASE)
# Thread error modes
## Code borrowed from: https://stackoverflow.com/a/29075319
SEM_NORMAL = ctypes.c_uint()
SEM_FAILCRITICALERRORS = 1
SEM_NOOPENFILEERRORBOX = 0x8000
SEM_FAIL = SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

61
scripts/wk.prev/settings/ddrescue.py
View file

@ -1,61 +0,0 @@
# Wizard Kit: Settings - ddrescue-tui
import re
from collections import OrderedDict
# General
MAP_DIR = '/Backups/Anaconda'
RECOMMENDED_FSTYPES = ['ext3', 'ext4', 'xfs']
RECOMMENDED_MAP_FSTYPES = ['cifs', 'ext2', 'ext3', 'ext4', 'vfat', 'xfs']
USAGE = """ {script_name} clone [source [destination]]
{script_name} image [source [destination]]
(e.g. {script_name} clone /dev/sda /dev/sdb)
"""
# Layout
SIDE_PANE_WIDTH = 21
TMUX_LAYOUT = OrderedDict({
'Source': {'y': 2, 'Check': True},
'Started': {'x': SIDE_PANE_WIDTH, 'Check': True},
'Progress': {'x': SIDE_PANE_WIDTH, 'Check': True},
})
# ddrescue
AUTO_PASS_1_THRESHOLD = 95
AUTO_PASS_2_THRESHOLD = 98
DDRESCUE_SETTINGS = {
'--binary-prefixes': {'Enabled': True, 'Hidden': True, },
'--data-preview': {'Enabled': True, 'Value': '5', 'Hidden': True, },
'--idirect': {'Enabled': True, },
'--odirect': {'Enabled': True, },
'--max-read-rate': {'Enabled': False, 'Value': '1MiB', },
'--min-read-rate': {'Enabled': True, 'Value': '64KiB', },
'--reopen-on-error': {'Enabled': True, },
'--retry-passes': {'Enabled': True, 'Value': '0', },
'--test-mode': {'Enabled': False, 'Value': 'test.map', },
'--timeout': {'Enabled': True, 'Value': '5m', },
'-vvvv': {'Enabled': True, 'Hidden': True, },
}
ETOC_REFRESH_RATE = 30 # in seconds
REGEX_DDRESCUE_LOG = re.compile(
r'^\s*(?P<key>\S+):\s+'
r'(?P<size>\d+)\s+'
r'(?P<unit>[PTGMKB])i?B?',
re.IGNORECASE,
)
REGEX_REMAINING_TIME = re.compile(
r'remaining time:'
r'\s*((?P<days>\d+)d)?'
r'\s*((?P<hours>\d+)h)?'
r'\s*((?P<minutes>\d+)m)?'
r'\s*((?P<seconds>\d+)s)?'
r'\s*(?P<na>n/a)?',
re.IGNORECASE
)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

114
scripts/wk.prev/settings/hw_diags.py
View file

@ -1,114 +0,0 @@
# Wizard Kit: Settings - HW Diagnostics
from collections import OrderedDict
# General
DEBUG_MODE = True
OVERRIDES_FORCED = False
OVERRIDES_LIMITED = True # If True this disables OVERRIDE_FORCED
STATUSES = {
'RED': ['Denied', 'ERROR', 'FAIL', 'TimedOut'],
'YELLOW': ['Aborted', 'N/A', 'OVERRIDE', 'Unknown', 'Working'],
'GREEN': ['PASS'],
}
TESTS_CPU = ['Prime95']
TESTS_DISK = [
'I/O Benchmark',
'NVMe / SMART',
'badblocks',
]
# Layout
## NOTE: Colors will be applied in functions/hw_diags.py
QUICK_LABEL = '{YELLOW}(Quick){CLEAR}'
SIDE_PANE_WIDTH = 20
TOP_PANE_TEXT = '{GREEN}Hardware Diagnostics{CLEAR}'
TMUX_LAYOUT = OrderedDict({
'Top': {'y': 2, 'Check': True},
'Started': {'x': SIDE_PANE_WIDTH, 'Check': True},
'Progress': {'x': SIDE_PANE_WIDTH, 'Check': True},
# Testing panes
'Prime95': {'y': 11, 'Check': False},
'Temps': {'y': 1000, 'Check': False},
'SMART': {'y': 3, 'Check': True},
'badblocks': {'y': 5, 'Check': True},
'I/O Benchmark': {'y': 1000, 'Check': False},
})
# Tests: badblocks
## NOTE: Force 4K read block size for disks >= to 3TB
BADBLOCKS_LARGE_DISK = 3*1024**4
# Tests: I/O Benchmark
IO_VARS = {
'Block Size': 512*1024,
'Chunk Size': 32*1024**2,
'Minimum Test Size': 10*1024**3,
'Alt Test Size Factor': 0.01,
'Progress Refresh Rate': 5,
'Scale 8': [2**(0.56*(x+1))+(16*(x+1)) for x in range(8)],
'Scale 16': [2**(0.56*(x+1))+(16*(x+1)) for x in range(16)],
'Scale 32': [2**(0.56*(x+1)/2)+(16*(x+1)/2) for x in range(32)],
'Threshold Graph Fail': 65*1024**2,
'Threshold Graph Warn': 135*1024**2,
'Threshold Graph Great': 750*1024**2,
'Threshold HDD Min': 50*1024**2,
'Threshold HDD High Avg': 75*1024**2,
'Threshold HDD Low Avg': 65*1024**2,
'Threshold SSD Min': 90*1024**2,
'Threshold SSD High Avg': 135*1024**2,
'Threshold SSD Low Avg': 100*1024**2,
'Graph Horizontal': ('▁', '▂', '▃', '▄', '▅', '▆', '▇', '█'),
'Graph Horizontal Width': 40,
'Graph Vertical': (
'▏', '▎', '▍', '▌',
'▋', '▊', '▉', '█',
'█▏', '█▎', '█▍', '█▌',
'█▋', '█▊', '█▉', '██',
'██▏', '██▎', '██▍', '██▌',
'██▋', '██▊', '██▉', '███',
'███▏', '███▎', '███▍', '███▌',
'███▋', '███▊', '███▉', '████'),
}
# Tests: NVMe/SMART
ATTRIBUTES = {
'NVMe': {
'critical_warning': {'Critical': True, 'Ignore': False, 'Warning': None, 'Error': 1, 'Maximum': None, },
'media_errors': {'Critical': False, 'Ignore': False, 'Warning': None, 'Error': 1, 'Maximum': None, },
'power_on_hours': {'Critical': False, 'Ignore': True, 'Warning': 17532, 'Error': 26298, 'Maximum': 122724,},
'unsafe_shutdowns': {'Critical': False, 'Ignore': True, 'Warning': 1, 'Error': None, 'Maximum': None, },
},
'SMART': {
5: {'Hex': '05', 'Critical': True, 'Ignore': False, 'Warning': None, 'Error': 1, 'Maximum': None, },
9: {'Hex': '09', 'Critical': False, 'Ignore': True, 'Warning': 17532, 'Error': 26298, 'Maximum': 122724,},
10: {'Hex': '10', 'Critical': False, 'Ignore': False, 'Warning': 1, 'Error': 10, 'Maximum': 10000, },
184: {'Hex': 'B8', 'Critical': False, 'Ignore': False, 'Warning': 1, 'Error': 10, 'Maximum': 10000, },
187: {'Hex': 'BB', 'Critical': False, 'Ignore': False, 'Warning': 1, 'Error': 10, 'Maximum': 10000, },
188: {'Hex': 'BC', 'Critical': False, 'Ignore': True, 'Warning': 1, 'Error': 10, 'Maximum': 10000, },
196: {'Hex': 'C4', 'Critical': False, 'Ignore': False, 'Warning': 1, 'Error': 10, 'Maximum': 10000, },
197: {'Hex': 'C5', 'Critical': True, 'Ignore': False, 'Warning': None, 'Error': 1, 'Maximum': None, },
198: {'Hex': 'C6', 'Critical': True, 'Ignore': False, 'Warning': None, 'Error': 1, 'Maximum': None, },
199: {'Hex': 'C7', 'Critical': False, 'Ignore': True, 'Warning': None, 'Error': 1, 'Maximum': None, },
201: {'Hex': 'C9', 'Critical': False, 'Ignore': False, 'Warning': None, 'Error': 1, 'Maximum': 10000, },
},
}
ATTRIBUTE_COLORS = (
# NOTE: The order here is important; least important to most important.
('Warning', 'YELLOW'),
('Error', 'RED'),
('Maximum', 'PURPLE'),
)
KEY_NVME = 'nvme_smart_health_information_log'
KEY_SMART = 'ata_smart_attributes'
# Tests: Prime95
MPRIME_LIMIT = 7 # of minutes to run Prime95
THERMAL_FAIL = 90 # Fail temperature in Celsius
THERMAL_LIMIT = 99 # Abort temperature in Celsius
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2 tw=0

58
scripts/wk.prev/settings/info.py
View file

@ -1,58 +0,0 @@
# Wizard Kit: Settings - Information
import re
# General
REG_PROFILE_LIST = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList'
REG_SHELL_FOLDERS = r'Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders'
TMP_HIVE_PATH = 'TEMP_HIVE_MOUNT'
EXTRA_FOLDERS = [
'Dropbox',
'Google Drive',
'OneDrive',
'SkyDrive',
]
SHELL_FOLDERS = {
#GUIDs from: https://msdn.microsoft.com/en-us/library/windows/desktop/dd378457(v=vs.85).aspx
'Desktop': (
'{B4BFCC3A-DB2C-424C-B029-7FE99A87C641}',
),
'Documents': (
'Personal',
'{FDD39AD0-238F-46AF-ADB4-6C85480369C7}',
),
'Downloads': (
'{374DE290-123F-4565-9164-39C4925E467B}',
),
'Favorites': (
'{1777F761-68AD-4D8A-87BD-30B759FA33DD}',
),
'Music': (
'My Music',
'{4BD8D571-6D19-48D3-BE97-422220080E43}',
),
'Pictures': (
'My Pictures',
'{33E28130-4E1E-4676-835A-98395C3BC3BB}',
),
'Videos': (
'My Video',
'{18989B1D-99B5-455B-841C-AB7C74E4DDFC}',
),
}
# Regex
REGEX_OFFICE = re.compile(
r'(Microsoft (Office\s+'
r'(365|Enterprise|Home|Pro(\s|fessional)'
r'|Single|Small|Standard|Starter|Ultimate|system)'
r'|Works[-\s\d]+\d)'
r'|(Libre|Open|Star)\s*Office'
r'|WordPerfect|Gnumeric|Abiword)',
re.IGNORECASE)
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

765
scripts/wk.prev/settings/launchers.py
View file

@ -1,765 +0,0 @@
'''Wizard Kit: Settings - Launchers'''
# pylint: disable=line-too-long
# vim: sts=2 sw=2 ts=2
LAUNCHERS = {
r'(Root)': {
'd7II': {
'L_TYPE': 'Executable',
'L_PATH': 'd7II',
'L_ITEM': 'd7II.exe',
'Extra Code': [
r'rem Pre-d7II safety checks',
r'rem NOTE: This is an ugly hack but it works',
r'',
r':Init2',
r'echo Running safety checks...',
r'set ARCH=32',
r'if /i "%PROCESSOR_ARCHITECTURE%" == "AMD64" set "ARCH=64"',
r'set "AV_REMOVER=%bin%\AVRemover\AVRemover.exe"',
r'set "PYTHON=%bin%\Python\x32\python.exe"',
r'if %ARCH% equ 64 (',
r' set "AV_REMOVER=%bin%\AVRemover\AVRemover64.exe"',
r' set "PYTHON=%bin%\Python\x64\python.exe"',
r')',
r'',
r':PythonChecks',
r'if not exist "%PYTHON%" goto ErrorPythonNotFound',
r'"%PYTHON%" --version >nul || goto ErrorPythonUnsupported',
r'echo Python: OK',
r'',
r':AVCheck',
r'rem Run ESETs AV Removal tool for tech to review',
r'echo Please check for running AV',
r'start "" /wait "%AV_REMOVER%"',
r'echo.',
r'echo Press Enter to Launch d7II...',
r'pause>nul',
r'echo.'
r'echo Starting d7II...'
r'goto DefineLaunch',
r'',
r':: Pre-d7II Errors',
r':ErrorPythonNotFound',
r'rem Broken Kit',
r'echo.',
r'echo ERROR: The Python executable is missing.',
r'echo This kit is damaged and needs to be rebuilt',
r'goto Abort',
r'',
r':ErrorPythonUnsupported',
r'rem The Windows installation lacks Windows update KB2999226 needed to run Python',
r'echo.',
r'echo ERROR: Failed to run Python, try installing Windows update KB2999226.',
r'echo NOTE: That update is from October 2015 so this system is SEVERELY outdated',
r'if exist "%bin%\..\Installers\Extras\Windows Updates" (',
r' start "" "explorer.exe" "%bin%\..\Installers\Extras\Windows Updates"',
r')',
r'goto Abort',
],
},
'System Setup': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'system_setup.py',
'L_ELEV': 'True',
},
},
r'.bin\Scripts\launchers_for_d7': {
'Browser Reset': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'reset_browsers.py',
'L_ARGS': 'd7mode',
},
'System Diagnostics': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'system_diagnostics.py',
'L_ARGS': 'd7mode',
'L_ELEV': 'True',
},
'Disable Windows Updates': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'windows_updates.py',
'L_ARGS': 'd7mode --disable',
'L_ELEV': 'True',
},
'Enable Windows Updates': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'windows_updates.py',
'L_ARGS': 'd7mode --enable',
'L_ELEV': 'True',
},
},
r'Data Recovery': {
'PhotoRec (CLI)': {
'L_TYPE': 'Executable',
'L_PATH': 'TestDisk',
'L_ITEM': 'photorec_win.exe',
'L_ELEV': 'True',
'L__CLI': 'True',
},
'PhotoRec': {
'L_TYPE': 'Executable',
'L_PATH': 'TestDisk',
'L_ITEM': 'qphotorec_win.exe',
'L_ELEV': 'True',
},
'TestDisk': {
'L_TYPE': 'Executable',
'L_PATH': 'TestDisk',
'L_ITEM': 'testdisk_win.exe',
'L_ELEV': 'True',
'L__CLI': 'True',
},
},
r'Data Transfers': {
# pylint: disable=bad-continuation
"Fab's Autobackup Pro": {
'L_TYPE': 'Executable',
'L_PATH': 'AutoBackupPro',
'L_ITEM': 'autobackup6pro.exe',
},
'FastCopy (as ADMIN)': {
'L_TYPE': 'Executable',
'L_PATH': 'FastCopy',
'L_ITEM': 'FastCopy.exe',
'L_ARGS': (
r' /logfile=%log_dir%\Tools\FastCopy.log'
r' /cmd=noexist_only'
r' /utf8'
r' /skip_empty_dir'
r' /linkdest'
r' /exclude='
r'$RECYCLE.BIN;'
r'$Recycle.Bin;'
r'.AppleDB;'
r'.AppleDesktop;'
r'.AppleDouble;'
r'.com.apple.timemachine.supported;'
r'.dbfseventsd;'
r'.DocumentRevisions-V100*;'
r'.DS_Store;'
r'.fseventsd;'
r'.PKInstallSandboxManager;'
r'.Spotlight*;'
r'.SymAV*;'
r'.symSchedScanLockxz;'
r'.TemporaryItems;'
r'.Trash*;'
r'.vol;'
r'.VolumeIcon.icns;'
r'desktop.ini;'
r'Desktop?DB;'
r'Desktop?DF;'
r'hiberfil.sys;'
r'lost+found;'
r'Network?Trash?Folder;'
r'pagefile.sys;'
r'Recycled;'
r'RECYCLER;'
r'System?Volume?Information;'
r'Temporary?Items;'
r'Thumbs.db'
r' /to=%client_dir%\Transfer_%iso_date%\ '
),
'L_ELEV': 'True',
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Logs /Transfer',
],
},
'FastCopy': {
'L_TYPE': 'Executable',
'L_PATH': 'FastCopy',
'L_ITEM': 'FastCopy.exe',
'L_ARGS': (
r' /logfile=%log_dir%\Tools\FastCopy.log'
r' /cmd=noexist_only'
r' /utf8'
r' /skip_empty_dir'
r' /linkdest'
r' /exclude='
r'$RECYCLE.BIN;'
r'$Recycle.Bin;'
r'.AppleDB;'
r'.AppleDesktop;'
r'.AppleDouble;'
r'.com.apple.timemachine.supported;'
r'.dbfseventsd;'
r'.DocumentRevisions-V100*;'
r'.DS_Store;'
r'.fseventsd;'
r'.PKInstallSandboxManager;'
r'.Spotlight*;'
r'.SymAV*;'
r'.symSchedScanLockxz;'
r'.TemporaryItems;'
r'.Trash*;'
r'.vol;'
r'.VolumeIcon.icns;'
r'desktop.ini;'
r'Desktop?DB;'
r'Desktop?DF;'
r'hiberfil.sys;'
r'lost+found;'
r'Network?Trash?Folder;'
r'pagefile.sys;'
r'Recycled;'
r'RECYCLER;'
r'System?Volume?Information;'
r'Temporary?Items;'
r'Thumbs.db'
r' /to=%client_dir%\Transfer_%iso_date%\ '
),
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Logs /Transfer',
],
},
'Find User Wallpapers': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'find_user_wallpapers.py',
},
'KVRT': {
'L_TYPE': 'Executable',
'L_PATH': 'KVRT',
'L_ITEM': 'KVRT.exe',
'L_ARGS': (
r' -accepteula'
r' -d %q_dir%'
r' -processlevel 3'
r' -dontcryptsupportinfo'
r' -fixednames'
),
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Quarantine',
r'set "q_dir=%client_dir%\Quarantine\KVRT"',
r'mkdir "%q_dir%">nul 2>&1',
],
},
'Mac & Linux Reader': {
'L_TYPE': 'Executable',
'L_PATH': 'LinuxReader',
'L_ITEM': 'LinuxReader.exe',
'L_ELEV': 'True',
},
'Transferred Keys': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'transferred_keys.py',
'L_ELEV': 'True',
},
'User Data Transfer': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'user_data_transfer.py',
'L_ELEV': 'True',
},
'XYplorer (as ADMIN)': {
'L_TYPE': 'Executable',
'L_PATH': 'XYplorerFree',
'L_ITEM': 'XYplorerFree.exe',
'L_ARGS': r'/exp /win=max %userprofile%',
'L_ELEV': 'True',
},
'XYplorer': {
'L_TYPE': 'Executable',
'L_PATH': 'XYplorerFree',
'L_ITEM': 'XYplorerFree.exe',
'L_ARGS': r'/exp /win=max %userprofile%',
},
},
r'Diagnostics': {
'AIDA64': {
'L_TYPE': 'Executable',
'L_PATH': 'AIDA64',
'L_ITEM': 'aida64.exe',
},
'ProduKey': {
'L_TYPE': 'Executable',
'L_PATH': 'ProduKey',
'L_ITEM': 'ProduKey.exe',
'L_ELEV': 'True',
'Extra Code': [
r'if exist "%bin%\ProduKey" (',
r' del "%bin%\ProduKey\ProduKey.cfg" 2>nul',
r' del "%bin%\ProduKey\ProduKey64.cfg" 2>nul',
r')',
],
},
'System Diagnostics': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'system_diagnostics.py',
'L_ELEV': 'True',
},
},
r'Diagnostics\Extras': {
'Autoruns (with VirusTotal Scan)': {
'L_TYPE': 'Executable',
'L_PATH': 'Autoruns',
'L_ITEM': 'Autoruns.exe',
'L_ARGS': '-e',
'Extra Code': [
r'reg add HKCU\Software\Sysinternals\AutoRuns /v checkvirustotal /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownomicrosoft /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownowindows /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v showonlyvirustotal /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v submitvirustotal /t REG_DWORD /d 0 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v verifysignatures /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns\SigCheck /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns\Streams /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns\VirusTotal /v VirusTotalTermsAccepted /t REG_DWORD /d 1 /f >nul',
],
},
'BleachBit': {
'L_TYPE': 'Executable',
'L_PATH': 'BleachBit',
'L_ITEM': 'bleachbit.exe',
},
'BlueScreenView': {
'L_TYPE': 'Executable',
'L_PATH': 'BlueScreenView',
'L_ITEM': 'BlueScreenView.exe',
},
'ERUNT': {
'L_TYPE': 'Executable',
'L_PATH': 'erunt',
'L_ITEM': 'ERUNT.EXE',
'L_ARGS': r'%client_dir%\Backups\Registry\%iso_date% sysreg curuser otherusers',
'L_ELEV': 'True',
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Logs',
],
},
'FurMark': {
'L_TYPE': 'Executable',
'L_PATH': 'FurMark',
'L_ITEM': 'FurMark.exe',
},
'HDTune Pro': {
'L_TYPE': 'Executable',
'L_PATH': 'HDTunePro',
'L_ITEM': 'HDTunePro.exe',
},
'HitmanPro': {
'L_TYPE': 'Executable',
'L_PATH': 'HitmanPro',
'L_ITEM': 'HitmanPro.exe',
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Logs',
],
},
'HWiNFO': {
'L_TYPE': 'Executable',
'L_PATH': 'HWiNFO',
'L_ITEM': 'HWiNFO.exe',
'Extra Code': [
r'for %%a in (32 64) do (',
r' copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SensorsOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r')',
],
},
'HWiNFO (Sensors)': {
'L_TYPE': 'Executable',
'L_PATH': 'HWiNFO',
'L_ITEM': 'HWiNFO.exe',
'Extra Code': [
r'for %%a in (32 64) do (',
r' copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SensorsOnly=1)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r')',
],
},
},
r'Drivers': {
'Intel RST (Current Release)': {
'L_TYPE': 'Executable',
'L_PATH': r'_Drivers\Intel RST',
'L_ITEM': 'SetupRST_17.2.exe',
'L_7ZIP': 'SetupRST_17.2.exe',
},
'Intel RST (Previous Releases)': {
'L_TYPE': 'Folder',
'L_PATH': r'_Drivers\Intel RST',
'L_ITEM': '.',
'L_NCMD': 'True',
},
'Intel SSD Toolbox': {
'L_TYPE': 'Executable',
'L_PATH': r'_Drivers\Intel SSD Toolbox',
'L_ITEM': 'Intel SSD Toolbox.exe',
},
'Samsing Magician': {
'L_TYPE': 'Executable',
'L_PATH': r'_Drivers\Samsung Magician',
'L_ITEM': 'Samsung Magician.exe',
},
'Snappy Driver Installer Origin': {
'L_TYPE': 'Executable',
'L_PATH': r'_Drivers\SDIO',
'L_ITEM': 'SDIO.exe',
},
},
r'Drivers\Extras': {
'Acer': {
'L_TYPE': 'Executable',
'L_PATH': 'HWiNFO',
'L_ITEM': 'HWiNFO.exe',
'Extra Code': [
r'for %%a in (32 64) do (',
r' copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SensorsOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r')',
r'start "" "http://us.acer.com/ac/en/US/content/drivers"',
],
},
'Lenovo': {
'L_TYPE': 'Executable',
'L_PATH': 'HWiNFO',
'L_ITEM': 'HWiNFO.exe',
'Extra Code': [
r'for %%a in (32 64) do (',
r' copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SensorsOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r')',
r'start "" "https://pcsupport.lenovo.com/us/en/"',
],
},
'Toshiba': {
'L_TYPE': 'Executable',
'L_PATH': 'HWiNFO',
'L_ITEM': 'HWiNFO.exe',
'Extra Code': [
r'for %%a in (32 64) do (',
r' copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SensorsOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r')',
r'start "" "http://support.toshiba.com/drivers"',
],
},
},
r'Installers': {
'ESET NOD32 AV': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'install_eset_nod32_av.py',
'L_ELEV': 'True',
},
'SW Bundle': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'install_sw_bundle.py',
'L_ELEV': 'True',
},
},
r'Installers\Extras\Office\2016': {
'Home and Business (x32)': {
'L_TYPE': 'Office',
'L_PATH': '2016',
'L_ITEM': '2016_hb_32.xml',
'L_NCMD': 'True',
},
'Home and Business (x64)': {
'L_TYPE': 'Office',
'L_PATH': '2016',
'L_ITEM': '2016_hb_64.xml',
'L_NCMD': 'True',
},
'Home and Student (x32)': {
'L_TYPE': 'Office',
'L_PATH': '2016',
'L_ITEM': '2016_hs_32.xml',
'L_NCMD': 'True',
},
'Home and Student (x64)': {
'L_TYPE': 'Office',
'L_PATH': '2016',
'L_ITEM': '2016_hs_64.xml',
'L_NCMD': 'True',
},
},
r'Installers\Extras\Office\2019': {
'Home and Business (x32)': {
'L_TYPE': 'Office',
'L_PATH': '2019',
'L_ITEM': '2019_hb_32.xml',
'L_NCMD': 'True',
},
'Home and Business (x64)': {
'L_TYPE': 'Office',
'L_PATH': '2019',
'L_ITEM': '2019_hb_64.xml',
'L_NCMD': 'True',
},
'Home and Student (x32)': {
'L_TYPE': 'Office',
'L_PATH': '2019',
'L_ITEM': '2019_hs_32.xml',
'L_NCMD': 'True',
},
'Home and Student (x64)': {
'L_TYPE': 'Office',
'L_PATH': '2019',
'L_ITEM': '2019_hs_64.xml',
'L_NCMD': 'True',
},
'Office 365 (x32)': {
'L_TYPE': 'Office',
'L_PATH': '2019',
'L_ITEM': '365_32.xml',
'L_NCMD': 'True',
},
'Office 365 (x64)': {
'L_TYPE': 'Office',
'L_PATH': '2019',
'L_ITEM': '365_64.xml',
'L_NCMD': 'True',
},
},
r'Installers\Extras\Runtimes': {
'Visual C++ Runtimes': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'install_vcredists.py',
'L_ELEV': 'True',
},
},
r'Misc': {
'Activate Windows': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'activate.py',
'L_ELEV': 'True',
},
'Cleanup CBS Temp Files': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'cbs_fix.py',
'L_ELEV': 'True',
},
'ConEmu (as ADMIN)': {
'L_TYPE': 'Executable',
'L_PATH': 'ConEmu',
'L_ITEM': 'ConEmu.exe',
'L_ELEV': 'True',
},
'ConEmu': {
'L_TYPE': 'Executable',
'L_PATH': 'ConEmu',
'L_ITEM': 'ConEmu.exe',
},
'Disable Windows Updates': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'windows_updates.py',
'L_ARGS': '--disable',
'L_ELEV': 'True',
},
'Enable Windows Updates': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'windows_updates.py',
'L_ARGS': '--enable',
'L_ELEV': 'True',
},
'Enter SafeMode': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'safemode_enter.py',
'L_ELEV': 'True',
},
'Everything': {
'L_TYPE': 'Executable',
'L_PATH': 'Everything',
'L_ITEM': 'Everything.exe',
'L_ARGS': '-nodb',
'L_ELEV': 'True',
},
'Exit SafeMode': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'safemode_exit.py',
'L_ELEV': 'True',
},
'Network Stability Test': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'network_stability_test.py',
},
'Notepad++': {
'L_TYPE': 'Executable',
'L_PATH': 'notepadplusplus',
'L_ITEM': 'notepadplusplus.exe',
},
'PuTTY': {
'L_TYPE': 'Executable',
'L_PATH': 'PuTTY',
'L_ITEM': 'PUTTY.EXE',
},
'ShutUp10': {
'L_TYPE': 'Executable',
'L_PATH': 'ShutUp10',
'L_ITEM': 'OOSU10.exe',
},
'ShutUp10 (1201 Minimal Selection)': {
'L_TYPE': 'Executable',
'L_PATH': 'ShutUp10',
'L_ITEM': 'OOSU10.exe',
'L_ARGS': '1201.cfg',
},
'WizTree': {
'L_TYPE': 'Executable',
'L_PATH': 'WizTree',
'L_ITEM': 'WizTree.exe',
'L_ELEV': 'True',
},
'XMPlay': {
'L_TYPE': 'Executable',
'L_PATH': 'XMPlay',
'L_ITEM': 'xmplay.exe',
'L_ARGS': r'"%bin%\XMPlay\music.7z"',
},
},
r'Repairs': {
'AdwCleaner': {
'L_TYPE': 'Executable',
'L_PATH': 'AdwCleaner',
'L_ITEM': 'AdwCleaner.exe',
},
'Autoruns': {
'L_TYPE': 'Executable',
'L_PATH': 'Autoruns',
'L_ITEM': 'Autoruns.exe',
'L_ARGS': '-e',
'Extra Code': [
r'reg add HKCU\Software\Sysinternals\AutoRuns /v checkvirustotal /t REG_DWORD /d 0 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownomicrosoft /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownowindows /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v showonlyvirustotal /t REG_DWORD /d 0 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v submitvirustotal /t REG_DWORD /d 0 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v verifysignatures /t REG_DWORD /d 0 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns\SigCheck /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns\Streams /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns\VirusTotal /v VirusTotalTermsAccepted /t REG_DWORD /d 1 /f >nul',
],
},
'CHKDSK': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'check_disk.py',
'L_ELEV': 'True',
},
'DISM': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'dism.py',
'L_ELEV': 'True',
},
'ESET Online Scanner': {
'L_TYPE': 'Executable',
'L_PATH': 'ESET',
'L_ITEM': 'ESET.exe',
},
'KVRT': {
'L_TYPE': 'Executable',
'L_PATH': 'KVRT',
'L_ITEM': 'KVRT.exe',
'L_ARGS': (
r' -accepteula'
r' -d %q_dir%'
r' -processlevel 3'
r' -dontcryptsupportinfo'
r' -fixednames'
),
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Quarantine',
r'set "q_dir=%client_dir%\Quarantine\KVRT"',
r'mkdir "%q_dir%">nul 2>&1',
],
},
'RKill': {
'L_TYPE': 'Executable',
'L_PATH': 'RKill',
'L_ITEM': 'RKill.exe',
'L_ARGS': r'-s -l %log_dir%\Tools\RKill.log',
'L_ELEV': 'True',
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Logs',
],
},
'SFC Scan': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'sfc_scan.py',
'L_ELEV': 'True',
},
'TDSSKiller': {
'L_TYPE': 'Executable',
'L_PATH': 'TDSSKiller',
'L_ITEM': 'TDSSKiller.exe',
'L_ARGS': (
r' -l %log_dir%\Tools\TDSSKiller.log'
r' -qpath %q_dir%'
r' -accepteula'
r' -accepteulaksn'
r' -dcexact'
r' -tdlfs'
),
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Quarantine',
r'set "q_dir=%client_dir%\Quarantine\TDSSKiller"',
r'mkdir "%q_dir%">nul 2>&1',
],
},
'WinAIO Repair': {
'L_TYPE': 'Executable',
'L_PATH': 'WinAIORepair',
'L_ITEM': 'Repair_Windows.exe',
'L_ELEV': 'True',
'Extra Code': [
r'copy /y "%bin%\WinAIORepair\__empty.ini" "%bin%\WinAIORepair\settings.ini"',
],
},
'WinAIO Repair (Fix Associations)': {
'L_TYPE': 'Executable',
'L_PATH': 'WinAIORepair',
'L_ITEM': 'Repair_Windows.exe',
'L_ELEV': 'True',
'Extra Code': [
r'copy /y "%bin%\WinAIORepair\__associations.ini" "%bin%\WinAIORepair\settings.ini"',
],
},
'WinAIO Repair (Fix Permissions)': {
'L_TYPE': 'Executable',
'L_PATH': 'WinAIORepair',
'L_ITEM': 'Repair_Windows.exe',
'L_ELEV': 'True',
'Extra Code': [
r'copy /y "%bin%\WinAIORepair\__permissions.ini" "%bin%\WinAIORepair\settings.ini"',
],
},
},
r'Uninstallers': {
'IObit Uninstaller': {
'L_TYPE': 'Executable',
'L_PATH': 'IObitUninstallerPortable',
'L_ITEM': 'IObitUninstallerPortable.exe',
},
},
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")

102
scripts/wk.prev/settings/main.py
View file

@ -1,102 +0,0 @@
# Wizard Kit: Settings - Main / Branding
# Features
ENABLED_OPEN_LOGS = False
ENABLED_TICKET_NUMBERS = False
ENABLED_UPLOAD_DATA = True
# STATIC VARIABLES (also used by BASH and BATCH files)
## NOTE: There are no spaces around the = for easier parsing in BASH and BATCH
# Main Kit
ARCHIVE_PASSWORD='Sorted1201'
KIT_NAME_FULL='1201-WizardKit'
KIT_NAME_SHORT='1201'
SUPPORT_MESSAGE='Please let support know by opening an issue on Gogs'
# imgur
IMGUR_CLIENT_ID='3d1ee1d38707b85'
# Live Linux
ROOT_PASSWORD='1201 loves computers!'
TECH_PASSWORD='Sorted1201'
# Root Certificate Authority
ROOT_CA_NAME='1201_Root_CA.crt'
# Server IP addresses
OFFICE_SERVER_IP='10.120.1.15'
QUICKBOOKS_SERVER_IP='10.120.1.15'
# Time Zones
LINUX_TIME_ZONE='America/Los_Angeles' # See 'timedatectl list-timezones' for valid values
WINDOWS_TIME_ZONE='Pacific Standard Time' # See 'tzutil /l' for valid values
# SERVER VARIABLES
## NOTE: Windows can only use one user per server. This means that if
## one server serves multiple shares then you have to use the same
## user/password for all of those shares.
BACKUP_SERVERS = [
{ 'IP': '10.120.1.15',
'Name': 'Anaconda',
'Mounted': False,
'Share': 'Backups',
'User': 'cx',
'Pass': 'cx',
'RW-User': 'backup',
'RW-Pass': '1201 loves computers!',
},
# DISABLED due to issues handling mounting a subdir
#{ 'IP': '10.120.1.23',
# 'Name': 'Server1201',
# 'Mounted': False,
# 'Share': r'Public\TEMP',
# 'User': 'cx',
# 'Pass': '',
# 'RW-User': 'it',
# 'RW-Pass': 'sorted',
#},
]
BENCHMARK_SERVER = {
'Name': 'Nextcloud',
'Short Url': 'https://nextcloud.1201.com/index.php/f/108024',
'Url': 'https://1201.ddns.net:8001/public.php/webdav/Benchmarks',
'User': 'QAx28ZgmPwCwGHc',
'Pass': '',
}
CRASH_SERVER = {
'Name': 'Nextcloud',
'Url': 'https://1201.ddns.net:8001/public.php/webdav/Issues',
'User': 'n9Ds76WizNyBw8Y',
'Pass': '',
}
OFFICE_SERVER = {
'IP': OFFICE_SERVER_IP,
'Name': 'Anaconda',
'Mounted': False,
'Share': r'Public\Office\MS Office',
'User': 'cx',
'Pass': 'cx',
'RW-User': 'backup',
'RW-Pass': '1201 loves computers!',
}
QUICKBOOKS_SERVER = {
'IP': QUICKBOOKS_SERVER_IP,
'Name': 'Anaconda',
'Mounted': False,
'Share': r'Public\QuickBooks',
'User': 'cx',
'Pass': 'cx',
'RW-User': 'backup',
'RW-Pass': '1201 loves computers!',
}
WINDOWS_SERVER = {
'IP': '10.120.1.15',
'Name': 'Anaconda',
'Mounted': False,
'Share': r'HH-Proliant\Windows',
'User': 'cx',
'Pass': 'cx',
'RW-User': 'backup',
'RW-Pass': '1201 loves computers!',
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

73
scripts/wk.prev/settings/music.py
View file

@ -1,73 +0,0 @@
# Wizard Kit: Settings - Music
MUSIC_MOD = [
'104208#banana_boat.mod',
'114971#tilbury_fair.mod',
'132563#ufo_tune.mod',
'135906#magnetik_girl.xm',
'140628#autumn_in_budapest.xm',
'143198#summer_memories_3.xm',
'144405#hillbilly_billyboy.xm',
'154795#4mat_-_eternity.xm',
'155845#bookworm.mo3',
'155914#battleofsteel.xm',
'158975#1_channel_moog.it',
'165495#trans.s3m',
'168513#necros_-_introspection.s3m',
'169628#radix_-_feng_shui_schematics.xm',
'175238#unknown48_-_twilight.mod',
'33432#ambrozia.xm',
'33460#amigatre.mod',
'34594#CHARIOT.S3M',
'34596#BUTTERFL.XM',
'34654#CTGOBLIN.S3M',
'35151#bananasplit.mod',
'35280#DEADLOCK.XM',
'38591#compo_liam.xm',
'39987#crystald.s3m',
'40475#ELYSIUM.MOD',
'42146#enigma.mod',
'42519#GHOST2.MOD',
'42560#GSLINGER.MOD',
'42872#existing.xm',
'50427#nf-stven.xm',
'51549#overture.mod',
'54250#SATELL.S3M',
'54313#realmk.s3m',
'55789#scrambld.mod',
'57934#spacedeb.mod',
'59344#stardstm.mod',
'60395#2ND_PM.S3M',
'66187#external.xm',
'66343#beek-substitutionology.it',
'67561#radix-unreal_superhero.xm',
'70829#inside_out.s3m',
'83779#beyond_music.mod',
]
MUSIC_SNES = [
'actr',
'crock',
'ct',
'dkc',
'dkq',
'ff6',
'fz',
'loz3',
'mmx',
'ptws',
'scv4',
'sf',
'sf2',
'sgng',
'smk',
'smw',
'yi',
'zamn'
]
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

326
scripts/wk.prev/settings/partition_uids.py
View file

@ -1,326 +0,0 @@
# Wizard Kit: Settings - Partition UIDs
# sources: https://en.wikipedia.org/wiki/GUID_Partition_Table
# https://en.wikipedia.org/wiki/Partition_type
# NOTE: Info has been trimmed for brevity. As such, there may be some inaccuracy.
PARTITION_UIDS = {
'00': {'OS': 'All','Description': 'Empty partition entry'},
'01': {'OS': 'DOS','Description': 'FAT12 as primary partition'},
'02': {'OS': 'XENIX','Description': 'XENIX root'},
'03': {'OS': 'XENIX','Description': 'XENIX usr'},
'04': {'OS': 'DOS','Description': 'FAT16 with less than 32 MB'},
'05': {'OS': 'DOS / SpeedStor','Description': 'Extended partition'},
'06': {'OS': 'DOS1+','Description': 'FAT16B [over 65K sectors]'},
'07': {'OS': 'Windows / OS/2 / QNX 2','Description': 'NTFS/exFAT/HPFS/IFS/QNX'},
'08': {'OS': 'CBM / DOS / OS/2 / AIX /QNX','Description': 'FAT12-16/AIX/QNY/SplitDrive'},
'09': {'OS': 'AIX / QNX / Coherent / OS-9','Description': 'AIX/QNZ/Coherent/RBF'},
'0A': {'OS': 'OS/2 / Coherent','Description': 'Boot Manager / Swap'},
'0B': {'OS': 'DOS','Description': 'FAT32 with CHS addressing'},
'0C': {'OS': 'DOS','Description': 'FAT32 with LBA'},
'0D': {'OS': 'Silicon Safe','Description': 'Reserved'},
'0E': {'OS': 'DOS','Description': 'FAT16B with LBA'},
'0F': {'OS': 'DOS','Description': 'Extended partition with LBA'},
'10': {'OS': 'OPUS','Description': 'Unknown'},
'11': {'OS': 'Leading Edge MS-DOS / OS/2','Description': 'FAT12/FAT16'},
'12': {'OS': 'Compaq Contura','Description': 'conf/diag/hiber/rescue/serv'},
'14': {'OS': 'AST DOS / OS/2 / MaverickOS','Description': 'FAT12/FAT16/Omega'},
'15': {'OS': 'OS/2 / Maverick OS','Description': 'Hidden extended / Swap'},
'16': {'OS': 'OS/2 Boot Manager','Description': 'Hidden FAT16B'},
'17': {'OS': 'OS/2 Boot Manager','Description': 'Hidden IFS/HPFS/NTFS/exFAT'},
'18': {'OS': 'AST Windows','Description': '0-Volt Suspend/SmartSleep'},
'19': {'OS': 'Willowtech Photon coS','Description': 'Willowtech Photon coS'},
'1B': {'OS': 'OS/2 Boot Manager','Description': 'Hidden FAT32'},
'1C': {'OS': 'OS/2 Boot Manager','Description': 'Hidden FAT32 with LBA'},
'1E': {'OS': 'OS/2 Boot Manager','Description': 'Hidden FAT16 with LBA'},
'1F': {'OS': 'OS/2 Boot Manager','Description': 'Hidden extended with LBA'},
'20': {'OS': 'Windows Mobile','Description': 'update XIP/Willowsoft OFS1'},
'21': {'OS': 'Oxygen','Description': 'SpeedStor / FSo2'},
'22': {'OS': 'Oxygen','Description': 'Oxygen Extended Partition'},
'23': {'OS': 'Windows Mobile','Description': 'Reserved / boot XIP'},
'24': {'OS': 'NEC MS-DOS0','Description': 'Logical FAT12 or FAT16'},
'25': {'OS': 'Windows Mobile','Description': 'IMGFS[citation needed]'},
'26': {'OS': 'Microsoft, IBM','Description': 'Reserved'},
'27': {'OS': 'Win/PQserv/MirOS/RooterBOOT','Description': 'WinRE/Rescue/MirOS/RooterBOOT'},
'2A': {'OS': 'AtheOS','Description': 'AthFS/AFS/Reserved'},
'2B': {'OS': 'SyllableOS','Description': 'SyllableSecure (SylStor)'},
'31': {'OS': 'Microsoft, IBM','Description': 'Reserved'},
'32': {'OS': 'NOS','Description': 'Unknown'},
'33': {'OS': 'Microsoft, IBM','Description': 'Reserved'},
'34': {'OS': 'Microsoft, IBM','Description': 'Reserved'},
'35': {'OS': 'OS/2 Server /eComStation','Description': 'JFS'},
'36': {'OS': 'Microsoft, IBM','Description': 'Reserved'},
'38': {'OS': 'THEOS','Description': 'THEOS version 3.2, 2 GB'},
'39': {'OS': 'Plan 9 / THEOS','Description': 'Plan 9 edition 3 / THEOS v4'},
'3A': {'OS': 'THEOS','Description': 'THEOS v4, 4 GB'},
'3B': {'OS': 'THEOS','Description': 'THEOS v4 extended'},
'3C': {'OS': 'PartitionMagic','Description': 'PqRP (image in progress)'},
'3D': {'OS': 'PartitionMagic','Description': 'Hidden NetWare'},
'3F': {'OS': 'OS/32','Description': 'Unknown'},
'40': {'OS': 'PICK / Venix','Description': 'PICK R83 / Venix 80286'},
'41': {'OS': 'RISC / Linux / PowerPC','Description': 'Boot / Old Linux/Minix'},
'42': {'OS': 'SFS / Linux / Win2K/XP/etc','Description': 'SFS / Old Linux Swap'},
'43': {'OS': 'Linux','Description': 'Old Linux native'},
'44': {'OS': 'GoBack','Description': 'Norton/WildFire/Adaptec/Roxio'},
'45': {'OS': 'Boot-US / EUMEL/ELAN','Description': 'Priam/Boot/EUMEL/ELAN (L2)'},
'46': {'OS': 'EUMEL/ELAN','Description': 'EUMEL/ELAN (L2)'},
'47': {'OS': 'EUMEL/ELAN','Description': 'EUMEL/ELAN (L2)'},
'48': {'OS': 'EUMEL/ELAN','Description': 'EUMEL/ELAN (L2), ERGOS L3'},
'4A': {'OS': 'AdaOS / ALFS/THIN','Description': 'Aquila / ALFS/THIN'},
'4C': {'OS': 'ETH Oberon','Description': 'Aos (A2) file system (76)'},
'4D': {'OS': 'QNX Neutrino','Description': 'Primary QNX POSIX volume'},
'4E': {'OS': 'QNX Neutrino','Description': 'Secondary QNX POSIX volume'},
'4F': {'OS': 'QNX Neutrino / ETH Oberon','Description': '3rd QNX POSIX/Boot/Native'},
'50': {'OS': 'DiskMan4/ETH/LynxOS/Novell','Description': 'Alt FS/Read-only/Lynx RTOS'},
'51': {'OS': 'Disk Manager 4-6','Description': 'R/W partition (Aux 1)'},
'52': {'OS': 'CP/M-80/ System V/AT, V/386','Description': 'CP/M-80'},
'53': {'OS': 'Disk Manager 6','Description': 'Auxiliary 3 (WO)'},
'54': {'OS': 'Disk Manager 6','Description': 'Dynamic Drive Overlay (DDO)'},
'55': {'OS': 'EZ-Drive','Description': 'Maxtor/MaxBlast/DriveGuide'},
'56': {'OS': 'AT&T DOS/EZ-Drive/VFeature','Description': 'FAT12 16/EZ-BIOS/VFeature'},
'57': {'OS': 'DrivePro','Description': 'VNDI partition'},
'5C': {'OS': 'EDISK','Description': 'Priam EDisk Volume'},
'61': {'OS': 'SpeedStor','Description': 'Unknown'},
'63': {'OS': 'Unix','Description': 'Unix,ISC,SysV,ix,BSD,HURD'},
'64': {'OS': 'SpeedStor / NetWare','Description': 'NetWare FS 286/2,PC-ARMOUR'},
'65': {'OS': 'NetWare','Description': 'NetWare File System 386'},
'66': {'OS': 'NetWare / NetWare','Description': 'NetWare FS 386 / SMS'},
'67': {'OS': 'NetWare','Description': 'Wolf Mountain'},
'68': {'OS': 'NetWare','Description': 'Unknown'},
'69': {'OS': 'NetWare 5 / NetWare','Description': 'Novell Storage Services'},
'6E': {'Description': 'Unknown'},
'70': {'OS': 'DiskSecure','Description': 'DiskSecure multiboot'},
'71': {'OS': 'Microsoft, IBM','Description': 'Reserved'},
'72': {'OS': 'APTI systems / Unix V7/x86','Description': 'APTI altFAT12 / V7 / x86'},
'73': {'OS': 'Microsoft, IBM','Description': 'Reserved'},
'74': {'OS': 'Microsoft, IBM','Description': 'Reserved / Scramdisk'},
'75': {'OS': 'PC/IX','Description': 'Unknown'},
'76': {'OS': 'Microsoft, IBM','Description': 'Reserved'},
'77': {'OS': 'Novell','Description': 'VNDI, M2FS, M2CS'},
'78': {'OS': 'Geurt Vos','Description': 'XOSL bootloader file system'},
'79': {'OS': 'APTI conformant systems','Description': 'APTI altFAT16 (CHS, SFN)'},
'7A': {'OS': 'APTI conformant systems','Description': 'APTI altFAT16 (LBA, SFN)'},
'7B': {'OS': 'APTI conformant systems','Description': 'APTI altFAT16B (CHS, SFN)'},
'7C': {'OS': 'APTI conformant systems','Description': 'APTI altFAT32 (LBA, SFN)'},
'7D': {'OS': 'APTI conformant systems','Description': 'APTI altFAT32 (CHS, SFN)'},
'7E': {'OS': 'F.I.X. (claim) / PrimoCache','Description': 'Level 2 cache'},
'7F': {'OS': 'Varies','Description': 'AltOS DevPartition Standard'},
'80': {'OS': 'Minix 1.1-1.4a','Description': 'Minix file system (old)'},
'81': {'OS': 'Minix 1.4b+ / Linux','Description': 'MINIX FS/Mitac AdvDiskManager'},
'82': {'OS': 'Linux / Sun Microsystems','Description': 'Swap / Solaris x86 / Prime'},
'83': {'OS': 'GNU/Linux','Description': 'Any native Linux FS'},
'84': {'OS': 'OS/2 / Windows 7','Description': 'Hibernat/HiddenC/RapidStart'},
'85': {'OS': 'GNU/Linux','Description': 'Linux extended'},
'86': {'OS': 'Windows NT 4 Server / Linux','Description': 'FAT16B mirror/LinuxRAID-old'},
'87': {'OS': 'Windows NT 4 Server','Description': 'HPFS/NTFS mirrored volume'},
'88': {'OS': 'GNU/Linux','Description': 'Plaintext partition table'},
'8A': {'OS': 'AiR-BOOT','Description': 'Linux kernel image'},
'8B': {'OS': 'Windows NT 4 Server','Description': 'FAT32 mirrored volume set'},
'8C': {'OS': 'Windows NT 4 Server','Description': 'FAT32 mirrored volume set'},
'8D': {'OS': 'Free FDISK','Description': 'Hidden FAT12'},
'8E': {'OS': 'Linux','Description': 'Linux LVM'},
'90': {'OS': 'Free FDISK','Description': 'Hidden FAT16'},
'91': {'OS': 'Free FDISK','Description': 'Hidden extended partition'},
'92': {'OS': 'Free FDISK','Description': 'Hidden FAT16B'},
'93': {'OS': 'Amoeba / Linux','Description': 'Amoeba native/Hidden Linux'},
'94': {'OS': 'Amoeba','Description': 'Amoeba bad block table'},
'95': {'OS': 'EXOPC','Description': 'EXOPC native'},
'96': {'OS': 'CHRP','Description': 'ISO-9660 file system'},
'97': {'OS': 'Free FDISK','Description': 'Hidden FAT32'},
'98': {'OS': 'Free FDISK / ROM-DOS','Description': 'Hidden FAT32 / service part'},
'99': {'OS': 'early Unix','Description': 'Unknown'},
'9A': {'OS': 'Free FDISK','Description': 'Hidden FAT16'},
'9B': {'OS': 'Free FDISK','Description': 'Hidden extended partition'},
'9E': {'OS': 'VSTA / ForthOS','Description': 'ForthOS (eForth port)'},
'9F': {'OS': 'BSD/OS 3.0+, BSDI','Description': 'Unknown'},
'A0': {'OS': 'HP/Phoenix/IBM/Toshiba/Sony','Description': 'Diagnostic for HP/Hibernate'},
'A1': {'OS': 'HP / Phoenix, NEC','Description': 'HP Vol Expansion/Hibernate'},
'A2': {'OS': 'Cyclone V','Description': 'Hard Processor System (HPS)'},
'A3': {'OS': 'HP','Description': 'HP Vol Expansion(SpeedStor)'},
'A4': {'OS': 'HP','Description': 'HP Vol Expansion(SpeedStor)'},
'A5': {'OS': 'BSD','Description': 'BSD slice'},
'A6': {'OS': 'OpenBSD','Description': 'HP Vol Expansion/BSD slice'},
'A7': {'OS': 'NeXT','Description': 'NeXTSTEP'},
'A8': {'OS': 'Darwin, Mac OS X','Description': 'Apple Darwin, Mac OS X UFS'},
'A9': {'OS': 'NetBSD','Description': 'NetBSD slice'},
'AA': {'OS': 'MS-DOS','Description': 'Olivetti DOS FAT12(1.44 MB)'},
'AB': {'OS': 'Darwin, Mac OS X / GO! OS','Description': 'Apple Darwin/OS X boot/GO!'},
'AD': {'OS': 'RISC OS','Description': 'ADFS / FileCore format'},
'AE': {'OS': 'ShagOS','Description': 'ShagOS file system'},
'AF': {'OS': 'ShagOS','Description': 'OS X HFS & HFS+/ShagOS Swap'},
'B0': {'OS': 'Boot-Star','Description': 'Boot-Star dummy partition'},
'B1': {'OS': 'QNX 6.x','Description': 'HPVolExpansion/QNX Neutrino'},
'B2': {'OS': 'QNX 6.x','Description': 'QNX Neutrino power-safe FS'},
'B3': {'OS': 'QNX 6.x','Description': 'HPVolExpansion/QNX Neutrino'},
'B4': {'OS': 'HP','Description': 'HP Vol Expansion(SpeedStor)'},
'B6': {'OS': 'Windows NT 4 Server','Description': 'HPVolExpansion/FAT16Bmirror'},
'B7': {'OS': 'BSDI / Windows NT 4 Server','Description': 'BSDI,Swap,HPFS/NTFS mirror'},
'B8': {'OS': 'BSDI (before 3.0)','Description': 'BSDI Swap / native FS'},
'BB': {'OS': 'Acronis/BootWizard/WinNT 4','Description': 'BootWizard/OEM/FAT32 mirror'},
'BC': {'OS': 'Acronis/WinNT/BackupCapsule','Description': 'FAT32RAID/SecureZone/Backup'},
'BD': {'OS': 'BonnyDOS/286','Description': 'Unknown'},
'BE': {'OS': 'Solaris 8','Description': 'Solaris 8 boot'},
'BF': {'OS': 'Solaris','Description': 'Solaris x86'},
'C0': {'OS': 'DR-DOS,MultiuserDOS,REAL/32','Description': 'Secured FAT (under 32 MB)'},
'C1': {'OS': 'DR DOS','Description': 'Secured FAT12'},
'C2': {'OS': 'Power Boot','Description': 'Hidden Linux native FS'},
'C3': {'OS': 'Power Boot','Description': 'Hidden Linux Swap'},
'C4': {'OS': 'DR DOS','Description': 'Secured FAT16'},
'C5': {'OS': 'DR DOS','Description': 'Secured extended partition'},
'C6': {'OS': 'DR DOS / WinNT 4 Server','Description': 'Secured FAT16B/FAT16Bmirror'},
'C7': {'OS': 'Syrinx / WinNT 4 Server','Description': 'Syrinx boot/HPFS/NTFSmirror'},
'C8': {'Description': "DR-DOS Reserved (since '97)"},
'C9': {'Description': "DR-DOS Reserved (since '97)"},
'CA': {'Description': "DR-DOS Reserved (since '97)"},
'CB': {'OS': 'DR-DOSx / WinNT 4 Server','Description': 'Secured FAT32/FAT32 mirror'},
'CC': {'OS': 'DR-DOSx / WinNT 4 Server','Description': 'Secured FAT32/FAT32 mirror'},
'CD': {'OS': 'CTOS','Description': 'Memory dump'},
'CE': {'OS': 'DR-DOSx','Description': 'Secured FAT16B'},
'CF': {'OS': 'DR-DOSx','Description': 'Secured extended partition'},
'D0': {'OS': 'Multiuser DOS, REAL/32','Description': 'Secured FAT (over 32 MB)'},
'D1': {'OS': 'Multiuser DOS','Description': 'Secured FAT12'},
'D4': {'OS': 'Multiuser DOS','Description': 'Secured FAT16'},
'D5': {'OS': 'Multiuser DOS','Description': 'Secured extended partition'},
'D6': {'OS': 'Multiuser DOS','Description': 'Secured FAT16B'},
'D8': {'OS': 'Digital Research','Description': 'CP/M-86 [citation needed]'},
'DA': {'OS': 'Powercopy Backup','Description': 'Non-FS data / Shielded disk'},
'DB': {'OS': 'CP/M-86/CDOS/CTOS/D800/DRMK','Description': 'CP/M-86/ConcDOS/Boot/FAT32'},
'DD': {'OS': 'CTOS','Description': 'Hidden memory dump'},
'DE': {'OS': 'Dell','Description': 'FAT16 utility/diagnostic'},
'DF': {'OS': 'DG/UX / BootIt / Aviion','Description': 'DG/UX Virt DiskMan / EMBRM'},
'E0': {'OS': 'STMicroelectronics','Description': 'ST AVFS'},
'E1': {'OS': 'SpeedStor','Description': 'ExtendedFAT12 >1023cylinder'},
'E2': {'Description': 'DOS read-only (XFDISK)'},
'E3': {'OS': 'SpeedStor','Description': 'DOS read-only'},
'E4': {'OS': 'SpeedStor','Description': 'ExtendedFAT16 <1024cylinder'},
'E5': {'OS': 'Tandy MS-DOS','Description': 'Logical FAT12 or FAT16'},
'E6': {'OS': 'SpeedStor','Description': 'Unknown'},
'E8': {'OS': 'LUKS','Description': 'Linux Unified Key Setup'},
'EB': {'OS': 'BeOS, Haiku','Description': 'BFS'},
'EC': {'OS': 'SkyOS','Description': 'SkyFS'},
'ED': {'OS': 'Sprytix / EDD 4','Description': 'EDC loader / GPT hybrid MBR'},
'EE': {'OS': 'EFI','Description': 'GPT protective MBR'},
'EF': {'OS': 'EFI','Description': 'EFI system partition'},
'F0': {'OS': 'Linux / OS/32','Description': 'PA-RISC Linux boot loader.'},
'F1': {'OS': 'SpeedStor','Description': 'Unknown'},
'F2': {'OS': 'SperryIT DOS/Unisys DOS','Description': 'Logical FAT12/FAT16'},
'F3': {'OS': 'SpeedStor','Description': 'Unknown'},
'F4': {'OS': 'SpeedStor / Prologue','Description': '"large"DOS part/NGF/TwinFS'},
'F5': {'OS': 'Prologue','Description': 'MD0-MD9 part for NGF/TwinFS'},
'F6': {'OS': 'SpeedStor','Description': 'Unknown'},
'F7': {'OS': 'O.S.G. / X1','Description': 'EFAT / Solid State FS'},
'F9': {'OS': 'Linux','Description': 'pCache ext2/ext3 cache'},
'FA': {'OS': 'Bochs','Description': 'x86 emulator'},
'FB': {'OS': 'VMware','Description': 'VMware VMFS partition'},
'FC': {'OS': 'VMware','Description': 'Swap / VMKCORE kernel dump'},
'FD': {'OS': 'Linux / FreeDOS','Description': 'LinuxRAID/Reserved4FreeDOS'},
'FE': {'OS': 'SpeedStor/LANstep/NT/Linux','Description': 'PS/2/DiskAdmin/old LinuxLVM'},
'FF': {'OS': 'XENIX','Description': 'XENIX bad block table'},
'00000000-0000-0000-0000-000000000000': {'Description': 'Unused entry'},
'024DEE41-33E7-11D3-9D69-0008C781F39F': {'Description': 'MBR partition scheme'},
'C12A7328-F81F-11D2-BA4B-00A0C93EC93B': {'Description': 'EFI System partition'},
'21686148-6449-6E6F-744E-656564454649': {'Description': 'BIOS Boot partition'},
'D3BFE2DE-3DAF-11DF-BA40-E3A556D89593': {'Description': 'Intel Fast Flash (iFFS) partition (for Intel Rapid Start technology)'},
'F4019732-066E-4E12-8273-346C5641494F': {'Description': 'Sony boot partition'},
'BFBFAFE7-A34F-448A-9A5B-6213EB736C22': {'Description': 'Lenovo boot partition'},
'E3C9E316-0B5C-4DB8-817D-F92DF00215AE': {'OS': 'Windows', 'Description': 'Microsoft Reserved Partition (MSR)'},
'EBD0A0A2-B9E5-4433-87C0-68B6B72699C7': {'OS': 'Windows', 'Description': 'Basic data partition'},
'5808C8AA-7E8F-42E0-85D2-E1E90434CFB3': {'OS': 'Windows', 'Description': 'Logical Disk Manager (LDM) metadata partition'},
'AF9B60A0-1431-4F62-BC68-3311714A69AD': {'OS': 'Windows', 'Description': 'Logical Disk Manager data partition'},
'DE94BBA4-06D1-4D40-A16A-BFD50179D6AC': {'OS': 'Windows', 'Description': 'Windows Recovery Environment'},
'37AFFC90-EF7D-4E96-91C3-2D7AE055B174': {'OS': 'Windows', 'Description': 'IBM General Parallel File System (GPFS) partition'},
'E75CAF8F-F680-4CEE-AFA3-B001E56EFC2D': {'OS': 'Windows', 'Description': 'Storage Spaces partition'},
'75894C1E-3AEB-11D3-B7C1-7B03A0000000': {'OS': 'HP-UX', 'Description': 'Data partition'},
'E2A1E728-32E3-11D6-A682-7B03A0000000': {'OS': 'HP-UX', 'Description': 'Service Partition'},
'0FC63DAF-8483-4772-8E79-3D69D8477DE4': {'OS': 'Linux', 'Description': 'Linux filesystem data'},
'A19D880F-05FC-4D3B-A006-743F0F84911E': {'OS': 'Linux', 'Description': 'RAID partition'},
'44479540-F297-41B2-9AF7-D131D5F0458A': {'OS': 'Linux', 'Description': 'Root partition (x86)'},
'4F68BCE3-E8CD-4DB1-96E7-FBCAF984B709': {'OS': 'Linux', 'Description': 'Root partition (x86-64)'},
'69DAD710-2CE4-4E3C-B16C-21A1D49ABED3': {'OS': 'Linux', 'Description': 'Root partition (32-bit ARM)'},
'B921B045-1DF0-41C3-AF44-4C6F280D3FAE': {'OS': 'Linux', 'Description': 'Root partition (64-bit ARM)/AArch64)'},
'0657FD6D-A4AB-43C4-84E5-0933C84B4F4F': {'OS': 'Linux', 'Description': 'Swap partition'},
'E6D6D379-F507-44C2-A23C-238F2A3DF928': {'OS': 'Linux', 'Description': 'Logical Volume Manager (LVM) partition'},
'933AC7E1-2EB4-4F13-B844-0E14E2AEF915': {'OS': 'Linux', 'Description': '/home partition'},
'3B8F8425-20E0-4F3B-907F-1A25A76F98E8': {'OS': 'Linux', 'Description': '/srv (server data) partition'},
'7FFEC5C9-2D00-49B7-8941-3EA10A5586B7': {'OS': 'Linux', 'Description': 'Plain dm-crypt partition'},
'CA7D7CCB-63ED-4C53-861C-1742536059CC': {'OS': 'Linux', 'Description': 'LUKS partition'},
'8DA63339-0007-60C0-C436-083AC8230908': {'OS': 'Linux', 'Description': 'Reserved'},
'83BD6B9D-7F41-11DC-BE0B-001560B84F0F': {'OS': 'FreeBSD', 'Description': 'Boot partition'},
'516E7CB4-6ECF-11D6-8FF8-00022D09712B': {'OS': 'FreeBSD', 'Description': 'Data partition'},
'516E7CB5-6ECF-11D6-8FF8-00022D09712B': {'OS': 'FreeBSD', 'Description': 'Swap partition'},
'516E7CB6-6ECF-11D6-8FF8-00022D09712B': {'OS': 'FreeBSD', 'Description': 'Unix File System (UFS) partition'},
'516E7CB8-6ECF-11D6-8FF8-00022D09712B': {'OS': 'FreeBSD', 'Description': 'Vinum volume manager partition'},
'516E7CBA-6ECF-11D6-8FF8-00022D09712B': {'OS': 'FreeBSD', 'Description': 'ZFS partition'},
'48465300-0000-11AA-AA11-00306543ECAC': {'OS': 'OS X Darwin', 'Description': 'Hierarchical File System Plus (HFS+) partition'},
'55465300-0000-11AA-AA11-00306543ECAC': {'OS': 'OS X Darwin', 'Description': 'Apple UFS'},
'6A898CC3-1DD2-11B2-99A6-080020736631': {'OS': 'OS X Darwin', 'Description': 'ZFS'},
'52414944-0000-11AA-AA11-00306543ECAC': {'OS': 'OS X Darwin', 'Description': 'Apple RAID partition'},
'52414944-5F4F-11AA-AA11-00306543ECAC': {'OS': 'OS X Darwin', 'Description': 'Apple RAID partition, offline'},
'426F6F74-0000-11AA-AA11-00306543ECAC': {'OS': 'OS X Darwin', 'Description': 'Apple Boot partition (Recovery HD)'},
'4C616265-6C00-11AA-AA11-00306543ECAC': {'OS': 'OS X Darwin', 'Description': 'Apple Label'},
'5265636F-7665-11AA-AA11-00306543ECAC': {'OS': 'OS X Darwin', 'Description': 'Apple TV Recovery partition'},
'53746F72-6167-11AA-AA11-00306543ECAC': {'OS': 'OS X Darwin', 'Description': 'Apple Core Storage (i.e. Lion FileVault) partition'},
'6A82CB45-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos', 'Description': 'Boot partition'},
'6A85CF4D-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos', 'Description': 'Root partition'},
'6A87C46F-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos', 'Description': 'Swap partition'},
'6A8B642B-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos', 'Description': 'Backup partition'},
'6A898CC3-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos', 'Description': '/usr partition'},
'6A8EF2E9-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos', 'Description': '/var partition'},
'6A90BA39-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos', 'Description': '/home partition'},
'6A9283A5-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos', 'Description': 'Alternate sector'},
'6A945A3B-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos', 'Description': 'Reserved partition'},
'6A9630D1-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos'},
'6A980767-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos'},
'6A96237F-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos'},
'6A8D2AC7-1DD2-11B2-99A6-080020736631': {'OS': 'Solaris illumos'},
'49F48D32-B10E-11DC-B99B-0019D1879648': {'OS': 'NetBSD', 'Description': 'Swap partition'},
'49F48D5A-B10E-11DC-B99B-0019D1879648': {'OS': 'NetBSD', 'Description': 'FFS partition'},
'49F48D82-B10E-11DC-B99B-0019D1879648': {'OS': 'NetBSD', 'Description': 'LFS partition'},
'49F48DAA-B10E-11DC-B99B-0019D1879648': {'OS': 'NetBSD', 'Description': 'RAID partition'},
'2DB519C4-B10F-11DC-B99B-0019D1879648': {'OS': 'NetBSD', 'Description': 'Concatenated partition'},
'2DB519EC-B10F-11DC-B99B-0019D1879648': {'OS': 'NetBSD', 'Description': 'Encrypted partition'},
'FE3A2A5D-4F32-41A7-B725-ACCC3285A309': {'OS': 'ChromeOS', 'Description': 'ChromeOS kernel'},
'3CB8E202-3B7E-47DD-8A3C-7FF2A13CFCEC': {'OS': 'ChromeOS', 'Description': 'ChromeOS rootfs'},
'2E0A753D-9E48-43B0-8337-B15192CB1B5E': {'OS': 'ChromeOS', 'Description': 'ChromeOS future use'},
'42465331-3BA3-10F1-802A-4861696B7521': {'OS': 'Haiku', 'Description': 'Haiku BFS'},
'85D5E45E-237C-11E1-B4B3-E89A8F7FC3A7': {'OS': 'MidnightBSD', 'Description': 'Boot partition'},
'85D5E45A-237C-11E1-B4B3-E89A8F7FC3A7': {'OS': 'MidnightBSD', 'Description': 'Data partition'},
'85D5E45B-237C-11E1-B4B3-E89A8F7FC3A7': {'OS': 'MidnightBSD', 'Description': 'Swap partition'},
'0394EF8B-237E-11E1-B4B3-E89A8F7FC3A7': {'OS': 'MidnightBSD', 'Description': 'Unix File System (UFS) partition'},
'85D5E45C-237C-11E1-B4B3-E89A8F7FC3A7': {'OS': 'MidnightBSD', 'Description': 'Vinum volume manager partition'},
'85D5E45D-237C-11E1-B4B3-E89A8F7FC3A7': {'OS': 'MidnightBSD', 'Description': 'ZFS partition'},
'45B0969E-9B03-4F30-B4C6-B4B80CEFF106': {'OS': 'Ceph', 'Description': 'Ceph Journal'},
'45B0969E-9B03-4F30-B4C6-5EC00CEFF106': {'OS': 'Ceph', 'Description': 'Ceph dm-crypt Encrypted Journal'},
'4FBD7E29-9D25-41B8-AFD0-062C0CEFF05D': {'OS': 'Ceph', 'Description': 'Ceph OSD'},
'4FBD7E29-9D25-41B8-AFD0-5EC00CEFF05D': {'OS': 'Ceph', 'Description': 'Ceph dm-crypt OSD'},
'89C57F98-2FE5-4DC0-89C1-F3AD0CEFF2BE': {'OS': 'Ceph', 'Description': 'Ceph disk in creation'},
'89C57F98-2FE5-4DC0-89C1-5EC00CEFF2BE': {'OS': 'Ceph', 'Description': 'Ceph dm-crypt disk in creation'},
'824CC7A0-36A8-11E3-890A-952519AD3F61': {'OS': 'OpenBSD', 'Description': 'Data partition'},
'CEF5A9AD-73BC-4601-89F3-CDEEEEE321A1': {'OS': 'QNX', 'Description': 'Power-safe (QNX6) file system'},
'C91818F9-8025-47AF-89D2-F030D7000C2C': {'OS': 'Plan 9', 'Description': 'Plan 9 partition'},
'9D275380-40AD-11DB-BF97-000C2911D1B8': {'OS': 'VMware ESX', 'Description': 'vmkcore (coredump partition)'},
'AA31E02A-400F-11DB-9590-000C2911D1B8': {'OS': 'VMware ESX', 'Description': 'VMFS filesystem partition'},
'9198EFFC-31C0-11DB-8F78-000C2911D1B8': {'OS': 'VMware ESX', 'Description': 'VMware Reserved'},
'2568845D-2332-4675-BC39-8FA5A4748D15': {'OS': 'Android-IA', 'Description': 'Bootloader'},
'114EAFFE-1552-4022-B26E-9B053604CF84': {'OS': 'Android-IA', 'Description': 'Bootloader2'},
'49A4D17F-93A3-45C1-A0DE-F50B2EBE2599': {'OS': 'Android-IA', 'Description': 'Boot'},
'4177C722-9E92-4AAB-8644-43502BFD5506': {'OS': 'Android-IA', 'Description': 'Recovery'},
'EF32A33B-A409-486C-9141-9FFB711F6266': {'OS': 'Android-IA', 'Description': 'Misc'},
'20AC26BE-20B7-11E3-84C5-6CFDB94711E9': {'OS': 'Android-IA', 'Description': 'Metadata'},
'38F428E6-D326-425D-9140-6E0EA133647C': {'OS': 'Android-IA', 'Description': 'System'},
'A893EF21-E428-470A-9E55-0668FD91A2D9': {'OS': 'Android-IA', 'Description': 'Cache'},
'DC76DDA9-5AC1-491C-AF42-A82591580C0D': {'OS': 'Android-IA', 'Description': 'Data'},
'EBC597D0-2053-4B15-8B64-E0AAC75F4DB1': {'OS': 'Android-IA', 'Description': 'Persistent'},
'8F68CC74-C5E5-48DA-BE91-A0C8C15E9C80': {'OS': 'Android-IA', 'Description': 'Factory'},
'767941D0-2085-11E3-AD3B-6CFDB94711E9': {'OS': 'Android-IA', 'Description': 'Fastboot / Tertiary'},
'AC6D7924-EB71-4DF8-B48D-E267B27148FF': {'OS': 'Android-IA', 'Description': 'OEM'},
'7412F7D5-A156-4B13-81DC-867174929325': {'OS': 'ONIE', 'Description': 'Boot'},
'D4E6E2CD-4469-46F3-B5CB-1BFF57AFC149': {'OS': 'ONIE', 'Description': 'Config'},
'9E1A2D38-C612-4316-AA26-8B49521E5A8B': {'OS': 'PowerPC', 'Description': 'PReP boot'},
'BC13C2FF-59E6-4262-A352-B275FD6F7172': {'OS': 'Freedesktop', 'Description': 'Extended Boot Partition ($BOOT)'},
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

21
scripts/wk.prev/settings/sensors.py
View file

@ -1,21 +0,0 @@
# Wizard Kit: Settings - Sensors
import re
# General
TEMP_LIMITS = {
'GREEN': 60,
'YELLOW': 70,
'ORANGE': 80,
'RED': 90,
}
# Regex
REGEX_COLORS = re.compile(r'\033\[\d+;?1?m')
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

261
scripts/wk.prev/settings/setup.py
View file

@ -1,261 +0,0 @@
'''Wizard Kit: Settings - Setup'''
# pylint: disable=bad-continuation,line-too-long
# vim: sts=2 sw=2 ts=2
import os
try:
import winreg
HKU = winreg.HKEY_USERS
HKCR = winreg.HKEY_CLASSES_ROOT
HKCU = winreg.HKEY_CURRENT_USER
HKLM = winreg.HKEY_LOCAL_MACHINE
except ImportError:
if os.name != 'posix':
raise
# General
OTHER_RESULTS = {
'Error': {
'CalledProcessError': 'Unknown Error',
'FileNotFoundError': 'File not found',
},
'Warning': {},
}
# Browsers
MOZILLA_FIREFOX_UBO_PATH = r'{}\{}\ublock_origin.xpi'.format(
os.environ.get('PROGRAMFILES'),
r'Mozilla Firefox\distribution\extensions')
SETTINGS_GOOGLE_CHROME = {
r'Software\Google\Chrome\Extensions\cjpalhdlnbpafiamejdnhcphjbkeiagm': {
'SZ Items': {
'update_url': 'https://clients2.google.com/service/update2/crx'},
'WOW64_32': True,
},
r'Software\Google\Chrome\Extensions\pgdnlhfefecpicbbihgmbmffkjpaplco': {
'SZ Items': {
'update_url': 'https://clients2.google.com/service/update2/crx'},
'WOW64_32': True,
},
}
SETTINGS_MOZILLA_FIREFOX_32 = {
r'Software\Mozilla\Firefox\Extensions': {
'SZ Items': {
'uBlock0@raymondhill.net': MOZILLA_FIREFOX_UBO_PATH},
'WOW64_32': True,
},
}
SETTINGS_MOZILLA_FIREFOX_64 = {
r'Software\Mozilla\Firefox\Extensions': {
'SZ Items': {
'uBlock0@raymondhill.net': MOZILLA_FIREFOX_UBO_PATH},
},
}
# Classic Start
SETTINGS_CLASSIC_START = {
r'Software\IvoSoft\ClassicShell\Settings': {},
r'Software\IvoSoft\ClassicStartMenu': {
'DWORD Items': {'ShowedStyle2': 1},
},
r'Software\IvoSoft\ClassicStartMenu\MRU': {},
r'Software\IvoSoft\ClassicStartMenu\Settings': {
'DWORD Items': {'SkipMetro': 1},
'SZ Items': {
'MenuStyle': 'Win7',
'RecentPrograms': 'Recent',
},
},
}
# ESET
SETTINGS_ESET_SYSTEM = {
r'Software\ESET\ESET Security\CurrentVersion\Config\Settings\LiveGrid': {
'DWORD Items': {
'LiveGridFeedbackEnabled': 1,
},
},
}
SETTINGS_ESET_USER = {
r'Software\ESET\ESET Security\CurrentVersion\gui\UI_CONFIG': {
'DWORD Items': {
'FullScreenMode': 0,
'ShowAlertStatus': 0x40000000,
'ShowDesktopAlert': 0,
'ShowSplash': 0,
},
},
}
# Explorer
SETTINGS_EXPLORER_SYSTEM = {
# Disable edge swipe
r'Software\Policies\Microsoft\Windows\EdgeUI': {
'DWORD Items': {'AllowEdgeSwipe': 0},
},
# Disable Location Tracking
r'Software\Microsoft\Windows NT\CurrentVersion\Sensor\Overrides\{BFA794E4-F964-4FDB-90F6-51056BFE4B44}': {
'DWORD Items': {'SensorPermissionState': 0},
},
r'System\CurrentControlSet\Services\lfsvc\Service\Configuration': {
'Status': {'Value': 0},
},
# Disable Telemetry
r'SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\DataCollection': {
# Using SOFTWARE in all caps to avoid collision with 32-bit setting below
'DWORD Items': {'AllowTelemetry': 0},
},
r'Software\Microsoft\Windows\CurrentVersion\Policies\DataCollection': {
'DWORD Items': {'AllowTelemetry': 0},
'WOW64_32': True,
},
r'Software\Policies\Microsoft\Windows\DataCollection': {
'DWORD Items': {'AllowTelemetry': 0},
},
# Disable Wi-Fi Sense
r'Software\Microsoft\PolicyManager\default\WiFi\AllowWiFiHotSpotReporting': {
'DWORD Items': {'Value': 0},
},
r'Software\Microsoft\PolicyManager\default\WiFi\AllowAutoConnectToWiFiSenseHotspots': {
'DWORD Items': {'Value': 0},
},
}
SETTINGS_EXPLORER_USER = {
# Desktop icons
r'Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons\ClassicStartMenu': {
'Invalid modes': ['Cur'],
'DWORD Items': {
# This PC
'{20D04FE0-3AEA-1069-A2D8-08002B30309D}': 0,
# User's Folder
'{59031a47-3f72-44a7-89c5-5595fe6b30ee}': 0,
},
},
r'Software\Microsoft\Windows\CurrentVersion\Explorer\HideDesktopIcons\NewStartPanel': {
'Invalid modes': ['Cur'],
'DWORD Items': {
# This PC
'{20D04FE0-3AEA-1069-A2D8-08002B30309D}': 0,
# User's Folder
'{59031a47-3f72-44a7-89c5-5595fe6b30ee}': 0,
},
},
# Desktop theme
r'Software\Microsoft\Windows\CurrentVersion\Themes\Personalize': {
'Invalid modes': ['Cur'],
'DWORD Items': {
# <= v1809 default
'AppsUseLightTheme': 1,
'SystemUsesLightTheme': 0,
},
},
# Disable features
r'Software\Microsoft\Windows\CurrentVersion\ContentDeliveryManager': {
'DWORD Items': {
# Silently installed apps
'SilentInstalledAppsEnabled': 0,
# Tips and Tricks
'SoftLandingEnabled ': 0,
'SubscribedContent-338389Enabled': 0,
},
},
# File Explorer
r'Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced': {
'Invalid modes': ['Cur'],
'DWORD Items': {
# Replace PowerShell with CMD in Win+X menu
'DontUsePowerShellOnWinX': 1,
# Change default Explorer view to "Computer"
'LaunchTo': 1,
},
},
r'SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\Advanced': {
# Dup path so it Will be applied to all modes
'DWORD Items': {
# Launch Folder Windows in a Separate Process
'SeparateProcess': 1,
},
},
# Hide People bar
r'Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced\People': {
'Invalid modes': ['Cur'],
'DWORD Items': {'PeopleBand': 0},
},
# Hide Search button / box
r'Software\Microsoft\Windows\CurrentVersion\Search': {
'Invalid modes': ['Cur'],
'DWORD Items': {'SearchboxTaskbarMode': 1},
},
}
# Fast Startup
SETTINGS_FAST_STARTUP = {
# Disable Fast Startup
r'SOFTWARE\Policies\Microsoft\Windows\System': {
'DWORD Items': {'HiberbootEnabled': 0},
},
}
# LibreOffice
LIBREOFFICE_XCU_DATA = '''<?xml version="1.0" encoding="UTF-8"?>
<oor:items xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<item oor:path="/org.openoffice.Setup/Office/Factories/org.openoffice.Setup:Factory['com.sun.star.presentation.PresentationDocument']"><prop oor:name="ooSetupFactoryDefaultFilter" oor:op="fuse"><value>Impress MS PowerPoint 2007 XML</value></prop></item>
<item oor:path="/org.openoffice.Setup/Office/Factories/org.openoffice.Setup:Factory['com.sun.star.sheet.SpreadsheetDocument']"><prop oor:name="ooSetupFactoryDefaultFilter" oor:op="fuse"><value>Calc MS Excel 2007 XML</value></prop></item>
<item oor:path="/org.openoffice.Setup/Office/Factories/org.openoffice.Setup:Factory['com.sun.star.text.TextDocument']"><prop oor:name="ooSetupFactoryDefaultFilter" oor:op="fuse"><value>MS Word 2007 XML</value></prop></item>
<item oor:path="/org.openoffice.Office.Common/Save/Document"><prop oor:name="WarnAlienFormat" oor:op="fuse"><value>false</value></prop></item>
</oor:items>
'''
# Power Plans
POWER_PLAN_GUIDS = {
'Power': 'a1841308-3541-4fab-bc81-f71556f20b4a',
'Balanced': '381b4222-f694-41f0-9685-ff5bb260df2e',
'High Performance': '8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c',
}
# Registry
SETTINGS_REGBACK = {
# Enable RegBack
r'System\CurrentControlSet\Control\Session Manager\Configuration Manager': {
'DWORD Items': {'EnablePeriodicBackup': 1},
},
}
# Visual C++ Runtimes
VCR_REDISTS = [
{'Name': 'Visual C++ 2010 x32...',
'Cmd': [r'2010sp1\x32\vcredist.exe', '/passive', '/norestart']},
{'Name': 'Visual C++ 2010 x64...',
'Cmd': [r'2010sp1\x64\vcredist.exe', '/passive', '/norestart']},
{'Name': 'Visual C++ 2012 Update 4 x32...',
'Cmd': [r'2012u4\x32\vcredist.exe', '/passive', '/norestart']},
{'Name': 'Visual C++ 2012 Update 4 x64...',
'Cmd': [r'2012u4\x64\vcredist.exe', '/passive', '/norestart']},
{'Name': 'Visual C++ 2013 x32...',
'Cmd': [r'2013\x32\vcredist.exe', '/install',
'/passive', '/norestart']},
{'Name': 'Visual C++ 2013 x64...',
'Cmd': [r'2013\x64\vcredist.exe', '/install',
'/passive', '/norestart']},
{'Name': 'Visual C++ 2017 x32...',
'Cmd': [r'2017\x32\vcredist.exe', '/install',
'/passive', '/norestart']},
{'Name': 'Visual C++ 2017 x64...',
'Cmd': [r'2017\x64\vcredist.exe', '/install',
'/passive', '/norestart']},
]
# Windows Updates
SETTINGS_WINDOWS_UPDATES = {
r'Software\Microsoft\WindowsUpdate\UX\Settings': {
'DWORD Items': {
# Set to non-targeted readiness level
'BranchReadinessLevel': 32,
'DeferFeatureUpdatesPeriodInDays': 60,
},
}
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")

239
scripts/wk.prev/settings/sources.py
View file

@ -1,239 +0,0 @@
'''Wizard Kit: Settings - Sources'''
# pylint: disable=line-too-long
# vim: sts=2 sw=2 ts=2 tw=0
SOURCE_URLS = {
'Adobe Reader DC': 'http://ardownload.adobe.com/pub/adobe/reader/win/AcrobatDC/1902120049/AcroRdrDC1902120049_en_US.exe',
'AdwCleaner': 'https://downloads.malwarebytes.com/file/adwcleaner',
'AIDA64': 'http://download.aida64.com/aida64engineer610.zip',
'aria2': 'https://github.com/aria2/aria2/releases/download/release-1.35.0/aria2-1.35.0-win-32bit-build1.zip',
'Autoruns': 'https://download.sysinternals.com/files/Autoruns.zip',
'BleachBit': 'https://www.bleachbit.org/download/file/t?file=BleachBit-3.0-portable.zip',
'BlueScreenView32': 'http://www.nirsoft.net/utils/bluescreenview.zip',
'BlueScreenView64': 'http://www.nirsoft.net/utils/bluescreenview-x64.zip',
'Caffeine': 'http://www.zhornsoftware.co.uk/caffeine/caffeine.zip',
'ClassicStartSkin': 'https://coddec.github.io/Classic-Shell/www.classicshell.net/forum/download/fileb1ba.php?id=3001',
'Du': 'https://download.sysinternals.com/files/DU.zip',
'ERUNT': 'http://www.aumha.org/downloads/erunt.zip',
'ESET AVRemover32': 'https://download.eset.com/com/eset/tools/installers/av_remover/latest/avremover_nt32_enu.exe',
'ESET AVRemover64': 'https://download.eset.com/com/eset/tools/installers/av_remover/latest/avremover_nt64_enu.exe',
'ESET NOD32 AV': 'https://download.eset.com/com/eset/apps/home/eav/windows/latest/eav_nt64.exe',
'ESET Online Scanner': 'https://download.eset.com/com/eset/tools/online_scanner/latest/esetonlinescanner_enu.exe',
'Everything32': 'https://www.voidtools.com/Everything-1.4.1.935.x86.en-US.zip',
'Everything64': 'https://www.voidtools.com/Everything-1.4.1.935.x64.en-US.zip',
'FastCopy': 'http://ftp.vector.co.jp/72/08/2323/FastCopy385_installer.exe',
'FurMark': 'https://geeks3d.com/dl/get/569',
'Firefox uBO': 'https://addons.mozilla.org/firefox/downloads/file/3428595/ublock_origin-1.23.0-an+fx.xpi',
'HitmanPro32': 'https://dl.surfright.nl/HitmanPro.exe',
'HitmanPro64': 'https://dl.surfright.nl/HitmanPro_x64.exe',
'HWiNFO': 'http://files2.majorgeeks.com/e4b5a2b01ee1b51b2d17a165855b43c142d822c4/systeminfo/hwi_614.zip',
'Intel SSD Toolbox': r'https://downloadmirror.intel.com/28593/eng/Intel%20SSD%20Toolbox%20-%20v3.5.9.exe',
'IOBit_Uninstaller': r'https://portableapps.com/redirect/?a=IObitUninstallerPortable&s=s&d=pa&f=IObitUninstallerPortable_7.5.0.7.paf.exe',
'KVRT': 'http://devbuilds.kaspersky-labs.com/devbuilds/KVRT/latest/full/KVRT.exe',
'LibreOffice': 'https://download.documentfoundation.org/libreoffice/stable/6.3.3/win/x86_64/LibreOffice_6.3.3_Win_x64.msi',
'Linux Reader': 'https://www.diskinternals.com/download/Linux_Reader.exe',
'Macs Fan Control': 'https://www.crystalidea.com/downloads/macsfancontrol_setup.exe',
'NirCmd32': 'https://www.nirsoft.net/utils/nircmd.zip',
'NirCmd64': 'https://www.nirsoft.net/utils/nircmd-x64.zip',
'NotepadPlusPlus': 'http://download.notepad-plus-plus.org/repository/7.x/7.8.1/npp.7.8.1.bin.minimalist.7z',
'Office Deployment Tool': 'https://download.microsoft.com/download/2/7/A/27AF1BE6-DD20-4CB4-B154-EBAB8A7D4A7E/officedeploymenttool_11617-33601.exe',
'ProduKey32': 'http://www.nirsoft.net/utils/produkey.zip',
'ProduKey64': 'http://www.nirsoft.net/utils/produkey-x64.zip',
'PuTTY': 'https://the.earth.li/~sgtatham/putty/latest/w32/putty.zip',
'RKill': 'https://www.bleepingcomputer.com/download/rkill/dl/10/',
'Samsung Magician': 'https://s3.ap-northeast-2.amazonaws.com/global.semi.static/SAMSUNG_SSD_v5_3_0_181121/CD0C7CC1BE00525FAC4675B9E502899B41D5C3909ECE3AA2FB6B74A766B2A1EA/Samsung_Magician_Installer.zip',
'SDIO Themes': 'http://snappy-driver-installer.org/downloads/SDIO_Themes.zip',
'SDIO Torrent': 'http://snappy-driver-installer.org/downloads/SDIO_Update.torrent',
'ShutUp10': 'https://dl5.oo-software.com/files/ooshutup10/OOSU10.exe',
'smartmontools': 'https://738-105252244-gh.circle-artifacts.com/0/builds/smartmontools-win32-setup-7.1-r4934.exe',
'TDSSKiller': 'https://media.kaspersky.com/utilities/VirusUtilities/EN/tdsskiller.exe',
'TestDisk': 'https://www.cgsecurity.org/testdisk-7.2-WIP.win.zip',
'wimlib32': 'https://wimlib.net/downloads/wimlib-1.13.1-windows-i686-bin.zip',
'wimlib64': 'https://wimlib.net/downloads/wimlib-1.13.1-windows-x86_64-bin.zip',
'WinAIO Repair': 'http://www.tweaking.com/files/setups/tweaking.com_windows_repair_aio.zip',
'Winapp2': 'https://github.com/MoscaDotTo/Winapp2/archive/master.zip',
'WizTree': 'https://antibody-software.com/files/wiztree_3_30_portable.zip',
'XMPlay 7z': 'https://support.xmplay.com/files/16/xmp-7z.zip?v=800962',
'XMPlay Game': 'https://support.xmplay.com/files/12/xmp-gme.zip?v=515637',
'XMPlay RAR': 'https://support.xmplay.com/files/16/xmp-rar.zip?v=409646',
'XMPlay WAModern': 'https://support.xmplay.com/files/10/WAModern.zip?v=207099',
'XMPlay': 'https://support.xmplay.com/files/20/xmplay383.zip?v=298195',
'XYplorerFree': 'https://www.xyplorer.com/download/xyplorer_free_noinstall.zip',
}
VCREDIST_SOURCES = {
'2010sp1': {
'32': 'https://download.microsoft.com/download/1/6/5/165255E7-1014-4D0A-B094-B6A430A6BFFC/vcredist_x86.exe',
'64': 'https://download.microsoft.com/download/1/6/5/165255E7-1014-4D0A-B094-B6A430A6BFFC/vcredist_x64.exe',
},
'2012u4': {
'32': 'https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x86.exe',
'64': 'https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x64.exe',
},
'2013': {
'32': 'https://download.microsoft.com/download/0/5/6/056dcda9-d667-4e27-8001-8a0c6971d6b1/vcredist_x86.exe',
'64': 'https://download.microsoft.com/download/0/5/6/056dcda9-d667-4e27-8001-8a0c6971d6b1/vcredist_x64.exe',
},
'2017': {
'32': 'https://aka.ms/vs/15/release/vc_redist.x86.exe',
'64': 'https://aka.ms/vs/15/release/vc_redist.x64.exe',
},
}
NINITE_REGEX = {
'base': ['7-Zip', 'VLC'],
'standard': ['Google Chrome', 'Mozilla Firefox', 'SumatraPDF'],
'standard7': ['Google Chrome', 'Mozilla Firefox', 'SumatraPDF'],
}
NINITE_SOURCES = {
'Bundles': {
'base.exe': '.net4.8-7zip-classicstart-vlc',
'base7.exe': '.net4.8-7zip-vlc',
'base-standard.exe': '.net4.8-7zip-chrome-classicstart-firefox-sumatrapdf-vlc',
'base-standard7.exe': '.net4.8-7zip-chrome-firefox-sumatrapdf-vlc',
'standard.exe': 'chrome-firefox-sumatrapdf',
'standard7.exe': 'chrome-firefox-sumatrapdf',
},
'Audio-Video': {
'AIMP.exe': 'aimp',
'Audacity.exe': 'audacity',
'CCCP.exe': 'cccp',
'Foobar2000.exe': 'foobar',
'GOM.exe': 'gom',
'HandBrake.exe': 'handbrake',
'iTunes.exe': 'itunes',
'K-Lite Codecs.exe': 'klitecodecs',
'MediaMonkey.exe': 'mediamonkey',
'MusicBee.exe': 'musicbee',
'Spotify.exe': 'spotify',
'VLC.exe': 'vlc',
'Winamp.exe': 'winamp',
},
'Cloud Storage': {
'Dropbox.exe': 'dropbox',
'Google Backup & Sync.exe': 'googlebackupandsync',
'Mozy.exe': 'mozy',
'OneDrive.exe': 'onedrive',
'SugarSync.exe': 'sugarsync',
},
'Communication': {
'Discord.exe': 'discord',
'Pidgin.exe': 'pidgin',
'Skype.exe': 'skype',
'Trillian.exe': 'trillian',
},
'Compression': {
'7-Zip.exe': '7zip',
'PeaZip.exe': 'peazip',
'WinRAR.exe': 'winrar',
},
'Developer': {
'Eclipse.exe': 'eclipse',
'Notepad++.exe': 'notepadplusplus',
'PuTTY.exe': 'putty',
'Python 2.exe': 'python',
'Visual Studio Code.exe': 'vscode',
'WinMerge.exe': 'winmerge',
'WinSCP.exe': 'winscp',
},
'File Sharing': {
'qBittorrent.exe': 'qbittorrent',
},
'Image-Photo': {
'Blender.exe': 'blender',
'FastStone.exe': 'faststone',
'GIMP.exe': 'gimp',
'Greenshot.exe': 'greenshot',
'Inkscape.exe': 'inkscape',
'IrfanView.exe': 'irfanview',
'Krita.exe': 'krita',
'Paint.NET.exe': 'paint.net',
'ShareX.exe': 'sharex',
'XnView.exe': 'xnview',
},
'Misc': {
'Evernote.exe': 'evernote',
'Everything.exe': 'everything',
'KeePass 2.exe': 'keepass2',
'Google Earth.exe': 'googleearth',
'NV Access.exe': 'nvda',
'Steam.exe': 'steam',
},
'Office': {
'CutePDF.exe': 'cutepdf',
'Foxit Reader.exe': 'foxit',
'LibreOffice.exe': 'libreoffice',
'OpenOffice.exe': 'openoffice',
'PDFCreator.exe': 'pdfcreator',
'SumatraPDF.exe': 'sumatrapdf',
'Thunderbird.exe': 'thunderbird',
},
'Runtimes': {
'Adobe Air.exe': 'air',
'dotNET.exe': '.net4.8',
'Shockwave.exe': 'shockwave',
'Silverlight.exe': 'silverlight',
},
'Security': {
'Avast.exe': 'avast',
'AVG.exe': 'avg',
'Avira.exe': 'avira',
'Microsoft Security Essentials.exe': 'essentials',
'Malwarebytes Anti-Malware.exe': 'malwarebytes',
'Spybot 2.exe': 'spybot2',
'SUPERAntiSpyware.exe': 'super',
},
'Utilities': {
'CDBurnerXP.exe': 'cdburnerxp',
'Classic Start.exe': 'classicstart',
'Glary Utilities.exe': 'glary',
'ImgBurn.exe': 'imgburn',
'InfraRecorder.exe': 'infrarecorder',
'Launchy.exe': 'launchy',
'RealVNC.exe': 'realvnc',
'Revo Uninstaller.exe': 'revo',
'TeamViewer 14.exe': 'teamviewer14',
'TeraCopy.exe': 'teracopy',
'WinDirStat.exe': 'windirstat',
},
'Web Browsers': {
'Google Chrome.exe': 'chrome',
'Mozilla Firefox.exe': 'firefox',
'Opera Chromium.exe': 'operaChromium',
},
}
RST_SOURCES = {
#SetupRST_12.0.exe : Removed from download center?
#SetupRST_12.5.exe : Removed from download center?
#SetupRST_12.8.exe : Removed from download center?
'SetupRST_12.9.exe': 'https://downloadmirror.intel.com/23496/eng/SetupRST.exe',
#SetupRST_13.x.exe : Broken, doesn't support > .NET 4.5
'SetupRST_14.0.exe': 'https://downloadmirror.intel.com/25091/eng/SetupRST.exe',
'SetupRST_14.8.exe': 'https://downloadmirror.intel.com/26759/eng/setuprst.exe',
'SetupRST_15.8.exe': 'https://downloadmirror.intel.com/27442/eng/SetupRST.exe',
'SetupRST_15.9.exe': 'https://downloadmirror.intel.com/28656/eng/SetupRST.exe',
#SetupRST_16.0.exe : Deprecated by Intel
#SetupRST_16.5.exe : Deprecated by Intel
#SetupRST_16.7.exe : Deprecated by Intel
'SetupRST_16.8.exe': 'https://downloadmirror.intel.com/28653/eng/SetupRST.exe',
'SetupRST_17.2.exe': 'https://downloadmirror.intel.com/28650/eng/SetupRST.exe',
}
WINDOWS_UPDATE_SOURCES = {
'2999226': {
# https://support.microsoft.com/en-us/help/2999226/update-for-universal-c-runtime-in-windows
'7': {
'32': 'https://download.microsoft.com/download/4/F/E/4FE73868-5EDD-4B47-8B33-CE1BB7B2B16A/Windows6.1-KB2999226-x86.msu',
'64': 'https://download.microsoft.com/download/1/1/5/11565A9A-EA09-4F0A-A57E-520D5D138140/Windows6.1-KB2999226-x64.msu',
},
'8': {
'32': 'https://download.microsoft.com/download/1/E/8/1E8AFE90-5217-464D-9292-7D0B95A56CE4/Windows8-RT-KB2999226-x86.msu',
'64': 'https://download.microsoft.com/download/A/C/1/AC15393F-A6E6-469B-B222-C44B3BB6ECCC/Windows8-RT-KB2999226-x64.msu',
},
'8.1': {
'32': 'https://download.microsoft.com/download/E/4/6/E4694323-8290-4A08-82DB-81F2EB9452C2/Windows8.1-KB2999226-x86.msu',
'64': 'https://download.microsoft.com/download/9/6/F/96FD0525-3DDF-423D-8845-5F92F4A6883E/Windows8.1-KB2999226-x64.msu',
},
},
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")

29
scripts/wk.prev/settings/sw_diags.py
View file

@ -1,29 +0,0 @@
# Wizard Kit: Settings - SW Diagnostics
# General
AUTORUNS_SETTINGS = {
r'Software\Sysinternals\AutoRuns': {
'checkvirustotal': 1,
'EulaAccepted': 1,
'shownomicrosoft': 1,
'shownowindows': 1,
'showonlyvirustotal': 1,
'submitvirustotal': 0,
'verifysignatures': 1,
},
r'Software\Sysinternals\AutoRuns\SigCheck': {
'EulaAccepted': 1,
},
r'Software\Sysinternals\AutoRuns\Streams': {
'EulaAccepted': 1,
},
r'Software\Sysinternals\AutoRuns\VirusTotal': {
'VirusTotalTermsAccepted': 1,
},
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

62
scripts/wk.prev/settings/tools.py
View file

@ -1,62 +0,0 @@
# Wizard Kit: Settings - Tools
TOOLS = {
# NOTE: BinDir will be prepended to these paths at runtime
'AIDA64': {
'32': r'AIDA64\aida64.exe'},
'AutoRuns': {
'32': r'Autoruns\autoruns.exe',
'64': r'Autoruns\autoruns64.exe'},
'BleachBit': {
'32': r'BleachBit\bleachbit_console.exe'},
'Caffeine': {
'32': r'Caffeine\caffeine.exe'},
'Du': {
'32': r'Du\du.exe',
'64': r'Du\du64.exe'},
'ERUNT': {
'32': r'ERUNT\ERUNT.EXE'},
'Everything': {
'32': r'Everything\Everything.exe',
'64': r'Everything\Everything64.exe'},
'FastCopy': {
'32': r'FastCopy\FastCopy.exe',
'64': r'FastCopy\FastCopy64.exe'},
'HitmanPro': {
'32': r'HitmanPro\HitmanPro.exe',
'64': r'HitmanPro\HitmanPro64.exe'},
'HWiNFO': {
'32': r'HWiNFO\HWiNFO.exe',
'64': r'HWiNFO\HWiNFO64.exe'},
'KVRT': {
'32': r'KVRT\KVRT.exe'},
'NirCmd': {
'32': r'NirCmd\nircmdc.exe',
'64': r'NirCmd\nircmdc64.exe'},
'NotepadPlusPlus': {
'32': r'NotepadPlusPlus\notepadplusplus.exe'},
'ProduKey': {
'32': r'ProduKey\ProduKey.exe',
'64': r'ProduKey\ProduKey64.exe'},
'RKill': {
'32': r'RKill\RKill.exe'},
'SevenZip': {
'32': r'7-Zip\7za.exe',
'64': r'7-Zip\7za64.exe'},
'smartctl': {
'32': r'smartmontools\smartctl.exe',
'64': r'smartmontools\smartctl64.exe'},
'TDSSKiller': {
'32': r'TDSSKiller\TDSSKiller.exe'},
'wimlib-imagex': {
'32': r'wimlib\x32\wimlib-imagex.exe',
'64': r'wimlib\x64\wimlib-imagex.exe'},
'XMPlay': {
'32': r'XMPlay\xmplay.exe'},
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

258
scripts/wk.prev/settings/windows_builds.py
View file

@ -1,258 +0,0 @@
'''Wizard Kit: Settings - Windows Builds'''
# pylint: disable=bad-continuation,bad-whitespace
# vim: sts=2 sw=2 ts=2
## NOTE: Data from here: https://en.wikipedia.org/wiki/Windows_10_version_history
WINDOWS_BUILDS = {
# Build, Version, Release, Codename, Marketing Name, Notes
'6000': ('Vista', 'RTM', 'Longhorn', None, 'unsupported'),
'6001': ('Vista', 'SP1', 'Longhorn', None, 'unsupported'),
'6002': ('Vista', 'SP2', 'Longhorn', None, 'unsupported'),
'7600': ('7', 'RTM', 'Vienna', None, 'unsupported'),
'7601': ('7', 'SP1', 'Vienna', None, 'outdated'),
#9199 is a fake build since Win 8 is 6.2.9200 but that collides with Win 8.1 (6.3.9200)
'9199': ('8', 'RTM', None, None, 'unsupported'),
'9200': ('8.1', None, 'Blue', None, 'outdated'),
'9600': ('8.1', None, 'Update', None, None),
'9841': ('10', None, 'Threshold 1', None, 'preview build'),
'9860': ('10', None, 'Threshold 1', None, 'preview build'),
'9879': ('10', None, 'Threshold 1', None, 'preview build'),
'9926': ('10', None, 'Threshold 1', None, 'preview build'),
'10041': ('10', None, 'Threshold 1', None, 'preview build'),
'10049': ('10', None, 'Threshold 1', None, 'preview build'),
'10061': ('10', None, 'Threshold 1', None, 'preview build'),
'10074': ('10', None, 'Threshold 1', None, 'preview build'),
'10122': ('10', None, 'Threshold 1', None, 'preview build'),
'10130': ('10', None, 'Threshold 1', None, 'preview build'),
'10158': ('10', None, 'Threshold 1', None, 'preview build'),
'10159': ('10', None, 'Threshold 1', None, 'preview build'),
'10162': ('10', None, 'Threshold 1', None, 'preview build'),
'10166': ('10', None, 'Threshold 1', None, 'preview build'),
'10240': ('10', 'v1507', 'Threshold 1', None, 'unsupported'),
'10525': ('10', None, 'Threshold 2', None, 'preview build'),
'10532': ('10', None, 'Threshold 2', None, 'preview build'),
'10547': ('10', None, 'Threshold 2', None, 'preview build'),
'10565': ('10', None, 'Threshold 2', None, 'preview build'),
'10576': ('10', None, 'Threshold 2', None, 'preview build'),
'10586': ('10', 'v1511', 'Threshold 2', 'November Update', 'unsupported'),
'11082': ('10', None, 'Redstone 1', None, 'preview build'),
'11099': ('10', None, 'Redstone 1', None, 'preview build'),
'11102': ('10', None, 'Redstone 1', None, 'preview build'),
'14251': ('10', None, 'Redstone 1', None, 'preview build'),
'14257': ('10', None, 'Redstone 1', None, 'preview build'),
'14271': ('10', None, 'Redstone 1', None, 'preview build'),
'14279': ('10', None, 'Redstone 1', None, 'preview build'),
'14291': ('10', None, 'Redstone 1', None, 'preview build'),
'14295': ('10', None, 'Redstone 1', None, 'preview build'),
'14316': ('10', None, 'Redstone 1', None, 'preview build'),
'14328': ('10', None, 'Redstone 1', None, 'preview build'),
'14332': ('10', None, 'Redstone 1', None, 'preview build'),
'14342': ('10', None, 'Redstone 1', None, 'preview build'),
'14352': ('10', None, 'Redstone 1', None, 'preview build'),
'14361': ('10', None, 'Redstone 1', None, 'preview build'),
'14366': ('10', None, 'Redstone 1', None, 'preview build'),
'14367': ('10', None, 'Redstone 1', None, 'preview build'),
'14371': ('10', None, 'Redstone 1', None, 'preview build'),
'14372': ('10', None, 'Redstone 1', None, 'preview build'),
'14376': ('10', None, 'Redstone 1', None, 'preview build'),
'14379': ('10', None, 'Redstone 1', None, 'preview build'),
'14383': ('10', None, 'Redstone 1', None, 'preview build'),
'14385': ('10', None, 'Redstone 1', None, 'preview build'),
'14388': ('10', None, 'Redstone 1', None, 'preview build'),
'14390': ('10', None, 'Redstone 1', None, 'preview build'),
'14393': ('10', 'v1607', 'Redstone 1', 'Anniversary Update', 'unsupported'),
'14901': ('10', None, 'Redstone 2', None, 'preview build'),
'14905': ('10', None, 'Redstone 2', None, 'preview build'),
'14915': ('10', None, 'Redstone 2', None, 'preview build'),
'14926': ('10', None, 'Redstone 2', None, 'preview build'),
'14931': ('10', None, 'Redstone 2', None, 'preview build'),
'14936': ('10', None, 'Redstone 2', None, 'preview build'),
'14942': ('10', None, 'Redstone 2', None, 'preview build'),
'14946': ('10', None, 'Redstone 2', None, 'preview build'),
'14951': ('10', None, 'Redstone 2', None, 'preview build'),
'14955': ('10', None, 'Redstone 2', None, 'preview build'),
'14959': ('10', None, 'Redstone 2', None, 'preview build'),
'14965': ('10', None, 'Redstone 2', None, 'preview build'),
'14971': ('10', None, 'Redstone 2', None, 'preview build'),
'14986': ('10', None, 'Redstone 2', None, 'preview build'),
'15002': ('10', None, 'Redstone 2', None, 'preview build'),
'15007': ('10', None, 'Redstone 2', None, 'preview build'),
'15014': ('10', None, 'Redstone 2', None, 'preview build'),
'15019': ('10', None, 'Redstone 2', None, 'preview build'),
'15025': ('10', None, 'Redstone 2', None, 'preview build'),
'15031': ('10', None, 'Redstone 2', None, 'preview build'),
'15042': ('10', None, 'Redstone 2', None, 'preview build'),
'15046': ('10', None, 'Redstone 2', None, 'preview build'),
'15048': ('10', None, 'Redstone 2', None, 'preview build'),
'15055': ('10', None, 'Redstone 2', None, 'preview build'),
'15058': ('10', None, 'Redstone 2', None, 'preview build'),
'15060': ('10', None, 'Redstone 2', None, 'preview build'),
'15061': ('10', None, 'Redstone 2', None, 'preview build'),
'15063': ('10', 'v1703', 'Redstone 2', 'Creators Update', 'unsupported'),
'16170': ('10', None, 'Redstone 3', None, 'preview build'),
'16176': ('10', None, 'Redstone 3', None, 'preview build'),
'16179': ('10', None, 'Redstone 3', None, 'preview build'),
'16184': ('10', None, 'Redstone 3', None, 'preview build'),
'16188': ('10', None, 'Redstone 3', None, 'preview build'),
'16193': ('10', None, 'Redstone 3', None, 'preview build'),
'16199': ('10', None, 'Redstone 3', None, 'preview build'),
'16212': ('10', None, 'Redstone 3', None, 'preview build'),
'16215': ('10', None, 'Redstone 3', None, 'preview build'),
'16226': ('10', None, 'Redstone 3', None, 'preview build'),
'16232': ('10', None, 'Redstone 3', None, 'preview build'),
'16237': ('10', None, 'Redstone 3', None, 'preview build'),
'16241': ('10', None, 'Redstone 3', None, 'preview build'),
'16251': ('10', None, 'Redstone 3', None, 'preview build'),
'16257': ('10', None, 'Redstone 3', None, 'preview build'),
'16273': ('10', None, 'Redstone 3', None, 'preview build'),
'16275': ('10', None, 'Redstone 3', None, 'preview build'),
'16278': ('10', None, 'Redstone 3', None, 'preview build'),
'16281': ('10', None, 'Redstone 3', None, 'preview build'),
'16288': ('10', None, 'Redstone 3', None, 'preview build'),
'16291': ('10', None, 'Redstone 3', None, 'preview build'),
'16294': ('10', None, 'Redstone 3', None, 'preview build'),
'16296': ('10', None, 'Redstone 3', None, 'preview build'),
'16299': ('10', 'v1709', 'Redstone 3', 'Fall Creators Update', 'outdated'),
'16353': ('10', None, 'Redstone 4', None, 'preview build'),
'16362': ('10', None, 'Redstone 4', None, 'preview build'),
'17004': ('10', None, 'Redstone 4', None, 'preview build'),
'17017': ('10', None, 'Redstone 4', None, 'preview build'),
'17025': ('10', None, 'Redstone 4', None, 'preview build'),
'17035': ('10', None, 'Redstone 4', None, 'preview build'),
'17040': ('10', None, 'Redstone 4', None, 'preview build'),
'17046': ('10', None, 'Redstone 4', None, 'preview build'),
'17063': ('10', None, 'Redstone 4', None, 'preview build'),
'17074': ('10', None, 'Redstone 4', None, 'preview build'),
'17083': ('10', None, 'Redstone 4', None, 'preview build'),
'17093': ('10', None, 'Redstone 4', None, 'preview build'),
'17101': ('10', None, 'Redstone 4', None, 'preview build'),
'17107': ('10', None, 'Redstone 4', None, 'preview build'),
'17110': ('10', None, 'Redstone 4', None, 'preview build'),
'17112': ('10', None, 'Redstone 4', None, 'preview build'),
'17115': ('10', None, 'Redstone 4', None, 'preview build'),
'17120': ('10', None, 'Redstone 4', None, 'preview build'),
'17123': ('10', None, 'Redstone 4', None, 'preview build'),
'17127': ('10', None, 'Redstone 4', None, 'preview build'),
'17128': ('10', None, 'Redstone 4', None, 'preview build'),
'17133': ('10', None, 'Redstone 4', None, 'preview build'),
'17134': ('10', 'v1803', 'Redstone 4', 'April 2018 Update', 'outdated'),
'17604': ('10', None, 'Redstone 5', None, 'preview build'),
'17618': ('10', None, 'Redstone 5', None, 'preview build'),
'17623': ('10', None, 'Redstone 5', None, 'preview build'),
'17627': ('10', None, 'Redstone 5', None, 'preview build'),
'17634': ('10', None, 'Redstone 5', None, 'preview build'),
'17639': ('10', None, 'Redstone 5', None, 'preview build'),
'17643': ('10', None, 'Redstone 5', None, 'preview build'),
'17650': ('10', None, 'Redstone 5', None, 'preview build'),
'17655': ('10', None, 'Redstone 5', None, 'preview build'),
'17661': ('10', None, 'Redstone 5', None, 'preview build'),
'17666': ('10', None, 'Redstone 5', None, 'preview build'),
'17677': ('10', None, 'Redstone 5', None, 'preview build'),
'17682': ('10', None, 'Redstone 5', None, 'preview build'),
'17686': ('10', None, 'Redstone 5', None, 'preview build'),
'17692': ('10', None, 'Redstone 5', None, 'preview build'),
'17704': ('10', None, 'Redstone 5', None, 'preview build'),
'17711': ('10', None, 'Redstone 5', None, 'preview build'),
'17713': ('10', None, 'Redstone 5', None, 'preview build'),
'17723': ('10', None, 'Redstone 5', None, 'preview build'),
'17728': ('10', None, 'Redstone 5', None, 'preview build'),
'17730': ('10', None, 'Redstone 5', None, 'preview build'),
'17733': ('10', None, 'Redstone 5', None, 'preview build'),
'17735': ('10', None, 'Redstone 5', None, 'preview build'),
'17738': ('10', None, 'Redstone 5', None, 'preview build'),
'17741': ('10', None, 'Redstone 5', None, 'preview build'),
'17744': ('10', None, 'Redstone 5', None, 'preview build'),
'17746': ('10', None, 'Redstone 5', None, 'preview build'),
'17751': ('10', None, 'Redstone 5', None, 'preview build'),
'17754': ('10', None, 'Redstone 5', None, 'preview build'),
'17755': ('10', None, 'Redstone 5', None, 'preview build'),
'17758': ('10', None, 'Redstone 5', None, 'preview build'),
'17760': ('10', None, 'Redstone 5', None, 'preview build'),
'17763': ('10', 'v1809', 'Redstone 5', 'October 2018 Update', None),
'18204': ('10', None, '19H1', None, 'preview build'),
'18214': ('10', None, '19H1', None, 'preview build'),
'18219': ('10', None, '19H1', None, 'preview build'),
'18234': ('10', None, '19H1', None, 'preview build'),
'18237': ('10', None, '19H1', None, 'preview build'),
'18242': ('10', None, '19H1', None, 'preview build'),
'18247': ('10', None, '19H1', None, 'preview build'),
'18252': ('10', None, '19H1', None, 'preview build'),
'18262': ('10', None, '19H1', None, 'preview build'),
'18267': ('10', None, '19H1', None, 'preview build'),
'18272': ('10', None, '19H1', None, 'preview build'),
'18277': ('10', None, '19H1', None, 'preview build'),
'18282': ('10', None, '19H1', None, 'preview build'),
'18290': ('10', None, '19H1', None, 'preview build'),
'18298': ('10', None, '19H1', None, 'preview build'),
'18305': ('10', None, '19H1', None, 'preview build'),
'18309': ('10', None, '19H1', None, 'preview build'),
'18312': ('10', None, '19H1', None, 'preview build'),
'18317': ('10', None, '19H1', None, 'preview build'),
'18323': ('10', None, '19H1', None, 'preview build'),
'18329': ('10', None, '19H1', None, 'preview build'),
'18334': ('10', None, '19H1', None, 'preview build'),
'18342': ('10', None, '19H1', None, 'preview build'),
'18343': ('10', None, '19H1', None, 'preview build'),
'18346': ('10', None, '19H1', None, 'preview build'),
'18348': ('10', None, '19H1', None, 'preview build'),
'18351': ('10', None, '19H1', None, 'preview build'),
'18353': ('10', None, '19H1', None, 'preview build'),
'18356': ('10', None, '19H1', None, 'preview build'),
'18358': ('10', None, '19H1', None, 'preview build'),
'18361': ('10', None, '19H1', None, 'preview build'),
'18362': ('10', 'v1903', '19H1', 'May 2019 Update', None),
'18363': ('10', 'v1909', '19H2', 'November 2019 Update', None),
'18836': ('10', None, '20H1', None, 'preview build'),
'18841': ('10', None, '20H1', None, 'preview build'),
'18845': ('10', None, '20H1', None, 'preview build'),
'18850': ('10', None, '20H1', None, 'preview build'),
'18855': ('10', None, '20H1', None, 'preview build'),
'18860': ('10', None, '20H1', None, 'preview build'),
'18865': ('10', None, '20H1', None, 'preview build'),
'18875': ('10', None, '20H1', None, 'preview build'),
'18885': ('10', None, '20H1', None, 'preview build'),
'18890': ('10', None, '20H1', None, 'preview build'),
'18894': ('10', None, '20H1', None, 'preview build'),
'18895': ('10', None, '20H1', None, 'preview build'),
'18898': ('10', None, '20H1', None, 'preview build'),
'18908': ('10', None, '20H1', None, 'preview build'),
'18912': ('10', None, '20H1', None, 'preview build'),
'18917': ('10', None, '20H1', None, 'preview build'),
'18922': ('10', None, '20H1', None, 'preview build'),
'18932': ('10', None, '20H1', None, 'preview build'),
'18936': ('10', None, '20H1', None, 'preview build'),
'18941': ('10', None, '20H1', None, 'preview build'),
'18945': ('10', None, '20H1', None, 'preview build'),
'18950': ('10', None, '20H1', None, 'preview build'),
'18956': ('10', None, '20H1', None, 'preview build'),
'18963': ('10', None, '20H1', None, 'preview build'),
'18965': ('10', None, '20H1', None, 'preview build'),
'18970': ('10', None, '20H1', None, 'preview build'),
'18975': ('10', None, '20H1', None, 'preview build'),
'18980': ('10', None, '20H1', None, 'preview build'),
'18985': ('10', None, '20H1', None, 'preview build'),
'18990': ('10', None, '20H1', None, 'preview build'),
'18995': ('10', None, '20H1', None, 'preview build'),
'18999': ('10', None, '20H1', None, 'preview build'),
'19002': ('10', None, '20H1', None, 'preview build'),
'19008': ('10', None, '20H1', None, 'preview build'),
'19013': ('10', None, '20H1', None, 'preview build'),
'19018': ('10', None, '20H1', None, 'preview build'),
'19023': ('10', None, '20H1', None, 'preview build'),
'19025': ('10', None, '20H1', None, 'preview build'),
'19028': ('10', None, '20H1', None, 'preview build'),
'19030': ('10', None, '20H1', None, 'preview build'),
'19033': ('10', None, '20H1', None, 'preview build'),
'19035': ('10', None, '20H1', None, 'preview build'),
'19037': ('10', None, '20H1', None, 'preview build'),
'19041': ('10', 'v2004', '20H1', 'May 2020 Update', None),
'19042': ('10', 'v20H2', '20H2', 'October 2020 Update', None),
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")

39
scripts/wk.prev/settings/windows_setup.py
View file

@ -1,39 +0,0 @@
# Wizard Kit: Settings - Windows Setup
# General
WINDOWS_VERSIONS = [
{'Name': 'Windows 7 Home Basic',
'Image File': 'Win7',
'Image Name': 'Windows 7 HOMEBASIC'},
{'Name': 'Windows 7 Home Premium',
'Image File': 'Win7',
'Image Name': 'Windows 7 HOMEPREMIUM'},
{'Name': 'Windows 7 Professional',
'Image File': 'Win7',
'Image Name': 'Windows 7 PROFESSIONAL'},
{'Name': 'Windows 7 Ultimate',
'Image File': 'Win7',
'Image Name': 'Windows 7 ULTIMATE'},
{'Name': 'Windows 8.1',
'Image File': 'Win8',
'Image Name': 'Windows 8.1',
'CRLF': True},
{'Name': 'Windows 8.1 Pro',
'Image File': 'Win8',
'Image Name': 'Windows 8.1 Pro'},
{'Name': 'Windows 10 Home',
'Image File': 'Win10',
'Image Name': 'Windows 10 Home',
'CRLF': True},
{'Name': 'Windows 10 Pro',
'Image File': 'Win10',
'Image Name': 'Windows 10 Pro'},
]
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

57
scripts/wk.prev/settings/winpe.py
View file

@ -1,57 +0,0 @@
# Wizard Kit: Settings - WinPE
from settings.data import *
# FastCopy
FAST_COPY_PE_ARGS = [
'/cmd=noexist_only',
'/utf8',
'/skip_empty_dir',
'/linkdest',
'/no_ui',
'/auto_close',
'/exclude={}'.format(';'.join(FAST_COPY_EXCLUDES)),
]
# General
PE_TOOLS = {
'BlueScreenView': {
'Path': r'BlueScreenView\BlueScreenView.exe',
},
'FastCopy': {
'Path': r'FastCopy\FastCopy.exe',
'Args': FAST_COPY_PE_ARGS,
},
'HWiNFO': {
'Path': r'HWiNFO\HWiNFO.exe',
},
'NT Password Editor': {
'Path': r'NT Password Editor\ntpwedit.exe',
},
'Notepad++': {
'Path': r'NotepadPlusPlus\NotepadPlusPlus.exe',
},
'PhotoRec': {
'Path': r'TestDisk\photorec_win.exe',
'Args': ['-new_console:n'],
},
'Prime95': {
'Path': r'Prime95\prime95.exe',
},
'ProduKey': {
'Path': r'ProduKey\ProduKey.exe',
},
'Q-Dir': {
'Path': r'Q-Dir\Q-Dir.exe',
},
'TestDisk': {
'Path': r'TestDisk\testdisk_win.exe',
'Args': ['-new_console:n'],
},
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

4
scripts/wk/cfg/__init__.py
View file

@ -2,9 +2,13 @@
from . import ddrescue
from . import hw
from . import launchers
from . import log
from . import main
from . import music
from . import net
from . import repairs
from . import setup
from . import sources
from . import ufd
from . import windows_builds

254
scripts/wk/cfg/launchers.py Normal file
View file

@ -0,0 +1,254 @@
"""WizardKit: Config - Launchers (Windows)"""
# pylint: disable=line-too-long
# vim: sts=2 sw=2 ts=2
LAUNCHERS = {
r'': { # Root Dir
'Auto Repairs': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'auto_repairs.py',
'L_ELEV': 'True',
},
'Auto Setup': {
'L_TYPE': 'PyScript',
'L_PATH': 'Scripts',
'L_ITEM': 'auto_setup.py',
'L_ELEV': 'True',
},
},
r'Data Recovery': {
'PhotoRec (CLI)': {
'L_TYPE': 'Executable',
'L_PATH': 'TestDisk',
'L_ITEM': 'photorec_win.exe',
'L_ELEV': 'True',
'L__CLI': 'True',
},
'PhotoRec': {
'L_TYPE': 'Executable',
'L_PATH': 'TestDisk',
'L_ITEM': 'qphotorec_win.exe',
'L_ELEV': 'True',
},
'TestDisk': {
'L_TYPE': 'Executable',
'L_PATH': 'TestDisk',
'L_ITEM': 'testdisk_win.exe',
'L_ELEV': 'True',
'L__CLI': 'True',
},
},
r'Data Transfers': {
'FastCopy (as ADMIN)': {
'L_TYPE': 'Executable',
'L_PATH': 'FastCopy',
'L_ITEM': 'FastCopy.exe',
'L_ARGS': (
r' /logfile=%log_dir%\Tools\FastCopy.log'
r' /cmd=noexist_only'
r' /utf8'
r' /skip_empty_dir'
r' /linkdest'
r' /exclude='
r'$RECYCLE.BIN;'
r'$Recycle.Bin;'
r'.AppleDB;'
r'.AppleDesktop;'
r'.AppleDouble;'
r'.com.apple.timemachine.supported;'
r'.dbfseventsd;'
r'.DocumentRevisions-V100*;'
r'.DS_Store;'
r'.fseventsd;'
r'.PKInstallSandboxManager;'
r'.Spotlight*;'
r'.SymAV*;'
r'.symSchedScanLockxz;'
r'.TemporaryItems;'
r'.Trash*;'
r'.vol;'
r'.VolumeIcon.icns;'
r'desktop.ini;'
r'Desktop?DB;'
r'Desktop?DF;'
r'hiberfil.sys;'
r'lost+found;'
r'Network?Trash?Folder;'
r'pagefile.sys;'
r'Recycled;'
r'RECYCLER;'
r'System?Volume?Information;'
r'Temporary?Items;'
r'Thumbs.db'
r' /to=%client_dir%\Transfer_%iso_date%\ '
),
'L_ELEV': 'True',
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Logs /Transfer',
],
},
'FastCopy': {
'L_TYPE': 'Executable',
'L_PATH': 'FastCopy',
'L_ITEM': 'FastCopy.exe',
'L_ARGS': (
r' /logfile=%log_dir%\Tools\FastCopy.log'
r' /cmd=noexist_only'
r' /utf8'
r' /skip_empty_dir'
r' /linkdest'
r' /exclude='
r'$RECYCLE.BIN;'
r'$Recycle.Bin;'
r'.AppleDB;'
r'.AppleDesktop;'
r'.AppleDouble;'
r'.com.apple.timemachine.supported;'
r'.dbfseventsd;'
r'.DocumentRevisions-V100*;'
r'.DS_Store;'
r'.fseventsd;'
r'.PKInstallSandboxManager;'
r'.Spotlight*;'
r'.SymAV*;'
r'.symSchedScanLockxz;'
r'.TemporaryItems;'
r'.Trash*;'
r'.vol;'
r'.VolumeIcon.icns;'
r'desktop.ini;'
r'Desktop?DB;'
r'Desktop?DF;'
r'hiberfil.sys;'
r'lost+found;'
r'Network?Trash?Folder;'
r'pagefile.sys;'
r'Recycled;'
r'RECYCLER;'
r'System?Volume?Information;'
r'Temporary?Items;'
r'Thumbs.db'
r' /to=%client_dir%\Transfer_%iso_date%\ '
),
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Logs /Transfer',
],
},
},
r'Diagnostics': {
'AIDA64': {
'L_TYPE': 'Executable',
'L_PATH': 'AIDA64',
'L_ITEM': 'aida64.exe',
},
'Autoruns (with VirusTotal Scan)': {
'L_TYPE': 'Executable',
'L_PATH': 'Sysinternals',
'L_ITEM': 'Autoruns.exe',
'L_ARGS': '-e',
'Extra Code': [
r'reg add HKCU\Software\Sysinternals\AutoRuns /v checkvirustotal /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownomicrosoft /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v shownowindows /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v showonlyvirustotal /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v submitvirustotal /t REG_DWORD /d 0 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns /v verifysignatures /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns\SigCheck /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns\Streams /v EulaAccepted /t REG_DWORD /d 1 /f >nul',
r'reg add HKCU\Software\Sysinternals\AutoRuns\VirusTotal /v VirusTotalTermsAccepted /t REG_DWORD /d 1 /f >nul',
],
},
'BleachBit': {
'L_TYPE': 'Executable',
'L_PATH': 'BleachBit',
'L_ITEM': 'bleachbit.exe',
},
'BlueScreenView': {
'L_TYPE': 'Executable',
'L_PATH': 'BlueScreenView',
'L_ITEM': 'BlueScreenView.exe',
},
'ERUNT': {
'L_TYPE': 'Executable',
'L_PATH': 'erunt',
'L_ITEM': 'ERUNT.EXE',
'L_ARGS': r'%client_dir%\Backups\Registry\%iso_date% sysreg curuser otherusers',
'L_ELEV': 'True',
'Extra Code': [
r'call "%bin%\Scripts\init_client_dir.cmd" /Logs',
],
},
'HWiNFO': {
'L_TYPE': 'Executable',
'L_PATH': 'HWiNFO',
'L_ITEM': 'HWiNFO.exe',
'Extra Code': [
r'for %%a in (32 64) do (',
r' copy /y "%bin%\HWiNFO\general.ini" "%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SensorsOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r' (echo SummaryOnly=0)>>"%bin%\HWiNFO\HWiNFO%%a.ini"',
r')',
],
},
'Snappy Driver Installer Origin': {
'L_TYPE': 'Executable',
'L_PATH': 'SDIO',
'L_ITEM': 'SDIO.exe',
},
},
r'Misc': {
'ConEmu (as ADMIN)': {
'L_TYPE': 'Executable',
'L_PATH': 'ConEmu',
'L_ITEM': 'ConEmu.exe',
'L_ELEV': 'True',
},
'ConEmu': {
'L_TYPE': 'Executable',
'L_PATH': 'ConEmu',
'L_ITEM': 'ConEmu.exe',
},
'Everything': {
'L_TYPE': 'Executable',
'L_PATH': 'Everything',
'L_ITEM': 'Everything.exe',
'L_ARGS': '-nodb',
'L_ELEV': 'True',
},
'Notepad++': {
'L_TYPE': 'Executable',
'L_PATH': 'notepadplusplus',
'L_ITEM': 'notepadplusplus.exe',
},
'PuTTY': {
'L_TYPE': 'Executable',
'L_PATH': 'PuTTY',
'L_ITEM': 'PUTTY.EXE',
},
'WizTree': {
'L_TYPE': 'Executable',
'L_PATH': 'WizTree',
'L_ITEM': 'WizTree.exe',
'L_ELEV': 'True',
},
'XMPlay': {
'L_TYPE': 'Executable',
'L_PATH': 'XMPlay',
'L_ITEM': 'xmplay.exe',
'L_ARGS': r'"%bin%\XMPlay\music.7z"',
},
},
r'Uninstallers': {
'IObit Uninstaller': {
'L_TYPE': 'Executable',
'L_PATH': 'IObitUninstallerPortable',
'L_ITEM': 'IObitUninstallerPortable.exe',
},
},
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")

76
scripts/wk/cfg/music.py Normal file
View file

@ -0,0 +1,76 @@
"""WizardKit: Config - Music Sources"""
# vim: sts=2 sw=2 ts=2
MUSIC_MOD = (
('33432', 'ambrozia.xm'),
('33460', 'amigatre.mod'),
('34594', 'CHARIOT.S3M'),
('34596', 'BUTTERFL.XM'),
('34654', 'CTGOBLIN.S3M'),
('35151', 'bananasplit.mod'),
('35280', 'DEADLOCK.XM'),
('38591', 'compo_liam.xm'),
('39987', 'crystald.s3m'),
('40475', 'ELYSIUM.MOD'),
('42146', 'enigma.mod'),
('42519', 'GHOST2.MOD'),
('42560', 'GSLINGER.MOD'),
('42872', 'existing.xm'),
('50427', 'nf-stven.xm'),
('51549', 'overture.mod'),
('54250', 'SATELL.S3M'),
('54313', 'realmk.s3m'),
('55789', 'scrambld.mod'),
('57934', 'spacedeb.mod'),
('59344', 'stardstm.mod'),
('60395', '2ND_PM.S3M'),
('66187', 'external.xm'),
('66343', 'beek-substitutionology.it'),
('67561', 'radix-unreal_superhero.xm'),
('70829', 'inside_out.s3m'),
('83779', 'beyond_music.mod'),
('104208', 'banana_boat.mod'),
('114971', 'tilbury_fair.mod'),
('132563', 'ufo_tune.mod'),
('135906', 'magnetik_girl.xm'),
('140628', 'autumn_in_budapest.xm'),
('143198', 'summer_memories_3.xm'),
('144405', 'hillbilly_billyboy.xm'),
('154795', '4mat_-_eternity.xm'),
('155845', 'bookworm.mo3'),
('155914', 'battleofsteel.xm'),
('158975', '1_channel_moog.it'),
('165495', 'trans.s3m'),
('168513', 'necros_-_introspection.s3m'),
('169628', 'radix_-_feng_shui_schematics.xm'),
('175238', 'unknown48_-_twilight.mod'),
)
MUSIC_SNES = (
'actr',
'crock',
'ct',
'dkc',
'dkq',
'ff6',
'fz',
'loz3',
'mmx',
'ptws',
'scv4',
'sf',
'sf2',
'sgng',
'smk',
'smw',
'yi',
'zamn',
)
MUSIC_SNES_BAD = {
'ct': ['ct-s*', 'ct-v*'],
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")
# vim: sts=2 sw=2 ts=2

93
scripts/wk/cfg/repairs.py Normal file
View file

@ -0,0 +1,93 @@
"""WizardKit: Config - Repairs"""
# vim: sts=2 sw=2 ts=2
from wk.cfg.main import KIT_NAME_FULL
AUTO_REPAIR_DELAY_IN_SECONDS = 30
AUTO_REPAIR_KEY = fr'Software\{KIT_NAME_FULL}\Auto Repairs'
BLEACH_BIT_CLEANERS = (
# Applications
'adobe_reader.cache',
'adobe_reader.tmp',
'amule.temp',
'discord.cache',
'flash.cache',
'gimp.tmp',
'google_earth.temporary_files',
'gpodder.cache',
'hippo_opensim_viewer.cache',
'java.cache',
'miro.cache',
'openofficeorg.cache',
'pidgin.cache',
'seamonkey.cache',
'secondlife_viewer.Cache',
'silverlight.temp',
'slack.cache',
'smartftp.cache',
'thunderbird.cache',
'vuze.cache',
'vuze.temp',
'windows_media_player.cache',
'winrar.temp',
'yahoo_messenger.cache',
'zoom.cache',
# Browsers
'brave.cache',
'brave.session',
'chromium.cache',
'chromium.search_engines',
'chromium.session',
'firefox.cache',
'firefox.session_restore',
'google_chrome.cache',
'google_chrome.session',
'internet_explorer.cache',
'microsoft_edge.cache',
'microsoft_edge.session',
'opera.cache',
'opera.session',
'palemoon.cache',
'palemoon.session_restore',
'safari.cache',
'waterfox.cache',
'waterfox.session_restore',
# System
'system.clipboard',
'system.tmp',
'windows_defender.temp',
'windows_explorer.run',
'windows_explorer.thumbnails',
)
POWER_PLANS = {
'Balanced': '381b4222-f694-41f0-9685-ff5bb260df2e',
'Custom': '01189998-8199-9119-725c-ccccccccccc3',
'High Performance': '8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c',
}
REG_UAC_DEFAULTS_WIN7 = {
'HKLM': {
r'Software\Microsoft\Windows\CurrentVersion\Policies\System': (
('ConsentPromptBehaviorAdmin', 5, 'DWORD'),
('EnableLUA', 1, 'DWORD'),
('PromptOnSecureDesktop', 1, 'DWORD'),
),
},
}
REG_UAC_DEFAULTS_WIN10 = {
'HKLM': {
r'Software\Microsoft\Windows\CurrentVersion\Policies\System': (
('ConsentPromptBehaviorAdmin', 5, 'DWORD'),
('ConsentPromptBehaviorUser', 3, 'DWORD'),
('EnableInstallerDetection', 1, 'DWORD'),
('EnableLUA', 1, 'DWORD'),
('EnableVirtualization', 1, 'DWORD'),
('PromptOnSecureDesktop', 1, 'DWORD'),
),
},
}
WIDTH = 50
if __name__ == '__main__':
print("This file is not meant to be called directly.")

148
scripts/wk/cfg/setup.py Normal file
View file

@ -0,0 +1,148 @@
"""WizardKit: Config - Setup"""
# pylint: disable=line-too-long
# vim: sts=2 sw=2 ts=2
BROWSER_PATHS = {
# Relative to PROGRAMFILES_64, PROGRAMFILES_32, LOCALAPPDATA (in that order)
'Google Chrome': 'Google/Chrome/Application/chrome.exe',
'Mozilla Firefox': 'Mozilla Firefox/firefox.exe',
'Microsoft Edge': 'Microsoft/Edge/Application/msedge.exe',
'Opera': 'Opera/launcher.exe',
}
LIBREOFFICE_XCU_DATA = '''<?xml version="1.0" encoding="UTF-8"?>
<oor:items xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http
<item oor:path="/org.openoffice.Setup/Office/Factories/org.openoffice.Setup:Factory['com.sun.star.presentation.Present
<item oor:path="/org.openoffice.Setup/Office/Factories/org.openoffice.Setup:Factory['com.sun.star.sheet.SpreadsheetDoc
<item oor:path="/org.openoffice.Setup/Office/Factories/org.openoffice.Setup:Factory['com.sun.star.text.TextDocument']"
<item oor:path="/org.openoffice.Office.Common/Save/Document"><prop oor:name="WarnAlienFormat" oor:op="fuse"><value>fal
</oor:items>
'''
REG_CHROME_UBLOCK_ORIGIN = {
'HKLM': {
r'Software\Google\Chrome\Extensions\cjpalhdlnbpafiamejdnhcphjbkeiagm': (
('update_url', 'https://clients2.google.com/service/update2/crx', 'SZ', '32'),
)
},
}
REG_ESET_NOD32_SETTINGS = {
'HKCU': {
r'Software\ESET\ESET Security\CurrentVersion\gui\UI_CONFIG': (
('FullScreenMode', 0, 'DWORD'),
('ShowAlertStatus', 0x40000000, 'DWORD'),
('ShowDesktopAlert', 0, 'DWORD'),
('ShowSplash', 0, 'DWORD'),
),
},
'HKLM': {
r'Software\ESET\ESET Security\CurrentVersion\Config\Settings\LiveGrid': (
('LiveGridFeedbackEnabled', 1, 'DWORD'),
),
},
}
REG_WINDOWS_EXPLORER = {
# pylint: disable=line-too-long
'HKLM': {
# Disable Location Tracking
r'Software\Microsoft\Windows NT\CurrentVersion\Sensor\Overrides\{BFA794E4-F964-4FDB-90F6-51056BFE4B44}': (
('SensorPermissionState', 0, 'DWORD'),
),
r'System\CurrentControlSet\Services\lfsvc\Service\Configuration': (
('Status', 0, 'DWORD'),
),
# Disable Telemetry
r'Software\Microsoft\Windows\CurrentVersion\Policies\DataCollection': (
('AllowTelemetry', 0, 'DWORD'),
('AllowTelemetry', 0, 'DWORD', '32'),
),
r'Software\Policies\Microsoft\Windows\DataCollection': (
('AllowTelemetry', 0, 'DWORD'),
),
# Disable Wi-Fi Sense
r'Software\Microsoft\PolicyManager\default\WiFi\AllowWiFiHotSpotReporting': (
('Value', 0, 'DWORD'),
),
r'Software\Microsoft\PolicyManager\default\WiFi\AllowAutoConnectToWiFiSenseHotspots': (
('Value', 0, 'DWORD'),
),
},
'HKCU': {
# Desktop theme (<= v1809 default)
r'Software\Microsoft\Windows\CurrentVersion\Themes\Personalize': (
('AppsUseLightTheme', 1, 'DWORD'),
('SystemUsesLightTheme', 0, 'DWORD'),
),
# Disable features
r'Software\Microsoft\Windows\CurrentVersion\ContentDeliveryManager': (
('SilentInstalledAppsEnabled', 0, 'DWORD'),
# Tips and Tricks
('SoftLandingEnabled ', 0, 'DWORD'),
('SubscribedContent-338389Enabled', 0, 'DWORD'),
),
# Disable news and interests from opening on hover
r'Software\Microsoft\Windows\CurrentVersion\Feeds': (
('ShellFeedsTaskbarOpenOnHover', 0, 'DWORD'),
),
# File Explorer
r'Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced': (
# Change default Explorer view to "Computer"
('LaunchTo', 1, 'DWORD'),
('SeparateProcess', 1, 'DWORD'),
),
# Hide People bar
r'Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced\People': (
('PeopleBand', 0, 'DWORD'),
),
# Hide Search button / box
r'Software\Microsoft\Windows\CurrentVersion\Search': (
('SearchboxTaskbarMode', 1, 'DWORD'),
),
},
}
REG_OPEN_SHELL_SETTINGS = {
'HKCU': {
r'Software\OpenShell\StartMenu': (
('ShowedStyle2', 1, 'DWORD'),
),
r'Software\OpenShell\StartMenu\Settings': (
('MenuStyle', 'Win7', 'SZ'),
('RecentPrograms', 'Recent', 'SZ'),
('SkinW7', 'Fluent-Metro', 'SZ'),
('SkinVariationW7', '', 'SZ'),
('SkipMetro', 1, 'DWORD'),
(
'SkinOptionsW7',
[
# NOTE: Seems to need all options specified to work?
'DARK_MAIN=1', 'METRO_MAIN=0', 'LIGHT_MAIN=0', 'AUTOMODE_MAIN=0',
'DARK_SUBMENU=0', 'METRO_SUBMENU=0', 'LIGHT_SUBMENU=0', 'AUTOMODE_SUBMENU=1',
'SUBMENU_SEPARATORS=1', 'DARK_SEARCH=0', 'METRO_SEARCH=0', 'LIGHT_SEARCH=1',
'AUTOMODE_SEARCH=0', 'SEARCH_FRAME=1', 'SEARCH_COLOR=0', 'SMALL_SEARCH=0',
'MODERN_SEARCH=1', 'SEARCH_ITALICS=0', 'NONE=0', 'SEPARATOR=0',
'TWO_TONE=1', 'CLASSIC_SELECTOR=1', 'HALF_SELECTOR=0', 'CURVED_MENUSEL=1',
'CURVED_SUBMENU=0', 'SELECTOR_REVEAL=0', 'TRANSPARENT=0', 'OPAQUE_SUBMENU=1',
'OPAQUE_MENU=0', 'OPAQUE=0', 'STANDARD=1', 'SMALL_MAIN2=0',
'SMALL_ICONS=0', 'COMPACT_SUBMENU=0', 'PRESERVE_MAIN2=0', 'LESS_PADDING=0',
'EXTRA_PADDING=1', '24_PADDING=0', 'LARGE_PROGRAMS=0', 'TRANSPARENT_SHUTDOWN=0',
'OUTLINE_SHUTDOWN=0', 'BUTTON_SHUTDOWN=1', 'EXPERIMENTAL_SHUTDOWN=0', 'LARGE_FONT=0',
'CONNECTED_BORDER=1', 'FLOATING_BORDER=0', 'LARGE_SUBMENU=0', 'LARGE_LISTS=0',
'THIN_MAIN2=0', 'EXPERIMENTAL_MAIN2=1', 'USER_IMAGE=1', 'USER_OUTSIDE=0',
'SCALING_USER=1', '56=0', '64=0', 'TRANSPARENT_USER=0',
'UWP_SCROLLBAR=1', 'MODERN_SCROLLBAR=0', 'OLD_ICONS=0', 'NEW_ICONS=1',
'SMALL_ARROWS=0', 'ICON_FRAME=0', 'SEARCH_SEPARATOR=0', 'NO_PROGRAMS_BUTTON=0',
],
'MULTI_SZ',
),
),
},
}
UBLOCK_ORIGIN_URLS = {
'Google Chrome': 'https://chrome.google.com/webstore/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm',
'Microsoft Edge': 'https://microsoftedge.microsoft.com/addons/detail/ublock-origin/odfafepnkmbhccpbejgmiehpchacaeak',
'Mozilla Firefox': 'https://addons.mozilla.org/addon/ublock-origin/',
'Opera': 'https://addons.opera.com/extensions/details/ublock/',
}
if __name__ == '__main__':
print("This file is not meant to be called directly.")

138
scripts/wk/cfg/sources.py
View file

@ -1,4 +1,4 @@
"""WizardKit: Config - Tools"""
"""WizardKit: Config - Tool Sources"""
# pylint: disable=line-too-long
# vim: sts=2 sw=2 ts=2
@ -9,79 +9,69 @@ DOWNLOAD_FREQUENCY = 7
# Sources
SOURCES = {
'Adobe Reader DC': 'https://ardownload2.adobe.com/pub/adobe/reader/win/AcrobatDC/2100120145/AcroRdrDC2100120145_en_US.exe',
'AdwCleaner': 'https://downloads.malwarebytes.com/file/adwcleaner',
'AIDA64': 'https://download.aida64.com/aida64engineer633.zip',
'aria2': 'https://github.com/aria2/aria2/releases/download/release-1.35.0/aria2-1.35.0-win-32bit-build1.zip',
'Autologon32': 'http://live.sysinternals.com/Autologon.exe',
'Autologon64': 'http://live.sysinternals.com/Autologon64.exe',
'Autoruns': 'https://download.sysinternals.com/files/Autoruns.zip',
'AVRemover32': 'https://download.eset.com/com/eset/tools/installers/av_remover/latest/avremover_nt32_enu.exe',
'AVRemover64': 'https://download.eset.com/com/eset/tools/installers/av_remover/latest/avremover_nt64_enu.exe',
'BleachBit': 'https://download.bleachbit.org/BleachBit-4.2.0-portable.zip',
'BlueScreenView32': 'http://www.nirsoft.net/utils/bluescreenview.zip',
'BlueScreenView64': 'http://www.nirsoft.net/utils/bluescreenview-x64.zip',
'Caffeine': 'http://www.zhornsoftware.co.uk/caffeine/caffeine.zip',
'ClassicStartSkin': 'http://www.classicshell.net/forum/download/file.php?id=3001&sid=9a195960d98fd754867dcb63d9315335',
'Du': 'https://download.sysinternals.com/files/DU.zip',
'EmsisoftCmd32': 'https://dl.emsisoft.com/EmsisoftCommandlineScanner32.exe',
'EmsisoftCmd64': 'https://dl.emsisoft.com/EmsisoftCommandlineScanner64.exe',
'ERUNT': 'http://www.aumha.org/downloads/erunt.zip',
'ESET_NOD32_AV32': 'https://download.eset.com/com/eset/apps/home/eav/windows/latest/eav_nt32.exe',
'ESET_NOD32_AV64': 'https://download.eset.com/com/eset/apps/home/eav/windows/latest/eav_nt64.exe',
'ESET Online Scanner': 'https://download.eset.com/com/eset/tools/online_scanner/latest/esetonlinescanner_enu.exe',
'Everything32': 'https://www.voidtools.com/Everything-1.4.1.1005.x86.en-US.zip',
'Everything64': 'https://www.voidtools.com/Everything-1.4.1.1005.x64.en-US.zip',
'FastCopy': 'https://ftp.vector.co.jp/73/10/2323/FastCopy392_installer.exe',
'Fluent-Metro': 'https://github.com/bonzibudd/Fluent-Metro/releases/download/v1.5.2/Fluent-Metro_1.5.2.zip',
'FurMark': 'https://geeks3d.com/dl/get/569',
'Firefox32': 'https://download.mozilla.org/?product=firefox-latest-ssl&os=win&lang=en-US',
'Firefox64': 'https://download.mozilla.org/?product=firefox-latest-ssl&os=win64&lang=en-US',
'HitmanPro': 'https://dl.surfright.nl/HitmanPro.exe',
'HitmanPro64': 'https://dl.surfright.nl/HitmanPro_x64.exe',
'HWiNFO': 'https://files1.majorgeeks.com/c8a055180587599139f8f454712dcc618cd1740e/systeminfo/hwi_702.zip',
'Intel SSD Toolbox': r'https://downloadmirror.intel.com/28593/eng/Intel%20SSD%20Toolbox%20-%20v3.5.9.exe',
'IOBit_Uninstaller': r'https://portableapps.com/redirect/?a=IObitUninstallerPortable&s=s&d=pa&f=IObitUninstallerPortable_7.5.0.7.paf.exe',
'KVRT': 'https://devbuilds.s.kaspersky-labs.com/devbuilds/KVRT/latest/full/KVRT.exe',
'LibreOffice': 'https://download.documentfoundation.org/libreoffice/stable/7.1.2/win/x86_64/LibreOffice_7.1.2_Win_x64.msi',
'Linux Reader': 'https://www.diskinternals.com/download/Linux_Reader.exe',
'Macs Fan Control': 'https://www.crystalidea.com/downloads/macsfancontrol_setup.exe',
'MBAM': 'https://downloads.malwarebytes.com/file/mb-windows',
'NirCmd32': 'https://www.nirsoft.net/utils/nircmd.zip',
'NirCmd64': 'https://www.nirsoft.net/utils/nircmd-x64.zip',
'NotepadPlusPlus': 'https://github.com/notepad-plus-plus/notepad-plus-plus/releases/download/v7.9.5/npp.7.9.5.portable.minimalist.7z',
'OpenShell': 'https://github.com/Open-Shell/Open-Shell-Menu/releases/download/v4.4.160/OpenShellSetup_4_4_160.exe',
'Office Deployment Tool': 'https://download.microsoft.com/download/2/7/A/27AF1BE6-DD20-4CB4-B154-EBAB8A7D4A7E/officedeploymenttool_11617-33601.exe',
'ProduKey32': 'http://www.nirsoft.net/utils/produkey.zip',
'ProduKey64': 'http://www.nirsoft.net/utils/produkey-x64.zip',
'PuTTY': 'https://the.earth.li/~sgtatham/putty/latest/w32/putty.zip',
'RegDelNull': 'https://download.sysinternals.com/files/Regdelnull.zip',
'RKill': 'https://download.bleepingcomputer.com/grinler/rkill.exe',
'Samsung Magician': 'https://s3.ap-northeast-2.amazonaws.com/global.semi.static/SAMSUNG_SSD_v5_3_0_181121/CD0C7CC1BE00525FAC4675B9E502899B41D5C3909ECE3AA2FB6B74A766B2A1EA/Samsung_Magician_Installer.zip',
'SDIO Themes': 'http://snappy-driver-installer.org/downloads/SDIO_Themes.zip',
'SDIO Torrent': 'http://snappy-driver-installer.org/downloads/SDIO_Update.torrent',
'Software Bundle': 'https://ninite.com/.net4.8-7zip-chrome-edge-vlc/ninite.exe',
'ShutUp10': 'https://dl5.oo-software.com/files/ooshutup10/OOSU10.exe',
'smartmontools': 'https://1278-105252244-gh.circle-artifacts.com/0/builds/smartmontools-win32-setup-7.3-r5216.exe',
'TDSSKiller': 'https://media.kaspersky.com/utilities/VirusUtilities/EN/tdsskiller.exe',
'TestDisk': 'https://www.cgsecurity.org/testdisk-7.2-WIP.win.zip',
'VCRedist_2012_x32': 'https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x86.exe',
'VCRedist_2012_x64': 'https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x64.exe',
'VCRedist_2013_x32': 'https://aka.ms/highdpimfc2013x86enu',
'VCRedist_2013_x64': 'https://aka.ms/highdpimfc2013x64enu',
'VCRedist_2019_x32': 'https://aka.ms/vs/16/release/vc_redist.x86.exe',
'VCRedist_2019_x64': 'https://aka.ms/vs/16/release/vc_redist.x64.exe',
'wimlib32': 'https://wimlib.net/downloads/wimlib-1.13.3-windows-i686-bin.zip',
'wimlib64': 'https://wimlib.net/downloads/wimlib-1.13.3-windows-x86_64-bin.zip',
'WinAIO Repair': 'http://www.tweaking.com/files/setups/tweaking.com_windows_repair_aio.zip',
'Winapp2': 'https://github.com/MoscaDotTo/Winapp2/archive/master.zip',
'WizTree': 'https://wiztreefree.com/files/wiztree_3_39_portable.zip',
'XMPlay 7z': 'https://support.xmplay.com/files/16/xmp-7z.zip?v=800962',
'XMPlay Game': 'https://support.xmplay.com/files/12/xmp-gme.zip?v=515637',
'XMPlay RAR': 'https://support.xmplay.com/files/16/xmp-rar.zip?v=409646',
'XMPlay WAModern': 'https://support.xmplay.com/files/10/WAModern.zip?v=207099',
'XMPlay': 'https://support.xmplay.com/files/20/xmplay383.zip?v=298195',
'XYplorerFree': 'https://www.xyplorer.com/download/xyplorer_free_noinstall.zip',
# Main
'AVRemover32': 'https://download.eset.com/com/eset/tools/installers/av_remover/latest/avremover_nt32_enu.exe',
'AVRemover64': 'https://download.eset.com/com/eset/tools/installers/av_remover/latest/avremover_nt64_enu.exe',
'AdwCleaner': 'https://downloads.malwarebytes.com/file/adwcleaner',
'Autologon32': 'http://live.sysinternals.com/Autologon.exe',
'Autologon64': 'http://live.sysinternals.com/Autologon64.exe',
'ESET_NOD32_AV32': 'https://download.eset.com/com/eset/apps/home/eav/windows/latest/eav_nt32.exe',
'ESET_NOD32_AV64': 'https://download.eset.com/com/eset/apps/home/eav/windows/latest/eav_nt64.exe',
'EmsisoftCmd32': 'https://dl.emsisoft.com/EmsisoftCommandlineScanner32.exe',
'EmsisoftCmd64': 'https://dl.emsisoft.com/EmsisoftCommandlineScanner64.exe',
'Firefox32': 'https://download.mozilla.org/?product=firefox-latest-ssl&os=win&lang=en-US',
'Firefox64': 'https://download.mozilla.org/?product=firefox-latest-ssl&os=win64&lang=en-US',
'Fluent-Metro': 'https://github.com/bonzibudd/Fluent-Metro/releases/download/v1.5.2/Fluent-Metro_1.5.2.zip',
'HitmanPro32': 'https://dl.surfright.nl/HitmanPro.exe',
'HitmanPro64': 'https://dl.surfright.nl/HitmanPro_x64.exe',
'KVRT': 'https://devbuilds.s.kaspersky-labs.com/devbuilds/KVRT/latest/full/KVRT.exe',
'MBAM': 'https://downloads.malwarebytes.com/file/mb-windows',
'OpenShell': 'https://github.com/Open-Shell/Open-Shell-Menu/releases/download/v4.4.160/OpenShellSetup_4_4_160.exe',
'RKill': 'https://download.bleepingcomputer.com/grinler/rkill.exe',
'RegDelNull': 'https://live.sysinternals.com/RegDelNull.exe',
'RegDelNull64': 'https://live.sysinternals.com/RegDelNull64.exe',
'Software Bundle': 'https://ninite.com/.net4.8-7zip-chrome-edge-vlc/ninite.exe',
'TDSSKiller': 'https://media.kaspersky.com/utilities/VirusUtilities/EN/tdsskiller.exe',
'VCRedist_2012_x32': 'https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x86.exe',
'VCRedist_2012_x64': 'https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x64.exe',
'VCRedist_2013_x32': 'https://aka.ms/highdpimfc2013x86enu',
'VCRedist_2013_x64': 'https://aka.ms/highdpimfc2013x64enu',
'VCRedist_2019_x32': 'https://aka.ms/vs/16/release/vc_redist.x86.exe',
'VCRedist_2019_x64': 'https://aka.ms/vs/16/release/vc_redist.x64.exe',
# Build Kit
'AIDA64': 'https://download.aida64.com/aida64engineer633.zip',
'Adobe Reader DC': 'https://ardownload2.adobe.com/pub/adobe/reader/win/AcrobatDC/2100720091/AcroRdrDC2100720091_en_US.exe',
'Aria2': 'https://github.com/aria2/aria2/releases/download/release-1.36.0/aria2-1.36.0-win-32bit-build1.zip',
'Autoruns32': 'http://live.sysinternals.com/Autoruns.exe',
'Autoruns64': 'http://live.sysinternals.com/Autoruns64.exe',
'BleachBit': 'https://download.bleachbit.org/BleachBit-4.4.0-portable.zip',
'BlueScreenView32': 'http://www.nirsoft.net/utils/bluescreenview.zip',
'BlueScreenView64': 'http://www.nirsoft.net/utils/bluescreenview-x64.zip',
'ERUNT': 'http://www.aumha.org/downloads/erunt.zip',
'Everything32': 'https://www.voidtools.com/Everything-1.4.1.1009.x86.en-US.zip',
'Everything64': 'https://www.voidtools.com/Everything-1.4.1.1009.x64.en-US.zip',
'FastCopy': 'https://ftp.vector.co.jp/73/10/2323/FastCopy392_installer.exe',
'FurMark': 'https://geeks3d.com/dl/get/569',
'HWiNFO': 'https://www.sac.sk/download/utildiag/hwi_712.zip',
'IOBit Uninstaller': 'https://portableapps.com/redirect/?a=IObitUninstallerPortable&s=s&d=pa&f=IObitUninstallerPortable_7.5.0.7.paf.exe',
'LibreOffice32': 'https://download.documentfoundation.org/libreoffice/stable/7.2.1/win/x86/LibreOffice_7.2.1_Win_x86.msi',
'LibreOffice64': 'https://download.documentfoundation.org/libreoffice/stable/7.2.1/win/x86_64/LibreOffice_7.2.1_Win_x64.msi',
'Linux Reader': 'https://www.diskinternals.com/download/Linux_Reader.exe',
'Macs Fan Control': 'https://www.crystalidea.com/downloads/macsfancontrol_setup.exe',
'Neutron': 'http://keir.net/download/neutron.zip',
'Notepad++': 'https://github.com/notepad-plus-plus/notepad-plus-plus/releases/download/v8.1.5/npp.8.1.5.portable.minimalist.7z',
'PuTTY': 'https://the.earth.li/~sgtatham/putty/latest/w32/putty.zip',
'SDIO Torrent': 'http://snappy-driver-installer.org/downloads/SDIO_Update.torrent',
'ShutUp10': 'https://dl5.oo-software.com/files/ooshutup10/OOSU10.exe',
'TestDisk': 'https://www.cgsecurity.org/testdisk-7.2-WIP.win.zip',
'WinAIO Repair': 'http://www.tweaking.com/files/setups/tweaking.com_windows_repair_aio.zip',
'WizTree': 'https://wiztreefree.com/files/wiztree_3_39_portable.zip',
'XMPlay': 'https://support.xmplay.com/files/20/xmplay385.zip?v=47090',
'XMPlay 7z': 'https://support.xmplay.com/files/16/xmp-7z.zip?v=800962',
'XMPlay Game': 'https://support.xmplay.com/files/12/xmp-gme.zip?v=515637',
'XMPlay RAR': 'https://support.xmplay.com/files/16/xmp-rar.zip?v=409646',
'XMPlay Innocuous': 'https://support.xmplay.com/files/10/Innocuous%20(v1.4).zip?v=594785',
}

11
scripts/wk/io.py
View file

@ -61,6 +61,17 @@ def case_insensitive_search(path, item):
return real_path
def copy_file(source, dest, overwrite=False):
"""Copy file and optionally overwrite the destination."""
source = case_insensitive_path(source)
dest = pathlib.Path(dest).resolve()
if dest.exists():
if not overwrite:
raise FileExistsError(f'Refusing to delete file: {dest}')
os.remove(dest)
shutil.copy2(source, dest)
def delete_empty_folders(path):
"""Recursively delete all empty folders in path."""
LOG.debug('path: %s', path)

3
scripts/wk/kit/__init__.py
View file

@ -7,3 +7,6 @@ from . import tools
if platform.system() == 'Linux':
from . import ufd
if platform.system() == 'Windows':
from . import build_win as build

518
scripts/wk/kit/build_win.py Normal file
View file

@ -0,0 +1,518 @@
"""WizardKit: Build Kit Functions (Windows)
NOTE: This script is meant to be called from within a new kit in ConEmu.
"""
# vim: sts=2 sw=2 ts=2
import logging
import os
import re
from wk.cfg.launchers import LAUNCHERS
from wk.cfg.main import ARCHIVE_PASSWORD, KIT_NAME_FULL
from wk.cfg.music import MUSIC_MOD, MUSIC_SNES, MUSIC_SNES_BAD
from wk.cfg.sources import SOURCES
from wk.exe import popen_program, run_program, wait_for_procs
from wk.io import copy_file, delete_item, recursive_copy, rename_item
from wk.kit.tools import (
download_file,
extract_archive,
find_kit_dir,
get_tool_path,
)
from wk.log import update_log_path
from wk.std import (
GenericError,
TryAndPrint,
clear_screen,
pause,
print_info,
print_success,
set_title,
sleep,
)
# STATIC VARIABLES
LOG = logging.getLogger(__name__)
BIN_DIR = find_kit_dir('.bin')
CBIN_DIR = find_kit_dir('.cbin')
INSTALLERS_DIR = BIN_DIR.parent.joinpath('Installers')
ROOT_DIR = BIN_DIR.parent
TMP_DIR = BIN_DIR.joinpath('tmp')
IN_CONEMU = 'ConEmuPID' in os.environ
LAUNCHER_TEMPLATE = BIN_DIR.joinpath('Scripts/Launcher_Template.cmd')
REGEX_SDIO_NETWORK_DRIVERS = re.compile(
r'DP_(WLAN|LAN_(Intel|Others|Realtek-NT))',
re.IGNORECASE,
)
REGEX_TORRENT_INDICES = re.compile(r'^(?P<index>\d+)\|(?P<path>.*)')
SEVEN_ZIP = get_tool_path('7-Zip', '7za')
SEVEN_ZIP_FULL = get_tool_path('7-Zip', '7z') # TODO: Replace with unrar from Pypi?
WIDTH = 50
# Functions
def compress_cbin_dirs():
"""Compress CBIN_DIR items using ARCHIVE_PASSWORD."""
current_dir = os.getcwd()
for item in CBIN_DIR.iterdir():
os.chdir(item)
cmd = [
SEVEN_ZIP,
'a', '-t7z', '-mx=9',
f'-p{ARCHIVE_PASSWORD}',
'-bso0', '-bse0', '-bsp0',
CBIN_DIR.joinpath(f'{item.name}.7z'),
'*',
]
run_program(cmd)
os.chdir(current_dir)
delete_item(item, force=True, ignore_errors=True)
def delete_from_temp(item_path):
"""Delete item from temp."""
delete_item(TMP_DIR.joinpath(item_path), force=True, ignore_errors=True)
def download_to_temp(filename, source_url):
"""Download file to temp dir, returns pathlib.Path."""
out_path = TMP_DIR.joinpath(filename)
download_file(out_path, source_url)
return out_path
def extract_to_bin(archive, folder):
"""Extract archive to folder under BIN_DIR."""
out_path = BIN_DIR.joinpath(folder)
extract_archive(archive, out_path)
def generate_launcher(section, name, options):
"""Generate launcher script."""
dest = ROOT_DIR.joinpath(f'{section+"/" if section else ""}{name}.cmd')
out_text = []
to_update = {}
# Build list of updates
for key, value in options.items():
if key == 'Extra Code':
to_update['rem EXTRA_CODE'] = '\n'.join(value)
elif key.startswith('L_'):
to_update[f'set {key}='] = f'set {key}={value}'
# Build launcher script
for line in LAUNCHER_TEMPLATE.read_text(encoding='utf-8').splitlines():
line = line.strip() # We'll let Python handle CRLF endings
if line in to_update:
out_text.append(to_update[line])
else:
out_text.append(line)
# Write file
dest.parent.mkdir(exist_ok=True)
dest.write_text('\n'.join(out_text), encoding='utf-8')
# Download functions
def download_adobe_reader():
"""Download Adobe Reader."""
out_path = INSTALLERS_DIR.joinpath('Adobe Reader DC.exe')
download_file(out_path, SOURCES['Adobe Reader DC'])
def download_aida64():
"""Download AIDA64."""
archive = download_to_temp('AIDA64.zip', SOURCES['AIDA64'])
extract_to_bin(archive, 'AIDA64')
delete_from_temp('AIDA64.zip')
def download_autoruns():
"""Download Autoruns."""
for item in ('Autoruns32', 'Autoruns64'):
out_path = BIN_DIR.joinpath(f'Sysinternals/{item}.exe')
download_file(out_path, SOURCES[item])
def download_bleachbit():
"""Download BleachBit."""
out_path = BIN_DIR.joinpath('BleachBit')
archive = download_to_temp('BleachBit.zip', SOURCES['BleachBit'])
extract_archive(archive, TMP_DIR)
for item in TMP_DIR.joinpath('BleachBit-Portable').iterdir():
try:
rename_item(item, out_path.joinpath(item.name))
except FileExistsError:
# Ignore and use our defaults
pass
delete_from_temp('BleachBit-Portable')
delete_from_temp('BleachBit.zip')
def download_bluescreenview():
"""Download BlueScreenView."""
archive_32 = download_to_temp(
'bluescreenview32.zip', SOURCES['BlueScreenView32'],
)
archive_64 = download_to_temp(
'bluescreenview64.zip', SOURCES['BlueScreenView64'],
)
out_path = BIN_DIR.joinpath('BlueScreenView')
extract_archive(archive_64, out_path, 'BlueScreenView.exe')
rename_item(
out_path.joinpath('BlueScreenView.exe'),
out_path.joinpath('BlueScreenView64.exe'),
)
extract_archive(archive_32, out_path)
delete_from_temp('bluescreenview32.zip')
delete_from_temp('bluescreenview64.zip')
def download_erunt():
"""Download ERUNT."""
archive = download_to_temp('erunt.zip', SOURCES['ERUNT'])
extract_to_bin(archive, 'ERUNT')
delete_from_temp('erunt.zip')
def download_everything():
"""Download Everything."""
archive_32 = download_to_temp('everything32.zip', SOURCES['Everything32'])
archive_64 = download_to_temp('everything64.zip', SOURCES['Everything64'])
out_path = BIN_DIR.joinpath('Everything')
extract_archive(archive_64, out_path, 'Everything.exe')
rename_item(
out_path.joinpath('Everything.exe'),
out_path.joinpath('Everything64.exe'),
)
extract_archive(archive_32, out_path)
delete_from_temp('everything32.zip')
delete_from_temp('everything64.zip')
def download_fastcopy():
"""Download FastCopy."""
installer = download_to_temp('FastCopyInstaller.exe', SOURCES['FastCopy'])
out_path = BIN_DIR.joinpath('FastCopy')
tmp_path = TMP_DIR.joinpath('FastCopy64')
run_program([installer, '/NOSUBDIR', f'/DIR={out_path}', '/EXTRACT32'])
run_program([installer, '/NOSUBDIR', f'/DIR={tmp_path}', '/EXTRACT64'])
rename_item(
tmp_path.joinpath('FastCopy.exe'),
out_path.joinpath('FastCopy64.exe'),
)
delete_from_temp('FastCopy64')
delete_from_temp('FastCopyInstaller.exe')
def download_furmark():
"""Download FurMark."""
installer = download_to_temp('FurMark_Setup.exe', SOURCES['FurMark'])
out_path = BIN_DIR.joinpath('FurMark')
tmp_path = TMP_DIR.joinpath('FurMarkInstall')
run_program([installer, f'/DIR={tmp_path}', '/SILENT'])
recursive_copy(f'{tmp_path}/', f'{out_path}/')
delete_from_temp('FurMark_Setup.exe')
try:
uninstaller = list(tmp_path.glob('unins*exe'))[0]
run_program([uninstaller, '/SILENT'])
except IndexError as _e:
raise GenericError('Failed to remove temporary FurMark install') from _e
delete_from_temp('FurMarkInstall')
def download_hwinfo():
"""Download HWiNFO."""
archive = download_to_temp('HWiNFO.zip', SOURCES['HWiNFO'])
extract_to_bin(archive, 'HWiNFO')
delete_from_temp('HWiNFO.zip')
def download_iobit_uninstaller():
"""Download IOBit Uninstaller."""
installer = CBIN_DIR.joinpath('IObitUninstallerPortable.exe')
download_file(installer, SOURCES['IOBit Uninstaller'])
popen_program([installer])
sleep(1)
wait_for_procs('IObitUninstallerPortable.exe')
delete_item(installer)
def download_macs_fan_control():
"""Download Macs Fan Control."""
out_path = INSTALLERS_DIR.joinpath('Macs Fan Control.exe')
download_file(out_path, SOURCES['Macs Fan Control'])
def download_libreoffice():
"""Download LibreOffice."""
for arch in 32, 64:
out_path = INSTALLERS_DIR.joinpath(f'LibreOffice{arch}.msi')
download_file(out_path, SOURCES[f'LibreOffice{arch}'])
def download_neutron():
"""Download Neutron."""
archive = download_to_temp('neutron.zip', SOURCES['Neutron'])
out_path = BIN_DIR.joinpath('Neutron')
extract_archive(archive, out_path, '-aos', mode='e')
delete_from_temp('neutron.zip')
def download_notepad_plus_plus():
"""Download Notepad++."""
archive = download_to_temp('npp.7z', SOURCES['Notepad++'])
extract_to_bin(archive, 'NotepadPlusPlus')
out_path = BIN_DIR.joinpath('NotepadPlusPlus')
rename_item(
out_path.joinpath('notepad++.exe'),
out_path.joinpath('notepadplusplus.exe'),
)
delete_from_temp('npp.7z')
def download_putty():
"""Download PuTTY."""
archive = download_to_temp('putty.zip', SOURCES['PuTTY'])
extract_to_bin(archive, 'PuTTY')
delete_from_temp('putty.zip')
def download_snappy_driver_installer_origin():
"""Download Snappy Driver Installer Origin."""
archive = download_to_temp('aria2.zip', SOURCES['Aria2'])
aria2c = TMP_DIR.joinpath('aria2/aria2c.exe')
extract_archive(archive, aria2c.parent, mode='e')
index_list = []
tmp_path = TMP_DIR.joinpath('SDIO')
out_path = BIN_DIR.joinpath('SDIO')
torrent_file = download_to_temp('SDIO.torrent', SOURCES['SDIO Torrent'])
# Build file selection list
proc = run_program([aria2c, '--show-files', torrent_file])
for line in proc.stdout.splitlines():
match = REGEX_TORRENT_INDICES.match(line.strip())
if not match:
continue
if 'drivers' not in match.group('path').lower():
index_list.append(match.group('index'))
elif REGEX_SDIO_NETWORK_DRIVERS.search(match.group('path')):
index_list.append(match.group('index'))
# Download
cmd = [
aria2c,
f'--select-file={",".join(index_list)}',
f'--dir={tmp_path}',
'--seed-time=0',
torrent_file,
]
if IN_CONEMU:
cmd.append('-new_console:n')
cmd.append('-new_console:s33V')
popen_program(cmd, cwd=aria2c.parent)
sleep(1)
wait_for_procs('aria2c.exe')
else:
run_program(cmd)
# Move into place
placeholder_archive = TMP_DIR.joinpath('fake.7z')
placeholder_archive.with_name('fake').touch()
cmd = [
SEVEN_ZIP,
'a', '-t7z', '-mx=9',
'-bso0', '-bse0', '-bsp0',
placeholder_archive,
placeholder_archive.with_name('fake'),
]
run_program(cmd)
for item in tmp_path.joinpath('SDIO_Update').iterdir():
name = item.name
if name.startswith('SDIO_') and name.endswith('.exe'):
name = f'SDIO{"64" if "64" in name else ""}.exe'
rename_item(item, out_path.joinpath(name))
# Create placeholder archives (except for network drivers)
for item in out_path.joinpath('indexes/SDI').glob('*bin'):
archive = out_path.joinpath(f'drivers/{item.stem}.7z')
if not REGEX_SDIO_NETWORK_DRIVERS.search(archive.name):
copy_file(placeholder_archive, archive, overwrite=True)
# Cleanup
delete_from_temp('SDIO')
delete_from_temp('SDIO.torrent')
delete_from_temp('aria2')
delete_from_temp('aria2.zip')
delete_from_temp('fake')
delete_from_temp('fake.7z')
def download_testdisk():
"""Download TestDisk."""
archive = download_to_temp('testdisk_wip.zip', SOURCES['TestDisk'])
out_path = BIN_DIR.joinpath('TestDisk')
tmp_path = TMP_DIR.joinpath('TestDisk')
extract_archive(archive, tmp_path)
rename_item(tmp_path.joinpath('testdisk-7.2-WIP'), out_path)
delete_from_temp('testdisk_wip.zip')
def download_wiztree():
"""Download WizTree."""
archive = download_to_temp('wiztree.zip', SOURCES['WizTree'])
extract_to_bin(archive, 'WizTree')
delete_from_temp('wiztree.zip')
def download_xmplay():
"""Download XMPlay."""
archives = [
download_to_temp('xmplay.zip', SOURCES['XMPlay']),
download_to_temp('xmp-7z.zip', SOURCES['XMPlay 7z']),
download_to_temp('xmp-gme.zip', SOURCES['XMPlay Game']),
download_to_temp('xmp-rar.zip', SOURCES['XMPlay RAR']),
download_to_temp('Innocuous.zip', SOURCES['XMPlay Innocuous']),
]
# Extract XMPlay and plugins
extract_to_bin(archives.pop(0), 'XMPlay')
for archive in archives:
args = [archive, BIN_DIR.joinpath('XMPlay/plugins')]
if archive.name == 'Innocuous.zip':
args.append(
'Innocuous (v1.4)/Innocuous (Hue Shifted)/'
'Innocuous (Dark Skies - Purple-80) [L1].xmpskin'
)
extract_archive(*args, mode='e')
# Cleanup
delete_from_temp('xmplay.zip')
delete_from_temp('xmp-7z.zip')
delete_from_temp('xmp-gme.zip')
delete_from_temp('xmp-rar.zip')
delete_from_temp('Innocuous.zip')
def download_xmplay_music():
"""Download XMPlay Music."""
music_tmp = TMP_DIR.joinpath('music')
music_tmp.mkdir(exist_ok=True)
current_dir = os.getcwd()
os.chdir(music_tmp)
url_mod = 'https://api.modarchive.org/downloads.php'
url_rsn = 'http://snesmusic.org/v2/download.php'
# Download music
for song_id, song_name in MUSIC_MOD:
download_file(
music_tmp.joinpath(f'MOD/{song_name}'),
f'{url_mod}?moduleid={song_id}#{song_name}',
)
for game in MUSIC_SNES:
download_file(
music_tmp.joinpath(f'SNES/{game}.rsn'),
f'{url_rsn}?spcNow={game}',
)
# Extract SNES archives
for item in music_tmp.joinpath('SNES').iterdir():
cmd = [
SEVEN_ZIP_FULL,
'x', item, f'-oSNES\\{item.stem}',
'-bso0', '-bse0', '-bsp0',
]
run_program(cmd)
delete_item(item)
# Remove 7-Zip (Full) from kit
delete_item(SEVEN_ZIP_FULL)
delete_item(SEVEN_ZIP_FULL.with_name('7z.dll'))
# Remove bad songs
for game, globs in MUSIC_SNES_BAD.items():
for glob in globs:
for item in music_tmp.joinpath(f'SNES/{game}').glob(glob):
delete_item(item)
# Compress music
cmd = [
SEVEN_ZIP,
'a', '-t7z', '-mx=9',
'-bso0', '-bse0', '-bsp0',
BIN_DIR.joinpath('XMPlay/music.7z'),
'MOD', 'SNES',
]
run_program(cmd)
os.chdir(current_dir)
# Cleanup
delete_from_temp('music')
# "Main" Function
def build_kit():
"""Build Kit."""
update_log_path(dest_name='Build Tool', timestamp=True)
title = f'{KIT_NAME_FULL}: Build Tool'
clear_screen()
set_title(title)
print_info(title)
print('')
# Set up TryAndPrint
try_print = TryAndPrint()
try_print.width = WIDTH
try_print.verbose = True
for error in ('CalledProcessError', 'FileNotFoundError'):
try_print.add_error(error)
# Download
try_print.run('Adobe Reader...', download_adobe_reader)
try_print.run('AIDA64...', download_aida64)
try_print.run('Autoruns...', download_autoruns)
try_print.run('BleachBit...', download_bleachbit)
try_print.run('BlueScreenView...', download_bluescreenview)
try_print.run('ERUNT...', download_erunt)
try_print.run('Everything...', download_everything)
try_print.run('FastCopy...', download_fastcopy)
try_print.run('FurMark...', download_furmark)
try_print.run('HWiNFO...', download_hwinfo)
try_print.run('IOBit Uninstaller...', download_iobit_uninstaller)
try_print.run('LibreOffice...', download_libreoffice)
try_print.run('Macs Fan Control...', download_macs_fan_control)
try_print.run('Neutron...', download_neutron)
try_print.run('Notepad++...', download_notepad_plus_plus)
try_print.run('PuTTY...', download_putty)
try_print.run('Snappy Driver Installer...', download_snappy_driver_installer_origin)
try_print.run('TestDisk...', download_testdisk)
try_print.run('WizTree...', download_wiztree)
try_print.run('XMPlay...', download_xmplay)
try_print.run('XMPlay Music...', download_xmplay_music)
# Pause
print('', flush=True)
pause('Please review and press Enter to continue...')
# Compress .cbin
try_print.run('Compress cbin...', compress_cbin_dirs)
# Generate launcher scripts
print_success('Generating launchers')
for section, launchers in sorted(LAUNCHERS.items()):
print_info(f' {section if section else "(Root)"}')
for name, options in sorted(launchers.items()):
try_print.run(
f' {name}...', generate_launcher,
section, name, options,
)
# Done
print('')
print('Done.')
pause('Press Enter to exit...')
if __name__ == '__main__':
print("This file is not meant to be called directly.")

12
scripts/wk/os/win.py
View file

@ -219,7 +219,7 @@ def get_installed_ram(as_list=False, raise_exceptions=False):
if raise_exceptions:
if RAM_OK > mem.total >= RAM_WARNING:
raise GenericWarning(mem_str)
if mem.total > RAM_WARNING:
if mem.total < RAM_WARNING:
raise GenericError(mem_str)
# Done
@ -276,6 +276,11 @@ def get_raw_disks():
json_data = get_json_from_command(cmd)
raw_disks = []
# Bail early
if not json_data:
# No RAW disks detected
return raw_disks
# Fix JSON if only one disk was detected
if isinstance(json_data, dict):
json_data = [json_data]
@ -595,7 +600,7 @@ def is_secure_boot_enabled(raise_exceptions=False, show_alert=False):
# Command completed
enabled = 'True' in proc.stdout
if 'False' in proc.stdout:
msg_error = 'ERROR'
msg_error = 'DISABLED'
else:
msg_warning = 'UNKNOWN'
@ -603,9 +608,8 @@ def is_secure_boot_enabled(raise_exceptions=False, show_alert=False):
for msg, exc in ((msg_error, GenericError), (msg_warning, GenericWarning)):
if not msg:
continue
msg = f'Secure Boot {msg}'
if show_alert:
show_alert_box(msg)
show_alert_box(f'Secure Boot {msg}')
if raise_exceptions:
raise exc(msg)
break

123
scripts/wk/repairs/win.py
View file

@ -5,7 +5,6 @@
import atexit
import logging
import os
import platform
import re
import sys
import time
@ -13,6 +12,15 @@ import time
from subprocess import CalledProcessError, DEVNULL
from wk.cfg.main import KIT_NAME_FULL, KIT_NAME_SHORT, WINDOWS_TIME_ZONE
from wk.cfg.repairs import (
AUTO_REPAIR_DELAY_IN_SECONDS,
AUTO_REPAIR_KEY,
BLEACH_BIT_CLEANERS,
POWER_PLANS,
REG_UAC_DEFAULTS_WIN7,
REG_UAC_DEFAULTS_WIN10,
WIDTH,
)
from wk.exe import (
get_procs,
run_program,
@ -26,13 +34,25 @@ from wk.io import (
rename_item,
)
from wk.kit.tools import (
ARCH,
download_tool,
extract_tool,
get_tool_path,
run_tool,
)
from wk.log import format_log_path, update_log_path
from wk.os.win import (
ARCH,
OS_VERSION,
get_timezone,
set_timezone,
reg_delete_value,
reg_read_value,
reg_set_value,
reg_write_settings,
disable_service,
enable_service,
stop_service,
)
from wk.std import (
GenericError,
GenericWarning,
@ -51,80 +71,14 @@ from wk.std import (
sleep,
strip_colors,
)
if platform.system() == 'Windows':
from wk.os.win import (
OS_VERSION,
get_timezone,
set_timezone,
reg_delete_value,
reg_read_value,
reg_set_value,
reg_write_settings,
disable_service,
enable_service,
stop_service,
)
else:
# Workaround to allow basic testing under non-Windows environments
OS_VERSION = -1
def no_op(*args, **kwargs): # pylint: disable=unused-argument
"""No-op function."""
# wk.os.win
get_timezone = no_op
set_timezone = no_op
reg_delete_value = no_op
reg_read_value = no_op
reg_set_value = no_op
reg_write_settings = no_op
disable_service = no_op
enable_service = no_op
stop_service = no_op
# STATIC VARIABLES
LOG = logging.getLogger(__name__)
AUTO_REPAIR_DELAY_IN_SECONDS = 30
AUTO_REPAIR_KEY = fr'Software\{KIT_NAME_FULL}\Auto Repairs'
BACKUP_BROWSER_BASE_CMD = (
get_tool_path('7-Zip', '7za'),
'a', '-t7z', '-mx=1', '-bso0', '-bse0', '-bsp0',
)
BLEACH_BIT_CLEANERS = (
# Applications
'adobe_reader.cache',
'adobe_reader.tmp',
'flash.cache',
'gimp.tmp',
'hippo_opensim_viewer.cache',
'java.cache',
'miro.cache',
'openofficeorg.cache',
'pidgin.cache',
'secondlife_viewer.Cache',
'thunderbird.cache',
'vuze.cache',
'yahoo_messenger.cache',
# Browsers
'chromium.cache',
'chromium.session',
'firefox.cache',
'firefox.session_restore',
'google_chrome.cache',
'google_chrome.session',
'google_earth.temporary_files',
'opera.cache',
'opera.session',
'safari.cache',
'seamonkey.cache',
# System
'system.clipboard',
'system.tmp',
'winapp2_windows.jump_lists',
'winapp2_windows.ms_search',
'windows_explorer.run',
'windows_explorer.search_history',
'windows_explorer.thumbnails',
)
CONEMU_EXE = get_tool_path('ConEmu', 'ConEmu', check=False)
GPUPDATE_SUCCESS_STRINGS = (
'Computer Policy update has completed successfully.',
@ -142,22 +96,6 @@ MBAM_UNINSTALL_KEY = (
r'Software\Microsoft\Windows\CurrentVersion\Uninstall'
r'\{35065F43-4BB2-439A-BFF7-0F1014F2E0CD}_is1'
)
OS_VERSION = float(platform.win32_ver()[0])
POWER_PLANS = {
'Balanced': '381b4222-f694-41f0-9685-ff5bb260df2e',
'Custom': '01189998-8199-9119-725c-ccccccccccc3',
'High Performance': '8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c',
}
REG_UAC_DEFAULT_SETTINGS = {
'HKLM': {
r'Software\Microsoft\Windows\CurrentVersion\Policies\System': (
('ConsentPromptBehaviorAdmin', 5, 'DWORD'),
('ConsentPromptBehaviorUser', 3, 'DWORD'),
('EnableLUA', 1, 'DWORD'),
('PromptOnSecureDesktop', 1, 'DWORD'),
),
},
}
SYSTEMDRIVE = os.environ.get('SYSTEMDRIVE', 'C:')
EMSISOFT_INSTALL_PATH = f'{SYSTEMDRIVE}/EmsisoftCmd'
WHITELIST = '\n'.join((
@ -170,7 +108,6 @@ WHITELIST = '\n'.join((
fr'{PROGRAMFILES_32}\TeamViewer\tv_x64.exe',
sys.executable,
))
WIDTH = 50
TRY_PRINT = TryAndPrint()
TRY_PRINT.width = WIDTH
TRY_PRINT.verbose = True
@ -327,8 +264,7 @@ def init_run(options):
)
if options['Sync Clock']['Selected']:
TRY_PRINT.run(
'Syncing Clock...', run_tool, 'Neutron', 'Neutron',
cbin=True, msg_good='DONE',
'Syncing Clock...', run_tool, 'Neutron', 'Neutron', msg_good='DONE',
)
if options['Run RKill']['Selected']:
TRY_PRINT.run('Running RKill...', run_rkill, msg_good='DONE')
@ -1027,13 +963,12 @@ def backup_registry():
raise GenericWarning('Backup already exists.')
# Backup registry
extract_tool('ERUNT')
run_tool('ERUNT', 'ERUNT', backup_path, 'sysreg', 'curuser', 'otherusers')
def delete_registry_null_keys():
"""Delete registry keys with embedded null characters."""
run_tool('RegDelNull', 'RegDelNull', '-s', '-y', cbin=True)
run_tool('RegDelNull', 'RegDelNull', '-s', '-y', download=True)
def fix_file_associations():
@ -1041,7 +976,7 @@ def fix_file_associations():
extract_tool('WinAIORepair')
winaio_path = get_tool_path('WinAIORepair', 'Repair_Windows').parent
winaio_path = winaio_path.joinpath(
f'Files/regfiles/file_associations/{platform.win32_ver()[0]}',
f'Files/regfiles/file_associations/{OS_VERSION}',
)
for item in winaio_path.iterdir():
if item.suffix.lower() != '.reg':
@ -1084,7 +1019,7 @@ def run_bleachbit(cleaners, preview=True):
)
log_path = format_log_path(log_name='BleachBit', timestamp=True, tool=True)
log_path.parent.mkdir(parents=True, exist_ok=True)
proc = run_tool('BleachBit', 'bleachbit_console', *cmd_args, cbin=True)
proc = run_tool('BleachBit', 'bleachbit_console', *cmd_args)
# Save logs
log_path.write_text(proc.stdout, encoding='utf-8')
@ -1488,7 +1423,11 @@ def reset_windows_updates():
def restore_uac_defaults():
"""Restore UAC default settings."""
reg_write_settings(REG_UAC_DEFAULT_SETTINGS)
settings = REG_UAC_DEFAULTS_WIN10
if OS_VERSION != 10:
settings = REG_UAC_DEFAULTS_WIN7
reg_write_settings(settings)
def run_chkdsk_offline():

5
scripts/wk/setup/__init__.py
View file

@ -3,6 +3,5 @@
import platform
#if platform.system() == 'Windows':
# from . import win
from . import win
if platform.system() == 'Windows':
from . import win

281
scripts/wk/setup/win.py
View file

@ -6,11 +6,19 @@ import configparser
import logging
import json
import os
import platform
import re
import sys
from wk.cfg.main import KIT_NAME_FULL
from wk.cfg.setup import (
BROWSER_PATHS,
REG_ESET_NOD32_SETTINGS,
LIBREOFFICE_XCU_DATA,
REG_CHROME_UBLOCK_ORIGIN,
REG_WINDOWS_EXPLORER,
REG_OPEN_SHELL_SETTINGS,
UBLOCK_ORIGIN_URLS,
)
from wk.exe import kill_procs, run_program, popen_program
from wk.io import case_insensitive_path, get_path_obj
from wk.kit.tools import (
@ -23,6 +31,32 @@ from wk.kit.tools import (
run_tool,
)
from wk.log import format_log_path, update_log_path
from wk.os.win import (
OS_VERSION,
activate_with_bios,
check_4k_alignment,
get_installed_antivirus,
get_installed_ram,
get_os_activation,
get_os_name,
get_raw_disks,
get_volume_usage,
is_activated,
is_secure_boot_enabled,
reg_set_value,
reg_write_settings,
)
from wk.repairs.win import (
WIDTH,
backup_all_browser_profiles,
backup_registry,
create_custom_power_plan,
create_system_restore_point,
enable_windows_updates,
export_power_plans,
reset_power_plans,
set_system_restore_size,
)
from wk.std import (
GenericError,
GenericWarning,
@ -42,81 +76,12 @@ from wk.std import (
sleep,
strip_colors,
)
if platform.system() == 'Windows':
from wk.os.win import (
OS_VERSION,
activate_with_bios,
check_4k_alignment,
get_installed_antivirus,
get_installed_ram,
get_os_activation,
get_os_name,
get_raw_disks,
get_volume_usage,
is_activated,
is_secure_boot_enabled,
reg_set_value,
reg_write_settings,
)
from wk.repairs.win import (
backup_all_browser_profiles,
backup_registry,
create_custom_power_plan,
create_system_restore_point,
enable_windows_updates,
export_power_plans,
reset_power_plans,
set_system_restore_size,
)
else:
# Workaround to allow basic testing under non-Windows environments
OS_VERSION = -1
def no_op(*args, **kwargs): # pylint: disable=unused-argument
"""No-op function."""
# wk.os.win
activate_with_bios = no_op
check_4k_alignment = no_op
get_installed_antivirus = no_op
get_installed_ram = no_op
get_os_activation = no_op
get_os_name = no_op
get_raw_disks = no_op
get_volume_usage = no_op
is_activated = no_op
is_secure_boot_enabled = no_op
reg_read_value = no_op
reg_set_value = no_op
reg_write_settings = no_op
# wk.repairs.win
backup_all_browser_profiles = no_op
backup_registry = no_op
create_custom_power_plan = no_op
create_system_restore_point = no_op
enable_windows_updates = no_op
export_power_plans = no_op
reset_power_plans = no_op
set_system_restore_size = no_op
# STATIC VARIABLES
LOG = logging.getLogger(__name__)
BROWSER_PATHS = {
# Relative to PROGRAMFILES_64, PROGRAMFILES_32, LOCALAPPDATA (in that order)
'Google Chrome': 'Google/Chrome/Application/chrome.exe',
'Mozilla Firefox': 'Mozilla Firefox/firefox.exe',
'Microsoft Edge': 'Microsoft/Edge/Application/msedge.exe',
'Opera': 'Opera/launcher.exe',
}
CONEMU_EXE = get_tool_path('ConEmu', 'ConEmu', check=False)
IN_CONEMU = 'ConEmuPID' in os.environ
LIBREOFFICE_XCU_DATA = '''<?xml version="1.0" encoding="UTF-8"?>
<oor:items xmlns:oor="http://openoffice.org/2001/registry" xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<item oor:path="/org.openoffice.Setup/Office/Factories/org.openoffice.Setup:Factory['com.sun.star.presentation.PresentationDocument']"><prop oor:name="ooSetupFactoryDefaultFilter" oor:op="fuse"><value>Impress MS PowerPoint 2007 XML</value></prop></item>
<item oor:path="/org.openoffice.Setup/Office/Factories/org.openoffice.Setup:Factory['com.sun.star.sheet.SpreadsheetDocument']"><prop oor:name="ooSetupFactoryDefaultFilter" oor:op="fuse"><value>Calc MS Excel 2007 XML</value></prop></item>
<item oor:path="/org.openoffice.Setup/Office/Factories/org.openoffice.Setup:Factory['com.sun.star.text.TextDocument']"><prop oor:name="ooSetupFactoryDefaultFilter" oor:op="fuse"><value>MS Word 2007 XML</value></prop></item>
<item oor:path="/org.openoffice.Office.Common/Save/Document"><prop oor:name="WarnAlienFormat" oor:op="fuse"><value>false</value></prop></item>
</oor:items>
'''
MENU_PRESETS = Menu()
PROGRAMFILES_32 = os.environ.get(
'PROGRAMFILES(X86)', os.environ.get(
@ -128,159 +93,12 @@ PROGRAMFILES_64 = os.environ.get(
'PROGRAMFILES', r'C:\Program Files',
),
)
REG_CHROME_UBLOCK_ORIGIN = {
'HKLM': {
r'Software\Google\Chrome\Extensions\cjpalhdlnbpafiamejdnhcphjbkeiagm': (
('update_url', 'https://clients2.google.com/service/update2/crx', 'SZ', '32'),
)
},
}
REG_ESET_NOD32_SETTINGS = {
'HKCU': {
r'Software\ESET\ESET Security\CurrentVersion\gui\UI_CONFIG': (
('FullScreenMode', 0, 'DWORD'),
('ShowAlertStatus', 0x40000000, 'DWORD'),
('ShowDesktopAlert', 0, 'DWORD'),
('ShowSplash', 0, 'DWORD'),
),
},
'HKLM': {
r'Software\ESET\ESET Security\CurrentVersion\Config\Settings\LiveGrid': (
('LiveGridFeedbackEnabled', 1, 'DWORD'),
),
},
}
REG_WINDOWS_EXPLORER = {
# pylint: disable=line-too-long
'HKLM': {
# Disable Location Tracking
r'Software\Microsoft\Windows NT\CurrentVersion\Sensor\Overrides\{BFA794E4-F964-4FDB-90F6-51056BFE4B44}': (
('SensorPermissionState', 0, 'DWORD'),
),
r'System\CurrentControlSet\Services\lfsvc\Service\Configuration': (
('Status', 0, 'DWORD'),
),
# Disable Telemetry
r'Software\Microsoft\Windows\CurrentVersion\Policies\DataCollection': (
('AllowTelemetry', 0, 'DWORD'),
('AllowTelemetry', 0, 'DWORD', '32'),
),
r'Software\Policies\Microsoft\Windows\DataCollection': (
('AllowTelemetry', 0, 'DWORD'),
),
# Disable Wi-Fi Sense
r'Software\Microsoft\PolicyManager\default\WiFi\AllowWiFiHotSpotReporting': (
('Value', 0, 'DWORD'),
),
r'Software\Microsoft\PolicyManager\default\WiFi\AllowAutoConnectToWiFiSenseHotspots': (
('Value', 0, 'DWORD'),
),
},
'HKCU': {
# Desktop theme (<= v1809 default)
r'Software\Microsoft\Windows\CurrentVersion\Themes\Personalize': (
('AppsUseLightTheme', 1, 'DWORD'),
('SystemUsesLightTheme', 0, 'DWORD'),
),
# Disable features
r'Software\Microsoft\Windows\CurrentVersion\ContentDeliveryManager': (
('SilentInstalledAppsEnabled', 0, 'DWORD'),
# Tips and Tricks
('SoftLandingEnabled ', 0, 'DWORD'),
('SubscribedContent-338389Enabled', 0, 'DWORD'),
),
# Disable news and interests from opening on hover
r'Software\Microsoft\Windows\CurrentVersion\Feeds': (
('ShellFeedsTaskbarOpenOnHover', 0, 'DWORD'),
),
# File Explorer
r'Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced': (
# Change default Explorer view to "Computer"
('LaunchTo', 1, 'DWORD'),
('SeparateProcess', 1, 'DWORD'),
),
# Hide People bar
r'Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced\People': (
('PeopleBand', 0, 'DWORD'),
),
# Hide Search button / box
r'Software\Microsoft\Windows\CurrentVersion\Search': (
('SearchboxTaskbarMode', 1, 'DWORD'),
),
},
}
REG_OPEN_SHELL_SETTINGS = {
'HKCU': {
r'Software\OpenShell\StartMenu': (
('ShowedStyle2', 1, 'DWORD'),
),
r'Software\OpenShell\StartMenu\Settings': (
('MenuStyle', 'Win7', 'SZ'),
('RecentPrograms', 'Recent', 'SZ'),
('SkinW7', 'Fluent-Metro', 'SZ'),
('SkinVariationW7', '', 'SZ'),
('SkipMetro', 1, 'DWORD'),
(
'SkinOptionsW7',
[
# NOTE: Seems to need all options specified to work?
'DARK_MAIN=1', 'METRO_MAIN=0', 'LIGHT_MAIN=0', 'AUTOMODE_MAIN=0',
'DARK_SUBMENU=0', 'METRO_SUBMENU=0', 'LIGHT_SUBMENU=0', 'AUTOMODE_SUBMENU=1',
'SUBMENU_SEPARATORS=1', 'DARK_SEARCH=0', 'METRO_SEARCH=0', 'LIGHT_SEARCH=1',
'AUTOMODE_SEARCH=0', 'SEARCH_FRAME=1', 'SEARCH_COLOR=0', 'SMALL_SEARCH=0',
'MODERN_SEARCH=1', 'SEARCH_ITALICS=0', 'NONE=0', 'SEPARATOR=0',
'TWO_TONE=1', 'CLASSIC_SELECTOR=1', 'HALF_SELECTOR=0', 'CURVED_MENUSEL=1',
'CURVED_SUBMENU=0', 'SELECTOR_REVEAL=0', 'TRANSPARENT=0', 'OPAQUE_SUBMENU=1',
'OPAQUE_MENU=0', 'OPAQUE=0', 'STANDARD=1', 'SMALL_MAIN2=0',
'SMALL_ICONS=0', 'COMPACT_SUBMENU=0', 'PRESERVE_MAIN2=0', 'LESS_PADDING=0',
'EXTRA_PADDING=1', '24_PADDING=0', 'LARGE_PROGRAMS=0', 'TRANSPARENT_SHUTDOWN=0',
'OUTLINE_SHUTDOWN=0', 'BUTTON_SHUTDOWN=1', 'EXPERIMENTAL_SHUTDOWN=0', 'LARGE_FONT=0',
'CONNECTED_BORDER=1', 'FLOATING_BORDER=0', 'LARGE_SUBMENU=0', 'LARGE_LISTS=0',
'THIN_MAIN2=0', 'EXPERIMENTAL_MAIN2=1', 'USER_IMAGE=1', 'USER_OUTSIDE=0',
'SCALING_USER=1', '56=0', '64=0', 'TRANSPARENT_USER=0',
'UWP_SCROLLBAR=1', 'MODERN_SCROLLBAR=0', 'OLD_ICONS=0', 'NEW_ICONS=1',
'SMALL_ARROWS=0', 'ICON_FRAME=0', 'SEARCH_SEPARATOR=0', 'NO_PROGRAMS_BUTTON=0',
],
'MULTI_SZ',
),
),
},
}
REG_UAC_DEFAULTS_WIN7 = {
'HKLM': {
r'Software\Microsoft\Windows\CurrentVersion\Policies\System': (
('ConsentPromptBehaviorAdmin', 5, 'DWORD'),
('EnableLUA', 1, 'DWORD'),
('PromptOnSecureDesktop', 1, 'DWORD'),
),
},
}
REG_UAC_DEFAULTS_WIN10 = {
'HKLM': {
r'Software\Microsoft\Windows\CurrentVersion\Policies\System': (
('ConsentPromptBehaviorAdmin', 5, 'DWORD'),
('ConsentPromptBehaviorUser', 3, 'DWORD'),
('EnableInstallerDetection', 1, 'DWORD'),
('EnableLUA', 1, 'DWORD'),
('EnableVirtualization', 1, 'DWORD'),
('PromptOnSecureDesktop', 1, 'DWORD'),
),
},
}
SYSTEMDRIVE = os.environ.get('SYSTEMDRIVE', 'C:')
WIDTH = 50
TRY_PRINT = TryAndPrint()
TRY_PRINT.width = WIDTH
TRY_PRINT.verbose = True
for error in ('CalledProcessError', 'FileNotFoundError'):
TRY_PRINT.add_error(error)
UBLOCK_ORIGIN_URLS = {
# pylint: disable=line-too-long
'Google Chrome': 'https://chrome.google.com/webstore/detail/ublock-origin/cjpalhdlnbpafiamejdnhcphjbkeiagm',
'Microsoft Edge': 'https://microsoftedge.microsoft.com/addons/detail/ublock-origin/odfafepnkmbhccpbejgmiehpchacaeak',
'Mozilla Firefox': 'https://addons.mozilla.org/addon/ublock-origin/',
'Opera': 'https://addons.opera.com/extensions/details/ublock/',
}
# Auto Setup
@ -709,11 +527,6 @@ def auto_open_xmplay():
TRY_PRINT.run('XMPlay...', open_xmplay)
def auto_restore_default_uac():
"""Restore default UAC settings."""
TRY_PRINT.run('User Account Control...', restore_default_uac)
def auto_show_4k_alignment_check():
"""Display 4K alignment check."""
TRY_PRINT.run('4K alignment Check...', check_4k_alignment, show_alert=True)
@ -862,15 +675,6 @@ def fix_windows_temp():
run_program(cmd)
def restore_default_uac():
"""Restore default UAC settings."""
settings = REG_UAC_DEFAULTS_WIN10
if OS_VERSION != 10:
settings = REG_UAC_DEFAULTS_WIN7
reg_write_settings(settings)
# Install Functions
def install_eset_nod32_av(msp=False):
"""Install ESET NOD32 Antivirus."""
@ -909,8 +713,10 @@ def install_firefox():
profile then it is reverted so the original existing profile instead.
"""
current_default_profile = None
firefox_exe = f'{os.environ["PROGRAMFILES"]}/Mozilla Firefox/firefox.exe'
profiles_ini = case_insensitive_path(
firefox_exe = get_path_obj(
f'{os.environ["PROGRAMFILES"]}/Mozilla Firefox/firefox.exe',
)
profiles_ini = get_path_obj(
f'{os.environ["APPDATA"]}/Mozilla/Firefox/profiles.ini',
)
program_path_32bit_exists = False
@ -937,7 +743,7 @@ def install_firefox():
run_tool('Firefox', 'Firefox', '/S', download=True)
# Open Firefox to force profiles.ini update
popen_program(firefox_exe)
popen_program([firefox_exe])
sleep(5)
kill_procs('firefox.exe', force=True)
@ -960,7 +766,7 @@ def install_firefox():
def install_libreoffice(
register_mso_types=True, use_mso_formats=False, vcredist=True):
"""Install LibreOffice."""
installer = find_kit_dir('Installers').joinpath('LibreOffice.msi')
installer = find_kit_dir('Installers').joinpath(f'LibreOffice{ARCH}.msi')
xcu_dir = get_path_obj(f'{os.environ.get("APPDATA")}/LibreOffice/4/user')
xcu_file = xcu_dir.joinpath('registrymodifications.xcu')
@ -1139,7 +945,8 @@ def export_aida64_report():
'/R', report_path,
'/CUSTOM', 'basic.rpf',
'/HTML', '/SILENT', '/SAFEST',
cbin=True, cwd=True)
cwd=True,
)
if proc.returncode:
raise GenericError('Error(s) encountered exporting report.')
@ -1183,7 +990,7 @@ def open_windows_updates():
def open_xmplay():
"""Open XMPlay."""
sleep(2)
run_tool('XMPlay', 'XMPlay', 'music.7z', cbin=True, cwd=True, popen=True)
run_tool('XMPlay', 'XMPlay', 'music.7z', cwd=True, popen=True)
def run_shutup_10():

28
setup/README.md Normal file
View file

@ -0,0 +1,28 @@
# WizardKit: Setup #
Build the various parts of the project.
## Requirements ##
* Linux
* 8 GB of RAM<sup>1</sup>
* 10 GB of free storage space<sup>2</sup>
* Arch Linux installed with internet access enabled
* The [Arch Linux Wiki](https://wiki.archlinux.org/) is a great resource
* macOS
* 10 GB of free storage space
* El Capitan, High Sierra, or Catalina installed
* WinPE
* _(Currently under development)_
* Windows Kit
* 10 GB of free storage space
* A recent version of Windows 10<sup>3</sup>
## Setup ##
Run the build script in this directory for the part you're looking for
## Notes ##
1. The Linux image is built under a tmpfs, overriding that may allow a lower RAM requirement.
2. Required free storage space can _probably_ be lower but 10 GB should be a safe starting point.
3. Building the Windows Kit under an older OS is not supported by these scripts

6
setup/build_linux
View file

@ -1,6 +1,6 @@
#!/bin/bash
#!/usr/bin/env bash
#
## Wizard Kit: Live Linux Build Tool
## WizardKit: Live Linux Build Tool
set -o errexit
set -o errtrace
@ -13,7 +13,7 @@ DATETIME="$(date +%Y-%m-%d_%H%M)"
ROOT_DIR="$(realpath $(dirname "$0")/..)"
BUILD_DIR="$ROOT_DIR/setup/BUILD"
LOG_DIR="$BUILD_DIR/logs"
OUT_DIR="$ROOT_DIR/setup/OUT"
OUT_DIR="$ROOT_DIR/setup/OUT_LINUX"
PROFILE_DIR="$BUILD_DIR/archiso-profile"
REPO_DIR="$BUILD_DIR/repo"
SKEL_DIR="$PROFILE_DIR/airootfs/etc/skel"

58
setup/macos/update-base-image → setup/build_macos
View file

@ -1,12 +1,36 @@
#!/usr/bin/env bash
#
## Update BaseImage for use as WK
## WizardKit: Live macOS Build Tool
set -o errexit
set -o errtrace
set -o nounset
set -o pipefail
# Show usage if necessary
if [[ "${1:-}" =~ "-h|--help" || ! -e "${1:-}" ]]; then
echo "Usage: build_macos [OPTIONS] <image_path>"
echo ""
echo "Options:"
echo " -h --help Show usage"
exit
fi
# Safety Check
LINUX_DIR="linux"
MACOS_DIR="macos"
ROOT_DIR=".."
TOOLS_TO_CHECK=(memtest mprime smc sysbench)
for tool in "${TOOLS_TO_CHECK[@]}"; do
if [[ ! -e "/usr/local/bin/$tool" ]]; then
echo "Missing tool(s) detected"
echo " Installing dependencies in 30 seconds, enter CTRL+c to abort."
sleep 30
"${MACOS_DIR}/install-deps"
exit
fi
done
# Prep
echo "Initializing..."
BASE_IMAGE="$1"
@ -14,7 +38,7 @@ IMAGE_DEV="$(hdiutil attach -mountpoint /Volumes/BaseSystem "${BASE_IMAGE}" -nob
OS_NAME="$(ls /Volumes/BaseSystem | grep -E 'OS X|macOS' | sed -E 's/Install (OS X|macOS) (.*)\.app/\2/')"
OS_VERSION="$(defaults read /Volumes/BaseSystem/System/Library/CoreServices/SystemVersion ProductVersion)"
OUT_NAME="${HOME}/Desktop/WK ${OS_NAME} ($(date +"%Y-%m-%d"))"
TIMEZONE="$(fgrep LINUX_TIME_ZONE ../../scripts/wk/cfg/main.py | cut -d '=' -f 2 | sed "s/'//g")"
TIMEZONE="$(fgrep LINUX_TIME_ZONE "${ROOT_DIR}/scripts/wk/cfg/main.py" | cut -d '=' -f 2 | sed "s/'//g")"
WK_PATH="/Volumes/1201_UFD"
# Convert to a 4 GB R/W image
@ -34,11 +58,11 @@ rm -R "${WK_PATH}"/Install*.app
# Update Utilities menu
echo "Updating Utilities menu..."
if [[ "${OS_VERSION:0:5}" == "10.11" ]]; then
cp -a "El Capitan/Utilities.plist" "${WK_PATH}/System/Installation/CDIS/OS X Utilities.app/Contents/Resources/Utilities.plist"
cp -a "${MACOS_DIR}/El Capitan/Utilities.plist" "${WK_PATH}/System/Installation/CDIS/OS X Utilities.app/Contents/Resources/Utilities.plist"
elif [[ "${OS_VERSION:0:5}" == "10.13" ]]; then
cp -a "High Sierra/Utilities.plist" "${WK_PATH}/System/Installation/CDIS/macOS Utilities.app/Contents/Resources/Utilities.plist"
cp -a "${MACOS_DIR}/High Sierra/Utilities.plist" "${WK_PATH}/System/Installation/CDIS/macOS Utilities.app/Contents/Resources/Utilities.plist"
elif [[ "${OS_VERSION:0:5}" == "10.15" ]]; then
cp -a "Catalina/Utilities.plist" "${WK_PATH}/System/Installation/CDIS/macOS Utilities.app/Contents/Resources/Utilities.plist"
cp -a "${MACOS_DIR}/Catalina/Utilities.plist" "${WK_PATH}/System/Installation/CDIS/macOS Utilities.app/Contents/Resources/Utilities.plist"
fi
# 1201 CA
@ -52,7 +76,7 @@ for t in rsa dss ecdsa ed25519; do
dropbearkey -t "${t}" -f "${WK_PATH}/etc/dropbear/dropbear_${t}_host_key"
done
ln -s /Volumes/RAM_Disk/.ssh "${WK_PATH}/var/root"/
cp -a ../linux/authorized_keys "${WK_PATH}/.authorized_keys"
cp -a "${LINUX_DIR}/authorized_keys" "${WK_PATH}/.authorized_keys"
# Homebrew
echo "Installing Hombrew..."
@ -74,7 +98,7 @@ cp -a /usr/bin/tput "${WK_PATH}/usr/bin"/
# Terminal
echo "Installing Terminal Preferences..."
rsync -aS com.apple.Terminal.plist "${WK_PATH}/var/root/Library/Preferences"/
cp -a "${MACOS_DIR}/com.apple.Terminal.plist" "${WK_PATH}/var/root/Library/Preferences"/
# Timezones
echo "Installing timezones..."
@ -90,7 +114,7 @@ fi
# zsh
echo "Installing zsh..."
cp -a /bin/zsh "${WK_PATH}/bin"/
cp -a zshenv "${WK_PATH}/etc"/
cp -a "${MACOS_DIR}/zshenv" "${WK_PATH}/etc"/
rsync -aS /usr/lib/zsh "${WK_PATH}/usr/lib"/
rsync -aS /usr/share/zsh "${WK_PATH}/usr/share"/
rsync -aS /usr/local/share/zsh "${WK_PATH}/usr/local/share"/
@ -102,12 +126,12 @@ sudo chown 0:0 "${WK_PATH}/usr/sbin/memtest"
sudo chmod 755 "${WK_PATH}/usr/sbin/memtest"
# Misc
cp -a ../linux/known_networks "${WK_PATH}/.known_networks"
cp -a "${LINUX_DIR}/known_networks" "${WK_PATH}/.known_networks"
cp -a /usr/bin/rsync "${WK_PATH}/usr/bin"/
cp -a /usr/sbin/networksetup "${WK_PATH}/usr/sbin"/
cp -a aliases "${WK_PATH}/.aliases"
cp -a bashrc "${WK_PATH}/etc/profile"
cp -a vimrc "${WK_PATH}/.vimrc"
cp -a "${MACOS_DIR}/aliases" "${WK_PATH}/.aliases"
cp -a "${MACOS_DIR}/bashrc" "${WK_PATH}/etc/profile"
cp -a "${MACOS_DIR}/vimrc" "${WK_PATH}/.vimrc"
if [[ "${OS_VERSION:3:2}" == "11" ]]; then
cp -a /usr/bin/fgrep "${WK_PATH}/usr/bin"/
cp -a /usr/bin/locale "${WK_PATH}/usr/bin"/
@ -120,13 +144,13 @@ fi
echo "Installing WizardKit env..."
touch "${WK_PATH}/.wk-live-macos"
ln -s /Volumes/RAM_Disk/Logs "${WK_PATH}/var/root/Logs"
cp -a ../linux/profile_base/airootfs/etc/skel/.tmux.conf "${WK_PATH}/etc/tmux.conf"
cp -a "${LINUX_DIR}/profile_base/airootfs/etc/skel/.tmux.conf" "${WK_PATH}/etc/tmux.conf"
rsync -aS /usr/bin/{env,killall} "${WK_PATH}/usr/bin"/
rsync -aS live-macos-startup ../../scripts/ "${WK_PATH}/usr/local/bin"/
if [[ -f "../../images/macOS-${OS_VERSION:0:5}.jpg" ]]; then
cp -a "../../images/macOS-${OS_VERSION:0:5}.jpg" "${WK_PATH}/usr/local/wallpaper.jpg"
rsync -aS "${MACOS_DIR}/live-macos-startup" "${ROOT_DIR}/scripts/" "${WK_PATH}/usr/local/bin"/
if [[ -f "${ROOT_DIR}/images/macOS-${OS_VERSION:0:5}.jpg" ]]; then
cp -a "${ROOT_DIR}/images/macOS-${OS_VERSION:0:5}.jpg" "${WK_PATH}/usr/local/wallpaper.jpg"
else
cp -a ../../images/macOS.jpg "${WK_PATH}/usr/local/wallpaper.jpg"
cp -a "${ROOT_DIR}/images/macOS.jpg" "${WK_PATH}/usr/local/wallpaper.jpg"
fi
# Unmount sparsebundle

4
setup/build_pe.cmd
View file

@ -1,10 +1,10 @@
:: Wizard Kit: Windows PE Build Tool Launcher ::
:: WizardKit: Windows PE Build Tool ::
@echo off
:Init
setlocal EnableDelayedExpansion
title Wizard Kit: Windows PE Build Tool
title WizardKit: Windows PE Build Tool
call :CheckFlags %*
call :CheckElevation || goto Exit
call :FindKitsRoot || goto ErrorKitNotFound

52
setup/build_windows.cmd
View file

@ -1,33 +1,42 @@
:: Wizard Kit: Build Tool Launcher ::
:: WizardKit: Windows Kit Build Tool ::
@echo off
:Init
setlocal
title Wizard Kit: Build Tool
setlocal EnableDelayedExpansion
pushd "%~dp0"
title WizardKit: Build Tool
call :CheckFlags %*
:PrepNewKit
rem Copy base files to a new folder OUT_KIT
robocopy /e .kit_items OUT_KIT
robocopy /e .bin OUT_KIT\.bin
robocopy /e .cbin OUT_KIT\.cbin
copy LICENSE.txt OUT_KIT\LICENSE.txt
copy README.md OUT_KIT\README.md
copy Images\ConEmu.jpg OUT_KIT\.bin\ConEmu\
mkdir OUT_KIT\.cbin >nul 2>&1
attrib +h OUT_KIT\.bin >nul 2>&1
attrib +h OUT_KIT\.cbin >nul 2>&1
:SetVariables
rem Set variables using settings\main.py file
set "SETTINGS=..\scripts\wk\cfg\main.py"
for %%v in (KIT_NAME_FULL) do (
set "var=%%v"
for /f "tokens=* usebackq" %%f in (`findstr "!var!=" "%SETTINGS%"`) do (
set "_v=%%f"
set "_v=!_v:*'=!"
set "%%v=!_v:~0,-1!"
)
)
set "OUT_DIR=OUT_KIT\%KIT_NAME_FULL%"
:EnsureCRLF
rem Rewrite main.py using PowerShell to have CRLF/`r`n lineendings
set "script=OUT_KIT\.bin\Scripts\borrowed\set-eol.ps1"
set "main=OUT_KIT\.bin\Scripts\settings\main.py"
powershell -executionpolicy bypass -noprofile -file %script% -lineEnding win -file %main% || goto ErrorUnknown
:PrepNewKit
rem Copy base files to a new folder %OUT_DIR%
mkdir %OUT_DIR% >nul 2>&1
robocopy /e windows/bin %OUT_DIR%\.bin
robocopy /e ..\scripts %OUT_DIR%\.bin\Scripts
rem robocopy /e windows/cbin %OUT_DIR%\.cbin
mkdir %OUT_DIR%\.cbin
copy ..\LICENSE.txt %OUT_DIR%\LICENSE.txt
copy ..\README.md %OUT_DIR%\README.md
copy ..\images\ConEmu.png %OUT_DIR%\.bin\ConEmu\
attrib +h %OUT_DIR%\.bin >nul 2>&1
attrib +h %OUT_DIR%\.cbin >nul 2>&1
:Launch
set "script=OUT_KIT\.bin\Scripts\build_kit.ps1"
powershell -executionpolicy bypass -noprofile -file %script% || goto ErrorUnknown
set "script=windows\build.ps1"
powershell -executionpolicy bypass -noprofile -file %script% "%OUT_DIR%" || goto ErrorUnknown
goto Exit
:: Functions ::
@ -58,5 +67,6 @@ goto Exit
:: Cleanup and exit ::
:Exit
popd
endlocal
exit /b %errorlevel%

1
setup/linux/packages/base
View file

@ -2,6 +2,7 @@ aic94xx-firmware
alsa-utils
amd-ucode
antiword
arch-install-scripts
base
bc
bind

2
setup/linux/profile_base/airootfs/etc/skel/.zshrc
View file

@ -6,7 +6,7 @@ HIST_STAMPS="yyyy-mm-dd"
plugins=(archlinux git sudo systemd tmux)
source $ZSH/oh-my-zsh.sh
# Wizard Kit
# WizardKit
. $HOME/.aliases
eval $(dircolors ~/.dircolors)
export PYTHONPATH="/usr/local/bin"

0
scripts/build_pe.ps1 → setup/pe/build_pe.ps1
View file

2
setup/windows/Drivers/Extras/AMD.url
View file

@ -1,2 +0,0 @@
[InternetShortcut]
URL=https://support.amd.com/en-us/download

2
setup/windows/Drivers/Extras/Dell (FTP - Browse for Drivers).url
View file

@ -1,2 +0,0 @@
[InternetShortcut]
URL=https://ftp.dell.com/browse_for_drivers/

Some files were not shown because too many files have changed in this diff Show more