Blog
/
/
January 9, 2019

Insider Analysis of Emotet Malware

Uncover the secrets of Emotet with our latest Darktrace expert analysis. Learn how to identify and understand trojan horse attacks.
Inside the SOC
Darktrace cyber analysts are world-class experts in threat intelligence, threat hunting and incident response, and provide 24/7 SOC support to thousands of Darktrace customers around the globe. Inside the SOC is exclusively authored by these experts, providing analysis of cyber incidents and threat trends, based on real-world experience in the field.
Written by
Max Heinemeyer
Global Field CISO
Default blog imageDefault blog imageDefault blog imageDefault blog imageDefault blog imageDefault blog image
09
Jan 2019

While both traditional security tools and the attacks against them continue to improve, advanced cyber-criminals are increasingly exploiting the weakness inherent to any organization’s security posture: its employees. Designed to mislead such employees into compromising their devices, computer trojans are now rapidly on the rise. In 2018, Darktrace detected a 239% year-on-year uptick in incidents related specifically to banking trojans, which use deception to harvest the credentials of online banking customers from infected machines. And one banking trojan in particular, Emotet, is among the costliest and most destructive malware variants currently imperilling governments and companies worldwide.

Emotet is a highly sophisticated malware with a modular architecture, installing its main component first before delivering additional payloads. Further increasing its subtlety is the fact that Emotet is considered to be ‘polymorphic malware’, since it constantly changes its identifiable features to evade detection by antivirus products. And, as will be subsequently discussed in greater detail, Emotet has advanced persistence techniques and worm-like self-propagation abilities, which render it uniquely resilient and dangerous.

Since its launch in 2014, Emotet has been adapted and repurposed on numerous occasions as its targets have diversified. Initially, Emotet’s primary victims were German banks, from which the malware was designed to steal financial information by intercepting network traffic. By this past year’s end, Emotet had spread far and wide while shifting focus to U.S. targets, resulting in permanently lost files, costly business interruptions, and serious reputational harm.

How Emotet works

(Image courtesy of US-CERT)

Emotet is spread by targeting Windows-based systems via sophisticated phishing campaigns, employing social engineering techniques to fool users into believing that the malware-laden emails are legitimate. For instance, the latest versions of Emotet were delivered by way of Thanksgiving-related emails, which invited their American recipients to open an apparently innocuous Thanksgiving card:

These emails contain Microsoft Word documents that are either linked or attached directly. The Word files, in turn, act as vectors for malicious macros, which must be explicitly enabled by the user to be executed. For security reasons, running macros by default is disabled in most of the latest Microsoft application versions, meaning that the cyber-criminals responsible must resort to tricking users in order to enable them — in this case, by enticing them with the Thanksgiving card.

Once the macros are enabled, the Word file is executed and a PowerShell command is activated to retrieve the main Emotet component from compromised servers. The trojan payload is then downloaded and executed into the victim’s system. As mentioned above, Emotet payloads are polymorphic, often allowing them to slip past conventional security tools undetected.

How Emotet persists and propagates

Once Emotet has been executed on the victim’s device, it begins deploying itself with two main objectives: (1) achieving persistence and (2) spreading to more machines. To achieve the first aim, which involves resisting a reboot and various attempts at removal, Emotet does the following:

  • Creates scheduled tasks and registry key entries, ensuring its automatic execution during every system start-up.
  • Registers itself by creating files that have randomly generated names in system root directories, which are run as Windows services.
  • Typically stores payloads in paths located off AppData\Local and AppData\Roaming directories that it masks with names that appear legitimate, such as ‘flashplayer.exe’.

Emotet’s second key goal is that of spreading across local networks and beyond in order to infect as many machines as possible. To this end, Emotet first gathers information on both the victim’s system itself and the operating system it uses. Following this reconnaissance stage, it establishes encrypted command and control communications (C2) with its parent infrastructure before determining which payloads it will deliver. After reporting a new infection, Emotet downloads modules from the C2 servers, including:

  • WebBrowserPassView: A tool that steals passwords from most common web browsers like Chrome, Safari, Firefox and Internet Explorer.
  • NetPass.exe: A legitimate tool that recovers all the network passwords stored on the system for the current logged-on user.
  • MailPassView: A tool that reveals passwords and account details for popular email clients, such as Hotmail, Gmail, Microsoft Outlook, and Yahoo! Mail.
  • Outlook PST scraper: A module that searches Outlook’s messages to obtain names and email addresses from the victim’s Outlook account.
  • Credential enumerator: A module that enumerates network resources and attempts to gain access to other machines via SMB enumeration and brute-forcing connections.
  • Banking trojans: These include Dridex, IceID, Zeus Panda, Trickbot and Qakbot, all of which harvest banking account information via browser monitoring routines.

Whilst the WebBrowserPassView, NetPass.exe and MailPassView modules are able to steal the compromised user’s credentials, the PST scraper module can ransack the user’s contact list of friends, family members, colleagues and clients, enabling Emotet to self-propagate by sending phishing emails to those contacts. And because such emails are sent from the hijacked accounts of known acquaintances and loved ones, their recipients are more likely to open their infected attachments and links.

Emotet’s other self-propagation method is via brute-forcing credentials using various password lists, with the intent of gaining access to other machines within the network. When unsuccessful, the malware’s repeated failed login attempts can cause users to become locked out of their accounts, and when successful, the victims may become infected without even clicking on a malicious link or attachment. These tactics have collectively made Emotet remarkably durable and widespread. Indeed, in line with Darktrace’s discovery that incidents related to banking trojans have increased by 239% from 2017 to 2018, Emotet alone recorded a 39% increase, and the worst may be yet to come.

How AI fights back

Emotet presents significant challenges for traditional security tools, both because it exploits the ubiquitous vulnerability of human error, and because it is designed specifically to bypass endpoint solutions. Yet unlike such traditional tools, Darktrace leverages unsupervised machine learning algorithms to detect cyber-threats that have already infiltrated the network. Modelled after the human immune system, Darktrace AI works by learning the individual ‘pattern of life’ of every user, device, and network that it safeguards. From this ever-evolving sense of ‘self,’ Darktrace can differentiate between normal and anomalous behavior, allowing it to identify cyber-attacks in much the same way that our immune system spots harmful germs.

Recently, Darktrace’s AI models managed to detect a machine on a clients’ network that was experiencing active signs of an Emotet infection. The device was observed downloading a suspicious file and, shortly thereafter, began beaconing to a rare external destination, likely reporting the infection to a C2 server.

The device was then observed moving laterally across the network by performing brute force activities. In fact, Darktrace detected thousands of Kerberos failed logins, including to administrative accounts, as well as multiple SMB session failures that used a range of common usernames, such as ‘admin’ and ‘exchange’. Below is a graph showing the SMB and Kerberos brute-force activity on the breached device:

In addition to the brute-forcing activity performed by the credential enumerator module, Darktrace also detected another payload that was potentially functioning as an email spammer. The infected machine started to make a high number of outgoing connections over common email ports. This activity is consistent with Emotet’s typical spreading behavior, which revolves around sending emails to the victim’s hijacked email contacts. Below is an image of Darktrace models breached during the reported Emotet infection:

By forming a comprehensive understanding of normalcy, Darktrace can flag even the most minute anomalies in real time, thwarting subtle threats like Emotet that have already circumvented the network perimeter. To counter such advanced banking trojans, cyber AI defenses like Darktrace have become an organizational necessity.

Inside the SOC
Darktrace cyber analysts are world-class experts in threat intelligence, threat hunting and incident response, and provide 24/7 SOC support to thousands of Darktrace customers around the globe. Inside the SOC is exclusively authored by these experts, providing analysis of cyber incidents and threat trends, based on real-world experience in the field.
Written by
Max Heinemeyer
Global Field CISO

More in this series

No items found.

Blog

/

Network

/

May 28, 2025

PumaBot: Novel Botnet Targeting IoT Surveillance Devices

password login screen on computerDefault blog imageDefault blog image

Introduction: PumaBot attacking IoT devices

Darktrace researchers have identified a custom Go-based Linux botnet named “PumaBot” targeting embedded Linux Internet of Things (IoT) devices. Rather than scanning the Internet, the malware retrieves a list of targets from a command-and-control (C2) server and attempts to brute-force SSH credentials. Upon gaining access, it receives remote commands and establishes persistence using system service files. This blog post provides a breakdown of its key functionalities, and explores binaries related to the campaign.

Technical Analysis

Filename: jierui

md5: cab6f908f4dedcdaedcdd07fdc0a8e38

The Go-based botnet gains initial access through brute-forcing SSH credentials across a list of harvested IP addresses. Once it identifies a valid credential pair, it logs in, deploys itself, and begins its replication process.

Overview of Jierui functions
Figure 1: Overview of Jierui functions.

The domain associated with the C2 server did not resolve to an IP address at the time of analysis. The following details are a result of static analysis of the malware.

The malware begins by retrieving a list of IP addresses of likely devices with open SSH ports from the C2 server (ssh.ddos-cc[.]org) via the getIPs() function. It then performs brute-force login attempts on port 22 using credential pairs also obtained from the C2 through the readLinesFromURL(), brute(), and trySSHLogin() functions.

Within trySSHLogin(), the malware performs several environment fingerprinting checks. These are used to avoid honeypots and unsuitable execution environments, such as restricted shells. Notably, the malware checks for the presence of the string “Pumatronix”, a manufacturer of surveillance and traffic camera systems, suggesting potential IoT targeting or an effort to evade specific devices [1].

Fingerprinting of “Pumatronix”.
Figure 2: Fingerprinting of “Pumatronix”.

If the environment passes these checks, the malware executes uname -a to collect basic system information, including the OS name, kernel version, and architecture. This data, along with the victim's IP address, port, username, and password, is then reported back to the C2 in a JSON payload.

Of note, the bot uses X-API-KEY: jieruidashabi, within a custom header when it communicates with the C2 server over HTTP.

The malware writes itself to /lib/redis, attempting to disguise itself as a legitimate Redis system file. It then creates a persistent systemd service in /etc/systemd/system, named either redis.service or mysqI.service (note the spelling of mysql with a capital I) depending on what has been hardcoded into the malware. This allows the malware to persist across reboots while appearing benign.

[Unit]
Description=redis Server Service

[Service]
Type=simple
Restart=always
RestartSec=1
User=root
ExecStart=/lib/redis e

[Install]
WantedBy=multi-user.target

In addition to gaining persistence with a systemd service, the malware also adds its own SSH keys into the users’ authorized_keys file. This ensures that access can be maintained, even if the service is removed.

A function named cleankill() contains an infinite loop that repeatedly attempts to execute the commands “xmrig” and “networkxm”. These are launched without full paths, relying on the system's PATH variable suggesting that the binaries may be downloaded or unpacked elsewhere on the system. The use of “time.Sleep” between attempts indicates this loop is designed to ensure persistence and possibly restart mining components if they are killed or missing.

During analysis of the botnet, Darktrace discovered related binaries that appear to be part of a wider campaign targeting Linux systems.

Filename: ddaemon
Md5: 48ee40c40fa320d5d5f8fc0359aa96f3

Ddaemon is a Go-based backdoor. The malware begins by parsing command line arguments and if conditions are met, enters a loop where it periodically verifies the MD5 hash of the binary. If the check fails or an update is available, it downloads a new version from a C2 server (db.17kp[.]xyz/getDdaemonMd5), verifies it and replaces the existing binary with a file of the same name and similar functionality (8b37d3a479d1921580981f325f13780c).

The malware uses main_downloadNetwork() to retrieve the binary “networkxm” into /usr/src/bao/networkxm. Additionally, the bash script “installx.sh” is also retrieved from the C2 and executed. The binary ensures persistence by writing a custom systemd service unit that auto starts on boot and executes ddaemon.

Filename: networkxm
Md5: be83729e943d8d0a35665f55358bdf88

The networkxm binary functions as an SSH brute-force tool, similar to the botnet. First it checks its own integrity using MD5 hashes and contacts the C2 server (db.17kp[.]xyz) to compare its hash with the latest version. If an update is found, it downloads and replaces itself.

Part of networkxm checking MD5 hash.
Figure 3: Part of networkxm checking MD5 hash.
MD5 hash
Figure 4: MD5 hash

After verifying its validity, it enters an infinite loop where it fetches a password list from the C2 (/getPassword), then attempts SSH connections across a list of target IPs from the /getIP endpoint. As with the other observed binaries, a systemd service is created if it doesn’t already exist for persistence in /etc/systemd/system/networkxm.service.

Bash script installx.sh.
Figure 5: Bash script installx.sh.

Installx.sh is a simple bash script used to retrieve the script “jc.sh” from 1.lusyn[.]xyz, set permissions, execute and clear bash history.

Figure 6: Snippet of bash script jc.sh.

The script jc.sh starts by detecting the operating system type Debian-based or Red Hat-based and determines the location of the pam_unix.so file. Linux Pluggable Authentication Modules (PAM) is a framework that allows for flexible and centralized user authentication on Linux systems. PAM allows system administrators to configure how users are authenticated for services like login, SSH, or sudo by plugging in various authentication modules.

Jc.sh then attempts to fetch the current version of PAM installed on the system and formats that version to construct a URL. Using either curl or wget, the script downloads a replacement pam_unix.so file from a remote server and replaces the existing one, after disabling file immutability and backing up the original.

The script also downloads and executes an additional binary named “1” from the same remote server. Security settings are modified including enabling PAM in the SSH configuration and disabling SELinux enforcement, before restarting the SSH service. Finally, the script removes itself from the system.

Filename: Pam_unix.so_v131
md5: 1bd6bcd480463b6137179bc703f49545

Based on the PAM version that is retrieved from the bash query, the new malicious PAM replaces the existing PAM file. In this instance, pam_unix.so_v131 was retrieved from the server based on version 1.3.1. The purpose of this binary is to act as a rootkit that steals credentials by intercepting successful logins. Login data can include all accounts authenticated by PAM, local and remote (SSH). The malware retrieves the logged in user, the password and verifies that the password is valid. The details are stored in a file “con.txt” in /usr/bin/.

Function storing logins to con.txt
Figure 7: Function storing logins to con.txt

Filename: 1

md5: cb4011921894195bcffcdf4edce97135

In addition to the malicious PAM file, a binary named “1” is also retrieved from the server http://dasfsdfsdfsdfasfgbczxxc[.]lusyn[.]xyz/jc/1. The binary “1” is used as a watcher for the malicious PAM file using inotify to monitor for “con.txt” being written or moved to /usr/bin/.

Following the daemonize() function, the binary is run daemonized ensuring it runs silently in the background. The function read_and_send_files() is called which reads the contents of “/usr/bin/con.txt”, queries the system IP with ifconfig.me, queries SSH ports and sends the data to the remote C2 (http://dasfsdfsdfsdfasfgbczxxc[.]lusyn[.]xyz/api/).

Command querying SSH ports.
Figure 8: Command querying SSH ports.

For persistence, a systemd service (my_daemon.service) is created to autostart the binary and ensure it restarts if the service has been terminated. Finally, con.txt is deleted, presumably to remove traces of the malware.

Conclusion

The botnet represents a persistent Go-based SSH threat that leverages automation, credential brute-forcing, and native Linux tools to gain and maintain control over compromised systems. By mimicking legitimate binaries (e.g., Redis), abusing systemd for persistence, and embedding fingerprinting logic to avoid detection in honeypots or restricted environments, it demonstrates an intent to evade defenses.

While it does not appear to propagate automatically like a traditional worm, it does maintain worm-like behavior by brute-forcing targets, suggesting a semi-automated botnet campaign focused on device compromise and long-term access.

Recommendations

  1. Monitor for anomalous SSH login activity, especially failed login attempts across a wide IP range, which may indicate brute-force attempts.
  2. Audit systemd services regularly. Look for suspicious entries in /etc/systemd/system/ (e.g., misspelled or duplicate services like mysqI.service) and binaries placed in non-standard locations such as /lib/redis.
  3. Inspect authorized_keys files across user accounts for unknown SSH keys that may enable unauthorized access.
  4. Filter or alert on outbound HTTP requests with non-standard headers, such as X-API-KEY: jieruidashabi, which may indicate botnet C2 communication.
  5. Apply strict firewall rules to limit SSH exposure rather than exposing port 22 to the internet.

Appendices

References

1.     https://pumatronix.com/

Indicators of Compromise (IoCs)

Hashes

cab6f908f4dedcdaedcdd07fdc0a8e38 - jierui

a9412371dc9247aa50ab3a9425b3e8ba - bao

0e455e06315b9184d2e64dd220491f7e - networkxm

cb4011921894195bcffcdf4edce97135 - 1
48ee40c40fa320d5d5f8fc0359aa96f3 - ddaemon
1bd6bcd480463b6137179bc703f49545 - pam_unix.so_v131

RSA Key

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC0tH30Li6Gduh0Jq5A5dO5rkWTsQlFttoWzPFnGnuGmuF+fwIfYvQN1z+WymKQmX0ogZdy/CEkki3swrkq29K/xsyQQclNm8+xgI8BJdEgTVDHqcvDyJv5D97cU7Bg1OL5ZsGLBwPjTo9huPE8TAkxCwOGBvWIKUE3SLZW3ap4ciR9m4ueQc7EmijPHy5qds/Fls+XN8uZWuz1e7mzTs0Pv1x2CtjWMR/NF7lQhdi4ek4ZAzj9t/2aRvLuNFlH+BQx+1kw+xzf2q74oBlGEoWVZP55bBicQ8tbBKSN03CZ/QF+JU81Ifb9hy2irBxZOkyLN20oSmWaMJIpBIsh4Pe9 @root

Network

http://ssh[.]ddos-cc.org:55554

http://ssh[.]ddos-cc.org:55554/log_success

http://ssh[.]ddos-cc.org:55554/get_cmd

http://ssh[.]ddos-cc.org:55554/pwd.txt

https://dow[.]17kp.xyz/

https://input[.]17kp.xyz/

https://db[.]17kp[.]xyz/

http://1[.]lusyn[.]xyz

http://1[.]lusyn[.]xyz/jc/1

http://1[.]lusyn[.]xyz/jc/jc.sh

http://1[.]lusyn[.]xyz/jc/aa

http://1[.]lusyn[.]xyz/jc/cs

http://dasfsdfsdfsdfasfgbczxxc[.]lusyn[.]xyz/api

http://dasfsdfsdfsdfasfgbczxxc[.]lusyn[.]xyz/jc

Detection Rule

rule Linux_PumaBot

{

  meta:

      description = "Rule to match on PumaBot samples"

      author = "tgould@cadosecurity.com"

  strings:

      $xapikey = "X-API-KEY" ascii

      $get_ips = "?count=5000" ascii

      $exec_start = "ExecStart=/lib/redis" ascii

      $svc_name1 = "redis.service" ascii

      $svc_name2 = "mysqI.service" ascii

      $uname = "uname -a" ascii

      $pumatronix = "Pumatronix" ascii

  condition:

      uint32(0) == 0x464c457f and

      all of (

          $xapikey,

          $uname,

          $get_ips,

          $exec_start

      ) and any of (

          $svc_name1,

          $svc_name2

      ) and $pumatronix

}

Continue reading
About the author
Tara Gould
Threat Researcher

Blog

/

Identity

/

May 27, 2025

From Rockstar2FA to FlowerStorm: Investigating a Blooming Phishing-as-a-Service Platform

man on computerDefault blog imageDefault blog image

What is FlowerStorm?

FlowerStorm is a Phishing-as-a-Service (PhaaS) platform believed to have gained traction following the decline of the former PhaaS platform Rockstar2FA. It employs Adversary-in-the-Middle (AitM) attacks to target Microsoft 365 credentials. After Rockstar2FA appeared to go dormant, similar PhaaS portals began to emerge under the name FlowerStorm. This naming is likely linked to the plant-themed terminology found in the HTML titles of its phishing pages, such as 'Sprout' and 'Blossom'. Given the abrupt disappearance of Rockstar2FA and the near-immediate rise of FlowerStorm, it is possible that the operators rebranded to reduce exposure [1].

External researchers identified several similarities between Rockstar2FA and FlowerStorm, suggesting a shared operational overlap. Both use fake login pages, typically spoofing Microsoft, to steal credentials and multi-factor authentication (MFA) tokens, with backend infrastructure hosted on .ru and .com domains. Their phishing kits use very similar HTML structures, including randomized comments, Cloudflare turnstile elements, and fake security prompts. Despite Rockstar2FA typically being known for using automotive themes in their HTML titles, while FlowerStorm shifted to a more botanical theme, the overall design remained consistent [1].

Despite these stylistic differences, both platforms use similar credential capture methods and support MFA bypass. Their domain registration patterns and synchronized activity spikes through late 2024 suggest shared tooling or coordination [1].

FlowerStorm, like Rockstar2FA, also uses their phishing portal to mimic legitimate login pages such as Microsoft 365 for the purpose of stealing credentials and MFA tokens while the portals are relying heavily on backend servers using top-level domains (TLDs) such as .ru, .moscow, and .com. Starting in June 2024, some of the phishing pages began utilizing Cloudflare services with domains such as pages[.]dev. Additionally, usage of the file “next.php” is used to communicate with their backend servers for exfiltration and data communication. FlowerStorm’s platform focuses on credential harvesting using fields such as email, pass, and session tracking tokens in addition to supporting email validation and MFA authentications via their backend systems [1].

Darktrace’s coverage of FlowerStorm Microsoft phishing

While multiple suspected instances of the FlowerStorm PhaaS platform were identified during Darktrace’s investigation, this blog will focus on a specific case from March 2025. Darktrace’s Threat Research team analyzed the affected customer environment and discovered that threat actors were accessing a Software-as-a-Service (SaaS) account from several rare external IP addresses and ASNs.

Around a week before the first indicators of FlowerStorm were observed, Darktrace detected anomalous logins via Microsoft Office 365 products, including Office365 Shell WCSS-Client and Microsoft PowerApps.  Although not confirmed in this instance, Microsoft PowerApps could potentially be leveraged by attackers to create phishing applications or exploit vulnerabilities in data connections [2].

Darktrace’s detection of the unusual SaaS credential use.
Figure 1: Darktrace’s detection of the unusual SaaS credential use.

Following this initial login, Darktrace observed subsequent login activity from the rare source IP, 69.49.230[.]198. Multiple open-source intelligence (OSINT) sources have since associated this IP with the FlowerStorm PhaaS operation [3][4].  Darktrace then observed the SaaS user resetting the password on the Core Directory of the Azure Active Directory using the user agent, O365AdminPortal.

Given FlowerStorm’s known use of AitM attacks targeting Microsoft 365 credentials, it seems highly likely that this activity represents an attacker who previously harvested credentials and is now attempting to escalate their privileges within the target network.

Darktrace / IDENTITY’s detection of privilege escalation on a compromised SaaS account, highlighting unusual login activity and a password reset event.
Figure 2: Darktrace / IDENTITY’s detection of privilege escalation on a compromised SaaS account, highlighting unusual login activity and a password reset event.

Notably, Darktrace’s Cyber AI Analyst also detected anomalies during a number of these login attempts, which is significant given FlowerStorm’s known capability to bypass MFA and steal session tokens.

Cyber AI Analyst’s detection of new login behavior for the SaaS user, including abnormal MFA usage.
Figure 3: Cyber AI Analyst’s detection of new login behavior for the SaaS user, including abnormal MFA usage.
Multiple login and failed login events were observed from the anomalous source IP over the month prior, as seen in Darktrace’s Advanced Search.
Figure 4: Multiple login and failed login events were observed from the anomalous source IP over the month prior, as seen in Darktrace’s Advanced Search.

In response to the suspicious SaaS activity, Darktrace recommended several Autonomous Response actions to contain the threat. These included blocking the user from making further connections to the unusual IP address 69.49.230[.]198 and disabling the user account to prevent any additional malicious activity. In this instance, Darktrace’s Autonomous Response was configured in Human Confirmation mode, requiring manual approval from the customer’s security team before any mitigative actions could be applied. Had the system been configured for full autonomous response, it would have immediately blocked the suspicious connections and disabled any users deviating from their expected behavior—significantly reducing the window of opportunity for attackers.

Figure 5: Autonomous Response Actions recommended on this account behavior; This would result in disabling the user and blocking further sign-in activity from the source IP.

Conclusion

The FlowerStorm platform, along with its predecessor, RockStar2FA is a PhaaS platform known to leverage AitM attacks to steal user credentials and bypass MFA, with threat actors adopting increasingly sophisticated toolkits and techniques to carry out their attacks.

In this incident observed within a Darktrace customer's SaaS environment, Darktrace detected suspicious login activity involving abnormal VPN usage from a previously unseen IP address, which was subsequently linked to the FlowerStorm PhaaS platform. The subsequent activity, specifically a password reset, was deemed highly suspicious and likely indicative of an attacker having obtained SaaS credentials through a prior credential harvesting attack.

Darktrace’s prompt detection of these SaaS anomalies and timely notifications from its Security Operations Centre (SOC) enabled the customer to mitigate and remediate the threat before attackers could escalate privileges and advance the attack, effectively shutting it down in its early stages.

Credit to Justin Torres (Senior Cyber Analyst), Vivek Rajan (Cyber Analyst), Ryan Traill (Analyst Content Lead)

Appendices

Darktrace Model Alert Detections

·      SaaS / Access / M365 High Risk Level Login

·      SaaS / Access / Unusual External Source for SaaS Credential Use

·      SaaS / Compromise / Login from Rare High-Risk Endpoint

·      SaaS / Compromise / SaaS Anomaly Following Anomalous Login

·      SaaS / Compromise / Unusual Login and Account Update

·      SaaS / Unusual Activity / Unusual MFA Auth and SaaS Activity

Cyber AI Analyst Coverage

·      Suspicious Access of Azure Active Directory  

·      Suspicious Access of Azure Active Directory  

List of Indicators of Compromise (IoCs)

IoC - Type - Description + Confidence

69.49.230[.]198 – Source IP – Malicious IP Associated with FlowerStorm, Observed in Login Activity

MITRE ATT&CK Mapping

Tactic – Technique – Sub-Technique  

Cloud Accounts - DEFENSE EVASION, PERSISTENCE, PRIVILEGE ESCALATION, INITIAL ACCESS - T1078.004 - T1078

Cloud Service Dashboard - DISCOVERY - T1538

Compromise Accounts - RESOURCE DEVELOPMENT - T1586

Steal Web Session Cookie - CREDENTIAL ACCESS - T1539

References:

[1] https://news.sophos.com/en-us/2024/12/19/phishing-platform-rockstar-2fa-trips-and-flowerstorm-picks-up-the-pieces/

[2] https://learn.microsoft.com/en-us/security/operations/incident-response-playbook-compromised-malicious-app

[3] https://www.virustotal.com/gui/ip-address/69.49.230.198/community

[4] https://otx.alienvault.com/indicator/ip/69.49.230.198

Continue reading
About the author
Justin Torres
Cyber Analyst
Your data. Our AI.
Elevate your network security with Darktrace AI