MIME Type — vad är det, filtyper och bestämning i iOS

Vad är MIME Type?

MIME Type (Multipurpose Internet Mail Extensions) — är en standardiserad identifierare för dataformat som består av två delar: huvudtyp (type) och subtyp (subtype), separerade med ett snedstreck. Huvudkategorier: text (text), image (bilder), audio (ljud), video (video), application (binärdata), multipart (sammansatta meddelanden).

MIME-standarden utvecklades ursprungligen för e-postbilagor (RFC 2046, 1996), men används idag överallt: HTTP-servrar anger Content-Type för svar, webbläsare bestämmer hur filer ska bearbetas och mobilapplikationer — vilken data som kan öppnas. IANA (Internet Assigned Numbers Authority) upprätthåller ett register över registrerade MIME-typer.

Enligt IANA Media Types Registry (2024) finns över 1800 officiella MIME-typer registrerade, och det faktiska antalet inklusive anpassade och leverantörstyper överstiger 5000. iOS stöder de flesta standardtyperna och tillhandahåller API för att arbeta med dem via Uniform Type Identifiers.

MIME och UTI i iOS: skillnader och konvertering

UTI (Uniform Type Identifier) — är Apples eget system för identifiering av innehållstyper, som används inom iOS och macOS. Till skillnad från MIME stöder UTI arvshierarki (t.ex. public.image — förälder för public.png och public.jpeg) och omfattar inte bara filformat utan även abstrakta datatyper.

Konvertering mellan MIME och UTI i iOS sker via klassen UTType (iOS 14+). Systemet upprätthåller en intern databas med överensstämmelser som täcker de flesta standardformat. För anpassade typer registrerar utvecklaren överensstämmelsen i Info.plist.

import UniformTypeIdentifiers

let mimeType = "image/jpeg"
if let uti = UTType(mimeType: mimeType) {
    print("UTI: \(uti.identifier)")
    print("Conforms to image: \(uti.conforms(to: .image))")
    print("Extension: \(uti.preferredFilenameExtension ?? "")")
}

// Omvänd konvertering: UTI till MIME
if let uti = UTType(filenameExtension: "pdf"),
   let mime = uti.preferredMIMEType {
    print("MIME for PDF: \(mime)")
}

UTI-hierarki gör det möjligt att kontrollera om en typ motsvarar en viss kategori. Till exempel alla bildtyper (JPEG, PNG, GIF) conforms(to: .image). Detta är praktiskt för gruppfiltrering och bestämning av typens bearbetningsförmåga av systemkomponenter.

Viktig skillnad: MIME — är en platt klassificering (utan arv), medan UTI stöder multipelt arv. Till exempel motsvarar public.html både public.source-code och public.text. Detta ger mer flexibel routning vid bearbetning av filer i iOS.

Hur man bestämmer MIME Type för en fil i iOS

Tre metoder för bestämning av MIME Type finns tillgängliga i iOS: via filändelse (snabbt, men opålitligt), via innehåll genom magic bytes (pålitligt, men kräver läsning av filen) och via HTTP-header Content-Type (endast för nätverksförfrågningar).

import UniformTypeIdentifiers

enum MIMEDetector {
    // Identifiera via ändelse
    static func fromExtension(_ ext: String) -> String? {
        UTType(filenameExtension: ext)?.preferredMIMEType
    }

    // Identifiera via innehåll (magic bytes)
    static func fromFile(at url: URL) -> String? {
        guard let handle = try? FileHandle(forReadingFrom: url) else {
            return nil
        }
        defer { handle.closeFile() }
        let header = handle.readData(ofLength: 12)

        // PNG: 89 50 4E 47 0D 0A 1A 0A
        // JPEG: FF D8 FF
        // PDF: 25 50 44 46
        // ZIP: 50 4B 03 04

        if header.starts(with: [0x89, 0x50, 0x4E, 0x47]) {
            return "image/png"
        }
        if header.starts(with: [0xFF, 0xD8, 0xFF]) {
            return "image/jpeg"
        }
        if header.starts(with: [0x25, 0x50, 0x44, 0x46]) {
            return "application/pdf"
        }
        return nil
    }
}

Bestämning via ändelse via UTType — den snabbaste metoden, men opålitlig om ändelsen saknas eller är förfalskad. En angripare kan byta namn på .exe till .jpg — systemet bestämmer image/jpeg, trots att filen är körbar. För kritiska scenarier (säkerhet, medicinska data) använd obligatoriskt kontroll via innehåll.

Magic bytes — är filens första byte, unika för varje format. De flesta format har en signatur på 2–12 byte. iOS tillhandahåller ingen inbyggd MIME-detektor baserad på innehåll — utvecklaren implementerar antingen en signaturtabell själv, eller använder bibliotek som CocoaLumberjack eller en anpassad detektor baserad på heuristik.

Registrering av anpassade MIME- och UTI-typer

Anpassade typer är nödvändiga när applikationen arbetar med proprietära dataformat som inte är registrerade hos IANA eller Apple. Registrering i Info.plist gör det möjligt för iOS att korrekt bearbeta sådana filer: öppna dem från Files.app, visa ikoner och vidarebefordra dem till andra applikationer via UIActivityViewController.

<key>CFBundleDocumentTypes</key>
<array>
    <dict>
        <key>CFBundleTypeName</key>
        <string>MyApp Document</string>
        <key>LSHandlerRank</key>
        <string>Owner</string>
        <key>LSItemContentTypes</key>
        <array>
            <string>com.myapp.secret-doc</string>
        </array>
    </dict>
</array>
<key>UTExportedTypeDeclarations</key>
<array>
    <dict>
        <key>UTTypeIdentifier</key>
        <string>com.myapp.secret-doc</string>
        <key>UTTypeTagSpecification</key>
        <dict>
            <key>public.filename-extension</key>
            <array><string>sdoc</string></array>
            <key>public.mime-type</key>
            <array><string>application/vnd.myapp.secret-doc</string></array>
        </dict>
    </dict>
</array>

För registrering av en anpassad typ måste du ange i Info.plist: UTI-identifierare (i reverse-DNS-format), överensstämmelse med överordnade typer, filändelse och MIME-typ. iOS använder denna information för filroutning: när en användare öppnar en .sdoc-fil vet systemet att dess ägare är din applikation.

UTExportedTypeDeclarations — för typer som definieras av din applikation (export). UTImportedTypeDeclarations — för typer som skapats av andra applikationer som din applikation kan arbeta med (import). Apple rekommenderar att registrera alla anpassade typer som applikationen arbetar med för korrekt integration med systemet.

Säkerhet och bearbetning av okända typer

Okända MIME-typer utgör en risk för iOS-applikationens säkerhet. Om en fil har en okänd eller overifierad typ bör applikationen vidta försiktighetsåtgärder: inte öppna filen automatiskt, visa en varning för användaren eller analysera innehållet före bearbetning.

Huvudsakliga hot: en fil med förfalskad MIME-typ kan innehålla skadlig kod eller en exploit för en sårbarhet i parsern. iOS skyddar systemet via Sandbox, men applikationen kan vara sårbar om den litar på MIME-typen utan innehållskontroll. Kontrollera alltid filen via magic bytes om den kommer från en opålitlig källa.

Enligt OWASP Mobile Security Guide, 2024 tillämpas följande praxis för bearbetning av filer av okända typer: avvisa filer med MIME-typen application/octet-stream från overifierade källor; använd UTType för kontroll av överensstämmelse med förväntade kategorier; öppna inte filer i externa applikationer utan användarens bekräftelse; logga alla fall av avvikelse mellan MIME och faktiskt innehåll för säkerhetsrevision.

Registrering av anpassade MIME-typer i Info.plist — är inte bara funktionalitet, utan också säkerhet. Om applikationen endast registrerar sina egna typer korrekt kommer systemet inte av misstag att skicka främmande filer till den. Använd specifika leverantörsprefix (application/vnd.company.app-format) istället för allmänna (application/x-format) för att undvika konflikter med andra applikationer.