package           : tis-windows11-upgrade-template
version           : 0-114
architecture      : x64
section           : base
priority          : optional
name              : Windows 11 Upgrade Template
categories        : System and network
maintainer        : WAPT Team,Tranquil IT,Jimmy PELÉ,Pierre COSSON
description       : Upgrade to the latest version of Windows 11 from Windows 7, 8, 10 and 11 - You must execute the "update-package" and "build-package" for every single necessary language before deploying the package
depends           : 
conflicts         : tis-windows10-upgrade-data,tis-windows10-2004-upgrade,tis-windows10-20h2-upgrade
maturity          : PROD
locale            : all
target_os         : windows
min_wapt_version  : 2.2
sources           : https://www.microsoft.com/software-download/windows11
installed_size    : 31000000000
impacted_process  : SetupHost
description_fr    : Mise à niveau vers la dernière version de Windows 11 à partir de Windows 7, 8, 10 et 11 - Vous devez exécuter le "update-package" et le "build-package" pour chaque langue nécessaire avant de déployer le paquet
description_pl    : Aktualizacja do najnowszej wersji Windows 11 z Windows 7, 8, 10 i 11 - musisz wykonać "update-package" i "build-package" dla każdego niezbędnego języka przed wdrożeniem pakietu
description_de    : Upgrade auf die neueste Version von Windows 11 von Windows 7, 8, 10 und 11 - Sie müssen das "update-package" und "build-package" für jede einzelne benötigte Sprache ausführen, bevor Sie das Paket bereitstellen
description_es    : Actualizar a la última versión de Windows 11 desde Windows 7, 8, 10 y 11 - Debe ejecutar el "update-package" y "build-package" para cada uno de los idiomas necesarios antes de desplegar el paquete
description_pt    : Actualização para a última versão do Windows 11 a partir do Windows 7, 8, 10 e 11 - Deve executar o "update-package" e o "build-package" para cada uma das línguas necessárias antes de implementar o pacote
description_it    : Aggiornamento all'ultima versione di Windows 11 da Windows 7, 8, 10 e 11 - È necessario eseguire "update-package" e "build-package" per ogni singola lingua necessaria prima di distribuire il pacchetto
description_nl    : Upgrade naar de laatste versie van Windows 11 vanuit Windows 7, 8, 10 en 11 - U moet de "update-package" en "build-package" uitvoeren voor elke noodzakelijke taal voordat u het pakket implementeert
description_ru    : Обновление до последней версии Windows 11 с Windows 7, 8, 10 и 11 - необходимо выполнить команды "update-package" и "build-package" для каждого необходимого языка перед развертыванием пакета
audit_schedule    : 
editor            : Microsoft
keywords          : 
licence           : Proprietary
homepage          : https://www.microsoft.com/software-download/windows11
package_uuid      : 39846045-e117-4f64-8d09-ee551dcc0579
valid_from        : 
valid_until       : 
forced_install_on : 
changelog         : https://docs.microsoft.com/windows/release-health/
min_os_version    : 6.1
max_os_version    : 
icon_sha256sum    : 9ccd55c246c5266669ff70a6e62c1e315666114c6d3f854071b6ff22fe48612b
signer            : Tranquil IT
signer_fingerprint: 8c5127a75392be9cc9afd0dbae1222a673072c308c14d88ab246e23832e8c6bb
signature_date    : 2025-01-28T20:06:53.000000
signed_attributes : package,version,architecture,section,priority,name,categories,maintainer,description,depends,conflicts,maturity,locale,target_os,min_wapt_version,sources,installed_size,impacted_process,description_fr,description_pl,description_de,description_es,description_pt,description_it,description_nl,description_ru,audit_schedule,editor,keywords,licence,homepage,package_uuid,valid_from,valid_until,forced_install_on,changelog,min_os_version,max_os_version,icon_sha256sum,signer,signer_fingerprint,signature_date,signed_attributes
signature         : qwvEBsb1jyerloHHtRe98nX6JVErh/D7qzNcyIXLSJPV29ihfmxT3Kw2WZbGtX9lRfSGE8x0Bcawn7mXwSFehTzE0Iz7gs1lsT+v7EkM5KmERz1mGZt7+tnu5x9rB7odRiwBA4WVSPMKbDAzCxINpjjmXsftPAW/bsWTfld9NGWeV6zlMeDMMF4IVsmmBLCPAD5davxySNqeilycVPNeZKtrXOZ+5EnyivZi62mOElPed59u6g18bfC656rVmH7SJZj6Q4hC8b4xnVMf0avLV588bydymGf0Ny5VX7CDTESe/8uEIym+w4eQg1UCa6AlGADbBZF9EZy+h5T0yQal5w==

# -*- coding: utf-8 -*-
from setuphelpers import *
import time


r"""
Sources:
https://docs.microsoft.com/windows-hardware/manufacture/desktop/windows-setup-command-line-options
https://www.prajwaldesai.com/windows-10-upgrade-setup-failed-with-exit-code-0xc1900200/
https://www.tomshardware.com/how-to/bypass-windows-11-tpm-requirement
https://docs.microsoft.com/windows-hardware/manufacture/desktop/windows-setup-command-line-options?view=windows-11#compat
https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/cleanmgr

Infos:
Forced install will automatically reboot the PC
This package can be updated graphically

"""
AllowUpgradesWithUnsupportedTPMOrCPU = False
DynamicUpdate = False
upgrade_path = makepath(systemdrive, "WindowsUpgrade")
upgrade_logs_path = makepath(systemdrive, "WindowsUpgradeLogs")
windows_old_path = makepath(systemdrive, "Windows.old")
cleanmgr_timeout = 660


def install():
    # Declaring local variables
    package_version = control.get_software_version()
    iso_path = makepath(basedir, "iso")
    cleanmgr_keys = [
        "Active Setup Temp Folders",
        "BranchCache",
        "Content Indexer Cleaner",
        "D3D Shader Cache",
        "Delivery Optimization Files",
        "Device Driver Packages",
        "Diagnostic Data Viewer database files",
        "Downloaded Program Files",
        "DownloadsFolder",
        "Internet Cache Files",
        "Language Pack",
        "Offline Pages Files",
        "Old ChkDsk Files",
        "Previous Installations",
        "Recycle Bin",
        "RetailDemo Offline Content",
        "Setup Log Files",
        "System error memory dump files",
        "System error minidump files",
        "Temporary Files",
        "Temporary Setup Files",
        "Temporary Sync Files",
        "Thumbnail Cache",
        "Update Cleanup",
        "Upgrade Discarded Files",
        "User file versions",
        "Windows Defender",
        "Windows Error Reporting Files",
        "Windows ESD installation files",
        "Windows Upgrade Log Files",
    ]

    # Checking if Windows must be upgraded
    if Version(windows_version(), 3) < Version(package_version, 3):
        # Trying to remove previous version of Windows if needed
        if isdir(windows_old_path) or isdir(r"C:\$Windows.~WS"):
            key_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\VolumeCaches"
            key_value = r"StateFlags0042"
            for key in cleanmgr_keys:
                if "Upgrade Discarded Files" in key or "Previous Installations" in key:
                    registry_set(HKEY_LOCAL_MACHINE, makepath(key_path, key), key_value, 2)
                else:
                    registry_set(HKEY_LOCAL_MACHINE, makepath(key_path, key), key_value, 0)

            print("Removing previous version of Windows")
            cleanmgr_cmd = "cleanmgr /verylowdisk /sagerun:42"
            run_notfatal(cleanmgr_cmd, timeout=cleanmgr_timeout)  # seems to timeout on missing user graphical interface
            # run_powershell(r"Start-Process -FilePath CleanMgr.exe -ArgumentList '/sagerun:42 /verylowdisk' -WindowStyle Hidden -Wait")

            print("Waiting for custom CleanMgr")
            max_loop = cleanmgr_timeout
            while isrunning("cleanmgr"):
                loop = 0
                loop += 10
                if loop > max_loop:
                    print("CleanMgr timed out after %s seconds, trying to continue" % max_loop)
                    print('If the upgrade fail, please run: "%s" manually as asministrator on the PC' % cleanmgr_cmd)
                time.sleep(10)
                print("CleanMgr is running since %s seconds" % loop)
            print("CleanMgr finished")

        # Move iso
        if isdir(upgrade_path):
            remove_tree(upgrade_path)
        os.rename(iso_path, upgrade_path)

        if not isdir(upgrade_logs_path):
            mkdirs(upgrade_logs_path)

        # Upgrading Windows if needed
        if isdir(upgrade_path):
            print("%s folder exists, continuing..." % upgrade_path)
            print("Free disk space: %d bytes" % get_disk_free_space(upgrade_path))
            if get_disk_free_space(upgrade_path) < 25000000000:
                error("Not enough free space on disk for upgrade, please cleanup")
            else:
                # Changing cmd options
                additionnal_cmd = ""
                if AllowUpgradesWithUnsupportedTPMOrCPU:
                    registry_set(HKEY_LOCAL_MACHINE, r"SYSTEM\Setup\MoSetup", "AllowUpgradesWithUnsupportedTPMOrCPU", 1)
                    additionnal_cmd = additionnal_cmd + " /compat ignorewarning"
                if DynamicUpdate:
                    additionnal_cmd = additionnal_cmd + " /dynamicupdate enable"
                else:
                    additionnal_cmd = additionnal_cmd + " /dynamicupdate disable"

                if force:
                    try:
                        print("Force Upgrading Windows from version: %s to Windows version: %s" % (windows_version(), package_version))
                        run(
                            rf'"{makepath(upgrade_path, "setup.exe")}" /auto upgrade /quiet /eula accept /telemetry disable /showoobe none /copylogs "{makepath(upgrade_logs_path, "win11_upgrade_logs")}" {additionnal_cmd}',
                            timeout=5000,
                        )
                    except Exception as error_force_upgrade:
                        error(error_force_upgrade)
                else:
                    additionnal_cmd = additionnal_cmd + " /noreboot"
                    try:
                        print("Upgrading Windows from version: %s to Windows version: %s" % (windows_version(), package_version))
                        run(
                            rf'"{makepath(upgrade_path, "setup.exe")}" /auto upgrade /quiet /eula accept /telemetry disable /showoobe none /copylogs "{makepath(upgrade_logs_path, "win11_upgrade_logs")}" {additionnal_cmd}',
                            timeout=5000,
                        )
                    except Exception as error_upgrade:
                        error(error_upgrade)
        else:
            error("%s do not exist, please reinstall this package" % upgrade_path)
    else:
        print("This PC is already up-to-date on Windows version: %s" % windows_version())


def uninstall():
    if AllowUpgradesWithUnsupportedTPMOrCPU:
        registry_delete(HKEY_LOCAL_MACHINE, r"SYSTEM\Setup\MoSetup", "AllowUpgradesWithUnsupportedTPMOrCPU")
    if isdir(upgrade_path):
        print("Removing: %s" % upgrade_path)
        remove_tree(upgrade_path)
    if isdir(upgrade_logs_path):
        print("Removing: %s" % upgrade_logs_path)
        remove_tree(upgrade_logs_path)


def audit():
    if Version(windows_version()) < Version(control.get_software_version()):
        if isrunning("SetupHost"):
            print("WARNING: Windows upgrade is running...")
            return "WARNING"
        elif is_pending_reboot():
            print("WARNING: Please reboot this PC to finalize the upgrade")
            return "WARNING"
        else:
            print("ERROR: Windows upgrade failed")
            return "ERROR"
    else:
        print("OK: This PC is now up-to-date on Windows version: %s" % windows_version())
        print("Cleaning up since the upgrade was successful...")
        if isdir(upgrade_path):
            print("Removing: %s" % upgrade_path)
            remove_tree(upgrade_path)
        if isdir(upgrade_logs_path):
            print("Removing: %s" % upgrade_logs_path)
            remove_tree(upgrade_logs_path)
        return "OK"

# -*- coding: utf-8 -*-
from setuphelpers import *
from setupdevhelpers import *
import waptguihelper
import uuid
import json
import requests
import traceback

# Products configuration
# Latest ID can be found official microsoft website or here : https://msdl.gravesoft.dev/ 
PRODUCTS = {
    # "48": "Windows 8.1 Single Language (9600.17415)",
    # "52": "Windows 8.1 (9600.17415)",
    # "55": "Windows 8.1 N (9600.17415)",
    # "61": "Windows 8.1 K (9600.17415)",
    # "62": "Windows 8.1 KN (9600.17415)",
    # "2378": "Windows 10 22H2 Home China (19045.2006)",
    # "2618": "Windows 10 22H2 v1 (19045.2965)",
    "3113": "Windows 11 24H2 (26100.1742)",
    # "3114": "Windows 11 24H2 Home China (26100.1742)",
    # "3115": "Windows 11 24H2 Pro China (26100.1742)",
    # "3131": "Windows 11 Arm64 24H2 (26100.1742)",
    # "3132": "Windows 11 Arm64 24H2 Home China (26100.1742)",
    # "3133": "Windows 11 Arm64 24H2 Pro China (26100.1742)"
}


class WindowsDownloader:
    def __init__(self, debug=False, fallback_msdl=True, proxies=None):
        self.debug = debug
        self.fallback_msdl = fallback_msdl
        self.proxies = proxies
        self.session = self._initialize_session()
        self.session_id = str(uuid.uuid4())
        self.SESSION_URL = "https://vlscppe.microsoft.com/tags?org_id=y6jn8c31&session_id="
        self.MS_API_URL = "https://www.microsoft.com/software-download-connector/api"
        self.MSDL_API_URL = "https://api.gravesoft.dev/msdl"
        self.PARAMS = "profile=606624d44113&Locale=en-US&sessionID="
        self.SHARED_SESSION_GUID = "47cbc254-4a79-4be6-9866-9c625eb20911"

        # Needed to validate links retrieved by MSDL proxy
        self.MICROSOFT_DOWNLOAD_URL = "https://software.download.prss.microsoft.com"

        self.prepare_download(self.session_id)

    def _initialize_session(self):
        session = requests.Session()
        if self.proxies :
            session.proxies.update(self.proxies)
        session.headers.update({
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0",
            "Accept": "application/json, text/javascript, */*; q=0.01",
            "x-requested-with": "XMLHttpRequest",
            "sec-ch-ua-platform": "Windows",
            "cache-control": "no-cache"
        })
        return session

    def log_debug(self, message):
        if self.debug:
            print(f"[DEBUG] {message}")

    def prepare_download(self, session_id):
        url = f"{self.SESSION_URL}{session_id}"
        self.log_debug(f"Preparing session with URL: {url}")
        try:
            response = self.session.get(url)
            response.raise_for_status()
        except requests.RequestException as e:
            # print(traceback.format_exc())
            print(f"Error preparing session: {e}")

    def fetch_data(self, url):
        self.log_debug(f"Fetching data from URL: {url}")
        try:
            response = self.session.get(url)
            response.raise_for_status()
            result = response.json()
            if isinstance(result, str):
                return json.loads(result)
            return response.json()
        except requests.RequestException as e:
            # print(traceback.format_exc())
            print(f"Error preparing session: {e}")
            return None

    def get_languages(self, product_id):
        url = f"{self.MS_API_URL}/getskuinformationbyproductedition?{self.PARAMS}{self.session_id}&ProductEditionId={product_id}"
        return self.fetch_data(url)

    def get_download_links(self, product_id, sku_id):
        # Attempt to get download links from MS API
        downloads = self._get_ms_download_links(product_id, sku_id)
        if downloads:
            return downloads

        # Retry with shared session GUID only if the first request not send False
        # That mean we have been banned from microsoft
        downloads = self._retry_ms_download_links(product_id, sku_id) if downloads is not False else None
        if downloads:
            return downloads

        # Fallback to MSDL API if enabled
        if self.fallback_msdl:
            downloads = self._get_download_links_msdl(product_id, sku_id)
            return downloads

        print("[ERROR] No download links available after all attempts.")
        return None

    def _get_ms_download_links(self, product_id, sku_id, session_guid=None):
        session_guid = session_guid or self.session_id
        url = f"{self.MS_API_URL}/GetProductDownloadLinksBySku?{self.PARAMS}{session_guid}&SKU={sku_id}&friendlyFileName=undefined&ProductEditionId=undefined"

        product_name = PRODUCTS[product_id]
        if "Windows 8.1" in product_name:
            windows_version = "8.1"
        elif "Windows 10" in product_name:
            windows_version = "10"
        elif "Windows 11" in product_name:
            windows_version = "11"

        self.session.headers.update({
            "referer": f"https://www.microsoft.com/fr-fr/software-download/windows{windows_version}"
        })
        result = self.fetch_data(url)
        if result and result.get('Errors'):
            self.log_debug(result["Errors"])
            if result.get('Errors')[0]['Type'] == 9:
                print("[ERROR] No download links available, You've been potentialy banned !")
                return False
            print("[WARNING] Errors found in microsoft download link response. (Trying another method)")
            return None
        return result

    def _retry_ms_download_links(self, product_id, sku_id):
        self.session.cookies.clear()
        self.prepare_download(self.SHARED_SESSION_GUID)
        return self._get_ms_download_links(product_id, sku_id, session_guid=self.SHARED_SESSION_GUID)

    def _get_download_links_msdl(self, product_id, sku_id):
        url = f"{self.MSDL_API_URL}/proxy?product_id={product_id}&sku_id={sku_id}"

        self.session.cookies.clear()
        del self.session.headers['referer']

        downloads = self.fetch_data(url)

        self.log_debug('Validating MSDL download links.')
        if all(self.MICROSOFT_DOWNLOAD_URL in option.get('Uri', '') for option in downloads.get("ProductDownloadOptions", [])):
            return downloads

        return None

def update_package():
    # Declaring local variables
    package_updated = False
    proxies = get_proxies()
    if not proxies:
        proxies = get_proxies_from_wapt_console()

    iso_path = makepath(basedir, "iso")
    setup_path = makepath(iso_path, "setup.exe")
    iso_present = False
    iso_extracted = False
    iso_copy_path = None
    iso_to_download = False
    keep_extracted_iso = False
    keep_current_iso = False

    lang_dict = {
        "fr": "French",
        "en": "English",
        "pl": "Polish",
        "de": "German",
        "es": "Spanish",
        "pt": "Portuguese",
        "it": "Italian",
        "nl": "Dutch",
        "ru": "Russian",
        "all": "Others",
    }
    lang_list = []
    for entry in lang_dict:
        lang_list.append({"short name": entry, "long name": lang_dict[entry]})

    # Detect ISO if placed
    for iso_in_dir in glob.glob("*.iso"):
        if isfile(iso_in_dir):
            iso_present = True

    # Detect ISO if already extracted
    if isfile(setup_path):
        iso_extracted = True

    if iso_present:
        keep_iso_present_question = waptguihelper.message_dialog("ISO found", f"Do you want to keep: {iso_in_dir}?", waptguihelper.ID_YES)
        if keep_iso_present_question == waptguihelper.ID_YES:
            keep_current_iso = True

    if iso_extracted:
        keep_iso_extracted_question = waptguihelper.message_dialog("An ISO is already extracted", "Do you want to keep it?", waptguihelper.ID_YES)
        if keep_iso_extracted_question == waptguihelper.ID_YES:
            keep_extracted_iso = True

    if keep_current_iso and keep_extracted_iso:
        keep_only_one_question = waptguihelper.grid_dialog(
            "Please select only one", [{"keep :": iso_in_dir}, {"keep :": "iso already extracted"}], waptguihelper.GRT_SELECTED
        )
        if "extracted" in keep_only_one_question[0]["keep :"]:
            keep_current_iso = False
        else:
            keep_extracted_iso = False

    if not keep_extracted_iso:
        if not iso_present:
            iso_absent_question = waptguihelper.message_dialog(
                "No ISO detected", "Do you want to download Windows ISO from Microsoft's servers?\nClick No to use your own ISO", waptguihelper.ID_YES
            )
            if iso_absent_question == waptguihelper.ID_YES:
                iso_to_download = True

    if iso_to_download:
        downloader = WindowsDownloader(fallback_msdl=True, proxies=proxies)

        products_waptgui = [ {'id': id, 'name': name} for id, name in PRODUCTS.items() ]
        product_id = waptguihelper.grid_dialog("Please select a product", products_waptgui, waptguihelper.GRT_SELECTED)[0]['id']

        languages = downloader.get_languages(product_id)
        if not languages:
            error('Unable to retrieved languages from microsoft')
        
        languages_waptgui = [ {"id": sku['Id'], 'language': sku['LocalizedLanguage']} for sku in languages.get("Skus", []) ]
        sku_id = waptguihelper.grid_dialog("Please select language", languages_waptgui, waptguihelper.GRT_SELECTED)[0]['id']

        downloads = downloader.get_download_links(product_id, sku_id)
        if downloads:
            iso_links = downloads.get('ProductDownloadOptions', [])
            if len(iso_links) > 1:
                iso_name_waptgui = [ {"name": iso['Uri'].rsplit('/', 1)[-1].split('?')[0]} for iso in iso_links ]
                iso_name = waptguihelper.grid_dialog(
                    "Please select an ISO", iso_name_waptgui, waptguihelper.GRT_SELECTED, 
                    '{"columns":[{"propertyname":"name","width":375}],"window":{"height":331,"width":380}}'
                )[0]['name']
                download_url = next((iso['Uri'] for iso in iso_links if iso_name in iso['Uri']), None)
            else:
                download_url = downloads['ProductDownloadOptions'][0]['Uri']
                iso_name = download_url.rsplit('/', 1)[-1].split('?')[0]
                
            print(f"Downloading {iso_name}...")
            wget(download_url, makepath(basedir, iso_name), proxies=proxies)
            iso_present = True
        else:
            error("No download links available")

    if not keep_current_iso and not iso_present and not keep_extracted_iso:
        # Cleanup ISO files
        for iso_in_dir in glob.glob("*.iso"):
            remove_file(iso_in_dir)

        iso_copy_path = waptguihelper.filename_dialog("Please provide the Windows ISO to copy in this package", "", "", "ISO Files|*.iso")
        print("Copying: " + iso_copy_path)
        filecopyto(iso_copy_path, basedir)

    # Extracting ISO
    if not keep_extracted_iso:
        # Cleanup ISO dir
        if isdir(iso_path):
            remove_tree(iso_path)
        iso_in_dir = glob.glob("*.iso")[0]
        print("Extracting: " + iso_in_dir)
        unzip_with_7zip(iso_in_dir, iso_path)
        remove_file(iso_in_dir)

    # Getting version from the ISO setup.exe
    version = ".".join(get_file_properties(setup_path)["ProductVersion"].split(".")[:3])

    # Changing version of the package
    if Version(version) > control.get_software_version():
        print("Software version updated from: %s to: %s" % (control.get_software_version(), Version(version)))
        package_updated = True
    control.set_software_version(version)
    control.save_control_to_wapt()

    # Changing locale of the package
    lang_short = waptguihelper.grid_dialog("Please select a language", lang_list, waptguihelper.GRT_SELECTED)[0]["short name"]

    # Updating pkg infos
    if "-template" in control.package:
        package_name = waptguihelper.input_dialog(control.package, "You can redefine the package name", control.package.split("-template")[0])
        control.package = package_name
        if " Template" in control.name:
            control.name = control.name.split(" Template")[0]
        print("Changing package name to: %s" % package_name)
    control.locale = lang_short
    control.save_control_to_wapt()
    print("Changing locale to: %s in WAPT\\control" % control.locale)

    # Validating update-package-sources
    return package_updated