Como Analisar e Limpar Metadados de Arquivos (PDF, Imagens e Documentos)

# Atualize repositórios e instale dependências essenciais
sudo apt update && sudo apt upgrade -y
# Dependências básicas
sudo apt install -y perl python3 python3-pip git curl wget build-essential
# Bibliotecas de desenvolvimento necessárias
sudo apt install -y libimage-exiftool-perl python3-dev pkg-config
# Para compilação de ferramentas (opcional)
sudo apt install -y cmake gcc g++ make

# Fedora/CentOS 8+
sudo dnf install -y perl python3 python3-pip git curl wget
# RHEL/CentOS 7
sudo yum install -y epel-release
sudo yum install -y perl python3 python3-pip git curl wget

# Verificar versões das linguagens
perl -v
python3 --version
pip3 --version
# Verificar se PATH está configurado
echo $PATH
# Windows (PowerShell)
echo $env:PATH

# Download e extração
wget [https://exiftool.org/Image-ExifTool-13.37.tar.gz](https://exiftool.org/Image-ExifTool-13.37.tar.gz)
tar -xzf Image-ExifTool-13.37.tar.gz
cd Image-ExifTool-13.37
# Cópia dos arquivos
copy [exiftool.pl](http://exiftool.pl) C:\Windows\System32\[exiftool.pl](http://exiftool.pl)
xcopy /E lib C:\Windows\System32\lib\
# Teste
perl C:\Windows\System32\[exiftool.pl](http://exiftool.pl) -ver

# 1. Instalar ou atualizar Homebrew
/bin/bash -c "$(curl -fsSL [https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh](https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh))"
# 2. Atualizar Homebrew
brew update
# 3. Instalar ExifTool
brew install exiftool
# 4. Verificar instalação
exiftool -ver
which exiftool

# 1. Download do pacote macOS
curl -O [https://exiftool.org/ExifTool-13.37.pkg](https://exiftool.org/ExifTool-13.37.pkg)
# 2. Instalação via GUI
open ExifTool-13.37.pkg
# Siga as instruções na tela
# 3. Verificação (pode ser necessário adicionar ao PATH)
echo 'export PATH="/usr/local/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc
exiftool -ver

# Instalação direta
sudo apt update
sudo apt install -y exiftool
# Verificação
exiftool -ver
which exiftool

# 1. Download e extração
wget [https://exiftool.org/Image-ExifTool-13.37.tar.gz](https://exiftool.org/Image-ExifTool-13.37.tar.gz)
tar -xzf Image-ExifTool-13.37.tar.gz
cd Image-ExifTool-13.37
# 2. Instalação
perl [Makefile.PL](http://Makefile.PL)
make test
sudo make install
# 3. Configuração do linker dinâmico
sudo ldconfig
# 4. Verificação
exiftool -ver

# Clone e instalação
git clone [https://github.com/exiftool/exiftool.git](https://github.com/exiftool/exiftool.git)
cd exiftool
chmod +x exiftool
sudo cp exiftool /usr/local/bin/
sudo cp -R lib /usr/local/bin/
# Verificação
exiftool -ver

# Criar arquivo de teste
echo "Teste ExifTool" > teste.txt
# Testar comandos básicos
exiftool teste.txt
exiftool -all= teste.txt  # Remove metadados
exiftool teste.txt        # Verificar remoção
# Testar com imagem (se disponível)
exiftool imagem.jpg
exiftool -GPS* imagem.jpg # Ver apenas dados GPS

# 1. Baixar qpdf para Windows
# Acesse: [https://github.com/qpdf/qpdf/releases#](https://github.com/qpdf/qpdf/releases#) Baixe: [qpdf-x.x.x-bin-msvcxx.zip](http://qpdf-x.x.x-bin-msvcxx.zip)
# 2. Extrair para diretório permanente
mkdir C:\Tools\qpdf
# Extrair arquivo ZIP para C:\Tools\qpdf
# 3. Adicionar ao PATH
# Adicione C:\Tools\qpdf\bin às variáveis de ambiente (mesmo processo do ExifTool)
# 4. Teste de segurança (Windows pode bloquear executável não reconhecido)
# Navegue até C:\Tools\qpdf\bin
# Clique duas vezes em qpdf.exe
# Aceite o aviso de segurança se aparecer
# 5. Verificação
qpdf --version

# Instalar Chocolatey primeiro (se não tiver)
Set-ExecutionPolicy Bypass -Scope Process -Force
[[System.Net](http://System.Net).ServicePointManager]::SecurityProtocol = [[System.Net](http://System.Net).ServicePointManager]::SecurityProtocol -bor 3072
iex ((New-Object [System.Net](http://System.Net).WebClient).DownloadString('[https://chocolatey.org/install.ps1](https://chocolatey.org/install.ps1)'))
# Instalar qpdf
choco install qpdf
# Verificação
qpdf --version

# Método 1: Homebrew (recomendado)
brew install qpdf
# Método 2: MacPorts (alternativa)
sudo port install qpdf
# Verificação
qpdf --version
which qpdf

# Método 1: Repositório (mais simples)
sudo apt update
sudo apt install -y qpdf
# Método 2: Compilação desde fonte (versão mais recente)
# Dependências necessárias
sudo apt install -y build-essential cmake libjpeg-dev zlib1g-dev
# Download e compilação
wget [https://github.com/qpdf/qpdf/releases/download/v12.2.0/qpdf-12.2.0.tar.gz](https://github.com/qpdf/qpdf/releases/download/v12.2.0/qpdf-12.2.0.tar.gz)
tar -xzf qpdf-12.2.0.tar.gz
cd qpdf-12.2.0
# Compilação
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release \
      -DCMAKE_INSTALL_PREFIX=/usr/local \
      ..
make -j$(nproc)
sudo make install
# Configurar bibliotecas dinâmicas
sudo ldconfig
# Verificação
qpdf --version

# Fedora
sudo dnf install -y qpdf
# CentOS/RHEL (via EPEL)
sudo yum install -y epel-release
sudo yum install -y qpdf
# Verificação
qpdf --version

# Criar PDF de teste simples (opcional)
echo "Teste qpdf" | ps2pdf - teste.pdf
# Testar comandos básicos
qpdf --show-data teste.pdf    # Mostrar estrutura
qpdf --json teste.pdf         # Informações em JSON
qpdf --linearize teste.pdf teste_linearizado.pdf  # Linearizar

# Método 1: Repositório oficial
sudo apt update
sudo apt install -y mat2
# Método 2: Via pip (versão mais recente)
sudo apt install -y python3-pip python3-dev
pip3 install mat2
# Dependências opcionais para formatos específicos
sudo apt install -y ffmpeg       # Para vídeos e áudios
sudo apt install -y bubblewrap   # Para sandboxing de segurança
sudo apt install -y gir1.2-poppler-0.18  # Para PDFs
# Verificação
mat2 --version
mat2 --check-dependencies

# Fedora
sudo dnf install -y mat2
# CentOS (via EPEL)
sudo yum install -y epel-release
sudo yum install -y python3-pip python3-devel
pip3 install mat2
# Verificação
mat2 --version

# Via Homebrew (não oficial, mas funciona)
brew install python3
pip3 install mat2
# Dependências opcionais
brew install ffmpeg
# Verificação
mat2 --version

# Instalar WSL2
wsl --install -d Ubuntu
# Dentro do WSL
sudo apt update
sudo apt install -y mat2

# Pull da imagem oficial
docker pull [0xacab.org:4567/jvoisin/mat2](http://0xacab.org:4567/jvoisin/mat2)
# Uso via Docker
docker run --rm -v $(pwd):/data [0xacab.org:4567/jvoisin/mat2](http://0xacab.org:4567/jvoisin/mat2) /data/arquivo.pdf

# Verificar quais formatos são suportados
mat2 --list
# Verificar dependências instaladas
mat2 --check-dependencies
# Testar com arquivo (modo visualização - não limpa)
mat2 --show arquivo.pdf
# Testar limpeza (gera arquivo.cleaned.ext)
mat2 arquivo.pdf
# Arquivo limpo será criado como arquivo.cleaned.pdf

# Método 1: Installer oficial
# 1. Baixe de [https://imagemagick.org/script/download.php#windows#](https://imagemagick.org/script/download.php#windows#)
# 2. Execute o instalador
# 3. IMPORTANTE: Marque "Add application directory to your system path"
# 4. Marque "Install FFmpeg" se quiser suporte a vídeos
# Método 2: Chocolatey
choco install imagemagick
# Verificação
magick -version
convert -version  # Comando legado

# Via Homebrew
brew install imagemagick
# Verificação
magick -version

# Ubuntu/Debian
sudo apt install -y imagemagick
# Para desenvolvimento/compilação
sudo apt install -y libimage-magick++-dev
# Fedora
sudo dnf install -y ImageMagick ImageMagick-devel
# Verificação
magick -version
identify -list format  # Ver formatos suportados

#!/bin/bash
echo "=== VERIFICAÇÃO DE INSTALAÇÃO DAS FERRAMENTAS DE METADADOS ==="
echo
# Verificar ExifTool
echo "1. ExifTool:"
if command -v exiftool &> /dev/null; then
    echo "   ✅ Instalado - Versão: $(exiftool -ver 2>/dev/null)"
else
    echo "   ❌ NÃO INSTALADO"
fi
# Verificar qpdf

echo "2. qpdf:"
if command -v qpdf &> /dev/null; then
    echo "   ✅ Instalado - Versão: $(qpdf --version 2>/dev/null | head -1)"
else
    echo "   ❌ NÃO INSTALADO"
fi
# Verificar MAT2

echo "3. MAT2:"
if command -v mat2 &> /dev/null; then
    echo "   ✅ Instalado - Versão: $(mat2 --version 2>/dev/null)"
else
    echo "   ❌ NÃO INSTALADO"
fi
# Verificar ImageMagick

echo "4. ImageMagick:"
if command -v magick &> /dev/null; then
    echo "   ✅ Instalado - Versão: $(magick -version 2>/dev/null | head -1)"
elif command -v convert &> /dev/null; then
    echo "   ✅ Instalado (versão antiga) - $(convert -version 2>/dev/null | head -1)"
else
    echo "   ❌ NÃO INSTALADO"
fi

echo

echo "=== VERIFICAÇÃO DE DEPENDÊNCIAS ==="
# Verificar Perl

echo "5. Perl:"
if command -v perl &> /dev/null; then
    echo "   ✅ Instalado - Versão: $(perl -v 2>/dev/null | grep 'version' | head -1)"
else
    echo "   ❌ NÃO INSTALADO"
fi
# Verificar Python

echo "6. Python 3:"
if command -v python3 &> /dev/null; then
    echo "   ✅ Instalado - Versão: $(python3 --version 2>/dev/null)"
else
    echo "   ❌ NÃO INSTALADO"
fi

echo

echo "=== TESTE FUNCIONAL BÁSICO ==="
# Teste básico com arquivo temporário
echo "Teste ExifTool funcionando..." > /tmp/teste_metadata.txt
if exiftool /tmp/teste_metadata.txt &> /dev/null; then
    echo "✅ ExifTool funcionando corretamente"
else
    echo "❌ ExifTool com problemas"
fi
rm -f /tmp/teste_metadata.txt

Write-Host "=== VERIFICAÇÃO DE INSTALAÇÃO ===" -ForegroundColor Yellow
# ExifTool
Write-Host "1. ExifTool:" -ForegroundColor Green
try {
    $version = & exiftool -ver 2>$null
    Write-Host "   ✅ Instalado - Versão: $version" -ForegroundColor Green
} catch {
    Write-Host "   ❌ NÃO INSTALADO" -ForegroundColor Red
}
# qpdf
Write-Host "2. qpdf:" -ForegroundColor Green
try {
    $version = & qpdf --version 2>$null | Select-Object -First 1
    Write-Host "   ✅ Instalado - Versão: $version" -ForegroundColor Green
} catch {
    Write-Host "   ❌ NÃO INSTALADO" -ForegroundColor Red
}
# Continue para outras ferramentas...

1. Clique com botão direito no arquivo
2. Selecione "Get Info" (⌘+I)
3. Expanda seções como:
   - "General" (informações básicas)
   - "More Info" (metadados específicos do formato)

1. Abra a imagem no Preview
2. Tools → Show Inspector (⌘+I)
3. Clique na aba (i) para informações gerais
4. Clique na aba "EXIF" para dados detalhados da câmera
5. Use as setas para navegar entre diferentes tipos de metadados

# Ver todos os metadados de um arquivo
mdls arquivo.jpg
# Filtrar metadados específicos
mdls -name kMDItemPixelWidth -name kMDItemPixelHeight arquivo.jpg
# Buscar arquivos com metadados específicos
mdfind "kMDItemAudioBitRate == 320000"
# Ver metadados de GPS
mdls -name kMDItemLatitude -name kMDItemLongitude arquivo.jpg

# Buscar imagens por câmera
mdfind "kMDItemAcquisitionMake == 'Canon'"
# Buscar documentos por autor
mdfind "kMDItemAuthors == 'João Silva'"
# Buscar por palavras-chave
mdfind "kMDItemKeywords == 'confidencial'"

1. Abra o documento no LibreOffice Writer/Calc/Impress
2. Menu "Arquivo" → "Propriedades"
3. A janela "Propriedades do Documento" abrirá com várias abas:

Aba "Geral":
- Tipo de arquivo, localização, tamanho
- Datas de criação, modificação, último acesso
- Tempo total de edição

Aba "Descrição":
- Título, Assunto, Palavras-chave
- Comentários
- ESTES CAMPOS SÃO EDITÁVEIS

Aba "Propriedades Personalizadas":
- Campos definidos pelo usuário
- Podem conter dados sensíveis como códigos de projeto, números de contratos
- VISUALIZE CUIDADOSAMENTE antes de compartilhar

Aba "Segurança":
- Informações de proteção por senha
- Permissões de edição/impressão

Aba "Estatísticas":
- Número de páginas, parágrafos, palavras, caracteres
- Tabelas, imagens, objetos inseridos

1. Menu "Editar" → "Controlar Alterações" → "Gerenciar"
2. Visualiza todas as alterações rastreadas:
   - Autor de cada alteração
   - Data e hora precisas
   - Tipo de alteração (inserção, exclusão, formatação)
   - Comentários de revisão

ATENÇÃO: Estes dados podem revelar:
- Quantas pessoas editaram o documento
- Ordem temporal de edições
- Conteúdo removido mas ainda visível

1. Arquivo → Propriedades
2. Aba "Geral":
   - Desmarque "Aplicar dados do usuário"
   - Clique "Redefinir" para limpar estatísticas
3. Aba "Descrição":
   - Limpe manualmente todos os campos
4. Aba "Propriedades Personalizadas":
   - Delete todas as propriedades personalizadas
5. Aba "Segurança":
   - Desmarque "Registrar alterações"

1. Arquivo → Exportar como PDF
2. Na janela de exportação:
   - Desmarque "Exportar marcadores"
   - Desmarque "Exportar comentários"
   - Desmarque "Incluir metadados"
3. Para outros formatos:
   - Arquivo → Salvar Como
   - Escolha "Usar filtro Microsoft Office" se necessário
   - Verifique opções de metadados específicas do formato

# Visualizar todos os metadados de uma imagem
exiftool imagem.jpg
# Extrair apenas dados GPS e de câmera
exiftool -Model -DateTimeOriginal -GPSLatitude -GPSLongitude imagem.jpg
# Processar recursivamente todos os arquivos em um diretório
exiftool -r /caminho/para/diretorio
# Exportar metadados em formato JSON para análise
exiftool -json imagem.jpg > metadados.json
# Comparar metadados entre dois arquivos
exiftool -diff arquivo1.jpg arquivo2.jpg

# Remover todos os metadados preservando o original
exiftool -all= imagem.jpg
# Processar em lote todos os JPGs no diretório
exiftool -all= *.jpg
# Remover apenas dados GPS mantendo informações da câmera
exiftool -gps:all= imagem.jpg
# Verificar se a limpeza funcionou
exiftool imagem.jpg

# Manter apenas metadados essenciais (dimensões, formato)
exiftool -all= -tagsfromfile @ -ColorSpace -ImageWidth -ImageHeight imagem.jpg
# Remover metadados mas manter orientação da imagem
exiftool -all= -tagsfromfile @ -Orientation imagem.jpg
# Processamento em lote com backup
exiftool -all= -r /pasta/imagens/
# Arquivos originais ficam como arquivo.jpg_original
# Restaurar backups se necessário
exiftool -restore_original /pasta/imagens/

# Passo 1: Remover metadados com ExifTool
exiftool -all:all= documento.pdf
# Passo 2: Linearizar com qpdf (torna remoção permanente)
qpdf --linearize documento.pdf documento_limpo.pdf
# Comando combinado
exiftool -all:all= documento.pdf && qpdf --linearize documento.pdf documento_final.pdf

# Verificar com ExifTool
exiftool documento_final.pdf
# Verificar estrutura interna
qpdf --show-data documento_final.pdf
# Buscar strings suspeitas
strings documento_final.pdf | grep -i -E "(author|creator|producer|title)"

# Instalar MAT2 no Ubuntu
sudo apt install mat2
# Limpar PDF (cria novo arquivo automaticamente)
mat2 documento.pdf
# Verificar metadados antes e depois
mat2 --show documento.pdf
mat2 --show documento.cleaned.pdf

# Ver formatos suportados
mat2 --list
# Verificar dependências
mat2 --check-dependencies
# Modo lightweight (preserva mais compatibilidade)
mat2 --lightweight documento.pdf
# Limpeza in-place (substitui arquivo original)
mat2 --inplace documento.pdf

1. Editar → Controlar Alterações → Aceitar ou Rejeitar
   - Aceite ou rejeite TODAS as alterações
   - Isso remove o histórico de revisão

2. Arquivo → Versões
   - Delete todas as versões salvas automaticamente

3. Formato → Estilos e Formatação
   - Remova estilos personalizados que podem conter metadados

4. Ferramentas → Opções → LibreOffice → Dados do Usuário
   - Limpe suas informações pessoais para documentos futuros

@echo off
echo Iniciando limpeza de metadados em lote...
mkdir limpos 2>nul

for %%f in (*.jpg *.jpeg *.png *.pdf *.docx *.xlsx *.pptx) do (
    echo Processando %%f
    exiftool -all= -overwrite_original "%%f"
    if exist "%%f" (
        move "%%f" limpos\
        echo %%f processado com sucesso
    ) else (
        echo ERRO ao processar %%f
    )
)

echo.
echo Processamento concluído!
echo Arquivos limpos movidos para pasta 'limpos'
pause

@echo off
setlocal enabledelayedexpansion

set LOGFILE=limpeza_metadados_%date:~-4,4%%date:~-7,2%%date:~-10,2%.log
echo Iniciando limpeza em lote - %date% %time% > %LOGFILE%

mkdir limpos 2>nul
set /a CONTADOR=0
set /a SUCESSOS=0
set /a ERROS=0

for %%f in (*.jpg *.jpeg *.png *.pdf *.docx *.xlsx *.pptx) do (
    set /a CONTADOR+=1
    echo [!CONTADOR!] Processando %%f
    echo [%time%] Processando %%f >> %LOGFILE%

    exiftool -all= -overwrite_original "%%f" 2>>%LOGFILE%
    if !errorlevel! equ 0 (
        move "%%f" limpos\ >>%LOGFILE% 2>&1
        set /a SUCESSOS+=1
        echo   ✓ Sucesso
    ) else (
        set /a ERROS+=1
        echo   ✗ Erro - verifique %LOGFILE%
    )
)

echo.
echo === RELATÓRIO FINAL ===
echo Total processados: !CONTADOR!
echo Sucessos: !SUCESSOS!
echo Erros: !ERROS!
echo Log salvo em: %LOGFILE%
pause

#!/bin/bash
# Configurações
PASTA_DESTINO="arquivos_limpos"
LOGFILE="limpeza_$(date +%Y%m%d_%H%M%S).log"
echo "Iniciando limpeza de metadados em lote..."
echo "Log: $LOGFILE"
echo
# Criar pasta de destino
mkdir -p "$PASTA_DESTINO"
# Contadores
total=0
sucessos=0
erros=0
# Processar arquivos
find . -maxdepth 1 -type f \( -iname "*.jpg" -o -iname "*.jpeg" -o -iname "*.png" -o -iname "*.pdf" -o -iname "*.docx" -o -iname "*.xlsx" \) | while read arquivo; do
    ((total++))
    echo "[$total] Processando: $(basename "$arquivo")"
    # Log detalhado
    echo "$(date): Processando $arquivo" >> "$LOGFILE"
    # Remover metadados
    if exiftool -all= -overwrite_original "$arquivo" 2>> "$LOGFILE"; then
        mv "$arquivo" "$PASTA_DESTINO/" 2>> "$LOGFILE"
        if [ $? -eq 0 ]; then
            ((sucessos++))
            echo "  ✓ Sucesso"
        else
            ((erros++))
            echo "  ✗ Erro ao mover arquivo"
        fi
    else
        ((erros++))
        echo "  ✗ Erro na limpeza"
    fi
done

echo
echo "=== RELATÓRIO FINAL ==="
echo "Total processados: $total"
echo "Sucessos: $sucessos"
echo "Erros: $erros"
echo "Arquivos limpos em: $PASTA_DESTINO"
echo "Log detalhado: $LOGFILE"

#!/usr/bin/env python3
import os
import subprocess
import shutil
from pathlib import Path
from datetime import datetime

def limpar_metadados(arquivo: Path):
    """Remove metadados usando ExifTool"""
    try:
        [subprocess.run](http://subprocess.run)(
            ['exiftool', '-all=', '-overwrite_original', str(arquivo)],
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        return True, ""
    except subprocess.CalledProcessError as e:
        return False, e.stderr
    except FileNotFoundError:
        return False, "ExifTool não encontrado. Instale primeiro."

def main():
    pasta_origem = Path('.')
    pasta_destino = Path('arquivos_limpos')
    pasta_destino.mkdir(exist_ok=True)
    extensoes = {'.jpg', '.jpeg', '.png', '.pdf', '.docx', '.xlsx', '.pptx'}

    log_file = f"limpeza_{[datetime.now](http://datetime.now)().strftime('%Y%m%d_%H%M%S')}.log"
    print("Limpeza de Metadados - Python Script")
    print(f"Log: {log_file}")
    print("-" * 50)

    total = sucessos = erros = 0
    with open(log_file, 'w', encoding='utf-8') as log:
        log.write(f"Limpeza iniciada: {[datetime.now](http://datetime.now)()}\n")
        for arquivo in pasta_origem.iterdir():
            if [arquivo.is](http://arquivo.is)_file() and arquivo.suffix.lower() in extensoes:
                total += 1
                print(f"[{total}] Processando: {[arquivo.name](http://arquivo.name)}")
                sucesso, erro = limpar_metadados(arquivo)
                log.write(f"{[datetime.now](http://datetime.now)()}: {[arquivo.name](http://arquivo.name)} - ")
                if sucesso:
                    try:
                        shutil.move(str(arquivo), pasta_destino / [arquivo.name](http://arquivo.name))
                        sucessos += 1
                        print("  ✓ Sucesso")
                        log.write("SUCESSO\n")
                    except Exception as e:
                        erros += 1
                        print(f"  ✗ Erro ao mover: {e}")
                        log.write(f"ERRO ao mover: {e}\n")
                else:
                    erros += 1
                    print(f"  ✗ Erro na limpeza: {erro}")
                    log.write(f"ERRO na limpeza: {erro}\n")
        log.write(f"\nResumo: {total} total, {sucessos} sucessos, {erros} erros\n")

    print("\n" + "=" * 50)
    print("RELATÓRIO FINAL")
    print(f"Total processados: {total}")
    print(f"Sucessos: {sucessos}")
    print(f"Erros: {erros}")
    print(f"Arquivos limpos em: {pasta_destino}")
    print(f"Log detalhado: {log_file}")

if __name__ == "__main__":
    main()