Piaskownica aplikacji platformy Xamarin.Mac

W tym artykule opisano piaskownicę aplikacji platformy Xamarin.Mac do wydania w sklepie App Store. Obejmuje wszystkie elementy, które przechodzą do piaskownicy, takie jak katalogi kontenerów, uprawnienia, uprawnienia określone przez użytkownika, separacja uprawnień i wymuszanie jądra.

Omówienie

Podczas pracy z językiem C# i platformą .NET w aplikacji platformy Xamarin.Mac masz taką samą możliwość piaskownicy aplikacji, jak podczas pracy z usługą Objective-C Lub Swift.

W tym artykule omówimy podstawy pracy z piaskownicą w aplikacji platformy Xamarin.Mac oraz wszystkie elementy, które przechodzą do piaskownicy: katalogi kontenerów, uprawnienia, uprawnienia, uprawnienia określone przez użytkownika, separacja uprawnień i wymuszanie jądra. Zdecydowanie zaleca się, aby najpierw zapoznać się z artykułem Hello, Mac , w szczególności wprowadzenie do narzędzi Xcode i Interface Builder i Outlet and Actions , ponieważ obejmuje ona kluczowe pojęcia i techniki, których będziemy używać w tym artykule.

Warto zapoznać się z sekcją Uwidacznianie klas/metod Objective-C języka C# w sekcji dokumentu Xamarin.Mac Internals , a także objaśnienie Register atrybutów i Export używanych do podłączania klas języka C# do Objective-C obiektów i elementów interfejsu użytkownika.

Informacje o piaskownicy aplikacji

Piaskownica aplikacji zapewnia silną ochronę przed uszkodzeniem, które mogą być spowodowane przez złośliwą aplikację uruchamianą na komputerze Mac, ograniczając dostęp do zasobów systemowych aplikacji.

Aplikacja nienależącą do piaskownicy ma pełne prawa użytkownika, który uruchamia aplikację i może uzyskiwać dostęp do aplikacji lub wykonywać dowolne czynności, które użytkownik może wykonać. Jeśli aplikacja zawiera luki w zabezpieczeniach (lub dowolną platformę używaną), haker może potencjalnie wykorzystać te słabości i użyć aplikacji do przejęcia kontroli nad komputerem Mac, na którym działa.

Ograniczając dostęp do zasobów dla poszczególnych aplikacji, aplikacja w trybie piaskownicy zapewnia linię obrony przed kradzieżą, uszkodzeniem lub złośliwym zamiarem ze strony aplikacji uruchomionej na komputerze użytkownika.

Piaskownica aplikacji to technologia kontroli dostępu wbudowana w system macOS (wymuszana na poziomie jądra), która zapewnia dwufoldową strategię:

1. Piaskownica aplikacji umożliwia deweloperowi opisanie sposobu interakcji aplikacji z systemem operacyjnym, a w ten sposób przyznano mu tylko prawa dostępu wymagane do wykonania zadania i nie tylko.
2. Piaskownica aplikacji umożliwia użytkownikowi bezproblemowe udzielanie dodatkowego dostępu do systemu za pośrednictwem okien dialogowych Otwieranie i zapisywanie, przeciąganie i upuszczanie oraz inne typowe interakcje użytkownika.

Przygotowywanie do zaimplementowania piaskownicy aplikacji

Elementy piaskownicy aplikacji, które zostaną szczegółowo omówione w artykule, są następujące:

• Katalogi kontenerów
• Uprawnienia
• Uprawnienia określone przez użytkownika
• Separacja uprawnień
• Wymuszanie jądra

Po zapoznaniu się z tymi szczegółami będzie można utworzyć plan wdrożenia piaskownicy aplikacji w aplikacji Xamarin.Mac.

Najpierw należy określić, czy aplikacja jest dobrym kandydatem do piaskownicy (większość aplikacji to). Następnie należy rozwiązać wszelkie niezgodności interfejsu API i określić, które elementy piaskownicy aplikacji będą wymagane. Na koniec przyjrzyj się używaniu separacji uprawnień, aby zmaksymalizować poziom obrony aplikacji.

Podczas wdrażania piaskownicy aplikacji niektóre lokalizacje systemu plików używane przez aplikację będą inne. Szczególnie aplikacja będzie mieć katalog kontenerów, który będzie używany do obsługi plików, baz danych, pamięci podręcznych i innych plików, które nie są dokumentami użytkownika. Systemy macOS i Xcode zapewniają obsługę migrowania plików tego typu z starszych lokalizacji do kontenera.

Przewodnik Szybki start dotyczący piaskownicy

W tej sekcji utworzymy prostą aplikację platformy Xamarin.Mac, która używa widoku internetowego (który wymaga połączenia sieciowego ograniczonego w trybie piaskownicy, chyba że jest to wymagane) jako przykład rozpoczynania pracy z piaskownicą aplikacji.

Sprawdzimy, czy aplikacja jest rzeczywiście w trybie piaskownicy, i dowiesz się, jak rozwiązywać typowe błędy piaskownicy aplikacji.

Tworzenie projektu platformy Xamarin.Mac

Wykonajmy następujące czynności, aby utworzyć nasz przykładowy projekt:

1. Uruchom Visual Studio dla komputerów Mac i kliknij link Nowy rozwiązanie..

2. W oknie dialogowym Nowy projekt wybierz pozycję Aplikacja Cocoa aplikacji> dla komputerów Mac:>

   

3. Kliknij przycisk Dalej, wprowadź MacSandbox nazwę projektu i kliknij przycisk Utwórz:

   

4. W okienku rozwiązania kliknij dwukrotnie plik Main.storyboard, aby otworzyć go do edycji w programie Xcode:

   

5. Przeciągnij widok sieci Web na okno, ustaw jego rozmiar, aby wypełnić obszar zawartości i ustawić go, aby zwiększyć i zmniejszyć okno:

   

6. Utwórz gniazdo dla widoku internetowego o nazwie webView:

   

7. Wróć do Visual Studio dla komputerów Mac i kliknij dwukrotnie plik ViewController.cs w okienku rozwiązania, aby otworzyć go do edycji.

8. Dodaj następującą instrukcję using: using WebKit;

9. Utwórz metodę ViewDidLoad podobną do następującej:

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

10. Zapisz zmiany.

Uruchom aplikację i upewnij się, że witryna internetowa firmy Apple jest wyświetlana w oknie w następujący sposób:

Podpisywanie i aprowizowanie aplikacji

Zanim włączymy piaskownicę aplikacji, najpierw musimy aprowizować i podpisać aplikację platformy Xamarin.Mac.

Wykonaj następujące czynności:

1. Zaloguj się do portalu dla deweloperów firmy Apple:

   

2. Wybierz pozycję Certyfikaty, Identyfikatory i profile:

   

3. W obszarze Aplikacje dla komputerów Mac wybierz pozycję Identyfikatory:

   

4. Utwórz nowy identyfikator aplikacji:

   

5. W obszarze Profile aprowizacji wybierz pozycję Programowanie:

   

6. Utwórz nowy profil i wybierz pozycję Programowanie aplikacji dla komputerów Mac:

   

7. Wybierz utworzony powyżej identyfikator aplikacji:

   

8. Wybierz pozycję Deweloperzy dla tego profilu:

   

9. Wybierz komputery dla tego profilu:

   

10. Nadaj profilowi nazwę:

    

11. Kliknij przycisk Gotowe.

Ważne

W niektórych przypadkach może być konieczne pobranie nowego profilu aprowizacji bezpośrednio z portalu deweloperów firmy Apple i dwukrotne kliknięcie go w celu zainstalowania. Może być również konieczne zatrzymanie i ponowne uruchomienie Visual Studio dla komputerów Mac przed uzyskaniem dostępu do nowego profilu.

Następnie należy załadować nowy identyfikator aplikacji i profil na maszynie dewelopera. Wykonajmy następujące czynności:

1. Uruchom program Xcode i wybierz pozycję Preferencje z menu Xcode :

   

2. Kliknij przycisk Wyświetl szczegóły...

   

3. Kliknij przycisk Odśwież (w lewym dolnym rogu).

4. Kliknij przycisk Gotowe.

Następnie musimy wybrać nowy identyfikator aplikacji i profil aprowizacji w projekcie Xamarin.Mac. Wykonajmy następujące czynności:

1. W okienku rozwiązania kliknij dwukrotnie plik Info.plist, aby otworzyć go do edycji.

2. Upewnij się, że identyfikator pakietu jest zgodny z utworzonym powyżej identyfikatorem aplikacji (przykład: com.appracatappra.MacSandbox):

   

3. Następnie kliknij dwukrotnie plik Entitlements.plist i upewnij się, że nasz sklep iCloud Key-Value Store i kontenery usługi iCloud są zgodne z naszym identyfikatorem aplikacji utworzonym powyżej (przykład: com.appracatappra.MacSandbox):

   

4. Zapisz zmiany.

5. W okienku rozwiązania kliknij dwukrotnie plik projektu, aby otworzyć jego opcje do edycji:

   

6. Wybierz pozycję Podpisywanie na komputerze Mac, a następnie zaznacz pole Podpisywanie pakietu aplikacji i Podpisywanie pakietu instalatora. W obszarze Profil aprowizacji wybierz utworzony powyżej profil:

   

7. Kliknij przycisk Gotowe.

Ważne

Może być konieczne zamknięcie i ponowne uruchomienie Visual Studio dla komputerów Mac, aby rozpoznać nowy identyfikator aplikacji i profil aprowizacji zainstalowany przez program Xcode.

Rozwiązywanie problemów z aprowizowaniem

W tym momencie należy spróbować uruchomić aplikację i upewnić się, że wszystko jest podpisane i aprowidowane poprawnie. Jeśli aplikacja nadal działa tak jak wcześniej, wszystko jest dobre. W przypadku awarii może zostać wyświetlone okno dialogowe podobne do następującego:

Poniżej przedstawiono najczęstsze przyczyny problemów z aprowizowaniem i podpisywaniem:

• Identyfikator pakietu aplikacji nie jest zgodny z identyfikatorem aplikacji wybranego profilu.
• Identyfikator dewelopera nie jest zgodny z identyfikatorem dewelopera wybranego profilu.
• Identyfikator UUID testowanego komputera Mac nie jest zarejestrowany w ramach wybranego profilu.

W przypadku problemu usuń problem w portalu dla deweloperów firmy Apple, odśwież profile w programie Xcode i wykonaj czystą kompilację w Visual Studio dla komputerów Mac.

Włączanie piaskownicy aplikacji

Piaskownicę aplikacji można włączyć, zaznaczając pole wyboru w opcjach projektów. Należy wykonać następujące czynności:

1. W okienku rozwiązania kliknij dwukrotnie plik Entitlements.plist, aby otworzyć go do edycji.

2. Sprawdź zarówno opcję Włącz uprawnienia , jak i Włącz piaskownicę aplikacji:

   

3. Zapisz zmiany.

W tym momencie włączono piaskownicę aplikacji, ale nie podano wymaganego dostępu do sieci dla widoku sieci Web. Jeśli teraz uruchomisz aplikację, powinno zostać wyświetlone puste okno:

Sprawdzanie, czy aplikacja jest w trybie piaskownicy

Oprócz zachowania blokowania zasobów istnieją trzy główne sposoby, aby sprawdzić, czy aplikacja platformy Xamarin.Mac została pomyślnie w trybie piaskownicy:

1. W programie Finder sprawdź zawartość ~/Library/Containers/ folderu — jeśli aplikacja jest w trybie piaskownicy, zostanie wyświetlony folder o nazwie podobny do identyfikatora pakietu aplikacji (na przykład: com.appracatappra.MacSandbox):

   

2. System widzi aplikację jako w trybie piaskownicy w monitorze aktywności:

   • Uruchom monitor aktywności (w obszarze /Applications/Utilities).
   • Wybierz pozycję Wyświetl>kolumny i upewnij się, że zaznaczono element menu Piaskownica.
   • Upewnij się, że kolumna Piaskownica odczytuje Yes dla aplikacji:

   

3. Sprawdź, czy plik binarny aplikacji jest w trybie piaskownicy:

   • Uruchom aplikację terminalu.
   • Przejdź do katalogu aplikacji bin .
   • Wydaj to polecenie: codesign -dvvv --entitlements :- executable_path (gdzie executable_path to ścieżka do aplikacji):

   

Debugowanie aplikacji w trybie piaskownicy

Debuger łączy się z aplikacjami platformy Xamarin.Mac za pośrednictwem protokołu TCP, co oznacza, że domyślnie po włączeniu piaskownicy nie może nawiązać połączenia z aplikacją, więc jeśli spróbujesz uruchomić aplikację bez włączenia odpowiednich uprawnień, zostanie wyświetlony błąd "Nie można nawiązać połączenia z debugerem".

Uprawnienie Zezwalaj na wychodzące połączenia sieciowe (klient) jest wymagane dla debugera, co umożliwi normalne debugowanie. Ponieważ nie można jej debugować, zaktualizowaliśmy CompileEntitlements element docelowy msbuild , aby automatycznie dodać to uprawnienie do uprawnień dla dowolnej aplikacji, która jest w trybie piaskownicy tylko dla kompilacji debugowania. Kompilacje wydania powinny używać uprawnień określonych w pliku uprawnień, niezmodyfikowanych.

Rozwiązywanie naruszenia piaskownicy aplikacji

Naruszenie piaskownicy aplikacji występuje, jeśli aplikacja platformy Xamarin.Mac w trybie piaskownicy próbowała uzyskać dostęp do zasobu, który nie jest jawnie dozwolony. Na przykład nasz widok internetowy nie jest już w stanie wyświetlić witryny internetowej firmy Apple.

Najczęstsze źródło naruszeń piaskownicy aplikacji występuje, gdy ustawienia uprawnień określone w Visual Studio dla komputerów Mac nie są zgodne z wymaganiami aplikacji. Wróćmy do naszego przykładu, że brakuje uprawnień połączenie sieciowe, które uniemożliwiają działanie widoku internetowego.

Odnajdywanie naruszeń piaskownicy aplikacji

Jeśli podejrzewasz, że naruszenie piaskownicy aplikacji występuje w aplikacji Xamarin.Mac, najszybszym sposobem wykrycia problemu jest użycie aplikacji konsolowej.

Należy wykonać następujące czynności:

1. Skompiluj aplikację i uruchom ją z Visual Studio dla komputerów Mac.

2. Otwórz aplikację konsolową (z /Applications/Utilties/pliku ).

3. Wybierz pozycję Wszystkie komunikaty na pasku bocznym i wprowadź sandbox ciąg w wyszukiwaniu:

   

W przypadku powyższej przykładowej aplikacji widać, że kernal blokuje network-outbound ruch ze względu na piaskownicę aplikacji, ponieważ nie zażądaliśmy tego prawa.

Naprawianie naruszeń piaskownicy aplikacji z uprawnieniami

Teraz, gdy zobaczyliśmy, jak znaleźć naruszenia piaskownicy aplikacji, zobaczmy, jak można je rozwiązać, dostosowując uprawnienia aplikacji.

Należy wykonać następujące czynności:

1. W okienku rozwiązania kliknij dwukrotnie plik Entitlements.plist, aby otworzyć go do edycji.

2. W sekcji Uprawnienia zaznacz pole wyboru Zezwalaj na wychodzące połączenia sieciowe (klient):

   

3. Zapisz zmiany w aplikacji.

Jeśli wykonamy powyższe czynności dla naszej przykładowej aplikacji, skompiluj ją i uruchomimy, zawartość internetowa będzie teraz wyświetlana zgodnie z oczekiwaniami.

Szczegółowa piaskownica aplikacji

Mechanizmy kontroli dostępu udostępniane przez piaskownicę aplikacji są nieliczne i łatwe do zrozumienia. Jednak sposób, w jaki piaskownica aplikacji zostanie przyjęta przez każdą aplikację, jest unikatowa i oparta na wymaganiach aplikacji.

Biorąc pod uwagę najlepsze wysiłki, aby chronić aplikację Xamarin.Mac przed wykorzystywaniem złośliwego kodu, w aplikacji (lub w jednej z używanych przez nią platform) potrzebna jest tylko jedna luka w zabezpieczeniach aplikacji (lub jedna z używanych przez nią struktur), aby uzyskać kontrolę nad interakcjami aplikacji z systemem.

Piaskownica aplikacji została zaprojektowana tak, aby zapobiec przejęciu (lub ograniczyć szkody, które może spowodować), umożliwiając określenie zamierzonych interakcji aplikacji z systemem. System udzieli dostępu tylko do zasobu, którego aplikacja wymaga, aby wykonać swoje zadanie i nic więcej.

Podczas projektowania piaskownicy aplikacji projektujesz w najgorszym scenariuszu. Jeśli aplikacja zostanie naruszona przez złośliwy kod, dostęp do plików i zasobów w piaskownicy aplikacji jest ograniczony.

Uprawnienia i dostęp do zasobów systemowych

Jak pokazano powyżej, aplikacja Xamarin.Mac, która nie została w trybie piaskownicy, ma przyznane pełne prawa i dostęp użytkownika, na którym jest uruchomiona aplikacja. W przypadku naruszenia zabezpieczeń przez złośliwy kod aplikacja niechodząca przed ochroną może działać jako agent wrogich zachowań, z szerokim potencjałem szkody.

Włączając piaskownicę aplikacji, usuwasz wszystkie, ale minimalny zestaw uprawnień, które następnie ponownie włączysz tylko przy użyciu uprawnień aplikacji Xamarin.Mac.

Zmodyfikuj zasoby piaskownicy aplikacji aplikacji, edytując jego plik Entitlements.plist i sprawdzając lub wybierając prawa wymagane z pól rozwijanych edytorów:

Katalogi kontenerów i dostęp do systemu plików

Gdy aplikacja Xamarin.Mac przyjmuje piaskownicę aplikacji, ma dostęp do następujących lokalizacji:

• Katalog kontenera aplikacji — po pierwszym uruchomieniu system operacyjny tworzy specjalny katalog kontenera, w którym wszystkie jego zasoby są dostępne. Aplikacja będzie mieć pełny dostęp do odczytu/zapisu do tego katalogu.
• Katalogi kontenerów grupy aplikacji — twoja aplikacja może mieć dostęp do co najmniej jednego kontenera grupy, które są współużytkowane przez aplikacje w tej samej grupie.
• Pliki określone przez użytkownika — aplikacja automatycznie uzyskuje dostęp do plików, które są jawnie otwierane lub przeciągane i porzucane do aplikacji przez użytkownika.
• Powiązane elementy — przy odpowiednich uprawnieniach aplikacja może mieć dostęp do pliku o tej samej nazwie, ale innym rozszerzeniu. Na przykład dokument, który został zapisany zarówno .txt jako plik, jak i .pdf.
• Katalogi tymczasowe, katalogi narzędzi wiersza polecenia i określone na świecie czytelne lokalizacje — aplikacja ma różny stopień dostępu do plików w innych dobrze zdefiniowanych lokalizacjach określonych przez system.

Katalog kontenera aplikacji

Katalog kontenera aplikacji platformy Xamarin.Mac ma następujące cechy:

• Znajduje się on w ukrytej lokalizacji w katalogu głównym użytkownika (zwykle ~Library/Containers) i można uzyskać do niego dostęp za pomocą NSHomeDirectory funkcji (patrz poniżej) w aplikacji. Ponieważ znajduje się on w katalogu głównym, każdy użytkownik otrzyma własny kontener dla aplikacji.
• Aplikacja ma nieograniczony dostęp do odczytu/zapisu do katalogu kontenera i wszystkich jego podkatalogów i plików w niej.
• Większość interfejsów API znajdowania ścieżki systemu macOS jest względna względem kontenera aplikacji. Na przykład kontener będzie miał własną bibliotekę (dostęp za pośrednictwem NSLibraryDirectory), podkatalogi Obsługa aplikacji i Preferencje .
• System macOS ustanawia i wymusza połączenie między aplikacją i kontenerem za pośrednictwem podpisywania kodu. Nawet inna aplikacja próbuje sfałszować aplikację przy użyciu identyfikatora pakietu, nie będzie mogła uzyskać dostępu do kontenera z powodu podpisywania kodu.
• Kontener nie jest przeznaczony dla plików wygenerowanych przez użytkownika. Zamiast tego dotyczy plików używanych przez aplikację, takich jak bazy danych, pamięci podręczne lub inne określone typy danych.
• W przypadku typów aplikacji shoebox (takich jak aplikacja Zdjęcie firmy Apple) zawartość użytkownika zostanie w kontenerze.

Ważne

Niestety platforma Xamarin.Mac nie ma jeszcze 100% pokrycia interfejsu API (w przeciwieństwie do platformy Xamarin.iOS), dlatego NSHomeDirectory interfejs API nie został zamapowany w bieżącej wersji platformy Xamarin.Mac.

Jako tymczasowe obejście problemu można użyć następującego kodu:

[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 ();
        }
}

Katalog kontenera grupy aplikacji

Począwszy od systemu MacOS 10.7.5 (i nowszych), aplikacja może używać com.apple.security.application-groups uprawnienia dostępu do udostępnionego kontenera, który jest wspólny dla wszystkich aplikacji w grupie. Tego udostępnionego kontenera można używać w przypadku zawartości nieużytkowanej, takiej jak baza danych lub inne typy plików pomocy technicznej (np. pamięci podręczne).

Kontenery grup są automatycznie dodawane do kontenera piaskownicy każdej aplikacji (jeśli są częścią grupy) i są przechowywane w lokalizacji ~/Library/Group Containers/<application-group-id>. Identyfikator grupy musi zaczynać się od identyfikatora zespołu deweloperów i okresu, na przykład:

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

Aby uzyskać więcej informacji, zobacz Dodawanie aplikacji do grupy aplikacji w dokumentacji klucza uprawnień firmy Apple.

Dostęp do usługi Powerbox i systemu plików poza kontenerem aplikacji

Aplikacja Xamarin.Mac w trybie piaskownicy może uzyskiwać dostęp do lokalizacji systemu plików spoza kontenera w następujący sposób:

• W określonym kierunku użytkownika (za pomocą okien dialogowych Otwierania i zapisywania lub innych metod, takich jak przeciąganie i upuszczanie).
• Za pomocą uprawnień dla określonych lokalizacji systemu plików (takich jak /bin lub /usr/lib).
• Gdy lokalizacja systemu plików znajduje się w niektórych katalogach, które są dostępne do odczytu (na przykład Udostępnianie).

Powerbox to technologia zabezpieczeń systemu macOS, która współdziała z użytkownikiem w celu rozszerzenia praw dostępu do plików aplikacji Xamarin.Mac w trybie piaskownicy. Usługa Powerbox nie ma interfejsu API, ale jest aktywowana w sposób niewidoczny, gdy aplikacja wywołuje element NSOpenPanel lub NSSavePanel. Dostęp do usługi Powerbox jest włączony za pośrednictwem uprawnień ustawionych dla aplikacji Xamarin.Mac.

Gdy aplikacja w trybie piaskownicy wyświetla okno dialogowe Otwórz lub Zapisz, zostanie wyświetlone przez usługę Powerbox (a nie AppKit) i w związku z tym ma dostęp do dowolnego pliku lub katalogu, do którego użytkownik ma dostęp.

Gdy użytkownik wybierze plik lub katalog z okna dialogowego Otwórz lub Zapisz (albo przeciągnij na ikonę aplikacji), program Powerbox doda skojarzona ścieżkę do piaskownicy aplikacji.

Ponadto system automatycznie zezwala na wykonywanie następujących czynności w aplikacji w trybie piaskownicy:

• Połączenie z metodą wejściową systemu.
• Wywołaj usługi wybrane przez użytkownika z menu Usługi (tylko dla usług oznaczonych jako bezpieczne dla aplikacji piaskownicy przez dostawcę usług).
• Otwórz pliki wybrane przez użytkownika z menu Otwórz ostatnio używane.
• Użyj opcji Kopiuj i wklej między innymi aplikacjami.
• Odczytywanie plików z następujących lokalizacji czytelnych dla świata:
  • /bin
  • /sbin
  • /usr/bin
  • /usr/lib
  • /usr/sbin
  • /usr/share
  • /System
• Odczytywanie i zapisywanie plików w katalogach utworzonych przez NSTemporaryDirectoryprogram .

Domyślnie pliki otwierane lub zapisywane przez aplikację platformy Xamarin.Mac w trybie piaskownicy pozostaną dostępne do momentu zakończenia działania aplikacji (chyba że plik został jeszcze otwarty, gdy aplikacja zakończy działanie). Otwieranie plików zostanie automatycznie przywrócone do piaskownicy aplikacji za pośrednictwem funkcji wznawiania systemu macOS przy następnym uruchomieniu aplikacji.

Aby zapewnić trwałość plików znajdujących się poza kontenerem aplikacji Xamarin.Mac, użyj zakładek o zakresie zabezpieczeń (zobacz poniżej).

Elementy pokrewne

Piaskownica aplikacji umożliwia aplikacji dostęp do powiązanych elementów, które mają tę samą nazwę pliku, ale różne rozszerzenia. Funkcja ma dwie części: a) listę powiązanych rozszerzeń w pliku aplikacji Info.plst , b) kod, aby poinformować piaskownicę, co aplikacja będzie robić z tymi plikami.

Istnieją dwa scenariusze, w których ma to sens:

1. Aplikacja musi mieć możliwość zapisania innej wersji pliku (z nowym rozszerzeniem). Na przykład eksportowanie .txt pliku do .pdf pliku. Aby obsłużyć tę sytuację, należy użyć elementu , NSFileCoordinator aby uzyskać dostęp do pliku. Najpierw wywołasz metodę WillMove(fromURL, toURL) , przenieś plik do nowego rozszerzenia, a następnie wywołasz metodę ItemMoved(fromURL, toURL).
2. Aplikacja musi otworzyć plik główny z jednym rozszerzeniem i kilkoma plikami pomocniczymi z różnymi rozszerzeniami. Na przykład film i plik podtytułu. Użyj elementu NSFilePresenter , aby uzyskać dostęp do pliku pomocniczego. Podaj plik PrimaryPresentedItemURL główny właściwości i plik pomocniczy do PresentedItemURL właściwości . Po otwarciu pliku głównego wywołaj AddFilePresenter metodę NSFileCoordinator klasy , aby zarejestrować plik pomocniczy.

W obu scenariuszach plik Info.plist aplikacji musi zadeklarować typy dokumentów, które aplikacja może otworzyć. W przypadku dowolnego typu pliku dodaj element NSIsRelatedItemType (z wartością YES) do wpisu w tablicy CFBundleDocumentTypes .

Otwieranie i zapisywanie zachowania okna dialogowego przy użyciu aplikacji w trybie piaskownicy

Następujące limity są umieszczane na obiekcie NSOpenPanel i NSSavePanel podczas wywoływania ich z aplikacji platformy Xamarin.Mac w trybie piaskownicy:

• Nie można programowo wywołać przycisku OK .
• Nie można programowo zmienić wyboru użytkownika w obiekcie NSOpenSavePanelDelegate.

Ponadto obowiązują następujące modyfikacje dziedziczenia:

• Aplikacja - NSOpenPanel nienależąca do piaskownicy NSSavePanel``NSPanel``NSWindow``NSResponder``NSObject``NSOpenPanel``NSSavePanel``NSObject``NSOpenPanel``NSSavePanel

Zakładki o zakresie zabezpieczeń i trwały dostęp do zasobów

Jak wspomniano powyżej, aplikacja Xamarin.Mac w trybie piaskownicy może uzyskiwać dostęp do pliku lub zasobu poza kontenerem, korzystając z bezpośredniej interakcji użytkownika (udostępnianej przez usługę PowerBox). Jednak dostęp do tych zasobów nie jest automatycznie utrwalany podczas uruchamiania aplikacji ani ponownego uruchamiania systemu.

Korzystając z zakładek o zakresie zabezpieczeń, aplikacja Xamarin.Mac w trybie piaskownicy może zachować intencję użytkownika i zachować dostęp do tych zasobów po ponownym uruchomieniu aplikacji.

Typy zakładek o zakresie zabezpieczeń

Podczas pracy z zakładkami o zakresie zabezpieczeń i trwałym dostępem do zasobów istnieją dwa sykstyńskie przypadki użycia:

• Zakładka o zakresie aplikacji zapewnia trwały dostęp do określonego przez użytkownika pliku lub folderu.

  Jeśli na przykład aplikacja Xamarin.Mac w trybie piaskownicy umożliwia otwarcie zewnętrznego dokumentu do edycji (przy użyciu elementu NSOpenPanel), aplikacja może utworzyć zakładkę o zakresie aplikacji, aby mogła ponownie uzyskać dostęp do tego samego pliku w przyszłości.

• Zakładka o zakresie dokumentów zapewnia określony dokument trwały dostęp do pliku podrzędnego.

Na przykład aplikacja do edycji wideo, która tworzy plik projektu, który ma dostęp do poszczególnych obrazów, klipów wideo i plików dźwiękowych, które później zostaną połączone w jeden film.

Gdy użytkownik zaimportuje plik zasobu do projektu (za pośrednictwem NSOpenPanelelementu ), aplikacja tworzy zakładkę o zakresie dokumentów dla elementu przechowywanego w projekcie, aby plik był zawsze dostępny dla aplikacji.

Zakładka o zakresie dokumentu może zostać rozpoznana przez dowolną aplikację, która może otwierać dane zakładki i sam dokument. Obsługuje to przenośność, umożliwiając użytkownikowi wysyłanie plików projektu do innego użytkownika i współdziałanie wszystkich zakładek.

Ważne

Zakładka o zakresie dokumentu może wskazywać tylko jeden plik, a nie folder i nie może znajdować się w lokalizacji używanej przez system (np/private. lub /Library).

Używanie zakładek o zakresie zabezpieczeń

Użycie dowolnego typu zakładki o zakresie zabezpieczeń wymaga wykonania następujących kroków:

1. Ustaw odpowiednie uprawnienia w aplikacji Xamarin.Mac, która musi używać zakładek o zakresie zabezpieczeń — w przypadku zakładek o zakresie aplikacji ustaw com.apple.security.files.bookmarks.app-scope klucz upoważnienia na truewartość . W przypadku zakładek o zakresie dokumentów ustaw klucz upoważnienia com.apple.security.files.bookmarks.document-scope na truewartość .
2. Utwórz zakładkę o zakresie zabezpieczeń — zrobisz to dla dowolnego pliku lub folderu, do którego użytkownik udzielił dostępu (na przykład za pośrednictwem NSOpenPanel ), do którego aplikacja będzie potrzebować trwałego dostępu. public virtual NSData CreateBookmarkData (NSUrlBookmarkCreationOptions options, string[] resourceValues, NSUrl relativeUrl, out NSError error) Użyj metody NSUrl klasy , aby utworzyć zakładkę.
3. Rozwiąż zakładkę o zakresie zabezpieczeń — gdy aplikacja musi ponownie uzyskać dostęp do zasobu (na przykład po ponownym uruchomieniu), będzie musiała rozpoznać zakładkę pod adresem URL o zakresie zabezpieczeń. public static NSUrl FromBookmarkData (NSData data, NSUrlBookmarkResolutionOptions options, NSUrl relativeToUrl, out bool isStale, out NSError error) Użyj metody NSUrl klasy, aby rozpoznać zakładkę.
4. Jawnie powiadom system, że chcesz uzyskać dostęp do pliku z adresu URL o zakresie zabezpieczeń — ten krok należy wykonać natychmiast po uzyskaniu powyższego adresu URL o zakresie zabezpieczeń lub, gdy później chcesz odzyskać dostęp do zasobu po wycofaniu dostępu do niego. Wywołaj metodę StartAccessingSecurityScopedResource () klasy , NSUrl aby rozpocząć uzyskiwanie dostępu do adresu URL o zakresie zabezpieczeń.
5. Jawnie powiadom system, że uzyskujesz dostęp do pliku z adresu URL o zakresie zabezpieczeń — jak najszybciej należy poinformować system, gdy aplikacja nie potrzebuje już dostępu do pliku (na przykład jeśli użytkownik go zamknie). Wywołaj metodę StopAccessingSecurityScopedResource () klasy , NSUrl aby zatrzymać dostęp do adresu URL o zakresie zabezpieczeń.

Po wycofaniu dostępu do zasobu należy powrócić do kroku 4, aby ponownie ustanowić dostęp. Jeśli aplikacja Xamarin.Mac zostanie ponownie uruchomiona, musisz wrócić do kroku 3 i ponownie rozwiązać zakładkę.

Ważne

Nie można zwolnić dostępu do zasobów adresu URL o zakresie zabezpieczeń, co spowoduje wyciek zasobów jądra aplikacji platformy Xamarin.Mac. W związku z tym aplikacja nie będzie już mogła dodawać lokalizacji systemu plików do kontenera, dopóki nie zostanie ponownie uruchomiona.

Piaskownica aplikacji i podpisywanie kodu

Po włączeniu piaskownicy aplikacji i włączeniu określonych wymagań aplikacji Xamarin.Mac (za pośrednictwem uprawnień) należy podpisać kod, aby piaskownica weszła w życie. Należy wykonać podpisywanie kodu, ponieważ uprawnienia wymagane do piaskownicy aplikacji są połączone z podpisem aplikacji.

System macOS wymusza połączenie między kontenerem aplikacji a jego podpisem kodu, w ten sposób żadna inna aplikacja nie może uzyskać dostępu do tego kontenera, nawet jeśli fałszuje identyfikator pakietu aplikacji. Ten mechanizm działa w następujący sposób:

1. Gdy system tworzy kontener aplikacji, ustawia listę kontroli dostępu (ACL) dla tego kontenera. Początkowy wpis kontroli dostępu na liście zawiera wyznaczone wymaganie aplikacji (DR), w którym opisano sposób rozpoznawania przyszłych wersji aplikacji (po uaktualnieniu).
2. Za każdym razem, gdy aplikacja z tym samym identyfikatorem pakietu zostanie uruchomiona, system sprawdza, czy podpis kodu aplikacji jest zgodny z wyznaczonymi wymaganiami określonymi w jednym z wpisów na liście ACL kontenera. Jeśli system nie znajdzie dopasowania, uniemożliwia uruchomienie aplikacji.

Podpisywanie kodu działa na następujące sposoby:

1. Przed utworzeniem projektu Xamarin.Mac uzyskaj certyfikat dewelopera, certyfikat dystrybucji i certyfikat identyfikatora dewelopera z portalu dla deweloperów firmy Apple.
2. Gdy sklep Mac App Store dystrybuuje aplikację Xamarin.Mac, jest podpisany przy użyciu podpisu kodu firmy Apple.

Podczas testowania i debugowania będziesz używać podpisanej wersji aplikacji Xamarin.Mac (która będzie używana do tworzenia kontenera aplikacji). Później, jeśli chcesz przetestować lub zainstalować wersję ze sklepu Apple App Store, zostanie podpisana przy użyciu podpisu firmy Apple i nie zostanie uruchomiona (ponieważ nie ma tego samego podpisu kodu co oryginalny kontener aplikacji). W takiej sytuacji otrzymasz raport o awarii podobny do następującego:

Exception Type:  EXC_BAD_INSTRUCTION (SIGILL)

Aby rozwiązać ten problem, należy dostosować wpis listy ACL, aby wskazać podpisaną przez firmę Apple wersję aplikacji.

Aby uzyskać więcej informacji na temat tworzenia i pobierania profilów aprowizacji wymaganych do piaskownicy, zobacz sekcję Podpisywanie i aprowizowanie aplikacji powyżej.

Dostosowywanie wpisu listy ACL

Aby zezwolić na uruchamianie podpisanej przez firmę Apple wersji aplikacji Xamarin.Mac, wykonaj następujące czynności:

1. Otwórz aplikację Terminal (w pliku /Applications/Utilities).
2. Otwórz okno wyszukiwania w podpisanej wersji aplikacji Xamarin.Mac firmy Apple.
3. Wpisz asctl container acl add -file polecenie w oknie Terminal.
4. Przeciągnij ikonę aplikacji Xamarin.Mac z okna wyszukiwania i upuść ją w oknie Terminal.
5. Pełna ścieżka do pliku zostanie dodana do polecenia w terminalu.
6. Naciśnij Enter, aby wykonać polecenie.

Lista ACL kontenera zawiera teraz wyznaczone wymagania dotyczące kodu dla obu wersji aplikacji Xamarin.Mac i systemu macOS, które będą teraz zezwalać na uruchamianie obu wersji.

Wyświetlanie listy wymagań dotyczących kodu listy ACL

Listę wymagań dotyczących kodu można wyświetlić na liście ACL kontenera, wykonując następujące czynności:

1. Otwórz aplikację Terminal (w pliku /Applications/Utilities).
2. Wpisz asctl container acl list -bundle <container-name>.
3. Naciśnij Enter, aby wykonać polecenie.

Jest <container-name> to zazwyczaj identyfikator pakietu dla aplikacji Xamarin.Mac.

Projektowanie aplikacji platformy Xamarin.Mac dla piaskownicy aplikacji

Istnieje typowy przepływ pracy, który należy wykonać podczas projektowania aplikacji platformy Xamarin.Mac dla piaskownicy aplikacji. Oznacza to, że specyfika implementacji piaskownicy w aplikacji będzie unikatowa dla funkcjonalności danej aplikacji.

Sześć kroków wdrażania piaskownicy aplikacji

Projektowanie aplikacji Xamarin.Mac dla piaskownicy aplikacji zwykle składa się z następujących kroków:

1. Ustal, czy aplikacja jest odpowiednia do piaskownicy.
2. Projektowanie strategii rozwoju i dystrybucji.
3. Rozwiąż wszelkie niezgodności interfejsu API.
4. Zastosuj wymagane uprawnienia piaskownicy aplikacji do projektu Xamarin.Mac.
5. Dodaj separację uprawnień przy użyciu narzędzia XPC.
6. Zaimplementuj strategię migracji.

Ważne

Musisz nie tylko piaskownicy głównego pliku wykonywalnego w pakiecie aplikacji, ale także każdej dołączonej aplikacji pomocniczej lub narzędzia w tym pakiecie. Jest to wymagane w przypadku każdej aplikacji dystrybuowanej ze sklepu Mac App Store i, jeśli to możliwe, należy wykonać w przypadku dowolnej innej formy dystrybucji aplikacji.

Aby uzyskać listę wszystkich plików binarnych wykonywalnych w pakiecie aplikacji Xamarin.Mac, wpisz następujące polecenie w terminalu:

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

Gdzie [Your-App-Bundle] to nazwa i ścieżka do pakietu aplikacji.

Określanie, czy aplikacja Xamarin.Mac jest odpowiednia do piaskownicy

Większość aplikacji Xamarin.Mac jest w pełni zgodna z piaskownicą aplikacji i dlatego nadaje się do piaskownicy. Jeśli aplikacja wymaga zachowania, na które piaskownica aplikacji nie zezwala, należy rozważyć alternatywne podejście.

Jeśli aplikacja wymaga jednego z następujących zachowań, jest niezgodna z piaskownicą aplikacji:

• Usługi autoryzacji — w piaskownicy aplikacji nie można pracować z funkcjami opisanymi w dokumentacji usług autoryzacji C.
• Interfejsy API ułatwień dostępu — nie można kontrolować aplikacji pomocniczych piaskownicy, takich jak czytniki zawartości ekranu lub aplikacje kontrolujące inne aplikacje.
• Wysyłanie zdarzeń firmy Apple do dowolnych aplikacji — jeśli aplikacja wymaga wysyłania zdarzeń firmy Apple do nieznanej, dowolnej aplikacji, nie może być w trybie piaskownicy. Aby uzyskać znaną listę nazywanych aplikacjami, aplikacja nadal może być w trybie piaskownicy, a uprawnienia muszą zawierać nazwę listy aplikacji.
• Wysyłanie słowników informacji o użytkowniku w powiadomieniach rozproszonych do innych zadań — w piaskownicy aplikacji nie można dołączyć userInfo słownika podczas publikowania w NSDistributedNotificationCenter obiekcie do obsługi komunikatów innych zadań.
• Ładowanie rozszerzeń jądra — ładowanie rozszerzeń jądra jest zabronione przez piaskownicę aplikacji.
• Symulowanie danych wejściowych użytkownika w oknach dialogowych otwierania i zapisywania — programowe manipulowanie oknami dialogowymi Otwieranie lub zapisywanie w celu symulowania lub zmieniania danych wejściowych użytkownika jest zabronione przez piaskownicę aplikacji.
• Uzyskiwanie dostępu do innych aplikacji lub ustawianie preferencji — manipulowanie ustawieniami innych aplikacji jest zabronione przez piaskownicę aplikacji.
• Konfigurowanie ustawień sieciowych — manipulowanie ustawieniami sieci jest zabronione przez piaskownicę aplikacji.
• Kończenie innych aplikacji — piaskownica aplikacji uniemożliwia zakończenie działania innych aplikacji przy użyciu polecenia NSRunningApplication .

Rozwiązywanie niezgodności interfejsu API

Podczas projektowania aplikacji platformy Xamarin.Mac dla piaskownicy aplikacji mogą wystąpić niezgodności z użyciem niektórych interfejsów API systemu macOS.

Oto kilka typowych problemów i czynności, które można rozwiązać, aby je rozwiązać:

• Otwieranie, zapisywanie i śledzenie dokumentów — jeśli zarządzasz dokumentami przy użyciu dowolnej technologii innej niż NSDocument, należy przełączyć się na nią ze względu na wbudowaną obsługę piaskownicy aplikacji. NSDocument Automatycznie współpracuje z usługą PowerBox i zapewnia obsługę przechowywania dokumentów w piaskownicy, jeśli użytkownik przenosi je w programie Finder.
• Zachowaj dostęp do zasobów systemu plików — jeśli aplikacja Xamarin.Mac zależy od trwałego dostępu do zasobów spoza kontenera, użyj zakładek o zakresie zabezpieczeń, aby zachować dostęp.
• Utwórz element logowania dla aplikacji — w piaskownicy aplikacji nie można utworzyć elementu logowania przy użyciu LSSharedFileList ani manipulować stanem usług uruchamiania przy użyciu polecenia LSRegisterURL. Użyj funkcji zgodnie z opisem SMLoginItemSetEnabled w artykule Dodawanie elementów logowania firmy Apple przy użyciu dokumentacji programu Service Management Framework .
• Uzyskiwanie dostępu do danych użytkownika — jeśli używasz funkcji POSIX, takich jak getpwuid uzyskiwanie katalogu macierzystego użytkownika z usług katalogowych, rozważ użycie symboli Cocoa lub Core Foundation, takich jak NSHomeDirectory.
• Uzyskiwanie dostępu do preferencji innych aplikacji — ponieważ piaskownica aplikacji kieruje interfejsy API znajdowania ścieżki do kontenera aplikacji, modyfikowanie preferencji odbywa się w tym kontenerze i uzyskiwanie dostępu do innych preferencji aplikacji w niedozwolonym.
• Korzystanie z osadzonego klipu wideo HTML5 w widokach internetowych — jeśli aplikacja Xamarin.Mac używa zestawu WebKit do odtwarzania osadzonych filmów wideo HTML5, należy również połączyć aplikację ze strukturą AV Foundation. Piaskownica aplikacji uniemożliwi usłudze CoreMedia odtwarzanie tych filmów wideo w przeciwnym razie.

Stosowanie wymaganych uprawnień piaskownicy aplikacji

Musisz edytować uprawnienia dla dowolnej aplikacji platformy Xamarin.Mac, którą chcesz uruchomić w piaskownicy aplikacji, i zaznaczyć pole wyboru Włącz piaskownicę aplikacji.

Na podstawie funkcjonalności aplikacji może być konieczne włączenie innych uprawnień w celu uzyskania dostępu do funkcji lub zasobów systemu operacyjnego. Piaskownica aplikacji działa najlepiej, gdy minimalizujesz uprawnienia, które żądasz do minimum wymaganego do uruchomienia aplikacji, więc po prostu losowo włącz uprawnienia.

Aby określić uprawnienia wymagane przez aplikację platformy Xamarin.Mac, wykonaj następujące czynności:

1. Włącz piaskownicę aplikacji i uruchom aplikację Xamarin.Mac.
2. Zapoznaj się z funkcjami aplikacji.
3. Otwórz aplikację konsolową (dostępną w programie /Applications/Utilities) i wyszukaj sandboxd naruszenia w dzienniku Wszystkie komunikaty .
4. W przypadku każdego sandboxd naruszenia rozwiąż problem przy użyciu kontenera aplikacji zamiast innych lokalizacji systemu plików lub zastosuj uprawnienia piaskownicy aplikacji, aby umożliwić dostęp do ograniczonych funkcji systemu operacyjnego.
5. Ponownie uruchom i ponownie przetestuj wszystkie funkcje aplikacji platformy Xamarin.Mac.
6. Powtarzaj, dopóki wszystkie sandboxd naruszenia nie zostały rozwiązane.

Dodawanie separacji uprawnień przy użyciu narzędzia XPC

Podczas tworzenia aplikacji platformy Xamarin.Mac dla piaskownicy aplikacji przyjrzyj się zachowaniom aplikacji pod względem uprawnień i dostępu, a następnie rozważ rozdzielenie operacji wysokiego ryzyka na własne usługi XPC.

Aby uzyskać więcej informacji, zobacz Tworzenie usług XPC i demonów i usług firmy Apple w przewodniku programowania.

Implementowanie strategii migracji

Jeśli publikujesz nową, w trybie piaskownicy wersję aplikacji platformy Xamarin.Mac, która nie została wcześniej w trybie piaskownicy, musisz upewnić się, że obecni użytkownicy mają płynną ścieżkę uaktualniania.

Aby uzyskać szczegółowe informacje na temat implementowania manifestu migracji kontenerów, przeczytaj dokumentację migrowania aplikacji firmy Apple do piaskownicy .

Podsumowanie

W tym artykule przedstawiono szczegółowe spojrzenie na piaskownicę aplikacji platformy Xamarin.Mac. Najpierw utworzyliśmy po prostu aplikację Xamarin.Mac, aby wyświetlić podstawy piaskownicy aplikacji. Następnie pokazaliśmy, jak rozwiązać problemy z naruszeniami piaskownicy. Następnie przyjrzeliśmy się szczegółowo piaskownicy aplikacji, a na koniec przyjrzeliśmy się projektowaniu aplikacji Xamarin.Mac dla piaskownicy aplikacji aplikacji.

Linki powiązane

• Publikowanie w sklepie App Store
• Informacje o piaskownicy aplikacji
• Typowe problemy z piaskownicą aplikacji