MIME Type — wat is het, bestandstypen en bepaling in iOS

Wat is MIME Type?

MIME Type (Multipurpose Internet Mail Extensions) — is een gestandaardiseerde identificatie van het gegevensformaat bestaande uit twee delen: het hoofdtype (type) en subtype (subtype), gescheiden door een schuine streep. Hoofdcategorieën: text (tekst), image (afbeeldingen), audio (audio), video (video), application (binaire gegevens), multipart (samengestelde berichten).

De MIME-standaard werd oorspronkelijk ontwikkeld voor e-mailbijlagen (RFC 2046, 1996), maar wordt tegenwoordig overal gebruikt: HTTP-servers geven de Content-Type van het antwoord aan, browsers bepalen hoe bestanden te verwerken, en mobiele applicaties — welke gegevens kunnen worden geopend. IANA (Internet Assigned Numbers Authority) onderhoudt het register van geregistreerde MIME-typen.

Volgens IANA Media Types Registry (2024) zijn er meer dan 1800 officiële MIME-typen geregistreerd, en het werkelijke aantal inclusief aangepaste en vendor-typen overschrijdt 5000. iOS ondersteunt de meeste standaardtypen en biedt API voor het werken ermee via Uniform Type Identifiers.

MIME en UTI in iOS: verschillen en conversie

UTI (Uniform Type Identifier) — is Apple's eigen systeem voor identificatie van inhoudstypen, gebruikt binnen iOS en macOS. In tegenstelling tot MIME ondersteunt UTI een overervingshiërarchie (bijv. public.image — ouder voor public.png en public.jpeg) en omvat niet alleen bestandsformaten, maar ook abstracte gegevenstypen.

Conversie tussen MIME en UTI in iOS gebeurt via de klasse UTType (iOS 14+). Het systeem onderhoudt een interne database van overeenkomsten die de meeste standaardformaten dekt. Voor aangepaste typen registreert de ontwikkelaar de overeenkomst in 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 ?? "")")
}

// Omgekeerde conversie: UTI naar MIME
if let uti = UTType(filenameExtension: "pdf"),
   let mime = uti.preferredMIMEType {
    print("MIME for PDF: \(mime)")
}

UTI-hiërarchie maakt het mogelijk te controleren of een type overeenkomt met een bepaalde categorie. Bijvoorbeeld, alle afbeeldingstypen (JPEG, PNG, GIF) conforms(to: .image). Dit is handig voor groepsfiltratie en het bepalen van de verwerkingscapaciteit van het type door systeemcomponenten.

Belangrijk verschil: MIME — is een platte classificatie (geen overerving), terwijl UTI meervoudige overerving ondersteunt. Bijvoorbeeld, public.html komt overeen met zowel public.source-code als public.text. Dit zorgt voor flexibelere routering bij het verwerken van bestanden in iOS.

Hoe het MIME Type van een bestand in iOS te bepalen

Drie methoden voor het bepalen van MIME Type zijn beschikbaar in iOS: via bestandsextensie (snel, maar onbetrouwbaar), via inhoud door magic bytes (betrouwbaar, maar vereist het lezen van het bestand) en via de HTTP-header Content-Type (alleen voor netwerkverzoeken).

import UniformTypeIdentifiers

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

    // Detecteer via inhoud (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
    }
}

Bepaling via extensie via UTType — is de snelste methode, maar onbetrouwbaar als de extensie ontbreekt of is vervalst. Een aanvaller kan .exe hernoemen naar .jpg — het systeem bepaalt image/jpeg, hoewel het bestand uitvoerbaar is. Voor kritieke scenario's (veiligheid, medische gegevens) gebruik altijd controle via inhoud.

Magic bytes — zijn de eerste bytes van het bestand, uniek voor elk formaat. De meeste formaten hebben een handtekening van 2–12 bytes. iOS biedt geen ingebouwde MIME-detector op basis van inhoud — de ontwikkelaar implementeert ofwel zelf een handtekeningentabel, of gebruikt bibliotheken zoals CocoaLumberjack of een aangepaste detector op basis van heuristieken.

Registratie van aangepaste MIME en UTI typen

Aangepaste typen zijn noodzakelijk wanneer de applicatie werkt met propriëtaire gegevensformaten die niet zijn geregistreerd bij IANA of Apple. Registratie in Info.plist stelt iOS in staat dergelijke bestanden correct te verwerken: ze te openen vanuit Files.app, pictogrammen weer te geven en ze door te geven aan andere applicaties 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>

Voor registratie van een aangepast type moet u in Info.plist vermelden: UTI-identificatie (in reverse-DNS-formaat), overeenkomst met bovenliggende typen, bestandsextensie en MIME-type. iOS gebruikt deze informatie voor bestandsroutering: wanneer een gebruiker een .sdoc-bestand opent, weet het systeem dat de eigenaar uw applicatie is.

UTExportedTypeDeclarations — voor typen gedefinieerd door uw applicatie (export). UTImportedTypeDeclarations — voor typen gemaakt door andere applicaties waarmee uw applicatie kan werken (import). Apple raadt aan alle aangepaste typen waarmee de applicatie werkt te registreren voor correcte integratie met het systeem.

Veiligheid en verwerking van onbekende typen

Onbekende MIME-typen vormen een risico voor de veiligheid van iOS-applicaties. Als een bestand een onbekend of niet-geverifieerd type heeft, moet de applicatie voorzorgsmaatregelen nemen: het bestand niet automatisch openen, een waarschuwing aan de gebruiker tonen of de inhoud analyseren vóór verwerking.

Belangrijkste bedreigingen: een bestand met een vervalst MIME-type kan kwaadaardige code of een exploit voor een parser-kwetsbaarheid bevatten. iOS beschermt het systeem via Sandbox, maar de applicatie kan kwetsbaar zijn als ze het MIME-type vertrouwt zonder inhoudscontrole. Controleer altijd het bestand via magic bytes als het uit een onbetrouwbare bron komt.

Volgens OWASP Mobile Security Guide, 2024 worden de volgende praktijken toegepast voor het verwerken van bestanden van onbekende typen: weiger bestanden met MIME-type application/octet-stream uit onbetrouwbare bronnen; gebruik UTType om overeenkomst met verwachte categorieën te controleren; open geen bestanden in externe applicaties zonder bevestiging van de gebruiker; log alle gevallen van niet-overeenstemming tussen MIME en werkelijke inhoud voor veiligheidsaudit.

Registratie van aangepaste MIME-typen in Info.plist — is niet alleen functionaliteit, maar ook veiligheid. Als de applicatie alleen haar eigen typen correct registreert, zal het systeem niet per ongeluk vreemde bestanden naar haar sturen. Gebruik specifieke vendor-prefixen (application/vnd.company.app-format) in plaats van algemene (application/x-format) om conflicten met andere applicaties te voorkomen.