Condividi tramite


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 alla C:\Program Files\WindowsApps cartella. Se l'applicazione tenta di scrivere nel contenitore di app di Windows, viene attivato un errore e la scrittura ha esito negativo. Puoi apportare miglioramenti al pacchetto dell'app di Windows per risolvere questo problema.

Analisi

Identificare prima di tutto l'errore e i percorsi di 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 procmon.exe SysInternals Process Monitor per avviare l'app.

  4. Se richiesto da Controllo dell'account utente, selezionare .

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

  6. Verificare che sia 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. Seleziona Aggiungi.

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

  10. Nel campo successivo selezionare non è disponibile nel 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 delle 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 Monitoraggio processo SysInternals. Se i risultati includono Accesso negato, con un dettaglio di accesso desiderato: 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'errore di scrittura dell'app di Windows nel contenitore di app di Windows, seguire questa procedura:

  1. Estrarre il contenuto dell'app di Windows in una directory di staging locale.
  2. Creare un file config.json e inserire i file di correzione PSF nella directory dell'app windows di staging.
  3. Configurare l'utilità di avvio dell'applicazione in modo che punti all'utilità di avvio PSF e configurare il file PSF config.json per reindirizzare l'utilità di avvio PSF, specificando la directory di lavoro.
  4. Aggiornare il file AppxManifest dell'app di Windows.
  5. Creare nuovamente il pacchetto 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
  • SysInternals Process Monitor

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 amministrativa di PowerShell:

    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
    • App C++ di Windows SDK per UWP
    • Windwos SDK per la localizzazione di app UWP
  5. Selezionare Installa e quindi OK.

Preparare 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 che l'app di Windows viene decompressa nel percorso di gestione temporanea, puoi inserire file di correzione PSF per correggere eventuali esperienze indesiderate.

  1. In una finestra amministrativa di PowerShell impostare le variabili seguenti per specificare come destinazione il file dell'app 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, creare un file config.json con informazioni sull'utilità di avvio delle app di Windows che ha esito negativo. Se si verificano problemi con più utilità di avvio delle 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 dell'app di Windows. L'esempio seguente mostra un file 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. Apportare le modifiche seguenti nel file config.json :

    • Impostare il applications.id valore su come Applications.Application.ID nel campo del file AppxManifest.xml .

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

    • Impostare il applications.executable valore su come destinazione del percorso relativo dell'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 AppxManifest.xml .

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

    • Impostare il process.executable valore su come destinazione del nome 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.dlldell'architettura. 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 in modo che corrisponda al tipo di file creato dall'applicazione. Se si usa .*\\.log, psf reindirizza tutte le scritture di file di log nella processes.fixups.config.redirectedPaths.packageRelative.base directory e nelle directory figlio.

  6. Salvare il file config.json aggiornato. L'esempio seguente mostra 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 di gestione temporanea. È 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 AppxManifest.xml dell'app di Windows per ogni utilità di avvio delle app di Windows inclusa in config.json. AppxManifest.xml Applications deve ora avere come destinazione PSFLauncher.exeassociato all'architettura dell'applicazione.

  1. Aprire AppxManifest.xml nella cartella dell'app MSIX a fasi 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, riapplicare l'app di Windows in un file MSIX e firmarla con un certificato di firma del codice.

  1. Aprire una finestra di PowerShell Amministrazione istrativa.

  2. Imposta 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 di Windows dalla cartella di gestione temporanea 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