CCNA Security Questions

Attackers frequently use DNS tunneling to bypass firewalls by encapsulating non-DNS protocols and encrypted payloads inside DNS packets. Because TCP port 53 allows for larger, reliable data streams compared to UDP, persistent encrypted traffic on this port is a classic indicator of an active data exfiltration channel.

Correlating authentication logs with firewall logs allows analysts to map failed login attempts to specific external IP addresses and network traffic patterns. This combination is essential for identifying distributed brute-force attacks, as it links application-level credential failures with network-level connection attempts.

AWS GuardDuty is a continuous security monitoring and threat detection service that analyzes VPC Flow Logs, AWS CloudTrail management event logs, CloudTrail S3 data events, and DNS logs. It utilizes threat intelligence feeds, machine learning, and anomaly detection to identify malicious activities, such as compromised EC2 instances, credential exfiltration, or unauthorized access within the AWS environment.

AWS GuardDuty actively leverages continuously updated threat intelligence feeds, including lists of known malicious IP addresses, domains, and attack signatures, to identify suspicious activity. When an EC2 instance communicates with an IP address or domain identified as a known command and control (C2) server by these feeds, GuardDuty generates a finding, indicating a high probability of compromise and C2 communication.

Aggregating alerts by source IP and time window groups multiple failed login attempts into a single, consolidated alert, effectively suppressing repetitive notifications while still preserving detection of brute-force or credential-stuffing activity. This correlation technique condenses dozens or hundreds of individual events into one actionable incident, reducing analyst alert fatigue and allowing the security team to focus on the actual attack pattern rather than being overwhelmed by event-level noise.

Logging in with valid credentials lets the scanner query installed package versions, registry keys, running services, and local patch levels directly from the OS, producing far fewer false positives and negatives than inferring vulnerabilities purely from external banners and network responses.

Implementing a suppression rule allows the SIEM to filter out or silence specific, known-benign event IDs under defined conditions. This directly reduces alert fatigue and noise in the console, allowing analysts to focus on legitimate security threats without losing the underlying log data.

Command and control (C2) beaconing involves an infected host periodically initiating outbound connections to a C2 server, often on a non-standard port like 4444, to check for new commands or upload data. These connections are typically regular, repetitive, and consistent in their destination and port, fitting the description of repeated connections to a single IP on port 4444. This behavior establishes a persistent communication channel for remote control of the compromised system.

DNS log analysis is the most effective method for identifying Domain Generation Algorithm (DGA) activity by examining the structural properties of queried domains. Analysts can calculate the Shannon entropy of domain strings to detect anomalous randomness and monitor query frequency for rapid bursts of failed resolutions (NXDOMAIN responses). This mathematical and behavioral analysis directly exposes the automated, algorithmic nature of DGA-based command-and-control (C2) communication.

Attackers frequently leverage legitimate binaries like svchost.exe as Living off the Land Binaries (LOLBins) to evade detection and bypass application whitelisting. In a standard Windows environment, services.exe is the exclusive parent process of svchost.exe. Observing cmd.exe spawning svchost.exe represents an anomalous parent-child relationship that strongly indicates an adversary attempting to masquerade malicious execution under a trusted system process name.

In a secure architecture, administrative traffic flows from privileged workstations to domain controllers, never the reverse. An outbound Remote Desktop Protocol (RDP) connection originating from a domain controller to a standard workstation is highly anomalous and strongly indicates an adversary is leveraging compromised domain-level credentials to pivot downstream.

DNS server logs are the primary source for detecting DNS tunneling because they contain the queried domain name, client IP, timestamp, record type (e.g., A, TXT, CNAME), and response size. Tunneling often manifests as base64-encoded subdomains, unusually long FQDNs, or high volumes of TXT/ANY queries with large response payloads—all visible directly in these logs. Correlating such patterns across multiple queries to the same domain from a single internal host provides strong, specific evidence of tunneling.

Sigma is an open, standardized signature format designed specifically for describing log events in a SIEM-neutral manner. It allows security analysts to write rules targeting process creation logs (such as Windows Event ID 1) to detect malicious command-line executions, such as regsvr32.exe loading remote scripts, which can then be converted into target SIEM queries like Splunk or ELK.

This alert strongly indicates a compromised account because the combination of an unmanaged personal device, anomalous off-hours access, and high-volume data downloads aligns perfectly with a classic data exfiltration pattern. Cloud Access Security Brokers (CASBs) utilize User and Entity Behavior Analytics (UEBA) to detect these deviations from established baselines, signaling that an unauthorized actor is likely draining corporate data storehouses.

Cloud application activity logs reveal exactly what the user did after the atypical sign-in, such as downloads, shares or configuration changes. Correlating these actions with the CASB geolocation alert distinguishes genuine malicious behaviour from legitimate travel or VPN use.

Cloud application audit logs (e.g., Microsoft 365's Unified Audit Log or Google Workspace's Admin Log) provide a tamper-evident record of every file access, download, share, and permission change linked to a user or session. By correlating the CASB alert's timestamp, source IP, and geolocation with these logs, the analyst can determine definitively whether sensitive files were opened, downloaded, or shared externally. This evidence-first approach confirms or refutes exfiltration and helps scope the incident without causing business disruption.

Reviewing the Windows Security Event Log for event ID 4698 is the most direct and effective method to detect the creation of new scheduled tasks. This specific event ID explicitly logs when a scheduled task is registered on the system, providing crucial forensic evidence of a potential persistence mechanism established by an attacker. Analyzing these logs allows analysts to identify the task name, creator, and associated command, which are vital details for incident response.

Adding the authorized scanner's IP address to an exclusion or allowlist within the specific detection rule suppresses benign alerts generated by scheduled vulnerability assessments. This targeted tuning preserves the rule's efficacy for detecting actual malicious activity from unauthorized sources while eliminating alert fatigue caused by known, legitimate scanning activities.

This is a living-off-the-land binary technique: adversaries hijack a legitimate, digitally signed process like svchost.exe to launch PowerShell so the activity blends into normal system noise and evades signature-based defenses. The subsequent external network connection from the PowerShell child strongly suggests staged malware download or C2 beaconing, warranting immediate containment and further EDR correlation.

Authentication logs capture critical event IDs related to logon attempts, such as Windows Event ID 4624 (successful logon) and 4625 (failed logon). Analyzing these logs allows security analysts to detect anomalous authentication patterns, lateral movement, and pass-the-hash (PtH) attacks by identifying unusual logon types (like Type 3 network logons) or mismatched credentials.

Agent-based scanning runs locally on each host and reports findings without the scanner sending intrusive network probes across the wire, and scheduling those scans for off-peak hours further ensures any residual resource usage does not compete with production workloads, directly satisfying both the accuracy and minimal-disruption requirements.

Firewall logs capture outbound network connections, while connection timestamps provide the temporal data required to calculate the intervals between these sessions. By correlating these timestamps, analysts can perform frequency analysis to identify highly regular, automated communication intervals (heartbeats) characteristic of command-and-control (C2) beaconing.

tcpdump is the industry-standard command-line utility for capturing and analyzing network packets directly on Linux systems. It interfaces with the libpcap library to intercept and display TCP/IP and other packets being transmitted or received over a network interface. Analysts can apply complex Berkeley Packet Filter (BPF) expressions to isolate specific traffic of interest for real-time analysis or save the capture to a PCAP file for offline inspection.

Modifying the AWS security group to restrict SSH access to specific, trusted source IP addresses immediately mitigates the brute-force or unauthorized access attempt. This stateful firewall change is applied at the hypervisor level, ensuring legitimate administrative access is preserved while blocking malicious traffic before it reaches the operating system.

Internal-only reachability and a WAF that actively blocks the specific attack vector are legitimate compensating controls that meaningfully reduce exploitability, so documenting a formal risk acceptance with those controls noted, an owner, and a review date is the appropriate response rather than treating the raw CVSS score as the sole driver of urgency.

Large DNS payload sizes are a classic indicator of tunneling because standard DNS queries and responses are deliberately small—classic UDP DNS is limited to 512 bytes without EDNS0, and even with EDNS0 typical resolvers rarely see TXT records exceeding a few hundred bytes. Tunneled traffic (via TXT or NULL records) packs encoded data into the payload, causing individual DNS messages to balloon in size and break from the statistical norm. This size anomaly is often detected when the maximum payload length or the distribution of payload sizes for a domain appears abnormal.

DNS tunneling utility tools encode payload data, such as commands or exfiltrated files, directly into the subdomain labels of a query destined for an attacker-controlled authoritative DNS server. Because of this encoding, the subdomains appear as long, high-entropy, randomized strings. A high frequency of these unique, lengthy queries directed to a single external domain is a definitive signature of active DNS tunneling.

Since an active Web Application Firewall (WAF) is successfully mitigating the vulnerability by blocking malicious traffic, the immediate threat is neutralized. Formally accepting the risk and documenting this compensating control in the risk register is the correct procedure, ensuring compliance and operational continuity without unnecessary disruption.

When threat actors acquire leaked or stolen AWS Access Keys, they frequently leverage programmatic access to bypass MFA and spin up high-compute EC2 instances for cryptomining. This malicious activity is typically detected via AWS CloudTrail logs showing API calls originating from unfamiliar IP addresses or targeting unused geographic regions.

This option is correct because the EDR alert describes a PowerShell download cradle, a classic Living off the Land (LotL) technique where command-line utilities like Invoke-WebRequest or Net.WebClient are abused to fetch and execute malicious code. Security analysts frequently flag these patterns because they bypass traditional file-based detection mechanisms by leveraging trusted system binaries to download payloads directly into memory or disk.

Data exfiltration is characterized by an anomalous, large-volume outbound data transfer, often utilizing encrypted protocols like HTTPS or SFTP to bypass deep packet inspection. The NetFlow record's asymmetric flow pattern—showing minimal inbound bytes and a massive outbound payload to an external host—is a classic indicator of compromise. This signature points directly to an attacker successfully staging and extracting sensitive corporate data.

The "Run" and "RunOnce" Registry keys are classic and highly effective persistence mechanisms. Entries added to `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run` or `HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run` instruct Windows to automatically launch specified programs or scripts every time a user logs on. This direct Registry modification ensures the malicious payload executes without requiring user interaction, making it a prime target for attackers seeking to maintain access.

By implementing a baseline of authorized parent-child process relationships or whitelisting known-good command-line arguments, analysts can significantly suppress benign positive alerts. This targeted tuning preserves the SIEM's ability to detect anomalous or unauthorized executions of the binary while minimizing alert fatigue.

Applying an isolation security group with no inbound or outbound rules immediately cuts off network communication at the hypervisor level. This effectively contains the threat and prevents further data exfiltration or command-and-control traffic while preserving the volatile memory and disk state of the EC2 instance for forensic analysis.

DNS tunneling abuses the DNS protocol by encoding non-DNS traffic, such as SSH or HTTP payloads, into the subdomains of queries sent to an attacker-controlled authoritative name server. The combination of high-volume, large-sized TXT or CNAME queries containing randomized subdomains directed to a consistent IP address is a classic signature of this exfiltration technique.

Scheduled tasks are a native Windows mechanism that can trigger a binary or script when a user logs on, at system startup, or at regular intervals. Attackers routinely create named or hidden tasks to rerun malware or maintain command-and-control, and these tasks survive a reboot (unless disabled). Because the task description, action, triggers, and run-as user are all stored in the Task Scheduler database, examining it with Velociraptor can reveal suspicious persistence. This makes scheduled tasks an essential artifact in any threat hunt.

AWS GuardDuty is a continuous security monitoring service that actively analyzes CloudTrail management events, VPC flow logs, and DNS query logs using threat intelligence and machine learning. It is specifically engineered to detect anomalous API operations, credential compromise, and malicious activity within an AWS environment, generating actionable security findings.

This is a true positive because the execution represents a classic Living off the Land (LotL) attack where a legitimate system binary (powershell.exe) is leveraged to bypass security controls. The parent-child relationship of svchost.exe spawning PowerShell with encoded arguments is a highly reliable indicator of compromise (IoC) pointing to privilege escalation or lateral movement.

Data exfiltration involves the unauthorized transfer of sensitive information from an internal network to an external, attacker-controlled destination. In NetFlow analysis, this is typically flagged by an anomalous, large-volume outbound connection (north-south traffic) originating from an internal host to an unfamiliar external IP address, especially outside of normal business hours.

When a permanent patch cannot be immediately deployed, implementing compensating controls—such as restricting network access via firewall rules or enabling specific intrusion prevention signatures—actively reduces the risk of exploitation. Documenting this risk and the associated temporary mitigations ensures compliance, maintains operational visibility, and establishes a clear path toward eventual remediation.

This scenario represents a false positive because the SIEM generated an alert for a standard, benign user login. The detection rule incorrectly flagged normal, authorized workstation access as a potential security incident, requiring analysts to investigate and tune the rule to reduce noise.

DNS query logs record every domain resolution request made by internal hosts, capturing the specific high-entropy, randomized domain names characteristic of Domain Generation Algorithms (DGAs). Analyzing these logs allows security analysts to detect anomalous NXDOMAIN spikes and identify compromised systems attempting to contact dynamic command-and-control servers.

Script Block Logging (Event ID 4104) records the actual PowerShell code executed, so loading the ActiveDirectory module and running its cmdlets is captured verbatim. This satisfies the hypothesis by surfacing AD reconnaissance commands that module-loading events alone would miss.

A CVSS base score reflects theoretical severity in a vacuum and does not account for environmental factors such as the WAF filtering malicious payloads and network ACLs restricting access to internal IPs; a documented risk assessment weighs these compensating controls against exploitability and business impact to set an appropriate remediation timeline.

DNS tunneling abuses the DNS protocol to bypass network security controls by encoding exfiltrated data or command-and-control (C2) payloads within DNS queries and responses (such as TXT, CNAME, or MX records). Because firewalls typically allow unrestricted outbound UDP port 53 traffic to resolve domain names, attackers can establish a covert bidirectional communication channel to slowly leak sensitive information without triggering traditional perimeter defenses.

Correlating EDR file-read telemetry with the timing of outbound TLS connections links sensitive document access to subsequent transmission. That temporal association distinguishes genuine staging and exfiltration from benign encrypted traffic, directly supporting the exfiltration hypothesis.

MITRE ATT&CK technique T1053.005 specifically represents the abuse of the Windows Task Scheduler to achieve persistence or elevate privileges. Threat actors leverage utilities like `schtasks.exe` or the Task Scheduler API to register malicious tasks that execute periodically or under specific trigger conditions, ensuring continuous access to the compromised host.

Memory injection techniques, such as process hollowing or DLL injection, require allocating memory with write permissions to copy payload code, and then execute permissions to run it. Legitimate software rarely allocates memory regions with concurrent Read-Write-Execute (RWX) permissions due to security mitigations like Data Execution Prevention (DEP) or W^X (Write XOR Execute). Finding an RWX memory region strongly indicates that shellcode has been injected and is prepared for execution.

External scans are conducted from outside the organization's network perimeter, directly simulating the perspective of an external attacker targeting public-facing assets. This approach identifies exposed ports, misconfigured firewalls, and unpatched vulnerabilities in public web applications without requiring internal network access or system credentials.

A false positive occurs when benign or authorized activity, such as an approved internal vulnerability scan, triggers a security alert as if it were malicious. Analysts must tune SIEM rules to recognize these authorized sources to prevent alert fatigue from these non-threatening events.

When a user opens a malicious spearphishing attachment, embedded VBA macros often execute and spawn child processes such as PowerShell, cmd.exe, or lolbins to download secondary payloads. Detecting Microsoft Word (winword.exe) spawning these command-line interpreters via osquery is a classic indicator of this initial access technique.

This technique precisely describes the action of an adversary transferring tools, utilities, or malware payloads from an external system into the target environment. When a threat hunter focuses on detecting PowerShell-based file downloads, they are specifically hunting for evidence of this ingress activity to identify initial staging or tool installation.

A Domain Generation Algorithm (DGA) is a technique used by malware to periodically generate a large number of pseudo-random domain names that can be used as rendezvous points for command-and-control (C2) servers. This allows attackers to evade static domain blocking and IP reputation lists, as the malware and the attacker only need to register a single domain from the generated list to establish a successful connection.

Threat actors frequently utilize PowerShell to execute obfuscated payloads, often passing Base64-encoded scripts via the `-e` or `-EncodedCommand` flags to bypass legacy security controls. An osquery search targeting these specific command-line arguments, especially when spawned by unusual parent processes like web servers or office applications, is a classic method for detecting active malicious PowerShell execution.

Performing a full packet capture (PCAP) is the most effective action because it allows the analyst to conduct deep packet inspection on the suspicious traffic. By analyzing the actual payloads and protocol headers, the threat hunter can definitively determine if sensitive data is being exfiltrated or if the traffic is benign. This provides the granular visibility that high-level NetFlow metadata lacks, confirming the exact nature of the transmission.

Disabling unnecessary plug-ins prevents the scanner from running checks that are not relevant to the environment, such as Windows-specific tests against Linux hosts. Each plug-in produces findings, and if it probes for software or services that are absent, it can generate false positives based on erroneous banner matches. By tailoring the active plug-in set to the actual asset inventory and exposed services, the analyst reduces meaningless alerts and focuses the scan on likely vulnerabilities. This is a core tuning step that directly reduces false positives while preserving comprehensive coverage.

Agent-based scans utilize a lightweight software package installed directly on the target endpoint to perform local, authenticated assessments. This method eliminates the need to manage network credentials or open inbound ports, allowing the agent to execute with local system privileges. It is highly effective for transient assets, such as remote laptops, which may not be consistently connected to the corporate network during scheduled network scans.

DNS logs record the specific domain queries (such as TXT, CNAME, or MX records) and responses that are manipulated during a DNS tunneling attack. Analyzing these logs allows security analysts to detect anomalies like unusually long subdomains, high query volume to a single authoritative name server, and encoded payloads within the queries.

Process analysis is the correct first step because it allows the analyst to inspect the process metadata, parent-child relationships, and command-line arguments. By examining the command line of the running powershell.exe process, the analyst can extract and decode obfuscated or Base64-encoded scripts directly to understand the payload's intent.

A definitive sign of code injection is the presence of an executable memory region that is not backed by an on-disk file. Malicious shellcode is often allocated with VirtualAllocEx and written via WriteProcessMemory, producing a private, executable page that does not map to any section object. Memory forensics tools like Volatility's malfind enumerate the Virtual Address Descriptor (VAD) tree to identify such executable pages without a backing file, making this technique a core method for detecting fileless injection.

This alert highlights Living off the Land Binary (LOLBin) abuse, where attackers leverage trusted, pre-installed system utilities like PowerShell to execute malicious commands. When a productivity application like Microsoft Word spawns a command-line interpreter, it strongly indicates a macro-based initial access vector exploiting native binaries to bypass traditional application whitelisting.

Modifying the instance's security group to deny all inbound and outbound traffic effectively isolates it from the network. This containment strategy immediately stops any ongoing malicious activity from spreading or exfiltrating data, while crucially preserving the instance's current state, memory, and disk for subsequent forensic analysis. This allows security analysts to investigate the root cause, understand the attack vector, and gather evidence without destroying critical information.

Isolating the EC2 instance by modifying its security groups to block all inbound and outbound traffic is the primary containment step. This action immediately halts malicious command-and-control (C2) communication or data exfiltration. Crucially, network isolation preserves the volatile memory (RAM) and disk state of the running instance for subsequent forensic analysis.

Adding a known-safe, high-volume domain to an exclusion list or whitelist within the SIEM suppresses repetitive false positive alerts without degrading overall detection capabilities. This tuning process optimizes analyst workflow by reducing alert fatigue while preserving the integrity of the underlying correlation rule for other unverified domains.

This chain matches a living-off-the-land binary (LOLBin) technique in which an adversary abuses the trusted svchost.exe process, often via a hijacked or malicious service DLL, to spawn powershell.exe and execute a downloader script while evading signature-based detection. Because svchost.exe is inherently trusted and its child processes are rarely scrutinized, this parent-child anomaly combined with the subsequent executable download is a strong indicator of active compromise requiring immediate isolation and deeper forensic review.

When an active security control, such as a Web Application Firewall, successfully mitigates a vulnerability, formalizing this state through documented risk acceptance is the correct protocol. Security analysts must record the compensating control's details and the residual risk in the risk register to maintain compliance and operational awareness.

By adding an exception or exclusion filter for the specific, known user account within the SIEM correlation logic, the analyst prevents benign, repetitive authentication failures from triggering the alert. This targeted approach directly eliminates false positives generated by this specific user's predictable behavior without degrading the rule's ability to detect brute-force attacks on other accounts.

Adding logical conditions, such as requiring the presence of an auxiliary malicious string or a specific file header, increases the rule's specificity. This multi-indicator approach significantly reduces false positives by ensuring the rule only triggers when a combination of unique threat characteristics is met, rather than a single, potentially benign string.

This behavior is characteristic of malware beaconing, where a compromised host establishes periodic, scheduled outbound connections to a command-and-control (C2) server to receive instructions. Utilizing port 443 allows this malicious traffic to blend seamlessly with legitimate, encrypted HTTPS web traffic, bypassing basic firewall inspection.

Wireshark is a graphical packet analyzer that allows analysts to perform deep packet inspection on captured network traffic. By reconstructing TCP streams and dissecting application-layer payloads, it enables the precise identification of sensitive data being exfiltrated. This granular visibility is crucial for verifying the exact contents of suspicious transmissions.

Proper risk management requires documenting the active compensating control, such as a WAF rule blocking the specific exploit vector, within the risk register. Because this control significantly reduces the likelihood of successful exploitation, the risk rating should be adjusted downward to reflect the actual residual risk. This ensures accurate reporting and prioritization for the security team.

This pattern of sending SYN packets, receiving SYN-ACK responses, and intentionally withholding the final ACK packet is the hallmark of a TCP SYN flood. By leaving these connections half-open, the attacker rapidly exhausts the target's connection queue (backlog queue), rendering the service unavailable to legitimate users.

This scenario represents a classic true positive for a brute-force attack, where an attacker systematically attempts numerous credential combinations against a single account from a single source IP until succeeding. The sequence of multiple rapid authentication failures followed immediately by a successful login is a high-fidelity indicator of compromise (IoC) that confirms the attack was successful.

Scheduled tasks allow the operating system to launch specified commands or executables on triggers such as system startup, user logon, or defined intervals. Attackers frequently create scheduled tasks that re-download or re-execute malicious payloads, and these tasks persist across reboots by being stored in the Task Scheduler database. Osquery can enumerate them through the scheduled_tasks table, revealing the task name, path, and schedule, which helps identify malicious creations with autorun capabilities.

A NetFlow analyzer aggregates metadata about network conversations, such as source/destination IPs, ports, and timestamps, without the overhead of full packet payloads. This lightweight data structure allows security analysts to rapidly query months of historical traffic across the entire enterprise to pinpoint which hosts communicated with a malicious external IP.