Sandbox — vad är det, isoleringsprincip och filsystem

Vad är Sandbox

Sandbox — är ett system för obligatorisk åtkomstkontroll (Mandatory Access Control), implementerat på iOS-kärnnivå (XNU — kernel extension Sandbox.kext). Varje applikation får vid start en unik UUID Sandbox-profil som bestämmer vilka systemresurser som är tillåtna att komma åt.

Sandbox-arkitekturen omfattar tre nyckelkomponenter: File System Isolation (varje applikation ser bara sin egen behållare), Network Access Control (förfrågningar till det lokala nätverket kan begränsas) och Inter-Process Communication (förbud mot direkt IPC med andra applikationer). Apple introducerade Sandbox i iOS 2.0 och har sedan dess avsevärt skärpt begränsningarna i varje större version.

Sandbox är inte valfri — alla applikationer från App Store körs i sandlådan. Utvecklaren kan inte inaktivera Sandbox eller kringgå dess begränsningar. Ett försök att komma åt en förbjuden resurs slutar med ett fel med kod EPERM (Operation not permitted) och en post i systemloggen.

import Foundation

// Försök att komma åt en annan applikations fil — returnerar nil
let otherAppPath = "/var/mobile/Containers/Data/Application/OTHER-UUID/Documents/file.txt"
let data = try? Data(contentsOf: URL(fileURLWithPath: otherAppPath))
// data == nil — Sandbox blockerar åtkomst

// Korrekt åtkomst — inom egen Sandbox
let fileManager = FileManager.default
guard let documentsURL = fileManager.urls(
    for: .documentDirectory,
    in: .userDomainMask
).first else { return }

let myFileURL = documentsURL.appendingPathComponent("notes.txt")
try "Hello, Sandbox!".write(to: myFileURL, atomically: true, encoding: .utf8)

Struktur för applikationens sandlåda

Sandbox för varje iOS-applikation innehåller flera fördefinierade kataloger, tillgängliga via Foundation API. Placeringen på det fysiska mediet — /var/mobile/Containers/Data/Application/{UUID}/, men utvecklare bör inte använda denna sökväg direkt: den ändras vid varje omstart av enheten i olika iOS-versioner.

Huvudkatalogerna i Sandbox: Bundle (.app — skrivskyddad, innehåller exekverbar kod och resurser), Documents (användardata, säkerhetskopieras till iCloud), Library (Caches, Preferences, Application Support — med olika regler för säkerhetskopiering), tmp (tillfälliga filer, raderas av systemet vid platsbrist). Varje katalog har sin egen livscykel och lagringspolicy.

Den fysiska sökvägen till Sandbox kan erhållas via NSHomeDirectory() eller FileManager.url(for: .documentDirectory). Apple rekommenderar att använda URL-baserat API eftersom det abstraherar den interna strukturen i filsystemet och förblir stabilt vid ändringar i macOS Sandbox på skrivbordet.

Åtkomst till filer utanför sandlådan

Direkt åtkomst till filsystemet för andra applikationer i iOS är helt blockerad. Även om utvecklaren känner till UUID för en annan applikations behållare kommer Sandbox på kärnnivå att returnera ett fel vid försök till läsning eller skrivning. Detta är den grundläggande skillnaden mellan iOS och macOS, där Sandbox är mer flexibel.

Apple tillhandahåller tre legitima mekanismer för datautbyte mellan applikationer: UIDocumentPickerViewController (användaren väljer en fil via systemgränssnittet, applikationen får en Security-Scoped URL), Share Extension (tillägg för att överföra data till en annan applikation) och App Groups (delad katalog för applikationer från samma utvecklare).

UIDocumentPicker — det enda sättet att få åtkomst till filer från andra applikationer utan föregående konfiguration. Användaren väljer explicit en fil via standard systemväljaren och iOS ger applikationen en tillfällig Security-Scoped URL. Åtkomsten gäller tills väljaren stängs eller tills stopAccessingSecurityScopedResource anropas.

Security-Scoped Bookmarks

Security-Scoped Bookmark — är en iOS-mekanism som gör det möjligt att behålla åtkomst till en fil utanför Sandbox mellan applikationsstarter. När användaren väljer en fil via UIDocumentPicker kan applikationen skapa ett bokmärke från Security-Scoped URL och spara det i UserDefaults eller annan lagring.

Vid nästa start återställer applikationen åtkomsten via URLByResolvingBookmarkData, som returnerar en Security-Scoped URL. Därefter måste startAccessingSecurityScopedResource anropas före läsning av filen och stopAccessingSecurityScopedResource efter avslutat arbete. Balans av anrop är obligatorisk — varje start måste ha en motsvarande stop, annars kommer systemet att förbruka gränsen för Security-Scoped-resurser.

// Skapa Security-Scoped Bookmark
func createBookmark(for url: URL) -> Data? {
    return try? url.bookmarkData(
        options: .minimalBookmark,
        includingResourceValuesForKeys: nil,
        relativeTo: nil
    )
}

// Lös bokmärkesdata till URL
func resolveBookmark(data: Data) -> URL? {
    var isStale = false
    let url = try? URL.byResolvingBookmarkData(
        data,
        options: .withoutUI,
        relativeTo: nil,
        bookmarkDataIsStale: &isStale
    )
    
    if isStale {
        // Bokmärket är inaktuellt, måste skapa nytt
    }
    
    return url
}

Viktig begränsning: Security-Scoped Bookmarks fungerar inte för filer inom den egna Sandbox — endast för filer som erhållits via UIDocumentPicker eller iCloud Drive. Bokmärket innehåller Security-Scoped-data som gör det möjligt för systemet att identifiera vilken applikation och för vilken fil som begär åtkomst. Om applikationens certifikat löper ut eller ändras blir bokmärket ogiltigt.

Sandbox och App Groups

App Groups — en iOS-mekanism som gör att flera applikationer (och deras tillägg) från samma utvecklare kan ha en delad Sandbox-katalog. För att aktivera måste du lägga till Capability App Groups i Xcode och ange samma gruppidentifierare för alla målapplikationer.

Den delade App Groups-katalogen ligger utanför varje enskild applikations Sandbox, men alla applikationer i gruppen har full åtkomst till den för läsning och skrivning. Detta möjliggör utbyte av filer, databaser (Core Data med Store URL i App Group) och UserDefaults (via initWithSuiteName) mellan huvudapplikationen, Today Widget, Watch Extension och Share Extension.

Apple rekommenderar att använda App Groups för synkronisering av tillstånd mellan applikationen och dess tillägg. Till exempel kan Today Widget läsa data från den delade App Group-katalogen där huvudapplikationen skriver aktuell data. Varje applikation är dock fortfarande isolerad från andra App Groups — endast applikationer med samma gruppidentifierare har åtkomst.

Begränsningar för sandlådan i iOS

Sandbox i iOS inför en rad strikta begränsningar som måste beaktas vid utveckling. De viktigaste: förbud mot dynamisk kod (laddning och exekvering av kod utanför Sandbox), förbud mot direkt åtkomst till adressboken, kalendern och foton utan användarens tillstånd (Privacy framework) och begränsningar för att skapa underprocesser (fork, exec är förbjudna).

Nätverk: applikationer kan ansluta till alla fjärrservrar via TCP/UDP, men åtkomst till localhost är begränsad — andra applikationer kan inte ansluta till servern inuti din applikation (förutom debug-byggen). Multicast och broadcast UDP blockeras också för App Store-applikationer.

Hårdvaruresurser: åtkomst till kamera, mikrofon, geolokalisering, Bluetooth och HealthKit kräver explicit tillstånd från användaren via en systemdialog. För varje resurstyp använder iOS en separat entitlement och Info.plist-nyckel med en beskrivning av orsaken (NSPhotoLibraryUsageDescription, NSCameraUsageDescription). En begäran om tillstånd utan orsaksbeskrivning i Info.plist leder till att applikationen avslutas.

• Dynamisk kod — förbjuden: JavaScriptCore för JS i WebView, men inte godtycklig maskinkod
• Underprocesser — fork, exec, system är inte tillgängliga från Sandbox
• Åtkomst till enheter — kamera, mikrofon, GPS kräver systemdialog
• Lokalt nätverk — multicast och broadcast UDP blockeras för App Store
• Krypteringsnycklar — Keychain tillgängligt, men endast för egen applikation (kSecAttrAccessGroup för App Group)