Tipo MIME — o que é, tipos de arquivos e detecção em iOS

O que é Tipo MIME?

MIME Type (Multipurpose Internet Mail Extensions) é um identificador padronizado de formato de dados que consiste em duas partes: um tipo principal (type) e um subtipo (subtype), separados por uma barra. Categorias principais: text (texto), image (imagens), audio, video, application (dados binários), multipart (mensagens compostas).

O padrão MIME foi originalmente desenvolvido para anexos de e-mail (RFC 2046, 1996), mas hoje é usado em toda parte: servidores HTTP especificam o Content-Type das respostas, navegadores determinam como lidar com arquivos e aplicativos móveis identificam quais dados podem ser abertos. A IANA (Internet Assigned Numbers Authority) mantém um registro de tipos MIME registrados.

De acordo com o Registro de Tipos de Mídia IANA (2024), mais de 1800 tipos MIME oficiais estão registrados, e o número real incluindo tipos personalizados e de fornecedores excede 5000. O iOS suporta a maioria dos tipos padrão e fornece APIs para trabalhar com eles através de Uniform Type Identifiers.

MIME e UTI em iOS: Diferenças e Conversão

UTI (Uniform Type Identifier) é o próprio sistema de identificação de tipos de conteúdo da Apple usado no iOS e macOS. Ao contrário do MIME, o UTI suporta uma hierarquia de herança (por exemplo, public.image é pai de public.png e public.jpeg) e inclui não apenas formatos de arquivo, mas também tipos de dados abstratos.

Conversão entre MIME e UTI em iOS é realizada através da classe UTType (iOS 14+). O sistema mantém um banco de dados interno de mapeamentos que cobre a maioria dos formatos padrão. Para tipos personalizados, o desenvolvedor registra o mapeamento no Info.plist.

import UniformTypeIdentifiers

let mimeType = "image/jpeg"
if let uti = UTType(mimeType: mimeType) {
    print("UTI: \(uti.identifier)")
    print("Conforma à imagem: \(uti.conforms(to: .image))")
    print("Extensão: \(uti.preferredFilenameExtension ?? "")")
}

// Conversão reversa: UTI para MIME
if let uti = UTType(filenameExtension: "pdf"),
   let mime = uti.preferredMIMEType {
    print("MIME para PDF: \(mime)")
}

Hierarquia UTI permite verificar se um tipo está em conformidade com uma determinada categoria. Por exemplo, todos os tipos de imagem (JPEG, PNG, GIF) conform(to: .image). Isso é conveniente para filtragem em grupo e para determinar se um tipo pode ser manipulado por componentes do sistema.

Diferença importante: MIME é uma classificação plana (sem herança), enquanto UTI suporta herança múltipla. Por exemplo, public.html está em conformidade com public.source-code e public.text. Isso fornece roteamento mais flexível ao processar arquivos no iOS.

Como Determinar o Tipo MIME de um Arquivo em iOS

Três métodos para determinar o Tipo MIME estão disponíveis no iOS: por extensão de arquivo (rápido mas não confiável), por conteúdo via magic bytes (confiável mas requer leitura do arquivo) e por cabeçalho HTTP Content-Type (apenas para solicitações de rede).

import UniformTypeIdentifiers

enum MIMEDetector {
    // Detectar por extensão
    static func fromExtension(_ ext: String) -> String? {
        UTType(filenameExtension: ext)?.preferredMIMEType
    }

    // Detectar por conteúdo (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
    }
}

Detecção por extensão através do UTType é o método mais rápido, mas não é confiável se a extensão estiver ausente ou falsificada. Um invasor pode renomear .exe para .jpg — o sistema o identificaria como image/jpeg mesmo que o arquivo seja executável. Para cenários críticos (segurança, dados médicos), sempre use verificação baseada em conteúdo.

Magic bytes são os primeiros bytes de um arquivo, únicos para cada formato. A maioria dos formatos tem uma assinatura de 2 a 12 bytes. O iOS não fornece um detector MIME integrado por conteúdo — o desenvolvedor implementa uma tabela de assinaturas por conta própria ou usa bibliotecas como CocoaLumberjack ou um detector personalizado baseado em heurísticas.

Registro de Tipos MIME e UTI Personalizados

Tipos personalizados são necessários quando um aplicativo trabalha com formatos de dados proprietários não registrados na IANA ou Apple. O registro no Info.plist permite que o iOS lide corretamente com esses arquivos: abri-los do Files.app, exibir ícones e passá-los para outros aplicativos 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>

Para registrar um tipo personalizado, você precisa especificar no Info.plist: o identificador UTI (no formato reverse-DNS), a conformidade com tipos pais, a extensão do arquivo e o tipo MIME. O iOS usa essas informações para roteamento de arquivos: quando um usuário abre um arquivo .sdoc, o sistema sabe que seu proprietário é seu aplicativo.

UTExportedTypeDeclarations — para tipos definidos pelo seu aplicativo (exportação). UTImportedTypeDeclarations — para tipos criados por outros aplicativos com os quais seu aplicativo pode trabalhar (importação). A Apple recomenda registrar todos os tipos personalizados com os quais seu aplicativo trabalha para uma correta integração com o sistema.

Segurança e Manipulação de Tipos Desconhecidos

Tipos MIME desconhecidos representam um risco de segurança para aplicativos iOS. Se um arquivo tem um tipo desconhecido ou não verificado, o aplicativo deve tomar precauções: não abrir o arquivo automaticamente, mostrar um aviso ao usuário ou analisar o conteúdo antes do processamento.

Principais ameaças: um arquivo com tipo MIME falsificado pode conter código malicioso ou um exploit direcionado a uma vulnerabilidade do analisador. O iOS protege o sistema através do Sandbox, mas o aplicativo pode ser vulnerável se confiar no tipo MIME sem verificar o conteúdo. Sempre verifique arquivos por magic bytes se eles vierem de uma fonte não confiável.

De acordo com o Guia de Segurança Móvel OWASP, 2024, as seguintes práticas se aplicam para manipular arquivos de tipos desconhecidos: rejeitar arquivos com tipo MIME application/octet-stream de fontes não confiáveis; usar UTType para verificar a conformidade com categorias esperadas; não abrir arquivos em aplicativos externos sem confirmação do usuário; registrar todos os casos de incompatibilidade entre MIME e conteúdo real para auditoria de segurança.

Registro de tipos MIME personalizados no Info.plist não é apenas funcionalidade, mas também segurança. Se um aplicativo registrar corretamente apenas seus próprios tipos, o sistema não passará erroneamente outros arquivos para ele. Use prefixos de fornecedor específicos (application/vnd.company.app-format) em vez de genéricos (application/x-format) para evitar conflitos com outros aplicativos.