Tipo MIME — qué es, tipos de archivos y detección en iOS

¿Qué es el Tipo MIME?

MIME Type (Multipurpose Internet Mail Extensions) es un identificador estandarizado de formato de datos que consta de dos partes: un tipo principal (type) y un subtipo (subtype), separados por una barra inclinada. Categorías principales: text (texto), image (imágenes), audio, video, application (datos binarios), multipart (mensajes compuestos).

El estándar MIME fue desarrollado originalmente para archivos adjuntos de correo electrónico (RFC 2046, 1996), pero hoy se utiliza en todas partes: los servidores HTTP especifican el Content-Type de las respuestas, los navegadores determinan cómo manejar los archivos y las aplicaciones móviles identifican qué datos se pueden abrir. IANA (Internet Assigned Numbers Authority) mantiene un registro de los tipos MIME registrados.

Según el Registro de Tipos de Medios IANA (2024), hay más de 1800 tipos MIME oficiales registrados, y el número real incluyendo tipos personalizados y de proveedores supera los 5000. iOS admite la mayoría de los tipos estándar y proporciona API para trabajar con ellos mediante Uniform Type Identifiers.

MIME y UTI en iOS: Diferencias y Conversión

UTI (Uniform Type Identifier) es el sistema propio de Apple para la identificación de tipos de contenido utilizado en iOS y macOS. A diferencia de MIME, UTI admite una jerarquía de herencia (por ejemplo, public.image es el padre de public.png y public.jpeg) e incluye no solo formatos de archivo sino también tipos de datos abstractos.

Conversión entre MIME y UTI en iOS se realiza mediante la clase UTType (iOS 14+). El sistema mantiene una base de datos interna de correspondencias que cubre la mayoría de los formatos estándar. Para tipos personalizados, el desarrollador registra la correspondencia en Info.plist.

import UniformTypeIdentifiers

let mimeType = "image/jpeg"
if let uti = UTType(mimeType: mimeType) {
    print("UTI: \(uti.identifier)")
    print("Conforma a imagen: \(uti.conforms(to: .image))")
    print("Extensión: \(uti.preferredFilenameExtension ?? "")")
}

// Conversión inversa: UTI a MIME
if let uti = UTType(filenameExtension: "pdf"),
   let mime = uti.preferredMIMEType {
    print("MIME para PDF: \(mime)")
}

Jerarquía UTI permite verificar si un tipo se ajusta a una categoría determinada. Por ejemplo, todos los tipos de imagen (JPEG, PNG, GIF) conform(to: .image). Esto es conveniente para el filtrado por grupos y para determinar si un tipo puede ser manejado por componentes del sistema.

Diferencia importante: MIME es una clasificación plana (sin herencia), mientras que UTI admite herencia múltiple. Por ejemplo, public.html conforma tanto a public.source-code como a public.text. Esto proporciona un enrutamiento más flexible al procesar archivos en iOS.

Cómo Determinar el Tipo MIME de un Archivo en iOS

Tres métodos para determinar el Tipo MIME están disponibles en iOS: por extensión de archivo (rápido pero poco fiable), por contenido mediante magic bytes (fiable pero requiere leer el archivo) y por cabecera HTTP Content-Type (solo para solicitudes de red).

import UniformTypeIdentifiers

enum MIMEDetector {
    // Detectar por extensión
    static func fromExtension(_ ext: String) -> String? {
        UTType(filenameExtension: ext)?.preferredMIMEType
    }

    // Detectar por contenido (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
    }
}

Detección por extensión mediante UTType es el método más rápido, pero no es fiable si la extensión falta o es falsificada. Un atacante podría renombrar .exe a .jpg — el sistema lo identificaría como image/jpeg aunque el archivo sea ejecutable. Para escenarios críticos (seguridad, datos médicos), use siempre verificación basada en contenido.

Magic bytes son los primeros bytes de un archivo, únicos para cada formato. La mayoría de los formatos tienen una firma de 2 a 12 bytes. iOS no proporciona un detector MIME integrado por contenido — el desarrollador implementa una tabla de firmas por sí mismo o utiliza bibliotecas como CocoaLumberjack o un detector personalizado basado en heurísticas.

Registro de Tipos MIME y UTI Personalizados

Tipos personalizados son necesarios cuando una aplicación trabaja con formatos de datos propietarios no registrados en IANA o Apple. El registro en Info.plist permite a iOS manejar correctamente dichos archivos: abrirlos desde Files.app, mostrar iconos y pasarlos a otras aplicaciones mediante 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>

Para registrar un tipo personalizado, debe especificar en Info.plist: el identificador UTI (en formato reverse-DNS), la conformidad con tipos padres, la extensión del archivo y el tipo MIME. iOS utiliza esta información para el enrutamiento de archivos: cuando un usuario abre un archivo .sdoc, el sistema sabe que su propietario es su aplicación.

UTExportedTypeDeclarations — para tipos definidos por su aplicación (exportación). UTImportedTypeDeclarations — para tipos creados por otras aplicaciones con los que su aplicación puede trabajar (importación). Apple recomienda registrar todos los tipos personalizados con los que trabaja su aplicación para una correcta integración con el sistema.

Seguridad y Manejo de Tipos Desconocidos

Tipos MIME desconocidos representan un riesgo de seguridad para las aplicaciones iOS. Si un archivo tiene un tipo desconocido o no verificado, la aplicación debe tomar precauciones: no abrir el archivo automáticamente, mostrar una advertencia al usuario o analizar el contenido antes de procesarlo.

Principales amenazas: un archivo con un tipo MIME falsificado puede contener código malicioso o un exploit dirigido a una vulnerabilidad del analizador. iOS protege el sistema mediante Sandbox, pero la aplicación puede ser vulnerable si confía en el tipo MIME sin verificar el contenido. Siempre verifique los archivos por magic bytes si provienen de una fuente no confiable.

Según la Guía de Seguridad Móvil OWASP, 2024, se aplican las siguientes prácticas para el manejo de archivos de tipos desconocidos: rechazar archivos con tipo MIME application/octet-stream de fuentes no confiables; usar UTType para verificar la conformidad con categorías esperadas; no abrir archivos en aplicaciones externas sin confirmación del usuario; registrar todos los casos de discrepancia entre MIME y el contenido real para auditoría de seguridad.

Registro de tipos MIME personalizados en Info.plist no es solo funcionalidad, sino también seguridad. Si una aplicación registra correctamente solo sus propios tipos, el sistema no le pasará erróneamente otros archivos. Use prefijos de proveedor específicos (application/vnd.company.app-format) en lugar de genéricos (application/x-format) para evitar conflictos con otras aplicaciones.