Comment corriger les erreurs de permission d’écriture du système de fichiers du Package Support Framework

Article
07/16/2024

Cet article décrit comment utiliser le Package Support Framework (PSF) pour résoudre une erreur de permission d’écriture du système de fichiers.

Les applications Windows redirigent des répertoires spécifiques liés aux applications vers le dossier C:\Program Files\WindowsApps. Si l’application tente d’écrire dans le conteneur d’application Windows, une erreur se déclenche et l’écriture échoue. Vous pouvez apporter des améliorations au package d’application Windows pour résoudre ce problème.

Examen

Tout d’abord, identifiez l’échec et les chemins de répertoire demandés par l’application.

Capturez l’échec de l’application Windows

Le filtrage des résultats est facultatif, mais facilite la visualisation des échecs liés aux applications. Pour filtrer les résultats, vous créez deux règles de filtrage. Le premier filtre inclut le nom du processus de l’application, et le deuxième filtre inclut tous les résultats qui ne sont pas réussis.

Téléchargez et extrayez le SysInternals Process Monitor dans le répertoire C:\PSF\ProcessMonitor.
Ouvrez l’Explorateur Windows et naviguez jusqu’au dossier extrait de SysInternals ProcessMonitor.
Sélectionnez le fichier SysInternals Process Monitor procmon.exe pour lancer l’application.
Si vous êtes invité par l’UAC, sélectionnez Oui.
Dans la fenêtre Process Monitor Filter, sélectionnez Process Name dans le menu déroulant du premier champ.
Vérifiez que is apparaît dans le champ suivant.
Dans le champ suivant, entrez le nom du processus de votre application, par exemple PSFSample.exe.
Sélectionnez Ajouter.
Dans la fenêtre Process Monitor Filter, sélectionnez Result dans le menu déroulant du premier champ.
Dans le champ suivant, sélectionnez is not dans le menu déroulant.
Dans le champ texte, entrez SUCCESS.
Sélectionnez Ajouter, puis OK.
Lancez l’application Windows, déclenchez l’erreur, puis fermez l’application Windows.

Examinez les journaux des échecs de l’application Windows

Après avoir capturé les processus de l’application Windows, examinez les résultats pour déterminer si l’échec est lié au répertoire de travail.

Examinez les résultats d’échec du SysInternals Process Monitor. Si les résultats incluent Access denied, avec un détail Desired Access: Generic Write, pour votre application ciblant C:\Program Files\WindowsApps\...\, vous avez identifié un échec de permission d’écriture lié au répertoire de travail.

Affiche le message d’erreur observé dans le SysInternals Process Monitor pour l’échec d’écriture dans le répertoire.

Si vous identifiez cette erreur, appliquez la correction PSF suivante à votre application.

Résolution

Pour résoudre le problème de l’échec de l’application Windows à écrire dans le conteneur d’application Windows, suivez ces étapes :

Extrayez le contenu de l’application Windows dans un répertoire de mise en scène local.
Créez un config.json et injectez les fichiers de correction PSF dans le répertoire de mise en scène de l’application Windows.
Configurez le lanceur d’application pour pointer vers le lanceur PSF et configurez le fichier config.json de PSF pour rediriger le lanceur PSF, en spécifiant le répertoire de travail.
Mettez à jour le fichier AppxManifest de l’application Windows.
Repackagez et signez l’application Windows.

Téléchargez et installez les outils requis

Ce processus nécessite les outils suivants :

Outil client NuGet
Package Support Framework (PSF)
Kit de développement logiciel Windows 10 (Win 10 SDK), dernière version
SysInternals Process Monitor

Pour télécharger et installer NuGet et PSF :

Téléchargez la dernière version non-preview de l’outil client NuGet et enregistrez nuget.exe dans C:\PSF\nuget.
Téléchargez et installez le Package Support Framework avec NuGet en exécutant la commande suivante depuis une fenêtre PowerShell administrative :
```
Set-Location "C:\PSF"
.\nuget\nuget.exe install Microsoft.PackageSupportFramework
```

Pour télécharger et installer le SDK Windows 10 :

Téléchargez le Win 10 SDK.
Exécutez winsdksetup.exe.
Cliquez sur Suivant.
Sélectionnez uniquement les trois fonctionnalités suivantes :
- Outils de signature SDK Windows pour les applications de bureau
- SDK Windows pour les applications UWP C++
- SDK Windows pour la localisation des applications UWP
Sélectionnez Installer, puis sélectionnez OK.

Mettez en scène l’application Windows

La mise en place de l’application Windows extrait et décompresse le contenu de l’application dans un répertoire local. Une fois l’application Windows décompressée à l’emplacement de mise en scène, vous pouvez injecter les fichiers de correction PSF pour corriger toute expérience indésirable.

Dans une fenêtre PowerShell administrative, définissez les variables suivantes pour cibler votre fichier d’application spécifique et la version du SDK Windows 10 :

$AppPath          = "C:\PSF\SourceApp\PSFSampleApp.msix"         ## Path to the MSIX App Installer
$StagingFolder    = "C:\PSF\Staging\PSFSampleApp"                ## Path to where the MSIX App will be staged
$OSArchitecture   = "x$((gwmi Win32_Processor).AddressWidth)"    ## Operating System Architecture
$Win10SDKVersion  = "10.0.19041.0"                               ## Latest version of the Win10 SDK

Décompressez l’application Windows dans le dossier de mise en scène en exécutant la cmdlet PowerShell suivante :

## Sets the directory to the Windows 10 SDK
Set-Location "${env:ProgramFiles(x86)}\Windows Kits\10\Bin\$Win10SDKVersion\$OSArchitecture"

## Unpackages the Windows app to the staging folder
.\makeappx.exe unpack /p "$AppPath" /d "$StagingFolder"

Créez et injectez les fichiers PSF requis

Pour corriger l’application Windows, vous créez un fichier config.json avec des informations sur le lanceur d’application Windows qui échoue. Si plusieurs lanceurs d’application Windows rencontrent des problèmes, vous pouvez configurer le fichier config.json avec plusieurs entrées.

Après avoir créé le fichier config.json, déplacez le config.json et les fichiers de correction PSF de support à la racine du package de l’application Windows.

Ouvrez Visual Studio Code ou un autre éditeur de texte.
Créez un nouveau fichier nommé config.json dans le répertoire de mise en scène de l’application Windows, C:\PSF\Staging\PSFSampleApp.

Copiez le code suivant dans le nouveau fichier config.json.

{
    "applications": [
        {
            "id": "",
            "executable": ""
        }
    ],
    "processes": [
        {
            "executable": "",
            "fixups": [
            {
                "dll": "",
                "config": {
                    "redirectedPaths": {
                        "packageRelative": [
                            {
                                "base": "",
                                "patterns": [
                                    ""
                                ]
                            }
                        ]
                    }
                }
            }
        ]
        }
    ]
}

Ouvrez le fichier AppxManifest.xml dans le dossier de mise en scène de l’application Windows. L’exemple suivant montre un fichier AppxManifest.xml :

<Applications>
    <Application Id="PSFSAMPLE" Executable="VFS\ProgramFilesX64\PS Sample App\PSFSample.exe" EntryPoint="Windows.FullTrustApplication">
    <uap:VisualElements BackgroundColor="transparent" DisplayName="PSFSample" Square150x150Logo="Assets\StoreLogo.png" Square44x44Logo="Assets\StoreLogo.png" Description="PSFSample">
        <uap:DefaultTile Wide310x150Logo="Assets\StoreLogo.png" Square310x310Logo="Assets\StoreLogo.png" Square71x71Logo="Assets\StoreLogo.png" />
    </uap:VisualElements>
    </Application>
</Applications>

Apportez les modifications suivantes dans le fichier config.json :
- Définissez la valeur applications.id pour être la même que celle de la rubrique Applications.Application.ID du fichier AppxManifest.xml.
- Définissez la valeur applications.executable pour cibler le chemin relatif à l’application situé dans la rubrique Applications.Application.Executable du fichier AppxManifest.xml.
- Définissez la valeur applications.workingdirectory pour cibler le chemin relatif au dossier dans la rubrique Applications.Application.Executable du fichier AppxManifest.xml.
- Définissez la valeur process.executable pour cibler le nom du fichier, sans chemin et extension, dans la rubrique Applications.Application.Executable du fichier AppxManifest.xml.
- Définissez la valeur processes.fixups.dll pour cibler le FileRedirectionFixup.dll spécifique à l’architecture. Si la correction est pour une architecture x64, définissez la valeur sur FileRedirectionFixup64.dll. Si l’architecture est x86 ou inconnue, définissez la valeur sur FileRedirectionFixup86.dll.
- Définissez la valeur processes.fixups.config.redirectedPaths.packageRelative.base pour le chemin relatif au package dans la rubrique Applications.Application.Executable du fichier AppxManifest.xml.
- Définissez la valeur processes.fixups.config.redirectedPaths.packageRelative.patterns pour correspondre au type de fichier créé par l’application. Si vous utilisez .*\\.log, le PSF redirige toutes les écritures de fichiers journaux dans le répertoire processes.fixups.config.redirectedPaths.packageRelative.base et les sous-répertoires.

Enregistrez le fichier config.json mis à jour. L’exemple suivant montre un fichier config.json mis à jour :

{
    "applications": [
        {
        "id": "PSFSample",
        "executable": "VFS/ProgramFilesX64/PS Sample App/PSFSample.exe"
        }
    ],
    "processes": [
        {
            "executable": "PSFSample",
            "fixups": [
                {
                    "dll": "FileRedirectionFixup64.dll",
                    "config": {
                        "redirectedPaths": {
                            "packageRelative": [
                                {
                                    "base": "VFS/ProgramFilesX64/PS Sample App/",
                                    "patterns": [
                                        ".*\\.log"
                                    ]
                                }
                            ]
                        }
                    }
                }
            ]
        }
    ]
}

Copiez les fichiers suivants du Package Support Framework pour l’architecture exécutable de l’application à la racine de l’application Windows mise en scène. Vous pouvez trouver les fichiers dans .\Microsoft.PackageSupportFramework.\<Version>\bin.

Application (x64)	Application (x86)
PSFLauncher64.exe	PSFLauncher32.exe
PSFRuntime64.dll	PSFRuntime32.dll
PSFRunDll64.exe	PSFRunDll32.exe
FileRedirectionFixup64.dll	FileRedirectionFixup64.dll

Mettez à jour l’AppxManifest

Après avoir créé et mis à jour le fichier config.json, mettez à jour le fichier AppxManifest.xml de l’application Windows pour chaque lanceur d’application Windows que vous avez inclus dans le config.json. Le AppxManifest.xml Applications doit maintenant cibler le PSFLauncher.exe associé à l’architecture de l’application.

Ouvrez AppxManifest.xml dans le dossier de l’application MSIX mise en scène, C:\PSF\Staging\PSFSampleApp.

Mettez à jour le AppxManifest.xml avec le code suivant :

<Package ...>
...
<Applications>
    <Application Id="PSFSample"
                Executable="PSFLauncher32.exe"
                EntryPoint="Windows.FullTrustApplication">
    ...
    </Application>
</Applications>
</Package>

Repackagez l’application

Après avoir appliqué toutes les corrections, repackagez l’application Windows dans un MSIX et signez-la avec un certificat de signature de code.

Ouvrez une fenêtre PowerShell administrative.

Définissez les variables suivantes :

$AppPath          = "C:\PSF\SourceApp\PSFSampleApp_Updated.msix" ## Path to the MSIX App Installer
$CodeSigningCert  = "C:\PSF\Cert\CodeSigningCertificate.pfx"     ## Path to your code signing certificate
$CodeSigningPass  = "<Password>"                                 ## Password used by the code signing certificate
$StagingFolder    = "C:\PSF\Staging\PSFSampleApp"                ## Path to where the MSIX App will be staged
$OSArchitecture   = "x$((gwmi Win32_Processor).AddressWidth)"    ## Operating System Architecture
$Win10SDKVersion  = "10.0.19041.0"                               ## Latest version of the Win10 SDK

Repackagez l’application Windows depuis le dossier de mise en scène en exécutant la cmdlet PowerShell suivante :

Set-Location "${env:ProgramFiles(x86)}\Windows Kits\10\Bin\$Win10SDKVersion\$OSArchitecture"
.\makeappx.exe pack /p "$AppPath" /d "$StagingFolder"

Signez l’application Windows en exécutant la cmdlet PowerShell suivante :

Set-Location "${env:ProgramFiles(x86)}\Windows Kits\10\Bin\$Win10SDKVersion\$OSArchitecture"
.\signtool.exe sign /v /fd sha256 /f $CodeSigningCert /p $CodeSigningPass $AppPath

Partager via