T1217

Browser Information Discovery

Discovery Last updated:

Adversaries may enumerate information about browsers to learn more about compromised environments. Data saved by browsers (such as bookmarks, accounts, and browsing history) may reveal personal information about users (banking sites, social media, relationships) as well as details about internal network resources such as servers, tools/dashboards, and other infrastructure. Browser information may also highlight additional targets after an adversary has access to valid credentials, especially credentials cached by browsers in Login Data or logins.json files. Specific storage locations vary by platform and application, but browser information is typically stored in local SQLite databases and JSON files under user profile directories.

What is T1217 Browser Information Discovery?

Browser Information Discovery (T1217) maps to the Discovery tactic — the adversary is trying to figure out your environment in MITRE ATT&CK.

This page provides production-ready detection logic for Browser Information Discovery, covering the data sources and telemetry it touches: File: File Access, File: File Modification, Microsoft Defender for Endpoint. The queries below are rated medium severity at medium confidence, and ship for 7 SIEM platforms — KQL, SPL, Elastic, QRadar, Sumo, YARA-L, LogScale.

MITRE ATT&CK

Tactic
Discovery
Technique
T1217 Browser Information Discovery
Canonical reference
https://attack.mitre.org/techniques/T1217/
Microsoft Sentinel / Defender
kusto
let BrowserDataFiles = dynamic([
  "History", "Bookmarks", "Login Data", "Cookies", "Web Data",
  "places.sqlite", "logins.json", "key4.db", "LocalState",
  "Favicons", "Network Action Predictor", "Visited Links",
  "Extension Cookies", "TransportSecurity", "BookmarksExtended"
]);
let LegitBrowserProcesses = dynamic([
  "chrome.exe", "msedge.exe", "firefox.exe", "brave.exe",
  "opera.exe", "iexplore.exe", "MicrosoftEdge.exe", "msedgewebview2.exe",
  "chromium.exe", "vivaldi.exe"
]);
let BrowserDataPaths = dynamic([
  "\\Google\\Chrome\\User Data\\",
  "\\Microsoft\\Edge\\User Data\\",
  "\\Mozilla\\Firefox\\Profiles\\",
  "\\BraveSoftware\\Brave-Browser\\User Data\\",
  "\\Opera Software\\Opera Stable\\",
  "\\Vivaldi\\User Data\\"
]);
let NoisySystemProcesses = dynamic([
  "MsMpEng.exe", "SearchIndexer.exe", "SgrmBroker.exe",
  "CompatTelRunner.exe", "TiWorker.exe"
]);
DeviceFileEvents
| where Timestamp > ago(24h)
| where ActionType in ("FileRead", "FileCopied", "FileCreated", "FileRenamed")
| where FolderPath has_any (BrowserDataPaths)
| where FileName in~ (BrowserDataFiles)
| where not(InitiatingProcessFileName in~ (LegitBrowserProcesses))
| where not(InitiatingProcessFileName in~ (NoisySystemProcesses))
| extend IsScriptEngine = InitiatingProcessFileName in~ ("powershell.exe", "pwsh.exe", "cmd.exe", "wscript.exe", "cscript.exe", "mshta.exe")
| extend IsArchiver = InitiatingProcessFileName in~ ("7z.exe", "winrar.exe", "zip.exe", "robocopy.exe", "xcopy.exe", "tar.exe")
| extend IsPython = InitiatingProcessFileName in~ ("python.exe", "python3.exe", "pythonw.exe")
| extend IsSuspiciousPath = InitiatingProcessFolderPath has_any ("\\Temp\\", "\\AppData\\Roaming\\", "\\Downloads\\", "\\Public\\")
| extend RiskScore = toint(IsScriptEngine) + toint(IsArchiver) + toint(IsPython) + toint(IsSuspiciousPath)
| project Timestamp, DeviceName, AccountName, FileName, FolderPath, ActionType,
          InitiatingProcessFileName, InitiatingProcessCommandLine,
          InitiatingProcessFolderPath, InitiatingProcessParentFileName,
          IsScriptEngine, IsArchiver, IsPython, IsSuspiciousPath, RiskScore
| sort by RiskScore desc, Timestamp desc

Detects non-browser processes reading or copying browser profile data files from known browser data directories. Monitors DeviceFileEvents for access to sensitive browser SQLite databases and JSON files (History, Bookmarks, Login Data, Cookies, places.sqlite, logins.json, key4.db, LocalState) by processes other than legitimate browser executables. Assigns a risk score based on whether the accessing process is a scripting engine, archiver, Python interpreter, or running from a suspicious directory path.

medium severity medium confidence

Data Sources

File: File Access File: File Modification Microsoft Defender for Endpoint

Required Tables

DeviceFileEvents

False Positives

  • Backup software (Veeam, Acronis, Windows Backup) backing up user AppData directories including browser profiles
  • Enterprise endpoint management tools (Tanium, BigFix, SCCM inventory agents) performing asset scans of user profile contents
  • Password managers (1Password, Bitwarden, KeePass import utilities) reading browser data for credential import/migration workflows
  • Browser profile migration or sync tools (e.g., MigrationAssistant, PCmover) during workstation refresh cycles
  • Security tools and DLP agents that scan browser storage as part of data classification or credential exposure monitoring

Sigma rule & cross-platform mapping

The detection logic for Browser Information Discovery (T1217) above is provided in a vendor-neutral form so you can deploy it on any SIEM. The same logic is shipped here as native KQL (Microsoft Sentinel / Defender), SPL (Splunk), Elastic (Elastic Security (EQL)), QRadar (IBM QRadar (AQL)), Sumo (Sumo Logic CSE), YARA-L (Google Chronicle / SecOps), LogScale (CrowdStrike LogScale (CQL)) queries. In Sigma terms, this detection targets the following logsource:

logsource:
  product: windows

Browse the community-maintained Sigma rules for this technique:


Testing Methodology

Validate this detection against 5 adversary techniques from Atomic Red Team. Each test below lists the behaviour to exercise and the telemetry you should expect to see. Executable commands and cleanup steps are available with Pro.

  1. Test 1PowerShell Copy Chrome History and Bookmarks

    Expected signal: Sysmon Event ID 1: Process Create — powershell.exe with CommandLine referencing 'Chrome\User Data\Default\History' and 'Chrome\User Data\Default\Bookmarks'. Sysmon Event ID 11: File Create — TargetFilename matching $TEMP\browser_data_test\History and $TEMP\browser_data_test\Bookmarks, with Image=powershell.exe. DeviceFileEvents ActionType=FileCopied for both files.

  2. Test 2CMD Directory Enumeration of Firefox Profiles

    Expected signal: Sysmon Event ID 1: Process Create — cmd.exe with CommandLine containing '%APPDATA%\Mozilla\Firefox\Profiles\'. Security Event ID 4688 (if process command line auditing enabled). No file creation events from dir enumeration, but process command line is the primary indicator.

  3. Test 3Python SQLite Query Against Chrome History

    Expected signal: Sysmon Event ID 1: Process Create — python.exe with CommandLine referencing '%LOCALAPPDATA%\Google\Chrome\User Data\Default\History' and 'sqlite3'. Sysmon Event ID 11: File Create — TargetFilename=$TEMP\hist_tmp.db with Image=python.exe. DeviceFileEvents ActionType=FileCopied for History file.

  4. Test 4PowerShell Read Chrome Bookmarks for Internal Resource Discovery

    Expected signal: Sysmon Event ID 1: Process Create — powershell.exe with CommandLine containing 'Chrome\User Data\Default\Bookmarks'. Sysmon Event ID 11: File Create may not fire for read-only access; rely on DeviceFileEvents ActionType=FileRead in MDE. PowerShell Script Block Log Event ID 4104 captures the full script including ConvertFrom-Json parsing logic.

  5. Test 5Linux Shell Script Collecting Firefox and Chrome Browser Data

    Expected signal: Linux auditd: syscall execve for bash/sh with browser path arguments, and open/read syscalls on ~/.mozilla/firefox/*/places.sqlite and ~/.config/google-chrome/Default/History. Syslog entries if auditd rules are configured for home directory access. Linux file access events in Sysmon for Linux (if deployed): EventCode=11 for file creation in /tmp/browser_staging.


Response Playbook

Triage

  1. Identify the accessing process — check InitiatingProcessFileName and InitiatingProcessFolderPath. Is it a scripting engine (PowerShell, Python), a known LOLBin, or an unknown executable from Temp/Downloads?
  2. Review the full command line of the initiating process — is it explicitly referencing browser profile paths, copying files, or querying SQLite databases? Look for patterns like 'Copy-Item *Chrome*', 'sqlite3 *History*', or 'cat *logins.json*'
  3. Identify which browser data files were accessed — Login Data and key4.db/logins.json are critical (stored credentials), History and Bookmarks are intelligence-gathering indicators, Cookies enable session hijacking
  4. Check the parent process of the accessing process — was it spawned by a user-interactive process, a phishing document (winword.exe, excel.exe), a scheduled task, or a service? Document the full process tree
  5. Review network events from the same process or host in the same time window — if browser data access is followed by outbound connections to external IPs, this indicates likely exfiltration
  6. Correlate with other discovery activity on the same host — browser info discovery is frequently combined with T1082 (System Info Discovery), T1033 (System Owner Discovery), and T1087 (Account Discovery) in reconnaissance phases

Containment

  1. If active credential theft is suspected (Login Data or logins.json accessed): immediately force password resets for accounts that had saved credentials in the affected browsers, and revoke active sessions for web services accessed from this workstation
  2. If session hijacking risk exists (Cookies file accessed): contact relevant web service owners to invalidate all active sessions for the affected user account, prioritizing banking, email, and internal tooling
  3. Isolate the endpoint via EDR network isolation if the accessing process appears malicious or if outbound exfiltration connections are confirmed
  4. Terminate the suspicious process if it is still running and preserve memory dump before termination: procdump.exe -ma <PID> C:\evidence\
  5. Block the initiating process hash at the EDR level to prevent execution on other endpoints while investigation continues
  6. If the accessing process was delivered via phishing or download: quarantine the file, identify delivery mechanism, and search for the same hash/path on other endpoints in the environment

Evidence Collection

  1. Browser data files accessed — copy the original files (History, Login Data, Bookmarks, places.sqlite, logins.json) from the victim's profile for forensic analysis; note that Login Data is an encrypted SQLite DB requiring DPAPI decryption
  2. Sysmon Event ID 11 (File Create) from Microsoft-Windows-Sysmon/Operational — captures exact filename, path, and initiating process with timestamp
  3. Sysmon Event ID 1 (Process Create) — full command line of the accessing process and its parent, correlation via ProcessGuid
  4. Sysmon Event ID 3 (Network Connection) — check for outbound connections from the suspicious process within the same session window, particularly to external IPs
  5. Sysmon Event ID 23 or 26 (File Delete/Shred) — adversaries may delete copies of browser data or the accessing tool after exfiltration
  6. Windows Prefetch — C:\Windows\Prefetch\ for execution evidence of the accessing binary (e.g., PYTHON.EXE-*.pf)
  7. PowerShell Script Block Logs (Event ID 4104) — if PowerShell was the accessing process, full decoded script content is available
  8. Security Event ID 4663 (Object Access) — if file system auditing is enabled on browser profile directories, records every access attempt with user and process context
  9. MFT ($MFT) and USN Journal — for timeline reconstruction of when browser data files were created, modified, or copied to staging locations

Escalation Criteria

  • ! Login Data (Chrome/Edge) or logins.json/key4.db (Firefox) accessed by any non-browser process — these files contain saved passwords and warrant immediate escalation regardless of other context
  • ! Cookies file accessed followed within 60 minutes by outbound connections from the same host to external IPs — high confidence session hijacking attempt
  • ! Browser data accessed by a process with a suspicious or unknown hash not seen elsewhere in the environment — possible novel malware or InfoStealer
  • ! Multiple browser data files (3+) accessed in a single session by the same non-browser process — bulk exfiltration pattern consistent with InfoStealers like RedLine, Vidar, or Raccoon
  • ! Browser data access on a privileged workstation (domain admin, IT admin, DevOps) — bookmarks and history from these users may expose internal infrastructure and sensitive URLs
  • ! Access to LocalState file (Chrome master encryption key) combined with Login Data access — attacker has both components required to decrypt stored credentials

Investigation Guide

Forensic Artifacts

  • > Chrome History: %LOCALAPPDATA%\Google\Chrome\User Data\Default\History — SQLite DB, tables: urls, visits, downloads. Query: SELECT url, title, visit_count, last_visit_time FROM urls ORDER BY last_visit_time DESC
  • > Chrome Login Data: %LOCALAPPDATA%\Google\Chrome\User Data\Default\Login Data — SQLite DB with DPAPI-encrypted passwords, tables: logins. Decryption requires user's DPAPI master key
  • > Chrome LocalState: %LOCALAPPDATA%\Google\Chrome\User Data\LocalState — JSON file containing AES-256-GCM key encrypted with DPAPI, used to decrypt Login Data passwords on Chrome 80+
  • > Chrome Bookmarks: %LOCALAPPDATA%\Google\Chrome\User Data\Default\Bookmarks — Plain JSON file, immediately readable without decryption
  • > Chrome Cookies: %LOCALAPPDATA%\Google\Chrome\User Data\Default\Network\Cookies — SQLite DB with session tokens
  • > Firefox places.sqlite: %APPDATA%\Mozilla\Firefox\Profiles\<profile>\places.sqlite — History and bookmarks in moz_places and moz_bookmarks tables
  • > Firefox logins.json: %APPDATA%\Mozilla\Firefox\Profiles\<profile>\logins.json — JSON file with credentials encrypted using key4.db master key
  • > Firefox key4.db: %APPDATA%\Mozilla\Firefox\Profiles\<profile>\key4.db — NSS key database, required to decrypt logins.json credentials
  • > Edge User Data: %LOCALAPPDATA%\Microsoft\Edge\User Data\Default\ — Same SQLite structure as Chrome (Chromium-based)
  • > Windows Security Event 4663 — Object access audit events if SACL configured on browser profile directories
  • > Prefetch files: C:\Windows\Prefetch\*.pf — Evidence of execution of browser data exfiltration tools
  • > Shadow Copies / VSS — Adversaries may access browser data via VSS snapshots to avoid file locking issues when browser is running

Tuning Guidance

Begin by identifying legitimate processes that routinely access browser data in your environment. Common sources include backup agents (check process parent and target paths — backups typically write to a network share or backup volume, not Temp), endpoint inventory tools, and DLP scanners. Create allowlists based on specific process paths (not just filenames) combined with parent process context. For example, allow robocopy.exe only when parent is your approved backup service account. Avoid broad exclusions on process names alone — attackers rename tools. If Sysmon Event ID 11 volume is too high, consider supplementing with Sysmon Event ID 10 (Process Access) targeting browser processes accessed by non-browser processes, which catches in-memory credential extraction from running browsers. For environments with MDE, the FileRead action type may require enabling advanced file access auditing; start with FileCopied and FileCreated which have lower volume. Consider setting a minimum RiskScore threshold of 2 to reduce noise from single-indicator events. Environments with regular browser profile migration or employee onboarding workflows should exclude the specific migration tool's executable hash rather than process name.


Hunting Queries

Hunt for processes accessing three or more distinct browser data files within the lookback window — a hallmark of InfoStealer malware bulk collection. Single-file access may be benign, but accessing History + Login Data + Cookies or History + Bookmarks + logins.json in combination is a strong indicator of systematic browser data harvesting.

Hunting — KQL
kql
DeviceFileEvents
| where Timestamp > ago(7d)
| where FolderPath has_any (
    "\\Google\\Chrome\\User Data\\",
    "\\Microsoft\\Edge\\User Data\\",
    "\\Mozilla\\Firefox\\Profiles\\",
    "\\BraveSoftware\\Brave-Browser\\User Data\\"
  )
| where FileName in~ ("History", "Login Data", "Bookmarks", "Cookies", "places.sqlite", "logins.json", "key4.db", "LocalState")
| where not(InitiatingProcessFileName in~ ("chrome.exe", "msedge.exe", "firefox.exe", "brave.exe", "MsMpEng.exe", "SearchIndexer.exe", "msedgewebview2.exe"))
| summarize FileCount=dcount(FileName), Files=make_set(FileName), ActionTypes=make_set(ActionType),
            FirstSeen=min(Timestamp), LastSeen=max(Timestamp)
            by DeviceName, AccountName, InitiatingProcessFileName, InitiatingProcessFolderPath
| where FileCount >= 3
| sort by FileCount desc
Hunting — SPL
spl
index=wineventlog sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=11
  (TargetFilename="*\\Chrome\\User Data\\*" OR TargetFilename="*\\Edge\\User Data\\*"
   OR TargetFilename="*\\Firefox\\Profiles\\*" OR TargetFilename="*\\Brave-Browser\\User Data\\*")
  (TargetFilename="*History*" OR TargetFilename="*Login Data*" OR TargetFilename="*Bookmarks*"
   OR TargetFilename="*Cookies*" OR TargetFilename="*places.sqlite*" OR TargetFilename="*logins.json*"
   OR TargetFilename="*key4.db*" OR TargetFilename="*LocalState*")
  NOT (Image="*\\chrome.exe" OR Image="*\\msedge.exe" OR Image="*\\firefox.exe"
       OR Image="*\\brave.exe" OR Image="*\\MsMpEng.exe" OR Image="*\\SearchIndexer.exe")
| stats dc(TargetFilename) as FileCount, values(TargetFilename) as Files,
         earliest(_time) as FirstSeen, latest(_time) as LastSeen by host, User, Image
| where FileCount >= 3
| sort - FileCount

Hunt for processes that both access browser data files AND make outbound connections to external IPs within the same session, indicating the browser data was exfiltrated. This join-based hunt catches the full kill chain: collect → exfiltrate. Particularly effective at catching InfoStealer C2 callbacks that occur within minutes of data collection.

Hunting — KQL
kql
let BrowserDataPaths = dynamic([
    "\\Google\\Chrome\\User Data\\",
    "\\Microsoft\\Edge\\User Data\\",
    "\\Mozilla\\Firefox\\Profiles\\"
]);
let BrowserDataFiles = dynamic(["History", "Login Data", "Bookmarks", "places.sqlite", "logins.json", "LocalState", "Cookies"]);
let SuspiciousFileAccess = DeviceFileEvents
| where Timestamp > ago(24h)
| where FolderPath has_any (BrowserDataPaths)
| where FileName in~ (BrowserDataFiles)
| where not(InitiatingProcessFileName in~ ("chrome.exe", "msedge.exe", "firefox.exe", "brave.exe", "MsMpEng.exe", "SearchIndexer.exe"));
let SubsequentNetwork = DeviceNetworkEvents
| where Timestamp > ago(24h)
| where RemoteIPType == "Public"
| where RemotePort in (80, 443, 4444, 8080, 8443, 1337);
SuspiciousFileAccess
| join kind=inner SubsequentNetwork
    on $left.DeviceName == $right.DeviceName,
       $left.InitiatingProcessId == $right.InitiatingProcessId
| where SubsequentNetwork.Timestamp between (SuspiciousFileAccess.Timestamp .. datetime_add('minute', 30, SuspiciousFileAccess.Timestamp))
| project FileAccessTime=SuspiciousFileAccess.Timestamp, NetworkTime=SubsequentNetwork.Timestamp,
          DeviceName, AccountName, FileName, InitiatingProcessFileName, InitiatingProcessCommandLine,
          RemoteIP, RemotePort, RemoteUrl
| sort by FileAccessTime desc
Hunting — SPL
spl
index=wineventlog sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational"
  (EventCode=11 OR EventCode=3)
| eval EventType=if(EventCode=11, "FileAccess", "NetworkConn")
| eval TargetIndicator=if(EventCode=11, TargetFilename, DestinationIp)
| eval BrowserDataAccess=if(EventCode=11 AND
    (match(TargetFilename, "(?i)(chrome|edge|firefox|brave).*\\(History|Login Data|Bookmarks|Cookies|places\.sqlite|logins\.json|LocalState)") AND
     NOT match(Image, "(?i)(chrome|msedge|firefox|brave|MsMpEng|SearchIndexer)")), 1, 0)
| eval ExternalConn=if(EventCode=3 AND
    NOT (match(DestinationIp, "^(10\.|172\.(1[6-9]|2[0-9]|3[01])\.|192\.168\.)") OR DestinationIp="127.0.0.1"), 1, 0)
| stats sum(BrowserDataAccess) as FileAccesses, sum(ExternalConn) as NetworkConns,
         values(TargetIndicator) as Indicators by host, User, Image, ProcessId
| where FileAccesses > 0 AND NetworkConns > 0
| sort - FileAccesses

Hunt for scripting engines and interpreters with browser profile paths explicitly referenced in command-line arguments. This catches adversaries using PowerShell, Python, or CMD scripts to enumerate or copy browser data, where the full path to browser directories is passed as an argument. Different from the main detection which uses file events — this catches the command construction phase before file access occurs.

Hunting — KQL
kql
DeviceProcessEvents
| where Timestamp > ago(7d)
| where ProcessCommandLine has_any (
    "Chrome\\User Data", "Edge\\User Data", "Firefox\\Profiles",
    "Brave-Browser\\User Data", "Login Data", "places.sqlite",
    "logins.json", "key4.db", "LocalState"
  )
| where FileName in~ ("powershell.exe", "pwsh.exe", "cmd.exe", "python.exe",
                       "python3.exe", "wscript.exe", "cscript.exe")
| project Timestamp, DeviceName, AccountName, FileName, ProcessCommandLine,
          InitiatingProcessFileName, InitiatingProcessCommandLine
| sort by Timestamp desc
Hunting — SPL
spl
index=wineventlog sourcetype="XmlWinEventLog:Microsoft-Windows-Sysmon/Operational" EventCode=1
  (Image="*\\powershell.exe" OR Image="*\\pwsh.exe" OR Image="*\\cmd.exe"
   OR Image="*\\python.exe" OR Image="*\\python3.exe" OR Image="*\\wscript.exe")
  (CommandLine="*Chrome\\User Data*" OR CommandLine="*Edge\\User Data*"
   OR CommandLine="*Firefox\\Profiles*" OR CommandLine="*Login Data*"
   OR CommandLine="*places.sqlite*" OR CommandLine="*logins.json*"
   OR CommandLine="*key4.db*" OR CommandLine="*LocalState*"
   OR CommandLine="*Brave-Browser*")
| table _time, host, User, Image, CommandLine, ParentImage, ParentCommandLine
| sort - _time

Atomic Red Team Tests

Test 1 PowerShell Copy Chrome History and Bookmarks
windows

Simulates an InfoStealer or post-exploitation script copying Chrome browser history and bookmarks to a staging location in the user's Temp directory. This is one of the most common patterns seen in commodity InfoStealer malware (RedLine, Vidar) and nation-state tools like Mafalda. Uses Copy-Item which generates Sysmon Event ID 11.

Command

powershell
powershell.exe -NoProfile -Command "$dest = "$env:TEMP\browser_data_test"; New-Item -ItemType Directory -Path $dest -Force | Out-Null; Copy-Item "$env:LOCALAPPDATA\Google\Chrome\User Data\Default\History" "$dest\History" -Force -ErrorAction SilentlyContinue; Copy-Item "$env:LOCALAPPDATA\Google\Chrome\User Data\Default\Bookmarks" "$dest\Bookmarks" -Force -ErrorAction SilentlyContinue; Write-Output 'Files staged to: ' $dest; Get-ChildItem $dest"

Cleanup

powershell
powershell.exe -NoProfile -Command "Remove-Item '$env:TEMP\browser_data_test' -Recurse -Force -ErrorAction SilentlyContinue"

Expected Telemetry

Sysmon Event ID 1: Process Create — powershell.exe with CommandLine referencing 'Chrome\User Data\Default\History' and 'Chrome\User Data\Default\Bookmarks'. Sysmon Event ID 11: File Create — TargetFilename matching $TEMP\browser_data_test\History and $TEMP\browser_data_test\Bookmarks, with Image=powershell.exe. DeviceFileEvents ActionType=FileCopied for both files.

Expected Detection

Main detection fires on FileCopied from Chrome\User Data\ path by powershell.exe. RiskScore=2 (IsScriptEngine=1 + IsSuspiciousPath=1 for TEMP destination). Hunting query 1 fires if Chrome Login Data is also accessed in same session.

Test 2 CMD Directory Enumeration of Firefox Profiles
windows

Enumerates Firefox profile directories and lists all files within using CMD. This technique is used by reconnaissance frameworks (Fox Kitten, Empire) to discover what browser profiles exist and which data files are present before staging a targeted copy operation. Generates process creation events with browser path references.

Command

powershell
cmd.exe /c dir "%APPDATA%\Mozilla\Firefox\Profiles\" /s /b 2>nul && cmd.exe /c dir "%APPDATA%\Mozilla\Firefox\Profiles\" /s /b /a:-d | findstr /i "places.sqlite logins.json key4.db"

Expected Telemetry

Sysmon Event ID 1: Process Create — cmd.exe with CommandLine containing '%APPDATA%\Mozilla\Firefox\Profiles\'. Security Event ID 4688 (if process command line auditing enabled). No file creation events from dir enumeration, but process command line is the primary indicator.

Expected Detection

Hunting query 3 fires on cmd.exe with Firefox\Profiles in CommandLine. Main file-based detection does not fire from dir enumeration alone — this test validates command-line detection coverage gap that hunting query 3 addresses.

Test 3 Python SQLite Query Against Chrome History
windows

Uses Python to directly query the Chrome History SQLite database, extracting the 20 most recently visited URLs. This represents a more sophisticated technique used by targeted intrusion sets (Volt Typhoon targeting network admin browsing history) that prefer direct SQLite queries over file copying to reduce forensic artifacts. Requires Python to be installed.

Command

powershell
python.exe -c "import sqlite3, shutil, os; src = os.path.expandvars('%LOCALAPPDATA%\\Google\\Chrome\\User Data\\Default\\History'); dst = os.path.expandvars('%TEMP%\\hist_tmp.db'); shutil.copy2(src, dst); conn = sqlite3.connect(dst); cur = conn.execute('SELECT url, title, visit_count FROM urls ORDER BY last_visit_time DESC LIMIT 20'); [print(r) for r in cur.fetchall()]; conn.close(); os.remove(dst)"

Cleanup

powershell
python.exe -c "import os; f=os.path.expandvars('%TEMP%\\hist_tmp.db'); os.remove(f) if os.path.exists(f) else None"

Expected Telemetry

Sysmon Event ID 1: Process Create — python.exe with CommandLine referencing '%LOCALAPPDATA%\Google\Chrome\User Data\Default\History' and 'sqlite3'. Sysmon Event ID 11: File Create — TargetFilename=$TEMP\hist_tmp.db with Image=python.exe. DeviceFileEvents ActionType=FileCopied for History file.

Expected Detection

Main detection fires on FileCopied from Chrome\User Data path by python.exe. RiskScore=2 (IsPython=1 + IsSuspiciousPath=1 for TEMP). Hunting query 3 also fires on python.exe with 'Chrome\User Data' in CommandLine.

Test 4 PowerShell Read Chrome Bookmarks for Internal Resource Discovery
windows

Reads and parses Chrome Bookmarks JSON file to enumerate saved bookmarks — a technique observed in Fox Kitten and APT38 operations to discover internal network resources, admin portals, and infrastructure URLs from compromised workstations. The Bookmarks file is unencrypted JSON and requires no special decryption.

Command

powershell
powershell.exe -NoProfile -Command "$bookmarks = Get-Content '$env:LOCALAPPDATA\Google\Chrome\User Data\Default\Bookmarks' -Raw | ConvertFrom-Json; function Get-Bookmarks($node) { if ($node.type -eq 'url') { Write-Output "$($node.name): $($node.url)" }; if ($node.children) { $node.children | ForEach-Object { Get-Bookmarks $_ } } }; Get-Bookmarks $bookmarks.roots.bookmark_bar; Get-Bookmarks $bookmarks.roots.other"

Expected Telemetry

Sysmon Event ID 1: Process Create — powershell.exe with CommandLine containing 'Chrome\User Data\Default\Bookmarks'. Sysmon Event ID 11: File Create may not fire for read-only access; rely on DeviceFileEvents ActionType=FileRead in MDE. PowerShell Script Block Log Event ID 4104 captures the full script including ConvertFrom-Json parsing logic.

Expected Detection

Main KQL detection fires on FileRead from Chrome\User Data path by powershell.exe (ActionType=FileRead). RiskScore=1 (IsScriptEngine=1). Hunting query 3 (command-line based) fires on PowerShell with 'Chrome\User Data\Default\Bookmarks' in command line. Note: Sysmon-based SPL detection uses EventCode=11 (FileCreate) and may not capture read-only access without additional Sysmon configuration.

Test 5 Linux Shell Script Collecting Firefox and Chrome Browser Data
linux

Simulates browser data collection on Linux using shell commands, as seen in Linux-targeting InfoStealer variants. Copies Firefox profile database files and Chrome history to /tmp staging directory. Relevant for Linux workstations, developer machines, or servers running browser-based applications.

Command

bash
mkdir -p /tmp/browser_staging && find ~/.mozilla/firefox -name 'places.sqlite' -exec cp {} /tmp/browser_staging/ff_places.sqlite \; 2>/dev/null; find ~/.mozilla/firefox -name 'logins.json' -exec cp {} /tmp/browser_staging/ff_logins.json \; 2>/dev/null; find ~/.config/google-chrome/Default -name 'History' -exec cp {} /tmp/browser_staging/chrome_history \; 2>/dev/null; ls -la /tmp/browser_staging/

Cleanup

bash
rm -rf /tmp/browser_staging

Expected Telemetry

Linux auditd: syscall execve for bash/sh with browser path arguments, and open/read syscalls on ~/.mozilla/firefox/*/places.sqlite and ~/.config/google-chrome/Default/History. Syslog entries if auditd rules are configured for home directory access. Linux file access events in Sysmon for Linux (if deployed): EventCode=11 for file creation in /tmp/browser_staging.

Expected Detection

Linux-specific detection via auditd rules monitoring open() syscalls on ~/.mozilla and ~/.config/google-chrome paths by non-browser processes. Sysmon for Linux EventCode=11 detection on /tmp/browser_staging file creation. KQL: DeviceFileEvents on Linux-enrolled MDE devices with FolderPath containing '.mozilla/firefox' or '.config/google-chrome'.

Related Detections

Tactic Hub