Aquisição Forense de Armazenamento em Nuvem

Visão Geral

A aquisição forense de armazenamento em nuvem envolve a coleta de evidências digitais de serviços como Google Drive, OneDrive, Dropbox e Box, por meio de aquisição remota baseada em API e análise de artefatos de endpoint local. Investigações modernas devem abordar o desafio de que arquivos sincronizados na nuvem podem existir em múltiplos estados: sincronizados localmente, apenas na nuvem (sob demanda), em cache e excluídos. Dispositivos de endpoint que sincronizaram com o armazenamento em nuvem contêm uma riqueza de metadados sobre arquivos sincronizados localmente, arquivos presentes apenas na nuvem e até mesmo itens excluídos recuperáveis de pastas de cache. A aquisição baseada em API, usando APIs específicas do serviço, fornece acesso direto a dados remotos com credenciais válidas e autorização legal adequada.

Quando Usar

• Ao realizar avaliações de segurança que envolvem a aquisição forense de armazenamento em nuvem
• 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 por meio de testes práticos

Pré-requisitos

• Autorização legal (mandado, consentimento ou política corporativa) para acesso a dados na nuvem
• Credenciais de usuário válidas ou tokens de acesso administrativo
• Magnet AXIOM Cloud, Cellebrite Cloud Analyzer ou ferramenta equivalente
• KAPE com arquivos de destino de armazenamento em nuvem
• Python 3.8+ com google-api-python-client, msal, dropbox SDK
• Conectividade de rede para aquisição baseada em API

Métodos de Aquisição

Método 1: Aquisição Remota Baseada em API

Aquisição da API do Google Drive

from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build
from googleapiclient.http import MediaIoBaseDownload
import io
import os
import json
from datetime import datetime


class GoogleDriveForensicAcquisition:
    """Adquire forensicamente arquivos e metadados do Google Drive via API."""

    def __init__(self, credentials_path: str, output_dir: str):
        self.creds = Credentials.from_authorized_user_file(credentials_path)
        self.service = build("drive", "v3", credentials=self.creds)
        self.output_dir = output_dir
        os.makedirs(output_dir, exist_ok=True)
        self.acquisition_log = []

    def list_all_files(self, include_trashed: bool = True) -> list:
        """Lista todos os arquivos, incluindo itens na lixeira."""
        files = []
        page_token = None
        query = "" if include_trashed else "trashed = false"

        while True:
            results = self.service.files().list(
                q=query,
                pageSize=1000,
                fields="nextPageToken, files(id, name, mimeType, size, "
                       "createdTime, modifiedTime, trashed, trashedTime, "
                       "owners, sharingUser, permissions, md5Checksum, "
                       "parents, webViewLink, driveId)",
                pageToken=page_token
            ).execute()

            files.extend(results.get("files", []))
            page_token = results.get("nextPageToken")
            if not page_token:
                break

        return files

    def download_file(self, file_id: str, file_name: str, mime_type: str) -> str:
        """Baixa um arquivo do Google Drive preservando a integridade forense."""
        output_path = os.path.join(self.output_dir, file_name)

        if mime_type.startswith("application/vnd.google-apps"):
            export_formats = {
                "application/vnd.google-apps.document": "application/pdf",
                "application/vnd.google-apps.spreadsheet": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                "application/vnd.google-apps.presentation": "application/pdf",
            }
            export_mime = export_formats.get(mime_type, "application/pdf")
            request = self.service.files().export_media(fileId=file_id, mimeType=export_mime)
        else:
            request = self.service.files().get_media(fileId=file_id)

        with io.FileIO(output_path, "wb") as fh:
            downloader = MediaIoBaseDownload(fh, request)
            done = False
            while not done:
                _, done = downloader.next_chunk()

        self.acquisition_log.append({
            "timestamp": datetime.utcnow().isoformat(),
            "file_id": file_id,
            "file_name": file_name,
            "output_path": output_path,
            "action": "downloaded"
        })
        return output_path


…