análise-de-pst-outlook-para-perícia-de-e-mail

Analisando PST do Outlook para Perícia Forense de E-mail

Visão Geral

Arquivos PST (Personal Storage Table) e OST (Offline Storage Table) do Microsoft Outlook são fontes de evidência críticas em investigações de perícia digital. Os arquivos PST armazenam mensagens de e-mail, eventos de calendário, contatos, tarefas e anotações em um formato binário proprietário baseado no sistema de propriedades MAPI (Messaging Application Programming Interface). A análise forense desses arquivos permite a recuperação de e-mails excluídos (da pasta Itens Recuperáveis), a extração de cabeçalhos de e-mail para rastrear rotas de mensagens, a análise de anexos para busca de malware ou dados exfiltrados e a reconstrução de padrões de comunicação. Arquivos PST modernos usam o formato Unicode com páginas de 4KB e podem crescer até 50GB, enquanto o formato ANSI legado é limitado a 2GB.

Quando Usar

• Ao investigar incidentes de segurança que exijam a análise de PST do Outlook para perícia forense de e-mail.
• Ao construir regras de detecção ou consultas de caça a ameaças para este domínio.
• Quando analistas de SOC precisam de procedimentos estruturados para este tipo de análise.
• Ao validar a cobertura de monitoramento de segurança para técnicas de ataque relacionadas.

Pré-requisitos

• libpff/pffexport (analisador PST de código aberto)
• Python 3.8+ com bibliotecas pypff ou libratom
• MailXaminer, Forensic Email Collector ou SysTools PST Forensics (comerciais)
• Microsoft Outlook (opcional, para acesso nativo a PST)
• Espaço em disco suficiente para o conteúdo extraído

Localizações de Arquivos PST

Origem	Caminho
Padrão Outlook 2016+	%USERPROFILE%\Documents\Outlook Files*.pst
Outlook Legado	%LOCALAPPDATA%\Microsoft\Outlook*.pst
Cache OST	%LOCALAPPDATA%\Microsoft\Outlook*.ost
Arquivo	%USERPROFILE%\Documents\Outlook Files\archive.pst

Análise com Ferramentas de Código Aberto

libpff / pffexport

# Exportar todos os itens de um arquivo PST
pffexport -m all evidence.pst -t exported_pst

# Exportar apenas mensagens de e-mail
pffexport -m items evidence.pst -t exported_emails

# Exportar itens recuperados/excluídos
pffexport -m recovered evidence.pst -t recovered_items

# Obter informações do arquivo PST
pffinfo evidence.pst

Análise PST em Python

import pypff
import os
import json
import hashlib
import email
import sys
from datetime import datetime
from collections import defaultdict


class PSTForensicAnalyzer:
    """Análise forense de arquivos PST/OST do Outlook."""

    def __init__(self, pst_path: str, output_dir: str):
        self.pst_path = pst_path
        self.output_dir = output_dir
        os.makedirs(output_dir, exist_ok=True)
        self.pst = pypff.file()
        self.pst.open(pst_path)
        self.messages = []
        self.attachments = []
        self.stats = defaultdict(int)

    def process_folder(self, folder, folder_path: str = ""):
        """Processa recursivamente pastas PST e extrai mensagens."""
        folder_name = folder.name or "Root"
        current_path = f"{folder_path}/{folder_name}" if folder_path else folder_name

        for i in range(folder.number_of_sub_messages):
            try:
                message = folder.get_sub_message(i)
                msg_data = self.extract_message(message, current_path)
                if msg_data:
                    self.messages.append(msg_data)
                    self.stats["total_messages"] += 1
            except Exception as e:
                self.stats["parse_errors"] += 1

        for i in range(folder.number_of_sub_folders):
            try:
                subfolder = folder.get_sub_folder(i)
                self.process_folder(subfolder, current_path)
            except Exception:
                continue

    def extract_message(self, message, folder_path: str) -> dict:
        """Extrai metadados forenses de uma única mensagem de e-mail."""
        msg_data = {
            "folder": folder_path,
            "subject": message.subject or "",
            "sender": message.sender_name or "",
            "sender_email": "",
            "creation_time": str(message.creation_time) if message.creation_time else None,
            "delivery_time": str(message.delivery_time) if message.delivery_time else None,
            "modification_time": str(message.modification_time) if message.modification_time else None,
            "has_attachments": message.number_of_attachments > 0,
            "attachment_count": message.number_of_attachments,
            "body_size": len(message.plain_text_body or b""),
            "html_size": len(message.html_body or b""),
        }

        # Extrair cabeçalhos de transporte para análise de roteamento
        headers = message.transport_headers
        if headers:
            msg_data["headers_present"] = True
            msg_data["headers_size"] = len(headers)
            # Analisar cabeçalhos principais
            parsed = email.message_from_string(headers)
            msg_data["from_header"] = parsed.get("From", "")
            msg_data["to_header"] = parsed.get("To", "")
            msg_data["date_header"] = parsed.get("Date", "")
            msg_data["message_id"] = parsed.get("Message-ID", "")
            msg_data["x_originating_ip"] = parsed.get("X-Originating-IP", "")
            msg_data["received_headers"] = parsed.get_all("Received", [])

        # Processar anexos
        for j in range(message.number_of_attachments):
            try:
                attachment = message.get_attachment(j)
                att_data = {
                    "message_subject": msg_data["subject"],
                    "name": attachment.name or f"attachment_{j}",
                    "size": attachment.size,
                    "content_type": "",
                }
                self.attachments.append(att_data)
                self.stats["total_attachments"] += 1
            except Exception:
                continue

        return msg_data

    def save_attachments(self, max_size_mb: int = 100):
        """Exporta anexos para disco para análise."""
        att_dir = os.path.join(self.output_dir, "attachments")
        os.makedirs(att_dir, exist_ok=True)

        root = self.pst.get_root_folder()
        self._save_attachments_recursive(root, att_dir, max_size_mb)

    def _save_attachments_recursive(self, folder, att_dir, max_size_mb):
        for i in range(folder.number_of_sub_messages):
            try:
                message = folder.get_sub_message(i)
                for j in range(message.number_of_attachments):
                    att = message.get_attachment(j)
                    if att.size and att.size < max_size_mb * 1024 * 1024:
                        name = att.name or f"unknown_{i}_{j}"
                        safe_name = "".join(c if c.isalnum() or c in ".-_" else "_" for c in name)
                        path = os.path.join(att_dir, safe_name)
                        try:
                            data = att.read_buffer(att.size)
                            with open(path, "wb") as f:
                                f.write(data)
                        except Exception:
                            continue
            except Exception:
                continue

        for i in range(folder.number_of_sub_folders):
            try:
                self._save_attachments_recursive(folder.get_sub_folder(i), att_dir, max_size_mb)
            except Exception:
                continue

    def generate_report(self) -> str:
        """Gera relatório abrangente de análise forense PST."""
        root = self.pst.get_root_folder()
        self.process_folder(root)

        report = {
            "analysis_timestamp": datetime.now().isoformat(),
            "pst_file": self.pst_path,
            "pst_size_bytes": os.path.getsize(self.pst_path),
            "statistics": dict(self.stats),
            "messages": self.messages[:500],
            "attachments": self.attachments[:200],
        }

        report_path = os.path.join(self.output_dir, "pst_forensic_report.json")
        with open(report_path, "w") as f:
            json.dump(report, f, indent=2, default=str)

        print(f"[*] Total mensagens: {self.stats['total_messages']}")
        print(f"[*] Total anexos: {self.stats['total_attachments']}")
        print(f"[*] Erros de análise: {self.stats['parse_errors']}")
        return report_path

    def close(self):
        self.pst.close()


def main():
    if len(sys.argv) < 3:
        print("Uso: python process.py <arquivo_pst> <diretorio_saida>")
        sys.exit(1)
    analyzer = PSTForensicAnalyzer(sys.argv[1], sys.argv[2])
    analyzer.generate_report()
    analyzer.close()


if __name__ == "__main__":
    main()

Análise de Cabeçalhos de E-mail

Cabeçalhos principais para investigação forense:

Cabeçalho	Valor Forense
Received	Cadeia de roteamento da mensagem (leia de baixo para cima)
X-Originating-IP	Endereço IP real do remetente
Message-ID	Identificador único para correlação
Date	Timestamp de envio
Return-Path	Endereço de devolução (pode diferir do From)
DKIM-Signature	Assinatura de autenticação de domínio
Authentication-Results	Resultados de verificação SPF, DKIM, DMARC
X-Mailer	Cliente de e-mail utilizado

Referências

• MailXaminer PST Forensics: https://www.mailxaminer.com/blog/outlook-pst-file-forensics/
• Documentação libpff: https://github.com/libyal/libpff
• Especificação do Formato de Arquivo PST: https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-pst/
• SANS Email Forensics: https://www.sans.org/blog/email-forensics/

Exemplo de Saída

$ pffexport /evidencias/jsmith_archive.pst -t /analise/saida_pst

pffexport 20231205 - libpff Ferramenta de Exportação PST/OST
=================================================
Entrada: /evidencias/jsmith_archive.pst (2.3 GB)

Exportando conteúdo PST...
  Pastas:        45
  Mensagens:     12.456
  Anexos:        3.234
  Contatos:      567
  Calendário:    234
  Tarefas:       89

Exportação concluída em 3m 42s.

$ python3 pst_analyzer.py /analise/saida_pst /analise/relatorio_email

Relatório de Análise Forense PST
==============================
Origem: jsmith_archive.pst ([email protected])
Intervalo de Datas: 2023-06-01 a 2024-01-18

--- Estatísticas da Caixa Postal ---
  Total de E-mails:      12.456
  Enviados:              4.567
  Recebidos:             7.889
  Com Anexos:            3.234
  Excluídos (recuperados): 234

--- E-mails de Phishing / Suspeitos ---
E-mail #8923
  Data:        2024-01-15 14:30:22 UTC
  De:          "Suporte TI" <[email protected]>
  Para:        [email protected]
  Assunto:     Urgente: Redefinição de Senha Necessária
  Cabeçalhos:
    Return-Path:    [email protected]
    X-Originating-IP: 203.0.113.55
    Received:       de relay-mensagem.ajuda-c0rporativa.com (203.0.113.55)
    SPF:            FALHA (domínio ajuda-c0rporativa.com)
    DKIM:           NENHUM
    DMARC:          FALHA
  Anexos:
    - Formulario_Redefinicao_Senha.xlsm (245 KB) SHA-256: 7a3b8c9d...e1f2a3b4
  Prévia do Corpo: "Prezado Colaborador, Sua senha expirará em 24 horas.
                  Por favor, abra o formulário anexo para redefinir suas credenciais..."

--- Indicadores de Exfiltração de Dados ---
E-mail #9102
  Data:        2024-01-16 03:15:45 UTC
  De:          [email protected]
  Para:          [email protected]
  Assunto:     (sem assunto)
  Anexos:
    - archive_parte1.7z (24.5 MB) - criptografado
    - archive_parte2.7z (24.5 MB) - criptografado

E-mail #9103
  Data:        2024-01-16 03:18:22 UTC
  De:          [email protected]
  Para:          [email protected]
  Assunto:     Re:
  Anexos:
    - archive_parte3.7z (18.2 MB) - criptografado

--- Ocorrências de Palavras-chave ---
  "confidencial":     45 e-mails
  "senha":            23 e-mails
  "transferência":     12 e-mails
  "demissão":          3 e-mails
  "apagar evidências": 1 e-mail (E-mail #9200, 2024-01-17 22:30:00 UTC)

Resumo:
  E-mails de phishing detectados:    1 (vetor de comprometimento inicial)
  E-mails enviados suspeitos:       5 (para contas pessoais com anexos)
  Anexos criptografados:             3 (67.2 MB total - possível exfiltração)
  Relatório: /analise/relatorio_email/pst_forensic_report.json