Guide pratique pour corriger les erreurs d’autorisation d’écriture du système de fichiers framework de prise en charge du package

  • Article

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.

Investigation

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.

  1. Téléchargez et extrayez sysInternals Process Monitor dans le répertoire C :\PSF\ProcessMonitor .

  2. Ouvrez l’Explorateur Windows et accédez au dossier SysInternals ProcessMonitor extrait.

  3. Sélectionnez le fichier Procmon.exe sysInternals Process Monitor pour lancer l’application.

  4. Si vous y êtes invité par UAC, sélectionnez Oui.

  5. Dans la fenêtre Filtre du moniteur de processus, sélectionnez Nom du processus dans le menu déroulant du premier champ.

  6. Vérifiez qu’il apparaît dans le champ suivant.

  7. Dans le champ suivant, entrez le nom du processus de votre application, par exemple PSFSample.exe.

    Example of the Process Monitor Filter window with app name.

  8. Sélectionnez Ajouter.

  9. Dans la fenêtre Filtre du moniteur de processus, sélectionnez Résultat dans le menu déroulant du premier champ.

  10. Dans le champ suivant, la sélection n’est pas dans le menu déroulant.

  11. Dans le champ texte, entrez SUCCESS.

    Example of the Process Monitor Filter window with Result.

  12. Sélectionnez Ajouter, puis OK.

  13. 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 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.

Displays the error message witnessed in the SysInternals Process Monitor for failure to write to directory.

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 :

  1. Extrayez le contenu de l’application Windows dans un répertoire intermédiaire local.
  2. Créez un fichier config.json et injectez les fichiers de correctif PSF dans le répertoire d’application Windows intermédiaire.
  3. 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.
  4. Mettez à jour le fichier AppxManifest de l’application Windows.
  5. Repackager 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 Shared Computer Toolkit (Kit de développement logiciel Win 10), dernière version
  • Moniteur de processus SysInternals

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

  1. Téléchargez la dernière version non préliminaire de l’outil client NuGet et enregistrez nuget.exe dans C :\PSF\nuget.

  2. 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 :

  1. Téléchargez le Kit de développement logiciel (SDK) Win 10.
  2. Exécutez winsdksetup.exe .
  3. Cliquez sur Suivant.
  4. 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
  5. Sélectionnez Installer, puis ok.

Étape de l’application Windows

La mise en lots de l’application Windows extrait et annule 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 PSF pour corriger les expériences indésirables.

  1. 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

  2. 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 le fichier config.json et la prise en charge des fichiers de correction PSF à la racine du package d’application Windows.

  1. Ouvrez Visual Studio Code ou un autre éditeur de texte.

  2. Créez un fichier nommé config.json dans le répertoire intermédiaire de l’application Windows, C :\PSF\Staging\PSFSampleApp.

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

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

  4. 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>

  5. 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 .

      Image showing the location of the ID within the AppxManifest file.

    • 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 .

      Image showing the location of the executable within the *AppxManifest.xml* file.

    • Définissez la applications.workingdirectory valeur pour cibler le chemin du dossier relatif dans le Applications.Application.Executable champ du fichier AppxManifest.xml .

      Image showing the location of the working directory within the AppxManifest file.

    • 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 .

      Image showing the location of the process executable within the AppxManifest file.

    • Définissez la processes.fixups.dll valeur pour cibler l’architecture spécifique FileRedirectionFixup.dllà l’architecture. 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 .

      Image showing the location of the working directory within the AppxManifest file.

    • 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, psF redirige toutes les écritures de fichier journal dans le processes.fixups.config.redirectedPaths.packageRelative.base répertoire et les répertoires enfants.

  6. 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"
                                    ]
                                }
                            ]
                        }
                    }
                }
            ]
        }
    ]
}

  7. Copiez les fichiers suivants à partir du Package Support Framework pour l’architecture 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)
    PSF Lanceur 64.exe PSF Lanceur 32.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. AppxManifest.xml Applications doit maintenant cibler le fichier PSF Lanceur.exe associé à l’architecture de l’application.

  1. Ouvrez AppxManifest.xml dans le dossier d’application MSIX intermédiaire, C :\PSF\Staging\PSFSampleApp.
  2. 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.

  1. Ouvrez une fenêtre PowerShell Administration istrative.

  2. 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

  3. 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"

  4. 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