Select Two (Multi-Select) Questions

Configure each firewall to send SNMP traps directly to Panorama for real-time monitoring.

Why it fails: SNMP traps are lightweight but do not significantly impact Panorama's scalability. Moreover, Panorama does not natively aggregate SNMP traps; they would need to be sent to a separate SNMP manager. This action does not address Panorama performance and may introduce unnecessary overhead if not properly managed.

Enable log forwarding from all firewalls to Panorama and store all logs on Panorama for centralized reporting.

Why it fails: While centralized logging is valuable, storing all logs on Panorama can overwhelm its resources, especially with 300 firewalls generating high log volumes. Panorama is not designed to be a long-term log repository; it is recommended to forward logs to a dedicated log collector or external syslog server. This action would degrade performance, not optimize it.

Increase the commit interval to 24 hours to reduce the frequency of configuration pushes.

Why it fails: Increasing the commit interval does not improve Panorama's performance; it only delays configuration updates, which can lead to security gaps and operational inefficiencies. The frequency of commits should be based on change management needs, not as a performance tuning knob. Panorama's performance is better addressed by efficient configuration organization and resource allocation.

Configuring XML API push notifications directly from the VMware NSX manager

Why it fails: NSX manager integration maps hypervisor tags, not Active Directory user login identities.

Installing the GlobalProtect app with embedded Host Information Profile (HIP) reporting on every user workstation

Why it fails: GlobalProtect HIP reporting gathers workstation posture data, not raw Active Directory IP-to-username mappings.

Enabling Terminal Server (TS) Agent on all client workstations

Why it fails: TS Agent is specifically designed for multi-user terminal servers (Citrix/RDS), not individual standard client workstations.

Automatic kernel panic recovery and reboot scheduling

Why it fails: Policy Optimizer analyses rule usage, hit counts and shadowing to identify unused, redundant or overly permissive rules; it has no kernel or reboot functionality. It tempts because Panorama manages firewall health, so recovery features sound related, yet they do nothing to reduce a 5,000-rule rulebase.

Automated DNS zone transfer generation for public-facing web servers

Why it fails: Policy Optimizer analyses existing firewall rule usage, shadowing and redundancy; DNS zone transfer generation is unrelated to rule cleanup. It is tempting because zone transfers do support security auditing of public DNS records, which would be correct when the task is external DNS inventory rather than firewall rulebase optimisation.

Physical hardware failure of enterprise branch PoE switches.

Why it fails: PoE switch hardware failure concerns branch LAN resilience, not generative AI or LLM threats such as prompt injection, data leakage or model abuse. It is tempting because availability planning belongs in network architecture, and redundant PoE switching would be the right focus for a branch office design question.

Traditional SQL injection attacks against legacy database servers.

Why it fails: SQL injection against legacy databases is a longstanding application-layer threat, unrelated to generative AI or LLM deployments. It would be in scope for a conventional web-application security architecture, but the question asks specifically about risks introduced by LLM inference, training data and prompt handling.

Decrypt all internal employee traffic without exception, including HR, legal, and financial counseling sessions.

Why it fails: Blanket decryption of HR, legal and counselling sessions breaches privacy and lawful-processing obligations, so those categories must be excluded via bypass rules. It is tempting because full inspection maximises threat visibility, and would be right where no sensitive or regulated traffic exists and policy permits universal decryption.

Configure all user endpoints to trust self-signed root certificates downloaded from unknown external websites.

Why it fails: Trust anchors must be distributed through enterprise endpoint management or group policy; pulling roots from unknown external sites enables attacker-supplied certificates and breaks the trust chain. It is tempting as a quick way to seed trust, and would fit only a lab where endpoints are manually provisioned and no managed distribution channel exists.

Manual administrator phone calls to every user prior to each login

Why it fails: Phoning every user before each login cannot scale, provides no technical evidence of a device's security state, and does nothing once a session has started, so it cannot deliver continuous validation. Zero Trust relies on automated, repeated checks: GlobalProtect collects host information, HIP profiles evaluate it, and security policy enforces the result for every connection.

Static WEP encryption keys shared among all remote workers

Why it fails: WEP is a broken, obsolete wireless encryption method, and a single static key shared by every remote worker gives no per-user or per-device identity, let alone posture information. It has nothing to do with GlobalProtect or Zero Trust, which depend on strong individual authentication, encrypted tunnels and continuous device checks through host information profiles.

Deploy Private VLANs on the data center switches to isolate each application tier at Layer 2.

Why it fails: Private VLANs provide Layer 2 isolation between hosts on the same subnet, but they do not evaluate user identity or endpoint posture. They also constrain traffic at the switch rather than at the Palo Alto Networks enforcement point, so they cannot satisfy a requirement to permit traffic only after identity and posture validation.

Apply decryption policies to all inter-tier traffic so the firewall can inspect payload contents.

Why it fails: Decryption is valuable for threat inspection, but it does not authenticate users or validate endpoint posture. Even fully decrypted traffic would still be permitted or denied based on whatever match criteria exist in the rule. It therefore does not deliver the identity and posture gating that the Zero Trust requirement demands.

Create static address objects for each application tier and reference them in the security rules.

Why it fails: Static address objects are exactly the subnet-based construct the scenario says must be avoided. They bind policy to topology rather than to identity or device state, so any host that obtains an address in the object range inherits access. This fails the requirement to authorize traffic based on validated user and device attributes.

Consolidate all business traffic into a single massive rule allowing 'any' application over port 443

Why it fails: An any-application port 443 rule removes the application identification and user context that Zero Trust rulebases need, making audit and least-privilege verification impossible. It is tempting because it reduces rule count, and would be right for coarse connectivity where inspection and per-app policy are not required.

Rely entirely on default intra-zone and inter-zone allow rules without creating custom policies

Why it fails: Relying on default intra-zone and inter-zone allow rules leaves traffic permitted by implicit trust, so no explicit identity- or segment-based policy exists to audit or maintain, directly contradicting Zero Trust least-privilege. Default rules suit a lab or migration baseline where connectivity must be proven before granular rules replace them.

Disable logging on all security rules to conserve disk space on Panorama Management Server

Why it fails: Disabling logging removes the traffic evidence auditors need to verify rule effectiveness and Zero Trust enforcement, directly contradicting the auditability goal. Logging is retained on rules precisely to support review and incident investigation, so this fits only environments where storage capacity genuinely cannot be expanded.

Decrypt all traffic indiscriminately, including banking and medical records, to achieve 100% visibility regardless of privacy regulations.

Why it fails: Blanket decryption of banking and medical traffic breaches privacy regulations and lawful intercept limits; best practice is selective bypass lists for sensitive categories. It tempts architects chasing complete visibility, yet full inspection is only defensible where no regulatory prohibition or consent constraint applies.

Store the private key of the forward proxy CA certificate unencrypted in a public AWS S3 bucket for easy disaster recovery.

Why it fails: An unencrypted private key in a public S3 bucket lets anyone mint trusted certificates and silently decrypt or impersonate traffic. Keys belong in an HSM or KMS-backed store with strict access controls. Public storage tempts teams seeking simple disaster recovery, but that convenience destroys the trust anchor.

Disabling all internal firewalls and routing traffic directly over unmanaged core switches

Why it fails: Removing internal firewalls and routing over unmanaged switches eliminates the enforcement points segmentation depends on, permitting unrestricted lateral movement. It would suit a flat, trusted-network design, but Zero Trust requires inspecting and controlling east-west traffic between workloads.

Relying entirely on physical perimeter firewalls for all internal data center traffic

Why it fails: Perimeter firewalls inspect traffic crossing the network edge, not lateral east-west flows between internal workloads, so they cannot enforce intra-data-centre segmentation. They are tempting because they already secure north-south ingress and egress, which is the correct role when protecting the boundary rather than internal tiers.

The SSH daemon must be configured to allow root password login.

Why it fails: API calls use HTTPS on the management interface, not SSH; enabling root password login grants shell access and weakens security without affecting API reachability. SSH access would be relevant for CLI administration or troubleshooting, whereas the API requires the management interface's permitted IP list and an administrative account with API privileges.

The firewall Data Plane interface must have user-id redistribution enabled.

Why it fails: User-ID redistribution pushes IP-to-user mappings from a firewall to Panorama or other firewalls; it does not carry API requests. API access terminates on the management plane, so the data plane interface is irrelevant. Redistribution would be correct when sharing user mappings across firewalls for policy enforcement, not for automation connectivity.

BGP routing must be enabled on the management interface to advertise API routes.

Why it fails: BGP advertises routes between autonomous systems; it does not govern API reachability on Panorama's management plane. The API listens on the management interface, so access depends on management interface permissions and allowed IP addresses. BGP would be relevant when peering Panorama with external routers for dynamic route exchange, not for enabling HTTPS API calls.

Local command-line interface (CLI) serial cable terminal emulation.

Why it fails: A local CLI serial cable terminal emulation is an on-box management access method, not a cloud-delivered security service, so it cannot appear in the CDSS subscription set. It is tempting because serial console access is a legitimate out-of-band management fallback for a firewall whose management plane is unreachable, but it delivers no cloud-hosted threat intelligence.

Static IP routing protocol configuration (OSPFv2).

Why it fails: OSPFv2 is a dynamic routing protocol configured locally on the firewall's virtual router, not a cloud-delivered subscription service. It is tempting because routing configuration genuinely matters in firewall deployments, but CDSS covers cloud-hosted threat inspection such as WildFire, DNS Security and URL Filtering, which the firewall queries externally.

A load balancer with a backend service that includes the Compute Engine instances as backends.

Why it fails: IAP TCP forwarding targets instances directly via their name or IP and does not require a load balancer. While IAP can integrate with load balancers for HTTP(S) applications, TCP forwarding uses a different mechanism that bypasses load balancing. Adding a load balancer would not provide the required access and would complicate the design unnecessarily.

An external IP address assigned to each Compute Engine instance so IAP can reach them.

Why it fails: Instances do not need external IP addresses for IAP TCP forwarding. In fact, a common Zero Trust goal is to remove external IPs to prevent direct internet exposure. IAP reaches instances through their internal IP addresses using the Google network, so assigning external IPs would increase attack surface without enabling the tunnel.

A Cloud NAT gateway configured in the instance's subnet to allow outbound connections to the IAP service.

Why it fails: IAP TCP forwarding does not require a Cloud NAT gateway. The tunnel is initiated by the user's gcloud command to the IAP service, and IAP connects to the instance from its own IP range. Outbound internet access from the instance is not needed for IAP to function, and adding Cloud NAT does not enable or improve the forwarding.

Disabling all User-ID enforcement mechanisms to rely strictly on source MAC address binding

Why it fails: Zero Trust micro-segmentation depends on identity-based enforcement, so removing User-ID and trusting spoofable MAC addresses destroys the user dimension of policy. It is tempting where legacy rules already match on MAC, but MAC binding cannot authenticate a user or survive device changes, unlike User-ID with group mapping.

Merging all internal IT and guest network zones into a single flat L2 virtual wire segment to simplify routing

Why it fails: Collapsing internal IT and guest zones into one flat segment removes the inter-zone boundaries micro-segmentation is built on, so no policy can distinguish the two populations. It is tempting as a routing simplification, but a virtual wire passes all traffic unfiltered between the merged zones rather than enforcing least-privilege rules.

Backing up Panorama VM virtual disks directly to public S3 buckets using unencrypted plain text.

Why it fails: Panorama backups require encrypted storage with controlled access; writing virtual disks to public S3 buckets in unencrypted plain text exposes configuration and credentials, breaching confidentiality requirements. Encrypted S3 or private storage is the correct target. The temptation is that S3 offers durable offsite storage, which suits DR retention when access controls and encryption are applied.

Relying on manual local text file copies on each individual VM-Series firewall instead of Panorama.

Why it fails: Manual text copies on each firewall cannot restore centralised Panorama policy, device groups, or templates, and scale poorly across hundreds of firewalls. Panorama's scheduled configuration export to external storage is the essential mechanism. The temptation is that local copies survive Panorama loss, which would suffice only for a handful of standalone firewalls.

Replacing the Azure cloud control plane with PAN-OS kernel code

Why it fails: VM-Series runs as a guest virtual machine within Azure, consuming Azure networking constructs; it cannot substitute PAN-OS kernel code for the Azure fabric control plane, which remains Microsoft-managed. The idea is tempting because VM-Series does perform its own routing and security processing, which would matter only for traffic inspection, not platform replacement.

Direct physical stacking of VM-Series software onto Azure physical datacenter routers

Why it fails: VM-Series is software running on Azure virtual machines; it cannot be stacked onto Microsoft's physical datacentre routers, which are not customer-accessible hardware. The notion is tempting because hardware firewalls are physically racked in on-premises datacentres, but Azure abstracts the physical underlay entirely from tenants.

Running VM-Series firewalls as native extensions inside Azure SQL databases

Why it fails: VM-Series is a firewall virtual machine deployed on Azure compute, not an extension loaded into Azure SQL Database, which is a managed relational database service with no host for third-party network appliances. It is tempting because Azure supports extensibility features in some services, but database engines cannot host firewall VMs.

Static SNMP v1 trap community strings

Why it fails: Static SNMP v1 trap community strings carry no user identity, so they cannot feed Palo Alto Networks' identity ecosystem, which relies on directory integration and user-ID mapping. They are tempting because SNMP traps legitimately deliver device monitoring and alerting telemetry to management platforms — the right choice for network health visibility, not identity.

Physical Layer 1 Ethernet patch cable labeling standards

Why it fails: Physical Layer 1 Ethernet patch cable labelling standards govern cabling documentation, not identity. They cannot authenticate users, map directory groups to security policy, or integrate with Microsoft Entra ID, so they fail the identity ecosystem requirement entirely. Cable labelling is genuinely useful for physical infrastructure audits and data-centre troubleshooting, which is why it appears as a distractor here.

Local firewall CLI root password rotation scripts written in bash

Why it fails: Bash scripts rotating the local firewall CLI root password manage a device-local administrative credential; they do not participate in the identity ecosystem, which exchanges user and group data with directories such as Microsoft Entra ID for policy enforcement. Such scripting would be the right approach for automating credential hygiene on standalone firewalls lacking centralised identity integration.

They replace the need for GlobalProtect client software on mobile user laptops.

Why it fails: Service Connections provide private connectivity from Prisma Access into internal resources; endpoint protection still requires GlobalProtect on each laptop to establish the tunnel. The option mistakes the transport tunnel for the endpoint agent, which is mandatory for mobile user traffic regardless of how many service connections are deployed.

They act as standalone public web servers hosting enterprise SaaS portals.

Why it fails: Service Connections are IPsec tunnels linking Prisma Access to your data centre or VPC, carrying internal traffic for mobile users and remote networks; they never host public-facing content. The option confuses them with internet-facing web hosting, which would instead be delivered via a load balancer or CDN in front of origin servers.

They perform local Wi-Fi channel optimization at branch office locations.

Why it fails: Service Connections are IPsec tunnels linking Prisma Access to your data centre or headquarters, not branch Wi-Fi tooling. Channel optimisation belongs to wireless LAN controllers or access points. The option tempts because branch offices are a Prisma Access deployment context, but Service Connections carry corporate traffic, not radio management.

Perform an automated BIOS flash on the switch fabric.

Why it fails: Enterprise DLP enforcement acts on data flows — blocking, quarantining, alerting or watermarking — and cannot issue hardware commands to network switches. BIOS flashing is a firmware-management task performed by device management tooling, not a data-loss-prevention response to a detected policy violation.

Automatically re-image the endpoint operating system via Cloud Identity Engine.

Why it fails: Enterprise DLP enforcement targets data handling — blocking transfers, quarantining files, notifying users — and cannot re-image operating systems. Cloud Identity Engine performs identity-based policy and authentication, not endpoint provisioning. OS re-imaging belongs to MDM or endpoint management platforms responding to compromised hosts.

Configure a decryption exemption for traffic to financial institutions to avoid false positives.

Why it fails: Exempting financial traffic from decryption would prevent DLP inspection of that traffic, potentially missing credit card data. This contradicts the goal of protecting data in motion. Exemptions are typically used for privacy or performance, but here they would create a blind spot.

Create a custom URL category to block all traffic to cloud storage services.

Why it fails: Blocking cloud storage via URL category is a coarse control that does not inspect for credit card numbers. DLP requires content inspection, not just URL filtering. This action would not satisfy the requirement to detect and protect credit card data in motion.

Install a DLP plugin on each endpoint to scan local files before transmission.

Why it fails: Enterprise DLP on Palo Alto Networks firewalls is a network-based solution and does not require endpoint plugins. Endpoint DLP is a separate product. The scenario specifies DLP on firewalls, so endpoint installation is irrelevant and would not enable network inspection.