Framework di supporto pacchetti-correzione autorizzazione di scrittura file SystemPackage Support Framework - Filesystem Write Permission fixup

Ricerca della causaInvestigation

App di Windows reindirizza le directory specifiche correlate all'applicazione alla cartella del contenitore delle app Windows.Windows Apps will redirect specific directories that are related to the application to the Windows App container folder. Se un'applicazione tenta di scrivere nel contenitore dell'app di Windows, verrà generato un errore e la scrittura avrà esito negativo.If an application attempts to write to the Windows App container, an error will trigger, and the write will fail.

Per risolvere questo problema, è possibile usare il Framework di supporto pacchetti (PSF).Using the Package Support Framework (PSF), enhancements can be made to the Windows App package to resolve this issue. In primo luogo, è necessario identificare l'errore e i percorsi di directory richiesti dall'app.First, we must identify the failure, and directory paths that are being requested by the app.

Acquisisci errore app WindowsCapture the Windows App Failure

Il filtraggio dei risultati è un passaggio facoltativo che rende più semplice la visualizzazione degli errori correlati alle applicazioni.Filtering the results is an optional step, that will make viewing application related failures easier. A tale scopo, vengono create due regole di filtro.To do this, we will create two filter rules. Il primo è un filtro di inclusione per il nome del processo dell'applicazione e il secondo è un'inclusione di tutti i risultati che non hanno esito positivo.The first an include filter for the application process name, and the second is an inclusion of any results that are not successful.

  1. Scaricare ed estrarre il Monitor di processo Sysinternals nella directory C:\PSF\ProcessMonitorDownload and extract the SysInternals Process Monitor to the C:\PSF\ProcessMonitor directory.
  2. Aprire Esplora risorse e passare alla cartella di monitoraggio del processo SysInternals estrattaOpen Windows Explorer and navigate to the extracted SysInternals Process Monitor Folder
  3. Fare doppio clic sul file di monitoraggio di processo SysInternals (procmon.exe), avviando l'app.Double-click the SysInternals Process Monitor (procmon.exe) file, launching the app.
  4. Se richiesto da UAC, selezionare il pulsante .If prompted by UAC, select the Yes button.
  5. Nella finestra Filtro del processo di monitoraggio selezionare il primo menu a discesa con l' architettura.In the Process Monitor Filter Window, select the first drop-down menu labeled with Architecture.
  6. Selezionare nome processo dal menu a discesa.Select Process Name from the drop-down menu.
  7. Nel menu a discesa successivo verificare che sia impostato con il valore di è.In the next drop-down menu, verify that it is set with the value of is.
  8. Nel campo di testo digitare il nome del processo dell'app, ad esempio: PSFSample.exe.In the text field type the process name of your App (Example: PSFSample.exe). Esempio di finestre filtro di monitoraggio processo con nome app
  9. Fare clic sul pulsante Aggiungi.Select the Add button.
  10. Nella finestra Filtro del processo di monitoraggio selezionare il primo menu a discesa con etichetta nome processo.In the Process Monitor Filter Window, select the first drop-down menu labeled Process Name.
  11. Selezionare risultato dal menu a discesa.Select Result from the drop-down menu.
  12. Nel menu a discesa successivo selezionarlo e selezionare non è presente nel menu a discesa.In the next drop-down menu, select it, and select is not from the drop-down menu.
  13. Nel campo testo digitare: Success.In the text field type: SUCCESS. Esempio di finestre filtro di monitoraggio processo con risultato
  14. Fare clic sul pulsante Aggiungi.Select the Add button.
  15. Selezionare il pulsante OK .Select the Ok button.
  16. avviare l'app di Windows, attivare l'errore e chiudere l'app di Windows.launch the Windows App, trigger the error, and close the Windows App.

Esaminare i log degli errori delle app WindowsReview the Windows App Failure Logs

Dopo l'acquisizione dei processi delle app di Windows, sarà necessario esaminare i risultati per identificare se l'errore è correlato alla directory di lavoro.After capturing the Windows App processes, the results will need to be investigated to identify if the failure is related to the working directory.

  1. Esaminare i risultati di monitoraggio processo SysInternals, cercando gli errori descritti nella tabella precedente.Review the SysInternals Process Monitor results, searching for failures outlined in the above table.
  2. Se i risultati mostrano un risultato "nome non trovato" , con i dettagli "accesso desiderato:..." per l'app specifica destinata a una directory esterna a "C:\Program Files\WindowsApps \ ... \ " come illustrato nell'immagine seguente, è stato identificato correttamente un errore correlato alla directory di lavoro. per informazioni su come applicare la correzione di PSF all'app, usare l'articolo relativo all' accesso al file di supporto di PSF .If the results show an "Name Not Found" result, with the details "Desired Access: ..." for your specific app targeting a directory outside of the "C:\Program Files\WindowsApps\...\" (as seen in the below image), then you have successfully identified a failure related with the working directory, use the PSF Support - Filesystem Access article for guidance on how to apply the PSF correction to your app. Visualizza il messaggio di errore visualizzato nel monitoraggio di processo SysInternals per la mancata scrittura nella directory.

SoluzioneResolution

App di Windows reindirizza le directory specifiche correlate all'applicazione alla cartella del contenitore delle app Windows.Windows Apps will redirect specific directories that are related to the application to the Windows App container folder. Se un'applicazione tenta di scrivere nel contenitore dell'app di Windows, verrà generato un errore e la scrittura avrà esito negativo.If an application attempts to write to the Windows App container, an error will trigger, and the write will fail.

Per risolvere il problema relativo all'impossibilità di scrivere nel contenitore dell'app di Windows, è necessario seguire i quattro passaggi seguenti:To resolve the issue related to the Windows App failing to write to the Windows App container, we must follow the following four steps:

  1. Organizzare l'app di Windows in una directory localeStage the Windows App to a local directory
  2. Creare il Config.jse inserire i file PSF necessariCreate the Config.json and inject required PSF Files
  3. Aggiornare il file AppxManifest dell'app WindowsUpdate the Windows App AppxManifest file
  4. Riassemblare e firmare l'app WindowsRepackage and sign the Windows App

I passaggi precedenti forniscono indicazioni per l'estrazione del contenuto dell'app di Windows in una directory di staging locale, l'inserimento dei file di correzione di PSF nella directory dell'app di Windows di gestione temporanea, la configurazione dell'utilità di avvio delle applicazioni in modo che punti all'utilità di avvio di PSF, quindi la configurazione del config.jsPSF sul file per reindirizzare l'utilità di avvio di PSF all'app specificandoThe above steps provide guidance through extracting the content of the Windows App to a local staged directory, injecting the PSF fixup files into the staged Windows App directory, configuring the Application Launcher to point to the PSF launcher, then configuring the PSF config.json file to redirect the PSF launcher to the app specifying the working directory.

Scaricare e installare gli strumenti necessariDownload and Install Required Tools

Questo processo fornirà le istruzioni per il recupero e l'utilizzo degli strumenti seguenti:This process will guide you through the retrieval of, and usage of the following tools:

  • Strumento client NuGetNuGet Client Tool
  • PSF (Package Support Framework)Package Support Framework
  • Windows 10 SDK (versione più recente)Windows 10 SDK (latest version)
  • Monitoraggio processo SysInternalsSysInternals Process Monitor

Di seguito vengono fornite istruzioni dettagliate per il download e l'installazione degli strumenti necessari.The following will provide step-by-step guidance on downloading and installing the required tools.

  1. Scaricare la versione più recente (non in anteprima) dello strumento client NuGete salvare il nuget.exe nella C:\PSF\nuget cartella.Download the latest (non-preview) version of the NuGet client tool, and save the nuget.exe in the C:\PSF\nuget folder.

  2. Scaricare il Framework di supporto pacchetti usando NuGet eseguendo il comando seguente da una finestra di PowerShell amministrativa:Download the Package Support Framework using Nuget by running the following from an Administrative PowerShell window:

    Set-Location "C:\PSF"
    .\nuget\nuget.exe install Microsoft.PackageSupportFramework
    
  3. Scaricare e installare Windows 10 Software Development Toolkit (Win 10 SDK).Download and install the Windows 10 Software Development Toolkit (Win 10 SDK).

    1. Scaricare l' SDK di Win 10.Download the Win 10 SDK.
    2. Eseguire il winsdksetup.exe scaricato nel passaggio precedente.Run the winsdksetup.exe that was downloaded in the previous step.
    3. Selezionare il pulsante Avanti.Select the Next button.
    4. Selezionare solo le tre funzionalità seguenti per l'installazione:Select only the following three features for install:
      • Strumenti di firma Windows SDK per le app desktopWindows SDK Signing Tools for Desktop Apps
      • Windows SDK per le app C++ UWPWindows SDK for UWP C++ Apps
      • Appartenenti SDK per la localizzazione di app UWPWindwos SDK for UWP Apps Localization
    5. Selezionare il pulsante Installa.Select the Install button.
    6. Selezionare il pulsante OK .Select the Ok button.

Organizzare l'app di WindowsStage the Windows App

Con la gestione temporanea dell'app di Windows, il contenuto dell'app di Windows verrà estratto o deselezionato in una directory locale.By staging the Windows App, we will be extracting / unpackaging the contents of the Windows App to a local directory. Una volta decompresso l'app di Windows nel percorso di gestione temporanea, è possibile inserire i file di correzione PSF per correggere eventuali esperienze indesiderate.Once the Windows App has been unpacked to the staging location, PSF fixup files can be injected correcting any unwanted experiences.

  1. Aprire una finestra di PowerShell amministrativa.Open an Administrative PowerShell window.

  2. Impostare le variabili seguenti destinate al file dell'app specifico e alla versione di Windows 10 SDK:Set the following variables targeting your specific app file, and Windows 10 SDK version:

    $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
    
  3. Decomprimere l'app Windows nella cartella di gestione temporanea eseguendo il cmdlet di PowerShell seguente:Unpack the Windows App to the staging folder by running the following PowerShell cmdlet:

    ## 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"
    

Creare e inserire i file PSF necessariCreate and inject required PSF Files

Per applicare le azioni correttive all'app di Windows, è necessario creare un config.jsnel file e fornire le informazioni sull'utilità di avvio delle app di Windows che ha avuto esito negativo.To apply corrective actions to the Windows App the a config.json file must be created, and supplied with information about the Windows App Launcher that is failing. Se sono presenti più lanci di app di Windows che riscontrano problemi, è possibile aggiornare il config.jssu file con più voci.If there are multiple Windows App Launchers that are experiencing issues, the config.json file can be updated with multiple entries.

Dopo l'aggiornamento del config.jsnel file, i file di correzione di config.jssu file e per il supporto di FPF devono essere spostati nella radice del pacchetto dell'app di Windows.After updating the config.json file, the config.json file and supporting PSF fixup files must then be moved into the root of the Windows App package.

  1. Aprire Visual Studio Code (VS Code) o qualsiasi altro editor di testo.Open Visual Studio Code (VS Code), or any other text editor.

  2. Creare un nuovo file selezionando il menu file nella parte superiore della vs code, selezionando nuovo file dal menu a discesa.Create a new file, by selecting the File menu at the top of the VS Code, selecting New File from the drop-down menu.

  3. Salvare il file come config.jsin, selezionare il menu file nella parte superiore della finestra vs code, quindi scegliere Salva dal menu a discesa.Save the file as config.json, by select the File menu at the top of the VS Code window, selecting Save from the drop-down menu. Nella finestra Salva con nome passare alla directory di gestione temporanea dell'app di Windows (C:\PSF\Staging\PSFSampleApp) e impostare il nome del file come config.json .In the Save As window, navigate to the Windows App Staging directory (C:\PSF\Staging\PSFSampleApp) and set the File Name as config.json. Fare clic sul pulsante Salva.Select the Save button.

  4. Copiare il codice seguente nelconfig.jsappena creato sul file.Copy the following code to the newly created config.json file.

    {
        "applications": [
            {
                "id": "",
                "executable": ""
            }
        ],
        "processes": [
            {
                "executable": "",
                "fixups": [
                {
                    "dll": "",
                    "config": {
                        "redirectedPaths": {
                            "packageRelative": [
                                {
                                    "base": "",
                                    "patterns": [
                                        ""
                                    ]
                                }
                            ]
                        }
                    }
                }
            ]
            }
        ]
    }
    
  5. Aprire il file appxmanifest dell'app Windows di gestione temporanea che si trova nella cartella di gestione temporanea delle app windows (C:\PSF\Staging\PSFSampleApp\AppxManifest.xml) utilizzando vs code o un altro editor di testo.Open the staged Windows App AppxManifest file located in the Windows App staging folder (C:\PSF\Staging\PSFSampleApp\AppxManifest.xml) using VS Code, or another text editor.

    <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>
    
  6. Impostare il applications.id valore del config.jssu in modo che corrisponda al valore trovato nel campo Applications.Application.ID del file di AppxManifest.xml .Set the applications.id value in the config.json to be the same value as found in the Applications.Application.ID field of the AppxManifest.xml file. Immagine che circonda il percorso dell'ID all'interno del file AppxManifest.

  7. Impostare il applications.executable valore nella config.jssu per fare riferimento al percorso relativo dell'applicazione che si trova nel campo Applications.Application.Executable del file AppxManifest.xml .Set the applications.executable value in the config.json to target the relative path to the application located in Applications.Application.Executable field of the AppxManifest.xml file. Immagine che circonda il percorso dell'eseguibile all'interno del file AppxManifest.

  8. Impostare il applications.workingdirectory valore nell' config.js in modo che sia destinato al percorso della cartella relativo trovato nel campo Applications.Application.Executable del file AppxManifest.xml .Set the applications.workingdirectory value in the config.json to target the relative folder path found in the Applications.Application.Executable field of the AppxManifest.xml file. Immagine che circonda il percorso della directory di lavoro all'interno del file AppxManifest.

  9. Impostare il process.executable valore nell' config.js in modo che abbia come destinazione il nome file (senza percorso ed estensioni) trovato nel campo Applications.Application.Executable del file AppxManifest.xml .Set the process.executable value in the config.json to target the file name (without path and extensions) found in the Applications.Application.Executable field of the AppxManifest.xml file. Immagine che circonda il percorso dell'eseguibile del processo all'interno del file AppxManifest.

  10. Impostare il processes.fixups.dll valore nell' config.js in modo che abbia come destinazione la FileRedirectionFixup.dll specifica dell'architettura.Set the processes.fixups.dll value in the config.json to target the architecture specific FileRedirectionFixup.dll. Se la correzione è per l'architettura x64, impostare il valore su FileRedirectionFixup64.dll.If correction is for x64 architecture, set the value to be FileRedirectionFixup64.dll. Se l'architettura è x86 o è sconosciuta, impostare il valore su FileRedirectionFixup86.dllIf the architecture is x86, or is unknown, set the value to be FileRedirectionFixup86.dll

  11. Impostare il processes.fixups.config.redirectedPaths.packageRelative.base valore nell' config.jssul percorso della cartella relativa del pacchetto, come riportato nella Applications.Application.Executable del file di AppxManifest.xml .Set the processes.fixups.config.redirectedPaths.packageRelative.base value in the config.json to the package relative folder path as found in the Applications.Application.Executable of the AppxManifest.xml file. Immagine che circonda il percorso della directory di lavoro all'interno del file AppxManifest.

  12. Impostare il processes.fixups.config.redirectedPaths.packageRelative.patterns valore nel file config.js in modo che corrisponda al tipo di file creato dall'applicazione.Set the processes.fixups.config.redirectedPaths.packageRelative.patterns value in the config.json file to match the file type being created by the application. Utilizzando ". * \ . log" , PSF reindirizza le Scritture per tutti i file di log presenti nella directory identificata nel percorso processes.fixups.config. redirectedPaths. packageRelative. base , nonché nelle directory figlio.By using ".*\.log" the PSF will redirect writes for all log files that are in the directory identified in the processes.fixups.config.redirectedPaths.packageRelative.base path, as well as child directories.

  13. Salvare il config.jsaggiornato sul file.Save the updated config.json file.

    {
        "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"
                                        ]
                                    }
                                ]
                            }
                        }
                    }
                ]
            }
        ]
    }
    
  14. Copiare i quattro file seguenti dal framework di supporto del pacchetto in base all'architettura eseguibile dell'applicazione alla radice dell'app di Windows di gestione temporanea.Copy the following four files from the Package Support Framework based on the application executable architecture to the root of the staged Windows App. I file seguenti si trovano all'interno di .\Microsoft.PackageSupportFramework. \bin.The following files are located within the .\Microsoft.PackageSupportFramework.\bin.

    Applicazione (x64)Application (x64) Applicazione (x86)Application (x86)
    PSFLauncher64.exePSFLauncher64.exe PSFLauncher32.exePSFLauncher32.exe
    PSFRuntime64.dllPSFRuntime64.dll PSFRuntime32.dllPSFRuntime32.dll
    PSFRunDll64.exePSFRunDll64.exe PSFRunDll32.exePSFRunDll32.exe
    FileRedirectionFixup64.dllFileRedirectionFixup64.dll FileRedirectionFixup64.dllFileRedirectionFixup64.dll

Aggiornare AppxManifestUpdate AppxManifest

Dopo la creazione e l'aggiornamento del config.jsnel file, è necessario aggiornare l' AppxManifest.xml dell'app di Windows per ogni utilità di avvio delle app di Windows inclusa nel config.js.After creating and updating the config.json file, the Windows App's AppxManifest.xml must be updated for each Windows App Launcher that was included in the config.json. Le applicazioni di appxmanifest devono ora avere come destinazione le PSFLauncher.exe associate all'architettura delle applicazioni.The AppxManifest's Applications must now target the PSFLauncher.exe associated with the applications architecture.

  1. Aprire Esplora file e passare alla cartella dell'app MSIX di gestione temporanea (C:\PSF\Staging\PSFSampleApp).Open File Explorer, and navigate to the Staged MSIX App folder (C:\PSF\Staging\PSFSampleApp).

  2. Fare clic con il pulsante destro del mouse su AppxManifest.xml e scegliere Apri con codice dal menu a discesa. Facoltativamente, è possibile aprire con un altro editor di testo.Right-click on AppxManifest.xml, and select Open with Code from the drop-down menu (Optionally, you can open with another text editor).

  3. Aggiornare il file di AppxManifest.xml con le seguenti informazioni:Update the AppxManifest.xml file with the following information:

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

Ricreare il pacchetto dell'applicazioneRe-package the application

Sono state applicate tutte le correzioni, ora è possibile ricreare il pacchetto dell'app di Windows in un MSIX e firmarla usando un certificato di firma codice.All of the corrections have been applied, now the Windows App can be re-packaged into an MSIX and signed using a code signing certificate.

  1. Aprire una finestra di PowerShell amministrativa.Open an Administrative PowerShell Window.

  2. Impostare le variabili seguenti:Set the following variables:

    $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. Ricomprimere l'app di Windows dalla cartella di gestione temporanea eseguendo il cmdlet di PowerShell seguente:Repack the Windows App from the staging folder by running the following PowerShell cmdlet:

    Set-Location "${env:ProgramFiles(x86)}\Windows Kits\10\Bin\$Win10SDKVersion\$OSArchitecture"
    .\makeappx.exe pack /p "$AppPath" /d "$StagingFolder"
    
  4. Firmare l'app Windows eseguendo il cmdlet di PowerShell seguente:Sign the Windows App by running the following PowerShell cmdlet:

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