Realizando Forense em Bancos de Dados SQLite

Visão Geral

SQLite é o motor de banco de dados mais amplamente implantado no mundo, usado por praticamente todos os aplicativos móveis, navegadores web e muitos aplicativos desktop para armazenar dados do usuário. Em forense digital, bancos de dados SQLite são fontes críticas de evidências contendo histórico de navegação, registros de mensagens, registros de chamadas, locais GPS, preferências de aplicativos e conteúdo em cache. A análise forense vai além de simples consultas SQL para examinar as estruturas internas de páginas B-tree, páginas de lista livre (freelist) contendo registros excluídos, arquivos Write-Ahead Log (WAL) preservando o histórico de transações e espaço não alocado dentro das páginas do banco de dados onde dados recuperáveis podem persistir após a exclusão.

Quando Usar

• Ao realizar avaliações de segurança que envolvam forense em bancos de dados SQLite
• Ao seguir procedimentos de resposta a incidentes para eventos de segurança relacionados
• Ao realizar testes de segurança ou atividades de auditoria agendadas
• Ao validar controles de segurança através de testes práticos

Pré-requisitos

• DB Browser for SQLite (sqlitebrowser)
• Ferramentas de linha de comando SQLite (sqlite3)
• Python 3.8+ com o módulo sqlite3
• Belkasoft Evidence Center ou Axiom (comercial)
• Editor hexadecimal (HxD, 010 Editor) para inspeção manual de páginas
• Compreensão de estruturas de dados B-tree

Estrutura Interna do SQLite

Cabeçalho do Banco de Dados (Primeiros 100 Bytes)

Tipos de Página

Recuperação de Registros Excluídos

Método 1: Análise de Página da Lista Livre

Quando registros são excluídos, o SQLite pode colocar suas páginas na lista livre (freelist) em vez de sobrescrevê-las imediatamente.

import struct
import sqlite3
import os


def analyze_freelist(db_path: str) -> dict:
    """Analisa a lista livre do SQLite para identificar páginas contendo dados excluídos."""
    with open(db_path, "rb") as f:
        # Lê o cabeçalho
        header = f.read(100)
        page_size = struct.unpack(">H", header[16:18])[0]
        if page_size == 1:
            page_size = 65536
        first_freelist_page = struct.unpack(">I", header[32:36])[0]
        total_freelist_pages = struct.unpack(">I", header[36:40])[0]

        freelist_info = {
            "page_size": page_size,
            "first_freelist_page": first_freelist_page,
            "total_freelist_pages": total_freelist_pages,
            "trunk_pages": [],
            "leaf_pages": []
        }

        if first_freelist_page == 0:
            return freelist_info

        # Percorre a cadeia de troncos da lista livre
        trunk_page = first_freelist_page
        while trunk_page != 0:
            offset = (trunk_page - 1) * page_size
            f.seek(offset)
            page_data = f.read(page_size)

            next_trunk = struct.unpack(">I", page_data[0:4])[0]
            leaf_count = struct.unpack(">I", page_data[4:8])[0]

            leaves = []
            for i in range(leaf_count):
                leaf_page = struct.unpack(">I", page_data[8 + i * 4:12 + i * 4])[0]
                leaves.append(leaf_page)

            freelist_info["trunk_pages"].append({
                "page_number": trunk_page,
                "next_trunk": next_trunk,
                "leaf_count": leaf_count,
                "leaf_pages": leaves
            })
            freelist_info["leaf_pages"].extend(leaves)
            trunk_page = next_trunk

    return freelist_info


def extract_freelist_content(db_path: str, output_dir: str):
    """Extrai o conteúdo bruto das páginas da lista livre para análise."""
    info = analyze_freelist(db_path)
    os.makedirs(output_dir, exist_ok=True)

    with open(db_path, "rb") as f:
        page_size = info["page_size"]

…