Guide pratique pour corriger les erreurs d’autorisations en écriture du système de fichiers du Framework de prise en charge des packages

2025-04-30

Cet article explique comment utiliser l’infrastructure de support de package (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’applications 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.

Enquête

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

Capturer 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 les résultats qui ne sont pas réussis.

Téléchargez et extrayez sysInternals Process Monitor dans le répertoire C :\PSF\ProcessMonitor .
Ouvrez l’Explorateur Windows et accédez au dossier SysInternals ProcessMonitor extrait.
Sélectionnez le fichier sysInternals Process Monitor procmon.exe 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 est 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 Filtre du moniteur de processus , sélectionnez Résultat dans le menu déroulant du premier champ.
Dans le champ suivant, sélectionnez n’est pas 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.

Passer en revue les journaux d’échec de l’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 Access refusé, avec une information détaillée Accès souhaité : Écriture générique, pour votre application ciblant C :\Program Files\WindowsApps\...\, vous avez identifié un échec d’autorisation en écriture lié au répertoire de travail.

Affiche le message d’erreur observé dans le moniteur de processus SysInternals pour l’échec de l’é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’application Windows qui n’a pas réussi à écrire dans le conteneur d’applications Windows, procédez comme suit :

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

Télécharger et installer les outils requis

Ce processus nécessite les outils suivants :

Outil client NuGet
Framework de prise en charge des packages
Kit de développement logiciel Windows 10 (SDK Win 10), dernière version
Moniteur de processus SysInternals

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

Téléchargez la dernière version non préliminaire de l’outil client NuGet et enregistrez nuget.exe en C :\PSF\nuget.
Téléchargez et installez Package Support Framework 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 C++ UWP
- Sdk Windwos pour la localisation des applications UWP
Sélectionnez Installer, puis ok.

Effectuer une copie intermédiaire de l’application Windows

La copie temporaire de l’application Windows extrait et décompresse le contenu de l’application dans un répertoire local. Une fois que l’application Windows est décompressée à l’emplacement intermédiaire, vous pouvez injecter des fichiers de correction du Framework de prise en charge des packages 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 la version du Kit de développement logiciel (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 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 des 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 ce fichier et les fichiers de correction du Framework de prise en charge des packages concernés à la racine dans 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 de l’application 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 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 applications.id valeur comme 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 et extension, dans le Applications.Application.Executable champ du fichier AppxManifest.xml .
- Définissez la valeur processes.fixups.dll 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 inconnue, définissez la valeur FileRedirectionFixup86.dllsur .
- 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 valeur pour qu’elle processes.fixups.config.redirectedPaths.packageRelative.patterns corresponde au type de fichier créé par l’application. Si vous utilisez .*\\.log, le PSF redirige toutes les écritures de fichier journal dans le répertoire processes.fixups.config.redirectedPaths.packageRelative.base et ses 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 du Framework de prise en charge des packages pour l’architecture de l’exécutable de l’application à 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 le config.json. Le AppxManifest.xmlApplications doit maintenant cibler le PSFLauncher.exe associé à l’architecture de l’application.

Ouvrez AppxManifest.xml dans le dossier d’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>

Repackager 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 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

Repackez 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