Apple x OpenAI: a engenharia forense por trás das “evidências chocantes”
Quando li a matéria no Olhardigital.com.br sobre a Apple ter apresentado à Justiça americana um MacBook com supostas evidências de roubo de propriedade intelectual, a primeira coisa que me veio à cabeça não foi o lado jurídico — foi o lado técnico. Forense digital em macOS é uma das áreas mais subestimadas do mercado, e o que a Apple descreveu nesse processo expõe como uma cadeia de custódia bem feita desmonta qualquer tentativa de apagar rastros. Vou destrinchar isso aqui, com profundidade, e mostrar o que devs e engenheiros de IA precisam entender sobre o assunto.
O que aconteceu, em resumo técnico
O ex-engenheiro sênior de sistemas elétricos da Apple, Chang Liu, deixou a empresa em janeiro para integrar o time da OpenAI. Segundo a Apple, antes de sair ele explorou uma falha de segurança interna para baixar arquivos confidenciais — incluindo esquemas elétricos — e continuou usando esses materiais na nova empresa. O processo, aberto em julho, ganhou força agora porque os advogados de Liu devolveram o MacBook dele, e a perícia forense encontrou quatro pontos que a Apple chamou de “evidências chocantes”.
O detalhe que mais me chamou a atenção foi o quarto ponto: Liu teria instruído uma colega na OpenAI a destruir provas depois de saber da investigação interna. Esse é um erro clássico de amador que vou comentar mais à frente.
Como se faz, de fato, uma análise forense em um MacBook
A Apple não publicou a metodologia, mas quem trabalha com forense digital em macOS sabe exatamente por onde começar. Vou te mostrar o playbook que eu mesmo aplico em auditorias de segurança.
1. Imagem bit-a-bit e cadeia de custódia
O primeiro passo é criar uma imagem forense do disco com dd ou ferramentas como FTK Imager e BlackLight. Em APFS, o sistema de arquivos do macOS moderno, existem snapshots que registram o estado do volume em pontos no tempo. Mesmo que o usuário apague arquivos, esses snapshots podem preservar versões anteriores — é por isso que formatar o Mac antes de devolver nunca é uma boa ideia.
2. Logs do Unified Log
Desde o macOS Sierra, a Apple centraliza tudo no Unified Log. Ali ficam registrados acessos a arquivos sensíveis, execuções de apps, conexões de rede e eventos do Gatekeeper. Para extrair esses logs em modo legível, o comando é:
log show --predicate 'subsystem == "com.apple.iCloud" OR eventMessage CONTAINS "FileVault"' --info --debug --last 90d > ~/Desktop/forense_icloud.logEsse é o tipo de comando que, em um processo como o da Apple, revela downloads de arquivos confidenciais para o iCloud, sincronizações indevidas e horários de acesso incompatíveis com a versão do réu.
3. SQLite databases locais
O macOS armazena metadados críticos em bancos SQLite que muita gente esquece: KnowledgeC.db (uso de apps), ~/Library/Logs/CoreDuet/ (eventos do sistema), LSApplicationWorkspace.sql (apps executados). Uma query típica para mapear atividade suspeita:
SELECT
ZSTARTDATE,
ZBUNDLEID,
ZVALUESTRING
FROM ZOBJECT
WHERE ZSTREAMNAME = '/app/usage'
AND ZBUNDLEID LIKE '%Confidential%'
ORDER BY ZSTARTDATE DESC;4. FSEvents e artefatos de tempo
O FSEvents mantém um registro de cada modificação no filesystem. Combinado com timestamps atime, mtime e btime, dá para reconstruir uma timeline completa do que aconteceu no Mac. Quem tenta apagar um arquivo e acha que “sumiu” está redondamente enganado.
Os quatro pontos da Apple — o que cada um significa tecnicamente
Ponto 1: download do esquema elétrico confidencial
A Apple já tinha logs de servidor mostrando o download. O MacBook provavelmente confirmou o acesso local ao arquivo, incluindo timestamps e hashes que casam com a versão corporativa. Isso é devastador em juízo porque estabelece correlação direta.
Ponto 2: uso do arquivo na OpenAI
Aqui mora o pulo do gato. Não basta provar que ele baixou — é preciso provar que usou. A Apple provavelmente encontrou:
- Referências ao arquivo em documentos salvos localmente durante o período em que Liu já estava na OpenAI
- Metadados de aplicações técnicas mostrando timestamps pós-contratação
- Acesso ao arquivo via caminhos sincronizados, indicando que ele levou o material para o novo emprego
Ponto 3: conhecimento do acesso não autorizado
A peça mais grave. Não foi um ato isolado — houve conivência. Em forense, isso se comprova com logs de comunicação (Slack, iMessage exportados), histórico de comandos no terminal e até mesmo dados de geolocalização mostrando reuniões entre as partes.
Ponto 4: instrução para destruir provas
Esse ponto transforma o caso civil em potencial caso criminal. Destruir provas é obstrução, e obstrução nos EUA costuma significar federal crime com agravantes. Tecnicamente, a Apple deve ter recuperado mensagens trocadas, mesmo as “apagadas”, porque o APFS e o iCloud frequentemente mantêm réplicas por até 30 dias.
Na Prática: como monitorar acessos sensíveis no seu próprio Mac
Se você trabalha com dados confidenciais — e como dev ou engenheiro de IA, isso inclui modelos, datasets e código proprietário — vale a pena configurar um monitoramento local. Aqui vai um script em Python que escrevi para auditar acessos a pastas críticas:
import os
import time
import hashlib
from datetime import datetime
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
class ConfidentialHandler(FileSystemEventHandler):
def __init__(self, watch_path, log_file):
self.watch_path = watch_path
self.log_file = log_file
def _hash_file(self, filepath):
sha256 = hashlib.sha256()
try:
with open(filepath, "rb") as f:
while chunk := f.read(8192):
sha256.update(chunk)
return sha256.hexdigest()
except Exception:
return "INACESSIVEL"
def _log_event(self, event_type, path):
timestamp = datetime.now().isoformat()
user = os.getenv("USER")
file_hash = self._hash_file(path) if not os.path.isdir(path) else "DIR"
log_line = (
f"{timestamp} | user={user} | "
f"evento={event_type} | path={path} | sha256={file_hash}"
)
with open(self.log_file, "a") as f:
f.write(log_line + "\n")
def on_modified(self, event):
self._log_event("MODIFICADO", event.src_path)
def on_created(self, event):
self._log_event("CRIADO", event.src_path)
def on_moved(self, event):
self._log_event(f"MOVIDO_DE_{event.src_path}", event.dest_path)
if __name__ == "__main__":
CAMINHO_SENSIVEL = os.path.expanduser("~/Documents/Projetos_Confidenciais")
LOG = os.path.expanduser("~/auditoria_local.log")
handler = ConfidentialHandler(CAMINHO_SENSIVEL, LOG)
observer = Observer()
observer.schedule(handler, CAMINHO_SENSIVEL, recursive=True)
observer.start()
print(f"[+] Monitorando {CAMINHO_SENSIVEL}... Ctrl+C para parar.")
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
observer.stop()
observer.join()Esse script usa a biblioteca watchdog e gera um log imutável com hash SHA-256 de cada arquivo tocado. Se você um dia precisar provar o que fez (ou deixou de fazer) com material da empresa, esse log é a sua defesa.
Erros comuns que devs cometem quando saem de empresas de tech
Eu já vi muita gente repetir os mesmos equívocos. Aprende com eles antes que vire processo:
- Copiar arquivos “só por garantia”. Qualquer cópia não autorizada de material confidencial, mesmo com a desculpa de “uso pessoal”, é base para processo. Apague tudo antes do último dia.
- Confiar em “limpar o histórico do navegador”. O Unified Log e o FSEvents não ligam para o seu Cmd+Shift+Delete. Histórico de acesso a documentos internos fica no sistema.
- Achatar o Mac antes de devolver. Pior impossível. Além de não apagar nada de verdade, configura destruição de provas de forma explícita.
- Conversar sobre o caso por canais pessoais. Mensagens em iMessage, WhatsApp web e até email pessoal podem ser obtidas via ordem judicial. Se precisar falar com advogado, use canal criptografado e nunca mencione ações concretas.
- Não revisar o NDA antes de sair. Muitos NDAs têm cláusulas de não-solicitação e auditoria pós-contrato que valem por até 5 anos. Leia o seu.
- Pedir para colega destruir algo. Como Liu aparentemente fez. Isso é o pior erro possível. Transforma um caso civil em criminal e ainda arrasta outra pessoa junto.
O que esse caso ensina sobre segurança corporativa em 2026
O movimento da Apple revela uma tendência clara: as big techs estão apertando o cerco contra vazamento de IP para concorrentes de IA. Não é coincidência que esse processo veio à tona justamente agora — a corrida por modelos generativos tornou cada linha de código sobre arquitetura, fine-tuning e infraestrutura muito mais valiosa. A Apple está protegendo o trabalho que alimenta a futura Siri baseada em LLM, e a OpenAI virou o alvo preferido porque contrata gente que conhece o segredo dos outros.
Para nós, devs e engenheiros, a lição prática é direta: trate qualquer arquivo da empresa como se fosse auditável. Porque vai ser.
FAQ — perguntas que devs realmente fazem
1. A Apple tem mesmo como acessar dados antigos do meu Mac mesmo após eu apagar?
Sim. APFS mantém snapshots, o Unified Log armazena eventos por meses, e o iCloud guarda metadados por até 30 dias após exclusão. Formatar o disco não impede uma perícia bem feita.
2. Se eu usar meu Mac pessoal para trabalho, a empresa tem direito de fazer perícia?
Depende do contrato. Se você misturou arquivos pessoais e profissionais, abre uma zona cinzenta. Por isso, separe claramente o que é seu e o que é da empresa — de preferência em máquinas e contas diferentes.
3. Existe ferramenta open source confiável para auditoria forense em macOS?
Sim. MacQuisition, The Sleuth Kit e Autopsy são os mais usados. Para logs, o log show nativo do macOS já resolve 80% dos casos.
4. Trocar de empresa do mesmo ramo pode configurar violação de NDA?
Sozinho, não. Trabalhar em empresa concorrente é legal. O que configura violação é levar consigo material confidencial, usar conhecimento específico não público em projetos da nova empresa, ou recrutar colegas em massa violando cláusulas de não-solicitação.
5. Como me proteger legalmente ao trocar de emprego?
Documente sua saída, apague arquivos da empresa, devolva hardware, faça backup apenas de materiais explicitamente permitidos e, se houver dúvida, consulte um advogado trabalhista especializado em tech antes de assinar qualquer coisa.
Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.