NSE7_SOC_AR-7.6 Fortinet NSE 7 - Security Operations 7.6 Architect Questions and Answers

In FortiSOAR 7.6 , the War Room is a collaborative space designed for high-priority incident investigation. The Evidences tab within the Investigate view (as shown in the exhibit) is specifically designed to highlight critical findings found during the investigation process.

Evidence Tagging: To populate the Action Logs Marked As Evidence section, an analyst must specifically tag a relevant log entry, a playbook output, or a comment within the collaboration workspace with the system-defined keyword " Evidence " .

Automatic Categorization: Once the tag is applied, FortiSOAR automatically parses these entries and displays them in this centralized view. This allows team members and stakeholders to quickly view substantiated facts and proof gathered during the " Root Cause Analysis " phase without sifting through all raw action logs.

Manual vs. Action Logs: The exhibit shows two distinct areas: " Manually Upload Evidences " (where files like the CSLAB document shown can be dragged and dropped) and " Action Logs Marked As Evidence. " The latter is reserved exclusively for system-generated logs or comments that have been promoted to evidence status via tagging.

Why other options are incorrect:

By linking an indicator to the war room (B): Linking indicators associates technical artifacts (like IPs or hashes) with the record, but it does not automatically classify them as evidence within the War Room action log view.

By creating an evidence collection task and attaching a file (C): While this is a valid step in an investigation, attaching a file to a task typically places it in the " Attachments " or " Manually Upload Evidences " area, rather than the " Action Logs " section specifically.

By executing a playbook with the Save Execution Logs option enabled (D): Saving execution logs ensures a trail of what the playbook did, but it does not mark the output as " Evidence " unless the specific logic or a manual analyst action applies the " Evidence " tag to the resulting log entry.

Exact Extract: “Click a playbook step to display the input, output, and configuration for that step. You can click ENV to toggle between the environment in which the playbook was executed and the steps of the playbook.” The guide also states that the ENV view contains “the complete environmental context, including input, output, and variables across all steps.”

Exact Extract: “Click Error Details to view the reason for a playbook failure. This helps you identify the root cause of the error and troubleshoot.”

The correct answer is C . The goal is to continue execution from the failed point while preserving the already-built runtime context from steps 1 through 29. Rerun From Last Failed Step is specifically designed for this situation. It avoids repeating prior successful steps and continues with the original environment, variables, inputs, and outputs already generated before the failure.

Option A is wrong because mock input is for testing or debugging and can override real step output. Option B is only useful for testing Jinja expressions against an environment JSON; it does not continue playbook execution. Option D is a bad design change: manually rewiring the playbook bypasses intended workflow logic and does not reliably preserve prior execution context.

Technical Deep Dive: In FortiSOAR, long playbooks often build dependency chains where later connector actions rely on earlier outputs, variables, decisions, record IDs, and enrichment data. Starting over can duplicate records, re-run remediation, or overwrite evidence. The correct operational recovery is to use the executed playbook log and resume from the failed step after fixing the transient condition. FortiGate NP/CP offloading is irrelevant because this is SOAR workflow execution state, not firewall packet processing.

Understanding FortiAnalyzer Features:

FortiAnalyzer includes several features for log analytics, monitoring, and incident response.

The SIEM (Security Information and Event Management) database is used to store and analyze log data, providing advanced analytics and insights.

Evaluating the Options:

Option A: Threat hunting

Threat hunting involves proactively searching through log data to detect and isolate threats that may not be captured by automated tools.

This feature leverages the SIEM database to perform advanced log analytics, correlate events, and identify potential security incidents.

Option B: Asset Identity Center

This feature focuses on asset and identity management rather than advanced log analytics.

Option C: Event monitor

While the event monitor provides real-time monitoring and alerting based on logs, it does not specifically utilize advanced log analytics in the way the SIEM database does for threat hunting.

Option D: Outbreak alerts

Outbreak alerts provide notifications about widespread security incidents but are not directly related to advanced log analytics using the SIEM database.

Conclusion:

The feature that uses the SIEM database for advanced log analytics and monitoring in FortiAnalyzer is Threat hunting .

Exact Extract: “INFO verbosity is recommended for well-established playbooks. It contains only the final playbook execution status and individual playbook step status.” The guide further states: “DEBUG verbosity is recommended for newer playbooks or for active troubleshooting. It contains detailed logging that includes execution information, such as step input, output, configuration, and other details.”

The correct answer is B . In the exhibit, the executed playbook shows Mode: INFO . INFO mode gives only high-level execution status and step status, which explains why the error panel shows only minimal details such as status: failed and execution time. To see connector input, output, configuration, and more useful troubleshooting details, the playbook logging verbosity must be changed to DEBUG .

A may cause a connector step to fail, but it does not explain why error details are missing. C is wrong because Ignore Error would allow the workflow to continue rather than fail normally. D could cause permission-related failure, but again it does not explain the lack of diagnostic detail. The visible clue is the logging mode.

Technical Deep Dive: For a newly built playbook, you should run tests in DEBUG mode until the workflow is stable. DEBUG logs expose step inputs, connector payloads, returned outputs, variable values, and configuration details. After validation, switch back to INFO in production to reduce log volume and storage usage. FortiGate NP/CP hardware offloading is irrelevant here because this is FortiSOAR workflow logging and connector execution diagnostics, not firewall data-plane traffic processing.

In a modern Security Operations Center (SOC) environment powered by FortiSIEM 7.3 and FortiSOAR 7.6 , the efficiency of the incident response lifecycle depends on two primary pillars of analysis:

Accurate detection of threats (A): The primary goal of a SOC is to identify genuine malicious activity. Using FortiSIEM ' s correlation rules and machine learning (UEBA), the system must be tuned to detect patterns that signify real risk. Accuracy ensures that the SOC is not blinded by noise and can focus on critical security events that impact the organization ' s posture.

Rapid identification of false positives (C): " Alert Fatigue " is one of the greatest challenges in a SOC. Analysts must be able to quickly distinguish between legitimate anomalies (false positives) and actual threats. FortiSOAR assists in this by using automated playbooks to perform initial triage and " pre-processing " —such as checking IP reputations or verifying user activity—to automatically close or demote alerts that do not represent a true threat, thereby freeing up analysts for high-priority investigations.

Why other options are incorrect:

Immediate escalation for all alerts (B): This is a poor SOC practice. Escalating every alert without triage leads to analyst burnout and overloads senior responders with low-value tasks. The goal of a tiered SOC (Tier 1, Tier 2, Tier 3) is to filter alerts so only significant incidents are escalated.

Periodic system downtime (D): SOC systems (SIEM/SOAR) are considered " Mission Critical " and must operate on a 24/7/365 basis. Maintenance should be performed using High Availability (HA) configurations or during " low-flow " windows without causing a complete stop in monitoring, as attackers often leverage downtime to strike.

Understanding the Playbook Configuration:

The " Malicious File Detect " playbook is designed to create an incident when a malicious file detection event is triggered.

The playbook includes tasks such as Attach_Data_To_Incident, Create Incident, and Get Events.

Analyzing the Playbook Execution:

The exhibit shows that the Create Incident task has failed, and the Attach_Data_To_Incident task has also failed.

The Get Events task succeeded, indicating that it was able to retrieve event data.

Reviewing Raw Logs:

The raw logs indicate an error related to parsing input in the incident_operator.py file.

The error traceback suggests that the task was expecting a specific input format (likely a name or number) but received an incorrect data format.

Identifying the Source of the Failure:

The Create Incident task failure is the root cause since it did not proceed correctly due to incorrect input format.

The Attach_Data_To_Incident task subsequently failed because it depends on the successful creation of an incident.

Conclusion:

The primary reason for the playbook execution failure is that the Create Incident task received an incorrect data format, which was not a name or number as expected.

Understanding the Issue :

The custom event handler for detecting SMTP reconnaissance activities is generating a large number of events.

This high volume of events is overwhelming the notification system, leading to potential alert fatigue and inefficiency in incident response.

Event Handler Configuration :

Event handlers are configured to trigger alerts based on specific criteria.

The frequency and volume of these alerts can be controlled by adjusting the trigger conditions.

Possible Solutions :

A. Increase the trigger count so that it identifies and reduces the count triggered by a particular group :

By increasing the trigger count, you ensure that the event handler only generates alerts after a higher threshold of activity is detected.

This reduces the number of events generated and helps prevent overwhelming the notification system.

Selected as it effectively manages the volume of generated events.

B. Disable the custom event handler because it is not working as expected :

Disabling the event handler is not a practical solution as it would completely stop monitoring for SMTP reconnaissance activities.

Not selected as it does not address the issue of fine-tuning the event generation.

C. Decrease the time range that the custom event handler covers during the attack :

Reducing the time range might help in some cases, but it could also lead to missing important activities if the attack spans a longer period.

Not selected as it could lead to underreporting of significant events.

D. Increase the log field value so that it looks for more unique field values when it creates the event :

Adjusting the log field value might refine the event criteria, but it does not directly control the volume of alerts.

Not selected as it is not the most effective way to manage event volume.

Implementation Steps :

Step 1 : Access the event handler configuration in FortiAnalyzer.

Step 2 : Locate the trigger count setting within the custom event handler for SMTP reconnaissance.

Step 3 : Increase the trigger count to a higher value that balances alert sensitivity and volume.

Step 4 : Save the configuration and monitor the event generation to ensure it aligns with expected levels.

Conclusion :

By increasing the trigger count, you can effectively reduce the number of events generated by the custom event handler, preventing the notification system from being overwhelmed.

Exact Extract: “Custom API Endpoint: Specify an arbitrary endpoint used to externally start a playbook. Uses a REST API POST action from another system. Supports token-based, basic, and no authentication.”

The correct answers are A and D. A Custom API Endpoint trigger allows an external system to start a FortiSOAR playbook through a defined arbitrary endpoint. It supports token-based authentication, basic authentication, or no authentication, depending on how you configure the trigger. C is wrong because the guide specifies REST API POST, not GET and PUT. B is not supported by the described trigger behavior; the endpoint is configured as a trigger for a playbook, not as a broadcast mechanism to trigger multiple playbooks simultaneously.

Technical Deep Dive: This trigger is useful when an external system cannot use a native FortiSOAR connector but can make an HTTP API call. Common use cases include webhook-style ingestion, third-party alert forwarding, and external workflow integration. Secure it properly; “no authentication” is possible but usually unacceptable in production unless protected by network controls.

Exact Extract: “FortiAI integration on FortiSIEM and FortiSOAR connects directly to LLMs from OpenAI… FortiAI lets you connect to your own OpenAI account, using your own OpenAI license key.” The guide also shows FortiSOAR configuration under Content Hub > FortiAI Connector.

Exact Extract: “Only authorized users can invoke the FortiAI assistant and perform CRUD operations to the relevant modules, based on FortiSOAR RBAC.”

The correct answers are C and D. To use FortiAI for playbook design, FortiSOAR must have the FortiAI content installed and configured so it can communicate with the LLM service. In addition, the user invoking FortiAI must have the correct RBAC permissions, including CRUD permissions on the relevant playbook modules. FortiAI is not the FortiSOAR machine learning engine, so A is wrong. B is misleading because the FortiSOAR-side configuration is handled through FortiAI/FortiAI connector content, not by training a local model.

Technical Deep Dive: FortiAI can generate playbook workflow logic, but it does not remove the need for human validation. Generated playbooks may still require variable mapping, connector credential validation, permission checks, and testing through execution logs. FortiGate NP/CP offloading is irrelevant because this is FortiSOAR automation design, not firewall data-plane processing.

Understanding Playbook Variables:

Playbook tasks in Security Operations Center (SOC) playbooks use variables to pass and manipulate data between different steps in the automation process.

Variables help in dynamically handling data, making the playbook more flexible and adaptive to different scenarios.

Types of Variables:

Input Variables:

Input variables are used to provide data to a playbook task. These variables can be set manually or derived from previous tasks.

They act as parameters that the task will use to perform its operations.

Output Variables:

Output variables store the result of a playbook task. These variables can then be used as inputs for subsequent tasks.

They capture the outcome of the task ' s execution, allowing for the dynamic flow of information through the playbook.

Other Options:

Create: Not typically referred to as a type of variable in playbook tasks. It might refer to an action but not a variable type.

Trigger: Refers to the initiation mechanism of the playbook or task (e.g., an event trigger), not a type of variable.

Conclusion:

The two types of variables used in playbook tasks are input and output .

Exact Extract: “Hybrid tenancy • Some tenants are distributed, but some are shared.” The guide also states that shared tenancy uses “one FortiSOAR instance” for multiple tenants and that “tenant data is isolated from other tenants through RBAC.”

Exact Extract: “The master cluster is a hybrid multi-tenant deployment because shared tenants are hosted locally on the cluster, in addition to the remote tenants that communicate through an SME.” It also states that the SME uses TCP 5671 and that “each tenant node has a dedicated space with the SME.”

Exact Extract: “For isolated and segmented networks, you can deploy a FortiSOAR agent to receive and execute connector actions… The agent requires outbound network connectivity only to the SME on TCP port 5671.”

The correct answers are B, C, and D . In a hybrid multi-tenant FortiSOAR design, the master cluster can host local shared tenants while also communicating with remote distributed tenant nodes through the secure message exchange. Shared tenants remain isolated through RBAC, so B is correct. The SME provides controlled message routing, and each tenant node has a dedicated space on the SME, so C is correct. Tenant nodes and agents use TCP 5671 to communicate with the SME, so D is correct. A is wrong because the guide says FortiSOAR can use either the embedded SME or a dedicated external SME; a dedicated SME is recommended for production scalability, but it is not mandatory. E is wrong because agents are deployed in isolated or segmented networks, not on the master cluster for HA performance.

Technical Deep Dive: FortiSOAR hybrid tenancy separates control, execution, and data ownership. The master cluster coordinates workflows and can push actions to tenant nodes, but remote execution happens at the tenant side using tenant credentials. The SME acts as the secure broker between master, tenants, and agents. This is critical when segmented networks block inbound access: an agent only needs outbound connectivity to the SME, which avoids opening risky inbound management paths. FortiGate NP/CP offloading is irrelevant here because SME communication is FortiSOAR application messaging, not firewall data-plane acceleration.

Exact Extract: “What are two characteristics of threat hunting? … It looks for undetected threats… It requires a hypothesis and investigation.”

Exact Extract: “By demonstrating competence in examining a simple threat hunting use case, you will be able to conduct threat hunting based on an easily verifiable hypothesis.”

The correct answer is C . This is a threat hunting scenario, not a normal alert-engineering scenario. You do not know the attacker identity, infrastructure, tools, or exact TTPs, so the first mature action is to form a hypothesis such as: “If a similar DDoS campaign is targeting us, we may observe abnormal inbound request volume, source diversity, protocol concentration, SYN/UDP/HTTP flood patterns, or service degradation against exposed assets.” That hypothesis then drives the FortiSIEM analytics search and evidence collection.

A is useful later, after the hunt identifies a reliable detection condition. B is too broad and operationally expensive as a first step. D is weak because no relevant threat intelligence has been received, and enriching every external IP is noisy and inefficient.

Technical Deep Dive: A good DDoS hunt should start with exposed services, normal traffic baselines, traffic volume anomalies, source ASN/country dispersion, destination service concentration, firewall deny/accept spikes, SYN-to-completion ratios, and web request rates. After confirming patterns, you tune FortiSIEM rules and FortiSOAR response playbooks. FortiGate NP/CP acceleration may affect packet-forwarding performance under flood conditions, but the hunting workflow itself is driven by SIEM telemetry and hypothesis-based analytics.

Exact Extract: “This playbook also expects input from the user, specifically an IP address… you can manually type in an IP address. The trigger input is saved as ipAddress, which you can refer to later as a dynamic value.”

Exact Extract: “The connector must first be configured… The selected action is Get IP Reputation… The Get IP Reputation action requires input. In the trigger step, you defined the ipAddress parameter from the trigger input, which you can dynamically map to this step.”

Exact Extract: “After the Connector step is the Approval step. You can manually add a description, or you can use the Dynamic Values window to populate fields such as the Description field.”

The correct answer is A . The workflow requires analyst-supplied input, so it must begin with a Manual trigger where the IP address is entered. That IP address is passed directly into the FortiSIEM Get Device Information connector action. The output from that connector action is then shown to the SOC manager through an Approval step. If approved, the playbook proceeds to Create Record , creating the asset record from the FortiSIEM CMDB result.

Option B is bloated. Set Variable steps are not required because the manual trigger value and connector output can be referenced directly through Dynamic Values/Jinja. Option C is wrong because On Create is event-driven, not manual input, and Manual Task does not provide the same approve/reject workflow as an Approval step. Option D is wrong because it lacks the manual trigger and adds an unnecessary Update Record step.

Technical Deep Dive: The clean FortiSOAR pattern is Manual Input → External Lookup → Human Approval → Record Creation. In implementation, the manual trigger captures device_ip, the FortiSIEM connector action maps that value to Device IP, the Approval step displays key returned fields such as hostname, IP, organization, device type, and CMDB attributes, and the Create Record step maps the approved output into the Assets module. This is SOAR workflow orchestration; FortiGate NP/CP hardware offload is irrelevant because no traffic forwarding or ASIC inspection path is involved.

Exact Extract: “You must enable HTTPS on the FortiGate interface that the FortiGate connector on FortiSOAR is pointing to. If trusted hosts are enabled on the API administrator used by FortiSOAR, you must add the FortiSOAR IP address to the list.”

Exact Extract: “When assigning an administrator profile to the API user, you must assign the required permissions to perform the actions you want completed on the connector. Consult the connector documentation for more information.”

The correct answers are A and B . In the exhibit, the FortiGate interface Transit (port2) has no administrative access enabled. Because the FortiSOAR FortiGate connector communicates with FortiGate by API over HTTPS, HTTPS must be enabled on the FortiGate interface that FortiSOAR targets. Also, the REST API admin has Trusted Hosts enabled, but the trusted host shown is 10.0.0.100 , while the FortiSOAR IP is 10.200.200.160 . FortiGate will reject API access from FortiSOAR unless 10.200.200.160/32 is allowed as a trusted host. Option C can matter for specific actions, but it is not the shown connection failure. Option D is nonsense; FortiGate interface roles do not include “Custom API Endpoint.”

Technical Deep Dive: The FortiSOAR connector calls the FortiGate REST API over HTTPS, so FortiGate must accept HTTPS management traffic on the target interface and must allow the API user source IP. CLI equivalent:

config system interface

edit " port2 "

set allowaccess https

next

end

config system api-user

edit " API-User "

set accprofile " API_Profile "

config trusthost

edit 1

set ipv4-trusthost 10.200.200.160 255.255.255.255

next

end

next

end

NP/CP hardware offloading is irrelevant here. This is management-plane HTTPS/API access, not data-plane traffic acceleration.

Understanding the Playbook Configuration:

The playbook " FortiMail Sender Blocklist " is designed to manually input email addresses or IP addresses and add them to the FortiMail block list.

The playbook uses a FortiMail connector with the action ADD_SENDER_TO_BLOCKLIST.

Analyzing the Playbook Execution:

The configuration and actions provided show that the playbook is straightforward, starting with an ON_DEMAND STARTER and proceeding to the ADD_SENDER_TO_BLOCKLIST action.

The action description indicates it is intended to block senders based on email addresses or domains.

Evaluating the Options:

Option A: Using GET_EMAIL_STATISTICS is not required for the task of adding senders to a block list. This action retrieves email statistics and is unrelated to the block list configuration.

Option B: The primary reason for failure could be the requirement for a fully qualified domain name (FQDN). FortiMail typically expects precise information to ensure the correct entries are added to the block list.

Option C: The trust level of the client-side browser with FortiAnalyzer ' s self-signed certificate does not impact the execution of the playbook on FortiMail.

Option D: Incorrect connector credentials would result in an authentication error, but the problem described is more likely related to the format of the input data.

Conclusion:

The FortiMail Sender Blocklist playbook execution is failing because FortiMail is expecting a fully qualified domain name (FQDN).

Exact Extract: “FortiSIEM uses the analytics search filter conditions to create the rule subpattern Filter conditions and the search display conditions to create the rule Group by conditions. When creating rules from analytics searches, FortiSIEM always sets the Aggregate condition to COUNT(Matched Events) > = 1.”

Exact Extract: “Note that the General and Define Action tabs need manual configuration. Only the Define Condition tab, with the subpattern, is configured for you using the search results. If your search parameters contain multiple rows, all of them will be included in one subpattern.”

The correct answers are C and D . When you create a rule from a FortiSIEM analytics search, FortiSIEM converts the analytics filter rows into the rule’s Define Condition logic. If the analytics search contains multiple filter rows, FortiSIEM places them into one subpattern , not multiple independent subpatterns. FortiSIEM also automatically sets the default aggregate to COUNT(Matched Events) > = 1 , which means at least one matching event is enough unless you manually adjust the threshold.

Option A is wrong because analytics searches are based on event data, and those search conditions can be used to build a rule. Option B is wrong because the guide is explicit: General and Define Action still require manual configuration. The event type does not automatically configure the incident action.

Technical Deep Dive: Creating a rule from analytics is a shortcut, not a complete rule-design process. FortiSIEM helps by translating search filters into a subpattern filter and display fields into Group By attributes. However, an architect still must validate the aggregate threshold, define the rule metadata, and configure the incident action. In real SOC design, you rarely leave COUNT(Matched Events) > = 1 unchanged for noisy detections; you tune it based on baseline frequency, event criticality, and time window. This is SIEM correlation logic only; FortiGate NP/CP offloading is irrelevant because no packet forwarding or ASIC inspection is involved.

Understanding the Event Handler Configuration :

The event handler is set up to detect specific security incidents, such as spearphishing, based on logs forwarded from other Fortinet products like FortiSandbox.

An event handler includes rules that define the conditions under which an event should be triggered.

Analyzing the Current Configuration :

The current event handler is named " Spearphishing handler " with a rule titled " Spearphishing Rule 1 " .

The log viewer shows that logs are being forwarded by FortiSandbox but no events are generated by FortiAnalyzer.

Key Components of Event Handling :

Log Type : Determines which type of logs will trigger the event handler.

Data Selector : Specifies the criteria that logs must meet to trigger an event.

Automation Stitch : Optional actions that can be triggered when an event occurs.

Notifications : Defines how alerts are communicated when an event is detected.

Issue Identification :

Since FortiSandbox logs are correctly forwarded but no event is generated, the issue likely lies in the data selector configuration or log type matching.

The data selector must be configured to include logs forwarded by FortiSandbox.

Solution :

B. Configure a FortiSandbox data selector and add it to the event handler :

By configuring a data selector specifically for FortiSandbox logs and adding it to the event handler, FortiAnalyzer can accurately identify and trigger events based on the forwarded logs.

Steps to Implement the Solution :

Step 1 : Go to the Event Handler settings in FortiAnalyzer.

Step 2 : Add a new data selector that includes criteria matching the logs forwarded by FortiSandbox (e.g., log subtype, malware detection details).

Step 3 : Link this data selector to the existing spearphishing event handler.

Step 4 : Save the configuration and test to ensure events are now being generated.

Conclusion :

The correct configuration of a FortiSandbox data selector within the event handler ensures that FortiAnalyzer can generate events based on relevant logs.

Understanding the Problem :

One FortiGate device is generating a significantly higher volume of logs compared to other devices, causing the ADOM to exceed its storage quota.

This can lead to performance issues and difficulties in managing logs effectively within FortiAnalyzer.

Possible Solutions :

The goal is to manage the volume of logs and ensure that the ADOM does not exceed its quota, while still maintaining effective log analysis and monitoring.

Solution A: Increase the Storage Space Quota for the First FortiGate Device :

While increasing the storage space quota might provide a temporary relief, it does not address the root cause of the issue, which is the excessive log volume.

This solution might not be sustainable in the long term as log volume could continue to grow.

Not selected as it does not provide a long-term, efficient solution.

Solution B: Create a Separate ADOM for the First FortiGate Device and Configure a Different Set of Storage Policies :

Creating a separate ADOM allows for tailored storage policies and management specifically for the high-log-volume device.

This can help in distributing the storage load and applying more stringent or customized retention and storage policies.

Selected as it effectively manages the storage and organization of logs.

Solution C: Reconfigure the First FortiGate Device to Reduce the Number of Logs it Forwards to FortiAnalyzer :

By adjusting the logging settings on the FortiGate device, you can reduce the volume of logs forwarded to FortiAnalyzer.

This can include disabling unnecessary logging, reducing the logging level, or filtering out less critical logs.

Selected as it directly addresses the issue of excessive log volume.

Solution D: Configure Data Selectors to Filter the Data Sent by the First FortiGate Device :

Data selectors can be used to filter the logs sent to FortiAnalyzer, ensuring only relevant logs are forwarded.

This can help in reducing the volume of logs but might require detailed configuration and regular updates to ensure critical logs are not missed.

Not selected as it might not be as effective as reconfiguring logging settings directly on the FortiGate device.

Implementation Steps :

For Solution B :

Step 1 : Access FortiAnalyzer and navigate to the ADOM management section.

Step 2 : Create a new ADOM for the high-log-volume FortiGate device.

Step 3 : Register the FortiGate device to this new ADOM.

Step 4 : Configure specific storage policies for the new ADOM to manage log retention and storage.

For Solution C :

Step 1 : Access the FortiGate device’s configuration interface.

Step 2 : Navigate to the logging settings.

Step 3 : Adjust the logging level and disable unnecessary logs.

Step 4 : Save the configuration and monitor the log volume sent to FortiAnalyzer.

Understanding Incident Creation in FortiAnalyzer:

FortiAnalyzer allows for the creation of incidents to track and manage security events.

Incidents can be created both automatically and manually based on detected events and predefined rules.

Analyzing the Methods:

Option A: Using a connector action typically involves integrating with other systems or services and is not a direct method for creating incidents on FortiAnalyzer.

Option B: Incidents can be created manually on the Event Monitor page by selecting relevant events and creating incidents from those events.

Option C: While playbooks can automate responses and actions, the direct creation of incidents is usually managed through event handlers or manual processes.

Option D: Custom event handlers can be configured to trigger incident creation based on specific events or conditions, automating the process within FortiAnalyzer.

Conclusion:

The two valid methods for creating an incident on FortiAnalyzer are manually on the Event Monitor page and using a custom event handler.

Exact Extract: “Fortinet recommends that you test a search query first in FortiSIEM to ensure that there are matching event logs. Then you can implement the same logic and time range with the connector action.”

Exact Extract: “You can define a time range, such as the last 30 days, and the maximum number of records to return in your query.”

The correct answer is A . The exhibit shows the FortiSIEM connector action completed with status: Success , but the returned events array is empty and totalCount is 0 . That means the connector did not fail; the query simply did not return matching FortiSIEM event logs. The first troubleshooting step is to run the same search directly in FortiSIEM Analytics with the same filters and time range to confirm whether matching logs actually exist.

B is wrong because saving empty output into a variable does not solve the missing results. C is not first because the connector action already shows Success , so connectivity is not the immediate problem. D is useful when mapping fields or understanding schema, but the immediate evidence points to no matching data, not unknown output structure.

Technical Deep Dive: In FortiSOAR threat-hunting playbooks, connector success only proves the API call completed. It does not prove the search logic was correct. Check the FortiSIEM query directly for event type, attribute names, time range, organization scope, and maximum result count. In this case, events: [] and totalCount: 0 are the hard clues. This is FortiSOAR-to-FortiSIEM query troubleshooting; FortiGate NP/CP offloading is irrelevant because no firewall packet-processing path is involved.

Understanding FortiAnalyzer Fabric Topology:

The FortiAnalyzer Fabric topology is designed to centralize logging and analysis across multiple devices in a network.

It involves a hierarchy where the supervisor node manages and coordinates with other Fabric members.

Analyzing the Options:

Option A: Downstream collectors forwarding logs to Fabric members is not a typical configuration. Instead, logs are usually centralized to the supervisor.

Option B: For effective management and log centralization, logging devices must be registered to the supervisor. This ensures proper log collection and coordination.

Option C: The supervisor does not primarily use an API to store logs, incidents, and events locally. Logs are stored directly in the FortiAnalyzer database.

Option D: For the Fabric topology to function correctly, all Fabric members need to be in analyzer mode. This mode allows them to collect, analyze, and forward logs appropriately within the topology.

Conclusion:

The correct statements regarding the FortiAnalyzer Fabric topology are that logging devices must be registered to the supervisor and that Fabric members must be in analyzer mode.

Exact Extract: “MITRE ATT & CK classifies and describes cyberattacks and intrusions through 14 tactics, each representing an adversary ' s technical objective… These categories are further broken down into specific techniques and subtechniques.”

Exact Extract: “When an incident contains alerts correlated with known adversary techniques, they are displayed on the MITRE ATT & CK matrix directly in the incident view. This helps analysts quickly understand the attack progression, identify affected tactics… and prioritize response actions based on threat context.”

The correct answers are A and C . The fake HR login page captured usernames and passwords, which maps to Credential Access because the attacker’s objective was to steal valid credentials. The later use of those stolen credentials to sign in through the company’s web VPN maps to Initial Access , because the attacker used valid credentials to gain access to the victim environment.

B is wrong because the scenario does not describe command-and-control beaconing, remote control, or malware maintaining communication with attacker infrastructure. D is wrong because there is no evidence of log clearing, obfuscation, masquerading for evasion after compromise, or disabling defenses.

Technical Deep Dive: In Fortinet SOC terms, the evidence chain would likely include FortiMail phishing delivery logs, web/DNS logs for the fake HR page, FortiClient or browser telemetry if available, and FortiGate SSL VPN successful-login events. FortiSOAR can enrich the phishing URL/domain, link affected users, and escalate the VPN login into an incident. The higher-value detection is not only blocking the domain; it is correlating credential harvesting with subsequent successful VPN authentication. NP/CP acceleration is not the main factor because the detection depends on logs, identity correlation, and MITRE mapping.

Understanding the Playbook and its Components:

The exhibit shows the status of a playbook named " DOS attack " and its associated tasks.

The playbook is designed to execute a series of tasks upon detecting a DoS attack event.

Analysis of Playbook Tasks:

Attach_Data_To_Incident: Task ID placeholder_8fab0102, status is " upstream_failed, " meaning it did not execute properly due to a previous task ' s failure.

Get Events: Task ID placeholder_fa2a573c, status is " success. "

Create SMTP Enumeration incident: Task ID placeholder_3db75c0a, status is " failed. "

Reviewing Raw Logs:

The error log shows a ValueError: invalid literal for int() with base 10: ' 10.200.200.100 ' .

This error indicates that the task attempted to convert a string (the IP address ' 10.200.200.100 ' ) to an integer, which is not possible.

Identifying the Source of the Error:

The error occurs in the file " incident_operator.py, " specifically in the execute method.

This suggests that the task " Create SMTP Enumeration incident " is the one causing the issue because it failed to process the data type correctly.

Conclusion:

The failure of the playbook is due to the " Create SMTP Enumeration incident " task receiving a string value (an IP address) when it expects an integer value. This mismatch in data types leads to the error.

Understanding the Custom Event Handler Configuration:

The event handler is set up to generate events based on specific log data.

The goal is to generate events specifically for spam emails detected by FortiMail.

Analyzing the Issue:

The event handler is currently generating events for both spam emails and clean emails.

This indicates that the rule ' s filtering criteria are not correctly distinguishing between spam and non-spam emails.

Evaluating the Options:

Option A: Selecting the " Anti-Spam Log (spam) " in the Log Type field will ensure that only logs related to spam emails are considered. This is the most straightforward and accurate way to filter for spam emails.

Option B: Typing type==spam in the Log filter by Text field might help filter the logs, but it is not as direct and reliable as selecting the correct log type.

Option C: Disabling the rule to use the filter in the data selector to create the event does not address the issue of filtering for spam logs specifically.

Option D: Selecting " Within a group, the log field Spam Name (snane) has 2 or more unique values " is not directly relevant to filtering spam logs and could lead to incorrect filtering criteria.

Conclusion:

The correct change to make in the rule is to select " Anti-Spam Log (spam) " in the Log Type field. This ensures that the event handler only generates events for spam emails.