Infostealer Browser Credential Theft

Stealer process → Login Data / logins.json file read → CryptUnprotectData() / NSS3 → C2 exfiltration

Credential Access Collection Exfiltration T1555.003 T1539 T1041 Detection difficulty: MEDIUM Prevalence: HIGH

Infostealers harvest credentials, cookies, and autofill data from browser credential databases. The invariant across all families: the stealer process must open browser credential files (Login Data, Cookies, logins.json) and invoke CryptUnprotectData() or NSS3 decryption - kernel-observable regardless of family or Chrome App-Bound Encryption bypass. The Snowflake breach (2024) demonstrated downstream impact: UNC5537 used infostealer-harvested credentials for initial access to 160+ organizations.

Attack Chokepoints 3 invariant stages

Each stage is an invariant condition the attacker must satisfy, regardless of tool, variant, or threat actor. Detection at any stage breaks the chain.

1 Credential Database Access ▶
  • Code execution on victim machine (via ClickFix, malvertising, cracked software, game cheats, SEO poisoning, YouTube malware, or social engineering)
  • Target must use a Chromium-based browser (Chrome, Edge, Brave, Opera, etc.) or Firefox
  • Browser credential database files must be accessible (not locked by exclusive handle; Chrome Login Data is typically not exclusively locked)
  • {"For App-Bound Encryption bypass variants"=>"Chrome must be installed (COM elevation requires GoogleChromeElevationService); OR Chrome must be running (CDP bypass); OR stealer must have code injection capability (memory injection bypass)"}
  • Outbound network access for C2 exfiltration (though some variants stage locally and exfiltrate via separate channel)
Input Stealer process is running on the victim machine
Chokepoint Must open browser credential database files (Login Data, Cookies, Local State, logins.json). These are the only locations where browser credentials are stored.
Observable Sysmon EID 11 (FileCreate; stealer copies credential DB to temp) or Windows Security EID 4663 (Object Access audit) showing a non-browser process accessing Chrome/Edge/Firefox credential files
Why unavoidable
Browser credentials only exist in these database files. The stealer must read them. There is no alternative path to the credentials.
  • Sysmon Event ID 10 (Process Access)
  • Sysmon Event ID 11 (File Created/Accessed)
  • Windows Security Event ID 4663 (Object Access)
View rule →
↓ Credential database content has been read
2 Credential Decryption ▶
Input Credential database content has been read
Chokepoint Must invoke platform decryption APIs. CryptUnprotectData() (DPAPI) for Chromium browsers, NSS3 decryption for Firefox, or an App-Bound Encryption bypass technique
Observable CryptUnprotectData calls from non-browser processes. Chrome Elevation Service COM interface activation. Chrome DevTools Protocol connections to running Chrome instances (CDP bypass).
Why unavoidable
The credentials are encrypted at rest. The stealer must decrypt them to extract usable passwords. The decryption API call is the artifact.
  • ETW DPAPI provider
  • Sysmon Event ID 1 (Process Creation for COM/CDP bypass processes)
  • Windows Security Event ID 4688
View rule →
↓ Credentials have been decrypted and collected
3 Data Exfiltration ▶
Input Credentials have been decrypted and collected
Chokepoint Must exfiltrate the harvested data to attacker infrastructure
Observable Outbound HTTP POST to low-reputation domains, Telegram bot API calls, Discord webhook POSTs from non-standard processes. Large data transfers from processes that recently accessed credential databases.
Why unavoidable
Stolen credentials are worthless if they stay on the victim machine. The exfiltration connection is the artifact.
  • Sysmon Event ID 3 (Network Connection)
  • Sysmon Event ID 22 (DNS Query)
  • Web proxy logs
View rule →

Variations 12 variants tracked

Tools and methods that exploit this chokepoint. The list grows. The chokepoint doesn't change.

LummaC2 2022-Q4 Disrupted (May 2025) / Active (rebrand expected) ▶
The dominant infostealer MaaS of 2024-2025, representing 51% of all dark web credential logs at peak. Delivered primarily via ClickFix (517% surge in 2025 ClickFix attacks) and malvertising. Targets 50+ Chromium-based browsers, Firefox profiles, cryptocurrency wallets, and 2FA applications. Despite law enforcement disruption, successor variants and rebrands are anticipated based on historical patterns (Raccoon v1 → v2, RedLine → successors, etc.).
Dominant stealer (51% of dark web logs at peak). Delivered primarily via ClickFix. Targets 50+ Chromium browsers, Firefox, crypto wallets, 2FA apps. Law enforcement disruption May 2025.
# Post-ClickFix delivery chain:
powershell.exe -enc <base64> → downloads LummaC2 loader
# Loader copies browser DBs:
copy "%LOCALAPPDATA%\Google\Chrome\User Data\Default\Login Data" %TEMP%\lg.db
copy "%LOCALAPPDATA%\Google\Chrome\User Data\Local State" %TEMP%\ls.json
# Calls CryptUnprotectData via embedded DPAPI wrapper
# Exfils via HTTPS POST to rotating C2 domains
  • Sysmon EID 10: Non-browser process accessing Login Data / Cookies files
  • ETW: CryptUnprotectData called by non-browser process
  • Sysmon EID 3: HTTPS POST to low-reputation domain from stealer process
Same chokepoint: Stealer executes → copies Login Data/Cookies → CryptUnprotectData() → HTTPS POST exfil to C2
Source: www.cisa.gov →
Stealc 2023-Q1 Active ▶
Emerged January 2023; lightweight MaaS stealer with modular plugin architecture. Targets Chromium browsers, Firefox, cryptocurrency wallets, and messaging apps (Discord, Telegram). Marketed on dark web forums as a "lightweight" alternative with per-target module loading to reduce detection footprint. Active through 2025-2026 across commodity and targeted campaigns.
$200/month MaaS. V2 (March 2025) added JSON C2, multi-monitor screenshots, built-in loader. Server-side credential decryption bypasses some ABE protections.
# StealC v2 - JSON-based C2, Themida-packed:
# Copies Login Data, Cookies, Local State from all Chromium profiles
# CryptUnprotectData for DPAPI decryption
# Multi-monitor screenshot capture
# HTTPS POST exfil with JSON format
  • Sysmon EID 10: Non-browser process accessing Login Data / Cookies
  • Sysmon EID 3: HTTPS POST to C2 with JSON-formatted exfil
Same chokepoint: Stealer executes → copies Login Data/Cookies → CryptUnprotectData → JSON C2 exfil
Source: www.picussecurity.com →
RedLine 2020-Q1 Disrupted (Oct 2024) / Variants Active ▶
One of the longest-running stealer families; dominated the market from 2020-2024. Targets all Chromium browsers and Firefox; also harvests VPN credentials, FTP clients, cryptocurrency wallets, and system information. Despite takedown, RedLine-derived code and techniques persist in successor families.
Longest-running major stealer (2020-2024). 51% of all infostealer infections 2020-2023. Operation Magnus (Oct 2024) seized infrastructure.
# .NET stealer targeting all Chromium + Firefox:
# Uses SQLite library to query browser DBs directly
# Targets: Login Data, Cookies, logins.json, key4.db
# Also: VPN credentials, FTP clients, crypto wallets
# Exfils via HTTP POST to C2 panel
  • Sysmon EID 10: .NET process accessing browser credential files
  • Sysmon EID 7: System.Data.SQLite.dll loaded by non-browser process
  • Sysmon EID 3: HTTP POST exfil to C2 panel
Same chokepoint: Stealer executes → SQLite queries against Login Data → CryptUnprotectData → HTTP POST exfil
Source: www.operation-magnus.com →
Raccoon v2 2022-Q3 Active ▶
Raccoon Stealer v1 shut down March 2022 when lead developer was arrested; v2 relaunched June 2022 with rewritten C++ codebase. Targets 60+ browsers including all major Chromium variants and Firefox. Employs DPAPI-based decryption for Chromium credentials. Continuously updated with new browser support and evasion techniques through 2025.
V1 shut down March 2022 (developer arrested). V2 C++ rewrite June 2022. Administrator sentenced to 5 years (2024). 52 million credentials linked.
# C++ rewrite (June 2022 relaunch):
# Targets 60+ browsers, DPAPI-based Chromium decryption
# Reads Login Data, Cookies, Local State from all profiles
# HTTP POST exfil with structured log format
  • Sysmon EID 10: Non-browser C++ process accessing browser credential files
  • Sysmon EID 3: HTTP POST to C2 with structured credential log
Same chokepoint: Stealer executes → reads 60+ browser credential DBs → DPAPI decryption → HTTP POST exfil
Source: blog.sekoia.io →
Vidar 2.0 2025-Q4 Active ▶
Complete rewrite of original Vidar stealer (2018) released October 2025 as pure C implementation. Introduced memory injection technique to bypass Chrome App-Bound Encryption by injecting into the chrome.exe process itself and calling decryption APIs from within the trusted process context. Represents the most technically sophisticated App-Bound bypass approach documented to date.
Complete rewrite. Memory injection into chrome.exe to call decryption from trusted context. Most sophisticated ABE bypass documented.
# Pure C rewrite (October 2025):
# Memory injection into chrome.exe for ABE bypass
# Calls decryption APIs from within trusted Chrome context
# Bypasses ABE without COM or CDP
  • Sysmon EID 10: Process access to chrome.exe with PROCESS_ALL_ACCESS
  • Sysmon EID 8: CreateRemoteThread into chrome.exe from non-browser process
Same chokepoint: Stealer injects into chrome.exe → calls decryption from trusted context → extracts credentials → exfil
Source: www.trendmicro.com →
AMOS (Atomic macOS Stealer) 2023-Q2 Active ▶
macOS-targeting infostealer marketed on Telegram for ~$1,000/month. Targets Safari Keychain, all Chromium browsers, Firefox, MetaMask, cryptocurrency wallets, and system information. Uses osascript to prompt for administrator password, bypassing macOS protections. Demonstrates that the browser credential database chokepoint applies cross-platform. macOS browsers use platform-native keychain APIs but the file access pattern is identical.
macOS-targeting. $1,000/month MaaS on Telegram. Uses osascript for admin password prompt. Demonstrates cross-platform applicability of the credential DB access chokepoint.
# macOS execution chain:
osascript -e 'display dialog "Chrome needs your password" default answer "" with hidden answer'
# Captures admin password via fake dialog
# Accesses Safari Keychain, Chrome Login Data, Firefox logins.json
# Exfils via HTTP POST to Telegram bot
  • macOS: osascript spawning dialog for credential capture
  • File access: Non-browser process reading Chrome/Safari credential files
  • Network: HTTP POST to api.telegram.org from non-Telegram process
Same chokepoint: osascript password prompt → read Keychain/Login Data → decrypt → Telegram bot exfil
Source: www.sentinelone.com →
EDDIESTEALER 2025-Q2 Active ▶
Identified May 2025; notable for Chrome App-Bound Encryption bypass via Chrome DevTools Protocol (CDP). Connects to a running Chrome instance in debug mode to extract cookies without needing to decrypt the database directly. Represents the third major App-Bound bypass approach (alongside COM elevation and memory injection).
Third major ABE bypass approach (after COM elevation and memory injection). Connects to Chrome in debug mode via CDP.
# Chrome DevTools Protocol (CDP) bypass:
chrome.exe --remote-debugging-port=9222
# Connects via WebSocket to CDP endpoint
# Extracts cookies via Network.getCookies without touching encrypted DB
  • Sysmon EID 1: chrome.exe launched with --remote-debugging-port
  • Sysmon EID 3: WebSocket connection to localhost:9222 from non-browser
Same chokepoint: Chrome launched in debug mode → CDP WebSocket connection → cookies extracted via CDP API → exfil
Source: thehackernews.com →
Medusa Stealer 2024-Q1 Active ▶
Supports credential harvesting from 100+ browsers, the broadest browser coverage of any tracked stealer family. Targets all Chromium and Gecko-based browsers, Electron apps storing credentials, and password managers. MaaS subscription model on dark web forums. Demonstrates that comprehensive browser coverage is a competitive differentiator in the stealer market.
100+ browser support; broadest coverage. Also targets Electron apps and password managers. MaaS subscription model.
# Broadest coverage: 100+ browsers
# Targets Chromium, Gecko, Electron apps
# Also targets password manager databases
# Same DPAPI/NSS3 decryption pattern
  • Sysmon EID 10: Non-browser process accessing 100+ browser profile paths
  • Sysmon EID 3: Large HTTP POST exfil (high volume from broad targeting)
Same chokepoint: Stealer enumerates 100+ browser paths → copies credential DBs → DPAPI/NSS3 decryption → bulk exfil
Source: www.resecurity.com →
Chrome App-Bound Encryption Bypass (COM Elevation) 2024-Q3 Active ▶
First documented bypass of Chrome App-Bound Encryption (introduced July 30, 2024), achieved approximately 45 days after ABE launch (September 2024). Technique: elevate via GoogleChromeElevationService COM interface to call decryption in a trusted context. Multiple families rapidly adopted this approach; Google patched but new bypasses emerged within weeks, demonstrating the cat-and-mouse pattern in App-Bound Encryption defense.
First bypass of Chrome App-Bound Encryption. Adopted by multiple stealer families within weeks. Google patched but new bypasses emerged rapidly.
# Embedded in stealer code - no standalone CLI:
# Elevates via GoogleChromeElevationService COM interface
# to call app-bound decryption in trusted process context
# Achieved ~45 days after ABE launch (July 2024)
  • Windows System: COM activation of GoogleChromeElevationService
  • Source process is NOT chrome.exe (the anomaly)
  • Sysmon EID 1: Chrome Elevation Service spawned by unusual parent
Same chokepoint: Stealer → COM activation of Chrome Elevation Service → decryption in trusted context → credential exfil
Source: security.googleblog.com →
North Korean APT Infostealer Operations 2024-Q1 Active ▶
North Korean threat actors (LAZARUS GROUP / HIDDEN COBRA) incorporated infostealer deployment into their tradecraft for financial operations. Connected to the February 2025 ByBit cryptocurrency exchange heist ($1.5B, the largest cryptocurrency theft in history). Hudson Rock 2026 trend report highlights the "infostealer-to-APT pipeline" where stealer credentials enable nation-state initial access without traditional spearphishing. Demonstrates infostealers as strategic intelligence-gathering tools, not just commodity theft.
LAZARUS GROUP incorporated commodity infostealers for financial operations. Stealer credentials enable initial access to crypto exchanges.
# NK groups use commodity stealers + custom tools:
# Deployed via trojanized crypto/DeFi apps
# Credential theft feeds financial operations
# ByBit heist ($1.5B, Feb 2025) used stealer credentials
  • Same as commodity stealer artifacts. Login Data access, DPAPI calls.
  • Additional: Crypto wallet file access (wallet.dat, keystore files)
Same chokepoint: Commodity stealer deployed → credentials harvested → NK APT uses for financial target access
Source: www.infostealers.com →
Contagious Interview (OtterCookie / North Korean Fake Job Interview Stealer) 2024-Q3 Active ▶
North Korean actors deliver OtterCookie JavaScript backdoor via fake developer job interviews, using malicious NPM packages or VS Code task configurations to achieve code execution and steal crypto keys and credentials. Evolved with heavy obfuscation since October 2025.
NK actors deliver OtterCookie via fake job interviews using malicious NPM packages or VS Code tasks. JavaScript-based backdoor.
# Delivery via fake developer job interview:
node.exe malicious_package/index.js
# OtterCookie JS backdoor steals crypto keys, browser creds, SSH keys
# Heavy obfuscation since October 2025
  • Sysmon EID 1: node.exe executing from npm cache or project directory
  • Sysmon EID 10: node.exe accessing browser credential files
  • File access: SSH key files, crypto wallet files accessed by node.exe
Same chokepoint: Malicious NPM package → node.exe executes OtterCookie → credential/key theft → C2 exfil
Source: unit42.paloaltonetworks.com →
Storm-2561 Fake VPN Client Stealer 2025-Q2 Active ▶
Storm-2561 uses SEO poisoning to lure users searching for enterprise VPN software (Pulse Secure, Fortinet, Ivanti, Cisco) to spoofed download sites redirecting to GitHub-hosted ZIP files containing MSI installers. The trojanized installer side-loads malicious DLLs signed by 'Taiyuan Lihua Near Information Technology Co., Ltd.' to harvest VPN credentials and browser credentials, then exfiltrates them. By 2026-Q1 the campaign expanded targeting to additional enterprise VPN clients, shifting lures toward corporate users rather than consumer software seekers.
Storm-2561 uses SEO poisoning targeting enterprise VPN searches. Trojanized MSI with side-loaded DLL signed by compromised Chinese certificate.
# SEO poisoning → spoofed VPN download site → GitHub ZIP:
msiexec /i fake_vpn_installer.msi
# Side-loaded DLL signed by "Taiyuan Lihua" harvests VPN + browser creds
  • Sysmon EID 1: msiexec.exe installing MSI from Downloads/Temp
  • Sysmon EID 7: DLL loaded with Taiyuan Lihua signature
  • Sysmon EID 10: Process accessing VPN credential stores + browser files
Same chokepoint: SEO poisoning → MSI install → side-loaded DLL → VPN + browser credential theft → exfil
Source: www.microsoft.com →

Detection Strategy

Rules organized by the chokepoint stage they detect. Each stage has one or more rules at different maturity levels.

1 Credential Database Access
Hunt rule
▶
Goal
Non-browser process reads browser credential database AND makes a DPAPI call
Log Sources
  • Sysmon Event ID 10 (Process Access to browser files)
  • Windows Security Event ID 4663 (File Access)
  • Sysmon Event ID 8 (CreateRemoteThread; for injection variants)
  • Windows API monitoring: CryptUnprotectData calls from non-browser processes
  • EDR behavioral telemetry
FP Rate
Low-Medium
Use Case
Active threat hunting for infostealer activity; correlates file access with decryption API call to distinguish intentional credential harvesting from incidental file access by legitimate tools
Non-browser, non-password-manager, non-backup process accesses a browser credential file AND within 60 seconds the same process calls CryptUnprotectData or NCryptUnprotectSecret. OR process access (EID 10) targeting chrome.exe/msedge.exe from an untrusted source with AccessRights including PROCESS_VM_READ (0x0010), the injection-based App-Bound bypass signal.
Sigma Rule - Hunt Level
title: Infostealer — Non-Browser Process Accesses Browser Credential DB from Suspicious Parent or Path
id: 790a46d5-2643-4afe-9718-18742e7eecd7
status: experimental
description: >
  Detects non-browser processes accessing credential database files from suspicious
  contexts — script interpreter parent, unsigned binary, or user-writable path origin.
references:
  - https://attack.mitre.org/techniques/T1555/003/
  - https://attack.mitre.org/techniques/T1539/
  - https://attack.mitre.org/techniques/T1059.001/
  - https://www.infostealers.com/article/2026-infostealer-trends-im-monitoring-at-hudson-rock/
  - https://blog.sekoia.io/lummac2-stealer-an-in-depth-analysis/
  - https://www.cisa.gov/news-events/cybersecurity-advisories/aa25-071a
  - https://security.googleblog.com/2024/09/improving-security-of-chrome-cookies.html
author: "@iimp0ster"
date: 2026/03/08
tags:
  - attack.credential_access
  - attack.t1555.003
  - attack.t1539
  - attack.execution
  - attack.t1059.001
  - detection.maturity.hunt
logsource:
  category: file_event
  product: windows
detection:
  # Selection A: Browser credential DB access by process with suspicious parent (ClickFix chain)
  selection_credential_path:
    TargetFilename|contains:
      - '\Google\Chrome\User Data\Default\Login Data'
      - '\Google\Chrome\User Data\Default\Cookies'
      - '\Google\Chrome\User Data\Local State'
      - '\Microsoft\Edge\User Data\Default\Login Data'
      - '\Microsoft\Edge\User Data\Default\Cookies'
      - '\BraveSoftware\Brave-Browser\User Data\Default\Login Data'
      - '\Mozilla\Firefox\Profiles\'
      - '\Opera Software\Opera Stable\Login Data'

  selection_suspicious_parent:
    ParentImage|endswith:
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\wscript.exe'
      - '\cscript.exe'
      - '\mshta.exe'
      - '\wmic.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
      - '\cmd.exe'
      - '\curl.exe'
      - '\certutil.exe'

  selection_suspicious_path:
    Image|contains:
      - '\AppData\Local\Temp\'
      - '\AppData\Roaming\'
      - '\Downloads\'
      - '\Desktop\'
      - '\Public\'
      - '\ProgramData\'
    Image|endswith:
      - '.exe'

  filter_legitimate_browsers:
    Image|endswith:
      - '\chrome.exe'
      - '\msedge.exe'
      - '\brave.exe'
      - '\firefox.exe'
      - '\opera.exe'
      - '\vivaldi.exe'
      - '\chromium.exe'
      - '\GoogleUpdate.exe'
      - '\MicrosoftEdgeUpdate.exe'
      - '\elevation_service.exe'

  # Selection B: Chrome spawned with debug port (CDP bypass — EDDIESTEALER)
  selection_cdp_bypass:
    Image|endswith: '\chrome.exe'
    CommandLine|contains: '--remote-debugging-port'
    ParentImage|endswith:
      - '.exe'
  filter_cdp_known_parents:
    ParentImage|endswith:
      - '\chrome.exe'
      - '\msedge.exe'
      - '\explorer.exe'
      - '\svchost.exe'

  # Selection C: nss3.dll loaded by non-Mozilla process (Firefox credential decryption)
  selection_nss3_non_firefox:
    ImageLoaded|endswith: '\nss3.dll'
    Image|endswith:
      - '.exe'
  filter_nss3_known_good:
    Image|endswith:
      - '\firefox.exe'
      - '\thunderbird.exe'
      - '\seamonkey.exe'
      - '\waterfox.exe'
      - '\librewolf.exe'
      - '\palemoon.exe'

  condition: >
    (selection_credential_path and (selection_suspicious_parent or selection_suspicious_path)
    and not filter_legitimate_browsers)
    or (selection_cdp_bypass and not filter_cdp_known_parents)
    or (selection_nss3_non_firefox and not filter_nss3_known_good)
falsepositives:
  - Password managers installed in non-standard paths (unlikely for enterprise software)
  - Developer tools or automation scripts legitimately testing browser automation
  - EDR products loading nss3.dll for Firefox credential inspection during on-access scan
  - Browser migration or import tools spawned from cmd.exe by IT staff
  - Software deployment scripts (SCCM/Intune) triggering browser profile operations during setup
level: medium
2 Credential Decryption
Analyst rule
Low FP
▶
Goal
Non-browser process accesses browser credential database AND makes outbound network connection. Complete infostealer execution chain with C2 exfiltration signal.
Log Sources
  • Sysmon Event ID 10 / 11 (File Access)
  • Sysmon Event ID 3 (Network Connection)
  • Windows Security Event ID 4663 + 5156 (File Access + Windows Filtering Platform)
  • EDR network telemetry
  • DNS logs (for C2 domain resolution)
FP Rate
Low
Use Case
SOC alerting; immediate IR escalation; the file-access + outbound-network correlation represents the full "harvest and exfiltrate" chain
Non-browser, non-password-manager process accesses a browser credential database (Login Data, Cookies, logins.json, key4.db) AND within 300 seconds the same process makes an outbound connection to a non-RFC1918 destination on port 80, 443, 8080, or an unusual port. Standalone high-confidence signal: same process accesses Login Data AND Local State in the same session (App-Bound Encryption key combo).
Sigma Rule - Analyst Level
title: Infostealer — Combined Login Data and Local State Access by Non-Browser Process (High Confidence)
id: b8e1369a-dcdd-413a-84a0-b7a953b8ff09
status: experimental
description: >
  Detects a non-browser process accessing both Chrome Login Data and Local State in
  the same session. Combined access has no legitimate use case outside credential theft.
references:
  - https://attack.mitre.org/techniques/T1555/003/
  - https://attack.mitre.org/techniques/T1539/
  - https://security.googleblog.com/2024/07/improving-security-of-chrome-cookies-on.html
  - https://security.googleblog.com/2024/09/improving-security-of-chrome-cookies.html
  - https://cloud.google.com/blog/topics/threat-intelligence/unc5537-snowflake-data-theft-extortion/
  - https://www.cisa.gov/news-events/cybersecurity-advisories/aa25-071a
  - https://blog.sekoia.io/lummac2-stealer-an-in-depth-analysis/
author: "@iimp0ster"
date: 2026/03/08
tags:
  - attack.credential_access
  - attack.t1555.003
  - attack.t1539
  - attack.collection
  - attack.t1005
  - detection.maturity.analyst
logsource:
  category: file_event
  product: windows
detection:
  # NOTE: This rule requires temporal correlation across two file events from the same process.
  # In Sigma, this is expressed as a grouped detection requiring both TargetFilename patterns
  # to appear from the same Image within a session window. SIEM-specific correlation is
  # required for full implementation — see the KQL and SPL queries in the analyst notes below.
  # The single-event approximation (either Login Data OR Local State by non-browser) is
  # captured as selection_combined for platforms that can apply process-grouped detection.

  # Selection A: Access to Login Data (encrypted credential SQLite database)
  selection_login_data:
    TargetFilename|contains:
      - '\Google\Chrome\User Data\Default\Login Data'
      - '\Microsoft\Edge\User Data\Default\Login Data'
      - '\BraveSoftware\Brave-Browser\User Data\Default\Login Data'
      - '\Opera Software\Opera Stable\Login Data'
      - '\Chromium\User Data\Default\Login Data'

  # Selection B: Access to Local State (App-Bound Encryption master key file)
  selection_local_state:
    TargetFilename|contains:
      - '\Google\Chrome\User Data\Local State'
      - '\Microsoft\Edge\User Data\Local State'
      - '\BraveSoftware\Brave-Browser\User Data\Local State'

  # Selection C: COM access to GoogleChromeElevationService by non-updater process
  # (App-Bound Encryption bypass via IElevator::DecryptData — Sept 2024 bypass)
  selection_abe_com_bypass:
    EventID: 4688  # Process creation as COM host
    CommandLine|contains:
      - 'GoogleChromeElevationService'

  # Filter for Selection C: exclude legitimate updater invocations
  # (moved from invalid |not|contains modifier to a proper filter block)
  filter_abe_updater:
    CommandLine|contains:
      - 'GoogleUpdate'
      - 'update'
      - 'install'

  # Selection D: Cross-process memory access to chrome.exe (memory injection bypass — Vidar 2.0)
  selection_chrome_injection:
    EventID: 10  # Sysmon ProcessAccess
    TargetImage|endswith: '\chrome.exe'
    GrantedAccess|contains:
      - '0x1010'   # PROCESS_VM_READ | PROCESS_QUERY_INFORMATION
      - '0x1438'   # PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION | PROCESS_QUERY_INFORMATION
      - '0x143a'

  # Filter for Selection D: exclude known-good processes from injection detection
  # (moved from invalid |not|endswith modifier to a proper filter block)
  filter_chrome_injection_known_good:
    SourceImage|endswith:
      - '\chrome.exe'
      - '\msedge.exe'
      - '\MsMpEng.exe'
      - '\SentinelAgent.exe'
      - '\CSFalconService.exe'

  filter_legitimate_browsers:
    Image|endswith:
      - '\chrome.exe'
      - '\msedge.exe'
      - '\brave.exe'
      - '\firefox.exe'
      - '\opera.exe'
      - '\vivaldi.exe'
      - '\chromium.exe'
      - '\GoogleUpdate.exe'
      - '\MicrosoftEdgeUpdate.exe'
      - '\elevation_service.exe'

  filter_system_processes:
    Image|startswith:
      - 'C:\Windows\System32\'
      - 'C:\Windows\SysWOW64\'
      - 'C:\Program Files\Windows Defender\'

  condition: >
    (selection_login_data and not (filter_legitimate_browsers or filter_system_processes))
    or (selection_local_state and not (filter_legitimate_browsers or filter_system_processes))
    or (selection_abe_com_bypass and not filter_abe_updater)
    or (selection_chrome_injection and not filter_chrome_injection_known_good)
falsepositives:
  - Enterprise password manager products (1Password, Bitwarden for Teams) — these should
    appear in the research baseline allowlist before this rule is deployed
  - Endpoint backup solutions performing AppData backup (Veeam, Acronis) — exclude by
    known backup agent path
  - EDR products performing behavioral analysis on browser credential files — verify by
    confirming the accessing process is signed by the EDR vendor and running from Program Files
  - Chrome's own elevation service (elevation_service.exe) accessing Local State — filtered
    above; if filtering fails, verify Image path is Google's installation directory
level: high
3 Data Exfiltration
Research rule
▶
Goal
Log all non-browser process access to browser credential database files
Log Sources
  • Sysmon Event ID 10 (Process Access)
  • Sysmon Event ID 11 (File Created / File Access)
  • Windows Security Event ID 4663 (File Access; requires Object Access auditing)
  • EDR file open telemetry (CrowdStrike, SentinelOne, Microsoft Defender for Endpoint)
FP Rate
Medium (password managers, backup tools, some AV products)
Use Case
Baseline legitimate access patterns; identify which processes routinely touch browser databases; validate EDR file access telemetry completeness
Any process accessing browser credential paths (Chrome Login Data, Cookies, Local State; Firefox Profiles; Edge Login Data; Brave Login Data) where AccessingProcess is NOT the browser itself (chrome.exe, msedge.exe, brave.exe, firefox.exe, opera.exe, vivaldi.exe) or a browser update process. Run for a week to build the password-manager and backup-tool allowlist.
Sigma Rule - Research Level
title: Infostealer — Non-Browser Process Access to Browser Credential Database (Research Baseline)
id: 632a951f-4e57-4c9f-b1dc-32641904d61f
status: experimental
description: >
  Detects any non-browser process opening browser credential database files (Login Data,
  Cookies, Local State, logins.json). Broad baseline for environmental baselining.
references:
  - https://attack.mitre.org/techniques/T1555/003/
  - https://attack.mitre.org/techniques/T1539/
  - https://www.infostealers.com/article/2026-infostealer-trends-im-monitoring-at-hudson-rock/
  - https://cloud.google.com/blog/topics/threat-intelligence/unc5537-snowflake-data-theft-extortion/
  - https://blog.sekoia.io/lummac2-stealer-an-in-depth-analysis/
author: "@iimp0ster"
date: 2026/03/08
tags:
  - attack.credential_access
  - attack.t1555.003
  - attack.collection
  - attack.t1005
  - detection.maturity.research
logsource:
  category: file_event
  product: windows
detection:
  selection_browser_credential_paths:
    TargetFilename|contains:
      # Chrome credential databases
      - '\Google\Chrome\User Data\Default\Login Data'
      - '\Google\Chrome\User Data\Default\Cookies'
      - '\Google\Chrome\User Data\Local State'
      # Edge credential databases
      - '\Microsoft\Edge\User Data\Default\Login Data'
      - '\Microsoft\Edge\User Data\Default\Cookies'
      - '\Microsoft\Edge\User Data\Local State'
      # Brave credential databases
      - '\BraveSoftware\Brave-Browser\User Data\Default\Login Data'
      - '\BraveSoftware\Brave-Browser\User Data\Default\Cookies'
      # Firefox credential databases
      - '\Mozilla\Firefox\Profiles\'
      # Opera credential databases
      - '\Opera Software\Opera Stable\Login Data'
      - '\Opera Software\Opera Stable\Cookies'
      # Chromium (generic)
      - '\Chromium\User Data\Default\Login Data'
  filter_legitimate_browsers:
    Image|endswith:
      - '\chrome.exe'
      - '\msedge.exe'
      - '\brave.exe'
      - '\firefox.exe'
      - '\opera.exe'
      - '\vivaldi.exe'
      - '\chromium.exe'
      - '\iexplore.exe'
      # Browser update/crash handler processes
      - '\chrome_crashpad_handler.exe'
      - '\crashpad_handler.exe'
      - '\elevation_service.exe'
      - '\GoogleUpdate.exe'
      - '\MicrosoftEdgeUpdate.exe'
  filter_system_paths:
    Image|startswith:
      - 'C:\Windows\System32\'
      - 'C:\Windows\SysWOW64\'
      - 'C:\Program Files\Windows Defender\'
  condition: selection_browser_credential_paths and not (filter_legitimate_browsers or filter_system_paths)
falsepositives:
  - Password managers (1Password, Bitwarden, Dashlane, KeePass, LastPass) accessing browser databases for import/sync
  - Backup software (Veeam, Acronis, Windows Backup) performing file-level backup of AppData
  - Antivirus on-access scanning of AppData files
  - Browser sync utilities and profile migration tools
  - IT asset management tools inventorying installed software and profiles
  - Privacy cleaners (CCleaner, BleachBit) clearing browser history/cookies
level: informational

Prevention

Prevention focuses on blocking the initial code execution that delivers the stealer and enforcing MFA so stolen credentials cannot be replayed. Controlling which browser extensions are permitted removes a harvesting class that bypasses file-access monitoring entirely.

Endpoint

Block execution of binaries downloaded to Temp or Downloads directories

Prevents infostealers from running before they touch credential databases; effective regardless of stealer family or App-Bound Encryption bypass technique.

Identity

Enforce phishing-resistant MFA (FIDO2 / hardware keys) on all sensitive applications

Stolen passwords and session cookies have limited replay value; removes the primary incentive for credential theft campaigns targeting enterprise accounts.

Endpoint · Application Control

Restrict unauthorized browser extensions across your fleet

Eliminates extension-based credential harvesting, which bypasses file-access monitoring entirely and is invisible to most host-based detection telemetry.

Raw Log Samples 5 samples

Detection-relevant event examples. Each card identifies its evidence basis and the Sigma tiers it exercises.

EID 11 Sysmon Non-browser process copies Chrome Login Data to temp directory (credential harvesting) ResearchHunt ▶
EventID: 11 (FileCreate)
UtcTime: 2024-09-14 03:17:42.381
ProcessGuid: {a1b2c3d4-1234-5678-abcd-ef0123456789}
ProcessId: 4832
Image: C:\Users\jsmith\AppData\Local\Temp\ChromeUpdate.exe
TargetFilename: C:\Users\jsmith\AppData\Local\Temp\lg.db
CreationUtcTime: 2024-09-14 03:17:42.381
# Key signal: Non-browser process (ChromeUpdate.exe from Temp) creating a copy # of a browser credential database file. The filename lg.db is a common stealer # convention for Login Data copies.
EID 4663 Windows Event Log Audit file access. Non-browser process reads the Login Data credential database. ResearchAnalyst ▶
EventID: 4663 (An attempt was made to access an object)
TimeCreated: 2024-09-14T03:17:42.5183920Z
Channel: Security

SubjectUserSid: S-1-5-21-3623811015-3361044348-30300820-1013
SubjectUserName: jsmith
SubjectDomainName: CORP
SubjectLogonId: 0x7169cb

ObjectServer: Security
ObjectType: File
ObjectName: C:\Users\jsmith\AppData\Local\Google\Chrome\User Data\Default\Login Data
HandleId: 0x1d4

ProcessId: 0x12e0
ProcessName: C:\Users\jsmith\AppData\Local\Temp\ChromeUpdate.exe

AccessList: %%4416 (ReadData / ListDirectory)
AccessMask: 0x1
EID 11 Sysmon Stealer copies Login Data to TEMP directory to avoid Chrome file lock ResearchAnalyst ▶
EventID: 11 (FileCreate)
UtcTime: 2024-09-14 03:17:42.612
ProcessGuid: {a1b2c3d4-1234-5678-abcd-ef0123456789}
ProcessId: 4832
Image: C:\Users\jsmith\AppData\Local\Temp\ChromeUpdate.exe
TargetFilename: C:\Users\jsmith\AppData\Local\Temp\~tmp_creds_8a3f.db
CreationUtcTime: 2024-09-14 03:17:42.612
EID 8 Sysmon CryptUnprotectData API call observed via Sysmon API monitoring. DPAPI decryption of harvested credentials. Hunt ▶
EventID: 8 (CreateRemoteThread), or via API monitoring:
UtcTime: 2024-09-14 03:17:43.108
ProcessGuid: {a1b2c3d4-1234-5678-abcd-ef0123456789}
ProcessId: 4832
Image: C:\Users\jsmith\AppData\Local\Temp\ChromeUpdate.exe
API: CryptUnprotectData
Module: C:\Windows\System32\crypt32.dll
# Note: CryptUnprotectData is called seconds after Login Data file access.
# Temporal correlation (EID 10 + CryptUnprotectData within 60s) is the Hunt rule signal.
EID 3 Sysmon Outbound C2 exfiltration connection immediately following credential decryption Analyst ▶
EventID: 3 (NetworkConnect)
UtcTime: 2024-09-14 03:17:44.883
ProcessGuid: {a1b2c3d4-1234-5678-abcd-ef0123456789}
ProcessId: 4832
Image: C:\Users\jsmith\AppData\Local\Temp\ChromeUpdate.exe
User: CORP\jsmith
Protocol: tcp
Initiated: true
SourceIsIpv6: false
SourceIp: 10.10.1.45
SourceHostname: CORP-WS-042
SourcePort: 51342
DestinationIsIpv6: false
DestinationIp: 185.220.101.47
DestinationHostname: -
DestinationPort: 443
# Non-browser process making HTTPS connection within seconds of credential DB access
# is the Analyst rule's final signal. High confidence, low FP.

Emulation

ATT&CK: T1555.003 Simulates infostealer browser credential access patterns for detection validation powershell ▶
⚠ Lab use only. Run in an isolated lab VM only. Creates temporary files and outbound network activity.
POWERSHELL
#Requires -Version 5.1
# MITRE ATT&CK: T1555.003 — Credentials from Web Browsers
# Simulates non-browser process access to Chrome Login Data, DPAPI decryption call, and outbound connection.

[CmdletBinding()]
param(
    [switch]$SkipNetwork,
    [switch]$CleanupOnly
)

Set-StrictMode -Version Latest
$ErrorActionPreference = 'Stop'

$ChromeLoginDataPath = Join-Path $env:LOCALAPPDATA `
    'Google\Chrome\User Data\Default\Login Data'
$TempCopy   = Join-Path $env:TEMP "~cred_emu_$(Get-Random).db"
$C2Endpoint = 'https://example.com'   # benign destination — change to your lab listener

function Write-Step ([string]$Message) {
    Write-Host "[*] $Message" -ForegroundColor Cyan
}
function Write-Ok ([string]$Message) {
    Write-Host "[+] $Message" -ForegroundColor Green
}
function Write-Warn ([string]$Message) {
    Write-Host "[!] $Message" -ForegroundColor Yellow
}

function Remove-Artefacts {
    if (Test-Path $TempCopy) {
        Remove-Item -Path $TempCopy -Force -ErrorAction SilentlyContinue
        Write-Ok "Removed temp file: $TempCopy"
    }
}

if ($CleanupOnly) {
    Remove-Artefacts
    exit 0
}

Write-Host ""
Write-Host "=== Browser Credential Theft Emulation ===" -ForegroundColor Magenta
Write-Host "    T1555.003 | Detection Chokepoints Project" -ForegroundColor DarkGray
Write-Host ""

if (-not (Test-Path $ChromeLoginDataPath)) {
    Write-Warn "Chrome Login Data not found at: $ChromeLoginDataPath"
    Write-Warn "Chrome must be installed and have been launched at least once."
    Write-Warn "Falling back to synthetic file for file-access telemetry only."
    $ChromeLoginDataPath = $null
}

Write-Step "Step 1/3 — Opening browser credential store (file access telemetry)"
Write-Verbose "  Target: $ChromeLoginDataPath"

if ($ChromeLoginDataPath) {
    try {
        # Open the file read-only to trigger file-access audit events.
        # Chrome locks Login Data while running; we copy first (also an Analyst indicator).
        $fs = [System.IO.File]::Open(
            $ChromeLoginDataPath,
            [System.IO.FileMode]::Open,
            [System.IO.FileAccess]::Read,
            [System.IO.FileShare]::ReadWrite
        )
        $buf = New-Object byte[] 4
        [void]$fs.Read($buf, 0, 4)   # read SQLite magic bytes only — no credential parsing
        $fs.Close()
        Write-Ok "File access completed (read 4 bytes — SQLite header only, no credentials parsed)"
    }
    catch [System.IO.IOException] {
        # Chrome is running and has an exclusive lock — copy approach instead
        Write-Warn "Chrome is running (file locked). Using file copy to trigger EID 11."
        Copy-Item -Path $ChromeLoginDataPath -Destination $TempCopy -ErrorAction SilentlyContinue
        Write-Ok "Copied Login Data to: $TempCopy"
    }
} else {
    # Synthetic fallback: create a dummy file in TEMP to generate EID 11
    [System.IO.File]::WriteAllText($TempCopy, "SQLite format 3`0")
    Write-Ok "Created synthetic credential file at: $TempCopy"
}

Start-Sleep -Milliseconds 500

Write-Step "Step 2/3 — Calling CryptUnprotectData (DPAPI decryption telemetry)"

Add-Type -TypeDefinition @'
using System;
using System.Runtime.InteropServices;
using System.Text;

public class Dpapi {
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct DATA_BLOB {
        public int cbData;
        public IntPtr pbData;
    }

    [DllImport("crypt32.dll", SetLastError = true, CharSet = CharSet.Auto)]
    public static extern bool CryptUnprotectData(
        ref DATA_BLOB pDataIn,
        StringBuilder szDataDescr,
        IntPtr pOptionalEntropy,
        IntPtr pvReserved,
        IntPtr pPromptStruct,
        int dwFlags,
        ref DATA_BLOB pDataOut);

    public static bool TestDpapi() {
        // Encrypt a benign string, then decrypt — exercises the CryptUnprotectData API path
        byte[] plain = Encoding.UTF8.GetBytes("detection-chokepoints-emulation-test");
        byte[] encrypted = System.Security.Cryptography.ProtectedData.Protect(
            plain, null, System.Security.Cryptography.DataProtectionScope.CurrentUser);

        DATA_BLOB inBlob  = new DATA_BLOB();
        DATA_BLOB outBlob = new DATA_BLOB();
        inBlob.cbData = encrypted.Length;
        inBlob.pbData = Marshal.AllocHGlobal(encrypted.Length);
        Marshal.Copy(encrypted, 0, inBlob.pbData, encrypted.Length);

        bool result = CryptUnprotectData(ref inBlob, null, IntPtr.Zero,
                                          IntPtr.Zero, IntPtr.Zero, 0, ref outBlob);
        Marshal.FreeHGlobal(inBlob.pbData);
        if (result) Marshal.FreeHGlobal(outBlob.pbData);
        return result;
    }
}
'@ -ReferencedAssemblies 'System.Security'

try {
    $result = [Dpapi]::TestDpapi()
    if ($result) {
        Write-Ok "CryptUnprotectData called successfully (benign test data decrypted)"
    } else {
        Write-Warn "CryptUnprotectData returned false — API monitoring telemetry may still fire"
    }
} catch {
    Write-Warn "DPAPI call skipped: $_"
}

Start-Sleep -Milliseconds 500

if (-not $SkipNetwork) {
    Write-Step "Step 3/3 — Making outbound connection (network exfiltration telemetry)"
    Write-Verbose "  Destination: $C2Endpoint"

    try {
        $response = Invoke-WebRequest -Uri $C2Endpoint -Method HEAD `
            -TimeoutSec 10 -UseBasicParsing -ErrorAction Stop
        Write-Ok "Network connection completed (HTTP $($response.StatusCode) from $C2Endpoint)"
    } catch {
        Write-Warn "Network request failed (connection telemetry may still have been generated): $_"
    }
} else {
    Write-Warn "Step 3 skipped (-SkipNetwork flag set)"
}

Write-Host ""
Write-Step "Cleaning up artefacts"
Remove-Artefacts

Write-Host ""
Write-Host "=== Emulation Complete ===" -ForegroundColor Magenta
Write-Host ""
Write-Host "Expected detections:" -ForegroundColor White
Write-Host "  [Research]  Sysmon EID 10/11 or WEL EID 4663 — non-browser file access" -ForegroundColor DarkCyan
Write-Host "  [Hunt]      EID 10 + CryptUnprotectData within 60 seconds"               -ForegroundColor DarkYellow
Write-Host "  [Analyst]   EID 10/11 + Sysmon EID 3 (outbound connection)"              -ForegroundColor DarkGreen
Write-Host ""
Write-Host "If no alerts fired, verify:" -ForegroundColor DarkGray
Write-Host "  - Sysmon is running with a config that captures EID 3/8/10/11"
Write-Host "  - Object Access auditing is enabled (auditpol) for EID 4663"
Write-Host "  - Sigma rules are deployed and log sources are ingested"
Write-Host ""

OSINT Pivots