Comment corriger les erreurs d’autorisation d’écriture du système de fichiers de l’infrastructure de package

Article
07/11/2023

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

Les applications Windows redirigent des répertoires spécifiques liés à l’application vers le C:\Program Files\WindowsApps dossier. 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.

Investigation

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

Capture de l’échec de l’application Windows

Le filtrage des résultats est facultatif, mais permet de voir plus facilement les échecs liés à l’application. Pour filtrer les résultats, vous créez deux règles de filtre. Le premier filtre inclut le nom du processus d’application, et le deuxième filtre inclut tous les résultats qui n’ont pas abouti.

Téléchargez et extrayez le moniteur de processus SysInternals dans le répertoire C:\PSF\ProcessMonitor .
Ouvrez Windows Explorer et accédez au dossier SysInternals ProcessMonitor extrait.
Sélectionnez le fichier procmon.exe SysInternals Process Monitor pour lancer l’application.
Si vous y êtes invité par UAC, sélectionnez Oui.
Dans la fenêtre Filtre du moniteur de processus, sélectionnez Nom du processus dans le menu déroulant du premier champ.
Vérifiez que s’affiche 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 Filtre du moniteur de processus, sélectionnez Résultat dans le menu déroulant du premier champ.
Dans le champ suivant, sélectionnez ne figure pas dans le menu déroulant.
Dans le champ de texte, entrez SUCCESS.
Sélectionnez Ajouter, puis OK.
Lancez l’application Windows, déclenchez l’erreur, puis fermez l’application Windows.

Passer en revue les journaux d’échecs d’application Windows

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

Passez en revue les résultats de l’échec du moniteur de processus SysInternals. Si les résultats incluent Accès refusé, avec un accès souhaité : détail d’écriture générique , pour votre application ciblant C:\Program Files\WindowsApps\...\, vous avez identifié un échec d’autorisation d’écriture lié au répertoire de travail.

Affiche le message d’erreur observé dans le moniteur de processus SysInternals en cas d’é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’écriture de l’application Windows dans le conteneur d’application Windows, procédez comme suit :

Extrayez le contenu de l’application Windows dans un répertoire intermédiaire local.
Créez un fichier config.json et injectez les fichiers de correction PSF dans le répertoire d’application Windows intermédiaire.
Configurez le lanceur d’applications pour qu’il pointe vers le lanceur PSF, et configurez le fichier PSF config.json pour rediriger le lanceur PSF, en spécifiant le répertoire de travail.
Mettez à jour le fichier AppxManifest de l’application Windows.
Reconditionner et signer l’application Windows.

Télécharger et installer les outils requis

Ce processus nécessite les outils suivants :

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

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

Téléchargez la dernière version non préversion de l’outil client NuGet et enregistrez nuget.exe dans C:\PSF\nuget.
Téléchargez et installez l’infrastructure de prise en charge des packages avec NuGet en exécutant la commande suivante à partir d’une fenêtre PowerShell d’administration :
```
Set-Location "C:\PSF"
.\nuget\nuget.exe install Microsoft.PackageSupportFramework
```

Pour télécharger et installer le Kit de développement logiciel (SDK) Windows 10 :

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

Étape de l’application Windows

La mise en préproduction de l’application Windows extrait et désemballe le contenu de l’application dans un répertoire local. Une fois l’application Windows décompressée à l’emplacement intermédiaire, vous pouvez injecter des fichiers de correction PSF pour corriger les expériences indésirables.

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

$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 intermédiaire en exécutant l’applet de commande 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éer et injecter les fichiers PSF requis

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

Après avoir créé le fichier config.json , vous déplacez les fichiers config.json et de correction PSF pris en charge vers la racine du package d’application Windows.

Ouvrez Visual Studio Code ou un autre éditeur de texte.
Créez un fichier nommé config.json dans le répertoire intermédiaire des applications Windows, C:\PSF\Staging\PSFSampleApp.

Copiez le code suivant dans le fichier config.json nouvellement créé.

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

Ouvrez le fichier AppxManifest.xml dans le dossier intermédiaire des applications 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 applications.id valeur sur la même valeur que dans le Applications.Application.ID champ du fichier AppxManifest.xml .
- Définissez la applications.executable valeur pour cibler le chemin relatif de l’application située dans le Applications.Application.Executable champ du fichier AppxManifest.xml .
- Définissez la applications.workingdirectory valeur pour cibler le chemin du dossier relatif dans le Applications.Application.Executable champ du fichier AppxManifest.xml .
- Définissez la process.executable valeur pour cibler le nom de fichier, sans chemin d’accès ni extension, dans le Applications.Application.Executable champ du fichier AppxManifest.xml .
- Définissez la processes.fixups.dll valeur pour cibler l’architecture spécifique FileRedirectionFixup.dll. Si la correction concerne l’architecture x64, définissez la valeur sur FileRedirectionFixup64.dll. Si l’architecture est x86 ou est inconnue, définissez la valeur sur FileRedirectionFixup86.dll.
- Définissez la processes.fixups.config.redirectedPaths.packageRelative.base valeur sur le chemin du dossier relatif au package dans le Applications.Application.Executable champ du fichier AppxManifest.xml .
- Définissez la processes.fixups.config.redirectedPaths.packageRelative.patterns valeur pour qu’elle corresponde au type de fichier créé par l’application. Si vous utilisez .*\\.log, le PSF redirige toutes les écritures de fichier journal dans le processes.fixups.config.redirectedPaths.packageRelative.base répertoire et les répertoires enfants.

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 de l’infrastructure de prise en charge des packages pour l’architecture exécutable de l’application vers la racine de l’application Windows intermédiaire. Vous trouverez 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

Mettre à jour 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’applications Windows que vous avez inclus dans config.json. Le AppxManifest.xmlApplications doit désormais cibler les PSFLauncher.exe associées à l’architecture de l’application.

Ouvrez AppxManifest.xml dans le dossier de l’application MSIX intermédiaire, C:\PSF\Staging\PSFSampleApp.

Mettez à jour AppxManifest.xml avec le code suivant :

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

Reconditionner l’application

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

Ouvrez une fenêtre PowerShell d’administration.

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

Remballez l’application Windows à partir du dossier intermédiaire en exécutant l’applet de commande 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 l’applet de commande PowerShell suivante :

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