MIME Type — ce este, tipuri de fișiere și determinare în iOS

Ce este MIME Type?

MIME Type (Multipurpose Internet Mail Extensions) — este un identificator standardizat al formatului de date format din două părți: tipul principal (type) și subtipul (subtype), separate printr-o bară oblică. Categoriile principale: text (text), image (imagini), audio (audio), video (video), application (date binare), multipart (mesaje compuse).

Standardul MIME a fost inițial dezvoltat pentru atașamentele de email (RFC 2046, 1996), dar astăzi este utilizat peste tot: serverele HTTP indică Content-Type al răspunsului, browserele determină cum să proceseze fișierele, iar aplicațiile mobile — ce date pot fi deschise. IANA (Internet Assigned Numbers Authority) menține registrul tipurilor MIME înregistrate.

Conform IANA Media Types Registry (2024), sunt înregistrate peste 1800 de tipuri MIME oficiale, iar numărul real incluzând tipurile personalizate și de vendor depășește 5000. iOS suportă majoritatea tipurilor standard și oferă API pentru lucrul cu ele prin Uniform Type Identifiers.

MIME și UTI în iOS: diferențe și conversie

UTI (Uniform Type Identifier) — este sistemul propriu Apple de identificare a tipurilor de conținut, utilizat în interiorul iOS și macOS. Spre deosebire de MIME, UTI suportă ierarhia de moștenire (de exemplu, public.image — părinte pentru public.png și public.jpeg) și include nu doar formatele de fișiere, ci și tipuri abstracte de date.

Conversia între MIME și UTI în iOS se realizează prin clasa UTType (iOS 14+). Sistemul menține o bază internă de corespondențe care acoperă majoritatea formatelor standard. Pentru tipurile personalizate, dezvoltatorul înregistrează corespondența în 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 ?? "")")
}

// Conversie inversă: UTI în MIME
if let uti = UTType(filenameExtension: "pdf"),
   let mime = uti.preferredMIMEType {
    print("MIME for PDF: \(mime)")
}

Ierarhia UTI permite verificarea dacă un tip corespunde unei anumite categorii. De exemplu, toate tipurile de imagini (JPEG, PNG, GIF) conforms(to: .image). Acest lucru este convenabil pentru filtrarea în grup și determinarea capacității de procesare a tipului de către componentele sistemului.

Diferența importantă: MIME — este o clasificare plată (fără moștenire), în timp ce UTI suportă moștenirea multiplă. De exemplu, public.html corespunde atât public.source-code, cât și public.text. Aceasta oferă o rutare mai flexibilă la procesarea fișierelor în iOS.

Cum se determină MIME Type al unui fișier în iOS

Trei metode de determinare a MIME Type sunt disponibile în iOS: după extensia fișierului (rapid, dar nesigur), după conținut prin magic bytes (sigur, dar necesită citirea fișierului) și după antetul HTTP Content-Type (doar pentru cererile de rețea).

import UniformTypeIdentifiers

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

    // Detectează după conținut (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
    }
}

Determinarea după extensie prin UTType — este cea mai rapidă metodă, dar este nesigură dacă extensia lipsește sau este falsificată. Un atacator poate redenumi .exe în .jpg — sistemul va determina image/jpeg, deși fișierul este executabil. Pentru scenariile critice (securitate, date medicale) utilizați obligatoriu verificarea după conținut.

Magic bytes — sunt primii octeți ai fișierului, unici pentru fiecare format. Majoritatea formatelor au o semnătură de 2–12 octeți. iOS nu oferă un detector MIME încorporat după conținut — dezvoltatorul fie implementează singur un tabel de semnături, fie utilizează biblioteci precum CocoaLumberjack sau un detector personalizat bazat pe euristici.

Înregistrarea tipurilor personalizate MIME și UTI

Tipurile personalizate sunt necesare atunci când aplicația lucrează cu formate de date proprietare, neînregistrate în IANA sau Apple. Înregistrarea în Info.plist permite iOS să proceseze corect astfel de fișiere: să le deschidă din Files.app, să afișeze pictograme și să le transmită altor aplicații prin 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>

Pentru înregistrarea unui tip personalizat, trebuie să specificați în Info.plist: identificatorul UTI (în format reverse-DNS), conformitatea cu tipurile părinte, extensia fișierului și tipul MIME. iOS utilizează aceste informații pentru rutarea fișierelor: când utilizatorul deschide un fișier .sdoc, sistemul știe că proprietarul său este aplicația dumneavoastră.

UTExportedTypeDeclarations — pentru tipurile definite de aplicația dumneavoastră (export). UTImportedTypeDeclarations — pentru tipurile create de alte aplicații cu care aplicația dumneavoastră poate lucra (import). Apple recomandă înregistrarea tuturor tipurilor personalizate cu care lucrează aplicația pentru o integrare corectă cu sistemul.

Securitatea și procesarea tipurilor necunoscute

Tipurile MIME necunoscute reprezintă un risc pentru securitatea aplicației iOS. Dacă un fișier are un tip necunoscut sau neverificat, aplicația trebuie să ia măsuri de precauție: să nu deschidă fișierul automat, să arate o avertizare utilizatorului sau să analizeze conținutul înainte de procesare.

Amenințările principale: un fișier cu tip MIME falsificat poate conține cod malițios sau un exploit pentru o vulnerabilitate a parserului. iOS protejează sistemul prin Sandbox, dar aplicația poate fi vulnerabilă dacă are încredere în tipul MIME fără verificarea conținutului. Verificați întotdeauna fișierul după magic bytes dacă provine dintr-o sursă nesigură.

Conform OWASP Mobile Security Guide, 2024, pentru procesarea fișierelor de tipuri necunoscute se aplică următoarele practici: respingeți fișierele cu tipul MIME application/octet-stream din surse neverificate; utilizați UTType pentru verificarea conformității cu categoriile așteptate; nu deschideți fișiere în aplicații externe fără confirmarea utilizatorului; înregistrați toate cazurile de neconcordanță între MIME și conținutul real pentru auditul de securitate.

Înregistrarea tipurilor MIME personalizate în Info.plist — nu este doar funcționalitate, ci și securitate. Dacă aplicația înregistrează corect doar propriile sale tipuri, sistemul nu va trimite în mod eronat fișiere străine către ea. Utilizați prefixe specifice de vendor (application/vnd.company.app-format) în loc de cele generale (application/x-format) pentru a evita conflictele cu alte aplicații.