performing-cloud-storage-forensic-acquisition

name	performing-cloud-storage-forensic-acquisition
description	Perform forensic acquisition of cloud storage services including Google Drive, OneDrive, Dropbox, and Box by pulling API-based remote data such as revision history and audit logs, and collecting local sync-client artifacts including KAPE targets and OneDrive databases from endpoints. Use during incident response or e-discovery when evidence resides in cloud-synced storage and both cloud-side and endpoint-side artifacts must be preserved.
domain	cybersecurity
subdomain	digital-forensics
tags	["cloud-forensics","google-drive","onedrive","dropbox","box","cloud-acquisition","api-forensics","sync-client","endpoint-artifacts","magnet-axiom"]
version	1.0
author	mahipal
license	Apache-2.0
nist_ai_rmf	["MEASURE-2.7","MAP-5.1","MANAGE-2.4"]
atlas_techniques	["AML.T0070","AML.T0066","AML.T0082"]
nist_csf	["RS.AN-03","DE.AE-02","RS.MA-01"]
mitre_attack	["T1005","T1074","T1119","T1070","T1059"]

Performing Cloud Storage Forensic Acquisition

Overview

Cloud storage forensic acquisition involves collecting digital evidence from services like Google Drive, OneDrive, Dropbox, and Box through both API-based remote acquisition and local endpoint artifact analysis. Modern investigations must address the challenge that cloud-synced files may exist in multiple states: locally synchronized, cloud-only (on-demand), cached, and deleted. Endpoint devices that have synchronized with cloud storage contain a wealth of metadata about locally synced files, files present only in the cloud, and even deleted items recoverable from cache folders. API-based acquisition using service-specific APIs provides direct access to remote data with valid credentials and proper legal authorization.

When to Use

• When conducting security assessments that involve performing cloud storage forensic acquisition
• When following incident response procedures for related security events
• When performing scheduled security testing or auditing activities
• When validating security controls through hands-on testing

Prerequisites

• Legal authorization (warrant, consent, or corporate policy) for cloud data access
• Valid user credentials or administrative access tokens
• Magnet AXIOM Cloud, Cellebrite Cloud Analyzer, or equivalent tool
• KAPE with cloud storage target files
• Python 3.8+ with google-api-python-client, msal, dropbox SDK
• Network connectivity for API-based acquisition

Acquisition Methods

Method 1: API-Based Remote Acquisition

Google Drive API Acquisition

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:
    """Forensically acquire files and metadata from Google Drive via API."""

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

     () -> :
        
        files = []
        page_token = 
        query =   include_trashed  

         :
            results = .service.files().(
                q=query,
                pageSize=,
                fields=
                       
                       
                       ,
                pageToken=page_token
            ).execute()

            files.extend(results.get(, []))
            page_token = results.get()
              page_token:
                

         files

     () -> :
        
        output_path = os.path.join(.output_dir, file_name)

         mime_type.startswith():
            export_formats = {
                : ,
                : ,
                : ,
            }
            export_mime = export_formats.get(mime_type, )
            request = .service.files().export_media(fileId=file_id, mimeType=export_mime)
        :
            request = .service.files().get_media(fileId=file_id)

         io.FileIO(output_path, )  fh:
            downloader = MediaIoBaseDownload(fh, request)
            done = 
              done:
                _, done = downloader.next_chunk()

        .acquisition_log.append({
            : datetime.utcnow().isoformat(),
            : file_id,
            : file_name,
            : output_path,
            : 
        })
         output_path

     () -> :
        
        revisions = .service.revisions().(
            fileId=file_id,
            fields=
        ).execute()
         revisions.get(, [])

     () -> :
        
        report_path = os.path.join(.output_dir, )
         (report_path, )  f:
            json.dump({
                : .acquisition_log[][]  .acquisition_log  ,
                : datetime.utcnow().isoformat(),
                : (.acquisition_log),
                : .acquisition_log
            }, f, indent=)
         report_path