Sandboxing di un'app Xamarin.Mac

Questo articolo illustra la sandbox di un'applicazione Xamarin.Mac per il rilascio nell'App Store. Vengono illustrati tutti gli elementi che passano al sandboxing, ad esempio directory di contenitori, diritti, autorizzazioni determinate dall'utente, separazione dei privilegi e imposizione del kernel.

Panoramica

Quando si lavora con C# e .NET in un'applicazione Xamarin.Mac, si ha la stessa possibilità di sandboxre un'applicazione quando si usa Objective-C o Swift.

In questo articolo verranno illustrate le nozioni di base sull'uso del sandboxing in un'applicazione Xamarin.Mac e tutti gli elementi che entrano in sandboxing: directory dei contenitori, entitlement, autorizzazioni determinate dall'utente, separazione dei privilegi e applicazione del kernel. È consigliabile usare prima di tutto l'articolo Hello, Mac , in particolare le sezioni Introduzione a Xcode e Interface Builder e Outlet e Actions , in quanto illustra i concetti e le tecniche chiave che verranno usati in questo articolo.

È possibile esaminare anche la sezione Esposizione di classi/metodi C# al Objective-C documento Internals di Xamarin.Mac, che illustra gli Register attributi e Export usati per collegare le classi C# agli oggetti e agli Objective-C elementi dell'interfaccia utente.

Informazioni sulla sandbox dell'app

La sandbox dell'app offre una difesa avanzata da danni che possono essere causati da un'applicazione dannosa eseguita in un Mac limitando l'accesso che un'applicazione deve alle risorse di sistema.

Un'applicazione non in modalità sandbox ha i diritti completi dell'utente che esegue l'app e può accedere o eseguire qualsiasi operazione che l'utente può eseguire. Se l'app contiene buchi di sicurezza (o qualsiasi framework in uso), un hacker può potenzialmente sfruttare tali punti deboli e usare l'app per assumere il controllo del Mac su cui è in esecuzione.

Limitando l'accesso alle risorse in base all'applicazione, un'app in modalità sandbox offre una linea di difesa contro il furto, il danneggiamento o la finalità dannosa da parte di un'applicazione in esecuzione nel computer dell'utente.

App Sandbox è una tecnologia di controllo di accesso integrata in macOS (applicata a livello di kernel) che fornisce una strategia duplice:

1. La sandbox dell'app consente allo sviluppatore di descrivere come un'applicazione interagirà con il sistema operativo e, in questo modo, viene concesso solo i diritti di accesso necessari per eseguire il processo e non più.
2. La sandbox dell'app consente all'utente di concedere facilmente l'accesso al sistema tramite le finestre di dialogo Apri e Salva, le operazioni di trascinamento della selezione e altre interazioni utente comuni.

Preparazione all'implementazione della sandbox dell'app

Gli elementi di App Sandbox che verranno descritti in dettaglio nell'articolo sono i seguenti:

• Directory dei contenitori
• Diritti
• Autorizzazioni determinate dall'utente
• Separazione dei privilegi
• Applicazione del kernel

Dopo aver compreso questi dettagli, sarà possibile creare un piano per l'adozione della sandbox app nell'applicazione Xamarin.Mac.

In primo luogo, è necessario determinare se l'applicazione è un buon candidato per il sandboxing (la maggior parte delle applicazioni è). Sarà quindi necessario risolvere eventuali incompatibilità dell'API e determinare quali elementi della sandbox dell'app saranno necessari. Infine, esaminare l'uso della separazione dei privilegi per ottimizzare il livello di difesa dell'applicazione.

Quando si adotta la sandbox dell'app, alcuni percorsi del file system usati dall'applicazione saranno diversi. In particolare, l'applicazione avrà una directory contenitore che verrà usata per i file di supporto dell'applicazione, i database, le cache e tutti gli altri file che non sono documenti utente. Sia macOS che Xcode forniscono supporto per eseguire la migrazione di questi tipi di file dai percorsi legacy al contenitore.

Avvio rapido per la sandboxing

In questa sezione verrà creata una semplice app Xamarin.Mac che usa una visualizzazione Web (che richiede una connessione di rete limitata alla sandbox, a meno che non venga richiesta specificamente) come esempio di introduzione alla sandbox dell'app.

Si verificherà che l'applicazione sia effettivamente in modalità sandbox e impari a risolvere gli errori comuni della sandbox dell'app.

Creazione del progetto Xamarin.Mac

Eseguire le operazioni seguenti per creare il progetto di esempio:

1. Avviare Visual Studio per Mac e fare clic sul collegamento Nuova soluzione.

2. Nella finestra di dialogo Nuovo progetto selezionare Mac>App Cocoa App>:

   

3. Fare clic sul pulsante Avanti , immettere MacSandbox per il nome del progetto e fare clic sul pulsante Crea :

   

4. Nel riquadro della soluzione fare doppio clic sul file Main.storyboard per aprirlo per la modifica in Xcode:

   

5. Trascinare una visualizzazione Web nella finestra, ridimensionarla per riempire l'area del contenuto e impostarla per crescere e compattarla con la finestra:

   

6. Creare un punto di uscita per la visualizzazione Web denominata webView:

   

7. Tornare a Visual Studio per Mac e fare doppio clic sul file ViewController.cs nel riquadro della soluzione per aprirlo per la modifica.

8. Aggiungere l'istruzione using seguente: using WebKit;

9. Fare in modo che il ViewDidLoad metodo sia simile al seguente:

   public override void AwakeFromNib ()
   {
       base.AwakeFromNib ();
       webView.MainFrame.LoadRequest(new NSUrlRequest(new NSUrl("http://www.apple.com")));
   }
   

10. Salva le modifiche.

Eseguire l'applicazione e assicurarsi che il sito Web Apple venga visualizzato nella finestra come indicato di seguito:

Firma e provisioning dell'app

Prima di poter abilitare la sandbox dell'app, è necessario effettuare il provisioning e firmare l'applicazione Xamarin.Mac.

Eseguire le operazioni seguenti:

1. Accedere al portale per sviluppatori Apple:

   

2. Selezionare Certificati, Identificatori e Profili:

   

3. In App Mac selezionare Identificatori:

   

4. Creare un nuovo ID per l'applicazione:

   

5. In Profili di provisioning selezionare Sviluppo:

   

6. Creare un nuovo profilo e selezionare Sviluppo di app Mac:

   

7. Selezionare l'ID app creato in precedenza:

   

8. Selezionare gli sviluppatori per questo profilo:

   

9. Selezionare i computer per questo profilo:

   

10. Assegnare un nome al profilo:

    

11. Fare clic sul pulsante Fine.

Importante

In alcuni casi potrebbe essere necessario scaricare il nuovo profilo di provisioning direttamente dal portale per sviluppatori di Apple e fare doppio clic su di esso per installarlo. Potrebbe anche essere necessario arrestare e riavviare Visual Studio per Mac prima di poter accedere al nuovo profilo.

Successivamente, è necessario caricare il nuovo ID app e profilo nel computer di sviluppo. Eseguire le operazioni seguenti:

1. Avviare Xcode e selezionare Preferenze dal menu Xcode :

   

2. Fare clic sul pulsante Visualizza dettagli...

   

3. Fare clic sul pulsante Aggiorna (nell'angolo inferiore sinistro).

4. Fare clic sul pulsante Fine .

Successivamente, è necessario selezionare il nuovo ID app e il profilo di provisioning nel progetto Xamarin.Mac. Eseguire le operazioni seguenti:

1. Nel riquadro della soluzione fare doppio clic sul file Info.plist per aprirlo per la modifica.

2. Assicurarsi che l'identificatore bundle corrisponda all'ID app creato in precedenza (esempio: com.appracatappra.MacSandbox):

   

3. Fare quindi doppio clic sul file Entitlements.plist e verificare che iCloud Key-Value Store e i Contenitori iCloud corrispondano all'ID app creato in precedenza (esempio: com.appracatappra.MacSandbox):

   

4. Salva le modifiche.

5. Nel riquadro della soluzione fare doppio clic sul file di progetto per aprire le opzioni per la modifica:

   

6. Selezionare Firma Mac, quindi selezionare Firma il bundle dell'applicazione e Firmare il pacchetto del programma di installazione. In Profilo di provisioning selezionare quello creato in precedenza:

   

7. Fare clic sul pulsante Fine.

Importante

Potrebbe essere necessario uscire e riavviare Visual Studio per Mac per ottenere il riconoscimento del nuovo ID app e del profilo di provisioning installato da Xcode.

Risoluzione dei problemi di provisioning

A questo punto è consigliabile provare a eseguire l'applicazione e assicurarsi che tutto sia firmato ed eseguito correttamente il provisioning. Se l'app viene ancora eseguita come in precedenza, tutto è buono. In caso di errore, è possibile che venga visualizzata una finestra di dialogo simile alla seguente:

Ecco le cause più comuni dei problemi di provisioning e firma:

• L'ID bundle dell'app non corrisponde all'ID app del profilo selezionato.
• L'ID sviluppatore non corrisponde all'ID sviluppatore del profilo selezionato.
• L'UUID del Mac in cui viene testato non è registrato come parte del profilo selezionato.

Nel caso di un problema, correggere il problema nel portale per sviluppatori Apple, aggiornare i profili in Xcode ed eseguire una compilazione pulita in Visual Studio per Mac.

Abilitare la sandbox dell'app

Per abilitare App Sandbox, selezionare una casella di controllo nelle opzioni dei progetti. Effettuare le operazioni seguenti:

1. Nel riquadro della soluzione fare doppio clic sul file Entitlements.plist per aprirlo per la modifica.

2. Selezionare sia Abilita entitlement che Abilita sandbox app:

   

3. Salva le modifiche.

A questo punto, è stata abilitata la sandbox dell'app, ma non è stato fornito l'accesso di rete necessario per la visualizzazione Web. Se si esegue ora l'applicazione, si otterrà una finestra vuota:

Verifica che l'app sia in modalità sandbox

Oltre al comportamento di blocco delle risorse, esistono tre modi principali per stabilire se un'applicazione Xamarin.Mac è stata eseguita correttamente in modalità sandbox:

1. In Finder controllare il contenuto della ~/Library/Containers/ cartella - Se l'app è in modalità sandbox, sarà presente una cartella denominata come l'identificatore bundle dell'app (ad esempio: com.appracatappra.MacSandbox):

   

2. Il sistema vede l'app come in modalità sandbox in Monitoraggio attività:

   • Avviare Monitoraggio attività (in /Applications/Utilities).
   • Scegliere Visualizza>colonne e verificare che la voce di menu Sandbox sia selezionata.
   • Verificare che la colonna Sandbox sia in Yes lettura per l'applicazione:

   

3. Verificare che il file binario dell'app sia in modalità sandbox:

   • Avviare l'app Terminale.
   • Passare alla directory delle applicazioni bin .
   • Eseguire questo comando: codesign -dvvv --entitlements :- executable_path (dove executable_path è il percorso dell'applicazione):

   

Debug di un'app in modalità sandbox

Il debugger si connette alle app Xamarin.Mac tramite TCP, il che significa che per impostazione predefinita quando si abilita il sandboxing, non è in grado di connettersi all'app, quindi se si tenta di eseguire l'app senza le autorizzazioni appropriate abilitate, viene visualizzato un errore "Impossibile connettersi al debugger".

L'autorizzazione Consenti connessioni di rete in uscita (client) è quella necessaria per il debugger, abilitando questa opzione, in genere sarà possibile eseguire il debug. Poiché non è possibile eseguire il debug senza di esso, la destinazione per msbuild è stata aggiornata CompileEntitlements per aggiungere automaticamente tale autorizzazione ai diritti per qualsiasi app in modalità sandbox solo per le compilazioni di debug. Le build di versione devono usare i diritti specificati nel file entitlement, senza modifiche.

Risoluzione di una violazione della sandbox dell'app

Una violazione sandbox dell'app si verifica se un'applicazione Xamarin.Mac in modalità sandbox ha tentato di accedere a una risorsa che non è consentita in modo esplicito. Ad esempio, la visualizzazione Web non è più in grado di visualizzare il sito Web Apple.

L'origine più comune delle violazioni della sandbox dell'app si verifica quando le impostazioni entitlement specificate in Visual Studio per Mac non soddisfano i requisiti dell'applicazione. Anche in questo caso, tornare all'esempio, i diritti di connessione di rete mancanti che impediscono il funzionamento della visualizzazione Web.

Individuazione delle violazioni della sandbox dell'app

Se si sospetta che si verifichi una violazione della sandbox dell'app nell'applicazione Xamarin.Mac, il modo più rapido per individuare il problema consiste nell'usare l'app console .

Effettuare le operazioni seguenti:

1. Compilare l'app in questione ed eseguirla da Visual Studio per Mac.

2. Aprire l'applicazione console (da /Applications/Utilties/).

3. Selezionare Tutti i messaggi nella barra laterale e immettere sandbox nella ricerca:

   

Per l'app di esempio precedente, è possibile notare che Kernal sta bloccando il network-outbound traffico a causa della sandbox dell'app, poiché non è stato richiesto tale diritto.

Correzione delle violazioni della sandbox dell'app con diritti

Ora che abbiamo visto come trovare le violazioni della sandbox delle app, vediamo come possono essere risolte modificando i diritti dell'applicazione.

Effettuare le operazioni seguenti:

1. Nel riquadro della soluzione fare doppio clic sul file Entitlements.plist per aprirlo per la modifica.

2. Nella sezione Entitlement selezionare la casella di controllo Consenti connessioni di rete in uscita (client):

   

3. Salvare le modifiche apportate all'applicazione.

Se si esegue la procedura precedente per l'app di esempio, compilarla ed eseguirla, il contenuto Web verrà ora visualizzato come previsto.

Approfondimento della sandbox dell'app

I meccanismi di controllo di accesso forniti da App Sandbox sono pochi e facili da comprendere. Tuttavia, il modo in cui la sandbox dell'app verrà adottata da ogni app è univoca e in base ai requisiti dell'app.

Dato il massimo sforzo per proteggere l'applicazione Xamarin.Mac da essere sfruttata da codice dannoso, è necessaria una singola vulnerabilità nell'app (o una delle librerie o dei framework usati) per ottenere il controllo delle interazioni dell'app con il sistema.

La sandbox dell'app è stata progettata per impedire l'acquisizione (o limitare il danno che può causare) consentendo di specificare le interazioni previste dell'applicazione con il sistema. Il sistema concederà solo l'accesso alla risorsa richiesta dall'applicazione per svolgere il proprio lavoro e niente di più.

Durante la progettazione per la sandbox dell'app, si sta progettando per uno scenario peggiore. Se l'applicazione viene compromessa da codice dannoso, è limitata all'accesso solo ai file e alle risorse nella sandbox dell'app.

Diritti e accesso alle risorse di sistema

Come illustrato in precedenza, a un'applicazione Xamarin.Mac che non è stata eseguita la sandbox vengono concessi i diritti completi e l'accesso dell'utente che esegue l'app. Se compromesso da codice dannoso, un'app non protetta può fungere da agente per un comportamento ostile, con un ampio potenziale di danni.

Abilitando la sandbox dell'app, si rimuove un set minimo di privilegi, che viene quindi riabilitare in base alle esigenze usando i diritti dell'app Xamarin.Mac.

È possibile modificare le risorse sandbox dell'applicazione modificando il file Entitlements.plist e controllando o selezionando i diritti necessari nelle caselle a discesa editor:

Directory dei contenitori e accesso al file system

Quando l'applicazione Xamarin.Mac adotta la sandbox dell'app, ha accesso alle posizioni seguenti:

• Directory contenitore dell'app: al primo esecuzione, il sistema operativo crea una directory contenitore speciale in cui tutte le risorse sono disponibili, che possono accedervi solo. L'app avrà accesso completo in lettura/scrittura a questa directory.
• Directory contenitori del gruppo di app: all'app è possibile concedere l'accesso a uno o più contenitori di gruppo condivisi tra le app nello stesso gruppo.
• File specificati dall'utente: l'applicazione ottiene automaticamente l'accesso ai file aperti o trascinati in modo esplicito nell'applicazione dall'utente.
• Elementi correlati: con i diritti appropriati, l'applicazione può accedere a un file con lo stesso nome ma con un'estensione diversa. Ad esempio, un documento salvato sia come file che come .txt ..pdf
• Directory temporanee, directory degli strumenti da riga di comando e posizioni leggibili specifiche: l'app ha vari gradi di accesso ai file in altri percorsi ben definiti, come specificato dal sistema.

Directory del contenitore dell'app

La directory contenitore app di un'applicazione Xamarin.Mac presenta le caratteristiche seguenti:

• Si trova in una posizione nascosta nella home directory dell'utente (in genere ~Library/Containers) ed è accessibile con la NSHomeDirectory funzione (vedere di seguito) all'interno dell'applicazione. Poiché si trova nella directory Home, ogni utente otterrà il proprio contenitore per l'app.
• L'app ha accesso in lettura/scrittura illimitato alla directory contenitore e a tutte le relative sottodirectory e file al suo interno.
• La maggior parte delle API di ricerca del percorso di macOS è relativa al contenitore dell'app. Ad esempio, il contenitore avrà una propria libreria (accessibile tramite NSLibraryDirectory), sottodirectory supporto applicazioni e preferenze .
• macOS stabilisce e applica la connessione tra e l'app e il relativo contenitore tramite la firma del codice. Anche se un'altra app tenta di eseguire lo spoofing dell'app usando il relativo identificatore bundle, non sarà in grado di accedere al contenitore a causa della firma del codice.
• Il contenitore non è destinato ai file generati dall'utente. È invece per i file usati dall'applicazione, ad esempio database, cache o altri tipi di dati specifici.
• Per i tipi di app shoebox (ad esempio l'app Foto di Apple), il contenuto dell'utente verrà inserito nel contenitore.

Importante

Sfortunatamente, Xamarin.Mac non ha ancora una copertura API del 100% (a differenza di Xamarin.iOS), di conseguenza l'API NSHomeDirectory non è stata mappata nella versione corrente di Xamarin.Mac.

Come soluzione alternativa temporanea, è possibile usare il codice seguente:

[System.Runtime.InteropServices.DllImport("/System/Library/Frameworks/Foundation.framework/Foundation")]
public static extern IntPtr NSHomeDirectory();

public static string ContainerDirectory {
    get {
        return ((NSString)ObjCRuntime.Runtime.GetNSObject(NSHomeDirectory())).ToString ();
        }
}

Directory del contenitore del gruppo di app

A partire da MacOS 10.7.5 (e versioni successive), un'applicazione può usare il com.apple.security.application-groups diritto di accedere a un contenitore condiviso comune a tutte le applicazioni del gruppo. È possibile usare questo contenitore condiviso per contenuti non destinati all'utente, ad esempio database o altri tipi di file di supporto, ad esempio cache.

I contenitori di gruppo vengono aggiunti automaticamente al contenitore sandbox di ogni app (se fanno parte di un gruppo) e vengono archiviati in ~/Library/Group Containers/<application-group-id>. L'ID gruppo deve iniziare con l'ID del team di sviluppo e un punto, ad esempio:

<team-id>.com.company.<group-name>

Per altre informazioni, vedere Aggiunta di un'applicazione a un gruppo di applicazioni in Informazioni di riferimento sulle chiavi entitlement di Apple.

Accesso a Powerbox e file system all'esterno del contenitore dell'app

Un'applicazione Xamarin.Mac in modalità sandbox può accedere ai percorsi del file system all'esterno del contenitore nei modi seguenti:

• Nella direzione specifica dell'utente (tramite Open e Save Dialogs o altri metodi, ad esempio trascinamento e rilascio).
• Usando i diritti per percorsi specifici del file system , ad esempio /bin o /usr/lib.
• Quando il percorso del file system si trova in determinate directory leggibili dal mondo, ad esempio condivisione.

Powerbox è la tecnologia di sicurezza macOS che interagisce con l'utente per espandere i diritti di accesso ai file dell'app Xamarin.Mac in modalità sandbox. Powerbox non dispone di API, ma viene attivata in modo trasparente quando l'app chiama o NSOpenPanel NSSavePanel. L'accesso a Powerbox è abilitato tramite entitlement impostati per l'applicazione Xamarin.Mac.

Quando un'app in modalità sandbox visualizza una finestra di dialogo Apri o Salva, la finestra viene visualizzata da Powerbox (e non da AppKit) e pertanto ha accesso a qualsiasi file o directory a cui l'utente può accedere.

Quando un utente seleziona un file o una directory dalla finestra di dialogo Apri o Salva (o trascina nell'icona dell'app), Powerbox aggiunge il percorso associato alla sandbox dell'app.

Inoltre, il sistema consente automaticamente il codice seguente a un'app in modalità sandbox:

• Connessione a un metodo di input di sistema.
• Chiama i servizi selezionati dall'utente dal menu Servizi (solo per i servizi contrassegnati come sicuri per le app sandbox dal provider di servizi).
• Apri file scegliere dall'utente dal menu Apri recenti .
• Usare Copia e Incolla tra altre applicazioni.
• Leggere i file dai percorsi leggibili seguenti:
  • /bin
  • /sbin
  • /usr/bin
  • /usr/lib
  • /usr/sbin
  • /usr/share
  • /System
• Leggere e scrivere file nelle directory create da NSTemporaryDirectory.

Per impostazione predefinita, i file aperti o salvati da un'app Xamarin.Mac in modalità sandbox rimangono accessibili fino al termine dell'app (a meno che il file non sia ancora aperto quando l'app viene chiusa). I file aperti verranno ripristinati automaticamente nella sandbox dell'app tramite la funzionalità riprendi macOS alla successiva avvio dell'app.

Per fornire la persistenza ai file che si trovano all'esterno di un contenitore di un'app Xamarin.Mac, usare segnalibri con ambito di sicurezza (vedere di seguito).

Elementi correlati

La sandbox dell'app consente a un'app di accedere agli elementi correlati con lo stesso nome file, ma estensioni diverse. La funzionalità include due parti: a) un elenco di estensioni correlate nel file dell'app Info.plst , b) codice per indicare alla sandbox che cosa l'app eseguirà con questi file.

Esistono due scenari in cui questo ha senso:

1. L'app deve essere in grado di salvare una versione diversa del file (con una nuova estensione). Ad esempio, l'esportazione di un .txt file in un .pdf file. Per gestire questa situazione, è necessario usare un NSFileCoordinator per accedere al file. Chiamare prima il WillMove(fromURL, toURL) metodo , spostare il file nella nuova estensione e quindi chiamare ItemMoved(fromURL, toURL).
2. L'app deve aprire un file principale con un'estensione e diversi file di supporto con estensioni diverse. Ad esempio, un film e un file di sottotitolo. Usare un NSFilePresenter oggetto per ottenere l'accesso al file secondario. Specificare il file principale per la PrimaryPresentedItemURL proprietà e il file secondario nella PresentedItemURL proprietà . Quando il file principale viene aperto, chiamare il AddFilePresenter metodo della NSFileCoordinator classe per registrare il file secondario.

In entrambi gli scenari, il file Info.plist dell'app deve dichiarare i tipi di documento che l'app può aprire. Per qualsiasi tipo di file, aggiungere ( NSIsRelatedItemType con un valore ) YESalla relativa voce nella CFBundleDocumentTypes matrice.

Aprire e salvare il comportamento della finestra di dialogo con app in modalità sandbox

I limiti seguenti vengono inseriti in NSOpenPanel e NSSavePanel quando vengono chiamati da un'app Xamarin.Mac in modalità sandbox:

• Non è possibile richiamare a livello di codice il pulsante OK .
• Non è possibile modificare a livello di codice la selezione di un utente in un oggetto NSOpenSavePanelDelegate.

Sono inoltre state apportate le modifiche di ereditarietà seguenti:

• App - NSOpenPanel non in modalità sandbox NSSavePanel``NSPanel``NSWindow``NSResponder``NSObject``NSOpenPanel``NSSavePanel``NSObject``NSOpenPanel``NSSavePanel

Segnalibri con ambito di sicurezza e accesso permanente alle risorse

Come indicato in precedenza, un'applicazione Xamarin.Mac in modalità sandbox può accedere a un file o a una risorsa all'esterno del contenitore tramite l'interazione diretta dell'utente (come fornito da PowerBox). Tuttavia, l'accesso a queste risorse non viene mantenuto automaticamente tra l'avvio dell'app o i riavvii del sistema.

Usando i segnalibri con ambito di sicurezza, un'applicazione Xamarin.Mac in modalità sandbox può mantenere la finalità dell'utente e mantenere l'accesso alle risorse fornite dopo il riavvio di un'app.

Tipi di segnalibro con ambito di sicurezza

Quando si usano i segnalibri con ambito di sicurezza e l'accesso permanente alle risorse, esistono due casi d'uso sistini:

• Un segnalibro con ambito app consente l'accesso permanente a un file o una cartella specificata dall'utente.

  Ad esempio, se l'applicazione Xamarin.Mac in modalità sandbox consente di usare per aprire un documento esterno per la modifica (usando un NSOpenPanel), l'app può creare un segnalibro con ambito app in modo che possa accedere nuovamente allo stesso file in futuro.

• Un segnalibro con ambito documento fornisce un accesso permanente a un documento specifico a un sotto-file.

Ad esempio, un'app di modifica video che crea un file di progetto che ha accesso alle singole immagini, clip video e file audio che verranno successivamente combinati in un singolo filmato.

Quando l'utente importa un file di risorse nel progetto (tramite un NSOpenPanel), l'app crea un segnalibro con ambito documento per l'elemento archiviato nel progetto, in modo che il file sia sempre accessibile all'app.

Un segnalibro con ambito documento può essere risolto da qualsiasi applicazione in grado di aprire i dati del segnalibro e il documento stesso. Ciò supporta la portabilità, consentendo all'utente di inviare i file di progetto a un altro utente e di disporre di tutti i segnalibri che funzionano anche per loro.

Importante

Un segnalibro con ambito documento può puntare solo a un singolo file e non a una cartella e tale file non può trovarsi in un percorso utilizzato dal sistema ( ad esempio /private o /Library).

Uso di segnalibri con ambito di sicurezza

Per usare uno dei due tipi di segnalibro con ambito di sicurezza, è necessario eseguire la procedura seguente:

1. Impostare i diritti appropriati nell'app Xamarin.Mac che deve usare i segnalibri con ambito di sicurezza - Per i segnalibri con ambito app impostare la com.apple.security.files.bookmarks.app-scope chiave Entitlement su true. Per i segnalibri con ambito documento impostare la com.apple.security.files.bookmarks.document-scope chiave Entitlement su true.
2. Crea un segnalibro con ambito di sicurezza: questa operazione verrà eseguita per qualsiasi file o cartella a cui l'utente ha fornito l'accesso (tramite NSOpenPanel ad esempio), a cui l'app dovrà accedere in modo permanente. Usare il public virtual NSData CreateBookmarkData (NSUrlBookmarkCreationOptions options, string[] resourceValues, NSUrl relativeUrl, out NSError error) metodo della NSUrl classe per creare il segnalibro.
3. Risolvere il segnalibro con ambito di sicurezza: quando l'app deve accedere nuovamente alla risorsa(ad esempio, dopo il riavvio) dovrà risolvere il segnalibro in un URL con ambito di sicurezza. Usare il public static NSUrl FromBookmarkData (NSData data, NSUrlBookmarkResolutionOptions options, NSUrl relativeToUrl, out bool isStale, out NSError error) metodo della NSUrl classe per risolvere il segnalibro.
4. Notificare in modo esplicito al sistema di voler accedere al file dall'URL con ambito di sicurezza: questo passaggio deve essere eseguito immediatamente dopo aver ottenuto l'URL con ambito di sicurezza precedente o, quando in un secondo momento si vuole ottenere nuovamente l'accesso alla risorsa dopo aver rinunciato all'accesso. Chiamare il StartAccessingSecurityScopedResource () metodo della NSUrl classe per iniziare ad accedere a un URL con ambito di sicurezza.
5. Notificare in modo esplicito al sistema di aver eseguito l'accesso al file dall'URL con ambito di sicurezza: appena possibile, è necessario informare il sistema quando l'app non deve più accedere al file ( ad esempio, se l'utente lo chiude). Chiamare il metodo della classe per interrompere l'accesso StopAccessingSecurityScopedResource () NSUrl a un URL con ambito di sicurezza.

Dopo aver rinunciato all'accesso a una risorsa, è necessario tornare al passaggio 4 per ristabilire l'accesso. Se l'app Xamarin.Mac viene riavviata, è necessario tornare al passaggio 3 e risolvere nuovamente il segnalibro.

Importante

Se non si rilascia l'accesso alle risorse URL con ambito di sicurezza, un'app Xamarin.Mac perderà le risorse del kernel. Di conseguenza, l'app non sarà più in grado di aggiungere percorsi del file system al contenitore fino al riavvio.

App Sandbox e firma del codice

Dopo aver abilitato la sandbox dell'app e aver abilitato i requisiti specifici per l'app Xamarin.Mac (tramite Entitlement), è necessario firmare il progetto per rendere effettivo il sandboxing. È necessario eseguire la firma del codice perché i diritti necessari per l'app sandboxing sono collegati alla firma dell'app.

macOS applica un collegamento tra il contenitore di un'app e la relativa firma di codice, in questo modo nessun'altra applicazione può accedere a tale contenitore, anche se esegue lo spoofing dell'ID bundle delle app. Questo meccanismo funziona come segue:

1. Quando il sistema crea il contenitore dell'app, imposta un elenco di Controllo di accesso (ACL) su tale contenitore. La voce di controllo di accesso iniziale nell'elenco contiene il requisito designato dell'app (RIPRISTINO di emergenza), che descrive come è possibile riconoscere le versioni future dell'app (quando è stato aggiornato).
2. Ogni volta che viene avviata un'app con lo stesso ID bundle, il sistema verifica che la firma del codice dell'app corrisponda ai requisiti designati specificati in una delle voci dell'ACL del contenitore. Se il sistema non trova una corrispondenza, impedisce l'avvio dell'app.

La firma del codice funziona nei modi seguenti:

1. Prima di creare il progetto Xamarin.Mac, ottenere un certificato di sviluppo, un certificato di distribuzione e un certificato ID sviluppatore dal portale per sviluppatori Apple.
2. Quando Mac App Store distribuisce l'app Xamarin.Mac, viene firmata con una firma di codice Apple.

Quando si esegue il test e il debug, si userà una versione dell'applicazione Xamarin.Mac firmata, che verrà usata per creare il contenitore di app. In seguito, se vuoi testare o installare la versione da Apple App Store, verrà firmata con la firma Apple e non verrà avviata (poiché non ha la stessa firma di codice del contenitore app originale). In questo caso, si otterrà un report di arresto anomalo simile al seguente:

Exception Type:  EXC_BAD_INSTRUCTION (SIGILL)

Per risolvere questo problema, è necessario modificare la voce ACL in modo che punti alla versione firmata apple dell'app.

Per altre informazioni sulla creazione e il download dei profili di provisioning necessari per sandboxing, vedere la sezione Firma e provisioning dell'app precedente.

Modifica della voce ACL

Per consentire l'esecuzione della versione firmata apple dell'app Xamarin.Mac, eseguire le operazioni seguenti:

1. Aprire l'app Terminale (in /Applications/Utilities).
2. Aprire una finestra finder alla versione firmata apple dell'app Xamarin.Mac.
3. Digitare asctl container acl add -file nella finestra Terminale.
4. Trascinare l'icona dell'app Xamarin.Mac dalla finestra del Finder e rilasciarla nella finestra Terminale.
5. Il percorso completo del file verrà aggiunto al comando in Terminale.
6. Premere INVIO per eseguire il comando.

L'ACL del contenitore ora contiene i requisiti di codice designati per entrambe le versioni dell'app Xamarin.Mac e macOS ora consentirà l'esecuzione di entrambe le versioni.

Visualizzare un elenco dei requisiti del codice ACL

È possibile visualizzare un elenco dei requisiti di codice nell'ACL di un contenitore eseguendo le operazioni seguenti:

1. Aprire l'app Terminale (in /Applications/Utilities).
2. Digitare asctl container acl list -bundle <container-name>.
3. Premere INVIO per eseguire il comando.

è <container-name> in genere l'identificatore del bundle per l'applicazione Xamarin.Mac.

Progettazione di un'app Xamarin.Mac per la sandbox dell'app

Quando si progetta un'app Xamarin.Mac per la sandbox dell'app, è necessario seguire un flusso di lavoro comune. Detto questo, le specifiche dell'implementazione del sandboxing in un'app saranno univoche per la funzionalità dell'app specificata.

Sei passaggi per l'adozione di App Sandbox

La progettazione di un'app Xamarin.Mac per la sandbox dell'app è in genere costituita dai passaggi seguenti:

1. Determinare se l'app è adatta per il sandboxing.
2. Progettare una strategia di sviluppo e distribuzione.
3. Risolvere eventuali incompatibilità dell'API.
4. Applicare i diritti della sandbox dell'app necessari al progetto Xamarin.Mac.
5. Aggiungere la separazione dei privilegi usando XPC.
6. Implementare una strategia di migrazione.

Importante

Non è necessario solo sandboxre il file eseguibile principale nel bundle dell'app, ma anche ogni app helper o strumento incluso in tale bundle. Questa operazione è necessaria per qualsiasi app distribuita da Mac App Store e, se possibile, deve essere eseguita per qualsiasi altra forma di distribuzione di app.

Per un elenco di tutti i file binari eseguibili nel bundle di un'app Xamarin.Mac, digitare il comando seguente in Terminale:

find -H [Your-App-Bundle].app -print0 | xargs -0 file | grep "Mach-O .*executable"

Dove [Your-App-Bundle] è il nome e il percorso del bundle dell'applicazione.

Determinare se un'app Xamarin.Mac è adatta per il sandboxing

La maggior parte delle app Xamarin.Mac è completamente compatibile con la sandbox dell'app e quindi adatta per il sandboxing. Se l'app richiede un comportamento non consentito dalla sandbox dell'app, è consigliabile prendere in considerazione un approccio alternativo.

Se l'app richiede uno dei comportamenti seguenti, non è compatibile con la sandbox dell'app:

• Servizi di autorizzazione: con la sandbox dell'app non è possibile usare le funzioni descritte in Guida di riferimento per I servizi di autorizzazione C.
• API di accessibilità: non è possibile usare app di assistive sandbox, ad esempio utilità per la lettura dello schermo o app che controllano altre applicazioni.
• Invia eventi Apple ad app arbitrarie: se l'app richiede l'invio di eventi Apple a un'app sconosciuta e arbitraria, non può essere sandbox. Per un elenco noto di app denominate, l'app può essere ancora in modalità sandbox e i entitlement dovranno includere l'elenco di app denominato.
• Inviare dizionari informazioni utente in Notifiche distribuite ad altre attività : con la sandbox dell'app non è possibile includere un userInfo dizionario durante la pubblicazione in un NSDistributedNotificationCenter oggetto per la messaggistica di altre attività.
• Caricare le estensioni del kernel: il caricamento delle estensioni del kernel non è consentito dalla sandbox dell'app.
• Simulazione dell'input dell'utente nelle finestre di dialogo Apri e salva : la modifica a livello di codice delle finestre di dialogo Apri o Salva per simulare o modificare l'input dell'utente non è consentita dalla sandbox dell'app.
• Accesso o impostazione delle preferenze in altre app : la modifica delle impostazioni di altre app non è consentita dalla sandbox dell'app.
• Configurazione delle impostazioni di rete: la modifica delle impostazioni di rete non è consentita dalla sandbox dell'app.
• Terminazione di altre app : la sandbox dell'app impedisce l'uso NSRunningApplication per terminare altre app.

Risoluzione delle incompatibilità dell'API

Quando si progetta un'app Xamarin.Mac per la sandbox dell'app, è possibile che si verifichino incompatibilità con l'uso di alcune API macOS.

Ecco alcuni problemi comuni e le operazioni che è possibile eseguire per risolverli:

• Apertura, salvataggio e rilevamento di documenti : se si gestiscono documenti che usano una tecnologia diversa NSDocumentda , è consigliabile passarvi a causa del supporto predefinito per la sandbox dell'app. NSDocument funziona automaticamente con PowerBox e fornisce supporto per mantenere i documenti all'interno della sandbox se l'utente li sposta in Finder.
• Mantenere l'accesso alle risorse del file system: se l'app Xamarin.Mac dipende dall'accesso permanente alle risorse esterne al contenitore, usare segnalibri con ambito di sicurezza per mantenere l'accesso.
• Creare un elemento di accesso per un'app: con la sandbox dell'app non è possibile creare un elemento di accesso usando LSSharedFileList né modificare lo stato dei servizi di avvio usando LSRegisterURL. Usare la SMLoginItemSetEnabled funzione come descritto in Apples Aggiunta di elementi di accesso tramite la documentazione di Service Management Framework .
• Accesso ai dati utente: se si usano funzioni POSIX, getpwuid ad esempio per ottenere la home directory dell'utente dai servizi directory, è consigliabile usare i simboli Cocoa o Core Foundation, NSHomeDirectoryad esempio .
• Accesso alle preferenze di altre app : poiché la sandbox dell'app indirizza le API di ricerca del percorso al contenitore dell'app, la modifica delle preferenze avviene all'interno di tale contenitore e l'accesso a altre preferenze di app non consentite.
• Uso di video incorporati HTML5 nelle visualizzazioni Web: se l'app Xamarin.Mac usa WebKit per riprodurre video HTML5 incorporati, è necessario collegare l'app anche al framework AV Foundation. La sandbox dell'app impedirà a CoreMedia di riprodurre questi video in caso contrario.

Applicazione dei diritti necessari per la sandbox dell'app

Sarà necessario modificare i diritti per qualsiasi applicazione Xamarin.Mac che si vuole eseguire nella sandbox dell'app e selezionare la casella di controllo Abilita sandbox app .

In base alle funzionalità dell'app, potrebbe essere necessario abilitare altri entitlement per accedere alle funzionalità o alle risorse del sistema operativo. Il sandboxing delle app funziona meglio quando si riducono al minimo i diritti richiesti per eseguire l'app in modo da abilitare in modo casuale i diritti.

Per determinare i diritti necessari per un'app Xamarin.Mac, eseguire le operazioni seguenti:

1. Abilitare la sandbox dell'app ed eseguire l'app Xamarin.Mac.
2. Eseguire le funzionalità dell'app.
3. Aprire l'app Console (disponibile in /Applications/Utilities) e cercare sandboxd le violazioni nel log Tutti i messaggi .
4. Per ogni sandboxd violazione, risolvere il problema usando il contenitore dell'app anziché altri percorsi del file system o applicare i diritti sandbox dell'app per abilitare l'accesso alle funzionalità del sistema operativo con restrizioni.
5. Riesecuzione e test di tutte le funzionalità dell'app Xamarin.Mac.
6. Ripetere fino a quando non vengono risolte tutte le sandboxd violazioni.

Aggiungere la separazione dei privilegi con XPC

Quando si sviluppa un'app Xamarin.Mac per la sandbox dell'app, esaminare i comportamenti dell'app in termini di privilegi e accesso, quindi valutare la possibilità di separare le operazioni ad alto rischio nei propri servizi XPC.

Per altre informazioni, vedere la Guida alla creazione di servizi XPC e Daemon e servizi di Apple.

Implementare una strategia di migrazione

Se si rilascia una nuova versione in modalità sandbox di un'applicazione Xamarin.Mac non precedentemente in modalità sandbox, è necessario assicurarsi che gli utenti correnti abbiano un percorso di aggiornamento uniforme.

Per informazioni dettagliate su come implementare un manifesto di migrazione dei contenitori, vedere la documentazione relativa alla migrazione di un'app a una sandbox di Apple.

Riepilogo

Questo articolo ha esaminato in dettaglio il sandboxing di un'applicazione Xamarin.Mac. Prima di tutto, è stata creata una semplice app Xamarin.Mac per illustrare le nozioni di base di App Sandbox. Successivamente, è stato illustrato come risolvere le violazioni della sandbox. Quindi, abbiamo esaminato in modo approfondito la sandbox dell'app e infine abbiamo esaminato la progettazione di un'app Xamarin.Mac per la sandbox dell'app.

Collegamenti correlati

• Pubblicazione nell'App Store
• Informazioni su Sandbox app
• Problemi comuni di sandboxing delle app