Type MIME — ce que c'est, types de fichiers et détection dans iOS

Qu'est-ce que le Type MIME ?

MIME Type (Multipurpose Internet Mail Extensions) est un identifiant normalisé de format de données composé de deux parties : un type principal (type) et un sous-type (subtype), séparés par une barre oblique. Catégories principales : text (texte), image (images), audio, video, application (données binaires), multipart (messages composites).

Le standard MIME a été initialement développé pour les pièces jointes des e-mails (RFC 2046, 1996), mais il est aujourd'hui utilisé partout : les serveurs HTTP spécifient le Content-Type des réponses, les navigateurs déterminent comment traiter les fichiers, et les applications mobiles identifient quelles données peuvent être ouvertes. L'IANA (Internet Assigned Numbers Authority) tient un registre des types MIME enregistrés.

Selon le Registre des Types Média IANA (2024), plus de 1 800 types MIME officiels sont enregistrés, et le nombre réel incluant les types personnalisés et fournisseurs dépasse les 5 000. iOS prend en charge la plupart des types standards et fournit des API pour travailler avec eux via les Uniform Type Identifiers.

MIME et UTI dans iOS : Différences et Conversion

UTI (Uniform Type Identifier) est le propre système d'identification des types de contenu d'Apple utilisé dans iOS et macOS. Contrairement à MIME, UTI prend en charge une hiérarchie d'héritage (par exemple, public.image est le parent de public.png et public.jpeg) et inclut non seulement les formats de fichiers mais aussi les types de données abstraits.

Conversion entre MIME et UTI dans iOS est effectuée via la classe UTType (iOS 14+). Le système maintient une base de données de correspondances interne qui couvre la plupart des formats standards. Pour les types personnalisés, le développeur enregistre la correspondance dans Info.plist.

import UniformTypeIdentifiers

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

// Conversion inverse : UTI vers MIME
if let uti = UTType(filenameExtension: "pdf"),
   let mime = uti.preferredMIMEType {
    print("MIME pour PDF : \(mime)")
}

Hiérarchie UTI permet de vérifier si un type est conforme à une certaine catégorie. Par exemple, tous les types d'image (JPEG, PNG, GIF) conform(to : .image). Ceci est pratique pour le filtrage par groupe et pour déterminer si un type peut être traité par les composants système.

Différence importante : MIME est une classification plate (sans héritage), tandis qu'UTI prend en charge l'héritage multiple. Par exemple, public.html est conforme à la fois à public.source-code et public.text. Cela permet un routage plus flexible lors du traitement des fichiers dans iOS.

Comment Déterminer le Type MIME d'un Fichier dans iOS

Trois méthodes pour déterminer le Type MIME sont disponibles dans iOS : par extension de fichier (rapide mais peu fiable), par contenu via magic bytes (fiable mais nécessite la lecture du fichier) et par en-tête HTTP Content-Type (uniquement pour les requêtes réseau).

import UniformTypeIdentifiers

enum MIMEDetector {
    // Détecter par extension
    static func fromExtension(_ ext: String) -> String? {
        UTType(filenameExtension: ext)?.preferredMIMEType
    }

    // Détecter par contenu (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
    }
}

Détection par extension via UTType est la méthode la plus rapide, mais elle n'est pas fiable si l'extension est absente ou falsifiée. Un attaquant pourrait renommer .exe en .jpg — le système l'identifierait comme image/jpeg même si le fichier est exécutable. Pour les scénarios critiques (sécurité, données médicales), utilisez toujours une vérification basée sur le contenu.

Magic bytes sont les premiers octets d'un fichier, uniques à chaque format. La plupart des formats ont une signature de 2 à 12 octets. iOS ne fournit pas de détecteur MIME intégré par contenu — le développeur implémente soit lui-même une table de signatures, soit utilise des bibliothèques comme CocoaLumberjack ou un détecteur personnalisé basé sur des heuristiques.

Enregistrement des Types MIME et UTI Personnalisés

Types personnalisés sont nécessaires lorsqu'une application travaille avec des formats de données propriétaires non enregistrés auprès de l'IANA ou d'Apple. L'enregistrement dans Info.plist permet à iOS de traiter correctement ces fichiers : les ouvrir depuis Files.app, afficher des icônes et les transmettre à d'autres applications 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>

Pour enregistrer un type personnalisé, vous devez spécifier dans Info.plist : l'identifiant UTI (au format reverse-DNS), la conformité aux types parents, l'extension de fichier et le type MIME. iOS utilise ces informations pour le routage des fichiers : lorsqu'un utilisateur ouvre un fichier .sdoc, le système sait que son propriétaire est votre application.

UTExportedTypeDeclarations — pour les types définis par votre application (exportation). UTImportedTypeDeclarations — pour les types créés par d'autres applications avec lesquels votre application peut travailler (importation). Apple recommande d'enregistrer tous les types personnalisés avec lesquels votre application travaille pour une intégration correcte avec le système.

Sécurité et Gestion des Types Inconnus

Types MIME inconnus représentent un risque de sécurité pour les applications iOS. Si un fichier a un type inconnu ou non vérifié, l'application doit prendre des précautions : ne pas ouvrir le fichier automatiquement, afficher un avertissement à l'utilisateur ou analyser le contenu avant le traitement.

Menaces principales : un fichier avec un type MIME falsifié peut contenir du code malveillant ou un exploit ciblant une vulnérabilité de l'analyseur. iOS protège le système via Sandbox, mais l'application peut être vulnérable si elle fait confiance au type MIME sans vérifier le contenu. Vérifiez toujours les fichiers par magic bytes s'ils proviennent d'une source non fiable.

Selon le Guide de Sécurité Mobile OWASP, 2024, les pratiques suivantes s'appliquent pour la gestion des fichiers de types inconnus : rejeter les fichiers avec le type MIME application/octet-stream provenant de sources non fiables ; utiliser UTType pour vérifier la conformité aux catégories attendues ; ne pas ouvrir les fichiers dans des applications externes sans confirmation de l'utilisateur ; journaliser tous les cas de non-concordance entre MIME et le contenu réel pour l'audit de sécurité.

Enregistrement des types MIME personnalisés dans Info.plist n'est pas seulement une question de fonctionnalité mais aussi de sécurité. Si une application enregistre correctement uniquement ses propres types, le système ne lui transmettra pas par erreur d'autres fichiers. Utilisez des préfixes de fournisseur spécifiques (application/vnd.company.app-format) plutôt que des préfixes génériques (application/x-format) pour éviter les conflits avec d'autres applications.