A Little Curiosity, a Lot of Logs
Cybersecurity is one of those fields where the learning never really stops. Technology changes, attackers change their methods, and defenders have to keep finding new ways to stay one step ahead. That constant evolution is a big part of what drew me to the field in the first place.
My name is Bryce Croop, and I enjoy the problem-solving side of cybersecurity. I like digging into something unfamiliar, figuring out how the pieces fit together, and working through a challenge until everything finally clicks. There is something especially satisfying about that “AHA!” moment when a confusing problem suddenly makes sense. It is a little like solving a puzzle, except sometimes the puzzle is hiding in a Windows event log.
For this bootcamp project, I wanted to get some hands-on experience with a Security Information and Event Management (SIEM) platform called Wazuh. The goal was to add a new Windows endpoint to an existing Wazuh monitoring environment and then run controlled security experiments to see whether the SIEM was properly collecting the activity and identifying events that could indicate malicious behavior.
I quickly learned that installing a monitoring agent is only the beginning. A SIEM is only as useful as the information it receives, and having logs available is not necessarily the same thing as having an alert. The real challenge was figuring out what happened, whether Wazuh saw it, and whether it recognized the activity as something worth investigating.
By the end of this project, I had learned that cybersecurity is not just about catching bad guys. It is also about patience, preparation, troubleshooting, and occasionally discovering that you downloaded the Linux version of a Windows tool. More on that shortly.
Setting Up: Getting Wazuh Ready for the Challenge
The first part of the project involved adding a new Windows endpoint to my Wazuh deployment. I used this endpoint to run Atomic Red Team, a framework that provides small, controlled tests based on techniques from the MITRE ATT&CK framework.
The idea was straightforward: generate activity on the endpoint, collect the resulting telemetry, and determine whether Wazuh could see what was happening.
- Adding the Windows endpoint -
The general setup process was:
Prepare the Windows endpoint. I made sure the Windows environment was ready to communicate with the Wazuh server.
Install the Wazuh agent. I downloaded and installed the Windows version of the Wazuh agent and configured it to communicate with my Wazuh manager.
Connect the endpoint. I enrolled the endpoint with Wazuh and verified that it appeared in the monitored agent list.
Install Sysmon. I installed Microsoft Sysmon to provide additional visibility into activity occurring on the Windows endpoint. Sysmon can record useful information about processes and other system activity.
Configure log collection. I configured Wazuh to collect the relevant Sysmon events so that the information could be sent to the SIEM for analysis.
Install Atomic Red Team. I installed the Atomic Red Team PowerShell framework and its associated test library on the Windows endpoint.
Verify the setup. Before running experiments, I checked that the endpoint was communicating with Wazuh and that the necessary telemetry was available.
One important distinction: Atomic Red Team was the testing framework running on the endpoint; the Windows machine itself was the device being monitored by Wazuh.
My first mistake: A little operating system confusion
Of course, no setup process would be complete without at least one mistake.
While installing Sysmon, I accidentally downloaded the Ubuntu version instead of the Windows version. In hindsight, this was a fairly simple mistake, but at the time it was another reminder that the details matter. A tool can be perfectly legitimate and still be completely useless if you download the wrong version for your environment.
I had to go back, locate the correct Windows version, and install that instead.
I learned to always verify the operating system and architecture before downloading a tool. Taking an extra minute to check the download can save quite a bit of troubleshooting later.
Experiment Time! Putting the MITRE ATT&CK Framework to Work:
With the endpoint connected and the monitoring environment prepared, it was time to start testing.
For my experiments, I used the MITRE ATT&CK framework to select three techniques that could be simulated in my lab environment. I used Atomic Red Team through PowerShell to execute the corresponding tests.
The general command format looked like this:
Invoke-AtomicTest (insert attack technique)
I used the corresponding technique identifier for each experiment.
The purpose was not simply to make an attack simulation run. I wanted to determine whether the activity generated useful logs, whether those logs reached Wazuh, and whether the SIEM generated an alert when an appropriate detection rule was available.
Experiment #1: T1078.003 — Valid Accounts: Local Accounts
The first experiment focused on T1078.003, Valid Accounts: Local Accounts.
This MITRE ATT&CK technique describes how an attacker may abuse legitimate local account credentials to gain access to a system. Instead of breaking into an account through an obvious exploit, an attacker may use credentials that already work. In other words, sometimes the front door is the easiest way in if someone has the key.
For this experiment, I used Atomic Red Team to simulate activity associated with the use of valid local account credentials on the monitored Windows endpoint.
I wanted to see whether Wazuh could identify the authentication-related activity and provide enough information to investigate what happened.
What I looked for:
Whether Windows generated authentication or account-related events.
Whether Wazuh received the corresponding logs.
Whether the events included useful information, such as the username, timestamp, and authentication result.
Whether Wazuh generated an alert based on the activity.
Results: Success! I was able to see in my MITRE ATT&CK section of my Wazuh SIEM that the event was properly logged! Score!
This experiment helped demonstrate why monitoring legitimate account activity matters. Not every suspicious-looking event involves malware or an unfamiliar program. Sometimes the activity comes from a valid account being used in an unexpected way.
Experiment #2: T1484.001 — Group Policy Modification
The second experiment focused on T1484.001, Group Policy Modification.
Group Policy is a Windows feature used by administrators to manage settings across users and computers in an Active Directory environment. It is incredibly useful for managing an organization, but that same level of control can become dangerous if an attacker gains the ability to modify policies.
An unauthorized Group Policy change could potentially affect security settings or distribute unwanted changes across multiple computers. It is a good example of how a feature designed to make life easier for administrators can become a security concern in the wrong hands.
For this experiment, I used Atomic Red Team to simulate activity associated with Group Policy modification and examined whether Wazuh could record the resulting events.
What I looked for:
Whether the test generated Group Policy or Active Directory-related activity.
Whether Windows recorded the policy modification or related system events.
Whether Wazuh received the available logs.
Whether Wazuh generated an alert identifying the change or the account responsible.
Results: Another one for the good guys! Same results were found just like the previous experiment!
One thing this experiment reinforced is that visibility matters. If a policy is modified, knowing that something changed is useful. Knowing which policy changed, when it happened, and which account made the change is much more useful.
Experiment #3: T1531 — Account Access Removal
The third experiment focused on T1531, Account Access Removal.
This technique involves disrupting access to legitimate accounts. An attacker might disable an account, delete it, change its credentials, or otherwise prevent a legitimate user from accessing a system.
This is particularly concerning because it can interfere with normal business operations and potentially prevent administrators or security personnel from accessing the resources they need.
For this experiment, I used Atomic Red Team to simulate account access removal activity in the controlled lab environment. I then examined whether Windows and Wazuh recorded the account-related changes.
What I looked for:
Whether the test generated account modification or access-removal events.
Whether Windows recorded the affected account and the action performed.
Whether Wazuh received the relevant security logs.
Whether Wazuh generated an alert identifying the account modification.
Results: 3 for 3! This one felt good! I certainly stumbled along the way (more on that later), but I had a beam of joy when I located the logs successfully for this attack!
This experiment highlighted an important point: cybersecurity is not only about protecting information from being stolen. It is also about protecting the availability of systems and accounts so legitimate users can continue doing their jobs.
The second mistake: Not every technique is in the toolbox
Another challenge I encountered was trying to run Atomic Red Team tests for MITRE ATT&CK techniques that were not available in my local PowerShell test library.
Initially, I assumed that if a technique appeared in the MITRE ATT&CK matrix, there would automatically be an Atomic Red Team test available for it. That was not always the case.
When I attempted to run one of the unavailable techniques, PowerShell returned an error indicating that the corresponding YAML file could not be found.
After some troubleshooting, I realized I needed to check which tests were actually included in my local Atomic Red Team library.
The command that helped me do this was:
Invoke-AtomicTest All -ShowDetailsBrief
This displayed a list of the available Atomic tests and their corresponding technique identifiers. From there, I could research the available options and make sure I was selecting tests that existed in my environment.
It was a good reminder that MITRE ATT&CK and Atomic Red Team serve different purposes. MITRE ATT&CK is a knowledge base of adversary tactics and techniques, while Atomic Red Team provides executable tests for many of those techniques. They are related, but they are not interchangeable.
Lesson learned: Before planning an experiment around a specific technique, verify that Atomic Red Team has a test for it, check the supported operating system, and review its prerequisites. A little research up front can save a lot of time chasing a YAML file that isn't there.
Conclusion: What Did the Experiments Tell Me?
This project gave me the opportunity to work with a SIEM in a practical environment rather than simply reading about how one works.
By adding a Windows endpoint to Wazuh, configuring Sysmon, and using Atomic Red Team to generate controlled activity, I was able to explore the relationship between endpoint telemetry and SIEM monitoring.
The three experiments focused on different types of security activity:
T1078.003 — Valid Accounts: Local Accounts: Examined activity involving legitimate local account credentials.
T1484.001 — Group Policy Modification: Examined changes to Windows Group Policy and the potential security implications.
T1531 — Account Access Removal: Examined activity that could prevent legitimate users from accessing their accounts.
The biggest takeaway was that detecting an attack is a process with several moving parts. First, the activity has to occur. Then the endpoint needs to generate the appropriate telemetry. That information must reach Wazuh, and finally, an applicable detection rule must identify the event and generate an alert.
It is important to distinguish between those steps. A successful test does not automatically mean a successful detection. Likewise, an event appearing in Wazuh does not necessarily mean that an alert should have been generated. Sometimes the most valuable finding is discovering which part of the monitoring process needs improvement.
Advice for avoiding my mistakes
If I were starting this project again, there are a few things I would do differently:
Double-check every download. Verify the operating system and architecture before installing tools such as Sysmon. Windows and Ubuntu are not interchangeable, no matter how much we wish they were.
Verify the Atomic Red Team library before choosing experiments. Use Invoke-AtomicTest All -ShowDetailsBrief to identify available tests and avoid selecting a technique that has no corresponding local test.
Read the test prerequisites. Some Atomic tests require specific permissions, software, configurations, or environments. Knowing those requirements ahead of time can prevent unnecessary troubleshooting.
Verify log collection before running experiments. Make sure the endpoint is connected to Wazuh and that the relevant event sources are being collected.
Record everything. Keep track of timestamps, test results, Windows event IDs, Wazuh alerts, rule IDs, and anything that did not work as expected. Those details make it much easier to understand what happened after the experiment is finished.
Some Final Thoughts
The coolest thing I learned!
The coolest thing I learned during this project was seeing how the different pieces of a security monitoring environment work together.
Before this experience, I understood the general purpose of a SIEM, but I had not fully appreciated how much depends on the quality of the telemetry being collected. Seeing how endpoint activity can become an event in Wazuh—and potentially become an alert—made the process feel much more tangible.
It also gave me a better appreciation for the people working in security operations centers. They are not just staring at screens waiting for something to happen. They are interpreting information, identifying patterns, investigating anomalies, and trying to determine whether something is actually a threat. That takes a lot more thought than simply watching a dashboard turn red.
One piece of advice for another cybersecurity newbie:
My biggest piece of advice is simple: Don't be afraid to make mistakes, but make sure you learn something from each one.
There were moments during this project when I was stuck, confused, or convinced I had broken something. Sometimes the answer was a missing file. Sometimes it was the wrong software version. Other times, I simply needed to slow down and research what I was trying to accomplish.
Cybersecurity has a steep learning curve, and nobody starts out knowing everything. Take your time, read the documentation, ask questions, and don't be discouraged when something doesn't work the first time.
The AHA! moments are worth the frustration.
A huge shoutout to my favorite external resource: MITRE ATT&CK
If I had to recommend one external resource to someone getting started in cybersecurity, it would be the MITRE ATT&CK framework.
The amount of information available through MITRE ATT&CK is incredible. It provides detailed descriptions of adversary tactics and techniques, real-world examples, detection strategies, and mitigation recommendations.
For this project, it was especially useful because it helped me understand not only what an attack technique was, but also why an attacker might use it and what defenders should look for.
I found the resource material I received from MITRE ATT&CK to be practically insurmountable—in the best possible way. There is so much information available that it can feel like opening a book and discovering that the book is actually an entire library.
I would highly recommend it to anyone interested in learning how attackers operate and how defenders can recognize their behavior.
A special thank you
I also want to take a moment to thank the two coaches who helped me the most throughout this project: Rick Rhaburn and Yeldar Yestayev.
Thank you both for your guidance, patience, and willingness to help me work through the challenges along the way. Having people who are willing to share their knowledge and help you understand the material makes a tremendous difference, especially when you're still finding your footing in a new field.
I genuinely appreciate the time and support you both provided.
References
The following resources helped me understand the techniques, research real-world attack activity, and learn how to configure and use the tools involved in this project.
“Sneaky Active Directory Persistence #17: Group Policy”
Author: Sean Metcalf
Affiliation: Trimarc (Active Directory security specialist; the article identifies his work with TrustedSec)
Published: March 14, 2016
Link: https://adsecurity.org/?p=2716
Why it was useful: This article explained how Group Policy Objects work in Active Directory and how attackers can abuse them to maintain access or change security settings. It was especially useful for understanding the risks behind T1484.001 and why Group Policy modifications should be monitored.
“From Wiper To Ransomware: The Evolution Of Agrius”
Author: SentinelLabs
Affiliation: SentinelOne's threat research team
Published: Publication date not clearly displayed on the accessible document landing page
Link: https://assets.sentinelone.com/sentinellabs/evol-agrius
Why it was useful: This threat research report discusses the evolution of the Agrius threat group and its use of destructive operations. It provided broader context for understanding how attackers use disruptive techniques and why defenders need visibility into activity that can affect system availability.
“Russian State-Sponsored Cyber Actors Targeting Network Infrastructure Devices” (TA18-106A)
Authors: U.S. Department of Homeland Security, Federal Bureau of Investigation, and United Kingdom National Cyber Security Centre
Affiliation: U.S. and U.K. government cybersecurity agencies
Published: April 16, 2018
Link: https://www.cisa.gov/news-events/alerts/2018/04/16/russian-state-sponsored-cyber-actors-targeting-network-infrastructure-devices
Why it was useful: This joint advisory provides real-world examples of how threat actors target network infrastructure, abuse legitimate access, and exploit weak configurations. Although it is not a direct guide to all three experiments, it helped illustrate the importance of monitoring systems and investigating suspicious activity.
“Valid Accounts: Local Accounts — T1078.003”
Author: MITRE
Affiliation: MITRE ATT&CK
Published: Continuously maintained; technique page lists its version and modification history
Link: https://attack.mitre.org/techniques/T1078/003/
Why it was useful: This was the primary reference for understanding the first experiment. It explains how legitimate local accounts can be abused by adversaries and provides context for the authentication activity defenders should monitor.
“Domain or Tenant Policy Modification: Group Policy Modification — T1484.001”
Author: MITRE
Affiliation: MITRE ATT&CK
Published: Continuously maintained; technique page lists its version and modification history
Link: https://attack.mitre.org/techniques/T1484/001/
Why it was useful: This resource explained the purpose of the second experiment and how malicious Group Policy modifications can affect an Active Directory environment. It also includes detection and mitigation information useful for understanding what defenders should monitor.
“Account Access Removal — T1531”
Author: MITRE
Affiliation: MITRE ATT&CK
Published: Continuously maintained; technique page lists its version and modification history
Link: https://attack.mitre.org/techniques/T1531/
Why it was useful: This resource provided the technical background for the third experiment. It describes ways attackers can disable, delete, or otherwise manipulate accounts to prevent legitimate access.
“List Atomics”
Author: Atomic Red Team documentation team
Affiliation: Atomic Red Team
Published: Continuously maintained; no individual publication date listed
Link: https://www.atomicredteam.io/docs/invoke-atomicredteam/list-atomics
Why it was useful: This documentation explains how to list the Atomic Red Team tests available in a local library, including the -ShowDetailsBrief and All options. It was especially useful when troubleshooting missing technique definitions and determining which tests were available to run.
“Monitoring Sysmon Events on a Windows Endpoint”
Author: Wazuh documentation team
Affiliation: Wazuh
Published: Continuously maintained; no individual publication date listed
Link: https://github.com/wazuh/wazuh-documentation/blob/main/source/user-manual/capabilities/log-data-collection/use-cases.rst
Why it was useful: This documentation explains how to configure a Wazuh agent to collect Sysmon events from a Windows endpoint. It helped me understand how to connect endpoint telemetry to the SIEM so that activity generated during the experiments could be investigated.
Final takeaway:
This project taught me that effective cybersecurity monitoring is about more than installing tools and running tests. It is about understanding what activity should look like, making sure the right information is collected, and verifying that the SIEM can turn that information into something useful. I still have plenty to learn, but I came away with a better understanding of how the pieces fit together—and a few fewer reasons to accidentally install Ubuntu software on Windows.
Thank you for your time in reading this newbie's first attempt at a blog post and watching me stumble through what I hope to become second nature later on in my career! I greatly look forward to one day coming back to this and seeing just how far I've come! Until next time!
Top comments (0)