Come correggere gli errori di autorizzazione di scrittura del file system di Package Support Framework

Questo articolo descrive come usare Package Support Framework (PSF) per risolvere un errore di autorizzazione di scrittura del file system.

Le app di Windows reindirizzano directory specifiche correlate all'applicazione nella cartella contenitore app di Windows. Se l'applicazione tenta di scrivere nel contenitore dell'app di Windows, viene attivato un errore e la scrittura ha esito negativo. È possibile apportare miglioramenti al pacchetto dell'app di Windows per risolvere questo problema.

Analisi

Identificare prima di tutto l'errore e i percorsi della directory richiesti dall'app.

Acquisire l'errore dell'app di Windows

Il filtro dei risultati è facoltativo, ma semplifica la visualizzazione degli errori correlati all'applicazione. Per filtrare i risultati, creare due regole di filtro. Il primo filtro include il nome del processo dell'applicazione e il secondo filtro include tutti i risultati che non hanno esito positivo.

  1. Scaricare ed estrarre sysInternals Process Monitor nella directory C:\PSF\ProcessMonitor .

  2. Aprire Esplora risorse e passare alla cartella SysInternals ProcessMonitor estratta.

  3. Selezionare il file SysInternals Process Monitor procmon.exe per avviare l'app.

  4. Se richiesto dall'interfaccia utente, selezionare .

  5. Nella finestra Filtro monitoraggio processo selezionare Nome processo dal menu a discesa del primo campo.

  6. Verificare che venga visualizzato nel campo successivo.

  7. Nel campo successivo immettere il nome del processo dell'app, ad esempio PSFSample.exe.

    Example of the Process Monitor Filter window with app name.

  8. Selezionare Aggiungi.

  9. Nella finestra Filtro monitoraggio processo selezionare Risultato dal menu a discesa del primo campo.

  10. Nel campo successivo selezionare non è dal menu a discesa.

  11. Nel campo di testo immettere SUCCESS.

    Example of the Process Monitor Filter window with Result.

  12. Selezionare Aggiungi e quindi OK.

  13. Avviare l'app di Windows, attivare l'errore e quindi chiudere l'app di Windows.

Esaminare i log degli errori dell'app di Windows

Dopo aver acquisito i processi dell'app Di Windows, esaminare i risultati per determinare se l'errore è correlato alla directory di lavoro.

Esaminare i risultati degli errori di SysInternals Process Monitor. Se i risultati includono Access negato, con un accesso desiderato: dettagli di scrittura generica , per l'app destinata a C:\Programmi\WindowsApps\...\, è stato identificato un errore di autorizzazione di scrittura correlato alla directory di lavoro.

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

Se si identifica questo errore, applicare la correzione PSF seguente all'app.

Risoluzione

Per risolvere il problema dell'app di Windows che non riesce a scrivere nel contenitore di app di Windows, seguire questa procedura:

  1. Estrarre il contenuto dell'app di Windows in una directory di gestione temporanea locale.
  2. Creare un file config.json e inserire i file di correzione PSF nella directory dell'app windows in fase.
  3. Configurare l'utilità di avvio dell'applicazione per puntare al launcher PSF e configurare il file PSF config.json per reindirizzare il launcher PSF, specificando la directory di lavoro.
  4. Aggiornare il file app AppxManifest di Windows.
  5. Ripacchetto e firmare l'app di Windows.

Scaricare e installare gli strumenti necessari

Questo processo richiede gli strumenti seguenti:

  • Strumento client NuGet
  • PSF (Package Support Framework)
  • Windows 10 Software Development Toolkit (Win 10 SDK), versione più recente
  • Monitoraggio dei processi SysInternals

Per scaricare e installare NuGet e PSF:

  1. Scaricare la versione non di anteprima più recente dello strumento client NuGet e salvare nuget.exe in C:\PSF\nuget.

  2. Scaricare e installare Package Support Framework con NuGet eseguendo il comando seguente da una finestra di PowerShell amministrativa:

    Set-Location "C:\PSF"
    .\nuget\nuget.exe install Microsoft.PackageSupportFramework
    

Per scaricare e installare Windows 10 SDK:

  1. Scaricare Win 10 SDK.
  2. Eseguire winsdksetup.exe .
  3. Selezionare Avanti.
  4. Selezionare solo le tre funzionalità seguenti:
    • Strumenti di firma di Windows SDK per app desktop
    • Windows SDK per le app C++ UWP
    • Windwos SDK per la localizzazione di app UWP
  5. Selezionare Installa e quindi OK.

Eseguire la fase dell'app Di Windows

La gestione temporanea dell'app di Windows estrae e annulla il pacchetto del contenuto dell'app in una directory locale. Dopo aver decompresso l'app di Windows nel percorso di gestione temporanea, è possibile inserire i file di correzione PSF per correggere eventuali esperienze indesiderate.

  1. In una finestra di PowerShell amministrativa impostare le variabili seguenti per indirizzare il file di app specifico e la versione di Windows 10 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
    
  2. Decomprimere l'app Di Windows nella cartella di staging eseguendo il cmdlet di PowerShell seguente:

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

Per correggere l'app di Windows, si crea un file config.json con informazioni sull'utilità di avvio delle app di Windows che ha esito negativo. Se si verificano problemi di avvio di più app di Windows, è possibile configurare il file config.json con più voci.

Dopo aver creato il file config.json , spostare i file config.json e supportare i file di correzione PSF nella radice del pacchetto dell'app di Windows.

  1. Aprire Visual Studio Code o un altro editor di testo.

  2. Creare un nuovo file denominato config.json nella directory di gestione temporanea dell'app di Windows , C:\PSF\Staging\PSFSampleApp.

  3. Copiare il codice seguente nel file config.json appena creato.

    {
        "applications": [
            {
                "id": "",
                "executable": ""
            }
        ],
        "processes": [
            {
                "executable": "",
                "fixups": [
                {
                    "dll": "",
                    "config": {
                        "redirectedPaths": {
                            "packageRelative": [
                                {
                                    "base": "",
                                    "patterns": [
                                        ""
                                    ]
                                }
                            ]
                        }
                    }
                }
            ]
            }
        ]
    }
    
  4. Aprire il file AppxManifest.xml nella cartella di gestione temporanea delle app di Windows. Nell'esempio seguente viene illustrato un file diAppxManifest.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. Apportare le modifiche seguenti nel file config.json :

    • Impostare il applications.id valore per essere lo stesso valore Applications.Application.ID del campo del file diAppxManifest.xml .

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

    • Impostare il applications.executable valore per indirizzare il percorso relativo all'applicazione che si trova nel Applications.Application.Executable campo del file AppxManifest.xml .

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

    • Impostare il applications.workingdirectory valore su come destinazione del percorso della cartella relativa nel Applications.Application.Executable campo del file diAppxManifest.xml .

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

    • Impostare il valore per indirizzare il process.executable nome del file, senza percorso ed estensione, nel Applications.Application.Executable campo del file AppxManifest.xml .

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

    • Impostare il processes.fixups.dll valore su come destinazione dell'architettura specifica FileRedirectionFixup.dll. Se la correzione è per l'architettura x64, impostare il valore su FileRedirectionFixup64.dll. Se l'architettura è x86 o è sconosciuta, impostare il valore su FileRedirectionFixup86.dll.

    • Impostare il processes.fixups.config.redirectedPaths.packageRelative.base valore sul percorso della cartella relativa al pacchetto nel Applications.Application.Executable campo del file AppxManifest.xml .

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

    • Impostare il processes.fixups.config.redirectedPaths.packageRelative.patterns valore per corrispondere al tipo di file creato dall'applicazione. Se si usa .*\\.log, il psf reindirizza tutte le scritture dei file di log nella directory e nelle processes.fixups.config.redirectedPaths.packageRelative.base directory figlio.

  6. Salvare il file config.json aggiornato. Nell'esempio seguente viene illustrato un file config.json aggiornato:

    {
        "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. Copiare i file seguenti da Package Support Framework per l'architettura eseguibile dell'applicazione nella radice dell'app Windows in fase. È possibile trovare i file in .\Microsoft.PackageSupportFramework.\Version>\<bin.

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

Aggiornare AppxManifest

Dopo aver creato e aggiornato il file config.json , aggiornare il file diAppxManifest.xml dell'app di Windows per ogni avvio dell'app Windows incluso nel file config.json. L'AppxManifest.xml deve ora essere destinate alle PSFLauncher.exeApplications associate all'architettura dell'applicazione.

  1. Aprire AppxManifest.xml nella cartella dell'app MSIX in fase C:\PSF\Staging\PSFSampleApp.
  2. Aggiornare AppxManifest.xml con il codice seguente:
    <Package ...>
    ...
    <Applications>
        <Application Id="PSFSample"
                    Executable="PSFLauncher32.exe"
                    EntryPoint="Windows.FullTrustApplication">
        ...
        </Application>
    </Applications>
    </Package>
    

Ripacchetto dell'applicazione

Dopo aver applicato tutte le correzioni, riconnettere l'app Windows in un MSIX e firmarla con un certificato di firma del codice.

  1. Aprire una finestra di PowerShell amministrativa.

  2. Impostare le variabili seguenti:

    $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 Windows dalla cartella di staging eseguendo il cmdlet di PowerShell seguente:

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

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